diff options
63 files changed, 3244 insertions, 14665 deletions
diff --git a/MAINTAINERS b/MAINTAINERS index 5ec945c9af..caf7e8aca8 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1647,12 +1647,6 @@ S: Maintained F: tcg/i386/ F: disas/i386.c -IA64 target -M: Aurelien Jarno <aurelien@aurel32.net> -S: Maintained -F: tcg/ia64/ -F: disas/ia64.c - MIPS target M: Aurelien Jarno <aurelien@aurel32.net> S: Maintained diff --git a/accel/tcg/Makefile.objs b/accel/tcg/Makefile.objs index 70cd474c01..22642e6f75 100644 --- a/accel/tcg/Makefile.objs +++ b/accel/tcg/Makefile.objs @@ -1,3 +1,4 @@ obj-$(CONFIG_SOFTMMU) += tcg-all.o obj-$(CONFIG_SOFTMMU) += cputlb.o obj-y += cpu-exec.o cpu-exec-common.o translate-all.o +obj-y += translator.o diff --git a/accel/tcg/translator.c b/accel/tcg/translator.c new file mode 100644 index 0000000000..afa3af478a --- /dev/null +++ b/accel/tcg/translator.c @@ -0,0 +1,138 @@ +/* + * Generic intermediate code generation. + * + * Copyright (C) 2016-2017 Lluís Vilanova <vilanova@ac.upc.edu> + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "qemu-common.h" +#include "qemu/error-report.h" +#include "cpu.h" +#include "tcg/tcg.h" +#include "tcg/tcg-op.h" +#include "exec/exec-all.h" +#include "exec/gen-icount.h" +#include "exec/log.h" +#include "exec/translator.h" + +/* Pairs with tcg_clear_temp_count. + To be called by #TranslatorOps.{translate_insn,tb_stop} if + (1) the target is sufficiently clean to support reporting, + (2) as and when all temporaries are known to be consumed. + For most targets, (2) is at the end of translate_insn. */ +void translator_loop_temp_check(DisasContextBase *db) +{ + if (tcg_check_temp_count()) { + qemu_log("warning: TCG temporary leaks before " + TARGET_FMT_lx "\n", db->pc_next); + } +} + +void translator_loop(const TranslatorOps *ops, DisasContextBase *db, + CPUState *cpu, TranslationBlock *tb) +{ + int max_insns; + + /* Initialize DisasContext */ + db->tb = tb; + db->pc_first = tb->pc; + db->pc_next = db->pc_first; + db->is_jmp = DISAS_NEXT; + db->num_insns = 0; + db->singlestep_enabled = cpu->singlestep_enabled; + + /* Instruction counting */ + max_insns = db->tb->cflags & CF_COUNT_MASK; + if (max_insns == 0) { + max_insns = CF_COUNT_MASK; + } + if (max_insns > TCG_MAX_INSNS) { + max_insns = TCG_MAX_INSNS; + } + if (db->singlestep_enabled || singlestep) { + max_insns = 1; + } + + max_insns = ops->init_disas_context(db, cpu, max_insns); + tcg_debug_assert(db->is_jmp == DISAS_NEXT); /* no early exit */ + + /* Reset the temp count so that we can identify leaks */ + tcg_clear_temp_count(); + + /* Start translating. */ + gen_tb_start(db->tb); + ops->tb_start(db, cpu); + tcg_debug_assert(db->is_jmp == DISAS_NEXT); /* no early exit */ + + while (true) { + db->num_insns++; + ops->insn_start(db, cpu); + tcg_debug_assert(db->is_jmp == DISAS_NEXT); /* no early exit */ + + /* Pass breakpoint hits to target for further processing */ + if (unlikely(!QTAILQ_EMPTY(&cpu->breakpoints))) { + CPUBreakpoint *bp; + QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) { + if (bp->pc == db->pc_next) { + if (ops->breakpoint_check(db, cpu, bp)) { + break; + } + } + } + /* The breakpoint_check hook may use DISAS_TOO_MANY to indicate + that only one more instruction is to be executed. Otherwise + it should use DISAS_NORETURN when generating an exception, + but may use a DISAS_TARGET_* value for Something Else. */ + if (db->is_jmp > DISAS_TOO_MANY) { + break; + } + } + + /* Disassemble one instruction. The translate_insn hook should + update db->pc_next and db->is_jmp to indicate what should be + done next -- either exiting this loop or locate the start of + the next instruction. */ + if (db->num_insns == max_insns && (db->tb->cflags & CF_LAST_IO)) { + /* Accept I/O on the last instruction. */ + gen_io_start(); + ops->translate_insn(db, cpu); + gen_io_end(); + } else { + ops->translate_insn(db, cpu); + } + + /* Stop translation if translate_insn so indicated. */ + if (db->is_jmp != DISAS_NEXT) { + break; + } + + /* Stop translation if the output buffer is full, + or we have executed all of the allowed instructions. */ + if (tcg_op_buf_full() || db->num_insns >= max_insns) { + db->is_jmp = DISAS_TOO_MANY; + break; + } + } + + /* Emit code to exit the TB, as indicated by db->is_jmp. */ + ops->tb_stop(db, cpu); + gen_tb_end(db->tb, db->num_insns); + + /* The disas_log hook may use these values rather than recompute. */ + db->tb->size = db->pc_next - db->pc_first; + db->tb->icount = db->num_insns; + +#ifdef DEBUG_DISAS + if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) + && qemu_log_in_addr_range(db->pc_first)) { + qemu_log_lock(); + qemu_log("----------------\n"); + ops->disas_log(db, cpu); + qemu_log("\n"); + qemu_log_unlock(); + } +#endif +} @@ -496,6 +496,8 @@ int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) if (drv && drv->bdrv_probe_blocksizes) { return drv->bdrv_probe_blocksizes(bs, bsz); + } else if (drv && drv->is_filter && bs->file) { + return bdrv_probe_blocksizes(bs->file->bs, bsz); } return -ENOTSUP; @@ -513,6 +515,8 @@ int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo) if (drv && drv->bdrv_probe_geometry) { return drv->bdrv_probe_geometry(bs, geo); + } else if (drv && drv->is_filter && bs->file) { + return bdrv_probe_geometry(bs->file->bs, geo); } return -ENOTSUP; @@ -3426,11 +3430,15 @@ int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc, assert(child->perm & BLK_PERM_RESIZE); + /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ if (!drv) { error_setg(errp, "No medium inserted"); return -ENOMEDIUM; } if (!drv->bdrv_truncate) { + if (bs->file && drv->is_filter) { + return bdrv_truncate(bs->file, offset, prealloc, errp); + } error_setg(errp, "Image format driver does not support resize"); return -ENOTSUP; } @@ -3767,6 +3775,9 @@ int bdrv_has_zero_init(BlockDriverState *bs) if (bs->drv->bdrv_has_zero_init) { return bs->drv->bdrv_has_zero_init(bs); } + if (bs->file && bs->drv->is_filter) { + return bdrv_has_zero_init(bs->file->bs); + } /* safe default */ return 0; @@ -3821,10 +3832,16 @@ void bdrv_get_backing_filename(BlockDriverState *bs, int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) { BlockDriver *drv = bs->drv; - if (!drv) + /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ + if (!drv) { return -ENOMEDIUM; - if (!drv->bdrv_get_info) + } + if (!drv->bdrv_get_info) { + if (bs->file && drv->is_filter) { + return bdrv_get_info(bs->file->bs, bdi); + } return -ENOTSUP; + } memset(bdi, 0, sizeof(*bdi)); return drv->bdrv_get_info(bs, bdi); } @@ -4175,20 +4192,6 @@ bool bdrv_is_inserted(BlockDriverState *bs) } /** - * Return whether the media changed since the last call to this - * function, or -ENOTSUP if we don't know. Most drivers don't know. - */ -int bdrv_media_changed(BlockDriverState *bs) -{ - BlockDriver *drv = bs->drv; - - if (drv && drv->bdrv_media_changed) { - return drv->bdrv_media_changed(bs); - } - return -ENOTSUP; -} - -/** * If eject_flag is TRUE, eject the media. Otherwise, close the tray */ void bdrv_eject(BlockDriverState *bs, bool eject_flag) diff --git a/block/Makefile.objs b/block/Makefile.objs index 2aaede4ae1..6eaf78a046 100644 --- a/block/Makefile.objs +++ b/block/Makefile.objs @@ -25,6 +25,7 @@ block-obj-y += accounting.o dirty-bitmap.o block-obj-y += write-threshold.o block-obj-y += backup.o block-obj-$(CONFIG_REPLICATION) += replication.o +block-obj-y += throttle.o block-obj-y += crypto.o diff --git a/block/blkdebug.c b/block/blkdebug.c index 8e385acf54..46e53f2f09 100644 --- a/block/blkdebug.c +++ b/block/blkdebug.c @@ -628,16 +628,6 @@ static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs, return bdrv_co_pdiscard(bs->file->bs, offset, bytes); } -static int64_t coroutine_fn blkdebug_co_get_block_status( - BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum, - BlockDriverState **file) -{ - *pnum = nb_sectors; - *file = bs->file->bs; - return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | - (sector_num << BDRV_SECTOR_BITS); -} - static void blkdebug_close(BlockDriverState *bs) { BDRVBlkdebugState *s = bs->opaque; @@ -808,12 +798,6 @@ static int64_t blkdebug_getlength(BlockDriverState *bs) return bdrv_getlength(bs->file->bs); } -static int blkdebug_truncate(BlockDriverState *bs, int64_t offset, - PreallocMode prealloc, Error **errp) -{ - return bdrv_truncate(bs->file, offset, prealloc, errp); -} - static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options) { BDRVBlkdebugState *s = bs->opaque; @@ -896,6 +880,7 @@ static BlockDriver bdrv_blkdebug = { .format_name = "blkdebug", .protocol_name = "blkdebug", .instance_size = sizeof(BDRVBlkdebugState), + .is_filter = true, .bdrv_parse_filename = blkdebug_parse_filename, .bdrv_file_open = blkdebug_open, @@ -904,7 +889,6 @@ static BlockDriver bdrv_blkdebug = { .bdrv_child_perm = bdrv_filter_default_perms, .bdrv_getlength = blkdebug_getlength, - .bdrv_truncate = blkdebug_truncate, .bdrv_refresh_filename = blkdebug_refresh_filename, .bdrv_refresh_limits = blkdebug_refresh_limits, @@ -913,7 +897,7 @@ static BlockDriver bdrv_blkdebug = { .bdrv_co_flush_to_disk = blkdebug_co_flush, .bdrv_co_pwrite_zeroes = blkdebug_co_pwrite_zeroes, .bdrv_co_pdiscard = blkdebug_co_pdiscard, - .bdrv_co_get_block_status = blkdebug_co_get_block_status, + .bdrv_co_get_block_status = bdrv_co_get_block_status_from_file, .bdrv_debug_event = blkdebug_debug_event, .bdrv_debug_breakpoint = blkdebug_debug_breakpoint, diff --git a/block/block-backend.c b/block/block-backend.c index 1031742401..45d9101be3 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -273,9 +273,6 @@ BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm) blk->shared_perm = shared_perm; blk_set_enable_write_cache(blk, true); - qemu_co_mutex_init(&blk->public.throttled_reqs_lock); - qemu_co_queue_init(&blk->public.throttled_reqs[0]); - qemu_co_queue_init(&blk->public.throttled_reqs[1]); block_acct_init(&blk->stats); notifier_list_init(&blk->remove_bs_notifiers); @@ -343,7 +340,7 @@ static void blk_delete(BlockBackend *blk) assert(!blk->refcnt); assert(!blk->name); assert(!blk->dev); - if (blk->public.throttle_state) { + if (blk->public.throttle_group_member.throttle_state) { blk_io_limits_disable(blk); } if (blk->root) { @@ -658,9 +655,12 @@ BlockBackend *blk_by_public(BlockBackendPublic *public) */ void blk_remove_bs(BlockBackend *blk) { + ThrottleTimers *tt; + notifier_list_notify(&blk->remove_bs_notifiers, blk); - if (blk->public.throttle_state) { - throttle_timers_detach_aio_context(&blk->public.throttle_timers); + if (blk->public.throttle_group_member.throttle_state) { + tt = &blk->public.throttle_group_member.throttle_timers; + throttle_timers_detach_aio_context(tt); } blk_update_root_state(blk); @@ -682,9 +682,10 @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp) bdrv_ref(bs); notifier_list_notify(&blk->insert_bs_notifiers, blk); - if (blk->public.throttle_state) { + if (blk->public.throttle_group_member.throttle_state) { throttle_timers_attach_aio_context( - &blk->public.throttle_timers, bdrv_get_aio_context(bs)); + &blk->public.throttle_group_member.throttle_timers, + bdrv_get_aio_context(bs)); } return 0; @@ -1046,8 +1047,9 @@ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset, bdrv_inc_in_flight(bs); /* throttling disk I/O */ - if (blk->public.throttle_state) { - throttle_group_co_io_limits_intercept(blk, bytes, false); + if (blk->public.throttle_group_member.throttle_state) { + throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member, + bytes, false); } ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags); @@ -1070,10 +1072,10 @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset, } bdrv_inc_in_flight(bs); - /* throttling disk I/O */ - if (blk->public.throttle_state) { - throttle_group_co_io_limits_intercept(blk, bytes, true); + if (blk->public.throttle_group_member.throttle_state) { + throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member, + bytes, true); } if (!blk->enable_write_cache) { @@ -1742,16 +1744,14 @@ static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb) void blk_set_aio_context(BlockBackend *blk, AioContext *new_context) { BlockDriverState *bs = blk_bs(blk); + ThrottleGroupMember *tgm = &blk->public.throttle_group_member; if (bs) { - if (blk->public.throttle_state) { - throttle_timers_detach_aio_context(&blk->public.throttle_timers); + if (tgm->throttle_state) { + throttle_group_detach_aio_context(tgm); + throttle_group_attach_aio_context(tgm, new_context); } bdrv_set_aio_context(bs, new_context); - if (blk->public.throttle_state) { - throttle_timers_attach_aio_context(&blk->public.throttle_timers, - new_context); - } } } @@ -1969,33 +1969,35 @@ int blk_commit_all(void) /* throttling disk I/O limits */ void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg) { - throttle_group_config(blk, cfg); + throttle_group_config(&blk->public.throttle_group_member, cfg); } void blk_io_limits_disable(BlockBackend *blk) { - assert(blk->public.throttle_state); + assert(blk->public.throttle_group_member.throttle_state); bdrv_drained_begin(blk_bs(blk)); - throttle_group_unregister_blk(blk); + throttle_group_unregister_tgm(&blk->public.throttle_group_member); bdrv_drained_end(blk_bs(blk)); } /* should be called before blk_set_io_limits if a limit is set */ void blk_io_limits_enable(BlockBackend *blk, const char *group) { - assert(!blk->public.throttle_state); - throttle_group_register_blk(blk, group); + assert(!blk->public.throttle_group_member.throttle_state); + throttle_group_register_tgm(&blk->public.throttle_group_member, + group, blk_get_aio_context(blk)); } void blk_io_limits_update_group(BlockBackend *blk, const char *group) { /* this BB is not part of any group */ - if (!blk->public.throttle_state) { + if (!blk->public.throttle_group_member.throttle_state) { return; } /* this BB is a part of the same group than the one we want */ - if (!g_strcmp0(throttle_group_get_name(blk), group)) { + if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member), + group)) { return; } @@ -2017,8 +2019,8 @@ static void blk_root_drained_begin(BdrvChild *child) /* Note that blk->root may not be accessible here yet if we are just * attaching to a BlockDriverState that is drained. Use child instead. */ - if (atomic_fetch_inc(&blk->public.io_limits_disabled) == 0) { - throttle_group_restart_blk(blk); + if (atomic_fetch_inc(&blk->public.throttle_group_member.io_limits_disabled) == 0) { + throttle_group_restart_tgm(&blk->public.throttle_group_member); } } @@ -2027,8 +2029,8 @@ static void blk_root_drained_end(BdrvChild *child) BlockBackend *blk = child->opaque; assert(blk->quiesce_counter); - assert(blk->public.io_limits_disabled); - atomic_dec(&blk->public.io_limits_disabled); + assert(blk->public.throttle_group_member.io_limits_disabled); + atomic_dec(&blk->public.throttle_group_member.io_limits_disabled); if (--blk->quiesce_counter == 0) { if (blk->dev_ops && blk->dev_ops->drained_end) { diff --git a/block/commit.c b/block/commit.c index c7857c3321..898d91f653 100644 --- a/block/commit.c +++ b/block/commit.c @@ -244,16 +244,6 @@ static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs, return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags); } -static int64_t coroutine_fn bdrv_commit_top_get_block_status( - BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum, - BlockDriverState **file) -{ - *pnum = nb_sectors; - *file = bs->backing->bs; - return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | - (sector_num << BDRV_SECTOR_BITS); -} - static void bdrv_commit_top_refresh_filename(BlockDriverState *bs, QDict *opts) { bdrv_refresh_filename(bs->backing->bs); @@ -279,7 +269,7 @@ static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c, static BlockDriver bdrv_commit_top = { .format_name = "commit_top", .bdrv_co_preadv = bdrv_commit_top_preadv, - .bdrv_co_get_block_status = bdrv_commit_top_get_block_status, + .bdrv_co_get_block_status = bdrv_co_get_block_status_from_backing, .bdrv_refresh_filename = bdrv_commit_top_refresh_filename, .bdrv_close = bdrv_commit_top_close, .bdrv_child_perm = bdrv_commit_top_child_perm, diff --git a/block/io.c b/block/io.c index 26003814eb..4378ae4c7d 100644 --- a/block/io.c +++ b/block/io.c @@ -1714,6 +1714,32 @@ typedef struct BdrvCoGetBlockStatusData { bool done; } BdrvCoGetBlockStatusData; +int64_t coroutine_fn bdrv_co_get_block_status_from_file(BlockDriverState *bs, + int64_t sector_num, + int nb_sectors, + int *pnum, + BlockDriverState **file) +{ + assert(bs->file && bs->file->bs); + *pnum = nb_sectors; + *file = bs->file->bs; + return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | + (sector_num << BDRV_SECTOR_BITS); +} + +int64_t coroutine_fn bdrv_co_get_block_status_from_backing(BlockDriverState *bs, + int64_t sector_num, + int nb_sectors, + int *pnum, + BlockDriverState **file) +{ + assert(bs->backing && bs->backing->bs); + *pnum = nb_sectors; + *file = bs->backing->bs; + return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | + (sector_num << BDRV_SECTOR_BITS); +} + /* * Returns the allocation status of the specified sectors. * Drivers not implementing the functionality are assumed to not support diff --git a/block/mirror.c b/block/mirror.c index 429751b9fe..6531652d73 100644 --- a/block/mirror.c +++ b/block/mirror.c @@ -1059,16 +1059,6 @@ static int coroutine_fn bdrv_mirror_top_flush(BlockDriverState *bs) return bdrv_co_flush(bs->backing->bs); } -static int64_t coroutine_fn bdrv_mirror_top_get_block_status( - BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum, - BlockDriverState **file) -{ - *pnum = nb_sectors; - *file = bs->backing->bs; - return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | - (sector_num << BDRV_SECTOR_BITS); -} - static int coroutine_fn bdrv_mirror_top_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes, BdrvRequestFlags flags) { @@ -1115,7 +1105,7 @@ static BlockDriver bdrv_mirror_top = { .bdrv_co_pwrite_zeroes = bdrv_mirror_top_pwrite_zeroes, .bdrv_co_pdiscard = bdrv_mirror_top_pdiscard, .bdrv_co_flush = bdrv_mirror_top_flush, - .bdrv_co_get_block_status = bdrv_mirror_top_get_block_status, + .bdrv_co_get_block_status = bdrv_co_get_block_status_from_backing, .bdrv_refresh_filename = bdrv_mirror_top_refresh_filename, .bdrv_close = bdrv_mirror_top_close, .bdrv_child_perm = bdrv_mirror_top_child_perm, diff --git a/block/qapi.c b/block/qapi.c index 5f1a71f5d2..7fa2437923 100644 --- a/block/qapi.c +++ b/block/qapi.c @@ -66,10 +66,11 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk, info->detect_zeroes = bs->detect_zeroes; - if (blk && blk_get_public(blk)->throttle_state) { + if (blk && blk_get_public(blk)->throttle_group_member.throttle_state) { ThrottleConfig cfg; + BlockBackendPublic *blkp = blk_get_public(blk); - throttle_group_get_config(blk, &cfg); + throttle_group_get_config(&blkp->throttle_group_member, &cfg); info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg; info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg; @@ -117,7 +118,8 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk, info->iops_size = cfg.op_size; info->has_group = true; - info->group = g_strdup(throttle_group_get_name(blk)); + info->group = + g_strdup(throttle_group_get_name(&blkp->throttle_group_member)); } info->write_threshold = bdrv_write_threshold_get(bs); diff --git a/block/qcow.c b/block/qcow.c index 63904a26ee..f450b00cfc 100644 --- a/block/qcow.c +++ b/block/qcow.c @@ -347,19 +347,22 @@ static int qcow_reopen_prepare(BDRVReopenState *state, * 'compressed_size'. 'compressed_size' must be > 0 and < * cluster_size * - * return 0 if not allocated. + * return 0 if not allocated, 1 if *result is assigned, and negative + * errno on failure. */ -static uint64_t get_cluster_offset(BlockDriverState *bs, - uint64_t offset, int allocate, - int compressed_size, - int n_start, int n_end) +static int get_cluster_offset(BlockDriverState *bs, + uint64_t offset, int allocate, + int compressed_size, + int n_start, int n_end, uint64_t *result) { BDRVQcowState *s = bs->opaque; - int min_index, i, j, l1_index, l2_index; - uint64_t l2_offset, *l2_table, cluster_offset, tmp; + int min_index, i, j, l1_index, l2_index, ret; + int64_t l2_offset; + uint64_t *l2_table, cluster_offset, tmp; uint32_t min_count; int new_l2_table; + *result = 0; l1_index = offset >> (s->l2_bits + s->cluster_bits); l2_offset = s->l1_table[l1_index]; new_l2_table = 0; @@ -368,15 +371,20 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, return 0; /* allocate a new l2 entry */ l2_offset = bdrv_getlength(bs->file->bs); + if (l2_offset < 0) { + return l2_offset; + } /* round to cluster size */ - l2_offset = (l2_offset + s->cluster_size - 1) & ~(s->cluster_size - 1); + l2_offset = QEMU_ALIGN_UP(l2_offset, s->cluster_size); /* update the L1 entry */ s->l1_table[l1_index] = l2_offset; tmp = cpu_to_be64(l2_offset); - if (bdrv_pwrite_sync(bs->file, - s->l1_table_offset + l1_index * sizeof(tmp), - &tmp, sizeof(tmp)) < 0) - return 0; + ret = bdrv_pwrite_sync(bs->file, + s->l1_table_offset + l1_index * sizeof(tmp), + &tmp, sizeof(tmp)); + if (ret < 0) { + return ret; + } new_l2_table = 1; } for(i = 0; i < L2_CACHE_SIZE; i++) { @@ -403,14 +411,17 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, l2_table = s->l2_cache + (min_index << s->l2_bits); if (new_l2_table) { memset(l2_table, 0, s->l2_size * sizeof(uint64_t)); - if (bdrv_pwrite_sync(bs->file, l2_offset, l2_table, - s->l2_size * sizeof(uint64_t)) < 0) - return 0; + ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table, + s->l2_size * sizeof(uint64_t)); + if (ret < 0) { + return ret; + } } else { - if (bdrv_pread(bs->file, l2_offset, l2_table, - s->l2_size * sizeof(uint64_t)) != - s->l2_size * sizeof(uint64_t)) - return 0; + ret = bdrv_pread(bs->file, l2_offset, l2_table, + s->l2_size * sizeof(uint64_t)); + if (ret < 0) { + return ret; + } } s->l2_cache_offsets[min_index] = l2_offset; s->l2_cache_counts[min_index] = 1; @@ -427,24 +438,36 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, /* if the cluster is already compressed, we must decompress it in the case it is not completely overwritten */ - if (decompress_cluster(bs, cluster_offset) < 0) - return 0; + if (decompress_cluster(bs, cluster_offset) < 0) { + return -EIO; + } cluster_offset = bdrv_getlength(bs->file->bs); - cluster_offset = (cluster_offset + s->cluster_size - 1) & - ~(s->cluster_size - 1); + if ((int64_t) cluster_offset < 0) { + return cluster_offset; + } + cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size); /* write the cluster content */ - if (bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache, - s->cluster_size) != - s->cluster_size) - return -1; + ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache, + s->cluster_size); + if (ret < 0) { + return ret; + } } else { cluster_offset = bdrv_getlength(bs->file->bs); + if ((int64_t) cluster_offset < 0) { + return cluster_offset; + } if (allocate == 1) { /* round to cluster size */ - cluster_offset = (cluster_offset + s->cluster_size - 1) & - ~(s->cluster_size - 1); - bdrv_truncate(bs->file, cluster_offset + s->cluster_size, - PREALLOC_MODE_OFF, NULL); + cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size); + if (cluster_offset + s->cluster_size > INT64_MAX) { + return -E2BIG; + } + ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size, + PREALLOC_MODE_OFF, NULL); + if (ret < 0) { + return ret; + } /* if encrypted, we must initialize the cluster content which won't be written */ if (bs->encrypted && @@ -459,13 +482,14 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, s->cluster_data, BDRV_SECTOR_SIZE, NULL) < 0) { - errno = EIO; - return -1; + return -EIO; + } + ret = bdrv_pwrite(bs->file, + cluster_offset + i * 512, + s->cluster_data, 512); + if (ret < 0) { + return ret; } - if (bdrv_pwrite(bs->file, - cluster_offset + i * 512, - s->cluster_data, 512) != 512) - return -1; } } } @@ -477,23 +501,29 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, /* update L2 table */ tmp = cpu_to_be64(cluster_offset); l2_table[l2_index] = tmp; - if (bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp), - &tmp, sizeof(tmp)) < 0) - return 0; + ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp), + &tmp, sizeof(tmp)); + if (ret < 0) { + return ret; + } } - return cluster_offset; + *result = cluster_offset; + return 1; } static int64_t coroutine_fn qcow_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file) { BDRVQcowState *s = bs->opaque; - int index_in_cluster, n; + int index_in_cluster, n, ret; uint64_t cluster_offset; qemu_co_mutex_lock(&s->lock); - cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0); + ret = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0, &cluster_offset); qemu_co_mutex_unlock(&s->lock); + if (ret < 0) { + return ret; + } index_in_cluster = sector_num & (s->cluster_sectors - 1); n = s->cluster_sectors - index_in_cluster; if (n > nb_sectors) @@ -585,8 +615,11 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num, while (nb_sectors != 0) { /* prepare next request */ - cluster_offset = get_cluster_offset(bs, sector_num << 9, - 0, 0, 0, 0); + ret = get_cluster_offset(bs, sector_num << 9, + 0, 0, 0, 0, &cluster_offset); + if (ret < 0) { + break; + } index_in_cluster = sector_num & (s->cluster_sectors - 1); n = s->cluster_sectors - index_in_cluster; if (n > nb_sectors) { @@ -603,7 +636,7 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num, ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov); qemu_co_mutex_lock(&s->lock); if (ret < 0) { - goto fail; + break; } } else { /* Note: in this case, no need to wait */ @@ -612,13 +645,15 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num, } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) { /* add AIO support for compressed blocks ? */ if (decompress_cluster(bs, cluster_offset) < 0) { - goto fail; + ret = -EIO; + break; } memcpy(buf, s->cluster_cache + index_in_cluster * 512, 512 * n); } else { if ((cluster_offset & 511) != 0) { - goto fail; + ret = -EIO; + break; } hd_iov.iov_base = (void *)buf; hd_iov.iov_len = n * 512; @@ -635,7 +670,8 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num, assert(s->crypto); if (qcrypto_block_decrypt(s->crypto, sector_num, buf, n * BDRV_SECTOR_SIZE, NULL) < 0) { - goto fail; + ret = -EIO; + break; } } } @@ -646,7 +682,6 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num, buf += n * 512; } -done: qemu_co_mutex_unlock(&s->lock); if (qiov->niov > 1) { @@ -655,10 +690,6 @@ done: } return ret; - -fail: - ret = -EIO; - goto done; } static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num, @@ -697,9 +728,12 @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num, if (n > nb_sectors) { n = nb_sectors; } - cluster_offset = get_cluster_offset(bs, sector_num << 9, 1, 0, - index_in_cluster, - index_in_cluster + n); + ret = get_cluster_offset(bs, sector_num << 9, 1, 0, + index_in_cluster, + index_in_cluster + n, &cluster_offset); + if (ret < 0) { + break; + } if (!cluster_offset || (cluster_offset & 511) != 0) { ret = -EIO; break; @@ -995,8 +1029,11 @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, goto success; } qemu_co_mutex_lock(&s->lock); - cluster_offset = get_cluster_offset(bs, offset, 2, out_len, 0, 0); + ret = get_cluster_offset(bs, offset, 2, out_len, 0, 0, &cluster_offset); qemu_co_mutex_unlock(&s->lock); + if (ret < 0) { + goto fail; + } if (cluster_offset == 0) { ret = -EIO; goto fail; diff --git a/block/qcow2.c b/block/qcow2.c index 2ec399663e..bae5893327 100644 --- a/block/qcow2.c +++ b/block/qcow2.c @@ -2036,6 +2036,14 @@ static int qcow2_inactivate(BlockDriverState *bs) int ret, result = 0; Error *local_err = NULL; + qcow2_store_persistent_dirty_bitmaps(bs, &local_err); + if (local_err != NULL) { + result = -EINVAL; + error_report_err(local_err); + error_report("Persistent bitmaps are lost for node '%s'", + bdrv_get_device_or_node_name(bs)); + } + ret = qcow2_cache_flush(bs, s->l2_table_cache); if (ret) { result = ret; @@ -2050,14 +2058,6 @@ static int qcow2_inactivate(BlockDriverState *bs) strerror(-ret)); } - qcow2_store_persistent_dirty_bitmaps(bs, &local_err); - if (local_err != NULL) { - result = -EINVAL; - error_report_err(local_err); - error_report("Persistent bitmaps are lost for node '%s'", - bdrv_get_device_or_node_name(bs)); - } - if (result == 0) { qcow2_mark_clean(bs); } diff --git a/block/raw-format.c b/block/raw-format.c index 142649ed56..ab552c0954 100644 --- a/block/raw-format.c +++ b/block/raw-format.c @@ -372,11 +372,6 @@ static int raw_truncate(BlockDriverState *bs, int64_t offset, return bdrv_truncate(bs->file, offset, prealloc, errp); } -static int raw_media_changed(BlockDriverState *bs) -{ - return bdrv_media_changed(bs->file->bs); -} - static void raw_eject(BlockDriverState *bs, bool eject_flag) { bdrv_eject(bs->file->bs, eject_flag); @@ -510,7 +505,6 @@ BlockDriver bdrv_raw = { .bdrv_refresh_limits = &raw_refresh_limits, .bdrv_probe_blocksizes = &raw_probe_blocksizes, .bdrv_probe_geometry = &raw_probe_geometry, - .bdrv_media_changed = &raw_media_changed, .bdrv_eject = &raw_eject, .bdrv_lock_medium = &raw_lock_medium, .bdrv_co_ioctl = &raw_co_ioctl, diff --git a/block/throttle-groups.c b/block/throttle-groups.c index 890bfded3f..6ba992c8d7 100644 --- a/block/throttle-groups.c +++ b/block/throttle-groups.c @@ -25,12 +25,20 @@ #include "qemu/osdep.h" #include "sysemu/block-backend.h" #include "block/throttle-groups.h" +#include "qemu/throttle-options.h" #include "qemu/queue.h" #include "qemu/thread.h" #include "sysemu/qtest.h" +#include "qapi/error.h" +#include "qapi-visit.h" +#include "qom/object.h" +#include "qom/object_interfaces.h" + +static void throttle_group_obj_init(Object *obj); +static void throttle_group_obj_complete(UserCreatable *obj, Error **errp); /* The ThrottleGroup structure (with its ThrottleState) is shared - * among different BlockBackends and it's independent from + * among different ThrottleGroupMembers and it's independent from * AioContext, so in order to use it from different threads it needs * its own locking. * @@ -40,82 +48,95 @@ * The whole ThrottleGroup structure is private and invisible to * outside users, that only use it through its ThrottleState. * - * In addition to the ThrottleGroup structure, BlockBackendPublic has + * In addition to the ThrottleGroup structure, ThrottleGroupMember has * fields that need to be accessed by other members of the group and * therefore also need to be protected by this lock. Once a - * BlockBackend is registered in a group those fields can be accessed + * ThrottleGroupMember is registered in a group those fields can be accessed * by other threads any time. * * Again, all this is handled internally and is mostly transparent to * the outside. The 'throttle_timers' field however has an additional * constraint because it may be temporarily invalid (see for example * blk_set_aio_context()). Therefore in this file a thread will - * access some other BlockBackend's timers only after verifying that - * that BlockBackend has throttled requests in the queue. + * access some other ThrottleGroupMember's timers only after verifying that + * that ThrottleGroupMember has throttled requests in the queue. */ typedef struct ThrottleGroup { + Object parent_obj; + + /* refuse individual property change if initialization is complete */ + bool is_initialized; char *name; /* This is constant during the lifetime of the group */ QemuMutex lock; /* This lock protects the following four fields */ ThrottleState ts; - QLIST_HEAD(, BlockBackendPublic) head; - BlockBackend *tokens[2]; + QLIST_HEAD(, ThrottleGroupMember) head; + ThrottleGroupMember *tokens[2]; bool any_timer_armed[2]; QEMUClockType clock_type; - /* These two are protected by the global throttle_groups_lock */ - unsigned refcount; + /* This field is protected by the global QEMU mutex */ QTAILQ_ENTRY(ThrottleGroup) list; } ThrottleGroup; -static QemuMutex throttle_groups_lock; +/* This is protected by the global QEMU mutex */ static QTAILQ_HEAD(, ThrottleGroup) throttle_groups = QTAILQ_HEAD_INITIALIZER(throttle_groups); + +/* This function reads throttle_groups and must be called under the global + * mutex. + */ +static ThrottleGroup *throttle_group_by_name(const char *name) +{ + ThrottleGroup *iter; + + /* Look for an existing group with that name */ + QTAILQ_FOREACH(iter, &throttle_groups, list) { + if (!g_strcmp0(name, iter->name)) { + return iter; + } + } + + return NULL; +} + +/* This function reads throttle_groups and must be called under the global + * mutex. + */ +bool throttle_group_exists(const char *name) +{ + return throttle_group_by_name(name) != NULL; +} + /* Increments the reference count of a ThrottleGroup given its name. * * If no ThrottleGroup is found with the given name a new one is * created. * + * This function edits throttle_groups and must be called under the global + * mutex. + * * @name: the name of the ThrottleGroup * @ret: the ThrottleState member of the ThrottleGroup */ ThrottleState *throttle_group_incref(const char *name) { ThrottleGroup *tg = NULL; - ThrottleGroup *iter; - - qemu_mutex_lock(&throttle_groups_lock); /* Look for an existing group with that name */ - QTAILQ_FOREACH(iter, &throttle_groups, list) { - if (!strcmp(name, iter->name)) { - tg = iter; - break; - } - } - - /* Create a new one if not found */ - if (!tg) { - tg = g_new0(ThrottleGroup, 1); + tg = throttle_group_by_name(name); + + if (tg) { + object_ref(OBJECT(tg)); + } else { + /* Create a new one if not found */ + /* new ThrottleGroup obj will have a refcnt = 1 */ + tg = THROTTLE_GROUP(object_new(TYPE_THROTTLE_GROUP)); tg->name = g_strdup(name); - tg->clock_type = QEMU_CLOCK_REALTIME; - - if (qtest_enabled()) { - /* For testing block IO throttling only */ - tg->clock_type = QEMU_CLOCK_VIRTUAL; - } - qemu_mutex_init(&tg->lock); - throttle_init(&tg->ts); - QLIST_INIT(&tg->head); - - QTAILQ_INSERT_TAIL(&throttle_groups, tg, list); + throttle_group_obj_complete(USER_CREATABLE(tg), &error_abort); } - tg->refcount++; - - qemu_mutex_unlock(&throttle_groups_lock); - return &tg->ts; } @@ -124,130 +145,123 @@ ThrottleState *throttle_group_incref(const char *name) * When the reference count reaches zero the ThrottleGroup is * destroyed. * + * This function edits throttle_groups and must be called under the global + * mutex. + * * @ts: The ThrottleGroup to unref, given by its ThrottleState member */ void throttle_group_unref(ThrottleState *ts) { ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - - qemu_mutex_lock(&throttle_groups_lock); - if (--tg->refcount == 0) { - QTAILQ_REMOVE(&throttle_groups, tg, list); - qemu_mutex_destroy(&tg->lock); - g_free(tg->name); - g_free(tg); - } - qemu_mutex_unlock(&throttle_groups_lock); + object_unref(OBJECT(tg)); } -/* Get the name from a BlockBackend's ThrottleGroup. The name (and the pointer) +/* Get the name from a ThrottleGroupMember's group. The name (and the pointer) * is guaranteed to remain constant during the lifetime of the group. * - * @blk: a BlockBackend that is member of a throttling group + * @tgm: a ThrottleGroupMember * @ret: the name of the group. */ -const char *throttle_group_get_name(BlockBackend *blk) +const char *throttle_group_get_name(ThrottleGroupMember *tgm) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); + ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts); return tg->name; } -/* Return the next BlockBackend in the round-robin sequence, simulating a - * circular list. +/* Return the next ThrottleGroupMember in the round-robin sequence, simulating + * a circular list. * * This assumes that tg->lock is held. * - * @blk: the current BlockBackend - * @ret: the next BlockBackend in the sequence + * @tgm: the current ThrottleGroupMember + * @ret: the next ThrottleGroupMember in the sequence */ -static BlockBackend *throttle_group_next_blk(BlockBackend *blk) +static ThrottleGroupMember *throttle_group_next_tgm(ThrottleGroupMember *tgm) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleState *ts = blkp->throttle_state; + ThrottleState *ts = tgm->throttle_state; ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - BlockBackendPublic *next = QLIST_NEXT(blkp, round_robin); + ThrottleGroupMember *next = QLIST_NEXT(tgm, round_robin); if (!next) { next = QLIST_FIRST(&tg->head); } - return blk_by_public(next); + return next; } /* - * Return whether a BlockBackend has pending requests. + * Return whether a ThrottleGroupMember has pending requests. * * This assumes that tg->lock is held. * - * @blk: the BlockBackend - * @is_write: the type of operation (read/write) - * @ret: whether the BlockBackend has pending requests. + * @tgm: the ThrottleGroupMember + * @is_write: the type of operation (read/write) + * @ret: whether the ThrottleGroupMember has pending requests. */ -static inline bool blk_has_pending_reqs(BlockBackend *blk, +static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm, bool is_write) { - const BlockBackendPublic *blkp = blk_get_public(blk); - return blkp->pending_reqs[is_write]; + return tgm->pending_reqs[is_write]; } -/* Return the next BlockBackend in the round-robin sequence with pending I/O - * requests. +/* Return the next ThrottleGroupMember in the round-robin sequence with pending + * I/O requests. * * This assumes that tg->lock is held. * - * @blk: the current BlockBackend + * @tgm: the current ThrottleGroupMember * @is_write: the type of operation (read/write) - * @ret: the next BlockBackend with pending requests, or blk if there is - * none. + * @ret: the next ThrottleGroupMember with pending requests, or tgm if + * there is none. */ -static BlockBackend *next_throttle_token(BlockBackend *blk, bool is_write) +static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm, + bool is_write) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); - BlockBackend *token, *start; + ThrottleState *ts = tgm->throttle_state; + ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); + ThrottleGroupMember *token, *start; start = token = tg->tokens[is_write]; /* get next bs round in round robin style */ - token = throttle_group_next_blk(token); - while (token != start && !blk_has_pending_reqs(token, is_write)) { - token = throttle_group_next_blk(token); + token = throttle_group_next_tgm(token); + while (token != start && !tgm_has_pending_reqs(token, is_write)) { + token = throttle_group_next_tgm(token); } /* If no IO are queued for scheduling on the next round robin token - * then decide the token is the current bs because chances are - * the current bs get the current request queued. + * then decide the token is the current tgm because chances are + * the current tgm got the current request queued. */ - if (token == start && !blk_has_pending_reqs(token, is_write)) { - token = blk; + if (token == start && !tgm_has_pending_reqs(token, is_write)) { + token = tgm; } - /* Either we return the original BB, or one with pending requests */ - assert(token == blk || blk_has_pending_reqs(token, is_write)); + /* Either we return the original TGM, or one with pending requests */ + assert(token == tgm || tgm_has_pending_reqs(token, is_write)); return token; } -/* Check if the next I/O request for a BlockBackend needs to be throttled or - * not. If there's no timer set in this group, set one and update the token - * accordingly. +/* Check if the next I/O request for a ThrottleGroupMember needs to be + * throttled or not. If there's no timer set in this group, set one and update + * the token accordingly. * * This assumes that tg->lock is held. * - * @blk: the current BlockBackend + * @tgm: the current ThrottleGroupMember * @is_write: the type of operation (read/write) * @ret: whether the I/O request needs to be throttled or not */ -static bool throttle_group_schedule_timer(BlockBackend *blk, bool is_write) +static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm, + bool is_write) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleState *ts = blkp->throttle_state; - ThrottleTimers *tt = &blkp->throttle_timers; + ThrottleState *ts = tgm->throttle_state; ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); + ThrottleTimers *tt = &tgm->throttle_timers; bool must_wait; - if (atomic_read(&blkp->io_limits_disabled)) { + if (atomic_read(&tgm->io_limits_disabled)) { return false; } @@ -258,30 +272,29 @@ static bool throttle_group_schedule_timer(BlockBackend *blk, bool is_write) must_wait = throttle_schedule_timer(ts, tt, is_write); - /* If a timer just got armed, set blk as the current token */ + /* If a timer just got armed, set tgm as the current token */ if (must_wait) { - tg->tokens[is_write] = blk; + tg->tokens[is_write] = tgm; tg->any_timer_armed[is_write] = true; } return must_wait; } -/* Start the next pending I/O request for a BlockBackend. Return whether +/* Start the next pending I/O request for a ThrottleGroupMember. Return whether * any request was actually pending. * - * @blk: the current BlockBackend + * @tgm: the current ThrottleGroupMember * @is_write: the type of operation (read/write) */ -static bool coroutine_fn throttle_group_co_restart_queue(BlockBackend *blk, +static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tgm, bool is_write) { - BlockBackendPublic *blkp = blk_get_public(blk); bool ret; - qemu_co_mutex_lock(&blkp->throttled_reqs_lock); - ret = qemu_co_queue_next(&blkp->throttled_reqs[is_write]); - qemu_co_mutex_unlock(&blkp->throttled_reqs_lock); + qemu_co_mutex_lock(&tgm->throttled_reqs_lock); + ret = qemu_co_queue_next(&tgm->throttled_reqs[is_write]); + qemu_co_mutex_unlock(&tgm->throttled_reqs_lock); return ret; } @@ -290,19 +303,19 @@ static bool coroutine_fn throttle_group_co_restart_queue(BlockBackend *blk, * * This assumes that tg->lock is held. * - * @blk: the current BlockBackend + * @tgm: the current ThrottleGroupMember * @is_write: the type of operation (read/write) */ -static void schedule_next_request(BlockBackend *blk, bool is_write) +static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); + ThrottleState *ts = tgm->throttle_state; + ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); bool must_wait; - BlockBackend *token; + ThrottleGroupMember *token; /* Check if there's any pending request to schedule next */ - token = next_throttle_token(blk, is_write); - if (!blk_has_pending_reqs(token, is_write)) { + token = next_throttle_token(tgm, is_write); + if (!tgm_has_pending_reqs(token, is_write)) { return; } @@ -311,12 +324,12 @@ static void schedule_next_request(BlockBackend *blk, bool is_write) /* If it doesn't have to wait, queue it for immediate execution */ if (!must_wait) { - /* Give preference to requests from the current blk */ + /* Give preference to requests from the current tgm */ if (qemu_in_coroutine() && - throttle_group_co_restart_queue(blk, is_write)) { - token = blk; + throttle_group_co_restart_queue(tgm, is_write)) { + token = tgm; } else { - ThrottleTimers *tt = &blk_get_public(token)->throttle_timers; + ThrottleTimers *tt = &token->throttle_timers; int64_t now = qemu_clock_get_ns(tg->clock_type); timer_mod(tt->timers[is_write], now); tg->any_timer_armed[is_write] = true; @@ -329,90 +342,86 @@ static void schedule_next_request(BlockBackend *blk, bool is_write) * if necessary, and schedule the next request using a round robin * algorithm. * - * @blk: the current BlockBackend + * @tgm: the current ThrottleGroupMember * @bytes: the number of bytes for this I/O * @is_write: the type of operation (read/write) */ -void coroutine_fn throttle_group_co_io_limits_intercept(BlockBackend *blk, +void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm, unsigned int bytes, bool is_write) { bool must_wait; - BlockBackend *token; - - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); + ThrottleGroupMember *token; + ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts); qemu_mutex_lock(&tg->lock); /* First we check if this I/O has to be throttled. */ - token = next_throttle_token(blk, is_write); + token = next_throttle_token(tgm, is_write); must_wait = throttle_group_schedule_timer(token, is_write); /* Wait if there's a timer set or queued requests of this type */ - if (must_wait || blkp->pending_reqs[is_write]) { - blkp->pending_reqs[is_write]++; + if (must_wait || tgm->pending_reqs[is_write]) { + tgm->pending_reqs[is_write]++; qemu_mutex_unlock(&tg->lock); - qemu_co_mutex_lock(&blkp->throttled_reqs_lock); - qemu_co_queue_wait(&blkp->throttled_reqs[is_write], - &blkp->throttled_reqs_lock); - qemu_co_mutex_unlock(&blkp->throttled_reqs_lock); + qemu_co_mutex_lock(&tgm->throttled_reqs_lock); + qemu_co_queue_wait(&tgm->throttled_reqs[is_write], + &tgm->throttled_reqs_lock); + qemu_co_mutex_unlock(&tgm->throttled_reqs_lock); qemu_mutex_lock(&tg->lock); - blkp->pending_reqs[is_write]--; + tgm->pending_reqs[is_write]--; } /* The I/O will be executed, so do the accounting */ - throttle_account(blkp->throttle_state, is_write, bytes); + throttle_account(tgm->throttle_state, is_write, bytes); /* Schedule the next request */ - schedule_next_request(blk, is_write); + schedule_next_request(tgm, is_write); qemu_mutex_unlock(&tg->lock); } typedef struct { - BlockBackend *blk; + ThrottleGroupMember *tgm; bool is_write; } RestartData; static void coroutine_fn throttle_group_restart_queue_entry(void *opaque) { RestartData *data = opaque; - BlockBackend *blk = data->blk; + ThrottleGroupMember *tgm = data->tgm; + ThrottleState *ts = tgm->throttle_state; + ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); bool is_write = data->is_write; - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); bool empty_queue; - empty_queue = !throttle_group_co_restart_queue(blk, is_write); + empty_queue = !throttle_group_co_restart_queue(tgm, is_write); /* If the request queue was empty then we have to take care of * scheduling the next one */ if (empty_queue) { qemu_mutex_lock(&tg->lock); - schedule_next_request(blk, is_write); + schedule_next_request(tgm, is_write); qemu_mutex_unlock(&tg->lock); } } -static void throttle_group_restart_queue(BlockBackend *blk, bool is_write) +static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write) { Coroutine *co; RestartData rd = { - .blk = blk, + .tgm = tgm, .is_write = is_write }; co = qemu_coroutine_create(throttle_group_restart_queue_entry, &rd); - aio_co_enter(blk_get_aio_context(blk), co); + aio_co_enter(tgm->aio_context, co); } -void throttle_group_restart_blk(BlockBackend *blk) +void throttle_group_restart_tgm(ThrottleGroupMember *tgm) { - BlockBackendPublic *blkp = blk_get_public(blk); - - if (blkp->throttle_state) { - throttle_group_restart_queue(blk, 0); - throttle_group_restart_queue(blk, 1); + if (tgm->throttle_state) { + throttle_group_restart_queue(tgm, 0); + throttle_group_restart_queue(tgm, 1); } } @@ -420,32 +429,30 @@ void throttle_group_restart_blk(BlockBackend *blk) * to throttle_config(), but guarantees atomicity within the * throttling group. * - * @blk: a BlockBackend that is a member of the group + * @tgm: a ThrottleGroupMember that is a member of the group * @cfg: the configuration to set */ -void throttle_group_config(BlockBackend *blk, ThrottleConfig *cfg) +void throttle_group_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleState *ts = blkp->throttle_state; + ThrottleState *ts = tgm->throttle_state; ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); qemu_mutex_lock(&tg->lock); throttle_config(ts, tg->clock_type, cfg); qemu_mutex_unlock(&tg->lock); - throttle_group_restart_blk(blk); + throttle_group_restart_tgm(tgm); } /* Get the throttle configuration from a particular group. Similar to * throttle_get_config(), but guarantees atomicity within the * throttling group. * - * @blk: a BlockBackend that is a member of the group + * @tgm: a ThrottleGroupMember that is a member of the group * @cfg: the configuration will be written here */ -void throttle_group_get_config(BlockBackend *blk, ThrottleConfig *cfg) +void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleState *ts = blkp->throttle_state; + ThrottleState *ts = tgm->throttle_state; ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); qemu_mutex_lock(&tg->lock); throttle_get_config(ts, cfg); @@ -455,13 +462,12 @@ void throttle_group_get_config(BlockBackend *blk, ThrottleConfig *cfg) /* ThrottleTimers callback. This wakes up a request that was waiting * because it had been throttled. * - * @blk: the BlockBackend whose request had been throttled + * @tgm: the ThrottleGroupMember whose request had been throttled * @is_write: the type of operation (read/write) */ -static void timer_cb(BlockBackend *blk, bool is_write) +static void timer_cb(ThrottleGroupMember *tgm, bool is_write) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleState *ts = blkp->throttle_state; + ThrottleState *ts = tgm->throttle_state; ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); /* The timer has just been fired, so we can update the flag */ @@ -470,7 +476,7 @@ static void timer_cb(BlockBackend *blk, bool is_write) qemu_mutex_unlock(&tg->lock); /* Run the request that was waiting for this timer */ - throttle_group_restart_queue(blk, is_write); + throttle_group_restart_queue(tgm, is_write); } static void read_timer_cb(void *opaque) @@ -483,85 +489,445 @@ static void write_timer_cb(void *opaque) timer_cb(opaque, true); } -/* Register a BlockBackend in the throttling group, also initializing its - * timers and updating its throttle_state pointer to point to it. If a +/* Register a ThrottleGroupMember from the throttling group, also initializing + * its timers and updating its throttle_state pointer to point to it. If a * throttling group with that name does not exist yet, it will be created. * - * @blk: the BlockBackend to insert + * This function edits throttle_groups and must be called under the global + * mutex. + * + * @tgm: the ThrottleGroupMember to insert * @groupname: the name of the group + * @ctx: the AioContext to use */ -void throttle_group_register_blk(BlockBackend *blk, const char *groupname) +void throttle_group_register_tgm(ThrottleGroupMember *tgm, + const char *groupname, + AioContext *ctx) { int i; - BlockBackendPublic *blkp = blk_get_public(blk); ThrottleState *ts = throttle_group_incref(groupname); ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - blkp->throttle_state = ts; + + tgm->throttle_state = ts; + tgm->aio_context = ctx; qemu_mutex_lock(&tg->lock); - /* If the ThrottleGroup is new set this BlockBackend as the token */ + /* If the ThrottleGroup is new set this ThrottleGroupMember as the token */ for (i = 0; i < 2; i++) { if (!tg->tokens[i]) { - tg->tokens[i] = blk; + tg->tokens[i] = tgm; } } - QLIST_INSERT_HEAD(&tg->head, blkp, round_robin); + QLIST_INSERT_HEAD(&tg->head, tgm, round_robin); - throttle_timers_init(&blkp->throttle_timers, - blk_get_aio_context(blk), + throttle_timers_init(&tgm->throttle_timers, + tgm->aio_context, tg->clock_type, read_timer_cb, write_timer_cb, - blk); + tgm); + qemu_co_mutex_init(&tgm->throttled_reqs_lock); + qemu_co_queue_init(&tgm->throttled_reqs[0]); + qemu_co_queue_init(&tgm->throttled_reqs[1]); qemu_mutex_unlock(&tg->lock); } -/* Unregister a BlockBackend from its group, removing it from the list, +/* Unregister a ThrottleGroupMember from its group, removing it from the list, * destroying the timers and setting the throttle_state pointer to NULL. * - * The BlockBackend must not have pending throttled requests, so the caller has - * to drain them first. + * The ThrottleGroupMember must not have pending throttled requests, so the + * caller has to drain them first. * * The group will be destroyed if it's empty after this operation. * - * @blk: the BlockBackend to remove + * @tgm the ThrottleGroupMember to remove */ -void throttle_group_unregister_blk(BlockBackend *blk) +void throttle_group_unregister_tgm(ThrottleGroupMember *tgm) { - BlockBackendPublic *blkp = blk_get_public(blk); - ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); + ThrottleState *ts = tgm->throttle_state; + ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); + ThrottleGroupMember *token; int i; - assert(blkp->pending_reqs[0] == 0 && blkp->pending_reqs[1] == 0); - assert(qemu_co_queue_empty(&blkp->throttled_reqs[0])); - assert(qemu_co_queue_empty(&blkp->throttled_reqs[1])); + if (!ts) { + /* Discard already unregistered tgm */ + return; + } + + assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0); + assert(qemu_co_queue_empty(&tgm->throttled_reqs[0])); + assert(qemu_co_queue_empty(&tgm->throttled_reqs[1])); qemu_mutex_lock(&tg->lock); for (i = 0; i < 2; i++) { - if (tg->tokens[i] == blk) { - BlockBackend *token = throttle_group_next_blk(blk); - /* Take care of the case where this is the last blk in the group */ - if (token == blk) { + if (tg->tokens[i] == tgm) { + token = throttle_group_next_tgm(tgm); + /* Take care of the case where this is the last tgm in the group */ + if (token == tgm) { token = NULL; } tg->tokens[i] = token; } } - /* remove the current blk from the list */ - QLIST_REMOVE(blkp, round_robin); - throttle_timers_destroy(&blkp->throttle_timers); + /* remove the current tgm from the list */ + QLIST_REMOVE(tgm, round_robin); + throttle_timers_destroy(&tgm->throttle_timers); qemu_mutex_unlock(&tg->lock); throttle_group_unref(&tg->ts); - blkp->throttle_state = NULL; + tgm->throttle_state = NULL; +} + +void throttle_group_attach_aio_context(ThrottleGroupMember *tgm, + AioContext *new_context) +{ + ThrottleTimers *tt = &tgm->throttle_timers; + throttle_timers_attach_aio_context(tt, new_context); + tgm->aio_context = new_context; +} + +void throttle_group_detach_aio_context(ThrottleGroupMember *tgm) +{ + ThrottleTimers *tt = &tgm->throttle_timers; + throttle_timers_detach_aio_context(tt); + tgm->aio_context = NULL; +} + +#undef THROTTLE_OPT_PREFIX +#define THROTTLE_OPT_PREFIX "x-" + +/* Helper struct and array for QOM property setter/getter */ +typedef struct { + const char *name; + BucketType type; + enum { + AVG, + MAX, + BURST_LENGTH, + IOPS_SIZE, + } category; +} ThrottleParamInfo; + +static ThrottleParamInfo properties[] = { + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL, + THROTTLE_OPS_TOTAL, AVG, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX, + THROTTLE_OPS_TOTAL, MAX, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX_LENGTH, + THROTTLE_OPS_TOTAL, BURST_LENGTH, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ, + THROTTLE_OPS_READ, AVG, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX, + THROTTLE_OPS_READ, MAX, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX_LENGTH, + THROTTLE_OPS_READ, BURST_LENGTH, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE, + THROTTLE_OPS_WRITE, AVG, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX, + THROTTLE_OPS_WRITE, MAX, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX_LENGTH, + THROTTLE_OPS_WRITE, BURST_LENGTH, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL, + THROTTLE_BPS_TOTAL, AVG, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX, + THROTTLE_BPS_TOTAL, MAX, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX_LENGTH, + THROTTLE_BPS_TOTAL, BURST_LENGTH, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ, + THROTTLE_BPS_READ, AVG, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX, + THROTTLE_BPS_READ, MAX, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX_LENGTH, + THROTTLE_BPS_READ, BURST_LENGTH, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE, + THROTTLE_BPS_WRITE, AVG, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX, + THROTTLE_BPS_WRITE, MAX, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX_LENGTH, + THROTTLE_BPS_WRITE, BURST_LENGTH, + }, + { + THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_SIZE, + 0, IOPS_SIZE, + } +}; + +/* This function edits throttle_groups and must be called under the global + * mutex */ +static void throttle_group_obj_init(Object *obj) +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + + tg->clock_type = QEMU_CLOCK_REALTIME; + if (qtest_enabled()) { + /* For testing block IO throttling only */ + tg->clock_type = QEMU_CLOCK_VIRTUAL; + } + tg->is_initialized = false; + qemu_mutex_init(&tg->lock); + throttle_init(&tg->ts); + QLIST_INIT(&tg->head); } +/* This function edits throttle_groups and must be called under the global + * mutex */ +static void throttle_group_obj_complete(UserCreatable *obj, Error **errp) +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + ThrottleConfig cfg; + + /* set group name to object id if it exists */ + if (!tg->name && tg->parent_obj.parent) { + tg->name = object_get_canonical_path_component(OBJECT(obj)); + } + /* We must have a group name at this point */ + assert(tg->name); + + /* error if name is duplicate */ + if (throttle_group_exists(tg->name)) { + error_setg(errp, "A group with this name already exists"); + return; + } + + /* check validity */ + throttle_get_config(&tg->ts, &cfg); + if (!throttle_is_valid(&cfg, errp)) { + return; + } + throttle_config(&tg->ts, tg->clock_type, &cfg); + QTAILQ_INSERT_TAIL(&throttle_groups, tg, list); + tg->is_initialized = true; +} + +/* This function edits throttle_groups and must be called under the global + * mutex */ +static void throttle_group_obj_finalize(Object *obj) +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + if (tg->is_initialized) { + QTAILQ_REMOVE(&throttle_groups, tg, list); + } + qemu_mutex_destroy(&tg->lock); + g_free(tg->name); +} + +static void throttle_group_set(Object *obj, Visitor *v, const char * name, + void *opaque, Error **errp) + +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + ThrottleConfig *cfg; + ThrottleParamInfo *info = opaque; + Error *local_err = NULL; + int64_t value; + + /* If we have finished initialization, don't accept individual property + * changes through QOM. Throttle configuration limits must be set in one + * transaction, as certain combinations are invalid. + */ + if (tg->is_initialized) { + error_setg(&local_err, "Property cannot be set after initialization"); + goto ret; + } + + visit_type_int64(v, name, &value, &local_err); + if (local_err) { + goto ret; + } + if (value < 0) { + error_setg(&local_err, "Property values cannot be negative"); + goto ret; + } + + cfg = &tg->ts.cfg; + switch (info->category) { + case AVG: + cfg->buckets[info->type].avg = value; + break; + case MAX: + cfg->buckets[info->type].max = value; + break; + case BURST_LENGTH: + if (value > UINT_MAX) { + error_setg(&local_err, "%s value must be in the" + "range [0, %u]", info->name, UINT_MAX); + goto ret; + } + cfg->buckets[info->type].burst_length = value; + break; + case IOPS_SIZE: + cfg->op_size = value; + break; + } + +ret: + error_propagate(errp, local_err); + return; + +} + +static void throttle_group_get(Object *obj, Visitor *v, const char *name, + void *opaque, Error **errp) +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + ThrottleConfig cfg; + ThrottleParamInfo *info = opaque; + int64_t value; + + throttle_get_config(&tg->ts, &cfg); + switch (info->category) { + case AVG: + value = cfg.buckets[info->type].avg; + break; + case MAX: + value = cfg.buckets[info->type].max; + break; + case BURST_LENGTH: + value = cfg.buckets[info->type].burst_length; + break; + case IOPS_SIZE: + value = cfg.op_size; + break; + } + + visit_type_int64(v, name, &value, errp); +} + +static void throttle_group_set_limits(Object *obj, Visitor *v, + const char *name, void *opaque, + Error **errp) + +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + ThrottleConfig cfg; + ThrottleLimits arg = { 0 }; + ThrottleLimits *argp = &arg; + Error *local_err = NULL; + + visit_type_ThrottleLimits(v, name, &argp, &local_err); + if (local_err) { + goto ret; + } + qemu_mutex_lock(&tg->lock); + throttle_get_config(&tg->ts, &cfg); + throttle_limits_to_config(argp, &cfg, &local_err); + if (local_err) { + goto unlock; + } + throttle_config(&tg->ts, tg->clock_type, &cfg); + +unlock: + qemu_mutex_unlock(&tg->lock); +ret: + error_propagate(errp, local_err); + return; +} + +static void throttle_group_get_limits(Object *obj, Visitor *v, + const char *name, void *opaque, + Error **errp) +{ + ThrottleGroup *tg = THROTTLE_GROUP(obj); + ThrottleConfig cfg; + ThrottleLimits arg = { 0 }; + ThrottleLimits *argp = &arg; + + qemu_mutex_lock(&tg->lock); + throttle_get_config(&tg->ts, &cfg); + qemu_mutex_unlock(&tg->lock); + + throttle_config_to_limits(&cfg, argp); + + visit_type_ThrottleLimits(v, name, &argp, errp); +} + +static bool throttle_group_can_be_deleted(UserCreatable *uc) +{ + return OBJECT(uc)->ref == 1; +} + +static void throttle_group_obj_class_init(ObjectClass *klass, void *class_data) +{ + size_t i = 0; + UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass); + + ucc->complete = throttle_group_obj_complete; + ucc->can_be_deleted = throttle_group_can_be_deleted; + + /* individual properties */ + for (i = 0; i < sizeof(properties) / sizeof(ThrottleParamInfo); i++) { + object_class_property_add(klass, + properties[i].name, + "int", + throttle_group_get, + throttle_group_set, + NULL, &properties[i], + &error_abort); + } + + /* ThrottleLimits */ + object_class_property_add(klass, + "limits", "ThrottleLimits", + throttle_group_get_limits, + throttle_group_set_limits, + NULL, NULL, + &error_abort); +} + +static const TypeInfo throttle_group_info = { + .name = TYPE_THROTTLE_GROUP, + .parent = TYPE_OBJECT, + .class_init = throttle_group_obj_class_init, + .instance_size = sizeof(ThrottleGroup), + .instance_init = throttle_group_obj_init, + .instance_finalize = throttle_group_obj_finalize, + .interfaces = (InterfaceInfo[]) { + { TYPE_USER_CREATABLE }, + { } + }, +}; + static void throttle_groups_init(void) { - qemu_mutex_init(&throttle_groups_lock); + type_register_static(&throttle_group_info); } -block_init(throttle_groups_init); +type_init(throttle_groups_init); diff --git a/block/throttle.c b/block/throttle.c new file mode 100644 index 0000000000..5bca76300f --- /dev/null +++ b/block/throttle.c @@ -0,0 +1,237 @@ +/* + * QEMU block throttling filter driver infrastructure + * + * Copyright (c) 2017 Manos Pitsidianakis + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 or + * (at your option) version 3 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + */ + +#include "qemu/osdep.h" +#include "block/throttle-groups.h" +#include "qemu/throttle-options.h" +#include "qapi/error.h" + +static QemuOptsList throttle_opts = { + .name = "throttle", + .head = QTAILQ_HEAD_INITIALIZER(throttle_opts.head), + .desc = { + { + .name = QEMU_OPT_THROTTLE_GROUP_NAME, + .type = QEMU_OPT_STRING, + .help = "Name of the throttle group", + }, + { /* end of list */ } + }, +}; + +static int throttle_configure_tgm(BlockDriverState *bs, + ThrottleGroupMember *tgm, + QDict *options, Error **errp) +{ + int ret; + const char *group_name; + Error *local_err = NULL; + QemuOpts *opts = qemu_opts_create(&throttle_opts, NULL, 0, &error_abort); + + qemu_opts_absorb_qdict(opts, options, &local_err); + if (local_err) { + error_propagate(errp, local_err); + ret = -EINVAL; + goto fin; + } + + group_name = qemu_opt_get(opts, QEMU_OPT_THROTTLE_GROUP_NAME); + if (!group_name) { + error_setg(errp, "Please specify a throttle group"); + ret = -EINVAL; + goto fin; + } else if (!throttle_group_exists(group_name)) { + error_setg(errp, "Throttle group '%s' does not exist", group_name); + ret = -EINVAL; + goto fin; + } + + /* Register membership to group with name group_name */ + throttle_group_register_tgm(tgm, group_name, bdrv_get_aio_context(bs)); + ret = 0; +fin: + qemu_opts_del(opts); + return ret; +} + +static int throttle_open(BlockDriverState *bs, QDict *options, + int flags, Error **errp) +{ + ThrottleGroupMember *tgm = bs->opaque; + + bs->file = bdrv_open_child(NULL, options, "file", bs, + &child_file, false, errp); + if (!bs->file) { + return -EINVAL; + } + bs->supported_write_flags = bs->file->bs->supported_write_flags; + bs->supported_zero_flags = bs->file->bs->supported_zero_flags; + + return throttle_configure_tgm(bs, tgm, options, errp); +} + +static void throttle_close(BlockDriverState *bs) +{ + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_unregister_tgm(tgm); +} + + +static int64_t throttle_getlength(BlockDriverState *bs) +{ + return bdrv_getlength(bs->file->bs); +} + +static int coroutine_fn throttle_co_preadv(BlockDriverState *bs, + uint64_t offset, uint64_t bytes, + QEMUIOVector *qiov, int flags) +{ + + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_co_io_limits_intercept(tgm, bytes, false); + + return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags); +} + +static int coroutine_fn throttle_co_pwritev(BlockDriverState *bs, + uint64_t offset, uint64_t bytes, + QEMUIOVector *qiov, int flags) +{ + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_co_io_limits_intercept(tgm, bytes, true); + + return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); +} + +static int coroutine_fn throttle_co_pwrite_zeroes(BlockDriverState *bs, + int64_t offset, int bytes, + BdrvRequestFlags flags) +{ + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_co_io_limits_intercept(tgm, bytes, true); + + return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); +} + +static int coroutine_fn throttle_co_pdiscard(BlockDriverState *bs, + int64_t offset, int bytes) +{ + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_co_io_limits_intercept(tgm, bytes, true); + + return bdrv_co_pdiscard(bs->file->bs, offset, bytes); +} + +static int throttle_co_flush(BlockDriverState *bs) +{ + return bdrv_co_flush(bs->file->bs); +} + +static void throttle_detach_aio_context(BlockDriverState *bs) +{ + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_detach_aio_context(tgm); +} + +static void throttle_attach_aio_context(BlockDriverState *bs, + AioContext *new_context) +{ + ThrottleGroupMember *tgm = bs->opaque; + throttle_group_attach_aio_context(tgm, new_context); +} + +static int throttle_reopen_prepare(BDRVReopenState *reopen_state, + BlockReopenQueue *queue, Error **errp) +{ + ThrottleGroupMember *tgm; + + assert(reopen_state != NULL); + assert(reopen_state->bs != NULL); + + reopen_state->opaque = g_new0(ThrottleGroupMember, 1); + tgm = reopen_state->opaque; + + return throttle_configure_tgm(reopen_state->bs, tgm, reopen_state->options, + errp); +} + +static void throttle_reopen_commit(BDRVReopenState *reopen_state) +{ + ThrottleGroupMember *old_tgm = reopen_state->bs->opaque; + ThrottleGroupMember *new_tgm = reopen_state->opaque; + + throttle_group_unregister_tgm(old_tgm); + g_free(old_tgm); + reopen_state->bs->opaque = new_tgm; + reopen_state->opaque = NULL; +} + +static void throttle_reopen_abort(BDRVReopenState *reopen_state) +{ + ThrottleGroupMember *tgm = reopen_state->opaque; + + throttle_group_unregister_tgm(tgm); + g_free(tgm); + reopen_state->opaque = NULL; +} + +static bool throttle_recurse_is_first_non_filter(BlockDriverState *bs, + BlockDriverState *candidate) +{ + return bdrv_recurse_is_first_non_filter(bs->file->bs, candidate); +} + +static BlockDriver bdrv_throttle = { + .format_name = "throttle", + .protocol_name = "throttle", + .instance_size = sizeof(ThrottleGroupMember), + + .bdrv_file_open = throttle_open, + .bdrv_close = throttle_close, + .bdrv_co_flush = throttle_co_flush, + + .bdrv_child_perm = bdrv_filter_default_perms, + + .bdrv_getlength = throttle_getlength, + + .bdrv_co_preadv = throttle_co_preadv, + .bdrv_co_pwritev = throttle_co_pwritev, + + .bdrv_co_pwrite_zeroes = throttle_co_pwrite_zeroes, + .bdrv_co_pdiscard = throttle_co_pdiscard, + + .bdrv_recurse_is_first_non_filter = throttle_recurse_is_first_non_filter, + + .bdrv_attach_aio_context = throttle_attach_aio_context, + .bdrv_detach_aio_context = throttle_detach_aio_context, + + .bdrv_reopen_prepare = throttle_reopen_prepare, + .bdrv_reopen_commit = throttle_reopen_commit, + .bdrv_reopen_abort = throttle_reopen_abort, + .bdrv_co_get_block_status = bdrv_co_get_block_status_from_file, + + .is_filter = true, +}; + +static void bdrv_throttle_init(void) +{ + bdrv_register(&bdrv_throttle); +} + +block_init(bdrv_throttle_init); diff --git a/blockdev.c b/blockdev.c index 796beaed94..56a6b24a0b 100644 --- a/blockdev.c +++ b/blockdev.c @@ -2686,7 +2686,7 @@ void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp) if (throttle_enabled(&cfg)) { /* Enable I/O limits if they're not enabled yet, otherwise * just update the throttling group. */ - if (!blk_get_public(blk)->throttle_state) { + if (!blk_get_public(blk)->throttle_group_member.throttle_state) { blk_io_limits_enable(blk, arg->has_group ? arg->group : arg->has_device ? arg->device : @@ -2696,7 +2696,7 @@ void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp) } /* Set the new throttling configuration */ blk_set_io_limits(blk, &cfg); - } else if (blk_get_public(blk)->throttle_state) { + } else if (blk_get_public(blk)->throttle_group_member.throttle_state) { /* If all throttling settings are set to 0, disable I/O limits */ blk_io_limits_disable(blk); } @@ -634,9 +634,6 @@ case "$cpu" in cpu="$cpu" supported_cpu="yes" ;; - ia64) - cpu="$cpu" - ;; i386|i486|i586|i686|i86pc|BePC) cpu="i386" supported_cpu="yes" @@ -6459,9 +6456,6 @@ for i in $ARCH $TARGET_BASE_ARCH ; do i386|x86_64|x32) disas_config "I386" ;; - ia64*) - disas_config "IA64" - ;; lm32) disas_config "LM32" ;; @@ -313,8 +313,6 @@ void disas(FILE *out, void *code, unsigned long size) print_insn = print_insn_s390; #elif defined(__hppa__) print_insn = print_insn_hppa; -#elif defined(__ia64__) - print_insn = print_insn_ia64; #endif if (print_insn == NULL) { print_insn = print_insn_od_host; diff --git a/disas/Makefile.objs b/disas/Makefile.objs index 62632ef0dd..194648fb1a 100644 --- a/disas/Makefile.objs +++ b/disas/Makefile.objs @@ -11,7 +11,6 @@ arm-a64.o-cflags := -I$(libvixldir) -Wno-sign-compare common-obj-$(CONFIG_CRIS_DIS) += cris.o common-obj-$(CONFIG_HPPA_DIS) += hppa.o common-obj-$(CONFIG_I386_DIS) += i386.o -common-obj-$(CONFIG_IA64_DIS) += ia64.o common-obj-$(CONFIG_M68K_DIS) += m68k.o common-obj-$(CONFIG_MICROBLAZE_DIS) += microblaze.o common-obj-$(CONFIG_MIPS_DIS) += mips.o diff --git a/disas/i386.c b/disas/i386.c index f1e376ca4a..a557e678ec 100644 --- a/disas/i386.c +++ b/disas/i386.c @@ -683,6 +683,8 @@ fetch_data(struct disassemble_info *info, bfd_byte *addr) #define PREGRP105 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 105 } } #define PREGRP106 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 106 } } #define PREGRP107 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 107 } } +#define PREGRP108 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 108 } } +#define PREGRP109 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 109 } } #define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } } #define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } } @@ -1484,7 +1486,7 @@ static const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = { /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ - /* f0 */ 1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0, /* ff */ + /* f0 */ 1,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0, /* ff */ /* ------------------------------- */ /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ }; @@ -1508,7 +1510,7 @@ static const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = { /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ - /* f0 */ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0, /* ff */ + /* f0 */ 0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, /* ff */ /* ------------------------------- */ /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ }; @@ -1556,7 +1558,7 @@ static const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = { /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ - /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ + /* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ /* ------------------------------- */ /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ }; @@ -2808,6 +2810,22 @@ static const struct dis386 prefix_user_table[][4] = { { "bsfS", { Gv, Ev } }, { "(bad)", { XX } }, }, + + /* PREGRP108 */ + { + { "bzhi", { Gv, Ev, Bv } }, + { "pext", { Gv, Bv, Ev } }, + { "(bad)", { XX } }, + { "pdep", { Gv, Bv, Ev } }, + }, + + /* PREGRP109 */ + { + { "(bad)", { XX } }, + { "(bad)", { XX } }, + { "(bad)", { XX } }, + { "rorx", { Gv, Ev, Ib } }, + }, }; static const struct dis386 x86_64_table[][2] = { @@ -3108,7 +3126,7 @@ static const struct dis386 three_byte_table[][256] = { { PREGRP105 }, { "(bad)", { XX } }, { "(bad)", { XX } }, - { "(bad)", { XX } }, + { PREGRP108 }, { "(bad)", { XX } }, { PREGRP106 }, /* f8 */ @@ -3394,7 +3412,7 @@ static const struct dis386 three_byte_table[][256] = { { "(bad)", { XX } }, { "(bad)", { XX } }, /* f0 */ - { "(bad)", { XX } }, + { PREGRP109 }, { "(bad)", { XX } }, { "(bad)", { XX } }, { "(bad)", { XX } }, @@ -3559,6 +3577,7 @@ ckvexprefix (void) } else { /* Two byte VEX prefix. */ newrex |= (vex2 & 0x80 ? 0 : REX_R); + newpfx |= PREFIX_VEX_0F; codep += 2; } diff --git a/disas/ia64.c b/disas/ia64.c deleted file mode 100644 index 140754c944..0000000000 --- a/disas/ia64.c +++ /dev/null @@ -1,10600 +0,0 @@ -/* ia64-dis.c -- Disassemble ia64 instructions - Copyright 1998, 1999, 2000, 2002 Free Software Foundation, Inc. - Contributed by David Mosberger-Tang <davidm@hpl.hp.com> - - This file is part of GDB, GAS, and the GNU binutils. - - GDB, GAS, and the GNU binutils are free software; you can redistribute - them and/or modify them under the terms of the GNU General Public - License as published by the Free Software Foundation; either version - 2, or (at your option) any later version. - - GDB, GAS, and the GNU binutils are distributed in the hope that they - will be useful, but WITHOUT ANY WARRANTY; without even the implied - warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See - the GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this file; see the file COPYING. If not, see - <http://www.gnu.org/licenses/>. */ - -#include "qemu/osdep.h" - -#include "disas/bfd.h" - -/* ia64.h -- Header file for ia64 opcode table - Copyright (C) 1998, 1999, 2000, 2002, 2005, 2006 - Free Software Foundation, Inc. - Contributed by David Mosberger-Tang <davidm@hpl.hp.com> */ - - -typedef uint64_t ia64_insn; - -enum ia64_insn_type - { - IA64_TYPE_NIL = 0, /* illegal type */ - IA64_TYPE_A, /* integer alu (I- or M-unit) */ - IA64_TYPE_I, /* non-alu integer (I-unit) */ - IA64_TYPE_M, /* memory (M-unit) */ - IA64_TYPE_B, /* branch (B-unit) */ - IA64_TYPE_F, /* floating-point (F-unit) */ - IA64_TYPE_X, /* long encoding (X-unit) */ - IA64_TYPE_DYN, /* Dynamic opcode */ - IA64_NUM_TYPES - }; - -enum ia64_unit - { - IA64_UNIT_NIL = 0, /* illegal unit */ - IA64_UNIT_I, /* integer unit */ - IA64_UNIT_M, /* memory unit */ - IA64_UNIT_B, /* branching unit */ - IA64_UNIT_F, /* floating-point unit */ - IA64_UNIT_L, /* long "unit" */ - IA64_UNIT_X, /* may be integer or branch unit */ - IA64_NUM_UNITS - }; - -/* Changes to this enumeration must be propagated to the operand table in - bfd/cpu-ia64-opc.c - */ -enum ia64_opnd - { - IA64_OPND_NIL, /* no operand---MUST BE FIRST!*/ - - /* constants */ - IA64_OPND_AR_CSD, /* application register csd (ar.csd) */ - IA64_OPND_AR_CCV, /* application register ccv (ar.ccv) */ - IA64_OPND_AR_PFS, /* application register pfs (ar.pfs) */ - IA64_OPND_C1, /* the constant 1 */ - IA64_OPND_C8, /* the constant 8 */ - IA64_OPND_C16, /* the constant 16 */ - IA64_OPND_GR0, /* gr0 */ - IA64_OPND_IP, /* instruction pointer (ip) */ - IA64_OPND_PR, /* predicate register (pr) */ - IA64_OPND_PR_ROT, /* rotating predicate register (pr.rot) */ - IA64_OPND_PSR, /* processor status register (psr) */ - IA64_OPND_PSR_L, /* processor status register L (psr.l) */ - IA64_OPND_PSR_UM, /* processor status register UM (psr.um) */ - - /* register operands: */ - IA64_OPND_AR3, /* third application register # (bits 20-26) */ - IA64_OPND_B1, /* branch register # (bits 6-8) */ - IA64_OPND_B2, /* branch register # (bits 13-15) */ - IA64_OPND_CR3, /* third control register # (bits 20-26) */ - IA64_OPND_F1, /* first floating-point register # */ - IA64_OPND_F2, /* second floating-point register # */ - IA64_OPND_F3, /* third floating-point register # */ - IA64_OPND_F4, /* fourth floating-point register # */ - IA64_OPND_P1, /* first predicate # */ - IA64_OPND_P2, /* second predicate # */ - IA64_OPND_R1, /* first register # */ - IA64_OPND_R2, /* second register # */ - IA64_OPND_R3, /* third register # */ - IA64_OPND_R3_2, /* third register # (limited to gr0-gr3) */ - - /* memory operands: */ - IA64_OPND_MR3, /* memory at addr of third register # */ - - /* indirect operands: */ - IA64_OPND_CPUID_R3, /* cpuid[reg] */ - IA64_OPND_DBR_R3, /* dbr[reg] */ - IA64_OPND_DTR_R3, /* dtr[reg] */ - IA64_OPND_ITR_R3, /* itr[reg] */ - IA64_OPND_IBR_R3, /* ibr[reg] */ - IA64_OPND_MSR_R3, /* msr[reg] */ - IA64_OPND_PKR_R3, /* pkr[reg] */ - IA64_OPND_PMC_R3, /* pmc[reg] */ - IA64_OPND_PMD_R3, /* pmd[reg] */ - IA64_OPND_RR_R3, /* rr[reg] */ - - /* immediate operands: */ - IA64_OPND_CCNT5, /* 5-bit count (31 - bits 20-24) */ - IA64_OPND_CNT2a, /* 2-bit count (1 + bits 27-28) */ - IA64_OPND_CNT2b, /* 2-bit count (bits 27-28): 1, 2, 3 */ - IA64_OPND_CNT2c, /* 2-bit count (bits 30-31): 0, 7, 15, or 16 */ - IA64_OPND_CNT5, /* 5-bit count (bits 14-18) */ - IA64_OPND_CNT6, /* 6-bit count (bits 27-32) */ - IA64_OPND_CPOS6a, /* 6-bit count (63 - bits 20-25) */ - IA64_OPND_CPOS6b, /* 6-bit count (63 - bits 14-19) */ - IA64_OPND_CPOS6c, /* 6-bit count (63 - bits 31-36) */ - IA64_OPND_IMM1, /* signed 1-bit immediate (bit 36) */ - IA64_OPND_IMMU2, /* unsigned 2-bit immediate (bits 13-14) */ - IA64_OPND_IMMU5b, /* unsigned 5-bit immediate (32 + bits 14-18) */ - IA64_OPND_IMMU7a, /* unsigned 7-bit immediate (bits 13-19) */ - IA64_OPND_IMMU7b, /* unsigned 7-bit immediate (bits 20-26) */ - IA64_OPND_SOF, /* 8-bit stack frame size */ - IA64_OPND_SOL, /* 8-bit size of locals */ - IA64_OPND_SOR, /* 6-bit number of rotating registers (scaled by 8) */ - IA64_OPND_IMM8, /* signed 8-bit immediate (bits 13-19 & 36) */ - IA64_OPND_IMM8U4, /* cmp4*u signed 8-bit immediate (bits 13-19 & 36) */ - IA64_OPND_IMM8M1, /* signed 8-bit immediate -1 (bits 13-19 & 36) */ - IA64_OPND_IMM8M1U4, /* cmp4*u signed 8-bit immediate -1 (bits 13-19 & 36)*/ - IA64_OPND_IMM8M1U8, /* cmp*u signed 8-bit immediate -1 (bits 13-19 & 36) */ - IA64_OPND_IMMU9, /* unsigned 9-bit immediate (bits 33-34, 20-26) */ - IA64_OPND_IMM9a, /* signed 9-bit immediate (bits 6-12, 27, 36) */ - IA64_OPND_IMM9b, /* signed 9-bit immediate (bits 13-19, 27, 36) */ - IA64_OPND_IMM14, /* signed 14-bit immediate (bits 13-19, 27-32, 36) */ - IA64_OPND_IMM17, /* signed 17-bit immediate (2*bits 6-12, 24-31, 36) */ - IA64_OPND_IMMU21, /* unsigned 21-bit immediate (bits 6-25, 36) */ - IA64_OPND_IMM22, /* signed 22-bit immediate (bits 13-19, 22-36) */ - IA64_OPND_IMMU24, /* unsigned 24-bit immediate (bits 6-26, 31-32, 36) */ - IA64_OPND_IMM44, /* signed 44-bit immediate (2^16*bits 6-32, 36) */ - IA64_OPND_IMMU62, /* unsigned 62-bit immediate */ - IA64_OPND_IMMU64, /* unsigned 64-bit immediate (lotsa bits...) */ - IA64_OPND_INC3, /* signed 3-bit (bits 13-15): +/-1, 4, 8, 16 */ - IA64_OPND_LEN4, /* 4-bit count (bits 27-30 + 1) */ - IA64_OPND_LEN6, /* 6-bit count (bits 27-32 + 1) */ - IA64_OPND_MBTYPE4, /* 4-bit mux type (bits 20-23) */ - IA64_OPND_MHTYPE8, /* 8-bit mux type (bits 20-27) */ - IA64_OPND_POS6, /* 6-bit count (bits 14-19) */ - IA64_OPND_TAG13, /* signed 13-bit tag (ip + 16*bits 6-12, 33-34) */ - IA64_OPND_TAG13b, /* signed 13-bit tag (ip + 16*bits 24-32) */ - IA64_OPND_TGT25, /* signed 25-bit (ip + 16*bits 6-25, 36) */ - IA64_OPND_TGT25b, /* signed 25-bit (ip + 16*bits 6-12, 20-32, 36) */ - IA64_OPND_TGT25c, /* signed 25-bit (ip + 16*bits 13-32, 36) */ - IA64_OPND_TGT64, /* 64-bit (ip + 16*bits 13-32, 36, 2-40(L)) */ - IA64_OPND_LDXMOV, /* any symbol, generates R_IA64_LDXMOV. */ - - IA64_OPND_COUNT /* # of operand types (MUST BE LAST!) */ - }; - -enum ia64_dependency_mode -{ - IA64_DV_RAW, - IA64_DV_WAW, - IA64_DV_WAR, -}; - -enum ia64_dependency_semantics -{ - IA64_DVS_NONE, - IA64_DVS_IMPLIED, - IA64_DVS_IMPLIEDF, - IA64_DVS_DATA, - IA64_DVS_INSTR, - IA64_DVS_SPECIFIC, - IA64_DVS_STOP, - IA64_DVS_OTHER, -}; - -enum ia64_resource_specifier -{ - IA64_RS_ANY, - IA64_RS_AR_K, - IA64_RS_AR_UNAT, - IA64_RS_AR, /* 8-15, 20, 22-23, 31, 33-35, 37-39, 41-43, 45-47, 67-111 */ - IA64_RS_ARb, /* 48-63, 112-127 */ - IA64_RS_BR, - IA64_RS_CFM, - IA64_RS_CPUID, - IA64_RS_CR_IRR, - IA64_RS_CR_LRR, - IA64_RS_CR, /* 3-7,10-15,18,26-63,75-79,82-127 */ - IA64_RS_DBR, - IA64_RS_FR, - IA64_RS_FRb, - IA64_RS_GR0, - IA64_RS_GR, - IA64_RS_IBR, - IA64_RS_INSERVICE, /* CR[EOI] or CR[IVR] */ - IA64_RS_MSR, - IA64_RS_PKR, - IA64_RS_PMC, - IA64_RS_PMD, - IA64_RS_PR, /* non-rotating, 1-15 */ - IA64_RS_PRr, /* rotating, 16-62 */ - IA64_RS_PR63, - IA64_RS_RR, - - IA64_RS_ARX, /* ARs not in RS_AR or RS_ARb */ - IA64_RS_CRX, /* CRs not in RS_CR */ - IA64_RS_PSR, /* PSR bits */ - IA64_RS_RSE, /* implementation-specific RSE resources */ - IA64_RS_AR_FPSR, -}; - -enum ia64_rse_resource -{ - IA64_RSE_N_STACKED_PHYS, - IA64_RSE_BOF, - IA64_RSE_STORE_REG, - IA64_RSE_LOAD_REG, - IA64_RSE_BSPLOAD, - IA64_RSE_RNATBITINDEX, - IA64_RSE_CFLE, - IA64_RSE_NDIRTY, -}; - -/* Information about a given resource dependency */ -struct ia64_dependency -{ - /* Name of the resource */ - const char *name; - /* Does this dependency need further specification? */ - enum ia64_resource_specifier specifier; - /* Mode of dependency */ - enum ia64_dependency_mode mode; - /* Dependency semantics */ - enum ia64_dependency_semantics semantics; - /* Register index, if applicable (distinguishes AR, CR, and PSR deps) */ -#define REG_NONE (-1) - int regindex; - /* Special info on semantics */ - const char *info; -}; - -/* Two arrays of indexes into the ia64_dependency table. - chks are dependencies to check for conflicts when an opcode is - encountered; regs are dependencies to register (mark as used) when an - opcode is used. chks correspond to readers (RAW) or writers (WAW or - WAR) of a resource, while regs correspond to writers (RAW or WAW) and - readers (WAR) of a resource. */ -struct ia64_opcode_dependency -{ - int nchks; - const unsigned short *chks; - int nregs; - const unsigned short *regs; -}; - -/* encode/extract the note/index for a dependency */ -#define RDEP(N,X) (((N)<<11)|(X)) -#define NOTE(X) (((X)>>11)&0x1F) -#define DEP(X) ((X)&0x7FF) - -/* A template descriptor describes the execution units that are active - for each of the three slots. It also specifies the location of - instruction group boundaries that may be present between two slots. */ -struct ia64_templ_desc - { - int group_boundary; /* 0=no boundary, 1=between slot 0 & 1, etc. */ - enum ia64_unit exec_unit[3]; - const char *name; - }; - -/* The opcode table is an array of struct ia64_opcode. */ - -struct ia64_opcode - { - /* The opcode name. */ - const char *name; - - /* The type of the instruction: */ - enum ia64_insn_type type; - - /* Number of output operands: */ - int num_outputs; - - /* The opcode itself. Those bits which will be filled in with - operands are zeroes. */ - ia64_insn opcode; - - /* The opcode mask. This is used by the disassembler. This is a - mask containing ones indicating those bits which must match the - opcode field, and zeroes indicating those bits which need not - match (and are presumably filled in by operands). */ - ia64_insn mask; - - /* An array of operand codes. Each code is an index into the - operand table. They appear in the order which the operands must - appear in assembly code, and are terminated by a zero. */ - enum ia64_opnd operands[5]; - - /* One bit flags for the opcode. These are primarily used to - indicate specific processors and environments support the - instructions. The defined values are listed below. */ - unsigned int flags; - - /* Used by ia64_find_next_opcode (). */ - short ent_index; - - /* Opcode dependencies. */ - const struct ia64_opcode_dependency *dependencies; - }; - -/* Values defined for the flags field of a struct ia64_opcode. */ - -#define IA64_OPCODE_FIRST (1<<0) /* must be first in an insn group */ -#define IA64_OPCODE_X_IN_MLX (1<<1) /* insn is allowed in X slot of MLX */ -#define IA64_OPCODE_LAST (1<<2) /* must be last in an insn group */ -#define IA64_OPCODE_PRIV (1<<3) /* privileged instruct */ -#define IA64_OPCODE_SLOT2 (1<<4) /* insn allowed in slot 2 only */ -#define IA64_OPCODE_NO_PRED (1<<5) /* insn cannot be predicated */ -#define IA64_OPCODE_PSEUDO (1<<6) /* insn is a pseudo-op */ -#define IA64_OPCODE_F2_EQ_F3 (1<<7) /* constraint: F2 == F3 */ -#define IA64_OPCODE_LEN_EQ_64MCNT (1<<8) /* constraint: LEN == 64-CNT */ -#define IA64_OPCODE_MOD_RRBS (1<<9) /* modifies all rrbs in CFM */ -#define IA64_OPCODE_POSTINC (1<<10) /* postincrement MR3 operand */ - -/* A macro to extract the major opcode from an instruction. */ -#define IA64_OP(i) (((i) >> 37) & 0xf) - -enum ia64_operand_class - { - IA64_OPND_CLASS_CST, /* constant */ - IA64_OPND_CLASS_REG, /* register */ - IA64_OPND_CLASS_IND, /* indirect register */ - IA64_OPND_CLASS_ABS, /* absolute value */ - IA64_OPND_CLASS_REL, /* IP-relative value */ - }; - -/* The operands table is an array of struct ia64_operand. */ - -struct ia64_operand -{ - enum ia64_operand_class class; - - /* Set VALUE as the operand bits for the operand of type SELF in the - instruction pointed to by CODE. If an error occurs, *CODE is not - modified and the returned string describes the cause of the - error. If no error occurs, NULL is returned. */ - const char *(*insert) (const struct ia64_operand *self, ia64_insn value, - ia64_insn *code); - - /* Extract the operand bits for an operand of type SELF from - instruction CODE store them in *VALUE. If an error occurs, the - cause of the error is described by the string returned. If no - error occurs, NULL is returned. */ - const char *(*extract) (const struct ia64_operand *self, ia64_insn code, - ia64_insn *value); - - /* A string whose meaning depends on the operand class. */ - - const char *str; - - struct bit_field - { - /* The number of bits in the operand. */ - int bits; - - /* How far the operand is left shifted in the instruction. */ - int shift; - } - field[4]; /* no operand has more than this many bit-fields */ - - unsigned int flags; - - const char *desc; /* brief description */ -}; - -/* Values defined for the flags field of a struct ia64_operand. */ - -/* Disassemble as signed decimal (instead of hex): */ -#define IA64_OPND_FLAG_DECIMAL_SIGNED (1<<0) -/* Disassemble as unsigned decimal (instead of hex): */ -#define IA64_OPND_FLAG_DECIMAL_UNSIGNED (1<<1) - -#define NELEMS(a) ((int) (sizeof (a) / sizeof (a[0]))) - -static const char* -ins_rsvd (const struct ia64_operand *self ATTRIBUTE_UNUSED, - ia64_insn value ATTRIBUTE_UNUSED, ia64_insn *code ATTRIBUTE_UNUSED) -{ - return "internal error---this shouldn't happen"; -} - -static const char* -ext_rsvd (const struct ia64_operand *self ATTRIBUTE_UNUSED, - ia64_insn code ATTRIBUTE_UNUSED, ia64_insn *valuep ATTRIBUTE_UNUSED) -{ - return "internal error---this shouldn't happen"; -} - -static const char* -ins_const (const struct ia64_operand *self ATTRIBUTE_UNUSED, - ia64_insn value ATTRIBUTE_UNUSED, ia64_insn *code ATTRIBUTE_UNUSED) -{ - return 0; -} - -static const char* -ext_const (const struct ia64_operand *self ATTRIBUTE_UNUSED, - ia64_insn code ATTRIBUTE_UNUSED, ia64_insn *valuep ATTRIBUTE_UNUSED) -{ - return 0; -} - -static const char* -ins_reg (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - if (value >= 1u << self->field[0].bits) - return "register number out of range"; - - *code |= value << self->field[0].shift; - return 0; -} - -static const char* -ext_reg (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - *valuep = ((code >> self->field[0].shift) - & ((1u << self->field[0].bits) - 1)); - return 0; -} - -static const char* -ins_immu (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - ia64_insn new = 0; - int i; - - for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) - { - new |= ((value & ((((ia64_insn) 1) << self->field[i].bits) - 1)) - << self->field[i].shift); - value >>= self->field[i].bits; - } - if (value) - return "integer operand out of range"; - - *code |= new; - return 0; -} - -static const char* -ext_immu (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - uint64_t value = 0; - int i, bits = 0, total = 0; - - for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) - { - bits = self->field[i].bits; - value |= ((code >> self->field[i].shift) - & ((((uint64_t) 1) << bits) - 1)) << total; - total += bits; - } - *valuep = value; - return 0; -} - -static const char* -ins_immu5b (const struct ia64_operand *self, ia64_insn value, - ia64_insn *code) -{ - if (value < 32 || value > 63) - return "value must be between 32 and 63"; - return ins_immu (self, value - 32, code); -} - -static const char* -ext_immu5b (const struct ia64_operand *self, ia64_insn code, - ia64_insn *valuep) -{ - const char *result; - - result = ext_immu (self, code, valuep); - if (result) - return result; - - *valuep = *valuep + 32; - return 0; -} - -static const char* -ins_immus8 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - if (value & 0x7) - return "value not an integer multiple of 8"; - return ins_immu (self, value >> 3, code); -} - -static const char* -ext_immus8 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - const char *result; - - result = ext_immu (self, code, valuep); - if (result) - return result; - - *valuep = *valuep << 3; - return 0; -} - -static const char* -ins_imms_scaled (const struct ia64_operand *self, ia64_insn value, - ia64_insn *code, int scale) -{ - int64_t svalue = value, sign_bit = 0; - ia64_insn new = 0; - int i; - - svalue >>= scale; - - for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) - { - new |= ((svalue & ((((ia64_insn) 1) << self->field[i].bits) - 1)) - << self->field[i].shift); - sign_bit = (svalue >> (self->field[i].bits - 1)) & 1; - svalue >>= self->field[i].bits; - } - if ((!sign_bit && svalue != 0) || (sign_bit && svalue != -1)) - return "integer operand out of range"; - - *code |= new; - return 0; -} - -static const char* -ext_imms_scaled (const struct ia64_operand *self, ia64_insn code, - ia64_insn *valuep, int scale) -{ - int i, bits = 0, total = 0; - int64_t val = 0, sign; - - for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) - { - bits = self->field[i].bits; - val |= ((code >> self->field[i].shift) - & ((((uint64_t) 1) << bits) - 1)) << total; - total += bits; - } - /* sign extend: */ - sign = (int64_t) 1 << (total - 1); - val = (val ^ sign) - sign; - - *valuep = (val << scale); - return 0; -} - -static const char* -ins_imms (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - return ins_imms_scaled (self, value, code, 0); -} - -static const char* -ins_immsu4 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - value = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000; - - return ins_imms_scaled (self, value, code, 0); -} - -static const char* -ext_imms (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - return ext_imms_scaled (self, code, valuep, 0); -} - -static const char* -ins_immsm1 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - --value; - return ins_imms_scaled (self, value, code, 0); -} - -static const char* -ins_immsm1u4 (const struct ia64_operand *self, ia64_insn value, - ia64_insn *code) -{ - value = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000; - - --value; - return ins_imms_scaled (self, value, code, 0); -} - -static const char* -ext_immsm1 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - const char *res = ext_imms_scaled (self, code, valuep, 0); - - ++*valuep; - return res; -} - -static const char* -ins_imms1 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - return ins_imms_scaled (self, value, code, 1); -} - -static const char* -ext_imms1 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - return ext_imms_scaled (self, code, valuep, 1); -} - -static const char* -ins_imms4 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - return ins_imms_scaled (self, value, code, 4); -} - -static const char* -ext_imms4 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - return ext_imms_scaled (self, code, valuep, 4); -} - -static const char* -ins_imms16 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - return ins_imms_scaled (self, value, code, 16); -} - -static const char* -ext_imms16 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - return ext_imms_scaled (self, code, valuep, 16); -} - -static const char* -ins_cimmu (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - ia64_insn mask = (((ia64_insn) 1) << self->field[0].bits) - 1; - return ins_immu (self, value ^ mask, code); -} - -static const char* -ext_cimmu (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - const char *result; - ia64_insn mask; - - mask = (((ia64_insn) 1) << self->field[0].bits) - 1; - result = ext_immu (self, code, valuep); - if (!result) - { - mask = (((ia64_insn) 1) << self->field[0].bits) - 1; - *valuep ^= mask; - } - return result; -} - -static const char* -ins_cnt (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - --value; - if (value >= ((uint64_t) 1) << self->field[0].bits) - return "count out of range"; - - *code |= value << self->field[0].shift; - return 0; -} - -static const char* -ext_cnt (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - *valuep = ((code >> self->field[0].shift) - & ((((uint64_t) 1) << self->field[0].bits) - 1)) + 1; - return 0; -} - -static const char* -ins_cnt2b (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - --value; - - if (value > 2) - return "count must be in range 1..3"; - - *code |= value << self->field[0].shift; - return 0; -} - -static const char* -ext_cnt2b (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - *valuep = ((code >> self->field[0].shift) & 0x3) + 1; - return 0; -} - -static const char* -ins_cnt2c (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - switch (value) - { - case 0: value = 0; break; - case 7: value = 1; break; - case 15: value = 2; break; - case 16: value = 3; break; - default: return "count must be 0, 7, 15, or 16"; - } - *code |= value << self->field[0].shift; - return 0; -} - -static const char* -ext_cnt2c (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - ia64_insn value; - - value = (code >> self->field[0].shift) & 0x3; - switch (value) - { - case 0: value = 0; break; - case 1: value = 7; break; - case 2: value = 15; break; - case 3: value = 16; break; - } - *valuep = value; - return 0; -} - -static const char* -ins_inc3 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) -{ - int64_t val = value; - uint64_t sign = 0; - - if (val < 0) - { - sign = 0x4; - value = -value; - } - switch (value) - { - case 1: value = 3; break; - case 4: value = 2; break; - case 8: value = 1; break; - case 16: value = 0; break; - default: return "count must be +/- 1, 4, 8, or 16"; - } - *code |= (sign | value) << self->field[0].shift; - return 0; -} - -static const char* -ext_inc3 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) -{ - int64_t val; - int negate; - - val = (code >> self->field[0].shift) & 0x7; - negate = val & 0x4; - switch (val & 0x3) - { - case 0: val = 16; break; - case 1: val = 8; break; - case 2: val = 4; break; - case 3: val = 1; break; - } - if (negate) - val = -val; - - *valuep = val; - return 0; -} - -/* glib.h defines ABS so we must undefine it to avoid a clash */ -#undef ABS - -#define CST IA64_OPND_CLASS_CST -#define REG IA64_OPND_CLASS_REG -#define IND IA64_OPND_CLASS_IND -#define ABS IA64_OPND_CLASS_ABS -#define REL IA64_OPND_CLASS_REL - -#define SDEC IA64_OPND_FLAG_DECIMAL_SIGNED -#define UDEC IA64_OPND_FLAG_DECIMAL_UNSIGNED - -const struct ia64_operand elf64_ia64_operands[IA64_OPND_COUNT] = - { - /* constants: */ - { CST, ins_const, ext_const, "NIL", {{ 0, 0}}, 0, "<none>" }, - { CST, ins_const, ext_const, "ar.csd", {{ 0, 0}}, 0, "ar.csd" }, - { CST, ins_const, ext_const, "ar.ccv", {{ 0, 0}}, 0, "ar.ccv" }, - { CST, ins_const, ext_const, "ar.pfs", {{ 0, 0}}, 0, "ar.pfs" }, - { CST, ins_const, ext_const, "1", {{ 0, 0}}, 0, "1" }, - { CST, ins_const, ext_const, "8", {{ 0, 0}}, 0, "8" }, - { CST, ins_const, ext_const, "16", {{ 0, 0}}, 0, "16" }, - { CST, ins_const, ext_const, "r0", {{ 0, 0}}, 0, "r0" }, - { CST, ins_const, ext_const, "ip", {{ 0, 0}}, 0, "ip" }, - { CST, ins_const, ext_const, "pr", {{ 0, 0}}, 0, "pr" }, - { CST, ins_const, ext_const, "pr.rot", {{ 0, 0}}, 0, "pr.rot" }, - { CST, ins_const, ext_const, "psr", {{ 0, 0}}, 0, "psr" }, - { CST, ins_const, ext_const, "psr.l", {{ 0, 0}}, 0, "psr.l" }, - { CST, ins_const, ext_const, "psr.um", {{ 0, 0}}, 0, "psr.um" }, - - /* register operands: */ - { REG, ins_reg, ext_reg, "ar", {{ 7, 20}}, 0, /* AR3 */ - "an application register" }, - { REG, ins_reg, ext_reg, "b", {{ 3, 6}}, 0, /* B1 */ - "a branch register" }, - { REG, ins_reg, ext_reg, "b", {{ 3, 13}}, 0, /* B2 */ - "a branch register"}, - { REG, ins_reg, ext_reg, "cr", {{ 7, 20}}, 0, /* CR */ - "a control register"}, - { REG, ins_reg, ext_reg, "f", {{ 7, 6}}, 0, /* F1 */ - "a floating-point register" }, - { REG, ins_reg, ext_reg, "f", {{ 7, 13}}, 0, /* F2 */ - "a floating-point register" }, - { REG, ins_reg, ext_reg, "f", {{ 7, 20}}, 0, /* F3 */ - "a floating-point register" }, - { REG, ins_reg, ext_reg, "f", {{ 7, 27}}, 0, /* F4 */ - "a floating-point register" }, - { REG, ins_reg, ext_reg, "p", {{ 6, 6}}, 0, /* P1 */ - "a predicate register" }, - { REG, ins_reg, ext_reg, "p", {{ 6, 27}}, 0, /* P2 */ - "a predicate register" }, - { REG, ins_reg, ext_reg, "r", {{ 7, 6}}, 0, /* R1 */ - "a general register" }, - { REG, ins_reg, ext_reg, "r", {{ 7, 13}}, 0, /* R2 */ - "a general register" }, - { REG, ins_reg, ext_reg, "r", {{ 7, 20}}, 0, /* R3 */ - "a general register" }, - { REG, ins_reg, ext_reg, "r", {{ 2, 20}}, 0, /* R3_2 */ - "a general register r0-r3" }, - - /* memory operands: */ - { IND, ins_reg, ext_reg, "", {{7, 20}}, 0, /* MR3 */ - "a memory address" }, - - /* indirect operands: */ - { IND, ins_reg, ext_reg, "cpuid", {{7, 20}}, 0, /* CPUID_R3 */ - "a cpuid register" }, - { IND, ins_reg, ext_reg, "dbr", {{7, 20}}, 0, /* DBR_R3 */ - "a dbr register" }, - { IND, ins_reg, ext_reg, "dtr", {{7, 20}}, 0, /* DTR_R3 */ - "a dtr register" }, - { IND, ins_reg, ext_reg, "itr", {{7, 20}}, 0, /* ITR_R3 */ - "an itr register" }, - { IND, ins_reg, ext_reg, "ibr", {{7, 20}}, 0, /* IBR_R3 */ - "an ibr register" }, - { IND, ins_reg, ext_reg, "msr", {{7, 20}}, 0, /* MSR_R3 */ - "an msr register" }, - { IND, ins_reg, ext_reg, "pkr", {{7, 20}}, 0, /* PKR_R3 */ - "a pkr register" }, - { IND, ins_reg, ext_reg, "pmc", {{7, 20}}, 0, /* PMC_R3 */ - "a pmc register" }, - { IND, ins_reg, ext_reg, "pmd", {{7, 20}}, 0, /* PMD_R3 */ - "a pmd register" }, - { IND, ins_reg, ext_reg, "rr", {{7, 20}}, 0, /* RR_R3 */ - "an rr register" }, - - /* immediate operands: */ - { ABS, ins_cimmu, ext_cimmu, 0, {{ 5, 20 }}, UDEC, /* CCNT5 */ - "a 5-bit count (0-31)" }, - { ABS, ins_cnt, ext_cnt, 0, {{ 2, 27 }}, UDEC, /* CNT2a */ - "a 2-bit count (1-4)" }, - { ABS, ins_cnt2b, ext_cnt2b, 0, {{ 2, 27 }}, UDEC, /* CNT2b */ - "a 2-bit count (1-3)" }, - { ABS, ins_cnt2c, ext_cnt2c, 0, {{ 2, 30 }}, UDEC, /* CNT2c */ - "a count (0, 7, 15, or 16)" }, - { ABS, ins_immu, ext_immu, 0, {{ 5, 14}}, UDEC, /* CNT5 */ - "a 5-bit count (0-31)" }, - { ABS, ins_immu, ext_immu, 0, {{ 6, 27}}, UDEC, /* CNT6 */ - "a 6-bit count (0-63)" }, - { ABS, ins_cimmu, ext_cimmu, 0, {{ 6, 20}}, UDEC, /* CPOS6a */ - "a 6-bit bit pos (0-63)" }, - { ABS, ins_cimmu, ext_cimmu, 0, {{ 6, 14}}, UDEC, /* CPOS6b */ - "a 6-bit bit pos (0-63)" }, - { ABS, ins_cimmu, ext_cimmu, 0, {{ 6, 31}}, UDEC, /* CPOS6c */ - "a 6-bit bit pos (0-63)" }, - { ABS, ins_imms, ext_imms, 0, {{ 1, 36}}, SDEC, /* IMM1 */ - "a 1-bit integer (-1, 0)" }, - { ABS, ins_immu, ext_immu, 0, {{ 2, 13}}, UDEC, /* IMMU2 */ - "a 2-bit unsigned (0-3)" }, - { ABS, ins_immu5b, ext_immu5b, 0, {{ 5, 14}}, UDEC, /* IMMU5b */ - "a 5-bit unsigned (32 + (0-31))" }, - { ABS, ins_immu, ext_immu, 0, {{ 7, 13}}, 0, /* IMMU7a */ - "a 7-bit unsigned (0-127)" }, - { ABS, ins_immu, ext_immu, 0, {{ 7, 20}}, 0, /* IMMU7b */ - "a 7-bit unsigned (0-127)" }, - { ABS, ins_immu, ext_immu, 0, {{ 7, 13}}, UDEC, /* SOF */ - "a frame size (register count)" }, - { ABS, ins_immu, ext_immu, 0, {{ 7, 20}}, UDEC, /* SOL */ - "a local register count" }, - { ABS, ins_immus8,ext_immus8,0, {{ 4, 27}}, UDEC, /* SOR */ - "a rotating register count (integer multiple of 8)" }, - { ABS, ins_imms, ext_imms, 0, /* IMM8 */ - {{ 7, 13}, { 1, 36}}, SDEC, - "an 8-bit integer (-128-127)" }, - { ABS, ins_immsu4, ext_imms, 0, /* IMM8U4 */ - {{ 7, 13}, { 1, 36}}, SDEC, - "an 8-bit signed integer for 32-bit unsigned compare (-128-127)" }, - { ABS, ins_immsm1, ext_immsm1, 0, /* IMM8M1 */ - {{ 7, 13}, { 1, 36}}, SDEC, - "an 8-bit integer (-127-128)" }, - { ABS, ins_immsm1u4, ext_immsm1, 0, /* IMM8M1U4 */ - {{ 7, 13}, { 1, 36}}, SDEC, - "an 8-bit integer for 32-bit unsigned compare (-127-(-1),1-128,0x100000000)" }, - { ABS, ins_immsm1, ext_immsm1, 0, /* IMM8M1U8 */ - {{ 7, 13}, { 1, 36}}, SDEC, - "an 8-bit integer for 64-bit unsigned compare (-127-(-1),1-128,0x10000000000000000)" }, - { ABS, ins_immu, ext_immu, 0, {{ 2, 33}, { 7, 20}}, 0, /* IMMU9 */ - "a 9-bit unsigned (0-511)" }, - { ABS, ins_imms, ext_imms, 0, /* IMM9a */ - {{ 7, 6}, { 1, 27}, { 1, 36}}, SDEC, - "a 9-bit integer (-256-255)" }, - { ABS, ins_imms, ext_imms, 0, /* IMM9b */ - {{ 7, 13}, { 1, 27}, { 1, 36}}, SDEC, - "a 9-bit integer (-256-255)" }, - { ABS, ins_imms, ext_imms, 0, /* IMM14 */ - {{ 7, 13}, { 6, 27}, { 1, 36}}, SDEC, - "a 14-bit integer (-8192-8191)" }, - { ABS, ins_imms1, ext_imms1, 0, /* IMM17 */ - {{ 7, 6}, { 8, 24}, { 1, 36}}, 0, - "a 17-bit integer (-65536-65535)" }, - { ABS, ins_immu, ext_immu, 0, {{20, 6}, { 1, 36}}, 0, /* IMMU21 */ - "a 21-bit unsigned" }, - { ABS, ins_imms, ext_imms, 0, /* IMM22 */ - {{ 7, 13}, { 9, 27}, { 5, 22}, { 1, 36}}, SDEC, - "a 22-bit signed integer" }, - { ABS, ins_immu, ext_immu, 0, /* IMMU24 */ - {{21, 6}, { 2, 31}, { 1, 36}}, 0, - "a 24-bit unsigned" }, - { ABS, ins_imms16,ext_imms16,0, {{27, 6}, { 1, 36}}, 0, /* IMM44 */ - "a 44-bit unsigned (least 16 bits ignored/zeroes)" }, - { ABS, ins_rsvd, ext_rsvd, 0, {{0, 0}}, 0, /* IMMU62 */ - "a 62-bit unsigned" }, - { ABS, ins_rsvd, ext_rsvd, 0, {{0, 0}}, 0, /* IMMU64 */ - "a 64-bit unsigned" }, - { ABS, ins_inc3, ext_inc3, 0, {{ 3, 13}}, SDEC, /* INC3 */ - "an increment (+/- 1, 4, 8, or 16)" }, - { ABS, ins_cnt, ext_cnt, 0, {{ 4, 27}}, UDEC, /* LEN4 */ - "a 4-bit length (1-16)" }, - { ABS, ins_cnt, ext_cnt, 0, {{ 6, 27}}, UDEC, /* LEN6 */ - "a 6-bit length (1-64)" }, - { ABS, ins_immu, ext_immu, 0, {{ 4, 20}}, 0, /* MBTYPE4 */ - "a mix type (@rev, @mix, @shuf, @alt, or @brcst)" }, - { ABS, ins_immu, ext_immu, 0, {{ 8, 20}}, 0, /* MBTYPE8 */ - "an 8-bit mix type" }, - { ABS, ins_immu, ext_immu, 0, {{ 6, 14}}, UDEC, /* POS6 */ - "a 6-bit bit pos (0-63)" }, - { REL, ins_imms4, ext_imms4, 0, {{ 7, 6}, { 2, 33}}, 0, /* TAG13 */ - "a branch tag" }, - { REL, ins_imms4, ext_imms4, 0, {{ 9, 24}}, 0, /* TAG13b */ - "a branch tag" }, - { REL, ins_imms4, ext_imms4, 0, {{20, 6}, { 1, 36}}, 0, /* TGT25 */ - "a branch target" }, - { REL, ins_imms4, ext_imms4, 0, /* TGT25b */ - {{ 7, 6}, {13, 20}, { 1, 36}}, 0, - "a branch target" }, - { REL, ins_imms4, ext_imms4, 0, {{20, 13}, { 1, 36}}, 0, /* TGT25c */ - "a branch target" }, - { REL, ins_rsvd, ext_rsvd, 0, {{0, 0}}, 0, /* TGT64 */ - "a branch target" }, - - { ABS, ins_const, ext_const, 0, {{0, 0}}, 0, /* LDXMOV */ - "ldxmov target" }, - }; - - -/* ia64-asmtab.h -- Header for compacted IA-64 opcode tables. - Copyright 1999, 2000 Free Software Foundation, Inc. - Contributed by Bob Manson of Cygnus Support <manson@cygnus.com> - - This file is part of GDB, GAS, and the GNU binutils. - - GDB, GAS, and the GNU binutils are free software; you can redistribute - them and/or modify them under the terms of the GNU General Public - License as published by the Free Software Foundation; either version - 2, or (at your option) any later version. - - GDB, GAS, and the GNU binutils are distributed in the hope that they - will be useful, but WITHOUT ANY WARRANTY; without even the implied - warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See - the GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this file; see the file COPYING. If not, see - <http://www.gnu.org/licenses/>. */ - -/* The primary opcode table is made up of the following: */ -struct ia64_main_table -{ - /* The entry in the string table that corresponds to the name of this - opcode. */ - unsigned short name_index; - - /* The type of opcode; corresponds to the TYPE field in - struct ia64_opcode. */ - unsigned char opcode_type; - - /* The number of outputs for this opcode. */ - unsigned char num_outputs; - - /* The base insn value for this opcode. It may be modified by completers. */ - ia64_insn opcode; - - /* The mask of valid bits in OPCODE. Zeros indicate operand fields. */ - ia64_insn mask; - - /* The operands of this instruction. Corresponds to the OPERANDS field - in struct ia64_opcode. */ - unsigned char operands[5]; - - /* The flags for this instruction. Corresponds to the FLAGS field in - struct ia64_opcode. */ - short flags; - - /* The tree of completers for this instruction; this is an offset into - completer_table. */ - short completers; -}; - -/* Each instruction has a set of possible "completers", or additional - suffixes that can alter the instruction's behavior, and which has - potentially different dependencies. - - The completer entries modify certain bits in the instruction opcode. - Which bits are to be modified are marked by the BITS, MASK and - OFFSET fields. The completer entry may also note dependencies for the - opcode. - - These completers are arranged in a DAG; the pointers are indexes - into the completer_table array. The completer DAG is searched by - find_completer () and ia64_find_matching_opcode (). - - Note that each completer needs to be applied in turn, so that if we - have the instruction - cmp.lt.unc - the completer entries for both "lt" and "unc" would need to be applied - to the opcode's value. - - Some instructions do not require any completers; these contain an - empty completer entry. Instructions that require a completer do - not contain an empty entry. - - Terminal completers (those completers that validly complete an - instruction) are marked by having the TERMINAL_COMPLETER flag set. - - Only dependencies listed in the terminal completer for an opcode are - considered to apply to that opcode instance. */ - -struct ia64_completer_table -{ - /* The bit value that this completer sets. */ - unsigned int bits; - - /* And its mask. 1s are bits that are to be modified in the - instruction. */ - unsigned int mask; - - /* The entry in the string table that corresponds to the name of this - completer. */ - unsigned short name_index; - - /* An alternative completer, or -1 if this is the end of the chain. */ - short alternative; - - /* A pointer to the DAG of completers that can potentially follow - this one, or -1. */ - short subentries; - - /* The bit offset in the instruction where BITS and MASK should be - applied. */ - unsigned char offset : 7; - - unsigned char terminal_completer : 1; - - /* Index into the dependency list table */ - short dependencies; -}; - -/* This contains sufficient information for the disassembler to resolve - the complete name of the original instruction. */ -struct ia64_dis_names -{ - /* COMPLETER_INDEX represents the tree of completers that make up - the instruction. The LSB represents the top of the tree for the - specified instruction. - - A 0 bit indicates to go to the next alternate completer via the - alternative field; a 1 bit indicates that the current completer - is part of the instruction, and to go down the subentries index. - We know we've reached the final completer when we run out of 1 - bits. - - There is always at least one 1 bit. */ - unsigned int completer_index : 20; - - /* The index in the main_table[] array for the instruction. */ - unsigned short insn_index : 11; - - /* If set, the next entry in this table is an alternate possibility - for this instruction encoding. Which one to use is determined by - the instruction type and other factors (see opcode_verify ()). */ - unsigned int next_flag : 1; - - /* The disassembly priority of this entry among instructions. */ - unsigned short priority; -}; - -static const char * const ia64_strings[] = { - "", "0", "1", "a", "acq", "add", "addl", "addp4", "adds", "alloc", "and", - "andcm", "b", "bias", "br", "break", "brl", "brp", "bsw", "c", "call", - "cexit", "chk", "cloop", "clr", "clrrrb", "cmp", "cmp4", "cmp8xchg16", - "cmpxchg1", "cmpxchg2", "cmpxchg4", "cmpxchg8", "cond", "cover", "ctop", - "czx1", "czx2", "d", "dep", "dpnt", "dptk", "e", "epc", "eq", "excl", - "exit", "exp", "extr", "f", "fabs", "fadd", "famax", "famin", "fand", - "fandcm", "fault", "fc", "fchkf", "fclass", "fclrf", "fcmp", "fcvt", - "fetchadd4", "fetchadd8", "few", "fill", "flushrs", "fma", "fmax", - "fmerge", "fmin", "fmix", "fmpy", "fms", "fneg", "fnegabs", "fnma", - "fnmpy", "fnorm", "for", "fpabs", "fpack", "fpamax", "fpamin", "fpcmp", - "fpcvt", "fpma", "fpmax", "fpmerge", "fpmin", "fpmpy", "fpms", "fpneg", - "fpnegabs", "fpnma", "fpnmpy", "fprcpa", "fprsqrta", "frcpa", "frsqrta", - "fselect", "fsetc", "fsub", "fswap", "fsxt", "fwb", "fx", "fxor", "fxu", - "g", "ga", "ge", "getf", "geu", "gt", "gtu", "h", "hint", "hu", "i", "ia", - "imp", "invala", "itc", "itr", "l", "ld1", "ld16", "ld2", "ld4", "ld8", - "ldf", "ldf8", "ldfd", "ldfe", "ldfp8", "ldfpd", "ldfps", "ldfs", "le", - "leu", "lfetch", "loadrs", "loop", "lr", "lt", "ltu", "lu", "m", "many", - "mf", "mix1", "mix2", "mix4", "mov", "movl", "mux1", "mux2", "nc", "ne", - "neq", "nge", "ngt", "nl", "nle", "nlt", "nm", "nop", "nr", "ns", "nt1", - "nt2", "nta", "nz", "or", "orcm", "ord", "pack2", "pack4", "padd1", - "padd2", "padd4", "pavg1", "pavg2", "pavgsub1", "pavgsub2", "pcmp1", - "pcmp2", "pcmp4", "pmax1", "pmax2", "pmin1", "pmin2", "pmpy2", "pmpyshr2", - "popcnt", "pr", "probe", "psad1", "pshl2", "pshl4", "pshladd2", "pshr2", - "pshr4", "pshradd2", "psub1", "psub2", "psub4", "ptc", "ptr", "r", "raz", - "rel", "ret", "rfi", "rsm", "rum", "rw", "s", "s0", "s1", "s2", "s3", - "sa", "se", "setf", "shl", "shladd", "shladdp4", "shr", "shrp", "sig", - "spill", "spnt", "sptk", "srlz", "ssm", "sss", "st1", "st16", "st2", - "st4", "st8", "stf", "stf8", "stfd", "stfe", "stfs", "sub", "sum", "sxt1", - "sxt2", "sxt4", "sync", "tak", "tbit", "tf", "thash", "tnat", "tpa", - "trunc", "ttag", "u", "unc", "unord", "unpack1", "unpack2", "unpack4", - "uss", "uus", "uuu", "vmsw", "w", "wexit", "wtop", "x", "xchg1", "xchg2", - "xchg4", "xchg8", "xf", "xma", "xmpy", "xor", "xuf", "z", "zxt1", "zxt2", - "zxt4", -}; - -static const struct ia64_dependency -dependencies[] = { - { "ALAT", 0, 0, 0, -1, NULL, }, - { "AR[BSP]", 26, 0, 2, 17, NULL, }, - { "AR[BSPSTORE]", 26, 0, 2, 18, NULL, }, - { "AR[CCV]", 26, 0, 2, 32, NULL, }, - { "AR[CFLG]", 26, 0, 2, 27, NULL, }, - { "AR[CSD]", 26, 0, 2, 25, NULL, }, - { "AR[EC]", 26, 0, 2, 66, NULL, }, - { "AR[EFLAG]", 26, 0, 2, 24, NULL, }, - { "AR[FCR]", 26, 0, 2, 21, NULL, }, - { "AR[FDR]", 26, 0, 2, 30, NULL, }, - { "AR[FIR]", 26, 0, 2, 29, NULL, }, - { "AR[FPSR].sf0.controls", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf1.controls", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf2.controls", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf3.controls", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf0.flags", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf1.flags", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf2.flags", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].sf3.flags", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].traps", 30, 0, 2, -1, NULL, }, - { "AR[FPSR].rv", 30, 0, 2, -1, NULL, }, - { "AR[FSR]", 26, 0, 2, 28, NULL, }, - { "AR[ITC]", 26, 0, 2, 44, NULL, }, - { "AR[K%], % in 0 - 7", 1, 0, 2, -1, NULL, }, - { "AR[LC]", 26, 0, 2, 65, NULL, }, - { "AR[PFS]", 26, 0, 2, 64, NULL, }, - { "AR[PFS]", 26, 0, 2, 64, NULL, }, - { "AR[PFS]", 26, 0, 0, 64, NULL, }, - { "AR[RNAT]", 26, 0, 2, 19, NULL, }, - { "AR[RSC]", 26, 0, 2, 16, NULL, }, - { "AR[SSD]", 26, 0, 2, 26, NULL, }, - { "AR[UNAT]{%}, % in 0 - 63", 2, 0, 2, -1, NULL, }, - { "AR%, % in 8-15, 20, 22-23, 31, 33-35, 37-39, 41-43, 45-47, 67-111", 3, 0, 0, -1, NULL, }, - { "AR%, % in 48-63, 112-127", 4, 0, 2, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 0, 2, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 0, 0, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 0, 2, -1, NULL, }, - { "CFM", 6, 0, 2, -1, NULL, }, - { "CFM", 6, 0, 2, -1, NULL, }, - { "CFM", 6, 0, 2, -1, NULL, }, - { "CFM", 6, 0, 2, -1, NULL, }, - { "CFM", 6, 0, 0, -1, NULL, }, - { "CPUID#", 7, 0, 5, -1, NULL, }, - { "CR[CMCV]", 27, 0, 3, 74, NULL, }, - { "CR[DCR]", 27, 0, 3, 0, NULL, }, - { "CR[EOI]", 27, 0, 7, 67, "SC Section 5.8.3.4, \"End of External Interrupt Register (EOI Ð CR67)\" on page 2:119", }, - { "CR[GPTA]", 27, 0, 3, 9, NULL, }, - { "CR[IFA]", 27, 0, 1, 20, NULL, }, - { "CR[IFA]", 27, 0, 3, 20, NULL, }, - { "CR[IFS]", 27, 0, 3, 23, NULL, }, - { "CR[IFS]", 27, 0, 1, 23, NULL, }, - { "CR[IFS]", 27, 0, 1, 23, NULL, }, - { "CR[IHA]", 27, 0, 3, 25, NULL, }, - { "CR[IIM]", 27, 0, 3, 24, NULL, }, - { "CR[IIP]", 27, 0, 3, 19, NULL, }, - { "CR[IIP]", 27, 0, 1, 19, NULL, }, - { "CR[IIPA]", 27, 0, 3, 22, NULL, }, - { "CR[IPSR]", 27, 0, 3, 16, NULL, }, - { "CR[IPSR]", 27, 0, 1, 16, NULL, }, - { "CR[IRR%], % in 0 - 3", 8, 0, 3, -1, NULL, }, - { "CR[ISR]", 27, 0, 3, 17, NULL, }, - { "CR[ITIR]", 27, 0, 3, 21, NULL, }, - { "CR[ITIR]", 27, 0, 1, 21, NULL, }, - { "CR[ITM]", 27, 0, 3, 1, NULL, }, - { "CR[ITV]", 27, 0, 3, 72, NULL, }, - { "CR[IVA]", 27, 0, 4, 2, NULL, }, - { "CR[IVR]", 27, 0, 7, 65, "SC Section 5.8.3.2, \"External Interrupt Vector Register (IVR Ð CR65)\" on page 2:118", }, - { "CR[LID]", 27, 0, 7, 64, "SC Section 5.8.3.1, \"Local ID (LID Ð CR64)\" on page 2:117", }, - { "CR[LRR%], % in 0 - 1", 9, 0, 3, -1, NULL, }, - { "CR[PMV]", 27, 0, 3, 73, NULL, }, - { "CR[PTA]", 27, 0, 3, 8, NULL, }, - { "CR[TPR]", 27, 0, 3, 66, NULL, }, - { "CR[TPR]", 27, 0, 7, 66, "SC Section 5.8.3.3, \"Task Priority Register (TPR Ð CR66)\" on page 2:119", }, - { "CR[TPR]", 27, 0, 1, 66, NULL, }, - { "CR%, % in 3-7, 10-15, 18, 26-63, 75-79, 82-127", 10, 0, 0, -1, NULL, }, - { "DBR#", 11, 0, 2, -1, NULL, }, - { "DBR#", 11, 0, 3, -1, NULL, }, - { "DTC", 0, 0, 3, -1, NULL, }, - { "DTC", 0, 0, 2, -1, NULL, }, - { "DTC", 0, 0, 0, -1, NULL, }, - { "DTC", 0, 0, 2, -1, NULL, }, - { "DTC_LIMIT*", 0, 0, 2, -1, NULL, }, - { "DTR", 0, 0, 3, -1, NULL, }, - { "DTR", 0, 0, 2, -1, NULL, }, - { "DTR", 0, 0, 3, -1, NULL, }, - { "DTR", 0, 0, 0, -1, NULL, }, - { "DTR", 0, 0, 2, -1, NULL, }, - { "FR%, % in 0 - 1", 12, 0, 0, -1, NULL, }, - { "FR%, % in 2 - 127", 13, 0, 2, -1, NULL, }, - { "FR%, % in 2 - 127", 13, 0, 0, -1, NULL, }, - { "GR0", 14, 0, 0, -1, NULL, }, - { "GR%, % in 1 - 127", 15, 0, 0, -1, NULL, }, - { "GR%, % in 1 - 127", 15, 0, 2, -1, NULL, }, - { "IBR#", 16, 0, 2, -1, NULL, }, - { "InService*", 17, 0, 3, -1, NULL, }, - { "InService*", 17, 0, 2, -1, NULL, }, - { "InService*", 17, 0, 2, -1, NULL, }, - { "IP", 0, 0, 0, -1, NULL, }, - { "ITC", 0, 0, 4, -1, NULL, }, - { "ITC", 0, 0, 2, -1, NULL, }, - { "ITC", 0, 0, 0, -1, NULL, }, - { "ITC", 0, 0, 4, -1, NULL, }, - { "ITC", 0, 0, 2, -1, NULL, }, - { "ITC_LIMIT*", 0, 0, 2, -1, NULL, }, - { "ITR", 0, 0, 2, -1, NULL, }, - { "ITR", 0, 0, 4, -1, NULL, }, - { "ITR", 0, 0, 2, -1, NULL, }, - { "ITR", 0, 0, 0, -1, NULL, }, - { "ITR", 0, 0, 4, -1, NULL, }, - { "memory", 0, 0, 0, -1, NULL, }, - { "MSR#", 18, 0, 5, -1, NULL, }, - { "PKR#", 19, 0, 3, -1, NULL, }, - { "PKR#", 19, 0, 0, -1, NULL, }, - { "PKR#", 19, 0, 2, -1, NULL, }, - { "PKR#", 19, 0, 2, -1, NULL, }, - { "PMC#", 20, 0, 2, -1, NULL, }, - { "PMC#", 20, 0, 7, -1, "SC Section 7.2.1, \"Generic Performance Counter Registers\" for PMC[0].fr on page 2:150", }, - { "PMD#", 21, 0, 2, -1, NULL, }, - { "PR0", 0, 0, 0, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 0, 2, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 0, 2, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 0, 0, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 0, 2, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 0, 2, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 0, 0, -1, NULL, }, - { "PR63", 24, 0, 2, -1, NULL, }, - { "PR63", 24, 0, 2, -1, NULL, }, - { "PR63", 24, 0, 0, -1, NULL, }, - { "PSR.ac", 28, 0, 1, 3, NULL, }, - { "PSR.ac", 28, 0, 3, 3, NULL, }, - { "PSR.ac", 28, 0, 2, 3, NULL, }, - { "PSR.ac", 28, 0, 2, 3, NULL, }, - { "PSR.be", 28, 0, 1, 1, NULL, }, - { "PSR.be", 28, 0, 3, 1, NULL, }, - { "PSR.be", 28, 0, 2, 1, NULL, }, - { "PSR.be", 28, 0, 2, 1, NULL, }, - { "PSR.bn", 28, 0, 2, 44, NULL, }, - { "PSR.cpl", 28, 0, 1, 32, NULL, }, - { "PSR.cpl", 28, 0, 2, 32, NULL, }, - { "PSR.da", 28, 0, 2, 38, NULL, }, - { "PSR.db", 28, 0, 3, 24, NULL, }, - { "PSR.db", 28, 0, 2, 24, NULL, }, - { "PSR.db", 28, 0, 2, 24, NULL, }, - { "PSR.dd", 28, 0, 2, 39, NULL, }, - { "PSR.dfh", 28, 0, 3, 19, NULL, }, - { "PSR.dfh", 28, 0, 2, 19, NULL, }, - { "PSR.dfh", 28, 0, 2, 19, NULL, }, - { "PSR.dfl", 28, 0, 3, 18, NULL, }, - { "PSR.dfl", 28, 0, 2, 18, NULL, }, - { "PSR.dfl", 28, 0, 2, 18, NULL, }, - { "PSR.di", 28, 0, 3, 22, NULL, }, - { "PSR.di", 28, 0, 2, 22, NULL, }, - { "PSR.di", 28, 0, 2, 22, NULL, }, - { "PSR.dt", 28, 0, 3, 17, NULL, }, - { "PSR.dt", 28, 0, 2, 17, NULL, }, - { "PSR.dt", 28, 0, 2, 17, NULL, }, - { "PSR.ed", 28, 0, 2, 43, NULL, }, - { "PSR.i", 28, 0, 2, 14, NULL, }, - { "PSR.ia", 28, 0, 0, 14, NULL, }, - { "PSR.ic", 28, 0, 2, 13, NULL, }, - { "PSR.ic", 28, 0, 3, 13, NULL, }, - { "PSR.ic", 28, 0, 2, 13, NULL, }, - { "PSR.id", 28, 0, 0, 14, NULL, }, - { "PSR.is", 28, 0, 0, 14, NULL, }, - { "PSR.it", 28, 0, 2, 14, NULL, }, - { "PSR.lp", 28, 0, 2, 25, NULL, }, - { "PSR.lp", 28, 0, 3, 25, NULL, }, - { "PSR.lp", 28, 0, 2, 25, NULL, }, - { "PSR.mc", 28, 0, 2, 35, NULL, }, - { "PSR.mfh", 28, 0, 2, 5, NULL, }, - { "PSR.mfl", 28, 0, 2, 4, NULL, }, - { "PSR.pk", 28, 0, 3, 15, NULL, }, - { "PSR.pk", 28, 0, 2, 15, NULL, }, - { "PSR.pk", 28, 0, 2, 15, NULL, }, - { "PSR.pp", 28, 0, 2, 21, NULL, }, - { "PSR.ri", 28, 0, 0, 41, NULL, }, - { "PSR.rt", 28, 0, 2, 27, NULL, }, - { "PSR.rt", 28, 0, 3, 27, NULL, }, - { "PSR.rt", 28, 0, 2, 27, NULL, }, - { "PSR.si", 28, 0, 2, 23, NULL, }, - { "PSR.si", 28, 0, 3, 23, NULL, }, - { "PSR.si", 28, 0, 2, 23, NULL, }, - { "PSR.sp", 28, 0, 2, 20, NULL, }, - { "PSR.sp", 28, 0, 3, 20, NULL, }, - { "PSR.sp", 28, 0, 2, 20, NULL, }, - { "PSR.ss", 28, 0, 2, 40, NULL, }, - { "PSR.tb", 28, 0, 3, 26, NULL, }, - { "PSR.tb", 28, 0, 2, 26, NULL, }, - { "PSR.tb", 28, 0, 2, 26, NULL, }, - { "PSR.up", 28, 0, 2, 2, NULL, }, - { "PSR.vm", 28, 0, 1, 46, NULL, }, - { "PSR.vm", 28, 0, 2, 46, NULL, }, - { "RR#", 25, 0, 3, -1, NULL, }, - { "RR#", 25, 0, 2, -1, NULL, }, - { "RSE", 29, 0, 2, -1, NULL, }, - { "ALAT", 0, 1, 0, -1, NULL, }, - { "AR[BSP]", 26, 1, 2, 17, NULL, }, - { "AR[BSPSTORE]", 26, 1, 2, 18, NULL, }, - { "AR[CCV]", 26, 1, 2, 32, NULL, }, - { "AR[CFLG]", 26, 1, 2, 27, NULL, }, - { "AR[CSD]", 26, 1, 2, 25, NULL, }, - { "AR[EC]", 26, 1, 2, 66, NULL, }, - { "AR[EFLAG]", 26, 1, 2, 24, NULL, }, - { "AR[FCR]", 26, 1, 2, 21, NULL, }, - { "AR[FDR]", 26, 1, 2, 30, NULL, }, - { "AR[FIR]", 26, 1, 2, 29, NULL, }, - { "AR[FPSR].sf0.controls", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf1.controls", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf2.controls", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf3.controls", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf0.flags", 30, 1, 0, -1, NULL, }, - { "AR[FPSR].sf0.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf0.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf1.flags", 30, 1, 0, -1, NULL, }, - { "AR[FPSR].sf1.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf1.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf2.flags", 30, 1, 0, -1, NULL, }, - { "AR[FPSR].sf2.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf2.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf3.flags", 30, 1, 0, -1, NULL, }, - { "AR[FPSR].sf3.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].sf3.flags", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].rv", 30, 1, 2, -1, NULL, }, - { "AR[FPSR].traps", 30, 1, 2, -1, NULL, }, - { "AR[FSR]", 26, 1, 2, 28, NULL, }, - { "AR[ITC]", 26, 1, 2, 44, NULL, }, - { "AR[K%], % in 0 - 7", 1, 1, 2, -1, NULL, }, - { "AR[LC]", 26, 1, 2, 65, NULL, }, - { "AR[PFS]", 26, 1, 0, 64, NULL, }, - { "AR[PFS]", 26, 1, 2, 64, NULL, }, - { "AR[PFS]", 26, 1, 2, 64, NULL, }, - { "AR[RNAT]", 26, 1, 2, 19, NULL, }, - { "AR[RSC]", 26, 1, 2, 16, NULL, }, - { "AR[SSD]", 26, 1, 2, 26, NULL, }, - { "AR[UNAT]{%}, % in 0 - 63", 2, 1, 2, -1, NULL, }, - { "AR%, % in 8-15, 20, 22-23, 31, 33-35, 37-39, 41-43, 45-47, 67-111", 3, 1, 0, -1, NULL, }, - { "AR%, % in 48 - 63, 112-127", 4, 1, 2, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 1, 2, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 1, 2, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 1, 2, -1, NULL, }, - { "BR%, % in 0 - 7", 5, 1, 0, -1, NULL, }, - { "CFM", 6, 1, 2, -1, NULL, }, - { "CPUID#", 7, 1, 0, -1, NULL, }, - { "CR[CMCV]", 27, 1, 2, 74, NULL, }, - { "CR[DCR]", 27, 1, 2, 0, NULL, }, - { "CR[EOI]", 27, 1, 7, 67, "SC Section 5.8.3.4, \"End of External Interrupt Register (EOI Ð CR67)\" on page 2:119", }, - { "CR[GPTA]", 27, 1, 2, 9, NULL, }, - { "CR[IFA]", 27, 1, 2, 20, NULL, }, - { "CR[IFS]", 27, 1, 2, 23, NULL, }, - { "CR[IHA]", 27, 1, 2, 25, NULL, }, - { "CR[IIM]", 27, 1, 2, 24, NULL, }, - { "CR[IIP]", 27, 1, 2, 19, NULL, }, - { "CR[IIPA]", 27, 1, 2, 22, NULL, }, - { "CR[IPSR]", 27, 1, 2, 16, NULL, }, - { "CR[IRR%], % in 0 - 3", 8, 1, 2, -1, NULL, }, - { "CR[ISR]", 27, 1, 2, 17, NULL, }, - { "CR[ITIR]", 27, 1, 2, 21, NULL, }, - { "CR[ITM]", 27, 1, 2, 1, NULL, }, - { "CR[ITV]", 27, 1, 2, 72, NULL, }, - { "CR[IVA]", 27, 1, 2, 2, NULL, }, - { "CR[IVR]", 27, 1, 7, 65, "SC", }, - { "CR[LID]", 27, 1, 7, 64, "SC", }, - { "CR[LRR%], % in 0 - 1", 9, 1, 2, -1, NULL, }, - { "CR[PMV]", 27, 1, 2, 73, NULL, }, - { "CR[PTA]", 27, 1, 2, 8, NULL, }, - { "CR[TPR]", 27, 1, 2, 66, NULL, }, - { "CR%, % in 3-7, 10-15, 18, 26-63, 75-79, 82-127", 10, 1, 0, -1, NULL, }, - { "DBR#", 11, 1, 2, -1, NULL, }, - { "DTC", 0, 1, 0, -1, NULL, }, - { "DTC", 0, 1, 2, -1, NULL, }, - { "DTC", 0, 1, 2, -1, NULL, }, - { "DTC_LIMIT*", 0, 1, 2, -1, NULL, }, - { "DTR", 0, 1, 2, -1, NULL, }, - { "DTR", 0, 1, 2, -1, NULL, }, - { "DTR", 0, 1, 2, -1, NULL, }, - { "DTR", 0, 1, 0, -1, NULL, }, - { "FR%, % in 0 - 1", 12, 1, 0, -1, NULL, }, - { "FR%, % in 2 - 127", 13, 1, 2, -1, NULL, }, - { "GR0", 14, 1, 0, -1, NULL, }, - { "GR%, % in 1 - 127", 15, 1, 2, -1, NULL, }, - { "IBR#", 16, 1, 2, -1, NULL, }, - { "InService*", 17, 1, 7, -1, "SC", }, - { "IP", 0, 1, 0, -1, NULL, }, - { "ITC", 0, 1, 0, -1, NULL, }, - { "ITC", 0, 1, 2, -1, NULL, }, - { "ITC", 0, 1, 2, -1, NULL, }, - { "ITR", 0, 1, 2, -1, NULL, }, - { "ITR", 0, 1, 2, -1, NULL, }, - { "ITR", 0, 1, 0, -1, NULL, }, - { "memory", 0, 1, 0, -1, NULL, }, - { "MSR#", 18, 1, 7, -1, "SC", }, - { "PKR#", 19, 1, 0, -1, NULL, }, - { "PKR#", 19, 1, 0, -1, NULL, }, - { "PKR#", 19, 1, 2, -1, NULL, }, - { "PMC#", 20, 1, 2, -1, NULL, }, - { "PMD#", 21, 1, 2, -1, NULL, }, - { "PR0", 0, 1, 0, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 1, 0, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 1, 0, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 1, 2, -1, NULL, }, - { "PR%, % in 1 - 15", 22, 1, 2, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 1, 0, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 1, 0, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 1, 2, -1, NULL, }, - { "PR%, % in 16 - 62", 23, 1, 2, -1, NULL, }, - { "PR63", 24, 1, 0, -1, NULL, }, - { "PR63", 24, 1, 0, -1, NULL, }, - { "PR63", 24, 1, 2, -1, NULL, }, - { "PR63", 24, 1, 2, -1, NULL, }, - { "PSR.ac", 28, 1, 2, 3, NULL, }, - { "PSR.be", 28, 1, 2, 1, NULL, }, - { "PSR.bn", 28, 1, 2, 44, NULL, }, - { "PSR.cpl", 28, 1, 2, 32, NULL, }, - { "PSR.da", 28, 1, 2, 38, NULL, }, - { "PSR.db", 28, 1, 2, 24, NULL, }, - { "PSR.dd", 28, 1, 2, 39, NULL, }, - { "PSR.dfh", 28, 1, 2, 19, NULL, }, - { "PSR.dfl", 28, 1, 2, 18, NULL, }, - { "PSR.di", 28, 1, 2, 22, NULL, }, - { "PSR.dt", 28, 1, 2, 17, NULL, }, - { "PSR.ed", 28, 1, 2, 43, NULL, }, - { "PSR.i", 28, 1, 2, 14, NULL, }, - { "PSR.ia", 28, 1, 2, 14, NULL, }, - { "PSR.ic", 28, 1, 2, 13, NULL, }, - { "PSR.id", 28, 1, 2, 14, NULL, }, - { "PSR.is", 28, 1, 2, 14, NULL, }, - { "PSR.it", 28, 1, 2, 14, NULL, }, - { "PSR.lp", 28, 1, 2, 25, NULL, }, - { "PSR.mc", 28, 1, 2, 35, NULL, }, - { "PSR.mfh", 28, 1, 0, 5, NULL, }, - { "PSR.mfh", 28, 1, 2, 5, NULL, }, - { "PSR.mfh", 28, 1, 2, 5, NULL, }, - { "PSR.mfl", 28, 1, 0, 4, NULL, }, - { "PSR.mfl", 28, 1, 2, 4, NULL, }, - { "PSR.mfl", 28, 1, 2, 4, NULL, }, - { "PSR.pk", 28, 1, 2, 15, NULL, }, - { "PSR.pp", 28, 1, 2, 21, NULL, }, - { "PSR.ri", 28, 1, 2, 41, NULL, }, - { "PSR.rt", 28, 1, 2, 27, NULL, }, - { "PSR.si", 28, 1, 2, 23, NULL, }, - { "PSR.sp", 28, 1, 2, 20, NULL, }, - { "PSR.ss", 28, 1, 2, 40, NULL, }, - { "PSR.tb", 28, 1, 2, 26, NULL, }, - { "PSR.up", 28, 1, 2, 2, NULL, }, - { "PSR.vm", 28, 1, 2, 46, NULL, }, - { "RR#", 25, 1, 2, -1, NULL, }, - { "RSE", 29, 1, 2, -1, NULL, }, - { "PR63", 24, 2, 6, -1, NULL, }, -}; - -static const unsigned short dep0[] = { - 97, 282, 2140, 2327, -}; - -static const unsigned short dep1[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2327, 4135, 20616, -}; - -static const unsigned short dep2[] = { - 97, 282, 2166, 2167, 2169, 2170, 2172, 2173, 2175, 2344, 2347, 2348, 2351, - 2352, 2355, 2356, -}; - -static const unsigned short dep3[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2344, 2347, 2348, 2351, 2352, 2355, 2356, 4135, 20616, -}; - -static const unsigned short dep4[] = { - 97, 282, 22646, 22647, 22649, 22650, 22652, 22653, 22655, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep5[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 4135, 20616, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep6[] = { - 97, 282, 2166, 2167, 2169, 2170, 2172, 2173, 2175, 2344, 2345, 2347, 2349, - 2351, 2353, 2355, -}; - -static const unsigned short dep7[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2344, 2345, 2348, 2349, 2352, 2353, 2356, 4135, 20616, -}; - -static const unsigned short dep8[] = { - 97, 282, 2166, 2167, 2169, 2170, 2172, 2173, 2175, 2344, 2346, 2348, 2350, - 2352, 2354, 2356, -}; - -static const unsigned short dep9[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2344, 2346, 2347, 2350, 2351, 2354, 2355, 4135, 20616, -}; - -static const unsigned short dep10[] = { - 97, 282, 2166, 2167, 2169, 2170, 2172, 2173, 2175, 2344, 2345, 2346, 2347, - 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, -}; - -static const unsigned short dep11[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, - 4135, 20616, -}; - -static const unsigned short dep12[] = { - 97, 282, 2395, -}; - -static const unsigned short dep13[] = { - 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2082, 2083, 2166, 2168, - 2169, 2171, 2172, 2174, 2175, 4135, -}; - -static const unsigned short dep14[] = { - 97, 163, 282, 325, 2395, 28866, 29018, -}; - -static const unsigned short dep15[] = { - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 40, 41, 97, 150, 152, 158, 162, - 164, 175, 185, 186, 188, 282, 325, 2082, 2083, 2166, 2168, 2169, 2171, 2172, - 2174, 2175, 4135, 28866, 29018, -}; - -static const unsigned short dep16[] = { - 1, 6, 40, 97, 137, 196, 201, 241, 282, 312, 2395, 28866, 29018, -}; - -static const unsigned short dep17[] = { - 1, 25, 27, 38, 40, 41, 97, 158, 162, 164, 166, 167, 175, 185, 186, 188, 196, - 201, 241, 282, 312, 2082, 2083, 2166, 2168, 2169, 2171, 2172, 2174, 2175, - 4135, 28866, 29018, -}; - -static const unsigned short dep18[] = { - 1, 40, 51, 97, 196, 241, 248, 282, 28866, 29018, -}; - -static const unsigned short dep19[] = { - 1, 38, 40, 41, 97, 158, 160, 161, 162, 175, 185, 190, 191, 196, 241, 248, - 282, 4135, 28866, 29018, -}; - -static const unsigned short dep20[] = { - 40, 97, 241, 282, -}; - -static const unsigned short dep21[] = { - 97, 158, 162, 175, 185, 241, 282, -}; - -static const unsigned short dep22[] = { - 1, 40, 97, 131, 135, 136, 138, 139, 142, 143, 146, 149, 152, 155, 156, 157, - 158, 161, 162, 163, 164, 167, 168, 169, 170, 173, 174, 175, 178, 181, 184, - 185, 188, 189, 191, 196, 241, 282, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 330, 331, 333, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 28866, 29018, -}; - -static const unsigned short dep23[] = { - 1, 38, 40, 41, 50, 51, 55, 58, 73, 97, 137, 138, 158, 162, 175, 185, 190, - 191, 196, 241, 282, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 330, 331, 333, 334, 335, 336, - 337, 338, 339, 340, 341, 342, 343, 344, 4135, 28866, 29018, -}; - -static const unsigned short dep24[] = { - 97, 136, 282, 311, -}; - -static const unsigned short dep25[] = { - 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 311, -}; - -static const unsigned short dep26[] = { - 97, 137, 282, 312, -}; - -static const unsigned short dep27[] = { - 25, 26, 97, 98, 101, 105, 108, 137, 138, 158, 162, 164, 175, 185, 282, 312, - -}; - -static const unsigned short dep28[] = { - 97, 190, 282, 344, -}; - -static const unsigned short dep29[] = { - 97, 98, 101, 105, 108, 137, 138, 158, 162, 164, 175, 185, 282, 344, -}; - -static const unsigned short dep30[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2168, 2169, 2171, 2172, 2174, 2175, - 4135, -}; - -static const unsigned short dep31[] = { - 1, 25, 40, 97, 196, 228, 229, 241, 282, 2082, 2285, 2288, 2395, 28866, 29018, - -}; - -static const unsigned short dep32[] = { - 1, 6, 38, 40, 41, 97, 137, 138, 158, 162, 164, 175, 185, 186, 188, 196, 228, - 230, 241, 282, 2082, 2083, 2166, 2168, 2169, 2171, 2172, 2174, 2175, 2286, - 2288, 4135, 28866, 29018, -}; - -static const unsigned short dep33[] = { - 97, 282, -}; - -static const unsigned short dep34[] = { - 97, 158, 162, 175, 185, 282, 2082, 2084, -}; - -static const unsigned short dep35[] = { - 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2166, 2168, 2169, 2171, - 2172, 2174, 2175, 4135, -}; - -static const unsigned short dep36[] = { - 6, 37, 38, 39, 97, 125, 126, 201, 241, 282, 307, 308, 2395, -}; - -static const unsigned short dep37[] = { - 6, 37, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 201, 241, 282, 307, - 308, 347, 2166, 2168, 2169, 2171, 2172, 2174, 2175, 4135, -}; - -static const unsigned short dep38[] = { - 24, 97, 227, 282, 2395, -}; - -static const unsigned short dep39[] = { - 24, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 227, 282, 2166, 2168, 2169, - 2171, 2172, 2174, 2175, 4135, -}; - -static const unsigned short dep40[] = { - 6, 24, 37, 38, 39, 97, 125, 126, 201, 227, 241, 282, 307, 308, 2395, -}; - -static const unsigned short dep41[] = { - 6, 24, 37, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 201, 227, 241, 282, - 307, 308, 347, 2166, 2168, 2169, 2171, 2172, 2174, 2175, 4135, -}; - -static const unsigned short dep42[] = { - 1, 6, 38, 40, 41, 97, 137, 138, 158, 162, 164, 175, 185, 186, 188, 196, 228, - 230, 241, 282, 2166, 2168, 2169, 2171, 2172, 2174, 2175, 2286, 2288, 4135, - 28866, 29018, -}; - -static const unsigned short dep43[] = { - 97, 158, 162, 175, 185, 282, -}; - -static const unsigned short dep44[] = { - 15, 97, 210, 211, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, 22827, 22828, 22831, - 22832, 22835, 22836, -}; - -static const unsigned short dep45[] = { - 11, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep46[] = { - 15, 16, 17, 18, 97, 210, 211, 213, 214, 216, 217, 219, 220, 282, 2136, 2325, - 18601, 18602, 18761, 18762, 18764, 18765, 22646, 22647, 22648, 22650, 22651, - 22653, 22654, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep47[] = { - 11, 12, 13, 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 213, 215, - 216, 218, 219, 221, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, 2325, 4135, - 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep48[] = { - 16, 97, 213, 214, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, 22827, 22828, 22831, - 22832, 22835, 22836, -}; - -static const unsigned short dep49[] = { - 12, 19, 20, 40, 41, 97, 158, 162, 175, 185, 213, 215, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep50[] = { - 17, 97, 216, 217, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, 22827, 22828, 22831, - 22832, 22835, 22836, -}; - -static const unsigned short dep51[] = { - 13, 19, 20, 40, 41, 97, 158, 162, 175, 185, 216, 218, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep52[] = { - 18, 97, 219, 220, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, 22827, 22828, 22831, - 22832, 22835, 22836, -}; - -static const unsigned short dep53[] = { - 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 219, 221, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep54[] = { - 15, 97, 210, 211, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - -}; - -static const unsigned short dep55[] = { - 11, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, -}; - -static const unsigned short dep56[] = { - 15, 16, 17, 18, 97, 210, 211, 213, 214, 216, 217, 219, 220, 282, 2136, 2325, - 18601, 18602, 18761, 18762, 18764, 18765, -}; - -static const unsigned short dep57[] = { - 11, 12, 13, 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 213, 215, - 216, 218, 219, 221, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, 2325, 4135, - 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, -}; - -static const unsigned short dep58[] = { - 16, 97, 213, 214, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - -}; - -static const unsigned short dep59[] = { - 12, 19, 20, 40, 41, 97, 158, 162, 175, 185, 213, 215, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, -}; - -static const unsigned short dep60[] = { - 17, 97, 216, 217, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - -}; - -static const unsigned short dep61[] = { - 13, 19, 20, 40, 41, 97, 158, 162, 175, 185, 216, 218, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, -}; - -static const unsigned short dep62[] = { - 18, 97, 219, 220, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, - -}; - -static const unsigned short dep63[] = { - 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 219, 221, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, - 18764, 18766, -}; - -static const unsigned short dep64[] = { - 97, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, -}; - -static const unsigned short dep65[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, - 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, -}; - -static const unsigned short dep66[] = { - 11, 97, 206, 282, -}; - -static const unsigned short dep67[] = { - 11, 40, 41, 97, 158, 162, 175, 185, 206, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep68[] = { - 11, 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep69[] = { - 12, 97, 207, 282, -}; - -static const unsigned short dep70[] = { - 11, 40, 41, 97, 158, 162, 175, 185, 207, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep71[] = { - 13, 97, 208, 282, -}; - -static const unsigned short dep72[] = { - 11, 40, 41, 97, 158, 162, 175, 185, 208, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep73[] = { - 14, 97, 209, 282, -}; - -static const unsigned short dep74[] = { - 11, 40, 41, 97, 158, 162, 175, 185, 209, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep75[] = { - 15, 97, 211, 212, 282, -}; - -static const unsigned short dep76[] = { - 40, 41, 97, 158, 162, 175, 185, 211, 212, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep77[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep78[] = { - 16, 97, 214, 215, 282, -}; - -static const unsigned short dep79[] = { - 40, 41, 97, 158, 162, 175, 185, 214, 215, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep80[] = { - 17, 97, 217, 218, 282, -}; - -static const unsigned short dep81[] = { - 40, 41, 97, 158, 162, 175, 185, 217, 218, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep82[] = { - 18, 97, 220, 221, 282, -}; - -static const unsigned short dep83[] = { - 40, 41, 97, 158, 162, 175, 185, 220, 221, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep84[] = { - 15, 19, 20, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2166, 2167, - 2170, 2173, 4135, -}; - -static const unsigned short dep85[] = { - 15, 16, 19, 20, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2166, - 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep86[] = { - 15, 17, 19, 20, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2166, - 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep87[] = { - 15, 18, 19, 20, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2166, - 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep88[] = { - 15, 97, 210, 211, 282, -}; - -static const unsigned short dep89[] = { - 11, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 282, 2166, 2167, 2170, - 2173, 4135, -}; - -static const unsigned short dep90[] = { - 15, 16, 17, 18, 97, 210, 211, 213, 214, 216, 217, 219, 220, 282, -}; - -static const unsigned short dep91[] = { - 11, 12, 13, 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 213, 215, - 216, 218, 219, 221, 282, 2166, 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep92[] = { - 16, 97, 213, 214, 282, -}; - -static const unsigned short dep93[] = { - 12, 19, 20, 40, 41, 97, 158, 162, 175, 185, 213, 215, 282, 2166, 2167, 2170, - 2173, 4135, -}; - -static const unsigned short dep94[] = { - 17, 97, 216, 217, 282, -}; - -static const unsigned short dep95[] = { - 13, 19, 20, 40, 41, 97, 158, 162, 175, 185, 216, 218, 282, 2166, 2167, 2170, - 2173, 4135, -}; - -static const unsigned short dep96[] = { - 18, 97, 219, 220, 282, -}; - -static const unsigned short dep97[] = { - 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 219, 221, 282, 2166, 2167, 2170, - 2173, 4135, -}; - -static const unsigned short dep98[] = { - 15, 97, 210, 211, 282, 2166, 2167, 2168, 2170, 2171, 2173, 2174, 2344, 2347, - 2348, 2351, 2352, 2355, 2356, -}; - -static const unsigned short dep99[] = { - 11, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2344, 2347, 2348, 2351, 2352, 2355, 2356, 4135, 16528, - 16530, 16531, 16533, -}; - -static const unsigned short dep100[] = { - 15, 16, 17, 18, 97, 210, 211, 213, 214, 216, 217, 219, 220, 282, 2166, 2167, - 2168, 2170, 2171, 2173, 2174, 2344, 2347, 2348, 2351, 2352, 2355, 2356, -}; - -static const unsigned short dep101[] = { - 11, 12, 13, 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 213, 215, - 216, 218, 219, 221, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, 2344, 2347, - 2348, 2351, 2352, 2355, 2356, 4135, 16528, 16530, 16531, 16533, -}; - -static const unsigned short dep102[] = { - 16, 97, 213, 214, 282, 2166, 2167, 2168, 2170, 2171, 2173, 2174, 2344, 2347, - 2348, 2351, 2352, 2355, 2356, -}; - -static const unsigned short dep103[] = { - 12, 19, 20, 40, 41, 97, 158, 162, 175, 185, 213, 215, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2344, 2347, 2348, 2351, 2352, 2355, 2356, 4135, 16528, - 16530, 16531, 16533, -}; - -static const unsigned short dep104[] = { - 17, 97, 216, 217, 282, 2166, 2167, 2168, 2170, 2171, 2173, 2174, 2344, 2347, - 2348, 2351, 2352, 2355, 2356, -}; - -static const unsigned short dep105[] = { - 13, 19, 20, 40, 41, 97, 158, 162, 175, 185, 216, 218, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2344, 2347, 2348, 2351, 2352, 2355, 2356, 4135, 16528, - 16530, 16531, 16533, -}; - -static const unsigned short dep106[] = { - 18, 97, 219, 220, 282, 2166, 2167, 2168, 2170, 2171, 2173, 2174, 2344, 2347, - 2348, 2351, 2352, 2355, 2356, -}; - -static const unsigned short dep107[] = { - 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 219, 221, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 2344, 2347, 2348, 2351, 2352, 2355, 2356, 4135, 16528, - 16530, 16531, 16533, -}; - -static const unsigned short dep108[] = { - 15, 97, 210, 211, 282, 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, - 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep109[] = { - 11, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 4135, 16528, 16530, 16531, 16533, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep110[] = { - 15, 16, 17, 18, 97, 210, 211, 213, 214, 216, 217, 219, 220, 282, 22646, 22647, - 22648, 22650, 22651, 22653, 22654, 22824, 22827, 22828, 22831, 22832, 22835, - 22836, -}; - -static const unsigned short dep111[] = { - 11, 12, 13, 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 210, 212, 213, 215, - 216, 218, 219, 221, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, 4135, 16528, - 16530, 16531, 16533, 22824, 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep112[] = { - 16, 97, 213, 214, 282, 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, - 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep113[] = { - 12, 19, 20, 40, 41, 97, 158, 162, 175, 185, 213, 215, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 4135, 16528, 16530, 16531, 16533, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep114[] = { - 17, 97, 216, 217, 282, 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, - 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep115[] = { - 13, 19, 20, 40, 41, 97, 158, 162, 175, 185, 216, 218, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 4135, 16528, 16530, 16531, 16533, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep116[] = { - 18, 97, 219, 220, 282, 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, - 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep117[] = { - 14, 19, 20, 40, 41, 97, 158, 162, 175, 185, 219, 221, 282, 2135, 2136, 2137, - 2166, 2167, 2170, 2173, 4135, 16528, 16530, 16531, 16533, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep118[] = { - 97, 282, 2166, 2167, 2168, 2170, 2171, 2173, 2174, 2344, 2347, 2348, 2351, - 2352, 2355, 2356, -}; - -static const unsigned short dep119[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, - 2344, 2347, 2348, 2351, 2352, 2355, 2356, 4135, 16528, 16530, 16531, 16533, - -}; - -static const unsigned short dep120[] = { - 97, 282, 22646, 22647, 22648, 22650, 22651, 22653, 22654, 22824, 22827, 22828, - 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep121[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, - 4135, 16528, 16530, 16531, 16533, 22824, 22827, 22828, 22831, 22832, 22835, - 22836, -}; - -static const unsigned short dep122[] = { - 19, 20, 40, 41, 97, 158, 162, 175, 185, 282, 2135, 2136, 2137, 2166, 2167, - 2170, 2173, 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, - -}; - -static const unsigned short dep123[] = { - 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2138, 2139, 2140, 2166, - 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep124[] = { - 97, 282, 2083, 2084, 2286, 2287, -}; - -static const unsigned short dep125[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2285, 2287, 4135, 20616, -}; - -static const unsigned short dep126[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2082, 2084, 2166, 2167, 2170, 2173, 2327, - 4135, 20616, -}; - -static const unsigned short dep127[] = { - 97, 282, 14455, 14457, 14458, 14460, 14461, 14463, 14635, 14636, 14639, 14640, - 14643, 14644, -}; - -static const unsigned short dep128[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 4135, 14635, 14636, - 14639, 14640, 14643, 14644, 20616, 24694, 24695, 24698, 24701, -}; - -static const unsigned short dep129[] = { - 97, 122, 124, 125, 127, 282, 303, 304, 307, 308, -}; - -static const unsigned short dep130[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 303, 304, 307, 308, 4135, 24694, 24695, - 24698, 24701, -}; - -static const unsigned short dep131[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 2327, 4135, 20616, - -}; - -static const unsigned short dep132[] = { - 40, 41, 97, 119, 122, 125, 158, 162, 175, 185, 282, 2327, 4135, 20616, 24694, - -}; - -static const unsigned short dep133[] = { - 6, 24, 26, 27, 97, 201, 227, 230, 282, 2081, 2284, -}; - -static const unsigned short dep134[] = { - 40, 41, 97, 158, 162, 175, 185, 201, 227, 229, 282, 2138, 2139, 2140, 2166, - 2167, 2170, 2173, 2284, 4135, 20616, -}; - -static const unsigned short dep135[] = { - 6, 24, 25, 26, 40, 41, 97, 158, 162, 175, 185, 282, 2081, 2166, 2167, 2170, - 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep136[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 2344, 2347, 2348, - 2351, 2352, 2355, 2356, 4135, -}; - -static const unsigned short dep137[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 4135, 22824, - 22827, 22828, 22831, 22832, 22835, 22836, -}; - -static const unsigned short dep138[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 2344, 2345, 2348, - 2349, 2352, 2353, 2356, 4135, -}; - -static const unsigned short dep139[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 2344, 2346, 2347, - 2350, 2351, 2354, 2355, 4135, -}; - -static const unsigned short dep140[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2166, 2167, 2170, 2173, 2344, 2345, 2346, - 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 4135, -}; - -static const unsigned short dep141[] = { - 0, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2166, 2167, 2170, 2173, - 4135, -}; - -static const unsigned short dep142[] = { - 0, 97, 195, 282, -}; - -static const unsigned short dep143[] = { - 0, 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 195, 282, 2166, 2167, 2170, - 2173, 4135, -}; - -static const unsigned short dep144[] = { - 40, 41, 97, 158, 162, 175, 185, 195, 282, 2166, 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep145[] = { - 2, 28, 97, 197, 231, 282, 28866, 29018, -}; - -static const unsigned short dep146[] = { - 1, 2, 28, 29, 97, 158, 162, 175, 177, 178, 185, 197, 231, 282, 28866, 29018, - -}; - -static const unsigned short dep147[] = { - 1, 28, 29, 38, 40, 41, 97, 158, 162, 175, 177, 178, 185, 197, 231, 282, 4135, - 28866, 29018, -}; - -static const unsigned short dep148[] = { - 0, 40, 41, 97, 158, 162, 175, 185, 195, 282, 2166, 2167, 2170, 2173, 4135, - -}; - -static const unsigned short dep149[] = { - 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 28, 29, 30, 31, 97, 196, 197, 198, 199, 200, 202, 203, 204, 205, 206, 207, - 208, 209, 211, 212, 214, 215, 217, 218, 220, 221, 222, 223, 224, 225, 231, - 232, 233, 234, 282, 2071, 2081, 2274, 2284, 28866, 29018, -}; - -static const unsigned short dep150[] = { - 29, 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 196, 197, 198, 199, - 200, 202, 203, 204, 205, 206, 207, 208, 209, 211, 212, 214, 215, 217, 218, - 220, 221, 222, 223, 224, 225, 231, 232, 233, 234, 282, 2138, 2139, 2140, 2166, - 2167, 2170, 2173, 2274, 2284, 4135, 20616, 28866, 29018, -}; - -static const unsigned short dep151[] = { - 97, 282, 14464, 14466, 14468, 14470, 14505, 14506, 14525, 14645, 14646, 14666, - 14667, 14669, 14670, 14679, -}; - -static const unsigned short dep152[] = { - 40, 41, 97, 158, 162, 175, 183, 184, 185, 282, 2166, 2167, 2170, 2173, 4135, - 14645, 14646, 14666, 14667, 14669, 14670, 14679, -}; - -static const unsigned short dep153[] = { - 14464, 14466, 14468, 14470, 14505, 14506, 14525, 14645, 14646, 14666, 14667, - 14669, 14670, 14679, -}; - -static const unsigned short dep154[] = { - 183, 184, 14645, 14646, 14666, 14667, 14669, 14670, 14679, -}; - -static const unsigned short dep155[] = { - 97, 282, 14465, 14466, 14469, 14470, 14480, 14481, 14483, 14484, 14486, 14487, - 14489, 14490, 14493, 14495, 14496, 14505, 14506, 14507, 14508, 14510, 14515, - 14516, 14518, 14519, 14525, 14645, 14646, 14652, 14653, 14654, 14655, 14657, - 14659, 14666, 14667, 14669, 14670, 14671, 14672, 14675, 14676, 14679, -}; - -static const unsigned short dep156[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2166, 2167, 2170, - 2173, 4135, 14645, 14646, 14652, 14653, 14654, 14655, 14657, 14659, 14666, - 14667, 14669, 14670, 14671, 14672, 14675, 14676, 14679, 34888, -}; - -static const unsigned short dep157[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2166, 2167, 2170, - 2173, 4135, 14645, 14646, 14652, 14653, 14654, 14655, 14657, 14659, 14666, - 14667, 14669, 14670, 14671, 14672, 14675, 14676, 14679, -}; - -static const unsigned short dep158[] = { - 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 28, 29, 30, 31, 40, 41, 97, 137, 138, 158, 162, 175, 180, 181, 185, 190, 191, - 282, 2071, 2081, 2166, 2167, 2170, 2173, 2327, 4135, 20616, 28866, -}; - -static const unsigned short dep159[] = { - 43, 44, 45, 46, 47, 48, 49, 50, 52, 53, 54, 55, 56, 57, 58, 60, 61, 62, 63, - 64, 65, 67, 69, 70, 71, 72, 73, 94, 96, 97, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 255, 256, 257, 258, 259, 261, 263, 264, 265, 281, - 282, 2116, 2310, -}; - -static const unsigned short dep160[] = { - 40, 41, 96, 97, 137, 138, 158, 160, 161, 162, 175, 185, 190, 191, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 255, 256, 257, 258, 259, 261, - 263, 264, 265, 281, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2310, 4135, - 20616, -}; - -static const unsigned short dep161[] = { - 59, 95, 97, 254, 281, 282, 2140, 2327, -}; - -static const unsigned short dep162[] = { - 40, 41, 43, 44, 46, 48, 49, 51, 52, 53, 54, 56, 57, 60, 61, 63, 64, 65, 66, - 67, 69, 70, 71, 94, 95, 97, 137, 138, 158, 160, 161, 162, 175, 185, 190, 191, - 254, 281, 282, 2107, 2116, 2166, 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep163[] = { - 2, 28, 41, 97, 197, 231, 241, 282, 2140, 2327, 28866, 29018, -}; - -static const unsigned short dep164[] = { - 2, 25, 26, 28, 29, 38, 40, 41, 97, 158, 162, 175, 177, 178, 185, 197, 231, - 241, 282, 2327, 4135, 20616, 28866, 29018, -}; - -static const unsigned short dep165[] = { - 97, 129, 130, 133, 134, 140, 141, 144, 145, 147, 148, 150, 151, 153, 154, - 157, 159, 160, 165, 166, 169, 170, 171, 172, 174, 176, 177, 179, 180, 182, - 183, 186, 187, 189, 282, 309, 310, 314, 316, 317, 318, 319, 321, 323, 327, - 330, 331, 333, 334, 335, 336, 338, 339, 340, 342, 343, -}; - -static const unsigned short dep166[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 309, 310, 314, 316, - 317, 318, 319, 321, 323, 327, 330, 331, 333, 334, 335, 336, 338, 339, 340, - 342, 343, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, 34888, -}; - -static const unsigned short dep167[] = { - 97, 128, 130, 132, 134, 169, 170, 189, 282, 309, 310, 330, 331, 333, 334, - 343, -}; - -static const unsigned short dep168[] = { - 40, 41, 97, 158, 162, 175, 183, 184, 185, 282, 309, 310, 330, 331, 333, 334, - 343, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep169[] = { - 40, 41, 97, 130, 131, 134, 135, 137, 138, 141, 142, 145, 146, 148, 149, 151, - 152, 154, 155, 157, 158, 159, 161, 162, 164, 165, 167, 168, 169, 170, 172, - 173, 174, 175, 176, 178, 179, 181, 182, 184, 185, 187, 188, 189, 190, 191, - 282, 2166, 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep170[] = { - 40, 41, 97, 130, 131, 134, 135, 158, 162, 169, 170, 175, 185, 189, 282, 2166, - 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep171[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 111, 137, 138, 153, 155, 158, 162, 171, 173, - 175, 185, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep172[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 111, 137, 138, 139, 140, 142, 143, 153, 155, - 158, 162, 171, 173, 175, 185, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, - 2173, 4135, 20616, -}; - -static const unsigned short dep173[] = { - 77, 78, 97, 101, 102, 269, 270, 282, 284, 285, -}; - -static const unsigned short dep174[] = { - 40, 41, 47, 62, 78, 80, 86, 97, 99, 102, 137, 138, 158, 160, 161, 162, 175, - 185, 190, 191, 192, 269, 270, 282, 284, 285, 2138, 2139, 2140, 2166, 2167, - 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep175[] = { - 40, 41, 47, 62, 78, 80, 97, 99, 102, 104, 106, 137, 138, 158, 160, 161, 162, - 175, 185, 190, 191, 192, 269, 270, 282, 284, 285, 2138, 2139, 2140, 2166, - 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep176[] = { - 97, 282, 12480, 12481, 12633, -}; - -static const unsigned short dep177[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 12633, 20616, -}; - -static const unsigned short dep178[] = { - 97, 282, 6219, 6220, 6411, -}; - -static const unsigned short dep179[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 6411, 20616, -}; - -static const unsigned short dep180[] = { - 97, 282, 6237, 6424, -}; - -static const unsigned short dep181[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 6424, 20616, -}; - -static const unsigned short dep182[] = { - 97, 282, 6255, 6256, 6257, 6258, 6435, 6437, 8484, -}; - -static const unsigned short dep183[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 6258, 6436, 6437, 8304, 8483, 20616, -}; - -static const unsigned short dep184[] = { - 97, 282, 6259, 6260, 6438, -}; - -static const unsigned short dep185[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 6438, 20616, -}; - -static const unsigned short dep186[] = { - 97, 282, 6261, 6439, -}; - -static const unsigned short dep187[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 6439, 20616, -}; - -static const unsigned short dep188[] = { - 97, 282, 10350, 10530, -}; - -static const unsigned short dep189[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 10530, 20616, -}; - -static const unsigned short dep190[] = { - 77, 78, 82, 83, 97, 101, 102, 269, 270, 272, 273, 282, 284, 285, -}; - -static const unsigned short dep191[] = { - 40, 41, 47, 62, 78, 80, 83, 86, 97, 99, 102, 137, 138, 158, 160, 161, 162, - 175, 185, 190, 191, 192, 269, 270, 272, 274, 282, 284, 285, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep192[] = { - 77, 78, 97, 101, 102, 104, 105, 269, 270, 282, 284, 285, 286, 287, -}; - -static const unsigned short dep193[] = { - 40, 41, 47, 62, 78, 80, 97, 99, 102, 104, 106, 137, 138, 158, 160, 161, 162, - 175, 185, 190, 191, 192, 269, 270, 282, 284, 285, 286, 287, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep194[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 12481, 20616, -}; - -static const unsigned short dep195[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 6219, 20616, -}; - -static const unsigned short dep196[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 6237, 20616, -}; - -static const unsigned short dep197[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 6257, 8303, 20616, -}; - -static const unsigned short dep198[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 6259, 20616, -}; - -static const unsigned short dep199[] = { - 40, 41, 97, 137, 138, 158, 162, 175, 183, 184, 185, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 6260, 6261, 20616, -}; - -static const unsigned short dep200[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2327, 4135, 10350, 20616, -}; - -static const unsigned short dep201[] = { - 40, 41, 97, 158, 162, 175, 185, 190, 191, 282, 2138, 2139, 2140, 2166, 2167, - 2170, 2173, 2327, 4135, 6186, 20616, -}; - -static const unsigned short dep202[] = { - 77, 79, 80, 97, 98, 99, 100, 268, 269, 282, 283, 284, -}; - -static const unsigned short dep203[] = { - 40, 41, 78, 79, 83, 85, 97, 100, 102, 104, 107, 137, 138, 158, 162, 175, 185, - 190, 191, 192, 268, 270, 282, 283, 285, 2138, 2139, 2140, 2166, 2167, 2170, - 2173, 4135, 20616, -}; - -static const unsigned short dep204[] = { - 77, 79, 80, 81, 97, 98, 99, 100, 103, 268, 269, 271, 282, 283, 284, -}; - -static const unsigned short dep205[] = { - 40, 41, 78, 79, 81, 83, 85, 97, 100, 102, 103, 104, 107, 137, 138, 158, 162, - 175, 185, 190, 191, 192, 268, 270, 271, 282, 283, 285, 2138, 2139, 2140, 2166, - 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep206[] = { - 77, 79, 80, 84, 85, 86, 97, 98, 99, 100, 268, 269, 274, 275, 282, 283, 284, - -}; - -static const unsigned short dep207[] = { - 40, 41, 78, 79, 83, 85, 97, 100, 102, 137, 138, 158, 162, 175, 185, 190, 191, - 192, 268, 270, 273, 275, 282, 283, 285, 2138, 2139, 2140, 2166, 2167, 2170, - 2173, 4135, 20616, -}; - -static const unsigned short dep208[] = { - 77, 79, 80, 97, 98, 99, 100, 106, 107, 108, 268, 269, 282, 283, 284, 287, - 288, -}; - -static const unsigned short dep209[] = { - 40, 41, 78, 79, 97, 100, 102, 104, 107, 137, 138, 158, 162, 175, 185, 190, - 191, 192, 268, 270, 282, 283, 285, 286, 288, 2138, 2139, 2140, 2166, 2167, - 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep210[] = { - 40, 41, 46, 70, 97, 158, 162, 175, 185, 190, 191, 192, 282, 2138, 2139, 2140, - 2166, 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep211[] = { - 40, 41, 97, 158, 162, 175, 185, 190, 191, 192, 282, 2138, 2139, 2140, 2166, - 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep212[] = { - 40, 41, 70, 77, 82, 84, 97, 137, 138, 153, 155, 158, 162, 175, 185, 190, 191, - 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep213[] = { - 40, 41, 97, 158, 162, 164, 175, 185, 186, 188, 282, 2135, 2136, 2137, 2138, - 2139, 2140, 2166, 2167, 2170, 2173, 4135, 16528, 16530, 16531, 16533, 20616, - -}; - -static const unsigned short dep214[] = { - 40, 41, 70, 77, 82, 84, 97, 153, 155, 158, 162, 175, 185, 192, 282, 2138, - 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep215[] = { - 40, 41, 78, 79, 97, 100, 137, 138, 158, 162, 175, 185, 190, 191, 268, 270, - 282, 283, 285, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, -}; - -static const unsigned short dep216[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep217[] = { - 5, 97, 200, 282, 2140, 2327, -}; - -static const unsigned short dep218[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 200, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, 20616, - -}; - -static const unsigned short dep219[] = { - 40, 41, 44, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 156, 158, 162, 171, 173, 175, 185, - 190, 191, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep220[] = { - 0, 97, 195, 282, 2140, 2327, -}; - -static const unsigned short dep221[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, - 191, 192, 195, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep222[] = { - 0, 40, 41, 44, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, - 135, 137, 138, 139, 140, 142, 143, 153, 155, 156, 158, 162, 171, 173, 175, - 185, 190, 191, 192, 195, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, - 4135, 20616, -}; - -static const unsigned short dep223[] = { - 31, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, - 191, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, 20616, - -}; - -static const unsigned short dep224[] = { - 0, 97, 195, 282, 2327, 26715, -}; - -static const unsigned short dep225[] = { - 0, 97, 109, 195, 282, 289, -}; - -static const unsigned short dep226[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, - -}; - -static const unsigned short dep227[] = { - 0, 5, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, - -}; - -static const unsigned short dep228[] = { - 0, 31, 97, 109, 195, 234, 282, 289, -}; - -static const unsigned short dep229[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 234, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 4135, 20616, - -}; - -static const unsigned short dep230[] = { - 0, 97, 109, 195, 282, 289, 2140, 2327, -}; - -static const unsigned short dep231[] = { - 0, 3, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, - 191, 192, 195, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep232[] = { - 0, 3, 5, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, - 135, 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, - 190, 191, 192, 195, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, - 4135, 20616, -}; - -static const unsigned short dep233[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, - 191, 192, 195, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep234[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2135, 2136, 2137, 2166, 2167, 2170, 2173, - 2327, 4135, 16528, 16530, 16531, 16533, 20616, -}; - -static const unsigned short dep235[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep236[] = { - 0, 31, 97, 109, 195, 234, 282, 289, 2140, 2327, -}; - -static const unsigned short dep237[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 234, 282, 289, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2327, 4135, - 20616, -}; - -static const unsigned short dep238[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, 4135, 16528, 16530, - 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep239[] = { - 40, 41, 44, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 156, 158, 162, 171, 173, 175, 185, - 190, 191, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, 4135, - 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep240[] = { - 0, 97, 195, 282, 2136, 2325, 18601, 18602, 18761, 18762, 18764, 18765, -}; - -static const unsigned short dep241[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, - 191, 192, 195, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, 4135, - 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep242[] = { - 0, 40, 41, 44, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, - 135, 137, 138, 139, 140, 142, 143, 153, 155, 156, 158, 162, 171, 173, 175, - 185, 190, 191, 192, 195, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, - 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep243[] = { - 0, 97, 195, 282, 2137, 2325, 18601, 18602, 18761, 18762, 18764, 18765, -}; - -static const unsigned short dep244[] = { - 97, 282, 2136, 2140, 2325, 2327, 18601, 18602, 18761, 18762, 18764, 18765, - -}; - -static const unsigned short dep245[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, 2327, 4135, 16528, - 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep246[] = { - 40, 41, 44, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 156, 158, 162, 171, 173, 175, 185, - 190, 191, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, 2327, - 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep247[] = { - 0, 97, 195, 282, 2136, 2140, 2325, 2327, 18601, 18602, 18761, 18762, 18764, - 18765, -}; - -static const unsigned short dep248[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, 135, - 137, 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, - 191, 192, 195, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, 2327, - 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, -}; - -static const unsigned short dep249[] = { - 0, 40, 41, 44, 70, 76, 77, 82, 84, 97, 109, 111, 128, 129, 131, 132, 133, - 135, 137, 138, 139, 140, 142, 143, 153, 155, 156, 158, 162, 171, 173, 175, - 185, 190, 191, 192, 195, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, 2325, - 2327, 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, - -}; - -static const unsigned short dep250[] = { - 0, 97, 195, 282, 2137, 2140, 2325, 2327, 18601, 18602, 18761, 18762, 18764, - 18765, -}; - -static const unsigned short dep251[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 282, 289, 2135, 2136, 2137, 2138, 2139, 2140, 2166, 2167, 2170, - 2173, 4135, 16528, 16530, 16531, 16533, 20616, -}; - -static const unsigned short dep252[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 137, 138, 139, 140, 142, 143, 153, 155, 156, - 158, 162, 171, 173, 175, 185, 192, 282, 2166, 2167, 2170, 2173, 4135, -}; - -static const unsigned short dep253[] = { - 40, 41, 70, 76, 77, 82, 84, 97, 137, 138, 139, 140, 142, 143, 153, 155, 156, - 158, 162, 171, 173, 175, 185, 192, 282, 2138, 2139, 2140, 2166, 2167, 2170, - 2173, 2327, 4135, 20616, -}; - -static const unsigned short dep254[] = { - 40, 41, 97, 158, 162, 175, 185, 282, 2138, 2139, 2140, 2166, 2167, 2170, 2173, - 2325, 4135, 16528, 16530, 16531, 16533, 18761, 18763, 18764, 18766, 20616, - -}; - -static const unsigned short dep255[] = { - 0, 40, 41, 70, 76, 77, 82, 84, 97, 111, 128, 129, 131, 132, 133, 135, 137, - 138, 139, 140, 142, 143, 153, 155, 158, 162, 171, 173, 175, 185, 190, 191, - 192, 195, 282, 289, 2135, 2136, 2137, 2138, 2139, 2140, 2166, 2167, 2170, - 2173, 2327, 4135, 16528, 16530, 16531, 16533, 20616, -}; - -static const unsigned short dep256[] = { - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 24, 26, 27, 28, 29, 30, 31, 97, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 211, 212, 214, 215, 217, 218, 220, 221, 222, - 223, 224, 225, 227, 230, 231, 232, 233, 234, 282, 2071, 2081, 2140, 2274, - 2284, 2327, 28866, 29018, -}; - -static const unsigned short dep257[] = { - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 24, 25, 26, 28, 29, 30, 31, 40, 41, 97, 137, 138, 158, 162, 175, 180, - 181, 185, 190, 191, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 211, 212, 214, 215, 217, 218, 220, 221, 222, 223, 224, 225, - 227, 229, 231, 232, 233, 234, 282, 2071, 2081, 2138, 2139, 2140, 2166, 2167, - 2170, 2173, 2274, 2284, 2327, 4135, 20616, 28866, 29018, -}; - -#define NELS(X) (sizeof(X)/sizeof(X[0])) -static const struct ia64_opcode_dependency -op_dependencies[] = { - { NELS(dep1), dep1, NELS(dep0), dep0, }, - { NELS(dep3), dep3, NELS(dep2), dep2, }, - { NELS(dep5), dep5, NELS(dep4), dep4, }, - { NELS(dep7), dep7, NELS(dep6), dep6, }, - { NELS(dep9), dep9, NELS(dep8), dep8, }, - { NELS(dep11), dep11, NELS(dep10), dep10, }, - { NELS(dep13), dep13, NELS(dep12), dep12, }, - { NELS(dep15), dep15, NELS(dep14), dep14, }, - { NELS(dep17), dep17, NELS(dep16), dep16, }, - { NELS(dep19), dep19, NELS(dep18), dep18, }, - { NELS(dep21), dep21, NELS(dep20), dep20, }, - { NELS(dep23), dep23, NELS(dep22), dep22, }, - { NELS(dep25), dep25, NELS(dep24), dep24, }, - { NELS(dep27), dep27, NELS(dep26), dep26, }, - { NELS(dep29), dep29, NELS(dep28), dep28, }, - { NELS(dep30), dep30, NELS(dep12), dep12, }, - { NELS(dep32), dep32, NELS(dep31), dep31, }, - { NELS(dep34), dep34, NELS(dep33), dep33, }, - { NELS(dep35), dep35, NELS(dep12), dep12, }, - { NELS(dep37), dep37, NELS(dep36), dep36, }, - { NELS(dep39), dep39, NELS(dep38), dep38, }, - { NELS(dep41), dep41, NELS(dep40), dep40, }, - { NELS(dep42), dep42, NELS(dep31), dep31, }, - { NELS(dep43), dep43, NELS(dep33), dep33, }, - { NELS(dep45), dep45, NELS(dep44), dep44, }, - { NELS(dep47), dep47, NELS(dep46), dep46, }, - { NELS(dep49), dep49, NELS(dep48), dep48, }, - { NELS(dep51), dep51, NELS(dep50), dep50, }, - { NELS(dep53), dep53, NELS(dep52), dep52, }, - { NELS(dep55), dep55, NELS(dep54), dep54, }, - { NELS(dep57), dep57, NELS(dep56), dep56, }, - { NELS(dep59), dep59, NELS(dep58), dep58, }, - { NELS(dep61), dep61, NELS(dep60), dep60, }, - { NELS(dep63), dep63, NELS(dep62), dep62, }, - { NELS(dep65), dep65, NELS(dep64), dep64, }, - { NELS(dep67), dep67, NELS(dep66), dep66, }, - { NELS(dep68), dep68, NELS(dep33), dep33, }, - { NELS(dep70), dep70, NELS(dep69), dep69, }, - { NELS(dep72), dep72, NELS(dep71), dep71, }, - { NELS(dep74), dep74, NELS(dep73), dep73, }, - { NELS(dep76), dep76, NELS(dep75), dep75, }, - { NELS(dep77), dep77, NELS(dep33), dep33, }, - { NELS(dep79), dep79, NELS(dep78), dep78, }, - { NELS(dep81), dep81, NELS(dep80), dep80, }, - { NELS(dep83), dep83, NELS(dep82), dep82, }, - { NELS(dep84), dep84, NELS(dep33), dep33, }, - { NELS(dep85), dep85, NELS(dep33), dep33, }, - { NELS(dep86), dep86, NELS(dep33), dep33, }, - { NELS(dep87), dep87, NELS(dep33), dep33, }, - { NELS(dep89), dep89, NELS(dep88), dep88, }, - { NELS(dep91), dep91, NELS(dep90), dep90, }, - { NELS(dep93), dep93, NELS(dep92), dep92, }, - { NELS(dep95), dep95, NELS(dep94), dep94, }, - { NELS(dep97), dep97, NELS(dep96), dep96, }, - { NELS(dep99), dep99, NELS(dep98), dep98, }, - { NELS(dep101), dep101, NELS(dep100), dep100, }, - { NELS(dep103), dep103, NELS(dep102), dep102, }, - { NELS(dep105), dep105, NELS(dep104), dep104, }, - { NELS(dep107), dep107, NELS(dep106), dep106, }, - { NELS(dep109), dep109, NELS(dep108), dep108, }, - { NELS(dep111), dep111, NELS(dep110), dep110, }, - { NELS(dep113), dep113, NELS(dep112), dep112, }, - { NELS(dep115), dep115, NELS(dep114), dep114, }, - { NELS(dep117), dep117, NELS(dep116), dep116, }, - { NELS(dep119), dep119, NELS(dep118), dep118, }, - { NELS(dep121), dep121, NELS(dep120), dep120, }, - { NELS(dep122), dep122, NELS(dep64), dep64, }, - { NELS(dep123), dep123, NELS(dep33), dep33, }, - { NELS(dep125), dep125, NELS(dep124), dep124, }, - { NELS(dep126), dep126, NELS(dep0), dep0, }, - { NELS(dep128), dep128, NELS(dep127), dep127, }, - { NELS(dep130), dep130, NELS(dep129), dep129, }, - { NELS(dep131), dep131, NELS(dep0), dep0, }, - { NELS(dep132), dep132, NELS(dep0), dep0, }, - { NELS(dep134), dep134, NELS(dep133), dep133, }, - { NELS(dep135), dep135, NELS(dep0), dep0, }, - { NELS(dep136), dep136, NELS(dep2), dep2, }, - { NELS(dep137), dep137, NELS(dep4), dep4, }, - { NELS(dep138), dep138, NELS(dep6), dep6, }, - { NELS(dep139), dep139, NELS(dep8), dep8, }, - { NELS(dep140), dep140, NELS(dep10), dep10, }, - { NELS(dep141), dep141, NELS(dep33), dep33, }, - { NELS(dep143), dep143, NELS(dep142), dep142, }, - { NELS(dep144), dep144, NELS(dep142), dep142, }, - { NELS(dep146), dep146, NELS(dep145), dep145, }, - { NELS(dep147), dep147, NELS(dep145), dep145, }, - { NELS(dep148), dep148, NELS(dep142), dep142, }, - { NELS(dep150), dep150, NELS(dep149), dep149, }, - { NELS(dep152), dep152, NELS(dep151), dep151, }, - { NELS(dep154), dep154, NELS(dep153), dep153, }, - { NELS(dep156), dep156, NELS(dep155), dep155, }, - { NELS(dep157), dep157, NELS(dep155), dep155, }, - { NELS(dep158), dep158, NELS(dep0), dep0, }, - { NELS(dep160), dep160, NELS(dep159), dep159, }, - { NELS(dep162), dep162, NELS(dep161), dep161, }, - { NELS(dep164), dep164, NELS(dep163), dep163, }, - { NELS(dep166), dep166, NELS(dep165), dep165, }, - { NELS(dep168), dep168, NELS(dep167), dep167, }, - { NELS(dep169), dep169, NELS(dep0), dep0, }, - { NELS(dep170), dep170, NELS(dep0), dep0, }, - { NELS(dep171), dep171, NELS(dep0), dep0, }, - { NELS(dep172), dep172, NELS(dep33), dep33, }, - { NELS(dep174), dep174, NELS(dep173), dep173, }, - { NELS(dep175), dep175, NELS(dep173), dep173, }, - { NELS(dep177), dep177, NELS(dep176), dep176, }, - { NELS(dep179), dep179, NELS(dep178), dep178, }, - { NELS(dep181), dep181, NELS(dep180), dep180, }, - { NELS(dep183), dep183, NELS(dep182), dep182, }, - { NELS(dep185), dep185, NELS(dep184), dep184, }, - { NELS(dep187), dep187, NELS(dep186), dep186, }, - { NELS(dep189), dep189, NELS(dep188), dep188, }, - { NELS(dep191), dep191, NELS(dep190), dep190, }, - { NELS(dep193), dep193, NELS(dep192), dep192, }, - { NELS(dep194), dep194, NELS(dep0), dep0, }, - { NELS(dep195), dep195, NELS(dep0), dep0, }, - { NELS(dep196), dep196, NELS(dep0), dep0, }, - { NELS(dep197), dep197, NELS(dep0), dep0, }, - { NELS(dep198), dep198, NELS(dep0), dep0, }, - { NELS(dep199), dep199, NELS(dep0), dep0, }, - { NELS(dep200), dep200, NELS(dep0), dep0, }, - { NELS(dep201), dep201, NELS(dep0), dep0, }, - { NELS(dep203), dep203, NELS(dep202), dep202, }, - { NELS(dep205), dep205, NELS(dep204), dep204, }, - { NELS(dep207), dep207, NELS(dep206), dep206, }, - { NELS(dep209), dep209, NELS(dep208), dep208, }, - { NELS(dep210), dep210, NELS(dep0), dep0, }, - { NELS(dep211), dep211, NELS(dep0), dep0, }, - { NELS(dep212), dep212, NELS(dep0), dep0, }, - { NELS(dep213), dep213, NELS(dep33), dep33, }, - { NELS(dep214), dep214, NELS(dep33), dep33, }, - { NELS(dep215), dep215, NELS(dep202), dep202, }, - { NELS(dep216), dep216, NELS(dep0), dep0, }, - { NELS(dep218), dep218, NELS(dep217), dep217, }, - { NELS(dep219), dep219, NELS(dep0), dep0, }, - { NELS(dep221), dep221, NELS(dep220), dep220, }, - { NELS(dep222), dep222, NELS(dep220), dep220, }, - { NELS(dep223), dep223, NELS(dep0), dep0, }, - { NELS(dep221), dep221, NELS(dep224), dep224, }, - { NELS(dep226), dep226, NELS(dep225), dep225, }, - { NELS(dep227), dep227, NELS(dep225), dep225, }, - { NELS(dep229), dep229, NELS(dep228), dep228, }, - { NELS(dep231), dep231, NELS(dep230), dep230, }, - { NELS(dep232), dep232, NELS(dep230), dep230, }, - { NELS(dep233), dep233, NELS(dep230), dep230, }, - { NELS(dep234), dep234, NELS(dep0), dep0, }, - { NELS(dep235), dep235, NELS(dep230), dep230, }, - { NELS(dep237), dep237, NELS(dep236), dep236, }, - { NELS(dep238), dep238, NELS(dep64), dep64, }, - { NELS(dep239), dep239, NELS(dep64), dep64, }, - { NELS(dep241), dep241, NELS(dep240), dep240, }, - { NELS(dep242), dep242, NELS(dep240), dep240, }, - { NELS(dep241), dep241, NELS(dep243), dep243, }, - { NELS(dep245), dep245, NELS(dep244), dep244, }, - { NELS(dep246), dep246, NELS(dep244), dep244, }, - { NELS(dep248), dep248, NELS(dep247), dep247, }, - { NELS(dep249), dep249, NELS(dep247), dep247, }, - { NELS(dep248), dep248, NELS(dep250), dep250, }, - { NELS(dep251), dep251, NELS(dep225), dep225, }, - { NELS(dep252), dep252, NELS(dep33), dep33, }, - { NELS(dep253), dep253, NELS(dep0), dep0, }, - { NELS(dep254), dep254, NELS(dep64), dep64, }, - { NELS(dep255), dep255, NELS(dep230), dep230, }, - { 0, NULL, 0, NULL, }, - { NELS(dep257), dep257, NELS(dep256), dep256, }, -}; - -static const struct ia64_completer_table -completer_table[] = { - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 95 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 95 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 594, -1, 0, 1, 6 }, - { 0x0, 0x0, 0, 657, -1, 0, 1, 18 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 162 }, - { 0x0, 0x0, 0, 756, -1, 0, 1, 18 }, - { 0x0, 0x0, 0, 2198, -1, 0, 1, 10 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 9 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 13 }, - { 0x1, 0x1, 0, -1, -1, 13, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, 2406, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, 1140, -1, 0, 1, 129 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 45 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 84 }, - { 0x0, 0x0, 0, 2246, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 2473, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 2250, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, 2252, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 2482, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 2485, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 2507, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 2510, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 25 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 25 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 25 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 25 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 36 }, - { 0x0, 0x0, 0, 2518, -1, 0, 1, 30 }, - { 0x0, 0x0, 0, 1409, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 162 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 83 }, - { 0x0, 0x0, 0, 1457, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1466, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1475, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1477, -1, 0, 1, 132 }, - { 0x0, 0x0, 0, 1479, -1, 0, 1, 132 }, - { 0x0, 0x0, 0, 1488, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1497, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1506, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1515, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1524, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1533, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1543, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1553, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1563, -1, 0, 1, 131 }, - { 0x0, 0x0, 0, 1572, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1578, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1584, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1590, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1596, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1602, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1608, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1614, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1620, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1626, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1632, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1638, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1644, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1650, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1656, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1662, -1, 0, 1, 147 }, - { 0x0, 0x0, 0, 1668, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1674, -1, 0, 1, 152 }, - { 0x0, 0x0, 0, 1678, -1, 0, 1, 158 }, - { 0x0, 0x0, 0, 1682, -1, 0, 1, 159 }, - { 0x0, 0x0, 0, 1686, -1, 0, 1, 159 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 85 }, - { 0x0, 0x0, 0, 258, -1, 0, 1, 41 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 68 }, - { 0x1, 0x1, 0, 1166, -1, 20, 1, 68 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 69 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 70 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 70 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 71 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 72 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 73 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 93 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 94 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 96 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 97 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 98 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 99 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 104 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 105 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 106 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 107 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 108 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 109 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 110 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 113 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 114 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 115 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 116 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 117 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 118 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 119 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 120 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 163 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 163 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 163 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 72 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 162 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2858, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2859, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2210, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2211, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2873, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2874, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2875, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2876, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2877, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2860, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, 2861, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 11 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 91 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 89 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x1, 0x1, 0, -1, -1, 13, 1, 0 }, - { 0x0, 0x0, 0, 2879, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 90 }, - { 0x0, 0x0, 0, 1966, -1, 0, 1, 138 }, - { 0x0, 0x0, 0, 1968, -1, 0, 1, 145 }, - { 0x0, 0x0, 0, 1970, -1, 0, 1, 139 }, - { 0x0, 0x0, 0, 1972, -1, 0, 1, 139 }, - { 0x0, 0x0, 0, 1974, -1, 0, 1, 138 }, - { 0x0, 0x0, 0, 1976, -1, 0, 1, 145 }, - { 0x0, 0x0, 0, 1978, -1, 0, 1, 138 }, - { 0x0, 0x0, 0, 1980, -1, 0, 1, 145 }, - { 0x0, 0x0, 0, 1983, -1, 0, 1, 138 }, - { 0x0, 0x0, 0, 1986, -1, 0, 1, 145 }, - { 0x0, 0x0, 0, 1989, -1, 0, 1, 157 }, - { 0x0, 0x0, 0, 1990, -1, 0, 1, 161 }, - { 0x0, 0x0, 0, 1991, -1, 0, 1, 157 }, - { 0x0, 0x0, 0, 1992, -1, 0, 1, 161 }, - { 0x0, 0x0, 0, 1993, -1, 0, 1, 157 }, - { 0x0, 0x0, 0, 1994, -1, 0, 1, 161 }, - { 0x0, 0x0, 0, 1995, -1, 0, 1, 157 }, - { 0x0, 0x0, 0, 1996, -1, 0, 1, 161 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 88 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 127 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 125 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 127 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 126 }, - { 0x0, 0x0, 0, 1687, -1, 0, 1, 143 }, - { 0x0, 0x0, 0, 1688, -1, 0, 1, 143 }, - { 0x0, 0x0, 0, 1689, -1, 0, 1, 143 }, - { 0x0, 0x0, 0, 1690, -1, 0, 1, 143 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 1, 224, -1, 0, 1, 12 }, - { 0x0, 0x0, 1, 225, -1, 0, 1, 14 }, - { 0x1, 0x1, 2, -1, -1, 27, 1, 12 }, - { 0x1, 0x1, 2, -1, -1, 27, 1, 14 }, - { 0x0, 0x0, 3, -1, 1340, 0, 0, -1 }, - { 0x0, 0x0, 3, -1, 1341, 0, 0, -1 }, - { 0x1, 0x1, 3, 2749, 1450, 33, 1, 134 }, - { 0x1, 0x1, 3, 2750, 1459, 33, 1, 134 }, - { 0x1, 0x1, 3, 2751, 1468, 33, 1, 134 }, - { 0x1, 0x1, 3, 2752, 1481, 33, 1, 134 }, - { 0x1, 0x1, 3, 2753, 1490, 33, 1, 134 }, - { 0x1, 0x1, 3, 2754, 1499, 33, 1, 134 }, - { 0x1, 0x1, 3, 2755, 1508, 33, 1, 134 }, - { 0x1, 0x1, 3, 2756, 1517, 33, 1, 134 }, - { 0x1, 0x1, 3, 2757, 1526, 33, 1, 134 }, - { 0x1, 0x1, 3, 2758, 1535, 33, 1, 134 }, - { 0x1, 0x1, 3, 2759, 1545, 33, 1, 134 }, - { 0x1, 0x1, 3, 2760, 1555, 33, 1, 134 }, - { 0x1, 0x1, 3, 2761, 1568, 33, 1, 149 }, - { 0x1, 0x1, 3, 2762, 1574, 33, 1, 154 }, - { 0x1, 0x1, 3, 2763, 1580, 33, 1, 154 }, - { 0x1, 0x1, 3, 2764, 1586, 33, 1, 149 }, - { 0x1, 0x1, 3, 2765, 1592, 33, 1, 154 }, - { 0x1, 0x1, 3, 2766, 1598, 33, 1, 154 }, - { 0x1, 0x1, 3, 2767, 1604, 33, 1, 149 }, - { 0x1, 0x1, 3, 2768, 1610, 33, 1, 154 }, - { 0x1, 0x1, 3, 2769, 1616, 33, 1, 154 }, - { 0x1, 0x1, 3, 2770, 1622, 33, 1, 149 }, - { 0x1, 0x1, 3, 2771, 1628, 33, 1, 154 }, - { 0x1, 0x1, 3, 2772, 1634, 33, 1, 149 }, - { 0x1, 0x1, 3, 2773, 1640, 33, 1, 154 }, - { 0x1, 0x1, 3, 2774, 1646, 33, 1, 149 }, - { 0x1, 0x1, 3, 2775, 1652, 33, 1, 154 }, - { 0x1, 0x1, 3, 2776, 1658, 33, 1, 149 }, - { 0x1, 0x1, 3, 2777, 1664, 33, 1, 154 }, - { 0x1, 0x1, 3, 2778, 1670, 33, 1, 154 }, - { 0x1, 0x1, 3, -1, -1, 27, 1, 41 }, - { 0x0, 0x0, 4, 2212, 1425, 0, 1, 142 }, - { 0x0, 0x0, 4, 2213, 1427, 0, 1, 142 }, - { 0x0, 0x0, 4, 2214, 1429, 0, 1, 141 }, - { 0x0, 0x0, 4, 2215, 1431, 0, 1, 141 }, - { 0x0, 0x0, 4, 2216, 1433, 0, 1, 141 }, - { 0x0, 0x0, 4, 2217, 1435, 0, 1, 141 }, - { 0x0, 0x0, 4, 2218, 1437, 0, 1, 141 }, - { 0x0, 0x0, 4, 2219, 1439, 0, 1, 141 }, - { 0x0, 0x0, 4, 2220, 1441, 0, 1, 141 }, - { 0x0, 0x0, 4, 2221, 1443, 0, 1, 141 }, - { 0x0, 0x0, 4, 2222, 1445, 0, 1, 143 }, - { 0x0, 0x0, 4, 2223, 1447, 0, 1, 143 }, - { 0x1, 0x1, 4, -1, 1454, 33, 1, 137 }, - { 0x5, 0x5, 4, 552, 1453, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1463, 33, 1, 137 }, - { 0x5, 0x5, 4, 553, 1462, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1472, 33, 1, 137 }, - { 0x5, 0x5, 4, 554, 1471, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1476, 32, 1, 132 }, - { 0x1, 0x1, 4, -1, 1478, 32, 1, 132 }, - { 0x1, 0x1, 4, -1, 1485, 33, 1, 137 }, - { 0x5, 0x5, 4, 555, 1484, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1494, 33, 1, 137 }, - { 0x5, 0x5, 4, 556, 1493, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1503, 33, 1, 137 }, - { 0x5, 0x5, 4, 557, 1502, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1512, 33, 1, 137 }, - { 0x5, 0x5, 4, 558, 1511, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1521, 33, 1, 137 }, - { 0x5, 0x5, 4, 559, 1520, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1530, 33, 1, 137 }, - { 0x5, 0x5, 4, 560, 1529, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1540, 33, 1, 137 }, - { 0x5, 0x5, 4, 1036, 1538, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1550, 33, 1, 137 }, - { 0x5, 0x5, 4, 1037, 1548, 32, 1, 131 }, - { 0x1, 0x1, 4, -1, 1560, 33, 1, 137 }, - { 0x5, 0x5, 4, 1038, 1558, 32, 1, 131 }, - { 0x1, 0x21, 10, 2013, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2014, -1, 12, 1, 3 }, - { 0x1, 0x21, 10, 420, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2074, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, -1, 2075, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2076, 0, 0, -1 }, - { 0x0, 0x0, 10, 2017, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2018, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 2019, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2020, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, 430, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2080, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 434, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2082, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, 438, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2084, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 442, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2086, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, 446, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2088, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 450, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2090, -1, 12, 1, 3 }, - { 0x1, 0x21, 10, 2033, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2034, -1, 12, 1, 3 }, - { 0x1, 0x21, 10, 460, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2096, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, -1, 2097, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2098, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2101, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2102, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2103, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2104, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2105, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2106, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2107, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2108, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2109, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2110, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2111, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2112, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2113, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2114, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2115, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2116, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2117, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2118, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2119, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2120, 0, 0, -1 }, - { 0x1, 0x21, 10, 2037, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2038, -1, 12, 1, 3 }, - { 0x1, 0x21, 10, 468, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2122, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, -1, 2123, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2124, 0, 0, -1 }, - { 0x0, 0x0, 10, 2041, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2042, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 2043, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2044, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, 478, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2128, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 482, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2130, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, 486, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2132, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 490, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2134, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, 494, -1, 0, 1, 3 }, - { 0x1, 0x1, 10, 2136, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 498, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2138, -1, 12, 1, 3 }, - { 0x1, 0x21, 10, 2057, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2058, -1, 12, 1, 3 }, - { 0x1, 0x21, 10, 508, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 10, 2144, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, -1, 2145, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2146, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2149, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2150, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2151, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2152, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2153, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2154, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2155, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2156, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2157, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2158, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2159, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2160, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2161, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2162, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2163, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2164, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2165, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2166, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2167, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2168, 0, 0, -1 }, - { 0x1, 0x1, 10, 2061, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 10, 2062, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 2063, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 10, 2064, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, -1, 2169, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2171, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2173, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2175, 0, 0, -1 }, - { 0x1, 0x1, 10, 2065, -1, 36, 1, 78 }, - { 0x1000001, 0x1000001, 10, 2066, -1, 12, 1, 78 }, - { 0x1, 0x1, 10, 2067, -1, 36, 1, 78 }, - { 0x1000001, 0x1000001, 10, 2068, -1, 12, 1, 78 }, - { 0x0, 0x0, 10, -1, 2177, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2179, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2181, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2183, 0, 0, -1 }, - { 0x1, 0x1, 10, 2069, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 10, 2070, -1, 12, 1, 3 }, - { 0x1, 0x1, 10, 2071, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 10, 2072, -1, 12, 1, 3 }, - { 0x0, 0x0, 10, -1, 2185, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2187, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2189, 0, 0, -1 }, - { 0x0, 0x0, 10, -1, 2191, 0, 0, -1 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x4200001, 11, 2015, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 300, -1, 33, 1, 3 }, - { 0x0, 0x0, 11, 2077, -1, 0, 1, 3 }, - { 0x1, 0x1, 11, 2078, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 2021, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x0, 0x0, 11, 308, -1, 0, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x200001, 11, 2023, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 310, -1, 33, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 2025, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x0, 0x0, 11, 312, -1, 0, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x200001, 11, 2027, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 314, -1, 33, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 2029, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x0, 0x0, 11, 316, -1, 0, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x200001, 11, 2031, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 318, -1, 33, 1, 3 }, - { 0x0, 0x0, 11, 2091, -1, 0, 1, 3 }, - { 0x1, 0x1, 11, 2092, -1, 12, 1, 3 }, - { 0x1, 0x1, 11, 2093, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 11, 2094, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x4200001, 11, 2035, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 322, -1, 33, 1, 3 }, - { 0x0, 0x0, 11, 2099, -1, 0, 1, 3 }, - { 0x1, 0x1, 11, 2100, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x4200001, 11, 2039, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 348, -1, 33, 1, 3 }, - { 0x0, 0x0, 11, 2125, -1, 0, 1, 3 }, - { 0x1, 0x1, 11, 2126, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 2045, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x0, 0x0, 11, 356, -1, 0, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x200001, 11, 2047, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 358, -1, 33, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 2049, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x0, 0x0, 11, 360, -1, 0, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x200001, 11, 2051, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 362, -1, 33, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 2053, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x0, 0x0, 11, 364, -1, 0, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x200001, 11, 2055, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 366, -1, 33, 1, 3 }, - { 0x0, 0x0, 11, 2139, -1, 0, 1, 3 }, - { 0x1, 0x1, 11, 2140, -1, 12, 1, 3 }, - { 0x1, 0x1, 11, 2141, -1, 33, 1, 3 }, - { 0x200001, 0x200001, 11, 2142, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x200001, 0x4200001, 11, 2059, -1, 12, 1, 3 }, - { 0x2, 0x3, 11, -1, -1, 37, 1, 5 }, - { 0x1, 0x1, 11, 370, -1, 33, 1, 3 }, - { 0x0, 0x0, 11, 2147, -1, 0, 1, 3 }, - { 0x1, 0x1, 11, 2148, -1, 12, 1, 3 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, 2170, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 11, 2172, -1, 12, 1, 3 }, - { 0x1, 0x1, 11, 2174, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 11, 2176, -1, 12, 1, 3 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 80 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 80 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 80 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 80 }, - { 0x1, 0x1, 11, 2178, -1, 36, 1, 78 }, - { 0x1000001, 0x1000001, 11, 2180, -1, 12, 1, 78 }, - { 0x1, 0x1, 11, 2182, -1, 36, 1, 78 }, - { 0x1000001, 0x1000001, 11, 2184, -1, 12, 1, 78 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, -1, -1, 36, 1, 5 }, - { 0x1, 0x1, 11, 2186, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 11, 2188, -1, 12, 1, 3 }, - { 0x1, 0x1, 11, 2190, -1, 36, 1, 3 }, - { 0x1000001, 0x1000001, 11, 2192, -1, 12, 1, 3 }, - { 0x0, 0x0, 12, -1, -1, 0, 1, 15 }, - { 0x0, 0x0, 12, -1, -1, 0, 1, 15 }, - { 0x0, 0x0, 12, -1, -1, 0, 1, 15 }, - { 0x1, 0x1, 13, 272, 1452, 34, 1, 131 }, - { 0x1, 0x1, 13, 274, 1461, 34, 1, 131 }, - { 0x1, 0x1, 13, 276, 1470, 34, 1, 131 }, - { 0x1, 0x1, 13, 280, 1483, 34, 1, 131 }, - { 0x1, 0x1, 13, 282, 1492, 34, 1, 131 }, - { 0x1, 0x1, 13, 284, 1501, 34, 1, 131 }, - { 0x1, 0x1, 13, 286, 1510, 34, 1, 131 }, - { 0x1, 0x1, 13, 288, 1519, 34, 1, 131 }, - { 0x1, 0x1, 13, 290, 1528, 34, 1, 131 }, - { 0x1, 0x1, 13, 292, 1537, 34, 1, 131 }, - { 0x1, 0x1, 13, 294, 1547, 34, 1, 131 }, - { 0x1, 0x1, 13, 296, 1557, 34, 1, 131 }, - { 0x0, 0x0, 19, -1, 795, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 796, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 797, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 798, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 799, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 800, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 801, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 802, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 803, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 804, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 805, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 806, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 807, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 808, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 809, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 810, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 811, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 812, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 813, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 814, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 815, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 816, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 817, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 818, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 819, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 820, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 821, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 822, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 823, 0, 0, -1 }, - { 0x0, 0x0, 19, -1, 824, 0, 0, -1 }, - { 0x0, 0x0, 20, -1, 2827, 0, 0, -1 }, - { 0x0, 0x0, 20, -1, 2828, 0, 0, -1 }, - { 0x0, 0x0, 20, -1, 2843, 0, 0, -1 }, - { 0x0, 0x0, 20, -1, 2844, 0, 0, -1 }, - { 0x0, 0x0, 20, -1, 2849, 0, 0, -1 }, - { 0x0, 0x0, 20, -1, 2850, 0, 0, -1 }, - { 0x0, 0x0, 21, 831, 2839, 0, 0, -1 }, - { 0x0, 0x0, 21, 832, 2841, 0, 0, -1 }, - { 0x0, 0x0, 23, -1, 2837, 0, 0, -1 }, - { 0x0, 0x0, 23, -1, 2838, 0, 0, -1 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, 1272, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 6 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 7 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 16 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, 1293, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, 1326, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 18 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, - { 0x1, 0x1, 24, -1, -1, 33, 1, 82 }, - { 0x1, 0x1, 24, -1, -1, 33, 1, 82 }, - { 0x1, 0x1, 24, 1342, 1455, 35, 1, 137 }, - { 0x1, 0x1, 24, 1343, 1464, 35, 1, 137 }, - { 0x1, 0x1, 24, 1344, 1473, 35, 1, 137 }, - { 0x1, 0x1, 24, 1345, 1486, 35, 1, 137 }, - { 0x1, 0x1, 24, 1346, 1495, 35, 1, 137 }, - { 0x1, 0x1, 24, 1347, 1504, 35, 1, 137 }, - { 0x1, 0x1, 24, 1348, 1513, 35, 1, 137 }, - { 0x1, 0x1, 24, 1349, 1522, 35, 1, 137 }, - { 0x1, 0x1, 24, 1350, 1531, 35, 1, 137 }, - { 0x1, 0x1, 24, 1351, 1541, 35, 1, 137 }, - { 0x1, 0x1, 24, 1352, 1551, 35, 1, 137 }, - { 0x1, 0x1, 24, 1353, 1561, 35, 1, 137 }, - { 0x1, 0x1, 24, 1354, 1570, 35, 1, 151 }, - { 0x1, 0x1, 24, 1355, 1576, 35, 1, 156 }, - { 0x1, 0x1, 24, 1356, 1582, 35, 1, 156 }, - { 0x1, 0x1, 24, 1357, 1588, 35, 1, 151 }, - { 0x1, 0x1, 24, 1358, 1594, 35, 1, 156 }, - { 0x1, 0x1, 24, 1359, 1600, 35, 1, 156 }, - { 0x1, 0x1, 24, 1360, 1606, 35, 1, 151 }, - { 0x1, 0x1, 24, 1361, 1612, 35, 1, 156 }, - { 0x1, 0x1, 24, 1362, 1618, 35, 1, 156 }, - { 0x1, 0x1, 24, 1363, 1624, 35, 1, 151 }, - { 0x1, 0x1, 24, 1364, 1630, 35, 1, 156 }, - { 0x1, 0x1, 24, 1365, 1636, 35, 1, 151 }, - { 0x1, 0x1, 24, 1366, 1642, 35, 1, 156 }, - { 0x1, 0x1, 24, 1367, 1648, 35, 1, 151 }, - { 0x1, 0x1, 24, 1368, 1654, 35, 1, 156 }, - { 0x1, 0x1, 24, 1369, 1660, 35, 1, 151 }, - { 0x1, 0x1, 24, 1370, 1666, 35, 1, 156 }, - { 0x1, 0x1, 24, 1371, 1672, 35, 1, 156 }, - { 0x0, 0x0, 33, 2821, 2819, 0, 0, -1 }, - { 0x0, 0x0, 33, 2824, 2822, 0, 0, -1 }, - { 0x0, 0x0, 33, 2830, 2829, 0, 0, -1 }, - { 0x0, 0x0, 33, 2832, 2831, 0, 0, -1 }, - { 0x0, 0x0, 33, 2846, 2845, 0, 0, -1 }, - { 0x0, 0x0, 33, 2848, 2847, 0, 0, -1 }, - { 0x0, 0x0, 35, -1, 2840, 0, 0, -1 }, - { 0x0, 0x0, 35, -1, 2842, 0, 0, -1 }, - { 0x1, 0x1, 38, -1, 2290, 37, 1, 30 }, - { 0x1, 0x1, 38, -1, 2349, 37, 1, 30 }, - { 0x0, 0x0, 38, -1, 2352, 0, 0, -1 }, - { 0x1, 0x1, 38, -1, -1, 37, 1, 30 }, - { 0x1, 0x1, 38, -1, 2357, 37, 1, 30 }, - { 0x0, 0x0, 38, -1, 2360, 0, 0, -1 }, - { 0x1, 0x1, 38, -1, -1, 37, 1, 30 }, - { 0x0, 0x0, 38, -1, 2363, 0, 0, -1 }, - { 0x1, 0x1, 38, -1, -1, 37, 1, 30 }, - { 0x1, 0x1, 38, -1, 2366, 37, 1, 30 }, - { 0x1, 0x1, 38, -1, 2369, 37, 1, 30 }, - { 0x1, 0x1, 38, -1, 2402, 37, 1, 30 }, - { 0x3, 0x3, 38, -1, -1, 30, 1, 144 }, - { 0x0, 0x0, 38, 1142, -1, 0, 1, 102 }, - { 0x0, 0x0, 38, -1, -1, 0, 1, 111 }, - { 0x0, 0x0, 38, 1148, -1, 0, 1, 123 }, - { 0x3, 0x3, 38, -1, -1, 30, 1, 160 }, - { 0x0, 0x0, 38, 1149, -1, 0, 1, 41 }, - { 0x0, 0x0, 40, -1, 973, 0, 0, -1 }, - { 0x0, 0x0, 40, -1, 981, 0, 0, -1 }, - { 0x0, 0x0, 40, 1151, 977, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 622, 33, 1, 6 }, - { 0x18000001, 0x18000001, 40, -1, 630, 6, 1, 7 }, - { 0x3, 0x3, 40, 1152, 626, 33, 1, 6 }, - { 0x0, 0x0, 40, -1, 985, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 642, 33, 1, 8 }, - { 0x0, 0x0, 40, -1, 989, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 654, 33, 1, 16 }, - { 0x0, 0x0, 40, -1, 994, 0, 0, -1 }, - { 0x0, 0x0, 40, -1, 998, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 677, 33, 1, 18 }, - { 0x3, 0x3, 40, -1, 681, 33, 1, 18 }, - { 0x0, 0x0, 40, -1, 1002, 0, 0, -1 }, - { 0x0, 0x0, 40, -1, 1006, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 701, 33, 1, 19 }, - { 0x18000001, 0x18000001, 40, -1, 705, 6, 1, 19 }, - { 0x0, 0x0, 40, -1, 1010, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 717, 33, 1, 20 }, - { 0x0, 0x0, 40, -1, 1014, 0, 0, -1 }, - { 0x0, 0x0, 40, -1, 1018, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 737, 33, 1, 21 }, - { 0x18000001, 0x18000001, 40, -1, 741, 6, 1, 21 }, - { 0x0, 0x0, 40, -1, 1022, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 753, 33, 1, 22 }, - { 0x0, 0x0, 40, -1, 1027, 0, 0, -1 }, - { 0x0, 0x0, 40, -1, 1031, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 776, 33, 1, 18 }, - { 0x3, 0x3, 40, -1, 780, 33, 1, 18 }, - { 0x0, 0x0, 40, -1, 1035, 0, 0, -1 }, - { 0x3, 0x3, 40, -1, 792, 33, 1, 22 }, - { 0x0, 0x0, 41, 851, 972, 0, 0, -1 }, - { 0x0, 0x0, 41, 852, 980, 0, 0, -1 }, - { 0x0, 0x0, 41, 853, 976, 0, 0, -1 }, - { 0x1, 0x1, 41, 854, 621, 34, 1, 6 }, - { 0x10000001, 0x10000001, 41, 855, 629, 6, 1, 7 }, - { 0x1, 0x1, 41, 856, 625, 34, 1, 6 }, - { 0x0, 0x0, 41, 857, 984, 0, 0, -1 }, - { 0x1, 0x1, 41, 858, 641, 34, 1, 8 }, - { 0x0, 0x0, 41, 859, 988, 0, 0, -1 }, - { 0x1, 0x1, 41, 860, 653, 34, 1, 16 }, - { 0x0, 0x0, 41, 861, 993, 0, 0, -1 }, - { 0x0, 0x0, 41, 862, 997, 0, 0, -1 }, - { 0x1, 0x1, 41, 863, 676, 34, 1, 18 }, - { 0x1, 0x1, 41, 864, 680, 34, 1, 18 }, - { 0x0, 0x0, 41, 865, 1001, 0, 0, -1 }, - { 0x0, 0x0, 41, 866, 1005, 0, 0, -1 }, - { 0x1, 0x1, 41, 867, 700, 34, 1, 19 }, - { 0x10000001, 0x10000001, 41, 868, 704, 6, 1, 19 }, - { 0x0, 0x0, 41, 869, 1009, 0, 0, -1 }, - { 0x1, 0x1, 41, 870, 716, 34, 1, 20 }, - { 0x0, 0x0, 41, 871, 1013, 0, 0, -1 }, - { 0x0, 0x0, 41, 872, 1017, 0, 0, -1 }, - { 0x1, 0x1, 41, 873, 736, 34, 1, 21 }, - { 0x10000001, 0x10000001, 41, 874, 740, 6, 1, 21 }, - { 0x0, 0x0, 41, 875, 1021, 0, 0, -1 }, - { 0x1, 0x1, 41, 876, 752, 34, 1, 22 }, - { 0x0, 0x0, 41, 877, 1026, 0, 0, -1 }, - { 0x0, 0x0, 41, 878, 1030, 0, 0, -1 }, - { 0x1, 0x1, 41, 879, 775, 34, 1, 18 }, - { 0x1, 0x1, 41, 880, 779, 34, 1, 18 }, - { 0x0, 0x0, 41, 881, 1034, 0, 0, -1 }, - { 0x1, 0x1, 41, 882, 791, 34, 1, 22 }, - { 0x800001, 0x800001, 41, -1, 1156, 4, 1, 17 }, - { 0x1, 0x1, 41, 2236, 1154, 4, 1, 17 }, - { 0x1, 0x1, 41, 957, 1159, 4, 1, 23 }, - { 0x2, 0x3, 41, -1, 1164, 20, 1, 68 }, - { 0x1, 0x1, 41, 2237, 1162, 21, 1, 68 }, - { 0x0, 0x0, 42, -1, -1, 0, 1, 86 }, - { 0x0, 0x0, 42, -1, -1, 0, 1, 86 }, - { 0x0, 0x0, 42, -1, -1, 0, 1, 130 }, - { 0x1, 0x1, 44, 1372, 297, 38, 1, 1 }, - { 0x1, 0x1, 44, 1373, 299, 38, 1, 1 }, - { 0x0, 0x0, 44, -1, 302, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 424, 0, 0, -1 }, - { 0x1, 0x1, 44, 1377, 319, 38, 1, 1 }, - { 0x1, 0x1, 44, 1378, 321, 38, 1, 1 }, - { 0x0, 0x0, 44, -1, 324, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 464, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 326, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 344, 0, 0, -1 }, - { 0x1, 0x1, 44, 1384, 345, 38, 1, 1 }, - { 0x1, 0x1, 44, 1385, 347, 38, 1, 1 }, - { 0x0, 0x0, 44, -1, 350, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 472, 0, 0, -1 }, - { 0x1, 0x1, 44, 1389, 367, 38, 1, 1 }, - { 0x1, 0x1, 44, 1390, 369, 38, 1, 1 }, - { 0x0, 0x0, 44, -1, 372, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 512, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 374, 0, 0, -1 }, - { 0x0, 0x0, 44, -1, 392, 0, 0, -1 }, - { 0x0, 0x0, 44, 1248, 2297, 0, 0, -1 }, - { 0x0, 0x0, 44, 1249, 2305, 0, 1, 55 }, - { 0x0, 0x0, 44, 1250, 2972, 0, 1, 55 }, - { 0x0, 0x0, 44, 1251, 2373, 0, 0, -1 }, - { 0x0, 0x0, 44, 1252, -1, 0, 1, 50 }, - { 0x0, 0x0, 44, 1120, -1, 0, 1, 0 }, - { 0x0, 0x0, 44, 1121, -1, 0, 1, 0 }, - { 0x0, 0x0, 44, 1122, -1, 0, 1, 0 }, - { 0x1, 0x1, 45, -1, 1676, 30, 1, 158 }, - { 0x1, 0x1, 45, 963, 1675, 30, 1, 158 }, - { 0x1, 0x1, 45, -1, 1680, 30, 1, 159 }, - { 0x1, 0x1, 45, 964, 1679, 30, 1, 159 }, - { 0x1, 0x1, 45, -1, 1684, 30, 1, 159 }, - { 0x1, 0x1, 45, 965, 1683, 30, 1, 159 }, - { 0x3, 0x3, 46, -1, 1160, 3, 1, 23 }, - { 0x1, 0x1, 47, 2257, -1, 30, 1, 144 }, - { 0x1, 0x1, 47, 2288, -1, 30, 1, 160 }, - { 0x0, 0x0, 49, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 49, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 49, -1, -1, 0, 1, 41 }, - { 0x1, 0x1, 56, -1, 1677, 31, 1, 158 }, - { 0x1, 0x1, 56, -1, 1681, 31, 1, 159 }, - { 0x1, 0x1, 56, -1, 1685, 31, 1, 159 }, - { 0x0, 0x0, 56, -1, -1, 0, 1, 101 }, - { 0x2, 0x3, 56, -1, -1, 27, 1, 101 }, - { 0x1, 0x1, 56, -1, -1, 28, 1, 101 }, - { 0x0, 0x0, 65, 14, 592, 0, 1, 6 }, - { 0x0, 0x0, 65, 1273, 595, 0, 1, 6 }, - { 0x1, 0x1, 65, 1274, 597, 33, 1, 6 }, - { 0x1, 0x1, 65, 1275, 599, 34, 1, 6 }, - { 0x3, 0x3, 65, 1276, 601, 33, 1, 6 }, - { 0x0, 0x0, 65, 1277, 603, 0, 1, 6 }, - { 0x1, 0x1, 65, 1278, 605, 33, 1, 6 }, - { 0x1, 0x1, 65, 1279, 607, 34, 1, 6 }, - { 0x3, 0x3, 65, 1280, 609, 33, 1, 6 }, - { 0x1, 0x1, 65, 1281, 611, 6, 1, 7 }, - { 0x8000001, 0x8000001, 65, 1282, 613, 6, 1, 7 }, - { 0x10000001, 0x10000001, 65, 1283, 615, 6, 1, 7 }, - { 0x18000001, 0x18000001, 65, 1284, 617, 6, 1, 7 }, - { 0x0, 0x0, 65, 1285, 631, 0, 1, 8 }, - { 0x1, 0x1, 65, 1286, 633, 33, 1, 8 }, - { 0x1, 0x1, 65, 1287, 635, 34, 1, 8 }, - { 0x3, 0x3, 65, 1288, 637, 33, 1, 8 }, - { 0x0, 0x0, 65, 1289, 643, 0, 1, 16 }, - { 0x1, 0x1, 65, 1290, 645, 33, 1, 16 }, - { 0x1, 0x1, 65, 1291, 647, 34, 1, 16 }, - { 0x3, 0x3, 65, 1292, 649, 33, 1, 16 }, - { 0x0, 0x0, 65, 15, 655, 0, 1, 18 }, - { 0x0, 0x0, 65, 1294, 658, 0, 1, 18 }, - { 0x1, 0x1, 65, 1295, 660, 33, 1, 18 }, - { 0x1, 0x1, 65, 1296, 662, 34, 1, 18 }, - { 0x3, 0x3, 65, 1297, 664, 33, 1, 18 }, - { 0x0, 0x0, 65, 1298, 666, 0, 1, 18 }, - { 0x1, 0x1, 65, 1299, 668, 33, 1, 18 }, - { 0x1, 0x1, 65, 1300, 670, 34, 1, 18 }, - { 0x3, 0x3, 65, 1301, 672, 33, 1, 18 }, - { 0x0, 0x0, 65, 1302, 682, 0, 1, 19 }, - { 0x1, 0x1, 65, 1303, 684, 33, 1, 19 }, - { 0x1, 0x1, 65, 1304, 686, 34, 1, 19 }, - { 0x3, 0x3, 65, 1305, 688, 33, 1, 19 }, - { 0x1, 0x1, 65, 1306, 690, 6, 1, 19 }, - { 0x8000001, 0x8000001, 65, 1307, 692, 6, 1, 19 }, - { 0x10000001, 0x10000001, 65, 1308, 694, 6, 1, 19 }, - { 0x18000001, 0x18000001, 65, 1309, 696, 6, 1, 19 }, - { 0x0, 0x0, 65, 1310, 706, 0, 1, 20 }, - { 0x1, 0x1, 65, 1311, 708, 33, 1, 20 }, - { 0x1, 0x1, 65, 1312, 710, 34, 1, 20 }, - { 0x3, 0x3, 65, 1313, 712, 33, 1, 20 }, - { 0x0, 0x0, 65, 1314, 718, 0, 1, 21 }, - { 0x1, 0x1, 65, 1315, 720, 33, 1, 21 }, - { 0x1, 0x1, 65, 1316, 722, 34, 1, 21 }, - { 0x3, 0x3, 65, 1317, 724, 33, 1, 21 }, - { 0x1, 0x1, 65, 1318, 726, 6, 1, 21 }, - { 0x8000001, 0x8000001, 65, 1319, 728, 6, 1, 21 }, - { 0x10000001, 0x10000001, 65, 1320, 730, 6, 1, 21 }, - { 0x18000001, 0x18000001, 65, 1321, 732, 6, 1, 21 }, - { 0x0, 0x0, 65, 1322, 742, 0, 1, 22 }, - { 0x1, 0x1, 65, 1323, 744, 33, 1, 22 }, - { 0x1, 0x1, 65, 1324, 746, 34, 1, 22 }, - { 0x3, 0x3, 65, 1325, 748, 33, 1, 22 }, - { 0x0, 0x0, 65, 17, 754, 0, 1, 18 }, - { 0x0, 0x0, 65, 1327, 757, 0, 1, 18 }, - { 0x1, 0x1, 65, 1328, 759, 33, 1, 18 }, - { 0x1, 0x1, 65, 1329, 761, 34, 1, 18 }, - { 0x3, 0x3, 65, 1330, 763, 33, 1, 18 }, - { 0x0, 0x0, 65, 1331, 765, 0, 1, 18 }, - { 0x1, 0x1, 65, 1332, 767, 33, 1, 18 }, - { 0x1, 0x1, 65, 1333, 769, 34, 1, 18 }, - { 0x3, 0x3, 65, 1334, 771, 33, 1, 18 }, - { 0x0, 0x0, 65, 1335, 781, 0, 1, 22 }, - { 0x1, 0x1, 65, 1336, 783, 33, 1, 22 }, - { 0x1, 0x1, 65, 1337, 785, 34, 1, 22 }, - { 0x3, 0x3, 65, 1338, 787, 33, 1, 22 }, - { 0x3, 0x3, 66, 561, 1539, 33, 1, 136 }, - { 0x3, 0x3, 66, 562, 1549, 33, 1, 136 }, - { 0x3, 0x3, 66, 563, 1559, 33, 1, 136 }, - { 0x0, 0x0, 66, -1, 1564, 0, 1, 147 }, - { 0x0, 0x0, 66, -1, 1565, 0, 1, 152 }, - { 0x0, 0x0, 66, -1, 1566, 0, 1, 152 }, - { 0x0, 0x0, 107, 1046, 2345, 0, 0, -1 }, - { 0x0, 0x0, 107, 1047, 2864, 0, 1, 30 }, - { 0x0, 0x0, 107, 1048, 2386, 0, 0, -1 }, - { 0x0, 0x0, 107, 1049, 2868, 0, 1, 30 }, - { 0x0, 0x0, 109, -1, 2347, 0, 0, -1 }, - { 0x1, 0x1, 109, -1, 2865, 27, 1, 30 }, - { 0x0, 0x0, 109, -1, 2388, 0, 0, -1 }, - { 0x1, 0x1, 109, -1, 2869, 27, 1, 30 }, - { 0x0, 0x0, 110, 1051, -1, 0, 1, 122 }, - { 0x1, 0x1, 111, -1, -1, 27, 1, 122 }, - { 0x0, 0x0, 112, 1082, 2894, 0, 1, 1 }, - { 0x0, 0x0, 112, 1083, 2897, 0, 1, 1 }, - { 0x0, 0x0, 112, 1224, 305, 0, 0, -1 }, - { 0x0, 0x0, 112, 1225, 309, 0, 0, -1 }, - { 0x0, 0x0, 112, 1185, 440, 0, 0, -1 }, - { 0x0, 0x0, 112, 1186, 448, 0, 0, -1 }, - { 0x0, 0x0, 112, -1, 456, 0, 0, -1 }, - { 0x0, 0x0, 112, 1084, 2910, 0, 1, 1 }, - { 0x0, 0x0, 112, 1085, 2913, 0, 1, 1 }, - { 0x0, 0x0, 112, -1, 330, 0, 0, -1 }, - { 0x0, 0x0, 112, -1, 334, 0, 0, -1 }, - { 0x0, 0x0, 112, 1233, 335, 0, 0, -1 }, - { 0x0, 0x0, 112, 1234, 339, 0, 0, -1 }, - { 0x0, 0x0, 112, 1086, 2934, 0, 1, 1 }, - { 0x0, 0x0, 112, 1087, 2937, 0, 1, 1 }, - { 0x0, 0x0, 112, 1237, 353, 0, 0, -1 }, - { 0x0, 0x0, 112, 1238, 357, 0, 0, -1 }, - { 0x0, 0x0, 112, 1198, 488, 0, 0, -1 }, - { 0x0, 0x0, 112, 1199, 496, 0, 0, -1 }, - { 0x0, 0x0, 112, -1, 504, 0, 0, -1 }, - { 0x0, 0x0, 112, 1391, 2948, 0, 1, 1 }, - { 0x0, 0x0, 112, 1392, 2950, 0, 1, 1 }, - { 0x0, 0x0, 112, -1, 378, 0, 0, -1 }, - { 0x0, 0x0, 112, -1, 382, 0, 0, -1 }, - { 0x0, 0x0, 112, 1246, 383, 0, 0, -1 }, - { 0x0, 0x0, 112, 1247, 387, 0, 0, -1 }, - { 0x0, 0x0, 112, -1, 2315, 0, 0, -1 }, - { 0x1, 0x9, 112, -1, 2319, 33, 1, 55 }, - { 0x1, 0x9, 112, -1, 2981, 33, 1, 55 }, - { 0x2, 0x3, 112, 1408, 2382, 27, 1, 50 }, - { 0x1, 0x1, 114, 1374, 2895, 37, 1, 1 }, - { 0x1, 0x1, 114, 1375, 2898, 37, 1, 1 }, - { 0x1, 0x1, 114, 1379, 2911, 37, 1, 1 }, - { 0x1, 0x1, 114, 1380, 2914, 37, 1, 1 }, - { 0x1, 0x1, 114, 1386, 2935, 37, 1, 1 }, - { 0x1, 0x1, 114, 1387, 2938, 37, 1, 1 }, - { 0x0, 0x0, 114, -1, 2958, 0, 1, 1 }, - { 0x0, 0x0, 114, -1, 2959, 0, 1, 1 }, - { 0x0, 0x0, 115, 1123, 2890, 0, 1, 1 }, - { 0x0, 0x0, 115, 1124, 2892, 0, 1, 1 }, - { 0x0, 0x0, 115, 1183, 303, 0, 0, -1 }, - { 0x0, 0x0, 115, 1184, 307, 0, 0, -1 }, - { 0x0, 0x0, 115, -1, 444, 0, 0, -1 }, - { 0x0, 0x0, 115, -1, 452, 0, 0, -1 }, - { 0x0, 0x0, 115, 1228, 454, 0, 0, -1 }, - { 0x0, 0x0, 115, -1, 2908, 0, 1, 1 }, - { 0x0, 0x0, 115, -1, 2909, 0, 1, 1 }, - { 0x0, 0x0, 115, 1231, 328, 0, 0, -1 }, - { 0x0, 0x0, 115, 1232, 332, 0, 0, -1 }, - { 0x0, 0x0, 115, 1192, 337, 0, 0, -1 }, - { 0x0, 0x0, 115, 1193, 341, 0, 0, -1 }, - { 0x0, 0x0, 115, 1127, 2930, 0, 1, 1 }, - { 0x0, 0x0, 115, 1128, 2932, 0, 1, 1 }, - { 0x0, 0x0, 115, 1196, 351, 0, 0, -1 }, - { 0x0, 0x0, 115, 1197, 355, 0, 0, -1 }, - { 0x0, 0x0, 115, -1, 492, 0, 0, -1 }, - { 0x0, 0x0, 115, -1, 500, 0, 0, -1 }, - { 0x0, 0x0, 115, 1241, 502, 0, 0, -1 }, - { 0x0, 0x0, 115, -1, 2946, 0, 1, 1 }, - { 0x0, 0x0, 115, -1, 2947, 0, 1, 1 }, - { 0x0, 0x0, 115, 1244, 376, 0, 0, -1 }, - { 0x0, 0x0, 115, 1245, 380, 0, 0, -1 }, - { 0x0, 0x0, 115, 1205, 385, 0, 0, -1 }, - { 0x0, 0x0, 115, 1206, 389, 0, 0, -1 }, - { 0x0, 0x0, 115, 1078, 2313, 0, 0, -1 }, - { 0x0, 0x0, 115, 1079, 2317, 0, 1, 55 }, - { 0x0, 0x0, 115, 1080, 2980, 0, 1, 55 }, - { 0x0, 0x0, 115, 1081, 2381, 0, 1, 50 }, - { 0x1, 0x1, 115, -1, -1, 27, 1, 0 }, - { 0x1, 0x1, 115, -1, -1, 27, 1, 0 }, - { 0x1, 0x1, 115, -1, -1, 27, 1, 0 }, - { 0x1, 0x1, 116, -1, 2891, 37, 1, 1 }, - { 0x1, 0x1, 116, -1, 2893, 37, 1, 1 }, - { 0x0, 0x0, 116, -1, 2918, 0, 1, 1 }, - { 0x0, 0x0, 116, -1, 2919, 0, 1, 1 }, - { 0x1, 0x1, 116, -1, 2931, 37, 1, 1 }, - { 0x1, 0x1, 116, -1, 2933, 37, 1, 1 }, - { 0x0, 0x0, 116, -1, 2956, 0, 1, 1 }, - { 0x0, 0x0, 116, -1, 2957, 0, 1, 1 }, - { 0x0, 0x0, 117, 1176, -1, 0, 1, 0 }, - { 0x0, 0x0, 117, 1177, -1, 0, 1, 0 }, - { 0x0, 0x0, 117, 1178, -1, 0, 1, 0 }, - { 0x3, 0x3, 117, 1136, -1, 34, 1, 34 }, - { 0x3, 0x3, 117, 1137, -1, 34, 1, 41 }, - { 0x1, 0x1, 119, -1, -1, 35, 1, 34 }, - { 0x1, 0x1, 119, -1, -1, 35, 1, 41 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 67 }, - { 0x1, 0x1, 120, -1, -1, 36, 1, 129 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 41 }, - { 0x1, 0x1, 120, -1, -1, 27, 1, 103 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 112 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 74 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 74 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 75 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 41 }, - { 0x1, 0x1, 120, -1, -1, 27, 1, 124 }, - { 0x1, 0x1, 120, -1, -1, 27, 1, 41 }, - { 0x0, 0x0, 120, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 121, -1, 2820, 0, 0, -1 }, - { 0x0, 0x0, 121, -1, 2823, 0, 0, -1 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 17 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 17 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 17 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 17 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 23 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 23 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 23 }, - { 0x1, 0x1, 122, -1, -1, 35, 1, 23 }, - { 0x1, 0x1, 122, -1, -1, 23, 1, 68 }, - { 0x1, 0x1, 122, -1, -1, 23, 1, 68 }, - { 0x1, 0x1, 122, -1, -1, 23, 1, 68 }, - { 0x1, 0x1, 122, -1, -1, 23, 1, 68 }, - { 0x1, 0x1, 122, 918, -1, 23, 1, 68 }, - { 0x9, 0x9, 122, 919, -1, 20, 1, 68 }, - { 0x0, 0x0, 126, 2199, -1, 0, 1, 0 }, - { 0x0, 0x0, 126, 2200, -1, 0, 1, 0 }, - { 0x1, 0x1, 126, -1, -1, 28, 1, 34 }, - { 0x1, 0x1, 126, -1, -1, 27, 1, 34 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x0, 0x0, 126, -1, -1, 0, 1, 121 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 126, -1, -1, 29, 1, 0 }, - { 0x0, 0x0, 126, 1134, -1, 0, 1, 34 }, - { 0x0, 0x0, 126, 1262, -1, 0, 1, 41 }, - { 0x0, 0x0, 140, 1212, 2886, 0, 1, 1 }, - { 0x0, 0x0, 140, 1213, 2888, 0, 1, 1 }, - { 0x0, 0x0, 140, 1054, 304, 0, 0, -1 }, - { 0x0, 0x0, 140, 1055, 432, 0, 0, -1 }, - { 0x0, 0x0, 140, 1094, 313, 0, 0, -1 }, - { 0x0, 0x0, 140, 1095, 317, 0, 0, -1 }, - { 0x0, 0x0, 140, 1096, 453, 0, 0, -1 }, - { 0x0, 0x0, 140, -1, 2906, 0, 1, 1 }, - { 0x0, 0x0, 140, -1, 2907, 0, 1, 1 }, - { 0x0, 0x0, 140, 1099, 327, 0, 0, -1 }, - { 0x0, 0x0, 140, 1100, 331, 0, 0, -1 }, - { 0x0, 0x0, 140, -1, 338, 0, 0, -1 }, - { 0x0, 0x0, 140, -1, 342, 0, 0, -1 }, - { 0x0, 0x0, 140, 1216, 2926, 0, 1, 1 }, - { 0x0, 0x0, 140, 1217, 2928, 0, 1, 1 }, - { 0x0, 0x0, 140, 1067, 352, 0, 0, -1 }, - { 0x0, 0x0, 140, 1068, 480, 0, 0, -1 }, - { 0x0, 0x0, 140, 1107, 361, 0, 0, -1 }, - { 0x0, 0x0, 140, 1108, 365, 0, 0, -1 }, - { 0x0, 0x0, 140, 1109, 501, 0, 0, -1 }, - { 0x0, 0x0, 140, -1, 2944, 0, 1, 1 }, - { 0x0, 0x0, 140, -1, 2945, 0, 1, 1 }, - { 0x0, 0x0, 140, 1112, 375, 0, 0, -1 }, - { 0x0, 0x0, 140, 1113, 379, 0, 0, -1 }, - { 0x0, 0x0, 140, -1, 386, 0, 0, -1 }, - { 0x0, 0x0, 140, -1, 390, 0, 0, -1 }, - { 0x0, 0x0, 140, 3012, 2301, 0, 0, -1 }, - { 0x1, 0x1, 140, 3013, 2309, 33, 1, 55 }, - { 0x1, 0x1, 140, 3014, 2974, 33, 1, 55 }, - { 0x0, 0x0, 140, 3015, 2375, 0, 0, -1 }, - { 0x1, 0x1, 140, 3016, -1, 28, 1, 50 }, - { 0x1, 0x1, 141, -1, 2887, 37, 1, 1 }, - { 0x1, 0x1, 141, -1, 2889, 37, 1, 1 }, - { 0x0, 0x0, 141, -1, 2916, 0, 1, 1 }, - { 0x0, 0x0, 141, -1, 2917, 0, 1, 1 }, - { 0x1, 0x1, 141, -1, 2927, 37, 1, 1 }, - { 0x1, 0x1, 141, -1, 2929, 37, 1, 1 }, - { 0x0, 0x0, 141, -1, 2954, 0, 1, 1 }, - { 0x0, 0x0, 141, -1, 2955, 0, 1, 1 }, - { 0x1, 0x1, 144, 917, 1158, 3, 1, 23 }, - { 0x0, 0x0, 145, 2201, -1, 0, 1, 34 }, - { 0x0, 0x0, 146, 923, 2880, 0, 1, 1 }, - { 0x0, 0x0, 146, 924, 2883, 0, 1, 1 }, - { 0x0, 0x0, 146, -1, 306, 0, 0, -1 }, - { 0x0, 0x0, 146, -1, 436, 0, 0, -1 }, - { 0x0, 0x0, 146, 1056, 311, 0, 0, -1 }, - { 0x0, 0x0, 146, 1057, 315, 0, 0, -1 }, - { 0x0, 0x0, 146, 1058, 455, 0, 0, -1 }, - { 0x0, 0x0, 146, 927, 2900, 0, 1, 1 }, - { 0x0, 0x0, 146, 928, 2903, 0, 1, 1 }, - { 0x0, 0x0, 146, 1061, 329, 0, 0, -1 }, - { 0x0, 0x0, 146, 1062, 333, 0, 0, -1 }, - { 0x0, 0x0, 146, 1101, 336, 0, 0, -1 }, - { 0x0, 0x0, 146, 1102, 340, 0, 0, -1 }, - { 0x0, 0x0, 146, 933, 2920, 0, 1, 1 }, - { 0x0, 0x0, 146, 934, 2923, 0, 1, 1 }, - { 0x0, 0x0, 146, -1, 354, 0, 0, -1 }, - { 0x0, 0x0, 146, -1, 484, 0, 0, -1 }, - { 0x0, 0x0, 146, 1069, 359, 0, 0, -1 }, - { 0x0, 0x0, 146, 1070, 363, 0, 0, -1 }, - { 0x0, 0x0, 146, 1071, 503, 0, 0, -1 }, - { 0x0, 0x0, 146, 937, 2940, 0, 1, 1 }, - { 0x0, 0x0, 146, 938, 2942, 0, 1, 1 }, - { 0x0, 0x0, 146, 1074, 377, 0, 0, -1 }, - { 0x0, 0x0, 146, 1075, 381, 0, 0, -1 }, - { 0x0, 0x0, 146, 1114, 384, 0, 0, -1 }, - { 0x0, 0x0, 146, 1115, 388, 0, 0, -1 }, - { 0x0, 0x0, 146, 1207, 2299, 0, 0, -1 }, - { 0x1, 0x1, 146, 1208, 2307, 36, 1, 55 }, - { 0x1, 0x1, 146, 1209, 2973, 36, 1, 55 }, - { 0x0, 0x0, 146, 1210, 2374, 0, 0, -1 }, - { 0x1, 0x1, 146, 1211, -1, 27, 1, 50 }, - { 0x1, 0x1, 147, -1, 2882, 37, 1, 1 }, - { 0x1, 0x1, 147, -1, 2885, 37, 1, 1 }, - { 0x1, 0x1, 147, -1, 2902, 37, 1, 1 }, - { 0x1, 0x1, 147, -1, 2905, 37, 1, 1 }, - { 0x1, 0x1, 147, -1, 2922, 37, 1, 1 }, - { 0x1, 0x1, 147, -1, 2925, 37, 1, 1 }, - { 0x0, 0x0, 147, -1, 2952, 0, 1, 1 }, - { 0x0, 0x0, 147, -1, 2953, 0, 1, 1 }, - { 0x0, 0x0, 148, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 148, 1135, -1, 0, 1, 41 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 67 }, - { 0x0, 0x0, 149, -1, 2960, 0, 1, 64 }, - { 0x0, 0x0, 149, -1, 2961, 0, 1, 64 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 87 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 87 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 92 }, - { 0x0, 0x0, 149, -1, -1, 0, 1, 41 }, - { 0x1, 0x1, 150, -1, 593, 12, 1, 6 }, - { 0x1, 0x1, 150, -1, 596, 12, 1, 6 }, - { 0x200001, 0x200001, 150, -1, 598, 12, 1, 6 }, - { 0x400001, 0x400001, 150, -1, 600, 12, 1, 6 }, - { 0x600001, 0x600001, 150, -1, 602, 12, 1, 6 }, - { 0x1, 0x1, 150, -1, 604, 12, 1, 6 }, - { 0x200001, 0x200001, 150, -1, 606, 12, 1, 6 }, - { 0x400001, 0x400001, 150, -1, 608, 12, 1, 6 }, - { 0x600001, 0x600001, 150, -1, 610, 12, 1, 6 }, - { 0x41, 0x41, 150, -1, 612, 6, 1, 7 }, - { 0x8000041, 0x8000041, 150, -1, 614, 6, 1, 7 }, - { 0x10000041, 0x10000041, 150, -1, 616, 6, 1, 7 }, - { 0x18000041, 0x18000041, 150, -1, 618, 6, 1, 7 }, - { 0x1, 0x1, 150, -1, 632, 12, 1, 8 }, - { 0x200001, 0x200001, 150, -1, 634, 12, 1, 8 }, - { 0x400001, 0x400001, 150, -1, 636, 12, 1, 8 }, - { 0x600001, 0x600001, 150, -1, 638, 12, 1, 8 }, - { 0x1, 0x1, 150, -1, 644, 12, 1, 16 }, - { 0x200001, 0x200001, 150, -1, 646, 12, 1, 16 }, - { 0x400001, 0x400001, 150, -1, 648, 12, 1, 16 }, - { 0x600001, 0x600001, 150, -1, 650, 12, 1, 16 }, - { 0x1, 0x1, 150, -1, 656, 12, 1, 18 }, - { 0x1, 0x1, 150, -1, 659, 12, 1, 18 }, - { 0x200001, 0x200001, 150, -1, 661, 12, 1, 18 }, - { 0x400001, 0x400001, 150, -1, 663, 12, 1, 18 }, - { 0x600001, 0x600001, 150, -1, 665, 12, 1, 18 }, - { 0x1, 0x1, 150, -1, 667, 12, 1, 18 }, - { 0x200001, 0x200001, 150, -1, 669, 12, 1, 18 }, - { 0x400001, 0x400001, 150, -1, 671, 12, 1, 18 }, - { 0x600001, 0x600001, 150, -1, 673, 12, 1, 18 }, - { 0x1, 0x1, 150, -1, 683, 12, 1, 19 }, - { 0x200001, 0x200001, 150, -1, 685, 12, 1, 19 }, - { 0x400001, 0x400001, 150, -1, 687, 12, 1, 19 }, - { 0x600001, 0x600001, 150, -1, 689, 12, 1, 19 }, - { 0x41, 0x41, 150, -1, 691, 6, 1, 19 }, - { 0x8000041, 0x8000041, 150, -1, 693, 6, 1, 19 }, - { 0x10000041, 0x10000041, 150, -1, 695, 6, 1, 19 }, - { 0x18000041, 0x18000041, 150, -1, 697, 6, 1, 19 }, - { 0x1, 0x1, 150, -1, 707, 12, 1, 20 }, - { 0x200001, 0x200001, 150, -1, 709, 12, 1, 20 }, - { 0x400001, 0x400001, 150, -1, 711, 12, 1, 20 }, - { 0x600001, 0x600001, 150, -1, 713, 12, 1, 20 }, - { 0x1, 0x1, 150, -1, 719, 12, 1, 21 }, - { 0x200001, 0x200001, 150, -1, 721, 12, 1, 21 }, - { 0x400001, 0x400001, 150, -1, 723, 12, 1, 21 }, - { 0x600001, 0x600001, 150, -1, 725, 12, 1, 21 }, - { 0x41, 0x41, 150, -1, 727, 6, 1, 21 }, - { 0x8000041, 0x8000041, 150, -1, 729, 6, 1, 21 }, - { 0x10000041, 0x10000041, 150, -1, 731, 6, 1, 21 }, - { 0x18000041, 0x18000041, 150, -1, 733, 6, 1, 21 }, - { 0x1, 0x1, 150, -1, 743, 12, 1, 22 }, - { 0x200001, 0x200001, 150, -1, 745, 12, 1, 22 }, - { 0x400001, 0x400001, 150, -1, 747, 12, 1, 22 }, - { 0x600001, 0x600001, 150, -1, 749, 12, 1, 22 }, - { 0x1, 0x1, 150, -1, 755, 12, 1, 18 }, - { 0x1, 0x1, 150, -1, 758, 12, 1, 18 }, - { 0x200001, 0x200001, 150, -1, 760, 12, 1, 18 }, - { 0x400001, 0x400001, 150, -1, 762, 12, 1, 18 }, - { 0x600001, 0x600001, 150, -1, 764, 12, 1, 18 }, - { 0x1, 0x1, 150, -1, 766, 12, 1, 18 }, - { 0x200001, 0x200001, 150, -1, 768, 12, 1, 18 }, - { 0x400001, 0x400001, 150, -1, 770, 12, 1, 18 }, - { 0x600001, 0x600001, 150, -1, 772, 12, 1, 18 }, - { 0x1, 0x1, 150, -1, 782, 12, 1, 22 }, - { 0x200001, 0x200001, 150, -1, 784, 12, 1, 22 }, - { 0x400001, 0x400001, 150, -1, 786, 12, 1, 22 }, - { 0x600001, 0x600001, 150, -1, 788, 12, 1, 22 }, - { 0x0, 0x0, 155, -1, -1, 0, 1, 131 }, - { 0x0, 0x0, 159, 793, -1, 0, 1, 81 }, - { 0x0, 0x0, 159, 794, -1, 0, 1, 81 }, - { 0x9, 0x9, 159, -1, 1456, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1465, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1474, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1487, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1496, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1505, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1514, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1523, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1532, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1542, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1552, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1562, 32, 1, 137 }, - { 0x9, 0x9, 159, -1, 1571, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1577, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1583, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1589, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1595, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1601, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1607, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1613, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1619, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1625, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1631, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1637, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1643, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1649, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1655, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1661, 32, 1, 151 }, - { 0x9, 0x9, 159, -1, 1667, 32, 1, 156 }, - { 0x9, 0x9, 159, -1, 1673, 32, 1, 156 }, - { 0x0, 0x0, 160, 1253, 298, 0, 0, -1 }, - { 0x0, 0x0, 160, 1254, 422, 0, 0, -1 }, - { 0x1, 0x1, 160, -1, 2896, 38, 1, 1 }, - { 0x1, 0x1, 160, 925, 2899, 38, 1, 1 }, - { 0x0, 0x0, 160, 926, 423, 0, 0, -1 }, - { 0x0, 0x0, 160, 1255, 320, 0, 0, -1 }, - { 0x0, 0x0, 160, 1256, 462, 0, 0, -1 }, - { 0x1, 0x1, 160, -1, 2912, 38, 1, 1 }, - { 0x1, 0x1, 160, 929, 2915, 38, 1, 1 }, - { 0x0, 0x0, 160, 930, 463, 0, 0, -1 }, - { 0x0, 0x0, 160, 931, 325, 0, 0, -1 }, - { 0x0, 0x0, 160, 932, 343, 0, 0, -1 }, - { 0x0, 0x0, 160, 1257, 346, 0, 0, -1 }, - { 0x0, 0x0, 160, 1258, 470, 0, 0, -1 }, - { 0x1, 0x1, 160, -1, 2936, 38, 1, 1 }, - { 0x1, 0x1, 160, 935, 2939, 38, 1, 1 }, - { 0x0, 0x0, 160, 936, 471, 0, 0, -1 }, - { 0x0, 0x0, 160, -1, 368, 0, 0, -1 }, - { 0x0, 0x0, 160, -1, 510, 0, 0, -1 }, - { 0x1, 0x1, 160, -1, 2949, 38, 1, 1 }, - { 0x1, 0x1, 160, 939, 2951, 38, 1, 1 }, - { 0x0, 0x0, 160, 940, 511, 0, 0, -1 }, - { 0x0, 0x0, 160, 941, 373, 0, 0, -1 }, - { 0x0, 0x0, 160, 942, 391, 0, 0, -1 }, - { 0x0, 0x0, 161, 1415, 2321, 0, 0, -1 }, - { 0x0, 0x0, 161, 1416, 2329, 0, 1, 55 }, - { 0x0, 0x0, 161, 1417, 2990, 0, 1, 55 }, - { 0x0, 0x0, 161, 1418, 2377, 0, 0, -1 }, - { 0x1, 0x1, 161, 1419, -1, 29, 1, 50 }, - { 0x0, 0x0, 162, -1, 2339, 0, 0, -1 }, - { 0x1, 0x9, 162, -1, 2343, 33, 1, 55 }, - { 0x1, 0x9, 162, -1, 2999, 33, 1, 55 }, - { 0x6, 0x7, 162, -1, 2384, 27, 1, 50 }, - { 0x0, 0x0, 163, 1401, 2337, 0, 0, -1 }, - { 0x0, 0x0, 163, 1402, 2341, 0, 1, 55 }, - { 0x0, 0x0, 163, 1403, 2998, 0, 1, 55 }, - { 0x1, 0x1, 163, 1404, 2383, 29, 1, 50 }, - { 0x1, 0x1, 164, 1422, -1, 27, 1, 34 }, - { 0x0, 0x0, 165, 2193, 2325, 0, 0, -1 }, - { 0x1, 0x1, 165, 2194, 2333, 33, 1, 55 }, - { 0x1, 0x1, 165, 2195, 2992, 33, 1, 55 }, - { 0x0, 0x0, 165, 2196, 2379, 0, 0, -1 }, - { 0x3, 0x3, 165, 2197, -1, 28, 1, 50 }, - { 0x0, 0x0, 166, 1410, 2323, 0, 0, -1 }, - { 0x1, 0x1, 166, 1411, 2331, 36, 1, 55 }, - { 0x1, 0x1, 166, 1412, 2991, 36, 1, 55 }, - { 0x0, 0x0, 166, 1413, 2378, 0, 0, -1 }, - { 0x5, 0x5, 166, 1414, -1, 27, 1, 50 }, - { 0x0, 0x0, 167, -1, 2962, 0, 1, 64 }, - { 0x0, 0x0, 167, -1, 2963, 0, 1, 64 }, - { 0x1, 0x1, 169, -1, -1, 28, 1, 34 }, - { 0x1, 0x1, 170, 2779, -1, 27, 1, 34 }, - { 0x1, 0x1, 170, 2780, -1, 27, 1, 34 }, - { 0x1, 0x1, 171, 1703, -1, 28, 1, 142 }, - { 0x1, 0x1, 171, 1704, -1, 28, 1, 142 }, - { 0x1, 0x1, 171, 1705, -1, 28, 1, 142 }, - { 0x1, 0x1, 171, 1706, -1, 28, 1, 142 }, - { 0x1, 0x1, 171, 1707, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1708, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1709, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1710, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1711, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1712, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1713, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1714, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1715, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1716, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1717, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1718, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1719, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1720, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1721, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1722, -1, 28, 1, 141 }, - { 0x1, 0x1, 171, 1723, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 1724, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 1725, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 1726, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 1727, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1728, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1729, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1730, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1731, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1732, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1733, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1734, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1735, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1736, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1737, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1738, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1739, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1740, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1741, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1742, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1743, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1744, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1745, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1746, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1747, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1748, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1749, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1750, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1751, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1752, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1753, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1754, -1, 28, 1, 132 }, - { 0x1, 0x1, 171, 1755, -1, 28, 1, 132 }, - { 0x1, 0x1, 171, 1756, -1, 28, 1, 132 }, - { 0x1, 0x1, 171, 1757, -1, 28, 1, 132 }, - { 0x1, 0x1, 171, 1758, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1759, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1760, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1761, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1762, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1763, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1764, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1765, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1766, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1767, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1768, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1769, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1770, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1771, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1772, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1773, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1774, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1775, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1776, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1777, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1778, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1779, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1780, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1781, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1782, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1783, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1784, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1785, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1786, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1787, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1788, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1789, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1790, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1791, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1792, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1793, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1794, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1795, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1796, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1797, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1798, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1799, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1800, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1801, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1802, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1803, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1804, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1805, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1806, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1807, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1808, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1809, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1810, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1811, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1812, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1813, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1814, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1815, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1816, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1817, -1, 28, 1, 136 }, - { 0x1, 0x1, 171, 1818, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1819, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1820, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1821, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1822, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1823, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1824, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1825, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1826, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1827, -1, 28, 1, 136 }, - { 0x1, 0x1, 171, 1828, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1829, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1830, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1831, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1832, -1, 28, 1, 133 }, - { 0x1, 0x1, 171, 1833, -1, 28, 1, 134 }, - { 0x1, 0x1, 171, 1834, -1, 28, 1, 135 }, - { 0x1, 0x1, 171, 1835, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1836, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1837, -1, 28, 1, 136 }, - { 0x1, 0x1, 171, 1838, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1839, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1840, -1, 28, 1, 137 }, - { 0x1, 0x1, 171, 1841, -1, 28, 1, 131 }, - { 0x1, 0x1, 171, 1842, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1843, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1844, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1845, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1846, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1847, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1848, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1849, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1850, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1851, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1852, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1853, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1854, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1855, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1856, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1857, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1858, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1859, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1860, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1861, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1862, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1863, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1864, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1865, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1866, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1867, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1868, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1869, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1870, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1871, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1872, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1873, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1874, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1875, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1876, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1877, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1878, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1879, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1880, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1881, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1882, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1883, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1884, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1885, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1886, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1887, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1888, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1889, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1890, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1891, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1892, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1893, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1894, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1895, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1896, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1897, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1898, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1899, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1900, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1901, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1902, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1903, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1904, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1905, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1906, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1907, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1908, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1909, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1910, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1911, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1912, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1913, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1914, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1915, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1916, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1917, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1918, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1919, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1920, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1921, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1922, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1923, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1924, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1925, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1926, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1927, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1928, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1929, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1930, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1931, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1932, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1933, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1934, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1935, -1, 28, 1, 148 }, - { 0x1, 0x1, 171, 1936, -1, 28, 1, 149 }, - { 0x1, 0x1, 171, 1937, -1, 28, 1, 150 }, - { 0x1, 0x1, 171, 1938, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1939, -1, 28, 1, 151 }, - { 0x1, 0x1, 171, 1940, -1, 28, 1, 147 }, - { 0x1, 0x1, 171, 1941, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1942, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1943, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1944, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1945, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1946, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1947, -1, 28, 1, 153 }, - { 0x1, 0x1, 171, 1948, -1, 28, 1, 154 }, - { 0x1, 0x1, 171, 1949, -1, 28, 1, 155 }, - { 0x1, 0x1, 171, 1950, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1951, -1, 28, 1, 156 }, - { 0x1, 0x1, 171, 1952, -1, 28, 1, 152 }, - { 0x1, 0x1, 171, 1691, -1, 28, 1, 158 }, - { 0x1, 0x1, 171, 1692, -1, 28, 1, 158 }, - { 0x1, 0x1, 171, 1693, -1, 28, 1, 158 }, - { 0x1, 0x1, 171, 1694, -1, 28, 1, 158 }, - { 0x1, 0x1, 171, 1695, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1696, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1697, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1698, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1699, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1700, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1701, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1702, -1, 28, 1, 159 }, - { 0x1, 0x1, 171, 1997, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 1998, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 1999, -1, 28, 1, 143 }, - { 0x1, 0x1, 171, 2000, -1, 28, 1, 143 }, - { 0x1, 0x1, 172, 1953, -1, 29, 1, 158 }, - { 0x1, 0x1, 172, 1954, -1, 29, 1, 158 }, - { 0x1, 0x1, 172, 1955, -1, 29, 1, 158 }, - { 0x1, 0x1, 172, 1956, -1, 29, 1, 158 }, - { 0x1, 0x1, 172, 1957, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1958, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1959, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1960, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1961, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1962, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1963, -1, 29, 1, 159 }, - { 0x1, 0x1, 172, 1964, -1, 29, 1, 159 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 142 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 142 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 142 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 142 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 141 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 271, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2258, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 273, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2259, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 275, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2260, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 132 }, - { 0x3, 0x3, 173, 277, -1, 28, 1, 132 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 132 }, - { 0x3, 0x3, 173, 278, -1, 28, 1, 132 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 279, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2261, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 281, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2262, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 283, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2263, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 285, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2264, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 287, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2265, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 289, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2266, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 136 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 291, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2267, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 136 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 293, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2268, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 133 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 134 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 135 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 136 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 295, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 137 }, - { 0x3, 0x3, 173, 2269, -1, 28, 1, 131 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2270, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2271, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2272, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2273, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2274, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2275, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2276, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2277, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2278, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2279, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2280, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2281, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2282, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2283, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2284, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 148 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 149 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 150 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 151 }, - { 0x3, 0x3, 173, 2285, -1, 28, 1, 147 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2286, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 153 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 154 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 155 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 156 }, - { 0x3, 0x3, 173, 2287, -1, 28, 1, 152 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 158 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 158 }, - { 0x3, 0x3, 173, 951, -1, 28, 1, 158 }, - { 0x3, 0x3, 173, 952, -1, 28, 1, 158 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, 953, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, 954, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, 955, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, 956, -1, 28, 1, 159 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, 2224, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, 2225, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 139 }, - { 0x3, 0x3, 173, 2226, -1, 28, 1, 139 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 139 }, - { 0x3, 0x3, 173, 2227, -1, 28, 1, 139 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, 2228, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, 2229, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, 2230, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, 2231, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 140 }, - { 0x3, 0x3, 173, 2232, -1, 28, 1, 138 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 146 }, - { 0x3, 0x3, 173, 2233, -1, 28, 1, 145 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 157 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 161 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 157 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 161 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 157 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 161 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 157 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 161 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 157 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 161 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x3, 0x3, 173, -1, -1, 28, 1, 143 }, - { 0x0, 0x0, 174, -1, 394, 0, 0, -1 }, - { 0x0, 0x0, 174, -1, 396, 0, 0, -1 }, - { 0x0, 0x0, 174, 3042, 3002, 0, 1, 1 }, - { 0x0, 0x0, 174, 3043, 3003, 0, 1, 1 }, - { 0x0, 0x0, 174, -1, 402, 0, 0, -1 }, - { 0x0, 0x0, 174, -1, 404, 0, 0, -1 }, - { 0x0, 0x0, 174, 3046, 3006, 0, 1, 76 }, - { 0x0, 0x0, 174, 3047, 3007, 0, 1, 76 }, - { 0x0, 0x0, 174, -1, 410, 0, 0, -1 }, - { 0x0, 0x0, 174, -1, 412, 0, 0, -1 }, - { 0x0, 0x0, 174, 3050, 3010, 0, 1, 1 }, - { 0x0, 0x0, 174, 3051, 3011, 0, 1, 1 }, - { 0x11, 0x31, 175, 2881, 417, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 418, 12, 1, 4 }, - { 0x11, 0x31, 175, 2073, 419, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 421, 12, 1, 4 }, - { 0x1, 0x1, 175, -1, 425, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 426, 12, 1, 4 }, - { 0x11, 0x11, 175, -1, 427, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 428, 12, 1, 4 }, - { 0x1, 0x1, 175, 2079, 429, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 431, 12, 1, 4 }, - { 0x11, 0x11, 175, 2081, 433, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 435, 12, 1, 4 }, - { 0x1, 0x1, 175, 2083, 437, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 439, 12, 1, 4 }, - { 0x11, 0x11, 175, 2085, 441, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 443, 12, 1, 4 }, - { 0x1, 0x1, 175, 2087, 445, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 447, 12, 1, 4 }, - { 0x11, 0x11, 175, 2089, 449, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 451, 12, 1, 4 }, - { 0x11, 0x31, 175, 2901, 457, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 458, 12, 1, 4 }, - { 0x11, 0x31, 175, 2095, 459, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 461, 12, 1, 4 }, - { 0x11, 0x31, 175, 2921, 465, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 466, 12, 1, 4 }, - { 0x11, 0x31, 175, 2121, 467, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 469, 12, 1, 4 }, - { 0x1, 0x1, 175, -1, 473, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 474, 12, 1, 4 }, - { 0x11, 0x11, 175, -1, 475, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 476, 12, 1, 4 }, - { 0x1, 0x1, 175, 2127, 477, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 479, 12, 1, 4 }, - { 0x11, 0x11, 175, 2129, 481, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 483, 12, 1, 4 }, - { 0x1, 0x1, 175, 2131, 485, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 487, 12, 1, 4 }, - { 0x11, 0x11, 175, 2133, 489, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 491, 12, 1, 4 }, - { 0x1, 0x1, 175, 2135, 493, 37, 1, 4 }, - { 0x2000001, 0x2000001, 175, -1, 495, 12, 1, 4 }, - { 0x11, 0x11, 175, 2137, 497, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 499, 12, 1, 4 }, - { 0x11, 0x31, 175, 2941, 505, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 506, 12, 1, 4 }, - { 0x11, 0x31, 175, 2143, 507, 33, 1, 4 }, - { 0x2200001, 0x2200001, 175, -1, 509, 12, 1, 4 }, - { 0x1, 0x1, 175, -1, 513, 33, 1, 4 }, - { 0x200001, 0x200001, 175, -1, 514, 12, 1, 4 }, - { 0x1, 0x1, 175, -1, 515, 33, 1, 4 }, - { 0x200001, 0x200001, 175, -1, 516, 12, 1, 4 }, - { 0x1, 0x1, 175, -1, 521, 33, 1, 79 }, - { 0x200001, 0x200001, 175, -1, 522, 12, 1, 79 }, - { 0x1, 0x1, 175, -1, 523, 33, 1, 79 }, - { 0x200001, 0x200001, 175, -1, 524, 12, 1, 79 }, - { 0x1, 0x1, 175, -1, 529, 33, 1, 4 }, - { 0x200001, 0x200001, 175, -1, 530, 12, 1, 4 }, - { 0x1, 0x1, 175, -1, 531, 33, 1, 4 }, - { 0x200001, 0x200001, 175, -1, 532, 12, 1, 4 }, - { 0x2200001, 0x6200001, 176, 2884, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2016, -1, 33, 1, 4 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x4200001, 0x4200001, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 37, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x1, 0x1, 176, 2022, -1, 37, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2024, -1, 33, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x1, 0x1, 176, 2026, -1, 37, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2028, -1, 33, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x1, 0x1, 176, 2030, -1, 37, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2032, -1, 33, 1, 4 }, - { 0x1, 0x1, 176, -1, -1, 37, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, -1, -1, 33, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x2200001, 0x6200001, 176, 2904, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2036, -1, 33, 1, 4 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x4200001, 0x4200001, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 37, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x2200001, 0x6200001, 176, 2924, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2040, -1, 33, 1, 4 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x4200001, 0x4200001, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 37, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x1, 0x1, 176, 2046, -1, 37, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2048, -1, 33, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x1, 0x1, 176, 2050, -1, 37, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2052, -1, 33, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x1, 0x1, 176, 2054, -1, 37, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2056, -1, 33, 1, 4 }, - { 0x1, 0x1, 176, -1, -1, 37, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, -1, -1, 33, 1, 4 }, - { 0x2200001, 0x2200001, 176, -1, -1, 12, 1, 4 }, - { 0x2200001, 0x6200001, 176, 2943, -1, 12, 1, 4 }, - { 0x11, 0x11, 176, 2060, -1, 33, 1, 4 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x4200001, 0x4200001, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 37, 1, 4 }, - { 0x2000001, 0x2000001, 176, -1, -1, 12, 1, 4 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 33, 1, 5 }, - { 0x200001, 0x200001, 176, -1, -1, 12, 1, 5 }, - { 0x0, 0x0, 176, -1, -1, 0, 1, 5 }, - { 0x1, 0x1, 176, -1, -1, 12, 1, 5 }, - { 0x9, 0x9, 176, -1, -1, 33, 1, 5 }, - { 0x1, 0x1, 176, 397, -1, 33, 1, 4 }, - { 0x1200001, 0x1200001, 176, -1, -1, 12, 1, 5 }, - { 0x200001, 0x200001, 176, 398, -1, 12, 1, 4 }, - { 0x9, 0x9, 176, -1, -1, 33, 1, 5 }, - { 0x1, 0x1, 176, 399, -1, 33, 1, 4 }, - { 0x1200001, 0x1200001, 176, -1, -1, 12, 1, 5 }, - { 0x200001, 0x200001, 176, 400, -1, 12, 1, 4 }, - { 0x9, 0x9, 176, -1, -1, 33, 1, 80 }, - { 0x1, 0x1, 176, 405, -1, 33, 1, 79 }, - { 0x1200001, 0x1200001, 176, -1, -1, 12, 1, 80 }, - { 0x200001, 0x200001, 176, 406, -1, 12, 1, 79 }, - { 0x9, 0x9, 176, -1, -1, 33, 1, 80 }, - { 0x1, 0x1, 176, 407, -1, 33, 1, 79 }, - { 0x1200001, 0x1200001, 176, -1, -1, 12, 1, 80 }, - { 0x200001, 0x200001, 176, 408, -1, 12, 1, 79 }, - { 0x9, 0x9, 176, -1, -1, 33, 1, 5 }, - { 0x1, 0x1, 176, 413, -1, 33, 1, 4 }, - { 0x1200001, 0x1200001, 176, -1, -1, 12, 1, 5 }, - { 0x200001, 0x200001, 176, 414, -1, 12, 1, 4 }, - { 0x9, 0x9, 176, -1, -1, 33, 1, 5 }, - { 0x1, 0x1, 176, 415, -1, 33, 1, 4 }, - { 0x1200001, 0x1200001, 176, -1, -1, 12, 1, 5 }, - { 0x200001, 0x200001, 176, 416, -1, 12, 1, 4 }, - { 0x0, 0x0, 177, -1, 2327, 0, 0, -1 }, - { 0x9, 0x9, 177, -1, 2335, 33, 1, 50 }, - { 0x9, 0x9, 177, -1, 2993, 33, 1, 50 }, - { 0x0, 0x0, 177, -1, 2380, 0, 0, -1 }, - { 0x7, 0x7, 177, -1, -1, 27, 1, 50 }, - { 0x1, 0x1, 197, -1, -1, 27, 1, 10 }, - { 0x1, 0x1, 211, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 211, -1, -1, 29, 1, 0 }, - { 0x2, 0x3, 211, 1169, -1, 27, 1, 34 }, - { 0x0, 0x0, 211, 1170, -1, 0, 1, 34 }, - { 0x0, 0x0, 211, 1171, -1, 0, 1, 0 }, - { 0x0, 0x0, 211, 1172, -1, 0, 1, 0 }, - { 0x0, 0x0, 211, 1173, -1, 0, 1, 0 }, - { 0x0, 0x0, 211, 1174, -1, 0, 1, 0 }, - { 0x0, 0x0, 211, 3026, -1, 0, 1, 100 }, - { 0x0, 0x0, 211, 3027, -1, 0, 1, 100 }, - { 0x0, 0x0, 211, 3028, 967, 0, 0, -1 }, - { 0x1, 0x1, 212, -1, -1, 27, 1, 0 }, - { 0x1, 0x1, 212, -1, -1, 27, 1, 0 }, - { 0x1, 0x1, 213, -1, 1426, 32, 1, 142 }, - { 0x1, 0x1, 213, -1, 1428, 32, 1, 142 }, - { 0x1, 0x1, 213, -1, 1430, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1432, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1434, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1436, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1438, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1440, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1442, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1444, 32, 1, 141 }, - { 0x1, 0x1, 213, -1, 1446, 32, 1, 143 }, - { 0x1, 0x1, 213, -1, 1448, 32, 1, 143 }, - { 0x1, 0x1, 213, -1, 1965, 32, 1, 138 }, - { 0x1, 0x1, 213, -1, 1967, 32, 1, 145 }, - { 0x1, 0x1, 213, -1, 1969, 32, 1, 139 }, - { 0x1, 0x1, 213, -1, 1971, 32, 1, 139 }, - { 0x1, 0x1, 213, -1, 1973, 32, 1, 138 }, - { 0x1, 0x1, 213, -1, 1975, 32, 1, 145 }, - { 0x1, 0x1, 213, -1, 1977, 32, 1, 138 }, - { 0x1, 0x1, 213, -1, 1979, 32, 1, 145 }, - { 0x1, 0x1, 213, 2783, 1981, 32, 1, 138 }, - { 0x1, 0x1, 213, 2784, 1984, 32, 1, 145 }, - { 0x0, 0x0, 214, -1, 2825, 0, 0, -1 }, - { 0x0, 0x0, 214, -1, 2826, 0, 0, -1 }, - { 0x0, 0x0, 214, -1, 2851, 0, 0, -1 }, - { 0x5, 0x5, 214, -1, 2854, 20, 1, 68 }, - { 0x0, 0x0, 218, 2209, 966, 0, 0, -1 }, - { 0x0, 0x0, 219, -1, 1139, 0, 0, -1 }, - { 0x0, 0x0, 219, -1, 1264, 0, 0, -1 }, - { 0x0, 0x0, 219, -1, -1, 0, 1, 128 }, - { 0x0, 0x0, 219, -1, -1, 0, 1, 67 }, - { 0x1, 0x1, 219, 833, 2289, 36, 1, 66 }, - { 0x1, 0x1, 219, 834, 2348, 36, 1, 66 }, - { 0x0, 0x0, 219, 835, 2351, 0, 0, -1 }, - { 0x1, 0x1, 219, 836, -1, 36, 1, 66 }, - { 0x0, 0x0, 219, 1423, -1, 0, 1, 34 }, - { 0x1, 0x1, 219, 837, 2356, 36, 1, 66 }, - { 0x0, 0x0, 219, 838, 2359, 0, 0, -1 }, - { 0x1, 0x1, 219, 839, -1, 36, 1, 66 }, - { 0x0, 0x0, 219, 840, 2362, 0, 0, -1 }, - { 0x1, 0x1, 219, 841, -1, 36, 1, 66 }, - { 0x1, 0x1, 219, 842, 2365, 36, 1, 66 }, - { 0x1, 0x1, 219, 843, 2368, 36, 1, 66 }, - { 0x0, 0x0, 219, 1424, -1, 0, 1, 34 }, - { 0x1, 0x1, 219, 844, 2401, 36, 1, 66 }, - { 0x1, 0x1, 219, 845, -1, 31, 1, 144 }, - { 0x1, 0x1, 219, 228, 1449, 32, 1, 133 }, - { 0x1, 0x1, 219, 229, 1458, 32, 1, 133 }, - { 0x1, 0x1, 219, 230, 1467, 32, 1, 133 }, - { 0x1, 0x1, 219, 231, 1480, 32, 1, 133 }, - { 0x1, 0x1, 219, 232, 1489, 32, 1, 133 }, - { 0x1, 0x1, 219, 233, 1498, 32, 1, 133 }, - { 0x1, 0x1, 219, 234, 1507, 32, 1, 133 }, - { 0x1, 0x1, 219, 235, 1516, 32, 1, 133 }, - { 0x1, 0x1, 219, 236, 1525, 32, 1, 133 }, - { 0x1, 0x1, 219, 237, 1534, 32, 1, 133 }, - { 0x1, 0x1, 219, 238, 1544, 32, 1, 133 }, - { 0x1, 0x1, 219, 239, 1554, 32, 1, 133 }, - { 0x1, 0x1, 219, 240, 1567, 32, 1, 148 }, - { 0x1, 0x1, 219, 241, 1573, 32, 1, 153 }, - { 0x1, 0x1, 219, 242, 1579, 32, 1, 153 }, - { 0x1, 0x1, 219, 243, 1585, 32, 1, 148 }, - { 0x1, 0x1, 219, 244, 1591, 32, 1, 153 }, - { 0x1, 0x1, 219, 245, 1597, 32, 1, 153 }, - { 0x1, 0x1, 219, 246, 1603, 32, 1, 148 }, - { 0x1, 0x1, 219, 247, 1609, 32, 1, 153 }, - { 0x1, 0x1, 219, 248, 1615, 32, 1, 153 }, - { 0x1, 0x1, 219, 249, 1621, 32, 1, 148 }, - { 0x1, 0x1, 219, 250, 1627, 32, 1, 153 }, - { 0x1, 0x1, 219, 251, 1633, 32, 1, 148 }, - { 0x1, 0x1, 219, 252, 1639, 32, 1, 153 }, - { 0x1, 0x1, 219, 253, 1645, 32, 1, 148 }, - { 0x1, 0x1, 219, 254, 1651, 32, 1, 153 }, - { 0x1, 0x1, 219, 255, 1657, 32, 1, 148 }, - { 0x1, 0x1, 219, 256, 1663, 32, 1, 153 }, - { 0x1, 0x1, 219, 257, 1669, 32, 1, 153 }, - { 0x1, 0x1, 219, 849, -1, 31, 1, 160 }, - { 0x0, 0x0, 220, 2404, -1, 0, 1, 66 }, - { 0x0, 0x0, 220, 2405, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 25, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2407, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2408, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2409, -1, 0, 1, 45 }, - { 0x0, 0x0, 220, 2410, -1, 0, 1, 40 }, - { 0x1, 0x1, 220, 2411, -1, 12, 1, 59 }, - { 0x0, 0x0, 220, 2412, -1, 0, 1, 54 }, - { 0x1000001, 0x1000001, 220, 2413, -1, 12, 1, 59 }, - { 0x1, 0x1, 220, 2414, -1, 36, 1, 54 }, - { 0x200001, 0x200001, 220, 2415, -1, 12, 1, 59 }, - { 0x1, 0x1, 220, 2416, -1, 33, 1, 54 }, - { 0x1200001, 0x1200001, 220, 2417, -1, 12, 1, 49 }, - { 0x9, 0x9, 220, 2418, -1, 33, 1, 49 }, - { 0x0, 0x0, 220, 2419, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2420, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2421, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2422, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2423, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2424, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2425, -1, 0, 1, 49 }, - { 0x0, 0x0, 220, 2426, -1, 0, 1, 49 }, - { 0x1, 0x1, 220, 2427, -1, 12, 1, 59 }, - { 0x0, 0x0, 220, 2428, -1, 0, 1, 54 }, - { 0x200001, 0x1200001, 220, 2429, -1, 12, 1, 59 }, - { 0x1, 0x9, 220, 2430, -1, 33, 1, 54 }, - { 0x0, 0x0, 220, 2431, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2432, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2433, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2434, -1, 0, 1, 54 }, - { 0x1, 0x1, 220, 2435, -1, 12, 1, 59 }, - { 0x0, 0x0, 220, 2436, -1, 0, 1, 54 }, - { 0x1000001, 0x1000001, 220, 2437, -1, 12, 1, 59 }, - { 0x1, 0x1, 220, 2438, -1, 36, 1, 54 }, - { 0x200001, 0x200001, 220, 2439, -1, 12, 1, 59 }, - { 0x1, 0x1, 220, 2440, -1, 33, 1, 54 }, - { 0x1200001, 0x1200001, 220, 2441, -1, 12, 1, 49 }, - { 0x9, 0x9, 220, 2442, -1, 33, 1, 49 }, - { 0x0, 0x0, 220, 2443, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2444, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2445, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2446, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2447, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2448, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2449, -1, 0, 1, 49 }, - { 0x0, 0x0, 220, 2450, -1, 0, 1, 49 }, - { 0x1, 0x1, 220, 2451, -1, 12, 1, 59 }, - { 0x0, 0x0, 220, 2452, -1, 0, 1, 54 }, - { 0x200001, 0x1200001, 220, 2453, -1, 12, 1, 59 }, - { 0x1, 0x9, 220, 2454, -1, 33, 1, 54 }, - { 0x0, 0x0, 220, 2455, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2456, -1, 0, 1, 54 }, - { 0x0, 0x0, 220, 2457, -1, 0, 1, 59 }, - { 0x0, 0x0, 220, 2458, -1, 0, 1, 54 }, - { 0x1, 0x1, 220, 2459, -1, 28, 1, 29 }, - { 0x0, 0x0, 220, 2460, -1, 0, 1, 29 }, - { 0x3, 0x3, 220, 2461, -1, 27, 1, 29 }, - { 0x1, 0x1, 220, 2462, -1, 27, 1, 29 }, - { 0x0, 0x0, 220, 2463, -1, 0, 1, 66 }, - { 0x0, 0x0, 220, 2464, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2465, -1, 0, 1, 29 }, - { 0x1, 0x1, 220, 2466, -1, 36, 1, 66 }, - { 0x1, 0x1, 220, 2467, -1, 37, 1, 29 }, - { 0x0, 0x0, 220, 2468, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2469, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2470, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2471, -1, 0, 1, 66 }, - { 0x0, 0x0, 220, 2472, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 37, -1, 0, 1, 29 }, - { 0x1, 0x1, 220, 2474, -1, 36, 1, 66 }, - { 0x1, 0x1, 220, 2475, -1, 37, 1, 29 }, - { 0x0, 0x0, 220, 2476, -1, 0, 1, 29 }, - { 0x1, 0x1, 220, 2477, -1, 36, 1, 66 }, - { 0x1, 0x1, 220, 2478, -1, 37, 1, 29 }, - { 0x0, 0x0, 220, 2479, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2480, -1, 0, 1, 66 }, - { 0x0, 0x0, 220, 2481, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 42, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2483, -1, 0, 1, 66 }, - { 0x0, 0x0, 220, 2484, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 43, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2486, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2487, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2488, -1, 0, 1, 49 }, - { 0x1, 0x1, 220, 2489, -1, 27, 1, 49 }, - { 0x1, 0x1, 220, 2490, -1, 28, 1, 49 }, - { 0x3, 0x3, 220, 2491, -1, 27, 1, 49 }, - { 0x1, 0x1, 220, 2492, -1, 29, 1, 49 }, - { 0x5, 0x5, 220, 2493, -1, 27, 1, 49 }, - { 0x3, 0x3, 220, 2494, -1, 28, 1, 49 }, - { 0x7, 0x7, 220, 2495, -1, 27, 1, 49 }, - { 0x0, 0x0, 220, 2496, -1, 0, 1, 49 }, - { 0x0, 0x0, 220, 2497, -1, 0, 1, 49 }, - { 0x0, 0x0, 220, 2498, -1, 0, 1, 49 }, - { 0x0, 0x0, 220, 2499, -1, 0, 1, 49 }, - { 0x1, 0x1, 220, 2500, -1, 28, 1, 29 }, - { 0x0, 0x0, 220, 2501, -1, 0, 1, 29 }, - { 0x3, 0x3, 220, 2502, -1, 27, 1, 29 }, - { 0x1, 0x1, 220, 2503, -1, 27, 1, 29 }, - { 0x0, 0x0, 220, 2504, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2505, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2506, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 52, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2508, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2509, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 57, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 2511, -1, 0, 1, 24 }, - { 0x0, 0x0, 220, 2512, -1, 0, 1, 24 }, - { 0x0, 0x0, 220, 2513, -1, 0, 1, 24 }, - { 0x0, 0x0, 220, 2514, -1, 0, 1, 24 }, - { 0x0, 0x0, 220, 2515, -1, 0, 1, 35 }, - { 0x0, 0x0, 220, 2516, -1, 0, 1, 66 }, - { 0x0, 0x0, 220, 2517, -1, 0, 1, 29 }, - { 0x0, 0x0, 220, 64, -1, 0, 1, 29 }, - { 0x1, 0x1, 221, 2519, -1, 34, 1, 66 }, - { 0x1, 0x1, 221, 2520, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2521, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2522, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2523, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2524, -1, 34, 1, 46 }, - { 0x1, 0x1, 221, 2525, -1, 34, 1, 42 }, - { 0x400001, 0x400001, 221, 2526, -1, 12, 1, 61 }, - { 0x1, 0x1, 221, 2527, -1, 34, 1, 56 }, - { 0x1400001, 0x1400001, 221, 2528, -1, 12, 1, 61 }, - { 0x5, 0x5, 221, 2529, -1, 34, 1, 56 }, - { 0x600001, 0x600001, 221, 2530, -1, 12, 1, 61 }, - { 0x3, 0x3, 221, 2531, -1, 33, 1, 56 }, - { 0x1600001, 0x1600001, 221, 2532, -1, 12, 1, 51 }, - { 0xb, 0xb, 221, 2533, -1, 33, 1, 51 }, - { 0x1, 0x1, 221, 2534, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2535, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2536, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2537, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2538, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2539, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2540, -1, 34, 1, 51 }, - { 0x1, 0x1, 221, 2541, -1, 34, 1, 51 }, - { 0x400001, 0x400001, 221, 2542, -1, 12, 1, 61 }, - { 0x1, 0x1, 221, 2543, -1, 34, 1, 56 }, - { 0x600001, 0x1600001, 221, 2544, -1, 12, 1, 61 }, - { 0x3, 0xb, 221, 2545, -1, 33, 1, 56 }, - { 0x1, 0x1, 221, 2546, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2547, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2548, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2549, -1, 34, 1, 56 }, - { 0x400001, 0x400001, 221, 2550, -1, 12, 1, 61 }, - { 0x1, 0x1, 221, 2551, -1, 34, 1, 56 }, - { 0x1400001, 0x1400001, 221, 2552, -1, 12, 1, 61 }, - { 0x5, 0x5, 221, 2553, -1, 34, 1, 56 }, - { 0x600001, 0x600001, 221, 2554, -1, 12, 1, 61 }, - { 0x3, 0x3, 221, 2555, -1, 33, 1, 56 }, - { 0x1600001, 0x1600001, 221, 2556, -1, 12, 1, 51 }, - { 0xb, 0xb, 221, 2557, -1, 33, 1, 51 }, - { 0x1, 0x1, 221, 2558, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2559, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2560, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2561, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2562, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2563, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2564, -1, 34, 1, 51 }, - { 0x1, 0x1, 221, 2565, -1, 34, 1, 51 }, - { 0x400001, 0x400001, 221, 2566, -1, 12, 1, 61 }, - { 0x1, 0x1, 221, 2567, -1, 34, 1, 56 }, - { 0x600001, 0x1600001, 221, 2568, -1, 12, 1, 61 }, - { 0x3, 0xb, 221, 2569, -1, 33, 1, 56 }, - { 0x1, 0x1, 221, 2570, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2571, -1, 34, 1, 56 }, - { 0x1, 0x1, 221, 2572, -1, 34, 1, 61 }, - { 0x1, 0x1, 221, 2573, -1, 34, 1, 56 }, - { 0x41, 0x41, 221, 2574, -1, 28, 1, 31 }, - { 0x1, 0x1, 221, 2575, -1, 34, 1, 31 }, - { 0x83, 0x83, 221, 2576, -1, 27, 1, 31 }, - { 0x81, 0x81, 221, 2577, -1, 27, 1, 31 }, - { 0x1, 0x1, 221, 2578, -1, 34, 1, 66 }, - { 0x1, 0x1, 221, 2579, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2580, -1, 34, 1, 31 }, - { 0x5, 0x5, 221, 2581, -1, 34, 1, 66 }, - { 0x9, 0x9, 221, 2582, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2583, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2584, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2585, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2586, -1, 34, 1, 66 }, - { 0x1, 0x1, 221, 2587, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2588, -1, 34, 1, 31 }, - { 0x5, 0x5, 221, 2589, -1, 34, 1, 66 }, - { 0x9, 0x9, 221, 2590, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2591, -1, 34, 1, 31 }, - { 0x5, 0x5, 221, 2592, -1, 34, 1, 66 }, - { 0x9, 0x9, 221, 2593, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2594, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2595, -1, 34, 1, 66 }, - { 0x1, 0x1, 221, 2596, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2597, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2598, -1, 34, 1, 66 }, - { 0x1, 0x1, 221, 2599, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2600, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2601, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2602, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2603, -1, 34, 1, 51 }, - { 0x81, 0x81, 221, 2604, -1, 27, 1, 51 }, - { 0x41, 0x41, 221, 2605, -1, 28, 1, 51 }, - { 0x83, 0x83, 221, 2606, -1, 27, 1, 51 }, - { 0x21, 0x21, 221, 2607, -1, 29, 1, 51 }, - { 0x85, 0x85, 221, 2608, -1, 27, 1, 51 }, - { 0x43, 0x43, 221, 2609, -1, 28, 1, 51 }, - { 0x87, 0x87, 221, 2610, -1, 27, 1, 51 }, - { 0x1, 0x1, 221, 2611, -1, 34, 1, 51 }, - { 0x1, 0x1, 221, 2612, -1, 34, 1, 51 }, - { 0x1, 0x1, 221, 2613, -1, 34, 1, 51 }, - { 0x1, 0x1, 221, 2614, -1, 34, 1, 51 }, - { 0x41, 0x41, 221, 2615, -1, 28, 1, 31 }, - { 0x1, 0x1, 221, 2616, -1, 34, 1, 31 }, - { 0x83, 0x83, 221, 2617, -1, 27, 1, 31 }, - { 0x81, 0x81, 221, 2618, -1, 27, 1, 31 }, - { 0x1, 0x1, 221, 2619, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2620, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2621, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2622, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2623, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2624, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2625, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2626, -1, 34, 1, 26 }, - { 0x1, 0x1, 221, 2627, -1, 34, 1, 26 }, - { 0x1, 0x1, 221, 2628, -1, 34, 1, 26 }, - { 0x1, 0x1, 221, 2629, -1, 34, 1, 26 }, - { 0x1, 0x1, 221, 2630, -1, 34, 1, 37 }, - { 0x1, 0x1, 221, 2631, -1, 34, 1, 66 }, - { 0x1, 0x1, 221, 2632, -1, 34, 1, 31 }, - { 0x1, 0x1, 221, 2633, -1, 34, 1, 31 }, - { 0x1, 0x1, 222, 2634, -1, 35, 1, 66 }, - { 0x1, 0x1, 222, 2635, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2636, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2637, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2638, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2639, -1, 35, 1, 47 }, - { 0x1, 0x1, 222, 2640, -1, 35, 1, 43 }, - { 0x800001, 0x800001, 222, 2641, -1, 12, 1, 62 }, - { 0x1, 0x1, 222, 2642, -1, 35, 1, 57 }, - { 0x1800001, 0x1800001, 222, 2643, -1, 12, 1, 62 }, - { 0x3, 0x3, 222, 2644, -1, 35, 1, 57 }, - { 0xa00001, 0xa00001, 222, 2645, -1, 12, 1, 62 }, - { 0x5, 0x5, 222, 2646, -1, 33, 1, 57 }, - { 0x1a00001, 0x1a00001, 222, 2647, -1, 12, 1, 52 }, - { 0xd, 0xd, 222, 2648, -1, 33, 1, 52 }, - { 0x1, 0x1, 222, 2649, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2650, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2651, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2652, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2653, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2654, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2655, -1, 35, 1, 52 }, - { 0x1, 0x1, 222, 2656, -1, 35, 1, 52 }, - { 0x800001, 0x800001, 222, 2657, -1, 12, 1, 62 }, - { 0x1, 0x1, 222, 2658, -1, 35, 1, 57 }, - { 0xa00001, 0x1a00001, 222, 2659, -1, 12, 1, 62 }, - { 0x5, 0xd, 222, 2660, -1, 33, 1, 57 }, - { 0x1, 0x1, 222, 2661, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2662, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2663, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2664, -1, 35, 1, 57 }, - { 0x800001, 0x800001, 222, 2665, -1, 12, 1, 62 }, - { 0x1, 0x1, 222, 2666, -1, 35, 1, 57 }, - { 0x1800001, 0x1800001, 222, 2667, -1, 12, 1, 62 }, - { 0x3, 0x3, 222, 2668, -1, 35, 1, 57 }, - { 0xa00001, 0xa00001, 222, 2669, -1, 12, 1, 62 }, - { 0x5, 0x5, 222, 2670, -1, 33, 1, 57 }, - { 0x1a00001, 0x1a00001, 222, 2671, -1, 12, 1, 52 }, - { 0xd, 0xd, 222, 2672, -1, 33, 1, 52 }, - { 0x1, 0x1, 222, 2673, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2674, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2675, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2676, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2677, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2678, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2679, -1, 35, 1, 52 }, - { 0x1, 0x1, 222, 2680, -1, 35, 1, 52 }, - { 0x800001, 0x800001, 222, 2681, -1, 12, 1, 62 }, - { 0x1, 0x1, 222, 2682, -1, 35, 1, 57 }, - { 0xa00001, 0x1a00001, 222, 2683, -1, 12, 1, 62 }, - { 0x5, 0xd, 222, 2684, -1, 33, 1, 57 }, - { 0x1, 0x1, 222, 2685, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2686, -1, 35, 1, 57 }, - { 0x1, 0x1, 222, 2687, -1, 35, 1, 62 }, - { 0x1, 0x1, 222, 2688, -1, 35, 1, 57 }, - { 0x81, 0x81, 222, 2689, -1, 28, 1, 32 }, - { 0x1, 0x1, 222, 2690, -1, 35, 1, 32 }, - { 0x103, 0x103, 222, 2691, -1, 27, 1, 32 }, - { 0x101, 0x101, 222, 2692, -1, 27, 1, 32 }, - { 0x1, 0x1, 222, 2693, -1, 35, 1, 66 }, - { 0x1, 0x1, 222, 2694, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2695, -1, 35, 1, 32 }, - { 0x3, 0x3, 222, 2696, -1, 35, 1, 66 }, - { 0x5, 0x5, 222, 2697, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2698, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2699, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2700, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2701, -1, 35, 1, 66 }, - { 0x1, 0x1, 222, 2702, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2703, -1, 35, 1, 32 }, - { 0x3, 0x3, 222, 2704, -1, 35, 1, 66 }, - { 0x5, 0x5, 222, 2705, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2706, -1, 35, 1, 32 }, - { 0x3, 0x3, 222, 2707, -1, 35, 1, 66 }, - { 0x5, 0x5, 222, 2708, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2709, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2710, -1, 35, 1, 66 }, - { 0x1, 0x1, 222, 2711, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2712, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2713, -1, 35, 1, 66 }, - { 0x1, 0x1, 222, 2714, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2715, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2716, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2717, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2718, -1, 35, 1, 52 }, - { 0x101, 0x101, 222, 2719, -1, 27, 1, 52 }, - { 0x81, 0x81, 222, 2720, -1, 28, 1, 52 }, - { 0x103, 0x103, 222, 2721, -1, 27, 1, 52 }, - { 0x41, 0x41, 222, 2722, -1, 29, 1, 52 }, - { 0x105, 0x105, 222, 2723, -1, 27, 1, 52 }, - { 0x83, 0x83, 222, 2724, -1, 28, 1, 52 }, - { 0x107, 0x107, 222, 2725, -1, 27, 1, 52 }, - { 0x1, 0x1, 222, 2726, -1, 35, 1, 52 }, - { 0x1, 0x1, 222, 2727, -1, 35, 1, 52 }, - { 0x1, 0x1, 222, 2728, -1, 35, 1, 52 }, - { 0x1, 0x1, 222, 2729, -1, 35, 1, 52 }, - { 0x81, 0x81, 222, 2730, -1, 28, 1, 32 }, - { 0x1, 0x1, 222, 2731, -1, 35, 1, 32 }, - { 0x103, 0x103, 222, 2732, -1, 27, 1, 32 }, - { 0x101, 0x101, 222, 2733, -1, 27, 1, 32 }, - { 0x1, 0x1, 222, 2734, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2735, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2736, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2737, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2738, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2739, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2740, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2741, -1, 35, 1, 27 }, - { 0x1, 0x1, 222, 2742, -1, 35, 1, 27 }, - { 0x1, 0x1, 222, 2743, -1, 35, 1, 27 }, - { 0x1, 0x1, 222, 2744, -1, 35, 1, 27 }, - { 0x1, 0x1, 222, 2745, -1, 35, 1, 38 }, - { 0x1, 0x1, 222, 2746, -1, 35, 1, 66 }, - { 0x1, 0x1, 222, 2747, -1, 35, 1, 32 }, - { 0x1, 0x1, 222, 2748, -1, 35, 1, 32 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 66 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2243, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 48 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 44 }, - { 0xc00001, 0xc00001, 223, -1, -1, 12, 1, 63 }, - { 0x3, 0x3, 223, 2964, -1, 34, 1, 58 }, - { 0x1c00001, 0x1c00001, 223, -1, -1, 12, 1, 63 }, - { 0x7, 0x7, 223, 2965, -1, 34, 1, 58 }, - { 0xe00001, 0xe00001, 223, -1, -1, 12, 1, 63 }, - { 0x7, 0x7, 223, 2966, -1, 33, 1, 58 }, - { 0x1e00001, 0x1e00001, 223, -1, -1, 12, 1, 53 }, - { 0xf, 0xf, 223, 2967, -1, 33, 1, 53 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2968, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2969, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2970, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0x3, 0x3, 223, 2971, -1, 34, 1, 53 }, - { 0xc00001, 0xc00001, 223, -1, -1, 12, 1, 63 }, - { 0x3, 0x3, 223, 2976, -1, 34, 1, 58 }, - { 0xe00001, 0x1e00001, 223, -1, -1, 12, 1, 63 }, - { 0x7, 0xf, 223, 2977, -1, 33, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2978, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2979, -1, 34, 1, 58 }, - { 0xc00001, 0xc00001, 223, -1, -1, 12, 1, 63 }, - { 0x3, 0x3, 223, 2982, -1, 34, 1, 58 }, - { 0x1c00001, 0x1c00001, 223, -1, -1, 12, 1, 63 }, - { 0x7, 0x7, 223, 2983, -1, 34, 1, 58 }, - { 0xe00001, 0xe00001, 223, -1, -1, 12, 1, 63 }, - { 0x7, 0x7, 223, 2984, -1, 33, 1, 58 }, - { 0x1e00001, 0x1e00001, 223, -1, -1, 12, 1, 53 }, - { 0xf, 0xf, 223, 2985, -1, 33, 1, 53 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2986, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2987, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2988, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0x3, 0x3, 223, 2989, -1, 34, 1, 53 }, - { 0xc00001, 0xc00001, 223, -1, -1, 12, 1, 63 }, - { 0x3, 0x3, 223, 2994, -1, 34, 1, 58 }, - { 0xe00001, 0x1e00001, 223, -1, -1, 12, 1, 63 }, - { 0x7, 0xf, 223, 2995, -1, 33, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2996, -1, 34, 1, 58 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 63 }, - { 0x3, 0x3, 223, 2997, -1, 34, 1, 58 }, - { 0xc1, 0xc1, 223, -1, -1, 28, 1, 33 }, - { 0x3, 0x3, 223, 2862, -1, 34, 1, 33 }, - { 0x183, 0x183, 223, -1, -1, 27, 1, 33 }, - { 0x181, 0x181, 223, 2863, -1, 27, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 66 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2244, -1, 34, 1, 33 }, - { 0x7, 0x7, 223, -1, -1, 34, 1, 66 }, - { 0xb, 0xb, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2245, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 66 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2248, -1, 34, 1, 33 }, - { 0x7, 0x7, 223, -1, -1, 34, 1, 66 }, - { 0xb, 0xb, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2249, -1, 34, 1, 33 }, - { 0x7, 0x7, 223, -1, -1, 34, 1, 66 }, - { 0xb, 0xb, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2251, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 66 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2253, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 66 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2254, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0x181, 0x181, 223, -1, -1, 27, 1, 53 }, - { 0xc1, 0xc1, 223, -1, -1, 28, 1, 53 }, - { 0x183, 0x183, 223, -1, -1, 27, 1, 53 }, - { 0x61, 0x61, 223, -1, -1, 29, 1, 53 }, - { 0x185, 0x185, 223, -1, -1, 27, 1, 53 }, - { 0xc3, 0xc3, 223, -1, -1, 28, 1, 53 }, - { 0x187, 0x187, 223, -1, -1, 27, 1, 53 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 53 }, - { 0xc1, 0xc1, 223, -1, -1, 28, 1, 33 }, - { 0x3, 0x3, 223, 2866, -1, 34, 1, 33 }, - { 0x183, 0x183, 223, -1, -1, 27, 1, 33 }, - { 0x181, 0x181, 223, 2867, -1, 27, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 28 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 28 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 28 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 28 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 39 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 66 }, - { 0x3, 0x3, 223, -1, -1, 34, 1, 33 }, - { 0x3, 0x3, 223, 2256, -1, 34, 1, 33 }, - { 0x3, 0x3, 224, 540, 1451, 32, 1, 135 }, - { 0x3, 0x3, 224, 541, 1460, 32, 1, 135 }, - { 0x3, 0x3, 224, 542, 1469, 32, 1, 135 }, - { 0x3, 0x3, 224, 543, 1482, 32, 1, 135 }, - { 0x3, 0x3, 224, 544, 1491, 32, 1, 135 }, - { 0x3, 0x3, 224, 545, 1500, 32, 1, 135 }, - { 0x3, 0x3, 224, 546, 1509, 32, 1, 135 }, - { 0x3, 0x3, 224, 547, 1518, 32, 1, 135 }, - { 0x3, 0x3, 224, 548, 1527, 32, 1, 135 }, - { 0x3, 0x3, 224, 549, 1536, 32, 1, 135 }, - { 0x3, 0x3, 224, 550, 1546, 32, 1, 135 }, - { 0x3, 0x3, 224, 551, 1556, 32, 1, 135 }, - { 0x3, 0x3, 224, 564, 1569, 32, 1, 150 }, - { 0x3, 0x3, 224, 565, 1575, 32, 1, 155 }, - { 0x3, 0x3, 224, 566, 1581, 32, 1, 155 }, - { 0x3, 0x3, 224, 567, 1587, 32, 1, 150 }, - { 0x3, 0x3, 224, 568, 1593, 32, 1, 155 }, - { 0x3, 0x3, 224, 569, 1599, 32, 1, 155 }, - { 0x3, 0x3, 224, 570, 1605, 32, 1, 150 }, - { 0x3, 0x3, 224, 571, 1611, 32, 1, 155 }, - { 0x3, 0x3, 224, 572, 1617, 32, 1, 155 }, - { 0x3, 0x3, 224, 573, 1623, 32, 1, 150 }, - { 0x3, 0x3, 224, 574, 1629, 32, 1, 155 }, - { 0x3, 0x3, 224, 575, 1635, 32, 1, 150 }, - { 0x3, 0x3, 224, 576, 1641, 32, 1, 155 }, - { 0x3, 0x3, 224, 577, 1647, 32, 1, 150 }, - { 0x3, 0x3, 224, 578, 1653, 32, 1, 155 }, - { 0x3, 0x3, 224, 579, 1659, 32, 1, 150 }, - { 0x3, 0x3, 224, 580, 1665, 32, 1, 155 }, - { 0x3, 0x3, 224, 581, 1671, 32, 1, 155 }, - { 0x1, 0x1, 225, -1, -1, 28, 1, 34 }, - { 0x1, 0x1, 225, -1, -1, 28, 1, 34 }, - { 0x0, 0x0, 232, 958, -1, 0, 1, 144 }, - { 0x0, 0x0, 232, 959, -1, 0, 1, 160 }, - { 0x1, 0x1, 233, -1, 1982, 33, 1, 140 }, - { 0x1, 0x1, 233, -1, 1985, 33, 1, 146 }, - { 0x0, 0x0, 233, -1, 1987, 0, 1, 157 }, - { 0x0, 0x0, 233, -1, 1988, 0, 1, 161 }, - { 0x0, 0x0, 234, 883, 971, 0, 0, -1 }, - { 0x0, 0x0, 234, 884, 979, 0, 0, -1 }, - { 0x0, 0x0, 234, 885, 975, 0, 0, -1 }, - { 0x1, 0x1, 234, 886, 620, 33, 1, 6 }, - { 0x8000001, 0x8000001, 234, 887, 628, 6, 1, 7 }, - { 0x1, 0x1, 234, 888, 624, 33, 1, 6 }, - { 0x0, 0x0, 234, 889, 983, 0, 0, -1 }, - { 0x1, 0x1, 234, 890, 640, 33, 1, 8 }, - { 0x0, 0x0, 234, 891, 987, 0, 0, -1 }, - { 0x1, 0x1, 234, 892, 652, 33, 1, 16 }, - { 0x0, 0x0, 234, 893, 992, 0, 0, -1 }, - { 0x0, 0x0, 234, 894, 996, 0, 0, -1 }, - { 0x1, 0x1, 234, 895, 675, 33, 1, 18 }, - { 0x1, 0x1, 234, 896, 679, 33, 1, 18 }, - { 0x0, 0x0, 234, 897, 1000, 0, 0, -1 }, - { 0x0, 0x0, 234, 898, 1004, 0, 0, -1 }, - { 0x1, 0x1, 234, 899, 699, 33, 1, 19 }, - { 0x8000001, 0x8000001, 234, 900, 703, 6, 1, 19 }, - { 0x0, 0x0, 234, 901, 1008, 0, 0, -1 }, - { 0x1, 0x1, 234, 902, 715, 33, 1, 20 }, - { 0x0, 0x0, 234, 903, 1012, 0, 0, -1 }, - { 0x0, 0x0, 234, 904, 1016, 0, 0, -1 }, - { 0x1, 0x1, 234, 905, 735, 33, 1, 21 }, - { 0x8000001, 0x8000001, 234, 906, 739, 6, 1, 21 }, - { 0x0, 0x0, 234, 907, 1020, 0, 0, -1 }, - { 0x1, 0x1, 234, 908, 751, 33, 1, 22 }, - { 0x0, 0x0, 234, 909, 1025, 0, 0, -1 }, - { 0x0, 0x0, 234, 910, 1029, 0, 0, -1 }, - { 0x1, 0x1, 234, 911, 774, 33, 1, 18 }, - { 0x1, 0x1, 234, 912, 778, 33, 1, 18 }, - { 0x0, 0x0, 234, 913, 1033, 0, 0, -1 }, - { 0x1, 0x1, 234, 914, 790, 33, 1, 22 }, - { 0x0, 0x0, 235, 2787, 970, 0, 0, -1 }, - { 0x0, 0x0, 235, 2788, 978, 0, 0, -1 }, - { 0x0, 0x0, 235, 2789, 974, 0, 0, -1 }, - { 0x0, 0x0, 235, 2790, 619, 0, 1, 6 }, - { 0x1, 0x1, 235, 2791, 627, 6, 1, 7 }, - { 0x0, 0x0, 235, 2792, 623, 0, 1, 6 }, - { 0x0, 0x0, 235, 2793, 982, 0, 0, -1 }, - { 0x0, 0x0, 235, 2794, 639, 0, 1, 8 }, - { 0x0, 0x0, 235, 2795, 986, 0, 0, -1 }, - { 0x0, 0x0, 235, 2796, 651, 0, 1, 16 }, - { 0x0, 0x0, 235, 2797, 991, 0, 0, -1 }, - { 0x0, 0x0, 235, 2798, 995, 0, 0, -1 }, - { 0x0, 0x0, 235, 2799, 674, 0, 1, 18 }, - { 0x0, 0x0, 235, 2800, 678, 0, 1, 18 }, - { 0x0, 0x0, 235, 2801, 999, 0, 0, -1 }, - { 0x0, 0x0, 235, 2802, 1003, 0, 0, -1 }, - { 0x0, 0x0, 235, 2803, 698, 0, 1, 19 }, - { 0x1, 0x1, 235, 2804, 702, 6, 1, 19 }, - { 0x0, 0x0, 235, 2805, 1007, 0, 0, -1 }, - { 0x0, 0x0, 235, 2806, 714, 0, 1, 20 }, - { 0x0, 0x0, 235, 2807, 1011, 0, 0, -1 }, - { 0x0, 0x0, 235, 2808, 1015, 0, 0, -1 }, - { 0x0, 0x0, 235, 2809, 734, 0, 1, 21 }, - { 0x1, 0x1, 235, 2810, 738, 6, 1, 21 }, - { 0x0, 0x0, 235, 2811, 1019, 0, 0, -1 }, - { 0x0, 0x0, 235, 2812, 750, 0, 1, 22 }, - { 0x0, 0x0, 235, 2813, 1024, 0, 0, -1 }, - { 0x0, 0x0, 235, 2814, 1028, 0, 0, -1 }, - { 0x0, 0x0, 235, 2815, 773, 0, 1, 18 }, - { 0x0, 0x0, 235, 2816, 777, 0, 1, 18 }, - { 0x0, 0x0, 235, 2817, 1032, 0, 0, -1 }, - { 0x0, 0x0, 235, 2818, 789, 0, 1, 22 }, - { 0x1, 0x1, 235, 915, 1155, 27, 1, 17 }, - { 0x0, 0x0, 235, 916, 1153, 0, 1, 17 }, - { 0x0, 0x0, 235, 1220, 1157, 0, 1, 23 }, - { 0x0, 0x1, 235, 1165, 1163, 20, 1, 68 }, - { 0x0, 0x0, 235, 111, 1161, 0, 1, 68 }, - { 0x1, 0x1, 238, -1, -1, 29, 1, 0 }, - { 0x0, 0x0, 238, -1, -1, 0, 1, 0 }, - { 0x1, 0x1, 238, 3022, -1, 27, 1, 0 }, - { 0x1, 0x1, 238, 3023, -1, 27, 1, 0 }, - { 0x1, 0x1, 238, 3024, -1, 27, 1, 0 }, - { 0x1, 0x1, 238, 3025, -1, 27, 1, 0 }, - { 0x0, 0x0, 261, -1, 2344, 0, 0, -1 }, - { 0x0, 0x0, 261, -1, 2346, 0, 0, -1 }, - { 0x1, 0x1, 261, -1, -1, 28, 1, 30 }, - { 0x1, 0x1, 261, -1, -1, 28, 1, 30 }, - { 0x0, 0x0, 261, -1, 2385, 0, 0, -1 }, - { 0x0, 0x0, 261, -1, 2387, 0, 0, -1 }, - { 0x1, 0x1, 261, -1, -1, 28, 1, 30 }, - { 0x1, 0x1, 261, -1, -1, 28, 1, 30 }, - { 0x0, 0x0, 263, 23, -1, 0, 1, 0 }, - { 0x0, 0x0, 263, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 263, -1, -1, 0, 1, 0 }, - { 0x0, 0x1, 263, -1, -1, 29, 1, 0 }, - { 0x0, 0x1, 263, -1, -1, 29, 1, 0 }, - { 0x0, 0x1, 263, -1, -1, 29, 1, 0 }, - { 0x0, 0x1, 263, -1, -1, 29, 1, 0 }, - { 0x0, 0x1, 263, -1, -1, 29, 1, 0 }, - { 0x0, 0x0, 263, 180, -1, 0, 1, 0 }, - { 0x0, 0x1, 263, -1, -1, 29, 1, 0 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 301, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 323, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 349, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 371, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 65 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 65 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 65 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 65 }, - { 0x0, 0x0, 264, -1, 2296, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2298, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2300, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2302, 0, 0, -1 }, - { 0x1, 0x1, 264, -1, 2304, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2306, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2308, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2310, 12, 1, 50 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 50 }, - { 0x0, 0x0, 264, -1, 2312, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2314, 0, 0, -1 }, - { 0x1, 0x1, 264, -1, 2316, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2318, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x0, 0x0, 264, -1, 2320, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2322, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2324, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2326, 0, 0, -1 }, - { 0x1, 0x1, 264, -1, 2328, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2330, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2332, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2334, 12, 1, 50 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 50 }, - { 0x0, 0x0, 264, -1, 2336, 0, 0, -1 }, - { 0x0, 0x0, 264, -1, 2338, 0, 0, -1 }, - { 0x1, 0x1, 264, -1, 2340, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, 2342, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, -1, -1, 12, 1, 60 }, - { 0x1, 0x1, 264, 393, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 395, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 517, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 519, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 401, -1, 12, 1, 77 }, - { 0x1, 0x1, 264, 403, -1, 12, 1, 77 }, - { 0x1, 0x1, 264, 525, -1, 12, 1, 77 }, - { 0x1, 0x1, 264, 527, -1, 12, 1, 77 }, - { 0x1, 0x1, 264, 409, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 411, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 533, -1, 12, 1, 2 }, - { 0x1, 0x1, 264, 535, -1, 12, 1, 2 }, - { 0x0, 0x0, 265, -1, 2303, 0, 0, -1 }, - { 0x9, 0x9, 265, -1, 2311, 33, 1, 50 }, - { 0x9, 0x9, 265, -1, 2975, 33, 1, 50 }, - { 0x0, 0x0, 265, 1399, 2376, 0, 0, -1 }, - { 0x3, 0x3, 265, 1400, -1, 27, 1, 50 }, - { 0x0, 0x0, 269, 2856, -1, 0, 1, 0 }, - { 0x3, 0x3, 270, -1, -1, 27, 1, 0 }, - { 0x3, 0x3, 270, -1, -1, 27, 1, 0 }, - { 0x3, 0x3, 270, -1, -1, 27, 1, 0 }, - { 0x3, 0x3, 270, -1, -1, 27, 1, 0 }, - { 0x1, 0x1, 271, 3018, -1, 28, 1, 0 }, - { 0x1, 0x1, 271, 3019, -1, 28, 1, 0 }, - { 0x1, 0x1, 271, 3020, -1, 28, 1, 0 }, - { 0x1, 0x1, 271, 3021, -1, 28, 1, 0 }, - { 0x1, 0x1, 273, -1, -1, 27, 1, 100 }, - { 0x1, 0x1, 273, -1, -1, 27, 1, 100 }, - { 0x0, 0x0, 273, -1, 968, 0, 0, -1 }, - { 0x0, 0x0, 274, 3031, 2833, 0, 0, -1 }, - { 0x0, 0x0, 274, 3032, 2835, 0, 0, -1 }, - { 0x0, 0x0, 275, -1, 2834, 0, 0, -1 }, - { 0x0, 0x0, 275, -1, 2836, 0, 0, -1 }, - { 0x0, 0x0, 276, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 276, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 276, -1, -1, 0, 1, 41 }, - { 0x0, 0x0, 281, -1, -1, 0, 1, 34 }, - { 0x0, 0x0, 285, -1, 2350, 0, 1, 30 }, - { 0x0, 0x0, 286, -1, -1, 0, 1, 0 }, - { 0x0, 0x0, 286, -1, -1, 0, 1, 72 }, - { 0x0, 0x0, 286, 2001, 3000, 0, 1, 1 }, - { 0x0, 0x0, 286, 2002, 3001, 0, 1, 1 }, - { 0x0, 0x0, 286, -1, 518, 0, 0, -1 }, - { 0x0, 0x0, 286, -1, 520, 0, 0, -1 }, - { 0x0, 0x0, 286, 2005, 3004, 0, 1, 76 }, - { 0x0, 0x0, 286, 2006, 3005, 0, 1, 76 }, - { 0x0, 0x0, 286, -1, 526, 0, 0, -1 }, - { 0x0, 0x0, 286, -1, 528, 0, 0, -1 }, - { 0x0, 0x0, 286, 2009, 3008, 0, 1, 1 }, - { 0x0, 0x0, 286, 2010, 3009, 0, 1, 1 }, - { 0x0, 0x0, 286, -1, 534, 0, 0, -1 }, - { 0x0, 0x0, 286, -1, 536, 0, 0, -1 }, -}; - -static const struct ia64_main_table -main_table[] = { - { 5, 1, 1, 0x0000010000000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 0, }, - { 5, 1, 1, 0x0000010008000000ull, 0x000001eff8000000ull, { 24, 25, 26, 4, 0 }, 0x0, 1, }, - { 5, 7, 1, 0x0000000000000000ull, 0x0000000000000000ull, { 24, 67, 27, 0, 0 }, 0x0, 2, }, - { 5, 7, 1, 0x0000000000000000ull, 0x0000000000000000ull, { 24, 64, 26, 0, 0 }, 0x0, 3, }, - { 6, 1, 1, 0x0000012000000000ull, 0x000001e000000000ull, { 24, 67, 27, 0, 0 }, 0x0, 4, }, - { 7, 1, 1, 0x0000010040000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 5, }, - { 7, 1, 1, 0x0000010c00000000ull, 0x000001ee00000000ull, { 24, 64, 26, 0, 0 }, 0x0, 6, }, - { 8, 1, 1, 0x0000010800000000ull, 0x000001ee00000000ull, { 24, 64, 26, 0, 0 }, 0x0, 7, }, - { 9, 3, 1, 0x0000002c00000000ull, 0x000001ee00000000ull, { 24, 3, 53, 54, 55 }, 0x221, 8, }, - { 9, 3, 1, 0x0000002c00000000ull, 0x000001ee00000000ull, { 24, 53, 54, 55, 0 }, 0x261, 9, }, - { 10, 1, 1, 0x0000010060000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 10, }, - { 10, 1, 1, 0x0000010160000000ull, 0x000001eff8000000ull, { 24, 56, 26, 0, 0 }, 0x0, 11, }, - { 11, 1, 1, 0x0000010068000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 12, }, - { 11, 1, 1, 0x0000010168000000ull, 0x000001eff8000000ull, { 24, 56, 26, 0, 0 }, 0x0, 13, }, - { 14, 4, 0, 0x0000000100000000ull, 0x000001eff80011ffull, { 16, 0, 0, 0, 0 }, 0x40, 969, }, - { 14, 4, 0, 0x0000000100000000ull, 0x000001eff80011c0ull, { 16, 0, 0, 0, 0 }, 0x0, 825, }, - { 14, 4, 0, 0x0000000100000000ull, 0x000001eff80011c0ull, { 16, 0, 0, 0, 0 }, 0x40, 826, }, - { 14, 4, 0, 0x0000000108000100ull, 0x000001eff80011c0ull, { 16, 0, 0, 0, 0 }, 0x200, 2234, }, - { 14, 4, 0, 0x0000000108000100ull, 0x000001eff80011c0ull, { 16, 0, 0, 0, 0 }, 0x240, 2235, }, - { 14, 4, 1, 0x0000002100000000ull, 0x000001ef00001000ull, { 15, 16, 0, 0, 0 }, 0x0, 582, }, - { 14, 4, 1, 0x0000002100000000ull, 0x000001ef00001000ull, { 15, 16, 0, 0, 0 }, 0x40, 583, }, - { 14, 4, 0, 0x0000008000000000ull, 0x000001ee000011ffull, { 82, 0, 0, 0, 0 }, 0x40, 990, }, - { 14, 4, 0, 0x0000008000000000ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x0, 827, }, - { 14, 4, 0, 0x0000008000000000ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x40, 828, }, - { 14, 4, 0, 0x0000008000000080ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x210, 3029, }, - { 14, 4, 0, 0x0000008000000080ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x250, 3030, }, - { 14, 4, 0, 0x0000008000000140ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x30, 590, }, - { 14, 4, 0, 0x0000008000000140ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x70, 591, }, - { 14, 4, 0, 0x0000008000000180ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x230, 588, }, - { 14, 4, 0, 0x0000008000000180ull, 0x000001ee000011c0ull, { 82, 0, 0, 0, 0 }, 0x270, 589, }, - { 14, 4, 1, 0x000000a000000000ull, 0x000001ee00001000ull, { 15, 82, 0, 0, 0 }, 0x0, 584, }, - { 14, 4, 1, 0x000000a000000000ull, 0x000001ee00001000ull, { 15, 82, 0, 0, 0 }, 0x40, 585, }, - { 15, 4, 0, 0x0000000000000000ull, 0x000001e1f8000000ull, { 66, 0, 0, 0, 0 }, 0x0, 537, }, - { 15, 5, 0, 0x0000000000000000ull, 0x000001e3f8000000ull, { 66, 0, 0, 0, 0 }, 0x0, 960, }, - { 15, 2, 0, 0x0000000000000000ull, 0x000001eff8000000ull, { 66, 0, 0, 0, 0 }, 0x2, 1138, }, - { 15, 3, 0, 0x0000000000000000ull, 0x000001eff8000000ull, { 66, 0, 0, 0, 0 }, 0x0, 1263, }, - { 15, 6, 0, 0x0000000000000000ull, 0x000001eff8000000ull, { 70, 0, 0, 0, 0 }, 0x0, 3033, }, - { 15, 7, 0, 0x0000000000000000ull, 0x0000000000000000ull, { 66, 0, 0, 0, 0 }, 0x0, 16, }, - { 16, 6, 0, 0x0000018000000000ull, 0x000001ee000011ffull, { 83, 0, 0, 0, 0 }, 0x40, 1023, }, - { 16, 6, 0, 0x0000018000000000ull, 0x000001ee000011c0ull, { 83, 0, 0, 0, 0 }, 0x0, 829, }, - { 16, 6, 0, 0x0000018000000000ull, 0x000001ee000011c0ull, { 83, 0, 0, 0, 0 }, 0x40, 830, }, - { 16, 6, 1, 0x000001a000000000ull, 0x000001ee00001000ull, { 15, 83, 0, 0, 0 }, 0x0, 586, }, - { 16, 6, 1, 0x000001a000000000ull, 0x000001ee00001000ull, { 15, 83, 0, 0, 0 }, 0x40, 587, }, - { 17, 4, 0, 0x0000004080000000ull, 0x000001e9f8000018ull, { 16, 78, 0, 0, 0 }, 0x20, 2852, }, - { 17, 4, 0, 0x000000e000000000ull, 0x000001e800000018ull, { 82, 78, 0, 0, 0 }, 0x20, 2853, }, - { 18, 4, 0, 0x0000000060000000ull, 0x000001e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x2c, 222, }, - { 22, 2, 0, 0x0000000200000000ull, 0x000001ee00000000ull, { 25, 81, 0, 0, 0 }, 0x0, 2239, }, - { 22, 3, 0, 0x0000000800000000ull, 0x000001ee00000000ull, { 24, 82, 0, 0, 0 }, 0x0, 226, }, - { 22, 3, 0, 0x0000000c00000000ull, 0x000001ee00000000ull, { 18, 82, 0, 0, 0 }, 0x0, 227, }, - { 22, 3, 0, 0x0000002200000000ull, 0x000001ee00000000ull, { 25, 81, 0, 0, 0 }, 0x0, 2240, }, - { 22, 3, 0, 0x0000002600000000ull, 0x000001ee00000000ull, { 19, 81, 0, 0, 0 }, 0x0, 2241, }, - { 22, 7, 0, 0x0000000000000000ull, 0x0000000000000000ull, { 25, 81, 0, 0, 0 }, 0x0, 2242, }, - { 25, 4, 0, 0x0000000020000000ull, 0x000001e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x224, 18, }, - { 26, 1, 2, 0x0000018000000000ull, 0x000001fe00001000ull, { 22, 23, 25, 26, 0 }, 0x0, 1222, }, - { 26, 1, 1, 0x0000018000000000ull, 0x000001fe00001000ull, { 22, 25, 26, 0, 0 }, 0x40, 1223, }, - { 26, 1, 2, 0x0000018000000000ull, 0x000001fe00001000ull, { 23, 22, 26, 25, 0 }, 0x0, 1181, }, - { 26, 1, 1, 0x0000018000000000ull, 0x000001fe00001000ull, { 23, 26, 25, 0, 0 }, 0x40, 1182, }, - { 26, 1, 2, 0x0000018000000000ull, 0x000001fe00001000ull, { 22, 23, 26, 25, 0 }, 0x0, 1090, }, - { 26, 1, 1, 0x0000018000000000ull, 0x000001fe00001000ull, { 22, 26, 25, 0, 0 }, 0x40, 1091, }, - { 26, 1, 2, 0x0000018000000000ull, 0x000001fe00001000ull, { 23, 22, 25, 26, 0 }, 0x0, 1052, }, - { 26, 1, 1, 0x0000018000000000ull, 0x000001fe00001000ull, { 23, 25, 26, 0, 0 }, 0x40, 1053, }, - { 26, 1, 2, 0x0000018200000000ull, 0x000001fe00001000ull, { 22, 23, 25, 26, 0 }, 0x40, 1376, }, - { 26, 1, 2, 0x0000019000000000ull, 0x000001fe00001000ull, { 22, 23, 7, 26, 0 }, 0x0, 1092, }, - { 26, 1, 1, 0x0000019000000000ull, 0x000001fe00001000ull, { 22, 7, 26, 0, 0 }, 0x40, 1093, }, - { 26, 1, 2, 0x0000019000000000ull, 0x000001fe00001000ull, { 22, 23, 26, 7, 0 }, 0x40, 1226, }, - { 26, 1, 1, 0x0000019000000000ull, 0x000001fe00001000ull, { 22, 26, 7, 0, 0 }, 0x40, 1227, }, - { 26, 1, 2, 0x0000019000000000ull, 0x000001fe00001000ull, { 22, 23, 7, 26, 0 }, 0x40, 1187, }, - { 26, 1, 2, 0x0000018800000000ull, 0x000001ee00001000ull, { 22, 23, 56, 26, 0 }, 0x0, 1229, }, - { 26, 1, 1, 0x0000018800000000ull, 0x000001ee00001000ull, { 22, 56, 26, 0, 0 }, 0x40, 1230, }, - { 26, 1, 2, 0x0000018800000000ull, 0x000001ee00001000ull, { 22, 23, 58, 26, 0 }, 0x0, 1188, }, - { 26, 1, 1, 0x0000018800000000ull, 0x000001ee00001000ull, { 22, 58, 26, 0, 0 }, 0x40, 1189, }, - { 26, 1, 2, 0x0000018800000000ull, 0x000001ee00001000ull, { 23, 22, 58, 26, 0 }, 0x0, 1097, }, - { 26, 1, 1, 0x0000018800000000ull, 0x000001ee00001000ull, { 23, 58, 26, 0, 0 }, 0x40, 1098, }, - { 26, 1, 2, 0x0000018800000000ull, 0x000001ee00001000ull, { 23, 22, 56, 26, 0 }, 0x0, 1059, }, - { 26, 1, 1, 0x0000018800000000ull, 0x000001ee00001000ull, { 23, 56, 26, 0, 0 }, 0x40, 1060, }, - { 26, 1, 2, 0x0000018a00000000ull, 0x000001ee00001000ull, { 22, 23, 56, 26, 0 }, 0x40, 1381, }, - { 26, 1, 2, 0x000001a800000000ull, 0x000001ee00001000ull, { 22, 23, 60, 26, 0 }, 0x0, 1214, }, - { 26, 1, 1, 0x000001a800000000ull, 0x000001ee00001000ull, { 22, 60, 26, 0, 0 }, 0x40, 1215, }, - { 26, 1, 2, 0x000001a800000000ull, 0x000001ee00001000ull, { 23, 22, 60, 26, 0 }, 0x0, 1125, }, - { 26, 1, 1, 0x000001a800000000ull, 0x000001ee00001000ull, { 23, 60, 26, 0, 0 }, 0x40, 1126, }, - { 26, 1, 2, 0x000001c200000000ull, 0x000001fe00001000ull, { 23, 22, 25, 26, 0 }, 0x40, 1382, }, - { 26, 1, 2, 0x000001d000000000ull, 0x000001fe00001000ull, { 23, 22, 7, 26, 0 }, 0x40, 1190, }, - { 26, 1, 1, 0x000001d000000000ull, 0x000001fe00001000ull, { 23, 7, 26, 0, 0 }, 0x40, 1191, }, - { 26, 1, 2, 0x000001d000000000ull, 0x000001fe00001000ull, { 23, 22, 26, 7, 0 }, 0x40, 1063, }, - { 26, 1, 1, 0x000001d000000000ull, 0x000001fe00001000ull, { 23, 26, 7, 0, 0 }, 0x40, 1064, }, - { 26, 1, 2, 0x000001ca00000000ull, 0x000001ee00001000ull, { 23, 22, 56, 26, 0 }, 0x40, 1383, }, - { 27, 1, 2, 0x0000018400000000ull, 0x000001fe00001000ull, { 22, 23, 25, 26, 0 }, 0x0, 1235, }, - { 27, 1, 1, 0x0000018400000000ull, 0x000001fe00001000ull, { 22, 25, 26, 0, 0 }, 0x40, 1236, }, - { 27, 1, 2, 0x0000018400000000ull, 0x000001fe00001000ull, { 23, 22, 26, 25, 0 }, 0x0, 1194, }, - { 27, 1, 1, 0x0000018400000000ull, 0x000001fe00001000ull, { 23, 26, 25, 0, 0 }, 0x40, 1195, }, - { 27, 1, 2, 0x0000018400000000ull, 0x000001fe00001000ull, { 22, 23, 26, 25, 0 }, 0x0, 1103, }, - { 27, 1, 1, 0x0000018400000000ull, 0x000001fe00001000ull, { 22, 26, 25, 0, 0 }, 0x40, 1104, }, - { 27, 1, 2, 0x0000018400000000ull, 0x000001fe00001000ull, { 23, 22, 25, 26, 0 }, 0x0, 1065, }, - { 27, 1, 1, 0x0000018400000000ull, 0x000001fe00001000ull, { 23, 25, 26, 0, 0 }, 0x40, 1066, }, - { 27, 1, 2, 0x0000018600000000ull, 0x000001fe00001000ull, { 22, 23, 25, 26, 0 }, 0x40, 1388, }, - { 27, 1, 2, 0x0000019400000000ull, 0x000001fe00001000ull, { 22, 23, 7, 26, 0 }, 0x0, 1105, }, - { 27, 1, 1, 0x0000019400000000ull, 0x000001fe00001000ull, { 22, 7, 26, 0, 0 }, 0x40, 1106, }, - { 27, 1, 2, 0x0000019400000000ull, 0x000001fe00001000ull, { 22, 23, 26, 7, 0 }, 0x40, 1239, }, - { 27, 1, 1, 0x0000019400000000ull, 0x000001fe00001000ull, { 22, 26, 7, 0, 0 }, 0x40, 1240, }, - { 27, 1, 2, 0x0000019400000000ull, 0x000001fe00001000ull, { 22, 23, 7, 26, 0 }, 0x40, 1200, }, - { 27, 1, 2, 0x0000018c00000000ull, 0x000001ee00001000ull, { 22, 23, 56, 26, 0 }, 0x0, 1242, }, - { 27, 1, 1, 0x0000018c00000000ull, 0x000001ee00001000ull, { 22, 56, 26, 0, 0 }, 0x40, 1243, }, - { 27, 1, 2, 0x0000018c00000000ull, 0x000001ee00001000ull, { 22, 23, 58, 26, 0 }, 0x0, 1201, }, - { 27, 1, 1, 0x0000018c00000000ull, 0x000001ee00001000ull, { 22, 58, 26, 0, 0 }, 0x40, 1202, }, - { 27, 1, 2, 0x0000018c00000000ull, 0x000001ee00001000ull, { 23, 22, 58, 26, 0 }, 0x0, 1110, }, - { 27, 1, 1, 0x0000018c00000000ull, 0x000001ee00001000ull, { 23, 58, 26, 0, 0 }, 0x40, 1111, }, - { 27, 1, 2, 0x0000018c00000000ull, 0x000001ee00001000ull, { 23, 22, 56, 26, 0 }, 0x0, 1072, }, - { 27, 1, 1, 0x0000018c00000000ull, 0x000001ee00001000ull, { 23, 56, 26, 0, 0 }, 0x40, 1073, }, - { 27, 1, 2, 0x0000018e00000000ull, 0x000001ee00001000ull, { 22, 23, 56, 26, 0 }, 0x40, 1393, }, - { 27, 1, 2, 0x000001ac00000000ull, 0x000001ee00001000ull, { 22, 23, 57, 26, 0 }, 0x0, 1259, }, - { 27, 1, 1, 0x000001ac00000000ull, 0x000001ee00001000ull, { 22, 57, 26, 0, 0 }, 0x40, 1260, }, - { 27, 1, 2, 0x000001ac00000000ull, 0x000001ee00001000ull, { 22, 23, 59, 26, 0 }, 0x0, 1218, }, - { 27, 1, 1, 0x000001ac00000000ull, 0x000001ee00001000ull, { 22, 59, 26, 0, 0 }, 0x40, 1219, }, - { 27, 1, 2, 0x000001ac00000000ull, 0x000001ee00001000ull, { 23, 22, 59, 26, 0 }, 0x0, 1129, }, - { 27, 1, 1, 0x000001ac00000000ull, 0x000001ee00001000ull, { 23, 59, 26, 0, 0 }, 0x40, 1130, }, - { 27, 1, 2, 0x000001ac00000000ull, 0x000001ee00001000ull, { 23, 22, 57, 26, 0 }, 0x0, 1088, }, - { 27, 1, 1, 0x000001ac00000000ull, 0x000001ee00001000ull, { 23, 57, 26, 0, 0 }, 0x40, 1089, }, - { 27, 1, 2, 0x000001c600000000ull, 0x000001fe00001000ull, { 23, 22, 25, 26, 0 }, 0x40, 1394, }, - { 27, 1, 2, 0x000001d400000000ull, 0x000001fe00001000ull, { 23, 22, 7, 26, 0 }, 0x40, 1203, }, - { 27, 1, 1, 0x000001d400000000ull, 0x000001fe00001000ull, { 23, 7, 26, 0, 0 }, 0x40, 1204, }, - { 27, 1, 2, 0x000001d400000000ull, 0x000001fe00001000ull, { 23, 22, 26, 7, 0 }, 0x40, 1076, }, - { 27, 1, 1, 0x000001d400000000ull, 0x000001fe00001000ull, { 23, 26, 7, 0, 0 }, 0x40, 1077, }, - { 27, 1, 2, 0x000001ce00000000ull, 0x000001ee00001000ull, { 23, 22, 56, 26, 0 }, 0x40, 1395, }, - { 28, 3, 1, 0x0000008808000000ull, 0x000001fff8000000ull, { 24, 28, 25, 1, 2 }, 0x0, 259, }, - { 28, 3, 1, 0x0000008808000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x40, 260, }, - { 29, 3, 1, 0x0000008008000000ull, 0x000001fff8000000ull, { 24, 28, 25, 2, 0 }, 0x0, 261, }, - { 29, 3, 1, 0x0000008008000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x40, 262, }, - { 30, 3, 1, 0x0000008048000000ull, 0x000001fff8000000ull, { 24, 28, 25, 2, 0 }, 0x0, 263, }, - { 30, 3, 1, 0x0000008048000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x40, 264, }, - { 31, 3, 1, 0x0000008088000000ull, 0x000001fff8000000ull, { 24, 28, 25, 2, 0 }, 0x0, 265, }, - { 31, 3, 1, 0x0000008088000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x40, 266, }, - { 32, 3, 1, 0x00000080c8000000ull, 0x000001fff8000000ull, { 24, 28, 25, 2, 0 }, 0x0, 267, }, - { 32, 3, 1, 0x00000080c8000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x40, 268, }, - { 34, 4, 0, 0x0000000010000000ull, 0x000001e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x224, 19, }, - { 36, 2, 1, 0x00000000c0000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 1167, }, - { 37, 2, 1, 0x00000000c8000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 1168, }, - { 39, 2, 1, 0x0000008000000000ull, 0x000001e000000000ull, { 24, 25, 26, 47, 73 }, 0x0, 20, }, - { 39, 2, 1, 0x000000a600000000ull, 0x000001ee04000000ull, { 24, 25, 45, 74, 0 }, 0x0, 3038, }, - { 39, 2, 1, 0x000000a604000000ull, 0x000001ee04000000ull, { 24, 56, 45, 74, 0 }, 0x0, 3039, }, - { 39, 2, 1, 0x000000ae00000000ull, 0x000001ee00000000ull, { 24, 48, 26, 46, 74 }, 0x0, 21, }, - { 43, 4, 0, 0x0000000080000000ull, 0x000001e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x20, 22, }, - { 48, 2, 1, 0x000000a400000000ull, 0x000001ee00002000ull, { 24, 26, 77, 74, 0 }, 0x0, 2870, }, - { 50, 5, 1, 0x0000000080000000ull, 0x000001e3f80fe000ull, { 18, 20, 0, 0, 0 }, 0x40, 24, }, - { 51, 5, 1, 0x0000010008000000ull, 0x000001fff8000000ull, { 18, 20, 19, 0, 0 }, 0x40, 2291, }, - { 52, 5, 1, 0x00000000b8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2292, }, - { 52, 5, 1, 0x00000000b8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 26, }, - { 53, 5, 1, 0x00000000b0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2293, }, - { 53, 5, 1, 0x00000000b0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 27, }, - { 54, 5, 1, 0x0000000160000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 28, }, - { 55, 5, 1, 0x0000000168000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 29, }, - { 57, 3, 0, 0x0000002180000000ull, 0x000001fff8000000ull, { 26, 0, 0, 0, 0 }, 0x0, 30, }, - { 58, 5, 0, 0x0000000040000000ull, 0x000001eff8000000ull, { 80, 0, 0, 0, 0 }, 0x0, 2294, }, - { 58, 5, 0, 0x0000000040000000ull, 0x000001eff8000000ull, { 80, 0, 0, 0, 0 }, 0x40, 31, }, - { 59, 5, 2, 0x000000a000000000ull, 0x000001e000001000ull, { 22, 23, 19, 61, 0 }, 0x0, 1265, }, - { 59, 5, 1, 0x000000a000000000ull, 0x000001e000001000ull, { 22, 19, 61, 0, 0 }, 0x40, 1266, }, - { 59, 5, 2, 0x000000a000000000ull, 0x000001e000001000ull, { 23, 22, 19, 61, 0 }, 0x40, 1420, }, - { 59, 5, 1, 0x000000a000000000ull, 0x000001e000001000ull, { 23, 19, 61, 0, 0 }, 0x40, 1421, }, - { 60, 5, 0, 0x0000000028000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 2295, }, - { 60, 5, 0, 0x0000000028000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x40, 32, }, - { 61, 5, 2, 0x0000008000000000ull, 0x000001fe00001000ull, { 22, 23, 19, 20, 0 }, 0x0, 943, }, - { 61, 5, 1, 0x0000008000000000ull, 0x000001fe00001000ull, { 22, 19, 20, 0, 0 }, 0x40, 944, }, - { 61, 5, 2, 0x0000008000000000ull, 0x000001fe00001000ull, { 22, 23, 19, 20, 0 }, 0x40, 945, }, - { 61, 5, 2, 0x0000009000000000ull, 0x000001fe00001000ull, { 22, 23, 20, 19, 0 }, 0x0, 1116, }, - { 61, 5, 1, 0x0000009000000000ull, 0x000001fe00001000ull, { 22, 20, 19, 0, 0 }, 0x40, 1117, }, - { 61, 5, 2, 0x0000009000000000ull, 0x000001fe00001000ull, { 22, 23, 20, 19, 0 }, 0x40, 1118, }, - { 61, 5, 2, 0x0000008000000000ull, 0x000001fe00001000ull, { 23, 22, 19, 20, 0 }, 0x0, 1396, }, - { 61, 5, 1, 0x0000008000000000ull, 0x000001fe00001000ull, { 23, 19, 20, 0, 0 }, 0x40, 1397, }, - { 61, 5, 2, 0x0000008000000000ull, 0x000001fe00001000ull, { 23, 22, 19, 20, 0 }, 0x40, 1398, }, - { 61, 5, 2, 0x0000009000000000ull, 0x000001fe00001000ull, { 23, 22, 20, 19, 0 }, 0x0, 1405, }, - { 61, 5, 1, 0x0000009000000000ull, 0x000001fe00001000ull, { 23, 20, 19, 0, 0 }, 0x40, 1406, }, - { 61, 5, 2, 0x0000009000000000ull, 0x000001fe00001000ull, { 23, 22, 20, 19, 0 }, 0x40, 1407, }, - { 62, 5, 1, 0x00000000c0000000ull, 0x000001eff8000000ull, { 18, 19, 0, 0, 0 }, 0x0, 1042, }, - { 62, 5, 1, 0x00000000c0000000ull, 0x000001eff8000000ull, { 18, 19, 0, 0, 0 }, 0x40, 1043, }, - { 62, 5, 1, 0x00000000e0000000ull, 0x000001e3f8000000ull, { 18, 19, 0, 0, 0 }, 0x0, 3036, }, - { 62, 5, 1, 0x0000010008000000ull, 0x000001fff80fe000ull, { 18, 20, 0, 0, 0 }, 0x40, 3037, }, - { 63, 3, 1, 0x0000008488000000ull, 0x000001fff8000000ull, { 24, 28, 72, 0, 0 }, 0x0, 269, }, - { 64, 3, 1, 0x00000084c8000000ull, 0x000001fff8000000ull, { 24, 28, 72, 0, 0 }, 0x0, 270, }, - { 67, 3, 0, 0x0000000060000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x21, 33, }, - { 68, 5, 1, 0x0000010000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 2353, }, - { 68, 5, 1, 0x0000010000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 34, }, - { 69, 5, 1, 0x00000000a8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2354, }, - { 69, 5, 1, 0x00000000a8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 35, }, - { 70, 5, 1, 0x0000000080000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2247, }, - { 71, 5, 1, 0x00000000a0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2355, }, - { 71, 5, 1, 0x00000000a0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 36, }, - { 72, 5, 1, 0x00000001c8000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 1221, }, - { 73, 5, 1, 0x0000010000000000ull, 0x000001fc000fe000ull, { 18, 20, 21, 0, 0 }, 0x40, 2358, }, - { 74, 5, 1, 0x0000014000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 2361, }, - { 74, 5, 1, 0x0000014000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 38, }, - { 75, 5, 1, 0x0000000088000000ull, 0x000001e3f8000000ull, { 18, 20, 0, 0, 0 }, 0xc0, 39, }, - { 76, 5, 1, 0x0000000088000000ull, 0x000001e3f80fe000ull, { 18, 20, 0, 0, 0 }, 0x40, 40, }, - { 77, 5, 1, 0x0000018000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 2364, }, - { 77, 5, 1, 0x0000018000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 41, }, - { 78, 5, 1, 0x0000018000000000ull, 0x000001fc000fe000ull, { 18, 20, 21, 0, 0 }, 0x40, 2367, }, - { 79, 5, 1, 0x0000010008000000ull, 0x000001fff80fe000ull, { 18, 20, 0, 0, 0 }, 0x40, 2370, }, - { 80, 5, 1, 0x0000000170000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 44, }, - { 81, 5, 1, 0x0000002080000000ull, 0x000001e3f80fe000ull, { 18, 20, 0, 0, 0 }, 0x40, 45, }, - { 82, 5, 1, 0x0000000140000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 46, }, - { 83, 5, 1, 0x00000020b8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2371, }, - { 83, 5, 1, 0x00000020b8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 47, }, - { 84, 5, 1, 0x00000020b0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2372, }, - { 84, 5, 1, 0x00000020b0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 48, }, - { 85, 5, 1, 0x0000002180000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 946, }, - { 85, 5, 1, 0x0000002180000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 947, }, - { 85, 5, 1, 0x0000002188000000ull, 0x000001eff8000000ull, { 18, 20, 19, 0, 0 }, 0x40, 1119, }, - { 86, 5, 1, 0x00000020c0000000ull, 0x000001eff8000000ull, { 18, 19, 0, 0, 0 }, 0x0, 1044, }, - { 86, 5, 1, 0x00000020c0000000ull, 0x000001eff8000000ull, { 18, 19, 0, 0, 0 }, 0x40, 1045, }, - { 87, 5, 1, 0x0000013000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 2389, }, - { 87, 5, 1, 0x0000013000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 49, }, - { 88, 5, 1, 0x00000020a8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2390, }, - { 88, 5, 1, 0x00000020a8000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 50, }, - { 89, 5, 1, 0x0000002080000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2255, }, - { 90, 5, 1, 0x00000020a0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2391, }, - { 90, 5, 1, 0x00000020a0000000ull, 0x000001eff8000000ull, { 18, 19, 20, 0, 0 }, 0x40, 51, }, - { 91, 5, 1, 0x0000013000000000ull, 0x000001fc000fe000ull, { 18, 20, 21, 0, 0 }, 0x40, 2392, }, - { 92, 5, 1, 0x0000017000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 2393, }, - { 92, 5, 1, 0x0000017000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 53, }, - { 93, 5, 1, 0x0000002088000000ull, 0x000001e3f8000000ull, { 18, 20, 0, 0, 0 }, 0xc0, 54, }, - { 94, 5, 1, 0x0000002088000000ull, 0x000001e3f80fe000ull, { 18, 20, 0, 0, 0 }, 0x40, 55, }, - { 95, 5, 1, 0x000001b000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 2394, }, - { 95, 5, 1, 0x000001b000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 56, }, - { 96, 5, 1, 0x000001b000000000ull, 0x000001fc000fe000ull, { 18, 20, 21, 0, 0 }, 0x40, 2395, }, - { 97, 5, 2, 0x0000002200000000ull, 0x000001fe00000000ull, { 18, 23, 19, 20, 0 }, 0x0, 2396, }, - { 97, 5, 2, 0x0000002200000000ull, 0x000001fe00000000ull, { 18, 23, 19, 20, 0 }, 0x40, 58, }, - { 98, 5, 2, 0x0000003200000000ull, 0x000001fe00000000ull, { 18, 23, 20, 0, 0 }, 0x0, 2397, }, - { 98, 5, 2, 0x0000003200000000ull, 0x000001fe00000000ull, { 18, 23, 20, 0, 0 }, 0x40, 59, }, - { 99, 5, 2, 0x0000000200000000ull, 0x000001fe00000000ull, { 18, 23, 19, 20, 0 }, 0x0, 2398, }, - { 99, 5, 2, 0x0000000200000000ull, 0x000001fe00000000ull, { 18, 23, 19, 20, 0 }, 0x40, 60, }, - { 100, 5, 2, 0x0000001200000000ull, 0x000001fe00000000ull, { 18, 23, 20, 0, 0 }, 0x0, 2399, }, - { 100, 5, 2, 0x0000001200000000ull, 0x000001fe00000000ull, { 18, 23, 20, 0, 0 }, 0x40, 61, }, - { 101, 5, 1, 0x000001c000000000ull, 0x000001f000000000ull, { 18, 20, 21, 19, 0 }, 0x0, 62, }, - { 102, 5, 0, 0x0000000020000000ull, 0x000001eff8000000ull, { 51, 52, 0, 0, 0 }, 0x0, 2400, }, - { 102, 5, 0, 0x0000000020000000ull, 0x000001eff8000000ull, { 51, 52, 0, 0, 0 }, 0x40, 63, }, - { 103, 5, 1, 0x0000014008000000ull, 0x000001fff8000000ull, { 18, 20, 19, 0, 0 }, 0x40, 2403, }, - { 104, 5, 1, 0x00000001a0000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 65, }, - { 105, 5, 1, 0x00000001e0000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 2202, }, - { 106, 3, 0, 0x0000000100000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 66, }, - { 108, 5, 1, 0x0000000178000000ull, 0x000001e3f8000000ull, { 18, 19, 20, 0, 0 }, 0x0, 67, }, - { 113, 3, 1, 0x0000008708000000ull, 0x000001ffc8000000ull, { 24, 19, 0, 0, 0 }, 0x0, 2781, }, - { 118, 4, 0, 0x0000004008000000ull, 0x000001e1f8000000ull, { 66, 0, 0, 0, 0 }, 0x0, 538, }, - { 118, 5, 0, 0x000000000c000000ull, 0x000001e3fc000000ull, { 66, 0, 0, 0, 0 }, 0x0, 961, }, - { 118, 2, 0, 0x000000000c000000ull, 0x000001effc000000ull, { 66, 0, 0, 0, 0 }, 0x2, 1141, }, - { 118, 3, 0, 0x000000000c000000ull, 0x000001effc000000ull, { 66, 0, 0, 0, 0 }, 0x0, 1267, }, - { 118, 6, 0, 0x000000000c000000ull, 0x000001effc000000ull, { 70, 0, 0, 0, 0 }, 0x0, 3034, }, - { 118, 7, 0, 0x0000000000000000ull, 0x0000000000000000ull, { 66, 0, 0, 0, 0 }, 0x0, 68, }, - { 123, 3, 0, 0x0000000080000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 69, }, - { 123, 3, 0, 0x0000000090000000ull, 0x000001eff8000000ull, { 24, 0, 0, 0, 0 }, 0x0, 920, }, - { 123, 3, 0, 0x0000000098000000ull, 0x000001eff8000000ull, { 18, 0, 0, 0, 0 }, 0x0, 921, }, - { 124, 3, 0, 0x0000002170000000ull, 0x000001eff8000000ull, { 25, 0, 0, 0, 0 }, 0xc, 846, }, - { 125, 3, 1, 0x0000002070000000ull, 0x000001eff8000000ull, { 31, 25, 0, 0, 0 }, 0x8, 847, }, - { 125, 3, 1, 0x0000002078000000ull, 0x000001eff8000000ull, { 32, 25, 0, 0, 0 }, 0x8, 1143, }, - { 127, 3, 1, 0x0000008000000000ull, 0x000001fff8000000ull, { 24, 28, 0, 0, 0 }, 0x0, 70, }, - { 127, 3, 1, 0x0000009000000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x400, 71, }, - { 127, 3, 1, 0x000000a000000000ull, 0x000001eff0000000ull, { 24, 28, 63, 0, 0 }, 0x400, 72, }, - { 128, 3, 2, 0x0000008a08000000ull, 0x000001fff8000000ull, { 24, 1, 28, 0, 0 }, 0x0, 73, }, - { 128, 3, 1, 0x0000008a08000000ull, 0x000001fff8000000ull, { 24, 28, 0, 0, 0 }, 0x40, 74, }, - { 129, 3, 1, 0x0000008040000000ull, 0x000001fff8000000ull, { 24, 28, 0, 0, 0 }, 0x0, 75, }, - { 129, 3, 1, 0x0000009040000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x400, 76, }, - { 129, 3, 1, 0x000000a040000000ull, 0x000001eff0000000ull, { 24, 28, 63, 0, 0 }, 0x400, 77, }, - { 130, 3, 1, 0x0000008080000000ull, 0x000001fff8000000ull, { 24, 28, 0, 0, 0 }, 0x0, 78, }, - { 130, 3, 1, 0x0000009080000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x400, 79, }, - { 130, 3, 1, 0x000000a080000000ull, 0x000001eff0000000ull, { 24, 28, 63, 0, 0 }, 0x400, 80, }, - { 131, 3, 1, 0x00000080c0000000ull, 0x000001fff8000000ull, { 24, 28, 0, 0, 0 }, 0x0, 81, }, - { 131, 3, 1, 0x00000080c0000000ull, 0x000001fff8000000ull, { 24, 28, 84, 0, 0 }, 0x0, 1339, }, - { 131, 3, 1, 0x00000090c0000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x400, 82, }, - { 131, 3, 1, 0x000000a0c0000000ull, 0x000001eff0000000ull, { 24, 28, 63, 0, 0 }, 0x400, 83, }, - { 132, 3, 1, 0x000000c6c0000000ull, 0x000001fff8000000ull, { 18, 28, 0, 0, 0 }, 0x0, 1039, }, - { 132, 3, 1, 0x000000d6c0000000ull, 0x000001fff8000000ull, { 18, 28, 25, 0, 0 }, 0x400, 1040, }, - { 132, 3, 1, 0x000000e6c0000000ull, 0x000001eff0000000ull, { 18, 28, 63, 0, 0 }, 0x400, 1041, }, - { 133, 3, 1, 0x000000c040000000ull, 0x000001fff8000000ull, { 18, 28, 0, 0, 0 }, 0x0, 84, }, - { 133, 3, 1, 0x000000d040000000ull, 0x000001fff8000000ull, { 18, 28, 25, 0, 0 }, 0x400, 85, }, - { 133, 3, 1, 0x000000e040000000ull, 0x000001eff0000000ull, { 18, 28, 63, 0, 0 }, 0x400, 86, }, - { 134, 3, 1, 0x000000c0c0000000ull, 0x000001fff8000000ull, { 18, 28, 0, 0, 0 }, 0x0, 87, }, - { 134, 3, 1, 0x000000d0c0000000ull, 0x000001fff8000000ull, { 18, 28, 25, 0, 0 }, 0x400, 88, }, - { 134, 3, 1, 0x000000e0c0000000ull, 0x000001eff0000000ull, { 18, 28, 63, 0, 0 }, 0x400, 89, }, - { 135, 3, 1, 0x000000c000000000ull, 0x000001fff8000000ull, { 18, 28, 0, 0, 0 }, 0x0, 90, }, - { 135, 3, 1, 0x000000d000000000ull, 0x000001fff8000000ull, { 18, 28, 25, 0, 0 }, 0x400, 91, }, - { 135, 3, 1, 0x000000e000000000ull, 0x000001eff0000000ull, { 18, 28, 63, 0, 0 }, 0x400, 92, }, - { 136, 3, 2, 0x000000c048000000ull, 0x000001fff8000000ull, { 18, 19, 28, 0, 0 }, 0x0, 93, }, - { 136, 3, 2, 0x000000d048000000ull, 0x000001fff8000000ull, { 18, 19, 28, 6, 0 }, 0x400, 94, }, - { 137, 3, 2, 0x000000c0c8000000ull, 0x000001fff8000000ull, { 18, 19, 28, 0, 0 }, 0x0, 95, }, - { 137, 3, 2, 0x000000d0c8000000ull, 0x000001fff8000000ull, { 18, 19, 28, 6, 0 }, 0x400, 96, }, - { 138, 3, 2, 0x000000c088000000ull, 0x000001fff8000000ull, { 18, 19, 28, 0, 0 }, 0x0, 97, }, - { 138, 3, 2, 0x000000d088000000ull, 0x000001fff8000000ull, { 18, 19, 28, 5, 0 }, 0x400, 98, }, - { 139, 3, 1, 0x000000c080000000ull, 0x000001fff8000000ull, { 18, 28, 0, 0, 0 }, 0x0, 99, }, - { 139, 3, 1, 0x000000d080000000ull, 0x000001fff8000000ull, { 18, 28, 25, 0, 0 }, 0x400, 100, }, - { 139, 3, 1, 0x000000e080000000ull, 0x000001eff0000000ull, { 18, 28, 63, 0, 0 }, 0x400, 101, }, - { 142, 3, 0, 0x000000cb00000000ull, 0x000001fff8000000ull, { 28, 0, 0, 0, 0 }, 0x0, 102, }, - { 142, 3, 0, 0x000000db00000000ull, 0x000001fff8000000ull, { 28, 25, 0, 0, 0 }, 0x400, 103, }, - { 142, 3, 0, 0x000000eb00000000ull, 0x000001eff0000000ull, { 28, 63, 0, 0, 0 }, 0x400, 104, }, - { 143, 3, 0, 0x0000000050000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x21, 105, }, - { 151, 3, 0, 0x0000000110000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 106, }, - { 152, 2, 1, 0x000000e880000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2203, }, - { 153, 2, 1, 0x000000ea80000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2204, }, - { 154, 2, 1, 0x000000f880000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2205, }, - { 155, 1, 1, 0x0000010800000000ull, 0x000001fff80fe000ull, { 24, 26, 0, 0, 0 }, 0x0, 107, }, - { 155, 1, 1, 0x0000012000000000ull, 0x000001e000300000ull, { 24, 67, 0, 0, 0 }, 0x40, 108, }, - { 155, 5, 1, 0x0000000080000000ull, 0x000001e3f8000000ull, { 18, 20, 0, 0, 0 }, 0xc0, 109, }, - { 155, 2, 1, 0x0000000e00100000ull, 0x000001ee00f00000ull, { 15, 25, 0, 0, 0 }, 0x40, 110, }, - { 155, 2, 1, 0x0000000e00000000ull, 0x000001ee00f00000ull, { 15, 25, 79, 0, 0 }, 0x0, 2855, }, - { 155, 2, 1, 0x0000000188000000ull, 0x000001eff8000000ull, { 24, 16, 0, 0, 0 }, 0x0, 112, }, - { 155, 2, 1, 0x0000000600000000ull, 0x000001ee00000000ull, { 9, 25, 65, 0, 0 }, 0x0, 113, }, - { 155, 2, 1, 0x00000016ff001fc0ull, 0x000001feff001fc0ull, { 9, 25, 0, 0, 0 }, 0x40, 114, }, - { 155, 2, 1, 0x0000000400000000ull, 0x000001ee00000000ull, { 10, 69, 0, 0, 0 }, 0x0, 115, }, - { 155, 2, 1, 0x0000000180000000ull, 0x000001eff8000000ull, { 24, 8, 0, 0, 0 }, 0x0, 116, }, - { 155, 2, 1, 0x0000000198000000ull, 0x000001eff8000000ull, { 24, 9, 0, 0, 0 }, 0x0, 117, }, - { 155, 2, 1, 0x0000000150000000ull, 0x000001eff8000000ull, { 14, 25, 0, 0, 0 }, 0x0, 1144, }, - { 155, 2, 1, 0x0000000050000000ull, 0x000001eff8000000ull, { 14, 56, 0, 0, 0 }, 0x0, 1145, }, - { 155, 2, 1, 0x0000000190000000ull, 0x000001eff8000000ull, { 24, 14, 0, 0, 0 }, 0x0, 1146, }, - { 155, 3, 1, 0x0000000140000000ull, 0x000001eff8000000ull, { 14, 56, 0, 0, 0 }, 0x0, 1268, }, - { 155, 3, 1, 0x0000002150000000ull, 0x000001eff8000000ull, { 14, 25, 0, 0, 0 }, 0x0, 1269, }, - { 155, 3, 1, 0x0000002110000000ull, 0x000001eff8000000ull, { 24, 14, 0, 0, 0 }, 0x0, 1270, }, - { 155, 3, 1, 0x0000002160000000ull, 0x000001eff8000000ull, { 17, 25, 0, 0, 0 }, 0x8, 118, }, - { 155, 3, 1, 0x0000002120000000ull, 0x000001eff8000000ull, { 24, 17, 0, 0, 0 }, 0x8, 119, }, - { 155, 3, 1, 0x0000002168000000ull, 0x000001eff8000000ull, { 12, 25, 0, 0, 0 }, 0x8, 120, }, - { 155, 3, 1, 0x0000002148000000ull, 0x000001eff8000000ull, { 13, 25, 0, 0, 0 }, 0x0, 121, }, - { 155, 3, 1, 0x0000002128000000ull, 0x000001eff8000000ull, { 24, 11, 0, 0, 0 }, 0x8, 122, }, - { 155, 3, 1, 0x0000002108000000ull, 0x000001eff8000000ull, { 24, 13, 0, 0, 0 }, 0x0, 123, }, - { 155, 3, 1, 0x0000002000000000ull, 0x000001eff8000000ull, { 38, 25, 0, 0, 0 }, 0x8, 124, }, - { 155, 3, 1, 0x0000002008000000ull, 0x000001eff8000000ull, { 30, 25, 0, 0, 0 }, 0x8, 125, }, - { 155, 3, 1, 0x0000002010000000ull, 0x000001eff8000000ull, { 33, 25, 0, 0, 0 }, 0x8, 126, }, - { 155, 3, 1, 0x0000002018000000ull, 0x000001eff8000000ull, { 35, 25, 0, 0, 0 }, 0x8, 127, }, - { 155, 3, 1, 0x0000002020000000ull, 0x000001eff8000000ull, { 36, 25, 0, 0, 0 }, 0x8, 128, }, - { 155, 3, 1, 0x0000002028000000ull, 0x000001eff8000000ull, { 37, 25, 0, 0, 0 }, 0x8, 129, }, - { 155, 3, 1, 0x0000002030000000ull, 0x000001eff8000000ull, { 34, 25, 0, 0, 0 }, 0x8, 130, }, - { 155, 3, 1, 0x0000002080000000ull, 0x000001eff8000000ull, { 24, 38, 0, 0, 0 }, 0x8, 131, }, - { 155, 3, 1, 0x0000002088000000ull, 0x000001eff8000000ull, { 24, 30, 0, 0, 0 }, 0x8, 132, }, - { 155, 3, 1, 0x0000002090000000ull, 0x000001eff8000000ull, { 24, 33, 0, 0, 0 }, 0x8, 133, }, - { 155, 3, 1, 0x0000002098000000ull, 0x000001eff8000000ull, { 24, 35, 0, 0, 0 }, 0x8, 134, }, - { 155, 3, 1, 0x00000020a0000000ull, 0x000001eff8000000ull, { 24, 36, 0, 0, 0 }, 0x8, 135, }, - { 155, 3, 1, 0x00000020a8000000ull, 0x000001eff8000000ull, { 24, 37, 0, 0, 0 }, 0x0, 136, }, - { 155, 3, 1, 0x00000020b0000000ull, 0x000001eff8000000ull, { 24, 34, 0, 0, 0 }, 0x8, 137, }, - { 155, 3, 1, 0x00000020b8000000ull, 0x000001eff8000000ull, { 24, 29, 0, 0, 0 }, 0x0, 138, }, - { 155, 7, 1, 0x0000000000000000ull, 0x0000000000000000ull, { 24, 14, 0, 0, 0 }, 0x0, 139, }, - { 155, 7, 1, 0x0000000000000000ull, 0x0000000000000000ull, { 14, 56, 0, 0, 0 }, 0x0, 140, }, - { 155, 7, 1, 0x0000000000000000ull, 0x0000000000000000ull, { 14, 25, 0, 0, 0 }, 0x0, 141, }, - { 156, 6, 1, 0x000000c000000000ull, 0x000001e000100000ull, { 24, 71, 0, 0, 0 }, 0x0, 142, }, - { 157, 2, 1, 0x000000eca0000000ull, 0x000001fff0000000ull, { 24, 25, 75, 0, 0 }, 0x0, 143, }, - { 158, 2, 1, 0x000000eea0000000ull, 0x000001fff0000000ull, { 24, 25, 76, 0, 0 }, 0x0, 144, }, - { 168, 4, 0, 0x0000004000000000ull, 0x000001e1f8000000ull, { 66, 0, 0, 0, 0 }, 0x0, 539, }, - { 168, 5, 0, 0x0000000008000000ull, 0x000001e3fc000000ull, { 66, 0, 0, 0, 0 }, 0x0, 962, }, - { 168, 2, 0, 0x0000000008000000ull, 0x000001effc000000ull, { 66, 0, 0, 0, 0 }, 0x2, 1147, }, - { 168, 3, 0, 0x0000000008000000ull, 0x000001effc000000ull, { 66, 0, 0, 0, 0 }, 0x0, 1271, }, - { 168, 6, 0, 0x0000000008000000ull, 0x000001effc000000ull, { 70, 0, 0, 0, 0 }, 0x0, 3035, }, - { 168, 7, 0, 0x0000000000000000ull, 0x0000000000000000ull, { 66, 0, 0, 0, 0 }, 0x0, 145, }, - { 175, 1, 1, 0x0000010070000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 146, }, - { 175, 1, 1, 0x0000010170000000ull, 0x000001eff8000000ull, { 24, 56, 26, 0, 0 }, 0x0, 147, }, - { 178, 2, 1, 0x000000ea00000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 3017, }, - { 179, 2, 1, 0x000000f820000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2857, }, - { 180, 1, 1, 0x0000010400000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 148, }, - { 181, 1, 1, 0x0000010600000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 149, }, - { 182, 1, 1, 0x0000011400000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 150, }, - { 183, 1, 1, 0x0000010450000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 151, }, - { 184, 1, 1, 0x0000010650000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 152, }, - { 185, 1, 1, 0x0000010470000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 153, }, - { 186, 1, 1, 0x0000010670000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 154, }, - { 187, 1, 1, 0x0000010520000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 948, }, - { 188, 1, 1, 0x0000010720000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 949, }, - { 189, 1, 1, 0x0000011520000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 950, }, - { 190, 2, 1, 0x000000e850000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2871, }, - { 191, 2, 1, 0x000000ea70000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 155, }, - { 192, 2, 1, 0x000000e810000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2872, }, - { 193, 2, 1, 0x000000ea30000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 156, }, - { 194, 2, 1, 0x000000ead0000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 2206, }, - { 195, 2, 1, 0x000000e230000000ull, 0x000001ff30000000ull, { 24, 25, 26, 42, 0 }, 0x0, 157, }, - { 196, 2, 1, 0x000000e690000000ull, 0x000001fff0000000ull, { 24, 26, 0, 0, 0 }, 0x0, 158, }, - { 198, 3, 1, 0x00000021c0000000ull, 0x000001eff8000000ull, { 24, 26, 25, 0, 0 }, 0x0, 2207, }, - { 198, 3, 1, 0x00000020c0000000ull, 0x000001eff8000000ull, { 24, 26, 49, 0, 0 }, 0x0, 2208, }, - { 198, 3, 0, 0x0000002188000000ull, 0x000001eff8000000ull, { 26, 49, 0, 0, 0 }, 0x0, 2238, }, - { 199, 2, 1, 0x000000e8b0000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 159, }, - { 200, 2, 1, 0x000000e240000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 160, }, - { 200, 2, 1, 0x000000ee50000000ull, 0x000001fff0000000ull, { 24, 25, 39, 0, 0 }, 0x0, 161, }, - { 201, 2, 1, 0x000000f040000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 162, }, - { 201, 2, 1, 0x000000fc50000000ull, 0x000001fff0000000ull, { 24, 25, 39, 0, 0 }, 0x0, 163, }, - { 202, 1, 1, 0x0000010680000000ull, 0x000001ffe0000000ull, { 24, 25, 41, 26, 0 }, 0x0, 164, }, - { 203, 2, 1, 0x000000e220000000ull, 0x000001fff0000000ull, { 24, 26, 25, 0, 0 }, 0x0, 165, }, - { 203, 2, 1, 0x000000e630000000ull, 0x000001fff0000000ull, { 24, 26, 43, 0, 0 }, 0x0, 166, }, - { 204, 2, 1, 0x000000f020000000ull, 0x000001fff0000000ull, { 24, 26, 25, 0, 0 }, 0x0, 167, }, - { 204, 2, 1, 0x000000f430000000ull, 0x000001fff0000000ull, { 24, 26, 43, 0, 0 }, 0x0, 168, }, - { 205, 1, 1, 0x00000106c0000000ull, 0x000001ffe0000000ull, { 24, 25, 41, 26, 0 }, 0x0, 169, }, - { 206, 1, 1, 0x0000010420000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 170, }, - { 207, 1, 1, 0x0000010620000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 171, }, - { 208, 1, 1, 0x0000011420000000ull, 0x000001fff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 172, }, - { 209, 3, 0, 0x0000002048000000ull, 0x000001eff8000000ull, { 26, 25, 0, 0, 0 }, 0x8, 1175, }, - { 209, 3, 0, 0x0000002050000000ull, 0x000001eff8000000ull, { 26, 25, 0, 0, 0 }, 0xc, 1050, }, - { 209, 3, 0, 0x00000021a0000000ull, 0x000001eff8000000ull, { 26, 0, 0, 0, 0 }, 0x8, 922, }, - { 210, 3, 0, 0x0000002060000000ull, 0x000001eff8000000ull, { 26, 25, 0, 0, 0 }, 0x8, 848, }, - { 215, 4, 0, 0x0000000040000000ull, 0x000001e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x22c, 173, }, - { 216, 3, 0, 0x0000000038000000ull, 0x000001ee78000000ull, { 68, 0, 0, 0, 0 }, 0x8, 174, }, - { 217, 3, 0, 0x0000000028000000ull, 0x000001ee78000000ull, { 68, 0, 0, 0, 0 }, 0x0, 175, }, - { 226, 3, 1, 0x000000c708000000ull, 0x000001ffc8000000ull, { 18, 25, 0, 0, 0 }, 0x0, 2782, }, - { 227, 2, 1, 0x000000a600000000ull, 0x000001ee04000000ull, { 24, 25, 45, 0, 0 }, 0x140, 176, }, - { 227, 2, 1, 0x000000f240000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 177, }, - { 228, 1, 1, 0x0000010080000000ull, 0x000001efe0000000ull, { 24, 25, 40, 26, 0 }, 0x0, 178, }, - { 229, 1, 1, 0x00000100c0000000ull, 0x000001efe0000000ull, { 24, 25, 40, 26, 0 }, 0x0, 179, }, - { 230, 2, 1, 0x000000a400000000ull, 0x000001ee00002000ull, { 24, 26, 77, 0, 0 }, 0x140, 2878, }, - { 230, 2, 1, 0x000000f220000000ull, 0x000001fff0000000ull, { 24, 26, 25, 0, 0 }, 0x0, 181, }, - { 231, 2, 1, 0x000000ac00000000ull, 0x000001ee00000000ull, { 24, 25, 26, 44, 0 }, 0x0, 182, }, - { 236, 3, 0, 0x0000000180000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 850, }, - { 237, 3, 0, 0x0000000030000000ull, 0x000001ee78000000ull, { 68, 0, 0, 0, 0 }, 0x8, 183, }, - { 239, 3, 1, 0x0000008c00000000ull, 0x000001fff8000000ull, { 28, 25, 0, 0, 0 }, 0x0, 184, }, - { 239, 3, 1, 0x000000ac00000000ull, 0x000001eff0000000ull, { 28, 25, 62, 0, 0 }, 0x400, 185, }, - { 240, 3, 1, 0x0000008c08000000ull, 0x000001fff8000000ull, { 28, 25, 1, 0, 0 }, 0x0, 186, }, - { 240, 3, 1, 0x0000008c08000000ull, 0x000001fff8000000ull, { 28, 25, 0, 0, 0 }, 0x40, 187, }, - { 241, 3, 1, 0x0000008c40000000ull, 0x000001fff8000000ull, { 28, 25, 0, 0, 0 }, 0x0, 188, }, - { 241, 3, 1, 0x000000ac40000000ull, 0x000001eff0000000ull, { 28, 25, 62, 0, 0 }, 0x400, 189, }, - { 242, 3, 1, 0x0000008c80000000ull, 0x000001fff8000000ull, { 28, 25, 0, 0, 0 }, 0x0, 190, }, - { 242, 3, 1, 0x000000ac80000000ull, 0x000001eff0000000ull, { 28, 25, 62, 0, 0 }, 0x400, 191, }, - { 243, 3, 1, 0x0000008cc0000000ull, 0x000001fff8000000ull, { 28, 25, 0, 0, 0 }, 0x0, 192, }, - { 243, 3, 1, 0x000000acc0000000ull, 0x000001eff0000000ull, { 28, 25, 62, 0, 0 }, 0x400, 193, }, - { 244, 3, 1, 0x000000cec0000000ull, 0x000001fff8000000ull, { 28, 19, 0, 0, 0 }, 0x0, 2785, }, - { 244, 3, 1, 0x000000eec0000000ull, 0x000001eff0000000ull, { 28, 19, 62, 0, 0 }, 0x400, 2786, }, - { 245, 3, 1, 0x000000cc40000000ull, 0x000001fff8000000ull, { 28, 19, 0, 0, 0 }, 0x0, 194, }, - { 245, 3, 1, 0x000000ec40000000ull, 0x000001eff0000000ull, { 28, 19, 62, 0, 0 }, 0x400, 195, }, - { 246, 3, 1, 0x000000ccc0000000ull, 0x000001fff8000000ull, { 28, 19, 0, 0, 0 }, 0x0, 196, }, - { 246, 3, 1, 0x000000ecc0000000ull, 0x000001eff0000000ull, { 28, 19, 62, 0, 0 }, 0x400, 197, }, - { 247, 3, 1, 0x000000cc00000000ull, 0x000001fff8000000ull, { 28, 19, 0, 0, 0 }, 0x0, 198, }, - { 247, 3, 1, 0x000000ec00000000ull, 0x000001eff0000000ull, { 28, 19, 62, 0, 0 }, 0x400, 199, }, - { 248, 3, 1, 0x000000cc80000000ull, 0x000001fff8000000ull, { 28, 19, 0, 0, 0 }, 0x0, 200, }, - { 248, 3, 1, 0x000000ec80000000ull, 0x000001eff0000000ull, { 28, 19, 62, 0, 0 }, 0x400, 201, }, - { 249, 1, 1, 0x0000010028000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 202, }, - { 249, 1, 1, 0x0000010020000000ull, 0x000001eff8000000ull, { 24, 25, 26, 4, 0 }, 0x0, 203, }, - { 249, 1, 1, 0x0000010128000000ull, 0x000001eff8000000ull, { 24, 56, 26, 0, 0 }, 0x0, 204, }, - { 250, 3, 0, 0x0000000020000000ull, 0x000001ee78000000ull, { 68, 0, 0, 0, 0 }, 0x0, 205, }, - { 251, 2, 1, 0x00000000a0000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 206, }, - { 252, 2, 1, 0x00000000a8000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 207, }, - { 253, 2, 1, 0x00000000b0000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 208, }, - { 254, 3, 0, 0x0000000198000000ull, 0x000001eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 1150, }, - { 255, 3, 1, 0x00000020f8000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x8, 209, }, - { 256, 2, 2, 0x000000a000000000ull, 0x000001fe00003000ull, { 22, 23, 26, 77, 0 }, 0x0, 3040, }, - { 256, 2, 1, 0x000000a000000000ull, 0x000001fe00003000ull, { 22, 26, 77, 0, 0 }, 0x40, 3041, }, - { 256, 2, 2, 0x000000a000000000ull, 0x000001fe00003000ull, { 23, 22, 26, 77, 0 }, 0x40, 2003, }, - { 256, 2, 1, 0x000000a000000000ull, 0x000001fe00003000ull, { 23, 26, 77, 0, 0 }, 0x40, 2004, }, - { 257, 2, 2, 0x000000a000082000ull, 0x000001fe00083000ull, { 22, 23, 50, 0, 0 }, 0x0, 3044, }, - { 257, 2, 1, 0x000000a000082000ull, 0x000001fe00083000ull, { 22, 50, 0, 0, 0 }, 0x40, 3045, }, - { 257, 2, 2, 0x000000a000082000ull, 0x000001fe00083000ull, { 23, 22, 50, 0, 0 }, 0x40, 2007, }, - { 257, 2, 1, 0x000000a000082000ull, 0x000001fe00083000ull, { 23, 50, 0, 0, 0 }, 0x40, 2008, }, - { 258, 3, 1, 0x00000020d0000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 210, }, - { 259, 2, 2, 0x000000a000002000ull, 0x000001fe00003000ull, { 22, 23, 26, 0, 0 }, 0x0, 3048, }, - { 259, 2, 1, 0x000000a000002000ull, 0x000001fe00003000ull, { 22, 26, 0, 0, 0 }, 0x40, 3049, }, - { 259, 2, 2, 0x000000a000002000ull, 0x000001fe00003000ull, { 23, 22, 26, 0, 0 }, 0x40, 2011, }, - { 259, 2, 1, 0x000000a000002000ull, 0x000001fe00003000ull, { 23, 26, 0, 0, 0 }, 0x40, 2012, }, - { 260, 3, 1, 0x00000020f0000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x8, 211, }, - { 262, 3, 1, 0x00000020d8000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 212, }, - { 266, 2, 1, 0x000000e840000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 1131, }, - { 267, 2, 1, 0x000000ea40000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 1132, }, - { 268, 2, 1, 0x000000f840000000ull, 0x000001fff0000000ull, { 24, 25, 26, 0, 0 }, 0x0, 1133, }, - { 272, 4, 0, 0x00000000c0000000ull, 0x000001e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x28, 223, }, - { 277, 3, 1, 0x0000008208000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x0, 213, }, - { 278, 3, 1, 0x0000008248000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x0, 214, }, - { 279, 3, 1, 0x0000008288000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x0, 215, }, - { 280, 3, 1, 0x00000082c8000000ull, 0x000001fff8000000ull, { 24, 28, 25, 0, 0 }, 0x0, 216, }, - { 282, 5, 1, 0x000001d000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x0, 1179, }, - { 282, 5, 1, 0x000001d000000000ull, 0x000001fc00000000ull, { 18, 20, 21, 19, 0 }, 0x40, 1261, }, - { 283, 5, 1, 0x000001d000000000ull, 0x000001fc000fe000ull, { 18, 20, 21, 0, 0 }, 0x40, 1180, }, - { 284, 1, 1, 0x0000010078000000ull, 0x000001eff8000000ull, { 24, 25, 26, 0, 0 }, 0x0, 217, }, - { 284, 1, 1, 0x0000010178000000ull, 0x000001eff8000000ull, { 24, 56, 26, 0, 0 }, 0x0, 218, }, - { 287, 2, 1, 0x0000000080000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 219, }, - { 288, 2, 1, 0x0000000088000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 220, }, - { 289, 2, 1, 0x0000000090000000ull, 0x000001eff8000000ull, { 24, 26, 0, 0, 0 }, 0x0, 221, }, -}; - -static const char dis_table[] = { -0xa0, 0xc7, 0xc8, 0xa0, 0x2e, 0xd8, 0xa0, 0x2c, 0xc0, 0xa0, 0x1c, 0x00, -0x98, 0xb0, 0x02, 0x50, 0x90, 0x50, 0x90, 0x28, 0x24, 0x39, 0x28, 0x24, -0x39, 0x20, 0x90, 0x28, 0x24, 0x39, 0x18, 0x24, 0x39, 0x10, 0x91, 0x60, -0x90, 0x28, 0x24, 0x39, 0x00, 0x10, 0x10, 0x58, 0x41, 0x61, 0xc7, 0xc0, -0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, -0x10, 0x10, 0x52, 0xc0, 0xc0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, -0x10, 0x10, 0x10, 0x24, 0x24, 0x70, 0x90, 0x28, 0x24, 0x38, 0xf0, 0x24, -0x38, 0xe8, 0xa8, 0x0b, 0x48, 0x15, 0x20, 0x97, 0x20, 0x95, 0xc8, 0x9a, -0xb8, 0x05, 0x38, 0x91, 0x18, 0x90, 0xa0, 0x90, 0x60, 0x80, 0x90, 0x20, -0x34, 0xa6, 0xa4, 0x25, 0x00, 0x34, 0xa3, 0x80, 0xa4, 0x36, 0xa0, 0x36, -0xd9, 0x90, 0x50, 0x90, 0x28, 0x80, 0x36, 0xcf, 0x80, 0x34, 0x86, 0x81, -0x33, 0xe2, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x24, 0x10, 0x34, -0x83, 0xa4, 0x1f, 0x08, 0x34, 0x80, 0x90, 0x38, 0xa4, 0x38, 0xa0, 0x37, -0x1a, 0xa4, 0x38, 0x48, 0x37, 0x0e, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x37, -0x20, 0x36, 0xef, 0xa4, 0x36, 0xf8, 0x36, 0xea, 0x80, 0xa4, 0x23, 0xf0, -0x34, 0x7f, 0x92, 0x18, 0x91, 0xc0, 0x80, 0x91, 0x80, 0x90, 0xf8, 0xdb, -0x84, 0x60, 0xf9, 0x40, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x68, 0x8c, 0x43, -0xc8, 0x84, 0x38, 0x83, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x58, 0x8c, 0x43, -0xa8, 0x84, 0x38, 0x81, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x38, -0x35, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x33, 0xa4, 0x1f, 0x18, 0x33, 0xe4, -0x80, 0x90, 0x28, 0x80, 0x33, 0xe0, 0x80, 0x34, 0x88, 0x81, 0x90, 0x38, -0xa4, 0x24, 0x80, 0x34, 0x8b, 0xa4, 0x24, 0x48, 0x34, 0x85, 0xc0, 0x40, -0x10, 0x10, 0x90, 0x38, 0xa4, 0x1e, 0xf0, 0x33, 0xdf, 0xa4, 0x1e, 0xe0, -0x33, 0xdd, 0x18, 0x24, 0x24, 0xf8, 0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, -0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x38, 0x38, 0x6d, 0xc0, 0xc0, 0x80, 0xa4, -0x42, 0x28, 0x38, 0x69, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x38, -0x2f, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x2d, 0x92, 0xb8, 0x99, 0x84, 0x24, -0x68, 0x90, 0x78, 0x90, 0x50, 0x10, 0x10, 0x80, 0xa4, 0x36, 0x98, 0x36, -0xd8, 0x82, 0x36, 0xce, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x38, -0x98, 0x37, 0x19, 0xa4, 0x38, 0x40, 0x37, 0x0d, 0x80, 0x90, 0x38, 0xa4, -0x37, 0x18, 0x36, 0xee, 0xa4, 0x36, 0xf0, 0x36, 0xe9, 0x83, 0x90, 0xa8, -0xd3, 0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x08, 0x38, 0x61, 0xc0, -0xc0, 0x80, 0xa4, 0x41, 0xf8, 0x38, 0x5d, 0xd3, 0x82, 0x40, 0x50, 0xc0, -0xc0, 0x81, 0x38, 0x29, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x27, 0x18, 0x24, -0x24, 0x78, 0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, -0x41, 0xd8, 0x38, 0x55, 0xc0, 0xc0, 0x80, 0xa4, 0x41, 0xc8, 0x38, 0x51, -0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x23, 0x50, 0xc0, 0xc0, -0x81, 0x38, 0x21, 0x94, 0x50, 0x92, 0xf8, 0x99, 0x84, 0x1f, 0x48, 0x90, -0x78, 0x90, 0x50, 0x10, 0x10, 0x80, 0xa4, 0x36, 0x90, 0x36, 0xd7, 0x82, -0x36, 0xcd, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x38, 0x90, 0x37, -0x18, 0xa4, 0x38, 0x38, 0x37, 0x0c, 0x80, 0x90, 0x38, 0xa4, 0x37, 0x10, -0x36, 0xed, 0xa4, 0x36, 0xe8, 0x36, 0xe8, 0x83, 0x90, 0xe8, 0xd3, 0x83, -0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x78, 0x8c, 0x43, 0xe8, 0x84, 0x38, -0x85, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x60, 0x8c, 0x43, 0xb8, 0x84, 0x38, -0x82, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x37, 0x50, 0xc0, -0xc0, 0x81, 0x38, 0x34, 0x18, 0x24, 0x1f, 0x40, 0x83, 0x90, 0xa8, 0xd3, -0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x48, 0x38, 0x71, 0xc0, 0xc0, -0x80, 0xa4, 0x42, 0x30, 0x38, 0x6b, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, -0x81, 0x38, 0x31, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x2e, 0x92, 0xb8, 0x99, -0x84, 0x1f, 0x38, 0x90, 0x78, 0x90, 0x50, 0x10, 0x10, 0x80, 0xa4, 0x36, -0x88, 0x36, 0xd6, 0x82, 0x36, 0xcc, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, -0xa4, 0x38, 0x88, 0x37, 0x17, 0xa4, 0x38, 0x30, 0x37, 0x0b, 0x80, 0x90, -0x38, 0xa4, 0x37, 0x08, 0x36, 0xec, 0xa4, 0x36, 0xe0, 0x36, 0xe7, 0x83, -0x90, 0xa8, 0xd3, 0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x18, 0x38, -0x65, 0xc0, 0xc0, 0x80, 0xa4, 0x42, 0x00, 0x38, 0x5f, 0xd3, 0x82, 0x40, -0x50, 0xc0, 0xc0, 0x81, 0x38, 0x2b, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x28, -0x18, 0x20, 0x01, 0x48, 0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, 0xc0, 0xc0, -0x80, 0xa4, 0x41, 0xe8, 0x38, 0x59, 0xc0, 0xc0, 0x80, 0xa4, 0x41, 0xd0, -0x38, 0x53, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x38, 0x25, 0x50, -0xc0, 0xc0, 0x81, 0x38, 0x22, 0xda, 0x06, 0xe0, 0xf9, 0x80, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x24, 0xe8, 0x34, 0x9b, 0x80, 0x34, 0x98, 0x90, 0x38, -0xa4, 0x24, 0x90, 0x34, 0x96, 0x80, 0x34, 0x93, 0x90, 0x60, 0x90, 0x38, -0xa4, 0x24, 0xd0, 0x34, 0x9c, 0x80, 0x34, 0x99, 0x90, 0x38, 0xa4, 0x24, -0xa8, 0x34, 0x97, 0x80, 0x34, 0x94, 0xc8, 0x40, 0x19, 0x00, 0x91, 0x58, -0x90, 0x60, 0x82, 0x90, 0x20, 0x36, 0xcb, 0xa4, 0x36, 0x48, 0x36, 0xca, -0x90, 0xc0, 0x80, 0x90, 0x90, 0x90, 0x48, 0xc9, 0xe1, 0xc1, 0x00, 0x85, -0x37, 0x03, 0xc9, 0xe1, 0xc0, 0x40, 0x85, 0x37, 0x00, 0x80, 0x36, 0xff, -0x10, 0x10, 0x81, 0x36, 0xdb, 0x90, 0xa8, 0x10, 0x10, 0x90, 0x28, 0x81, -0x36, 0xf9, 0x90, 0x38, 0xa4, 0x37, 0xa0, 0x36, 0xf5, 0xa4, 0x37, 0x90, -0x36, 0xf3, 0x90, 0x70, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x37, 0xb8, 0x36, -0xf8, 0x80, 0x36, 0xf6, 0x90, 0x60, 0x90, 0x28, 0x24, 0x37, 0xf0, 0xa4, -0x37, 0xe0, 0x36, 0xfd, 0x80, 0xa4, 0x37, 0xd0, 0x36, 0xfb, 0x80, 0x90, -0xf8, 0x90, 0x90, 0x90, 0x50, 0x90, 0x28, 0x80, 0x38, 0x17, 0x80, 0x38, -0x20, 0x80, 0xa4, 0x40, 0xf0, 0x38, 0x1f, 0x90, 0x28, 0x81, 0x38, 0x1d, -0x80, 0xa4, 0x40, 0xd8, 0x38, 0x1c, 0x90, 0x28, 0x82, 0x38, 0x1a, 0x81, -0xa4, 0x40, 0xc0, 0x38, 0x19, 0x98, 0xe8, 0x01, 0xb0, 0x90, 0x88, 0x90, -0x60, 0xa4, 0x36, 0x38, 0x10, 0x10, 0x10, 0x10, 0x83, 0x33, 0xb7, 0x24, -0x36, 0x30, 0x90, 0x28, 0x24, 0x36, 0x28, 0x24, 0x36, 0x20, 0x90, 0x88, -0x90, 0x60, 0xa4, 0x36, 0x10, 0x10, 0x10, 0x10, 0x10, 0x83, 0x33, 0xb6, -0x24, 0x36, 0x08, 0x90, 0x28, 0x24, 0x36, 0x00, 0x24, 0x35, 0xf8, 0xa8, -0x09, 0x00, 0x0e, 0x20, 0x96, 0x48, 0x95, 0xe8, 0x93, 0x38, 0x91, 0xa0, -0x90, 0xd0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x1e, 0x60, 0x33, 0xcd, 0xa4, -0x1e, 0x50, 0x33, 0xcb, 0x90, 0x38, 0xa4, 0x1e, 0x40, 0x33, 0xc9, 0x80, -0x33, 0xc7, 0x90, 0x60, 0x90, 0x28, 0x24, 0x1e, 0x00, 0xa4, 0x1d, 0xf0, -0x33, 0xbf, 0x90, 0x38, 0xa4, 0x1d, 0xe0, 0x33, 0xbd, 0xa4, 0x1e, 0x28, -0x33, 0xc6, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x1e, 0x18, 0x33, -0xc4, 0xa4, 0x1e, 0x08, 0x33, 0xc2, 0x90, 0x38, 0xa4, 0x35, 0xb0, 0x36, -0xbc, 0xa4, 0x35, 0x50, 0x36, 0xb0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x32, -0x90, 0x36, 0x5e, 0xa4, 0x32, 0x60, 0x36, 0x58, 0x10, 0x10, 0xa4, 0x1d, -0xd0, 0x33, 0xbb, 0x99, 0x60, 0x02, 0x70, 0x90, 0x90, 0x90, 0x50, 0x90, -0x28, 0x24, 0x1e, 0x90, 0x80, 0x33, 0xda, 0x80, 0xa4, 0x1e, 0x98, 0x33, -0xd8, 0x90, 0x50, 0x90, 0x28, 0x24, 0x1e, 0xa0, 0x80, 0x33, 0xdb, 0x90, -0x38, 0xa4, 0x1e, 0xa8, 0x33, 0xd9, 0xa4, 0x1e, 0x70, 0x33, 0xcf, 0x90, -0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0xe8, 0x36, 0xa5, 0xa4, 0x34, -0x48, 0x36, 0x92, 0x90, 0x38, 0xa4, 0x33, 0xe0, 0x36, 0x83, 0xa4, 0x33, -0x50, 0x36, 0x72, 0x81, 0xa4, 0x1e, 0x80, 0x33, 0xd1, 0xe4, 0xa2, 0x04, -0x40, 0x38, 0x13, 0x18, 0x24, 0x1d, 0xc8, 0xe4, 0xe2, 0x02, 0xc0, 0x38, -0x0d, 0x92, 0x40, 0x91, 0x08, 0x10, 0x10, 0x90, 0x80, 0x10, 0x10, 0x90, -0x38, 0xa4, 0x35, 0xa8, 0x36, 0xbb, 0xa4, 0x35, 0x48, 0x36, 0xaf, 0x80, -0x90, 0x38, 0xa4, 0x32, 0x88, 0x36, 0x5d, 0xa4, 0x32, 0x58, 0x36, 0x57, -0x18, 0x20, 0x00, 0xf8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0xd8, -0x36, 0xa4, 0xa4, 0x34, 0x40, 0x36, 0x90, 0x90, 0x38, 0xa4, 0x33, 0xd0, -0x36, 0x82, 0xa4, 0x33, 0x48, 0x36, 0x70, 0xe4, 0xa2, 0x01, 0x40, 0x38, -0x07, 0x18, 0x24, 0x1d, 0xc0, 0xe4, 0xe1, 0xff, 0xc0, 0x38, 0x01, 0x92, -0x90, 0x92, 0x40, 0x91, 0x08, 0x10, 0x10, 0x90, 0x80, 0x10, 0x10, 0x90, -0x38, 0xa4, 0x35, 0xa0, 0x36, 0xba, 0xa4, 0x35, 0x40, 0x36, 0xae, 0x80, -0x90, 0x38, 0xa4, 0x32, 0x80, 0x36, 0x5c, 0xa4, 0x32, 0x50, 0x36, 0x56, -0x18, 0x20, 0x00, 0xf8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0xc8, -0x36, 0xa3, 0xa4, 0x34, 0x38, 0x36, 0x8e, 0x90, 0x38, 0xa4, 0x33, 0xc0, -0x36, 0x81, 0xa4, 0x33, 0x40, 0x36, 0x6e, 0xe4, 0xa2, 0x04, 0x80, 0x38, -0x15, 0x10, 0x10, 0xe4, 0xe2, 0x03, 0x00, 0x38, 0x0f, 0x92, 0x50, 0x99, -0x1c, 0x1e, 0xb0, 0x10, 0x10, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, -0x35, 0x98, 0x36, 0xb9, 0xa4, 0x35, 0x38, 0x36, 0xad, 0x80, 0x90, 0x38, -0xa4, 0x32, 0x78, 0x36, 0x5b, 0xa4, 0x32, 0x48, 0x36, 0x55, 0x18, 0x20, -0x00, 0xf8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0xb8, 0x36, 0xa2, -0xa4, 0x34, 0x30, 0x36, 0x8c, 0x90, 0x38, 0xa4, 0x33, 0xb0, 0x36, 0x80, -0xa4, 0x33, 0x38, 0x36, 0x6c, 0xe4, 0xa2, 0x01, 0x80, 0x38, 0x09, 0x10, -0x10, 0xe4, 0xe2, 0x00, 0x00, 0x38, 0x03, 0xc0, 0x40, 0x80, 0x10, 0x10, -0x81, 0x90, 0x90, 0x90, 0x48, 0xc9, 0xe1, 0x98, 0x80, 0x85, 0x36, 0x66, -0xc9, 0xe1, 0x99, 0x00, 0x85, 0x36, 0x63, 0x80, 0x36, 0x61, 0x80, 0xd8, -0x47, 0x80, 0x0d, 0xc0, 0xc0, 0x80, 0x10, 0x10, 0x82, 0x90, 0x58, 0xd5, -0x81, 0x80, 0x80, 0x37, 0xfd, 0x80, 0x37, 0xfb, 0xd5, 0x81, 0x80, 0x80, -0x37, 0xf9, 0x80, 0x37, 0xf7, 0xc0, 0x80, 0x10, 0x10, 0x82, 0x90, 0x58, -0xd5, 0x81, 0x80, 0x80, 0x37, 0xfe, 0x80, 0x37, 0xfc, 0xd5, 0x81, 0x80, -0x80, 0x37, 0xfa, 0x80, 0x37, 0xf8, 0xc0, 0x80, 0x83, 0xa4, 0x3f, 0xa8, -0x37, 0xf6, 0xa0, 0x59, 0x60, 0xa0, 0x41, 0xe0, 0xa8, 0x1e, 0xb0, 0x34, -0x88, 0xa0, 0x12, 0x38, 0xa0, 0x0b, 0x48, 0x96, 0x00, 0x9a, 0xf0, 0x05, -0xc0, 0x91, 0x70, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x15, 0x58, -0x33, 0xb5, 0xa4, 0x15, 0x78, 0x33, 0xb4, 0x10, 0x10, 0xa4, 0x15, 0x68, -0x33, 0xb3, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x14, 0xf8, 0x33, 0x9a, 0xa4, -0x15, 0x18, 0x33, 0x99, 0x10, 0x10, 0xa4, 0x15, 0x08, 0x33, 0x98, 0x90, -0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x14, 0x98, 0x33, 0x7f, 0xa4, 0x14, -0xb8, 0x33, 0x7e, 0x10, 0x10, 0xa4, 0x14, 0xa8, 0x33, 0x7d, 0x90, 0x70, -0x90, 0x38, 0xa4, 0x14, 0x38, 0x33, 0x63, 0xa4, 0x14, 0x58, 0x33, 0x62, -0x10, 0x10, 0xa4, 0x14, 0x48, 0x33, 0x61, 0x91, 0x70, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x15, 0x28, 0x33, 0xb0, 0xa4, 0x15, 0x48, 0x33, -0xb2, 0x10, 0x10, 0xa4, 0x15, 0x38, 0x33, 0xb1, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x14, 0xc8, 0x33, 0x95, 0xa4, 0x14, 0xe8, 0x33, 0x97, 0x10, 0x10, -0xa4, 0x14, 0xd8, 0x33, 0x96, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, -0x14, 0x68, 0x33, 0x7a, 0xa4, 0x14, 0x88, 0x33, 0x7c, 0x10, 0x10, 0xa4, -0x14, 0x78, 0x33, 0x7b, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x14, 0x08, 0x33, -0x5e, 0xa4, 0x14, 0x28, 0x33, 0x60, 0x10, 0x10, 0xa4, 0x14, 0x18, 0x33, -0x5f, 0xe4, 0xe1, 0x8b, 0x40, 0x36, 0x41, 0x9a, 0xf0, 0x05, 0x00, 0x91, -0x70, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0xa0, 0x33, 0xad, -0xa4, 0x13, 0x98, 0x33, 0xaf, 0x10, 0x10, 0xa4, 0x13, 0x90, 0x33, 0xae, -0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0x88, 0x33, 0x92, 0xa4, 0x13, 0x80, -0x33, 0x94, 0x10, 0x10, 0xa4, 0x13, 0x78, 0x33, 0x93, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x13, 0x70, 0x33, 0x77, 0xa4, 0x13, 0x68, 0x33, -0x79, 0x10, 0x10, 0xa4, 0x13, 0x60, 0x33, 0x78, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x13, 0x58, 0x33, 0x5b, 0xa4, 0x13, 0x50, 0x33, 0x5d, 0x10, 0x10, -0xa4, 0x13, 0x48, 0x33, 0x5c, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x33, 0xaa, 0x80, 0x33, 0xac, 0x10, 0x10, 0x80, 0x33, 0xab, -0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x8f, 0x80, 0x33, 0x91, 0x10, 0x10, -0x80, 0x33, 0x90, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x74, -0x80, 0x33, 0x76, 0x10, 0x10, 0x80, 0x33, 0x75, 0x90, 0x50, 0x90, 0x28, -0x80, 0x33, 0x58, 0x80, 0x33, 0x5a, 0x10, 0x10, 0x80, 0x33, 0x59, 0xe4, -0xe1, 0x66, 0x40, 0x35, 0xc1, 0x95, 0x40, 0x9a, 0x90, 0x05, 0x00, 0x91, -0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xa7, 0x80, 0x33, -0xa9, 0x10, 0x10, 0x80, 0x33, 0xa8, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, -0x8c, 0x80, 0x33, 0x8e, 0x10, 0x10, 0x80, 0x33, 0x8d, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x13, 0x30, 0x33, 0x71, 0xa4, 0x13, 0x40, 0x33, -0x73, 0x10, 0x10, 0xa4, 0x13, 0x38, 0x33, 0x72, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x13, 0x00, 0x33, 0x55, 0xa4, 0x13, 0x10, 0x33, 0x57, 0x10, 0x10, -0xa4, 0x13, 0x08, 0x33, 0x56, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x33, 0xa4, 0x80, 0x33, 0xa6, 0x10, 0x10, 0x80, 0x33, 0xa5, -0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x89, 0x80, 0x33, 0x8b, 0x10, 0x10, -0x80, 0x33, 0x8a, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0x18, -0x33, 0x6e, 0xa4, 0x13, 0x28, 0x33, 0x70, 0x10, 0x10, 0xa4, 0x13, 0x20, -0x33, 0x6f, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0xe8, 0x33, 0x52, 0xa4, -0x12, 0xf8, 0x33, 0x54, 0x10, 0x10, 0xa4, 0x12, 0xf0, 0x33, 0x53, 0xe4, -0xe1, 0x8a, 0x40, 0x36, 0x3d, 0x98, 0xb8, 0x01, 0x68, 0x10, 0x10, 0x10, -0x10, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x4f, 0x80, 0x33, 0x51, 0x10, -0x10, 0x80, 0x33, 0x50, 0x90, 0x60, 0x90, 0x30, 0x60, 0xa0, 0x97, 0x00, -0x60, 0xa0, 0x96, 0xc0, 0x90, 0x30, 0x60, 0xa0, 0x96, 0x80, 0x60, 0xa0, -0x96, 0x40, 0xe4, 0xe1, 0x64, 0x40, 0x35, 0xb9, 0xa0, 0x08, 0x08, 0x94, -0xe0, 0x9a, 0x60, 0x04, 0xa0, 0x91, 0x40, 0x90, 0xb8, 0x90, 0x70, 0x90, -0x38, 0xa4, 0x13, 0xd8, 0x33, 0x9e, 0xa4, 0x13, 0xf8, 0x33, 0xa3, 0x10, -0x10, 0xa4, 0x13, 0xe8, 0x33, 0xa2, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, -0x83, 0x80, 0x33, 0x88, 0x10, 0x10, 0x80, 0x33, 0x87, 0x90, 0x88, 0x90, -0x50, 0x90, 0x28, 0x80, 0x33, 0x68, 0x80, 0x33, 0x6d, 0x10, 0x10, 0x80, -0x33, 0x6c, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x49, 0x80, 0x33, 0x4e, -0x10, 0x10, 0x80, 0x33, 0x4d, 0x91, 0x40, 0x90, 0xb8, 0x90, 0x70, 0x90, -0x38, 0xa4, 0x13, 0xa8, 0x33, 0x9b, 0xa4, 0x13, 0xc8, 0x33, 0x9d, 0x10, -0x10, 0xa4, 0x13, 0xb8, 0x33, 0x9c, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, -0x80, 0x80, 0x33, 0x82, 0x10, 0x10, 0x80, 0x33, 0x81, 0x90, 0x88, 0x90, -0x50, 0x90, 0x28, 0x80, 0x33, 0x65, 0x80, 0x33, 0x67, 0x10, 0x10, 0x80, -0x33, 0x66, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x46, 0x80, 0x33, 0x48, -0x10, 0x10, 0x80, 0x33, 0x47, 0xe4, 0xe1, 0x89, 0x40, 0x36, 0x39, 0x9a, -0x60, 0x02, 0xe0, 0x91, 0x40, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, -0x1a, 0x20, 0x33, 0x9f, 0xa4, 0x1a, 0x10, 0x33, 0xa1, 0x10, 0x10, 0xa4, -0x1a, 0x00, 0x33, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x84, 0x80, -0x33, 0x86, 0x10, 0x10, 0x80, 0x33, 0x85, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x33, 0x69, 0x80, 0x33, 0x6b, 0x10, 0x10, 0x80, 0x33, 0x6a, -0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x4a, 0x80, 0x33, 0x4c, 0x10, 0x10, -0x80, 0x33, 0x4b, 0x81, 0x90, 0x50, 0x90, 0x28, 0x24, 0x19, 0xd0, 0x24, -0x19, 0xf0, 0x10, 0x10, 0x24, 0x19, 0xe0, 0xe4, 0xe1, 0x62, 0x40, 0x35, -0xb1, 0x93, 0x90, 0x99, 0xb8, 0x03, 0x50, 0x90, 0xe8, 0x90, 0x88, 0x90, -0x40, 0x80, 0xa4, 0x15, 0xb8, 0x32, 0xca, 0x10, 0x10, 0xa4, 0x15, 0xa8, -0x32, 0xc9, 0x90, 0x28, 0x81, 0x32, 0xc6, 0x10, 0x10, 0x80, 0x32, 0xc5, -0x90, 0x60, 0x90, 0x28, 0x81, 0x32, 0xc2, 0x10, 0x10, 0x80, 0x32, 0xc1, -0x90, 0x28, 0x81, 0x32, 0xbe, 0x10, 0x10, 0x80, 0x32, 0xbd, 0x90, 0xe8, -0x90, 0x88, 0x90, 0x40, 0x80, 0xa4, 0x15, 0x88, 0x32, 0xc7, 0x10, 0x10, -0xa4, 0x15, 0x98, 0x32, 0xc8, 0x90, 0x28, 0x81, 0x32, 0xc3, 0x10, 0x10, -0x80, 0x32, 0xc4, 0x90, 0x60, 0x90, 0x28, 0x81, 0x32, 0xbf, 0x10, 0x10, -0x80, 0x32, 0xc0, 0x90, 0x28, 0x81, 0x32, 0xbb, 0x10, 0x10, 0x80, 0x32, -0xbc, 0xe4, 0xe1, 0x88, 0x40, 0x36, 0x35, 0x88, 0x00, 0x88, 0x10, 0x10, -0x10, 0x10, 0x90, 0x28, 0x81, 0x32, 0xb9, 0x10, 0x10, 0x80, 0x32, 0xba, -0xe4, 0xe1, 0x60, 0x40, 0x35, 0xa9, 0xa0, 0x0e, 0x80, 0xa0, 0x09, 0x08, -0x94, 0x80, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, -0x90, 0x28, 0x80, 0x33, 0x39, 0x80, 0x33, 0x38, 0x10, 0x10, 0x80, 0x33, -0x37, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x1e, 0x80, 0x33, 0x1d, 0x10, -0x10, 0x80, 0x33, 0x1c, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, -0x03, 0x80, 0x33, 0x02, 0x10, 0x10, 0x80, 0x33, 0x01, 0x90, 0x50, 0x90, -0x28, 0x80, 0x32, 0xe8, 0x80, 0x32, 0xe7, 0x10, 0x10, 0x80, 0x32, 0xe6, -0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x34, 0x80, -0x33, 0x36, 0x10, 0x10, 0x80, 0x33, 0x35, 0x90, 0x50, 0x90, 0x28, 0x80, -0x33, 0x19, 0x80, 0x33, 0x1b, 0x10, 0x10, 0x80, 0x33, 0x1a, 0x90, 0x88, -0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xfe, 0x80, 0x33, 0x00, 0x10, 0x10, -0x80, 0x32, 0xff, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xe3, 0x80, 0x32, -0xe5, 0x10, 0x10, 0x80, 0x32, 0xe4, 0xe4, 0xe1, 0x7a, 0x40, 0x36, 0x11, -0x9a, 0x30, 0x04, 0x40, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, -0x80, 0x33, 0x31, 0x80, 0x33, 0x33, 0x10, 0x10, 0x80, 0x33, 0x32, 0x90, -0x50, 0x90, 0x28, 0x80, 0x33, 0x16, 0x80, 0x33, 0x18, 0x10, 0x10, 0x80, -0x33, 0x17, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xfb, 0x80, -0x32, 0xfd, 0x10, 0x10, 0x80, 0x32, 0xfc, 0x90, 0x50, 0x90, 0x28, 0x80, -0x32, 0xe0, 0x80, 0x32, 0xe2, 0x10, 0x10, 0x80, 0x32, 0xe1, 0x91, 0x10, -0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x2e, 0x80, 0x33, 0x30, -0x10, 0x10, 0x80, 0x33, 0x2f, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x13, -0x80, 0x33, 0x15, 0x10, 0x10, 0x80, 0x33, 0x14, 0x90, 0x88, 0x90, 0x50, -0x90, 0x28, 0x80, 0x32, 0xf8, 0x80, 0x32, 0xfa, 0x10, 0x10, 0x80, 0x32, -0xf9, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xdd, 0x80, 0x32, 0xdf, 0x10, -0x10, 0x80, 0x32, 0xde, 0xe4, 0xe1, 0x59, 0x40, 0x35, 0x79, 0x94, 0x80, -0x9a, 0x30, 0x04, 0x40, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, -0x80, 0x33, 0x2b, 0x80, 0x33, 0x2d, 0x10, 0x10, 0x80, 0x33, 0x2c, 0x90, -0x50, 0x90, 0x28, 0x80, 0x33, 0x10, 0x80, 0x33, 0x12, 0x10, 0x10, 0x80, -0x33, 0x11, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xf5, 0x80, -0x32, 0xf7, 0x10, 0x10, 0x80, 0x32, 0xf6, 0x90, 0x50, 0x90, 0x28, 0x80, -0x32, 0xda, 0x80, 0x32, 0xdc, 0x10, 0x10, 0x80, 0x32, 0xdb, 0x91, 0x10, -0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x28, 0x80, 0x33, 0x2a, -0x10, 0x10, 0x80, 0x33, 0x29, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x0d, -0x80, 0x33, 0x0f, 0x10, 0x10, 0x80, 0x33, 0x0e, 0x90, 0x88, 0x90, 0x50, -0x90, 0x28, 0x80, 0x32, 0xf2, 0x80, 0x32, 0xf4, 0x10, 0x10, 0x80, 0x32, -0xf3, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xd7, 0x80, 0x32, 0xd9, 0x10, -0x10, 0x80, 0x32, 0xd8, 0xe4, 0xe1, 0x78, 0x40, 0x36, 0x09, 0x88, 0x00, -0xb0, 0x10, 0x10, 0x10, 0x10, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xd4, -0x80, 0x32, 0xd6, 0x10, 0x10, 0x80, 0x32, 0xd5, 0xe4, 0xe1, 0x58, 0x40, -0x35, 0x75, 0x96, 0xe8, 0x94, 0x80, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x10, -0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x22, 0x80, 0x33, 0x27, -0x10, 0x10, 0x80, 0x33, 0x26, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x07, -0x80, 0x33, 0x0c, 0x10, 0x10, 0x80, 0x33, 0x0b, 0x90, 0x88, 0x90, 0x50, -0x90, 0x28, 0x80, 0x32, 0xec, 0x80, 0x32, 0xf1, 0x10, 0x10, 0x80, 0x32, -0xf0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xce, 0x80, 0x32, 0xd3, 0x10, -0x10, 0x80, 0x32, 0xd2, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, -0x80, 0x33, 0x1f, 0x80, 0x33, 0x21, 0x10, 0x10, 0x80, 0x33, 0x20, 0x90, -0x50, 0x90, 0x28, 0x80, 0x33, 0x04, 0x80, 0x33, 0x06, 0x10, 0x10, 0x80, -0x33, 0x05, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xe9, 0x80, -0x32, 0xeb, 0x10, 0x10, 0x80, 0x32, 0xea, 0x90, 0x50, 0x90, 0x28, 0x80, -0x32, 0xcb, 0x80, 0x32, 0xcd, 0x10, 0x10, 0x80, 0x32, 0xcc, 0xe4, 0xe1, -0x76, 0x40, 0x36, 0x01, 0x88, 0x02, 0x28, 0x91, 0x10, 0x90, 0x88, 0x90, -0x50, 0x90, 0x28, 0x80, 0x33, 0x23, 0x80, 0x33, 0x25, 0x10, 0x10, 0x80, -0x33, 0x24, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x08, 0x80, 0x33, 0x0a, -0x10, 0x10, 0x80, 0x33, 0x09, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, -0x32, 0xed, 0x80, 0x32, 0xef, 0x10, 0x10, 0x80, 0x32, 0xee, 0x90, 0x50, -0x90, 0x28, 0x80, 0x32, 0xcf, 0x80, 0x32, 0xd1, 0x10, 0x10, 0x80, 0x32, -0xd0, 0xe4, 0xe1, 0x57, 0x40, 0x35, 0x71, 0x90, 0x40, 0xe5, 0x21, 0x74, -0x40, 0x35, 0xf9, 0xe5, 0x21, 0x56, 0x40, 0x35, 0x6d, 0x9e, 0xb4, 0x23, -0xe8, 0x93, 0x70, 0x91, 0xd8, 0xd5, 0x07, 0x80, 0xd0, 0xc4, 0x40, 0x90, -0x48, 0x80, 0x8c, 0x3f, 0x38, 0x84, 0x37, 0xf1, 0xa4, 0x3d, 0x18, 0x37, -0xbb, 0x90, 0x28, 0x24, 0x3c, 0x58, 0xa4, 0x3a, 0xd8, 0x37, 0x73, 0xd0, -0xc4, 0x40, 0x90, 0x48, 0x80, 0x8c, 0x3f, 0x18, 0x84, 0x37, 0xef, 0xa4, -0x3d, 0x08, 0x37, 0xb9, 0x90, 0x28, 0x24, 0x3c, 0x48, 0xa4, 0x3a, 0xc8, -0x37, 0x71, 0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, -0xdb, 0xa4, 0x3c, 0xe8, 0x37, 0xb5, 0x90, 0x28, 0x24, 0x3c, 0x28, 0xa4, -0x3a, 0xa8, 0x37, 0x6d, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, 0xd7, -0xa4, 0x3c, 0xd8, 0x37, 0xb3, 0x90, 0x28, 0x24, 0x3c, 0x18, 0xa4, 0x3a, -0x98, 0x37, 0x6b, 0x91, 0x98, 0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, -0x28, 0x80, 0x37, 0xcf, 0xa4, 0x3c, 0xb8, 0x37, 0xaf, 0x90, 0x28, 0x24, -0x3b, 0xf8, 0xa4, 0x3a, 0x78, 0x37, 0x67, 0xd0, 0xc3, 0x40, 0x90, 0x28, -0x80, 0x37, 0xcb, 0xa4, 0x3c, 0xa8, 0x37, 0xad, 0x90, 0x28, 0x24, 0x3b, -0xe8, 0xa4, 0x3a, 0x68, 0x37, 0x65, 0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, -0x90, 0x28, 0x80, 0x37, 0xc3, 0xa4, 0x3c, 0x88, 0x37, 0xa9, 0x90, 0x28, -0x24, 0x3b, 0xc8, 0xa4, 0x3a, 0x48, 0x37, 0x61, 0xd0, 0xc3, 0x40, 0x90, -0x28, 0x80, 0x37, 0xbf, 0xa4, 0x3c, 0x78, 0x37, 0xa7, 0x90, 0x28, 0x24, -0x3b, 0xb8, 0xa4, 0x3a, 0x38, 0x37, 0x5f, 0x93, 0x70, 0x91, 0xd8, 0xd5, -0x07, 0x80, 0xd0, 0xc4, 0x40, 0x90, 0x48, 0x80, 0x8c, 0x3f, 0x58, 0x84, -0x37, 0xf3, 0xa4, 0x3d, 0x28, 0x37, 0xbd, 0x90, 0x28, 0x24, 0x3c, 0x68, -0xa4, 0x3a, 0xe8, 0x37, 0x75, 0xd0, 0xc4, 0x40, 0x90, 0x48, 0x80, 0x8c, -0x3f, 0x28, 0x84, 0x37, 0xf0, 0xa4, 0x3d, 0x10, 0x37, 0xba, 0x90, 0x28, -0x24, 0x3c, 0x50, 0xa4, 0x3a, 0xd0, 0x37, 0x72, 0xd5, 0x06, 0x80, 0xd0, -0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, 0xdf, 0xa4, 0x3c, 0xf8, 0x37, 0xb7, -0x90, 0x28, 0x24, 0x3c, 0x38, 0xa4, 0x3a, 0xb8, 0x37, 0x6f, 0xd0, 0xc3, -0x40, 0x90, 0x28, 0x80, 0x37, 0xd9, 0xa4, 0x3c, 0xe0, 0x37, 0xb4, 0x90, -0x28, 0x24, 0x3c, 0x20, 0xa4, 0x3a, 0xa0, 0x37, 0x6c, 0x91, 0x98, 0xd5, -0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, 0xd3, 0xa4, 0x3c, -0xc8, 0x37, 0xb1, 0x90, 0x28, 0x24, 0x3c, 0x08, 0xa4, 0x3a, 0x88, 0x37, -0x69, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, 0xcd, 0xa4, 0x3c, 0xb0, -0x37, 0xae, 0x90, 0x28, 0x24, 0x3b, 0xf0, 0xa4, 0x3a, 0x70, 0x37, 0x66, -0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, 0xc7, 0xa4, -0x3c, 0x98, 0x37, 0xab, 0x90, 0x28, 0x24, 0x3b, 0xd8, 0xa4, 0x3a, 0x58, -0x37, 0x63, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x37, 0xc1, 0xa4, 0x3c, -0x80, 0x37, 0xa8, 0x90, 0x28, 0x24, 0x3b, 0xc0, 0xa4, 0x3a, 0x40, 0x37, -0x60, 0x99, 0xd8, 0x03, 0x90, 0x81, 0x90, 0xe0, 0x5b, 0x41, 0x40, 0x03, -0x40, 0x51, 0x40, 0xc0, 0xa4, 0x23, 0x80, 0x34, 0x60, 0xd1, 0x42, 0x00, -0xa4, 0x22, 0x80, 0x34, 0x40, 0xa4, 0x21, 0x80, 0x34, 0x20, 0x5b, 0x41, -0x40, 0x03, 0x40, 0x51, 0x40, 0xc0, 0xa4, 0x22, 0xa0, 0x34, 0x64, 0xd1, -0x42, 0x00, 0xa4, 0x21, 0xa0, 0x34, 0x44, 0xa4, 0x20, 0xa0, 0x34, 0x24, -0x81, 0x90, 0xe0, 0x5b, 0x41, 0x40, 0x03, 0x40, 0x51, 0x40, 0xc0, 0xa4, -0x22, 0xe0, 0x34, 0x6c, 0xd1, 0x42, 0x00, 0xa4, 0x21, 0xe0, 0x34, 0x4c, -0xa4, 0x20, 0xe0, 0x34, 0x2c, 0x5b, 0x41, 0x40, 0x03, 0x40, 0x51, 0x40, -0xc0, 0xa4, 0x22, 0xc0, 0x34, 0x68, 0xd1, 0x42, 0x00, 0xa4, 0x21, 0xc0, -0x34, 0x48, 0xa4, 0x20, 0xc0, 0x34, 0x28, 0xa8, 0x0b, 0x18, 0x13, 0xa8, -0x96, 0x80, 0x93, 0x40, 0x99, 0x90, 0x03, 0x00, 0x90, 0xc0, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x12, 0xb8, 0x32, 0x58, 0x24, 0x12, 0xb0, 0x90, 0x38, -0xa4, 0x11, 0xe0, 0x32, 0x3d, 0x24, 0x11, 0xd8, 0x90, 0x60, 0x90, 0x38, -0xa4, 0x11, 0x08, 0x32, 0x22, 0x24, 0x11, 0x00, 0x90, 0x38, 0xa4, 0x10, -0x30, 0x32, 0x07, 0x24, 0x10, 0x28, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, -0xa4, 0x12, 0xa8, 0x32, 0x53, 0x24, 0x12, 0xa0, 0x90, 0x38, 0xa4, 0x11, -0xd0, 0x32, 0x38, 0x24, 0x11, 0xc8, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x10, -0xf8, 0x32, 0x1d, 0x24, 0x10, 0xf0, 0x90, 0x38, 0xa4, 0x10, 0x20, 0x32, -0x02, 0x24, 0x10, 0x18, 0xe4, 0xe1, 0xd0, 0x40, 0x37, 0x43, 0x99, 0x90, -0x03, 0x00, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x12, 0x90, 0x32, -0x50, 0x24, 0x12, 0x88, 0x90, 0x38, 0xa4, 0x11, 0xb8, 0x32, 0x35, 0x24, -0x11, 0xb0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x10, 0xe0, 0x32, 0x1a, 0x24, -0x10, 0xd8, 0x90, 0x38, 0xa4, 0x10, 0x08, 0x31, 0xff, 0x24, 0x10, 0x00, -0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x12, 0x78, 0x32, 0x4d, 0x24, -0x12, 0x70, 0x90, 0x38, 0xa4, 0x11, 0xa0, 0x32, 0x32, 0x24, 0x11, 0x98, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x10, 0xc8, 0x32, 0x17, 0x24, 0x10, 0xc0, -0x90, 0x38, 0xa4, 0x0f, 0xf0, 0x31, 0xfc, 0x24, 0x0f, 0xe8, 0xe4, 0xe1, -0xce, 0xc0, 0x37, 0x3d, 0x93, 0x78, 0x99, 0x90, 0x03, 0x00, 0x90, 0xc0, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x12, 0x60, 0x32, 0x4a, 0x24, 0x12, 0x58, -0x90, 0x38, 0xa4, 0x11, 0x88, 0x32, 0x2f, 0x24, 0x11, 0x80, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x10, 0xb0, 0x32, 0x14, 0x24, 0x10, 0xa8, 0x90, 0x38, -0xa4, 0x0f, 0xd8, 0x31, 0xf9, 0x24, 0x0f, 0xd0, 0x90, 0xc0, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x12, 0x48, 0x32, 0x47, 0x24, 0x12, 0x40, 0x90, 0x38, -0xa4, 0x11, 0x70, 0x32, 0x2c, 0x24, 0x11, 0x68, 0x90, 0x60, 0x90, 0x38, -0xa4, 0x10, 0x98, 0x32, 0x11, 0x24, 0x10, 0x90, 0x90, 0x38, 0xa4, 0x0f, -0xc0, 0x31, 0xf6, 0x24, 0x0f, 0xb8, 0xec, 0xa1, 0x1e, 0x00, 0x02, 0x00, -0x34, 0x7a, 0xa4, 0x39, 0xa8, 0x37, 0x37, 0x88, 0x00, 0x88, 0x10, 0x10, -0x10, 0x10, 0x90, 0x38, 0xa4, 0x0f, 0xa8, 0x31, 0xf3, 0x24, 0x0f, 0xa0, -0xe9, 0x61, 0x1d, 0x40, 0x02, 0x00, 0x34, 0x76, 0xe3, 0x61, 0xcb, 0xc0, -0x37, 0x31, 0x95, 0x08, 0x93, 0x40, 0x99, 0x90, 0x03, 0x00, 0x90, 0xc0, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x12, 0x30, 0x32, 0x41, 0x24, 0x12, 0x28, -0x90, 0x38, 0xa4, 0x11, 0x58, 0x32, 0x26, 0x24, 0x11, 0x50, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x10, 0x80, 0x32, 0x0b, 0x24, 0x10, 0x78, 0x90, 0x38, -0xa4, 0x0f, 0x90, 0x31, 0xed, 0x24, 0x0f, 0x88, 0x90, 0xc0, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x12, 0x00, 0x32, 0x3e, 0x24, 0x11, 0xf8, 0x90, 0x38, -0xa4, 0x11, 0x28, 0x32, 0x23, 0x24, 0x11, 0x20, 0x90, 0x60, 0x90, 0x38, -0xa4, 0x10, 0x50, 0x32, 0x08, 0x24, 0x10, 0x48, 0x90, 0x38, 0xa4, 0x0f, -0x60, 0x31, 0xea, 0x24, 0x0f, 0x58, 0xe4, 0xe1, 0xd0, 0x80, 0x37, 0x45, -0x88, 0x01, 0x88, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x12, 0x20, -0x32, 0x42, 0x24, 0x12, 0x18, 0x90, 0x38, 0xa4, 0x11, 0x48, 0x32, 0x27, -0x24, 0x11, 0x40, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x10, 0x70, 0x32, 0x0c, -0x24, 0x10, 0x68, 0x90, 0x38, 0xa4, 0x0f, 0x80, 0x31, 0xee, 0x24, 0x0f, -0x78, 0xe4, 0xe1, 0xcf, 0x00, 0x37, 0x3f, 0x92, 0xd0, 0x99, 0x50, 0x02, -0x80, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xe9, 0x24, 0x0f, -0x40, 0x90, 0x28, 0x80, 0x31, 0xe5, 0x24, 0x0f, 0x20, 0x90, 0x50, 0x90, -0x28, 0x80, 0x31, 0xe1, 0x24, 0x0f, 0x00, 0x90, 0x28, 0x80, 0x31, 0xdd, -0x24, 0x0e, 0xe0, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xe6, -0x24, 0x0f, 0x38, 0x90, 0x28, 0x80, 0x31, 0xe2, 0x24, 0x0f, 0x18, 0x90, -0x50, 0x90, 0x28, 0x80, 0x31, 0xde, 0x24, 0x0e, 0xf8, 0x90, 0x28, 0x80, -0x31, 0xda, 0x24, 0x0e, 0xd8, 0xec, 0xe1, 0xcd, 0xa1, 0x1f, 0x00, 0x37, -0x39, 0x88, 0x00, 0x78, 0x10, 0x10, 0x10, 0x10, 0x90, 0x28, 0x80, 0x31, -0xd8, 0x24, 0x0e, 0xc8, 0xec, 0xe1, 0xcc, 0x21, 0x1d, 0x00, 0x37, 0x33, -0xe5, 0xa1, 0x55, 0x40, 0x35, 0x51, 0xa0, 0x2a, 0x10, 0xa8, 0x16, 0x60, -0x29, 0xd8, 0xa0, 0x0c, 0x48, 0xa0, 0x0a, 0xc8, 0x95, 0x60, 0x92, 0xb0, -0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xa1, 0x80, -0x31, 0xa0, 0x10, 0x10, 0x80, 0x31, 0x9f, 0x90, 0x70, 0x90, 0x38, 0xa4, -0x08, 0x98, 0x31, 0xb3, 0xa4, 0x08, 0x90, 0x31, 0xb2, 0x10, 0x10, 0xa4, -0x08, 0x88, 0x31, 0xb1, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x09, -0xb8, 0x31, 0xd7, 0xa4, 0x09, 0xb0, 0x31, 0xd6, 0x10, 0x10, 0xa4, 0x09, -0xa8, 0x31, 0xd5, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x09, 0x28, 0x31, 0xc5, -0xa4, 0x09, 0x20, 0x31, 0xc4, 0x10, 0x10, 0xa4, 0x09, 0x18, 0x31, 0xc3, -0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0x9c, 0x80, -0x31, 0x9e, 0x10, 0x10, 0x80, 0x31, 0x9d, 0x90, 0x70, 0x90, 0x38, 0xa4, -0x08, 0x70, 0x31, 0xae, 0xa4, 0x08, 0x80, 0x31, 0xb0, 0x10, 0x10, 0xa4, -0x08, 0x78, 0x31, 0xaf, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x09, -0x90, 0x31, 0xd2, 0xa4, 0x09, 0xa0, 0x31, 0xd4, 0x10, 0x10, 0xa4, 0x09, -0x98, 0x31, 0xd3, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x09, 0x00, 0x31, 0xc0, -0xa4, 0x09, 0x10, 0x31, 0xc2, 0x10, 0x10, 0xa4, 0x09, 0x08, 0x31, 0xc1, -0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, -0x99, 0x80, 0x31, 0x9b, 0x10, 0x10, 0x80, 0x31, 0x9a, 0x90, 0x70, 0x90, -0x38, 0xa4, 0x08, 0x58, 0x31, 0xab, 0xa4, 0x08, 0x68, 0x31, 0xad, 0x10, -0x10, 0xa4, 0x08, 0x60, 0x31, 0xac, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x09, 0x78, 0x31, 0xcf, 0xa4, 0x09, 0x88, 0x31, 0xd1, 0x10, 0x10, -0xa4, 0x09, 0x80, 0x31, 0xd0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, 0xe8, -0x31, 0xbd, 0xa4, 0x08, 0xf8, 0x31, 0xbf, 0x10, 0x10, 0xa4, 0x08, 0xf0, -0x31, 0xbe, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, -0x96, 0x80, 0x31, 0x98, 0x10, 0x10, 0x80, 0x31, 0x97, 0x90, 0x70, 0x90, -0x38, 0xa4, 0x08, 0x40, 0x31, 0xa8, 0xa4, 0x08, 0x50, 0x31, 0xaa, 0x10, -0x10, 0xa4, 0x08, 0x48, 0x31, 0xa9, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x09, 0x60, 0x31, 0xcc, 0xa4, 0x09, 0x70, 0x31, 0xce, 0x10, 0x10, -0xa4, 0x09, 0x68, 0x31, 0xcd, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, 0xd0, -0x31, 0xba, 0xa4, 0x08, 0xe0, 0x31, 0xbc, 0x10, 0x10, 0xa4, 0x08, 0xd8, -0x31, 0xbb, 0x10, 0x10, 0x90, 0xa8, 0x10, 0x10, 0x10, 0x10, 0x90, 0x50, -0x90, 0x28, 0x80, 0x31, 0x8d, 0x80, 0x31, 0x8f, 0x10, 0x10, 0x80, 0x31, -0x8e, 0x90, 0x60, 0x90, 0x30, 0x60, 0xa0, 0x2a, 0xc0, 0x60, 0xa0, 0x2a, -0x80, 0x90, 0x30, 0x60, 0xa0, 0x2a, 0x40, 0x60, 0xa0, 0x2a, 0x00, 0x97, -0xf0, 0x95, 0x60, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x31, 0x93, 0x80, 0x31, 0x95, 0x10, 0x10, 0x80, 0x31, 0x94, -0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, 0x28, 0x31, 0xa5, 0xa4, 0x08, 0x38, -0x31, 0xa7, 0x10, 0x10, 0xa4, 0x08, 0x30, 0x31, 0xa6, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x09, 0x48, 0x31, 0xc9, 0xa4, 0x09, 0x58, 0x31, -0xcb, 0x10, 0x10, 0xa4, 0x09, 0x50, 0x31, 0xca, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x08, 0xb8, 0x31, 0xb7, 0xa4, 0x08, 0xc8, 0x31, 0xb9, 0x10, 0x10, -0xa4, 0x08, 0xc0, 0x31, 0xb8, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x31, 0x90, 0x80, 0x31, 0x92, 0x10, 0x10, 0x80, 0x31, 0x91, -0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, 0x10, 0x31, 0xa2, 0xa4, 0x08, 0x20, -0x31, 0xa4, 0x10, 0x10, 0xa4, 0x08, 0x18, 0x31, 0xa3, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x09, 0x30, 0x31, 0xc6, 0xa4, 0x09, 0x40, 0x31, -0xc8, 0x10, 0x10, 0xa4, 0x09, 0x38, 0x31, 0xc7, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x08, 0xa0, 0x31, 0xb4, 0xa4, 0x08, 0xb0, 0x31, 0xb6, 0x10, 0x10, -0xa4, 0x08, 0xa8, 0x31, 0xb5, 0x10, 0x10, 0x91, 0x40, 0x90, 0xa0, 0x90, -0x50, 0x90, 0x28, 0x80, 0x30, 0xcb, 0x80, 0x30, 0xca, 0x90, 0x28, 0x80, -0x30, 0xc9, 0x80, 0x30, 0xc8, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0xc4, -0x80, 0x30, 0xc7, 0x90, 0x28, 0x80, 0x30, 0xc6, 0x80, 0x30, 0xc5, 0x90, -0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0xbc, 0x80, 0x30, 0xc3, 0x90, -0x28, 0x80, 0x30, 0xc2, 0x80, 0x30, 0xc1, 0x90, 0x50, 0x90, 0x28, 0x80, -0x30, 0xbd, 0x80, 0x30, 0xc0, 0x90, 0x28, 0x80, 0x30, 0xbf, 0x80, 0x30, -0xbe, 0x91, 0x88, 0x80, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x28, 0x81, 0x31, -0x3b, 0x10, 0x10, 0x80, 0x31, 0x3a, 0x90, 0x28, 0x81, 0x31, 0x3d, 0x10, -0x10, 0x80, 0x31, 0x3c, 0x90, 0x60, 0x90, 0x28, 0x81, 0x31, 0x41, 0x10, -0x10, 0x80, 0x31, 0x40, 0x90, 0x28, 0x81, 0x31, 0x3f, 0x10, 0x10, 0x80, -0x31, 0x3e, 0x80, 0x10, 0x10, 0x10, 0x10, 0x90, 0x28, 0x81, 0x31, 0x38, -0x10, 0x10, 0x80, 0x31, 0x39, 0xa0, 0x0b, 0x90, 0xa0, 0x0a, 0xc8, 0x95, -0x60, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, -0x31, 0x56, 0x80, 0x31, 0x55, 0x10, 0x10, 0x80, 0x31, 0x54, 0x90, 0x70, -0x90, 0x38, 0xa4, 0x06, 0xe8, 0x31, 0x68, 0xa4, 0x06, 0xe0, 0x31, 0x67, -0x10, 0x10, 0xa4, 0x06, 0xd8, 0x31, 0x66, 0x90, 0xb8, 0x90, 0x70, 0x90, -0x38, 0xa4, 0x08, 0x08, 0x31, 0x8c, 0xa4, 0x08, 0x00, 0x31, 0x8b, 0x10, -0x10, 0xa4, 0x07, 0xf8, 0x31, 0x8a, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x07, -0x78, 0x31, 0x7a, 0xa4, 0x07, 0x70, 0x31, 0x79, 0x10, 0x10, 0xa4, 0x07, -0x68, 0x31, 0x78, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, -0x31, 0x51, 0x80, 0x31, 0x53, 0x10, 0x10, 0x80, 0x31, 0x52, 0x90, 0x70, -0x90, 0x38, 0xa4, 0x06, 0xc0, 0x31, 0x63, 0xa4, 0x06, 0xd0, 0x31, 0x65, -0x10, 0x10, 0xa4, 0x06, 0xc8, 0x31, 0x64, 0x90, 0xb8, 0x90, 0x70, 0x90, -0x38, 0xa4, 0x07, 0xe0, 0x31, 0x87, 0xa4, 0x07, 0xf0, 0x31, 0x89, 0x10, -0x10, 0xa4, 0x07, 0xe8, 0x31, 0x88, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x07, -0x50, 0x31, 0x75, 0xa4, 0x07, 0x60, 0x31, 0x77, 0x10, 0x10, 0xa4, 0x07, -0x58, 0x31, 0x76, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x31, 0x4e, 0x80, 0x31, 0x50, 0x10, 0x10, 0x80, 0x31, 0x4f, -0x90, 0x70, 0x90, 0x38, 0xa4, 0x06, 0xa8, 0x31, 0x60, 0xa4, 0x06, 0xb8, -0x31, 0x62, 0x10, 0x10, 0xa4, 0x06, 0xb0, 0x31, 0x61, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x07, 0xc8, 0x31, 0x84, 0xa4, 0x07, 0xd8, 0x31, -0x86, 0x10, 0x10, 0xa4, 0x07, 0xd0, 0x31, 0x85, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x07, 0x38, 0x31, 0x72, 0xa4, 0x07, 0x48, 0x31, 0x74, 0x10, 0x10, -0xa4, 0x07, 0x40, 0x31, 0x73, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, -0x28, 0x80, 0x31, 0x4b, 0x80, 0x31, 0x4d, 0x10, 0x10, 0x80, 0x31, 0x4c, -0x90, 0x70, 0x90, 0x38, 0xa4, 0x06, 0x90, 0x31, 0x5d, 0xa4, 0x06, 0xa0, -0x31, 0x5f, 0x10, 0x10, 0xa4, 0x06, 0x98, 0x31, 0x5e, 0x90, 0xb8, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x07, 0xb0, 0x31, 0x81, 0xa4, 0x07, 0xc0, 0x31, -0x83, 0x10, 0x10, 0xa4, 0x07, 0xb8, 0x31, 0x82, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x07, 0x20, 0x31, 0x6f, 0xa4, 0x07, 0x30, 0x31, 0x71, 0x10, 0x10, -0xa4, 0x07, 0x28, 0x31, 0x70, 0x10, 0x10, 0x80, 0x10, 0x10, 0x10, 0x10, -0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0x42, 0x80, 0x31, 0x44, 0x10, 0x10, -0x80, 0x31, 0x43, 0x80, 0x95, 0x60, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, -0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0x48, 0x80, 0x31, 0x4a, 0x10, 0x10, -0x80, 0x31, 0x49, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x06, 0x78, 0x31, 0x5a, -0xa4, 0x06, 0x88, 0x31, 0x5c, 0x10, 0x10, 0xa4, 0x06, 0x80, 0x31, 0x5b, -0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x07, 0x98, 0x31, 0x7e, 0xa4, -0x07, 0xa8, 0x31, 0x80, 0x10, 0x10, 0xa4, 0x07, 0xa0, 0x31, 0x7f, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x07, 0x08, 0x31, 0x6c, 0xa4, 0x07, 0x18, 0x31, -0x6e, 0x10, 0x10, 0xa4, 0x07, 0x10, 0x31, 0x6d, 0x91, 0x40, 0x90, 0x88, -0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0x45, 0x80, 0x31, 0x47, 0x10, 0x10, -0x80, 0x31, 0x46, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x06, 0x60, 0x31, 0x57, -0xa4, 0x06, 0x70, 0x31, 0x59, 0x10, 0x10, 0xa4, 0x06, 0x68, 0x31, 0x58, -0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x07, 0x80, 0x31, 0x7b, 0xa4, -0x07, 0x90, 0x31, 0x7d, 0x10, 0x10, 0xa4, 0x07, 0x88, 0x31, 0x7c, 0x90, -0x70, 0x90, 0x38, 0xa4, 0x06, 0xf0, 0x31, 0x69, 0xa4, 0x07, 0x00, 0x31, -0x6b, 0x10, 0x10, 0xa4, 0x06, 0xf8, 0x31, 0x6a, 0x10, 0x10, 0x91, 0x40, -0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0xbb, 0x80, 0x30, 0xba, -0x90, 0x28, 0x80, 0x30, 0xb9, 0x80, 0x30, 0xb8, 0x90, 0x50, 0x90, 0x28, -0x80, 0x30, 0xb4, 0x80, 0x30, 0xb7, 0x90, 0x28, 0x80, 0x30, 0xb6, 0x80, -0x30, 0xb5, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0xac, 0x80, -0x30, 0xb3, 0x90, 0x28, 0x80, 0x30, 0xb2, 0x80, 0x30, 0xb1, 0x90, 0x50, -0x90, 0x28, 0x80, 0x30, 0xad, 0x80, 0x30, 0xb0, 0x90, 0x28, 0x80, 0x30, -0xaf, 0x80, 0x30, 0xae, 0xc3, 0xc0, 0x30, 0x42, 0x9c, 0xe8, 0x07, 0x60, -0x91, 0x90, 0x90, 0xf0, 0x10, 0x10, 0x80, 0x88, 0x00, 0x80, 0x90, 0x50, -0x90, 0x28, 0x80, 0x33, 0xf8, 0x80, 0x33, 0xf9, 0x81, 0x33, 0xef, 0xd0, -0x41, 0x80, 0x24, 0x20, 0x90, 0x24, 0x20, 0x98, 0x10, 0x10, 0x80, 0x90, -0x58, 0x80, 0x90, 0x28, 0x24, 0x1f, 0x90, 0x24, 0x1f, 0x98, 0x81, 0x24, -0x1f, 0x50, 0x92, 0x68, 0x91, 0x00, 0x80, 0x90, 0x90, 0x90, 0x30, 0x80, -0x24, 0x20, 0x00, 0x90, 0x38, 0xa4, 0x1f, 0xf8, 0x34, 0x06, 0x80, 0x34, -0x05, 0x80, 0x90, 0x28, 0x80, 0x34, 0x0f, 0xa4, 0x1f, 0xe0, 0x34, 0x0e, -0x80, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x28, 0x80, 0x34, 0x09, 0xa4, 0x1f, -0xf0, 0x34, 0x08, 0x90, 0x28, 0x80, 0x34, 0x04, 0xa4, 0x1f, 0xe8, 0x34, -0x03, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x0d, 0x80, 0x34, 0x0c, 0x90, -0x28, 0x24, 0x20, 0x88, 0x24, 0x20, 0x80, 0x90, 0x58, 0x80, 0x10, 0x10, -0x80, 0x10, 0x10, 0x80, 0x33, 0xfb, 0x80, 0x90, 0x40, 0x10, 0x10, 0x80, -0x24, 0x1f, 0x60, 0x80, 0x10, 0x10, 0x80, 0x33, 0xfa, 0x91, 0x58, 0x91, -0x00, 0x90, 0x80, 0x81, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xf6, 0x80, -0x33, 0xf7, 0x81, 0x33, 0xee, 0x81, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, -0xf4, 0x80, 0x33, 0xf5, 0x81, 0x33, 0xed, 0x83, 0x90, 0x28, 0x24, 0x1f, -0x80, 0x24, 0x1f, 0x88, 0x90, 0xe8, 0x81, 0x90, 0x88, 0x90, 0x38, 0x10, -0x10, 0x80, 0x34, 0x07, 0x90, 0x28, 0x80, 0x34, 0x02, 0x80, 0x34, 0x01, -0x80, 0x90, 0x28, 0x80, 0x34, 0x0b, 0x80, 0x34, 0x0a, 0x82, 0x10, 0x10, -0x80, 0x24, 0x1f, 0x58, 0x97, 0x10, 0x9e, 0x10, 0x06, 0x98, 0x93, 0x00, -0x91, 0x80, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x03, 0x80, 0x30, -0x71, 0x24, 0x03, 0x78, 0x90, 0x38, 0xa4, 0x04, 0x10, 0x30, 0x83, 0x24, -0x04, 0x08, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x05, 0x30, 0x30, 0xa7, 0x24, -0x05, 0x28, 0x90, 0x38, 0xa4, 0x04, 0xa0, 0x30, 0x95, 0x24, 0x04, 0x98, -0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x03, 0x70, 0x30, 0x6c, 0x24, -0x03, 0x68, 0x90, 0x38, 0xa4, 0x04, 0x00, 0x30, 0x7e, 0x24, 0x03, 0xf8, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x05, 0x20, 0x30, 0xa2, 0x24, 0x05, 0x18, -0x90, 0x38, 0xa4, 0x04, 0x90, 0x30, 0x90, 0x24, 0x04, 0x88, 0x91, 0x80, -0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x03, 0x58, 0x30, 0x69, 0x24, -0x03, 0x50, 0x90, 0x38, 0xa4, 0x03, 0xe8, 0x30, 0x7b, 0x24, 0x03, 0xe0, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x05, 0x08, 0x30, 0x9f, 0x24, 0x05, 0x00, -0x90, 0x38, 0xa4, 0x04, 0x78, 0x30, 0x8d, 0x24, 0x04, 0x70, 0x90, 0xc0, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x03, 0x40, 0x30, 0x66, 0x24, 0x03, 0x38, -0x90, 0x38, 0xa4, 0x03, 0xd0, 0x30, 0x78, 0x24, 0x03, 0xc8, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x04, 0xf0, 0x30, 0x9c, 0x24, 0x04, 0xe8, 0x90, 0x38, -0xa4, 0x04, 0x60, 0x30, 0x8a, 0x24, 0x04, 0x58, 0x10, 0x10, 0x80, 0x10, -0x10, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x02, 0xf8, 0x30, 0x5d, 0x24, 0x02, -0xf0, 0xd7, 0x42, 0x00, 0xa4, 0x39, 0x58, 0x37, 0x2d, 0xa4, 0x39, 0x38, -0x37, 0x29, 0x9c, 0xe0, 0x06, 0x90, 0x93, 0x00, 0x91, 0x80, 0x90, 0xc0, -0x90, 0x60, 0x90, 0x38, 0xa4, 0x03, 0x28, 0x30, 0x63, 0x24, 0x03, 0x20, -0x90, 0x38, 0xa4, 0x03, 0xb8, 0x30, 0x75, 0x24, 0x03, 0xb0, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x04, 0xd8, 0x30, 0x99, 0x24, 0x04, 0xd0, 0x90, 0x38, -0xa4, 0x04, 0x48, 0x30, 0x87, 0x24, 0x04, 0x40, 0x90, 0xc0, 0x90, 0x60, -0x90, 0x38, 0xa4, 0x03, 0x10, 0x30, 0x60, 0x24, 0x03, 0x08, 0x90, 0x38, -0xa4, 0x03, 0xa0, 0x30, 0x72, 0x24, 0x03, 0x98, 0x90, 0x60, 0x90, 0x38, -0xa4, 0x04, 0xc0, 0x30, 0x96, 0x24, 0x04, 0xb8, 0x90, 0x38, 0xa4, 0x04, -0x30, 0x30, 0x84, 0x24, 0x04, 0x28, 0x10, 0x10, 0x90, 0xe0, 0x90, 0x70, -0x90, 0x38, 0xa4, 0x02, 0x88, 0x30, 0x52, 0xa4, 0x02, 0x78, 0x30, 0x50, -0x90, 0x38, 0xa4, 0x02, 0x70, 0x30, 0x4b, 0xa4, 0x02, 0x60, 0x30, 0x4d, -0x90, 0x70, 0x90, 0x38, 0xa4, 0x02, 0x50, 0x30, 0x43, 0xa4, 0x02, 0x40, -0x30, 0x49, 0x90, 0x38, 0xa4, 0x02, 0x38, 0x30, 0x44, 0xa4, 0x02, 0x28, -0x30, 0x46, 0x91, 0x48, 0x80, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, -0x30, 0x56, 0x24, 0x02, 0xa8, 0x90, 0x28, 0x80, 0x30, 0x58, 0x24, 0x02, -0xb8, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0x5c, 0x24, 0x02, 0xd8, 0x90, -0x28, 0x80, 0x30, 0x5a, 0x24, 0x02, 0xc8, 0x80, 0x10, 0x10, 0x10, 0x10, -0x90, 0x28, 0x80, 0x30, 0x53, 0x24, 0x02, 0xa0, 0xd7, 0x42, 0x00, 0xa4, -0x39, 0x60, 0x37, 0x2e, 0xa4, 0x39, 0x40, 0x37, 0x2a, 0xa0, 0x14, 0x68, -0xa0, 0x10, 0x90, 0xa0, 0x0c, 0x60, 0x9e, 0x88, 0x09, 0xd0, 0x94, 0xf0, -0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x4c, 0x40, -0x85, 0x35, 0x4d, 0xcb, 0x61, 0x45, 0x00, 0x85, 0x35, 0x23, 0x9a, 0x00, -0x03, 0xf8, 0x91, 0x98, 0x80, 0x91, 0x10, 0x90, 0xa0, 0x90, 0x68, 0x90, -0x20, 0x3a, 0x75, 0xc9, 0xe2, 0x9c, 0xc0, 0x85, 0x35, 0x4b, 0xa4, 0x53, -0x88, 0x3a, 0x72, 0x90, 0x38, 0xa4, 0x53, 0x50, 0x3a, 0x6b, 0xa4, 0x53, -0x40, 0x3a, 0x69, 0x90, 0x48, 0x10, 0x10, 0xa4, 0x53, 0x08, 0x3a, 0x62, -0x10, 0x10, 0x80, 0x3a, 0x5e, 0x81, 0x10, 0x10, 0x80, 0xa4, 0x52, 0xd8, -0x3a, 0x5c, 0x91, 0xb0, 0x91, 0x60, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, -0xa4, 0x53, 0x78, 0x3a, 0x70, 0xa4, 0x53, 0x68, 0x3a, 0x6e, 0x90, 0x38, -0xa4, 0x53, 0x30, 0x3a, 0x67, 0xa4, 0x53, 0x20, 0x3a, 0x65, 0x90, 0x48, -0x10, 0x10, 0xa4, 0x52, 0xf8, 0x3a, 0x60, 0x10, 0x10, 0x80, 0x3a, 0x5d, -0x90, 0x28, 0x80, 0x3a, 0x56, 0x80, 0x3a, 0x55, 0x81, 0x10, 0x10, 0x80, -0xa4, 0x52, 0xc8, 0x3a, 0x5a, 0xcb, 0x61, 0x44, 0xc0, 0x85, 0x35, 0x22, -0x90, 0xd8, 0x88, 0x00, 0x90, 0x84, 0x90, 0x38, 0xc1, 0xc0, 0x85, 0x3a, -0x78, 0xc9, 0xe1, 0x4c, 0x00, 0x85, 0x35, 0x49, 0xcb, 0x61, 0x44, 0x80, -0x85, 0x35, 0x21, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x4b, -0xc0, 0x85, 0x35, 0x47, 0xcb, 0x61, 0x44, 0x40, 0x85, 0x35, 0x20, 0x91, -0xf8, 0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x4b, -0x40, 0x85, 0x35, 0x43, 0xcb, 0x61, 0x43, 0xc0, 0x85, 0x35, 0x1e, 0x88, -0x01, 0x00, 0x90, 0xa0, 0x81, 0x90, 0x70, 0x80, 0x90, 0x20, 0x3a, 0x6c, -0xc9, 0xe1, 0x4b, 0x00, 0x85, 0x35, 0x41, 0x81, 0x3a, 0x63, 0x81, 0x10, -0x10, 0x80, 0xa4, 0x52, 0xb8, 0x3a, 0x58, 0xcb, 0x61, 0x43, 0x80, 0x85, -0x35, 0x1d, 0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, -0x4a, 0xc0, 0x85, 0x35, 0x3f, 0xcb, 0x61, 0x43, 0x40, 0x85, 0x35, 0x1c, -0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x4a, 0x80, 0x85, 0x35, -0x3d, 0xcb, 0x61, 0x43, 0x00, 0x85, 0x35, 0x1b, 0x92, 0x38, 0x81, 0x91, -0x68, 0x91, 0x18, 0x90, 0x80, 0x90, 0x40, 0x80, 0xa4, 0x54, 0x38, 0x3a, -0x88, 0x80, 0xa4, 0x54, 0x30, 0x3a, 0x85, 0x90, 0x28, 0x81, 0x3a, 0x84, -0x90, 0x38, 0xa4, 0x54, 0x10, 0x3a, 0x83, 0xa4, 0x54, 0x00, 0x3a, 0x81, -0x90, 0x28, 0x80, 0x3a, 0x7f, 0x80, 0x3a, 0x7e, 0x80, 0x90, 0x40, 0x10, -0x10, 0x80, 0x24, 0x53, 0xe8, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x53, 0xd8, -0x3a, 0x7c, 0xa4, 0x53, 0xc8, 0x3a, 0x7a, 0x90, 0x28, 0x80, 0x3a, 0x77, -0x80, 0x3a, 0x76, 0x9a, 0xd0, 0x03, 0xe0, 0x91, 0x60, 0x90, 0xb0, 0x88, -0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x4a, 0x00, 0x85, 0x35, 0x39, -0xcb, 0x61, 0x42, 0x80, 0x85, 0x35, 0x19, 0x88, 0x00, 0x68, 0x84, 0x10, -0x10, 0xc9, 0xe1, 0x49, 0xc0, 0x85, 0x35, 0x37, 0xcb, 0x61, 0x42, 0x40, -0x85, 0x35, 0x18, 0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, -0xe1, 0x49, 0x80, 0x85, 0x35, 0x35, 0xcb, 0x61, 0x42, 0x00, 0x85, 0x35, -0x17, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x49, 0x40, 0x85, -0x35, 0x33, 0xcb, 0x61, 0x41, 0xc0, 0x85, 0x35, 0x16, 0x90, 0x90, 0x90, -0x48, 0xcb, 0xa1, 0x40, 0x00, 0x85, 0x35, 0x05, 0xcb, 0xa1, 0x3f, 0xc0, -0x85, 0x35, 0x04, 0x90, 0x48, 0xcb, 0xa1, 0x3f, 0x80, 0x85, 0x35, 0x03, -0xcb, 0xa1, 0x3f, 0x40, 0x85, 0x35, 0x02, 0xcb, 0xa2, 0x94, 0xc0, 0x80, -0x3a, 0x54, 0x92, 0x40, 0x91, 0x20, 0x90, 0x90, 0x90, 0x48, 0x8c, 0x27, -0x60, 0x84, 0x24, 0x27, 0xd8, 0x8c, 0x27, 0x58, 0x84, 0x24, 0x27, 0xd0, -0x90, 0x48, 0x8c, 0x27, 0x50, 0x84, 0x24, 0x27, 0xc8, 0x8c, 0x27, 0x48, -0x84, 0x24, 0x27, 0xc0, 0x90, 0x90, 0x90, 0x48, 0x8c, 0x27, 0x38, 0x84, -0x24, 0x27, 0xb0, 0x8c, 0x27, 0x30, 0x84, 0x24, 0x27, 0xa8, 0x90, 0x48, -0x8c, 0x27, 0x28, 0x84, 0x24, 0x27, 0xa0, 0x8c, 0x27, 0x20, 0x84, 0x24, -0x27, 0x98, 0x91, 0x20, 0x90, 0x90, 0x90, 0x48, 0x8c, 0x27, 0x10, 0x84, -0x24, 0x27, 0x88, 0x8c, 0x27, 0x08, 0x84, 0x24, 0x27, 0x80, 0x90, 0x48, -0x8c, 0x27, 0x00, 0x84, 0x24, 0x27, 0x78, 0x8c, 0x26, 0xf8, 0x84, 0x24, -0x27, 0x70, 0x90, 0x38, 0xa4, 0x26, 0xe0, 0x34, 0xdd, 0xa4, 0x26, 0xd0, -0x34, 0xdb, 0xa0, 0x0f, 0x50, 0xa0, 0x09, 0x08, 0x9a, 0x30, 0x04, 0x40, -0x91, 0x90, 0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x22, 0x92, 0xc0, -0x3a, 0x43, 0xe5, 0x22, 0x8a, 0xc0, 0x3a, 0x3f, 0xcb, 0x61, 0x32, 0x40, -0x85, 0x34, 0xd8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x22, 0x82, 0xc0, 0x3a, -0x03, 0xe5, 0x22, 0x7a, 0xc0, 0x39, 0xff, 0xcb, 0x61, 0x32, 0x00, 0x85, -0x34, 0xd7, 0x90, 0x48, 0xcb, 0xa1, 0x31, 0xc0, 0x85, 0x34, 0xd6, 0xcb, -0xa1, 0x31, 0x80, 0x85, 0x34, 0xd5, 0x91, 0x90, 0x90, 0xc8, 0x98, 0x50, -0x00, 0x80, 0xe5, 0x22, 0x6c, 0xc0, 0x39, 0xcb, 0xe5, 0x22, 0x60, 0xc0, -0x39, 0x9b, 0xcb, 0x61, 0x31, 0x00, 0x85, 0x34, 0xd3, 0x98, 0x50, 0x00, -0x80, 0xe5, 0x22, 0x54, 0xc0, 0x39, 0x6b, 0xe5, 0x22, 0x48, 0xc0, 0x39, -0x3b, 0xcb, 0x61, 0x30, 0xc0, 0x85, 0x34, 0xd2, 0x90, 0x48, 0xcb, 0xa1, -0x30, 0x80, 0x85, 0x34, 0xd1, 0xcb, 0xa1, 0x30, 0x40, 0x85, 0x34, 0xd0, -0x92, 0x20, 0x91, 0x30, 0x90, 0xb8, 0xd5, 0x03, 0x00, 0xc0, 0xc0, 0x81, -0x8c, 0x01, 0xa0, 0x84, 0x30, 0x3e, 0xc0, 0xc0, 0x81, 0x8c, 0x01, 0x80, -0x84, 0x30, 0x3c, 0xd5, 0x02, 0x00, 0xc0, 0xc0, 0x81, 0x30, 0x28, 0xc0, -0xc0, 0x81, 0x30, 0x24, 0x90, 0x78, 0xd5, 0x02, 0x00, 0xc0, 0xc0, 0x81, -0x30, 0x1c, 0xc0, 0xc0, 0x81, 0x30, 0x18, 0xd5, 0x02, 0x00, 0xc0, 0xc0, -0x81, 0x30, 0x10, 0xc0, 0xc0, 0x81, 0x30, 0x0c, 0x91, 0x70, 0x90, 0xd8, -0xd5, 0x03, 0x80, 0xc8, 0xe2, 0x40, 0xc0, 0x81, 0x8c, 0x01, 0xc0, 0x84, -0x30, 0x40, 0xc8, 0xe2, 0x42, 0xc0, 0x81, 0x8c, 0x01, 0x90, 0x84, 0x30, -0x3d, 0xd5, 0x02, 0x80, 0xc8, 0xe2, 0x3f, 0xc0, 0x81, 0x30, 0x2c, 0xc8, -0xe2, 0x3a, 0x40, 0x81, 0x30, 0x26, 0x90, 0x98, 0xd5, 0x02, 0x80, 0xc8, -0xe2, 0x2f, 0x40, 0x81, 0x30, 0x20, 0xc8, 0xe2, 0x31, 0x40, 0x81, 0x30, -0x1a, 0xd5, 0x02, 0x80, 0xc8, 0xe2, 0x2e, 0x40, 0x81, 0x30, 0x14, 0xc8, -0xe2, 0x28, 0xc0, 0x81, 0x30, 0x0e, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x90, -0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x22, 0x86, 0xc0, 0x3a, 0x13, -0xe5, 0x22, 0x88, 0xc0, 0x3a, 0x37, 0xcb, 0x61, 0x2f, 0xc0, 0x85, 0x34, -0xce, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x22, 0x76, 0xc0, 0x39, 0xd3, 0xe5, -0x22, 0x78, 0xc0, 0x39, 0xf7, 0xcb, 0x61, 0x2f, 0x80, 0x85, 0x34, 0xcd, -0x90, 0x48, 0xcb, 0xa1, 0x2f, 0x40, 0x85, 0x34, 0xcc, 0xcb, 0xa1, 0x2f, -0x00, 0x85, 0x34, 0xcb, 0x91, 0x90, 0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, -0xe5, 0x22, 0x68, 0xc0, 0x39, 0xbb, 0xe5, 0x22, 0x5c, 0xc0, 0x39, 0x8b, -0xcb, 0x61, 0x2d, 0x40, 0x85, 0x34, 0xba, 0x98, 0x50, 0x00, 0x80, 0xe5, -0x22, 0x50, 0xc0, 0x39, 0x5b, 0xe5, 0x22, 0x44, 0xc0, 0x39, 0x2b, 0xcb, -0x61, 0x2d, 0x00, 0x85, 0x34, 0xb9, 0x90, 0x48, 0xcb, 0xa1, 0x2c, 0xc0, -0x85, 0x34, 0xb8, 0xcb, 0xa1, 0x2c, 0x80, 0x85, 0x34, 0xb7, 0x91, 0x00, -0x90, 0x80, 0x90, 0x40, 0xe5, 0x20, 0x02, 0x40, 0x30, 0x0a, 0xe5, 0x20, -0x01, 0x80, 0x30, 0x07, 0x90, 0x40, 0xe5, 0x20, 0x00, 0xc0, 0x30, 0x04, -0xe5, 0x20, 0x00, 0x00, 0x30, 0x01, 0x90, 0x80, 0x90, 0x40, 0xe5, 0x22, -0x35, 0xc0, 0x38, 0xcd, 0xe5, 0x22, 0x38, 0x00, 0x38, 0xf5, 0x90, 0x40, -0xe5, 0x22, 0x24, 0x40, 0x38, 0x87, 0xe5, 0x22, 0x26, 0x80, 0x38, 0xaf, -0x80, 0x99, 0x28, 0x02, 0xf0, 0x8c, 0x25, 0x48, 0x90, 0x80, 0x90, 0x40, -0xe5, 0x22, 0x8c, 0xc0, 0x3a, 0x2f, 0xe5, 0x22, 0x89, 0xc0, 0x3a, 0x3b, -0x90, 0x40, 0xe5, 0x22, 0x7c, 0xc0, 0x39, 0xef, 0xe5, 0x22, 0x79, 0xc0, -0x39, 0xfb, 0x91, 0x48, 0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x22, -0x6a, 0xc0, 0x39, 0xc3, 0xe5, 0x22, 0x5e, 0xc0, 0x39, 0x93, 0xcb, 0x61, -0x2b, 0x00, 0x85, 0x34, 0xb0, 0x90, 0x40, 0xe5, 0x22, 0x52, 0xc0, 0x39, -0x63, 0xe5, 0x22, 0x46, 0xc0, 0x39, 0x33, 0x90, 0x48, 0xcb, 0xa1, 0x2a, -0x80, 0x85, 0x34, 0xae, 0xcb, 0xa1, 0x2a, 0xc0, 0x85, 0x34, 0xaf, 0x10, -0x10, 0x90, 0x80, 0x90, 0x40, 0xe5, 0x22, 0x3c, 0x40, 0x38, 0xed, 0xe5, -0x22, 0x39, 0x40, 0x38, 0xfb, 0x90, 0x40, 0xe5, 0x22, 0x2a, 0xc0, 0x38, -0xa7, 0xe5, 0x22, 0x27, 0xc0, 0x38, 0xb5, -}; - -static const struct ia64_dis_names ia64_dis_names[] = { -{ 0x51, 41, 0, 10 }, -{ 0x31, 41, 1, 20 }, -{ 0x11, 42, 0, 19 }, -{ 0x29, 41, 0, 12 }, -{ 0x19, 41, 1, 24 }, -{ 0x9, 42, 0, 23 }, -{ 0x15, 41, 0, 14 }, -{ 0xd, 41, 1, 28 }, -{ 0x5, 42, 0, 27 }, -{ 0xb, 41, 0, 16 }, -{ 0x7, 41, 1, 32 }, -{ 0x3, 42, 0, 31 }, -{ 0x51, 39, 1, 58 }, -{ 0x50, 39, 0, 34 }, -{ 0xd1, 39, 1, 57 }, -{ 0xd0, 39, 0, 33 }, -{ 0x31, 39, 1, 68 }, -{ 0x30, 39, 1, 44 }, -{ 0x11, 40, 1, 67 }, -{ 0x10, 40, 0, 43 }, -{ 0x71, 39, 1, 66 }, -{ 0x70, 39, 1, 42 }, -{ 0x31, 40, 1, 65 }, -{ 0x30, 40, 0, 41 }, -{ 0x29, 39, 1, 60 }, -{ 0x28, 39, 0, 36 }, -{ 0x69, 39, 1, 59 }, -{ 0x68, 39, 0, 35 }, -{ 0x19, 39, 1, 72 }, -{ 0x18, 39, 1, 48 }, -{ 0x9, 40, 1, 71 }, -{ 0x8, 40, 0, 47 }, -{ 0x39, 39, 1, 70 }, -{ 0x38, 39, 1, 46 }, -{ 0x19, 40, 1, 69 }, -{ 0x18, 40, 0, 45 }, -{ 0x15, 39, 1, 62 }, -{ 0x14, 39, 0, 38 }, -{ 0x35, 39, 1, 61 }, -{ 0x34, 39, 0, 37 }, -{ 0xd, 39, 1, 76 }, -{ 0xc, 39, 1, 52 }, -{ 0x5, 40, 1, 75 }, -{ 0x4, 40, 0, 51 }, -{ 0x1d, 39, 1, 74 }, -{ 0x1c, 39, 1, 50 }, -{ 0xd, 40, 1, 73 }, -{ 0xc, 40, 0, 49 }, -{ 0xb, 39, 1, 64 }, -{ 0xa, 39, 0, 40 }, -{ 0x1b, 39, 1, 63 }, -{ 0x1a, 39, 0, 39 }, -{ 0x7, 39, 1, 80 }, -{ 0x6, 39, 1, 56 }, -{ 0x3, 40, 1, 79 }, -{ 0x2, 40, 0, 55 }, -{ 0xf, 39, 1, 78 }, -{ 0xe, 39, 1, 54 }, -{ 0x7, 40, 1, 77 }, -{ 0x6, 40, 0, 53 }, -{ 0x8, 38, 0, 82 }, -{ 0x18, 38, 0, 81 }, -{ 0x1, 38, 1, 86 }, -{ 0x2, 38, 0, 85 }, -{ 0x3, 38, 1, 84 }, -{ 0x4, 38, 0, 83 }, -{ 0x1, 336, 0, 87 }, -{ 0x20, 289, 0, 98 }, -{ 0x220, 289, 0, 94 }, -{ 0x1220, 289, 0, 91 }, -{ 0xa20, 289, 0, 92 }, -{ 0x620, 289, 0, 93 }, -{ 0x120, 289, 0, 95 }, -{ 0xa0, 289, 0, 96 }, -{ 0x60, 289, 0, 97 }, -{ 0x10, 289, 0, 102 }, -{ 0x90, 289, 0, 99 }, -{ 0x50, 289, 0, 100 }, -{ 0x30, 289, 0, 101 }, -{ 0x8, 289, 0, 103 }, -{ 0x4, 289, 0, 104 }, -{ 0x2, 289, 0, 105 }, -{ 0x1, 289, 0, 106 }, -{ 0x1, 411, 0, 108 }, -{ 0x3, 411, 0, 107 }, -{ 0x2, 417, 0, 109 }, -{ 0x1, 417, 0, 110 }, -{ 0x2, 413, 0, 111 }, -{ 0x1, 413, 0, 112 }, -{ 0x2, 415, 0, 113 }, -{ 0x1, 415, 0, 114 }, -{ 0x2, 419, 0, 115 }, -{ 0x1, 419, 0, 116 }, -{ 0x1, 268, 0, 143 }, -{ 0x5, 268, 0, 141 }, -{ 0x3, 268, 0, 142 }, -{ 0x140, 277, 0, 119 }, -{ 0x540, 277, 0, 117 }, -{ 0x340, 277, 0, 118 }, -{ 0xc0, 277, 0, 131 }, -{ 0x2c0, 277, 0, 129 }, -{ 0x1c0, 277, 0, 130 }, -{ 0x20, 277, 0, 146 }, -{ 0xa0, 277, 0, 144 }, -{ 0x60, 277, 0, 145 }, -{ 0x10, 277, 0, 158 }, -{ 0x50, 277, 0, 156 }, -{ 0x30, 277, 0, 157 }, -{ 0x8, 277, 0, 170 }, -{ 0x28, 277, 0, 168 }, -{ 0x18, 277, 0, 169 }, -{ 0x4, 277, 0, 180 }, -{ 0x2, 277, 0, 181 }, -{ 0x1, 277, 0, 182 }, -{ 0x140, 271, 0, 122 }, -{ 0x540, 271, 0, 120 }, -{ 0x340, 271, 0, 121 }, -{ 0xc0, 271, 0, 134 }, -{ 0x2c0, 271, 0, 132 }, -{ 0x1c0, 271, 0, 133 }, -{ 0x20, 271, 0, 149 }, -{ 0xa0, 271, 0, 147 }, -{ 0x60, 271, 0, 148 }, -{ 0x10, 271, 0, 161 }, -{ 0x50, 271, 0, 159 }, -{ 0x30, 271, 0, 160 }, -{ 0x8, 271, 0, 173 }, -{ 0x28, 271, 0, 171 }, -{ 0x18, 271, 0, 172 }, -{ 0x4, 271, 0, 183 }, -{ 0x2, 271, 0, 184 }, -{ 0x1, 271, 0, 185 }, -{ 0x140, 274, 0, 125 }, -{ 0x540, 274, 0, 123 }, -{ 0x340, 274, 0, 124 }, -{ 0xc0, 274, 0, 137 }, -{ 0x2c0, 274, 0, 135 }, -{ 0x1c0, 274, 0, 136 }, -{ 0x20, 274, 0, 152 }, -{ 0xa0, 274, 0, 150 }, -{ 0x60, 274, 0, 151 }, -{ 0x10, 274, 0, 164 }, -{ 0x50, 274, 0, 162 }, -{ 0x30, 274, 0, 163 }, -{ 0x8, 274, 0, 176 }, -{ 0x28, 274, 0, 174 }, -{ 0x18, 274, 0, 175 }, -{ 0x4, 274, 0, 186 }, -{ 0x2, 274, 0, 187 }, -{ 0x1, 274, 0, 188 }, -{ 0x140, 286, 0, 128 }, -{ 0x540, 286, 0, 126 }, -{ 0x340, 286, 0, 127 }, -{ 0xc0, 286, 0, 140 }, -{ 0x2c0, 286, 0, 138 }, -{ 0x1c0, 286, 0, 139 }, -{ 0x20, 286, 0, 155 }, -{ 0xa0, 286, 0, 153 }, -{ 0x60, 286, 0, 154 }, -{ 0x10, 286, 0, 167 }, -{ 0x50, 286, 0, 165 }, -{ 0x30, 286, 0, 166 }, -{ 0x8, 286, 0, 179 }, -{ 0x28, 286, 0, 177 }, -{ 0x18, 286, 0, 178 }, -{ 0x4, 286, 0, 189 }, -{ 0x2, 286, 0, 190 }, -{ 0x1, 286, 0, 191 }, -{ 0x8, 390, 0, 192 }, -{ 0x4, 390, 0, 193 }, -{ 0x2, 390, 0, 194 }, -{ 0x1, 390, 0, 195 }, -{ 0x20, 288, 0, 203 }, -{ 0x220, 288, 0, 199 }, -{ 0x1220, 288, 0, 196 }, -{ 0xa20, 288, 0, 197 }, -{ 0x620, 288, 0, 198 }, -{ 0x120, 288, 0, 200 }, -{ 0xa0, 288, 0, 201 }, -{ 0x60, 288, 0, 202 }, -{ 0x10, 288, 0, 207 }, -{ 0x90, 288, 0, 204 }, -{ 0x50, 288, 0, 205 }, -{ 0x30, 288, 0, 206 }, -{ 0x8, 288, 0, 208 }, -{ 0x4, 288, 0, 209 }, -{ 0x2, 288, 0, 210 }, -{ 0x1, 288, 0, 211 }, -{ 0x20, 287, 0, 219 }, -{ 0x220, 287, 0, 215 }, -{ 0x1220, 287, 0, 212 }, -{ 0xa20, 287, 0, 213 }, -{ 0x620, 287, 0, 214 }, -{ 0x120, 287, 0, 216 }, -{ 0xa0, 287, 0, 217 }, -{ 0x60, 287, 0, 218 }, -{ 0x10, 287, 0, 223 }, -{ 0x90, 287, 0, 220 }, -{ 0x50, 287, 0, 221 }, -{ 0x30, 287, 0, 222 }, -{ 0x8, 287, 0, 224 }, -{ 0x4, 287, 0, 225 }, -{ 0x2, 287, 0, 226 }, -{ 0x1, 287, 0, 227 }, -{ 0x140, 279, 0, 230 }, -{ 0x540, 279, 0, 228 }, -{ 0x340, 279, 0, 229 }, -{ 0xc0, 279, 0, 239 }, -{ 0x2c0, 279, 0, 237 }, -{ 0x1c0, 279, 0, 238 }, -{ 0x20, 279, 0, 248 }, -{ 0xa0, 279, 0, 246 }, -{ 0x60, 279, 0, 247 }, -{ 0x10, 279, 0, 257 }, -{ 0x50, 279, 0, 255 }, -{ 0x30, 279, 0, 256 }, -{ 0x8, 279, 0, 266 }, -{ 0x28, 279, 0, 264 }, -{ 0x18, 279, 0, 265 }, -{ 0x4, 279, 0, 273 }, -{ 0x2, 279, 0, 274 }, -{ 0x1, 279, 0, 275 }, -{ 0x140, 281, 0, 233 }, -{ 0x540, 281, 0, 231 }, -{ 0x340, 281, 0, 232 }, -{ 0xc0, 281, 0, 242 }, -{ 0x2c0, 281, 0, 240 }, -{ 0x1c0, 281, 0, 241 }, -{ 0x20, 281, 0, 251 }, -{ 0xa0, 281, 0, 249 }, -{ 0x60, 281, 0, 250 }, -{ 0x10, 281, 0, 260 }, -{ 0x50, 281, 0, 258 }, -{ 0x30, 281, 0, 259 }, -{ 0x8, 281, 0, 269 }, -{ 0x28, 281, 0, 267 }, -{ 0x18, 281, 0, 268 }, -{ 0x4, 281, 0, 276 }, -{ 0x2, 281, 0, 277 }, -{ 0x1, 281, 0, 278 }, -{ 0x140, 283, 0, 236 }, -{ 0x540, 283, 0, 234 }, -{ 0x340, 283, 0, 235 }, -{ 0xc0, 283, 0, 245 }, -{ 0x2c0, 283, 0, 243 }, -{ 0x1c0, 283, 0, 244 }, -{ 0x20, 283, 0, 254 }, -{ 0xa0, 283, 0, 252 }, -{ 0x60, 283, 0, 253 }, -{ 0x10, 283, 0, 263 }, -{ 0x50, 283, 0, 261 }, -{ 0x30, 283, 0, 262 }, -{ 0x8, 283, 0, 272 }, -{ 0x28, 283, 0, 270 }, -{ 0x18, 283, 0, 271 }, -{ 0x4, 283, 0, 279 }, -{ 0x2, 283, 0, 280 }, -{ 0x1, 283, 0, 281 }, -{ 0x140, 278, 0, 284 }, -{ 0x540, 278, 0, 282 }, -{ 0x340, 278, 0, 283 }, -{ 0xc0, 278, 0, 293 }, -{ 0x2c0, 278, 0, 291 }, -{ 0x1c0, 278, 0, 292 }, -{ 0x20, 278, 0, 302 }, -{ 0xa0, 278, 0, 300 }, -{ 0x60, 278, 0, 301 }, -{ 0x10, 278, 0, 311 }, -{ 0x50, 278, 0, 309 }, -{ 0x30, 278, 0, 310 }, -{ 0x8, 278, 0, 320 }, -{ 0x28, 278, 0, 318 }, -{ 0x18, 278, 0, 319 }, -{ 0x4, 278, 0, 327 }, -{ 0x2, 278, 0, 328 }, -{ 0x1, 278, 0, 329 }, -{ 0x140, 280, 0, 287 }, -{ 0x540, 280, 0, 285 }, -{ 0x340, 280, 0, 286 }, -{ 0xc0, 280, 0, 296 }, -{ 0x2c0, 280, 0, 294 }, -{ 0x1c0, 280, 0, 295 }, -{ 0x20, 280, 0, 305 }, -{ 0xa0, 280, 0, 303 }, -{ 0x60, 280, 0, 304 }, -{ 0x10, 280, 0, 314 }, -{ 0x50, 280, 0, 312 }, -{ 0x30, 280, 0, 313 }, -{ 0x8, 280, 0, 323 }, -{ 0x28, 280, 0, 321 }, -{ 0x18, 280, 0, 322 }, -{ 0x4, 280, 0, 330 }, -{ 0x2, 280, 0, 331 }, -{ 0x1, 280, 0, 332 }, -{ 0x140, 282, 0, 290 }, -{ 0x540, 282, 0, 288 }, -{ 0x340, 282, 0, 289 }, -{ 0xc0, 282, 0, 299 }, -{ 0x2c0, 282, 0, 297 }, -{ 0x1c0, 282, 0, 298 }, -{ 0x20, 282, 0, 308 }, -{ 0xa0, 282, 0, 306 }, -{ 0x60, 282, 0, 307 }, -{ 0x10, 282, 0, 317 }, -{ 0x50, 282, 0, 315 }, -{ 0x30, 282, 0, 316 }, -{ 0x8, 282, 0, 326 }, -{ 0x28, 282, 0, 324 }, -{ 0x18, 282, 0, 325 }, -{ 0x4, 282, 0, 333 }, -{ 0x2, 282, 0, 334 }, -{ 0x1, 282, 0, 335 }, -{ 0x1, 410, 0, 337 }, -{ 0x3, 410, 0, 336 }, -{ 0x2, 416, 0, 338 }, -{ 0x1, 416, 0, 339 }, -{ 0x2, 412, 0, 340 }, -{ 0x1, 412, 0, 341 }, -{ 0x2, 414, 0, 342 }, -{ 0x1, 414, 0, 343 }, -{ 0x2, 418, 0, 344 }, -{ 0x1, 418, 0, 345 }, -{ 0x1, 267, 0, 372 }, -{ 0x5, 267, 0, 370 }, -{ 0x3, 267, 0, 371 }, -{ 0x140, 276, 0, 348 }, -{ 0x540, 276, 0, 346 }, -{ 0x340, 276, 0, 347 }, -{ 0xc0, 276, 0, 360 }, -{ 0x2c0, 276, 0, 358 }, -{ 0x1c0, 276, 0, 359 }, -{ 0x20, 276, 0, 375 }, -{ 0xa0, 276, 0, 373 }, -{ 0x60, 276, 0, 374 }, -{ 0x10, 276, 0, 387 }, -{ 0x50, 276, 0, 385 }, -{ 0x30, 276, 0, 386 }, -{ 0x8, 276, 0, 399 }, -{ 0x28, 276, 0, 397 }, -{ 0x18, 276, 0, 398 }, -{ 0x4, 276, 0, 409 }, -{ 0x2, 276, 0, 410 }, -{ 0x1, 276, 0, 411 }, -{ 0x140, 270, 0, 351 }, -{ 0x540, 270, 0, 349 }, -{ 0x340, 270, 0, 350 }, -{ 0xc0, 270, 0, 363 }, -{ 0x2c0, 270, 0, 361 }, -{ 0x1c0, 270, 0, 362 }, -{ 0x20, 270, 0, 378 }, -{ 0xa0, 270, 0, 376 }, -{ 0x60, 270, 0, 377 }, -{ 0x10, 270, 0, 390 }, -{ 0x50, 270, 0, 388 }, -{ 0x30, 270, 0, 389 }, -{ 0x8, 270, 0, 402 }, -{ 0x28, 270, 0, 400 }, -{ 0x18, 270, 0, 401 }, -{ 0x4, 270, 0, 412 }, -{ 0x2, 270, 0, 413 }, -{ 0x1, 270, 0, 414 }, -{ 0x140, 273, 0, 354 }, -{ 0x540, 273, 0, 352 }, -{ 0x340, 273, 0, 353 }, -{ 0xc0, 273, 0, 366 }, -{ 0x2c0, 273, 0, 364 }, -{ 0x1c0, 273, 0, 365 }, -{ 0x20, 273, 0, 381 }, -{ 0xa0, 273, 0, 379 }, -{ 0x60, 273, 0, 380 }, -{ 0x10, 273, 0, 393 }, -{ 0x50, 273, 0, 391 }, -{ 0x30, 273, 0, 392 }, -{ 0x8, 273, 0, 405 }, -{ 0x28, 273, 0, 403 }, -{ 0x18, 273, 0, 404 }, -{ 0x4, 273, 0, 415 }, -{ 0x2, 273, 0, 416 }, -{ 0x1, 273, 0, 417 }, -{ 0x140, 285, 0, 357 }, -{ 0x540, 285, 0, 355 }, -{ 0x340, 285, 0, 356 }, -{ 0xc0, 285, 0, 369 }, -{ 0x2c0, 285, 0, 367 }, -{ 0x1c0, 285, 0, 368 }, -{ 0x20, 285, 0, 384 }, -{ 0xa0, 285, 0, 382 }, -{ 0x60, 285, 0, 383 }, -{ 0x10, 285, 0, 396 }, -{ 0x50, 285, 0, 394 }, -{ 0x30, 285, 0, 395 }, -{ 0x8, 285, 0, 408 }, -{ 0x28, 285, 0, 406 }, -{ 0x18, 285, 0, 407 }, -{ 0x4, 285, 0, 418 }, -{ 0x2, 285, 0, 419 }, -{ 0x1, 285, 0, 420 }, -{ 0x1, 266, 0, 447 }, -{ 0x5, 266, 0, 445 }, -{ 0x3, 266, 0, 446 }, -{ 0x140, 275, 0, 423 }, -{ 0x540, 275, 0, 421 }, -{ 0x340, 275, 0, 422 }, -{ 0xc0, 275, 0, 435 }, -{ 0x2c0, 275, 0, 433 }, -{ 0x1c0, 275, 0, 434 }, -{ 0x20, 275, 0, 450 }, -{ 0xa0, 275, 0, 448 }, -{ 0x60, 275, 0, 449 }, -{ 0x10, 275, 0, 462 }, -{ 0x50, 275, 0, 460 }, -{ 0x30, 275, 0, 461 }, -{ 0x8, 275, 0, 474 }, -{ 0x28, 275, 0, 472 }, -{ 0x18, 275, 0, 473 }, -{ 0x4, 275, 0, 484 }, -{ 0x2, 275, 0, 485 }, -{ 0x1, 275, 0, 486 }, -{ 0x140, 269, 0, 426 }, -{ 0x540, 269, 0, 424 }, -{ 0x340, 269, 0, 425 }, -{ 0xc0, 269, 0, 438 }, -{ 0x2c0, 269, 0, 436 }, -{ 0x1c0, 269, 0, 437 }, -{ 0x20, 269, 0, 453 }, -{ 0xa0, 269, 0, 451 }, -{ 0x60, 269, 0, 452 }, -{ 0x10, 269, 0, 465 }, -{ 0x50, 269, 0, 463 }, -{ 0x30, 269, 0, 464 }, -{ 0x8, 269, 0, 477 }, -{ 0x28, 269, 0, 475 }, -{ 0x18, 269, 0, 476 }, -{ 0x4, 269, 0, 487 }, -{ 0x2, 269, 0, 488 }, -{ 0x1, 269, 0, 489 }, -{ 0x140, 272, 0, 429 }, -{ 0x540, 272, 0, 427 }, -{ 0x340, 272, 0, 428 }, -{ 0xc0, 272, 0, 441 }, -{ 0x2c0, 272, 0, 439 }, -{ 0x1c0, 272, 0, 440 }, -{ 0x20, 272, 0, 456 }, -{ 0xa0, 272, 0, 454 }, -{ 0x60, 272, 0, 455 }, -{ 0x10, 272, 0, 468 }, -{ 0x50, 272, 0, 466 }, -{ 0x30, 272, 0, 467 }, -{ 0x8, 272, 0, 480 }, -{ 0x28, 272, 0, 478 }, -{ 0x18, 272, 0, 479 }, -{ 0x4, 272, 0, 490 }, -{ 0x2, 272, 0, 491 }, -{ 0x1, 272, 0, 492 }, -{ 0x140, 284, 0, 432 }, -{ 0x540, 284, 0, 430 }, -{ 0x340, 284, 0, 431 }, -{ 0xc0, 284, 0, 444 }, -{ 0x2c0, 284, 0, 442 }, -{ 0x1c0, 284, 0, 443 }, -{ 0x20, 284, 0, 459 }, -{ 0xa0, 284, 0, 457 }, -{ 0x60, 284, 0, 458 }, -{ 0x10, 284, 0, 471 }, -{ 0x50, 284, 0, 469 }, -{ 0x30, 284, 0, 470 }, -{ 0x8, 284, 0, 483 }, -{ 0x28, 284, 0, 481 }, -{ 0x18, 284, 0, 482 }, -{ 0x4, 284, 0, 493 }, -{ 0x2, 284, 0, 494 }, -{ 0x1, 284, 0, 495 }, -{ 0x8, 409, 0, 497 }, -{ 0x18, 409, 0, 496 }, -{ 0x4, 409, 0, 499 }, -{ 0xc, 409, 0, 498 }, -{ 0x2, 409, 0, 506 }, -{ 0x1, 409, 0, 507 }, -{ 0x4, 407, 0, 501 }, -{ 0xc, 407, 0, 500 }, -{ 0x2, 407, 0, 508 }, -{ 0x1, 407, 0, 509 }, -{ 0x4, 405, 0, 503 }, -{ 0xc, 405, 0, 502 }, -{ 0x2, 405, 0, 510 }, -{ 0x1, 405, 0, 511 }, -{ 0x4, 401, 0, 505 }, -{ 0xc, 401, 0, 504 }, -{ 0x2, 401, 0, 512 }, -{ 0x1, 401, 0, 513 }, -{ 0xa00, 265, 0, 528 }, -{ 0x2a00, 265, 0, 526 }, -{ 0x1a00, 265, 0, 527 }, -{ 0x600, 265, 0, 540 }, -{ 0x2600, 265, 0, 516 }, -{ 0xa600, 265, 0, 514 }, -{ 0x6600, 265, 0, 515 }, -{ 0x1600, 265, 0, 538 }, -{ 0xe00, 265, 0, 539 }, -{ 0x100, 265, 0, 552 }, -{ 0x500, 265, 0, 550 }, -{ 0x300, 265, 0, 551 }, -{ 0x80, 265, 0, 555 }, -{ 0x280, 265, 0, 553 }, -{ 0x180, 265, 0, 554 }, -{ 0x40, 265, 0, 567 }, -{ 0x140, 265, 0, 565 }, -{ 0xc0, 265, 0, 566 }, -{ 0x20, 265, 0, 579 }, -{ 0xa0, 265, 0, 577 }, -{ 0x60, 265, 0, 578 }, -{ 0x10, 265, 0, 591 }, -{ 0x50, 265, 0, 589 }, -{ 0x30, 265, 0, 590 }, -{ 0x8, 265, 0, 603 }, -{ 0x28, 265, 0, 601 }, -{ 0x18, 265, 0, 602 }, -{ 0x4, 265, 0, 613 }, -{ 0x2, 265, 0, 614 }, -{ 0x1, 265, 0, 615 }, -{ 0x500, 261, 0, 531 }, -{ 0x1500, 261, 0, 529 }, -{ 0xd00, 261, 0, 530 }, -{ 0x300, 261, 0, 543 }, -{ 0x1300, 261, 0, 519 }, -{ 0x5300, 261, 0, 517 }, -{ 0x3300, 261, 0, 518 }, -{ 0xb00, 261, 0, 541 }, -{ 0x700, 261, 0, 542 }, -{ 0x80, 261, 0, 558 }, -{ 0x280, 261, 0, 556 }, -{ 0x180, 261, 0, 557 }, -{ 0x40, 261, 0, 570 }, -{ 0x140, 261, 0, 568 }, -{ 0xc0, 261, 0, 569 }, -{ 0x20, 261, 0, 582 }, -{ 0xa0, 261, 0, 580 }, -{ 0x60, 261, 0, 581 }, -{ 0x10, 261, 0, 594 }, -{ 0x50, 261, 0, 592 }, -{ 0x30, 261, 0, 593 }, -{ 0x8, 261, 0, 606 }, -{ 0x28, 261, 0, 604 }, -{ 0x18, 261, 0, 605 }, -{ 0x4, 261, 0, 616 }, -{ 0x2, 261, 0, 617 }, -{ 0x1, 261, 0, 618 }, -{ 0x500, 258, 0, 534 }, -{ 0x1500, 258, 0, 532 }, -{ 0xd00, 258, 0, 533 }, -{ 0x300, 258, 0, 546 }, -{ 0x1300, 258, 0, 522 }, -{ 0x5300, 258, 0, 520 }, -{ 0x3300, 258, 0, 521 }, -{ 0xb00, 258, 0, 544 }, -{ 0x700, 258, 0, 545 }, -{ 0x80, 258, 0, 561 }, -{ 0x280, 258, 0, 559 }, -{ 0x180, 258, 0, 560 }, -{ 0x40, 258, 0, 573 }, -{ 0x140, 258, 0, 571 }, -{ 0xc0, 258, 0, 572 }, -{ 0x20, 258, 0, 585 }, -{ 0xa0, 258, 0, 583 }, -{ 0x60, 258, 0, 584 }, -{ 0x10, 258, 0, 597 }, -{ 0x50, 258, 0, 595 }, -{ 0x30, 258, 0, 596 }, -{ 0x8, 258, 0, 609 }, -{ 0x28, 258, 0, 607 }, -{ 0x18, 258, 0, 608 }, -{ 0x4, 258, 0, 619 }, -{ 0x2, 258, 0, 620 }, -{ 0x1, 258, 0, 621 }, -{ 0x500, 253, 0, 537 }, -{ 0x1500, 253, 0, 535 }, -{ 0xd00, 253, 0, 536 }, -{ 0x300, 253, 0, 549 }, -{ 0x1300, 253, 0, 525 }, -{ 0x5300, 253, 0, 523 }, -{ 0x3300, 253, 0, 524 }, -{ 0xb00, 253, 0, 547 }, -{ 0x700, 253, 0, 548 }, -{ 0x80, 253, 0, 564 }, -{ 0x280, 253, 0, 562 }, -{ 0x180, 253, 0, 563 }, -{ 0x40, 253, 0, 576 }, -{ 0x140, 253, 0, 574 }, -{ 0xc0, 253, 0, 575 }, -{ 0x20, 253, 0, 588 }, -{ 0xa0, 253, 0, 586 }, -{ 0x60, 253, 0, 587 }, -{ 0x10, 253, 0, 600 }, -{ 0x50, 253, 0, 598 }, -{ 0x30, 253, 0, 599 }, -{ 0x8, 253, 0, 612 }, -{ 0x28, 253, 0, 610 }, -{ 0x18, 253, 0, 611 }, -{ 0x4, 253, 0, 622 }, -{ 0x2, 253, 0, 623 }, -{ 0x1, 253, 0, 624 }, -{ 0x8, 238, 0, 625 }, -{ 0x4, 238, 0, 626 }, -{ 0x2, 238, 0, 627 }, -{ 0x1, 238, 0, 628 }, -{ 0x2, 176, 0, 631 }, -{ 0xa, 176, 0, 629 }, -{ 0x6, 176, 0, 630 }, -{ 0x1, 176, 0, 637 }, -{ 0x5, 176, 0, 635 }, -{ 0x3, 176, 0, 636 }, -{ 0x2, 175, 0, 634 }, -{ 0xa, 175, 0, 632 }, -{ 0x6, 175, 0, 633 }, -{ 0x1, 175, 0, 640 }, -{ 0x5, 175, 0, 638 }, -{ 0x3, 175, 0, 639 }, -{ 0x4, 451, 0, 641 }, -{ 0x2, 451, 0, 642 }, -{ 0x1, 451, 0, 643 }, -{ 0x4, 450, 0, 644 }, -{ 0x2, 450, 0, 645 }, -{ 0x1, 450, 0, 646 }, -{ 0x4, 449, 0, 647 }, -{ 0x2, 449, 0, 648 }, -{ 0x1, 449, 0, 649 }, -{ 0x4, 448, 0, 650 }, -{ 0x2, 448, 0, 651 }, -{ 0x1, 448, 0, 652 }, -{ 0x2, 123, 1, 658 }, -{ 0x2, 124, 0, 657 }, -{ 0xa, 123, 1, 654 }, -{ 0xa, 124, 0, 653 }, -{ 0x6, 123, 1, 656 }, -{ 0x6, 124, 0, 655 }, -{ 0x1, 123, 1, 688 }, -{ 0x1, 124, 0, 687 }, -{ 0x5, 123, 1, 684 }, -{ 0x5, 124, 0, 683 }, -{ 0x3, 123, 1, 686 }, -{ 0x3, 124, 0, 685 }, -{ 0x2, 131, 1, 664 }, -{ 0x2, 132, 0, 663 }, -{ 0xa, 131, 1, 660 }, -{ 0xa, 132, 0, 659 }, -{ 0x6, 131, 1, 662 }, -{ 0x6, 132, 0, 661 }, -{ 0x1, 131, 1, 694 }, -{ 0x1, 132, 0, 693 }, -{ 0x5, 131, 1, 690 }, -{ 0x5, 132, 0, 689 }, -{ 0x3, 131, 1, 692 }, -{ 0x3, 132, 0, 691 }, -{ 0x2, 129, 1, 670 }, -{ 0x2, 130, 0, 669 }, -{ 0xa, 129, 1, 666 }, -{ 0xa, 130, 0, 665 }, -{ 0x6, 129, 1, 668 }, -{ 0x6, 130, 0, 667 }, -{ 0x1, 129, 1, 700 }, -{ 0x1, 130, 0, 699 }, -{ 0x5, 129, 1, 696 }, -{ 0x5, 130, 0, 695 }, -{ 0x3, 129, 1, 698 }, -{ 0x3, 130, 0, 697 }, -{ 0x2, 127, 1, 676 }, -{ 0x2, 128, 0, 675 }, -{ 0xa, 127, 1, 672 }, -{ 0xa, 128, 0, 671 }, -{ 0x6, 127, 1, 674 }, -{ 0x6, 128, 0, 673 }, -{ 0x1, 127, 1, 706 }, -{ 0x1, 128, 0, 705 }, -{ 0x5, 127, 1, 702 }, -{ 0x5, 128, 0, 701 }, -{ 0x3, 127, 1, 704 }, -{ 0x3, 128, 0, 703 }, -{ 0x2, 125, 1, 682 }, -{ 0x2, 126, 0, 681 }, -{ 0xa, 125, 1, 678 }, -{ 0xa, 126, 0, 677 }, -{ 0x6, 125, 1, 680 }, -{ 0x6, 126, 0, 679 }, -{ 0x1, 125, 1, 712 }, -{ 0x1, 126, 0, 711 }, -{ 0x5, 125, 1, 708 }, -{ 0x5, 126, 0, 707 }, -{ 0x3, 125, 1, 710 }, -{ 0x3, 126, 0, 709 }, -{ 0x4, 402, 1, 718 }, -{ 0x4, 403, 0, 717 }, -{ 0xc, 402, 1, 716 }, -{ 0xc, 403, 0, 715 }, -{ 0x2, 402, 1, 728 }, -{ 0x2, 403, 0, 727 }, -{ 0x1, 402, 1, 730 }, -{ 0x1, 403, 0, 729 }, -{ 0x8, 408, 0, 714 }, -{ 0x18, 408, 0, 713 }, -{ 0x4, 408, 0, 720 }, -{ 0xc, 408, 0, 719 }, -{ 0x2, 408, 0, 731 }, -{ 0x1, 408, 0, 732 }, -{ 0x4, 406, 0, 722 }, -{ 0xc, 406, 0, 721 }, -{ 0x2, 406, 0, 733 }, -{ 0x1, 406, 0, 734 }, -{ 0x4, 404, 0, 724 }, -{ 0xc, 404, 0, 723 }, -{ 0x2, 404, 0, 735 }, -{ 0x1, 404, 0, 736 }, -{ 0x4, 400, 0, 726 }, -{ 0xc, 400, 0, 725 }, -{ 0x2, 400, 0, 737 }, -{ 0x1, 400, 0, 738 }, -{ 0xa00, 264, 0, 753 }, -{ 0x2a00, 264, 0, 751 }, -{ 0x1a00, 264, 0, 752 }, -{ 0x600, 264, 0, 765 }, -{ 0x2600, 264, 0, 741 }, -{ 0xa600, 264, 0, 739 }, -{ 0x6600, 264, 0, 740 }, -{ 0x1600, 264, 0, 763 }, -{ 0xe00, 264, 0, 764 }, -{ 0x100, 264, 0, 777 }, -{ 0x500, 264, 0, 775 }, -{ 0x300, 264, 0, 776 }, -{ 0x80, 264, 0, 780 }, -{ 0x280, 264, 0, 778 }, -{ 0x180, 264, 0, 779 }, -{ 0x40, 264, 0, 792 }, -{ 0x140, 264, 0, 790 }, -{ 0xc0, 264, 0, 791 }, -{ 0x20, 264, 0, 804 }, -{ 0xa0, 264, 0, 802 }, -{ 0x60, 264, 0, 803 }, -{ 0x10, 264, 0, 816 }, -{ 0x50, 264, 0, 814 }, -{ 0x30, 264, 0, 815 }, -{ 0x8, 264, 0, 828 }, -{ 0x28, 264, 0, 826 }, -{ 0x18, 264, 0, 827 }, -{ 0x4, 264, 0, 838 }, -{ 0x2, 264, 0, 839 }, -{ 0x1, 264, 0, 840 }, -{ 0x500, 260, 0, 756 }, -{ 0x1500, 260, 0, 754 }, -{ 0xd00, 260, 0, 755 }, -{ 0x300, 260, 0, 768 }, -{ 0x1300, 260, 0, 744 }, -{ 0x5300, 260, 0, 742 }, -{ 0x3300, 260, 0, 743 }, -{ 0xb00, 260, 0, 766 }, -{ 0x700, 260, 0, 767 }, -{ 0x80, 260, 0, 783 }, -{ 0x280, 260, 0, 781 }, -{ 0x180, 260, 0, 782 }, -{ 0x40, 260, 0, 795 }, -{ 0x140, 260, 0, 793 }, -{ 0xc0, 260, 0, 794 }, -{ 0x20, 260, 0, 807 }, -{ 0xa0, 260, 0, 805 }, -{ 0x60, 260, 0, 806 }, -{ 0x10, 260, 0, 819 }, -{ 0x50, 260, 0, 817 }, -{ 0x30, 260, 0, 818 }, -{ 0x8, 260, 0, 831 }, -{ 0x28, 260, 0, 829 }, -{ 0x18, 260, 0, 830 }, -{ 0x4, 260, 0, 841 }, -{ 0x2, 260, 0, 842 }, -{ 0x1, 260, 0, 843 }, -{ 0x500, 257, 0, 759 }, -{ 0x1500, 257, 0, 757 }, -{ 0xd00, 257, 0, 758 }, -{ 0x300, 257, 0, 771 }, -{ 0x1300, 257, 0, 747 }, -{ 0x5300, 257, 0, 745 }, -{ 0x3300, 257, 0, 746 }, -{ 0xb00, 257, 0, 769 }, -{ 0x700, 257, 0, 770 }, -{ 0x80, 257, 0, 786 }, -{ 0x280, 257, 0, 784 }, -{ 0x180, 257, 0, 785 }, -{ 0x40, 257, 0, 798 }, -{ 0x140, 257, 0, 796 }, -{ 0xc0, 257, 0, 797 }, -{ 0x20, 257, 0, 810 }, -{ 0xa0, 257, 0, 808 }, -{ 0x60, 257, 0, 809 }, -{ 0x10, 257, 0, 822 }, -{ 0x50, 257, 0, 820 }, -{ 0x30, 257, 0, 821 }, -{ 0x8, 257, 0, 834 }, -{ 0x28, 257, 0, 832 }, -{ 0x18, 257, 0, 833 }, -{ 0x4, 257, 0, 844 }, -{ 0x2, 257, 0, 845 }, -{ 0x1, 257, 0, 846 }, -{ 0x500, 252, 0, 762 }, -{ 0x1500, 252, 0, 760 }, -{ 0xd00, 252, 0, 761 }, -{ 0x300, 252, 0, 774 }, -{ 0x1300, 252, 0, 750 }, -{ 0x5300, 252, 0, 748 }, -{ 0x3300, 252, 0, 749 }, -{ 0xb00, 252, 0, 772 }, -{ 0x700, 252, 0, 773 }, -{ 0x80, 252, 0, 789 }, -{ 0x280, 252, 0, 787 }, -{ 0x180, 252, 0, 788 }, -{ 0x40, 252, 0, 801 }, -{ 0x140, 252, 0, 799 }, -{ 0xc0, 252, 0, 800 }, -{ 0x20, 252, 0, 813 }, -{ 0xa0, 252, 0, 811 }, -{ 0x60, 252, 0, 812 }, -{ 0x10, 252, 0, 825 }, -{ 0x50, 252, 0, 823 }, -{ 0x30, 252, 0, 824 }, -{ 0x8, 252, 0, 837 }, -{ 0x28, 252, 0, 835 }, -{ 0x18, 252, 0, 836 }, -{ 0x4, 252, 0, 847 }, -{ 0x2, 252, 0, 848 }, -{ 0x1, 252, 0, 849 }, -{ 0x8, 254, 1, 895 }, -{ 0x8, 255, 0, 894 }, -{ 0x28, 254, 1, 891 }, -{ 0x28, 255, 0, 890 }, -{ 0x18, 254, 1, 893 }, -{ 0x18, 255, 0, 892 }, -{ 0x4, 254, 1, 957 }, -{ 0x4, 255, 0, 956 }, -{ 0x2, 254, 1, 959 }, -{ 0x2, 255, 0, 958 }, -{ 0x1, 254, 1, 961 }, -{ 0x1, 255, 0, 960 }, -{ 0xa00, 262, 0, 865 }, -{ 0x2a00, 262, 0, 863 }, -{ 0x1a00, 262, 0, 864 }, -{ 0x600, 262, 0, 877 }, -{ 0x2600, 262, 0, 853 }, -{ 0xa600, 262, 0, 851 }, -{ 0x6600, 262, 0, 852 }, -{ 0x1600, 262, 0, 875 }, -{ 0xe00, 262, 0, 876 }, -{ 0x100, 262, 0, 889 }, -{ 0x500, 262, 0, 887 }, -{ 0x300, 262, 0, 888 }, -{ 0x80, 262, 0, 898 }, -{ 0x280, 262, 0, 896 }, -{ 0x180, 262, 0, 897 }, -{ 0x40, 262, 0, 910 }, -{ 0x140, 262, 0, 908 }, -{ 0xc0, 262, 0, 909 }, -{ 0x20, 262, 0, 922 }, -{ 0xa0, 262, 0, 920 }, -{ 0x60, 262, 0, 921 }, -{ 0x10, 262, 0, 934 }, -{ 0x50, 262, 0, 932 }, -{ 0x30, 262, 0, 933 }, -{ 0x8, 262, 0, 946 }, -{ 0x28, 262, 0, 944 }, -{ 0x18, 262, 0, 945 }, -{ 0x4, 262, 0, 962 }, -{ 0x2, 262, 0, 963 }, -{ 0x1, 262, 1, 964 }, -{ 0x1, 263, 0, 850 }, -{ 0x500, 259, 0, 868 }, -{ 0x1500, 259, 0, 866 }, -{ 0xd00, 259, 0, 867 }, -{ 0x300, 259, 0, 880 }, -{ 0x1300, 259, 0, 856 }, -{ 0x5300, 259, 0, 854 }, -{ 0x3300, 259, 0, 855 }, -{ 0xb00, 259, 0, 878 }, -{ 0x700, 259, 0, 879 }, -{ 0x80, 259, 0, 901 }, -{ 0x280, 259, 0, 899 }, -{ 0x180, 259, 0, 900 }, -{ 0x40, 259, 0, 913 }, -{ 0x140, 259, 0, 911 }, -{ 0xc0, 259, 0, 912 }, -{ 0x20, 259, 0, 925 }, -{ 0xa0, 259, 0, 923 }, -{ 0x60, 259, 0, 924 }, -{ 0x10, 259, 0, 937 }, -{ 0x50, 259, 0, 935 }, -{ 0x30, 259, 0, 936 }, -{ 0x8, 259, 0, 949 }, -{ 0x28, 259, 0, 947 }, -{ 0x18, 259, 0, 948 }, -{ 0x4, 259, 0, 965 }, -{ 0x2, 259, 0, 966 }, -{ 0x1, 259, 0, 967 }, -{ 0x500, 256, 0, 871 }, -{ 0x1500, 256, 0, 869 }, -{ 0xd00, 256, 0, 870 }, -{ 0x300, 256, 0, 883 }, -{ 0x1300, 256, 0, 859 }, -{ 0x5300, 256, 0, 857 }, -{ 0x3300, 256, 0, 858 }, -{ 0xb00, 256, 0, 881 }, -{ 0x700, 256, 0, 882 }, -{ 0x80, 256, 0, 904 }, -{ 0x280, 256, 0, 902 }, -{ 0x180, 256, 0, 903 }, -{ 0x40, 256, 0, 916 }, -{ 0x140, 256, 0, 914 }, -{ 0xc0, 256, 0, 915 }, -{ 0x20, 256, 0, 928 }, -{ 0xa0, 256, 0, 926 }, -{ 0x60, 256, 0, 927 }, -{ 0x10, 256, 0, 940 }, -{ 0x50, 256, 0, 938 }, -{ 0x30, 256, 0, 939 }, -{ 0x8, 256, 0, 952 }, -{ 0x28, 256, 0, 950 }, -{ 0x18, 256, 0, 951 }, -{ 0x4, 256, 0, 968 }, -{ 0x2, 256, 0, 969 }, -{ 0x1, 256, 0, 970 }, -{ 0x500, 251, 0, 874 }, -{ 0x1500, 251, 0, 872 }, -{ 0xd00, 251, 0, 873 }, -{ 0x300, 251, 0, 886 }, -{ 0x1300, 251, 0, 862 }, -{ 0x5300, 251, 0, 860 }, -{ 0x3300, 251, 0, 861 }, -{ 0xb00, 251, 0, 884 }, -{ 0x700, 251, 0, 885 }, -{ 0x80, 251, 0, 907 }, -{ 0x280, 251, 0, 905 }, -{ 0x180, 251, 0, 906 }, -{ 0x40, 251, 0, 919 }, -{ 0x140, 251, 0, 917 }, -{ 0xc0, 251, 0, 918 }, -{ 0x20, 251, 0, 931 }, -{ 0xa0, 251, 0, 929 }, -{ 0x60, 251, 0, 930 }, -{ 0x10, 251, 0, 943 }, -{ 0x50, 251, 0, 941 }, -{ 0x30, 251, 0, 942 }, -{ 0x8, 251, 0, 955 }, -{ 0x28, 251, 0, 953 }, -{ 0x18, 251, 0, 954 }, -{ 0x4, 251, 0, 971 }, -{ 0x2, 251, 0, 972 }, -{ 0x1, 251, 0, 973 }, -{ 0x2, 150, 0, 975 }, -{ 0x1, 150, 0, 976 }, -{ 0x1, 50, 0, 977 }, -{ 0x3, 49, 0, 978 }, -{ 0x1, 428, 0, 979 }, -{ 0x1, 442, 0, 980 }, -{ 0x2, 386, 0, 983 }, -{ 0x1, 386, 0, 984 }, -{ 0x2, 384, 0, 985 }, -{ 0x1, 384, 0, 986 }, -{ 0x1, 383, 0, 987 }, -{ 0x1, 328, 0, 992 }, -{ 0x1, 327, 0, 993 }, -{ 0x1, 326, 0, 994 }, -{ 0x1, 325, 0, 995 }, -{ 0x1, 250, 0, 996 }, -{ 0x1, 249, 0, 997 }, -{ 0x1, 324, 0, 998 }, -{ 0x1, 323, 0, 999 }, -{ 0x1, 322, 0, 1000 }, -{ 0x1, 321, 0, 1001 }, -{ 0x1, 320, 0, 1002 }, -{ 0x1, 319, 0, 1003 }, -{ 0x1, 318, 0, 1004 }, -{ 0x2, 248, 0, 1005 }, -{ 0x1, 248, 0, 1006 }, -{ 0x2, 366, 0, 1012 }, -{ 0x1, 366, 0, 1013 }, -{ 0x1, 317, 0, 1014 }, -{ 0x1, 316, 0, 1015 }, -{ 0x1, 315, 0, 1016 }, -{ 0x1, 314, 0, 1017 }, -{ 0x1, 8, 1, 1019 }, -{ 0x1, 9, 0, 1018 }, -{ 0x1, 313, 0, 1020 }, -{ 0x1, 312, 0, 1021 }, -{ 0x1, 311, 0, 1022 }, -{ 0x1, 310, 0, 1023 }, -{ 0x1, 388, 0, 1024 }, -{ 0x1, 399, 0, 1025 }, -{ 0x1, 389, 0, 1026 }, -{ 0x1, 423, 0, 1027 }, -{ 0x1, 309, 0, 1031 }, -{ 0x1, 247, 0, 1032 }, -{ 0x1, 177, 0, 1035 }, -{ 0x2, 291, 0, 1039 }, -{ 0x1, 291, 0, 1040 }, -{ 0x1, 236, 0, 1041 }, -{ 0x5, 48, 0, 1043 }, -{ 0x3, 48, 0, 1044 }, -{ 0x5, 47, 0, 1045 }, -{ 0x3, 47, 0, 1046 }, -{ 0x1, 365, 0, 1047 }, -{ 0x1, 373, 0, 1048 }, -{ 0x1, 371, 0, 1049 }, -{ 0x1, 392, 0, 1050 }, -{ 0x1, 372, 0, 1051 }, -{ 0x1, 370, 0, 1052 }, -{ 0x2, 378, 0, 1053 }, -{ 0x1, 378, 0, 1055 }, -{ 0x2, 376, 0, 1054 }, -{ 0x1, 376, 0, 1056 }, -{ 0x2, 396, 0, 1057 }, -{ 0x1, 396, 0, 1060 }, -{ 0x2, 377, 0, 1058 }, -{ 0x1, 377, 0, 1061 }, -{ 0x2, 375, 0, 1059 }, -{ 0x1, 375, 0, 1062 }, -{ 0x1, 338, 0, 1063 }, -{ 0x1, 337, 0, 1064 }, -{ 0x1, 369, 0, 1065 }, -{ 0x1, 360, 0, 1066 }, -{ 0x1, 362, 0, 1067 }, -{ 0x1, 359, 0, 1068 }, -{ 0x1, 361, 0, 1069 }, -{ 0x2, 446, 0, 1070 }, -{ 0x1, 446, 0, 1073 }, -{ 0x2, 445, 0, 1071 }, -{ 0x1, 445, 0, 1074 }, -{ 0x2, 444, 0, 1072 }, -{ 0x1, 444, 0, 1075 }, -{ 0x1, 348, 0, 1076 }, -{ 0x2, 347, 0, 1077 }, -{ 0x1, 347, 0, 1078 }, -{ 0x2, 294, 0, 1079 }, -{ 0x1, 294, 0, 1082 }, -{ 0x2, 293, 0, 1080 }, -{ 0x1, 293, 0, 1083 }, -{ 0x2, 292, 0, 1081 }, -{ 0x1, 292, 0, 1084 }, -{ 0x2, 363, 0, 1085 }, -{ 0x1, 363, 0, 1086 }, -{ 0x2, 364, 0, 1087 }, -{ 0x1, 364, 0, 1088 }, -{ 0xa, 438, 1, 1100 }, -{ 0xa, 439, 1, 1099 }, -{ 0xa, 440, 1, 1098 }, -{ 0xa, 441, 0, 1097 }, -{ 0x1a, 438, 1, 1092 }, -{ 0x1a, 439, 1, 1091 }, -{ 0x32, 440, 1, 1090 }, -{ 0x32, 441, 0, 1089 }, -{ 0x6, 438, 1, 1108 }, -{ 0x6, 439, 1, 1107 }, -{ 0x6, 440, 1, 1106 }, -{ 0x6, 441, 0, 1105 }, -{ 0x1, 438, 1, 1120 }, -{ 0x1, 439, 1, 1119 }, -{ 0x1, 440, 1, 1118 }, -{ 0x1, 441, 0, 1117 }, -{ 0x9, 438, 1, 1104 }, -{ 0x9, 439, 1, 1103 }, -{ 0x9, 440, 1, 1102 }, -{ 0x9, 441, 0, 1101 }, -{ 0x19, 438, 1, 1096 }, -{ 0x19, 439, 1, 1095 }, -{ 0x31, 440, 1, 1094 }, -{ 0x31, 441, 0, 1093 }, -{ 0x5, 438, 1, 1112 }, -{ 0x5, 439, 1, 1111 }, -{ 0x5, 440, 1, 1110 }, -{ 0x5, 441, 0, 1109 }, -{ 0x3, 438, 1, 1116 }, -{ 0x3, 439, 1, 1115 }, -{ 0x3, 440, 1, 1114 }, -{ 0x3, 441, 0, 1113 }, -{ 0xa, 429, 1, 1132 }, -{ 0xa, 430, 1, 1131 }, -{ 0xa, 431, 1, 1130 }, -{ 0xa, 432, 0, 1129 }, -{ 0x1a, 429, 1, 1124 }, -{ 0x1a, 430, 1, 1123 }, -{ 0x32, 431, 1, 1122 }, -{ 0x32, 432, 0, 1121 }, -{ 0x6, 429, 1, 1140 }, -{ 0x6, 430, 1, 1139 }, -{ 0x6, 431, 1, 1138 }, -{ 0x6, 432, 0, 1137 }, -{ 0x1, 429, 1, 1152 }, -{ 0x1, 430, 1, 1151 }, -{ 0x1, 431, 1, 1150 }, -{ 0x1, 432, 0, 1149 }, -{ 0x9, 429, 1, 1136 }, -{ 0x9, 430, 1, 1135 }, -{ 0x9, 431, 1, 1134 }, -{ 0x9, 432, 0, 1133 }, -{ 0x19, 429, 1, 1128 }, -{ 0x19, 430, 1, 1127 }, -{ 0x31, 431, 1, 1126 }, -{ 0x31, 432, 0, 1125 }, -{ 0x5, 429, 1, 1144 }, -{ 0x5, 430, 1, 1143 }, -{ 0x5, 431, 1, 1142 }, -{ 0x5, 432, 0, 1141 }, -{ 0x3, 429, 1, 1148 }, -{ 0x3, 430, 1, 1147 }, -{ 0x3, 431, 1, 1146 }, -{ 0x3, 432, 0, 1145 }, -{ 0xa, 433, 1, 1164 }, -{ 0xa, 434, 1, 1163 }, -{ 0xa, 435, 1, 1162 }, -{ 0xa, 436, 0, 1161 }, -{ 0x1a, 433, 1, 1156 }, -{ 0x1a, 434, 1, 1155 }, -{ 0x32, 435, 1, 1154 }, -{ 0x32, 436, 0, 1153 }, -{ 0x6, 433, 1, 1172 }, -{ 0x6, 434, 1, 1171 }, -{ 0x6, 435, 1, 1170 }, -{ 0x6, 436, 0, 1169 }, -{ 0x1, 433, 1, 1184 }, -{ 0x1, 434, 1, 1183 }, -{ 0x1, 435, 1, 1182 }, -{ 0x1, 436, 0, 1181 }, -{ 0x9, 433, 1, 1168 }, -{ 0x9, 434, 1, 1167 }, -{ 0x9, 435, 1, 1166 }, -{ 0x9, 436, 0, 1165 }, -{ 0x19, 433, 1, 1160 }, -{ 0x19, 434, 1, 1159 }, -{ 0x31, 435, 1, 1158 }, -{ 0x31, 436, 0, 1157 }, -{ 0x5, 433, 1, 1176 }, -{ 0x5, 434, 1, 1175 }, -{ 0x5, 435, 1, 1174 }, -{ 0x5, 436, 0, 1173 }, -{ 0x3, 433, 1, 1180 }, -{ 0x3, 434, 1, 1179 }, -{ 0x3, 435, 1, 1178 }, -{ 0x3, 436, 0, 1177 }, -{ 0x1, 139, 0, 1185 }, -{ 0x1, 138, 0, 1186 }, -{ 0x1, 391, 1, 1188 }, -{ 0x1, 137, 0, 1187 }, -{ 0x2, 395, 1, 1190 }, -{ 0x2, 141, 0, 1189 }, -{ 0x1, 395, 1, 1192 }, -{ 0x1, 141, 0, 1191 }, -{ 0x1, 397, 0, 1193 }, -{ 0x1, 136, 0, 1194 }, -{ 0x2, 135, 0, 1195 }, -{ 0x2, 134, 0, 1196 }, -{ 0x1, 459, 1, 1202 }, -{ 0x1, 246, 0, 1033 }, -{ 0x1, 458, 0, 1203 }, -{ 0x1, 457, 1, 1204 }, -{ 0x1, 245, 0, 1042 }, -{ 0x1, 308, 0, 1205 }, -{ 0x1, 307, 1, 1206 }, -{ 0x1, 290, 0, 1034 }, -{ 0x1, 306, 0, 1207 }, -{ 0x1, 305, 1, 1208 }, -{ 0x1, 427, 0, 1036 }, -{ 0x1, 304, 1, 1209 }, -{ 0x1, 398, 0, 1038 }, -{ 0x1, 303, 0, 1210 }, -{ 0x1, 302, 0, 1211 }, -{ 0x1, 301, 0, 1212 }, -{ 0x1, 300, 1, 1213 }, -{ 0x2, 398, 0, 1037 }, -{ 0x10, 299, 0, 1217 }, -{ 0x90, 299, 0, 1215 }, -{ 0x190, 299, 0, 1214 }, -{ 0x50, 299, 0, 1216 }, -{ 0x30, 299, 0, 1219 }, -{ 0x70, 299, 0, 1218 }, -{ 0x8, 299, 0, 1221 }, -{ 0x18, 299, 0, 1220 }, -{ 0x4, 299, 0, 1222 }, -{ 0x1, 299, 0, 1225 }, -{ 0x3, 299, 0, 1224 }, -{ 0x1, 298, 1, 1226 }, -{ 0x2, 299, 0, 1223 }, -{ 0x3, 46, 0, 1227 }, -{ 0x1, 241, 1, 1228 }, -{ 0x1, 242, 1, 1028 }, -{ 0x1, 243, 0, 88 }, -{ 0x1, 341, 1, 1229 }, -{ 0x1, 342, 1, 1029 }, -{ 0x1, 343, 0, 89 }, -{ 0x1, 34, 1, 1230 }, -{ 0x1, 35, 1, 1030 }, -{ 0x1, 36, 0, 90 }, -{ 0x1, 230, 0, 1231 }, -{ 0x4, 452, 0, 1232 }, -{ 0x2, 452, 0, 1233 }, -{ 0x1, 452, 1, 1235 }, -{ 0x1, 453, 0, 1234 }, -{ 0x8, 454, 0, 1236 }, -{ 0x4, 454, 0, 1237 }, -{ 0x1, 454, 1, 1239 }, -{ 0x2, 454, 0, 1238 }, -{ 0x8, 219, 0, 1240 }, -{ 0x4, 219, 0, 1241 }, -{ 0x2, 219, 0, 1242 }, -{ 0x1, 219, 1, 1244 }, -{ 0x1, 220, 0, 1243 }, -{ 0x10, 221, 0, 1245 }, -{ 0x8, 221, 0, 1246 }, -{ 0x4, 221, 0, 1247 }, -{ 0x1, 221, 1, 1249 }, -{ 0x2, 221, 0, 1248 }, -{ 0x220, 191, 0, 1250 }, -{ 0x120, 191, 0, 1251 }, -{ 0xa0, 191, 0, 1252 }, -{ 0x60, 191, 1, 1254 }, -{ 0x4, 192, 0, 1253 }, -{ 0x110, 191, 0, 1260 }, -{ 0x90, 191, 0, 1261 }, -{ 0x50, 191, 0, 1262 }, -{ 0x30, 191, 1, 1264 }, -{ 0x2, 192, 0, 1263 }, -{ 0x8, 191, 0, 1265 }, -{ 0x4, 191, 0, 1266 }, -{ 0x2, 191, 0, 1267 }, -{ 0x1, 191, 1, 1269 }, -{ 0x1, 192, 0, 1268 }, -{ 0x440, 193, 0, 1255 }, -{ 0x240, 193, 0, 1256 }, -{ 0x140, 193, 0, 1257 }, -{ 0xc0, 193, 1, 1259 }, -{ 0x40, 193, 0, 1258 }, -{ 0x220, 193, 0, 1270 }, -{ 0x120, 193, 0, 1271 }, -{ 0xa0, 193, 0, 1272 }, -{ 0x60, 193, 1, 1274 }, -{ 0x20, 193, 0, 1273 }, -{ 0x10, 193, 0, 1275 }, -{ 0x8, 193, 0, 1276 }, -{ 0x4, 193, 0, 1277 }, -{ 0x1, 193, 1, 1279 }, -{ 0x2, 193, 0, 1278 }, -{ 0x8, 215, 0, 1280 }, -{ 0x4, 215, 0, 1281 }, -{ 0x2, 215, 0, 1282 }, -{ 0x1, 215, 1, 1284 }, -{ 0x1, 216, 0, 1283 }, -{ 0x220, 187, 0, 1285 }, -{ 0x120, 187, 0, 1286 }, -{ 0xa0, 187, 0, 1287 }, -{ 0x60, 187, 1, 1289 }, -{ 0x4, 188, 0, 1288 }, -{ 0x110, 187, 0, 1295 }, -{ 0x90, 187, 0, 1296 }, -{ 0x50, 187, 0, 1297 }, -{ 0x30, 187, 1, 1299 }, -{ 0x2, 188, 0, 1298 }, -{ 0x8, 187, 0, 1300 }, -{ 0x4, 187, 0, 1301 }, -{ 0x2, 187, 0, 1302 }, -{ 0x1, 187, 1, 1304 }, -{ 0x1, 188, 0, 1303 }, -{ 0x440, 233, 0, 1290 }, -{ 0x240, 233, 0, 1291 }, -{ 0x140, 233, 0, 1292 }, -{ 0xc0, 233, 1, 1294 }, -{ 0x40, 233, 0, 1293 }, -{ 0x220, 233, 0, 1305 }, -{ 0x120, 233, 0, 1306 }, -{ 0xa0, 233, 0, 1307 }, -{ 0x60, 233, 1, 1309 }, -{ 0x20, 233, 0, 1308 }, -{ 0x10, 233, 0, 1310 }, -{ 0x8, 233, 0, 1311 }, -{ 0x4, 233, 0, 1312 }, -{ 0x1, 233, 1, 1314 }, -{ 0x2, 233, 0, 1313 }, -{ 0x8, 207, 0, 1315 }, -{ 0x4, 207, 0, 1316 }, -{ 0x2, 207, 0, 1317 }, -{ 0x1, 207, 1, 1319 }, -{ 0x1, 208, 0, 1318 }, -{ 0x10, 214, 0, 1320 }, -{ 0x8, 214, 0, 1321 }, -{ 0x4, 214, 0, 1322 }, -{ 0x1, 214, 1, 1324 }, -{ 0x2, 214, 0, 1323 }, -{ 0x220, 178, 0, 1325 }, -{ 0x120, 178, 0, 1326 }, -{ 0xa0, 178, 0, 1327 }, -{ 0x60, 178, 1, 1329 }, -{ 0x4, 179, 0, 1328 }, -{ 0x110, 178, 0, 1350 }, -{ 0x90, 178, 0, 1351 }, -{ 0x50, 178, 0, 1352 }, -{ 0x30, 178, 1, 1354 }, -{ 0x2, 179, 0, 1353 }, -{ 0x8, 178, 0, 1355 }, -{ 0x4, 178, 0, 1356 }, -{ 0x2, 178, 0, 1357 }, -{ 0x1, 178, 1, 1359 }, -{ 0x1, 179, 0, 1358 }, -{ 0x440, 186, 0, 1330 }, -{ 0x240, 186, 0, 1331 }, -{ 0x140, 186, 0, 1332 }, -{ 0xc0, 186, 1, 1334 }, -{ 0x40, 186, 0, 1333 }, -{ 0x220, 186, 0, 1360 }, -{ 0x120, 186, 0, 1361 }, -{ 0xa0, 186, 0, 1362 }, -{ 0x60, 186, 1, 1364 }, -{ 0x20, 186, 0, 1363 }, -{ 0x10, 186, 0, 1365 }, -{ 0x8, 186, 0, 1366 }, -{ 0x4, 186, 0, 1367 }, -{ 0x1, 186, 1, 1369 }, -{ 0x2, 186, 0, 1368 }, -{ 0x440, 143, 0, 1335 }, -{ 0x240, 143, 0, 1336 }, -{ 0x140, 143, 0, 1337 }, -{ 0xc0, 143, 1, 1339 }, -{ 0x40, 143, 0, 1338 }, -{ 0x220, 143, 0, 1370 }, -{ 0x120, 143, 0, 1371 }, -{ 0xa0, 143, 0, 1372 }, -{ 0x60, 143, 1, 1374 }, -{ 0x20, 143, 0, 1373 }, -{ 0x10, 143, 0, 1375 }, -{ 0x8, 143, 0, 1376 }, -{ 0x1, 143, 1, 1379 }, -{ 0x2, 143, 0, 1378 }, -{ 0x440, 194, 1, 1345 }, -{ 0x441, 174, 0, 1340 }, -{ 0x240, 194, 1, 1346 }, -{ 0x241, 174, 0, 1341 }, -{ 0x140, 194, 1, 1347 }, -{ 0x141, 174, 0, 1342 }, -{ 0xc0, 194, 1, 1349 }, -{ 0x40, 194, 1, 1348 }, -{ 0xc1, 174, 1, 1344 }, -{ 0x41, 174, 0, 1343 }, -{ 0x220, 194, 1, 1390 }, -{ 0x221, 174, 0, 1380 }, -{ 0x120, 194, 1, 1391 }, -{ 0x121, 174, 0, 1381 }, -{ 0xa0, 194, 1, 1392 }, -{ 0xa1, 174, 0, 1382 }, -{ 0x60, 194, 1, 1394 }, -{ 0x20, 194, 1, 1393 }, -{ 0x61, 174, 1, 1384 }, -{ 0x21, 174, 0, 1383 }, -{ 0x10, 194, 1, 1395 }, -{ 0x11, 174, 0, 1385 }, -{ 0x8, 194, 1, 1396 }, -{ 0x9, 174, 0, 1386 }, -{ 0x4, 194, 1, 1397 }, -{ 0x5, 174, 0, 1387 }, -{ 0x1, 194, 1, 1399 }, -{ 0x2, 194, 1, 1398 }, -{ 0x3, 174, 1, 1389 }, -{ 0x1, 174, 0, 1388 }, -{ 0x1, 153, 1, 1407 }, -{ 0x1, 154, 1, 1406 }, -{ 0x1, 155, 1, 1405 }, -{ 0x1, 156, 0, 1404 }, -{ 0x3, 153, 1, 1403 }, -{ 0x3, 154, 1, 1402 }, -{ 0x3, 155, 1, 1401 }, -{ 0x3, 156, 0, 1400 }, -{ 0x1108, 159, 1, 1569 }, -{ 0x1108, 160, 1, 1568 }, -{ 0x1108, 165, 1, 1409 }, -{ 0x1108, 166, 0, 1408 }, -{ 0x908, 159, 1, 1571 }, -{ 0x908, 160, 1, 1570 }, -{ 0x908, 165, 1, 1411 }, -{ 0x908, 166, 0, 1410 }, -{ 0x508, 159, 1, 1573 }, -{ 0x508, 160, 1, 1572 }, -{ 0x508, 165, 1, 1413 }, -{ 0x508, 166, 0, 1412 }, -{ 0x308, 159, 1, 1577 }, -{ 0x308, 160, 1, 1576 }, -{ 0x108, 160, 1, 1574 }, -{ 0x18, 161, 1, 1575 }, -{ 0x308, 165, 1, 1417 }, -{ 0x308, 166, 1, 1416 }, -{ 0x108, 166, 1, 1414 }, -{ 0x18, 167, 0, 1415 }, -{ 0x88, 159, 1, 1609 }, -{ 0x88, 160, 1, 1608 }, -{ 0x88, 165, 1, 1489 }, -{ 0x88, 166, 0, 1488 }, -{ 0x48, 159, 1, 1611 }, -{ 0x48, 160, 1, 1610 }, -{ 0x48, 165, 1, 1491 }, -{ 0x48, 166, 0, 1490 }, -{ 0x28, 159, 1, 1613 }, -{ 0x28, 160, 1, 1612 }, -{ 0x28, 165, 1, 1493 }, -{ 0x28, 166, 0, 1492 }, -{ 0x18, 159, 1, 1617 }, -{ 0x18, 160, 1, 1616 }, -{ 0x8, 160, 1, 1614 }, -{ 0x8, 161, 1, 1615 }, -{ 0x18, 165, 1, 1497 }, -{ 0x18, 166, 1, 1496 }, -{ 0x8, 166, 1, 1494 }, -{ 0x8, 167, 0, 1495 }, -{ 0x884, 159, 1, 1579 }, -{ 0x884, 160, 1, 1578 }, -{ 0x442, 162, 1, 1469 }, -{ 0x442, 163, 1, 1468 }, -{ 0x884, 165, 1, 1439 }, -{ 0x884, 166, 1, 1438 }, -{ 0x442, 168, 1, 1419 }, -{ 0x442, 169, 0, 1418 }, -{ 0x484, 159, 1, 1581 }, -{ 0x484, 160, 1, 1580 }, -{ 0x242, 162, 1, 1471 }, -{ 0x242, 163, 1, 1470 }, -{ 0x484, 165, 1, 1441 }, -{ 0x484, 166, 1, 1440 }, -{ 0x242, 168, 1, 1421 }, -{ 0x242, 169, 0, 1420 }, -{ 0x284, 159, 1, 1583 }, -{ 0x284, 160, 1, 1582 }, -{ 0x142, 162, 1, 1473 }, -{ 0x142, 163, 1, 1472 }, -{ 0x284, 165, 1, 1443 }, -{ 0x284, 166, 1, 1442 }, -{ 0x142, 168, 1, 1423 }, -{ 0x142, 169, 0, 1422 }, -{ 0x184, 159, 1, 1587 }, -{ 0x184, 160, 1, 1586 }, -{ 0x84, 160, 1, 1584 }, -{ 0xc, 161, 1, 1585 }, -{ 0xc2, 162, 1, 1477 }, -{ 0xc2, 163, 1, 1476 }, -{ 0x42, 163, 1, 1474 }, -{ 0x6, 164, 1, 1475 }, -{ 0x184, 165, 1, 1447 }, -{ 0x184, 166, 1, 1446 }, -{ 0x84, 166, 1, 1444 }, -{ 0xc, 167, 1, 1445 }, -{ 0xc2, 168, 1, 1427 }, -{ 0xc2, 169, 1, 1426 }, -{ 0x42, 169, 1, 1424 }, -{ 0x6, 170, 0, 1425 }, -{ 0x44, 159, 1, 1619 }, -{ 0x44, 160, 1, 1618 }, -{ 0x22, 162, 1, 1549 }, -{ 0x22, 163, 1, 1548 }, -{ 0x44, 165, 1, 1519 }, -{ 0x44, 166, 1, 1518 }, -{ 0x22, 168, 1, 1499 }, -{ 0x22, 169, 0, 1498 }, -{ 0x24, 159, 1, 1621 }, -{ 0x24, 160, 1, 1620 }, -{ 0x12, 162, 1, 1551 }, -{ 0x12, 163, 1, 1550 }, -{ 0x24, 165, 1, 1521 }, -{ 0x24, 166, 1, 1520 }, -{ 0x12, 168, 1, 1501 }, -{ 0x12, 169, 0, 1500 }, -{ 0x14, 159, 1, 1623 }, -{ 0x14, 160, 1, 1622 }, -{ 0xa, 162, 1, 1553 }, -{ 0xa, 163, 1, 1552 }, -{ 0x14, 165, 1, 1523 }, -{ 0x14, 166, 1, 1522 }, -{ 0xa, 168, 1, 1503 }, -{ 0xa, 169, 0, 1502 }, -{ 0xc, 159, 1, 1627 }, -{ 0xc, 160, 1, 1626 }, -{ 0x4, 160, 1, 1624 }, -{ 0x4, 161, 1, 1625 }, -{ 0x6, 162, 1, 1557 }, -{ 0x6, 163, 1, 1556 }, -{ 0x2, 163, 1, 1554 }, -{ 0x2, 164, 1, 1555 }, -{ 0xc, 165, 1, 1527 }, -{ 0xc, 166, 1, 1526 }, -{ 0x4, 166, 1, 1524 }, -{ 0x4, 167, 1, 1525 }, -{ 0x6, 168, 1, 1507 }, -{ 0x6, 169, 1, 1506 }, -{ 0x2, 169, 1, 1504 }, -{ 0x2, 170, 0, 1505 }, -{ 0x442, 159, 1, 1589 }, -{ 0x442, 160, 1, 1588 }, -{ 0x221, 162, 1, 1479 }, -{ 0x221, 163, 1, 1478 }, -{ 0x442, 165, 1, 1449 }, -{ 0x442, 166, 1, 1448 }, -{ 0x221, 168, 1, 1429 }, -{ 0x221, 169, 0, 1428 }, -{ 0x242, 159, 1, 1591 }, -{ 0x242, 160, 1, 1590 }, -{ 0x121, 162, 1, 1481 }, -{ 0x121, 163, 1, 1480 }, -{ 0x242, 165, 1, 1451 }, -{ 0x242, 166, 1, 1450 }, -{ 0x121, 168, 1, 1431 }, -{ 0x121, 169, 0, 1430 }, -{ 0x142, 159, 1, 1593 }, -{ 0x142, 160, 1, 1592 }, -{ 0xa1, 162, 1, 1483 }, -{ 0xa1, 163, 1, 1482 }, -{ 0x142, 165, 1, 1453 }, -{ 0x142, 166, 1, 1452 }, -{ 0xa1, 168, 1, 1433 }, -{ 0xa1, 169, 0, 1432 }, -{ 0xc2, 159, 1, 1597 }, -{ 0xc2, 160, 1, 1596 }, -{ 0x42, 160, 1, 1594 }, -{ 0x6, 161, 1, 1595 }, -{ 0x61, 162, 1, 1487 }, -{ 0x61, 163, 1, 1486 }, -{ 0x21, 163, 1, 1484 }, -{ 0x3, 164, 1, 1485 }, -{ 0xc2, 165, 1, 1457 }, -{ 0xc2, 166, 1, 1456 }, -{ 0x42, 166, 1, 1454 }, -{ 0x6, 167, 1, 1455 }, -{ 0x61, 168, 1, 1437 }, -{ 0x61, 169, 1, 1436 }, -{ 0x21, 169, 1, 1434 }, -{ 0x3, 170, 0, 1435 }, -{ 0x22, 159, 1, 1629 }, -{ 0x22, 160, 1, 1628 }, -{ 0x11, 162, 1, 1559 }, -{ 0x11, 163, 1, 1558 }, -{ 0x22, 165, 1, 1529 }, -{ 0x22, 166, 1, 1528 }, -{ 0x11, 168, 1, 1509 }, -{ 0x11, 169, 0, 1508 }, -{ 0x12, 159, 1, 1631 }, -{ 0x12, 160, 1, 1630 }, -{ 0x9, 162, 1, 1561 }, -{ 0x9, 163, 1, 1560 }, -{ 0x12, 165, 1, 1531 }, -{ 0x12, 166, 1, 1530 }, -{ 0x9, 168, 1, 1511 }, -{ 0x9, 169, 0, 1510 }, -{ 0xa, 159, 1, 1633 }, -{ 0xa, 160, 1, 1632 }, -{ 0x5, 162, 1, 1563 }, -{ 0x5, 163, 1, 1562 }, -{ 0xa, 165, 1, 1533 }, -{ 0xa, 166, 1, 1532 }, -{ 0x5, 168, 1, 1513 }, -{ 0x5, 169, 0, 1512 }, -{ 0x6, 159, 1, 1637 }, -{ 0x6, 160, 1, 1636 }, -{ 0x2, 160, 1, 1634 }, -{ 0x2, 161, 1, 1635 }, -{ 0x3, 162, 1, 1567 }, -{ 0x3, 163, 1, 1566 }, -{ 0x1, 163, 1, 1564 }, -{ 0x1, 164, 1, 1565 }, -{ 0x6, 165, 1, 1537 }, -{ 0x6, 166, 1, 1536 }, -{ 0x2, 166, 1, 1534 }, -{ 0x2, 167, 1, 1535 }, -{ 0x3, 168, 1, 1517 }, -{ 0x3, 169, 1, 1516 }, -{ 0x1, 169, 1, 1514 }, -{ 0x1, 170, 0, 1515 }, -{ 0x221, 159, 1, 1599 }, -{ 0x221, 160, 1, 1598 }, -{ 0x221, 165, 1, 1459 }, -{ 0x221, 166, 0, 1458 }, -{ 0x121, 159, 1, 1601 }, -{ 0x121, 160, 1, 1600 }, -{ 0x121, 165, 1, 1461 }, -{ 0x121, 166, 0, 1460 }, -{ 0xa1, 159, 1, 1603 }, -{ 0xa1, 160, 1, 1602 }, -{ 0xa1, 165, 1, 1463 }, -{ 0xa1, 166, 0, 1462 }, -{ 0x61, 159, 1, 1607 }, -{ 0x61, 160, 1, 1606 }, -{ 0x21, 160, 1, 1604 }, -{ 0x3, 161, 1, 1605 }, -{ 0x61, 165, 1, 1467 }, -{ 0x61, 166, 1, 1466 }, -{ 0x21, 166, 1, 1464 }, -{ 0x3, 167, 0, 1465 }, -{ 0x11, 159, 1, 1639 }, -{ 0x11, 160, 1, 1638 }, -{ 0x11, 165, 1, 1539 }, -{ 0x11, 166, 0, 1538 }, -{ 0x9, 159, 1, 1641 }, -{ 0x9, 160, 1, 1640 }, -{ 0x9, 165, 1, 1541 }, -{ 0x9, 166, 0, 1540 }, -{ 0x5, 159, 1, 1643 }, -{ 0x5, 160, 1, 1642 }, -{ 0x5, 165, 1, 1543 }, -{ 0x5, 166, 0, 1542 }, -{ 0x3, 159, 1, 1647 }, -{ 0x3, 160, 1, 1646 }, -{ 0x1, 160, 1, 1644 }, -{ 0x1, 161, 1, 1645 }, -{ 0x3, 165, 1, 1547 }, -{ 0x3, 166, 1, 1546 }, -{ 0x1, 166, 1, 1544 }, -{ 0x1, 167, 0, 1545 }, -{ 0x442, 205, 0, 1648 }, -{ 0x242, 205, 0, 1649 }, -{ 0x142, 205, 0, 1650 }, -{ 0xc2, 205, 1, 1652 }, -{ 0x6, 206, 1, 1651 }, -{ 0x1, 443, 0, 981 }, -{ 0x22, 205, 0, 1658 }, -{ 0x12, 205, 0, 1659 }, -{ 0xa, 205, 0, 1660 }, -{ 0x6, 205, 1, 1662 }, -{ 0x2, 206, 1, 1661 }, -{ 0x2, 367, 0, 1010 }, -{ 0x221, 205, 0, 1653 }, -{ 0x121, 205, 0, 1654 }, -{ 0xa1, 205, 0, 1655 }, -{ 0x61, 205, 1, 1657 }, -{ 0x3, 206, 1, 1656 }, -{ 0x1, 437, 0, 982 }, -{ 0x11, 205, 0, 1663 }, -{ 0x9, 205, 0, 1664 }, -{ 0x5, 205, 0, 1665 }, -{ 0x3, 205, 1, 1667 }, -{ 0x1, 206, 1, 1666 }, -{ 0x1, 367, 0, 1011 }, -{ 0x4, 211, 0, 1668 }, -{ 0x1, 211, 0, 1670 }, -{ 0x1, 218, 0, 1671 }, -{ 0x1, 217, 1, 1672 }, -{ 0x2, 211, 0, 1669 }, -{ 0x1, 196, 0, 1673 }, -{ 0x880, 202, 0, 1674 }, -{ 0x480, 202, 0, 1675 }, -{ 0x280, 202, 0, 1676 }, -{ 0x180, 202, 1, 1678 }, -{ 0x80, 203, 0, 1677 }, -{ 0x440, 202, 1, 1689 }, -{ 0x88, 204, 0, 1679 }, -{ 0x240, 202, 1, 1690 }, -{ 0x48, 204, 0, 1680 }, -{ 0x140, 202, 1, 1691 }, -{ 0x28, 204, 0, 1681 }, -{ 0xc0, 202, 1, 1693 }, -{ 0x40, 203, 1, 1692 }, -{ 0x18, 204, 1, 1683 }, -{ 0x8, 204, 0, 1682 }, -{ 0x220, 202, 1, 1694 }, -{ 0x44, 204, 0, 1684 }, -{ 0x120, 202, 1, 1695 }, -{ 0x24, 204, 0, 1685 }, -{ 0xa0, 202, 1, 1696 }, -{ 0x14, 204, 0, 1686 }, -{ 0x60, 202, 1, 1698 }, -{ 0x20, 203, 1, 1697 }, -{ 0xc, 204, 1, 1688 }, -{ 0x4, 204, 0, 1687 }, -{ 0x110, 202, 0, 1699 }, -{ 0x90, 202, 0, 1700 }, -{ 0x50, 202, 0, 1701 }, -{ 0x30, 202, 1, 1703 }, -{ 0x10, 203, 1, 1702 }, -{ 0x1, 385, 0, 974 }, -{ 0x88, 202, 0, 1704 }, -{ 0x48, 202, 0, 1705 }, -{ 0x28, 202, 0, 1706 }, -{ 0x18, 202, 1, 1708 }, -{ 0x8, 203, 1, 1707 }, -{ 0xc, 368, 0, 1007 }, -{ 0x44, 202, 1, 1719 }, -{ 0x22, 204, 0, 1709 }, -{ 0x24, 202, 1, 1720 }, -{ 0x12, 204, 0, 1710 }, -{ 0x14, 202, 1, 1721 }, -{ 0xa, 204, 0, 1711 }, -{ 0xc, 202, 1, 1723 }, -{ 0x4, 203, 1, 1722 }, -{ 0x6, 204, 1, 1713 }, -{ 0x2, 204, 1, 1712 }, -{ 0x6, 368, 0, 1008 }, -{ 0x22, 202, 1, 1724 }, -{ 0x11, 204, 0, 1714 }, -{ 0x12, 202, 1, 1725 }, -{ 0x9, 204, 0, 1715 }, -{ 0xa, 202, 1, 1726 }, -{ 0x5, 204, 0, 1716 }, -{ 0x6, 202, 1, 1728 }, -{ 0x2, 203, 1, 1727 }, -{ 0x3, 204, 1, 1718 }, -{ 0x1, 204, 1, 1717 }, -{ 0x3, 368, 0, 1009 }, -{ 0x11, 202, 0, 1729 }, -{ 0x9, 202, 0, 1730 }, -{ 0x5, 202, 0, 1731 }, -{ 0x3, 202, 1, 1733 }, -{ 0x1, 203, 0, 1732 }, -{ 0x8, 198, 0, 1734 }, -{ 0x4, 198, 0, 1735 }, -{ 0x2, 198, 0, 1736 }, -{ 0x1, 198, 1, 1738 }, -{ 0x1, 199, 1, 1737 }, -{ 0x1, 332, 0, 988 }, -{ 0x8, 200, 0, 1739 }, -{ 0x4, 200, 0, 1740 }, -{ 0x2, 200, 0, 1741 }, -{ 0x1, 200, 1, 1743 }, -{ 0x1, 201, 1, 1742 }, -{ 0x1, 331, 0, 989 }, -{ 0x8, 209, 0, 1744 }, -{ 0x4, 209, 0, 1745 }, -{ 0x2, 209, 0, 1746 }, -{ 0x1, 209, 1, 1748 }, -{ 0x1, 210, 1, 1747 }, -{ 0x1, 330, 0, 990 }, -{ 0x8, 212, 0, 1749 }, -{ 0x4, 212, 0, 1750 }, -{ 0x2, 212, 0, 1751 }, -{ 0x1, 212, 1, 1753 }, -{ 0x1, 213, 1, 1752 }, -{ 0x1, 329, 0, 991 }, -{ 0x8, 224, 0, 1754 }, -{ 0x4, 224, 0, 1755 }, -{ 0x2, 224, 0, 1756 }, -{ 0x1, 224, 1, 1758 }, -{ 0x1, 225, 0, 1757 }, -{ 0x8, 222, 0, 1759 }, -{ 0x4, 222, 0, 1760 }, -{ 0x2, 222, 0, 1761 }, -{ 0x1, 222, 1, 1763 }, -{ 0x1, 223, 0, 1762 }, -{ 0x1, 240, 0, 1764 }, -{ 0x1, 340, 0, 1765 }, -{ 0x1, 33, 0, 1766 }, -{ 0x8, 151, 0, 1767 }, -{ 0x4, 151, 0, 1768 }, -{ 0x2, 151, 0, 1769 }, -{ 0x1, 151, 1, 1771 }, -{ 0x1, 152, 0, 1770 }, -{ 0x8, 157, 0, 1772 }, -{ 0x4, 157, 0, 1773 }, -{ 0x2, 157, 0, 1774 }, -{ 0x1, 157, 1, 1776 }, -{ 0x1, 158, 0, 1775 }, -{ 0x8, 231, 0, 1777 }, -{ 0x4, 231, 0, 1778 }, -{ 0x2, 231, 0, 1779 }, -{ 0x1, 231, 1, 1781 }, -{ 0x1, 232, 0, 1780 }, -{ 0x1, 173, 0, 1782 }, -{ 0x442, 171, 0, 1783 }, -{ 0x242, 171, 0, 1784 }, -{ 0x142, 171, 0, 1785 }, -{ 0xc2, 171, 1, 1787 }, -{ 0x6, 172, 0, 1786 }, -{ 0x22, 171, 0, 1793 }, -{ 0x12, 171, 0, 1794 }, -{ 0xa, 171, 0, 1795 }, -{ 0x6, 171, 1, 1797 }, -{ 0x2, 172, 1, 1796 }, -{ 0x1, 135, 0, 1197 }, -{ 0x221, 171, 0, 1788 }, -{ 0x121, 171, 0, 1789 }, -{ 0xa1, 171, 0, 1790 }, -{ 0x61, 171, 1, 1792 }, -{ 0x3, 172, 0, 1791 }, -{ 0x11, 171, 0, 1798 }, -{ 0x9, 171, 0, 1799 }, -{ 0x5, 171, 0, 1800 }, -{ 0x3, 171, 1, 1802 }, -{ 0x1, 172, 1, 1801 }, -{ 0x1, 134, 0, 1198 }, -{ 0x1, 237, 0, 1803 }, -{ 0x1, 195, 0, 1804 }, -{ 0x1, 149, 0, 1805 }, -{ 0x1, 148, 0, 1806 }, -{ 0x4, 234, 0, 1807 }, -{ 0x2, 234, 0, 1808 }, -{ 0x1, 234, 0, 1809 }, -{ 0x1, 197, 0, 1810 }, -{ 0x2, 235, 0, 1811 }, -{ 0x1, 235, 0, 1812 }, -{ 0x4, 185, 0, 1813 }, -{ 0x2, 185, 0, 1814 }, -{ 0x1, 185, 0, 1815 }, -{ 0x4, 182, 0, 1816 }, -{ 0x1, 190, 0, 1819 }, -{ 0x1, 189, 1, 1820 }, -{ 0x2, 182, 0, 1817 }, -{ 0x1, 142, 0, 1821 }, -{ 0x1, 297, 1, 1822 }, -{ 0x1, 182, 0, 1818 }, -{ 0x8, 144, 0, 1823 }, -{ 0x4, 144, 0, 1824 }, -{ 0x2, 144, 0, 1825 }, -{ 0x1, 144, 1, 1827 }, -{ 0x1, 145, 0, 1826 }, -{ 0x8, 146, 0, 1828 }, -{ 0x4, 146, 0, 1829 }, -{ 0x2, 146, 0, 1830 }, -{ 0x1, 146, 1, 1832 }, -{ 0x1, 147, 1, 1831 }, -{ 0x1, 426, 0, 1199 }, -{ 0x8, 180, 0, 1833 }, -{ 0x4, 180, 0, 1834 }, -{ 0x2, 180, 0, 1835 }, -{ 0x1, 180, 1, 1837 }, -{ 0x1, 181, 1, 1836 }, -{ 0x1, 425, 0, 1200 }, -{ 0x8, 183, 0, 1838 }, -{ 0x4, 183, 0, 1839 }, -{ 0x2, 183, 0, 1840 }, -{ 0x1, 183, 1, 1842 }, -{ 0x1, 184, 1, 1841 }, -{ 0x1, 424, 0, 1201 }, -{ 0x8, 228, 0, 1843 }, -{ 0x4, 228, 0, 1844 }, -{ 0x2, 228, 0, 1845 }, -{ 0x1, 228, 1, 1847 }, -{ 0x1, 229, 0, 1846 }, -{ 0x8, 226, 0, 1848 }, -{ 0x4, 226, 0, 1849 }, -{ 0x2, 226, 0, 1850 }, -{ 0x1, 226, 1, 1852 }, -{ 0x1, 227, 0, 1851 }, -{ 0x8, 44, 0, 1857 }, -{ 0x18, 44, 0, 1853 }, -{ 0x4, 44, 0, 1858 }, -{ 0xc, 44, 0, 1854 }, -{ 0x2, 44, 0, 1859 }, -{ 0x6, 44, 0, 1855 }, -{ 0x1, 44, 0, 1860 }, -{ 0x3, 44, 0, 1856 }, -{ 0x51, 30, 0, 1862 }, -{ 0xd1, 30, 0, 1861 }, -{ 0x31, 30, 1, 1872 }, -{ 0x11, 31, 0, 1871 }, -{ 0x71, 30, 1, 1870 }, -{ 0x31, 31, 0, 1869 }, -{ 0x29, 30, 0, 1864 }, -{ 0x69, 30, 0, 1863 }, -{ 0x19, 30, 1, 1876 }, -{ 0x9, 31, 0, 1875 }, -{ 0x39, 30, 1, 1874 }, -{ 0x19, 31, 0, 1873 }, -{ 0x15, 30, 0, 1866 }, -{ 0x35, 30, 0, 1865 }, -{ 0xd, 30, 1, 1880 }, -{ 0x5, 31, 0, 1879 }, -{ 0x1d, 30, 1, 1878 }, -{ 0xd, 31, 0, 1877 }, -{ 0xb, 30, 0, 1868 }, -{ 0x1b, 30, 0, 1867 }, -{ 0x7, 30, 1, 1884 }, -{ 0x3, 31, 0, 1883 }, -{ 0xf, 30, 1, 1882 }, -{ 0x7, 31, 0, 1881 }, -{ 0xa2, 28, 0, 1886 }, -{ 0x1a2, 28, 0, 1885 }, -{ 0x62, 28, 1, 1896 }, -{ 0x22, 29, 0, 1895 }, -{ 0xe2, 28, 1, 1894 }, -{ 0x62, 29, 0, 1893 }, -{ 0x52, 28, 0, 1888 }, -{ 0xd2, 28, 0, 1887 }, -{ 0x32, 28, 1, 1900 }, -{ 0x12, 29, 0, 1899 }, -{ 0x72, 28, 1, 1898 }, -{ 0x32, 29, 0, 1897 }, -{ 0x2a, 28, 0, 1890 }, -{ 0x6a, 28, 0, 1889 }, -{ 0x1a, 28, 1, 1904 }, -{ 0xa, 29, 0, 1903 }, -{ 0x3a, 28, 1, 1902 }, -{ 0x1a, 29, 0, 1901 }, -{ 0x16, 28, 0, 1892 }, -{ 0x36, 28, 0, 1891 }, -{ 0xe, 28, 1, 1908 }, -{ 0x6, 29, 0, 1907 }, -{ 0x1e, 28, 1, 1906 }, -{ 0xe, 29, 0, 1905 }, -{ 0x51, 28, 0, 1910 }, -{ 0xd1, 28, 0, 1909 }, -{ 0x31, 28, 1, 1920 }, -{ 0x11, 29, 0, 1919 }, -{ 0x71, 28, 1, 1918 }, -{ 0x31, 29, 0, 1917 }, -{ 0x29, 28, 0, 1912 }, -{ 0x69, 28, 0, 1911 }, -{ 0x19, 28, 1, 1924 }, -{ 0x9, 29, 0, 1923 }, -{ 0x39, 28, 1, 1922 }, -{ 0x19, 29, 0, 1921 }, -{ 0x15, 28, 0, 1914 }, -{ 0x35, 28, 0, 1913 }, -{ 0xd, 28, 1, 1928 }, -{ 0x5, 29, 0, 1927 }, -{ 0x1d, 28, 1, 1926 }, -{ 0xd, 29, 0, 1925 }, -{ 0xb, 28, 0, 1916 }, -{ 0x1b, 28, 0, 1915 }, -{ 0x7, 28, 1, 1932 }, -{ 0x3, 29, 0, 1931 }, -{ 0xf, 28, 1, 1930 }, -{ 0x7, 29, 0, 1929 }, -{ 0x51, 26, 0, 1934 }, -{ 0xd1, 26, 0, 1933 }, -{ 0x31, 26, 1, 1944 }, -{ 0x11, 27, 0, 1943 }, -{ 0x71, 26, 1, 1942 }, -{ 0x31, 27, 0, 1941 }, -{ 0x29, 26, 0, 1936 }, -{ 0x69, 26, 0, 1935 }, -{ 0x19, 26, 1, 1948 }, -{ 0x9, 27, 0, 1947 }, -{ 0x39, 26, 1, 1946 }, -{ 0x19, 27, 0, 1945 }, -{ 0x15, 26, 0, 1938 }, -{ 0x35, 26, 0, 1937 }, -{ 0xd, 26, 1, 1952 }, -{ 0x5, 27, 0, 1951 }, -{ 0x1d, 26, 1, 1950 }, -{ 0xd, 27, 0, 1949 }, -{ 0xb, 26, 0, 1940 }, -{ 0x1b, 26, 0, 1939 }, -{ 0x7, 26, 1, 1956 }, -{ 0x3, 27, 0, 1955 }, -{ 0xf, 26, 1, 1954 }, -{ 0x7, 27, 0, 1953 }, -{ 0xa2, 24, 0, 1958 }, -{ 0x1a2, 24, 0, 1957 }, -{ 0x62, 24, 1, 1968 }, -{ 0x22, 25, 0, 1967 }, -{ 0xe2, 24, 1, 1966 }, -{ 0x62, 25, 0, 1965 }, -{ 0x52, 24, 0, 1960 }, -{ 0xd2, 24, 0, 1959 }, -{ 0x32, 24, 1, 1972 }, -{ 0x12, 25, 0, 1971 }, -{ 0x72, 24, 1, 1970 }, -{ 0x32, 25, 0, 1969 }, -{ 0x2a, 24, 0, 1962 }, -{ 0x6a, 24, 0, 1961 }, -{ 0x1a, 24, 1, 1976 }, -{ 0xa, 25, 0, 1975 }, -{ 0x3a, 24, 1, 1974 }, -{ 0x1a, 25, 0, 1973 }, -{ 0x16, 24, 0, 1964 }, -{ 0x36, 24, 0, 1963 }, -{ 0xe, 24, 1, 1980 }, -{ 0x6, 25, 0, 1979 }, -{ 0x1e, 24, 1, 1978 }, -{ 0xe, 25, 0, 1977 }, -{ 0x51, 24, 0, 1982 }, -{ 0xd1, 24, 0, 1981 }, -{ 0x31, 24, 1, 1992 }, -{ 0x11, 25, 0, 1991 }, -{ 0x71, 24, 1, 1990 }, -{ 0x31, 25, 0, 1989 }, -{ 0x29, 24, 0, 1984 }, -{ 0x69, 24, 0, 1983 }, -{ 0x19, 24, 1, 1996 }, -{ 0x9, 25, 0, 1995 }, -{ 0x39, 24, 1, 1994 }, -{ 0x19, 25, 0, 1993 }, -{ 0x15, 24, 0, 1986 }, -{ 0x35, 24, 0, 1985 }, -{ 0xd, 24, 1, 2000 }, -{ 0x5, 25, 0, 1999 }, -{ 0x1d, 24, 1, 1998 }, -{ 0xd, 25, 0, 1997 }, -{ 0xb, 24, 0, 1988 }, -{ 0x1b, 24, 0, 1987 }, -{ 0x7, 24, 1, 2004 }, -{ 0x3, 25, 0, 2003 }, -{ 0xf, 24, 1, 2002 }, -{ 0x7, 25, 0, 2001 }, -{ 0x51, 22, 1, 2030 }, -{ 0x50, 22, 0, 2006 }, -{ 0xd1, 22, 1, 2029 }, -{ 0xd0, 22, 0, 2005 }, -{ 0x31, 22, 1, 2040 }, -{ 0x30, 22, 1, 2016 }, -{ 0x11, 23, 1, 2039 }, -{ 0x10, 23, 0, 2015 }, -{ 0x71, 22, 1, 2038 }, -{ 0x70, 22, 1, 2014 }, -{ 0x31, 23, 1, 2037 }, -{ 0x30, 23, 0, 2013 }, -{ 0x29, 22, 1, 2032 }, -{ 0x28, 22, 0, 2008 }, -{ 0x69, 22, 1, 2031 }, -{ 0x68, 22, 0, 2007 }, -{ 0x19, 22, 1, 2044 }, -{ 0x18, 22, 1, 2020 }, -{ 0x9, 23, 1, 2043 }, -{ 0x8, 23, 0, 2019 }, -{ 0x39, 22, 1, 2042 }, -{ 0x38, 22, 1, 2018 }, -{ 0x19, 23, 1, 2041 }, -{ 0x18, 23, 0, 2017 }, -{ 0x15, 22, 1, 2034 }, -{ 0x14, 22, 0, 2010 }, -{ 0x35, 22, 1, 2033 }, -{ 0x34, 22, 0, 2009 }, -{ 0xd, 22, 1, 2048 }, -{ 0xc, 22, 1, 2024 }, -{ 0x5, 23, 1, 2047 }, -{ 0x4, 23, 0, 2023 }, -{ 0x1d, 22, 1, 2046 }, -{ 0x1c, 22, 1, 2022 }, -{ 0xd, 23, 1, 2045 }, -{ 0xc, 23, 0, 2021 }, -{ 0xb, 22, 1, 2036 }, -{ 0xa, 22, 0, 2012 }, -{ 0x1b, 22, 1, 2035 }, -{ 0x1a, 22, 0, 2011 }, -{ 0x7, 22, 1, 2052 }, -{ 0x6, 22, 1, 2028 }, -{ 0x3, 23, 1, 2051 }, -{ 0x2, 23, 0, 2027 }, -{ 0xf, 22, 1, 2050 }, -{ 0xe, 22, 1, 2026 }, -{ 0x7, 23, 1, 2049 }, -{ 0x6, 23, 0, 2025 }, -{ 0x8, 21, 0, 2054 }, -{ 0x18, 21, 0, 2053 }, -{ 0x1, 21, 1, 2058 }, -{ 0x2, 21, 0, 2057 }, -{ 0x3, 21, 1, 2056 }, -{ 0x4, 21, 0, 2055 }, -{ 0x1, 239, 0, 2059 }, -{ 0x1, 339, 0, 2060 }, -{ 0x14, 43, 0, 2063 }, -{ 0x34, 43, 0, 2061 }, -{ 0xc, 43, 0, 2064 }, -{ 0x1c, 43, 0, 2062 }, -{ 0x2, 43, 0, 2067 }, -{ 0x6, 43, 0, 2065 }, -{ 0x1, 43, 0, 2068 }, -{ 0x3, 43, 0, 2066 }, -{ 0x51, 19, 0, 2070 }, -{ 0xd1, 19, 0, 2069 }, -{ 0x31, 19, 1, 2080 }, -{ 0x11, 20, 0, 2079 }, -{ 0x71, 19, 1, 2078 }, -{ 0x31, 20, 0, 2077 }, -{ 0x29, 19, 0, 2072 }, -{ 0x69, 19, 0, 2071 }, -{ 0x19, 19, 1, 2084 }, -{ 0x9, 20, 0, 2083 }, -{ 0x39, 19, 1, 2082 }, -{ 0x19, 20, 0, 2081 }, -{ 0x15, 19, 0, 2074 }, -{ 0x35, 19, 0, 2073 }, -{ 0xd, 19, 1, 2088 }, -{ 0x5, 20, 0, 2087 }, -{ 0x1d, 19, 1, 2086 }, -{ 0xd, 20, 0, 2085 }, -{ 0xb, 19, 0, 2076 }, -{ 0x1b, 19, 0, 2075 }, -{ 0x7, 19, 1, 2092 }, -{ 0x3, 20, 0, 2091 }, -{ 0xf, 19, 1, 2090 }, -{ 0x7, 20, 0, 2089 }, -{ 0x1, 32, 0, 2093 }, -{ 0x2, 447, 0, 2094 }, -{ 0x1, 447, 0, 2095 }, -{ 0x1, 140, 0, 2096 }, -{ 0x2, 45, 0, 2097 }, -{ 0x1, 45, 0, 2098 }, -{ 0x1, 387, 0, 2099 }, -{ 0x2, 52, 0, 2100 }, -{ 0x1, 52, 0, 2101 }, -{ 0x1, 133, 0, 2102 }, -{ 0x51, 17, 0, 2104 }, -{ 0xd1, 17, 0, 2103 }, -{ 0x31, 17, 1, 2114 }, -{ 0x11, 18, 0, 2113 }, -{ 0x71, 17, 1, 2112 }, -{ 0x31, 18, 0, 2111 }, -{ 0x29, 17, 0, 2106 }, -{ 0x69, 17, 0, 2105 }, -{ 0x19, 17, 1, 2118 }, -{ 0x9, 18, 0, 2117 }, -{ 0x39, 17, 1, 2116 }, -{ 0x19, 18, 0, 2115 }, -{ 0x15, 17, 0, 2108 }, -{ 0x35, 17, 0, 2107 }, -{ 0xd, 17, 1, 2122 }, -{ 0x5, 18, 0, 2121 }, -{ 0x1d, 17, 1, 2120 }, -{ 0xd, 18, 0, 2119 }, -{ 0xb, 17, 0, 2110 }, -{ 0x1b, 17, 0, 2109 }, -{ 0x7, 17, 1, 2126 }, -{ 0x3, 18, 0, 2125 }, -{ 0xf, 17, 1, 2124 }, -{ 0x7, 18, 0, 2123 }, -{ 0xa20, 15, 0, 2128 }, -{ 0x1a20, 15, 0, 2127 }, -{ 0x620, 15, 1, 2138 }, -{ 0x220, 16, 0, 2137 }, -{ 0xe20, 15, 1, 2136 }, -{ 0x620, 16, 0, 2135 }, -{ 0x520, 15, 0, 2130 }, -{ 0xd20, 15, 0, 2129 }, -{ 0x320, 15, 1, 2142 }, -{ 0x120, 16, 0, 2141 }, -{ 0x720, 15, 1, 2140 }, -{ 0x320, 16, 0, 2139 }, -{ 0x2a0, 15, 0, 2132 }, -{ 0x6a0, 15, 0, 2131 }, -{ 0x1a0, 15, 1, 2146 }, -{ 0xa0, 16, 0, 2145 }, -{ 0x3a0, 15, 1, 2144 }, -{ 0x1a0, 16, 0, 2143 }, -{ 0x160, 15, 0, 2134 }, -{ 0x360, 15, 0, 2133 }, -{ 0xe0, 15, 1, 2150 }, -{ 0x60, 16, 0, 2149 }, -{ 0x1e0, 15, 1, 2148 }, -{ 0xe0, 16, 0, 2147 }, -{ 0x51, 15, 1, 2176 }, -{ 0x50, 15, 0, 2152 }, -{ 0xd1, 15, 1, 2175 }, -{ 0xd0, 15, 0, 2151 }, -{ 0x31, 15, 1, 2186 }, -{ 0x30, 15, 1, 2162 }, -{ 0x11, 16, 1, 2185 }, -{ 0x10, 16, 0, 2161 }, -{ 0x71, 15, 1, 2184 }, -{ 0x70, 15, 1, 2160 }, -{ 0x31, 16, 1, 2183 }, -{ 0x30, 16, 0, 2159 }, -{ 0x29, 15, 1, 2178 }, -{ 0x28, 15, 0, 2154 }, -{ 0x69, 15, 1, 2177 }, -{ 0x68, 15, 0, 2153 }, -{ 0x19, 15, 1, 2190 }, -{ 0x18, 15, 1, 2166 }, -{ 0x9, 16, 1, 2189 }, -{ 0x8, 16, 0, 2165 }, -{ 0x39, 15, 1, 2188 }, -{ 0x38, 15, 1, 2164 }, -{ 0x19, 16, 1, 2187 }, -{ 0x18, 16, 0, 2163 }, -{ 0x15, 15, 1, 2180 }, -{ 0x14, 15, 0, 2156 }, -{ 0x35, 15, 1, 2179 }, -{ 0x34, 15, 0, 2155 }, -{ 0xd, 15, 1, 2194 }, -{ 0xc, 15, 1, 2170 }, -{ 0x5, 16, 1, 2193 }, -{ 0x4, 16, 0, 2169 }, -{ 0x1d, 15, 1, 2192 }, -{ 0x1c, 15, 1, 2168 }, -{ 0xd, 16, 1, 2191 }, -{ 0xc, 16, 0, 2167 }, -{ 0xb, 15, 1, 2182 }, -{ 0xa, 15, 0, 2158 }, -{ 0x1b, 15, 1, 2181 }, -{ 0x1a, 15, 0, 2157 }, -{ 0x7, 15, 1, 2198 }, -{ 0x6, 15, 1, 2174 }, -{ 0x3, 16, 1, 2197 }, -{ 0x2, 16, 0, 2173 }, -{ 0xf, 15, 1, 2196 }, -{ 0xe, 15, 1, 2172 }, -{ 0x7, 16, 1, 2195 }, -{ 0x6, 16, 0, 2171 }, -{ 0x8, 14, 0, 2200 }, -{ 0x18, 14, 0, 2199 }, -{ 0x1, 14, 1, 2204 }, -{ 0x2, 14, 0, 2203 }, -{ 0x3, 14, 1, 2202 }, -{ 0x4, 14, 0, 2201 }, -{ 0x1, 109, 1, 2356 }, -{ 0x1, 110, 1, 2355 }, -{ 0x1, 111, 1, 2354 }, -{ 0x1, 112, 1, 2353 }, -{ 0x1, 113, 1, 2352 }, -{ 0x1, 114, 1, 2351 }, -{ 0x1, 115, 1, 2350 }, -{ 0x1, 116, 1, 2349 }, -{ 0x39, 41, 1, 22 }, -{ 0x19, 42, 0, 21 }, -{ 0x3, 109, 1, 2348 }, -{ 0x3, 110, 1, 2347 }, -{ 0x3, 111, 1, 2346 }, -{ 0x3, 112, 1, 2345 }, -{ 0x3, 113, 1, 2344 }, -{ 0x3, 114, 1, 2343 }, -{ 0x3, 115, 1, 2342 }, -{ 0x3, 116, 1, 2341 }, -{ 0x69, 41, 0, 11 }, -{ 0x14, 100, 1, 2336 }, -{ 0x22, 101, 1, 2333 }, -{ 0x44, 101, 1, 2335 }, -{ 0xa, 108, 1, 2334 }, -{ 0xd1, 41, 0, 9 }, -{ 0x34, 100, 1, 2208 }, -{ 0xc4, 101, 1, 2207 }, -{ 0x1c, 107, 1, 2205 }, -{ 0xe, 122, 0, 2206 }, -{ 0xc, 100, 1, 2496 }, -{ 0xa, 101, 1, 2493 }, -{ 0x14, 101, 1, 2495 }, -{ 0x6, 108, 0, 2494 }, -{ 0x2, 100, 1, 2220 }, -{ 0x2, 101, 1, 2219 }, -{ 0x2, 106, 1, 2218 }, -{ 0x2, 107, 0, 2217 }, -{ 0x12, 100, 1, 2216 }, -{ 0x42, 101, 1, 2215 }, -{ 0x6, 106, 1, 2214 }, -{ 0x6, 107, 0, 2213 }, -{ 0xa, 100, 1, 2340 }, -{ 0x12, 101, 1, 2339 }, -{ 0x24, 101, 1, 2337 }, -{ 0x5, 108, 1, 2338 }, -{ 0x71, 41, 1, 18 }, -{ 0x31, 42, 0, 17 }, -{ 0x1a, 100, 1, 2212 }, -{ 0x32, 101, 1, 2211 }, -{ 0x1a, 107, 1, 2209 }, -{ 0x7, 122, 0, 2210 }, -{ 0x6, 100, 1, 2500 }, -{ 0x6, 101, 1, 2499 }, -{ 0xc, 101, 1, 2497 }, -{ 0x3, 108, 0, 2498 }, -{ 0x1, 100, 1, 2516 }, -{ 0x1, 101, 1, 2515 }, -{ 0x1, 102, 1, 2514 }, -{ 0x1, 103, 1, 2513 }, -{ 0x1, 104, 1, 2512 }, -{ 0x1, 105, 1, 2511 }, -{ 0x1, 106, 1, 2510 }, -{ 0x1, 107, 0, 2509 }, -{ 0x3, 100, 1, 2508 }, -{ 0x3, 101, 1, 2507 }, -{ 0x3, 102, 1, 2506 }, -{ 0x3, 103, 1, 2505 }, -{ 0x3, 104, 1, 2504 }, -{ 0x3, 105, 1, 2503 }, -{ 0x3, 106, 1, 2502 }, -{ 0x3, 107, 0, 2501 }, -{ 0x8, 67, 1, 2380 }, -{ 0x8, 68, 1, 2379 }, -{ 0x2, 73, 1, 2374 }, -{ 0x2, 74, 1, 2373 }, -{ 0x1, 76, 1, 2378 }, -{ 0x1, 77, 1, 2377 }, -{ 0x1, 78, 1, 2376 }, -{ 0x1, 79, 1, 2375 }, -{ 0xf, 41, 1, 30 }, -{ 0x7, 42, 0, 29 }, -{ 0x18, 67, 1, 2372 }, -{ 0x18, 68, 1, 2371 }, -{ 0x6, 73, 1, 2366 }, -{ 0x6, 74, 1, 2365 }, -{ 0x3, 76, 1, 2370 }, -{ 0x3, 77, 1, 2369 }, -{ 0x3, 78, 1, 2368 }, -{ 0x3, 79, 1, 2367 }, -{ 0x1b, 41, 0, 15 }, -{ 0x14, 67, 1, 2360 }, -{ 0x22, 68, 1, 2357 }, -{ 0x44, 68, 1, 2359 }, -{ 0xa, 75, 1, 2358 }, -{ 0x35, 41, 0, 13 }, -{ 0x34, 67, 1, 2224 }, -{ 0xc4, 68, 1, 2223 }, -{ 0x38, 74, 1, 2221 }, -{ 0xe, 85, 0, 2222 }, -{ 0xc, 67, 1, 2520 }, -{ 0xa, 68, 1, 2517 }, -{ 0x14, 68, 1, 2519 }, -{ 0x6, 75, 0, 2518 }, -{ 0x2, 67, 1, 2236 }, -{ 0x2, 68, 1, 2235 }, -{ 0x4, 73, 1, 2234 }, -{ 0x4, 74, 0, 2233 }, -{ 0x12, 67, 1, 2232 }, -{ 0x42, 68, 1, 2231 }, -{ 0xc, 73, 1, 2230 }, -{ 0xc, 74, 0, 2229 }, -{ 0xa, 67, 1, 2364 }, -{ 0x12, 68, 1, 2363 }, -{ 0x24, 68, 1, 2361 }, -{ 0x5, 75, 1, 2362 }, -{ 0x1d, 41, 1, 26 }, -{ 0xd, 42, 0, 25 }, -{ 0x1a, 67, 1, 2228 }, -{ 0x32, 68, 1, 2227 }, -{ 0x34, 74, 1, 2225 }, -{ 0x7, 85, 0, 2226 }, -{ 0x6, 67, 1, 2524 }, -{ 0x6, 68, 1, 2523 }, -{ 0xc, 68, 1, 2521 }, -{ 0x3, 75, 0, 2522 }, -{ 0x1, 67, 1, 2540 }, -{ 0x1, 68, 1, 2539 }, -{ 0x1, 69, 1, 2538 }, -{ 0x1, 70, 1, 2537 }, -{ 0x1, 71, 1, 2536 }, -{ 0x1, 72, 1, 2535 }, -{ 0x1, 73, 1, 2534 }, -{ 0x1, 74, 0, 2533 }, -{ 0x3, 67, 1, 2532 }, -{ 0x3, 68, 1, 2531 }, -{ 0x3, 69, 1, 2530 }, -{ 0x3, 70, 1, 2529 }, -{ 0x3, 71, 1, 2528 }, -{ 0x3, 72, 1, 2527 }, -{ 0x3, 73, 1, 2526 }, -{ 0x3, 74, 0, 2525 }, -{ 0x28, 95, 1, 2388 }, -{ 0x44, 96, 1, 2383 }, -{ 0x88, 96, 1, 2387 }, -{ 0x44, 97, 1, 2382 }, -{ 0x88, 97, 1, 2386 }, -{ 0x44, 98, 1, 2381 }, -{ 0x88, 98, 1, 2385 }, -{ 0x28, 99, 0, 2384 }, -{ 0x68, 95, 1, 2244 }, -{ 0x188, 96, 1, 2243 }, -{ 0x188, 97, 1, 2242 }, -{ 0x188, 98, 1, 2241 }, -{ 0x38, 118, 1, 2240 }, -{ 0x38, 119, 1, 2239 }, -{ 0x38, 120, 1, 2238 }, -{ 0x38, 121, 0, 2237 }, -{ 0x18, 95, 1, 2548 }, -{ 0x14, 96, 1, 2543 }, -{ 0x28, 96, 1, 2547 }, -{ 0x14, 97, 1, 2542 }, -{ 0x28, 97, 1, 2546 }, -{ 0x14, 98, 1, 2541 }, -{ 0x28, 98, 1, 2545 }, -{ 0x18, 99, 0, 2544 }, -{ 0x14, 95, 1, 2396 }, -{ 0x24, 96, 1, 2395 }, -{ 0x48, 96, 1, 2391 }, -{ 0x24, 97, 1, 2394 }, -{ 0x48, 97, 1, 2390 }, -{ 0x24, 98, 1, 2393 }, -{ 0x48, 98, 1, 2389 }, -{ 0x14, 99, 0, 2392 }, -{ 0x34, 95, 1, 2252 }, -{ 0x64, 96, 1, 2251 }, -{ 0x64, 97, 1, 2250 }, -{ 0x64, 98, 1, 2249 }, -{ 0x1c, 118, 1, 2248 }, -{ 0x1c, 119, 1, 2247 }, -{ 0x1c, 120, 1, 2246 }, -{ 0x1c, 121, 0, 2245 }, -{ 0xc, 95, 1, 2556 }, -{ 0xc, 96, 1, 2555 }, -{ 0x18, 96, 1, 2551 }, -{ 0xc, 97, 1, 2554 }, -{ 0x18, 97, 1, 2550 }, -{ 0xc, 98, 1, 2553 }, -{ 0x18, 98, 1, 2549 }, -{ 0xc, 99, 0, 2552 }, -{ 0xa, 95, 1, 2404 }, -{ 0x11, 96, 1, 2399 }, -{ 0x22, 96, 1, 2403 }, -{ 0x11, 97, 1, 2398 }, -{ 0x22, 97, 1, 2402 }, -{ 0x11, 98, 1, 2397 }, -{ 0x22, 98, 1, 2401 }, -{ 0xa, 99, 0, 2400 }, -{ 0x1a, 95, 1, 2260 }, -{ 0x62, 96, 1, 2259 }, -{ 0x62, 97, 1, 2258 }, -{ 0x62, 98, 1, 2257 }, -{ 0xe, 118, 1, 2256 }, -{ 0xe, 119, 1, 2255 }, -{ 0xe, 120, 1, 2254 }, -{ 0xe, 121, 0, 2253 }, -{ 0x6, 95, 1, 2564 }, -{ 0x5, 96, 1, 2559 }, -{ 0xa, 96, 1, 2563 }, -{ 0x5, 97, 1, 2558 }, -{ 0xa, 97, 1, 2562 }, -{ 0x5, 98, 1, 2557 }, -{ 0xa, 98, 1, 2561 }, -{ 0x6, 99, 0, 2560 }, -{ 0x5, 95, 1, 2412 }, -{ 0x9, 96, 1, 2411 }, -{ 0x12, 96, 1, 2407 }, -{ 0x9, 97, 1, 2410 }, -{ 0x12, 97, 1, 2406 }, -{ 0x9, 98, 1, 2409 }, -{ 0x12, 98, 1, 2405 }, -{ 0x5, 99, 0, 2408 }, -{ 0xd, 95, 1, 2268 }, -{ 0x19, 96, 1, 2267 }, -{ 0x19, 97, 1, 2266 }, -{ 0x19, 98, 1, 2265 }, -{ 0x7, 118, 1, 2264 }, -{ 0x7, 119, 1, 2263 }, -{ 0x7, 120, 1, 2262 }, -{ 0x7, 121, 0, 2261 }, -{ 0x3, 95, 1, 2572 }, -{ 0x3, 96, 1, 2571 }, -{ 0x6, 96, 1, 2567 }, -{ 0x3, 97, 1, 2570 }, -{ 0x6, 97, 1, 2566 }, -{ 0x3, 98, 1, 2569 }, -{ 0x6, 98, 1, 2565 }, -{ 0x3, 99, 0, 2568 }, -{ 0x28, 62, 1, 2420 }, -{ 0x44, 63, 1, 2415 }, -{ 0x88, 63, 1, 2419 }, -{ 0x44, 64, 1, 2414 }, -{ 0x88, 64, 1, 2418 }, -{ 0x44, 65, 1, 2413 }, -{ 0x88, 65, 1, 2417 }, -{ 0x28, 66, 0, 2416 }, -{ 0x68, 62, 1, 2276 }, -{ 0x188, 63, 1, 2275 }, -{ 0x188, 64, 1, 2274 }, -{ 0x188, 65, 1, 2273 }, -{ 0x38, 81, 1, 2272 }, -{ 0x38, 82, 1, 2271 }, -{ 0x38, 83, 1, 2270 }, -{ 0x38, 84, 0, 2269 }, -{ 0x18, 62, 1, 2580 }, -{ 0x14, 63, 1, 2575 }, -{ 0x28, 63, 1, 2579 }, -{ 0x14, 64, 1, 2574 }, -{ 0x28, 64, 1, 2578 }, -{ 0x14, 65, 1, 2573 }, -{ 0x28, 65, 1, 2577 }, -{ 0x18, 66, 0, 2576 }, -{ 0x14, 62, 1, 2428 }, -{ 0x24, 63, 1, 2427 }, -{ 0x48, 63, 1, 2423 }, -{ 0x24, 64, 1, 2426 }, -{ 0x48, 64, 1, 2422 }, -{ 0x24, 65, 1, 2425 }, -{ 0x48, 65, 1, 2421 }, -{ 0x14, 66, 0, 2424 }, -{ 0x34, 62, 1, 2284 }, -{ 0x64, 63, 1, 2283 }, -{ 0x64, 64, 1, 2282 }, -{ 0x64, 65, 1, 2281 }, -{ 0x1c, 81, 1, 2280 }, -{ 0x1c, 82, 1, 2279 }, -{ 0x1c, 83, 1, 2278 }, -{ 0x1c, 84, 0, 2277 }, -{ 0xc, 62, 1, 2588 }, -{ 0xc, 63, 1, 2587 }, -{ 0x18, 63, 1, 2583 }, -{ 0xc, 64, 1, 2586 }, -{ 0x18, 64, 1, 2582 }, -{ 0xc, 65, 1, 2585 }, -{ 0x18, 65, 1, 2581 }, -{ 0xc, 66, 0, 2584 }, -{ 0xa, 62, 1, 2436 }, -{ 0x11, 63, 1, 2431 }, -{ 0x22, 63, 1, 2435 }, -{ 0x11, 64, 1, 2430 }, -{ 0x22, 64, 1, 2434 }, -{ 0x11, 65, 1, 2429 }, -{ 0x22, 65, 1, 2433 }, -{ 0xa, 66, 0, 2432 }, -{ 0x1a, 62, 1, 2292 }, -{ 0x62, 63, 1, 2291 }, -{ 0x62, 64, 1, 2290 }, -{ 0x62, 65, 1, 2289 }, -{ 0xe, 81, 1, 2288 }, -{ 0xe, 82, 1, 2287 }, -{ 0xe, 83, 1, 2286 }, -{ 0xe, 84, 0, 2285 }, -{ 0x6, 62, 1, 2596 }, -{ 0x5, 63, 1, 2591 }, -{ 0xa, 63, 1, 2595 }, -{ 0x5, 64, 1, 2590 }, -{ 0xa, 64, 1, 2594 }, -{ 0x5, 65, 1, 2589 }, -{ 0xa, 65, 1, 2593 }, -{ 0x6, 66, 0, 2592 }, -{ 0x5, 62, 1, 2444 }, -{ 0x9, 63, 1, 2443 }, -{ 0x12, 63, 1, 2439 }, -{ 0x9, 64, 1, 2442 }, -{ 0x12, 64, 1, 2438 }, -{ 0x9, 65, 1, 2441 }, -{ 0x12, 65, 1, 2437 }, -{ 0x5, 66, 0, 2440 }, -{ 0xd, 62, 1, 2300 }, -{ 0x19, 63, 1, 2299 }, -{ 0x19, 64, 1, 2298 }, -{ 0x19, 65, 1, 2297 }, -{ 0x7, 81, 1, 2296 }, -{ 0x7, 82, 1, 2295 }, -{ 0x7, 83, 1, 2294 }, -{ 0x7, 84, 0, 2293 }, -{ 0x3, 62, 1, 2604 }, -{ 0x3, 63, 1, 2603 }, -{ 0x6, 63, 1, 2599 }, -{ 0x3, 64, 1, 2602 }, -{ 0x6, 64, 1, 2598 }, -{ 0x3, 65, 1, 2601 }, -{ 0x6, 65, 1, 2597 }, -{ 0x3, 66, 0, 2600 }, -{ 0x8, 86, 1, 2468 }, -{ 0x8, 87, 1, 2467 }, -{ 0x2, 88, 1, 2466 }, -{ 0x2, 89, 1, 2465 }, -{ 0x2, 90, 1, 2464 }, -{ 0x2, 91, 1, 2463 }, -{ 0x2, 92, 1, 2462 }, -{ 0x2, 93, 0, 2461 }, -{ 0x18, 86, 1, 2460 }, -{ 0x18, 87, 1, 2459 }, -{ 0x6, 88, 1, 2458 }, -{ 0x6, 89, 1, 2457 }, -{ 0x6, 90, 1, 2456 }, -{ 0x6, 91, 1, 2455 }, -{ 0x6, 92, 1, 2454 }, -{ 0x6, 93, 0, 2453 }, -{ 0x14, 86, 1, 2448 }, -{ 0x22, 87, 1, 2445 }, -{ 0x44, 87, 1, 2447 }, -{ 0xa, 94, 0, 2446 }, -{ 0x34, 86, 1, 2304 }, -{ 0xc4, 87, 1, 2303 }, -{ 0x38, 93, 1, 2301 }, -{ 0xe, 117, 0, 2302 }, -{ 0xc, 86, 1, 2608 }, -{ 0xa, 87, 1, 2605 }, -{ 0x14, 87, 1, 2607 }, -{ 0x6, 94, 0, 2606 }, -{ 0x2, 86, 1, 2316 }, -{ 0x2, 87, 1, 2315 }, -{ 0x4, 92, 1, 2314 }, -{ 0x4, 93, 0, 2313 }, -{ 0x12, 86, 1, 2312 }, -{ 0x42, 87, 1, 2311 }, -{ 0xc, 92, 1, 2310 }, -{ 0xc, 93, 0, 2309 }, -{ 0xa, 86, 1, 2452 }, -{ 0x12, 87, 1, 2451 }, -{ 0x24, 87, 1, 2449 }, -{ 0x5, 94, 0, 2450 }, -{ 0x1a, 86, 1, 2308 }, -{ 0x32, 87, 1, 2307 }, -{ 0x34, 93, 1, 2305 }, -{ 0x7, 117, 0, 2306 }, -{ 0x6, 86, 1, 2612 }, -{ 0x6, 87, 1, 2611 }, -{ 0xc, 87, 1, 2609 }, -{ 0x3, 94, 0, 2610 }, -{ 0x1, 86, 1, 2628 }, -{ 0x1, 87, 1, 2627 }, -{ 0x1, 88, 1, 2626 }, -{ 0x1, 89, 1, 2625 }, -{ 0x1, 90, 1, 2624 }, -{ 0x1, 91, 1, 2623 }, -{ 0x1, 92, 1, 2622 }, -{ 0x1, 93, 0, 2621 }, -{ 0x3, 86, 1, 2620 }, -{ 0x3, 87, 1, 2619 }, -{ 0x3, 88, 1, 2618 }, -{ 0x3, 89, 1, 2617 }, -{ 0x3, 90, 1, 2616 }, -{ 0x3, 91, 1, 2615 }, -{ 0x3, 92, 1, 2614 }, -{ 0x3, 93, 0, 2613 }, -{ 0x8, 53, 1, 2492 }, -{ 0x8, 54, 1, 2491 }, -{ 0x2, 55, 1, 2490 }, -{ 0x2, 56, 1, 2489 }, -{ 0x2, 57, 1, 2488 }, -{ 0x2, 58, 1, 2487 }, -{ 0x2, 59, 1, 2486 }, -{ 0x2, 60, 0, 2485 }, -{ 0x18, 53, 1, 2484 }, -{ 0x18, 54, 1, 2483 }, -{ 0x6, 55, 1, 2482 }, -{ 0x6, 56, 1, 2481 }, -{ 0x6, 57, 1, 2480 }, -{ 0x6, 58, 1, 2479 }, -{ 0x6, 59, 1, 2478 }, -{ 0x6, 60, 0, 2477 }, -{ 0x14, 53, 1, 2472 }, -{ 0x22, 54, 1, 2469 }, -{ 0x44, 54, 1, 2471 }, -{ 0xa, 61, 0, 2470 }, -{ 0x34, 53, 1, 2320 }, -{ 0xc4, 54, 1, 2319 }, -{ 0x38, 60, 1, 2317 }, -{ 0xe, 80, 0, 2318 }, -{ 0xc, 53, 1, 2632 }, -{ 0xa, 54, 1, 2629 }, -{ 0x14, 54, 1, 2631 }, -{ 0x6, 61, 0, 2630 }, -{ 0x2, 53, 1, 2332 }, -{ 0x2, 54, 1, 2331 }, -{ 0x4, 59, 1, 2330 }, -{ 0x4, 60, 0, 2329 }, -{ 0x12, 53, 1, 2328 }, -{ 0x42, 54, 1, 2327 }, -{ 0xc, 59, 1, 2326 }, -{ 0xc, 60, 0, 2325 }, -{ 0xa, 53, 1, 2476 }, -{ 0x12, 54, 1, 2475 }, -{ 0x24, 54, 1, 2473 }, -{ 0x5, 61, 0, 2474 }, -{ 0x1a, 53, 1, 2324 }, -{ 0x32, 54, 1, 2323 }, -{ 0x34, 60, 1, 2321 }, -{ 0x7, 80, 0, 2322 }, -{ 0x6, 53, 1, 2636 }, -{ 0x6, 54, 1, 2635 }, -{ 0xc, 54, 1, 2633 }, -{ 0x3, 61, 0, 2634 }, -{ 0x1, 53, 1, 2652 }, -{ 0x1, 54, 1, 2651 }, -{ 0x1, 55, 1, 2650 }, -{ 0x1, 56, 1, 2649 }, -{ 0x1, 57, 1, 2648 }, -{ 0x1, 58, 1, 2647 }, -{ 0x1, 59, 1, 2646 }, -{ 0x1, 60, 0, 2645 }, -{ 0x3, 53, 1, 2644 }, -{ 0x3, 54, 1, 2643 }, -{ 0x3, 55, 1, 2642 }, -{ 0x3, 56, 1, 2641 }, -{ 0x3, 57, 1, 2640 }, -{ 0x3, 58, 1, 2639 }, -{ 0x3, 59, 1, 2638 }, -{ 0x3, 60, 0, 2637 }, -{ 0x1, 4, 0, 2653 }, -{ 0x1, 296, 0, 2654 }, -{ 0x1, 379, 0, 2655 }, -{ 0x1, 374, 0, 2656 }, -{ 0x2, 358, 0, 2657 }, -{ 0x1, 358, 0, 2660 }, -{ 0x2, 357, 0, 2658 }, -{ 0x1, 357, 0, 2661 }, -{ 0x2, 356, 0, 2659 }, -{ 0x1, 356, 0, 2662 }, -{ 0x1, 355, 0, 2663 }, -{ 0x1, 354, 0, 2664 }, -{ 0x2, 353, 0, 2665 }, -{ 0x1, 353, 0, 2667 }, -{ 0x2, 352, 0, 2666 }, -{ 0x1, 352, 0, 2668 }, -{ 0x1, 382, 0, 2675 }, -{ 0x8, 381, 0, 2669 }, -{ 0x4, 381, 0, 2671 }, -{ 0x2, 381, 0, 2673 }, -{ 0x1, 381, 0, 2676 }, -{ 0x8, 380, 0, 2670 }, -{ 0x4, 380, 0, 2672 }, -{ 0x2, 380, 0, 2674 }, -{ 0x1, 380, 0, 2677 }, -{ 0x1, 351, 0, 2684 }, -{ 0x8, 350, 0, 2678 }, -{ 0x4, 350, 0, 2680 }, -{ 0x2, 350, 0, 2682 }, -{ 0x1, 350, 0, 2685 }, -{ 0x8, 349, 0, 2679 }, -{ 0x4, 349, 0, 2681 }, -{ 0x2, 349, 1, 2683 }, -{ 0x4, 143, 0, 1377 }, -{ 0x1, 349, 0, 2686 }, -{ 0x1, 6, 0, 2687 }, -{ 0x1, 7, 0, 2688 }, -{ 0x1, 295, 0, 2689 }, -{ 0x1, 456, 0, 2690 }, -{ 0x1, 346, 0, 2691 }, -{ 0x1, 13, 0, 2692 }, -{ 0x1, 11, 0, 2693 }, -{ 0x1, 422, 0, 2694 }, -{ 0x1, 394, 0, 2695 }, -{ 0x1, 393, 0, 2696 }, -{ 0x1, 455, 0, 2697 }, -{ 0x1, 345, 0, 2698 }, -{ 0x1, 12, 0, 2699 }, -{ 0x1, 10, 0, 2700 }, -{ 0x1, 5, 0, 2701 }, -{ 0x1, 421, 0, 2702 }, -{ 0x1, 420, 0, 2703 }, -{ 0x1, 1, 0, 2704 }, -{ 0x1, 0, 0, 2705 }, -}; - - -/* ia64-opc.c -- Functions to access the compacted opcode table - Copyright 1999, 2000, 2001, 2003, 2005 Free Software Foundation, Inc. - Written by Bob Manson of Cygnus Solutions, <manson@cygnus.com> - - This file is part of GDB, GAS, and the GNU binutils. - - GDB, GAS, and the GNU binutils are free software; you can redistribute - them and/or modify them under the terms of the GNU General Public - License as published by the Free Software Foundation; either version - 2, or (at your option) any later version. - - GDB, GAS, and the GNU binutils are distributed in the hope that they - will be useful, but WITHOUT ANY WARRANTY; without even the implied - warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See - the GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this file; see the file COPYING. If not, see - <http://www.gnu.org/licenses/>. */ - -static const struct ia64_templ_desc ia64_templ_desc[16] = - { - { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" }, /* 0 */ - { 2, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" }, - { 0, { IA64_UNIT_M, IA64_UNIT_L, IA64_UNIT_X }, "MLX" }, - { 0, { 0, }, "-3-" }, - { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" }, /* 4 */ - { 1, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" }, - { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_I }, "MFI" }, - { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_F }, "MMF" }, - { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_B }, "MIB" }, /* 8 */ - { 0, { IA64_UNIT_M, IA64_UNIT_B, IA64_UNIT_B }, "MBB" }, - { 0, { 0, }, "-a-" }, - { 0, { IA64_UNIT_B, IA64_UNIT_B, IA64_UNIT_B }, "BBB" }, - { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_B }, "MMB" }, /* c */ - { 0, { 0, }, "-d-" }, - { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_B }, "MFB" }, - { 0, { 0, }, "-f-" }, - }; - -/* Apply the completer referred to by COMPLETER_INDEX to OPCODE, and - return the result. */ - -static ia64_insn -apply_completer (ia64_insn opcode, int completer_index) -{ - ia64_insn mask = completer_table[completer_index].mask; - ia64_insn bits = completer_table[completer_index].bits; - int shiftamt = (completer_table[completer_index].offset & 63); - - mask = mask << shiftamt; - bits = bits << shiftamt; - opcode = (opcode & ~mask) | bits; - return opcode; -} - -/* Extract BITS number of bits starting from OP_POINTER + BITOFFSET in - the dis_table array, and return its value. (BITOFFSET is numbered - starting from MSB to LSB, so a BITOFFSET of 0 indicates the MSB of the - first byte in OP_POINTER.) */ - -static int -extract_op_bits (int op_pointer, int bitoffset, int bits) -{ - int res = 0; - - op_pointer += (bitoffset / 8); - - if (bitoffset % 8) - { - unsigned int op = dis_table[op_pointer++]; - int numb = 8 - (bitoffset % 8); - int mask = (1 << numb) - 1; - int bata = (bits < numb) ? bits : numb; - int delta = numb - bata; - - res = (res << bata) | ((op & mask) >> delta); - bitoffset += bata; - bits -= bata; - } - while (bits >= 8) - { - res = (res << 8) | (dis_table[op_pointer++] & 255); - bits -= 8; - } - if (bits > 0) - { - unsigned int op = (dis_table[op_pointer++] & 255); - res = (res << bits) | (op >> (8 - bits)); - } - return res; -} - -/* Examine the state machine entry at OP_POINTER in the dis_table - array, and extract its values into OPVAL and OP. The length of the - state entry in bits is returned. */ - -static int -extract_op (int op_pointer, int *opval, unsigned int *op) -{ - int oplen = 5; - - *op = dis_table[op_pointer]; - - if ((*op) & 0x40) - { - opval[0] = extract_op_bits (op_pointer, oplen, 5); - oplen += 5; - } - switch ((*op) & 0x30) - { - case 0x10: - { - opval[1] = extract_op_bits (op_pointer, oplen, 8); - oplen += 8; - opval[1] += op_pointer; - break; - } - case 0x20: - { - opval[1] = extract_op_bits (op_pointer, oplen, 16); - if (! (opval[1] & 32768)) - { - opval[1] += op_pointer; - } - oplen += 16; - break; - } - case 0x30: - { - oplen--; - opval[2] = extract_op_bits (op_pointer, oplen, 12); - oplen += 12; - opval[2] |= 32768; - break; - } - } - if (((*op) & 0x08) && (((*op) & 0x30) != 0x30)) - { - opval[2] = extract_op_bits (op_pointer, oplen, 16); - oplen += 16; - if (! (opval[2] & 32768)) - { - opval[2] += op_pointer; - } - } - return oplen; -} - -/* Returns a non-zero value if the opcode in the main_table list at - PLACE matches OPCODE and is of type TYPE. */ - -static int -opcode_verify (ia64_insn opcode, int place, enum ia64_insn_type type) -{ - if (main_table[place].opcode_type != type) - { - return 0; - } - if (main_table[place].flags - & (IA64_OPCODE_F2_EQ_F3 | IA64_OPCODE_LEN_EQ_64MCNT)) - { - const struct ia64_operand *o1, *o2; - ia64_insn f2, f3; - - if (main_table[place].flags & IA64_OPCODE_F2_EQ_F3) - { - o1 = elf64_ia64_operands + IA64_OPND_F2; - o2 = elf64_ia64_operands + IA64_OPND_F3; - (*o1->extract) (o1, opcode, &f2); - (*o2->extract) (o2, opcode, &f3); - if (f2 != f3) - return 0; - } - else - { - ia64_insn len, count; - - /* length must equal 64-count: */ - o1 = elf64_ia64_operands + IA64_OPND_LEN6; - o2 = elf64_ia64_operands + main_table[place].operands[2]; - (*o1->extract) (o1, opcode, &len); - (*o2->extract) (o2, opcode, &count); - if (len != 64 - count) - return 0; - } - } - return 1; -} - -/* Find an instruction entry in the ia64_dis_names array that matches - opcode OPCODE and is of type TYPE. Returns either a positive index - into the array, or a negative value if an entry for OPCODE could - not be found. Checks all matches and returns the one with the highest - priority. */ - -static int -locate_opcode_ent (ia64_insn opcode, enum ia64_insn_type type) -{ - int currtest[41]; - int bitpos[41]; - int op_ptr[41]; - int currstatenum = 0; - short found_disent = -1; - short found_priority = -1; - - currtest[currstatenum] = 0; - op_ptr[currstatenum] = 0; - bitpos[currstatenum] = 40; - - while (1) - { - int op_pointer = op_ptr[currstatenum]; - unsigned int op; - int currbitnum = bitpos[currstatenum]; - int oplen; - int opval[3] = {0}; - int next_op; - int currbit; - - oplen = extract_op (op_pointer, opval, &op); - - bitpos[currstatenum] = currbitnum; - - /* Skip opval[0] bits in the instruction. */ - if (op & 0x40) - { - currbitnum -= opval[0]; - } - - /* The value of the current bit being tested. */ - currbit = opcode & (((ia64_insn) 1) << currbitnum) ? 1 : 0; - next_op = -1; - - /* We always perform the tests specified in the current state in - a particular order, falling through to the next test if the - previous one failed. */ - switch (currtest[currstatenum]) - { - case 0: - currtest[currstatenum]++; - if (currbit == 0 && (op & 0x80)) - { - /* Check for a zero bit. If this test solely checks for - a zero bit, we can check for up to 8 consecutive zero - bits (the number to check is specified by the lower 3 - bits in the state code.) - - If the state instruction matches, we go to the very - next state instruction; otherwise, try the next test. */ - - if ((op & 0xf8) == 0x80) - { - int count = op & 0x7; - int x; - - for (x = 0; x <= count; x++) - { - int i = - opcode & (((ia64_insn) 1) << (currbitnum - x)) ? 1 : 0; - if (i) - { - break; - } - } - if (x > count) - { - next_op = op_pointer + ((oplen + 7) / 8); - currbitnum -= count; - break; - } - } - else if (! currbit) - { - next_op = op_pointer + ((oplen + 7) / 8); - break; - } - } - /* FALLTHROUGH */ - case 1: - /* If the bit in the instruction is one, go to the state - instruction specified by opval[1]. */ - currtest[currstatenum]++; - if (currbit && (op & 0x30) != 0 && ((op & 0x30) != 0x30)) - { - next_op = opval[1]; - break; - } - /* FALLTHROUGH */ - case 2: - /* Don't care. Skip the current bit and go to the state - instruction specified by opval[2]. - - An encoding of 0x30 is special; this means that a 12-bit - offset into the ia64_dis_names[] array is specified. */ - currtest[currstatenum]++; - if ((op & 0x08) || ((op & 0x30) == 0x30)) - { - next_op = opval[2]; - break; - } - } - - /* If bit 15 is set in the address of the next state, an offset - in the ia64_dis_names array was specified instead. We then - check to see if an entry in the list of opcodes matches the - opcode we were given; if so, we have succeeded. */ - - if ((next_op >= 0) && (next_op & 32768)) - { - short disent = next_op & 32767; - short priority = -1; - - if (next_op > 65535) - { - abort (); - } - - /* Run through the list of opcodes to check, trying to find - one that matches. */ - while (disent >= 0) - { - int place = ia64_dis_names[disent].insn_index; - - priority = ia64_dis_names[disent].priority; - - if (opcode_verify (opcode, place, type) - && priority > found_priority) - { - break; - } - if (ia64_dis_names[disent].next_flag) - { - disent++; - } - else - { - disent = -1; - } - } - - if (disent >= 0) - { - found_disent = disent; - found_priority = priority; - } - /* Try the next test in this state, regardless of whether a match - was found. */ - next_op = -2; - } - - /* next_op == -1 is "back up to the previous state". - next_op == -2 is "stay in this state and try the next test". - Otherwise, transition to the state indicated by next_op. */ - - if (next_op == -1) - { - currstatenum--; - if (currstatenum < 0) - { - return found_disent; - } - } - else if (next_op >= 0) - { - currstatenum++; - bitpos[currstatenum] = currbitnum - 1; - op_ptr[currstatenum] = next_op; - currtest[currstatenum] = 0; - } - } -} - -/* Construct an ia64_opcode entry based on OPCODE, NAME and PLACE. */ - -static struct ia64_opcode * -make_ia64_opcode (ia64_insn opcode, const char *name, int place, int depind) -{ - struct ia64_opcode *res = - (struct ia64_opcode *) malloc (sizeof (struct ia64_opcode)); - res->name = strdup (name); - res->type = main_table[place].opcode_type; - res->num_outputs = main_table[place].num_outputs; - res->opcode = opcode; - res->mask = main_table[place].mask; - res->operands[0] = main_table[place].operands[0]; - res->operands[1] = main_table[place].operands[1]; - res->operands[2] = main_table[place].operands[2]; - res->operands[3] = main_table[place].operands[3]; - res->operands[4] = main_table[place].operands[4]; - res->flags = main_table[place].flags; - res->ent_index = place; - res->dependencies = &op_dependencies[depind]; - return res; -} - -/* Determine the ia64_opcode entry for the opcode specified by INSN - and TYPE. If a valid entry is not found, return NULL. */ -static struct ia64_opcode * -ia64_dis_opcode (ia64_insn insn, enum ia64_insn_type type) -{ - int disent = locate_opcode_ent (insn, type); - - if (disent < 0) - { - return NULL; - } - else - { - unsigned int cb = ia64_dis_names[disent].completer_index; - static char name[128]; - int place = ia64_dis_names[disent].insn_index; - int ci = main_table[place].completers; - ia64_insn tinsn = main_table[place].opcode; - - strcpy (name, ia64_strings [main_table[place].name_index]); - - while (cb) - { - if (cb & 1) - { - int cname = completer_table[ci].name_index; - - tinsn = apply_completer (tinsn, ci); - - if (ia64_strings[cname][0] != '\0') - { - strcat (name, "."); - strcat (name, ia64_strings[cname]); - } - if (cb != 1) - { - ci = completer_table[ci].subentries; - } - } - else - { - ci = completer_table[ci].alternative; - } - if (ci < 0) - { - abort (); - } - cb = cb >> 1; - } - if (tinsn != (insn & main_table[place].mask)) - { - abort (); - } - return make_ia64_opcode (insn, name, place, - completer_table[ci].dependencies); - } -} - -/* Free any resources used by ENT. */ -static void -ia64_free_opcode (struct ia64_opcode *ent) -{ - free ((void *)ent->name); - free (ent); -} - -/* Disassemble ia64 instruction. */ - -/* Return the instruction type for OPCODE found in unit UNIT. */ - -static enum ia64_insn_type -unit_to_type (ia64_insn opcode, enum ia64_unit unit) -{ - enum ia64_insn_type type; - int op; - - op = IA64_OP (opcode); - - if (op >= 8 && (unit == IA64_UNIT_I || unit == IA64_UNIT_M)) - { - type = IA64_TYPE_A; - } - else - { - switch (unit) - { - case IA64_UNIT_I: - type = IA64_TYPE_I; break; - case IA64_UNIT_M: - type = IA64_TYPE_M; break; - case IA64_UNIT_B: - type = IA64_TYPE_B; break; - case IA64_UNIT_F: - type = IA64_TYPE_F; break; - case IA64_UNIT_L: - case IA64_UNIT_X: - type = IA64_TYPE_X; break; - default: - type = -1; - } - } - return type; -} - -int -print_insn_ia64 (bfd_vma memaddr, struct disassemble_info *info) -{ - ia64_insn t0, t1, slot[3], template, s_bit, insn; - int slotnum, j, status, need_comma, retval, slot_multiplier; - const struct ia64_operand *odesc; - const struct ia64_opcode *idesc; - const char *err, *str, *tname; - uint64_t value; - bfd_byte bundle[16]; - enum ia64_unit unit; - char regname[16]; - - if (info->bytes_per_line == 0) - info->bytes_per_line = 6; - info->display_endian = info->endian; - - slot_multiplier = info->bytes_per_line; - retval = slot_multiplier; - - slotnum = (((long) memaddr) & 0xf) / slot_multiplier; - if (slotnum > 2) - return -1; - - memaddr -= (memaddr & 0xf); - status = (*info->read_memory_func) (memaddr, bundle, sizeof (bundle), info); - if (status != 0) - { - (*info->memory_error_func) (status, memaddr, info); - return -1; - } - /* bundles are always in little-endian byte order */ - t0 = bfd_getl64 (bundle); - t1 = bfd_getl64 (bundle + 8); - s_bit = t0 & 1; - template = (t0 >> 1) & 0xf; - slot[0] = (t0 >> 5) & 0x1ffffffffffLL; - slot[1] = ((t0 >> 46) & 0x3ffff) | ((t1 & 0x7fffff) << 18); - slot[2] = (t1 >> 23) & 0x1ffffffffffLL; - - tname = ia64_templ_desc[template].name; - if (slotnum == 0) - (*info->fprintf_func) (info->stream, "[%s] ", tname); - else - (*info->fprintf_func) (info->stream, " "); - - unit = ia64_templ_desc[template].exec_unit[slotnum]; - - if (template == 2 && slotnum == 1) - { - /* skip L slot in MLI template: */ - slotnum = 2; - retval += slot_multiplier; - } - - insn = slot[slotnum]; - - if (unit == IA64_UNIT_NIL) - goto decoding_failed; - - idesc = ia64_dis_opcode (insn, unit_to_type (insn, unit)); - if (idesc == NULL) - goto decoding_failed; - - /* print predicate, if any: */ - - if ((idesc->flags & IA64_OPCODE_NO_PRED) - || (insn & 0x3f) == 0) - (*info->fprintf_func) (info->stream, " "); - else - (*info->fprintf_func) (info->stream, "(p%02d) ", (int)(insn & 0x3f)); - - /* now the actual instruction: */ - - (*info->fprintf_func) (info->stream, "%s", idesc->name); - if (idesc->operands[0]) - (*info->fprintf_func) (info->stream, " "); - - need_comma = 0; - for (j = 0; j < NELEMS (idesc->operands) && idesc->operands[j]; ++j) - { - odesc = elf64_ia64_operands + idesc->operands[j]; - - if (need_comma) - (*info->fprintf_func) (info->stream, ","); - - if (odesc - elf64_ia64_operands == IA64_OPND_IMMU64) - { - /* special case of 64 bit immediate load: */ - value = ((insn >> 13) & 0x7f) | (((insn >> 27) & 0x1ff) << 7) - | (((insn >> 22) & 0x1f) << 16) | (((insn >> 21) & 0x1) << 21) - | (slot[1] << 22) | (((insn >> 36) & 0x1) << 63); - } - else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62) - { - /* 62-bit immediate for nop.x/break.x */ - value = ((slot[1] & 0x1ffffffffffLL) << 21) - | (((insn >> 36) & 0x1) << 20) - | ((insn >> 6) & 0xfffff); - } - else if (odesc - elf64_ia64_operands == IA64_OPND_TGT64) - { - /* 60-bit immediate for long branches. */ - value = (((insn >> 13) & 0xfffff) - | (((insn >> 36) & 1) << 59) - | (((slot[1] >> 2) & 0x7fffffffffLL) << 20)) << 4; - } - else - { - err = (*odesc->extract) (odesc, insn, &value); - if (err) - { - (*info->fprintf_func) (info->stream, "%s", err); - goto done; - } - } - - switch (odesc->class) - { - case IA64_OPND_CLASS_CST: - (*info->fprintf_func) (info->stream, "%s", odesc->str); - break; - - case IA64_OPND_CLASS_REG: - if (odesc->str[0] == 'a' && odesc->str[1] == 'r') - { - switch (value) - { - case 0: case 1: case 2: case 3: - case 4: case 5: case 6: case 7: - sprintf (regname, "ar.k%u", (unsigned int) value); - break; - case 16: strcpy (regname, "ar.rsc"); break; - case 17: strcpy (regname, "ar.bsp"); break; - case 18: strcpy (regname, "ar.bspstore"); break; - case 19: strcpy (regname, "ar.rnat"); break; - case 32: strcpy (regname, "ar.ccv"); break; - case 36: strcpy (regname, "ar.unat"); break; - case 40: strcpy (regname, "ar.fpsr"); break; - case 44: strcpy (regname, "ar.itc"); break; - case 64: strcpy (regname, "ar.pfs"); break; - case 65: strcpy (regname, "ar.lc"); break; - case 66: strcpy (regname, "ar.ec"); break; - default: - sprintf (regname, "ar%u", (unsigned int) value); - break; - } - (*info->fprintf_func) (info->stream, "%s", regname); - } - else - (*info->fprintf_func) (info->stream, "%s%d", odesc->str, (int)value); - break; - - case IA64_OPND_CLASS_IND: - (*info->fprintf_func) (info->stream, "%s[r%d]", odesc->str, (int)value); - break; - - case IA64_OPND_CLASS_ABS: - str = 0; - if (odesc - elf64_ia64_operands == IA64_OPND_MBTYPE4) - switch (value) - { - case 0x0: str = "@brcst"; break; - case 0x8: str = "@mix"; break; - case 0x9: str = "@shuf"; break; - case 0xa: str = "@alt"; break; - case 0xb: str = "@rev"; break; - } - - if (str) - (*info->fprintf_func) (info->stream, "%s", str); - else if (odesc->flags & IA64_OPND_FLAG_DECIMAL_SIGNED) - (*info->fprintf_func) (info->stream, "%" PRId64, - (int64_t) value); - else if (odesc->flags & IA64_OPND_FLAG_DECIMAL_UNSIGNED) - (*info->fprintf_func) (info->stream, "%" PRIu64, - (uint64_t) value); - else - (*info->fprintf_func) (info->stream, "0x%" PRIx64, - (uint64_t) value); - break; - - case IA64_OPND_CLASS_REL: - (*info->print_address_func) (memaddr + value, info); - break; - } - - need_comma = 1; - if (j + 1 == idesc->num_outputs) - { - (*info->fprintf_func) (info->stream, "="); - need_comma = 0; - } - } - if (slotnum + 1 == ia64_templ_desc[template].group_boundary - || ((slotnum == 2) && s_bit)) - (*info->fprintf_func) (info->stream, ";;"); - - done: - ia64_free_opcode ((struct ia64_opcode *)idesc); - failed: - if (slotnum == 2) - retval += 16 - 3*slot_multiplier; - return retval; - - decoding_failed: - (*info->fprintf_func) (info->stream, " data8 %#011llx", (long long) insn); - goto failed; -} diff --git a/include/block/block.h b/include/block/block.h index ab80195378..2ad18775af 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -441,7 +441,6 @@ int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp); bool bdrv_is_sg(BlockDriverState *bs); bool bdrv_is_inserted(BlockDriverState *bs); -int bdrv_media_changed(BlockDriverState *bs); void bdrv_lock_medium(BlockDriverState *bs, bool locked); void bdrv_eject(BlockDriverState *bs, bool eject_flag); const char *bdrv_get_format_name(BlockDriverState *bs); diff --git a/include/block/block_int.h b/include/block/block_int.h index 7816b43a27..ba4c383393 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -87,7 +87,11 @@ struct BlockDriver { const char *format_name; int instance_size; - /* set to true if the BlockDriver is a block filter */ + /* set to true if the BlockDriver is a block filter. Block filters pass + * certain callbacks that refer to data (see block.c) to their bs->file if + * the driver doesn't implement them. Drivers that do not wish to forward + * must implement them and return -ENOTSUP. + */ bool is_filter; /* for snapshots block filter like Quorum can implement the * following recursive callback. @@ -275,7 +279,6 @@ struct BlockDriver { /* removable device specific */ bool (*bdrv_is_inserted)(BlockDriverState *bs); - int (*bdrv_media_changed)(BlockDriverState *bs); void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked); @@ -992,6 +995,24 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, uint64_t perm, uint64_t shared, uint64_t *nperm, uint64_t *nshared); +/* + * Default implementation for drivers to pass bdrv_co_get_block_status() to + * their file. + */ +int64_t coroutine_fn bdrv_co_get_block_status_from_file(BlockDriverState *bs, + int64_t sector_num, + int nb_sectors, + int *pnum, + BlockDriverState **file); +/* + * Default implementation for drivers to pass bdrv_co_get_block_status() to + * their backing file. + */ +int64_t coroutine_fn bdrv_co_get_block_status_from_backing(BlockDriverState *bs, + int64_t sector_num, + int nb_sectors, + int *pnum, + BlockDriverState **file); const char *bdrv_get_parent_name(const BlockDriverState *bs); void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp); bool blk_dev_has_removable_media(BlockBackend *blk); diff --git a/include/block/throttle-groups.h b/include/block/throttle-groups.h index d983d34074..e2fd0513c4 100644 --- a/include/block/throttle-groups.h +++ b/include/block/throttle-groups.h @@ -28,20 +28,58 @@ #include "qemu/throttle.h" #include "block/block_int.h" -const char *throttle_group_get_name(BlockBackend *blk); +/* The ThrottleGroupMember structure indicates membership in a ThrottleGroup + * and holds related data. + */ + +typedef struct ThrottleGroupMember { + AioContext *aio_context; + /* throttled_reqs_lock protects the CoQueues for throttled requests. */ + CoMutex throttled_reqs_lock; + CoQueue throttled_reqs[2]; + + /* Nonzero if the I/O limits are currently being ignored; generally + * it is zero. Accessed with atomic operations. + */ + unsigned int io_limits_disabled; + + /* The following fields are protected by the ThrottleGroup lock. + * See the ThrottleGroup documentation for details. + * throttle_state tells us if I/O limits are configured. */ + ThrottleState *throttle_state; + ThrottleTimers throttle_timers; + unsigned pending_reqs[2]; + QLIST_ENTRY(ThrottleGroupMember) round_robin; + +} ThrottleGroupMember; + +#define TYPE_THROTTLE_GROUP "throttle-group" +#define THROTTLE_GROUP(obj) OBJECT_CHECK(ThrottleGroup, (obj), TYPE_THROTTLE_GROUP) + +const char *throttle_group_get_name(ThrottleGroupMember *tgm); ThrottleState *throttle_group_incref(const char *name); void throttle_group_unref(ThrottleState *ts); -void throttle_group_config(BlockBackend *blk, ThrottleConfig *cfg); -void throttle_group_get_config(BlockBackend *blk, ThrottleConfig *cfg); +void throttle_group_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg); +void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg); -void throttle_group_register_blk(BlockBackend *blk, const char *groupname); -void throttle_group_unregister_blk(BlockBackend *blk); -void throttle_group_restart_blk(BlockBackend *blk); +void throttle_group_register_tgm(ThrottleGroupMember *tgm, + const char *groupname, + AioContext *ctx); +void throttle_group_unregister_tgm(ThrottleGroupMember *tgm); +void throttle_group_restart_tgm(ThrottleGroupMember *tgm); -void coroutine_fn throttle_group_co_io_limits_intercept(BlockBackend *blk, +void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm, unsigned int bytes, bool is_write); +void throttle_group_attach_aio_context(ThrottleGroupMember *tgm, + AioContext *new_context); +void throttle_group_detach_aio_context(ThrottleGroupMember *tgm); +/* + * throttle_group_exists() must be called under the global + * mutex. + */ +bool throttle_group_exists(const char *name); #endif diff --git a/include/exec/exec-all.h b/include/exec/exec-all.h index 440fc31b37..ff8fbe423d 100644 --- a/include/exec/exec-all.h +++ b/include/exec/exec-all.h @@ -35,35 +35,6 @@ typedef abi_ulong tb_page_addr_t; typedef ram_addr_t tb_page_addr_t; #endif -/* DisasContext is_jmp field values - * - * is_jmp starts as DISAS_NEXT. The translator will keep processing - * instructions until an exit condition is reached. If we reach the - * exit condition and is_jmp is still DISAS_NEXT (because of some - * other condition) we simply "jump" to the next address. - * The remaining exit cases are: - * - * DISAS_JUMP - Only the PC was modified dynamically (e.g computed) - * DISAS_TB_JUMP - Only the PC was modified statically (e.g. branch) - * - * In these cases as long as the PC is updated we can chain to the - * next TB either by exiting the loop or looking up the next TB via - * the loookup helper. - * - * DISAS_UPDATE - CPU State was modified dynamically - * - * This covers any other CPU state which necessities us exiting the - * TCG code to the main run-loop. Typically this includes anything - * that might change the interrupt state. - * - * Individual translators may define additional exit cases to deal - * with per-target special conditions. - */ -#define DISAS_NEXT 0 /* next instruction can be analyzed */ -#define DISAS_JUMP 1 /* only pc was modified dynamically */ -#define DISAS_TB_JUMP 2 /* only pc was modified statically */ -#define DISAS_UPDATE 3 /* cpu state was modified dynamically */ - #include "qemu/log.h" void gen_intermediate_code(CPUState *cpu, struct TranslationBlock *tb); diff --git a/include/exec/translator.h b/include/exec/translator.h new file mode 100644 index 0000000000..e2dc2a04ae --- /dev/null +++ b/include/exec/translator.h @@ -0,0 +1,144 @@ +/* + * Generic intermediate code generation. + * + * Copyright (C) 2016-2017 Lluís Vilanova <vilanova@ac.upc.edu> + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#ifndef EXEC__TRANSLATOR_H +#define EXEC__TRANSLATOR_H + +/* + * Include this header from a target-specific file, and add a + * + * DisasContextBase base; + * + * member in your target-specific DisasContext. + */ + + +#include "exec/exec-all.h" +#include "tcg/tcg.h" + + +/** + * DisasJumpType: + * @DISAS_NEXT: Next instruction in program order. + * @DISAS_TOO_MANY: Too many instructions translated. + * @DISAS_NORETURN: Following code is dead. + * @DISAS_TARGET_*: Start of target-specific conditions. + * + * What instruction to disassemble next. + */ +typedef enum DisasJumpType { + DISAS_NEXT, + DISAS_TOO_MANY, + DISAS_NORETURN, + DISAS_TARGET_0, + DISAS_TARGET_1, + DISAS_TARGET_2, + DISAS_TARGET_3, + DISAS_TARGET_4, + DISAS_TARGET_5, + DISAS_TARGET_6, + DISAS_TARGET_7, + DISAS_TARGET_8, + DISAS_TARGET_9, + DISAS_TARGET_10, + DISAS_TARGET_11, +} DisasJumpType; + +/** + * DisasContextBase: + * @tb: Translation block for this disassembly. + * @pc_first: Address of first guest instruction in this TB. + * @pc_next: Address of next guest instruction in this TB (current during + * disassembly). + * @is_jmp: What instruction to disassemble next. + * @num_insns: Number of translated instructions (including current). + * @singlestep_enabled: "Hardware" single stepping enabled. + * + * Architecture-agnostic disassembly context. + */ +typedef struct DisasContextBase { + TranslationBlock *tb; + target_ulong pc_first; + target_ulong pc_next; + DisasJumpType is_jmp; + unsigned int num_insns; + bool singlestep_enabled; +} DisasContextBase; + +/** + * TranslatorOps: + * @init_disas_context: + * Initialize the target-specific portions of DisasContext struct. + * The generic DisasContextBase has already been initialized. + * Return max_insns, modified as necessary by db->tb->flags. + * + * @tb_start: + * Emit any code required before the start of the main loop, + * after the generic gen_tb_start(). + * + * @insn_start: + * Emit the tcg_gen_insn_start opcode. + * + * @breakpoint_check: + * When called, the breakpoint has already been checked to match the PC, + * but the target may decide the breakpoint missed the address + * (e.g., due to conditions encoded in their flags). Return true to + * indicate that the breakpoint did hit, in which case no more breakpoints + * are checked. If the breakpoint did hit, emit any code required to + * signal the exception, and set db->is_jmp as necessary to terminate + * the main loop. + * + * @translate_insn: + * Disassemble one instruction and set db->pc_next for the start + * of the following instruction. Set db->is_jmp as necessary to + * terminate the main loop. + * + * @tb_stop: + * Emit any opcodes required to exit the TB, based on db->is_jmp. + * + * @disas_log: + * Print instruction disassembly to log. + */ +typedef struct TranslatorOps { + int (*init_disas_context)(DisasContextBase *db, CPUState *cpu, + int max_insns); + void (*tb_start)(DisasContextBase *db, CPUState *cpu); + void (*insn_start)(DisasContextBase *db, CPUState *cpu); + bool (*breakpoint_check)(DisasContextBase *db, CPUState *cpu, + const CPUBreakpoint *bp); + void (*translate_insn)(DisasContextBase *db, CPUState *cpu); + void (*tb_stop)(DisasContextBase *db, CPUState *cpu); + void (*disas_log)(const DisasContextBase *db, CPUState *cpu); +} TranslatorOps; + +/** + * translator_loop: + * @ops: Target-specific operations. + * @db: Disassembly context. + * @cpu: Target vCPU. + * @tb: Translation block. + * + * Generic translator loop. + * + * Translation will stop in the following cases (in order): + * - When is_jmp set by #TranslatorOps::breakpoint_check. + * - set to DISAS_TOO_MANY exits after translating one more insn + * - set to any other value than DISAS_NEXT exits immediately. + * - When is_jmp set by #TranslatorOps::translate_insn. + * - set to any value other than DISAS_NEXT exits immediately. + * - When the TCG operation buffer is full. + * - When single-stepping is enabled (system-wide or on the current vCPU). + * - When too many instructions have been translated. + */ +void translator_loop(const TranslatorOps *ops, DisasContextBase *db, + CPUState *cpu, TranslationBlock *tb); + +void translator_loop_temp_check(DisasContextBase *db); + +#endif /* EXEC__TRANSLATOR_H */ diff --git a/include/qemu/iov.h b/include/qemu/iov.h index bd9fd55b0a..72d4c559b4 100644 --- a/include/qemu/iov.h +++ b/include/qemu/iov.h @@ -31,11 +31,6 @@ size_t iov_size(const struct iovec *iov, const unsigned int iov_cnt); * Number of bytes actually copied will be returned, which is * min(bytes, iov_size(iov)-offset) * `Offset' must point to the inside of iovec. - * It is okay to use very large value for `bytes' since we're - * limited by the size of the iovec anyway, provided that the - * buffer pointed to by buf has enough space. One possible - * such "large" value is -1 (sinice size_t is unsigned), - * so specifying `-1' as `bytes' means 'up to the end of iovec'. */ size_t iov_from_buf_full(const struct iovec *iov, unsigned int iov_cnt, size_t offset, const void *buf, size_t bytes); @@ -76,7 +71,6 @@ iov_to_buf(const struct iovec *iov, const unsigned int iov_cnt, * up to the end of it, will be filled with the specified value. * Function return actual number of bytes processed, which is * min(size, iov_size(iov) - offset). - * Again, it is okay to use large value for `bytes' to mean "up to the end". */ size_t iov_memset(const struct iovec *iov, const unsigned int iov_cnt, size_t offset, int fillc, size_t bytes); diff --git a/include/qemu/throttle-options.h b/include/qemu/throttle-options.h index 3133d1ca40..3528a8f4a2 100644 --- a/include/qemu/throttle-options.h +++ b/include/qemu/throttle-options.h @@ -10,81 +10,103 @@ #ifndef THROTTLE_OPTIONS_H #define THROTTLE_OPTIONS_H +#define QEMU_OPT_IOPS_TOTAL "iops-total" +#define QEMU_OPT_IOPS_TOTAL_MAX "iops-total-max" +#define QEMU_OPT_IOPS_TOTAL_MAX_LENGTH "iops-total-max-length" +#define QEMU_OPT_IOPS_READ "iops-read" +#define QEMU_OPT_IOPS_READ_MAX "iops-read-max" +#define QEMU_OPT_IOPS_READ_MAX_LENGTH "iops-read-max-length" +#define QEMU_OPT_IOPS_WRITE "iops-write" +#define QEMU_OPT_IOPS_WRITE_MAX "iops-write-max" +#define QEMU_OPT_IOPS_WRITE_MAX_LENGTH "iops-write-max-length" +#define QEMU_OPT_BPS_TOTAL "bps-total" +#define QEMU_OPT_BPS_TOTAL_MAX "bps-total-max" +#define QEMU_OPT_BPS_TOTAL_MAX_LENGTH "bps-total-max-length" +#define QEMU_OPT_BPS_READ "bps-read" +#define QEMU_OPT_BPS_READ_MAX "bps-read-max" +#define QEMU_OPT_BPS_READ_MAX_LENGTH "bps-read-max-length" +#define QEMU_OPT_BPS_WRITE "bps-write" +#define QEMU_OPT_BPS_WRITE_MAX "bps-write-max" +#define QEMU_OPT_BPS_WRITE_MAX_LENGTH "bps-write-max-length" +#define QEMU_OPT_IOPS_SIZE "iops-size" +#define QEMU_OPT_THROTTLE_GROUP_NAME "throttle-group" + +#define THROTTLE_OPT_PREFIX "throttling." #define THROTTLE_OPTS \ { \ - .name = "throttling.iops-total",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL,\ .type = QEMU_OPT_NUMBER,\ .help = "limit total I/O operations per second",\ },{ \ - .name = "throttling.iops-read",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ,\ .type = QEMU_OPT_NUMBER,\ .help = "limit read operations per second",\ },{ \ - .name = "throttling.iops-write",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE,\ .type = QEMU_OPT_NUMBER,\ .help = "limit write operations per second",\ },{ \ - .name = "throttling.bps-total",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL,\ .type = QEMU_OPT_NUMBER,\ .help = "limit total bytes per second",\ },{ \ - .name = "throttling.bps-read",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ,\ .type = QEMU_OPT_NUMBER,\ .help = "limit read bytes per second",\ },{ \ - .name = "throttling.bps-write",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE,\ .type = QEMU_OPT_NUMBER,\ .help = "limit write bytes per second",\ },{ \ - .name = "throttling.iops-total-max",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX,\ .type = QEMU_OPT_NUMBER,\ .help = "I/O operations burst",\ },{ \ - .name = "throttling.iops-read-max",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX,\ .type = QEMU_OPT_NUMBER,\ .help = "I/O operations read burst",\ },{ \ - .name = "throttling.iops-write-max",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX,\ .type = QEMU_OPT_NUMBER,\ .help = "I/O operations write burst",\ },{ \ - .name = "throttling.bps-total-max",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX,\ .type = QEMU_OPT_NUMBER,\ .help = "total bytes burst",\ },{ \ - .name = "throttling.bps-read-max",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX,\ .type = QEMU_OPT_NUMBER,\ .help = "total bytes read burst",\ },{ \ - .name = "throttling.bps-write-max",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX,\ .type = QEMU_OPT_NUMBER,\ .help = "total bytes write burst",\ },{ \ - .name = "throttling.iops-total-max-length",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX_LENGTH,\ .type = QEMU_OPT_NUMBER,\ .help = "length of the iops-total-max burst period, in seconds",\ },{ \ - .name = "throttling.iops-read-max-length",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX_LENGTH,\ .type = QEMU_OPT_NUMBER,\ .help = "length of the iops-read-max burst period, in seconds",\ },{ \ - .name = "throttling.iops-write-max-length",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX_LENGTH,\ .type = QEMU_OPT_NUMBER,\ .help = "length of the iops-write-max burst period, in seconds",\ },{ \ - .name = "throttling.bps-total-max-length",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX_LENGTH,\ .type = QEMU_OPT_NUMBER,\ .help = "length of the bps-total-max burst period, in seconds",\ },{ \ - .name = "throttling.bps-read-max-length",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX_LENGTH,\ .type = QEMU_OPT_NUMBER,\ .help = "length of the bps-read-max burst period, in seconds",\ },{ \ - .name = "throttling.bps-write-max-length",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX_LENGTH,\ .type = QEMU_OPT_NUMBER,\ .help = "length of the bps-write-max burst period, in seconds",\ },{ \ - .name = "throttling.iops-size",\ + .name = THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_SIZE,\ .type = QEMU_OPT_NUMBER,\ .help = "when limiting by iops max size of an I/O in bytes",\ } diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h index 8e01885d29..8c93237866 100644 --- a/include/qemu/throttle.h +++ b/include/qemu/throttle.h @@ -152,5 +152,8 @@ bool throttle_schedule_timer(ThrottleState *ts, bool is_write); void throttle_account(ThrottleState *ts, bool is_write, uint64_t size); +void throttle_limits_to_config(ThrottleLimits *arg, ThrottleConfig *cfg, + Error **errp); +void throttle_config_to_limits(ThrottleConfig *cfg, ThrottleLimits *var); #endif diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h index aadc733daf..c4e52a5fa3 100644 --- a/include/sysemu/block-backend.h +++ b/include/sysemu/block-backend.h @@ -70,24 +70,10 @@ typedef struct BlockDevOps { /* This struct is embedded in (the private) BlockBackend struct and contains * fields that must be public. This is in particular for QLIST_ENTRY() and - * friends so that BlockBackends can be kept in lists outside block-backend.c */ + * friends so that BlockBackends can be kept in lists outside block-backend.c + * */ typedef struct BlockBackendPublic { - /* throttled_reqs_lock protects the CoQueues for throttled requests. */ - CoMutex throttled_reqs_lock; - CoQueue throttled_reqs[2]; - - /* Nonzero if the I/O limits are currently being ignored; generally - * it is zero. Accessed with atomic operations. - */ - unsigned int io_limits_disabled; - - /* The following fields are protected by the ThrottleGroup lock. - * See the ThrottleGroup documentation for details. - * throttle_state tells us if I/O limits are configured. */ - ThrottleState *throttle_state; - ThrottleTimers throttle_timers; - unsigned pending_reqs[2]; - QLIST_ENTRY(BlockBackendPublic) round_robin; + ThrottleGroupMember throttle_group_member; } BlockBackendPublic; BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm); diff --git a/qapi/block-core.json b/qapi/block-core.json index 28abb9e6cf..bb11815608 100644 --- a/qapi/block-core.json +++ b/qapi/block-core.json @@ -1906,6 +1906,54 @@ '*iops_size': 'int', '*group': 'str' } } ## +# @ThrottleLimits: +# +# Limit parameters for throttling. +# Since some limit combinations are illegal, limits should always be set in one +# transaction. All fields are optional. When setting limits, if a field is +# missing the current value is not changed. +# +# @iops-total: limit total I/O operations per second +# @iops-total-max: I/O operations burst +# @iops-total-max-length: length of the iops-total-max burst period, in seconds +# It must only be set if @iops-total-max is set as well. +# @iops-read: limit read operations per second +# @iops-read-max: I/O operations read burst +# @iops-read-max-length: length of the iops-read-max burst period, in seconds +# It must only be set if @iops-read-max is set as well. +# @iops-write: limit write operations per second +# @iops-write-max: I/O operations write burst +# @iops-write-max-length: length of the iops-write-max burst period, in seconds +# It must only be set if @iops-write-max is set as well. +# @bps-total: limit total bytes per second +# @bps-total-max: total bytes burst +# @bps-total-max-length: length of the bps-total-max burst period, in seconds. +# It must only be set if @bps-total-max is set as well. +# @bps-read: limit read bytes per second +# @bps-read-max: total bytes read burst +# @bps-read-max-length: length of the bps-read-max burst period, in seconds +# It must only be set if @bps-read-max is set as well. +# @bps-write: limit write bytes per second +# @bps-write-max: total bytes write burst +# @bps-write-max-length: length of the bps-write-max burst period, in seconds +# It must only be set if @bps-write-max is set as well. +# @iops-size: when limiting by iops max size of an I/O in bytes +# +# Since: 2.11 +## +{ 'struct': 'ThrottleLimits', + 'data': { '*iops-total' : 'int', '*iops-total-max' : 'int', + '*iops-total-max-length' : 'int', '*iops-read' : 'int', + '*iops-read-max' : 'int', '*iops-read-max-length' : 'int', + '*iops-write' : 'int', '*iops-write-max' : 'int', + '*iops-write-max-length' : 'int', '*bps-total' : 'int', + '*bps-total-max' : 'int', '*bps-total-max-length' : 'int', + '*bps-read' : 'int', '*bps-read-max' : 'int', + '*bps-read-max-length' : 'int', '*bps-write' : 'int', + '*bps-write-max' : 'int', '*bps-write-max-length' : 'int', + '*iops-size' : 'int' } } + +## # @block-stream: # # Copy data from a backing file into a block device. @@ -2175,6 +2223,7 @@ # Drivers that are supported in block device operations. # # @vxhs: Since 2.10 +# @throttle: Since 2.11 # # Since: 2.9 ## @@ -2184,7 +2233,7 @@ 'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs', 'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh', - 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] } + 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] } ## # @BlockdevOptionsFile: @@ -3048,6 +3097,20 @@ '*tls-creds': 'str' } } ## +# @BlockdevOptionsThrottle: +# +# Driver specific block device options for the throttle driver +# +# @throttle-group: the name of the throttle-group object to use. It +# must already exist. +# @file: reference to or definition of the data source block device +# Since: 2.11 +## +{ 'struct': 'BlockdevOptionsThrottle', + 'data': { 'throttle-group': 'str', + 'file' : 'BlockdevRef' + } } +## # @BlockdevOptions: # # Options for creating a block device. Many options are available for all @@ -3108,6 +3171,7 @@ 'replication':'BlockdevOptionsReplication', 'sheepdog': 'BlockdevOptionsSheepdog', 'ssh': 'BlockdevOptionsSsh', + 'throttle': 'BlockdevOptionsThrottle', 'vdi': 'BlockdevOptionsGenericFormat', 'vhdx': 'BlockdevOptionsGenericFormat', 'vmdk': 'BlockdevOptionsGenericCOWFormat', diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c index cb44632d16..9017e30510 100644 --- a/target/arm/translate-a64.c +++ b/target/arm/translate-a64.c @@ -304,7 +304,7 @@ static void gen_exception_internal_insn(DisasContext *s, int offset, int excp) { gen_a64_set_pc_im(s->pc - offset); gen_exception_internal(excp); - s->is_jmp = DISAS_EXC; + s->base.is_jmp = DISAS_NORETURN; } static void gen_exception_insn(DisasContext *s, int offset, int excp, @@ -312,7 +312,7 @@ static void gen_exception_insn(DisasContext *s, int offset, int excp, { gen_a64_set_pc_im(s->pc - offset); gen_exception(excp, syndrome, target_el); - s->is_jmp = DISAS_EXC; + s->base.is_jmp = DISAS_NORETURN; } static void gen_ss_advance(DisasContext *s) @@ -340,7 +340,7 @@ static void gen_step_complete_exception(DisasContext *s) gen_ss_advance(s); gen_exception(EXCP_UDEF, syn_swstep(s->ss_same_el, 1, s->is_ldex), default_exception_el(s)); - s->is_jmp = DISAS_EXC; + s->base.is_jmp = DISAS_NORETURN; } static inline bool use_goto_tb(DisasContext *s, int n, uint64_t dest) @@ -348,13 +348,13 @@ static inline bool use_goto_tb(DisasContext *s, int n, uint64_t dest) /* No direct tb linking with singlestep (either QEMU's or the ARM * debug architecture kind) or deterministic io */ - if (s->singlestep_enabled || s->ss_active || (s->tb->cflags & CF_LAST_IO)) { + if (s->base.singlestep_enabled || s->ss_active || (s->base.tb->cflags & CF_LAST_IO)) { return false; } #ifndef CONFIG_USER_ONLY /* Only link tbs from inside the same guest page */ - if ((s->tb->pc & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) { + if ((s->base.tb->pc & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) { return false; } #endif @@ -366,21 +366,21 @@ static inline void gen_goto_tb(DisasContext *s, int n, uint64_t dest) { TranslationBlock *tb; - tb = s->tb; + tb = s->base.tb; if (use_goto_tb(s, n, dest)) { tcg_gen_goto_tb(n); gen_a64_set_pc_im(dest); tcg_gen_exit_tb((intptr_t)tb + n); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } else { gen_a64_set_pc_im(dest); if (s->ss_active) { gen_step_complete_exception(s); - } else if (s->singlestep_enabled) { + } else if (s->base.singlestep_enabled) { gen_exception_internal(EXCP_DEBUG); } else { tcg_gen_lookup_and_goto_ptr(cpu_pc); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } } } @@ -1331,16 +1331,16 @@ static void handle_hint(DisasContext *s, uint32_t insn, case 0: /* NOP */ return; case 3: /* WFI */ - s->is_jmp = DISAS_WFI; + s->base.is_jmp = DISAS_WFI; return; case 1: /* YIELD */ if (!parallel_cpus) { - s->is_jmp = DISAS_YIELD; + s->base.is_jmp = DISAS_YIELD; } return; case 2: /* WFE */ if (!parallel_cpus) { - s->is_jmp = DISAS_WFE; + s->base.is_jmp = DISAS_WFE; } return; case 4: /* SEV */ @@ -1424,7 +1424,7 @@ static void handle_msr_i(DisasContext *s, uint32_t insn, tcg_temp_free_i32(tcg_op); /* For DAIFClear, exit the cpu loop to re-evaluate pending IRQs. */ gen_a64_set_pc_im(s->pc); - s->is_jmp = (op == 0x1f ? DISAS_EXIT : DISAS_JUMP); + s->base.is_jmp = (op == 0x1f ? DISAS_EXIT : DISAS_JUMP); break; } default: @@ -1559,7 +1559,7 @@ static void handle_sys(DisasContext *s, uint32_t insn, bool isread, break; } - if ((s->tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { + if ((s->base.tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { gen_io_start(); } @@ -1590,16 +1590,16 @@ static void handle_sys(DisasContext *s, uint32_t insn, bool isread, } } - if ((s->tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { + if ((s->base.tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { /* I/O operations must end the TB here (whether read or write) */ gen_io_end(); - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } else if (!isread && !(ri->type & ARM_CP_SUPPRESS_TB_END)) { /* We default to ending the TB on a coprocessor register write, * but allow this to be suppressed by the register definition * (usually only necessary to work around guest bugs). */ - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } } @@ -1789,7 +1789,7 @@ static void disas_uncond_b_reg(DisasContext *s, uint32_t insn) } gen_helper_exception_return(cpu_env); /* Must exit loop to check un-masked IRQs */ - s->is_jmp = DISAS_EXIT; + s->base.is_jmp = DISAS_EXIT; return; case 5: /* DRPS */ if (rn != 0x1f) { @@ -1803,7 +1803,7 @@ static void disas_uncond_b_reg(DisasContext *s, uint32_t insn) return; } - s->is_jmp = DISAS_JUMP; + s->base.is_jmp = DISAS_JUMP; } /* C3.2 Branches, exception generating and system instructions */ @@ -11200,23 +11200,15 @@ static void disas_a64_insn(CPUARMState *env, DisasContext *s) free_tmp_a64(s); } -void gen_intermediate_code_a64(CPUState *cs, TranslationBlock *tb) +static int aarch64_tr_init_disas_context(DisasContextBase *dcbase, + CPUState *cpu, int max_insns) { - CPUARMState *env = cs->env_ptr; - ARMCPU *cpu = arm_env_get_cpu(env); - DisasContext dc1, *dc = &dc1; - target_ulong pc_start; - target_ulong next_page_start; - int num_insns; - int max_insns; + DisasContext *dc = container_of(dcbase, DisasContext, base); + CPUARMState *env = cpu->env_ptr; + ARMCPU *arm_cpu = arm_env_get_cpu(env); + int bound; - pc_start = tb->pc; - - dc->tb = tb; - - dc->is_jmp = DISAS_NEXT; - dc->pc = pc_start; - dc->singlestep_enabled = cs->singlestep_enabled; + dc->pc = dc->base.pc_first; dc->condjmp = 0; dc->aarch64 = 1; @@ -11227,20 +11219,20 @@ void gen_intermediate_code_a64(CPUState *cs, TranslationBlock *tb) !arm_el_is_aa64(env, 3); dc->thumb = 0; dc->sctlr_b = 0; - dc->be_data = ARM_TBFLAG_BE_DATA(tb->flags) ? MO_BE : MO_LE; + dc->be_data = ARM_TBFLAG_BE_DATA(dc->base.tb->flags) ? MO_BE : MO_LE; dc->condexec_mask = 0; dc->condexec_cond = 0; - dc->mmu_idx = core_to_arm_mmu_idx(env, ARM_TBFLAG_MMUIDX(tb->flags)); - dc->tbi0 = ARM_TBFLAG_TBI0(tb->flags); - dc->tbi1 = ARM_TBFLAG_TBI1(tb->flags); + dc->mmu_idx = core_to_arm_mmu_idx(env, ARM_TBFLAG_MMUIDX(dc->base.tb->flags)); + dc->tbi0 = ARM_TBFLAG_TBI0(dc->base.tb->flags); + dc->tbi1 = ARM_TBFLAG_TBI1(dc->base.tb->flags); dc->current_el = arm_mmu_idx_to_el(dc->mmu_idx); #if !defined(CONFIG_USER_ONLY) dc->user = (dc->current_el == 0); #endif - dc->fp_excp_el = ARM_TBFLAG_FPEXC_EL(tb->flags); + dc->fp_excp_el = ARM_TBFLAG_FPEXC_EL(dc->base.tb->flags); dc->vec_len = 0; dc->vec_stride = 0; - dc->cp_regs = cpu->cp_regs; + dc->cp_regs = arm_cpu->cp_regs; dc->features = env->features; /* Single step state. The code-generation logic here is: @@ -11258,127 +11250,131 @@ void gen_intermediate_code_a64(CPUState *cs, TranslationBlock *tb) * emit code to generate a software step exception * end the TB */ - dc->ss_active = ARM_TBFLAG_SS_ACTIVE(tb->flags); - dc->pstate_ss = ARM_TBFLAG_PSTATE_SS(tb->flags); + dc->ss_active = ARM_TBFLAG_SS_ACTIVE(dc->base.tb->flags); + dc->pstate_ss = ARM_TBFLAG_PSTATE_SS(dc->base.tb->flags); dc->is_ldex = false; dc->ss_same_el = (arm_debug_target_el(env) == dc->current_el); - init_tmp_a64_array(dc); + /* Bound the number of insns to execute to those left on the page. */ + bound = -(dc->base.pc_first | TARGET_PAGE_MASK) / 4; - next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE; - num_insns = 0; - max_insns = tb->cflags & CF_COUNT_MASK; - if (max_insns == 0) { - max_insns = CF_COUNT_MASK; - } - if (max_insns > TCG_MAX_INSNS) { - max_insns = TCG_MAX_INSNS; + /* If architectural single step active, limit to 1. */ + if (dc->ss_active) { + bound = 1; } + max_insns = MIN(max_insns, bound); - gen_tb_start(tb); + init_tmp_a64_array(dc); + return max_insns; +} + +static void aarch64_tr_tb_start(DisasContextBase *db, CPUState *cpu) +{ tcg_clear_temp_count(); +} - do { - dc->insn_start_idx = tcg_op_buf_count(); - tcg_gen_insn_start(dc->pc, 0, 0); - num_insns++; - - if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) { - CPUBreakpoint *bp; - QTAILQ_FOREACH(bp, &cs->breakpoints, entry) { - if (bp->pc == dc->pc) { - if (bp->flags & BP_CPU) { - gen_a64_set_pc_im(dc->pc); - gen_helper_check_breakpoints(cpu_env); - /* End the TB early; it likely won't be executed */ - dc->is_jmp = DISAS_UPDATE; - } else { - gen_exception_internal_insn(dc, 0, EXCP_DEBUG); - /* The address covered by the breakpoint must be - included in [tb->pc, tb->pc + tb->size) in order - to for it to be properly cleared -- thus we - increment the PC here so that the logic setting - tb->size below does the right thing. */ - dc->pc += 4; - goto done_generating; - } - break; - } - } - } +static void aarch64_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); - if (num_insns == max_insns && (tb->cflags & CF_LAST_IO)) { - gen_io_start(); - } + dc->insn_start_idx = tcg_op_buf_count(); + tcg_gen_insn_start(dc->pc, 0, 0); +} - if (dc->ss_active && !dc->pstate_ss) { - /* Singlestep state is Active-pending. - * If we're in this state at the start of a TB then either - * a) we just took an exception to an EL which is being debugged - * and this is the first insn in the exception handler - * b) debug exceptions were masked and we just unmasked them - * without changing EL (eg by clearing PSTATE.D) - * In either case we're going to take a swstep exception in the - * "did not step an insn" case, and so the syndrome ISV and EX - * bits should be zero. - */ - assert(num_insns == 1); - gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0), - default_exception_el(dc)); - dc->is_jmp = DISAS_EXC; - break; - } +static bool aarch64_tr_breakpoint_check(DisasContextBase *dcbase, CPUState *cpu, + const CPUBreakpoint *bp) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); - disas_a64_insn(env, dc); + if (bp->flags & BP_CPU) { + gen_a64_set_pc_im(dc->pc); + gen_helper_check_breakpoints(cpu_env); + /* End the TB early; it likely won't be executed */ + dc->base.is_jmp = DISAS_TOO_MANY; + } else { + gen_exception_internal_insn(dc, 0, EXCP_DEBUG); + /* The address covered by the breakpoint must be + included in [tb->pc, tb->pc + tb->size) in order + to for it to be properly cleared -- thus we + increment the PC here so that the logic setting + tb->size below does the right thing. */ + dc->pc += 4; + dc->base.is_jmp = DISAS_NORETURN; + } - if (tcg_check_temp_count()) { - fprintf(stderr, "TCG temporary leak before "TARGET_FMT_lx"\n", - dc->pc); - } + return true; +} + +static void aarch64_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + CPUARMState *env = cpu->env_ptr; - /* Translation stops when a conditional branch is encountered. - * Otherwise the subsequent code could get translated several times. - * Also stop translation when a page boundary is reached. This - * ensures prefetch aborts occur at the right place. + if (dc->ss_active && !dc->pstate_ss) { + /* Singlestep state is Active-pending. + * If we're in this state at the start of a TB then either + * a) we just took an exception to an EL which is being debugged + * and this is the first insn in the exception handler + * b) debug exceptions were masked and we just unmasked them + * without changing EL (eg by clearing PSTATE.D) + * In either case we're going to take a swstep exception in the + * "did not step an insn" case, and so the syndrome ISV and EX + * bits should be zero. */ - } while (!dc->is_jmp && !tcg_op_buf_full() && - !cs->singlestep_enabled && - !singlestep && - !dc->ss_active && - dc->pc < next_page_start && - num_insns < max_insns); - - if (tb->cflags & CF_LAST_IO) { - gen_io_end(); + assert(dc->base.num_insns == 1); + gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0), + default_exception_el(dc)); + dc->base.is_jmp = DISAS_NORETURN; + } else { + disas_a64_insn(env, dc); } - if (unlikely(cs->singlestep_enabled || dc->ss_active) - && dc->is_jmp != DISAS_EXC) { + dc->base.pc_next = dc->pc; + translator_loop_temp_check(&dc->base); +} + +static void aarch64_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + if (unlikely(dc->base.singlestep_enabled || dc->ss_active)) { /* Note that this means single stepping WFI doesn't halt the CPU. * For conditional branch insns this is harmless unreachable code as * gen_goto_tb() has already handled emitting the debug exception * (and thus a tb-jump is not possible when singlestepping). */ - assert(dc->is_jmp != DISAS_TB_JUMP); - if (dc->is_jmp != DISAS_JUMP) { + switch (dc->base.is_jmp) { + default: gen_a64_set_pc_im(dc->pc); - } - if (cs->singlestep_enabled) { - gen_exception_internal(EXCP_DEBUG); - } else { - gen_step_complete_exception(dc); + /* fall through */ + case DISAS_JUMP: + if (dc->base.singlestep_enabled) { + gen_exception_internal(EXCP_DEBUG); + } else { + gen_step_complete_exception(dc); + } + break; + case DISAS_NORETURN: + break; } } else { - switch (dc->is_jmp) { + switch (dc->base.is_jmp) { case DISAS_NEXT: + case DISAS_TOO_MANY: gen_goto_tb(dc, 1, dc->pc); break; + default: + case DISAS_UPDATE: + gen_a64_set_pc_im(dc->pc); + /* fall through */ case DISAS_JUMP: tcg_gen_lookup_and_goto_ptr(cpu_pc); break; - case DISAS_TB_JUMP: - case DISAS_EXC: + case DISAS_EXIT: + tcg_gen_exit_tb(0); + break; + case DISAS_NORETURN: case DISAS_SWI: break; case DISAS_WFE: @@ -11400,31 +11396,29 @@ void gen_intermediate_code_a64(CPUState *cs, TranslationBlock *tb) */ tcg_gen_exit_tb(0); break; - case DISAS_UPDATE: - gen_a64_set_pc_im(dc->pc); - /* fall through */ - case DISAS_EXIT: - default: - tcg_gen_exit_tb(0); - break; } } -done_generating: - gen_tb_end(tb, num_insns); + /* Functions above can change dc->pc, so re-align db->pc_next */ + dc->base.pc_next = dc->pc; +} -#ifdef DEBUG_DISAS - if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) && - qemu_log_in_addr_range(pc_start)) { - qemu_log_lock(); - qemu_log("----------------\n"); - qemu_log("IN: %s\n", lookup_symbol(pc_start)); - log_target_disas(cs, pc_start, dc->pc - pc_start, - 4 | (bswap_code(dc->sctlr_b) ? 2 : 0)); - qemu_log("\n"); - qemu_log_unlock(); - } -#endif - tb->size = dc->pc - pc_start; - tb->icount = num_insns; +static void aarch64_tr_disas_log(const DisasContextBase *dcbase, + CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + qemu_log("IN: %s\n", lookup_symbol(dc->base.pc_first)); + log_target_disas(cpu, dc->base.pc_first, dc->base.tb->size, + 4 | (bswap_code(dc->sctlr_b) ? 2 : 0)); } + +const TranslatorOps aarch64_translator_ops = { + .init_disas_context = aarch64_tr_init_disas_context, + .tb_start = aarch64_tr_tb_start, + .insn_start = aarch64_tr_insn_start, + .breakpoint_check = aarch64_tr_breakpoint_check, + .translate_insn = aarch64_tr_translate_insn, + .tb_stop = aarch64_tr_tb_stop, + .disas_log = aarch64_tr_disas_log, +}; diff --git a/target/arm/translate.c b/target/arm/translate.c index e52a6d7622..6946e56a3a 100644 --- a/target/arm/translate.c +++ b/target/arm/translate.c @@ -224,7 +224,7 @@ static void store_reg(DisasContext *s, int reg, TCGv_i32 var) * We choose to ignore [1:0] in ARM mode for all architecture versions. */ tcg_gen_andi_i32(var, var, s->thumb ? ~1 : ~3); - s->is_jmp = DISAS_JUMP; + s->base.is_jmp = DISAS_JUMP; } tcg_gen_mov_i32(cpu_R[reg], var); tcg_temp_free_i32(var); @@ -297,7 +297,7 @@ static void gen_step_complete_exception(DisasContext *s) gen_ss_advance(s); gen_exception(EXCP_UDEF, syn_swstep(s->ss_same_el, 1, s->is_ldex), default_exception_el(s)); - s->is_jmp = DISAS_EXC; + s->base.is_jmp = DISAS_NORETURN; } static void gen_singlestep_exception(DisasContext *s) @@ -321,7 +321,7 @@ static inline bool is_singlestepping(DisasContext *s) * misnamed as it only means "one instruction per TB" and doesn't * affect the code we generate. */ - return s->singlestep_enabled || s->ss_active; + return s->base.singlestep_enabled || s->ss_active; } static void gen_smul_dual(TCGv_i32 a, TCGv_i32 b) @@ -930,7 +930,7 @@ static inline void gen_bx_im(DisasContext *s, uint32_t addr) { TCGv_i32 tmp; - s->is_jmp = DISAS_JUMP; + s->base.is_jmp = DISAS_JUMP; if (s->thumb != (addr & 1)) { tmp = tcg_temp_new_i32(); tcg_gen_movi_i32(tmp, addr & 1); @@ -943,7 +943,7 @@ static inline void gen_bx_im(DisasContext *s, uint32_t addr) /* Set PC and Thumb state from var. var is marked as dead. */ static inline void gen_bx(DisasContext *s, TCGv_i32 var) { - s->is_jmp = DISAS_JUMP; + s->base.is_jmp = DISAS_JUMP; tcg_gen_andi_i32(cpu_R[15], var, ~1); tcg_gen_andi_i32(var, var, 1); store_cpu_field(var, thumb); @@ -957,11 +957,11 @@ static inline void gen_bx(DisasContext *s, TCGv_i32 var) static inline void gen_bx_excret(DisasContext *s, TCGv_i32 var) { /* Generate the same code here as for a simple bx, but flag via - * s->is_jmp that we need to do the rest of the work later. + * s->base.is_jmp that we need to do the rest of the work later. */ gen_bx(s, var); if (s->v7m_handler_mode && arm_dc_feature(s, ARM_FEATURE_M)) { - s->is_jmp = DISAS_BX_EXCRET; + s->base.is_jmp = DISAS_BX_EXCRET; } } @@ -1161,7 +1161,7 @@ static inline void gen_hvc(DisasContext *s, int imm16) */ s->svc_imm = imm16; gen_set_pc_im(s, s->pc); - s->is_jmp = DISAS_HVC; + s->base.is_jmp = DISAS_HVC; } static inline void gen_smc(DisasContext *s) @@ -1176,7 +1176,7 @@ static inline void gen_smc(DisasContext *s) gen_helper_pre_smc(cpu_env, tmp); tcg_temp_free_i32(tmp); gen_set_pc_im(s, s->pc); - s->is_jmp = DISAS_SMC; + s->base.is_jmp = DISAS_SMC; } static void gen_exception_internal_insn(DisasContext *s, int offset, int excp) @@ -1184,7 +1184,7 @@ static void gen_exception_internal_insn(DisasContext *s, int offset, int excp) gen_set_condexec(s); gen_set_pc_im(s, s->pc - offset); gen_exception_internal(excp); - s->is_jmp = DISAS_EXC; + s->base.is_jmp = DISAS_NORETURN; } static void gen_exception_insn(DisasContext *s, int offset, int excp, @@ -1193,14 +1193,14 @@ static void gen_exception_insn(DisasContext *s, int offset, int excp, gen_set_condexec(s); gen_set_pc_im(s, s->pc - offset); gen_exception(excp, syn, target_el); - s->is_jmp = DISAS_EXC; + s->base.is_jmp = DISAS_NORETURN; } /* Force a TB lookup after an instruction that changes the CPU state. */ static inline void gen_lookup_tb(DisasContext *s) { tcg_gen_movi_i32(cpu_R[15], s->pc & ~1); - s->is_jmp = DISAS_EXIT; + s->base.is_jmp = DISAS_EXIT; } static inline void gen_hlt(DisasContext *s, int imm) @@ -4145,7 +4145,7 @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn) static inline bool use_goto_tb(DisasContext *s, target_ulong dest) { #ifndef CONFIG_USER_ONLY - return (s->tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) || + return (s->base.tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) || ((s->pc - 1) & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK); #else return true; @@ -4169,12 +4169,12 @@ static void gen_goto_tb(DisasContext *s, int n, target_ulong dest) if (use_goto_tb(s, dest)) { tcg_gen_goto_tb(n); gen_set_pc_im(s, dest); - tcg_gen_exit_tb((uintptr_t)s->tb + n); + tcg_gen_exit_tb((uintptr_t)s->base.tb + n); } else { gen_set_pc_im(s, dest); gen_goto_ptr(); } - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } static inline void gen_jmp (DisasContext *s, uint32_t dest) @@ -4436,7 +4436,7 @@ static void gen_msr_banked(DisasContext *s, int r, int sysm, int rn) tcg_temp_free_i32(tcg_tgtmode); tcg_temp_free_i32(tcg_regno); tcg_temp_free_i32(tcg_reg); - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } static void gen_mrs_banked(DisasContext *s, int r, int sysm, int rn) @@ -4458,7 +4458,7 @@ static void gen_mrs_banked(DisasContext *s, int r, int sysm, int rn) tcg_temp_free_i32(tcg_tgtmode); tcg_temp_free_i32(tcg_regno); store_reg(s, rn, tcg_reg); - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } /* Store value to PC as for an exception return (ie don't @@ -4482,7 +4482,7 @@ static void gen_rfe(DisasContext *s, TCGv_i32 pc, TCGv_i32 cpsr) gen_helper_cpsr_write_eret(cpu_env, cpsr); tcg_temp_free_i32(cpsr); /* Must exit loop to check un-masked IRQs */ - s->is_jmp = DISAS_EXIT; + s->base.is_jmp = DISAS_EXIT; } /* Generate an old-style exception return. Marks pc as dead. */ @@ -4505,17 +4505,17 @@ static void gen_nop_hint(DisasContext *s, int val) case 1: /* yield */ if (!parallel_cpus) { gen_set_pc_im(s, s->pc); - s->is_jmp = DISAS_YIELD; + s->base.is_jmp = DISAS_YIELD; } break; case 3: /* wfi */ gen_set_pc_im(s, s->pc); - s->is_jmp = DISAS_WFI; + s->base.is_jmp = DISAS_WFI; break; case 2: /* wfe */ if (!parallel_cpus) { gen_set_pc_im(s, s->pc); - s->is_jmp = DISAS_WFE; + s->base.is_jmp = DISAS_WFE; } break; case 4: /* sev */ @@ -7654,13 +7654,13 @@ static int disas_coproc_insn(DisasContext *s, uint32_t insn) return 1; } gen_set_pc_im(s, s->pc); - s->is_jmp = DISAS_WFI; + s->base.is_jmp = DISAS_WFI; return 0; default: break; } - if ((s->tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { + if ((s->base.tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { gen_io_start(); } @@ -7751,7 +7751,7 @@ static int disas_coproc_insn(DisasContext *s, uint32_t insn) } } - if ((s->tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { + if ((s->base.tb->cflags & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) { /* I/O operations must end the TB here (whether read or write) */ gen_io_end(); gen_lookup_tb(s); @@ -8065,7 +8065,7 @@ static void gen_srs(DisasContext *s, tcg_temp_free_i32(tmp); } tcg_temp_free_i32(addr); - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } static void disas_arm_insn(DisasContext *s, unsigned int insn) @@ -8153,7 +8153,7 @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) /* setend */ if (((insn >> 9) & 1) != !!(s->be_data == MO_BE)) { gen_helper_setend(cpu_env); - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } return; } else if ((insn & 0x0fffff00) == 0x057ff000) { @@ -9527,7 +9527,7 @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) gen_helper_cpsr_write_eret(cpu_env, tmp); tcg_temp_free_i32(tmp); /* Must exit loop to check un-masked IRQs */ - s->is_jmp = DISAS_EXIT; + s->base.is_jmp = DISAS_EXIT; } } break; @@ -9565,7 +9565,7 @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) /* swi */ gen_set_pc_im(s, s->pc); s->svc_imm = extract32(insn, 0, 24); - s->is_jmp = DISAS_SWI; + s->base.is_jmp = DISAS_SWI; break; default: illegal_op: @@ -11657,7 +11657,7 @@ static void disas_thumb_insn(CPUARMState *env, DisasContext *s) ARCH(6); if (((insn >> 3) & 1) != !!(s->be_data == MO_BE)) { gen_helper_setend(cpu_env); - s->is_jmp = DISAS_UPDATE; + s->base.is_jmp = DISAS_UPDATE; } break; case 3: @@ -11751,7 +11751,7 @@ static void disas_thumb_insn(CPUARMState *env, DisasContext *s) /* swi */ gen_set_pc_im(s, s->pc); s->svc_imm = extract32(insn, 0, 8); - s->is_jmp = DISAS_SWI; + s->base.is_jmp = DISAS_SWI; break; } /* generate a conditional jump to next instruction */ @@ -11824,35 +11824,14 @@ static bool insn_crosses_page(CPUARMState *env, DisasContext *s) return false; } -/* generate intermediate code for basic block 'tb'. */ -void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) +static int arm_tr_init_disas_context(DisasContextBase *dcbase, + CPUState *cs, int max_insns) { + DisasContext *dc = container_of(dcbase, DisasContext, base); CPUARMState *env = cs->env_ptr; ARMCPU *cpu = arm_env_get_cpu(env); - DisasContext dc1, *dc = &dc1; - target_ulong pc_start; - target_ulong next_page_start; - int num_insns; - int max_insns; - bool end_of_page; - - /* generate intermediate code */ - - /* The A64 decoder has its own top level loop, because it doesn't need - * the A32/T32 complexity to do with conditional execution/IT blocks/etc. - */ - if (ARM_TBFLAG_AARCH64_STATE(tb->flags)) { - gen_intermediate_code_a64(cs, tb); - return; - } - pc_start = tb->pc; - - dc->tb = tb; - - dc->is_jmp = DISAS_NEXT; - dc->pc = pc_start; - dc->singlestep_enabled = cs->singlestep_enabled; + dc->pc = dc->base.pc_first; dc->condjmp = 0; dc->aarch64 = 0; @@ -11861,23 +11840,23 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) */ dc->secure_routed_to_el3 = arm_feature(env, ARM_FEATURE_EL3) && !arm_el_is_aa64(env, 3); - dc->thumb = ARM_TBFLAG_THUMB(tb->flags); - dc->sctlr_b = ARM_TBFLAG_SCTLR_B(tb->flags); - dc->be_data = ARM_TBFLAG_BE_DATA(tb->flags) ? MO_BE : MO_LE; - dc->condexec_mask = (ARM_TBFLAG_CONDEXEC(tb->flags) & 0xf) << 1; - dc->condexec_cond = ARM_TBFLAG_CONDEXEC(tb->flags) >> 4; - dc->mmu_idx = core_to_arm_mmu_idx(env, ARM_TBFLAG_MMUIDX(tb->flags)); + dc->thumb = ARM_TBFLAG_THUMB(dc->base.tb->flags); + dc->sctlr_b = ARM_TBFLAG_SCTLR_B(dc->base.tb->flags); + dc->be_data = ARM_TBFLAG_BE_DATA(dc->base.tb->flags) ? MO_BE : MO_LE; + dc->condexec_mask = (ARM_TBFLAG_CONDEXEC(dc->base.tb->flags) & 0xf) << 1; + dc->condexec_cond = ARM_TBFLAG_CONDEXEC(dc->base.tb->flags) >> 4; + dc->mmu_idx = core_to_arm_mmu_idx(env, ARM_TBFLAG_MMUIDX(dc->base.tb->flags)); dc->current_el = arm_mmu_idx_to_el(dc->mmu_idx); #if !defined(CONFIG_USER_ONLY) dc->user = (dc->current_el == 0); #endif - dc->ns = ARM_TBFLAG_NS(tb->flags); - dc->fp_excp_el = ARM_TBFLAG_FPEXC_EL(tb->flags); - dc->vfp_enabled = ARM_TBFLAG_VFPEN(tb->flags); - dc->vec_len = ARM_TBFLAG_VECLEN(tb->flags); - dc->vec_stride = ARM_TBFLAG_VECSTRIDE(tb->flags); - dc->c15_cpar = ARM_TBFLAG_XSCALE_CPAR(tb->flags); - dc->v7m_handler_mode = ARM_TBFLAG_HANDLER(tb->flags); + dc->ns = ARM_TBFLAG_NS(dc->base.tb->flags); + dc->fp_excp_el = ARM_TBFLAG_FPEXC_EL(dc->base.tb->flags); + dc->vfp_enabled = ARM_TBFLAG_VFPEN(dc->base.tb->flags); + dc->vec_len = ARM_TBFLAG_VECLEN(dc->base.tb->flags); + dc->vec_stride = ARM_TBFLAG_VECSTRIDE(dc->base.tb->flags); + dc->c15_cpar = ARM_TBFLAG_XSCALE_CPAR(dc->base.tb->flags); + dc->v7m_handler_mode = ARM_TBFLAG_HANDLER(dc->base.tb->flags); dc->cp_regs = cpu->cp_regs; dc->features = env->features; @@ -11896,11 +11875,26 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) * emit code to generate a software step exception * end the TB */ - dc->ss_active = ARM_TBFLAG_SS_ACTIVE(tb->flags); - dc->pstate_ss = ARM_TBFLAG_PSTATE_SS(tb->flags); + dc->ss_active = ARM_TBFLAG_SS_ACTIVE(dc->base.tb->flags); + dc->pstate_ss = ARM_TBFLAG_PSTATE_SS(dc->base.tb->flags); dc->is_ldex = false; dc->ss_same_el = false; /* Can't be true since EL_d must be AArch64 */ + dc->next_page_start = + (dc->base.pc_first & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE; + + /* If architectural single step active, limit to 1. */ + if (is_singlestepping(dc)) { + max_insns = 1; + } + + /* ARM is a fixed-length ISA. Bound the number of insns to execute + to those left on the page. */ + if (!dc->thumb) { + int bound = (dc->next_page_start - dc->base.pc_first) / 4; + max_insns = MIN(max_insns, bound); + } + cpu_F0s = tcg_temp_new_i32(); cpu_F1s = tcg_temp_new_i32(); cpu_F0d = tcg_temp_new_i64(); @@ -11909,19 +11903,13 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) cpu_V1 = cpu_F1d; /* FIXME: cpu_M0 can probably be the same as cpu_V0. */ cpu_M0 = tcg_temp_new_i64(); - next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE; - num_insns = 0; - max_insns = tb->cflags & CF_COUNT_MASK; - if (max_insns == 0) { - max_insns = CF_COUNT_MASK; - } - if (max_insns > TCG_MAX_INSNS) { - max_insns = TCG_MAX_INSNS; - } - gen_tb_start(tb); + return max_insns; +} - tcg_clear_temp_count(); +static void arm_tr_tb_start(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); /* A note on handling of the condexec (IT) bits: * @@ -11955,141 +11943,173 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) /* Reset the conditional execution bits immediately. This avoids complications trying to do it at the end of the block. */ - if (dc->condexec_mask || dc->condexec_cond) - { + if (dc->condexec_mask || dc->condexec_cond) { TCGv_i32 tmp = tcg_temp_new_i32(); tcg_gen_movi_i32(tmp, 0); store_cpu_field(tmp, condexec_bits); - } - do { - dc->insn_start_idx = tcg_op_buf_count(); - tcg_gen_insn_start(dc->pc, - (dc->condexec_cond << 4) | (dc->condexec_mask >> 1), - 0); - num_insns++; + } + tcg_clear_temp_count(); +} + +static void arm_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + dc->insn_start_idx = tcg_op_buf_count(); + tcg_gen_insn_start(dc->pc, + (dc->condexec_cond << 4) | (dc->condexec_mask >> 1), + 0); +} +static bool arm_tr_breakpoint_check(DisasContextBase *dcbase, CPUState *cpu, + const CPUBreakpoint *bp) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + if (bp->flags & BP_CPU) { + gen_set_condexec(dc); + gen_set_pc_im(dc, dc->pc); + gen_helper_check_breakpoints(cpu_env); + /* End the TB early; it's likely not going to be executed */ + dc->base.is_jmp = DISAS_TOO_MANY; + } else { + gen_exception_internal_insn(dc, 0, EXCP_DEBUG); + /* The address covered by the breakpoint must be + included in [tb->pc, tb->pc + tb->size) in order + to for it to be properly cleared -- thus we + increment the PC here so that the logic setting + tb->size below does the right thing. */ + /* TODO: Advance PC by correct instruction length to + * avoid disassembler error messages */ + dc->pc += 2; + dc->base.is_jmp = DISAS_NORETURN; + } + + return true; +} + +static bool arm_pre_translate_insn(DisasContext *dc) +{ #ifdef CONFIG_USER_ONLY - /* Intercept jump to the magic kernel page. */ - if (dc->pc >= 0xffff0000) { - /* We always get here via a jump, so know we are not in a - conditional execution block. */ - gen_exception_internal(EXCP_KERNEL_TRAP); - dc->is_jmp = DISAS_EXC; - break; - } + /* Intercept jump to the magic kernel page. */ + if (dc->pc >= 0xffff0000) { + /* We always get here via a jump, so know we are not in a + conditional execution block. */ + gen_exception_internal(EXCP_KERNEL_TRAP); + dc->base.is_jmp = DISAS_NORETURN; + return true; + } #endif - if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) { - CPUBreakpoint *bp; - QTAILQ_FOREACH(bp, &cs->breakpoints, entry) { - if (bp->pc == dc->pc) { - if (bp->flags & BP_CPU) { - gen_set_condexec(dc); - gen_set_pc_im(dc, dc->pc); - gen_helper_check_breakpoints(cpu_env); - /* End the TB early; it's likely not going to be executed */ - dc->is_jmp = DISAS_UPDATE; - } else { - gen_exception_internal_insn(dc, 0, EXCP_DEBUG); - /* The address covered by the breakpoint must be - included in [tb->pc, tb->pc + tb->size) in order - to for it to be properly cleared -- thus we - increment the PC here so that the logic setting - tb->size below does the right thing. */ - /* TODO: Advance PC by correct instruction length to - * avoid disassembler error messages */ - dc->pc += 2; - goto done_generating; - } - break; - } - } - } + if (dc->ss_active && !dc->pstate_ss) { + /* Singlestep state is Active-pending. + * If we're in this state at the start of a TB then either + * a) we just took an exception to an EL which is being debugged + * and this is the first insn in the exception handler + * b) debug exceptions were masked and we just unmasked them + * without changing EL (eg by clearing PSTATE.D) + * In either case we're going to take a swstep exception in the + * "did not step an insn" case, and so the syndrome ISV and EX + * bits should be zero. + */ + assert(dc->base.num_insns == 1); + gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0), + default_exception_el(dc)); + dc->base.is_jmp = DISAS_NORETURN; + return true; + } - if (num_insns == max_insns && (tb->cflags & CF_LAST_IO)) { - gen_io_start(); - } + return false; +} - if (dc->ss_active && !dc->pstate_ss) { - /* Singlestep state is Active-pending. - * If we're in this state at the start of a TB then either - * a) we just took an exception to an EL which is being debugged - * and this is the first insn in the exception handler - * b) debug exceptions were masked and we just unmasked them - * without changing EL (eg by clearing PSTATE.D) - * In either case we're going to take a swstep exception in the - * "did not step an insn" case, and so the syndrome ISV and EX - * bits should be zero. - */ - assert(num_insns == 1); - gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0), - default_exception_el(dc)); - goto done_generating; - } +static void arm_post_translate_insn(DisasContext *dc) +{ + if (dc->condjmp && !dc->base.is_jmp) { + gen_set_label(dc->condlabel); + dc->condjmp = 0; + } + dc->base.pc_next = dc->pc; + translator_loop_temp_check(&dc->base); +} - if (dc->thumb) { - disas_thumb_insn(env, dc); - if (dc->condexec_mask) { - dc->condexec_cond = (dc->condexec_cond & 0xe) - | ((dc->condexec_mask >> 4) & 1); - dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f; - if (dc->condexec_mask == 0) { - dc->condexec_cond = 0; - } - } - } else { - unsigned int insn = arm_ldl_code(env, dc->pc, dc->sctlr_b); - dc->pc += 4; - disas_arm_insn(dc, insn); - } +static void arm_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + CPUARMState *env = cpu->env_ptr; + unsigned int insn; - if (dc->condjmp && !dc->is_jmp) { - gen_set_label(dc->condlabel); - dc->condjmp = 0; - } + if (arm_pre_translate_insn(dc)) { + return; + } - if (tcg_check_temp_count()) { - fprintf(stderr, "TCG temporary leak before "TARGET_FMT_lx"\n", - dc->pc); - } + insn = arm_ldl_code(env, dc->pc, dc->sctlr_b); + dc->pc += 4; + disas_arm_insn(dc, insn); - /* Translation stops when a conditional branch is encountered. - * Otherwise the subsequent code could get translated several times. - * Also stop translation when a page boundary is reached. This - * ensures prefetch aborts occur at the right place. */ + arm_post_translate_insn(dc); - /* We want to stop the TB if the next insn starts in a new page, - * or if it spans between this page and the next. This means that - * if we're looking at the last halfword in the page we need to - * see if it's a 16-bit Thumb insn (which will fit in this TB) - * or a 32-bit Thumb insn (which won't). - * This is to avoid generating a silly TB with a single 16-bit insn - * in it at the end of this page (which would execute correctly - * but isn't very efficient). - */ - end_of_page = (dc->pc >= next_page_start) || - ((dc->pc >= next_page_start - 3) && insn_crosses_page(env, dc)); + /* ARM is a fixed-length ISA. We performed the cross-page check + in init_disas_context by adjusting max_insns. */ +} - } while (!dc->is_jmp && !tcg_op_buf_full() && - !is_singlestepping(dc) && - !singlestep && - !end_of_page && - num_insns < max_insns); +static void thumb_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + CPUARMState *env = cpu->env_ptr; - if (tb->cflags & CF_LAST_IO) { - if (dc->condjmp) { - /* FIXME: This can theoretically happen with self-modifying - code. */ - cpu_abort(cs, "IO on conditional branch instruction"); + if (arm_pre_translate_insn(dc)) { + return; + } + + disas_thumb_insn(env, dc); + + /* Advance the Thumb condexec condition. */ + if (dc->condexec_mask) { + dc->condexec_cond = ((dc->condexec_cond & 0xe) | + ((dc->condexec_mask >> 4) & 1)); + dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f; + if (dc->condexec_mask == 0) { + dc->condexec_cond = 0; } - gen_io_end(); + } + + arm_post_translate_insn(dc); + + /* Thumb is a variable-length ISA. Stop translation when the next insn + * will touch a new page. This ensures that prefetch aborts occur at + * the right place. + * + * We want to stop the TB if the next insn starts in a new page, + * or if it spans between this page and the next. This means that + * if we're looking at the last halfword in the page we need to + * see if it's a 16-bit Thumb insn (which will fit in this TB) + * or a 32-bit Thumb insn (which won't). + * This is to avoid generating a silly TB with a single 16-bit insn + * in it at the end of this page (which would execute correctly + * but isn't very efficient). + */ + if (dc->base.is_jmp == DISAS_NEXT + && (dc->pc >= dc->next_page_start + || (dc->pc >= dc->next_page_start - 3 + && insn_crosses_page(env, dc)))) { + dc->base.is_jmp = DISAS_TOO_MANY; + } +} + +static void arm_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + if (dc->base.tb->cflags & CF_LAST_IO && dc->condjmp) { + /* FIXME: This can theoretically happen with self-modifying code. */ + cpu_abort(cpu, "IO on conditional branch instruction"); } /* At this stage dc->condjmp will only be set when the skipped instruction was a conditional branch or trap, and the PC has already been written. */ gen_set_condexec(dc); - if (dc->is_jmp == DISAS_BX_EXCRET) { + if (dc->base.is_jmp == DISAS_BX_EXCRET) { /* Exception return branches need some special case code at the * end of the TB, which is complex enough that it has to * handle the single-step vs not and the condition-failed @@ -12098,7 +12118,7 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) gen_bx_excret_final_code(dc); } else if (unlikely(is_singlestepping(dc))) { /* Unconditional and "condition passed" instruction codepath. */ - switch (dc->is_jmp) { + switch (dc->base.is_jmp) { case DISAS_SWI: gen_ss_advance(dc); gen_exception(EXCP_SWI, syn_aa32_svc(dc->svc_imm, dc->thumb), @@ -12113,12 +12133,16 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) gen_exception(EXCP_SMC, syn_aa32_smc(), 3); break; case DISAS_NEXT: + case DISAS_TOO_MANY: case DISAS_UPDATE: gen_set_pc_im(dc, dc->pc); /* fall through */ default: /* FIXME: Single stepping a WFI insn will not halt the CPU. */ gen_singlestep_exception(dc); + break; + case DISAS_NORETURN: + break; } } else { /* While branches must always occur at the end of an IT block, @@ -12129,8 +12153,9 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) - Hardware watchpoints. Hardware breakpoints have already been handled and skip this code. */ - switch(dc->is_jmp) { + switch(dc->base.is_jmp) { case DISAS_NEXT: + case DISAS_TOO_MANY: gen_goto_tb(dc, 1, dc->pc); break; case DISAS_JUMP: @@ -12143,8 +12168,7 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) /* indicate that the hash table must be used to find the next TB */ tcg_gen_exit_tb(0); break; - case DISAS_TB_JUMP: - case DISAS_EXC: + case DISAS_NORETURN: /* nothing more to generate */ break; case DISAS_WFI: @@ -12185,23 +12209,55 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) } } -done_generating: - gen_tb_end(tb, num_insns); + /* Functions above can change dc->pc, so re-align db->pc_next */ + dc->base.pc_next = dc->pc; +} + +static void arm_tr_disas_log(const DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); -#ifdef DEBUG_DISAS - if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) && - qemu_log_in_addr_range(pc_start)) { - qemu_log_lock(); - qemu_log("----------------\n"); - qemu_log("IN: %s\n", lookup_symbol(pc_start)); - log_target_disas(cs, pc_start, dc->pc - pc_start, - dc->thumb | (dc->sctlr_b << 1)); - qemu_log("\n"); - qemu_log_unlock(); + qemu_log("IN: %s\n", lookup_symbol(dc->base.pc_first)); + log_target_disas(cpu, dc->base.pc_first, dc->base.tb->size, + dc->thumb | (dc->sctlr_b << 1)); +} + +static const TranslatorOps arm_translator_ops = { + .init_disas_context = arm_tr_init_disas_context, + .tb_start = arm_tr_tb_start, + .insn_start = arm_tr_insn_start, + .breakpoint_check = arm_tr_breakpoint_check, + .translate_insn = arm_tr_translate_insn, + .tb_stop = arm_tr_tb_stop, + .disas_log = arm_tr_disas_log, +}; + +static const TranslatorOps thumb_translator_ops = { + .init_disas_context = arm_tr_init_disas_context, + .tb_start = arm_tr_tb_start, + .insn_start = arm_tr_insn_start, + .breakpoint_check = arm_tr_breakpoint_check, + .translate_insn = thumb_tr_translate_insn, + .tb_stop = arm_tr_tb_stop, + .disas_log = arm_tr_disas_log, +}; + +/* generate intermediate code for basic block 'tb'. */ +void gen_intermediate_code(CPUState *cpu, TranslationBlock *tb) +{ + DisasContext dc; + const TranslatorOps *ops = &arm_translator_ops; + + if (ARM_TBFLAG_THUMB(tb->flags)) { + ops = &thumb_translator_ops; + } +#ifdef TARGET_AARCH64 + if (ARM_TBFLAG_AARCH64_STATE(tb->flags)) { + ops = &aarch64_translator_ops; } #endif - tb->size = dc->pc - pc_start; - tb->icount = num_insns; + + translator_loop(ops, &dc.base, cpu, tb); } static const char *cpu_mode_names[16] = { diff --git a/target/arm/translate.h b/target/arm/translate.h index 2fe144baa9..55d691db40 100644 --- a/target/arm/translate.h +++ b/target/arm/translate.h @@ -1,11 +1,16 @@ #ifndef TARGET_ARM_TRANSLATE_H #define TARGET_ARM_TRANSLATE_H +#include "exec/translator.h" + + /* internal defines */ typedef struct DisasContext { + DisasContextBase base; + target_ulong pc; + target_ulong next_page_start; uint32_t insn; - int is_jmp; /* Nonzero if this instruction has been conditionally skipped. */ int condjmp; /* The label that will be jumped to when the instruction is skipped. */ @@ -13,8 +18,6 @@ typedef struct DisasContext { /* Thumb-2 conditional execution bits. */ int condexec_mask; int condexec_cond; - struct TranslationBlock *tb; - int singlestep_enabled; int thumb; int sctlr_b; TCGMemOp be_data; @@ -119,49 +122,43 @@ static void disas_set_insn_syndrome(DisasContext *s, uint32_t syn) s->insn_start_idx = 0; } -/* target-specific extra values for is_jmp */ +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ /* These instructions trap after executing, so the A32/T32 decoder must * defer them until after the conditional execution state has been updated. * WFI also needs special handling when single-stepping. */ -#define DISAS_WFI 4 -#define DISAS_SWI 5 -/* For instructions which unconditionally cause an exception we can skip - * emitting unreachable code at the end of the TB in the A64 decoder - */ -#define DISAS_EXC 6 +#define DISAS_WFI DISAS_TARGET_2 +#define DISAS_SWI DISAS_TARGET_3 /* WFE */ -#define DISAS_WFE 7 -#define DISAS_HVC 8 -#define DISAS_SMC 9 -#define DISAS_YIELD 10 +#define DISAS_WFE DISAS_TARGET_4 +#define DISAS_HVC DISAS_TARGET_5 +#define DISAS_SMC DISAS_TARGET_6 +#define DISAS_YIELD DISAS_TARGET_7 /* M profile branch which might be an exception return (and so needs * custom end-of-TB code) */ -#define DISAS_BX_EXCRET 11 +#define DISAS_BX_EXCRET DISAS_TARGET_8 /* For instructions which want an immediate exit to the main loop, * as opposed to attempting to use lookup_and_goto_ptr. Unlike * DISAS_UPDATE this doesn't write the PC on exiting the translation * loop so you need to ensure something (gen_a64_set_pc_im or runtime * helper) has done so before we reach return from cpu_tb_exec. */ -#define DISAS_EXIT 12 +#define DISAS_EXIT DISAS_TARGET_9 #ifdef TARGET_AARCH64 void a64_translate_init(void); -void gen_intermediate_code_a64(CPUState *cpu, TranslationBlock *tb); void gen_a64_set_pc_im(uint64_t val); void aarch64_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf, int flags); +extern const TranslatorOps aarch64_translator_ops; #else static inline void a64_translate_init(void) { } -static inline void gen_intermediate_code_a64(CPUState *cpu, TranslationBlock *tb) -{ -} - static inline void gen_a64_set_pc_im(uint64_t val) { } diff --git a/target/cris/translate.c b/target/cris/translate.c index 12b96eb68f..38a999e6f1 100644 --- a/target/cris/translate.c +++ b/target/cris/translate.c @@ -31,6 +31,7 @@ #include "exec/helper-proto.h" #include "mmu.h" #include "exec/cpu_ldst.h" +#include "exec/translator.h" #include "crisv32-decode.h" #include "exec/helper-gen.h" @@ -50,7 +51,11 @@ #define BUG() (gen_BUG(dc, __FILE__, __LINE__)) #define BUG_ON(x) ({if (x) BUG();}) -#define DISAS_SWI 5 +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ +#define DISAS_SWI DISAS_TARGET_3 /* Used by the decoder. */ #define EXTRACT_FIELD(src, start, end) \ diff --git a/target/i386/translate.c b/target/i386/translate.c index 5fdadf98cf..de0c989763 100644 --- a/target/i386/translate.c +++ b/target/i386/translate.c @@ -24,6 +24,7 @@ #include "exec/exec-all.h" #include "tcg-op.h" #include "exec/cpu_ldst.h" +#include "exec/translator.h" #include "exec/helper-proto.h" #include "exec/helper-gen.h" @@ -31,7 +32,6 @@ #include "trace-tcg.h" #include "exec/log.h" - #define PREFIX_REPZ 0x01 #define PREFIX_REPNZ 0x02 #define PREFIX_LOCK 0x04 @@ -95,6 +95,8 @@ static int x86_64_hregs; #endif typedef struct DisasContext { + DisasContextBase base; + /* current insn context */ int override; /* -1 if no override */ int prefix; @@ -102,8 +104,6 @@ typedef struct DisasContext { TCGMemOp dflag; target_ulong pc_start; target_ulong pc; /* pc = eip + cs_base */ - int is_jmp; /* 1 = means jump (stop translation), 2 means CPU - static state change (stop translation) */ /* current block context */ target_ulong cs_base; /* base of CS segment */ int pe; /* protected mode */ @@ -124,12 +124,10 @@ typedef struct DisasContext { int cpl; int iopl; int tf; /* TF cpu flag */ - int singlestep_enabled; /* "hardware" single step enabled */ int jmp_opt; /* use direct block chaining for direct jumps */ int repz_opt; /* optimize jumps within repz instructions */ int mem_index; /* select memory access functions */ uint64_t flags; /* all execution flags */ - struct TranslationBlock *tb; int popl_esp_hack; /* for correct popl with esp base handling */ int rip_offset; /* only used in x86_64, but left for simplicity */ int cpuid_features; @@ -1119,7 +1117,7 @@ static void gen_bpt_io(DisasContext *s, TCGv_i32 t_port, int ot) static inline void gen_ins(DisasContext *s, TCGMemOp ot) { - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_string_movl_A0_EDI(s); @@ -1134,14 +1132,14 @@ static inline void gen_ins(DisasContext *s, TCGMemOp ot) gen_op_movl_T0_Dshift(ot); gen_op_add_reg_T0(s->aflag, R_EDI); gen_bpt_io(s, cpu_tmp2_i32, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); } } static inline void gen_outs(DisasContext *s, TCGMemOp ot) { - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_string_movl_A0_ESI(s); @@ -1154,7 +1152,7 @@ static inline void gen_outs(DisasContext *s, TCGMemOp ot) gen_op_movl_T0_Dshift(ot); gen_op_add_reg_T0(s->aflag, R_ESI); gen_bpt_io(s, cpu_tmp2_i32, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); } } @@ -2137,7 +2135,7 @@ static inline int insn_const_size(TCGMemOp ot) static inline bool use_goto_tb(DisasContext *s, target_ulong pc) { #ifndef CONFIG_USER_ONLY - return (pc & TARGET_PAGE_MASK) == (s->tb->pc & TARGET_PAGE_MASK) || + return (pc & TARGET_PAGE_MASK) == (s->base.tb->pc & TARGET_PAGE_MASK) || (pc & TARGET_PAGE_MASK) == (s->pc_start & TARGET_PAGE_MASK); #else return true; @@ -2152,7 +2150,8 @@ static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip) /* jump to same page: we can use a direct jump */ tcg_gen_goto_tb(tb_num); gen_jmp_im(eip); - tcg_gen_exit_tb((uintptr_t)s->tb + tb_num); + tcg_gen_exit_tb((uintptr_t)s->base.tb + tb_num); + s->base.is_jmp = DISAS_NORETURN; } else { /* jump to another page */ gen_jmp_im(eip); @@ -2173,7 +2172,6 @@ static inline void gen_jcc(DisasContext *s, int b, gen_set_label(l1); gen_goto_tb(s, 1, val); - s->is_jmp = DISAS_TB_JUMP; } else { l1 = gen_new_label(); l2 = gen_new_label(); @@ -2243,12 +2241,14 @@ static void gen_movl_seg_T0(DisasContext *s, int seg_reg) because ss32 may change. For R_SS, translation must always stop as a special handling must be done to disable hardware interrupts for the next instruction */ - if (seg_reg == R_SS || (s->code32 && seg_reg < R_FS)) - s->is_jmp = DISAS_TB_JUMP; + if (seg_reg == R_SS || (s->code32 && seg_reg < R_FS)) { + s->base.is_jmp = DISAS_TOO_MANY; + } } else { gen_op_movl_seg_T0_vm(seg_reg); - if (seg_reg == R_SS) - s->is_jmp = DISAS_TB_JUMP; + if (seg_reg == R_SS) { + s->base.is_jmp = DISAS_TOO_MANY; + } } } @@ -2420,7 +2420,7 @@ static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip) gen_update_cc_op(s); gen_jmp_im(cur_eip); gen_helper_raise_exception(cpu_env, tcg_const_i32(trapno)); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } /* Generate #UD for the current instruction. The assumption here is that @@ -2458,7 +2458,7 @@ static void gen_interrupt(DisasContext *s, int intno, gen_jmp_im(cur_eip); gen_helper_raise_interrupt(cpu_env, tcg_const_i32(intno), tcg_const_i32(next_eip - cur_eip)); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } static void gen_debug(DisasContext *s, target_ulong cur_eip) @@ -2466,7 +2466,7 @@ static void gen_debug(DisasContext *s, target_ulong cur_eip) gen_update_cc_op(s); gen_jmp_im(cur_eip); gen_helper_debug(cpu_env); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } static void gen_set_hflag(DisasContext *s, uint32_t mask) @@ -2522,10 +2522,10 @@ do_gen_eob_worker(DisasContext *s, bool inhibit, bool recheck_tf, TCGv jr) gen_reset_hflag(s, HF_INHIBIT_IRQ_MASK); } - if (s->tb->flags & HF_RF_MASK) { + if (s->base.tb->flags & HF_RF_MASK) { gen_helper_reset_rf(cpu_env); } - if (s->singlestep_enabled) { + if (s->base.singlestep_enabled) { gen_helper_debug(cpu_env); } else if (recheck_tf) { gen_helper_rechecking_single_step(cpu_env); @@ -2541,7 +2541,7 @@ do_gen_eob_worker(DisasContext *s, bool inhibit, bool recheck_tf, TCGv jr) } else { tcg_gen_exit_tb(0); } - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } static inline void @@ -2580,7 +2580,6 @@ static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num) set_cc_op(s, CC_OP_DYNAMIC); if (s->jmp_opt) { gen_goto_tb(s, tb_num, eip); - s->is_jmp = DISAS_TB_JUMP; } else { gen_jmp_im(eip); gen_eob(s); @@ -4416,17 +4415,18 @@ static void gen_sse(CPUX86State *env, DisasContext *s, int b, } } -/* convert one instruction. s->is_jmp is set if the translation must +/* convert one instruction. s->base.is_jmp is set if the translation must be stopped. Return the next pc value */ -static target_ulong disas_insn(CPUX86State *env, DisasContext *s, - target_ulong pc_start) +static target_ulong disas_insn(DisasContext *s, CPUState *cpu) { + CPUX86State *env = cpu->env_ptr; int b, prefixes; int shift; TCGMemOp ot, aflag, dflag; int modrm, reg, rm, mod, op, opreg, val; target_ulong next_eip, tval; int rex_w, rex_r; + target_ulong pc_start = s->base.pc_next; s->pc_start = s->pc = pc_start; prefixes = 0; @@ -5376,7 +5376,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_movl_seg_T0(s, reg); gen_pop_update(s, ot); /* Note that reg == R_SS in gen_movl_seg_T0 always sets is_jmp. */ - if (s->is_jmp) { + if (s->base.is_jmp) { gen_jmp_im(s->pc - s->cs_base); if (reg == R_SS) { s->tf = 0; @@ -5391,7 +5391,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, ot = gen_pop_T0(s); gen_movl_seg_T0(s, (b >> 3) & 7); gen_pop_update(s, ot); - if (s->is_jmp) { + if (s->base.is_jmp) { gen_jmp_im(s->pc - s->cs_base); gen_eob(s); } @@ -5442,7 +5442,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0); gen_movl_seg_T0(s, reg); /* Note that reg == R_SS in gen_movl_seg_T0 always sets is_jmp. */ - if (s->is_jmp) { + if (s->base.is_jmp) { gen_jmp_im(s->pc - s->cs_base); if (reg == R_SS) { s->tf = 0; @@ -5651,7 +5651,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_movl_seg_T0(s, op); /* then put the data */ gen_op_mov_reg_v(ot, reg, cpu_T1); - if (s->is_jmp) { + if (s->base.is_jmp) { gen_jmp_im(s->pc - s->cs_base); gen_eob(s); } @@ -6307,7 +6307,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base); } else { gen_ins(s, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_jmp(s, s->pc - s->cs_base); } } @@ -6322,7 +6322,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base); } else { gen_outs(s, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_jmp(s, s->pc - s->cs_base); } } @@ -6338,14 +6338,14 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, tcg_gen_movi_tl(cpu_T0, val); gen_check_io(s, ot, pc_start - s->cs_base, SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes)); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } tcg_gen_movi_i32(cpu_tmp2_i32, val); gen_helper_in_func(ot, cpu_T1, cpu_tmp2_i32); gen_op_mov_reg_v(ot, R_EAX, cpu_T1); gen_bpt_io(s, cpu_tmp2_i32, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_jmp(s, s->pc - s->cs_base); } @@ -6359,14 +6359,14 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, svm_is_rep(prefixes)); gen_op_mov_v_reg(ot, cpu_T1, R_EAX); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } tcg_gen_movi_i32(cpu_tmp2_i32, val); tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T1); gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32); gen_bpt_io(s, cpu_tmp2_i32, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_jmp(s, s->pc - s->cs_base); } @@ -6377,14 +6377,14 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, tcg_gen_ext16u_tl(cpu_T0, cpu_regs[R_EDX]); gen_check_io(s, ot, pc_start - s->cs_base, SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes)); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T0); gen_helper_in_func(ot, cpu_T1, cpu_tmp2_i32); gen_op_mov_reg_v(ot, R_EAX, cpu_T1); gen_bpt_io(s, cpu_tmp2_i32, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_jmp(s, s->pc - s->cs_base); } @@ -6397,14 +6397,14 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, svm_is_rep(prefixes)); gen_op_mov_v_reg(ot, cpu_T1, R_EAX); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T0); tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T1); gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32); gen_bpt_io(s, cpu_tmp2_i32, ot); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_jmp(s, s->pc - s->cs_base); } @@ -6943,7 +6943,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_update_cc_op(s); gen_jmp_im(pc_start - s->cs_base); gen_helper_pause(cpu_env, tcg_const_i32(s->pc - pc_start)); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } break; case 0x9b: /* fwait */ @@ -7112,11 +7112,11 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, case 0x131: /* rdtsc */ gen_update_cc_op(s); gen_jmp_im(pc_start - s->cs_base); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_helper_rdtsc(cpu_env); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_jmp(s, s->pc - s->cs_base); } @@ -7188,7 +7188,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_update_cc_op(s); gen_jmp_im(pc_start - s->cs_base); gen_helper_hlt(cpu_env, tcg_const_i32(s->pc - pc_start)); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; } break; case 0x100: @@ -7371,7 +7371,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_helper_vmrun(cpu_env, tcg_const_i32(s->aflag - 1), tcg_const_i32(s->pc - pc_start)); tcg_gen_exit_tb(0); - s->is_jmp = DISAS_TB_JUMP; + s->base.is_jmp = DISAS_NORETURN; break; case 0xd9: /* VMMCALL */ @@ -7571,11 +7571,11 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, } gen_update_cc_op(s); gen_jmp_im(pc_start - s->cs_base); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_helper_rdtscp(cpu_env); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_jmp(s, s->pc - s->cs_base); } @@ -7940,24 +7940,24 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s, gen_update_cc_op(s); gen_jmp_im(pc_start - s->cs_base); if (b & 2) { - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_op_mov_v_reg(ot, cpu_T0, rm); gen_helper_write_crN(cpu_env, tcg_const_i32(reg), cpu_T0); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); } gen_jmp_im(s->pc - s->cs_base); gen_eob(s); } else { - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_helper_read_crN(cpu_T0, cpu_env, tcg_const_i32(reg)); gen_op_mov_reg_v(ot, rm, cpu_T0); - if (s->tb->cflags & CF_USE_ICOUNT) { + if (s->base.tb->cflags & CF_USE_ICOUNT) { gen_io_end(); } } @@ -8378,22 +8378,13 @@ void tcg_x86_init(void) } } -/* generate intermediate code for basic block 'tb'. */ -void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) +static int i386_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cpu, + int max_insns) { - CPUX86State *env = cs->env_ptr; - DisasContext dc1, *dc = &dc1; - target_ulong pc_ptr; - uint32_t flags; - target_ulong pc_start; - target_ulong cs_base; - int num_insns; - int max_insns; - - /* generate intermediate code */ - pc_start = tb->pc; - cs_base = tb->cs_base; - flags = tb->flags; + DisasContext *dc = container_of(dcbase, DisasContext, base); + CPUX86State *env = cpu->env_ptr; + uint32_t flags = dc->base.tb->flags; + target_ulong cs_base = dc->base.tb->cs_base; dc->pe = (flags >> HF_PE_SHIFT) & 1; dc->code32 = (flags >> HF_CS32_SHIFT) & 1; @@ -8404,11 +8395,9 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) dc->cpl = (flags >> HF_CPL_SHIFT) & 3; dc->iopl = (flags >> IOPL_SHIFT) & 3; dc->tf = (flags >> TF_SHIFT) & 1; - dc->singlestep_enabled = cs->singlestep_enabled; dc->cc_op = CC_OP_DYNAMIC; dc->cc_op_dirty = false; dc->cs_base = cs_base; - dc->tb = tb; dc->popl_esp_hack = 0; /* select memory access functions */ dc->mem_index = 0; @@ -8426,7 +8415,7 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) dc->code64 = (flags >> HF_CS64_SHIFT) & 1; #endif dc->flags = flags; - dc->jmp_opt = !(dc->tf || cs->singlestep_enabled || + dc->jmp_opt = !(dc->tf || dc->base.singlestep_enabled || (flags & HF_INHIBIT_IRQ_MASK)); /* Do not optimize repz jumps at all in icount mode, because rep movsS instructions are execured with different paths @@ -8438,7 +8427,7 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) record/replay modes and there will always be an additional step for ecx=0 when icount is enabled. */ - dc->repz_opt = !dc->jmp_opt && !(tb->cflags & CF_USE_ICOUNT); + dc->repz_opt = !dc->jmp_opt && !(dc->base.tb->cflags & CF_USE_ICOUNT); #if 0 /* check addseg logic */ if (!dc->addseg && (dc->vm86 || !dc->pe || !dc->code32)) @@ -8458,107 +8447,112 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb) cpu_ptr1 = tcg_temp_new_ptr(); cpu_cc_srcT = tcg_temp_local_new(); - dc->is_jmp = DISAS_NEXT; - pc_ptr = pc_start; - num_insns = 0; - max_insns = tb->cflags & CF_COUNT_MASK; - if (max_insns == 0) { - max_insns = CF_COUNT_MASK; - } - if (max_insns > TCG_MAX_INSNS) { - max_insns = TCG_MAX_INSNS; + return max_insns; +} + +static void i386_tr_tb_start(DisasContextBase *db, CPUState *cpu) +{ +} + +static void i386_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + tcg_gen_insn_start(dc->base.pc_next, dc->cc_op); +} + +static bool i386_tr_breakpoint_check(DisasContextBase *dcbase, CPUState *cpu, + const CPUBreakpoint *bp) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + /* If RF is set, suppress an internally generated breakpoint. */ + int flags = dc->base.tb->flags & HF_RF_MASK ? BP_GDB : BP_ANY; + if (bp->flags & flags) { + gen_debug(dc, dc->base.pc_next - dc->cs_base); + dc->base.is_jmp = DISAS_NORETURN; + /* The address covered by the breakpoint must be included in + [tb->pc, tb->pc + tb->size) in order to for it to be + properly cleared -- thus we increment the PC here so that + the generic logic setting tb->size later does the right thing. */ + dc->base.pc_next += 1; + return true; + } else { + return false; } +} - gen_tb_start(tb); - for(;;) { - tcg_gen_insn_start(pc_ptr, dc->cc_op); - num_insns++; - - /* If RF is set, suppress an internally generated breakpoint. */ - if (unlikely(cpu_breakpoint_test(cs, pc_ptr, - tb->flags & HF_RF_MASK - ? BP_GDB : BP_ANY))) { - gen_debug(dc, pc_ptr - dc->cs_base); - /* The address covered by the breakpoint must be included in - [tb->pc, tb->pc + tb->size) in order to for it to be - properly cleared -- thus we increment the PC here so that - the logic setting tb->size below does the right thing. */ - pc_ptr += 1; - goto done_generating; - } - if (num_insns == max_insns && (tb->cflags & CF_LAST_IO)) { - gen_io_start(); - } +static void i386_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + target_ulong pc_next = disas_insn(dc, cpu); - pc_ptr = disas_insn(env, dc, pc_ptr); - /* stop translation if indicated */ - if (dc->is_jmp) - break; + if (dc->tf || (dc->base.tb->flags & HF_INHIBIT_IRQ_MASK)) { /* if single step mode, we generate only one instruction and generate an exception */ /* if irq were inhibited with HF_INHIBIT_IRQ_MASK, we clear the flag and abort the translation to give the irqs a - change to be happen */ - if (dc->tf || dc->singlestep_enabled || - (flags & HF_INHIBIT_IRQ_MASK)) { - gen_jmp_im(pc_ptr - dc->cs_base); - gen_eob(dc); - break; - } + chance to happen */ + dc->base.is_jmp = DISAS_TOO_MANY; + } else if ((dc->base.tb->cflags & CF_USE_ICOUNT) + && ((dc->base.pc_next & TARGET_PAGE_MASK) + != ((dc->base.pc_next + TARGET_MAX_INSN_SIZE - 1) + & TARGET_PAGE_MASK) + || (dc->base.pc_next & ~TARGET_PAGE_MASK) == 0)) { /* Do not cross the boundary of the pages in icount mode, it can cause an exception. Do it only when boundary is crossed by the first instruction in the block. If current instruction already crossed the bound - it's ok, because an exception hasn't stopped this code. */ - if ((tb->cflags & CF_USE_ICOUNT) - && ((pc_ptr & TARGET_PAGE_MASK) - != ((pc_ptr + TARGET_MAX_INSN_SIZE - 1) & TARGET_PAGE_MASK) - || (pc_ptr & ~TARGET_PAGE_MASK) == 0)) { - gen_jmp_im(pc_ptr - dc->cs_base); - gen_eob(dc); - break; - } - /* if too long translation, stop generation too */ - if (tcg_op_buf_full() || - (pc_ptr - pc_start) >= (TARGET_PAGE_SIZE - 32) || - num_insns >= max_insns) { - gen_jmp_im(pc_ptr - dc->cs_base); - gen_eob(dc); - break; - } - if (singlestep) { - gen_jmp_im(pc_ptr - dc->cs_base); - gen_eob(dc); - break; - } + dc->base.is_jmp = DISAS_TOO_MANY; + } else if ((pc_next - dc->base.pc_first) >= (TARGET_PAGE_SIZE - 32)) { + dc->base.is_jmp = DISAS_TOO_MANY; } - if (tb->cflags & CF_LAST_IO) - gen_io_end(); -done_generating: - gen_tb_end(tb, num_insns); -#ifdef DEBUG_DISAS - if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) - && qemu_log_in_addr_range(pc_start)) { - int disas_flags; - qemu_log_lock(); - qemu_log("----------------\n"); - qemu_log("IN: %s\n", lookup_symbol(pc_start)); + dc->base.pc_next = pc_next; +} + +static void i386_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + + if (dc->base.is_jmp == DISAS_TOO_MANY) { + gen_jmp_im(dc->base.pc_next - dc->cs_base); + gen_eob(dc); + } +} + +static void i386_tr_disas_log(const DisasContextBase *dcbase, + CPUState *cpu) +{ + DisasContext *dc = container_of(dcbase, DisasContext, base); + int disas_flags = !dc->code32; + + qemu_log("IN: %s\n", lookup_symbol(dc->base.pc_first)); #ifdef TARGET_X86_64 - if (dc->code64) - disas_flags = 2; - else -#endif - disas_flags = !dc->code32; - log_target_disas(cs, pc_start, pc_ptr - pc_start, disas_flags); - qemu_log("\n"); - qemu_log_unlock(); + if (dc->code64) { + disas_flags = 2; } #endif + log_target_disas(cpu, dc->base.pc_first, dc->base.tb->size, disas_flags); +} + +static const TranslatorOps i386_tr_ops = { + .init_disas_context = i386_tr_init_disas_context, + .tb_start = i386_tr_tb_start, + .insn_start = i386_tr_insn_start, + .breakpoint_check = i386_tr_breakpoint_check, + .translate_insn = i386_tr_translate_insn, + .tb_stop = i386_tr_tb_stop, + .disas_log = i386_tr_disas_log, +}; + +/* generate intermediate code for basic block 'tb'. */ +void gen_intermediate_code(CPUState *cpu, TranslationBlock *tb) +{ + DisasContext dc; - tb->size = pc_ptr - pc_start; - tb->icount = num_insns; + translator_loop(&i386_tr_ops, &dc.base, cpu, tb); } void restore_state_to_opc(CPUX86State *env, TranslationBlock *tb, diff --git a/target/lm32/translate.c b/target/lm32/translate.c index f68f372f15..65bc9c0bf6 100644 --- a/target/lm32/translate.c +++ b/target/lm32/translate.c @@ -22,6 +22,7 @@ #include "disas/disas.h" #include "exec/helper-proto.h" #include "exec/exec-all.h" +#include "exec/translator.h" #include "tcg-op.h" #include "exec/cpu_ldst.h" @@ -47,6 +48,11 @@ #define MEM_INDEX 0 +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ + static TCGv_env cpu_env; static TCGv cpu_R[32]; static TCGv cpu_pc; diff --git a/target/m68k/translate.c b/target/m68k/translate.c index be24355080..d738f32f9c 100644 --- a/target/m68k/translate.c +++ b/target/m68k/translate.c @@ -25,6 +25,7 @@ #include "tcg-op.h" #include "qemu/log.h" #include "exec/cpu_ldst.h" +#include "exec/translator.h" #include "exec/helper-proto.h" #include "exec/helper-gen.h" @@ -173,7 +174,11 @@ static void do_writebacks(DisasContext *s) } } -#define DISAS_JUMP_NEXT 4 +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ +#define DISAS_JUMP_NEXT DISAS_TARGET_3 #if defined(CONFIG_USER_ONLY) #define IS_USER(s) 1 diff --git a/target/microblaze/translate.c b/target/microblaze/translate.c index 83e2ef4960..067b0878d6 100644 --- a/target/microblaze/translate.c +++ b/target/microblaze/translate.c @@ -27,6 +27,7 @@ #include "microblaze-decode.h" #include "exec/cpu_ldst.h" #include "exec/helper-gen.h" +#include "exec/translator.h" #include "trace-tcg.h" #include "exec/log.h" @@ -46,6 +47,11 @@ #define EXTRACT_FIELD(src, start, end) \ (((src) >> start) & ((1 << (end - start + 1)) - 1)) +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ + static TCGv env_debug; static TCGv_env cpu_env; static TCGv cpu_R[32]; diff --git a/target/nios2/translate.c b/target/nios2/translate.c index 8b97d6585f..6b0961837d 100644 --- a/target/nios2/translate.c +++ b/target/nios2/translate.c @@ -29,6 +29,12 @@ #include "exec/helper-gen.h" #include "exec/log.h" #include "exec/cpu_ldst.h" +#include "exec/translator.h" + +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ #define INSTRUCTION_FLG(func, flags) { (func), (flags) } #define INSTRUCTION(func) \ diff --git a/target/openrisc/translate.c b/target/openrisc/translate.c index a01413113b..112db1ad0f 100644 --- a/target/openrisc/translate.c +++ b/target/openrisc/translate.c @@ -27,6 +27,7 @@ #include "qemu/log.h" #include "qemu/bitops.h" #include "exec/cpu_ldst.h" +#include "exec/translator.h" #include "exec/helper-proto.h" #include "exec/helper-gen.h" @@ -37,6 +38,11 @@ #define LOG_DIS(str, ...) \ qemu_log_mask(CPU_LOG_TB_IN_ASM, "%08x: " str, dc->pc, ## __VA_ARGS__) +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ + typedef struct DisasContext { TranslationBlock *tb; target_ulong pc; diff --git a/target/s390x/translate.c b/target/s390x/translate.c index 4b0db7b7bd..909b12818d 100644 --- a/target/s390x/translate.c +++ b/target/s390x/translate.c @@ -77,7 +77,8 @@ typedef struct { } u; } DisasCompare; -#define DISAS_EXCP 4 +/* is_jmp field values */ +#define DISAS_EXCP DISAS_TARGET_0 #ifdef DEBUG_INLINE_BRANCHES static uint64_t inline_branch_hit[CC_OP_MAX]; diff --git a/target/unicore32/translate.c b/target/unicore32/translate.c index 8f30cff932..6c094d59d7 100644 --- a/target/unicore32/translate.c +++ b/target/unicore32/translate.c @@ -16,6 +16,7 @@ #include "tcg-op.h" #include "qemu/log.h" #include "exec/cpu_ldst.h" +#include "exec/translator.h" #include "exec/helper-proto.h" #include "exec/helper-gen.h" @@ -45,9 +46,13 @@ typedef struct DisasContext { #define IS_USER(s) 1 #endif +/* is_jmp field values */ +#define DISAS_JUMP DISAS_TARGET_0 /* only pc was modified dynamically */ +#define DISAS_UPDATE DISAS_TARGET_1 /* cpu state was modified dynamically */ +#define DISAS_TB_JUMP DISAS_TARGET_2 /* only pc was modified statically */ /* These instructions trap after executing, so defer them until after the conditional executions state has been updated. */ -#define DISAS_SYSCALL 5 +#define DISAS_SYSCALL DISAS_TARGET_3 static TCGv_env cpu_env; static TCGv_i32 cpu_R[32]; diff --git a/target/xtensa/translate.c b/target/xtensa/translate.c index f3f0ff589c..d7bf07e8e6 100644 --- a/target/xtensa/translate.c +++ b/target/xtensa/translate.c @@ -38,6 +38,7 @@ #include "sysemu/sysemu.h" #include "exec/cpu_ldst.h" #include "exec/semihost.h" +#include "exec/translator.h" #include "exec/helper-proto.h" #include "exec/helper-gen.h" @@ -46,6 +47,9 @@ #include "exec/log.h" +/* is_jmp field values */ +#define DISAS_UPDATE DISAS_TARGET_0 /* cpu state was modified dynamically */ + typedef struct DisasContext { const XtensaConfig *config; TranslationBlock *tb; diff --git a/tcg/aarch64/tcg-target.h b/tcg/aarch64/tcg-target.h index 55a46ac825..b41a248bee 100644 --- a/tcg/aarch64/tcg-target.h +++ b/tcg/aarch64/tcg-target.h @@ -117,4 +117,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) __builtin___clear_cache((char *)start, (char *)stop); } +#define TCG_TARGET_DEFAULT_MO (0) + #endif /* AARCH64_TCG_TARGET_H */ diff --git a/tcg/arm/tcg-target.h b/tcg/arm/tcg-target.h index 5ef1086710..a38be15a39 100644 --- a/tcg/arm/tcg-target.h +++ b/tcg/arm/tcg-target.h @@ -134,4 +134,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) __builtin___clear_cache((char *) start, (char *) stop); } +#define TCG_TARGET_DEFAULT_MO (0) + #endif diff --git a/tcg/ia64/tcg-target.h b/tcg/ia64/tcg-target.h deleted file mode 100644 index 901bb7575d..0000000000 --- a/tcg/ia64/tcg-target.h +++ /dev/null @@ -1,198 +0,0 @@ -/* - * Tiny Code Generator for QEMU - * - * Copyright (c) 2009-2010 Aurelien Jarno <aurelien@aurel32.net> - * Based on i386/tcg-target.c - Copyright (c) 2008 Fabrice Bellard - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -#ifndef IA64_TCG_TARGET_H -#define IA64_TCG_TARGET_H - -#define TCG_TARGET_INSN_UNIT_SIZE 16 -#define TCG_TARGET_TLB_DISPLACEMENT_BITS 21 - -typedef struct { - uint64_t lo __attribute__((aligned(16))); - uint64_t hi; -} tcg_insn_unit; - -/* We only map the first 64 registers */ -#define TCG_TARGET_NB_REGS 64 -typedef enum { - TCG_REG_R0 = 0, - TCG_REG_R1, - TCG_REG_R2, - TCG_REG_R3, - TCG_REG_R4, - TCG_REG_R5, - TCG_REG_R6, - TCG_REG_R7, - TCG_REG_R8, - TCG_REG_R9, - TCG_REG_R10, - TCG_REG_R11, - TCG_REG_R12, - TCG_REG_R13, - TCG_REG_R14, - TCG_REG_R15, - TCG_REG_R16, - TCG_REG_R17, - TCG_REG_R18, - TCG_REG_R19, - TCG_REG_R20, - TCG_REG_R21, - TCG_REG_R22, - TCG_REG_R23, - TCG_REG_R24, - TCG_REG_R25, - TCG_REG_R26, - TCG_REG_R27, - TCG_REG_R28, - TCG_REG_R29, - TCG_REG_R30, - TCG_REG_R31, - TCG_REG_R32, - TCG_REG_R33, - TCG_REG_R34, - TCG_REG_R35, - TCG_REG_R36, - TCG_REG_R37, - TCG_REG_R38, - TCG_REG_R39, - TCG_REG_R40, - TCG_REG_R41, - TCG_REG_R42, - TCG_REG_R43, - TCG_REG_R44, - TCG_REG_R45, - TCG_REG_R46, - TCG_REG_R47, - TCG_REG_R48, - TCG_REG_R49, - TCG_REG_R50, - TCG_REG_R51, - TCG_REG_R52, - TCG_REG_R53, - TCG_REG_R54, - TCG_REG_R55, - TCG_REG_R56, - TCG_REG_R57, - TCG_REG_R58, - TCG_REG_R59, - TCG_REG_R60, - TCG_REG_R61, - TCG_REG_R62, - TCG_REG_R63, - - TCG_AREG0 = TCG_REG_R32, -} TCGReg; - -#define TCG_CT_CONST_ZERO 0x100 -#define TCG_CT_CONST_S22 0x200 - -/* used for function call generation */ -#define TCG_REG_CALL_STACK TCG_REG_R12 -#define TCG_TARGET_STACK_ALIGN 16 -#define TCG_TARGET_CALL_STACK_OFFSET 16 - -/* optional instructions */ -#define TCG_TARGET_HAS_div_i32 0 -#define TCG_TARGET_HAS_rem_i32 0 -#define TCG_TARGET_HAS_div_i64 0 -#define TCG_TARGET_HAS_rem_i64 0 -#define TCG_TARGET_HAS_andc_i32 1 -#define TCG_TARGET_HAS_andc_i64 1 -#define TCG_TARGET_HAS_bswap16_i32 1 -#define TCG_TARGET_HAS_bswap16_i64 1 -#define TCG_TARGET_HAS_bswap32_i32 1 -#define TCG_TARGET_HAS_bswap32_i64 1 -#define TCG_TARGET_HAS_bswap64_i64 1 -#define TCG_TARGET_HAS_eqv_i32 1 -#define TCG_TARGET_HAS_eqv_i64 1 -#define TCG_TARGET_HAS_ext8s_i32 1 -#define TCG_TARGET_HAS_ext16s_i32 1 -#define TCG_TARGET_HAS_ext8s_i64 1 -#define TCG_TARGET_HAS_ext16s_i64 1 -#define TCG_TARGET_HAS_ext32s_i64 1 -#define TCG_TARGET_HAS_ext8u_i32 1 -#define TCG_TARGET_HAS_ext16u_i32 1 -#define TCG_TARGET_HAS_ext8u_i64 1 -#define TCG_TARGET_HAS_ext16u_i64 1 -#define TCG_TARGET_HAS_ext32u_i64 1 -#define TCG_TARGET_HAS_nand_i32 1 -#define TCG_TARGET_HAS_nand_i64 1 -#define TCG_TARGET_HAS_nor_i32 1 -#define TCG_TARGET_HAS_clz_i32 0 -#define TCG_TARGET_HAS_clz_i64 0 -#define TCG_TARGET_HAS_ctz_i32 0 -#define TCG_TARGET_HAS_ctz_i64 0 -#define TCG_TARGET_HAS_ctpop_i32 0 -#define TCG_TARGET_HAS_ctpop_i64 0 -#define TCG_TARGET_HAS_nor_i64 1 -#define TCG_TARGET_HAS_orc_i32 1 -#define TCG_TARGET_HAS_orc_i64 1 -#define TCG_TARGET_HAS_rot_i32 1 -#define TCG_TARGET_HAS_rot_i64 1 -#define TCG_TARGET_HAS_movcond_i32 1 -#define TCG_TARGET_HAS_movcond_i64 1 -#define TCG_TARGET_HAS_deposit_i32 1 -#define TCG_TARGET_HAS_deposit_i64 1 -#define TCG_TARGET_HAS_extract_i32 0 -#define TCG_TARGET_HAS_extract_i64 0 -#define TCG_TARGET_HAS_sextract_i32 0 -#define TCG_TARGET_HAS_sextract_i64 0 -#define TCG_TARGET_HAS_add2_i32 0 -#define TCG_TARGET_HAS_add2_i64 0 -#define TCG_TARGET_HAS_sub2_i32 0 -#define TCG_TARGET_HAS_sub2_i64 0 -#define TCG_TARGET_HAS_mulu2_i32 0 -#define TCG_TARGET_HAS_mulu2_i64 0 -#define TCG_TARGET_HAS_muls2_i32 0 -#define TCG_TARGET_HAS_muls2_i64 0 -#define TCG_TARGET_HAS_muluh_i32 0 -#define TCG_TARGET_HAS_muluh_i64 0 -#define TCG_TARGET_HAS_mulsh_i32 0 -#define TCG_TARGET_HAS_mulsh_i64 0 -#define TCG_TARGET_HAS_extrl_i64_i32 0 -#define TCG_TARGET_HAS_extrh_i64_i32 0 -#define TCG_TARGET_HAS_goto_ptr 0 - -#define TCG_TARGET_deposit_i32_valid(ofs, len) ((len) <= 16) -#define TCG_TARGET_deposit_i64_valid(ofs, len) ((len) <= 16) - -/* optional instructions automatically implemented */ -#define TCG_TARGET_HAS_neg_i32 0 /* sub r1, r0, r3 */ -#define TCG_TARGET_HAS_neg_i64 0 /* sub r1, r0, r3 */ -#define TCG_TARGET_HAS_not_i32 0 /* xor r1, -1, r3 */ -#define TCG_TARGET_HAS_not_i64 0 /* xor r1, -1, r3 */ - -static inline void flush_icache_range(uintptr_t start, uintptr_t stop) -{ - start = start & ~(32UL - 1UL); - stop = (stop + (32UL - 1UL)) & ~(32UL - 1UL); - - for (; start < stop; start += 32UL) { - asm volatile ("fc.i %0" :: "r" (start)); - } - asm volatile (";;sync.i;;srlz.i;;"); -} - -#endif diff --git a/tcg/ia64/tcg-target.inc.c b/tcg/ia64/tcg-target.inc.c deleted file mode 100644 index bf9a97d75c..0000000000 --- a/tcg/ia64/tcg-target.inc.c +++ /dev/null @@ -1,2482 +0,0 @@ -/* - * Tiny Code Generator for QEMU - * - * Copyright (c) 2009-2010 Aurelien Jarno <aurelien@aurel32.net> - * Based on i386/tcg-target.c - Copyright (c) 2008 Fabrice Bellard - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -/* - * Register definitions - */ - -#ifdef CONFIG_DEBUG_TCG -static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = { - "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", - "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", - "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", - "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", - "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", - "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", - "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55", - "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63", -}; -#endif - -#ifndef CONFIG_SOFTMMU -#define TCG_GUEST_BASE_REG TCG_REG_R55 -#endif - -/* Branch registers */ -enum { - TCG_REG_B0 = 0, - TCG_REG_B1, - TCG_REG_B2, - TCG_REG_B3, - TCG_REG_B4, - TCG_REG_B5, - TCG_REG_B6, - TCG_REG_B7, -}; - -/* Floating point registers */ -enum { - TCG_REG_F0 = 0, - TCG_REG_F1, - TCG_REG_F2, - TCG_REG_F3, - TCG_REG_F4, - TCG_REG_F5, - TCG_REG_F6, - TCG_REG_F7, - TCG_REG_F8, - TCG_REG_F9, - TCG_REG_F10, - TCG_REG_F11, - TCG_REG_F12, - TCG_REG_F13, - TCG_REG_F14, - TCG_REG_F15, -}; - -/* Predicate registers */ -enum { - TCG_REG_P0 = 0, - TCG_REG_P1, - TCG_REG_P2, - TCG_REG_P3, - TCG_REG_P4, - TCG_REG_P5, - TCG_REG_P6, - TCG_REG_P7, - TCG_REG_P8, - TCG_REG_P9, - TCG_REG_P10, - TCG_REG_P11, - TCG_REG_P12, - TCG_REG_P13, - TCG_REG_P14, - TCG_REG_P15, -}; - -/* Application registers */ -enum { - TCG_REG_PFS = 64, -}; - -static const int tcg_target_reg_alloc_order[] = { - TCG_REG_R35, - TCG_REG_R36, - TCG_REG_R37, - TCG_REG_R38, - TCG_REG_R39, - TCG_REG_R40, - TCG_REG_R41, - TCG_REG_R42, - TCG_REG_R43, - TCG_REG_R44, - TCG_REG_R45, - TCG_REG_R46, - TCG_REG_R47, - TCG_REG_R48, - TCG_REG_R49, - TCG_REG_R50, - TCG_REG_R51, - TCG_REG_R52, - TCG_REG_R53, - TCG_REG_R54, - TCG_REG_R55, - TCG_REG_R14, - TCG_REG_R15, - TCG_REG_R16, - TCG_REG_R17, - TCG_REG_R18, - TCG_REG_R19, - TCG_REG_R20, - TCG_REG_R21, - TCG_REG_R22, - TCG_REG_R23, - TCG_REG_R24, - TCG_REG_R25, - TCG_REG_R26, - TCG_REG_R27, - TCG_REG_R28, - TCG_REG_R29, - TCG_REG_R30, - TCG_REG_R31, - TCG_REG_R56, - TCG_REG_R57, - TCG_REG_R58, - TCG_REG_R59, - TCG_REG_R60, - TCG_REG_R61, - TCG_REG_R62, - TCG_REG_R63, - TCG_REG_R8, - TCG_REG_R9, - TCG_REG_R10, - TCG_REG_R11 -}; - -static const int tcg_target_call_iarg_regs[8] = { - TCG_REG_R56, - TCG_REG_R57, - TCG_REG_R58, - TCG_REG_R59, - TCG_REG_R60, - TCG_REG_R61, - TCG_REG_R62, - TCG_REG_R63, -}; - -static const int tcg_target_call_oarg_regs[] = { - TCG_REG_R8 -}; - -/* - * opcode formation - */ - -/* bundle templates: stops (double bar in the IA64 manual) are marked with - an uppercase letter. */ -enum { - mii = 0x00, - miI = 0x01, - mIi = 0x02, - mII = 0x03, - mlx = 0x04, - mLX = 0x05, - mmi = 0x08, - mmI = 0x09, - Mmi = 0x0a, - MmI = 0x0b, - mfi = 0x0c, - mfI = 0x0d, - mmf = 0x0e, - mmF = 0x0f, - mib = 0x10, - miB = 0x11, - mbb = 0x12, - mbB = 0x13, - bbb = 0x16, - bbB = 0x17, - mmb = 0x18, - mmB = 0x19, - mfb = 0x1c, - mfB = 0x1d, -}; - -enum { - OPC_ADD_A1 = 0x10000000000ull, - OPC_AND_A1 = 0x10060000000ull, - OPC_AND_A3 = 0x10160000000ull, - OPC_ANDCM_A1 = 0x10068000000ull, - OPC_ANDCM_A3 = 0x10168000000ull, - OPC_ADDS_A4 = 0x10800000000ull, - OPC_ADDL_A5 = 0x12000000000ull, - OPC_ALLOC_M34 = 0x02c00000000ull, - OPC_BR_DPTK_FEW_B1 = 0x08400000000ull, - OPC_BR_SPTK_MANY_B1 = 0x08000001000ull, - OPC_BR_CALL_SPNT_FEW_B3 = 0x0a200000000ull, - OPC_BR_SPTK_MANY_B4 = 0x00100001000ull, - OPC_BR_CALL_SPTK_MANY_B5 = 0x02100001000ull, - OPC_BR_RET_SPTK_MANY_B4 = 0x00108001100ull, - OPC_BRL_SPTK_MANY_X3 = 0x18000001000ull, - OPC_BRL_CALL_SPNT_MANY_X4 = 0x1a200001000ull, - OPC_BRL_CALL_SPTK_MANY_X4 = 0x1a000001000ull, - OPC_CMP_LT_A6 = 0x18000000000ull, - OPC_CMP_LTU_A6 = 0x1a000000000ull, - OPC_CMP_EQ_A6 = 0x1c000000000ull, - OPC_CMP4_LT_A6 = 0x18400000000ull, - OPC_CMP4_LTU_A6 = 0x1a400000000ull, - OPC_CMP4_EQ_A6 = 0x1c400000000ull, - OPC_DEP_I14 = 0x0ae00000000ull, - OPC_DEP_I15 = 0x08000000000ull, - OPC_DEP_Z_I12 = 0x0a600000000ull, - OPC_EXTR_I11 = 0x0a400002000ull, - OPC_EXTR_U_I11 = 0x0a400000000ull, - OPC_FCVT_FX_TRUNC_S1_F10 = 0x004d0000000ull, - OPC_FCVT_FXU_TRUNC_S1_F10 = 0x004d8000000ull, - OPC_FCVT_XF_F11 = 0x000e0000000ull, - OPC_FMA_S1_F1 = 0x10400000000ull, - OPC_FNMA_S1_F1 = 0x18400000000ull, - OPC_FRCPA_S1_F6 = 0x00600000000ull, - OPC_GETF_SIG_M19 = 0x08708000000ull, - OPC_LD1_M1 = 0x08000000000ull, - OPC_LD1_M3 = 0x0a000000000ull, - OPC_LD2_M1 = 0x08040000000ull, - OPC_LD2_M3 = 0x0a040000000ull, - OPC_LD4_M1 = 0x08080000000ull, - OPC_LD4_M3 = 0x0a080000000ull, - OPC_LD8_M1 = 0x080c0000000ull, - OPC_LD8_M3 = 0x0a0c0000000ull, - OPC_MF_M24 = 0x00110000000ull, - OPC_MUX1_I3 = 0x0eca0000000ull, - OPC_NOP_B9 = 0x04008000000ull, - OPC_NOP_F16 = 0x00008000000ull, - OPC_NOP_I18 = 0x00008000000ull, - OPC_NOP_M48 = 0x00008000000ull, - OPC_MOV_I21 = 0x00e00100000ull, - OPC_MOV_RET_I21 = 0x00e00500000ull, - OPC_MOV_I22 = 0x00188000000ull, - OPC_MOV_I_I26 = 0x00150000000ull, - OPC_MOVL_X2 = 0x0c000000000ull, - OPC_OR_A1 = 0x10070000000ull, - OPC_OR_A3 = 0x10170000000ull, - OPC_SETF_EXP_M18 = 0x0c748000000ull, - OPC_SETF_SIG_M18 = 0x0c708000000ull, - OPC_SHL_I7 = 0x0f240000000ull, - OPC_SHR_I5 = 0x0f220000000ull, - OPC_SHR_U_I5 = 0x0f200000000ull, - OPC_SHRP_I10 = 0x0ac00000000ull, - OPC_SXT1_I29 = 0x000a0000000ull, - OPC_SXT2_I29 = 0x000a8000000ull, - OPC_SXT4_I29 = 0x000b0000000ull, - OPC_ST1_M4 = 0x08c00000000ull, - OPC_ST2_M4 = 0x08c40000000ull, - OPC_ST4_M4 = 0x08c80000000ull, - OPC_ST8_M4 = 0x08cc0000000ull, - OPC_SUB_A1 = 0x10028000000ull, - OPC_SUB_A3 = 0x10128000000ull, - OPC_UNPACK4_L_I2 = 0x0f860000000ull, - OPC_XMA_L_F2 = 0x1d000000000ull, - OPC_XOR_A1 = 0x10078000000ull, - OPC_XOR_A3 = 0x10178000000ull, - OPC_ZXT1_I29 = 0x00080000000ull, - OPC_ZXT2_I29 = 0x00088000000ull, - OPC_ZXT4_I29 = 0x00090000000ull, - - INSN_NOP_M = OPC_NOP_M48, /* nop.m 0 */ - INSN_NOP_I = OPC_NOP_I18, /* nop.i 0 */ -}; - -static inline uint64_t tcg_opc_a1(int qp, uint64_t opc, int r1, - int r2, int r3) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_a3(int qp, uint64_t opc, int r1, - uint64_t imm, int r3) -{ - return opc - | ((imm & 0x80) << 29) /* s */ - | ((imm & 0x7f) << 13) /* imm7b */ - | ((r3 & 0x7f) << 20) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_a4(int qp, uint64_t opc, int r1, - uint64_t imm, int r3) -{ - return opc - | ((imm & 0x2000) << 23) /* s */ - | ((imm & 0x1f80) << 20) /* imm6d */ - | ((imm & 0x007f) << 13) /* imm7b */ - | ((r3 & 0x7f) << 20) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_a5(int qp, uint64_t opc, int r1, - uint64_t imm, int r3) -{ - return opc - | ((imm & 0x200000) << 15) /* s */ - | ((imm & 0x1f0000) << 6) /* imm5c */ - | ((imm & 0x00ff80) << 20) /* imm9d */ - | ((imm & 0x00007f) << 13) /* imm7b */ - | ((r3 & 0x03) << 20) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_a6(int qp, uint64_t opc, int p1, - int p2, int r2, int r3) -{ - return opc - | ((p2 & 0x3f) << 27) - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((p1 & 0x3f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_b1(int qp, uint64_t opc, uint64_t imm) -{ - return opc - | ((imm & 0x100000) << 16) /* s */ - | ((imm & 0x0fffff) << 13) /* imm20b */ - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_b3(int qp, uint64_t opc, int b1, uint64_t imm) -{ - return opc - | ((imm & 0x100000) << 16) /* s */ - | ((imm & 0x0fffff) << 13) /* imm20b */ - | ((b1 & 0x7) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_b4(int qp, uint64_t opc, int b2) -{ - return opc - | ((b2 & 0x7) << 13) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_b5(int qp, uint64_t opc, int b1, int b2) -{ - return opc - | ((b2 & 0x7) << 13) - | ((b1 & 0x7) << 6) - | (qp & 0x3f); -} - - -static inline uint64_t tcg_opc_b9(int qp, uint64_t opc, uint64_t imm) -{ - return opc - | ((imm & 0x100000) << 16) /* i */ - | ((imm & 0x0fffff) << 6) /* imm20a */ - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_f1(int qp, uint64_t opc, int f1, - int f3, int f4, int f2) -{ - return opc - | ((f4 & 0x7f) << 27) - | ((f3 & 0x7f) << 20) - | ((f2 & 0x7f) << 13) - | ((f1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_f2(int qp, uint64_t opc, int f1, - int f3, int f4, int f2) -{ - return opc - | ((f4 & 0x7f) << 27) - | ((f3 & 0x7f) << 20) - | ((f2 & 0x7f) << 13) - | ((f1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_f6(int qp, uint64_t opc, int f1, - int p2, int f2, int f3) -{ - return opc - | ((p2 & 0x3f) << 27) - | ((f3 & 0x7f) << 20) - | ((f2 & 0x7f) << 13) - | ((f1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_f10(int qp, uint64_t opc, int f1, int f2) -{ - return opc - | ((f2 & 0x7f) << 13) - | ((f1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_f11(int qp, uint64_t opc, int f1, int f2) -{ - return opc - | ((f2 & 0x7f) << 13) - | ((f1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_f16(int qp, uint64_t opc, uint64_t imm) -{ - return opc - | ((imm & 0x100000) << 16) /* i */ - | ((imm & 0x0fffff) << 6) /* imm20a */ - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i2(int qp, uint64_t opc, int r1, - int r2, int r3) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i3(int qp, uint64_t opc, int r1, - int r2, int mbtype) -{ - return opc - | ((mbtype & 0x0f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i5(int qp, uint64_t opc, int r1, - int r3, int r2) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i7(int qp, uint64_t opc, int r1, - int r2, int r3) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i10(int qp, uint64_t opc, int r1, - int r2, int r3, uint64_t count) -{ - return opc - | ((count & 0x3f) << 27) - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i11(int qp, uint64_t opc, int r1, - int r3, uint64_t pos, uint64_t len) -{ - return opc - | ((len & 0x3f) << 27) - | ((r3 & 0x7f) << 20) - | ((pos & 0x3f) << 14) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i12(int qp, uint64_t opc, int r1, - int r2, uint64_t pos, uint64_t len) -{ - return opc - | ((len & 0x3f) << 27) - | ((pos & 0x3f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i14(int qp, uint64_t opc, int r1, uint64_t imm, - int r3, uint64_t pos, uint64_t len) -{ - return opc - | ((imm & 0x01) << 36) - | ((len & 0x3f) << 27) - | ((r3 & 0x7f) << 20) - | ((pos & 0x3f) << 14) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i15(int qp, uint64_t opc, int r1, int r2, - int r3, uint64_t pos, uint64_t len) -{ - return opc - | ((pos & 0x3f) << 31) - | ((len & 0x0f) << 27) - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i18(int qp, uint64_t opc, uint64_t imm) -{ - return opc - | ((imm & 0x100000) << 16) /* i */ - | ((imm & 0x0fffff) << 6) /* imm20a */ - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i21(int qp, uint64_t opc, int b1, - int r2, uint64_t imm) -{ - return opc - | ((imm & 0x1ff) << 24) - | ((r2 & 0x7f) << 13) - | ((b1 & 0x7) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i22(int qp, uint64_t opc, int r1, int b2) -{ - return opc - | ((b2 & 0x7) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i26(int qp, uint64_t opc, int ar3, int r2) -{ - return opc - | ((ar3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_i29(int qp, uint64_t opc, int r1, int r3) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_l2(uint64_t imm) -{ - return (imm & 0x7fffffffffc00000ull) >> 22; -} - -static inline uint64_t tcg_opc_l3(uint64_t imm) -{ - return (imm & 0x07fffffffff00000ull) >> 18; -} - -#define tcg_opc_l4 tcg_opc_l3 - -static inline uint64_t tcg_opc_m1(int qp, uint64_t opc, int r1, int r3) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_m3(int qp, uint64_t opc, int r1, - int r3, uint64_t imm) -{ - return opc - | ((imm & 0x100) << 28) /* s */ - | ((imm & 0x080) << 20) /* i */ - | ((imm & 0x07f) << 13) /* imm7b */ - | ((r3 & 0x7f) << 20) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_m4(int qp, uint64_t opc, int r2, int r3) -{ - return opc - | ((r3 & 0x7f) << 20) - | ((r2 & 0x7f) << 13) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_m18(int qp, uint64_t opc, int f1, int r2) -{ - return opc - | ((r2 & 0x7f) << 13) - | ((f1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_m19(int qp, uint64_t opc, int r1, int f2) -{ - return opc - | ((f2 & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_m34(int qp, uint64_t opc, int r1, - int sof, int sol, int sor) -{ - return opc - | ((sor & 0x0f) << 27) - | ((sol & 0x7f) << 20) - | ((sof & 0x7f) << 13) - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_m48(int qp, uint64_t opc, uint64_t imm) -{ - return opc - | ((imm & 0x100000) << 16) /* i */ - | ((imm & 0x0fffff) << 6) /* imm20a */ - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_x2(int qp, uint64_t opc, - int r1, uint64_t imm) -{ - return opc - | ((imm & 0x8000000000000000ull) >> 27) /* i */ - | (imm & 0x0000000000200000ull) /* ic */ - | ((imm & 0x00000000001f0000ull) << 6) /* imm5c */ - | ((imm & 0x000000000000ff80ull) << 20) /* imm9d */ - | ((imm & 0x000000000000007full) << 13) /* imm7b */ - | ((r1 & 0x7f) << 6) - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_x3(int qp, uint64_t opc, uint64_t imm) -{ - return opc - | ((imm & 0x0800000000000000ull) >> 23) /* i */ - | ((imm & 0x00000000000fffffull) << 13) /* imm20b */ - | (qp & 0x3f); -} - -static inline uint64_t tcg_opc_x4(int qp, uint64_t opc, int b1, uint64_t imm) -{ - return opc - | ((imm & 0x0800000000000000ull) >> 23) /* i */ - | ((imm & 0x00000000000fffffull) << 13) /* imm20b */ - | ((b1 & 0x7) << 6) - | (qp & 0x3f); -} - - -/* - * Relocations - Note that we never encode branches elsewhere than slot 2. - */ - -static void reloc_pcrel21b_slot2(tcg_insn_unit *pc, tcg_insn_unit *target) -{ - uint64_t imm = target - pc; - - pc->hi = (pc->hi & 0xf700000fffffffffull) - | ((imm & 0x100000) << 39) /* s */ - | ((imm & 0x0fffff) << 36); /* imm20b */ -} - -static uint64_t get_reloc_pcrel21b_slot2(tcg_insn_unit *pc) -{ - int64_t high = pc->hi; - - return ((high >> 39) & 0x100000) + /* s */ - ((high >> 36) & 0x0fffff); /* imm20b */ -} - -static void patch_reloc(tcg_insn_unit *code_ptr, int type, - intptr_t value, intptr_t addend) -{ - tcg_debug_assert(addend == 0); - tcg_debug_assert(type == R_IA64_PCREL21B); - reloc_pcrel21b_slot2(code_ptr, (tcg_insn_unit *)value); -} - -/* - * Constraints - */ - -/* parse target specific constraints */ -static const char *target_parse_constraint(TCGArgConstraint *ct, - const char *ct_str, TCGType type) -{ - switch(*ct_str++) { - case 'r': - ct->ct |= TCG_CT_REG; - tcg_regset_set(ct->u.regs, 0xffffffffffffffffull); - break; - case 'I': - ct->ct |= TCG_CT_CONST_S22; - break; - case 'S': - ct->ct |= TCG_CT_REG; - tcg_regset_set(ct->u.regs, 0xffffffffffffffffull); -#if defined(CONFIG_SOFTMMU) - tcg_regset_reset_reg(ct->u.regs, TCG_REG_R56); - tcg_regset_reset_reg(ct->u.regs, TCG_REG_R57); - tcg_regset_reset_reg(ct->u.regs, TCG_REG_R58); -#endif - break; - case 'Z': - /* We are cheating a bit here, using the fact that the register - r0 is also the register number 0. Hence there is no need - to check for const_args in each instruction. */ - ct->ct |= TCG_CT_CONST_ZERO; - break; - default: - return NULL; - } - return ct_str; -} - -/* test if a constant matches the constraint */ -static inline int tcg_target_const_match(tcg_target_long val, TCGType type, - const TCGArgConstraint *arg_ct) -{ - int ct; - ct = arg_ct->ct; - if (ct & TCG_CT_CONST) - return 1; - else if ((ct & TCG_CT_CONST_ZERO) && val == 0) - return 1; - else if ((ct & TCG_CT_CONST_S22) && val == ((int32_t)val << 10) >> 10) - return 1; - else - return 0; -} - -/* - * Code generation - */ - -static tcg_insn_unit *tb_ret_addr; - -static inline void tcg_out_bundle(TCGContext *s, int template, - uint64_t slot0, uint64_t slot1, - uint64_t slot2) -{ - template &= 0x1f; /* 5 bits */ - slot0 &= 0x1ffffffffffull; /* 41 bits */ - slot1 &= 0x1ffffffffffull; /* 41 bits */ - slot2 &= 0x1ffffffffffull; /* 41 bits */ - - *s->code_ptr++ = (tcg_insn_unit){ - (slot1 << 46) | (slot0 << 5) | template, - (slot2 << 23) | (slot1 >> 18) - }; -} - -static inline uint64_t tcg_opc_mov_a(int qp, TCGReg dst, TCGReg src) -{ - return tcg_opc_a4(qp, OPC_ADDS_A4, dst, 0, src); -} - -static inline void tcg_out_mov(TCGContext *s, TCGType type, - TCGReg ret, TCGReg arg) -{ - tcg_out_bundle(s, mmI, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_mov_a(TCG_REG_P0, ret, arg)); -} - -static inline uint64_t tcg_opc_movi_a(int qp, TCGReg dst, int64_t src) -{ - tcg_debug_assert(src == sextract64(src, 0, 22)); - return tcg_opc_a5(qp, OPC_ADDL_A5, dst, src, TCG_REG_R0); -} - -static inline void tcg_out_movi(TCGContext *s, TCGType type, - TCGReg reg, tcg_target_long arg) -{ - tcg_out_bundle(s, mLX, - INSN_NOP_M, - tcg_opc_l2 (arg), - tcg_opc_x2 (TCG_REG_P0, OPC_MOVL_X2, reg, arg)); -} - -static void tcg_out_br(TCGContext *s, TCGLabel *l) -{ - uint64_t imm; - - /* We pay attention here to not modify the branch target by reading - the existing value and using it again. This ensure that caches and - memory are kept coherent during retranslation. */ - if (l->has_value) { - imm = l->u.value_ptr - s->code_ptr; - } else { - imm = get_reloc_pcrel21b_slot2(s->code_ptr); - tcg_out_reloc(s, s->code_ptr, R_IA64_PCREL21B, l, 0); - } - - tcg_out_bundle(s, mmB, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_b1(TCG_REG_P0, OPC_BR_SPTK_MANY_B1, imm)); -} - -static inline void tcg_out_call(TCGContext *s, tcg_insn_unit *desc) -{ - uintptr_t func = desc->lo, gp = desc->hi, disp; - - /* Look through the function descriptor. */ - tcg_out_bundle(s, mlx, - INSN_NOP_M, - tcg_opc_l2 (gp), - tcg_opc_x2 (TCG_REG_P0, OPC_MOVL_X2, TCG_REG_R1, gp)); - disp = (tcg_insn_unit *)func - s->code_ptr; - tcg_out_bundle(s, mLX, - INSN_NOP_M, - tcg_opc_l4 (disp), - tcg_opc_x4 (TCG_REG_P0, OPC_BRL_CALL_SPTK_MANY_X4, - TCG_REG_B0, disp)); -} - -static void tcg_out_exit_tb(TCGContext *s, tcg_target_long arg) -{ - uint64_t imm, opc1; - - /* At least arg == 0 is a common operation. */ - if (arg == sextract64(arg, 0, 22)) { - opc1 = tcg_opc_movi_a(TCG_REG_P0, TCG_REG_R8, arg); - } else { - tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R8, arg); - opc1 = INSN_NOP_M; - } - - imm = tb_ret_addr - s->code_ptr; - - tcg_out_bundle(s, mLX, - opc1, - tcg_opc_l3 (imm), - tcg_opc_x3 (TCG_REG_P0, OPC_BRL_SPTK_MANY_X3, imm)); -} - -static inline void tcg_out_goto_tb(TCGContext *s, TCGArg arg) -{ - if (s->tb_jmp_insn_offset) { - /* direct jump method */ - tcg_abort(); - } else { - /* indirect jump method */ - tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R2, - (tcg_target_long)(s->tb_jmp_target_addr + arg)); - tcg_out_bundle(s, MmI, - tcg_opc_m1 (TCG_REG_P0, OPC_LD8_M1, - TCG_REG_R2, TCG_REG_R2), - INSN_NOP_M, - tcg_opc_i21(TCG_REG_P0, OPC_MOV_I21, TCG_REG_B6, - TCG_REG_R2, 0)); - tcg_out_bundle(s, mmB, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_b4 (TCG_REG_P0, OPC_BR_SPTK_MANY_B4, - TCG_REG_B6)); - } - s->tb_jmp_reset_offset[arg] = tcg_current_code_size(s); -} - -static inline void tcg_out_jmp(TCGContext *s, TCGArg addr) -{ - tcg_out_bundle(s, mmI, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_i21(TCG_REG_P0, OPC_MOV_I21, TCG_REG_B6, addr, 0)); - tcg_out_bundle(s, mmB, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_b4(TCG_REG_P0, OPC_BR_SPTK_MANY_B4, TCG_REG_B6)); -} - -static inline void tcg_out_ld_rel(TCGContext *s, uint64_t opc_m4, TCGArg arg, - TCGArg arg1, tcg_target_long arg2) -{ - if (arg2 == ((int16_t)arg2 >> 2) << 2) { - tcg_out_bundle(s, MmI, - tcg_opc_a4(TCG_REG_P0, OPC_ADDS_A4, - TCG_REG_R2, arg2, arg1), - tcg_opc_m1 (TCG_REG_P0, opc_m4, arg, TCG_REG_R2), - INSN_NOP_I); - } else { - tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R2, arg2); - tcg_out_bundle(s, MmI, - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, - TCG_REG_R2, TCG_REG_R2, arg1), - tcg_opc_m1 (TCG_REG_P0, opc_m4, arg, TCG_REG_R2), - INSN_NOP_I); - } -} - -static inline void tcg_out_st_rel(TCGContext *s, uint64_t opc_m4, TCGArg arg, - TCGArg arg1, tcg_target_long arg2) -{ - if (arg2 == ((int16_t)arg2 >> 2) << 2) { - tcg_out_bundle(s, MmI, - tcg_opc_a4(TCG_REG_P0, OPC_ADDS_A4, - TCG_REG_R2, arg2, arg1), - tcg_opc_m4 (TCG_REG_P0, opc_m4, arg, TCG_REG_R2), - INSN_NOP_I); - } else { - tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R2, arg2); - tcg_out_bundle(s, MmI, - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, - TCG_REG_R2, TCG_REG_R2, arg1), - tcg_opc_m4 (TCG_REG_P0, opc_m4, arg, TCG_REG_R2), - INSN_NOP_I); - } -} - -static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg, - TCGReg arg1, intptr_t arg2) -{ - if (type == TCG_TYPE_I32) { - tcg_out_ld_rel(s, OPC_LD4_M1, arg, arg1, arg2); - } else { - tcg_out_ld_rel(s, OPC_LD8_M1, arg, arg1, arg2); - } -} - -static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, - TCGReg arg1, intptr_t arg2) -{ - if (type == TCG_TYPE_I32) { - tcg_out_st_rel(s, OPC_ST4_M4, arg, arg1, arg2); - } else { - tcg_out_st_rel(s, OPC_ST8_M4, arg, arg1, arg2); - } -} - -static inline bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val, - TCGReg base, intptr_t ofs) -{ - if (val == 0) { - tcg_out_st(s, type, TCG_REG_R0, base, ofs); - return true; - } - return false; -} - -static inline void tcg_out_alu(TCGContext *s, uint64_t opc_a1, uint64_t opc_a3, - TCGReg ret, TCGArg arg1, int const_arg1, - TCGArg arg2, int const_arg2) -{ - uint64_t opc1 = 0, opc2 = 0, opc3 = 0; - - if (const_arg2 && arg2 != 0) { - opc2 = tcg_opc_movi_a(TCG_REG_P0, TCG_REG_R3, arg2); - arg2 = TCG_REG_R3; - } - if (const_arg1 && arg1 != 0) { - if (opc_a3 && arg1 == (int8_t)arg1) { - opc3 = tcg_opc_a3(TCG_REG_P0, opc_a3, ret, arg1, arg2); - } else { - opc1 = tcg_opc_movi_a(TCG_REG_P0, TCG_REG_R2, arg1); - arg1 = TCG_REG_R2; - } - } - if (opc3 == 0) { - opc3 = tcg_opc_a1(TCG_REG_P0, opc_a1, ret, arg1, arg2); - } - - tcg_out_bundle(s, (opc1 || opc2 ? mII : miI), - opc1 ? opc1 : INSN_NOP_M, - opc2 ? opc2 : INSN_NOP_I, - opc3); -} - -static inline void tcg_out_add(TCGContext *s, TCGReg ret, TCGReg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2 && arg2 == sextract64(arg2, 0, 14)) { - tcg_out_bundle(s, mmI, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_a4(TCG_REG_P0, OPC_ADDS_A4, ret, arg2, arg1)); - } else { - tcg_out_alu(s, OPC_ADD_A1, 0, ret, arg1, 0, arg2, const_arg2); - } -} - -static inline void tcg_out_sub(TCGContext *s, TCGReg ret, TCGArg arg1, - int const_arg1, TCGArg arg2, int const_arg2) -{ - if (!const_arg1 && const_arg2 && -arg2 == sextract64(-arg2, 0, 14)) { - tcg_out_bundle(s, mmI, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_a4(TCG_REG_P0, OPC_ADDS_A4, ret, -arg2, arg1)); - } else { - tcg_out_alu(s, OPC_SUB_A1, OPC_SUB_A3, ret, - arg1, const_arg1, arg2, const_arg2); - } -} - -static inline void tcg_out_eqv(TCGContext *s, TCGArg ret, - TCGArg arg1, int const_arg1, - TCGArg arg2, int const_arg2) -{ - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_a1 (TCG_REG_P0, OPC_XOR_A1, ret, arg1, arg2), - tcg_opc_a3 (TCG_REG_P0, OPC_ANDCM_A3, ret, -1, ret)); -} - -static inline void tcg_out_nand(TCGContext *s, TCGArg ret, - TCGArg arg1, int const_arg1, - TCGArg arg2, int const_arg2) -{ - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_a1 (TCG_REG_P0, OPC_AND_A1, ret, arg1, arg2), - tcg_opc_a3 (TCG_REG_P0, OPC_ANDCM_A3, ret, -1, ret)); -} - -static inline void tcg_out_nor(TCGContext *s, TCGArg ret, - TCGArg arg1, int const_arg1, - TCGArg arg2, int const_arg2) -{ - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_a1 (TCG_REG_P0, OPC_OR_A1, ret, arg1, arg2), - tcg_opc_a3 (TCG_REG_P0, OPC_ANDCM_A3, ret, -1, ret)); -} - -static inline void tcg_out_orc(TCGContext *s, TCGArg ret, - TCGArg arg1, int const_arg1, - TCGArg arg2, int const_arg2) -{ - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_a3 (TCG_REG_P0, OPC_ANDCM_A3, TCG_REG_R2, -1, arg2), - tcg_opc_a1 (TCG_REG_P0, OPC_OR_A1, ret, arg1, TCG_REG_R2)); -} - -static inline void tcg_out_mul(TCGContext *s, TCGArg ret, - TCGArg arg1, TCGArg arg2) -{ - tcg_out_bundle(s, mmI, - tcg_opc_m18(TCG_REG_P0, OPC_SETF_SIG_M18, TCG_REG_F6, arg1), - tcg_opc_m18(TCG_REG_P0, OPC_SETF_SIG_M18, TCG_REG_F7, arg2), - INSN_NOP_I); - tcg_out_bundle(s, mmF, - INSN_NOP_M, - INSN_NOP_M, - tcg_opc_f2 (TCG_REG_P0, OPC_XMA_L_F2, TCG_REG_F6, TCG_REG_F6, - TCG_REG_F7, TCG_REG_F0)); - tcg_out_bundle(s, miI, - tcg_opc_m19(TCG_REG_P0, OPC_GETF_SIG_M19, ret, TCG_REG_F6), - INSN_NOP_I, - INSN_NOP_I); -} - -static inline void tcg_out_sar_i32(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_I11, - ret, arg1, arg2, 31 - arg2)); - } else { - tcg_out_bundle(s, mII, - tcg_opc_a3 (TCG_REG_P0, OPC_AND_A3, - TCG_REG_R3, 0x1f, arg2), - tcg_opc_i29(TCG_REG_P0, OPC_SXT4_I29, TCG_REG_R2, arg1), - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_I5, ret, - TCG_REG_R2, TCG_REG_R3)); - } -} - -static inline void tcg_out_sar_i64(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_I11, - ret, arg1, arg2, 63 - arg2)); - } else { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_I5, ret, arg1, arg2)); - } -} - -static inline void tcg_out_shl_i32(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, ret, - arg1, 63 - arg2, 31 - arg2)); - } else { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_a3 (TCG_REG_P0, OPC_AND_A3, TCG_REG_R2, - 0x1f, arg2), - tcg_opc_i7 (TCG_REG_P0, OPC_SHL_I7, ret, - arg1, TCG_REG_R2)); - } -} - -static inline void tcg_out_shl_i64(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, ret, - arg1, 63 - arg2, 63 - arg2)); - } else { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i7 (TCG_REG_P0, OPC_SHL_I7, ret, - arg1, arg2)); - } -} - -static inline void tcg_out_shr_i32(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_U_I11, ret, - arg1, arg2, 31 - arg2)); - } else { - tcg_out_bundle(s, mII, - tcg_opc_a3 (TCG_REG_P0, OPC_AND_A3, TCG_REG_R3, - 0x1f, arg2), - tcg_opc_i29(TCG_REG_P0, OPC_ZXT4_I29, TCG_REG_R2, arg1), - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_U_I5, ret, - TCG_REG_R2, TCG_REG_R3)); - } -} - -static inline void tcg_out_shr_i64(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_U_I11, ret, - arg1, arg2, 63 - arg2)); - } else { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_U_I5, ret, - arg1, arg2)); - } -} - -static inline void tcg_out_rotl_i32(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i2 (TCG_REG_P0, OPC_UNPACK4_L_I2, - TCG_REG_R2, arg1, arg1), - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_U_I11, ret, - TCG_REG_R2, 32 - arg2, 31)); - } else { - tcg_out_bundle(s, miI, - INSN_NOP_M, - tcg_opc_i2 (TCG_REG_P0, OPC_UNPACK4_L_I2, - TCG_REG_R2, arg1, arg1), - tcg_opc_a3 (TCG_REG_P0, OPC_AND_A3, TCG_REG_R3, - 0x1f, arg2)); - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_a3 (TCG_REG_P0, OPC_SUB_A3, TCG_REG_R3, - 0x20, TCG_REG_R3), - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_U_I5, ret, - TCG_REG_R2, TCG_REG_R3)); - } -} - -static inline void tcg_out_rotl_i64(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i10(TCG_REG_P0, OPC_SHRP_I10, ret, arg1, - arg1, 0x40 - arg2)); - } else { - tcg_out_bundle(s, mII, - tcg_opc_a3 (TCG_REG_P0, OPC_SUB_A3, TCG_REG_R2, - 0x40, arg2), - tcg_opc_i7 (TCG_REG_P0, OPC_SHL_I7, TCG_REG_R3, - arg1, arg2), - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_U_I5, TCG_REG_R2, - arg1, TCG_REG_R2)); - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_a1 (TCG_REG_P0, OPC_OR_A1, ret, - TCG_REG_R2, TCG_REG_R3)); - } -} - -static inline void tcg_out_rotr_i32(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i2 (TCG_REG_P0, OPC_UNPACK4_L_I2, - TCG_REG_R2, arg1, arg1), - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_U_I11, ret, - TCG_REG_R2, arg2, 31)); - } else { - tcg_out_bundle(s, mII, - tcg_opc_a3 (TCG_REG_P0, OPC_AND_A3, TCG_REG_R3, - 0x1f, arg2), - tcg_opc_i2 (TCG_REG_P0, OPC_UNPACK4_L_I2, - TCG_REG_R2, arg1, arg1), - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_U_I5, ret, - TCG_REG_R2, TCG_REG_R3)); - } -} - -static inline void tcg_out_rotr_i64(TCGContext *s, TCGArg ret, TCGArg arg1, - TCGArg arg2, int const_arg2) -{ - if (const_arg2) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i10(TCG_REG_P0, OPC_SHRP_I10, ret, arg1, - arg1, arg2)); - } else { - tcg_out_bundle(s, mII, - tcg_opc_a3 (TCG_REG_P0, OPC_SUB_A3, TCG_REG_R2, - 0x40, arg2), - tcg_opc_i5 (TCG_REG_P0, OPC_SHR_U_I5, TCG_REG_R3, - arg1, arg2), - tcg_opc_i7 (TCG_REG_P0, OPC_SHL_I7, TCG_REG_R2, - arg1, TCG_REG_R2)); - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_a1 (TCG_REG_P0, OPC_OR_A1, ret, - TCG_REG_R2, TCG_REG_R3)); - } -} - -static const uint64_t opc_ext_i29[8] = { - OPC_ZXT1_I29, OPC_ZXT2_I29, OPC_ZXT4_I29, 0, - OPC_SXT1_I29, OPC_SXT2_I29, OPC_SXT4_I29, 0 -}; - -static inline uint64_t tcg_opc_ext_i(int qp, TCGMemOp opc, TCGReg d, TCGReg s) -{ - if ((opc & MO_SIZE) == MO_64) { - return tcg_opc_mov_a(qp, d, s); - } else { - return tcg_opc_i29(qp, opc_ext_i29[opc & MO_SSIZE], d, s); - } -} - -static inline void tcg_out_ext(TCGContext *s, uint64_t opc_i29, - TCGArg ret, TCGArg arg) -{ - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i29(TCG_REG_P0, opc_i29, ret, arg)); -} - -static inline uint64_t tcg_opc_bswap64_i(int qp, TCGReg d, TCGReg s) -{ - return tcg_opc_i3(qp, OPC_MUX1_I3, d, s, 0xb); -} - -static inline void tcg_out_bswap16(TCGContext *s, TCGArg ret, TCGArg arg) -{ - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, ret, arg, 15, 15), - tcg_opc_bswap64_i(TCG_REG_P0, ret, ret)); -} - -static inline void tcg_out_bswap32(TCGContext *s, TCGArg ret, TCGArg arg) -{ - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, ret, arg, 31, 31), - tcg_opc_bswap64_i(TCG_REG_P0, ret, ret)); -} - -static inline void tcg_out_bswap64(TCGContext *s, TCGArg ret, TCGArg arg) -{ - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_bswap64_i(TCG_REG_P0, ret, arg)); -} - -static inline void tcg_out_deposit(TCGContext *s, TCGArg ret, TCGArg a1, - TCGArg a2, int const_a2, int pos, int len) -{ - uint64_t i1 = 0, i2 = 0; - int cpos = 63 - pos, lm1 = len - 1; - - if (const_a2) { - /* Truncate the value of a constant a2 to the width of the field. */ - int mask = (1u << len) - 1; - a2 &= mask; - - if (a2 == 0 || a2 == mask) { - /* 1-bit signed constant inserted into register. */ - i2 = tcg_opc_i14(TCG_REG_P0, OPC_DEP_I14, ret, a2, a1, cpos, lm1); - } else { - /* Otherwise, load any constant into a temporary. Do this into - the first I slot to help out with cross-unit delays. */ - i1 = tcg_opc_movi_a(TCG_REG_P0, TCG_REG_R2, a2); - a2 = TCG_REG_R2; - } - } - if (i2 == 0) { - i2 = tcg_opc_i15(TCG_REG_P0, OPC_DEP_I15, ret, a2, a1, cpos, lm1); - } - tcg_out_bundle(s, (i1 ? mII : miI), - INSN_NOP_M, - i1 ? i1 : INSN_NOP_I, - i2); -} - -static inline uint64_t tcg_opc_cmp_a(int qp, TCGCond cond, TCGArg arg1, - TCGArg arg2, int cmp4) -{ - uint64_t opc_eq_a6, opc_lt_a6, opc_ltu_a6; - - if (cmp4) { - opc_eq_a6 = OPC_CMP4_EQ_A6; - opc_lt_a6 = OPC_CMP4_LT_A6; - opc_ltu_a6 = OPC_CMP4_LTU_A6; - } else { - opc_eq_a6 = OPC_CMP_EQ_A6; - opc_lt_a6 = OPC_CMP_LT_A6; - opc_ltu_a6 = OPC_CMP_LTU_A6; - } - - switch (cond) { - case TCG_COND_EQ: - return tcg_opc_a6 (qp, opc_eq_a6, TCG_REG_P6, TCG_REG_P7, arg1, arg2); - case TCG_COND_NE: - return tcg_opc_a6 (qp, opc_eq_a6, TCG_REG_P7, TCG_REG_P6, arg1, arg2); - case TCG_COND_LT: - return tcg_opc_a6 (qp, opc_lt_a6, TCG_REG_P6, TCG_REG_P7, arg1, arg2); - case TCG_COND_LTU: - return tcg_opc_a6 (qp, opc_ltu_a6, TCG_REG_P6, TCG_REG_P7, arg1, arg2); - case TCG_COND_GE: - return tcg_opc_a6 (qp, opc_lt_a6, TCG_REG_P7, TCG_REG_P6, arg1, arg2); - case TCG_COND_GEU: - return tcg_opc_a6 (qp, opc_ltu_a6, TCG_REG_P7, TCG_REG_P6, arg1, arg2); - case TCG_COND_LE: - return tcg_opc_a6 (qp, opc_lt_a6, TCG_REG_P7, TCG_REG_P6, arg2, arg1); - case TCG_COND_LEU: - return tcg_opc_a6 (qp, opc_ltu_a6, TCG_REG_P7, TCG_REG_P6, arg2, arg1); - case TCG_COND_GT: - return tcg_opc_a6 (qp, opc_lt_a6, TCG_REG_P6, TCG_REG_P7, arg2, arg1); - case TCG_COND_GTU: - return tcg_opc_a6 (qp, opc_ltu_a6, TCG_REG_P6, TCG_REG_P7, arg2, arg1); - default: - tcg_abort(); - break; - } -} - -static inline void tcg_out_brcond(TCGContext *s, TCGCond cond, TCGReg arg1, - TCGReg arg2, TCGLabel *l, int cmp4) -{ - uint64_t imm; - - /* We pay attention here to not modify the branch target by reading - the existing value and using it again. This ensure that caches and - memory are kept coherent during retranslation. */ - if (l->has_value) { - imm = l->u.value_ptr - s->code_ptr; - } else { - imm = get_reloc_pcrel21b_slot2(s->code_ptr); - tcg_out_reloc(s, s->code_ptr, R_IA64_PCREL21B, l, 0); - } - - tcg_out_bundle(s, miB, - INSN_NOP_M, - tcg_opc_cmp_a(TCG_REG_P0, cond, arg1, arg2, cmp4), - tcg_opc_b1(TCG_REG_P6, OPC_BR_DPTK_FEW_B1, imm)); -} - -static inline void tcg_out_setcond(TCGContext *s, TCGCond cond, TCGArg ret, - TCGArg arg1, TCGArg arg2, int cmp4) -{ - tcg_out_bundle(s, MmI, - tcg_opc_cmp_a(TCG_REG_P0, cond, arg1, arg2, cmp4), - tcg_opc_movi_a(TCG_REG_P6, ret, 1), - tcg_opc_movi_a(TCG_REG_P7, ret, 0)); -} - -static inline void tcg_out_movcond(TCGContext *s, TCGCond cond, TCGArg ret, - TCGArg c1, TCGArg c2, - TCGArg v1, int const_v1, - TCGArg v2, int const_v2, int cmp4) -{ - uint64_t opc1, opc2; - - if (const_v1) { - opc1 = tcg_opc_movi_a(TCG_REG_P6, ret, v1); - } else if (ret == v1) { - opc1 = INSN_NOP_M; - } else { - opc1 = tcg_opc_mov_a(TCG_REG_P6, ret, v1); - } - if (const_v2) { - opc2 = tcg_opc_movi_a(TCG_REG_P7, ret, v2); - } else if (ret == v2) { - opc2 = INSN_NOP_I; - } else { - opc2 = tcg_opc_mov_a(TCG_REG_P7, ret, v2); - } - - tcg_out_bundle(s, MmI, - tcg_opc_cmp_a(TCG_REG_P0, cond, c1, c2, cmp4), - opc1, - opc2); -} - -#if defined(CONFIG_SOFTMMU) -/* We're expecting to use an signed 22-bit immediate add. */ -QEMU_BUILD_BUG_ON(offsetof(CPUArchState, tlb_table[NB_MMU_MODES - 1][1]) - > 0x1fffff) - -/* Load and compare a TLB entry, and return the result in (p6, p7). - R2 is loaded with the addend TLB entry. - R57 is loaded with the address, zero extented on 32-bit targets. - R1, R3 are clobbered, leaving R56 free for... - BSWAP_1, BSWAP_2 and I-slot insns for swapping data for store. */ -static inline void tcg_out_qemu_tlb(TCGContext *s, TCGReg addr_reg, - TCGMemOp opc, int off_rw, int off_add, - uint64_t bswap1, uint64_t bswap2) -{ - unsigned s_bits = opc & MO_SIZE; - unsigned a_bits = get_alignment_bits(opc); - - /* We don't support unaligned accesses, but overalignment is easy. */ - if (a_bits < s_bits) { - a_bits = s_bits; - } - - /* - .mii - mov r2 = off_rw - extr.u r3 = addr_reg, ... # extract tlb page - zxt4 r57 = addr_reg # or mov for 64-bit guest - ;; - .mii - addl r2 = r2, areg0 - shl r3 = r3, cteb # via dep.z - dep r1 = 0, r57, ... # zero page ofs, keep align - ;; - .mmi - add r2 = r2, r3 - ;; - ld4 r3 = [r2], off_add-off_rw # or ld8 for 64-bit guest - nop - ;; - .mmi - nop - cmp.eq p6, p7 = r3, r58 - nop - ;; - */ - tcg_out_bundle(s, miI, - tcg_opc_movi_a(TCG_REG_P0, TCG_REG_R2, off_rw), - tcg_opc_i11(TCG_REG_P0, OPC_EXTR_U_I11, TCG_REG_R3, - addr_reg, TARGET_PAGE_BITS, CPU_TLB_BITS - 1), - tcg_opc_ext_i(TCG_REG_P0, - TARGET_LONG_BITS == 32 ? MO_UL : MO_Q, - TCG_REG_R57, addr_reg)); - tcg_out_bundle(s, miI, - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, TCG_REG_R2, - TCG_REG_R2, TCG_AREG0), - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, TCG_REG_R3, - TCG_REG_R3, 63 - CPU_TLB_ENTRY_BITS, - 63 - CPU_TLB_ENTRY_BITS), - tcg_opc_i14(TCG_REG_P0, OPC_DEP_I14, TCG_REG_R1, 0, - TCG_REG_R57, 63 - a_bits, - TARGET_PAGE_BITS - a_bits - 1)); - tcg_out_bundle(s, MmI, - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, - TCG_REG_R2, TCG_REG_R2, TCG_REG_R3), - tcg_opc_m3 (TCG_REG_P0, - (TARGET_LONG_BITS == 32 - ? OPC_LD4_M3 : OPC_LD8_M3), TCG_REG_R3, - TCG_REG_R2, off_add - off_rw), - bswap1); - tcg_out_bundle(s, mmI, - tcg_opc_m1 (TCG_REG_P0, OPC_LD8_M1, TCG_REG_R2, TCG_REG_R2), - tcg_opc_a6 (TCG_REG_P0, OPC_CMP_EQ_A6, TCG_REG_P6, - TCG_REG_P7, TCG_REG_R1, TCG_REG_R3), - bswap2); -} - -typedef struct TCGLabelQemuLdst { - bool is_ld; - TCGMemOp size; - tcg_insn_unit *label_ptr; /* label pointers to be updated */ - struct TCGLabelQemuLdst *next; -} TCGLabelQemuLdst; - -typedef struct TCGBackendData { - TCGLabelQemuLdst *labels; -} TCGBackendData; - -static inline void tcg_out_tb_init(TCGContext *s) -{ - s->be->labels = NULL; -} - -static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOp opc, - tcg_insn_unit *label_ptr) -{ - TCGBackendData *be = s->be; - TCGLabelQemuLdst *l = tcg_malloc(sizeof(*l)); - - l->is_ld = is_ld; - l->size = opc & MO_SIZE; - l->label_ptr = label_ptr; - l->next = be->labels; - be->labels = l; -} - -static bool tcg_out_tb_finalize(TCGContext *s) -{ - static const void * const helpers[8] = { - helper_ret_stb_mmu, - helper_le_stw_mmu, - helper_le_stl_mmu, - helper_le_stq_mmu, - helper_ret_ldub_mmu, - helper_le_lduw_mmu, - helper_le_ldul_mmu, - helper_le_ldq_mmu, - }; - tcg_insn_unit *thunks[8] = { }; - TCGLabelQemuLdst *l; - - for (l = s->be->labels; l != NULL; l = l->next) { - long x = l->is_ld * 4 + l->size; - tcg_insn_unit *dest = thunks[x]; - - /* The out-of-line thunks are all the same; load the return address - from B0, load the GP, and branch to the code. Note that we are - always post-call, so the register window has rolled, so we're - using incoming parameter register numbers, not outgoing. */ - if (dest == NULL) { - uintptr_t *desc = (uintptr_t *)helpers[x]; - uintptr_t func = desc[0], gp = desc[1], disp; - - thunks[x] = dest = s->code_ptr; - - tcg_out_bundle(s, mlx, - INSN_NOP_M, - tcg_opc_l2 (gp), - tcg_opc_x2 (TCG_REG_P0, OPC_MOVL_X2, - TCG_REG_R1, gp)); - tcg_out_bundle(s, mii, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_i22(TCG_REG_P0, OPC_MOV_I22, - l->is_ld ? TCG_REG_R35 : TCG_REG_R36, - TCG_REG_B0)); - disp = (tcg_insn_unit *)func - s->code_ptr; - tcg_out_bundle(s, mLX, - INSN_NOP_M, - tcg_opc_l3 (disp), - tcg_opc_x3 (TCG_REG_P0, OPC_BRL_SPTK_MANY_X3, disp)); - } - - reloc_pcrel21b_slot2(l->label_ptr, dest); - - /* Test for (pending) buffer overflow. The assumption is that any - one operation beginning below the high water mark cannot overrun - the buffer completely. Thus we can test for overflow after - generating code without having to check during generation. */ - if (unlikely((void *)s->code_ptr > s->code_gen_highwater)) { - return false; - } - } - return true; -} - -static inline void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args) -{ - static const uint64_t opc_ld_m1[4] = { - OPC_LD1_M1, OPC_LD2_M1, OPC_LD4_M1, OPC_LD8_M1 - }; - int addr_reg, data_reg, mem_index; - TCGMemOpIdx oi; - TCGMemOp opc, s_bits; - uint64_t fin1, fin2; - tcg_insn_unit *label_ptr; - - data_reg = args[0]; - addr_reg = args[1]; - oi = args[2]; - opc = get_memop(oi); - mem_index = get_mmuidx(oi); - s_bits = opc & MO_SIZE; - - /* Read the TLB entry */ - tcg_out_qemu_tlb(s, addr_reg, opc, - offsetof(CPUArchState, tlb_table[mem_index][0].addr_read), - offsetof(CPUArchState, tlb_table[mem_index][0].addend), - INSN_NOP_I, INSN_NOP_I); - - /* P6 is the fast path, and P7 the slow path */ - - fin2 = 0; - if (opc & MO_BSWAP) { - fin1 = tcg_opc_bswap64_i(TCG_REG_P0, data_reg, TCG_REG_R8); - if (s_bits < MO_64) { - int shift = 64 - (8 << s_bits); - fin2 = (opc & MO_SIGN ? OPC_EXTR_I11 : OPC_EXTR_U_I11); - fin2 = tcg_opc_i11(TCG_REG_P0, fin2, - data_reg, data_reg, shift, 63 - shift); - } - } else { - fin1 = tcg_opc_ext_i(TCG_REG_P0, opc, data_reg, TCG_REG_R8); - } - - tcg_out_bundle(s, mmI, - tcg_opc_mov_a(TCG_REG_P7, TCG_REG_R56, TCG_AREG0), - tcg_opc_a1 (TCG_REG_P6, OPC_ADD_A1, TCG_REG_R2, - TCG_REG_R2, TCG_REG_R57), - tcg_opc_movi_a(TCG_REG_P7, TCG_REG_R58, oi)); - label_ptr = s->code_ptr; - tcg_out_bundle(s, miB, - tcg_opc_m1 (TCG_REG_P6, opc_ld_m1[s_bits], - TCG_REG_R8, TCG_REG_R2), - INSN_NOP_I, - tcg_opc_b3 (TCG_REG_P7, OPC_BR_CALL_SPNT_FEW_B3, TCG_REG_B0, - get_reloc_pcrel21b_slot2(label_ptr))); - - add_qemu_ldst_label(s, 1, opc, label_ptr); - - /* Note that we always use LE helper functions, so the bswap insns - here for the fast path also apply to the slow path. */ - tcg_out_bundle(s, (fin2 ? mII : miI), - INSN_NOP_M, - fin1, - fin2 ? fin2 : INSN_NOP_I); -} - -static inline void tcg_out_qemu_st(TCGContext *s, const TCGArg *args) -{ - static const uint64_t opc_st_m4[4] = { - OPC_ST1_M4, OPC_ST2_M4, OPC_ST4_M4, OPC_ST8_M4 - }; - TCGReg addr_reg, data_reg; - int mem_index; - uint64_t pre1, pre2; - TCGMemOpIdx oi; - TCGMemOp opc, s_bits; - tcg_insn_unit *label_ptr; - - data_reg = args[0]; - addr_reg = args[1]; - oi = args[2]; - opc = get_memop(oi); - mem_index = get_mmuidx(oi); - s_bits = opc & MO_SIZE; - - /* Note that we always use LE helper functions, so the bswap insns - that are here for the fast path also apply to the slow path, - and move the data into the argument register. */ - pre2 = INSN_NOP_I; - if (opc & MO_BSWAP) { - pre1 = tcg_opc_bswap64_i(TCG_REG_P0, TCG_REG_R58, data_reg); - if (s_bits < MO_64) { - int shift = 64 - (8 << s_bits); - pre2 = tcg_opc_i11(TCG_REG_P0, OPC_EXTR_U_I11, - TCG_REG_R58, TCG_REG_R58, shift, 63 - shift); - } - } else { - /* Just move the data into place for the slow path. */ - pre1 = tcg_opc_ext_i(TCG_REG_P0, opc, TCG_REG_R58, data_reg); - } - - tcg_out_qemu_tlb(s, addr_reg, opc, - offsetof(CPUArchState, tlb_table[mem_index][0].addr_write), - offsetof(CPUArchState, tlb_table[mem_index][0].addend), - pre1, pre2); - - /* P6 is the fast path, and P7 the slow path */ - tcg_out_bundle(s, mmI, - tcg_opc_mov_a(TCG_REG_P7, TCG_REG_R56, TCG_AREG0), - tcg_opc_a1 (TCG_REG_P6, OPC_ADD_A1, TCG_REG_R2, - TCG_REG_R2, TCG_REG_R57), - tcg_opc_movi_a(TCG_REG_P7, TCG_REG_R59, oi)); - label_ptr = s->code_ptr; - tcg_out_bundle(s, miB, - tcg_opc_m4 (TCG_REG_P6, opc_st_m4[s_bits], - TCG_REG_R58, TCG_REG_R2), - INSN_NOP_I, - tcg_opc_b3 (TCG_REG_P7, OPC_BR_CALL_SPNT_FEW_B3, TCG_REG_B0, - get_reloc_pcrel21b_slot2(label_ptr))); - - add_qemu_ldst_label(s, 0, opc, label_ptr); -} - -#else /* !CONFIG_SOFTMMU */ -# include "tcg-be-null.h" - -static inline void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args) -{ - static uint64_t const opc_ld_m1[4] = { - OPC_LD1_M1, OPC_LD2_M1, OPC_LD4_M1, OPC_LD8_M1 - }; - int addr_reg, data_reg; - TCGMemOp opc, s_bits, bswap; - - data_reg = args[0]; - addr_reg = args[1]; - opc = args[2]; - s_bits = opc & MO_SIZE; - bswap = opc & MO_BSWAP; - -#if TARGET_LONG_BITS == 32 - if (guest_base != 0) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i29(TCG_REG_P0, OPC_ZXT4_I29, - TCG_REG_R3, addr_reg), - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, TCG_REG_R2, - TCG_GUEST_BASE_REG, TCG_REG_R3)); - } else { - tcg_out_bundle(s, miI, - INSN_NOP_M, - tcg_opc_i29(TCG_REG_P0, OPC_ZXT4_I29, - TCG_REG_R2, addr_reg), - INSN_NOP_I); - } - - if (!bswap) { - if (!(opc & MO_SIGN)) { - tcg_out_bundle(s, miI, - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_I, - INSN_NOP_I); - } else { - tcg_out_bundle(s, mII, - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_I, - tcg_opc_ext_i(TCG_REG_P0, opc, data_reg, data_reg)); - } - } else if (s_bits == MO_64) { - tcg_out_bundle(s, mII, - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_I, - tcg_opc_bswap64_i(TCG_REG_P0, data_reg, data_reg)); - } else { - if (s_bits == MO_16) { - tcg_out_bundle(s, mII, - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_I, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - data_reg, data_reg, 15, 15)); - } else { - tcg_out_bundle(s, mII, - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_I, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - data_reg, data_reg, 31, 31)); - } - if (!(opc & MO_SIGN)) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_bswap64_i(TCG_REG_P0, data_reg, data_reg)); - } else { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_bswap64_i(TCG_REG_P0, data_reg, data_reg), - tcg_opc_ext_i(TCG_REG_P0, opc, data_reg, data_reg)); - } - } -#else - if (guest_base != 0) { - tcg_out_bundle(s, MmI, - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, TCG_REG_R2, - TCG_GUEST_BASE_REG, addr_reg), - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_I); - } else { - tcg_out_bundle(s, mmI, - INSN_NOP_M, - tcg_opc_m1 (TCG_REG_P0, opc_ld_m1[s_bits], - data_reg, addr_reg), - INSN_NOP_I); - } - - if (bswap && s_bits == MO_16) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - data_reg, data_reg, 15, 15), - tcg_opc_bswap64_i(TCG_REG_P0, data_reg, data_reg)); - } else if (bswap && s_bits == MO_32) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - data_reg, data_reg, 31, 31), - tcg_opc_bswap64_i(TCG_REG_P0, data_reg, data_reg)); - } else if (bswap && s_bits == MO_64) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_bswap64_i(TCG_REG_P0, data_reg, data_reg)); - } - if (opc & MO_SIGN) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_ext_i(TCG_REG_P0, opc, data_reg, data_reg)); - } -#endif -} - -static inline void tcg_out_qemu_st(TCGContext *s, const TCGArg *args) -{ - static uint64_t const opc_st_m4[4] = { - OPC_ST1_M4, OPC_ST2_M4, OPC_ST4_M4, OPC_ST8_M4 - }; - int addr_reg, data_reg; -#if TARGET_LONG_BITS == 64 - uint64_t add_guest_base; -#endif - TCGMemOp opc, s_bits, bswap; - - data_reg = args[0]; - addr_reg = args[1]; - opc = args[2]; - s_bits = opc & MO_SIZE; - bswap = opc & MO_BSWAP; - -#if TARGET_LONG_BITS == 32 - if (guest_base != 0) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i29(TCG_REG_P0, OPC_ZXT4_I29, - TCG_REG_R3, addr_reg), - tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, TCG_REG_R2, - TCG_GUEST_BASE_REG, TCG_REG_R3)); - } else { - tcg_out_bundle(s, miI, - INSN_NOP_M, - tcg_opc_i29(TCG_REG_P0, OPC_ZXT4_I29, - TCG_REG_R2, addr_reg), - INSN_NOP_I); - } - - if (bswap) { - if (s_bits == MO_16) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - TCG_REG_R3, data_reg, 15, 15), - tcg_opc_bswap64_i(TCG_REG_P0, - TCG_REG_R3, TCG_REG_R3)); - data_reg = TCG_REG_R3; - } else if (s_bits == MO_32) { - tcg_out_bundle(s, mII, - INSN_NOP_M, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - TCG_REG_R3, data_reg, 31, 31), - tcg_opc_bswap64_i(TCG_REG_P0, - TCG_REG_R3, TCG_REG_R3)); - data_reg = TCG_REG_R3; - } else if (s_bits == MO_64) { - tcg_out_bundle(s, miI, - INSN_NOP_M, - INSN_NOP_I, - tcg_opc_bswap64_i(TCG_REG_P0, TCG_REG_R3, data_reg)); - data_reg = TCG_REG_R3; - } - } - tcg_out_bundle(s, mmI, - tcg_opc_m4 (TCG_REG_P0, opc_st_m4[s_bits], - data_reg, TCG_REG_R2), - INSN_NOP_M, - INSN_NOP_I); -#else - if (guest_base != 0) { - add_guest_base = tcg_opc_a1 (TCG_REG_P0, OPC_ADD_A1, TCG_REG_R2, - TCG_GUEST_BASE_REG, addr_reg); - addr_reg = TCG_REG_R2; - } else { - add_guest_base = INSN_NOP_M; - } - - if (!bswap) { - tcg_out_bundle(s, (guest_base ? MmI : mmI), - add_guest_base, - tcg_opc_m4 (TCG_REG_P0, opc_st_m4[s_bits], - data_reg, addr_reg), - INSN_NOP_I); - } else { - if (s_bits == MO_16) { - tcg_out_bundle(s, mII, - add_guest_base, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - TCG_REG_R3, data_reg, 15, 15), - tcg_opc_bswap64_i(TCG_REG_P0, - TCG_REG_R3, TCG_REG_R3)); - data_reg = TCG_REG_R3; - } else if (s_bits == MO_32) { - tcg_out_bundle(s, mII, - add_guest_base, - tcg_opc_i12(TCG_REG_P0, OPC_DEP_Z_I12, - TCG_REG_R3, data_reg, 31, 31), - tcg_opc_bswap64_i(TCG_REG_P0, - TCG_REG_R3, TCG_REG_R3)); - data_reg = TCG_REG_R3; - } else if (s_bits == MO_64) { - tcg_out_bundle(s, miI, - add_guest_base, - INSN_NOP_I, - tcg_opc_bswap64_i(TCG_REG_P0, TCG_REG_R3, data_reg)); - data_reg = TCG_REG_R3; - } - tcg_out_bundle(s, miI, - tcg_opc_m4 (TCG_REG_P0, opc_st_m4[s_bits], - data_reg, addr_reg), - INSN_NOP_I, - INSN_NOP_I); - } -#endif -} - -#endif - -static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, - const TCGArg *args, const int *const_args) -{ - switch(opc) { - case INDEX_op_exit_tb: - tcg_out_exit_tb(s, args[0]); - break; - case INDEX_op_br: - tcg_out_br(s, arg_label(args[0])); - break; - case INDEX_op_goto_tb: - tcg_out_goto_tb(s, args[0]); - break; - - case INDEX_op_ld8u_i32: - case INDEX_op_ld8u_i64: - tcg_out_ld_rel(s, OPC_LD1_M1, args[0], args[1], args[2]); - break; - case INDEX_op_ld8s_i32: - case INDEX_op_ld8s_i64: - tcg_out_ld_rel(s, OPC_LD1_M1, args[0], args[1], args[2]); - tcg_out_ext(s, OPC_SXT1_I29, args[0], args[0]); - break; - case INDEX_op_ld16u_i32: - case INDEX_op_ld16u_i64: - tcg_out_ld_rel(s, OPC_LD2_M1, args[0], args[1], args[2]); - break; - case INDEX_op_ld16s_i32: - case INDEX_op_ld16s_i64: - tcg_out_ld_rel(s, OPC_LD2_M1, args[0], args[1], args[2]); - tcg_out_ext(s, OPC_SXT2_I29, args[0], args[0]); - break; - case INDEX_op_ld_i32: - case INDEX_op_ld32u_i64: - tcg_out_ld_rel(s, OPC_LD4_M1, args[0], args[1], args[2]); - break; - case INDEX_op_ld32s_i64: - tcg_out_ld_rel(s, OPC_LD4_M1, args[0], args[1], args[2]); - tcg_out_ext(s, OPC_SXT4_I29, args[0], args[0]); - break; - case INDEX_op_ld_i64: - tcg_out_ld_rel(s, OPC_LD8_M1, args[0], args[1], args[2]); - break; - case INDEX_op_st8_i32: - case INDEX_op_st8_i64: - tcg_out_st_rel(s, OPC_ST1_M4, args[0], args[1], args[2]); - break; - case INDEX_op_st16_i32: - case INDEX_op_st16_i64: - tcg_out_st_rel(s, OPC_ST2_M4, args[0], args[1], args[2]); - break; - case INDEX_op_st_i32: - case INDEX_op_st32_i64: - tcg_out_st_rel(s, OPC_ST4_M4, args[0], args[1], args[2]); - break; - case INDEX_op_st_i64: - tcg_out_st_rel(s, OPC_ST8_M4, args[0], args[1], args[2]); - break; - - case INDEX_op_add_i32: - case INDEX_op_add_i64: - tcg_out_add(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_sub_i32: - case INDEX_op_sub_i64: - tcg_out_sub(s, args[0], args[1], const_args[1], args[2], const_args[2]); - break; - - case INDEX_op_and_i32: - case INDEX_op_and_i64: - /* TCG expects arg2 constant; A3 expects arg1 constant. Swap. */ - tcg_out_alu(s, OPC_AND_A1, OPC_AND_A3, args[0], - args[2], const_args[2], args[1], const_args[1]); - break; - case INDEX_op_andc_i32: - case INDEX_op_andc_i64: - tcg_out_alu(s, OPC_ANDCM_A1, OPC_ANDCM_A3, args[0], - args[1], const_args[1], args[2], const_args[2]); - break; - case INDEX_op_eqv_i32: - case INDEX_op_eqv_i64: - tcg_out_eqv(s, args[0], args[1], const_args[1], - args[2], const_args[2]); - break; - case INDEX_op_nand_i32: - case INDEX_op_nand_i64: - tcg_out_nand(s, args[0], args[1], const_args[1], - args[2], const_args[2]); - break; - case INDEX_op_nor_i32: - case INDEX_op_nor_i64: - tcg_out_nor(s, args[0], args[1], const_args[1], - args[2], const_args[2]); - break; - case INDEX_op_or_i32: - case INDEX_op_or_i64: - /* TCG expects arg2 constant; A3 expects arg1 constant. Swap. */ - tcg_out_alu(s, OPC_OR_A1, OPC_OR_A3, args[0], - args[2], const_args[2], args[1], const_args[1]); - break; - case INDEX_op_orc_i32: - case INDEX_op_orc_i64: - tcg_out_orc(s, args[0], args[1], const_args[1], - args[2], const_args[2]); - break; - case INDEX_op_xor_i32: - case INDEX_op_xor_i64: - /* TCG expects arg2 constant; A3 expects arg1 constant. Swap. */ - tcg_out_alu(s, OPC_XOR_A1, OPC_XOR_A3, args[0], - args[2], const_args[2], args[1], const_args[1]); - break; - - case INDEX_op_mul_i32: - case INDEX_op_mul_i64: - tcg_out_mul(s, args[0], args[1], args[2]); - break; - - case INDEX_op_sar_i32: - tcg_out_sar_i32(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_sar_i64: - tcg_out_sar_i64(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_shl_i32: - tcg_out_shl_i32(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_shl_i64: - tcg_out_shl_i64(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_shr_i32: - tcg_out_shr_i32(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_shr_i64: - tcg_out_shr_i64(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_rotl_i32: - tcg_out_rotl_i32(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_rotl_i64: - tcg_out_rotl_i64(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_rotr_i32: - tcg_out_rotr_i32(s, args[0], args[1], args[2], const_args[2]); - break; - case INDEX_op_rotr_i64: - tcg_out_rotr_i64(s, args[0], args[1], args[2], const_args[2]); - break; - - case INDEX_op_ext8s_i32: - case INDEX_op_ext8s_i64: - tcg_out_ext(s, OPC_SXT1_I29, args[0], args[1]); - break; - case INDEX_op_ext8u_i32: - case INDEX_op_ext8u_i64: - tcg_out_ext(s, OPC_ZXT1_I29, args[0], args[1]); - break; - case INDEX_op_ext16s_i32: - case INDEX_op_ext16s_i64: - tcg_out_ext(s, OPC_SXT2_I29, args[0], args[1]); - break; - case INDEX_op_ext16u_i32: - case INDEX_op_ext16u_i64: - tcg_out_ext(s, OPC_ZXT2_I29, args[0], args[1]); - break; - case INDEX_op_ext_i32_i64: - case INDEX_op_ext32s_i64: - tcg_out_ext(s, OPC_SXT4_I29, args[0], args[1]); - break; - case INDEX_op_extu_i32_i64: - case INDEX_op_ext32u_i64: - tcg_out_ext(s, OPC_ZXT4_I29, args[0], args[1]); - break; - - case INDEX_op_bswap16_i32: - case INDEX_op_bswap16_i64: - tcg_out_bswap16(s, args[0], args[1]); - break; - case INDEX_op_bswap32_i32: - case INDEX_op_bswap32_i64: - tcg_out_bswap32(s, args[0], args[1]); - break; - case INDEX_op_bswap64_i64: - tcg_out_bswap64(s, args[0], args[1]); - break; - - case INDEX_op_deposit_i32: - case INDEX_op_deposit_i64: - tcg_out_deposit(s, args[0], args[1], args[2], const_args[2], - args[3], args[4]); - break; - - case INDEX_op_brcond_i32: - tcg_out_brcond(s, args[2], args[0], args[1], arg_label(args[3]), 1); - break; - case INDEX_op_brcond_i64: - tcg_out_brcond(s, args[2], args[0], args[1], arg_label(args[3]), 0); - break; - case INDEX_op_setcond_i32: - tcg_out_setcond(s, args[3], args[0], args[1], args[2], 1); - break; - case INDEX_op_setcond_i64: - tcg_out_setcond(s, args[3], args[0], args[1], args[2], 0); - break; - case INDEX_op_movcond_i32: - tcg_out_movcond(s, args[5], args[0], args[1], args[2], - args[3], const_args[3], args[4], const_args[4], 1); - break; - case INDEX_op_movcond_i64: - tcg_out_movcond(s, args[5], args[0], args[1], args[2], - args[3], const_args[3], args[4], const_args[4], 0); - break; - - case INDEX_op_qemu_ld_i32: - tcg_out_qemu_ld(s, args); - break; - case INDEX_op_qemu_ld_i64: - tcg_out_qemu_ld(s, args); - break; - case INDEX_op_qemu_st_i32: - tcg_out_qemu_st(s, args); - break; - case INDEX_op_qemu_st_i64: - tcg_out_qemu_st(s, args); - break; - - case INDEX_op_mb: - tcg_out_bundle(s, mmI, OPC_MF_M24, INSN_NOP_M, INSN_NOP_I); - break; - case INDEX_op_mov_i32: /* Always emitted via tcg_out_mov. */ - case INDEX_op_mov_i64: - case INDEX_op_movi_i32: /* Always emitted via tcg_out_movi. */ - case INDEX_op_movi_i64: - case INDEX_op_call: /* Always emitted via tcg_out_call. */ - default: - tcg_abort(); - } -} - -static const TCGTargetOpDef ia64_op_defs[] = { - { INDEX_op_br, { } }, - { INDEX_op_exit_tb, { } }, - { INDEX_op_goto_tb, { } }, - - { INDEX_op_ld8u_i32, { "r", "r" } }, - { INDEX_op_ld8s_i32, { "r", "r" } }, - { INDEX_op_ld16u_i32, { "r", "r" } }, - { INDEX_op_ld16s_i32, { "r", "r" } }, - { INDEX_op_ld_i32, { "r", "r" } }, - { INDEX_op_st8_i32, { "rZ", "r" } }, - { INDEX_op_st16_i32, { "rZ", "r" } }, - { INDEX_op_st_i32, { "rZ", "r" } }, - - { INDEX_op_add_i32, { "r", "rZ", "rI" } }, - { INDEX_op_sub_i32, { "r", "rI", "rI" } }, - - { INDEX_op_and_i32, { "r", "rI", "rI" } }, - { INDEX_op_andc_i32, { "r", "rI", "rI" } }, - { INDEX_op_eqv_i32, { "r", "rZ", "rZ" } }, - { INDEX_op_nand_i32, { "r", "rZ", "rZ" } }, - { INDEX_op_nor_i32, { "r", "rZ", "rZ" } }, - { INDEX_op_or_i32, { "r", "rI", "rI" } }, - { INDEX_op_orc_i32, { "r", "rZ", "rZ" } }, - { INDEX_op_xor_i32, { "r", "rI", "rI" } }, - - { INDEX_op_mul_i32, { "r", "rZ", "rZ" } }, - - { INDEX_op_sar_i32, { "r", "rZ", "ri" } }, - { INDEX_op_shl_i32, { "r", "rZ", "ri" } }, - { INDEX_op_shr_i32, { "r", "rZ", "ri" } }, - { INDEX_op_rotl_i32, { "r", "rZ", "ri" } }, - { INDEX_op_rotr_i32, { "r", "rZ", "ri" } }, - - { INDEX_op_ext8s_i32, { "r", "rZ"} }, - { INDEX_op_ext8u_i32, { "r", "rZ"} }, - { INDEX_op_ext16s_i32, { "r", "rZ"} }, - { INDEX_op_ext16u_i32, { "r", "rZ"} }, - - { INDEX_op_bswap16_i32, { "r", "rZ" } }, - { INDEX_op_bswap32_i32, { "r", "rZ" } }, - - { INDEX_op_brcond_i32, { "rZ", "rZ" } }, - { INDEX_op_setcond_i32, { "r", "rZ", "rZ" } }, - { INDEX_op_movcond_i32, { "r", "rZ", "rZ", "rI", "rI" } }, - - { INDEX_op_ld8u_i64, { "r", "r" } }, - { INDEX_op_ld8s_i64, { "r", "r" } }, - { INDEX_op_ld16u_i64, { "r", "r" } }, - { INDEX_op_ld16s_i64, { "r", "r" } }, - { INDEX_op_ld32u_i64, { "r", "r" } }, - { INDEX_op_ld32s_i64, { "r", "r" } }, - { INDEX_op_ld_i64, { "r", "r" } }, - { INDEX_op_st8_i64, { "rZ", "r" } }, - { INDEX_op_st16_i64, { "rZ", "r" } }, - { INDEX_op_st32_i64, { "rZ", "r" } }, - { INDEX_op_st_i64, { "rZ", "r" } }, - - { INDEX_op_add_i64, { "r", "rZ", "rI" } }, - { INDEX_op_sub_i64, { "r", "rI", "rI" } }, - - { INDEX_op_and_i64, { "r", "rI", "rI" } }, - { INDEX_op_andc_i64, { "r", "rI", "rI" } }, - { INDEX_op_eqv_i64, { "r", "rZ", "rZ" } }, - { INDEX_op_nand_i64, { "r", "rZ", "rZ" } }, - { INDEX_op_nor_i64, { "r", "rZ", "rZ" } }, - { INDEX_op_or_i64, { "r", "rI", "rI" } }, - { INDEX_op_orc_i64, { "r", "rZ", "rZ" } }, - { INDEX_op_xor_i64, { "r", "rI", "rI" } }, - - { INDEX_op_mul_i64, { "r", "rZ", "rZ" } }, - - { INDEX_op_sar_i64, { "r", "rZ", "ri" } }, - { INDEX_op_shl_i64, { "r", "rZ", "ri" } }, - { INDEX_op_shr_i64, { "r", "rZ", "ri" } }, - { INDEX_op_rotl_i64, { "r", "rZ", "ri" } }, - { INDEX_op_rotr_i64, { "r", "rZ", "ri" } }, - - { INDEX_op_ext8s_i64, { "r", "rZ"} }, - { INDEX_op_ext8u_i64, { "r", "rZ"} }, - { INDEX_op_ext16s_i64, { "r", "rZ"} }, - { INDEX_op_ext16u_i64, { "r", "rZ"} }, - { INDEX_op_ext32s_i64, { "r", "rZ"} }, - { INDEX_op_ext32u_i64, { "r", "rZ"} }, - { INDEX_op_ext_i32_i64, { "r", "rZ" } }, - { INDEX_op_extu_i32_i64, { "r", "rZ" } }, - - { INDEX_op_bswap16_i64, { "r", "rZ" } }, - { INDEX_op_bswap32_i64, { "r", "rZ" } }, - { INDEX_op_bswap64_i64, { "r", "rZ" } }, - - { INDEX_op_brcond_i64, { "rZ", "rZ" } }, - { INDEX_op_setcond_i64, { "r", "rZ", "rZ" } }, - { INDEX_op_movcond_i64, { "r", "rZ", "rZ", "rI", "rI" } }, - - { INDEX_op_deposit_i32, { "r", "rZ", "ri" } }, - { INDEX_op_deposit_i64, { "r", "rZ", "ri" } }, - - { INDEX_op_qemu_ld_i32, { "r", "r" } }, - { INDEX_op_qemu_ld_i64, { "r", "r" } }, - { INDEX_op_qemu_st_i32, { "SZ", "r" } }, - { INDEX_op_qemu_st_i64, { "SZ", "r" } }, - - { INDEX_op_mb, { } }, - { -1 }, -}; - -static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode op) -{ - int i, n = ARRAY_SIZE(ia64_op_defs); - - for (i = 0; i < n; ++i) { - if (ia64_op_defs[i].op == op) { - return &ia64_op_defs[i]; - } - } - return NULL; -} - -/* Generate global QEMU prologue and epilogue code */ -static void tcg_target_qemu_prologue(TCGContext *s) -{ - int frame_size; - - /* reserve some stack space */ - frame_size = TCG_STATIC_CALL_ARGS_SIZE + - CPU_TEMP_BUF_NLONGS * sizeof(long); - frame_size = (frame_size + TCG_TARGET_STACK_ALIGN - 1) & - ~(TCG_TARGET_STACK_ALIGN - 1); - tcg_set_frame(s, TCG_REG_CALL_STACK, TCG_STATIC_CALL_ARGS_SIZE, - CPU_TEMP_BUF_NLONGS * sizeof(long)); - - /* First emit adhoc function descriptor */ - *s->code_ptr = (tcg_insn_unit){ - (uint64_t)(s->code_ptr + 1), /* entry point */ - 0 /* skip gp */ - }; - s->code_ptr++; - - /* prologue */ - tcg_out_bundle(s, miI, - tcg_opc_m34(TCG_REG_P0, OPC_ALLOC_M34, - TCG_REG_R34, 32, 24, 0), - INSN_NOP_I, - tcg_opc_i21(TCG_REG_P0, OPC_MOV_I21, - TCG_REG_B6, TCG_REG_R33, 0)); - - /* ??? If guest_base < 0x200000, we could load the register via - an ADDL in the M slot of the next bundle. */ - if (guest_base != 0) { - tcg_out_bundle(s, mlx, - INSN_NOP_M, - tcg_opc_l2(guest_base), - tcg_opc_x2 (TCG_REG_P0, OPC_MOVL_X2, - TCG_GUEST_BASE_REG, guest_base)); - tcg_regset_set_reg(s->reserved_regs, TCG_GUEST_BASE_REG); - } - - tcg_out_bundle(s, miB, - tcg_opc_a4 (TCG_REG_P0, OPC_ADDS_A4, - TCG_REG_R12, -frame_size, TCG_REG_R12), - tcg_opc_i22(TCG_REG_P0, OPC_MOV_I22, - TCG_REG_R33, TCG_REG_B0), - tcg_opc_b4 (TCG_REG_P0, OPC_BR_SPTK_MANY_B4, TCG_REG_B6)); - - /* epilogue */ - tb_ret_addr = s->code_ptr; - tcg_out_bundle(s, miI, - INSN_NOP_M, - tcg_opc_i21(TCG_REG_P0, OPC_MOV_I21, - TCG_REG_B0, TCG_REG_R33, 0), - tcg_opc_a4 (TCG_REG_P0, OPC_ADDS_A4, - TCG_REG_R12, frame_size, TCG_REG_R12)); - tcg_out_bundle(s, miB, - INSN_NOP_M, - tcg_opc_i26(TCG_REG_P0, OPC_MOV_I_I26, - TCG_REG_PFS, TCG_REG_R34), - tcg_opc_b4 (TCG_REG_P0, OPC_BR_RET_SPTK_MANY_B4, - TCG_REG_B0)); -} - -static void tcg_target_init(TCGContext *s) -{ - tcg_regset_set(tcg_target_available_regs[TCG_TYPE_I32], - 0xffffffffffffffffull); - tcg_regset_set(tcg_target_available_regs[TCG_TYPE_I64], - 0xffffffffffffffffull); - - tcg_regset_clear(tcg_target_call_clobber_regs); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R8); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R9); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R10); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R11); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R14); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R15); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R16); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R17); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R18); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R19); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R20); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R21); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R22); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R23); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R24); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R25); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R26); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R27); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R28); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R29); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R30); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R31); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R56); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R57); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R58); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R59); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R60); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R61); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R62); - tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R63); - - tcg_regset_clear(s->reserved_regs); - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R0); /* zero register */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R1); /* global pointer */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R2); /* internal use */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R3); /* internal use */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R12); /* stack pointer */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R13); /* thread pointer */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R33); /* return address */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R34); /* PFS */ - - /* The following 4 are not in use, are call-saved, but *not* saved - by the prologue. Therefore we cannot use them without modifying - the prologue. There doesn't seem to be any good reason to use - these as opposed to the windowed registers. */ - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R4); - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R5); - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R6); - tcg_regset_set_reg(s->reserved_regs, TCG_REG_R7); -} diff --git a/tcg/mips/tcg-target.h b/tcg/mips/tcg-target.h index d75cb63ed3..e9558d15bc 100644 --- a/tcg/mips/tcg-target.h +++ b/tcg/mips/tcg-target.h @@ -206,4 +206,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) cacheflush ((void *)start, stop-start, ICACHE); } +#define TCG_TARGET_DEFAULT_MO (0) + #endif diff --git a/tcg/ppc/tcg-target.h b/tcg/ppc/tcg-target.h index 5f4a40a5b4..5a092b038a 100644 --- a/tcg/ppc/tcg-target.h +++ b/tcg/ppc/tcg-target.h @@ -125,4 +125,6 @@ extern bool have_isa_3_00; void flush_icache_range(uintptr_t start, uintptr_t stop); +#define TCG_TARGET_DEFAULT_MO (0) + #endif diff --git a/tcg/s390/tcg-target.h b/tcg/s390/tcg-target.h index 957f0c0afe..bedda5edf6 100644 --- a/tcg/s390/tcg-target.h +++ b/tcg/s390/tcg-target.h @@ -58,6 +58,8 @@ typedef enum TCGReg { #define FACILITY_GEN_INST_EXT (1ULL << (63 - 34)) #define FACILITY_LOAD_ON_COND (1ULL << (63 - 45)) #define FACILITY_FAST_BCR_SER FACILITY_LOAD_ON_COND +#define FACILITY_DISTINCT_OPS FACILITY_LOAD_ON_COND +#define FACILITY_LOAD_ON_COND2 (1ULL << (63 - 53)) extern uint64_t s390_facilities; @@ -133,6 +135,8 @@ extern uint64_t s390_facilities; #define TCG_TARGET_EXTEND_ARGS 1 +#define TCG_TARGET_DEFAULT_MO (TCG_MO_ALL & ~TCG_MO_ST_LD) + enum { TCG_AREG0 = TCG_REG_R10, }; diff --git a/tcg/s390/tcg-target.inc.c b/tcg/s390/tcg-target.inc.c index 5d7083e90c..38b9e791ee 100644 --- a/tcg/s390/tcg-target.inc.c +++ b/tcg/s390/tcg-target.inc.c @@ -38,12 +38,13 @@ a 32-bit displacement here Just In Case. */ #define USE_LONG_BRANCHES 0 -#define TCG_CT_CONST_MULI 0x100 -#define TCG_CT_CONST_ORI 0x200 -#define TCG_CT_CONST_XORI 0x400 -#define TCG_CT_CONST_CMPI 0x800 -#define TCG_CT_CONST_ADLI 0x1000 -#define TCG_CT_CONST_ZERO 0x2000 +#define TCG_CT_CONST_S16 0x100 +#define TCG_CT_CONST_S32 0x200 +#define TCG_CT_CONST_NN16 0x400 +#define TCG_CT_CONST_NN32 0x800 +#define TCG_CT_CONST_U31 0x1000 +#define TCG_CT_CONST_S33 0x2000 +#define TCG_CT_CONST_ZERO 0x4000 /* Several places within the instruction set 0 means "no register" rather than TCG_REG_R0. */ @@ -121,6 +122,7 @@ typedef enum S390Opcode { RIE_CLGIJ = 0xec7d, RIE_CLRJ = 0xec77, RIE_CRJ = 0xec76, + RIE_LOCGHI = 0xec46, RIE_RISBG = 0xec55, RRE_AGR = 0xb908, @@ -158,6 +160,16 @@ typedef enum S390Opcode { RRF_LOCR = 0xb9f2, RRF_LOCGR = 0xb9e2, + RRF_NRK = 0xb9f4, + RRF_NGRK = 0xb9e4, + RRF_ORK = 0xb9f6, + RRF_OGRK = 0xb9e6, + RRF_SRK = 0xb9f9, + RRF_SGRK = 0xb9e9, + RRF_SLRK = 0xb9fb, + RRF_SLGRK = 0xb9eb, + RRF_XRK = 0xb9f7, + RRF_XGRK = 0xb9e7, RR_AR = 0x1a, RR_ALR = 0x1e, @@ -178,8 +190,11 @@ typedef enum S390Opcode { RSY_RLL = 0xeb1d, RSY_RLLG = 0xeb1c, RSY_SLLG = 0xeb0d, + RSY_SLLK = 0xebdf, RSY_SRAG = 0xeb0a, + RSY_SRAK = 0xebdc, RSY_SRLG = 0xeb0c, + RSY_SRLK = 0xebde, RS_SLL = 0x89, RS_SRA = 0x8a, @@ -386,19 +401,33 @@ static const char *target_parse_constraint(TCGArgConstraint *ct, tcg_regset_set_reg(ct->u.regs, TCG_REG_R3); break; case 'A': - ct->ct |= TCG_CT_CONST_ADLI; + ct->ct |= TCG_CT_CONST_S33; break; - case 'K': - ct->ct |= TCG_CT_CONST_MULI; + case 'I': + ct->ct |= TCG_CT_CONST_S16; break; - case 'O': - ct->ct |= TCG_CT_CONST_ORI; + case 'J': + ct->ct |= TCG_CT_CONST_S32; break; - case 'X': - ct->ct |= TCG_CT_CONST_XORI; + case 'N': + ct->ct |= TCG_CT_CONST_NN16; + break; + case 'M': + ct->ct |= TCG_CT_CONST_NN32; break; case 'C': - ct->ct |= TCG_CT_CONST_CMPI; + /* ??? We have no insight here into whether the comparison is + signed or unsigned. The COMPARE IMMEDIATE insn uses a 32-bit + signed immediate, and the COMPARE LOGICAL IMMEDIATE insn uses + a 32-bit unsigned immediate. If we were to use the (semi) + obvious "val == (int32_t)val" we would be enabling unsigned + comparisons vs very large numbers. The only solution is to + take the intersection of the ranges. */ + /* ??? Another possible solution is to simply lie and allow all + constants here and force the out-of-range values into a temp + register in tgen_cmp when we have knowledge of the actual + comparison code in use. */ + ct->ct |= TCG_CT_CONST_U31; break; case 'Z': ct->ct |= TCG_CT_CONST_ZERO; @@ -409,103 +438,6 @@ static const char *target_parse_constraint(TCGArgConstraint *ct, return ct_str; } -/* Immediates to be used with logical OR. This is an optimization only, - since a full 64-bit immediate OR can always be performed with 4 sequential - OI[LH][LH] instructions. What we're looking for is immediates that we - can load efficiently, and the immediate load plus the reg-reg OR is - smaller than the sequential OI's. */ - -static int tcg_match_ori(TCGType type, tcg_target_long val) -{ - if (s390_facilities & FACILITY_EXT_IMM) { - if (type == TCG_TYPE_I32) { - /* All 32-bit ORs can be performed with 1 48-bit insn. */ - return 1; - } - } - - /* Look for negative values. These are best to load with LGHI. */ - if (val < 0) { - if (val == (int16_t)val) { - return 0; - } - if (s390_facilities & FACILITY_EXT_IMM) { - if (val == (int32_t)val) { - return 0; - } - } - } - - return 1; -} - -/* Immediates to be used with logical XOR. This is almost, but not quite, - only an optimization. XOR with immediate is only supported with the - extended-immediate facility. That said, there are a few patterns for - which it is better to load the value into a register first. */ - -static int tcg_match_xori(TCGType type, tcg_target_long val) -{ - if ((s390_facilities & FACILITY_EXT_IMM) == 0) { - return 0; - } - - if (type == TCG_TYPE_I32) { - /* All 32-bit XORs can be performed with 1 48-bit insn. */ - return 1; - } - - /* Look for negative values. These are best to load with LGHI. */ - if (val < 0 && val == (int32_t)val) { - return 0; - } - - return 1; -} - -/* Imediates to be used with comparisons. */ - -static int tcg_match_cmpi(TCGType type, tcg_target_long val) -{ - if (s390_facilities & FACILITY_EXT_IMM) { - /* The COMPARE IMMEDIATE instruction is available. */ - if (type == TCG_TYPE_I32) { - /* We have a 32-bit immediate and can compare against anything. */ - return 1; - } else { - /* ??? We have no insight here into whether the comparison is - signed or unsigned. The COMPARE IMMEDIATE insn uses a 32-bit - signed immediate, and the COMPARE LOGICAL IMMEDIATE insn uses - a 32-bit unsigned immediate. If we were to use the (semi) - obvious "val == (int32_t)val" we would be enabling unsigned - comparisons vs very large numbers. The only solution is to - take the intersection of the ranges. */ - /* ??? Another possible solution is to simply lie and allow all - constants here and force the out-of-range values into a temp - register in tgen_cmp when we have knowledge of the actual - comparison code in use. */ - return val >= 0 && val <= 0x7fffffff; - } - } else { - /* Only the LOAD AND TEST instruction is available. */ - return val == 0; - } -} - -/* Immediates to be used with add2/sub2. */ - -static int tcg_match_add2i(TCGType type, tcg_target_long val) -{ - if (s390_facilities & FACILITY_EXT_IMM) { - if (type == TCG_TYPE_I32) { - return 1; - } else if (val >= -0xffffffffll && val <= 0xffffffffll) { - return 1; - } - } - return 0; -} - /* Test if a constant matches the constraint. */ static int tcg_target_const_match(tcg_target_long val, TCGType type, const TCGArgConstraint *arg_ct) @@ -521,24 +453,18 @@ static int tcg_target_const_match(tcg_target_long val, TCGType type, } /* The following are mutually exclusive. */ - if (ct & TCG_CT_CONST_MULI) { - /* Immediates that may be used with multiply. If we have the - general-instruction-extensions, then we have MULTIPLY SINGLE - IMMEDIATE with a signed 32-bit, otherwise we have only - MULTIPLY HALFWORD IMMEDIATE, with a signed 16-bit. */ - if (s390_facilities & FACILITY_GEN_INST_EXT) { - return val == (int32_t)val; - } else { - return val == (int16_t)val; - } - } else if (ct & TCG_CT_CONST_ADLI) { - return tcg_match_add2i(type, val); - } else if (ct & TCG_CT_CONST_ORI) { - return tcg_match_ori(type, val); - } else if (ct & TCG_CT_CONST_XORI) { - return tcg_match_xori(type, val); - } else if (ct & TCG_CT_CONST_CMPI) { - return tcg_match_cmpi(type, val); + if (ct & TCG_CT_CONST_S16) { + return val == (int16_t)val; + } else if (ct & TCG_CT_CONST_S32) { + return val == (int32_t)val; + } else if (ct & TCG_CT_CONST_S33) { + return val >= -0xffffffffll && val <= 0xffffffffll; + } else if (ct & TCG_CT_CONST_NN16) { + return !(val < 0 && val == (int16_t)val); + } else if (ct & TCG_CT_CONST_NN32) { + return !(val < 0 && val == (int32_t)val); + } else if (ct & TCG_CT_CONST_U31) { + return val >= 0 && val <= 0x7fffffff; } else if (ct & TCG_CT_CONST_ZERO) { return val == 0; } @@ -570,6 +496,13 @@ static void tcg_out_insn_RI(TCGContext *s, S390Opcode op, TCGReg r1, int i2) tcg_out32(s, (op << 16) | (r1 << 20) | (i2 & 0xffff)); } +static void tcg_out_insn_RIE(TCGContext *s, S390Opcode op, TCGReg r1, + int i2, int m3) +{ + tcg_out16(s, (op & 0xff00) | (r1 << 4) | m3); + tcg_out32(s, (i2 << 16) | (op & 0xff)); +} + static void tcg_out_insn_RIL(TCGContext *s, S390Opcode op, TCGReg r1, int i2) { tcg_out16(s, op | (r1 << 4)); @@ -1138,11 +1071,33 @@ static void tgen_setcond(TCGContext *s, TCGType type, TCGCond cond, TCGReg dest, TCGReg c1, TCGArg c2, int c2const) { int cc; + bool have_loc; + + /* With LOC2, we can always emit the minimum 3 insns. */ + if (s390_facilities & FACILITY_LOAD_ON_COND2) { + /* Emit: d = 0, d = (cc ? 1 : d). */ + cc = tgen_cmp(s, type, cond, c1, c2, c2const, false); + tcg_out_movi(s, TCG_TYPE_I64, dest, 0); + tcg_out_insn(s, RIE, LOCGHI, dest, 1, cc); + return; + } + have_loc = (s390_facilities & FACILITY_LOAD_ON_COND) != 0; + + /* For HAVE_LOC, only the paths through GTU/GT/LEU/LE are smaller. */ + restart: switch (cond) { + case TCG_COND_NE: + /* X != 0 is X > 0. */ + if (c2const && c2 == 0) { + cond = TCG_COND_GTU; + } else { + break; + } + /* fallthru */ + case TCG_COND_GTU: case TCG_COND_GT: - do_greater: /* The result of a compare has CC=2 for GT and CC=3 unused. ADD LOGICAL WITH CARRY considers (CC & 2) the carry bit. */ tgen_cmp(s, type, cond, c1, c2, c2const, true); @@ -1150,34 +1105,34 @@ static void tgen_setcond(TCGContext *s, TCGType type, TCGCond cond, tcg_out_insn(s, RRE, ALCGR, dest, dest); return; - case TCG_COND_GEU: - do_geu: - /* We need "real" carry semantics, so use SUBTRACT LOGICAL - instead of COMPARE LOGICAL. This needs an extra move. */ - tcg_out_mov(s, type, TCG_TMP0, c1); - if (c2const) { - tcg_out_movi(s, TCG_TYPE_I64, dest, 0); - if (type == TCG_TYPE_I32) { - tcg_out_insn(s, RIL, SLFI, TCG_TMP0, c2); - } else { - tcg_out_insn(s, RIL, SLGFI, TCG_TMP0, c2); - } + case TCG_COND_EQ: + /* X == 0 is X <= 0. */ + if (c2const && c2 == 0) { + cond = TCG_COND_LEU; } else { - if (type == TCG_TYPE_I32) { - tcg_out_insn(s, RR, SLR, TCG_TMP0, c2); - } else { - tcg_out_insn(s, RRE, SLGR, TCG_TMP0, c2); - } - tcg_out_movi(s, TCG_TYPE_I64, dest, 0); + break; } - tcg_out_insn(s, RRE, ALCGR, dest, dest); - return; + /* fallthru */ case TCG_COND_LEU: + case TCG_COND_LE: + /* As above, but we're looking for borrow, or !carry. + The second insn computes d - d - borrow, or -1 for true + and 0 for false. So we must mask to 1 bit afterward. */ + tgen_cmp(s, type, cond, c1, c2, c2const, true); + tcg_out_insn(s, RRE, SLBGR, dest, dest); + tgen_andi(s, type, dest, 1); + return; + + case TCG_COND_GEU: case TCG_COND_LTU: case TCG_COND_LT: - /* Swap operands so that we can use GEU/GTU/GT. */ + case TCG_COND_GE: + /* Swap operands so that we can use LEU/GTU/GT/LE. */ if (c2const) { + if (have_loc) { + break; + } tcg_out_movi(s, type, TCG_TMP0, c2); c2 = c1; c2const = 0; @@ -1187,37 +1142,15 @@ static void tgen_setcond(TCGContext *s, TCGType type, TCGCond cond, c1 = c2; c2 = t; } - if (cond == TCG_COND_LEU) { - goto do_geu; - } cond = tcg_swap_cond(cond); - goto do_greater; - - case TCG_COND_NE: - /* X != 0 is X > 0. */ - if (c2const && c2 == 0) { - cond = TCG_COND_GTU; - goto do_greater; - } - break; - - case TCG_COND_EQ: - /* X == 0 is X <= 0 is 0 >= X. */ - if (c2const && c2 == 0) { - tcg_out_movi(s, TCG_TYPE_I64, TCG_TMP0, 0); - c2 = c1; - c2const = 0; - c1 = TCG_TMP0; - goto do_geu; - } - break; + goto restart; default: - break; + g_assert_not_reached(); } cc = tgen_cmp(s, type, cond, c1, c2, c2const, false); - if (s390_facilities & FACILITY_LOAD_ON_COND) { + if (have_loc) { /* Emit: d = 0, t = 1, d = (cc ? t : d). */ tcg_out_movi(s, TCG_TYPE_I64, dest, 0); tcg_out_movi(s, TCG_TYPE_I64, TCG_TMP0, 1); @@ -1231,19 +1164,24 @@ static void tgen_setcond(TCGContext *s, TCGType type, TCGCond cond, } static void tgen_movcond(TCGContext *s, TCGType type, TCGCond c, TCGReg dest, - TCGReg c1, TCGArg c2, int c2const, TCGReg r3) + TCGReg c1, TCGArg c2, int c2const, + TCGArg v3, int v3const) { int cc; if (s390_facilities & FACILITY_LOAD_ON_COND) { cc = tgen_cmp(s, type, c, c1, c2, c2const, false); - tcg_out_insn(s, RRF, LOCGR, dest, r3, cc); + if (v3const) { + tcg_out_insn(s, RIE, LOCGHI, dest, v3, cc); + } else { + tcg_out_insn(s, RRF, LOCGR, dest, v3, cc); + } } else { c = tcg_invert_cond(c); cc = tgen_cmp(s, type, c, c1, c2, c2const, false); /* Emit: if (cc) goto over; dest = r3; over: */ tcg_out_insn(s, RI, BRC, cc, (4 + 4) >> 1); - tcg_out_insn(s, RRE, LGR, dest, r3); + tcg_out_insn(s, RRE, LGR, dest, v3); } } @@ -1736,7 +1674,7 @@ static void tcg_out_qemu_st(TCGContext* s, TCGReg data_reg, TCGReg addr_reg, static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, const int *const_args) { - S390Opcode op; + S390Opcode op, op2; TCGArg a0, a1, a2; switch (opc) { @@ -1841,29 +1779,44 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, if (const_args[2]) { a2 = -a2; goto do_addi_32; + } else if (a0 == a1) { + tcg_out_insn(s, RR, SR, a0, a2); + } else { + tcg_out_insn(s, RRF, SRK, a0, a1, a2); } - tcg_out_insn(s, RR, SR, args[0], args[2]); break; case INDEX_op_and_i32: + a0 = args[0], a1 = args[1], a2 = (uint32_t)args[2]; if (const_args[2]) { - tgen_andi(s, TCG_TYPE_I32, args[0], args[2]); + tcg_out_mov(s, TCG_TYPE_I32, a0, a1); + tgen_andi(s, TCG_TYPE_I32, a0, a2); + } else if (a0 == a1) { + tcg_out_insn(s, RR, NR, a0, a2); } else { - tcg_out_insn(s, RR, NR, args[0], args[2]); + tcg_out_insn(s, RRF, NRK, a0, a1, a2); } break; case INDEX_op_or_i32: + a0 = args[0], a1 = args[1], a2 = (uint32_t)args[2]; if (const_args[2]) { - tgen64_ori(s, args[0], args[2] & 0xffffffff); + tcg_out_mov(s, TCG_TYPE_I32, a0, a1); + tgen64_ori(s, a0, a2); + } else if (a0 == a1) { + tcg_out_insn(s, RR, OR, a0, a2); } else { - tcg_out_insn(s, RR, OR, args[0], args[2]); + tcg_out_insn(s, RRF, ORK, a0, a1, a2); } break; case INDEX_op_xor_i32: + a0 = args[0], a1 = args[1], a2 = (uint32_t)args[2]; if (const_args[2]) { - tgen64_xori(s, args[0], args[2] & 0xffffffff); - } else { + tcg_out_mov(s, TCG_TYPE_I32, a0, a1); + tgen64_xori(s, a0, a2); + } else if (a0 == a1) { tcg_out_insn(s, RR, XR, args[0], args[2]); + } else { + tcg_out_insn(s, RRF, XRK, a0, a1, a2); } break; @@ -1892,18 +1845,31 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, case INDEX_op_shl_i32: op = RS_SLL; + op2 = RSY_SLLK; do_shift32: - if (const_args[2]) { - tcg_out_sh32(s, op, args[0], TCG_REG_NONE, args[2]); + a0 = args[0], a1 = args[1], a2 = (int32_t)args[2]; + if (a0 == a1) { + if (const_args[2]) { + tcg_out_sh32(s, op, a0, TCG_REG_NONE, a2); + } else { + tcg_out_sh32(s, op, a0, a2, 0); + } } else { - tcg_out_sh32(s, op, args[0], args[2], 0); + /* Using tcg_out_sh64 here for the format; it is a 32-bit shift. */ + if (const_args[2]) { + tcg_out_sh64(s, op2, a0, a1, TCG_REG_NONE, a2); + } else { + tcg_out_sh64(s, op2, a0, a1, a2, 0); + } } break; case INDEX_op_shr_i32: op = RS_SRL; + op2 = RSY_SRLK; goto do_shift32; case INDEX_op_sar_i32: op = RS_SRA; + op2 = RSY_SRAK; goto do_shift32; case INDEX_op_rotl_i32: @@ -1978,7 +1944,7 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, break; case INDEX_op_movcond_i32: tgen_movcond(s, TCG_TYPE_I32, args[5], args[0], args[1], - args[2], const_args[2], args[3]); + args[2], const_args[2], args[3], const_args[3]); break; case INDEX_op_qemu_ld_i32: @@ -2045,30 +2011,44 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, if (const_args[2]) { a2 = -a2; goto do_addi_64; + } else if (a0 == a1) { + tcg_out_insn(s, RRE, SGR, a0, a2); } else { - tcg_out_insn(s, RRE, SGR, args[0], args[2]); + tcg_out_insn(s, RRF, SGRK, a0, a1, a2); } break; case INDEX_op_and_i64: + a0 = args[0], a1 = args[1], a2 = args[2]; if (const_args[2]) { + tcg_out_mov(s, TCG_TYPE_I64, a0, a1); tgen_andi(s, TCG_TYPE_I64, args[0], args[2]); - } else { + } else if (a0 == a1) { tcg_out_insn(s, RRE, NGR, args[0], args[2]); + } else { + tcg_out_insn(s, RRF, NGRK, a0, a1, a2); } break; case INDEX_op_or_i64: + a0 = args[0], a1 = args[1], a2 = args[2]; if (const_args[2]) { - tgen64_ori(s, args[0], args[2]); + tcg_out_mov(s, TCG_TYPE_I64, a0, a1); + tgen64_ori(s, a0, a2); + } else if (a0 == a1) { + tcg_out_insn(s, RRE, OGR, a0, a2); } else { - tcg_out_insn(s, RRE, OGR, args[0], args[2]); + tcg_out_insn(s, RRF, OGRK, a0, a1, a2); } break; case INDEX_op_xor_i64: + a0 = args[0], a1 = args[1], a2 = args[2]; if (const_args[2]) { - tgen64_xori(s, args[0], args[2]); + tcg_out_mov(s, TCG_TYPE_I64, a0, a1); + tgen64_xori(s, a0, a2); + } else if (a0 == a1) { + tcg_out_insn(s, RRE, XGR, a0, a2); } else { - tcg_out_insn(s, RRE, XGR, args[0], args[2]); + tcg_out_insn(s, RRF, XGRK, a0, a1, a2); } break; @@ -2197,7 +2177,7 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, break; case INDEX_op_movcond_i64: tgen_movcond(s, TCG_TYPE_I64, args[5], args[0], args[1], - args[2], const_args[2], args[3]); + args[2], const_args[2], args[3], const_args[3]); break; OP_32_64(deposit): @@ -2246,134 +2226,210 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, } } -static const TCGTargetOpDef s390_op_defs[] = { - { INDEX_op_exit_tb, { } }, - { INDEX_op_goto_tb, { } }, - { INDEX_op_br, { } }, - { INDEX_op_goto_ptr, { "r" } }, - - { INDEX_op_ld8u_i32, { "r", "r" } }, - { INDEX_op_ld8s_i32, { "r", "r" } }, - { INDEX_op_ld16u_i32, { "r", "r" } }, - { INDEX_op_ld16s_i32, { "r", "r" } }, - { INDEX_op_ld_i32, { "r", "r" } }, - { INDEX_op_st8_i32, { "r", "r" } }, - { INDEX_op_st16_i32, { "r", "r" } }, - { INDEX_op_st_i32, { "r", "r" } }, - - { INDEX_op_add_i32, { "r", "r", "ri" } }, - { INDEX_op_sub_i32, { "r", "0", "ri" } }, - { INDEX_op_mul_i32, { "r", "0", "rK" } }, - - { INDEX_op_div2_i32, { "b", "a", "0", "1", "r" } }, - { INDEX_op_divu2_i32, { "b", "a", "0", "1", "r" } }, - - { INDEX_op_and_i32, { "r", "0", "ri" } }, - { INDEX_op_or_i32, { "r", "0", "rO" } }, - { INDEX_op_xor_i32, { "r", "0", "rX" } }, - - { INDEX_op_neg_i32, { "r", "r" } }, - - { INDEX_op_shl_i32, { "r", "0", "ri" } }, - { INDEX_op_shr_i32, { "r", "0", "ri" } }, - { INDEX_op_sar_i32, { "r", "0", "ri" } }, - - { INDEX_op_rotl_i32, { "r", "r", "ri" } }, - { INDEX_op_rotr_i32, { "r", "r", "ri" } }, - - { INDEX_op_ext8s_i32, { "r", "r" } }, - { INDEX_op_ext8u_i32, { "r", "r" } }, - { INDEX_op_ext16s_i32, { "r", "r" } }, - { INDEX_op_ext16u_i32, { "r", "r" } }, - - { INDEX_op_bswap16_i32, { "r", "r" } }, - { INDEX_op_bswap32_i32, { "r", "r" } }, - - { INDEX_op_add2_i32, { "r", "r", "0", "1", "rA", "r" } }, - { INDEX_op_sub2_i32, { "r", "r", "0", "1", "rA", "r" } }, - - { INDEX_op_brcond_i32, { "r", "rC" } }, - { INDEX_op_setcond_i32, { "r", "r", "rC" } }, - { INDEX_op_movcond_i32, { "r", "r", "rC", "r", "0" } }, - { INDEX_op_deposit_i32, { "r", "rZ", "r" } }, - { INDEX_op_extract_i32, { "r", "r" } }, - - { INDEX_op_qemu_ld_i32, { "r", "L" } }, - { INDEX_op_qemu_ld_i64, { "r", "L" } }, - { INDEX_op_qemu_st_i32, { "L", "L" } }, - { INDEX_op_qemu_st_i64, { "L", "L" } }, - - { INDEX_op_ld8u_i64, { "r", "r" } }, - { INDEX_op_ld8s_i64, { "r", "r" } }, - { INDEX_op_ld16u_i64, { "r", "r" } }, - { INDEX_op_ld16s_i64, { "r", "r" } }, - { INDEX_op_ld32u_i64, { "r", "r" } }, - { INDEX_op_ld32s_i64, { "r", "r" } }, - { INDEX_op_ld_i64, { "r", "r" } }, - - { INDEX_op_st8_i64, { "r", "r" } }, - { INDEX_op_st16_i64, { "r", "r" } }, - { INDEX_op_st32_i64, { "r", "r" } }, - { INDEX_op_st_i64, { "r", "r" } }, - - { INDEX_op_add_i64, { "r", "r", "ri" } }, - { INDEX_op_sub_i64, { "r", "0", "ri" } }, - { INDEX_op_mul_i64, { "r", "0", "rK" } }, - - { INDEX_op_div2_i64, { "b", "a", "0", "1", "r" } }, - { INDEX_op_divu2_i64, { "b", "a", "0", "1", "r" } }, - { INDEX_op_mulu2_i64, { "b", "a", "0", "r" } }, - - { INDEX_op_and_i64, { "r", "0", "ri" } }, - { INDEX_op_or_i64, { "r", "0", "rO" } }, - { INDEX_op_xor_i64, { "r", "0", "rX" } }, - - { INDEX_op_neg_i64, { "r", "r" } }, - - { INDEX_op_shl_i64, { "r", "r", "ri" } }, - { INDEX_op_shr_i64, { "r", "r", "ri" } }, - { INDEX_op_sar_i64, { "r", "r", "ri" } }, - - { INDEX_op_rotl_i64, { "r", "r", "ri" } }, - { INDEX_op_rotr_i64, { "r", "r", "ri" } }, - - { INDEX_op_ext8s_i64, { "r", "r" } }, - { INDEX_op_ext8u_i64, { "r", "r" } }, - { INDEX_op_ext16s_i64, { "r", "r" } }, - { INDEX_op_ext16u_i64, { "r", "r" } }, - { INDEX_op_ext32s_i64, { "r", "r" } }, - { INDEX_op_ext32u_i64, { "r", "r" } }, - - { INDEX_op_ext_i32_i64, { "r", "r" } }, - { INDEX_op_extu_i32_i64, { "r", "r" } }, - - { INDEX_op_bswap16_i64, { "r", "r" } }, - { INDEX_op_bswap32_i64, { "r", "r" } }, - { INDEX_op_bswap64_i64, { "r", "r" } }, - - { INDEX_op_clz_i64, { "r", "r", "ri" } }, - - { INDEX_op_add2_i64, { "r", "r", "0", "1", "rA", "r" } }, - { INDEX_op_sub2_i64, { "r", "r", "0", "1", "rA", "r" } }, - - { INDEX_op_brcond_i64, { "r", "rC" } }, - { INDEX_op_setcond_i64, { "r", "r", "rC" } }, - { INDEX_op_movcond_i64, { "r", "r", "rC", "r", "0" } }, - { INDEX_op_deposit_i64, { "r", "0", "r" } }, - { INDEX_op_extract_i64, { "r", "r" } }, - - { INDEX_op_mb, { } }, - { -1 }, -}; - static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode op) { - int i, n = ARRAY_SIZE(s390_op_defs); + static const TCGTargetOpDef r = { .args_ct_str = { "r" } }; + static const TCGTargetOpDef r_r = { .args_ct_str = { "r", "r" } }; + static const TCGTargetOpDef r_L = { .args_ct_str = { "r", "L" } }; + static const TCGTargetOpDef L_L = { .args_ct_str = { "L", "L" } }; + static const TCGTargetOpDef r_ri = { .args_ct_str = { "r", "ri" } }; + static const TCGTargetOpDef r_rC = { .args_ct_str = { "r", "rC" } }; + static const TCGTargetOpDef r_rZ = { .args_ct_str = { "r", "rZ" } }; + static const TCGTargetOpDef r_r_ri = { .args_ct_str = { "r", "r", "ri" } }; + static const TCGTargetOpDef r_r_rM = { .args_ct_str = { "r", "r", "rM" } }; + static const TCGTargetOpDef r_0_r = { .args_ct_str = { "r", "0", "r" } }; + static const TCGTargetOpDef r_0_ri = { .args_ct_str = { "r", "0", "ri" } }; + static const TCGTargetOpDef r_0_rI = { .args_ct_str = { "r", "0", "rI" } }; + static const TCGTargetOpDef r_0_rJ = { .args_ct_str = { "r", "0", "rJ" } }; + static const TCGTargetOpDef r_0_rN = { .args_ct_str = { "r", "0", "rN" } }; + static const TCGTargetOpDef r_0_rM = { .args_ct_str = { "r", "0", "rM" } }; + static const TCGTargetOpDef a2_r + = { .args_ct_str = { "r", "r", "0", "1", "r", "r" } }; + static const TCGTargetOpDef a2_ri + = { .args_ct_str = { "r", "r", "0", "1", "ri", "r" } }; + static const TCGTargetOpDef a2_rA + = { .args_ct_str = { "r", "r", "0", "1", "rA", "r" } }; + + switch (op) { + case INDEX_op_goto_ptr: + return &r; + + case INDEX_op_ld8u_i32: + case INDEX_op_ld8u_i64: + case INDEX_op_ld8s_i32: + case INDEX_op_ld8s_i64: + case INDEX_op_ld16u_i32: + case INDEX_op_ld16u_i64: + case INDEX_op_ld16s_i32: + case INDEX_op_ld16s_i64: + case INDEX_op_ld_i32: + case INDEX_op_ld32u_i64: + case INDEX_op_ld32s_i64: + case INDEX_op_ld_i64: + case INDEX_op_st8_i32: + case INDEX_op_st8_i64: + case INDEX_op_st16_i32: + case INDEX_op_st16_i64: + case INDEX_op_st_i32: + case INDEX_op_st32_i64: + case INDEX_op_st_i64: + return &r_r; + + case INDEX_op_add_i32: + case INDEX_op_add_i64: + return &r_r_ri; + case INDEX_op_sub_i32: + case INDEX_op_sub_i64: + return (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_ri : &r_0_ri); + + case INDEX_op_mul_i32: + /* If we have the general-instruction-extensions, then we have + MULTIPLY SINGLE IMMEDIATE with a signed 32-bit, otherwise we + have only MULTIPLY HALFWORD IMMEDIATE, with a signed 16-bit. */ + return (s390_facilities & FACILITY_GEN_INST_EXT ? &r_0_ri : &r_0_rI); + case INDEX_op_mul_i64: + return (s390_facilities & FACILITY_GEN_INST_EXT ? &r_0_rJ : &r_0_rI); + + case INDEX_op_or_i32: + /* The use of [iNM] constraints are optimization only, since a full + 64-bit immediate OR can always be performed with 4 sequential + OI[LH][LH] instructions. By rejecting certain negative ranges, + the immediate load plus the reg-reg OR is smaller. */ + return (s390_facilities & FACILITY_EXT_IMM + ? (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_ri : &r_0_ri) + : &r_0_rN); + case INDEX_op_or_i64: + return (s390_facilities & FACILITY_EXT_IMM + ? (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_rM : &r_0_rM) + : &r_0_rN); + + case INDEX_op_xor_i32: + /* Without EXT_IMM, no immediates are supported. Otherwise, + rejecting certain negative ranges leads to smaller code. */ + return (s390_facilities & FACILITY_EXT_IMM + ? (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_ri : &r_0_ri) + : &r_0_r); + case INDEX_op_xor_i64: + return (s390_facilities & FACILITY_EXT_IMM + ? (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_rM : &r_0_rM) + : &r_0_r); + + case INDEX_op_and_i32: + case INDEX_op_and_i64: + return (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_ri : &r_0_ri); + + case INDEX_op_shl_i32: + case INDEX_op_shr_i32: + case INDEX_op_sar_i32: + return (s390_facilities & FACILITY_DISTINCT_OPS ? &r_r_ri : &r_0_ri); + + case INDEX_op_shl_i64: + case INDEX_op_shr_i64: + case INDEX_op_sar_i64: + return &r_r_ri; + + case INDEX_op_rotl_i32: + case INDEX_op_rotl_i64: + case INDEX_op_rotr_i32: + case INDEX_op_rotr_i64: + return &r_r_ri; + + case INDEX_op_brcond_i32: + /* Without EXT_IMM, only the LOAD AND TEST insn is available. */ + return (s390_facilities & FACILITY_EXT_IMM ? &r_ri : &r_rZ); + case INDEX_op_brcond_i64: + return (s390_facilities & FACILITY_EXT_IMM ? &r_rC : &r_rZ); + + case INDEX_op_bswap16_i32: + case INDEX_op_bswap16_i64: + case INDEX_op_bswap32_i32: + case INDEX_op_bswap32_i64: + case INDEX_op_bswap64_i64: + case INDEX_op_neg_i32: + case INDEX_op_neg_i64: + case INDEX_op_ext8s_i32: + case INDEX_op_ext8s_i64: + case INDEX_op_ext8u_i32: + case INDEX_op_ext8u_i64: + case INDEX_op_ext16s_i32: + case INDEX_op_ext16s_i64: + case INDEX_op_ext16u_i32: + case INDEX_op_ext16u_i64: + case INDEX_op_ext32s_i64: + case INDEX_op_ext32u_i64: + case INDEX_op_ext_i32_i64: + case INDEX_op_extu_i32_i64: + case INDEX_op_extract_i32: + case INDEX_op_extract_i64: + return &r_r; + + case INDEX_op_clz_i64: + return &r_r_ri; - for (i = 0; i < n; ++i) { - if (s390_op_defs[i].op == op) { - return &s390_op_defs[i]; + case INDEX_op_qemu_ld_i32: + case INDEX_op_qemu_ld_i64: + return &r_L; + case INDEX_op_qemu_st_i64: + case INDEX_op_qemu_st_i32: + return &L_L; + + case INDEX_op_deposit_i32: + case INDEX_op_deposit_i64: + { + static const TCGTargetOpDef dep + = { .args_ct_str = { "r", "rZ", "r" } }; + return &dep; + } + case INDEX_op_setcond_i32: + case INDEX_op_setcond_i64: + { + /* Without EXT_IMM, only the LOAD AND TEST insn is available. */ + static const TCGTargetOpDef setc_z + = { .args_ct_str = { "r", "r", "rZ" } }; + static const TCGTargetOpDef setc_c + = { .args_ct_str = { "r", "r", "rC" } }; + return (s390_facilities & FACILITY_EXT_IMM ? &setc_c : &setc_z); + } + case INDEX_op_movcond_i32: + case INDEX_op_movcond_i64: + { + /* Without EXT_IMM, only the LOAD AND TEST insn is available. */ + static const TCGTargetOpDef movc_z + = { .args_ct_str = { "r", "r", "rZ", "r", "0" } }; + static const TCGTargetOpDef movc_c + = { .args_ct_str = { "r", "r", "rC", "r", "0" } }; + static const TCGTargetOpDef movc_l + = { .args_ct_str = { "r", "r", "rC", "rI", "0" } }; + return (s390_facilities & FACILITY_EXT_IMM + ? (s390_facilities & FACILITY_LOAD_ON_COND2 + ? &movc_l : &movc_c) + : &movc_z); + } + case INDEX_op_div2_i32: + case INDEX_op_div2_i64: + case INDEX_op_divu2_i32: + case INDEX_op_divu2_i64: + { + static const TCGTargetOpDef div2 + = { .args_ct_str = { "b", "a", "0", "1", "r" } }; + return &div2; } + case INDEX_op_mulu2_i64: + { + static const TCGTargetOpDef mul2 + = { .args_ct_str = { "b", "a", "0", "r" } }; + return &mul2; + } + + case INDEX_op_add2_i32: + case INDEX_op_sub2_i32: + return (s390_facilities & FACILITY_EXT_IMM ? &a2_ri : &a2_r); + case INDEX_op_add2_i64: + case INDEX_op_sub2_i64: + return (s390_facilities & FACILITY_EXT_IMM ? &a2_rA : &a2_r); + + default: + break; } return NULL; } diff --git a/tcg/sparc/tcg-target.h b/tcg/sparc/tcg-target.h index 854a0afd70..4515c9ab48 100644 --- a/tcg/sparc/tcg-target.h +++ b/tcg/sparc/tcg-target.h @@ -162,6 +162,8 @@ extern bool use_vis3_instructions; #define TCG_AREG0 TCG_REG_I0 +#define TCG_TARGET_DEFAULT_MO (0) + static inline void flush_icache_range(uintptr_t start, uintptr_t stop) { uintptr_t p; diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c index 87f673ef49..688d91755b 100644 --- a/tcg/tcg-op.c +++ b/tcg/tcg-op.c @@ -28,6 +28,7 @@ #include "exec/exec-all.h" #include "tcg.h" #include "tcg-op.h" +#include "tcg-mo.h" #include "trace-tcg.h" #include "trace/mem.h" @@ -2662,8 +2663,20 @@ static void gen_ldst_i64(TCGOpcode opc, TCGv_i64 val, TCGv addr, #endif } +static void tcg_gen_req_mo(TCGBar type) +{ +#ifdef TCG_GUEST_DEFAULT_MO + type &= TCG_GUEST_DEFAULT_MO; +#endif + type &= ~TCG_TARGET_DEFAULT_MO; + if (type) { + tcg_gen_mb(type | TCG_BAR_SC); + } +} + void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) { + tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD); memop = tcg_canonicalize_memop(memop, 0, 0); trace_guest_mem_before_tcg(tcg_ctx.cpu, tcg_ctx.tcg_env, addr, trace_mem_get_info(memop, 0)); @@ -2672,6 +2685,7 @@ void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) { + tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST); memop = tcg_canonicalize_memop(memop, 0, 1); trace_guest_mem_before_tcg(tcg_ctx.cpu, tcg_ctx.tcg_env, addr, trace_mem_get_info(memop, 1)); @@ -2680,6 +2694,7 @@ void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) { + tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD); if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) { tcg_gen_qemu_ld_i32(TCGV_LOW(val), addr, idx, memop); if (memop & MO_SIGN) { @@ -2698,6 +2713,7 @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) { + tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST); if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) { tcg_gen_qemu_st_i32(TCGV_LOW(val), addr, idx, memop); return; diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184 new file mode 100755 index 0000000000..704f38f936 --- /dev/null +++ b/tests/qemu-iotests/184 @@ -0,0 +1,205 @@ +#!/bin/bash +# +# Test I/O throttle block filter driver interface +# +# Copyright (C) 2017 Manos Pitsidianakis +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator +owner="Manos Pitsidianakis" + +seq=`basename $0` +echo "QA output created by $seq" + +here=`pwd` +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +_supported_fmt qcow2 +_supported_proto file +_supported_os Linux + +function do_run_qemu() +{ + echo Testing: "$@" | _filter_imgfmt + $QEMU -nographic -qmp-pretty stdio -serial none "$@" + echo +} + +function run_qemu() +{ + do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_qmp\ + | _filter_qemu_io | _filter_generated_node_ids +} + +_make_test_img 64M +test_throttle=$($QEMU_IMG --help|grep throttle) +[ "$test_throttle" = "" ] && _supported_fmt throttle + +echo +echo "== checking interface ==" + +run_qemu <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", + "arguments": { + "driver": "$IMGFMT", + "node-name": "disk0", + "file": { + "driver": "file", + "filename": "$TEST_IMG" + } + } +} +{ "execute": "object-add", + "arguments": { + "qom-type": "throttle-group", + "id": "group0", + "props": { + "limits" : { + "iops-total": 1000 + } + } + } +} +{ "execute": "blockdev-add", + "arguments": { + "driver": "throttle", + "node-name": "throttle0", + "throttle-group": "group0", + "file": "disk0" + } +} +{ "execute": "query-named-block-nodes" } +{ "execute": "query-block" } +{ "execute": "quit" } +EOF + +echo +echo "== property changes in ThrottleGroup ==" + +run_qemu <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "object-add", + "arguments": { + "qom-type": "throttle-group", + "id": "group0", + "props" : { + "limits": { + "iops-total": 1000 + } + } + } +} +{ "execute" : "qom-get", + "arguments" : { + "path" : "group0", + "property" : "limits" + } +} +{ "execute" : "qom-set", + "arguments" : { + "path" : "group0", + "property" : "limits", + "value" : { + "iops-total" : 0 + } + } +} +{ "execute" : "qom-get", + "arguments" : { + "path" : "group0", + "property" : "limits" + } +} +{ "execute": "quit" } +EOF + +echo +echo "== object creation/set errors ==" + +run_qemu <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "object-add", + "arguments": { + "qom-type": "throttle-group", + "id": "group0", + "props" : { + "limits": { + "iops-total": 1000 + } + } + } +} +{ "execute" : "qom-set", + "arguments" : { + "path" : "group0", + "property" : "x-iops-total", + "value" : 0 + } +} +{ "execute" : "qom-set", + "arguments" : { + "path" : "group0", + "property" : "limits", + "value" : { + "iops-total" : 10, + "iops-read" : 10 + } + } +} +{ "execute": "quit" } +EOF + +echo +echo "== don't specify group ==" + +run_qemu <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", + "arguments": { + "driver": "$IMGFMT", + "node-name": "disk0", + "file": { + "driver": "file", + "filename": "$TEST_IMG" + } + } +} +{ "execute": "blockdev-add", + "arguments": { + "driver": "throttle", + "node-name": "throttle0", + "file": "disk0" + } +} +{ "execute": "quit" } +EOF + +echo +# success, all done +echo "*** done" +rm -f $seq.full +status=0 diff --git a/tests/qemu-iotests/184.out b/tests/qemu-iotests/184.out new file mode 100644 index 0000000000..0aed1a2220 --- /dev/null +++ b/tests/qemu-iotests/184.out @@ -0,0 +1,302 @@ +QA output created by 184 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + +== checking interface == +Testing: +{ + QMP_VERSION +} +{ + "return": { + } +} +{ + "return": { + } +} +{ + "return": { + } +} +{ + "return": { + } +} +{ + "return": [ + { + "iops_rd": 0, + "detect_zeroes": "off", + "image": { + "virtual-size": 67108864, + "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}", + "cluster-size": 65536, + "format": "throttle", + "actual-size": 200704, + "dirty-flag": false + }, + "iops_wr": 0, + "ro": false, + "node-name": "throttle0", + "backing_file_depth": 0, + "drv": "throttle", + "iops": 0, + "bps_wr": 0, + "write_threshold": 0, + "encrypted": false, + "bps": 0, + "bps_rd": 0, + "cache": { + "no-flush": false, + "direct": false, + "writeback": true + }, + "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}", + "encryption_key_missing": false + }, + { + "iops_rd": 0, + "detect_zeroes": "off", + "image": { + "virtual-size": 67108864, + "filename": "TEST_DIR/t.qcow2", + "cluster-size": 65536, + "format": "qcow2", + "actual-size": 200704, + "format-specific": { + "type": "qcow2", + "data": { + "compat": "1.1", + "lazy-refcounts": false, + "refcount-bits": 16, + "corrupt": false + } + }, + "dirty-flag": false + }, + "iops_wr": 0, + "ro": false, + "node-name": "disk0", + "backing_file_depth": 0, + "drv": "qcow2", + "iops": 0, + "bps_wr": 0, + "write_threshold": 0, + "encrypted": false, + "bps": 0, + "bps_rd": 0, + "cache": { + "no-flush": false, + "direct": false, + "writeback": true + }, + "file": "TEST_DIR/t.qcow2", + "encryption_key_missing": false + }, + { + "iops_rd": 0, + "detect_zeroes": "off", + "image": { + "virtual-size": 197120, + "filename": "TEST_DIR/t.qcow2", + "format": "file", + "actual-size": 200704, + "dirty-flag": false + }, + "iops_wr": 0, + "ro": false, + "node-name": "NODE_NAME", + "backing_file_depth": 0, + "drv": "file", + "iops": 0, + "bps_wr": 0, + "write_threshold": 0, + "encrypted": false, + "bps": 0, + "bps_rd": 0, + "cache": { + "no-flush": false, + "direct": false, + "writeback": true + }, + "file": "TEST_DIR/t.qcow2", + "encryption_key_missing": false + } + ] +} +{ + "return": [ + ] +} +{ + "return": { + } +} +{ + "timestamp": { + "seconds": TIMESTAMP, + "microseconds": TIMESTAMP + }, + "event": "SHUTDOWN", + "data": { + "guest": false + } +} + + +== property changes in ThrottleGroup == +Testing: +{ + QMP_VERSION +} +{ + "return": { + } +} +{ + "return": { + } +} +{ + "return": { + "bps-read-max-length": 1, + "iops-read-max-length": 1, + "bps-read-max": 0, + "bps-total": 0, + "iops-total-max-length": 1, + "iops-total": 1000, + "iops-write-max": 0, + "bps-write": 0, + "bps-total-max": 0, + "bps-write-max": 0, + "iops-size": 0, + "iops-read": 0, + "iops-write-max-length": 1, + "iops-write": 0, + "bps-total-max-length": 1, + "iops-read-max": 0, + "bps-read": 0, + "bps-write-max-length": 1, + "iops-total-max": 0 + } +} +{ + "return": { + } +} +{ + "return": { + "bps-read-max-length": 1, + "iops-read-max-length": 1, + "bps-read-max": 0, + "bps-total": 0, + "iops-total-max-length": 1, + "iops-total": 0, + "iops-write-max": 0, + "bps-write": 0, + "bps-total-max": 0, + "bps-write-max": 0, + "iops-size": 0, + "iops-read": 0, + "iops-write-max-length": 1, + "iops-write": 0, + "bps-total-max-length": 1, + "iops-read-max": 0, + "bps-read": 0, + "bps-write-max-length": 1, + "iops-total-max": 0 + } +} +{ + "return": { + } +} +{ + "timestamp": { + "seconds": TIMESTAMP, + "microseconds": TIMESTAMP + }, + "event": "SHUTDOWN", + "data": { + "guest": false + } +} + + +== object creation/set errors == +Testing: +{ + QMP_VERSION +} +{ + "return": { + } +} +{ + "return": { + } +} +{ + "error": { + "class": "GenericError", + "desc": "Property cannot be set after initialization" + } +} +{ + "error": { + "class": "GenericError", + "desc": "bps/iops/max total values and read/write values cannot be used at the same time" + } +} +{ + "return": { + } +} +{ + "timestamp": { + "seconds": TIMESTAMP, + "microseconds": TIMESTAMP + }, + "event": "SHUTDOWN", + "data": { + "guest": false + } +} + + +== don't specify group == +Testing: +{ + QMP_VERSION +} +{ + "return": { + } +} +{ + "return": { + } +} +{ + "error": { + "class": "GenericError", + "desc": "Parameter 'throttle-group' is missing" + } +} +{ + "return": { + } +} +{ + "timestamp": { + "seconds": TIMESTAMP, + "microseconds": TIMESTAMP + }, + "event": "SHUTDOWN", + "data": { + "guest": false + } +} + + +*** done diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 4bd5017008..94e764865a 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -180,6 +180,7 @@ 181 rw auto migration 182 rw auto quick 183 rw auto migration +184 rw auto quick 185 rw auto 186 rw auto 187 rw auto diff --git a/tests/test-iov.c b/tests/test-iov.c index fa3d75aee1..458ca25099 100644 --- a/tests/test-iov.c +++ b/tests/test-iov.c @@ -81,17 +81,17 @@ static void test_to_from_buf_1(void) * skip whole vector and process exactly 0 bytes */ /* first set bytes [i..sz) to some "random" value */ - n = iov_memset(iov, niov, 0, 0xff, -1); + n = iov_memset(iov, niov, 0, 0xff, sz); g_assert(n == sz); /* next copy bytes [i..sz) from ibuf to iovec */ - n = iov_from_buf(iov, niov, i, ibuf + i, -1); + n = iov_from_buf(iov, niov, i, ibuf + i, sz - i); g_assert(n == sz - i); /* clear part of obuf */ memset(obuf + i, 0, sz - i); /* and set this part of obuf to values from iovec */ - n = iov_to_buf(iov, niov, i, obuf + i, -1); + n = iov_to_buf(iov, niov, i, obuf + i, sz - i); g_assert(n == sz - i); /* now compare resulting buffers */ @@ -109,7 +109,7 @@ static void test_to_from_buf_1(void) * with j in [i..sz]. */ /* clear iovec */ - n = iov_memset(iov, niov, 0, 0xff, -1); + n = iov_memset(iov, niov, 0, 0xff, sz); g_assert(n == sz); /* copy bytes [i..j) from ibuf to iovec */ @@ -225,7 +225,7 @@ static void test_io(void) for (i = 0; i <= sz; ++i) { for (j = i; j <= sz; ++j) { k = i; - iov_memset(iov, niov, 0, 0xff, -1); + iov_memset(iov, niov, 0, 0xff, sz); do { s = g_test_rand_int_range(0, j - k + 1); r = iov_recv(sv[0], iov, niov, k, s); diff --git a/tests/test-throttle.c b/tests/test-throttle.c index bf7a5a648a..948a42c991 100644 --- a/tests/test-throttle.c +++ b/tests/test-throttle.c @@ -24,8 +24,9 @@ static AioContext *ctx; static LeakyBucket bkt; static ThrottleConfig cfg; +static ThrottleGroupMember tgm; static ThrottleState ts; -static ThrottleTimers tt; +static ThrottleTimers *tt; /* useful function */ static bool double_cmp(double x, double y) @@ -153,19 +154,21 @@ static void test_init(void) { int i; + tt = &tgm.throttle_timers; + /* fill the structures with crap */ memset(&ts, 1, sizeof(ts)); - memset(&tt, 1, sizeof(tt)); + memset(tt, 1, sizeof(*tt)); /* init structures */ throttle_init(&ts); - throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL, + throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts); /* check initialized fields */ - g_assert(tt.clock_type == QEMU_CLOCK_VIRTUAL); - g_assert(tt.timers[0]); - g_assert(tt.timers[1]); + g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL); + g_assert(tt->timers[0]); + g_assert(tt->timers[1]); /* check other fields where cleared */ g_assert(!ts.previous_leak); @@ -176,18 +179,18 @@ static void test_init(void) g_assert(!ts.cfg.buckets[i].level); } - throttle_timers_destroy(&tt); + throttle_timers_destroy(tt); } static void test_destroy(void) { int i; throttle_init(&ts); - throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL, + throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts); - throttle_timers_destroy(&tt); + throttle_timers_destroy(tt); for (i = 0; i < 2; i++) { - g_assert(!tt.timers[i]); + g_assert(!tt->timers[i]); } } @@ -224,7 +227,7 @@ static void test_config_functions(void) orig_cfg.op_size = 1; throttle_init(&ts); - throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL, + throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts); /* structure reset by throttle_init previous_leak should be null */ g_assert(!ts.previous_leak); @@ -236,7 +239,7 @@ static void test_config_functions(void) /* get back the fixed configuration */ throttle_get_config(&ts, &final_cfg); - throttle_timers_destroy(&tt); + throttle_timers_destroy(tt); g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].avg == 153); g_assert(final_cfg.buckets[THROTTLE_BPS_READ].avg == 56); @@ -494,45 +497,45 @@ static void test_have_timer(void) { /* zero structures */ memset(&ts, 0, sizeof(ts)); - memset(&tt, 0, sizeof(tt)); + memset(tt, 0, sizeof(*tt)); /* no timer set should return false */ - g_assert(!throttle_timers_are_initialized(&tt)); + g_assert(!throttle_timers_are_initialized(tt)); /* init structures */ throttle_init(&ts); - throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL, + throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts); /* timer set by init should return true */ - g_assert(throttle_timers_are_initialized(&tt)); + g_assert(throttle_timers_are_initialized(tt)); - throttle_timers_destroy(&tt); + throttle_timers_destroy(tt); } static void test_detach_attach(void) { /* zero structures */ memset(&ts, 0, sizeof(ts)); - memset(&tt, 0, sizeof(tt)); + memset(tt, 0, sizeof(*tt)); /* init the structure */ throttle_init(&ts); - throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL, + throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts); /* timer set by init should return true */ - g_assert(throttle_timers_are_initialized(&tt)); + g_assert(throttle_timers_are_initialized(tt)); /* timer should no longer exist after detaching */ - throttle_timers_detach_aio_context(&tt); - g_assert(!throttle_timers_are_initialized(&tt)); + throttle_timers_detach_aio_context(tt); + g_assert(!throttle_timers_are_initialized(tt)); /* timer should exist again after attaching */ - throttle_timers_attach_aio_context(&tt, ctx); - g_assert(throttle_timers_are_initialized(&tt)); + throttle_timers_attach_aio_context(tt, ctx); + g_assert(throttle_timers_are_initialized(tt)); - throttle_timers_destroy(&tt); + throttle_timers_destroy(tt); } static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */ @@ -561,7 +564,7 @@ static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */ cfg.op_size = op_size; throttle_init(&ts); - throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL, + throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts); throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &cfg); @@ -588,7 +591,7 @@ static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */ return false; } - throttle_timers_destroy(&tt); + throttle_timers_destroy(tt); return true; } @@ -669,6 +672,7 @@ static void test_groups(void) ThrottleConfig cfg1, cfg2; BlockBackend *blk1, *blk2, *blk3; BlockBackendPublic *blkp1, *blkp2, *blkp3; + ThrottleGroupMember *tgm1, *tgm2, *tgm3; /* No actual I/O is performed on these devices */ blk1 = blk_new(0, BLK_PERM_ALL); @@ -679,21 +683,25 @@ static void test_groups(void) blkp2 = blk_get_public(blk2); blkp3 = blk_get_public(blk3); - g_assert(blkp1->throttle_state == NULL); - g_assert(blkp2->throttle_state == NULL); - g_assert(blkp3->throttle_state == NULL); + tgm1 = &blkp1->throttle_group_member; + tgm2 = &blkp2->throttle_group_member; + tgm3 = &blkp3->throttle_group_member; + + g_assert(tgm1->throttle_state == NULL); + g_assert(tgm2->throttle_state == NULL); + g_assert(tgm3->throttle_state == NULL); - throttle_group_register_blk(blk1, "bar"); - throttle_group_register_blk(blk2, "foo"); - throttle_group_register_blk(blk3, "bar"); + throttle_group_register_tgm(tgm1, "bar", blk_get_aio_context(blk1)); + throttle_group_register_tgm(tgm2, "foo", blk_get_aio_context(blk2)); + throttle_group_register_tgm(tgm3, "bar", blk_get_aio_context(blk3)); - g_assert(blkp1->throttle_state != NULL); - g_assert(blkp2->throttle_state != NULL); - g_assert(blkp3->throttle_state != NULL); + g_assert(tgm1->throttle_state != NULL); + g_assert(tgm2->throttle_state != NULL); + g_assert(tgm3->throttle_state != NULL); - g_assert(!strcmp(throttle_group_get_name(blk1), "bar")); - g_assert(!strcmp(throttle_group_get_name(blk2), "foo")); - g_assert(blkp1->throttle_state == blkp3->throttle_state); + g_assert(!strcmp(throttle_group_get_name(tgm1), "bar")); + g_assert(!strcmp(throttle_group_get_name(tgm2), "foo")); + g_assert(tgm1->throttle_state == tgm3->throttle_state); /* Setting the config of a group member affects the whole group */ throttle_config_init(&cfg1); @@ -701,29 +709,29 @@ static void test_groups(void) cfg1.buckets[THROTTLE_BPS_WRITE].avg = 285000; cfg1.buckets[THROTTLE_OPS_READ].avg = 20000; cfg1.buckets[THROTTLE_OPS_WRITE].avg = 12000; - throttle_group_config(blk1, &cfg1); + throttle_group_config(tgm1, &cfg1); - throttle_group_get_config(blk1, &cfg1); - throttle_group_get_config(blk3, &cfg2); + throttle_group_get_config(tgm1, &cfg1); + throttle_group_get_config(tgm3, &cfg2); g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1))); cfg2.buckets[THROTTLE_BPS_READ].avg = 4547; cfg2.buckets[THROTTLE_BPS_WRITE].avg = 1349; cfg2.buckets[THROTTLE_OPS_READ].avg = 123; cfg2.buckets[THROTTLE_OPS_WRITE].avg = 86; - throttle_group_config(blk3, &cfg1); + throttle_group_config(tgm3, &cfg1); - throttle_group_get_config(blk1, &cfg1); - throttle_group_get_config(blk3, &cfg2); + throttle_group_get_config(tgm1, &cfg1); + throttle_group_get_config(tgm3, &cfg2); g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1))); - throttle_group_unregister_blk(blk1); - throttle_group_unregister_blk(blk2); - throttle_group_unregister_blk(blk3); + throttle_group_unregister_tgm(tgm1); + throttle_group_unregister_tgm(tgm2); + throttle_group_unregister_tgm(tgm3); - g_assert(blkp1->throttle_state == NULL); - g_assert(blkp2->throttle_state == NULL); - g_assert(blkp3->throttle_state == NULL); + g_assert(tgm1->throttle_state == NULL); + g_assert(tgm2->throttle_state == NULL); + g_assert(tgm3->throttle_state == NULL); } int main(int argc, char **argv) @@ -731,6 +739,7 @@ int main(int argc, char **argv) qemu_init_main_loop(&error_fatal); ctx = qemu_get_aio_context(); bdrv_init(); + module_call_init(MODULE_INIT_QOM); do {} while (g_main_context_iteration(NULL, false)); diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c index d4da09f147..4b98018478 100644 --- a/tests/vhost-user-test.c +++ b/tests/vhost-user-test.c @@ -31,6 +31,8 @@ #include <linux/virtio_net.h> #include <sys/vfs.h> +#define VHOST_USER_NET_TESTS_WORKING 0 /* broken as of 2.10.0 */ + /* GLIB version compatibility flags */ #if !GLIB_CHECK_VERSION(2, 26, 0) #define G_TIME_SPAN_SECOND (G_GINT64_CONSTANT(1000000)) @@ -472,11 +474,6 @@ static void test_server_listen(TestServer *server) test_server_create_chr(server, ",server,nowait"); } -static inline void test_server_connect(TestServer *server) -{ - test_server_create_chr(server, ",reconnect=1"); -} - #define GET_QEMU_CMD(s) \ g_strdup_printf(QEMU_CMD, 512, 512, (root), (s)->chr_name, \ (s)->socket_path, "", (s)->chr_name) @@ -722,7 +719,12 @@ static void wait_for_rings_started(TestServer *s, size_t count) g_mutex_unlock(&s->data_mutex); } -#ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS +#if VHOST_USER_NET_TESTS_WORKING && defined(CONFIG_HAS_GLIB_SUBPROCESS_TESTS) +static inline void test_server_connect(TestServer *server) +{ + test_server_create_chr(server, ",reconnect=1"); +} + static gboolean reconnect_cb(gpointer user_data) { @@ -962,7 +964,8 @@ int main(int argc, char **argv) qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem); qtest_add_func("/vhost-user/migrate", test_migrate); qtest_add_func("/vhost-user/multiqueue", test_multiqueue); -#ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS + +#if VHOST_USER_NET_TESTS_WORKING && defined(CONFIG_HAS_GLIB_SUBPROCESS_TESTS) qtest_add_func("/vhost-user/reconnect/subprocess", test_reconnect_subprocess); qtest_add_func("/vhost-user/reconnect", test_reconnect); diff --git a/tests/vmgenid-test.c b/tests/vmgenid-test.c index 3d5c1c3615..918c82c82a 100644 --- a/tests/vmgenid-test.c +++ b/tests/vmgenid-test.c @@ -40,7 +40,7 @@ static uint32_t acpi_find_vgia(void) AcpiRsdpDescriptor rsdp_table; uint32_t rsdt; AcpiRsdtDescriptorRev1 rsdt_table; - int tables_nr; + size_t tables_nr; uint32_t *tables; AcpiTableHeader ssdt_table; VgidTable vgid_table; @@ -62,9 +62,9 @@ static uint32_t acpi_find_vgia(void) ACPI_ASSERT_CMP(rsdt_table.signature, "RSDT"); /* compute the table entries in rsdt */ + g_assert_cmpint(rsdt_table.length, >, sizeof(AcpiRsdtDescriptorRev1)); tables_nr = (rsdt_table.length - sizeof(AcpiRsdtDescriptorRev1)) / sizeof(uint32_t); - g_assert_cmpint(tables_nr, >, 0); /* get the addresses of the tables pointed by rsdt */ tables = g_new0(uint32_t, tables_nr); diff --git a/util/throttle.c b/util/throttle.c index b8c524336c..06bf916adc 100644 --- a/util/throttle.c +++ b/util/throttle.c @@ -484,3 +484,154 @@ void throttle_account(ThrottleState *ts, bool is_write, uint64_t size) } } +/* return a ThrottleConfig based on the options in a ThrottleLimits + * + * @arg: the ThrottleLimits object to read from + * @cfg: the ThrottleConfig to edit + * @errp: error object + */ +void throttle_limits_to_config(ThrottleLimits *arg, ThrottleConfig *cfg, + Error **errp) +{ + if (arg->has_bps_total) { + cfg->buckets[THROTTLE_BPS_TOTAL].avg = arg->bps_total; + } + if (arg->has_bps_read) { + cfg->buckets[THROTTLE_BPS_READ].avg = arg->bps_read; + } + if (arg->has_bps_write) { + cfg->buckets[THROTTLE_BPS_WRITE].avg = arg->bps_write; + } + + if (arg->has_iops_total) { + cfg->buckets[THROTTLE_OPS_TOTAL].avg = arg->iops_total; + } + if (arg->has_iops_read) { + cfg->buckets[THROTTLE_OPS_READ].avg = arg->iops_read; + } + if (arg->has_iops_write) { + cfg->buckets[THROTTLE_OPS_WRITE].avg = arg->iops_write; + } + + if (arg->has_bps_total_max) { + cfg->buckets[THROTTLE_BPS_TOTAL].max = arg->bps_total_max; + } + if (arg->has_bps_read_max) { + cfg->buckets[THROTTLE_BPS_READ].max = arg->bps_read_max; + } + if (arg->has_bps_write_max) { + cfg->buckets[THROTTLE_BPS_WRITE].max = arg->bps_write_max; + } + if (arg->has_iops_total_max) { + cfg->buckets[THROTTLE_OPS_TOTAL].max = arg->iops_total_max; + } + if (arg->has_iops_read_max) { + cfg->buckets[THROTTLE_OPS_READ].max = arg->iops_read_max; + } + if (arg->has_iops_write_max) { + cfg->buckets[THROTTLE_OPS_WRITE].max = arg->iops_write_max; + } + + if (arg->has_bps_total_max_length) { + if (arg->bps_total_max_length > UINT_MAX) { + error_setg(errp, "bps-total-max-length value must be in" + " the range [0, %u]", UINT_MAX); + return; + } + cfg->buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_total_max_length; + } + if (arg->has_bps_read_max_length) { + if (arg->bps_read_max_length > UINT_MAX) { + error_setg(errp, "bps-read-max-length value must be in" + " the range [0, %u]", UINT_MAX); + return; + } + cfg->buckets[THROTTLE_BPS_READ].burst_length = arg->bps_read_max_length; + } + if (arg->has_bps_write_max_length) { + if (arg->bps_write_max_length > UINT_MAX) { + error_setg(errp, "bps-write-max-length value must be in" + " the range [0, %u]", UINT_MAX); + return; + } + cfg->buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_write_max_length; + } + if (arg->has_iops_total_max_length) { + if (arg->iops_total_max_length > UINT_MAX) { + error_setg(errp, "iops-total-max-length value must be in" + " the range [0, %u]", UINT_MAX); + return; + } + cfg->buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_total_max_length; + } + if (arg->has_iops_read_max_length) { + if (arg->iops_read_max_length > UINT_MAX) { + error_setg(errp, "iops-read-max-length value must be in" + " the range [0, %u]", UINT_MAX); + return; + } + cfg->buckets[THROTTLE_OPS_READ].burst_length = arg->iops_read_max_length; + } + if (arg->has_iops_write_max_length) { + if (arg->iops_write_max_length > UINT_MAX) { + error_setg(errp, "iops-write-max-length value must be in" + " the range [0, %u]", UINT_MAX); + return; + } + cfg->buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_write_max_length; + } + + if (arg->has_iops_size) { + cfg->op_size = arg->iops_size; + } + + throttle_is_valid(cfg, errp); +} + +/* write the options of a ThrottleConfig to a ThrottleLimits + * + * @cfg: the ThrottleConfig to read from + * @var: the ThrottleLimits to write to + */ +void throttle_config_to_limits(ThrottleConfig *cfg, ThrottleLimits *var) +{ + var->bps_total = cfg->buckets[THROTTLE_BPS_TOTAL].avg; + var->bps_read = cfg->buckets[THROTTLE_BPS_READ].avg; + var->bps_write = cfg->buckets[THROTTLE_BPS_WRITE].avg; + var->iops_total = cfg->buckets[THROTTLE_OPS_TOTAL].avg; + var->iops_read = cfg->buckets[THROTTLE_OPS_READ].avg; + var->iops_write = cfg->buckets[THROTTLE_OPS_WRITE].avg; + var->bps_total_max = cfg->buckets[THROTTLE_BPS_TOTAL].max; + var->bps_read_max = cfg->buckets[THROTTLE_BPS_READ].max; + var->bps_write_max = cfg->buckets[THROTTLE_BPS_WRITE].max; + var->iops_total_max = cfg->buckets[THROTTLE_OPS_TOTAL].max; + var->iops_read_max = cfg->buckets[THROTTLE_OPS_READ].max; + var->iops_write_max = cfg->buckets[THROTTLE_OPS_WRITE].max; + var->bps_total_max_length = cfg->buckets[THROTTLE_BPS_TOTAL].burst_length; + var->bps_read_max_length = cfg->buckets[THROTTLE_BPS_READ].burst_length; + var->bps_write_max_length = cfg->buckets[THROTTLE_BPS_WRITE].burst_length; + var->iops_total_max_length = cfg->buckets[THROTTLE_OPS_TOTAL].burst_length; + var->iops_read_max_length = cfg->buckets[THROTTLE_OPS_READ].burst_length; + var->iops_write_max_length = cfg->buckets[THROTTLE_OPS_WRITE].burst_length; + var->iops_size = cfg->op_size; + + var->has_bps_total = true; + var->has_bps_read = true; + var->has_bps_write = true; + var->has_iops_total = true; + var->has_iops_read = true; + var->has_iops_write = true; + var->has_bps_total_max = true; + var->has_bps_read_max = true; + var->has_bps_write_max = true; + var->has_iops_total_max = true; + var->has_iops_read_max = true; + var->has_iops_write_max = true; + var->has_bps_read_max_length = true; + var->has_bps_total_max_length = true; + var->has_bps_write_max_length = true; + var->has_iops_total_max_length = true; + var->has_iops_read_max_length = true; + var->has_iops_write_max_length = true; + var->has_iops_size = true; +} |