blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
721
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
57
| license_type
stringclasses 2
values | repo_name
stringlengths 5
91
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 321
values | visit_date
timestamp[ns]date 2016-08-12 09:31:09
2023-09-06 10:45:07
| revision_date
timestamp[ns]date 2010-09-28 14:01:40
2023-09-06 06:22:19
| committer_date
timestamp[ns]date 2010-09-28 14:01:40
2023-09-06 06:22:19
| github_id
int64 426
681M
| star_events_count
int64 101
243k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[ns]date 2012-06-28 18:51:49
2023-09-14 21:59:16
⌀ | gha_created_at
timestamp[ns]date 2008-02-11 22:55:26
2023-08-10 11:14:58
⌀ | gha_language
stringclasses 147
values | src_encoding
stringclasses 26
values | language
stringclasses 2
values | is_vendor
bool 2
classes | is_generated
bool 2
classes | length_bytes
int64 6
10.2M
| extension
stringclasses 115
values | filename
stringlengths 3
113
| content
stringlengths 6
10.2M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2383b601c28507cfaed378eead09aa43e53427bb
|
d61b532db0d3e08818338cfaac530a1ced1ffe3b
|
/lang/cem/libcc.ansi/sys/stdio/setbuf.c
|
58a99ecad3e8f5cbcbadb069b168c455173c32fa
|
[
"LicenseRef-scancode-other-permissive"
] |
permissive
|
davidgiven/ack
|
61049c7a8e95ff61a77b1edd3c22bb290720e276
|
db5a32c68c4a60ca26a3927a799ea662b5b2b0e5
|
refs/heads/default
| 2023-08-29T07:33:12.771205
| 2023-07-08T20:17:27
| 2023-07-08T20:17:27
| 37,686,316
| 376
| 74
|
NOASSERTION
| 2023-07-08T20:17:28
| 2015-06-18T21:33:42
|
C
|
UTF-8
|
C
| false
| false
| 265
|
c
|
setbuf.c
|
/*
* setbuf.c - control buffering of a stream
*/
/* $Id$ */
#include <stdio.h>
#if ACKCONF_WANT_STDIO && ACKCONF_WANT_EMULATED_FILE
void setbuf(register FILE* stream, char* buf)
{
(void)setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), (size_t)BUFSIZ);
}
#endif
|
78599c84b3cf11343982d4970082b8a2e3db85ea
|
2c73a693c2b3c162eae2ab94f649d8c4494878ba
|
/components/u8g2/u8x8_debounce.c
|
f6dc156b7516f6da98ecd44ca48fe1bd2bfd759f
|
[
"MIT"
] |
permissive
|
openLuat/LuatOS
|
185e1e140aed908434168133571ddcafe98f4e12
|
4b29d5121ab4f7133630331e8502c526c7856897
|
refs/heads/master
| 2023-08-23T04:57:23.263539
| 2023-08-23T04:46:46
| 2023-08-23T04:46:46
| 230,403,844
| 378
| 93
|
MIT
| 2021-12-17T02:19:30
| 2019-12-27T08:29:19
|
C
|
UTF-8
|
C
| false
| false
| 5,614
|
c
|
u8x8_debounce.c
|
/*
u8x8_debounce.c
Key/button simple debounce algorithm (Addon for u8x8)
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "u8x8.h"
static uint8_t u8x8_read_pin_state(u8x8_t *u8x8)
{
uint8_t i;
uint8_t pin_state;
pin_state = 255; /* be compatible with the setup of the default pin setup, which is 255 */
for( i = 0; i < U8X8_PIN_INPUT_CNT; i++ )
{
pin_state <<= 1;
/* the callback function should put the return value into this variable */
u8x8->gpio_result = 1;
u8x8_gpio_call(u8x8, U8X8_MSG_GPIO(i+U8X8_PIN_OUTPUT_CNT), 0);
pin_state |= u8x8->gpio_result & 1;
}
return pin_state;
}
/*
return 0 to U8X8_PIN_INPUT_CNT-1 if there is a difference
return U8X8_PIN_INPUT_CNT if there is no difference
*/
static uint8_t u8x8_find_first_diff(uint8_t a, uint8_t b)
{
uint8_t mask;
uint8_t i;
mask = 1;
i = U8X8_PIN_INPUT_CNT;
do
{
i--;
if ( (a & mask) != (b & mask) )
return i;
mask <<= 1;
} while( i > 0 );
return U8X8_PIN_INPUT_CNT;
}
/*
State A:
u8x8->debounce_last_pin_state == current_state
--> State A
u8x8->debounce_last_pin_state != current_state
--> u8x8->debounce_last_pin_state = current_state
--> State B + cnt
State B + cnt
--> state--
State B
u8x8->debounce_last_pin_state == current_state
--> keypress detected
--> State C
u8x8->debounce_last_pin_state != current_state
--> State A
State C
u8x8->debounce_last_pin_state == current_state
--> State C
u8x8->debounce_last_pin_state != current_state
--> State A
*/
#ifdef __unix__xxxxxx_THIS_IS_DISABLED
#include <stdio.h>
#include <stdlib.h>
uint8_t u8x8_GetMenuEvent(u8x8_t *u8x8)
{
int c;
c = getc(stdin);
switch(c)
{
case 'n':
return U8X8_MSG_GPIO_MENU_NEXT;
case 'p':
return U8X8_MSG_GPIO_MENU_PREV;
case 's':
return U8X8_MSG_GPIO_MENU_SELECT;
case 'h':
return U8X8_MSG_GPIO_MENU_HOME;
case 'x':
exit(0);
default:
puts("press n, p, s, h or x");
break;
}
return 0;
}
#else /* __unix__ */
#define U8X8_DEBOUNCE_WAIT 2
/* do debounce and return a GPIO msg which indicates the event */
/* returns 0, if there is no event */
#if defined(__GNUC__) && !defined(__CYGWIN__)
# pragma weak u8x8_GetMenuEvent
#endif
uint8_t u8x8_GetMenuEvent(u8x8_t *u8x8)
{
uint8_t pin_state;
uint8_t result_msg = 0; /* invalid message, no event */
pin_state = u8x8_read_pin_state(u8x8);
/* States A, B, C & D are encoded in the upper 4 bit*/
switch(u8x8->debounce_state)
{
case 0x00: /* State A, default state */
if ( u8x8->debounce_default_pin_state != pin_state )
{
//u8x8->debounce_last_pin_state = pin_state;
u8x8->debounce_state = 0x010 + U8X8_DEBOUNCE_WAIT;
}
break;
case 0x10: /* State B */
//if ( u8x8->debounce_last_pin_state != pin_state )
if ( u8x8->debounce_default_pin_state == pin_state )
{
u8x8->debounce_state = 0x00; /* back to state A */
}
else
{
/* keypress detected */
u8x8->debounce_last_pin_state = pin_state;
//result_msg = U8X8_MSG_GPIO_MENU_NEXT;
u8x8->debounce_state = 0x020 + U8X8_DEBOUNCE_WAIT; /* got to state C */
}
break;
case 0x20: /* State C */
if ( u8x8->debounce_last_pin_state != pin_state )
{
u8x8->debounce_state = 0x00; /* back to state A */
}
else
{
u8x8->debounce_state = 0x030; /* got to state D */
}
break;
case 0x30: /* State D */
/* wait until key release */
if ( u8x8->debounce_default_pin_state == pin_state )
{
u8x8->debounce_state = 0x00; /* back to state A */
result_msg = U8X8_MSG_GPIO(u8x8_find_first_diff(u8x8->debounce_default_pin_state, u8x8->debounce_last_pin_state)+U8X8_PIN_OUTPUT_CNT);
}
else
{
//result_msg = U8X8_MSG_GPIO_MENU_NEXT;
// maybe implement autorepeat here
}
break;
default:
u8x8->debounce_state--; /* count down, until there is a valid state */
break;
}
return result_msg;
}
#endif /* __unix__ */
|
d97537a096089674834d4e259de8a9593a1ee82a
|
e814383d36a10839104efaa4df277996ab220fa3
|
/opal/mca/btl/smcuda/btl_smcuda_component.c
|
2adcc5229a4f9cb6d22a211da3bf4d74df065772
|
[
"mpich2",
"BSD-3-Clause-Open-MPI"
] |
permissive
|
open-mpi/ompi
|
a1d7483ae1d83dd8fd8ae3ee95e832e0a0ee04e3
|
1edfdb025c4450f694600083ad871cf06c8d45cd
|
refs/heads/main
| 2023-09-01T01:30:02.040705
| 2023-08-29T17:32:18
| 2023-08-29T17:32:18
| 24,107,001
| 2,008
| 973
|
NOASSERTION
| 2023-09-14T20:59:26
| 2014-09-16T16:08:30
|
C
|
UTF-8
|
C
| false
| false
| 47,217
|
c
|
btl_smcuda_component.c
|
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/*
* Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2020 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2006-2007 Voltaire. All rights reserved.
* Copyright (c) 2009-2010 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2010-2016 Los Alamos National Security, LLC. All rights
* reserved.
* Copyright (c) 2011-2015 NVIDIA Corporation. All rights reserved.
* Copyright (c) 2014 Intel, Inc. All rights reserved.
* Copyright (c) 2018-2022 Amazon.com, Inc. or its affiliates. All Rights reserved.
* Copyright (c) 2022 IBM Corporation. All rights reserved.
* Copyright (c) 2023 Triad National Security, LLC. All rights
* reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "opal_config.h"
#include <errno.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif /* HAVE_UNISTD_H */
#include <string.h>
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif /* HAVE_FCNTL_H */
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_SYS_MMAN_H
# include <sys/mman.h>
#endif /* HAVE_SYS_MMAN_H */
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h> /* for mkfifo */
#endif /* HAVE_SYS_STAT_H */
#include "opal/mca/accelerator/accelerator.h"
#include "opal/mca/accelerator/base/base.h"
#include "opal/mca/hwloc/base/base.h"
#include "opal/mca/shmem/base/base.h"
#include "opal/mca/shmem/shmem.h"
#include "opal/util/bit_ops.h"
#include "opal/util/output.h"
#include "opal/util/printf.h"
#include "opal/util/show_help.h"
#include "opal/mca/btl/base/btl_base_error.h"
#include "opal/mca/common/sm/common_sm.h"
#include "opal/mca/mpool/base/base.h"
#include "opal/runtime/opal_params.h"
#include "btl_smcuda.h"
#include "btl_smcuda_fifo.h"
#include "btl_smcuda_frag.h"
#include "btl_smcuda_accelerator.h"
static int mca_btl_smcuda_component_open(void);
static int mca_btl_smcuda_component_close(void);
static int smcuda_register(void);
static mca_btl_base_module_t **
mca_btl_smcuda_component_init(int *num_btls, bool enable_progress_threads, bool enable_mpi_threads);
static void mca_btl_smcuda_component_fini(void);
typedef enum {
MCA_BTL_SM_RNDV_MOD_SM = 0,
MCA_BTL_SM_RNDV_MOD_MPOOL
} mca_btl_sm_rndv_module_type_t;
/*
* Shared Memory (SM) component instance.
*/
mca_btl_smcuda_component_t mca_btl_smcuda_component = {
.super =
{
/* First, the mca_base_component_t struct containing meta information
about the component itself */
.btl_version =
{
MCA_BTL_DEFAULT_VERSION("smcuda"),
.mca_open_component = mca_btl_smcuda_component_open,
.mca_close_component = mca_btl_smcuda_component_close,
.mca_register_component_params = smcuda_register,
},
.btl_data =
{/* The component is checkpoint ready */
.param_field = MCA_BASE_METADATA_PARAM_CHECKPOINT},
.btl_init = mca_btl_smcuda_component_init,
.btl_progress = mca_btl_smcuda_component_progress,
} /* end super */
};
/*
* utility routines for parameter registration
*/
static inline int mca_btl_smcuda_param_register_int(const char *param_name, int default_value,
int level, int *storage)
{
*storage = default_value;
(void) mca_base_component_var_register(&mca_btl_smcuda_component.super.btl_version, param_name,
NULL, MCA_BASE_VAR_TYPE_INT, NULL, 0, 0, level,
MCA_BASE_VAR_SCOPE_READONLY, storage);
return *storage;
}
static inline unsigned int mca_btl_smcuda_param_register_uint(const char *param_name,
unsigned int default_value, int level,
unsigned int *storage)
{
*storage = default_value;
(void) mca_base_component_var_register(&mca_btl_smcuda_component.super.btl_version, param_name,
NULL, MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, 0, level,
MCA_BASE_VAR_SCOPE_READONLY, storage);
return *storage;
}
static int mca_btl_smcuda_component_verify(void)
{
/* We canot support async memcpy right now */
if ((mca_btl_smcuda.super.btl_flags & MCA_BTL_FLAGS_ACCELERATOR_COPY_ASYNC_RECV)
|| (mca_btl_smcuda.super.btl_flags & MCA_BTL_FLAGS_ACCELERATOR_COPY_ASYNC_SEND)) {
opal_output_verbose(10, opal_btl_base_framework.framework_output,
"btl: smcuda: disable all asynchronous memcpy support");
}
mca_btl_smcuda.super.btl_flags &= ~(MCA_BTL_FLAGS_ACCELERATOR_COPY_ASYNC_RECV
| MCA_BTL_FLAGS_ACCELERATOR_COPY_ASYNC_SEND);
return mca_btl_base_param_verify(&mca_btl_smcuda.super);
}
static int smcuda_register(void)
{
/* register SM component parameters */
mca_btl_smcuda_component.mpool_min_size = 134217728;
(void) mca_base_component_var_register(&mca_btl_smcuda_component.super.btl_version, "min_size",
"Minimum size of the common/sm mpool shared memory file",
MCA_BASE_VAR_TYPE_UNSIGNED_LONG, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_READONLY,
&mca_btl_smcuda_component.mpool_min_size);
mca_btl_smcuda_param_register_int("free_list_num", 8, OPAL_INFO_LVL_5,
&mca_btl_smcuda_component.sm_free_list_num);
mca_btl_smcuda_param_register_int("free_list_max", -1, OPAL_INFO_LVL_5,
&mca_btl_smcuda_component.sm_free_list_max);
mca_btl_smcuda_param_register_int("free_list_inc", 64, OPAL_INFO_LVL_5,
&mca_btl_smcuda_component.sm_free_list_inc);
mca_btl_smcuda_param_register_int("max_procs", -1, OPAL_INFO_LVL_5,
&mca_btl_smcuda_component.sm_max_procs);
/* there is no practical use for the mpool name parameter since mpool resources differ
between components */
mca_btl_smcuda_component.sm_mpool_name = "sm";
mca_btl_smcuda_param_register_uint("fifo_size", 4096, OPAL_INFO_LVL_4,
&mca_btl_smcuda_component.fifo_size);
mca_btl_smcuda_param_register_int("num_fifos", 1, OPAL_INFO_LVL_4,
&mca_btl_smcuda_component.nfifos);
mca_btl_smcuda_param_register_uint("fifo_lazy_free", 120, OPAL_INFO_LVL_5,
&mca_btl_smcuda_component.fifo_lazy_free);
/* default number of extra procs to allow for future growth */
mca_btl_smcuda_param_register_int("sm_extra_procs", 0, OPAL_INFO_LVL_9,
&mca_btl_smcuda_component.sm_extra_procs);
mca_btl_smcuda_component.allocator = "bucket";
(void) mca_base_component_var_register(
&mca_btl_smcuda_component.super.btl_version, "allocator",
"Name of allocator component to use for btl/smcuda allocations", MCA_BASE_VAR_TYPE_STRING,
NULL, 0, 0, OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_LOCAL, &mca_btl_smcuda_component.allocator);
/* Lower priority when CUDA support is not requested */
if (0 == strcmp(opal_accelerator_base_selected_component.base_version.mca_component_name, "cuda")) {
mca_btl_smcuda.super.btl_exclusivity = MCA_BTL_EXCLUSIVITY_HIGH + 1;
} else {
mca_btl_smcuda.super.btl_exclusivity = MCA_BTL_EXCLUSIVITY_LOW;
}
mca_btl_smcuda_param_register_int("use_cuda_ipc", 1, OPAL_INFO_LVL_4,
&mca_btl_smcuda_component.use_cuda_ipc);
mca_btl_smcuda_param_register_int("use_cuda_ipc_same_gpu", 1, OPAL_INFO_LVL_4,
&mca_btl_smcuda_component.use_cuda_ipc_same_gpu);
mca_btl_smcuda_param_register_int("cuda_ipc_verbose", 0, OPAL_INFO_LVL_4,
&mca_btl_smcuda_component.cuda_ipc_verbose);
mca_btl_smcuda_component.cuda_ipc_output = opal_output_open(NULL);
opal_output_set_verbosity(mca_btl_smcuda_component.cuda_ipc_output,
mca_btl_smcuda_component.cuda_ipc_verbose);
mca_btl_smcuda.super.btl_eager_limit = 4 * 1024;
mca_btl_smcuda.super.btl_rndv_eager_limit = 4 * 1024;
mca_btl_smcuda.super.btl_max_send_size = 32 * 1024;
mca_btl_smcuda.super.btl_rdma_pipeline_send_length = 64 * 1024;
mca_btl_smcuda.super.btl_rdma_pipeline_frag_size = 64 * 1024;
mca_btl_smcuda.super.btl_min_rdma_pipeline_size = 64 * 1024;
mca_btl_smcuda.super.btl_flags = MCA_BTL_FLAGS_SEND;
mca_btl_smcuda.super.btl_registration_handle_size = sizeof(mca_btl_base_registration_handle_t);
mca_btl_smcuda.super.btl_bandwidth = 9000; /* Mbs */
mca_btl_smcuda.super.btl_latency = 1; /* Microsecs */
/* Call the BTL based to register its MCA params */
mca_btl_base_param_register(&mca_btl_smcuda_component.super.btl_version, &mca_btl_smcuda.super);
/* If user has not set the value, then set to the defalt */
if (0 == mca_btl_smcuda.super.btl_accelerator_max_send_size) {
mca_btl_smcuda.super.btl_accelerator_max_send_size = 128 * 1024;
}
#if OPAL_CUDA_GDR_SUPPORT
/* If user has not set the value, then set to magic number which will be converted to the
* minimum size needed to fit the PML header (see pml_ob1.c) */
if (0 == mca_btl_smcuda.super.btl_accelerator_eager_limit) {
mca_btl_smcuda.super.btl_accelerator_eager_limit = SIZE_MAX; /* magic number */
}
#endif /* OPAL_CUDA_SUPPORT */
return mca_btl_smcuda_component_verify();
}
/*
* Called by MCA framework to open the component, registers
* component parameters.
*/
static int mca_btl_smcuda_component_open(void)
{
if (OPAL_SUCCESS != mca_btl_smcuda_component_verify()) {
return OPAL_ERROR;
}
mca_btl_smcuda_component.sm_max_btls = 1;
/* make sure the number of fifos is a power of 2 */
mca_btl_smcuda_component.nfifos = opal_next_poweroftwo_inclusive(
mca_btl_smcuda_component.nfifos);
/* make sure that queue size and lazy free parameter are compatible */
if (mca_btl_smcuda_component.fifo_lazy_free >= (mca_btl_smcuda_component.fifo_size >> 1))
mca_btl_smcuda_component.fifo_lazy_free = (mca_btl_smcuda_component.fifo_size >> 1);
if (mca_btl_smcuda_component.fifo_lazy_free <= 0)
mca_btl_smcuda_component.fifo_lazy_free = 1;
mca_btl_smcuda_component.max_frag_size = mca_btl_smcuda.super.btl_max_send_size;
mca_btl_smcuda_component.eager_limit = mca_btl_smcuda.super.btl_eager_limit;
/* Possibly adjust max_frag_size if the cuda size is bigger */
if (mca_btl_smcuda.super.btl_accelerator_max_send_size > mca_btl_smcuda.super.btl_max_send_size) {
mca_btl_smcuda_component.max_frag_size = mca_btl_smcuda.super.btl_accelerator_max_send_size;
}
opal_output_verbose(10, opal_btl_base_framework.framework_output,
"btl: smcuda: cuda_max_send_size=%d, max_send_size=%d, max_frag_size=%d",
(int) mca_btl_smcuda.super.btl_accelerator_max_send_size,
(int) mca_btl_smcuda.super.btl_max_send_size,
(int) mca_btl_smcuda_component.max_frag_size);
/* initialize objects */
OBJ_CONSTRUCT(&mca_btl_smcuda_component.sm_lock, opal_mutex_t);
OBJ_CONSTRUCT(&mca_btl_smcuda_component.sm_frags_eager, opal_free_list_t);
OBJ_CONSTRUCT(&mca_btl_smcuda_component.sm_frags_max, opal_free_list_t);
OBJ_CONSTRUCT(&mca_btl_smcuda_component.sm_frags_user, opal_free_list_t);
OBJ_CONSTRUCT(&mca_btl_smcuda_component.pending_send_fl, opal_free_list_t);
return OPAL_SUCCESS;
}
static int mca_btl_smcuda_component_close(void)
{
return OPAL_SUCCESS;
}
/*
* component cleanup - sanity checking of queue lengths
*/
static void mca_btl_smcuda_component_fini(void)
{
int rc;
mca_btl_smcuda_accelerator_fini();
OBJ_DESTRUCT(&mca_btl_smcuda_component.sm_lock);
/**
* We don't have to destroy the fragment lists. They are allocated
* directly into the mmapped file, they will auto-magically disappear
* when the file get unmapped.
*/
/*OBJ_DESTRUCT(&mca_btl_smcuda_component.sm_frags_eager);*/
/*OBJ_DESTRUCT(&mca_btl_smcuda_component.sm_frags_max);*/
/* unmap the shared memory control structure */
if (mca_btl_smcuda_component.sm_seg != NULL) {
rc = mca_common_sm_fini(mca_btl_smcuda_component.sm_seg);
if (OPAL_SUCCESS != rc) {
opal_output(0, " mca_common_sm_fini failed\n");
return;
}
/* unlink file, so that it will be deleted when all references
* to it are gone - no error checking, since we want all procs
* to call this, so that in an abnormal termination scenario,
* this file will still get cleaned up */
unlink(mca_btl_smcuda_component.sm_seg->shmem_ds.seg_name);
OBJ_RELEASE(mca_btl_smcuda_component.sm_seg);
}
#if OPAL_ENABLE_PROGRESS_THREADS == 1
/* close/cleanup fifo create for event notification */
if (mca_btl_smcuda_component.sm_fifo_fd > 0) {
/* write a done message down the pipe */
unsigned char cmd = DONE;
if (write(mca_btl_smcuda_component.sm_fifo_fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
opal_output(0, "mca_btl_smcuda_component_close: write fifo failed: errno=%d\n", errno);
}
opal_thread_join(&mca_btl_smcuda_component.sm_fifo_thread, NULL);
close(mca_btl_smcuda_component.sm_fifo_fd);
unlink(mca_btl_smcuda_component.sm_fifo_path);
}
#endif
return;
}
/*
* Returns the number of processes on the node.
*/
static inline int get_num_local_procs(void)
{
/* num_local_peers does not include us in
* its calculation, so adjust for that */
return (int) (1 + opal_process_info.num_local_peers);
}
static void calc_sm_max_procs(int n)
{
/* see if need to allocate space for extra procs */
if (0 > mca_btl_smcuda_component.sm_max_procs) {
/* no limit */
if (0 <= mca_btl_smcuda_component.sm_extra_procs) {
/* limit */
mca_btl_smcuda_component.sm_max_procs = n + mca_btl_smcuda_component.sm_extra_procs;
} else {
/* no limit */
mca_btl_smcuda_component.sm_max_procs = 2 * n;
}
}
}
static int create_and_attach(mca_btl_smcuda_component_t *comp_ptr, size_t size, char *file_name,
size_t size_ctl_structure, size_t data_seg_alignment,
mca_common_sm_module_t **out_modp)
{
if (NULL
== (*out_modp = mca_common_sm_module_create_and_attach(size, file_name, size_ctl_structure,
data_seg_alignment))) {
opal_output(0,
"create_and_attach: unable to create shared memory "
"BTL coordinating structure :: size %lu \n",
(unsigned long) size);
return OPAL_ERROR;
}
return OPAL_SUCCESS;
}
static int get_mpool_res_size(int32_t max_procs, size_t *out_res_size)
{
size_t size = 0;
*out_res_size = 0;
/* determine how much memory to create */
/*
* This heuristic formula mostly says that we request memory for:
* - nfifos FIFOs, each comprising:
* . a sm_fifo_t structure
* . many pointers (fifo_size of them per FIFO)
* - eager fragments (2*n of them, allocated in sm_free_list_inc chunks)
* - max fragments (sm_free_list_num of them)
*
* On top of all that, we sprinkle in some number of
* "opal_cache_line_size" additions to account for some
* padding and edge effects that may lie in the allocator.
*/
size = FIFO_MAP_NUM(max_procs)
* (sizeof(sm_fifo_t) + sizeof(void *) * mca_btl_smcuda_component.fifo_size
+ 4 * opal_cache_line_size)
+ (2 * max_procs + mca_btl_smcuda_component.sm_free_list_inc)
* (mca_btl_smcuda_component.eager_limit + 2 * opal_cache_line_size)
+ mca_btl_smcuda_component.sm_free_list_num
* (mca_btl_smcuda_component.max_frag_size + 2 * opal_cache_line_size);
/* add something for the control structure */
size += sizeof(mca_common_sm_module_t);
/* before we multiply by max_procs, make sure the result won't overflow */
/* Stick that little pad in, particularly since we'll eventually
* need a little extra space. E.g., in mca_mpool_sm_init() in
* mpool_sm_component.c when sizeof(mca_common_sm_module_t) is
* added.
*/
if (((double) size) * max_procs > LONG_MAX - 4096) {
return OPAL_ERR_VALUE_OUT_OF_BOUNDS;
}
size *= (size_t) max_procs;
*out_res_size = size;
return OPAL_SUCCESS;
}
/* Generates all the unique paths for the shared-memory segments that this BTL
* needs along with other file paths used to share "connection information". */
static int set_uniq_paths_for_init_rndv(mca_btl_smcuda_component_t *comp_ptr)
{
int rc = OPAL_ERR_OUT_OF_RESOURCE;
/* NOTE: don't forget to free these after init */
comp_ptr->sm_mpool_ctl_file_name = NULL;
comp_ptr->sm_mpool_rndv_file_name = NULL;
comp_ptr->sm_ctl_file_name = NULL;
comp_ptr->sm_rndv_file_name = NULL;
if (opal_asprintf(&comp_ptr->sm_mpool_ctl_file_name,
"%s" OPAL_PATH_SEP "shared_mem_cuda_pool.%s",
opal_process_info.job_session_dir, opal_process_info.nodename)
< 0) {
/* rc set */
goto out;
}
if (opal_asprintf(&comp_ptr->sm_mpool_rndv_file_name,
"%s" OPAL_PATH_SEP "shared_mem_cuda_pool_rndv.%s",
opal_process_info.job_session_dir, opal_process_info.nodename)
< 0) {
/* rc set */
goto out;
}
if (opal_asprintf(&comp_ptr->sm_ctl_file_name,
"%s" OPAL_PATH_SEP "shared_mem_cuda_btl_module.%s",
opal_process_info.job_session_dir, opal_process_info.nodename)
< 0) {
/* rc set */
goto out;
}
if (opal_asprintf(&comp_ptr->sm_rndv_file_name,
"%s" OPAL_PATH_SEP "shared_mem_cuda_btl_rndv.%s",
opal_process_info.job_session_dir, opal_process_info.nodename)
< 0) {
/* rc set */
goto out;
}
/* all is well */
rc = OPAL_SUCCESS;
out:
if (OPAL_SUCCESS != rc) {
if (comp_ptr->sm_mpool_ctl_file_name) {
free(comp_ptr->sm_mpool_ctl_file_name);
}
if (comp_ptr->sm_mpool_rndv_file_name) {
free(comp_ptr->sm_mpool_rndv_file_name);
}
if (comp_ptr->sm_ctl_file_name) {
free(comp_ptr->sm_ctl_file_name);
}
if (comp_ptr->sm_rndv_file_name) {
free(comp_ptr->sm_rndv_file_name);
}
}
return rc;
}
static int create_rndv_file(mca_btl_smcuda_component_t *comp_ptr,
mca_btl_sm_rndv_module_type_t type)
{
size_t size = 0;
int rc = OPAL_SUCCESS;
int fd = -1;
char *fname = NULL;
/* used as a temporary store so we can extract shmem_ds info */
mca_common_sm_module_t *tmp_modp = NULL;
if (MCA_BTL_SM_RNDV_MOD_MPOOL == type) {
/* get the segment size for the sm mpool. */
if (OPAL_SUCCESS != (rc = get_mpool_res_size(comp_ptr->sm_max_procs, &size))) {
/* rc is already set */
goto out;
}
/* update size if less than required minimum */
if (size < mca_btl_smcuda_component.mpool_min_size) {
size = mca_btl_smcuda_component.mpool_min_size;
}
/* we only need the shmem_ds info at this point. initialization will be
* completed in the mpool module code. the idea is that we just need this
* info so we can populate the rndv file (or modex when we have it). */
if (OPAL_SUCCESS
!= (rc = create_and_attach(comp_ptr, size, comp_ptr->sm_mpool_ctl_file_name,
sizeof(mca_common_sm_module_t), 8, &tmp_modp))) {
/* rc is set */
goto out;
}
fname = comp_ptr->sm_mpool_rndv_file_name;
} else if (MCA_BTL_SM_RNDV_MOD_SM == type) {
/* calculate the segment size. */
size = sizeof(mca_common_sm_seg_header_t)
+ comp_ptr->sm_max_procs * (sizeof(sm_fifo_t *) + sizeof(char *) + sizeof(uint16_t))
+ opal_cache_line_size;
if (OPAL_SUCCESS
!= (rc = create_and_attach(comp_ptr, size, comp_ptr->sm_ctl_file_name,
sizeof(mca_common_sm_seg_header_t), opal_cache_line_size,
&comp_ptr->sm_seg))) {
/* rc is set */
goto out;
}
fname = comp_ptr->sm_rndv_file_name;
tmp_modp = comp_ptr->sm_seg;
} else {
return OPAL_ERR_BAD_PARAM;
}
/* at this point, we have all the info we need to populate the rendezvous
* file containing all the meta info required for attach. */
/* now just write the contents of tmp_modp->shmem_ds to the full
* sizeof(opal_shmem_ds_t), so we know where the mpool_res_size starts. */
if (-1 == (fd = open(fname, O_CREAT | O_RDWR, 0600))) {
int err = errno;
opal_show_help("help-mpi-btl-smcuda.txt", "sys call fail", true, "open(2)", strerror(err),
err);
rc = OPAL_ERR_IN_ERRNO;
goto out;
}
if ((ssize_t) sizeof(opal_shmem_ds_t)
!= write(fd, &(tmp_modp->shmem_ds), sizeof(opal_shmem_ds_t))) {
int err = errno;
opal_show_help("help-mpi-btl-smcuda.txt", "sys call fail", true, "write(2)", strerror(err),
err);
rc = OPAL_ERR_IN_ERRNO;
goto out;
}
if (MCA_BTL_SM_RNDV_MOD_MPOOL == type) {
if ((ssize_t) sizeof(size) != write(fd, &size, sizeof(size))) {
int err = errno;
opal_show_help("help-mpi-btl-smcuda.txt", "sys call fail", true, "write(2)",
strerror(err), err);
rc = OPAL_ERR_IN_ERRNO;
goto out;
}
/* only do this for the mpool case */
OBJ_RELEASE(tmp_modp);
}
out:
if (-1 != fd) {
(void) close(fd);
}
return rc;
}
/*
* Creates information required for the sm modex and modex sends it.
*/
static int backing_store_init(mca_btl_smcuda_component_t *comp_ptr, uint32_t local_rank)
{
int rc = OPAL_SUCCESS;
if (OPAL_SUCCESS != (rc = set_uniq_paths_for_init_rndv(comp_ptr))) {
goto out;
}
/* only let the lowest rank setup the metadata */
if (0 == local_rank) {
/* === sm mpool === */
if (OPAL_SUCCESS != (rc = create_rndv_file(comp_ptr, MCA_BTL_SM_RNDV_MOD_MPOOL))) {
goto out;
}
/* === sm === */
if (OPAL_SUCCESS != (rc = create_rndv_file(comp_ptr, MCA_BTL_SM_RNDV_MOD_SM))) {
goto out;
}
}
out:
return rc;
}
/**
* Send a CUDA IPC ACK or NOTREADY message back to the peer.
*
* @param btl (IN) BTL module
* @param peer (IN) BTL peer addressing
* @param peer (IN) If ready, then send ACK
*/
static void mca_btl_smcuda_send_cuda_ipc_ack(struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, int ready)
{
mca_btl_smcuda_frag_t *frag;
ctrlhdr_t ctrlhdr;
int rc;
if (mca_btl_smcuda_component.num_outstanding_frags * 2
> (int) mca_btl_smcuda_component.fifo_size) {
mca_btl_smcuda_component_progress();
}
/* allocate a fragment, giving up if we can't get one */
MCA_BTL_SMCUDA_FRAG_ALLOC_EAGER(frag);
if (OPAL_UNLIKELY(NULL == frag)) {
endpoint->ipcstate = IPC_BAD;
return;
}
if (ready) {
ctrlhdr.ctag = IPC_ACK;
} else {
ctrlhdr.ctag = IPC_NOTREADY;
}
/* Fill in fragment fields. */
frag->hdr->tag = MCA_BTL_TAG_SMCUDA;
frag->base.des_flags = MCA_BTL_DES_FLAGS_BTL_OWNERSHIP;
frag->endpoint = endpoint;
memcpy(frag->segment.seg_addr.pval, &ctrlhdr, sizeof(struct ctrlhdr_st));
/* write the fragment pointer to the FIFO */
/*
* Note that we don't care what the FIFO-write return code is. Even if
* the return code indicates failure, the write has still "completed" from
* our point of view: it has been posted to a "pending send" queue.
*/
OPAL_THREAD_ADD_FETCH32(&mca_btl_smcuda_component.num_outstanding_frags, +1);
MCA_BTL_SMCUDA_FIFO_WRITE(endpoint, endpoint->my_smp_rank, endpoint->peer_smp_rank,
(void *) VIRTUAL2RELATIVE(frag->hdr), false, true, rc);
/* Set state now that we have sent message */
if (ready) {
endpoint->ipcstate = IPC_ACKED;
} else {
endpoint->ipcstate = IPC_INIT;
}
return;
}
/* This function is utilized to set up CUDA IPC support within the smcuda
* BTL. It handles smcuda specific control messages that are triggered
* when GPU memory transfers are initiated. */
static void btl_smcuda_control(mca_btl_base_module_t *btl,
const mca_btl_base_receive_descriptor_t *descriptor)
{
int mydevnum, ipcaccess, res;
ctrlhdr_t ctrlhdr;
opal_proc_t *ep_proc;
mca_btl_smcuda_t *smcuda_btl = (mca_btl_smcuda_t *) btl;
const mca_btl_base_segment_t *segments = descriptor->des_segments;
struct mca_btl_base_endpoint_t *endpoint = descriptor->endpoint;
ep_proc = endpoint->proc_opal;
/* Copy out control message payload to examine it */
memcpy(&ctrlhdr, segments->seg_addr.pval, sizeof(struct ctrlhdr_st));
/* Handle an incoming CUDA IPC control message. */
switch (ctrlhdr.ctag) {
case IPC_REQ:
/* Initial request to set up IPC. If the state of IPC
* initialization is IPC_INIT, then check on the peer to peer
* access and act accordingly. If we are in the IPC_SENT
* state, then this means both sides are trying to set up the
* connection. If my smp rank is higher then check and act
* accordingly. Otherwise, drop the request and let the other
* side continue the handshake. */
OPAL_THREAD_LOCK(&endpoint->endpoint_lock);
if ((IPC_INIT == endpoint->ipcstate)
|| ((IPC_SENT == endpoint->ipcstate)
&& (endpoint->my_smp_rank > endpoint->peer_smp_rank))) {
endpoint->ipcstate = IPC_ACKING; /* Move into new state to prevent any new connection
attempts */
OPAL_THREAD_UNLOCK(&endpoint->endpoint_lock);
/* Get my current device. If this fails, move this endpoint state into
* bad state. No need to send a reply. */
res = opal_accelerator.get_device(&mydevnum);
if (0 != res) {
endpoint->ipcstate = IPC_BAD;
return;
}
/* Check for IPC support between devices. If they are the
* same device and use_cuda_ipc_same_gpu is 1 (default),
* then assume CUDA IPC is possible. This could be a
* device running in DEFAULT mode or running under MPS.
* Otherwise, check peer access to determine CUDA IPC
* support. If the CUDA API call fails, then just move
* endpoint into bad state. No need to send a reply. */
if (mydevnum == ctrlhdr.cudev) {
if (mca_btl_smcuda_component.use_cuda_ipc_same_gpu) {
ipcaccess = 1;
} else {
opal_output_verbose(
10, mca_btl_smcuda_component.cuda_ipc_output,
"Analyzed CUDA IPC request: myrank=%d, mydev=%d, peerrank=%d, "
"peerdev=%d --> Access is disabled by btl_smcuda_use_cuda_ipc_same_gpu",
endpoint->my_smp_rank, mydevnum, endpoint->peer_smp_rank, ctrlhdr.cudev);
endpoint->ipcstate = IPC_BAD;
return;
}
} else {
res = opal_accelerator.device_can_access_peer(&ipcaccess, mydevnum, ctrlhdr.cudev);
if (0 != res) {
opal_output_verbose(
10, mca_btl_smcuda_component.cuda_ipc_output,
"Analyzed CUDA IPC request: myrank=%d, mydev=%d, peerrank=%d, "
"peerdev=%d --> Access is disabled because peer check failed with err=%d",
endpoint->my_smp_rank, mydevnum, endpoint->peer_smp_rank, ctrlhdr.cudev,
res);
endpoint->ipcstate = IPC_BAD;
return;
}
}
opal_output_verbose(10, mca_btl_smcuda_component.cuda_ipc_output,
"Analyzed CUDA IPC request: myrank=%d, mydev=%d, peerrank=%d, "
"peerdev=%d --> ACCESS=%d",
endpoint->my_smp_rank, mydevnum, endpoint->peer_smp_rank,
ctrlhdr.cudev, ipcaccess);
if (0 == ipcaccess) {
/* No CUDA IPC support */
opal_output_verbose(10, mca_btl_smcuda_component.cuda_ipc_output,
"Not sending CUDA IPC ACK, no P2P support");
endpoint->ipcstate = IPC_BAD;
} else {
/* CUDA IPC works */
smcuda_btl->error_cb(&smcuda_btl->super, MCA_BTL_ERROR_FLAGS_ADD_ACCELERATOR_IPC, ep_proc,
(char *) &mca_btl_smcuda_component.cuda_ipc_output);
opal_output_verbose(
10, mca_btl_smcuda_component.cuda_ipc_output,
"Sending CUDA IPC ACK: myrank=%d, mydev=%d, peerrank=%d, peerdev=%d",
endpoint->my_smp_rank, mydevnum, endpoint->peer_smp_rank, ctrlhdr.cudev);
mca_btl_smcuda_send_cuda_ipc_ack(btl, endpoint, 1);
}
} else {
OPAL_THREAD_UNLOCK(&endpoint->endpoint_lock);
opal_output_verbose(10, mca_btl_smcuda_component.cuda_ipc_output,
"Not sending CUDA IPC ACK because request already initiated");
}
break;
case IPC_ACK:
opal_output_verbose(10, mca_btl_smcuda_component.cuda_ipc_output,
"Received CUDA IPC ACK, notifying PML: myrank=%d, peerrank=%d",
endpoint->my_smp_rank, endpoint->peer_smp_rank);
smcuda_btl->error_cb(&smcuda_btl->super, MCA_BTL_ERROR_FLAGS_ADD_ACCELERATOR_IPC, ep_proc,
(char *) &mca_btl_smcuda_component.cuda_ipc_output);
assert(endpoint->ipcstate == IPC_SENT);
endpoint->ipcstate = IPC_ACKED;
break;
case IPC_NOTREADY:
/* The remote side is not ready. Reset state to initialized so next
* send call will try again to set up connection. */
opal_output_verbose(10, mca_btl_smcuda_component.cuda_ipc_output,
"Received CUDA IPC NOTREADY, reset state to allow another attempt: "
"myrank=%d, peerrank=%d",
endpoint->my_smp_rank, endpoint->peer_smp_rank);
OPAL_THREAD_LOCK(&endpoint->endpoint_lock);
if (IPC_SENT == endpoint->ipcstate) {
endpoint->ipcstate = IPC_INIT;
}
OPAL_THREAD_UNLOCK(&endpoint->endpoint_lock);
break;
default:
opal_output(0, "Received UNKNOWN CUDA IPC control message. This should not happen.");
}
}
/*
* SM component initialization
*/
static mca_btl_base_module_t **
mca_btl_smcuda_component_init(int *num_btls, bool enable_progress_threads, bool enable_mpi_threads)
{
int num_local_procs = 0;
mca_btl_base_module_t **btls = NULL;
uint32_t my_local_rank = UINT32_MAX;
*num_btls = 0;
/* lookup/create shared memory pool only when used */
mca_btl_smcuda_component.sm_mpool = NULL;
mca_btl_smcuda_component.sm_mpool_base = NULL;
if (OPAL_SUCCESS != mca_btl_smcuda_accelerator_init()) {
return NULL;
}
/* if no session directory was created, then we cannot be used */
if (NULL == opal_process_info.job_session_dir) {
/* SKG - this isn't true anymore. Some backing facilities don't require a
* file-backed store. Extend shmem to provide this info one day. Especially
* when we use a proper modex for init. */
return NULL;
}
/* if we don't have locality information, then we cannot be used because we
* need to know who the respective node ranks for initialization. note the
* use of my_local_rank here. we use this instead of my_node_rank because in
* the spawn case we need to designate a metadata creator rank within the
* set of processes that are initializing the btl, and my_local_rank seems
* to provide that for us. */
if (UINT32_MAX == (my_local_rank = opal_process_info.my_local_rank)) {
opal_show_help("help-mpi-btl-smcuda.txt", "no locality", true);
return NULL;
}
/* no use trying to use sm with less than two procs, so just bail. */
if ((num_local_procs = get_num_local_procs()) < 2) {
return NULL;
}
/* calculate max procs so we can figure out how large to make the
* shared-memory segment. this routine sets component sm_max_procs. */
calc_sm_max_procs(num_local_procs);
/* Before we can safely create the backend file we need to know minimal
* information about the local node. We need at least a size of a cache line
* as we align the data in the backing file to it. The simplest way for now is
* to force the HWLOC initialization.
*/
opal_hwloc_base_get_topology();
/* This is where the modex will live some day. For now, just have local rank
* 0 create a rendezvous file containing the backing store info, so the
* other local procs can read from it during add_procs. The rest will just
* stash the known paths for use later in init. */
if (OPAL_SUCCESS != backing_store_init(&mca_btl_smcuda_component, my_local_rank)) {
return NULL;
}
#if OPAL_ENABLE_PROGRESS_THREADS == 1
/* create a named pipe to receive events */
sprintf(mca_btl_smcuda_component.sm_fifo_path, "%s" OPAL_PATH_SEP "sm_fifo.%lu",
opal_process_info.job_session_dir, (unsigned long) OPAL_PROC_MY_NAME->vpid);
if (mkfifo(mca_btl_smcuda_component.sm_fifo_path, 0660) < 0) {
opal_output(0, "mca_btl_smcuda_component_init: mkfifo failed with errno=%d\n", errno);
return NULL;
}
mca_btl_smcuda_component.sm_fifo_fd = open(mca_btl_smcuda_component.sm_fifo_path, O_RDWR);
if (mca_btl_smcuda_component.sm_fifo_fd < 0) {
opal_output(0,
"mca_btl_smcuda_component_init: "
"open(%s) failed with errno=%d\n",
mca_btl_smcuda_component.sm_fifo_path, errno);
return NULL;
}
OBJ_CONSTRUCT(&mca_btl_smcuda_component.sm_fifo_thread, opal_thread_t);
mca_btl_smcuda_component.sm_fifo_thread.t_run = (opal_thread_fn_t)
mca_btl_smcuda_component_event_thread;
opal_thread_start(&mca_btl_smcuda_component.sm_fifo_thread);
#endif
mca_btl_smcuda_component.sm_btls = (mca_btl_smcuda_t **) malloc(
mca_btl_smcuda_component.sm_max_btls * sizeof(mca_btl_smcuda_t *));
if (NULL == mca_btl_smcuda_component.sm_btls) {
return NULL;
}
/* allocate the Shared Memory BTL */
*num_btls = 1;
btls = (mca_btl_base_module_t **) malloc(sizeof(mca_btl_base_module_t *));
if (NULL == btls) {
return NULL;
}
/* get pointer to the btls */
btls[0] = (mca_btl_base_module_t *) (&(mca_btl_smcuda));
mca_btl_smcuda_component.sm_btls[0] = (mca_btl_smcuda_t *) (&(mca_btl_smcuda));
/* initialize some BTL data */
/* start with no SM procs */
mca_btl_smcuda_component.num_smp_procs = 0;
mca_btl_smcuda_component.my_smp_rank = -1; /* not defined */
mca_btl_smcuda_component.sm_num_btls = 1;
/* set flag indicating btl not inited */
mca_btl_smcuda.btl_inited = false;
/* Assume CUDA GET works. */
mca_btl_smcuda.super.btl_get = mca_btl_smcuda_get_cuda;
/* Register a smcuda control function to help setup IPC support */
mca_btl_base_active_message_trigger[MCA_BTL_TAG_SMCUDA].cbfunc = btl_smcuda_control;
mca_btl_base_active_message_trigger[MCA_BTL_TAG_SMCUDA].cbdata = NULL;
/*
* add smcuda component fini code to opal's list of cleanup functions.
* Cleanups are called before all the MCA frameworks are closed, so by
* of the closing of the BTL framework with the accelerator framework, etc. etc.
* We add it here in the btl_init routine as its possible under
* certain scenarios that one of the steps above in this routine will fail,
* resulting in a NULL return value, and the btl component selector to close
* the btl. This can also happen in normal operation, for instance for singleton
* where the smcuda is closed during mpi initialization. We don't want
* to add a cleanup callback if no btls were returned.
*/
if (NULL != btls) {
opal_finalize_register_cleanup(mca_btl_smcuda_component_fini);
}
return btls;
}
/*
* SM component progress.
*/
#if OPAL_ENABLE_PROGRESS_THREADS == 1
void mca_btl_smcuda_component_event_thread(opal_object_t *thread)
{
while (1) {
unsigned char cmd;
if (read(mca_btl_smcuda_component.sm_fifo_fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
/* error condition */
return;
}
if (DONE == cmd) {
/* return when done message received */
return;
}
mca_btl_smcuda_component_progress();
}
}
#endif
void btl_smcuda_process_pending_sends(struct mca_btl_base_endpoint_t *ep)
{
btl_smcuda_pending_send_item_t *si;
int rc;
while (0 < opal_list_get_size(&ep->pending_sends)) {
/* Note that we access the size of ep->pending_sends unlocked
as it doesn't really matter if the result is wrong as
opal_list_remove_first is called with a lock and we handle it
not finding an item to process */
OPAL_THREAD_LOCK(&ep->endpoint_lock);
si = (btl_smcuda_pending_send_item_t *) opal_list_remove_first(&ep->pending_sends);
OPAL_THREAD_UNLOCK(&ep->endpoint_lock);
if (NULL == si)
return; /* Another thread got in before us. That's ok. */
OPAL_THREAD_ADD_FETCH32(&mca_btl_smcuda_component.num_pending_sends, -1);
MCA_BTL_SMCUDA_FIFO_WRITE(ep, ep->my_smp_rank, ep->peer_smp_rank, si->data, true, false,
rc);
opal_free_list_return(&mca_btl_smcuda_component.pending_send_fl,
(opal_free_list_item_t *) si);
if (OPAL_SUCCESS != rc)
return;
}
}
int mca_btl_smcuda_component_progress(void)
{
/* local variables */
mca_btl_base_segment_t seg;
mca_btl_smcuda_frag_t *frag;
sm_fifo_t *fifo = NULL;
mca_btl_smcuda_hdr_t *hdr;
int my_smp_rank = mca_btl_smcuda_component.my_smp_rank;
int peer_smp_rank, j, rc = 0, nevents = 0;
/* first, deal with any pending sends */
/* This check should be fast since we only need to check one variable. */
if (0 < mca_btl_smcuda_component.num_pending_sends) {
/* perform a loop to find the endpoints that have pending sends */
/* This can take a while longer if there are many endpoints to check. */
for (peer_smp_rank = 0; peer_smp_rank < mca_btl_smcuda_component.num_smp_procs;
peer_smp_rank++) {
struct mca_btl_base_endpoint_t *endpoint;
if (peer_smp_rank == my_smp_rank)
continue;
endpoint = mca_btl_smcuda_component.sm_peers[peer_smp_rank];
if (0 < opal_list_get_size(&endpoint->pending_sends))
btl_smcuda_process_pending_sends(endpoint);
}
}
/* poll each fifo */
for (j = 0; j < FIFO_MAP_NUM(mca_btl_smcuda_component.num_smp_procs); j++) {
fifo = &(mca_btl_smcuda_component.fifo[my_smp_rank][j]);
recheck_peer:
/* acquire thread lock */
if (opal_using_threads()) {
opal_atomic_lock(&(fifo->tail_lock));
}
hdr = (mca_btl_smcuda_hdr_t *) sm_fifo_read(fifo);
/* release thread lock */
if (opal_using_threads()) {
opal_atomic_unlock(&(fifo->tail_lock));
}
if (SM_FIFO_FREE == hdr) {
continue;
}
nevents++;
/* dispatch fragment by type */
switch (((uintptr_t) hdr) & MCA_BTL_SMCUDA_FRAG_TYPE_MASK) {
case MCA_BTL_SMCUDA_FRAG_SEND: {
/* change the address from address relative to the shared
* memory address, to a true virtual address */
hdr = (mca_btl_smcuda_hdr_t *) RELATIVE2VIRTUAL(hdr);
peer_smp_rank = hdr->my_smp_rank;
#if OPAL_ENABLE_DEBUG
if (FIFO_MAP(peer_smp_rank) != j) {
opal_output(0,
"mca_btl_smcuda_component_progress: "
"rank %d got %d on FIFO %d, but this sender should send to FIFO %d\n",
my_smp_rank, peer_smp_rank, j, FIFO_MAP(peer_smp_rank));
}
#endif
seg.seg_addr.pval = ((char *) hdr) + sizeof(mca_btl_smcuda_hdr_t);
seg.seg_len = hdr->len;
mca_btl_active_message_callback_t *reg = mca_btl_base_active_message_trigger + hdr->tag;
mca_btl_base_receive_descriptor_t recv_desc = {.endpoint = mca_btl_smcuda_component
.sm_peers[peer_smp_rank],
.des_segments = &seg,
.des_segment_count = 1,
.tag = hdr->tag,
.cbdata = reg->cbdata};
reg->cbfunc(&mca_btl_smcuda.super, &recv_desc);
/* return the fragment */
MCA_BTL_SMCUDA_FIFO_WRITE(mca_btl_smcuda_component.sm_peers[peer_smp_rank], my_smp_rank,
peer_smp_rank, hdr->frag, false, true, rc);
break;
}
case MCA_BTL_SMCUDA_FRAG_ACK: {
int status = (uintptr_t) hdr & MCA_BTL_SMCUDA_FRAG_STATUS_MASK;
int btl_ownership;
struct mca_btl_base_endpoint_t *endpoint;
frag = (mca_btl_smcuda_frag_t *) ((
char *) ((uintptr_t) hdr
& (~(MCA_BTL_SMCUDA_FRAG_TYPE_MASK | MCA_BTL_SMCUDA_FRAG_STATUS_MASK))));
endpoint = frag->endpoint;
btl_ownership = (frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP);
if (MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags) {
/* completion callback */
frag->base.des_cbfunc(&mca_btl_smcuda.super, frag->endpoint, &frag->base,
status ? OPAL_ERROR : OPAL_SUCCESS);
}
if (btl_ownership) {
MCA_BTL_SMCUDA_FRAG_RETURN(frag);
}
OPAL_THREAD_ADD_FETCH32(&mca_btl_smcuda_component.num_outstanding_frags, -1);
if (0 < opal_list_get_size(&endpoint->pending_sends)) {
btl_smcuda_process_pending_sends(endpoint);
}
goto recheck_peer;
}
default:
/* unknown */
/*
* This code path should presumably never be called.
* It's unclear if it should exist or, if so, how it should be written.
* If we want to return it to the sending process,
* we have to figure out who the sender is.
* It seems we need to subtract the mask bits.
* Then, hopefully this is an sm header that has an smp_rank field.
* Presumably that means the received header was relative.
* Or, maybe this code should just be removed.
*/
opal_output(0, "mca_btl_smcuda_component_progress read an unknown type of header");
hdr = (mca_btl_smcuda_hdr_t *) RELATIVE2VIRTUAL(hdr);
peer_smp_rank = hdr->my_smp_rank;
hdr = (mca_btl_smcuda_hdr_t *) ((uintptr_t) hdr->frag
| MCA_BTL_SMCUDA_FRAG_STATUS_MASK);
MCA_BTL_SMCUDA_FIFO_WRITE(mca_btl_smcuda_component.sm_peers[peer_smp_rank], my_smp_rank,
peer_smp_rank, hdr, false, true, rc);
break;
}
}
(void) rc; /* this is safe to ignore as the message is requeued till success */
/* Check to see if there are any outstanding CUDA events that have
* completed. If so, issue the PML callbacks on the fragments.
*/
while (1 == mca_btl_smcuda_progress_one_ipc_event((mca_btl_base_descriptor_t **) &frag)) {
mca_btl_base_rdma_completion_fn_t cbfunc = (mca_btl_base_rdma_completion_fn_t)
frag->base.des_cbfunc;
cbfunc(&mca_btl_smcuda.super, frag->endpoint, frag->segment.seg_addr.pval,
frag->local_handle, frag->base.des_context, frag->base.des_cbdata, OPAL_SUCCESS);
if (frag->registration != NULL) {
frag->endpoint->rcache->rcache_deregister(frag->endpoint->rcache,
(mca_rcache_base_registration_t *)
frag->registration);
frag->registration = NULL;
MCA_BTL_SMCUDA_FRAG_RETURN(frag);
}
nevents++;
}
return nevents;
}
|
0b1e7037cabbc83611aa4c3c89d16a828e48b09f
|
abe704eb3b53944cdd6505f922f58558e334c589
|
/components/usb/esp_tinyuf2/cdc/tinyusb_types.h
|
106aaaf15531b4b3c179b988dbe242a07b3257b4
|
[
"Apache-2.0"
] |
permissive
|
espressif/esp-iot-solution
|
c25079eb26a8f54ddacd23689a7288533c721916
|
2227f0ca21ab37df9cf9d74182fa84c52dffc76f
|
refs/heads/master
| 2023-09-01T15:06:17.000154
| 2023-08-31T10:26:21
| 2023-08-31T10:26:21
| 99,690,601
| 1,612
| 758
|
Apache-2.0
| 2023-09-08T08:43:59
| 2017-08-08T12:32:16
|
C
|
UTF-8
|
C
| false
| false
| 297
|
h
|
tinyusb_types.h
|
/*
* SPDX-FileCopyrightText: 2020-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#define USB_ESPRESSIF_VID 0x303A
typedef enum {
TINYUSB_USBDEV_0,
} tinyusb_usbdev_t;
#ifdef __cplusplus
}
#endif
|
1a8f2b63f9ae694230377adf5fe694244a96f4b1
|
e73547787354afd9b717ea57fe8dd0695d161821
|
/src/world/area_kpa/kpa_82/kpa_82_0_header.c
|
b505574caeafebc28e2b8e1f17ed1c16a1bc7690
|
[] |
no_license
|
pmret/papermario
|
8b514b19653cef8d6145e47499b3636b8c474a37
|
9774b26d93f1045dd2a67e502b6efc9599fb6c31
|
refs/heads/main
| 2023-08-31T07:09:48.951514
| 2023-08-21T18:07:08
| 2023-08-21T18:07:08
| 287,151,133
| 904
| 139
| null | 2023-09-14T02:44:23
| 2020-08-13T01:22:57
|
C
|
UTF-8
|
C
| false
| false
| 346
|
c
|
kpa_82_0_header.c
|
#include "kpa_82.h"
EntryList N(Entrances) = {
[kpa_82_ENTRY_0] { -210.0, 0.0, 150.0, 90.0 },
[kpa_82_ENTRY_1] { 150.0, 0.0, 150.0, 270.0 },
};
MapSettings N(settings) = {
.main = &N(EVS_Main),
.entryList = &N(Entrances),
.entryCount = ENTRY_COUNT(N(Entrances)),
.tattle = { MSG_MapTattle_kpa_82 },
};
|
8fff24862bfa31eb6b3102dbd32e80a49366ab56
|
08e45b61b7ac40ee355a61cb88d1fd5d499d13a4
|
/7.55 [OLD]/4.70/REBUG/REX/SRC/lv2/include/lv2/syscall.h
|
4333c1c310c86d1c6772c0f2a9e365334a3db5f9
|
[] |
no_license
|
Evilnat/Cobra-PS3
|
fa27f2a34859a1e741ae1925a188c769da3a2a08
|
fc99aa5f893107971b20e95f664bccce69dfc319
|
refs/heads/master
| 2023-03-06T16:12:28.366491
| 2023-03-05T08:01:31
| 2023-03-05T08:01:31
| 160,098,774
| 141
| 50
| null | 2022-11-27T02:22:44
| 2018-12-02T21:36:53
|
C
|
UTF-8
|
C
| false
| false
| 21,127
|
h
|
syscall.h
|
#ifndef __LV2_SYSCALL_H__
#define __LV2_SYSCALL_H__
#include <lv2/lv2.h>
#include <lv2/patch.h>
#define SYS_PROCESS_GETPID 1
#define SYS_PROCESS_WAIT_FOR_CHILD 2
#define SYS_PROCESS_GET_STATUS 4
#define SYS_PROCESS_DETACH_CHILD 5
#define SYS_PROCESS_GET_NUMBER_OF_OBJECT 12
#define SYS_PROCESS_GET_ID 13
#define SYS_PROCESS_IS_SPU_LOCK_LINE_RESERVATION_ADDRESS 14
#define SYS_PROCESS_GETPPID 18
#define SYS_PROCESS_KILL 19
// 21 -> create_process
// 27 -> aother create process too, used for games, ps1 emu, etc
#define SYS_PROCESS_WAIT_FOR_CHILD2 23
#define SYS_PROCESS_GET_SDK_VERSION 25
#define SYS_PROCESS_GET_PARAMSFO 30 /* Added */
#define SYS_PROCESS_GET_PPU_GUID 31
#define SYS_PPU_THREAD_YIELD 43
#define SYS_PPU_THREAD_JOIN 44
#define SYS_PPU_THREAD_DETACH 45
#define SYS_PPU_THREAD_GET_JOIN_STATE 46
#define SYS_PPU_THREAD_SET_PRIORITY 47
#define SYS_PPU_THREAD_GET_PRIORITY 48
#define SYS_PPU_THREAD_GET_STACK_INFORMATION 49
#define SYS_PPU_THREAD_RENAME 56
#define SYS_PPU_THREAD_RECOVER_PAGE_FAULT 57
#define SYS_PPU_THREAD_GET_PAGE_FAULT_CONTEXT 58
#define SYS_TRACE_ALLOCATE_BUFFER 67
#define SYS_TRACE_FREE_BUFFER 68
#define SYS_TRACE_CREATE2 69
#define SYS_TIMER_CREATE 70
#define SYS_TIMER_DESTROY 71
#define SYS_TIMER_GET_INFORMATION 72
#define _SYS_TIMER_START 73
#define SYS_TIMER_STOP 74
#define SYS_TIMER_CONNECT_EVENT_QUEUE 75
#define SYS_TIMER_DISCONNECT_EVENT_QUEUE 76
#define SYS_TRACE_CREATE2_IN_CBEPM 77
#define SYS_INTERRUPT_TAG_CREATE 80
#define SYS_INTERRUPT_TAG_DESTROY 81
#define SYS_EVENT_FLAG_CREATE 82
#define SYS_EVENT_FLAG_DESTROY 83
#define _SYS_INTERRUPT_THREAD_ESTABLISH 84
#define SYS_EVENT_FLAG_WAIT 85
#define SYS_EVENT_FLAG_TRYWAIT 86
#define SYS_EVENT_FLAG_SET 87
#define SYS_INTERRUPT_THREAD_EOI 88
#define _SYS_INTERRUPT_THREAD_DISESTABLISH 89
#define SYS_SEMAPHORE_CREATE 90
#define SYS_SEMAPHORE_DESTROY 91
#define SYS_SEMAPHORE_WAIT 92
#define SYS_SEMAPHORE_TRYWAIT 93
#define SYS_SEMAPHORE_POST 94
#define SYS_MUTEX_CREATE 100
#define SYS_MUTEX_DESTROY 101
#define SYS_MUTEX_LOCK 102
#define SYS_MUTEX_TRYLOCK 103
#define SYS_MUTEX_UNLOCK 104
#define SYS_COND_CREATE 105
#define SYS_COND_DESTROY 106
#define SYS_COND_WAIT 107
#define SYS_COND_SIGNAL 108
#define SYS_COND_SIGNAL_ALL 109
#define SYS_COND_SIGNAL_TO 110
#define SYS_SEMAPHORE_GET_VALUE 114
#define SYS_EVENT_FLAG_CLEAR 118
#define SYS_RWLOCK_CREATE 120
#define SYS_RWLOCK_DESTROY 121
#define SYS_RWLOCK_RLOCK 122
#define SYS_RWLOCK_TRYRLOCK 123
#define SYS_RWLOCK_RUNLOCK 124
#define SYS_RWLOCK_WLOCK 125
#define SYS_RWLOCK_WUNLOCK 127
#define SYS_EVENT_QUEUE_CREATE 128
#define SYS_EVENT_QUEUE_DESTROY 129
#define SYS_EVENT_QUEUE_RECEIVE 130
#define SYS_EVENT_QUEUE_TRYRECEIVE 131
#define SYS_EVENT_FLAG_CANCEL 132
#define SYS_EVENT_QUEUE_DRAIN 133
#define SYS_EVENT_PORT_CREATE 134
#define SYS_EVENT_PORT_DESTROY 135
#define SYS_EVENT_PORT_CONNECT_LOCAL 136
#define SYS_EVENT_PORT_DISCONNECT 137
#define SYS_EVENT_PORT_SEND 138
#define SYS_EVENT_FLAG_GET 139
#define SYS_EVENT_PORT_CONNECT_IPC 140
#define SYS_TIMER_USLEEP 141
#define SYS_TIMER_SLEEP 142
#define SYS_TIME_GET_CURRENT_TIME 145
#define SYS_TIME_GET_TIMEBASE_FREQUENCY 147
#define SYS_RWLOCK_TRYWLOCK 148
#define SYS_RAW_SPU_CREATE_INTERRUPT_TAG 150
#define SYS_RAW_SPU_SET_INT_MASK 151
#define SYS_RAW_SPU_GET_INT_MASK 152
#define SYS_RAW_SPU_SET_INT_STAT 153
#define SYS_RAW_SPU_GET_INT_STAT 154
#define SYS_SPU_IMAGE_OPEN 156
#define SYS_RAW_SPU_CREATE 160
#define SYS_RAW_SPU_DESTROY 161
#define SYS_RAW_SPU_READ_PUINT_MB 163
#define SYS_SPU_THREAD_GET_EXIT_STATUS 165
#define SYS_SPU_THREAD_SET_ARGUMENT 166
#define SYS_SPU_THREAD_GROUP_START_ON_EXIT 167
#define SYS_SPU_INITIALIZE 169
#define SYS_SPU_THREAD_GROUP_CREATE 170
#define SYS_SPU_THREAD_GROUP_DESTROY 171
#define SYS_SPU_THREAD_INITIALIZE 172
#define SYS_SPU_THREAD_GROUP_START 173
#define SYS_SPU_THREAD_GROUP_SUSPEND 174
#define SYS_SPU_THREAD_GROUP_RESUME 175
#define SYS_SPU_THREAD_GROUP_YIELD 176
#define SYS_SPU_THREAD_GROUP_TERMINATE 177
#define SYS_SPU_THREAD_GROUP_JOIN 178
#define SYS_SPU_THREAD_GROUP_SET_PRIORITY 179
#define SYS_SPU_THREAD_GROUP_GET_PRIORITY 180
#define SYS_SPU_THREAD_WRITE_LS 181
#define SYS_SPU_THREAD_READ_LS 182
#define SYS_SPU_THREAD_WRITE_SNR 184
#define SYS_SPU_THREAD_GROUP_CONNECT_EVENT 185
#define SYS_SPU_THREAD_GROUP_DISCONNECT_EVENT 186
#define SYS_SPU_THREAD_SET_SPU_CFG 187
#define SYS_SPU_THREAD_GET_SPU_CFG 188
#define SYS_SPU_THREAD_WRITE_SPU_MB 190
#define SYS_SPU_THREAD_CONNECT_EVENT 191
#define SYS_SPU_THREAD_DISCONNECT_EVENT 192
#define SYS_SPU_THREAD_BIND_QUEUE 193
#define SYS_SPU_THREAD_UNBIND_QUEUE 194
#define SYS_RAW_SPU_SET_SPU_CFG 196
#define SYS_RAW_SPU_GET_SPU_CFG 197
#define SYS_SPU_THREAD_RECOVER_PAGE_FAULT 198
#define SYS_RAW_SPU_RECOVER_PAGE_FAULT 199
#define SYS_SPU_THREAD_GROUP_SET_COOPERATIVE_VICTIMS 250
#define SYS_SPU_THREAD_GROUP_CONNECT_EVENT_ALL_THREADS 251
#define SYS_SPU_THREAD_GROUP_DISCONNECT_EVENT_ALL_THREADS 252
#define SYS_SPU_IMAGE_OPEN_BY_FD 260
#define SYS_VM_MEMORY_MAP 300
#define SYS_VM_UNMAP 301
#define SYS_VM_APPEND_MEMORY 302
#define SYS_VM_RETURN_MEMORY 303
#define SYS_VM_LOCK 304
#define SYS_VM_UNLOCK 305
#define SYS_VM_TOUCH 306
#define SYS_VM_FLUSH 307
#define SYS_VM_INVALIDATE 308
#define SYS_VM_STORE 309
#define SYS_VM_SYNC 310
#define SYS_VM_TEST 311
#define SYS_VM_GET_STATISTICS 312
#define SYS_MEMORY_CONTAINER_CREATE 324
#define SYS_MEMORY_CONTAINER_DESTROY 325
#define SYS_MMAPPER_ALLOCATE_FIXED_ADDRESS 326
#define SYS_MMAPPER_ENABLE_PAGE_FAULT_NOTIFICATION 327
#define SYS_MMAPPER_ALLOCATE_ADDRESS 330
#define SYS_MMAPPER_FREE_ADDRESS 331
#define SYS_MMAPPER_CHANGE_ADDRESS_ACCESS_RIGHT 336
#define SYS_MMAPPER_SEARCH_AND_MAP 337
#define SYS_MEMORY_CONTAINER_GET_SIZE 343
#define SYS_MEMORY_ALLOCATE 348
#define SYS_MEMORY_FREE 349
#define SYS_MEMORY_ALLOCATE_FROM_CONTAINER 350
#define SYS_MEMORY_GET_PAGE_ATTRIBUTE 351
#define SYS_MEMORY_GET_USER_MEMORY_SIZE 352
#define SYS_SM_GET_EXT_EVENT2 378 /* Added */
#define SYS_SM_SHUTDOWN 379 /* Added */
#define SYS_SM_GET_PARAMS 380 /* Added */
#define SYS_GET_HW_CONFIG 393 /* Added */
#define SYS_CONSOLE_WRITE 398
#define SYS_TTY_READ 402
#define SYS_TTY_WRITE 403
#define SYS_OVERLAY_LOAD_MODULE 450
#define SYS_OVERLAY_UNLOAD_MODULE 451
#define SYS_OVERLAY_GET_MODULE_LIST 452
#define SYS_OVERLAY_GET_MODULE_INFO 453
#define SYS_OVERLAY_LOAD_MODULE_BY_FD 454
#define SYS_OVERLAY_GET_MODULE_INFO2 455
#define SYS_OVERLAY_GET_SDK_VERSION 456
#define _SYS_PRX_GET_MODULE_ID_BY_ADDRESS 461
#define _SYS_PRX_LOAD_MODULE_BY_FD 463
#define _SYS_PRX_LOAD_MODULE_ON_MEMCONTAINER_BY_FD 464
#define _SYS_PRX_LOAD_MODULE_LIST 465
#define _SYS_PRX_LOAD_MODULE_LIST_ON_MEMCONTAINER 466
#define SYS_PRX_GET_PPU_GUID 467
#define _SYS_PRX_LOAD_MODULE 480
#define _SYS_PRX_START_MODULE 481
#define _SYS_PRX_STOP_MODULE 482
#define _SYS_PRX_UNLOAD_MODULE 483
#define _SYS_PRX_REGISTER_MODULE 484
#define _SYS_PRX_QUERY_MODULE 485
#define _SYS_PRX_REGISTER_LIBRARY 486
#define _SYS_PRX_UNREGISTER_LIBRARY 487
#define _SYS_PRX_LINK_LIBRARY 488
#define _SYS_PRX_UNLINK_LIBRARY 489
#define _SYS_PRX_QUERY_LIBRARY 490
#define _SYS_PRX_GET_MODULE_LIST 494
#define _SYS_PRX_GET_MODULE_INFO 495
#define _SYS_PRX_GET_MODULE_ID_BY_NAME 496
#define _SYS_PRX_LOAD_MODULE_ON_MEMCONTAINER 497
#define _SYS_PRX_START 498
#define _SYS_PRX_STOP 499
#define SYS_STORAGE_OPEN 600
#define SYS_STORAGE_CLOSE 601
#define SYS_STORAGE_READ 602
#define SYS_STORAGE_WRITE 603
#define SYS_STORAGE_SEND_DEVICE_COMMAND 604
#define SYS_STORAGE_ASYNC_CONFIGURE 605
#define SYS_STORAGE_ASYNC_READ 606
#define SYS_STORAGE_ASYNC_WRITE 607
#define SYS_STORAGE_ASYNC_CANCEL 608
#define SYS_STORAGE_GET_DEVICE_INFO 609
#define SYS_STORAGE_GET_DEVICE_CONFIG 610
#define SYS_STORAGE_REPORT_DEVICES 611
#define SYS_STORAGE_CONFIGURE_MEDIUM_EVENT 612
#define SYS_STORAGE_SET_MEDIUM_POLLING_INTERVAL 613
#define SYS_STORAGE_CREATE_REGION 614
#define SYS_STORAGE_DELETE_REGION 615
#define SYS_STORAGE_EXECUTE_DEVICE_COMMAND 616
#define SYS_STORAGE_GET_REGION_ACL 617
#define SYS_STORAGE_SET_REGION_ACL 618
#define SYS_STORAGE_ASYNC_SEND_DEVICE_COMMAND 619
#define SYS_IO_BUFFER_CREATE 624
#define SYS_IO_BUFFER_DESTROY 625
#define SYS_IO_BUFFER_ALLOCATE 626
#define SYS_IO_BUFFER_FREE 627
#define SYS_GPIO_SET 630
#define SYS_GPIO_GET 631
#define SYS_FSW_CONNECT_EVENT 633
#define SYS_FSW_DISCONNECT_EVENT 634
#define SYS_RSX_DEVICE_OPEN 666
#define SYS_RSX_DEVICE_CLOSE 667
#define SYS_RSX_MEMORY_ALLOCATE 668
#define SYS_RSX_MEMORY_FREE 669
#define SYS_RSX_CONTEXT_ALLOCATE 670
#define SYS_RSX_CONTEXT_FREE 671
#define SYS_RSX_CONTEXT_IOMAP 672
#define SYS_RSX_CONTEXT_IOUNMAP 673
#define SYS_RSX_CONTEXT_ATTRIBUTE 674
#define SYS_RSX_DEVICE_MAP 675
#define SYS_RSX_DEVICE_UNMAP 676
#define SYS_RSX_ATTRIBUTE 677
#define SYS_BDEMU_SEND_COMMAND 699
#define SYS_NET_ACCEPT 700 /* Added */
#define SYS_NET_BIND 701 /* Added */
#define SYS_NET_CONNECT 702 /* Added */
#define SYS_NET_LISTEN 706 /* Added */
#define SYS_NET_RECVFROM 707 /* Added */
#define SYS_NET_SENDTO 710 /* Added */
#define SYS_NET_SHUTDOWN 712 /* Added */
#define SYS_NET_SOCKET 713 /* Added */
#define SYS_NET_CLOSE 714 /* Added */
#define SYS_CELLFSOPEN 801 /* Added */
#define SYS_CELLFSREAD 802 /* Added */
#define SYS_CELLFSWRITE 803 /* Added */
#define SYS_CELLFSCLOSE 804 /* Added */
#define SYS_CELLFSOPENDIR 805 /* Added */
#define SYS_CELLFSSTAT 808 /* Added */
#define SYS_CELLFSFSTAT 809 /* Added */
#define SYS_CELLFSMKDIR 811 /* Added */
#define SYS_CELLFSUNLINK 814 /* Added */
#define SYS_CELLFSUTIME 815 /* Added */
#define SYS_CELLFSLSEEK 818 /* Added */
#define SYS_CELLFSNEWFS 836 /* Added */
#define SYS_CELLFSMOUNT 837 /* Added */
#define SYS_CELLFSUMOUNT 838 /* Added */
// 864. auth psx disc: 0x5004, 1. auth ps3 disc: 0x5007, in/out buffer of 0x18 bytes
// return to normal : 0x5004, 0x29
#define SYS_SS_ACCESS_CONTROL_ENGINE 871 /* Added */
#define SYS_SS_GET_OPEN_PSID 872
#define SYS_SS_GET_CACHE_OF_PRODUCT_MODE 873 /* Added */
#define SYS_SS_GET_CACHE_OF_FLASH_EXT_FLAG 874 /* Added */
#define SYS_SS_GET_BOOT_DEVICE 875 /* Added */
#define SYS_SS_DISC_ACCESS_CONTROL 876 /* Added */
#define SYS_SS_AD_SIGN 878 /* Added */
#define SYS_SS_MEDIA_ID 879 /* Added */
#define SYS_DECI3_OPEN 880
#define SYS_DECI3_CREATE_EVENT_PATH 881
#define SYS_DECI3_CLOSE 882
#define SYS_DECI3_SEND 883
#define SYS_DECI3_RECEIVE 884
#define MAX_NUM_OF_SYSTEM_CALLS 1024
#define LV2_SYSCALL LV2_CONTEXT
#define LV2_SYSCALL2(ret, name, args) asm("" \
" .section \".text\"\n" \
" .align 2\n" \
" .p2align 3,,7\n" \
" .globl "#name"\n" \
" .section \".opd\",\"aw\"\n" \
" .align 3\n" \
#name": \n" \
" .quad .L."#name",.TOC.@tocbase\n" \
" .previous\n" \
" .type "#name", @function\n" \
".L."#name":\n" \
" nop\n" \
" nop\n" \
" nop\n" \
" nop\n" \
" mflr 0\n" \
" std 0, 32(1)\n" \
" std 2, 40(1)\n" \
" bl +4\n" \
" li 0, 0\n" \
" li 2, 0\n" \
" oris 2, 2, __toc@h\n" \
" ori 2, 2, __toc@l\n" \
" oris 0, 0, .L."#name"@h\n" \
" ori 0, 0, .L."#name"@l\n" \
" subf 0, 0, 2\n" \
" mflr 2\n" \
" addi 2, 2, -32\n" \
" add 2, 2, 0\n" \
" bl .L._"#name"\n" \
" ld 2, 40(1)\n" \
" ld 0, 32(1)\n" \
" mtlr 0\n" \
" blr\n" \
" .size "#name",.-.L."#name"\n"); \
ret name args; \
ret _##name args
/* Extends the kernel stack of the syscall in 4096 bytes. Can only be called once in a syscall */
LV2_EXPORT int extend_kstack(int unk);
static INLINE uint64_t get_syscall_address(int n)
{
uint64_t **table = (uint64_t **)MKA(syscall_table_symbol);
uint64_t *syscall = table[n];
return syscall[0];
}
static INLINE void create_syscall(int n, void *func)
{
uint64_t ***table = (uint64_t ***)MKA(syscall_table_symbol);
uint64_t **syscall = table[n];
f_desc_t *f = (f_desc_t *)func;
syscall[0] = f->addr;
}
static INLINE void create_syscall2(int n, void *func)
{
uint64_t **table = (uint64_t **)MKA(syscall_table_symbol);
f_desc_t *f = (f_desc_t *)func;
uint64_t *opd = f->addr;
opd[0] = ((uint64_t)opd) + 16;
opd[1] = MKA(TOC);
table[n] = opd;
}
#define patch_syscall create_syscall
static INLINE void set_syscall_handler(void *syscall_handler)
{
patch_call(syscall_call_offset, syscall_handler);
}
#endif /* __LV2_SYSCALL_H__ */
|
54fda2589f0f12374017cbd33cc85f323634a884
|
d2319e63a4082e81a351d96f36e4089cb7dc6bc7
|
/csrc/cuda/weighting_cuda.h
|
fc35809c355d9419321660fbe01785f30303b38e
|
[
"MIT"
] |
permissive
|
rusty1s/pytorch_spline_conv
|
b60141257f46e73950b05c60633f807369e6aff7
|
70247f1f770469f3b14486a5477e486370e9f844
|
refs/heads/master
| 2023-04-02T06:50:42.808775
| 2023-03-16T11:55:17
| 2023-03-16T11:55:17
| 115,535,501
| 165
| 40
|
MIT
| 2023-03-16T11:55:19
| 2017-12-27T15:47:09
|
C++
|
UTF-8
|
C
| false
| false
| 1,127
|
h
|
weighting_cuda.h
|
#pragma once
#include <torch/extension.h>
torch::Tensor spline_weighting_fw_cuda(torch::Tensor x, torch::Tensor weight,
torch::Tensor basis,
torch::Tensor weight_index);
torch::Tensor spline_weighting_bw_x_cuda(torch::Tensor grad_out,
torch::Tensor weight,
torch::Tensor basis,
torch::Tensor weight_index);
torch::Tensor spline_weighting_bw_weight_cuda(torch::Tensor grad_out,
torch::Tensor x,
torch::Tensor basis,
torch::Tensor weight_index,
int64_t kernel_size);
torch::Tensor spline_weighting_bw_basis_cuda(torch::Tensor grad_out,
torch::Tensor x,
torch::Tensor weight,
torch::Tensor weight_index);
|
c306331900c821e13eef322a7c3fe75d09961a6a
|
ea8fc70c7dbf49059431fa45a940742736c68fb8
|
/ext/cli/color.c
|
b4ec7ceb8b7b802b9e3a79c50025c62ad7b1fd9f
|
[
"BSD-3-Clause"
] |
permissive
|
dreamsxin/cphalcon7
|
1bd2194a251657b48857326927db69fef617ab91
|
1b8c6b04b4ca237a5ead87d4752df0d2e85c7a9d
|
refs/heads/master
| 2023-03-08T04:53:08.829432
| 2022-07-07T07:48:59
| 2022-07-07T07:48:59
| 47,245,335
| 298
| 73
| null | 2021-06-22T11:53:25
| 2015-12-02T07:44:43
|
C
|
UTF-8
|
C
| false
| false
| 13,722
|
c
|
color.c
|
/*
+------------------------------------------------------------------------+
| Phalcon Framework |
+------------------------------------------------------------------------+
| Copyright (c) 2011-2014 Phalcon Team (http://www.phalconphp.com) |
+------------------------------------------------------------------------+
| This source file is subject to the New BSD License that is bundled |
| with this package in the file docs/LICENSE.txt. |
| |
| If you did not receive a copy of the license and are unable to |
| obtain it through the world-wide-web, please send an email |
| to license@phalconphp.com so we can send you a copy immediately. |
+------------------------------------------------------------------------+
| Authors: Andres Gutierrez <andres@phalconphp.com> |
| Eduar Carvajal <eduar@phalconphp.com> |
| ZhuZongXin <dreamsxin@qq.com> |
+------------------------------------------------------------------------+
*/
#include "cli/color.h"
#include <main/SAPI.h>
#include "kernel/main.h"
#include "kernel/exception.h"
#include "kernel/fcall.h"
#include "kernel/object.h"
#include "kernel/array.h"
#include "kernel/concat.h"
#include "kernel/operators.h"
#include "kernel/string.h"
#include "kernel/debug.h"
/**
* Phalcon\Cli\Color
*
*<code>
*
* echo Phalcon\Cli\Color::head("head");
* echo Phalcon\Cli\Color::error("error");
* echo Phalcon\Cli\Color::success("success");
* echo Phalcon\Cli\Color::info("info");
*</code>
*/
zend_class_entry *phalcon_cli_color_ce;
PHP_METHOD(Phalcon_Cli_Color, isSupportedShell);
PHP_METHOD(Phalcon_Cli_Color, colorize);
PHP_METHOD(Phalcon_Cli_Color, head);
PHP_METHOD(Phalcon_Cli_Color, error);
PHP_METHOD(Phalcon_Cli_Color, success);
PHP_METHOD(Phalcon_Cli_Color, info);
ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_cli_color_colorize, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
ZEND_ARG_TYPE_INFO(0, fg, IS_LONG, 1)
ZEND_ARG_TYPE_INFO(0, at, IS_LONG, 1)
ZEND_ARG_TYPE_INFO(0, bg, IS_LONG, 1)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_cli_color_head, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_cli_color_error, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_cli_color_success, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_cli_color_info, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
ZEND_END_ARG_INFO()
static const zend_function_entry phalcon_cli_color_method_entry[] = {
PHP_ME(Phalcon_Cli_Color, isSupportedShell, arginfo_empty, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Phalcon_Cli_Color, colorize, arginfo_phalcon_cli_color_colorize, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Phalcon_Cli_Color, head, arginfo_phalcon_cli_color_head, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Phalcon_Cli_Color, error, arginfo_phalcon_cli_color_error, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Phalcon_Cli_Color, success, arginfo_phalcon_cli_color_success, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Phalcon_Cli_Color, info, arginfo_phalcon_cli_color_info, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_FE_END
};
/**
* Phalcon\Cli\Color initializer
*/
PHALCON_INIT_CLASS(Phalcon_Cli_Color){
PHALCON_REGISTER_CLASS(Phalcon\\Cli, Color, cli_color, phalcon_cli_color_method_entry, 0);
zend_declare_property_null(phalcon_cli_color_ce, SL("_fg"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
zend_declare_property_null(phalcon_cli_color_ce, SL("_bg"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
zend_declare_property_null(phalcon_cli_color_ce, SL("_at"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
/* constraints */
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_BLACK"), PHALCON_CLI_COLOR_FG_BLACK);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_DARK_GRAY"), PHALCON_CLI_COLOR_FG_DARK_GRAY);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_RED"), PHALCON_CLI_COLOR_FG_RED);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_LIGHT_RED"), PHALCON_CLI_COLOR_FG_LIGHT_RED);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_GREEN"), PHALCON_CLI_COLOR_FG_GREEN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_LIGHT_GREEN"), PHALCON_CLI_COLOR_FG_LIGHT_GREEN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_BROWN"), PHALCON_CLI_COLOR_FG_BROWN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_YELLOW"), PHALCON_CLI_COLOR_FG_YELLOW);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_BLUE"), PHALCON_CLI_COLOR_FG_BLUE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_LIGHT_BLUE"), PHALCON_CLI_COLOR_FG_LIGHT_BLUE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_PURPLE"), PHALCON_CLI_COLOR_FG_PURPLE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_LIGHT_PURPLE"), PHALCON_CLI_COLOR_FG_LIGHT_PURPLE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_CYAN"), PHALCON_CLI_COLOR_FG_CYAN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_LIGHT_CYAN"), PHALCON_CLI_COLOR_FG_LIGHT_CYAN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_LIGHT_GRAY"), PHALCON_CLI_COLOR_FG_LIGHT_GRAY);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("FG_WHITE"), PHALCON_CLI_COLOR_FG_WHITE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_BLACK"), PHALCON_CLI_COLOR_BG_BLACK);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_RED"), PHALCON_CLI_COLOR_BG_RED);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_GREEN"), PHALCON_CLI_COLOR_BG_GREEN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_YELLOW"), PHALCON_CLI_COLOR_BG_YELLOW);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_BLUE"), PHALCON_CLI_COLOR_BG_BLUE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_MAGENTA"), PHALCON_CLI_COLOR_BG_MAGENTA);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_CYAN"), PHALCON_CLI_COLOR_BG_CYAN);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("BG_LIGHT_GRAY"), PHALCON_CLI_COLOR_BG_LIGHT_GRAY);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_NORMAL"), PHALCON_CLI_COLOR_AT_NORMAL);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_BOLD"), PHALCON_CLI_COLOR_AT_BOLD);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_ITALIC"), PHALCON_CLI_COLOR_AT_ITALIC);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_UNDERLINE"), PHALCON_CLI_COLOR_AT_UNDERLINE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_BLINK"), PHALCON_CLI_COLOR_AT_BLINK);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_OUTLINE"), PHALCON_CLI_COLOR_AT_OUTLINE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_REVERSE"), PHALCON_CLI_COLOR_AT_REVERSE);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_NONDISP"), PHALCON_CLI_COLOR_AT_NONDISP);
zend_declare_class_constant_long(phalcon_cli_color_ce, SL("AT_STRIKE"), PHALCON_CLI_COLOR_AT_STRIKE);
return SUCCESS;
}
/**
* Identify if console supports colors
*
* @return boolean
*/
PHP_METHOD(Phalcon_Cli_Color, isSupportedShell){
zval ret = {};
#ifdef PHP_WIN32
zval arg = {};
ZVAL_STRING(&arg, "ANSICON");
PHALCON_CALL_FUNCTION(&ret, "getenv", &arg);
zval_ptr_dtor(&arg);
if (!PHALCON_IS_FALSE(&ret)) {
RETURN_TRUE;
}
zval_ptr_dtor(&ret);
ZVAL_STRING(&arg, "ConEmuANSI");
PHALCON_CALL_FUNCTION(&ret, "getenv", &arg);
zval_ptr_dtor(&arg);
if (PHALCON_IS_STRING(&ret, "ON")) {
zval_ptr_dtor(&ret);
RETURN_TRUE;
}
zval_ptr_dtor(&ret);
ZVAL_STRING(&arg, "TERM");
PHALCON_CALL_FUNCTION(&ret, "getenv", &arg);
zval_ptr_dtor(&arg);
if (PHALCON_IS_STRING(&ret, "xterm")) {
zval_ptr_dtor(&ret);
RETURN_TRUE;
}
zval_ptr_dtor(&ret);
#endif
if (phalcon_has_constant(SL("STDOUT"))) {
if (phalcon_function_exists_ex(SL("posix_isatty")) == SUCCESS) {
zval arg = {};
ZVAL_STRING(&arg, "STDOUT");
PHALCON_CALL_FUNCTION(&ret, "posix_isatty", &arg);
if (zend_is_true(&ret)) {
zval_ptr_dtor(&arg);
RETURN_TRUE;
}
zval_ptr_dtor(&arg);
}
}
RETURN_FALSE;
}
static char* fg_map[] = {"0;30","1;30","0;31","1;31","0;32","1;32","0;33","1;33","0;34","1;34","0;35","1;35","0;36","1;36","0;37","1;37"};
static char* at_map[] = {"0","1","3","4","5","6","7","8","9"};
static char* bg_map[] = {"40","41","42","43","44","45","46","47"};
/**
* Colorizes the string using provided colors.
*
* @param string $str
* @param null|integer $fg
* @param null|integer $at
* @param null|integer $bg
* @return string
*/
PHP_METHOD(Phalcon_Cli_Color, colorize){
zval *str, *fg = NULL, *at = NULL, *bg = NULL;
zval ret = {}, colored = {};
int i;
phalcon_fetch_params(1, 1, 3, &str, &fg, &at, &bg);
PHALCON_MM_CALL_CE_STATIC(&ret, phalcon_cli_color_ce, "issupportedshell");
if (!zend_is_true(&ret)) {
RETURN_MM_CTOR(str);
}
if (fg && Z_TYPE_P(fg) == IS_LONG) {
i = Z_LVAL_P(fg);
if (i >= PHALCON_CLI_COLOR_FG_BLACK && i <= PHALCON_CLI_COLOR_FG_WHITE) {
phalcon_concat_sss(&colored, SL("\033["), fg_map[i], strlen(fg_map[i]), "m", 1, 0);
PHALCON_MM_ADD_ENTRY(&colored);
}
}
if (bg && Z_TYPE_P(bg) == IS_LONG) {
i = Z_LVAL_P(bg);
if (i >= PHALCON_CLI_COLOR_BG_BLACK && i <= PHALCON_CLI_COLOR_BG_LIGHT_GRAY) {
phalcon_concat_sss(&colored, SL("\033["), bg_map[i], strlen(bg_map[i]), "m", 1, 1);
PHALCON_MM_ADD_ENTRY(&colored);
}
}
if (at && Z_TYPE_P(at) == IS_LONG) {
i = Z_LVAL_P(at);
if (i >= PHALCON_CLI_COLOR_AT_NORMAL && i <= PHALCON_CLI_COLOR_AT_STRIKE) {
phalcon_concat_sss(&colored, SL("\033["), at_map[i], strlen(at_map[i]), "m", 1, 1);
PHALCON_MM_ADD_ENTRY(&colored);
}
}
PHALCON_CONCAT_VVS(return_value, &colored, str, "\033[0m");
RETURN_MM();
}
/**
* Color style for head messages.
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Cli_Color, head){
zval *str, fg = {}, tmp = {};
phalcon_fetch_params(0, 1, 0, &str);
ZVAL_LONG(&fg, PHALCON_CLI_COLOR_FG_BROWN);
PHALCON_CALL_CE_STATIC(&tmp, phalcon_cli_color_ce, "colorize", str, &fg);
PHALCON_CONCAT_VS(return_value, &tmp, PHP_EOL);
zval_ptr_dtor(&tmp);
}
/**
* Color style for error messages.
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Cli_Color, error){
zval *str, fg = {}, at= {}, bg= {}, msg = {}, tmp = {};
zval input = {}, out = {}, line1 = {}, line2 = {};
int space;
phalcon_fetch_params(0, 1, 0, &str);
ZVAL_LONG(&fg, PHALCON_CLI_COLOR_FG_WHITE);
ZVAL_LONG(&at, PHALCON_CLI_COLOR_AT_BOLD);
ZVAL_LONG(&bg, PHALCON_CLI_COLOR_BG_RED);
PHALCON_CONCAT_SV(&tmp, "Error: ", str);
space = Z_STRLEN(tmp) + 4;
PHALCON_CONCAT_SVS(&msg, " ", &tmp, " ");
zval_ptr_dtor(&tmp);
ZVAL_STRING(&input, " ");
phalcon_pad_str(&out, &input, space, " ", PHALCON_PDA_RIGHT);
zval_ptr_dtor(&input);
PHALCON_CALL_CE_STATIC(&line1, phalcon_cli_color_ce, "colorize", &out, &fg, &at, &bg);
PHALCON_CALL_CE_STATIC(&line2, phalcon_cli_color_ce, "colorize", &msg, &fg, &at, &bg);
zval_ptr_dtor(&out);
zval_ptr_dtor(&msg);
PHALCON_CONCAT_VSVSVS(return_value, &line1, PHP_EOL, &line2, PHP_EOL, &line1, PHP_EOL);
zval_ptr_dtor(&line1);
zval_ptr_dtor(&line2);
}
/**
* Color style for success messages.
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Cli_Color, success){
zval *str, fg = {}, at= {}, bg= {}, msg = {}, tmp = {};
zval input = {}, out = {}, line1 = {}, line2 = {};
int space;
phalcon_fetch_params(0, 1, 0, &str);
ZVAL_LONG(&fg, PHALCON_CLI_COLOR_FG_WHITE);
ZVAL_LONG(&at, PHALCON_CLI_COLOR_AT_BOLD);
ZVAL_LONG(&bg, PHALCON_CLI_COLOR_BG_GREEN);
PHALCON_CONCAT_SV(&tmp, "Success: ", str);
space = Z_STRLEN(tmp) + 4;
PHALCON_CONCAT_SVS(&msg, " ", &tmp, " ");
zval_ptr_dtor(&tmp);
ZVAL_STRING(&input, " ");
phalcon_pad_str(&out, &input, space, " ", PHALCON_PDA_RIGHT);
zval_ptr_dtor(&input);
PHALCON_CALL_CE_STATIC(&line1, phalcon_cli_color_ce, "colorize", &out, &fg, &at, &bg);
PHALCON_CALL_CE_STATIC(&line2, phalcon_cli_color_ce, "colorize", &msg, &fg, &at, &bg);
zval_ptr_dtor(&out);
zval_ptr_dtor(&msg);
PHALCON_CONCAT_VSVSVS(return_value, &line1, PHP_EOL, &line2, PHP_EOL, &line1, PHP_EOL);
zval_ptr_dtor(&line1);
zval_ptr_dtor(&line2);
}
/**
* Color style for info messages.
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Cli_Color, info){
zval *str, fg = {}, at= {}, bg= {}, msg = {}, tmp = {};
zval input = {}, out = {}, line1 = {}, line2 = {};
int space;
phalcon_fetch_params(0, 1, 0, &str);
ZVAL_LONG(&fg, PHALCON_CLI_COLOR_FG_WHITE);
ZVAL_LONG(&at, PHALCON_CLI_COLOR_AT_BOLD);
ZVAL_LONG(&bg, PHALCON_CLI_COLOR_BG_BLUE);
PHALCON_CONCAT_SV(&tmp, "Info: ", str);
space = Z_STRLEN(tmp) + 4;
PHALCON_CONCAT_SVS(&msg, " ", &tmp, " ");
zval_ptr_dtor(&tmp);
ZVAL_STRING(&input, " ");
phalcon_pad_str(&out, &input, space, " ", PHALCON_PDA_RIGHT);
zval_ptr_dtor(&input);
PHALCON_CALL_CE_STATIC(&line1, phalcon_cli_color_ce, "colorize", &out, &fg, &at, &bg);
PHALCON_CALL_CE_STATIC(&line2, phalcon_cli_color_ce, "colorize", &msg, &fg, &at, &bg);
zval_ptr_dtor(&out);
zval_ptr_dtor(&msg);
PHALCON_CONCAT_VSVSVS(return_value, &line1, PHP_EOL, &line2, PHP_EOL, &line1, PHP_EOL);
zval_ptr_dtor(&line1);
zval_ptr_dtor(&line2);
}
|
5c76f03239b937ebe0d068f7fb934b58f716141a
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/drivers/md/dm-thin-metadata.h
|
8f4d62baf09b51be2ca94579537a0cad2da5357f
|
[
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 6,102
|
h
|
dm-thin-metadata.h
|
/*
* Copyright (C) 2010-2011 Red Hat, Inc.
*
* This file is released under the GPL.
*/
#ifndef DM_THIN_METADATA_H
#define DM_THIN_METADATA_H
#include "persistent-data/dm-block-manager.h"
#include "persistent-data/dm-space-map.h"
#define THIN_METADATA_BLOCK_SIZE 4096
/*
* The metadata device is currently limited in size.
*
* We have one block of index, which can hold 255 index entries. Each
* index entry contains allocation info about 16k metadata blocks.
*/
#define THIN_METADATA_MAX_SECTORS (255 * (1 << 14) * (THIN_METADATA_BLOCK_SIZE / (1 << SECTOR_SHIFT)))
/*
* A metadata device larger than 16GB triggers a warning.
*/
#define THIN_METADATA_MAX_SECTORS_WARNING (16 * (1024 * 1024 * 1024 >> SECTOR_SHIFT))
/*----------------------------------------------------------------*/
struct dm_pool_metadata;
struct dm_thin_device;
/*
* Device identifier
*/
typedef uint64_t dm_thin_id;
/*
* Reopens or creates a new, empty metadata volume.
*/
struct dm_pool_metadata *dm_pool_metadata_open(struct block_device *bdev,
sector_t data_block_size,
bool format_device);
int dm_pool_metadata_close(struct dm_pool_metadata *pmd);
/*
* Compat feature flags. Any incompat flags beyond the ones
* specified below will prevent use of the thin metadata.
*/
#define THIN_FEATURE_COMPAT_SUPP 0UL
#define THIN_FEATURE_COMPAT_RO_SUPP 0UL
#define THIN_FEATURE_INCOMPAT_SUPP 0UL
/*
* Device creation/deletion.
*/
int dm_pool_create_thin(struct dm_pool_metadata *pmd, dm_thin_id dev);
/*
* An internal snapshot.
*
* You can only snapshot a quiesced origin i.e. one that is either
* suspended or not instanced at all.
*/
int dm_pool_create_snap(struct dm_pool_metadata *pmd, dm_thin_id dev,
dm_thin_id origin);
/*
* Deletes a virtual device from the metadata. It _is_ safe to call this
* when that device is open. Operations on that device will just start
* failing. You still need to call close() on the device.
*/
int dm_pool_delete_thin_device(struct dm_pool_metadata *pmd,
dm_thin_id dev);
/*
* Commits _all_ metadata changes: device creation, deletion, mapping
* updates.
*/
int dm_pool_commit_metadata(struct dm_pool_metadata *pmd);
/*
* Discards all uncommitted changes. Rereads the superblock, rolling back
* to the last good transaction. Thin devices remain open.
* dm_thin_aborted_changes() tells you if they had uncommitted changes.
*
* If this call fails it's only useful to call dm_pool_metadata_close().
* All other methods will fail with -EINVAL.
*/
int dm_pool_abort_metadata(struct dm_pool_metadata *pmd);
/*
* Set/get userspace transaction id.
*/
int dm_pool_set_metadata_transaction_id(struct dm_pool_metadata *pmd,
uint64_t current_id,
uint64_t new_id);
int dm_pool_get_metadata_transaction_id(struct dm_pool_metadata *pmd,
uint64_t *result);
/*
* Hold/get root for userspace transaction.
*
* The metadata snapshot is a copy of the current superblock (minus the
* space maps). Userland can access the data structures for READ
* operations only. A small performance hit is incurred by providing this
* copy of the metadata to userland due to extra copy-on-write operations
* on the metadata nodes. Release this as soon as you finish with it.
*/
int dm_pool_reserve_metadata_snap(struct dm_pool_metadata *pmd);
int dm_pool_release_metadata_snap(struct dm_pool_metadata *pmd);
int dm_pool_get_metadata_snap(struct dm_pool_metadata *pmd,
dm_block_t *result);
/*
* Actions on a single virtual device.
*/
/*
* Opening the same device more than once will fail with -EBUSY.
*/
int dm_pool_open_thin_device(struct dm_pool_metadata *pmd, dm_thin_id dev,
struct dm_thin_device **td);
int dm_pool_close_thin_device(struct dm_thin_device *td);
dm_thin_id dm_thin_dev_id(struct dm_thin_device *td);
struct dm_thin_lookup_result {
dm_block_t block;
unsigned shared:1;
};
/*
* Returns:
* -EWOULDBLOCK iff @can_block is set and would block.
* -ENODATA iff that mapping is not present.
* 0 success
*/
int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block,
int can_block, struct dm_thin_lookup_result *result);
/*
* Obtain an unused block.
*/
int dm_pool_alloc_data_block(struct dm_pool_metadata *pmd, dm_block_t *result);
/*
* Insert or remove block.
*/
int dm_thin_insert_block(struct dm_thin_device *td, dm_block_t block,
dm_block_t data_block);
int dm_thin_remove_block(struct dm_thin_device *td, dm_block_t block);
/*
* Queries.
*/
bool dm_thin_changed_this_transaction(struct dm_thin_device *td);
bool dm_pool_changed_this_transaction(struct dm_pool_metadata *pmd);
bool dm_thin_aborted_changes(struct dm_thin_device *td);
int dm_thin_get_highest_mapped_block(struct dm_thin_device *td,
dm_block_t *highest_mapped);
int dm_thin_get_mapped_count(struct dm_thin_device *td, dm_block_t *result);
int dm_pool_get_free_block_count(struct dm_pool_metadata *pmd,
dm_block_t *result);
int dm_pool_get_free_metadata_block_count(struct dm_pool_metadata *pmd,
dm_block_t *result);
int dm_pool_get_metadata_dev_size(struct dm_pool_metadata *pmd,
dm_block_t *result);
int dm_pool_get_data_block_size(struct dm_pool_metadata *pmd, sector_t *result);
int dm_pool_get_data_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result);
int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *result);
/*
* Returns -ENOSPC if the new size is too small and already allocated
* blocks would be lost.
*/
int dm_pool_resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_size);
int dm_pool_resize_metadata_dev(struct dm_pool_metadata *pmd, dm_block_t new_size);
/*
* Flicks the underlying block manager into read only mode, so you know
* that nothing is changing.
*/
void dm_pool_metadata_read_only(struct dm_pool_metadata *pmd);
int dm_pool_register_metadata_threshold(struct dm_pool_metadata *pmd,
dm_block_t threshold,
dm_sm_threshold_fn fn,
void *context);
/*----------------------------------------------------------------*/
#endif
|
72dd3f0f4e0c4f6bb076dacb312300f0466e17e1
|
13e746c9f5a4bb762e3dbcf06ffa7127e14575c6
|
/Zend/zend_vm_handlers.h
|
0fd402eeab8339a75c16d614a7f97a97c186ab52
|
[
"PHP-3.01",
"LicenseRef-scancode-other-permissive",
"TCL",
"BSD-3-Clause",
"BSD-4-Clause-UC",
"Zlib",
"ISC",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"Zend-2.0"
] |
permissive
|
zendtech/php-src
|
e7c3d05f81d3f42bfcc3624285d2a1cff0ffc6a0
|
f82e5b3abe1ff1d3ffc7954b0810bc584fd650a5
|
refs/heads/jit-dynasm
| 2021-01-17T13:51:27.985676
| 2019-03-28T14:41:43
| 2019-03-28T14:41:43
| 31,417,057
| 450
| 65
|
NOASSERTION
| 2019-02-28T16:55:58
| 2015-02-27T11:48:08
|
C
|
UTF-8
|
C
| false
| false
| 115,250
|
h
|
zend_vm_handlers.h
|
#define VM_HANDLERS(_) \
_(0, ZEND_NOP_SPEC) \
_(1, ZEND_ADD_SPEC_CONST_CONST) \
_(2, ZEND_ADD_SPEC_CONST_TMPVAR) \
_(3, ZEND_ADD_SPEC_CONST_TMPVAR) \
_(5, ZEND_ADD_SPEC_CONST_CV) \
_(6, ZEND_ADD_SPEC_TMPVAR_CONST) \
_(7, ZEND_ADD_SPEC_TMPVAR_TMPVAR) \
_(8, ZEND_ADD_SPEC_TMPVAR_TMPVAR) \
_(10, ZEND_ADD_SPEC_TMPVAR_CV) \
_(11, ZEND_ADD_SPEC_TMPVAR_CONST) \
_(12, ZEND_ADD_SPEC_TMPVAR_TMPVAR) \
_(13, ZEND_ADD_SPEC_TMPVAR_TMPVAR) \
_(15, ZEND_ADD_SPEC_TMPVAR_CV) \
_(21, ZEND_ADD_SPEC_CV_CONST) \
_(22, ZEND_ADD_SPEC_CV_TMPVAR) \
_(23, ZEND_ADD_SPEC_CV_TMPVAR) \
_(25, ZEND_ADD_SPEC_CV_CV) \
_(26, ZEND_SUB_SPEC_CONST_CONST) \
_(27, ZEND_SUB_SPEC_CONST_TMPVAR) \
_(28, ZEND_SUB_SPEC_CONST_TMPVAR) \
_(30, ZEND_SUB_SPEC_CONST_CV) \
_(31, ZEND_SUB_SPEC_TMPVAR_CONST) \
_(32, ZEND_SUB_SPEC_TMPVAR_TMPVAR) \
_(33, ZEND_SUB_SPEC_TMPVAR_TMPVAR) \
_(35, ZEND_SUB_SPEC_TMPVAR_CV) \
_(36, ZEND_SUB_SPEC_TMPVAR_CONST) \
_(37, ZEND_SUB_SPEC_TMPVAR_TMPVAR) \
_(38, ZEND_SUB_SPEC_TMPVAR_TMPVAR) \
_(40, ZEND_SUB_SPEC_TMPVAR_CV) \
_(46, ZEND_SUB_SPEC_CV_CONST) \
_(47, ZEND_SUB_SPEC_CV_TMPVAR) \
_(48, ZEND_SUB_SPEC_CV_TMPVAR) \
_(50, ZEND_SUB_SPEC_CV_CV) \
_(51, ZEND_MUL_SPEC_CONST_CONST) \
_(56, ZEND_MUL_SPEC_TMPVAR_CONST) \
_(57, ZEND_MUL_SPEC_TMPVAR_TMPVAR) \
_(58, ZEND_MUL_SPEC_TMPVAR_TMPVAR) \
_(61, ZEND_MUL_SPEC_TMPVAR_CONST) \
_(62, ZEND_MUL_SPEC_TMPVAR_TMPVAR) \
_(63, ZEND_MUL_SPEC_TMPVAR_TMPVAR) \
_(71, ZEND_MUL_SPEC_CV_CONST) \
_(72, ZEND_MUL_SPEC_CV_TMPVAR) \
_(73, ZEND_MUL_SPEC_CV_TMPVAR) \
_(75, ZEND_MUL_SPEC_CV_CV) \
_(76, ZEND_DIV_SPEC_CONST_CONST) \
_(77, ZEND_DIV_SPEC_CONST_TMPVAR) \
_(78, ZEND_DIV_SPEC_CONST_TMPVAR) \
_(80, ZEND_DIV_SPEC_CONST_CV) \
_(81, ZEND_DIV_SPEC_TMPVAR_CONST) \
_(82, ZEND_DIV_SPEC_TMPVAR_TMPVAR) \
_(83, ZEND_DIV_SPEC_TMPVAR_TMPVAR) \
_(85, ZEND_DIV_SPEC_TMPVAR_CV) \
_(86, ZEND_DIV_SPEC_TMPVAR_CONST) \
_(87, ZEND_DIV_SPEC_TMPVAR_TMPVAR) \
_(88, ZEND_DIV_SPEC_TMPVAR_TMPVAR) \
_(90, ZEND_DIV_SPEC_TMPVAR_CV) \
_(96, ZEND_DIV_SPEC_CV_CONST) \
_(97, ZEND_DIV_SPEC_CV_TMPVAR) \
_(98, ZEND_DIV_SPEC_CV_TMPVAR) \
_(100, ZEND_DIV_SPEC_CV_CV) \
_(101, ZEND_MOD_SPEC_CONST_CONST) \
_(102, ZEND_MOD_SPEC_CONST_TMPVAR) \
_(103, ZEND_MOD_SPEC_CONST_TMPVAR) \
_(105, ZEND_MOD_SPEC_CONST_CV) \
_(106, ZEND_MOD_SPEC_TMPVAR_CONST) \
_(107, ZEND_MOD_SPEC_TMPVAR_TMPVAR) \
_(108, ZEND_MOD_SPEC_TMPVAR_TMPVAR) \
_(110, ZEND_MOD_SPEC_TMPVAR_CV) \
_(111, ZEND_MOD_SPEC_TMPVAR_CONST) \
_(112, ZEND_MOD_SPEC_TMPVAR_TMPVAR) \
_(113, ZEND_MOD_SPEC_TMPVAR_TMPVAR) \
_(115, ZEND_MOD_SPEC_TMPVAR_CV) \
_(121, ZEND_MOD_SPEC_CV_CONST) \
_(122, ZEND_MOD_SPEC_CV_TMPVAR) \
_(123, ZEND_MOD_SPEC_CV_TMPVAR) \
_(125, ZEND_MOD_SPEC_CV_CV) \
_(126, ZEND_SL_SPEC_CONST_CONST) \
_(127, ZEND_SL_SPEC_CONST_TMPVAR) \
_(128, ZEND_SL_SPEC_CONST_TMPVAR) \
_(130, ZEND_SL_SPEC_CONST_CV) \
_(131, ZEND_SL_SPEC_TMPVAR_CONST) \
_(132, ZEND_SL_SPEC_TMPVAR_TMPVAR) \
_(133, ZEND_SL_SPEC_TMPVAR_TMPVAR) \
_(135, ZEND_SL_SPEC_TMPVAR_CV) \
_(136, ZEND_SL_SPEC_TMPVAR_CONST) \
_(137, ZEND_SL_SPEC_TMPVAR_TMPVAR) \
_(138, ZEND_SL_SPEC_TMPVAR_TMPVAR) \
_(140, ZEND_SL_SPEC_TMPVAR_CV) \
_(146, ZEND_SL_SPEC_CV_CONST) \
_(147, ZEND_SL_SPEC_CV_TMPVAR) \
_(148, ZEND_SL_SPEC_CV_TMPVAR) \
_(150, ZEND_SL_SPEC_CV_CV) \
_(151, ZEND_SR_SPEC_CONST_CONST) \
_(152, ZEND_SR_SPEC_CONST_TMPVAR) \
_(153, ZEND_SR_SPEC_CONST_TMPVAR) \
_(155, ZEND_SR_SPEC_CONST_CV) \
_(156, ZEND_SR_SPEC_TMPVAR_CONST) \
_(157, ZEND_SR_SPEC_TMPVAR_TMPVAR) \
_(158, ZEND_SR_SPEC_TMPVAR_TMPVAR) \
_(160, ZEND_SR_SPEC_TMPVAR_CV) \
_(161, ZEND_SR_SPEC_TMPVAR_CONST) \
_(162, ZEND_SR_SPEC_TMPVAR_TMPVAR) \
_(163, ZEND_SR_SPEC_TMPVAR_TMPVAR) \
_(165, ZEND_SR_SPEC_TMPVAR_CV) \
_(171, ZEND_SR_SPEC_CV_CONST) \
_(172, ZEND_SR_SPEC_CV_TMPVAR) \
_(173, ZEND_SR_SPEC_CV_TMPVAR) \
_(175, ZEND_SR_SPEC_CV_CV) \
_(177, ZEND_CONCAT_SPEC_CONST_TMPVAR) \
_(178, ZEND_CONCAT_SPEC_CONST_TMPVAR) \
_(180, ZEND_CONCAT_SPEC_CONST_CV) \
_(181, ZEND_CONCAT_SPEC_TMPVAR_CONST) \
_(182, ZEND_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(183, ZEND_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(185, ZEND_CONCAT_SPEC_TMPVAR_CV) \
_(186, ZEND_CONCAT_SPEC_TMPVAR_CONST) \
_(187, ZEND_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(188, ZEND_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(190, ZEND_CONCAT_SPEC_TMPVAR_CV) \
_(196, ZEND_CONCAT_SPEC_CV_CONST) \
_(197, ZEND_CONCAT_SPEC_CV_TMPVAR) \
_(198, ZEND_CONCAT_SPEC_CV_TMPVAR) \
_(200, ZEND_CONCAT_SPEC_CV_CV) \
_(201, ZEND_BW_OR_SPEC_CONST_CONST) \
_(206, ZEND_BW_OR_SPEC_TMPVAR_CONST) \
_(207, ZEND_BW_OR_SPEC_TMPVAR_TMPVAR) \
_(208, ZEND_BW_OR_SPEC_TMPVAR_TMPVAR) \
_(211, ZEND_BW_OR_SPEC_TMPVAR_CONST) \
_(212, ZEND_BW_OR_SPEC_TMPVAR_TMPVAR) \
_(213, ZEND_BW_OR_SPEC_TMPVAR_TMPVAR) \
_(221, ZEND_BW_OR_SPEC_CV_CONST) \
_(222, ZEND_BW_OR_SPEC_CV_TMPVAR) \
_(223, ZEND_BW_OR_SPEC_CV_TMPVAR) \
_(225, ZEND_BW_OR_SPEC_CV_CV) \
_(226, ZEND_BW_AND_SPEC_CONST_CONST) \
_(231, ZEND_BW_AND_SPEC_TMPVAR_CONST) \
_(232, ZEND_BW_AND_SPEC_TMPVAR_TMPVAR) \
_(233, ZEND_BW_AND_SPEC_TMPVAR_TMPVAR) \
_(236, ZEND_BW_AND_SPEC_TMPVAR_CONST) \
_(237, ZEND_BW_AND_SPEC_TMPVAR_TMPVAR) \
_(238, ZEND_BW_AND_SPEC_TMPVAR_TMPVAR) \
_(246, ZEND_BW_AND_SPEC_CV_CONST) \
_(247, ZEND_BW_AND_SPEC_CV_TMPVAR) \
_(248, ZEND_BW_AND_SPEC_CV_TMPVAR) \
_(250, ZEND_BW_AND_SPEC_CV_CV) \
_(251, ZEND_BW_XOR_SPEC_CONST_CONST) \
_(256, ZEND_BW_XOR_SPEC_TMPVAR_CONST) \
_(257, ZEND_BW_XOR_SPEC_TMPVAR_TMPVAR) \
_(258, ZEND_BW_XOR_SPEC_TMPVAR_TMPVAR) \
_(261, ZEND_BW_XOR_SPEC_TMPVAR_CONST) \
_(262, ZEND_BW_XOR_SPEC_TMPVAR_TMPVAR) \
_(263, ZEND_BW_XOR_SPEC_TMPVAR_TMPVAR) \
_(271, ZEND_BW_XOR_SPEC_CV_CONST) \
_(272, ZEND_BW_XOR_SPEC_CV_TMPVAR) \
_(273, ZEND_BW_XOR_SPEC_CV_TMPVAR) \
_(275, ZEND_BW_XOR_SPEC_CV_CV) \
_(276, ZEND_BW_NOT_SPEC_CONST) \
_(277, ZEND_BW_NOT_SPEC_TMPVAR) \
_(278, ZEND_BW_NOT_SPEC_TMPVAR) \
_(280, ZEND_BW_NOT_SPEC_CV) \
_(281, ZEND_BOOL_NOT_SPEC_CONST) \
_(282, ZEND_BOOL_NOT_SPEC_TMPVAR) \
_(283, ZEND_BOOL_NOT_SPEC_TMPVAR) \
_(285, ZEND_BOOL_NOT_SPEC_CV) \
_(286, ZEND_BOOL_XOR_SPEC_CONST_CONST) \
_(291, ZEND_BOOL_XOR_SPEC_TMPVAR_CONST) \
_(292, ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) \
_(293, ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) \
_(296, ZEND_BOOL_XOR_SPEC_TMPVAR_CONST) \
_(297, ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) \
_(298, ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) \
_(306, ZEND_BOOL_XOR_SPEC_CV_CONST) \
_(307, ZEND_BOOL_XOR_SPEC_CV_TMPVAR) \
_(308, ZEND_BOOL_XOR_SPEC_CV_TMPVAR) \
_(310, ZEND_BOOL_XOR_SPEC_CV_CV) \
_(311, ZEND_IS_IDENTICAL_SPEC_CONST_CONST) \
_(316, ZEND_IS_IDENTICAL_SPEC_TMP_CONST) \
_(317, ZEND_IS_IDENTICAL_SPEC_TMP_TMP) \
_(321, ZEND_IS_IDENTICAL_SPEC_VAR_CONST) \
_(322, ZEND_IS_IDENTICAL_SPEC_VAR_TMP) \
_(323, ZEND_IS_IDENTICAL_SPEC_VAR_VAR) \
_(331, ZEND_IS_IDENTICAL_SPEC_CV_CONST) \
_(332, ZEND_IS_IDENTICAL_SPEC_CV_TMP) \
_(333, ZEND_IS_IDENTICAL_SPEC_CV_VAR) \
_(335, ZEND_IS_IDENTICAL_SPEC_CV_CV) \
_(336, ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST) \
_(341, ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST) \
_(342, ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP) \
_(346, ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST) \
_(347, ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP) \
_(348, ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR) \
_(356, ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST) \
_(357, ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP) \
_(358, ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR) \
_(360, ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV) \
_(361, ZEND_IS_EQUAL_SPEC_CONST_CONST) \
_(366, ZEND_IS_EQUAL_SPEC_TMPVAR_CONST) \
_(367, ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(368, ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(371, ZEND_IS_EQUAL_SPEC_TMPVAR_CONST) \
_(372, ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(373, ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(381, ZEND_IS_EQUAL_SPEC_CV_CONST) \
_(382, ZEND_IS_EQUAL_SPEC_CV_TMPVAR) \
_(383, ZEND_IS_EQUAL_SPEC_CV_TMPVAR) \
_(385, ZEND_IS_EQUAL_SPEC_CV_CV) \
_(386, ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST) \
_(391, ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST) \
_(392, ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(393, ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(396, ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST) \
_(397, ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(398, ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(406, ZEND_IS_NOT_EQUAL_SPEC_CV_CONST) \
_(407, ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR) \
_(408, ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR) \
_(410, ZEND_IS_NOT_EQUAL_SPEC_CV_CV) \
_(411, ZEND_IS_SMALLER_SPEC_CONST_CONST) \
_(412, ZEND_IS_SMALLER_SPEC_CONST_TMPVAR) \
_(413, ZEND_IS_SMALLER_SPEC_CONST_TMPVAR) \
_(415, ZEND_IS_SMALLER_SPEC_CONST_CV) \
_(416, ZEND_IS_SMALLER_SPEC_TMPVAR_CONST) \
_(417, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
_(418, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
_(420, ZEND_IS_SMALLER_SPEC_TMPVAR_CV) \
_(421, ZEND_IS_SMALLER_SPEC_TMPVAR_CONST) \
_(422, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
_(423, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
_(425, ZEND_IS_SMALLER_SPEC_TMPVAR_CV) \
_(431, ZEND_IS_SMALLER_SPEC_CV_CONST) \
_(432, ZEND_IS_SMALLER_SPEC_CV_TMPVAR) \
_(433, ZEND_IS_SMALLER_SPEC_CV_TMPVAR) \
_(435, ZEND_IS_SMALLER_SPEC_CV_CV) \
_(436, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST) \
_(437, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR) \
_(438, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR) \
_(440, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV) \
_(441, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST) \
_(442, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(443, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(445, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV) \
_(446, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST) \
_(447, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(448, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
_(450, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV) \
_(456, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST) \
_(457, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR) \
_(458, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR) \
_(460, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV) \
_(461, ZEND_CAST_SPEC_CONST) \
_(462, ZEND_CAST_SPEC_TMP) \
_(463, ZEND_CAST_SPEC_VAR) \
_(465, ZEND_CAST_SPEC_CV) \
_(466, ZEND_QM_ASSIGN_SPEC_CONST) \
_(467, ZEND_QM_ASSIGN_SPEC_TMP) \
_(468, ZEND_QM_ASSIGN_SPEC_VAR) \
_(470, ZEND_QM_ASSIGN_SPEC_CV) \
_(474, ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP) \
_(478, ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(482, ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(486, ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP) \
_(494, ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP) \
_(498, ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(502, ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(506, ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP) \
_(511, ZEND_ASSIGN_ADD_SPEC_VAR_CONST) \
_(512, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_DIM) \
_(513, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ) \
_(514, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP) \
_(515, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR) \
_(516, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM) \
_(517, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ) \
_(518, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(519, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR) \
_(520, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM) \
_(521, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ) \
_(522, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(524, ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM) \
_(526, ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP) \
_(527, ZEND_ASSIGN_ADD_SPEC_VAR_CV) \
_(528, ZEND_ASSIGN_ADD_SPEC_VAR_CV_DIM) \
_(529, ZEND_ASSIGN_ADD_SPEC_VAR_CV_OBJ) \
_(533, ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ) \
_(537, ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ) \
_(541, ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ) \
_(549, ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_OBJ) \
_(551, ZEND_ASSIGN_ADD_SPEC_CV_CONST) \
_(552, ZEND_ASSIGN_ADD_SPEC_CV_CONST_DIM) \
_(553, ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ) \
_(554, ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP) \
_(555, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR) \
_(556, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM) \
_(557, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ) \
_(558, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP) \
_(559, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR) \
_(560, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM) \
_(561, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ) \
_(562, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP) \
_(564, ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM) \
_(566, ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP) \
_(567, ZEND_ASSIGN_ADD_SPEC_CV_CV) \
_(568, ZEND_ASSIGN_ADD_SPEC_CV_CV_DIM) \
_(569, ZEND_ASSIGN_ADD_SPEC_CV_CV_OBJ) \
_(574, ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP) \
_(578, ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(582, ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(586, ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP) \
_(594, ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP) \
_(598, ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(602, ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(606, ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP) \
_(611, ZEND_ASSIGN_SUB_SPEC_VAR_CONST) \
_(612, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_DIM) \
_(613, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ) \
_(614, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP) \
_(615, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR) \
_(616, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM) \
_(617, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ) \
_(618, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(619, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR) \
_(620, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM) \
_(621, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ) \
_(622, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(624, ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM) \
_(626, ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP) \
_(627, ZEND_ASSIGN_SUB_SPEC_VAR_CV) \
_(628, ZEND_ASSIGN_SUB_SPEC_VAR_CV_DIM) \
_(629, ZEND_ASSIGN_SUB_SPEC_VAR_CV_OBJ) \
_(633, ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_OBJ) \
_(637, ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ) \
_(641, ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ) \
_(649, ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_OBJ) \
_(651, ZEND_ASSIGN_SUB_SPEC_CV_CONST) \
_(652, ZEND_ASSIGN_SUB_SPEC_CV_CONST_DIM) \
_(653, ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ) \
_(654, ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP) \
_(655, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR) \
_(656, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM) \
_(657, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ) \
_(658, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP) \
_(659, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR) \
_(660, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM) \
_(661, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ) \
_(662, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP) \
_(664, ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM) \
_(666, ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP) \
_(667, ZEND_ASSIGN_SUB_SPEC_CV_CV) \
_(668, ZEND_ASSIGN_SUB_SPEC_CV_CV_DIM) \
_(669, ZEND_ASSIGN_SUB_SPEC_CV_CV_OBJ) \
_(674, ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP) \
_(678, ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(682, ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(686, ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP) \
_(694, ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP) \
_(698, ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(702, ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(706, ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP) \
_(711, ZEND_ASSIGN_MUL_SPEC_VAR_CONST) \
_(712, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_DIM) \
_(713, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ) \
_(714, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP) \
_(715, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR) \
_(716, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM) \
_(717, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ) \
_(718, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(719, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR) \
_(720, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM) \
_(721, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ) \
_(722, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(724, ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM) \
_(726, ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP) \
_(727, ZEND_ASSIGN_MUL_SPEC_VAR_CV) \
_(728, ZEND_ASSIGN_MUL_SPEC_VAR_CV_DIM) \
_(729, ZEND_ASSIGN_MUL_SPEC_VAR_CV_OBJ) \
_(733, ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_OBJ) \
_(737, ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ) \
_(741, ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ) \
_(749, ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_OBJ) \
_(751, ZEND_ASSIGN_MUL_SPEC_CV_CONST) \
_(752, ZEND_ASSIGN_MUL_SPEC_CV_CONST_DIM) \
_(753, ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ) \
_(754, ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP) \
_(755, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR) \
_(756, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM) \
_(757, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ) \
_(758, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP) \
_(759, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR) \
_(760, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM) \
_(761, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ) \
_(762, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP) \
_(764, ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM) \
_(766, ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP) \
_(767, ZEND_ASSIGN_MUL_SPEC_CV_CV) \
_(768, ZEND_ASSIGN_MUL_SPEC_CV_CV_DIM) \
_(769, ZEND_ASSIGN_MUL_SPEC_CV_CV_OBJ) \
_(774, ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP) \
_(778, ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(782, ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(786, ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP) \
_(794, ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP) \
_(798, ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(802, ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(806, ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP) \
_(811, ZEND_ASSIGN_DIV_SPEC_VAR_CONST) \
_(812, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_DIM) \
_(813, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ) \
_(814, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP) \
_(815, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR) \
_(816, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM) \
_(817, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ) \
_(818, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(819, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR) \
_(820, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM) \
_(821, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ) \
_(822, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(824, ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM) \
_(826, ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP) \
_(827, ZEND_ASSIGN_DIV_SPEC_VAR_CV) \
_(828, ZEND_ASSIGN_DIV_SPEC_VAR_CV_DIM) \
_(829, ZEND_ASSIGN_DIV_SPEC_VAR_CV_OBJ) \
_(833, ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_OBJ) \
_(837, ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ) \
_(841, ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ) \
_(849, ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_OBJ) \
_(851, ZEND_ASSIGN_DIV_SPEC_CV_CONST) \
_(852, ZEND_ASSIGN_DIV_SPEC_CV_CONST_DIM) \
_(853, ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ) \
_(854, ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP) \
_(855, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR) \
_(856, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM) \
_(857, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ) \
_(858, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP) \
_(859, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR) \
_(860, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM) \
_(861, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ) \
_(862, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP) \
_(864, ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM) \
_(866, ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP) \
_(867, ZEND_ASSIGN_DIV_SPEC_CV_CV) \
_(868, ZEND_ASSIGN_DIV_SPEC_CV_CV_DIM) \
_(869, ZEND_ASSIGN_DIV_SPEC_CV_CV_OBJ) \
_(874, ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP) \
_(878, ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(882, ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(886, ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP) \
_(894, ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP) \
_(898, ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(902, ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(906, ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP) \
_(911, ZEND_ASSIGN_MOD_SPEC_VAR_CONST) \
_(912, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_DIM) \
_(913, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ) \
_(914, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP) \
_(915, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR) \
_(916, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM) \
_(917, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ) \
_(918, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(919, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR) \
_(920, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM) \
_(921, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ) \
_(922, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(924, ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM) \
_(926, ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP) \
_(927, ZEND_ASSIGN_MOD_SPEC_VAR_CV) \
_(928, ZEND_ASSIGN_MOD_SPEC_VAR_CV_DIM) \
_(929, ZEND_ASSIGN_MOD_SPEC_VAR_CV_OBJ) \
_(933, ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_OBJ) \
_(937, ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ) \
_(941, ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ) \
_(949, ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_OBJ) \
_(951, ZEND_ASSIGN_MOD_SPEC_CV_CONST) \
_(952, ZEND_ASSIGN_MOD_SPEC_CV_CONST_DIM) \
_(953, ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ) \
_(954, ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP) \
_(955, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR) \
_(956, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM) \
_(957, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ) \
_(958, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP) \
_(959, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR) \
_(960, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM) \
_(961, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ) \
_(962, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP) \
_(964, ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM) \
_(966, ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP) \
_(967, ZEND_ASSIGN_MOD_SPEC_CV_CV) \
_(968, ZEND_ASSIGN_MOD_SPEC_CV_CV_DIM) \
_(969, ZEND_ASSIGN_MOD_SPEC_CV_CV_OBJ) \
_(974, ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP) \
_(978, ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(982, ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(986, ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP) \
_(994, ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP) \
_(998, ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1002, ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1006, ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP) \
_(1011, ZEND_ASSIGN_SL_SPEC_VAR_CONST) \
_(1012, ZEND_ASSIGN_SL_SPEC_VAR_CONST_DIM) \
_(1013, ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ) \
_(1014, ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP) \
_(1015, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR) \
_(1016, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM) \
_(1017, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ) \
_(1018, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1019, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR) \
_(1020, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM) \
_(1021, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ) \
_(1022, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1024, ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM) \
_(1026, ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP) \
_(1027, ZEND_ASSIGN_SL_SPEC_VAR_CV) \
_(1028, ZEND_ASSIGN_SL_SPEC_VAR_CV_DIM) \
_(1029, ZEND_ASSIGN_SL_SPEC_VAR_CV_OBJ) \
_(1033, ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_OBJ) \
_(1037, ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ) \
_(1041, ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ) \
_(1049, ZEND_ASSIGN_SL_SPEC_UNUSED_CV_OBJ) \
_(1051, ZEND_ASSIGN_SL_SPEC_CV_CONST) \
_(1052, ZEND_ASSIGN_SL_SPEC_CV_CONST_DIM) \
_(1053, ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ) \
_(1054, ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP) \
_(1055, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR) \
_(1056, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM) \
_(1057, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ) \
_(1058, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1059, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR) \
_(1060, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM) \
_(1061, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ) \
_(1062, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1064, ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM) \
_(1066, ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP) \
_(1067, ZEND_ASSIGN_SL_SPEC_CV_CV) \
_(1068, ZEND_ASSIGN_SL_SPEC_CV_CV_DIM) \
_(1069, ZEND_ASSIGN_SL_SPEC_CV_CV_OBJ) \
_(1074, ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP) \
_(1078, ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1082, ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1086, ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP) \
_(1094, ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP) \
_(1098, ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1102, ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1106, ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP) \
_(1111, ZEND_ASSIGN_SR_SPEC_VAR_CONST) \
_(1112, ZEND_ASSIGN_SR_SPEC_VAR_CONST_DIM) \
_(1113, ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ) \
_(1114, ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP) \
_(1115, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR) \
_(1116, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM) \
_(1117, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ) \
_(1118, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1119, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR) \
_(1120, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM) \
_(1121, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ) \
_(1122, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1124, ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM) \
_(1126, ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP) \
_(1127, ZEND_ASSIGN_SR_SPEC_VAR_CV) \
_(1128, ZEND_ASSIGN_SR_SPEC_VAR_CV_DIM) \
_(1129, ZEND_ASSIGN_SR_SPEC_VAR_CV_OBJ) \
_(1133, ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_OBJ) \
_(1137, ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ) \
_(1141, ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ) \
_(1149, ZEND_ASSIGN_SR_SPEC_UNUSED_CV_OBJ) \
_(1151, ZEND_ASSIGN_SR_SPEC_CV_CONST) \
_(1152, ZEND_ASSIGN_SR_SPEC_CV_CONST_DIM) \
_(1153, ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ) \
_(1154, ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP) \
_(1155, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR) \
_(1156, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM) \
_(1157, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ) \
_(1158, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1159, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR) \
_(1160, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM) \
_(1161, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ) \
_(1162, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1164, ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM) \
_(1166, ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP) \
_(1167, ZEND_ASSIGN_SR_SPEC_CV_CV) \
_(1168, ZEND_ASSIGN_SR_SPEC_CV_CV_DIM) \
_(1169, ZEND_ASSIGN_SR_SPEC_CV_CV_OBJ) \
_(1174, ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP) \
_(1178, ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1182, ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1186, ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP) \
_(1194, ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP) \
_(1198, ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1202, ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1206, ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP) \
_(1211, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST) \
_(1212, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_DIM) \
_(1213, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ) \
_(1214, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP) \
_(1215, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR) \
_(1216, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM) \
_(1217, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ) \
_(1218, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1219, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR) \
_(1220, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM) \
_(1221, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ) \
_(1222, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1224, ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM) \
_(1226, ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP) \
_(1227, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV) \
_(1228, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_DIM) \
_(1229, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_OBJ) \
_(1233, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_OBJ) \
_(1237, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ) \
_(1241, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ) \
_(1249, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_OBJ) \
_(1251, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST) \
_(1252, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_DIM) \
_(1253, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ) \
_(1254, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP) \
_(1255, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR) \
_(1256, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM) \
_(1257, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ) \
_(1258, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1259, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR) \
_(1260, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM) \
_(1261, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ) \
_(1262, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1264, ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM) \
_(1266, ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP) \
_(1267, ZEND_ASSIGN_CONCAT_SPEC_CV_CV) \
_(1268, ZEND_ASSIGN_CONCAT_SPEC_CV_CV_DIM) \
_(1269, ZEND_ASSIGN_CONCAT_SPEC_CV_CV_OBJ) \
_(1274, ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP) \
_(1278, ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1282, ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1286, ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP) \
_(1294, ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP) \
_(1298, ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1302, ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1306, ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP) \
_(1311, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST) \
_(1312, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_DIM) \
_(1313, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ) \
_(1314, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP) \
_(1315, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR) \
_(1316, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM) \
_(1317, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ) \
_(1318, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1319, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR) \
_(1320, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM) \
_(1321, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ) \
_(1322, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1324, ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM) \
_(1326, ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP) \
_(1327, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV) \
_(1328, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_DIM) \
_(1329, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_OBJ) \
_(1333, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_OBJ) \
_(1337, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ) \
_(1341, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ) \
_(1349, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_OBJ) \
_(1351, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST) \
_(1352, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_DIM) \
_(1353, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ) \
_(1354, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP) \
_(1355, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR) \
_(1356, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM) \
_(1357, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ) \
_(1358, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1359, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR) \
_(1360, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM) \
_(1361, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ) \
_(1362, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1364, ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM) \
_(1366, ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP) \
_(1367, ZEND_ASSIGN_BW_OR_SPEC_CV_CV) \
_(1368, ZEND_ASSIGN_BW_OR_SPEC_CV_CV_DIM) \
_(1369, ZEND_ASSIGN_BW_OR_SPEC_CV_CV_OBJ) \
_(1374, ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP) \
_(1378, ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1382, ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1386, ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP) \
_(1394, ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP) \
_(1398, ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1402, ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1406, ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP) \
_(1411, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST) \
_(1412, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_DIM) \
_(1413, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ) \
_(1414, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP) \
_(1415, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR) \
_(1416, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM) \
_(1417, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ) \
_(1418, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1419, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR) \
_(1420, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM) \
_(1421, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ) \
_(1422, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1424, ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM) \
_(1426, ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP) \
_(1427, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV) \
_(1428, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_DIM) \
_(1429, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_OBJ) \
_(1433, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_OBJ) \
_(1437, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ) \
_(1441, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ) \
_(1449, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_OBJ) \
_(1451, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST) \
_(1452, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_DIM) \
_(1453, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ) \
_(1454, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP) \
_(1455, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR) \
_(1456, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM) \
_(1457, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ) \
_(1458, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1459, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR) \
_(1460, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM) \
_(1461, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ) \
_(1462, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1464, ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM) \
_(1466, ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP) \
_(1467, ZEND_ASSIGN_BW_AND_SPEC_CV_CV) \
_(1468, ZEND_ASSIGN_BW_AND_SPEC_CV_CV_DIM) \
_(1469, ZEND_ASSIGN_BW_AND_SPEC_CV_CV_OBJ) \
_(1474, ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP) \
_(1478, ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1482, ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(1486, ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP) \
_(1494, ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP) \
_(1498, ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1502, ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(1506, ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP) \
_(1511, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST) \
_(1512, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_DIM) \
_(1513, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ) \
_(1514, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP) \
_(1515, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR) \
_(1516, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM) \
_(1517, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ) \
_(1518, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1519, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR) \
_(1520, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM) \
_(1521, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ) \
_(1522, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(1524, ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM) \
_(1526, ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP) \
_(1527, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV) \
_(1528, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_DIM) \
_(1529, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_OBJ) \
_(1533, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_OBJ) \
_(1537, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ) \
_(1541, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ) \
_(1549, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_OBJ) \
_(1551, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST) \
_(1552, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_DIM) \
_(1553, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ) \
_(1554, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP) \
_(1555, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR) \
_(1556, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM) \
_(1557, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ) \
_(1558, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1559, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR) \
_(1560, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM) \
_(1561, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ) \
_(1562, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP) \
_(1564, ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM) \
_(1566, ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP) \
_(1567, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV) \
_(1568, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_DIM) \
_(1569, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_OBJ) \
_(1575, ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED) \
_(1576, ZEND_PRE_INC_SPEC_VAR_RETVAL_USED) \
_(1579, ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED) \
_(1580, ZEND_PRE_INC_SPEC_CV_RETVAL_USED) \
_(1585, ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED) \
_(1586, ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED) \
_(1589, ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED) \
_(1590, ZEND_PRE_DEC_SPEC_CV_RETVAL_USED) \
_(1593, ZEND_POST_INC_SPEC_VAR) \
_(1595, ZEND_POST_INC_SPEC_CV) \
_(1598, ZEND_POST_DEC_SPEC_VAR) \
_(1600, ZEND_POST_DEC_SPEC_CV) \
_(1621, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED) \
_(1622, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED) \
_(1623, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED) \
_(1624, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED) \
_(1625, ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED) \
_(1626, ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED) \
_(1629, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED) \
_(1630, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED) \
_(1641, ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED) \
_(1642, ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED) \
_(1643, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED) \
_(1644, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED) \
_(1645, ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED) \
_(1646, ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED) \
_(1649, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED) \
_(1650, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED) \
_(1663, ZEND_ASSIGN_REF_SPEC_VAR_VAR) \
_(1665, ZEND_ASSIGN_REF_SPEC_VAR_CV) \
_(1673, ZEND_ASSIGN_REF_SPEC_CV_VAR) \
_(1675, ZEND_ASSIGN_REF_SPEC_CV_CV) \
_(1676, ZEND_ECHO_SPEC_CONST) \
_(1677, ZEND_ECHO_SPEC_TMPVAR) \
_(1678, ZEND_ECHO_SPEC_TMPVAR) \
_(1680, ZEND_ECHO_SPEC_CV) \
_(1681, ZEND_GENERATOR_CREATE_SPEC) \
_(1682, ZEND_JMP_SPEC) \
_(1683, ZEND_JMPZ_SPEC_CONST) \
_(1684, ZEND_JMPZ_SPEC_TMPVAR) \
_(1685, ZEND_JMPZ_SPEC_TMPVAR) \
_(1687, ZEND_JMPZ_SPEC_CV) \
_(1688, ZEND_JMPNZ_SPEC_CONST) \
_(1689, ZEND_JMPNZ_SPEC_TMPVAR) \
_(1690, ZEND_JMPNZ_SPEC_TMPVAR) \
_(1692, ZEND_JMPNZ_SPEC_CV) \
_(1693, ZEND_JMPZNZ_SPEC_CONST) \
_(1694, ZEND_JMPZNZ_SPEC_TMPVAR) \
_(1695, ZEND_JMPZNZ_SPEC_TMPVAR) \
_(1697, ZEND_JMPZNZ_SPEC_CV) \
_(1698, ZEND_JMPZ_EX_SPEC_CONST) \
_(1699, ZEND_JMPZ_EX_SPEC_TMPVAR) \
_(1700, ZEND_JMPZ_EX_SPEC_TMPVAR) \
_(1702, ZEND_JMPZ_EX_SPEC_CV) \
_(1703, ZEND_JMPNZ_EX_SPEC_CONST) \
_(1704, ZEND_JMPNZ_EX_SPEC_TMPVAR) \
_(1705, ZEND_JMPNZ_EX_SPEC_TMPVAR) \
_(1707, ZEND_JMPNZ_EX_SPEC_CV) \
_(1708, ZEND_CASE_SPEC_TMPVAR_CONST) \
_(1709, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \
_(1710, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \
_(1712, ZEND_CASE_SPEC_TMPVAR_CV) \
_(1713, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \
_(1714, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR) \
_(1715, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK) \
_(1718, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
_(1720, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
_(1721, ZEND_BOOL_SPEC_CONST) \
_(1722, ZEND_BOOL_SPEC_TMPVAR) \
_(1723, ZEND_BOOL_SPEC_TMPVAR) \
_(1725, ZEND_BOOL_SPEC_CV) \
_(1726, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \
_(1727, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \
_(1728, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \
_(1730, ZEND_FAST_CONCAT_SPEC_CONST_CV) \
_(1731, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \
_(1732, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(1733, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(1735, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \
_(1736, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \
_(1737, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(1738, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
_(1740, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \
_(1746, ZEND_FAST_CONCAT_SPEC_CV_CONST) \
_(1747, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \
_(1748, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \
_(1750, ZEND_FAST_CONCAT_SPEC_CV_CV) \
_(1751, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \
_(1752, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \
_(1753, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \
_(1755, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \
_(1756, ZEND_ROPE_ADD_SPEC_TMP_CONST) \
_(1757, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \
_(1758, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \
_(1760, ZEND_ROPE_ADD_SPEC_TMP_CV) \
_(1761, ZEND_ROPE_END_SPEC_TMP_CONST) \
_(1762, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \
_(1763, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \
_(1765, ZEND_ROPE_END_SPEC_TMP_CV) \
_(1766, ZEND_BEGIN_SILENCE_SPEC) \
_(1767, ZEND_END_SILENCE_SPEC_TMP) \
_(1768, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \
_(1769, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \
_(1770, ZEND_DO_FCALL_SPEC_RETVAL_USED) \
_(1771, ZEND_INIT_FCALL_SPEC_CONST) \
_(1772, ZEND_RETURN_SPEC_CONST) \
_(1773, ZEND_RETURN_SPEC_TMP) \
_(1774, ZEND_RETURN_SPEC_VAR) \
_(1776, ZEND_RETURN_SPEC_CV) \
_(1777, ZEND_RECV_SPEC_UNUSED) \
_(1778, ZEND_RECV_INIT_SPEC_CONST) \
_(1779, ZEND_SEND_VAL_SPEC_CONST) \
_(1780, ZEND_SEND_VAL_SPEC_TMPVAR) \
_(1781, ZEND_SEND_VAL_SPEC_TMPVAR) \
_(1788, ZEND_SEND_VAR_EX_SPEC_VAR) \
_(1789, ZEND_SEND_VAR_EX_SPEC_VAR_QUICK) \
_(1792, ZEND_SEND_VAR_EX_SPEC_CV) \
_(1793, ZEND_SEND_VAR_EX_SPEC_CV_QUICK) \
_(1796, ZEND_SEND_REF_SPEC_VAR) \
_(1798, ZEND_SEND_REF_SPEC_CV) \
_(1799, ZEND_NEW_SPEC_CONST_UNUSED) \
_(1801, ZEND_NEW_SPEC_VAR_UNUSED) \
_(1802, ZEND_NEW_SPEC_UNUSED_UNUSED) \
_(1804, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \
_(1805, ZEND_FREE_SPEC_TMPVAR) \
_(1806, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \
_(1807, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
_(1808, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
_(1809, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \
_(1810, ZEND_INIT_ARRAY_SPEC_CONST_CV) \
_(1811, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \
_(1812, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
_(1813, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
_(1814, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \
_(1815, ZEND_INIT_ARRAY_SPEC_TMP_CV) \
_(1816, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \
_(1817, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
_(1818, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
_(1819, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \
_(1820, ZEND_INIT_ARRAY_SPEC_VAR_CV) \
_(1826, ZEND_INIT_ARRAY_SPEC_CV_CONST) \
_(1827, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
_(1828, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
_(1829, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \
_(1830, ZEND_INIT_ARRAY_SPEC_CV_CV) \
_(1831, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \
_(1832, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
_(1833, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
_(1834, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \
_(1835, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \
_(1836, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \
_(1837, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
_(1838, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
_(1839, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \
_(1840, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \
_(1841, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \
_(1842, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
_(1843, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
_(1844, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \
_(1845, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \
_(1851, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \
_(1852, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
_(1853, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
_(1854, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \
_(1855, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \
_(1856, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \
_(1857, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
_(1858, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
_(1860, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \
_(1861, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \
_(1862, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
_(1863, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
_(1865, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \
_(1876, ZEND_UNSET_DIM_SPEC_VAR_CONST) \
_(1877, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
_(1878, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
_(1880, ZEND_UNSET_DIM_SPEC_VAR_CV) \
_(1886, ZEND_UNSET_DIM_SPEC_CV_CONST) \
_(1887, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
_(1888, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
_(1890, ZEND_UNSET_DIM_SPEC_CV_CV) \
_(1901, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \
_(1902, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
_(1903, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
_(1905, ZEND_UNSET_OBJ_SPEC_VAR_CV) \
_(1906, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \
_(1907, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
_(1908, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
_(1910, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \
_(1911, ZEND_UNSET_OBJ_SPEC_CV_CONST) \
_(1912, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
_(1913, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
_(1915, ZEND_UNSET_OBJ_SPEC_CV_CV) \
_(1916, ZEND_FE_RESET_R_SPEC_CONST) \
_(1917, ZEND_FE_RESET_R_SPEC_TMP) \
_(1918, ZEND_FE_RESET_R_SPEC_VAR) \
_(1920, ZEND_FE_RESET_R_SPEC_CV) \
_(1921, ZEND_FE_FETCH_R_SPEC_VAR) \
_(1922, ZEND_EXIT_SPEC_CONST) \
_(1923, ZEND_EXIT_SPEC_TMPVAR) \
_(1924, ZEND_EXIT_SPEC_TMPVAR) \
_(1925, ZEND_EXIT_SPEC_UNUSED) \
_(1926, ZEND_EXIT_SPEC_CV) \
_(1927, ZEND_FETCH_R_SPEC_CONST_UNUSED) \
_(1928, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
_(1929, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
_(1931, ZEND_FETCH_R_SPEC_CV_UNUSED) \
_(1932, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \
_(1933, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
_(1934, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
_(1936, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \
_(1937, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
_(1938, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
_(1939, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
_(1941, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
_(1942, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
_(1943, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
_(1944, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
_(1946, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
_(1952, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \
_(1953, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
_(1954, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
_(1956, ZEND_FETCH_DIM_R_SPEC_CV_CV) \
_(1957, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \
_(1958, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
_(1959, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
_(1961, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \
_(1962, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
_(1963, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
_(1964, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
_(1966, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
_(1967, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
_(1968, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
_(1969, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
_(1971, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
_(1972, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \
_(1973, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
_(1974, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
_(1976, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \
_(1977, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \
_(1978, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
_(1979, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
_(1981, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \
_(1982, ZEND_FETCH_W_SPEC_CONST_UNUSED) \
_(1983, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
_(1984, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
_(1986, ZEND_FETCH_W_SPEC_CV_UNUSED) \
_(1997, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \
_(1998, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
_(1999, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
_(2000, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \
_(2001, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \
_(2007, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \
_(2008, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
_(2009, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
_(2010, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \
_(2011, ZEND_FETCH_DIM_W_SPEC_CV_CV) \
_(2022, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \
_(2023, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
_(2024, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
_(2026, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \
_(2027, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \
_(2028, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
_(2029, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
_(2031, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \
_(2032, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \
_(2033, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
_(2034, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
_(2036, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \
_(2037, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \
_(2038, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
_(2039, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
_(2041, ZEND_FETCH_RW_SPEC_CV_UNUSED) \
_(2052, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \
_(2053, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
_(2054, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
_(2055, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \
_(2056, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \
_(2062, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \
_(2063, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
_(2064, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
_(2065, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \
_(2066, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \
_(2077, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \
_(2078, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
_(2079, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
_(2081, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \
_(2082, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \
_(2083, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
_(2084, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
_(2086, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \
_(2087, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \
_(2088, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
_(2089, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
_(2091, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \
_(2092, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \
_(2093, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
_(2094, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
_(2096, ZEND_FETCH_IS_SPEC_CV_UNUSED) \
_(2097, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \
_(2098, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
_(2099, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
_(2101, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \
_(2102, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
_(2103, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
_(2104, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
_(2106, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
_(2107, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
_(2108, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
_(2109, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
_(2111, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
_(2117, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \
_(2118, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
_(2119, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
_(2121, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \
_(2122, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \
_(2123, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
_(2124, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
_(2126, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \
_(2127, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
_(2128, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
_(2129, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
_(2131, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
_(2132, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
_(2133, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
_(2134, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
_(2136, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
_(2137, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \
_(2138, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
_(2139, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
_(2141, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \
_(2142, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \
_(2143, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
_(2144, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
_(2146, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \
_(2147, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \
_(2148, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
_(2149, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
_(2151, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \
_(2152, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \
_(2153, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
_(2154, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
_(2155, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \
_(2156, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \
_(2157, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \
_(2158, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
_(2159, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
_(2160, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \
_(2161, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \
_(2162, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \
_(2163, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
_(2164, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
_(2165, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \
_(2166, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \
_(2172, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \
_(2173, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
_(2174, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
_(2175, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \
_(2176, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \
_(2177, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \
_(2178, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
_(2179, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
_(2181, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \
_(2182, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \
_(2183, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
_(2184, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
_(2186, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \
_(2187, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \
_(2188, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
_(2189, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
_(2191, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \
_(2192, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \
_(2193, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
_(2194, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
_(2196, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \
_(2197, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \
_(2198, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
_(2199, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
_(2201, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \
_(2202, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \
_(2203, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
_(2204, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
_(2206, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \
_(2217, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \
_(2218, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
_(2219, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
_(2221, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \
_(2227, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \
_(2228, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
_(2229, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
_(2231, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \
_(2242, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \
_(2243, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
_(2244, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
_(2246, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \
_(2247, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \
_(2248, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
_(2249, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
_(2251, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \
_(2252, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \
_(2253, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
_(2254, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
_(2256, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \
_(2257, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \
_(2258, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
_(2259, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
_(2261, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \
_(2262, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
_(2263, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
_(2264, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
_(2266, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
_(2267, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
_(2268, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
_(2269, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
_(2271, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
_(2277, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
_(2278, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
_(2279, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
_(2281, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
_(2282, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \
_(2283, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED) \
_(2284, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK) \
_(2285, ZEND_EXT_STMT_SPEC) \
_(2286, ZEND_EXT_FCALL_BEGIN_SPEC) \
_(2287, ZEND_EXT_FCALL_END_SPEC) \
_(2288, ZEND_EXT_NOP_SPEC) \
_(2289, ZEND_TICKS_SPEC) \
_(2290, ZEND_SEND_VAR_NO_REF_SPEC_VAR) \
_(2291, ZEND_CATCH_SPEC_CONST) \
_(2292, ZEND_THROW_SPEC_CONST) \
_(2293, ZEND_THROW_SPEC_TMP) \
_(2294, ZEND_THROW_SPEC_VAR) \
_(2296, ZEND_THROW_SPEC_CV) \
_(2297, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \
_(2298, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
_(2299, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
_(2300, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \
_(2301, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \
_(2302, ZEND_CLONE_SPEC_CONST) \
_(2303, ZEND_CLONE_SPEC_TMPVAR) \
_(2304, ZEND_CLONE_SPEC_TMPVAR) \
_(2305, ZEND_CLONE_SPEC_UNUSED) \
_(2306, ZEND_CLONE_SPEC_CV) \
_(2307, ZEND_RETURN_BY_REF_SPEC_CONST) \
_(2308, ZEND_RETURN_BY_REF_SPEC_TMP) \
_(2309, ZEND_RETURN_BY_REF_SPEC_VAR) \
_(2311, ZEND_RETURN_BY_REF_SPEC_CV) \
_(2312, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \
_(2313, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
_(2314, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
_(2316, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \
_(2317, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
_(2318, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
_(2319, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
_(2321, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
_(2322, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
_(2323, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
_(2324, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
_(2326, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
_(2327, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \
_(2328, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
_(2329, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
_(2331, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \
_(2332, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \
_(2333, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
_(2334, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
_(2336, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \
_(2337, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \
_(2338, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
_(2339, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
_(2340, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \
_(2341, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \
_(2347, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \
_(2348, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
_(2349, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
_(2350, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \
_(2351, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \
_(2352, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \
_(2353, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
_(2354, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
_(2355, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \
_(2356, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \
_(2362, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \
_(2363, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
_(2364, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
_(2366, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \
_(2367, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \
_(2368, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
_(2369, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
_(2371, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \
_(2372, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
_(2373, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2374, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2376, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
_(2377, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
_(2378, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2379, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2381, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
_(2387, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \
_(2388, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
_(2389, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
_(2391, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \
_(2392, ZEND_SEND_VAL_EX_SPEC_CONST) \
_(2393, ZEND_SEND_VAL_EX_SPEC_CONST_QUICK) \
_(2394, ZEND_SEND_VAL_EX_SPEC_TMP) \
_(2395, ZEND_SEND_VAL_EX_SPEC_TMP_QUICK) \
_(2404, ZEND_SEND_VAR_SPEC_VAR) \
_(2406, ZEND_SEND_VAR_SPEC_CV) \
_(2407, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \
_(2408, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
_(2409, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
_(2411, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \
_(2412, ZEND_SEND_ARRAY_SPEC) \
_(2413, ZEND_SEND_USER_SPEC_CONST) \
_(2414, ZEND_SEND_USER_SPEC_TMP) \
_(2415, ZEND_SEND_USER_SPEC_VAR) \
_(2417, ZEND_SEND_USER_SPEC_CV) \
_(2418, ZEND_STRLEN_SPEC_CONST) \
_(2419, ZEND_STRLEN_SPEC_TMPVAR) \
_(2420, ZEND_STRLEN_SPEC_TMPVAR) \
_(2422, ZEND_STRLEN_SPEC_CV) \
_(2423, ZEND_DEFINED_SPEC_CONST) \
_(2424, ZEND_TYPE_CHECK_SPEC_CONST) \
_(2425, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
_(2426, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
_(2428, ZEND_TYPE_CHECK_SPEC_CV) \
_(2429, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \
_(2430, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \
_(2431, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \
_(2432, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \
_(2433, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \
_(2434, ZEND_FE_RESET_RW_SPEC_CONST) \
_(2435, ZEND_FE_RESET_RW_SPEC_TMP) \
_(2436, ZEND_FE_RESET_RW_SPEC_VAR) \
_(2438, ZEND_FE_RESET_RW_SPEC_CV) \
_(2439, ZEND_FE_FETCH_RW_SPEC_VAR) \
_(2440, ZEND_FE_FREE_SPEC_TMPVAR) \
_(2441, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \
_(2442, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
_(2443, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
_(2445, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \
_(2446, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \
_(2447, ZEND_DO_ICALL_SPEC_RETVAL_USED) \
_(2448, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
_(2449, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
_(2450, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
_(2451, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
_(2462, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
_(2463, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
_(2464, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
_(2466, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
_(2467, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
_(2468, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2469, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2471, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
_(2472, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
_(2473, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
_(2474, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
_(2476, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
_(2487, ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST) \
_(2488, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \
_(2489, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \
_(2491, ZEND_PRE_DEC_OBJ_SPEC_VAR_CV) \
_(2492, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST) \
_(2493, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2494, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2496, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV) \
_(2497, ZEND_PRE_DEC_OBJ_SPEC_CV_CONST) \
_(2498, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \
_(2499, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \
_(2501, ZEND_PRE_DEC_OBJ_SPEC_CV_CV) \
_(2512, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
_(2513, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
_(2514, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
_(2516, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
_(2517, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
_(2518, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2519, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2521, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
_(2522, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
_(2523, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
_(2524, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
_(2526, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
_(2537, ZEND_POST_DEC_OBJ_SPEC_VAR_CONST) \
_(2538, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \
_(2539, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \
_(2541, ZEND_POST_DEC_OBJ_SPEC_VAR_CV) \
_(2542, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST) \
_(2543, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2544, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
_(2546, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV) \
_(2547, ZEND_POST_DEC_OBJ_SPEC_CV_CONST) \
_(2548, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \
_(2549, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \
_(2551, ZEND_POST_DEC_OBJ_SPEC_CV_CV) \
_(2602, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST) \
_(2603, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP) \
_(2604, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR) \
_(2606, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV) \
_(2607, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
_(2608, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
_(2609, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
_(2611, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) \
_(2612, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
_(2613, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
_(2614, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
_(2616, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) \
_(2622, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST) \
_(2623, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP) \
_(2624, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR) \
_(2626, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV) \
_(2627, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST) \
_(2628, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP) \
_(2629, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR) \
_(2631, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV) \
_(2632, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) \
_(2633, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) \
_(2634, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
_(2636, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
_(2637, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) \
_(2638, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) \
_(2639, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
_(2641, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
_(2647, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST) \
_(2648, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP) \
_(2649, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR) \
_(2651, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV) \
_(2652, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST) \
_(2653, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP) \
_(2654, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR) \
_(2656, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV) \
_(2657, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) \
_(2658, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) \
_(2659, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) \
_(2661, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) \
_(2662, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) \
_(2663, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) \
_(2664, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) \
_(2666, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) \
_(2672, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST) \
_(2673, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP) \
_(2674, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR) \
_(2676, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV) \
_(2683, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
_(2685, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
_(2686, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
_(2688, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
_(2690, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
_(2691, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
_(2698, ZEND_INSTANCEOF_SPEC_CV_CONST) \
_(2700, ZEND_INSTANCEOF_SPEC_CV_VAR) \
_(2701, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
_(2703, ZEND_DECLARE_CLASS_SPEC_CONST) \
_(2704, ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST) \
_(2705, ZEND_DECLARE_FUNCTION_SPEC) \
_(2706, ZEND_YIELD_FROM_SPEC_CONST) \
_(2707, ZEND_YIELD_FROM_SPEC_TMP) \
_(2708, ZEND_YIELD_FROM_SPEC_VAR) \
_(2710, ZEND_YIELD_FROM_SPEC_CV) \
_(2711, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
_(2712, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) \
_(2763, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \
_(2764, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \
_(2765, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \
_(2767, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \
_(2768, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
_(2769, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
_(2770, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
_(2772, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \
_(2773, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
_(2774, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
_(2775, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
_(2777, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \
_(2778, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \
_(2779, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \
_(2780, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \
_(2782, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \
_(2783, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \
_(2784, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \
_(2785, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \
_(2787, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \
_(2813, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \
_(2814, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \
_(2815, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \
_(2817, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \
_(2818, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \
_(2819, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \
_(2820, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \
_(2822, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \
_(2823, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \
_(2824, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \
_(2825, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \
_(2827, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \
_(2828, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \
_(2829, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \
_(2830, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \
_(2832, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \
_(2833, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \
_(2834, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \
_(2835, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \
_(2837, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \
_(2838, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
_(2839, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
_(2840, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
_(2842, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \
_(2843, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
_(2844, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2845, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2847, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
_(2848, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
_(2849, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2850, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
_(2852, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
_(2853, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
_(2854, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
_(2855, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
_(2857, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
_(2858, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
_(2859, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
_(2860, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
_(2862, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
_(2863, ZEND_HANDLE_EXCEPTION_SPEC) \
_(2864, ZEND_USER_OPCODE_SPEC) \
_(2865, ZEND_ASSERT_CHECK_SPEC) \
_(2866, ZEND_JMP_SET_SPEC_CONST) \
_(2867, ZEND_JMP_SET_SPEC_TMP) \
_(2868, ZEND_JMP_SET_SPEC_VAR) \
_(2870, ZEND_JMP_SET_SPEC_CV) \
_(2871, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \
_(2872, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
_(2873, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
_(2874, ZEND_CALL_TRAMPOLINE_SPEC) \
_(2875, ZEND_DISCARD_EXCEPTION_SPEC) \
_(2876, ZEND_YIELD_SPEC_CONST_CONST) \
_(2877, ZEND_YIELD_SPEC_CONST_TMP) \
_(2878, ZEND_YIELD_SPEC_CONST_VAR) \
_(2879, ZEND_YIELD_SPEC_CONST_UNUSED) \
_(2880, ZEND_YIELD_SPEC_CONST_CV) \
_(2881, ZEND_YIELD_SPEC_TMP_CONST) \
_(2882, ZEND_YIELD_SPEC_TMP_TMP) \
_(2883, ZEND_YIELD_SPEC_TMP_VAR) \
_(2884, ZEND_YIELD_SPEC_TMP_UNUSED) \
_(2885, ZEND_YIELD_SPEC_TMP_CV) \
_(2886, ZEND_YIELD_SPEC_VAR_CONST) \
_(2887, ZEND_YIELD_SPEC_VAR_TMP) \
_(2888, ZEND_YIELD_SPEC_VAR_VAR) \
_(2889, ZEND_YIELD_SPEC_VAR_UNUSED) \
_(2890, ZEND_YIELD_SPEC_VAR_CV) \
_(2891, ZEND_YIELD_SPEC_UNUSED_CONST) \
_(2892, ZEND_YIELD_SPEC_UNUSED_TMP) \
_(2893, ZEND_YIELD_SPEC_UNUSED_VAR) \
_(2894, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
_(2895, ZEND_YIELD_SPEC_UNUSED_CV) \
_(2896, ZEND_YIELD_SPEC_CV_CONST) \
_(2897, ZEND_YIELD_SPEC_CV_TMP) \
_(2898, ZEND_YIELD_SPEC_CV_VAR) \
_(2899, ZEND_YIELD_SPEC_CV_UNUSED) \
_(2900, ZEND_YIELD_SPEC_CV_CV) \
_(2901, ZEND_GENERATOR_RETURN_SPEC_CONST) \
_(2902, ZEND_GENERATOR_RETURN_SPEC_TMP) \
_(2903, ZEND_GENERATOR_RETURN_SPEC_VAR) \
_(2905, ZEND_GENERATOR_RETURN_SPEC_CV) \
_(2906, ZEND_FAST_CALL_SPEC) \
_(2907, ZEND_FAST_RET_SPEC) \
_(2908, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
_(2909, ZEND_SEND_UNPACK_SPEC) \
_(2910, ZEND_POW_SPEC_CONST_CONST) \
_(2911, ZEND_POW_SPEC_CONST_TMPVAR) \
_(2912, ZEND_POW_SPEC_CONST_TMPVAR) \
_(2914, ZEND_POW_SPEC_CONST_CV) \
_(2915, ZEND_POW_SPEC_TMPVAR_CONST) \
_(2916, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
_(2917, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
_(2919, ZEND_POW_SPEC_TMPVAR_CV) \
_(2920, ZEND_POW_SPEC_TMPVAR_CONST) \
_(2921, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
_(2922, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
_(2924, ZEND_POW_SPEC_TMPVAR_CV) \
_(2930, ZEND_POW_SPEC_CV_CONST) \
_(2931, ZEND_POW_SPEC_CV_TMPVAR) \
_(2932, ZEND_POW_SPEC_CV_TMPVAR) \
_(2934, ZEND_POW_SPEC_CV_CV) \
_(2938, ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP) \
_(2942, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(2946, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \
_(2950, ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP) \
_(2958, ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP) \
_(2962, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(2966, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \
_(2970, ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP) \
_(2975, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \
_(2976, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \
_(2977, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \
_(2978, ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP) \
_(2979, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
_(2980, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
_(2981, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
_(2982, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(2983, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
_(2984, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
_(2985, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
_(2986, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \
_(2988, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \
_(2990, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP) \
_(2991, ZEND_ASSIGN_POW_SPEC_VAR_CV) \
_(2992, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \
_(2993, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \
_(2997, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \
_(3001, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
_(3005, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
_(3013, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \
_(3015, ZEND_ASSIGN_POW_SPEC_CV_CONST) \
_(3016, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \
_(3017, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \
_(3018, ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP) \
_(3019, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
_(3020, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
_(3021, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
_(3022, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \
_(3023, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
_(3024, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
_(3025, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
_(3026, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \
_(3028, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \
_(3030, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP) \
_(3031, ZEND_ASSIGN_POW_SPEC_CV_CV) \
_(3032, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \
_(3033, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \
_(3035, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
_(3036, ZEND_COALESCE_SPEC_CONST) \
_(3037, ZEND_COALESCE_SPEC_TMPVAR) \
_(3038, ZEND_COALESCE_SPEC_TMPVAR) \
_(3040, ZEND_COALESCE_SPEC_CV) \
_(3041, ZEND_SPACESHIP_SPEC_CONST_CONST) \
_(3042, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
_(3043, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
_(3045, ZEND_SPACESHIP_SPEC_CONST_CV) \
_(3046, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
_(3047, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
_(3048, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
_(3050, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
_(3051, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
_(3052, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
_(3053, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
_(3055, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
_(3061, ZEND_SPACESHIP_SPEC_CV_CONST) \
_(3062, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
_(3063, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
_(3065, ZEND_SPACESHIP_SPEC_CV_CV) \
_(3066, ZEND_DECLARE_ANON_CLASS_SPEC) \
_(3067, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \
_(3068, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \
_(3070, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \
_(3071, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \
_(3073, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
_(3075, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
_(3076, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
_(3078, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
_(3080, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
_(3081, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
_(3088, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \
_(3090, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \
_(3091, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \
_(3093, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \
_(3095, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \
_(3096, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \
_(3098, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
_(3100, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
_(3101, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
_(3103, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
_(3105, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
_(3106, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
_(3113, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \
_(3115, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \
_(3116, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \
_(3118, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \
_(3120, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \
_(3121, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \
_(3123, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
_(3125, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
_(3126, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
_(3128, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
_(3130, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
_(3131, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
_(3138, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \
_(3140, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \
_(3141, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \
_(3143, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \
_(3145, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \
_(3146, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \
_(3148, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
_(3150, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
_(3151, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
_(3153, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
_(3155, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
_(3156, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
_(3163, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \
_(3165, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \
_(3166, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \
_(3168, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \
_(3170, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \
_(3171, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \
_(3173, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
_(3175, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
_(3176, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
_(3178, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
_(3180, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
_(3181, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
_(3188, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \
_(3190, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \
_(3191, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \
_(3193, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \
_(3195, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \
_(3196, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \
_(3198, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
_(3200, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
_(3201, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
_(3203, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
_(3205, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
_(3206, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
_(3213, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \
_(3215, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \
_(3216, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \
_(3218, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \
_(3220, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \
_(3221, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \
_(3223, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3225, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3226, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3228, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3230, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3231, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3238, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \
_(3240, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \
_(3241, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \
_(3243, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \
_(3244, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
_(3246, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
_(3247, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
_(3249, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
_(3250, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
_(3251, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
_(3252, ZEND_SEND_FUNC_ARG_SPEC_VAR) \
_(3253, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
_(3254, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
_(3255, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
_(3256, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
_(3258, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
_(3259, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
_(3260, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
_(3261, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
_(3263, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
_(3264, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
_(3265, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
_(3266, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
_(3268, ZEND_IN_ARRAY_SPEC_CV_CONST) \
_(3269, ZEND_COUNT_SPEC_CONST_UNUSED) \
_(3270, ZEND_COUNT_SPEC_TMP_UNUSED) \
_(3271, ZEND_COUNT_SPEC_VAR_UNUSED) \
_(3273, ZEND_COUNT_SPEC_CV_UNUSED) \
_(3274, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
_(3275, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \
_(3276, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \
_(3277, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
_(3278, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
_(3279, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
_(3280, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
_(3281, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
_(3282, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
_(3284, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
_(3285, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
_(3286, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
_(3289, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
_(3291, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
_(3292, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
_(3293, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
_(3294, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
_(3295, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
_(3296, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
_(3298, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
_(3299, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
_(3300, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
_(3301, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
_(3303, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
_(3304, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
_(3305, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
_(3306, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
_(3308, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
_(3309, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
_(3310, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
_(3311, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
_(3313, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
_(3319, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
_(3320, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
_(3321, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
_(3323, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
_(3376, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \
_(3378, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \
_(3381, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
_(3383, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \
_(3386, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
_(3388, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \
_(3396, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \
_(3398, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \
_(3401, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \
_(3403, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \
_(3406, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
_(3408, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
_(3411, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
_(3413, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
_(3421, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \
_(3423, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \
_(3426, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \
_(3428, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \
_(3431, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \
_(3433, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \
_(3436, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \
_(3438, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \
_(3446, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \
_(3448, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \
_(3449, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST) \
_(3450, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP) \
_(3451, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) \
_(3453, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV) \
_(3454, ZEND_ASSIGN_STATIC_PROP_REF_SPEC) \
_(3455, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST) \
_(3457, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR) \
_(3458, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED) \
_(3460, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3462, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3463, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3465, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3467, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3468, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3475, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST) \
_(3477, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR) \
_(3478, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED) \
_(3480, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST) \
_(3482, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR) \
_(3483, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \
_(3485, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3487, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3488, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3490, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3492, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3493, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3500, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST) \
_(3502, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR) \
_(3503, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED) \
_(3505, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST) \
_(3507, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR) \
_(3508, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED) \
_(3510, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3512, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3513, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3515, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3517, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3518, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3525, ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST) \
_(3527, ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR) \
_(3528, ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED) \
_(3530, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST) \
_(3532, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR) \
_(3533, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \
_(3535, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3537, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3538, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3540, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
_(3542, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
_(3543, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
_(3550, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \
_(3552, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \
_(3553, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \
_(3555, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
_(3556, ZEND_JMP_FORWARD_SPEC) \
_(3562, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3566, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3577, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3579, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3581, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3587, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
_(3588, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3589, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3591, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3592, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
_(3593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3594, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3602, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
_(3603, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3604, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3606, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3612, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3616, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3627, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3629, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3631, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
_(3634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
_(3636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
_(3637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3641, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3652, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3658, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
_(3659, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
_(3661, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
_(3662, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
_(3663, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3664, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3666, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3667, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
_(3668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3669, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3677, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
_(3678, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3679, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3681, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3683, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
_(3684, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
_(3686, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
_(3687, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3691, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3702, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3704, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3706, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3712, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3716, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3727, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
_(3728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3729, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3731, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
_(3737, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
_(3738, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3739, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3741, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3742, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
_(3743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3744, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3752, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
_(3753, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3754, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3756, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3762, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3766, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3777, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3779, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3781, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(3798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(3799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(3813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(3814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(3843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(3844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(3874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(3889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(3918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(3919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(3930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(3948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(3949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(3963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(3964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(3993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(3994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(3995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(3997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(3998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(3999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
_(4086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
_(4087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
_(4089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
_(4090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4094, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
_(4095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
_(4096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
_(4098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(4099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
_(4113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(4114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
_(4143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(4144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
_(4161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
_(4162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
_(4164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
_(4165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4169, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
_(4170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
_(4171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
_(4236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
_(4237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
_(4239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
_(4240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
_(4245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
_(4246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(4248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(4249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(4263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(4264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
_(4293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
_(4294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
_(4305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
_(4311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
_(4312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
_(4314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
_(4315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
_(4320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
_(4321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
_(4322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
_(4368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
_(4369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
_(4370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
_(4380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
_(4381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
_(4382, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
_(4383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
_(4384, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
_(4385, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
_(4386, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
_(4387, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
_(4388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
_(4389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
_(4390, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
_(4391, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
_(4392, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
_(4393, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
_(4394, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
_(4395, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
_(4396, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
_(4397, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
_(4398, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
_(4399, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
_(4400, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
_(4401, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
_(4402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
_(4404, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
_(4405, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
_(4406, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
_(4407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
_(4409, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
_(4411, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
_(4412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
_(4414, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
_(4415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
_(4416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
_(4417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
_(4419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
_(4420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
_(4421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
_(4422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
_(4424, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
_(4430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
_(4431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
_(4432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
_(4434, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
_(4437, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
_(4439, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
_(4442, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
_(4444, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
_(4445, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
_(4446, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
_(4447, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
_(4448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
_(4448+1, ZEND_NULL)
|
6a1ebbc024af7885e46055814749399bc426d69f
|
e73547787354afd9b717ea57fe8dd0695d161821
|
/src/battle/action_cmd/jump.h
|
b88e8a426e03649f48c61829eed78cf392d5ca25
|
[] |
no_license
|
pmret/papermario
|
8b514b19653cef8d6145e47499b3636b8c474a37
|
9774b26d93f1045dd2a67e502b6efc9599fb6c31
|
refs/heads/main
| 2023-08-31T07:09:48.951514
| 2023-08-21T18:07:08
| 2023-08-21T18:07:08
| 287,151,133
| 904
| 139
| null | 2023-09-14T02:44:23
| 2020-08-13T01:22:57
|
C
|
UTF-8
|
C
| false
| false
| 266
|
h
|
jump.h
|
#ifndef _JUMP_H_
#define _JUMP_H_
#include "common_structs.h"
API_CALLABLE(action_command_jump_init);
API_CALLABLE(action_command_jump_start);
void action_command_jump_update(void);
void action_command_jump_draw(void);
void action_command_jump_free(void);
#endif
|
90d2314827d296dbb50390f27422d51c1b62a691
|
1231379e557a3094413045721b4c65ce9bae568b
|
/src/generated/linux/datagram.c.clog.h
|
a5283082eb4ad7bf3d0406dacab7948982075146
|
[
"MIT"
] |
permissive
|
microsoft/msquic
|
a63982f1b7d017fb0497e2dce56f1ef527bd6eaa
|
f91ccc2f975225a278bc68238555ed0923e676ba
|
refs/heads/main
| 2023-09-04T01:25:39.133074
| 2023-08-28T18:04:51
| 2023-08-28T18:04:51
| 217,654,199
| 3,641
| 521
|
MIT
| 2023-09-14T14:36:09
| 2019-10-26T04:10:24
|
C
|
UTF-8
|
C
| false
| false
| 6,141
|
h
|
datagram.c.clog.h
|
#ifndef CLOG_DO_NOT_INCLUDE_HEADER
#include <clog.h>
#endif
#undef TRACEPOINT_PROVIDER
#define TRACEPOINT_PROVIDER CLOG_DATAGRAM_C
#undef TRACEPOINT_PROBE_DYNAMIC_LINKAGE
#define TRACEPOINT_PROBE_DYNAMIC_LINKAGE
#undef TRACEPOINT_INCLUDE
#define TRACEPOINT_INCLUDE "datagram.c.clog.h.lttng.h"
#if !defined(DEF_CLOG_DATAGRAM_C) || defined(TRACEPOINT_HEADER_MULTI_READ)
#define DEF_CLOG_DATAGRAM_C
#include <lttng/tracepoint.h>
#define __int64 __int64_t
#include "datagram.c.clog.h.lttng.h"
#endif
#include <lttng/tracepoint-event.h>
#ifndef _clog_MACRO_QuicTraceLogConnVerbose
#define _clog_MACRO_QuicTraceLogConnVerbose 1
#define QuicTraceLogConnVerbose(a, ...) _clog_CAT(_clog_ARGN_SELECTOR(__VA_ARGS__), _clog_CAT(_,a(#a, __VA_ARGS__)))
#endif
#ifndef _clog_MACRO_QuicTraceEvent
#define _clog_MACRO_QuicTraceEvent 1
#define QuicTraceEvent(a, ...) _clog_CAT(_clog_ARGN_SELECTOR(__VA_ARGS__), _clog_CAT(_,a(#a, __VA_ARGS__)))
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*----------------------------------------------------------
// Decoder Ring for DatagramSendStateChanged
// [conn][%p] Indicating DATAGRAM_SEND_STATE_CHANGED to %u
// QuicTraceLogConnVerbose(
DatagramSendStateChanged,
Connection,
"Indicating DATAGRAM_SEND_STATE_CHANGED to %u",
(uint32_t)State);
// arg1 = arg1 = Connection = arg1
// arg3 = arg3 = (uint32_t)State = arg3
----------------------------------------------------------*/
#ifndef _clog_4_ARGS_TRACE_DatagramSendStateChanged
#define _clog_4_ARGS_TRACE_DatagramSendStateChanged(uniqueId, arg1, encoded_arg_string, arg3)\
tracepoint(CLOG_DATAGRAM_C, DatagramSendStateChanged , arg1, arg3);\
#endif
/*----------------------------------------------------------
// Decoder Ring for DatagramSendShutdown
// [conn][%p] Datagram send shutdown
// QuicTraceLogConnVerbose(
DatagramSendShutdown,
Connection,
"Datagram send shutdown");
// arg1 = arg1 = Connection = arg1
----------------------------------------------------------*/
#ifndef _clog_3_ARGS_TRACE_DatagramSendShutdown
#define _clog_3_ARGS_TRACE_DatagramSendShutdown(uniqueId, arg1, encoded_arg_string)\
tracepoint(CLOG_DATAGRAM_C, DatagramSendShutdown , arg1);\
#endif
/*----------------------------------------------------------
// Decoder Ring for IndicateDatagramStateChanged
// [conn][%p] Indicating QUIC_CONNECTION_EVENT_DATAGRAM_STATE_CHANGED [SendEnabled=%hhu] [MaxSendLength=%hu]
// QuicTraceLogConnVerbose(
IndicateDatagramStateChanged,
Connection,
"Indicating QUIC_CONNECTION_EVENT_DATAGRAM_STATE_CHANGED [SendEnabled=%hhu] [MaxSendLength=%hu]",
Event.DATAGRAM_STATE_CHANGED.SendEnabled,
Event.DATAGRAM_STATE_CHANGED.MaxSendLength);
// arg1 = arg1 = Connection = arg1
// arg3 = arg3 = Event.DATAGRAM_STATE_CHANGED.SendEnabled = arg3
// arg4 = arg4 = Event.DATAGRAM_STATE_CHANGED.MaxSendLength = arg4
----------------------------------------------------------*/
#ifndef _clog_5_ARGS_TRACE_IndicateDatagramStateChanged
#define _clog_5_ARGS_TRACE_IndicateDatagramStateChanged(uniqueId, arg1, encoded_arg_string, arg3, arg4)\
tracepoint(CLOG_DATAGRAM_C, IndicateDatagramStateChanged , arg1, arg3, arg4);\
#endif
/*----------------------------------------------------------
// Decoder Ring for DatagramSendQueued
// [conn][%p] Datagram [%p] queued with %llu bytes (flags 0x%x)
// QuicTraceLogConnVerbose(
DatagramSendQueued,
Connection,
"Datagram [%p] queued with %llu bytes (flags 0x%x)",
SendRequest,
SendRequest->TotalLength,
SendRequest->Flags);
// arg1 = arg1 = Connection = arg1
// arg3 = arg3 = SendRequest = arg3
// arg4 = arg4 = SendRequest->TotalLength = arg4
// arg5 = arg5 = SendRequest->Flags = arg5
----------------------------------------------------------*/
#ifndef _clog_6_ARGS_TRACE_DatagramSendQueued
#define _clog_6_ARGS_TRACE_DatagramSendQueued(uniqueId, arg1, encoded_arg_string, arg3, arg4, arg5)\
tracepoint(CLOG_DATAGRAM_C, DatagramSendQueued , arg1, arg3, arg4, arg5);\
#endif
/*----------------------------------------------------------
// Decoder Ring for IndicateDatagramReceived
// [conn][%p] Indicating DATAGRAM_RECEIVED [len=%hu]
// QuicTraceLogConnVerbose(
IndicateDatagramReceived,
Connection,
"Indicating DATAGRAM_RECEIVED [len=%hu]",
(uint16_t)Frame.Length);
// arg1 = arg1 = Connection = arg1
// arg3 = arg3 = (uint16_t)Frame.Length = arg3
----------------------------------------------------------*/
#ifndef _clog_4_ARGS_TRACE_IndicateDatagramReceived
#define _clog_4_ARGS_TRACE_IndicateDatagramReceived(uniqueId, arg1, encoded_arg_string, arg3)\
tracepoint(CLOG_DATAGRAM_C, IndicateDatagramReceived , arg1, arg3);\
#endif
/*----------------------------------------------------------
// Decoder Ring for ConnError
// [conn][%p] ERROR, %s.
// QuicTraceEvent(
ConnError,
"[conn][%p] ERROR, %s.",
Connection,
"Datagram send while disabled");
// arg2 = arg2 = Connection = arg2
// arg3 = arg3 = "Datagram send while disabled" = arg3
----------------------------------------------------------*/
#ifndef _clog_4_ARGS_TRACE_ConnError
#define _clog_4_ARGS_TRACE_ConnError(uniqueId, encoded_arg_string, arg2, arg3)\
tracepoint(CLOG_DATAGRAM_C, ConnError , arg2, arg3);\
#endif
/*----------------------------------------------------------
// Decoder Ring for AllocFailure
// Allocation of '%s' failed. (%llu bytes)
// QuicTraceEvent(
AllocFailure,
"Allocation of '%s' failed. (%llu bytes)",
"DATAGRAM_SEND operation",
0);
// arg2 = arg2 = "DATAGRAM_SEND operation" = arg2
// arg3 = arg3 = 0 = arg3
----------------------------------------------------------*/
#ifndef _clog_4_ARGS_TRACE_AllocFailure
#define _clog_4_ARGS_TRACE_AllocFailure(uniqueId, encoded_arg_string, arg2, arg3)\
tracepoint(CLOG_DATAGRAM_C, AllocFailure , arg2, arg3);\
#endif
#ifdef __cplusplus
}
#endif
#ifdef CLOG_INLINE_IMPLEMENTATION
#include "quic.clog_datagram.c.clog.h.c"
#endif
|
f4ef3a5d9b689e593daf6ce2699e9d8977271cae
|
e65a4dbfbfb0e54e59787ba7741efee12f7687f3
|
/sysutils/onefetch/files/patch-cargo-crates_libz-ng-sys-1.1.8_src_zlib-ng_arch_power_chunkset__power8.c
|
8f8a5c324897beff7d835d9cf18072b68465abb8
|
[
"BSD-2-Clause"
] |
permissive
|
freebsd/freebsd-ports
|
86f2e89d43913412c4f6b2be3e255bc0945eac12
|
605a2983f245ac63f5420e023e7dce56898ad801
|
refs/heads/main
| 2023-08-30T21:46:28.720924
| 2023-08-30T19:33:44
| 2023-08-30T19:33:44
| 1,803,961
| 916
| 918
|
NOASSERTION
| 2023-09-08T04:06:26
| 2011-05-26T11:15:35
| null |
UTF-8
|
C
| false
| false
| 458
|
c
|
patch-cargo-crates_libz-ng-sys-1.1.8_src_zlib-ng_arch_power_chunkset__power8.c
|
--- cargo-crates/libz-ng-sys-1.1.8/src/zlib-ng/arch/power/chunkset_power8.c.orig 2022-12-29 16:08:43 UTC
+++ cargo-crates/libz-ng-sys-1.1.8/src/zlib-ng/arch/power/chunkset_power8.c
@@ -27,7 +27,7 @@ static inline void chunkmemset_4(uint8_t *from, chunk_
}
static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
- uint64_t tmp;
+ unsigned long long tmp;
zmemcpy_8(&tmp, from);
*chunk = (vector unsigned char)vec_splats(tmp);
}
|
0981dcd03de32ed2f131d2c85b03314cd3b4dd7b
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/u-boot_new/arch/arm/include/asm/arch-spear/hardware.h
|
c6da405cc07a6fafe346999321187837ee2eaf34
|
[
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"GPL-2.0-or-later"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 2,058
|
h
|
hardware.h
|
/*
* (C) Copyright 2009
* Vipin Kumar, STMicroelectronics, <vipin.kumar@st.com>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef _ASM_ARCH_HARDWARE_H
#define _ASM_ARCH_HARDWARE_H
#define CONFIG_SYS_USBD_BASE 0xE1100000
#define CONFIG_SYS_PLUG_BASE 0xE1200000
#define CONFIG_SYS_FIFO_BASE 0xE1000800
#define CONFIG_SYS_SMI_BASE 0xFC000000
#define CONFIG_SPEAR_SYSCNTLBASE 0xFCA00000
#define CONFIG_SPEAR_TIMERBASE 0xFC800000
#define CONFIG_SPEAR_MISCBASE 0xFCA80000
#define CONFIG_SPEAR_ETHBASE 0xE0800000
#define CONFIG_SPEAR_MPMCBASE 0xFC600000
#define CONFIG_SSP1_BASE 0xD0100000
#define CONFIG_SSP2_BASE 0xD0180000
#define CONFIG_SSP3_BASE 0xD8180000
#define CONFIG_GPIO_BASE 0xD8100000
#define CONFIG_SYS_NAND_CLE (1 << 16)
#define CONFIG_SYS_NAND_ALE (1 << 17)
#if defined(CONFIG_SPEAR600)
#define CONFIG_SYS_FSMC_BASE 0xD1800000
#define CONFIG_FSMC_NAND_BASE 0xD2000000
#define CONFIG_SPEAR_BOOTSTRAPCFG 0xFCA80000
#define CONFIG_SPEAR_BOOTSTRAPSHFT 16
#define CONFIG_SPEAR_BOOTSTRAPMASK 0xB
#define CONFIG_SPEAR_ONLYSNORBOOT 0xA
#define CONFIG_SPEAR_NORNANDBOOT 0xB
#define CONFIG_SPEAR_NORNAND8BOOT 0x8
#define CONFIG_SPEAR_NORNAND16BOOT 0x9
#define CONFIG_SPEAR_USBBOOT 0x8
#define CONFIG_SPEAR_MPMCREGS 100
#elif defined(CONFIG_SPEAR300)
#define CONFIG_SYS_FSMC_BASE 0x94000000
#elif defined(CONFIG_SPEAR310)
#define CONFIG_SYS_FSMC_BASE 0x44000000
#undef CONFIG_SYS_NAND_CLE
#undef CONFIG_SYS_NAND_ALE
#define CONFIG_SYS_NAND_CLE (1 << 17)
#define CONFIG_SYS_NAND_ALE (1 << 16)
#define CONFIG_SPEAR_EMIBASE 0x4F000000
#define CONFIG_SPEAR_RASBASE 0xB4000000
#define CONFIG_SYS_MACB0_BASE 0xB0000000
#define CONFIG_SYS_MACB1_BASE 0xB0800000
#define CONFIG_SYS_MACB2_BASE 0xB1000000
#define CONFIG_SYS_MACB3_BASE 0xB1800000
#elif defined(CONFIG_SPEAR320)
#define CONFIG_SYS_FSMC_BASE 0x4C000000
#define CONFIG_SPEAR_EMIBASE 0x40000000
#define CONFIG_SPEAR_RASBASE 0xB3000000
#define CONFIG_SYS_MACB0_BASE 0xAA000000
#endif
#endif /* _ASM_ARCH_HARDWARE_H */
|
ae1070234ac7d818a17aff8d9ca34b8e516486d5
|
59864cbd213b5da6f50d6255b0a021564b3d5bd4
|
/disabled-challenges/CAT/src/switch.c
|
d3eb411261ac35db7b50b9a57fd70cd969c809df
|
[
"MIT"
] |
permissive
|
trailofbits/cb-multios
|
8af96a4fbc3b34644367faa135347f88e0e0d0a3
|
810d7b24b1f62f56ef49b148fe155b0d0629cad2
|
refs/heads/master
| 2023-09-05T03:56:20.229403
| 2022-12-27T15:47:54
| 2022-12-27T15:47:54
| 41,688,943
| 522
| 133
|
MIT
| 2023-06-29T02:47:13
| 2015-08-31T17:04:31
|
C
|
UTF-8
|
C
| false
| false
| 673,011
|
c
|
switch.c
|
/*
* Copyright (C) Narf Industries <info@narfindustries.com>
*
* 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.
*/
#include "cgc_static.h"
cgc_size_t cgc_static_switch(cgc_size_t idx) {
switch (idx) {
case 0x00000000:
return 0x2e4c7aa3;
case 0x00000004:
return 0xd37edee9;
case 0x00000008:
return 0x7289a220;
case 0x0000000c:
return 0x6a2ade8e;
case 0x00000010:
return 0x04c90bb1;
case 0x00000014:
return 0x4fe78602;
case 0x00000018:
return 0xd2a992a6;
case 0x0000001c:
return 0xa33b6316;
case 0x00000020:
return 0x7b86672f;
case 0x00000024:
return 0xb449d0ea;
case 0x00000028:
return 0x6a428bac;
case 0x0000002c:
return 0xfd37eb51;
case 0x00000030:
return 0xa53bebed;
case 0x00000034:
return 0x34140218;
case 0x00000038:
return 0x97457f6f;
case 0x0000003c:
return 0x7753c77d;
case 0x00000040:
return 0xf9ca3abc;
case 0x00000044:
return 0x95b0366c;
case 0x00000048:
return 0x8ce80c56;
case 0x0000004c:
return 0x0a22c174;
case 0x00000050:
return 0xf7706f63;
case 0x00000054:
return 0xd5014cb5;
case 0x00000058:
return 0x516352b1;
case 0x0000005c:
return 0x911ad6ed;
case 0x00000060:
return 0x58aacd30;
case 0x00000064:
return 0x0f557caa;
case 0x00000068:
return 0x3e4171fc;
case 0x0000006c:
return 0x3a210a11;
case 0x00000070:
return 0x64c04c4b;
case 0x00000074:
return 0xfbcfe354;
case 0x00000078:
return 0xb31d2f23;
case 0x0000007c:
return 0x99c00b79;
case 0x00000080:
return 0x71702cfa;
case 0x00000084:
return 0xd3f1f3a0;
case 0x00000088:
return 0xadef0eac;
case 0x0000008c:
return 0x5a3b6b3b;
case 0x00000090:
return 0x2ceb8f6a;
case 0x00000094:
return 0xd79c09a1;
case 0x00000098:
return 0xc8a4409f;
case 0x0000009c:
return 0xde739920;
case 0x000000a0:
return 0xfe1b258c;
case 0x000000a4:
return 0xdc35dffa;
case 0x000000a8:
return 0x49208171;
case 0x000000ac:
return 0x4099bbe5;
case 0x000000b0:
return 0x46adb084;
case 0x000000b4:
return 0x3bddcb53;
case 0x000000b8:
return 0x9e646ae6;
case 0x000000bc:
return 0x32a5ab49;
case 0x000000c0:
return 0xd92d4346;
case 0x000000c4:
return 0xb1e7a460;
case 0x000000c8:
return 0x11859963;
case 0x000000cc:
return 0x0e5930b9;
case 0x000000d0:
return 0xf85d3d8b;
case 0x000000d4:
return 0x97c84d66;
case 0x000000d8:
return 0x558c12f9;
case 0x000000dc:
return 0x784cb173;
case 0x000000e0:
return 0x2adaa510;
case 0x000000e4:
return 0x7306837b;
case 0x000000e8:
return 0xc1923b6b;
case 0x000000ec:
return 0x7ddb1fb1;
case 0x000000f0:
return 0x2bc5967a;
case 0x000000f4:
return 0x93d9e052;
case 0x000000f8:
return 0x41eba87b;
case 0x000000fc:
return 0xbbec6f81;
case 0x00000100:
return 0x49b65b16;
case 0x00000104:
return 0x908a5345;
case 0x00000108:
return 0x5a80aac0;
case 0x0000010c:
return 0xf7f95ecf;
case 0x00000110:
return 0x8af42564;
case 0x00000114:
return 0xd4b0ce48;
case 0x00000118:
return 0x4d5d6f62;
case 0x0000011c:
return 0xdc79bcf7;
case 0x00000120:
return 0x0fa22883;
case 0x00000124:
return 0x7f578e78;
case 0x00000128:
return 0x9add2a57;
case 0x0000012c:
return 0x0f36e9e7;
case 0x00000130:
return 0x899eff72;
case 0x00000134:
return 0x8962edf6;
case 0x00000138:
return 0x20c9216f;
case 0x0000013c:
return 0xa6c0b44a;
case 0x00000140:
return 0x5b1ed0b8;
case 0x00000144:
return 0xb5677758;
case 0x00000148:
return 0xd2828710;
case 0x0000014c:
return 0x4ae8497b;
case 0x00000150:
return 0xf7ecccbb;
case 0x00000154:
return 0x1804d6d7;
case 0x00000158:
return 0x61af5489;
case 0x0000015c:
return 0xc28243ca;
case 0x00000160:
return 0x1826d065;
case 0x00000164:
return 0xd8eba2ba;
case 0x00000168:
return 0x702dfaef;
case 0x0000016c:
return 0x2313b2dd;
case 0x00000170:
return 0x825f6436;
case 0x00000174:
return 0x23df238b;
case 0x00000178:
return 0xcd21a278;
case 0x0000017c:
return 0x997a1459;
case 0x00000180:
return 0xb70fb6b7;
case 0x00000184:
return 0xf1832d0d;
case 0x00000188:
return 0xd8a2fc99;
case 0x0000018c:
return 0x02ccefed;
case 0x00000190:
return 0xb8b46fe1;
case 0x00000194:
return 0xaaca685a;
case 0x00000198:
return 0x27706707;
case 0x0000019c:
return 0xd8b7c847;
case 0x000001a0:
return 0xc33b5305;
case 0x000001a4:
return 0xf23d3a57;
case 0x000001a8:
return 0xe41d5fad;
case 0x000001ac:
return 0x22068211;
case 0x000001b0:
return 0x3616091f;
case 0x000001b4:
return 0x545abd8d;
case 0x000001b8:
return 0xdbe9eaf7;
case 0x000001bc:
return 0x0d448deb;
case 0x000001c0:
return 0xe99fcee2;
case 0x000001c4:
return 0x3994c807;
case 0x000001c8:
return 0x70810e6c;
case 0x000001cc:
return 0x1e1927cc;
case 0x000001d0:
return 0x2df513cb;
case 0x000001d4:
return 0x3c0560aa;
case 0x000001d8:
return 0x715e62ec;
case 0x000001dc:
return 0x3170a259;
case 0x000001e0:
return 0xa185d439;
case 0x000001e4:
return 0xa541ea0e;
case 0x000001e8:
return 0xd0985534;
case 0x000001ec:
return 0xd37de58b;
case 0x000001f0:
return 0x7077d607;
case 0x000001f4:
return 0xcceed1b0;
case 0x000001f8:
return 0xb62d0a50;
case 0x000001fc:
return 0x53659a88;
case 0x00000200:
return 0xcd21c50a;
case 0x00000204:
return 0xd5b93faf;
case 0x00000208:
return 0x79628a99;
case 0x0000020c:
return 0x62321ffa;
case 0x00000210:
return 0x50a416af;
case 0x00000214:
return 0xdc1e1a12;
case 0x00000218:
return 0xe7e8ee3e;
case 0x0000021c:
return 0xbe8ff9b0;
case 0x00000220:
return 0x54a4f42c;
case 0x00000224:
return 0x99dc3497;
case 0x00000228:
return 0x507518f0;
case 0x0000022c:
return 0xdadcb2c2;
case 0x00000230:
return 0x7fe8f908;
case 0x00000234:
return 0xaa3cd055;
case 0x00000238:
return 0x45201d56;
case 0x0000023c:
return 0xad39babe;
case 0x00000240:
return 0xf7240b5f;
case 0x00000244:
return 0x822b00da;
case 0x00000248:
return 0x94b617cc;
case 0x0000024c:
return 0x0cff92ee;
case 0x00000250:
return 0x90768743;
case 0x00000254:
return 0x67a49268;
case 0x00000258:
return 0x34fa24f7;
case 0x0000025c:
return 0x643abeaf;
case 0x00000260:
return 0xbaa18c42;
case 0x00000264:
return 0x3de5fbc1;
case 0x00000268:
return 0x47465022;
case 0x0000026c:
return 0x77dd5c99;
case 0x00000270:
return 0x747df307;
case 0x00000274:
return 0xd666c6b3;
case 0x00000278:
return 0x3fe4587a;
case 0x0000027c:
return 0x7ee7cec7;
case 0x00000280:
return 0x9b383398;
case 0x00000284:
return 0x045606fa;
case 0x00000288:
return 0x5ba5a5a6;
case 0x0000028c:
return 0x457c8ddf;
case 0x00000290:
return 0x1872daa0;
case 0x00000294:
return 0xac4f23a7;
case 0x00000298:
return 0xe2d48a45;
case 0x0000029c:
return 0xc5ace788;
case 0x000002a0:
return 0xd5bbf858;
case 0x000002a4:
return 0x946b5882;
case 0x000002a8:
return 0x3ae77c27;
case 0x000002ac:
return 0x7c16cf4d;
case 0x000002b0:
return 0x51475153;
case 0x000002b4:
return 0x7f308d9d;
case 0x000002b8:
return 0x8f506214;
case 0x000002bc:
return 0xa0ad1eea;
case 0x000002c0:
return 0x08a2bb75;
case 0x000002c4:
return 0xcaf45c38;
case 0x000002c8:
return 0xf293a0ad;
case 0x000002cc:
return 0x727220c3;
case 0x000002d0:
return 0x17e6739e;
case 0x000002d4:
return 0x9c3b4743;
case 0x000002d8:
return 0x5b691f58;
case 0x000002dc:
return 0xd0ae79ba;
case 0x000002e0:
return 0x5ccbd5d5;
case 0x000002e4:
return 0xe8aa4375;
case 0x000002e8:
return 0xe18a5ba2;
case 0x000002ec:
return 0xe9b6e602;
case 0x000002f0:
return 0xc09ce3b9;
case 0x000002f4:
return 0x30745d58;
case 0x000002f8:
return 0x6390b788;
case 0x000002fc:
return 0x6b8eda72;
case 0x00000300:
return 0x9cde040e;
case 0x00000304:
return 0xeb8906b5;
case 0x00000308:
return 0x1368a7e5;
case 0x0000030c:
return 0x4f9d5882;
case 0x00000310:
return 0xa42e5939;
case 0x00000314:
return 0xddf4d331;
case 0x00000318:
return 0x466e708c;
case 0x0000031c:
return 0x0dfdc638;
case 0x00000320:
return 0xbd31aa05;
case 0x00000324:
return 0x5aaa3e23;
case 0x00000328:
return 0x5f8dcb2e;
case 0x0000032c:
return 0x5d786b4e;
case 0x00000330:
return 0x35018788;
case 0x00000334:
return 0xcf69b33b;
case 0x00000338:
return 0xb2bba39e;
case 0x0000033c:
return 0x282e9a54;
case 0x00000340:
return 0x7acd2079;
case 0x00000344:
return 0x545ef601;
case 0x00000348:
return 0x0cda4813;
case 0x0000034c:
return 0x95569757;
case 0x00000350:
return 0xb62bb38a;
case 0x00000354:
return 0xd9294855;
case 0x00000358:
return 0xc6683343;
case 0x0000035c:
return 0xe174ae58;
case 0x00000360:
return 0xeb003cb4;
case 0x00000364:
return 0xdedd43bd;
case 0x00000368:
return 0x6ab46545;
case 0x0000036c:
return 0x3eb6bc06;
case 0x00000370:
return 0x6016c6ac;
case 0x00000374:
return 0x9c33518a;
case 0x00000378:
return 0xa1a89c6d;
case 0x0000037c:
return 0xa09fc6f1;
case 0x00000380:
return 0x22b677d5;
case 0x00000384:
return 0xbc34031d;
case 0x00000388:
return 0x286648b9;
case 0x0000038c:
return 0xfc3e1ef9;
case 0x00000390:
return 0x97dc6a7b;
case 0x00000394:
return 0x20f0350a;
case 0x00000398:
return 0xb030cd6d;
case 0x0000039c:
return 0xa9b48b38;
case 0x000003a0:
return 0x05e6066a;
case 0x000003a4:
return 0x9d857a31;
case 0x000003a8:
return 0xa093d16c;
case 0x000003ac:
return 0x4976c76b;
case 0x000003b0:
return 0xd9769c53;
case 0x000003b4:
return 0x04010e92;
case 0x000003b8:
return 0x9cbe4779;
case 0x000003bc:
return 0xd5dec301;
case 0x000003c0:
return 0xce66a5a2;
case 0x000003c4:
return 0x10e88e46;
case 0x000003c8:
return 0xcee33982;
case 0x000003cc:
return 0xe16eb36d;
case 0x000003d0:
return 0xa79c3ff3;
case 0x000003d4:
return 0x7fc6c7e2;
case 0x000003d8:
return 0xbc70afe6;
case 0x000003dc:
return 0x0a81eea3;
case 0x000003e0:
return 0x8753350c;
case 0x000003e4:
return 0xc22b1356;
case 0x000003e8:
return 0x7ffe2c42;
case 0x000003ec:
return 0x7616c5c1;
case 0x000003f0:
return 0x6fff0d71;
case 0x000003f4:
return 0x4f245367;
case 0x000003f8:
return 0x227bd876;
case 0x000003fc:
return 0x369d398a;
case 0x00000400:
return 0x31722b03;
case 0x00000404:
return 0x230a4654;
case 0x00000408:
return 0x574d5103;
case 0x0000040c:
return 0x1bf36f81;
case 0x00000410:
return 0x76fb9944;
case 0x00000414:
return 0xd5aff4f6;
case 0x00000418:
return 0xa80f7e63;
case 0x0000041c:
return 0xea160381;
case 0x00000420:
return 0xcf22c9cb;
case 0x00000424:
return 0xd7406000;
case 0x00000428:
return 0xe99a5ff8;
case 0x0000042c:
return 0x28a60d3f;
case 0x00000430:
return 0x1f199439;
case 0x00000434:
return 0x43da96c2;
case 0x00000438:
return 0xa8861d84;
case 0x0000043c:
return 0x9bc4857d;
case 0x00000440:
return 0xee34617e;
case 0x00000444:
return 0xcf38e3e8;
case 0x00000448:
return 0xedc5f6fc;
case 0x0000044c:
return 0x214f3a62;
case 0x00000450:
return 0x7fca0a20;
case 0x00000454:
return 0x1e3adfcb;
case 0x00000458:
return 0x0973882c;
case 0x0000045c:
return 0xd451b3be;
case 0x00000460:
return 0x08be4d5d;
case 0x00000464:
return 0xb9c8e41c;
case 0x00000468:
return 0xd9311e65;
case 0x0000046c:
return 0xd95fd495;
case 0x00000470:
return 0x6f66a3bc;
case 0x00000474:
return 0x007f0a31;
case 0x00000478:
return 0xcd61bcb4;
case 0x0000047c:
return 0x1f589237;
case 0x00000480:
return 0x8376a336;
case 0x00000484:
return 0x1819b76e;
case 0x00000488:
return 0x84514a8c;
case 0x0000048c:
return 0xfc58e387;
case 0x00000490:
return 0xbaf4e4a2;
case 0x00000494:
return 0x4b3e6ec0;
case 0x00000498:
return 0xdb7123ee;
case 0x0000049c:
return 0xbf9101a3;
case 0x000004a0:
return 0x7dbd1f8b;
case 0x000004a4:
return 0x671b3d38;
case 0x000004a8:
return 0xa6d3155b;
case 0x000004ac:
return 0x911c6d08;
case 0x000004b0:
return 0x674253f3;
case 0x000004b4:
return 0x5eeb62f7;
case 0x000004b8:
return 0xdd4dc392;
case 0x000004bc:
return 0xdbf382ab;
case 0x000004c0:
return 0x27ed3dc0;
case 0x000004c4:
return 0x02655b6a;
case 0x000004c8:
return 0xa59d1360;
case 0x000004cc:
return 0x6bc4eff4;
case 0x000004d0:
return 0xdfedd926;
case 0x000004d4:
return 0x0a13847c;
case 0x000004d8:
return 0x64d589ad;
case 0x000004dc:
return 0x766376b9;
case 0x000004e0:
return 0xaf6170e8;
case 0x000004e4:
return 0x0116f56a;
case 0x000004e8:
return 0xe7448fe2;
case 0x000004ec:
return 0x11cd2609;
case 0x000004f0:
return 0x867e5821;
case 0x000004f4:
return 0x83816da1;
case 0x000004f8:
return 0x158f769a;
case 0x000004fc:
return 0x16d54f9b;
case 0x00000500:
return 0x816656e5;
case 0x00000504:
return 0x385304a4;
case 0x00000508:
return 0xcb2cb164;
case 0x0000050c:
return 0x6783eb4d;
case 0x00000510:
return 0x1cfc71de;
case 0x00000514:
return 0x34eb210d;
case 0x00000518:
return 0x5b8ca7ea;
case 0x0000051c:
return 0x3e38848d;
case 0x00000520:
return 0x19a01f82;
case 0x00000524:
return 0x047d21d4;
case 0x00000528:
return 0x43cebab7;
case 0x0000052c:
return 0xc1849da7;
case 0x00000530:
return 0x3665ab83;
case 0x00000534:
return 0x98b90539;
case 0x00000538:
return 0x743802d9;
case 0x0000053c:
return 0x3649584d;
case 0x00000540:
return 0xc3074e6c;
case 0x00000544:
return 0x117733b4;
case 0x00000548:
return 0x4cea85a5;
case 0x0000054c:
return 0x2b4cfbb2;
case 0x00000550:
return 0x312106f0;
case 0x00000554:
return 0xd9104c45;
case 0x00000558:
return 0x7ce40d3c;
case 0x0000055c:
return 0x3c4a7ac1;
case 0x00000560:
return 0x20bae962;
case 0x00000564:
return 0x44524f15;
case 0x00000568:
return 0x12b71e9d;
case 0x0000056c:
return 0xefbeefaf;
case 0x00000570:
return 0x71f1be0a;
case 0x00000574:
return 0xcd019c18;
case 0x00000578:
return 0xef89ddd4;
case 0x0000057c:
return 0x1aeaf29f;
case 0x00000580:
return 0x13522538;
case 0x00000584:
return 0x67f77e93;
case 0x00000588:
return 0x5ee62307;
case 0x0000058c:
return 0x9d666e16;
case 0x00000590:
return 0x98fb3a39;
case 0x00000594:
return 0xd28c1c2f;
case 0x00000598:
return 0x689db8b2;
case 0x0000059c:
return 0xee9bec45;
case 0x000005a0:
return 0x1bff3802;
case 0x000005a4:
return 0x6361a4c4;
case 0x000005a8:
return 0x4a20c195;
case 0x000005ac:
return 0x9f8f5803;
case 0x000005b0:
return 0xfd595100;
case 0x000005b4:
return 0x1743be85;
case 0x000005b8:
return 0x83396cf0;
case 0x000005bc:
return 0x29c8bea9;
case 0x000005c0:
return 0x71fbb284;
case 0x000005c4:
return 0xb64f067d;
case 0x000005c8:
return 0xb39599ee;
case 0x000005cc:
return 0x72cf3499;
case 0x000005d0:
return 0xd7ca17e5;
case 0x000005d4:
return 0x4331cdd5;
case 0x000005d8:
return 0x2e558d32;
case 0x000005dc:
return 0x8797d32a;
case 0x000005e0:
return 0x78c6e0dc;
case 0x000005e4:
return 0x6c5f56ad;
case 0x000005e8:
return 0xd95b1017;
case 0x000005ec:
return 0xae7e9a96;
case 0x000005f0:
return 0xa513e3be;
case 0x000005f4:
return 0x2d69be31;
case 0x000005f8:
return 0xed2b9882;
case 0x000005fc:
return 0xb1e151f7;
case 0x00000600:
return 0xfcc3614a;
case 0x00000604:
return 0x660716c1;
case 0x00000608:
return 0x6b444522;
case 0x0000060c:
return 0x3df3bb2b;
case 0x00000610:
return 0x1f36ef3d;
case 0x00000614:
return 0xa4edfd1e;
case 0x00000618:
return 0x856dbb23;
case 0x0000061c:
return 0xcc9cd245;
case 0x00000620:
return 0x3f8422e5;
case 0x00000624:
return 0xe2590b12;
case 0x00000628:
return 0x099c8479;
case 0x0000062c:
return 0xafee2c68;
case 0x00000630:
return 0xfbfe7f86;
case 0x00000634:
return 0x8c49360f;
case 0x00000638:
return 0x8f2137ff;
case 0x0000063c:
return 0x4e592828;
case 0x00000640:
return 0xc2668d3f;
case 0x00000644:
return 0xb87853d3;
case 0x00000648:
return 0x8ad8973b;
case 0x0000064c:
return 0xd3b92c68;
case 0x00000650:
return 0x835eadb5;
case 0x00000654:
return 0x900bbcaa;
case 0x00000658:
return 0xf79609e9;
case 0x0000065c:
return 0x3996f5d1;
case 0x00000660:
return 0x63250d09;
case 0x00000664:
return 0xc0da1c57;
case 0x00000668:
return 0x8f9c93ce;
case 0x0000066c:
return 0x2e270a76;
case 0x00000670:
return 0x04f95b46;
case 0x00000674:
return 0xe2866b7c;
case 0x00000678:
return 0x8296068b;
case 0x0000067c:
return 0x6f557790;
case 0x00000680:
return 0x03d8c609;
case 0x00000684:
return 0xcd177cbd;
case 0x00000688:
return 0x7ecca8ed;
case 0x0000068c:
return 0x29ca48a3;
case 0x00000690:
return 0xd0b858e4;
case 0x00000694:
return 0x5d73bf9b;
case 0x00000698:
return 0x4311a519;
case 0x0000069c:
return 0xc8fe3afa;
case 0x000006a0:
return 0x0c769abd;
case 0x000006a4:
return 0x30268d36;
case 0x000006a8:
return 0x362437ae;
case 0x000006ac:
return 0x3ed71d10;
case 0x000006b0:
return 0x13b962b3;
case 0x000006b4:
return 0xcb0f4ece;
case 0x000006b8:
return 0x87fe655d;
case 0x000006bc:
return 0x0bcdd68a;
case 0x000006c0:
return 0x4ee8e763;
case 0x000006c4:
return 0x1f41abb1;
case 0x000006c8:
return 0xc4324f4c;
case 0x000006cc:
return 0x9f6caeaf;
case 0x000006d0:
return 0xb93bcaa8;
case 0x000006d4:
return 0x77cf2c28;
case 0x000006d8:
return 0xe499c67f;
case 0x000006dc:
return 0xc7a2fadb;
case 0x000006e0:
return 0xd9acd823;
case 0x000006e4:
return 0x12b53770;
case 0x000006e8:
return 0xe506e29e;
case 0x000006ec:
return 0x6a326ed9;
case 0x000006f0:
return 0xd21fd235;
case 0x000006f4:
return 0xa891ce29;
case 0x000006f8:
return 0x9efa424b;
case 0x000006fc:
return 0xf2eb7872;
case 0x00000700:
return 0xefbfd0f4;
case 0x00000704:
return 0xcb0c730e;
case 0x00000708:
return 0x12e341e7;
case 0x0000070c:
return 0x109aab27;
case 0x00000710:
return 0x504a0a7e;
case 0x00000714:
return 0xb32c5f5e;
case 0x00000718:
return 0xbf12d08b;
case 0x0000071c:
return 0xe30b6c8b;
case 0x00000720:
return 0x704917ff;
case 0x00000724:
return 0x62392ac3;
case 0x00000728:
return 0x04802605;
case 0x0000072c:
return 0xd78b82f8;
case 0x00000730:
return 0xe4422eeb;
case 0x00000734:
return 0xc1ddc24e;
case 0x00000738:
return 0xcd1d9167;
case 0x0000073c:
return 0x70625a4e;
case 0x00000740:
return 0x1a79f7cc;
case 0x00000744:
return 0x85041258;
case 0x00000748:
return 0x5f4c8fd9;
case 0x0000074c:
return 0xd21c634a;
case 0x00000750:
return 0xaefe4599;
case 0x00000754:
return 0xca11d6fe;
case 0x00000758:
return 0xb161cfe4;
case 0x0000075c:
return 0xeb90a705;
case 0x00000760:
return 0x51ac10e8;
case 0x00000764:
return 0xa06fd61a;
case 0x00000768:
return 0x3019ebbd;
case 0x0000076c:
return 0xb5370d81;
case 0x00000770:
return 0x0a29c3fa;
case 0x00000774:
return 0xa81519f1;
case 0x00000778:
return 0x90382f0f;
case 0x0000077c:
return 0x1de0b571;
case 0x00000780:
return 0x8804d5b1;
case 0x00000784:
return 0x997ebaf1;
case 0x00000788:
return 0x1439377e;
case 0x0000078c:
return 0x4dc3cefc;
case 0x00000790:
return 0xe098ef40;
case 0x00000794:
return 0xb7677f02;
case 0x00000798:
return 0xc2c31efb;
case 0x0000079c:
return 0xe14ecee1;
case 0x000007a0:
return 0x31e3da24;
case 0x000007a4:
return 0x2976953e;
case 0x000007a8:
return 0x992a7e8a;
case 0x000007ac:
return 0x872cd221;
case 0x000007b0:
return 0xe24af11a;
case 0x000007b4:
return 0xacb03a83;
case 0x000007b8:
return 0x367b08fc;
case 0x000007bc:
return 0x7bea9fcf;
case 0x000007c0:
return 0x2f01b5af;
case 0x000007c4:
return 0x41a91169;
case 0x000007c8:
return 0xa57ea9e0;
case 0x000007cc:
return 0xe10971f4;
case 0x000007d0:
return 0x97252b11;
case 0x000007d4:
return 0xb9778d90;
case 0x000007d8:
return 0x5733c2f3;
case 0x000007dc:
return 0x353ea4c6;
case 0x000007e0:
return 0x78d23293;
case 0x000007e4:
return 0x11f693a1;
case 0x000007e8:
return 0x8d7ca9fa;
case 0x000007ec:
return 0xac898887;
case 0x000007f0:
return 0x6451e134;
case 0x000007f4:
return 0x594c390b;
case 0x000007f8:
return 0xdd6a1770;
case 0x000007fc:
return 0xbce97e8e;
case 0x00000800:
return 0x40d81098;
case 0x00000804:
return 0xaf2514bb;
case 0x00000808:
return 0xff768f83;
case 0x0000080c:
return 0x6272df80;
case 0x00000810:
return 0xc38fa403;
case 0x00000814:
return 0x92465d41;
case 0x00000818:
return 0x6aa1d9bb;
case 0x0000081c:
return 0x18575dea;
case 0x00000820:
return 0xeb6ecdd7;
case 0x00000824:
return 0xa590f647;
case 0x00000828:
return 0xb2cfbeb3;
case 0x0000082c:
return 0xba02148b;
case 0x00000830:
return 0x1fcb846b;
case 0x00000834:
return 0xad32e750;
case 0x00000838:
return 0xdf6f1f11;
case 0x0000083c:
return 0xf4bd371e;
case 0x00000840:
return 0xb25e526b;
case 0x00000844:
return 0xe7ff8bdc;
case 0x00000848:
return 0xc0ea9eb1;
case 0x0000084c:
return 0x0456dfa2;
case 0x00000850:
return 0x921fcd73;
case 0x00000854:
return 0xe073febf;
case 0x00000858:
return 0x077bd12c;
case 0x0000085c:
return 0xf7be70b4;
case 0x00000860:
return 0xae43ad10;
case 0x00000864:
return 0xf1a17347;
case 0x00000868:
return 0x20143ade;
case 0x0000086c:
return 0xb8c9aae0;
case 0x00000870:
return 0xc5f38c63;
case 0x00000874:
return 0x34aa0b4a;
case 0x00000878:
return 0x802f3839;
case 0x0000087c:
return 0x56c018c9;
case 0x00000880:
return 0xf362f6d6;
case 0x00000884:
return 0xc88080d5;
case 0x00000888:
return 0x61b5ce13;
case 0x0000088c:
return 0xa4f33dcf;
case 0x00000890:
return 0x98f44d1f;
case 0x00000894:
return 0xb2946dfd;
case 0x00000898:
return 0x4e78b143;
case 0x0000089c:
return 0x636d9573;
case 0x000008a0:
return 0xaf5918fe;
case 0x000008a4:
return 0x66b122a6;
case 0x000008a8:
return 0x72e3c931;
case 0x000008ac:
return 0x94932673;
case 0x000008b0:
return 0x2d725d30;
case 0x000008b4:
return 0x0e89c957;
case 0x000008b8:
return 0x28f4e151;
case 0x000008bc:
return 0x812ae341;
case 0x000008c0:
return 0xd301591f;
case 0x000008c4:
return 0x9803e3c2;
case 0x000008c8:
return 0x59aa471d;
case 0x000008cc:
return 0xbd14e878;
case 0x000008d0:
return 0xa405382e;
case 0x000008d4:
return 0x764c02c2;
case 0x000008d8:
return 0x9e84e249;
case 0x000008dc:
return 0xb8d090d1;
case 0x000008e0:
return 0xdadcaefc;
case 0x000008e4:
return 0x40ae25c0;
case 0x000008e8:
return 0x828fd3e7;
case 0x000008ec:
return 0xa7cdfe7c;
case 0x000008f0:
return 0xc59a3b01;
case 0x000008f4:
return 0xa1f7cc46;
case 0x000008f8:
return 0x69d0ef2f;
case 0x000008fc:
return 0x523558cf;
case 0x00000900:
return 0x256b5be0;
case 0x00000904:
return 0x786dfa6a;
case 0x00000908:
return 0x6f07eeda;
case 0x0000090c:
return 0x2b24d171;
case 0x00000910:
return 0x903710fd;
case 0x00000914:
return 0xe96cea9f;
case 0x00000918:
return 0x891092c7;
case 0x0000091c:
return 0xbea595d8;
case 0x00000920:
return 0xbef7f9a5;
case 0x00000924:
return 0x75a36948;
case 0x00000928:
return 0xb48e3bf0;
case 0x0000092c:
return 0x24130542;
case 0x00000930:
return 0xba9e2a27;
case 0x00000934:
return 0x1a3e9324;
case 0x00000938:
return 0xe671a899;
case 0x0000093c:
return 0x9f77cd8b;
case 0x00000940:
return 0x6ccfae07;
case 0x00000944:
return 0x64b16046;
case 0x00000948:
return 0x79b1b891;
case 0x0000094c:
return 0x89267f5c;
case 0x00000950:
return 0x16978ffe;
case 0x00000954:
return 0x3b713296;
case 0x00000958:
return 0x58245017;
case 0x0000095c:
return 0xc1061e60;
case 0x00000960:
return 0x33e3bf25;
case 0x00000964:
return 0x55cd80a4;
case 0x00000968:
return 0x884668ef;
case 0x0000096c:
return 0xeb0fa234;
case 0x00000970:
return 0x9aece0e4;
case 0x00000974:
return 0x741be27e;
case 0x00000978:
return 0xba98c6b1;
case 0x0000097c:
return 0xdb3ff86b;
case 0x00000980:
return 0xa8084f21;
case 0x00000984:
return 0x1d3a68ce;
case 0x00000988:
return 0x6d467e73;
case 0x0000098c:
return 0x123ae25b;
case 0x00000990:
return 0x356c7bce;
case 0x00000994:
return 0xd00df1cd;
case 0x00000998:
return 0xefe8341d;
case 0x0000099c:
return 0x55b15ac2;
case 0x000009a0:
return 0x8ab9623f;
case 0x000009a4:
return 0x426bc10b;
case 0x000009a8:
return 0xfc6f814b;
case 0x000009ac:
return 0x987fb615;
case 0x000009b0:
return 0xb7f1c817;
case 0x000009b4:
return 0x57275251;
case 0x000009b8:
return 0x0edb23fb;
case 0x000009bc:
return 0x92545ad4;
case 0x000009c0:
return 0xc6173614;
case 0x000009c4:
return 0x1720b77f;
case 0x000009c8:
return 0xd9b2616f;
case 0x000009cc:
return 0xaabc6a90;
case 0x000009d0:
return 0x14fc46a6;
case 0x000009d4:
return 0x73bf7964;
case 0x000009d8:
return 0x7e9b3beb;
case 0x000009dc:
return 0x6699bb0a;
case 0x000009e0:
return 0xa3829ecc;
case 0x000009e4:
return 0xffd6a9b1;
case 0x000009e8:
return 0xb774830f;
case 0x000009ec:
return 0x74d475a9;
case 0x000009f0:
return 0x434330ee;
case 0x000009f4:
return 0xce4302e2;
case 0x000009f8:
return 0xcbef6669;
case 0x000009fc:
return 0xfdb6d2b7;
case 0x00000a00:
return 0x349d45ec;
case 0x00000a04:
return 0x866babcf;
case 0x00000a08:
return 0x70a30eeb;
case 0x00000a0c:
return 0x0b1620dd;
case 0x00000a10:
return 0xbf2253d3;
case 0x00000a14:
return 0xd429e629;
case 0x00000a18:
return 0x12a3d20b;
case 0x00000a1c:
return 0x0350750b;
case 0x00000a20:
return 0x96886048;
case 0x00000a24:
return 0x06d37301;
case 0x00000a28:
return 0xa7f845a5;
case 0x00000a2c:
return 0x4b4f6490;
case 0x00000a30:
return 0xc386ba35;
case 0x00000a34:
return 0x29edbc97;
case 0x00000a38:
return 0x8026361b;
case 0x00000a3c:
return 0x2840fa69;
case 0x00000a40:
return 0x2e7bcdef;
case 0x00000a44:
return 0x51582ed8;
case 0x00000a48:
return 0x654fefc5;
case 0x00000a4c:
return 0x4dc905da;
case 0x00000a50:
return 0x3e5fd466;
case 0x00000a54:
return 0xa93c1575;
case 0x00000a58:
return 0xfa9c78e3;
case 0x00000a5c:
return 0xf44d9f4d;
case 0x00000a60:
return 0x5c3c259c;
case 0x00000a64:
return 0x101f0efa;
case 0x00000a68:
return 0xa910b56e;
case 0x00000a6c:
return 0x5f6f0891;
case 0x00000a70:
return 0x689e62cd;
case 0x00000a74:
return 0xb709034f;
case 0x00000a78:
return 0x61fd2ec1;
case 0x00000a7c:
return 0x1f877910;
case 0x00000a80:
return 0x9451b2ae;
case 0x00000a84:
return 0x8e00a242;
case 0x00000a88:
return 0xfc51f670;
case 0x00000a8c:
return 0x6f007e7b;
case 0x00000a90:
return 0x517cc2c5;
case 0x00000a94:
return 0x3168a44e;
case 0x00000a98:
return 0x9874b086;
case 0x00000a9c:
return 0x62d9c898;
case 0x00000aa0:
return 0xecbe05e6;
case 0x00000aa4:
return 0x8f6ccf40;
case 0x00000aa8:
return 0x6f94f3c8;
case 0x00000aac:
return 0x7cb94377;
case 0x00000ab0:
return 0x8beb0c79;
case 0x00000ab4:
return 0xf6af1ae0;
case 0x00000ab8:
return 0x7d9fc16b;
case 0x00000abc:
return 0x173a434b;
case 0x00000ac0:
return 0x21d27bfc;
case 0x00000ac4:
return 0x82aaba63;
case 0x00000ac8:
return 0x4f876b0c;
case 0x00000acc:
return 0xffacad40;
case 0x00000ad0:
return 0x7b47605c;
case 0x00000ad4:
return 0xddb1fdf4;
case 0x00000ad8:
return 0xdb1ec911;
case 0x00000adc:
return 0xfd14cff8;
case 0x00000ae0:
return 0x499fbb7a;
case 0x00000ae4:
return 0x987d4c12;
case 0x00000ae8:
return 0xc956dabf;
case 0x00000aec:
return 0x6caa72c0;
case 0x00000af0:
return 0x4ee5b8a2;
case 0x00000af4:
return 0xd956cb80;
case 0x00000af8:
return 0xf6f39b0c;
case 0x00000afc:
return 0x117be7ba;
case 0x00000b00:
return 0xa84c0d7b;
case 0x00000b04:
return 0x7c12ca49;
case 0x00000b08:
return 0x28a3fac3;
case 0x00000b0c:
return 0x38307587;
case 0x00000b10:
return 0x3ad206eb;
case 0x00000b14:
return 0xac39c551;
case 0x00000b18:
return 0xb258c1a7;
case 0x00000b1c:
return 0xbf74c2e7;
case 0x00000b20:
return 0xa2d8715d;
case 0x00000b24:
return 0x562c5a9d;
case 0x00000b28:
return 0x86476590;
case 0x00000b2c:
return 0xd339c70a;
case 0x00000b30:
return 0x824a2dab;
case 0x00000b34:
return 0x0fe979da;
case 0x00000b38:
return 0x59dbba4e;
case 0x00000b3c:
return 0xed9aab7c;
case 0x00000b40:
return 0x241c03df;
case 0x00000b44:
return 0x1fee51ec;
case 0x00000b48:
return 0x41ad039f;
case 0x00000b4c:
return 0x0880bd23;
case 0x00000b50:
return 0x8412f634;
case 0x00000b54:
return 0xb9702aa2;
case 0x00000b58:
return 0x39d12d8e;
case 0x00000b5c:
return 0xf36d7243;
case 0x00000b60:
return 0x91a52660;
case 0x00000b64:
return 0xd73f011b;
case 0x00000b68:
return 0x0572d550;
case 0x00000b6c:
return 0xefaae71a;
case 0x00000b70:
return 0x7329f656;
case 0x00000b74:
return 0x73722317;
case 0x00000b78:
return 0xd85593de;
case 0x00000b7c:
return 0xaf5e62bb;
case 0x00000b80:
return 0x9f0276f0;
case 0x00000b84:
return 0x11fc7421;
case 0x00000b88:
return 0xcb548fa8;
case 0x00000b8c:
return 0x0c899e04;
case 0x00000b90:
return 0x29d0d889;
case 0x00000b94:
return 0xe84a251d;
case 0x00000b98:
return 0x5611a378;
case 0x00000b9c:
return 0xa3d5f1b2;
case 0x00000ba0:
return 0xc388f5c6;
case 0x00000ba4:
return 0x918c698c;
case 0x00000ba8:
return 0x966030a1;
case 0x00000bac:
return 0x38379a59;
case 0x00000bb0:
return 0x4806a2bc;
case 0x00000bb4:
return 0x65547d47;
case 0x00000bb8:
return 0x3877bb87;
case 0x00000bbc:
return 0xfe5e7f59;
case 0x00000bc0:
return 0x92a8e7c0;
case 0x00000bc4:
return 0x11e79e88;
case 0x00000bc8:
return 0x1f825c96;
case 0x00000bcc:
return 0x8b2a424f;
case 0x00000bd0:
return 0xb2f8fbd5;
case 0x00000bd4:
return 0xe17c44bd;
case 0x00000bd8:
return 0x5595e095;
case 0x00000bdc:
return 0x14a304ee;
case 0x00000be0:
return 0xe036e7ba;
case 0x00000be4:
return 0xa32029d8;
case 0x00000be8:
return 0x478ce6cc;
case 0x00000bec:
return 0xc432c134;
case 0x00000bf0:
return 0x60a3f0d5;
case 0x00000bf4:
return 0xac5de5aa;
case 0x00000bf8:
return 0x83fae795;
case 0x00000bfc:
return 0xb05a2099;
case 0x00000c00:
return 0xa81ba6ff;
case 0x00000c04:
return 0x22063610;
case 0x00000c08:
return 0xf3ef0fab;
case 0x00000c0c:
return 0x20cd926f;
case 0x00000c10:
return 0x209c99d2;
case 0x00000c14:
return 0x66dfb6cb;
case 0x00000c18:
return 0x46d8cb09;
case 0x00000c1c:
return 0x2dc5ffcd;
case 0x00000c20:
return 0x79efec84;
case 0x00000c24:
return 0xd7af20e7;
case 0x00000c28:
return 0x94f40730;
case 0x00000c2c:
return 0x7f439cb9;
case 0x00000c30:
return 0x32833865;
case 0x00000c34:
return 0x4de11844;
case 0x00000c38:
return 0x4c27fef8;
case 0x00000c3c:
return 0x06f90193;
case 0x00000c40:
return 0xee8f7385;
case 0x00000c44:
return 0xe0ea8eaf;
case 0x00000c48:
return 0xb14a9f54;
case 0x00000c4c:
return 0x072ed944;
case 0x00000c50:
return 0xe6e799dc;
case 0x00000c54:
return 0xf594a8f9;
case 0x00000c58:
return 0x551cac72;
case 0x00000c5c:
return 0xdd08d4b5;
case 0x00000c60:
return 0xca59abad;
case 0x00000c64:
return 0x392fe5d9;
case 0x00000c68:
return 0x392f1c96;
case 0x00000c6c:
return 0x30c79903;
case 0x00000c70:
return 0xc20702b1;
case 0x00000c74:
return 0xcb5d8cb6;
case 0x00000c78:
return 0xf3675ace;
case 0x00000c7c:
return 0x09201eaa;
case 0x00000c80:
return 0x4226c78e;
case 0x00000c84:
return 0x96fa46fc;
case 0x00000c88:
return 0xcdbeb484;
case 0x00000c8c:
return 0xa15c0047;
case 0x00000c90:
return 0xe962e8e3;
case 0x00000c94:
return 0x58362bae;
case 0x00000c98:
return 0x48ead195;
case 0x00000c9c:
return 0xd5b8e9e0;
case 0x00000ca0:
return 0xbf7264d6;
case 0x00000ca4:
return 0x7d20796c;
case 0x00000ca8:
return 0x475dc949;
case 0x00000cac:
return 0x08a6adb0;
case 0x00000cb0:
return 0xcfc3eab9;
case 0x00000cb4:
return 0xc351af07;
case 0x00000cb8:
return 0xa6a61779;
case 0x00000cbc:
return 0x9d6f1082;
case 0x00000cc0:
return 0x20a5b675;
case 0x00000cc4:
return 0x399ebdb9;
case 0x00000cc8:
return 0xcb17e636;
case 0x00000ccc:
return 0x3acac1e1;
case 0x00000cd0:
return 0xfadda9f0;
case 0x00000cd4:
return 0x8e2da58f;
case 0x00000cd8:
return 0x01a3980a;
case 0x00000cdc:
return 0xc07846a2;
case 0x00000ce0:
return 0x9e16c65c;
case 0x00000ce4:
return 0x58519cf7;
case 0x00000ce8:
return 0xd16f9d24;
case 0x00000cec:
return 0x9cdde3f9;
case 0x00000cf0:
return 0x9244ba83;
case 0x00000cf4:
return 0x5fece937;
case 0x00000cf8:
return 0x0caa0c6b;
case 0x00000cfc:
return 0xb07c246b;
case 0x00000d00:
return 0xc71e22ba;
case 0x00000d04:
return 0x693a4b63;
case 0x00000d08:
return 0x2938abf0;
case 0x00000d0c:
return 0xf8760800;
case 0x00000d10:
return 0xda0dc4df;
case 0x00000d14:
return 0x63b74c04;
case 0x00000d18:
return 0xf5e10383;
case 0x00000d1c:
return 0x76f09641;
case 0x00000d20:
return 0x755ebcf3;
case 0x00000d24:
return 0xb2a64b07;
case 0x00000d28:
return 0x67b10efc;
case 0x00000d2c:
return 0xb5cfa629;
case 0x00000d30:
return 0xc7ad0562;
case 0x00000d34:
return 0x1498e04a;
case 0x00000d38:
return 0x20fe356f;
case 0x00000d3c:
return 0xbbd834e6;
case 0x00000d40:
return 0xb2b81494;
case 0x00000d44:
return 0x8a94a261;
case 0x00000d48:
return 0x55740c50;
case 0x00000d4c:
return 0x2a85f7bc;
case 0x00000d50:
return 0x644ed94e;
case 0x00000d54:
return 0x99819ea0;
case 0x00000d58:
return 0x1850c90b;
case 0x00000d5c:
return 0x6fd63367;
case 0x00000d60:
return 0xb4788199;
case 0x00000d64:
return 0x05ff39a3;
case 0x00000d68:
return 0xdb951642;
case 0x00000d6c:
return 0x2a2d88a5;
case 0x00000d70:
return 0xec6cf8f9;
case 0x00000d74:
return 0xb1b00655;
case 0x00000d78:
return 0xd7e9a4b7;
case 0x00000d7c:
return 0xe8e37870;
case 0x00000d80:
return 0x70c61419;
case 0x00000d84:
return 0xc22cc49f;
case 0x00000d88:
return 0x1b5200f0;
case 0x00000d8c:
return 0x8c142e62;
case 0x00000d90:
return 0x2d786f8a;
case 0x00000d94:
return 0x18e34618;
case 0x00000d98:
return 0xa2a0f764;
case 0x00000d9c:
return 0x1f22e22d;
case 0x00000da0:
return 0x0331001b;
case 0x00000da4:
return 0x23a8b3d0;
case 0x00000da8:
return 0x3ae1160b;
case 0x00000dac:
return 0x28db0864;
case 0x00000db0:
return 0x28b34520;
case 0x00000db4:
return 0x75414a1d;
case 0x00000db8:
return 0x7d8b0227;
case 0x00000dbc:
return 0x8e4ed47f;
case 0x00000dc0:
return 0x91e6f77e;
case 0x00000dc4:
return 0x098284c3;
case 0x00000dc8:
return 0x12d9ff6e;
case 0x00000dcc:
return 0xe7ab340e;
case 0x00000dd0:
return 0xcad735ed;
case 0x00000dd4:
return 0x3d329e37;
case 0x00000dd8:
return 0xa8ad09fd;
case 0x00000ddc:
return 0xeed53263;
case 0x00000de0:
return 0xc4321702;
case 0x00000de4:
return 0xb1b7ceb0;
case 0x00000de8:
return 0x53ec8ee9;
case 0x00000dec:
return 0x6137a2f4;
case 0x00000df0:
return 0xed1d79f0;
case 0x00000df4:
return 0x1f9987fe;
case 0x00000df8:
return 0xcc5fd818;
case 0x00000dfc:
return 0xa1090ee3;
case 0x00000e00:
return 0xe9e03b01;
case 0x00000e04:
return 0x53249711;
case 0x00000e08:
return 0xf39c3015;
case 0x00000e0c:
return 0x43c75671;
case 0x00000e10:
return 0x30953d19;
case 0x00000e14:
return 0xda4ac0e6;
case 0x00000e18:
return 0x48500c18;
case 0x00000e1c:
return 0xc4db4eab;
case 0x00000e20:
return 0xdebd03d1;
case 0x00000e24:
return 0xc4648e22;
case 0x00000e28:
return 0x53c1ce50;
case 0x00000e2c:
return 0x7df4c735;
case 0x00000e30:
return 0xde508c05;
case 0x00000e34:
return 0xb96a3c57;
case 0x00000e38:
return 0xba379c0e;
case 0x00000e3c:
return 0x8d4a939c;
case 0x00000e40:
return 0x9aff4fd2;
case 0x00000e44:
return 0xf93507aa;
case 0x00000e48:
return 0xa083a1bf;
case 0x00000e4c:
return 0xe0aceea5;
case 0x00000e50:
return 0x460e2c53;
case 0x00000e54:
return 0x59f163ad;
case 0x00000e58:
return 0x91297c03;
case 0x00000e5c:
return 0x723018c9;
case 0x00000e60:
return 0x75698f0e;
case 0x00000e64:
return 0x37953be8;
case 0x00000e68:
return 0xb4f89bef;
case 0x00000e6c:
return 0xe715c5b8;
case 0x00000e70:
return 0xbc3e1e3a;
case 0x00000e74:
return 0x110df66c;
case 0x00000e78:
return 0x17745b1a;
case 0x00000e7c:
return 0x71b18d34;
case 0x00000e80:
return 0x80ac9e59;
case 0x00000e84:
return 0x0be1f13d;
case 0x00000e88:
return 0xfdb4e308;
case 0x00000e8c:
return 0xce7e61c4;
case 0x00000e90:
return 0xe15a8a33;
case 0x00000e94:
return 0x8f6c5f99;
case 0x00000e98:
return 0x3af80e14;
case 0x00000e9c:
return 0x386a710f;
case 0x00000ea0:
return 0xf8055028;
case 0x00000ea4:
return 0x3c6c7835;
case 0x00000ea8:
return 0x23f72002;
case 0x00000eac:
return 0xda7429ee;
case 0x00000eb0:
return 0x907f2a76;
case 0x00000eb4:
return 0x8faa7e57;
case 0x00000eb8:
return 0xbb3a6351;
case 0x00000ebc:
return 0x56fdf4c5;
case 0x00000ec0:
return 0x267fb381;
case 0x00000ec4:
return 0x051bd61d;
case 0x00000ec8:
return 0xbf2a3338;
case 0x00000ecc:
return 0x1d902685;
case 0x00000ed0:
return 0x0fd36508;
case 0x00000ed4:
return 0x39d84911;
case 0x00000ed8:
return 0x43a04f29;
case 0x00000edc:
return 0x07024b60;
case 0x00000ee0:
return 0x8cfacdc6;
case 0x00000ee4:
return 0xb5dfde5e;
case 0x00000ee8:
return 0x7f4820dd;
case 0x00000eec:
return 0x6d991ffd;
case 0x00000ef0:
return 0xda00df6e;
case 0x00000ef4:
return 0xa30ff315;
case 0x00000ef8:
return 0x06191def;
case 0x00000efc:
return 0x4b31633d;
case 0x00000f00:
return 0x16bca03c;
case 0x00000f04:
return 0x8d04eab6;
case 0x00000f08:
return 0xdefa5826;
case 0x00000f0c:
return 0xcad8339e;
case 0x00000f10:
return 0x2fc31646;
case 0x00000f14:
return 0x09b29576;
case 0x00000f18:
return 0x807e1978;
case 0x00000f1c:
return 0xcb19d004;
case 0x00000f20:
return 0x02316870;
case 0x00000f24:
return 0x94dcff7f;
case 0x00000f28:
return 0xb9a2f9d4;
case 0x00000f2c:
return 0xe04da4e9;
case 0x00000f30:
return 0xbc93679a;
case 0x00000f34:
return 0x0763e42b;
case 0x00000f38:
return 0x6ee30063;
case 0x00000f3c:
return 0x2580b4d9;
case 0x00000f40:
return 0x9e605651;
case 0x00000f44:
return 0xf83c0615;
case 0x00000f48:
return 0xace85145;
case 0x00000f4c:
return 0xc19060c3;
case 0x00000f50:
return 0xb07ddb42;
case 0x00000f54:
return 0xbe3dbdad;
case 0x00000f58:
return 0x04dd3298;
case 0x00000f5c:
return 0x9e3ab3b4;
case 0x00000f60:
return 0xf85b9341;
case 0x00000f64:
return 0x213634b5;
case 0x00000f68:
return 0xe4a777f5;
case 0x00000f6c:
return 0xeb04fbc0;
case 0x00000f70:
return 0x362967d6;
case 0x00000f74:
return 0xc07ed720;
case 0x00000f78:
return 0xed3f8a7f;
case 0x00000f7c:
return 0x2332fba4;
case 0x00000f80:
return 0x0d19133a;
case 0x00000f84:
return 0xaf002947;
case 0x00000f88:
return 0xd83d0a7e;
case 0x00000f8c:
return 0xf6da6380;
case 0x00000f90:
return 0xc5f6c1a8;
case 0x00000f94:
return 0xf3dee287;
case 0x00000f98:
return 0xab4068e6;
case 0x00000f9c:
return 0x1a54571a;
case 0x00000fa0:
return 0xa1dbc631;
case 0x00000fa4:
return 0x5a095229;
case 0x00000fa8:
return 0xcc46fbdf;
case 0x00000fac:
return 0x689e3889;
case 0x00000fb0:
return 0xb617c8d2;
case 0x00000fb4:
return 0xf07d32b6;
case 0x00000fb8:
return 0xfbcc3130;
case 0x00000fbc:
return 0x2ebaa19d;
case 0x00000fc0:
return 0x72047fc4;
case 0x00000fc4:
return 0x461ca48a;
case 0x00000fc8:
return 0x4e2fb625;
case 0x00000fcc:
return 0xb3fbdf2c;
case 0x00000fd0:
return 0x73203744;
case 0x00000fd4:
return 0xd44269e8;
case 0x00000fd8:
return 0xf28afabf;
case 0x00000fdc:
return 0xfee80e82;
case 0x00000fe0:
return 0x72648d21;
case 0x00000fe4:
return 0x36e1bcbd;
case 0x00000fe8:
return 0x66a1eb9a;
case 0x00000fec:
return 0x82eae5c2;
case 0x00000ff0:
return 0x55a3cf67;
case 0x00000ff4:
return 0xfa46bb44;
case 0x00000ff8:
return 0x662bb76b;
case 0x00000ffc:
return 0xa07a591b;
case 0x00001000:
return 0xb015f920;
case 0x00001004:
return 0xd97a7332;
case 0x00001008:
return 0x29bd8548;
case 0x0000100c:
return 0x017f4cb0;
case 0x00001010:
return 0x644fbbbe;
case 0x00001014:
return 0x75e0bda8;
case 0x00001018:
return 0x6c348fe2;
case 0x0000101c:
return 0x836bbf11;
case 0x00001020:
return 0x1a39e2c3;
case 0x00001024:
return 0x2a2abfac;
case 0x00001028:
return 0x1e0804b1;
case 0x0000102c:
return 0xb1cae680;
case 0x00001030:
return 0x4dcb19e0;
case 0x00001034:
return 0x5d362122;
case 0x00001038:
return 0x8a87a169;
case 0x0000103c:
return 0x0d839f8a;
case 0x00001040:
return 0xb964edd4;
case 0x00001044:
return 0xd43f5d07;
case 0x00001048:
return 0x3b1edde8;
case 0x0000104c:
return 0x8d4835fc;
case 0x00001050:
return 0xa819976d;
case 0x00001054:
return 0x30ee15fb;
case 0x00001058:
return 0x7b3cb8b4;
case 0x0000105c:
return 0x5789cff5;
case 0x00001060:
return 0x0b3cfbc8;
case 0x00001064:
return 0xf9971e8f;
case 0x00001068:
return 0x41457946;
case 0x0000106c:
return 0x41699624;
case 0x00001070:
return 0x6fcffea2;
case 0x00001074:
return 0xab67e7bd;
case 0x00001078:
return 0x9c83f3fa;
case 0x0000107c:
return 0xb4978121;
case 0x00001080:
return 0xacd52eef;
case 0x00001084:
return 0xb3555711;
case 0x00001088:
return 0xf8053e7b;
case 0x0000108c:
return 0xbcf9e13e;
case 0x00001090:
return 0x11c47259;
case 0x00001094:
return 0x4f399788;
case 0x00001098:
return 0x9c66402b;
case 0x0000109c:
return 0x49be15ef;
case 0x000010a0:
return 0x55a8cef8;
case 0x000010a4:
return 0xc10e4b70;
case 0x000010a8:
return 0x3a21b78a;
case 0x000010ac:
return 0xf2526417;
case 0x000010b0:
return 0x63a96ca6;
case 0x000010b4:
return 0xfbced870;
case 0x000010b8:
return 0xe628885f;
case 0x000010bc:
return 0x4d7282a3;
case 0x000010c0:
return 0x61453d0e;
case 0x000010c4:
return 0x42d01827;
case 0x000010c8:
return 0xe7e1ff2b;
case 0x000010cc:
return 0x27ab355b;
case 0x000010d0:
return 0x8d4060f1;
case 0x000010d4:
return 0x69f50143;
case 0x000010d8:
return 0xa2723b61;
case 0x000010dc:
return 0xfa7cc03e;
case 0x000010e0:
return 0xc6ab7e4a;
case 0x000010e4:
return 0xa48fb1cf;
case 0x000010e8:
return 0x0817591a;
case 0x000010ec:
return 0x1f6f38ed;
case 0x000010f0:
return 0x682568c1;
case 0x000010f4:
return 0x32f231c6;
case 0x000010f8:
return 0x5aaeeeee;
case 0x000010fc:
return 0x9df04529;
case 0x00001100:
return 0x39d7f00d;
case 0x00001104:
return 0x250161eb;
case 0x00001108:
return 0x515e9042;
case 0x0000110c:
return 0x7728a634;
case 0x00001110:
return 0xd71f8244;
case 0x00001114:
return 0x9f23a72c;
case 0x00001118:
return 0x1c694ee6;
case 0x0000111c:
return 0xe0dfb293;
case 0x00001120:
return 0xa98e84fd;
case 0x00001124:
return 0x3e16c299;
case 0x00001128:
return 0x51f25475;
case 0x0000112c:
return 0xbccf52af;
case 0x00001130:
return 0x4ca01b46;
case 0x00001134:
return 0x8753b2d8;
case 0x00001138:
return 0x893d97ff;
case 0x0000113c:
return 0x6e48d072;
case 0x00001140:
return 0xd729d317;
case 0x00001144:
return 0xdfc37d8b;
case 0x00001148:
return 0xd521ea6f;
case 0x0000114c:
return 0x105d4044;
case 0x00001150:
return 0x2e83c728;
case 0x00001154:
return 0xc6c7e1e3;
case 0x00001158:
return 0xac896560;
case 0x0000115c:
return 0xfd24df0d;
case 0x00001160:
return 0x8a0f6619;
case 0x00001164:
return 0x51471528;
case 0x00001168:
return 0x97234085;
case 0x0000116c:
return 0xe6d1b30c;
case 0x00001170:
return 0x260b1d4e;
case 0x00001174:
return 0x93b91289;
case 0x00001178:
return 0xd9f02a9c;
case 0x0000117c:
return 0x58e4d34d;
case 0x00001180:
return 0x86c830e6;
case 0x00001184:
return 0xbed9d4ce;
case 0x00001188:
return 0x8a0f2c27;
case 0x0000118c:
return 0xff7a9e4e;
case 0x00001190:
return 0x58a0a134;
case 0x00001194:
return 0x3978e1b6;
case 0x00001198:
return 0xa0778481;
case 0x0000119c:
return 0xd68f86c2;
case 0x000011a0:
return 0x63272b7d;
case 0x000011a4:
return 0x2063b1e5;
case 0x000011a8:
return 0x7ea34d08;
case 0x000011ac:
return 0x3547094c;
case 0x000011b0:
return 0x7fc4f8dc;
case 0x000011b4:
return 0x3a62429a;
case 0x000011b8:
return 0xe55a48a0;
case 0x000011bc:
return 0xaaf56db0;
case 0x000011c0:
return 0x8afc08ac;
case 0x000011c4:
return 0xf599a482;
case 0x000011c8:
return 0x655c9be7;
case 0x000011cc:
return 0x70a478a8;
case 0x000011d0:
return 0x88bab894;
case 0x000011d4:
return 0x17fc7d2f;
case 0x000011d8:
return 0xb6eb98a1;
case 0x000011dc:
return 0x0e01664a;
case 0x000011e0:
return 0xa6093dfc;
case 0x000011e4:
return 0x5b2f35c0;
case 0x000011e8:
return 0x550a698e;
case 0x000011ec:
return 0x36ada8d5;
case 0x000011f0:
return 0x6c947bff;
case 0x000011f4:
return 0xf09950e8;
case 0x000011f8:
return 0x3fdde534;
case 0x000011fc:
return 0xb638064f;
case 0x00001200:
return 0x110d0a0a;
case 0x00001204:
return 0xdfa7018e;
case 0x00001208:
return 0x840ae92c;
case 0x0000120c:
return 0xd54435d4;
case 0x00001210:
return 0x91922f5b;
case 0x00001214:
return 0x85dfee16;
case 0x00001218:
return 0x9abc2060;
case 0x0000121c:
return 0x2197c077;
case 0x00001220:
return 0xaefe542e;
case 0x00001224:
return 0x52d41e6f;
case 0x00001228:
return 0xee9768d1;
case 0x0000122c:
return 0x1a6449a4;
case 0x00001230:
return 0xfa480a82;
case 0x00001234:
return 0x51ec5192;
case 0x00001238:
return 0xbed9ba9f;
case 0x0000123c:
return 0x9d766619;
case 0x00001240:
return 0x43fb3b7f;
case 0x00001244:
return 0xab18cd69;
case 0x00001248:
return 0x939b7848;
case 0x0000124c:
return 0x10a1723d;
case 0x00001250:
return 0xf5164f14;
case 0x00001254:
return 0xf9611215;
case 0x00001258:
return 0x1941c339;
case 0x0000125c:
return 0xa36474dc;
case 0x00001260:
return 0x931203a3;
case 0x00001264:
return 0xfec0f1c0;
case 0x00001268:
return 0xf25c59d1;
case 0x0000126c:
return 0xc0042bdb;
case 0x00001270:
return 0x6c5a65d5;
case 0x00001274:
return 0xc4e6fff5;
case 0x00001278:
return 0x1da570ee;
case 0x0000127c:
return 0x79ce6c4a;
case 0x00001280:
return 0xf55da09a;
case 0x00001284:
return 0x2bda32a2;
case 0x00001288:
return 0xbd4e19cd;
case 0x0000128c:
return 0x850372bb;
case 0x00001290:
return 0x2fcf0cee;
case 0x00001294:
return 0x4e028e41;
case 0x00001298:
return 0xbc8f4ea3;
case 0x0000129c:
return 0x86d1644f;
case 0x000012a0:
return 0x6d3ec9d6;
case 0x000012a4:
return 0x31b7cd33;
case 0x000012a8:
return 0x86e8f1c3;
case 0x000012ac:
return 0x6b58382c;
case 0x000012b0:
return 0x39c99096;
case 0x000012b4:
return 0xae1055e7;
case 0x000012b8:
return 0x0fb00988;
case 0x000012bc:
return 0x71fea087;
case 0x000012c0:
return 0x29abb7e6;
case 0x000012c4:
return 0x3d944197;
case 0x000012c8:
return 0xaca4b7fe;
case 0x000012cc:
return 0x66a6b296;
case 0x000012d0:
return 0xceb67250;
case 0x000012d4:
return 0x7611b033;
case 0x000012d8:
return 0x67a12652;
case 0x000012dc:
return 0x6c79b857;
case 0x000012e0:
return 0xb2d809bc;
case 0x000012e4:
return 0xb681b843;
case 0x000012e8:
return 0x15cd1579;
case 0x000012ec:
return 0xc033a36b;
case 0x000012f0:
return 0xc1de513d;
case 0x000012f4:
return 0x7e44e669;
case 0x000012f8:
return 0x2f9cfced;
case 0x000012fc:
return 0x27cc1a96;
case 0x00001300:
return 0x5af0fe88;
case 0x00001304:
return 0x1beeb564;
case 0x00001308:
return 0xf1c9df10;
case 0x0000130c:
return 0x89bea7ab;
case 0x00001310:
return 0xfc7cbae6;
case 0x00001314:
return 0x78067e3c;
case 0x00001318:
return 0x336a12a9;
case 0x0000131c:
return 0x66216789;
case 0x00001320:
return 0xddd23574;
case 0x00001324:
return 0x1fdfbd52;
case 0x00001328:
return 0x30ad53bf;
case 0x0000132c:
return 0x20f522f0;
case 0x00001330:
return 0x5ed012e2;
case 0x00001334:
return 0xbc8ad53e;
case 0x00001338:
return 0xf00fef77;
case 0x0000133c:
return 0x48559928;
case 0x00001340:
return 0x123fc33b;
case 0x00001344:
return 0x1ecd51f5;
case 0x00001348:
return 0x075dce6d;
case 0x0000134c:
return 0x0d73893c;
case 0x00001350:
return 0x1a816352;
case 0x00001354:
return 0xc782b94e;
case 0x00001358:
return 0x8341836c;
case 0x0000135c:
return 0x81edc656;
case 0x00001360:
return 0xbba47922;
case 0x00001364:
return 0x1e615bcd;
case 0x00001368:
return 0xbfd31f57;
case 0x0000136c:
return 0x0e536cf3;
case 0x00001370:
return 0xacf519c6;
case 0x00001374:
return 0xf8fab260;
case 0x00001378:
return 0x89eacce7;
case 0x0000137c:
return 0xc37886de;
case 0x00001380:
return 0x8c075317;
case 0x00001384:
return 0x47f99b2f;
case 0x00001388:
return 0x4a5c8820;
case 0x0000138c:
return 0x8f856ce2;
case 0x00001390:
return 0x1cfff49a;
case 0x00001394:
return 0x25dc2e0b;
case 0x00001398:
return 0xf95118d3;
case 0x0000139c:
return 0x0b3a1856;
case 0x000013a0:
return 0xa8e81b88;
case 0x000013a4:
return 0x50afa864;
case 0x000013a8:
return 0x97f98719;
case 0x000013ac:
return 0x5119dd12;
case 0x000013b0:
return 0x58ff6714;
case 0x000013b4:
return 0xfe64fe06;
case 0x000013b8:
return 0x48f1adc0;
case 0x000013bc:
return 0x6bfe18ec;
case 0x000013c0:
return 0x84715883;
case 0x000013c4:
return 0x2501b7b7;
case 0x000013c8:
return 0x678e5267;
case 0x000013cc:
return 0x2d6b28e4;
case 0x000013d0:
return 0x46f18db8;
case 0x000013d4:
return 0x731f6fb9;
case 0x000013d8:
return 0xc1394362;
case 0x000013dc:
return 0x231c0505;
case 0x000013e0:
return 0xd6925815;
case 0x000013e4:
return 0x4bc5c53c;
case 0x000013e8:
return 0x4a5c8a54;
case 0x000013ec:
return 0x3ce5c657;
case 0x000013f0:
return 0x498545ed;
case 0x000013f4:
return 0x443a093f;
case 0x000013f8:
return 0x06cff8ec;
case 0x000013fc:
return 0x5ef11884;
case 0x00001400:
return 0xd3ba0d31;
case 0x00001404:
return 0x61d33155;
case 0x00001408:
return 0x4a3aa3e2;
case 0x0000140c:
return 0x745763ac;
case 0x00001410:
return 0xc610dde3;
case 0x00001414:
return 0x6bfe8a85;
case 0x00001418:
return 0x18372343;
case 0x0000141c:
return 0x6501ac59;
case 0x00001420:
return 0x8e8ddd18;
case 0x00001424:
return 0x36d4db43;
case 0x00001428:
return 0x029fbc7c;
case 0x0000142c:
return 0x5d9b198a;
case 0x00001430:
return 0xbdbcb9ef;
case 0x00001434:
return 0xab11974a;
case 0x00001438:
return 0xffb3bc4c;
case 0x0000143c:
return 0x9935a12a;
case 0x00001440:
return 0x27c22321;
case 0x00001444:
return 0x8a9e2f66;
case 0x00001448:
return 0x9f071265;
case 0x0000144c:
return 0x516de2f2;
case 0x00001450:
return 0xf25a3ed6;
case 0x00001454:
return 0x4158b80a;
case 0x00001458:
return 0x7447edf0;
case 0x0000145c:
return 0x4b75bada;
case 0x00001460:
return 0xbc5b8e14;
case 0x00001464:
return 0x58f0ee80;
case 0x00001468:
return 0x14b575ec;
case 0x0000146c:
return 0x0dc1249b;
case 0x00001470:
return 0x14565e88;
case 0x00001474:
return 0xf4e6fa2a;
case 0x00001478:
return 0xde198c81;
case 0x0000147c:
return 0x67b33a54;
case 0x00001480:
return 0x983b33c7;
case 0x00001484:
return 0x8f8f81d0;
case 0x00001488:
return 0xdc96a6bc;
case 0x0000148c:
return 0xa63cc245;
case 0x00001490:
return 0x85a28dd6;
case 0x00001494:
return 0xa49c06d6;
case 0x00001498:
return 0x8f197153;
case 0x0000149c:
return 0x3ce09282;
case 0x000014a0:
return 0x835c3181;
case 0x000014a4:
return 0x2cfb9609;
case 0x000014a8:
return 0x555c596e;
case 0x000014ac:
return 0x704790bd;
case 0x000014b0:
return 0x22568245;
case 0x000014b4:
return 0x71c5ef4a;
case 0x000014b8:
return 0xbe547470;
case 0x000014bc:
return 0xa7ba9864;
case 0x000014c0:
return 0x6d156f5c;
case 0x000014c4:
return 0x9ff56c9d;
case 0x000014c8:
return 0x0e822075;
case 0x000014cc:
return 0x46e9c643;
case 0x000014d0:
return 0x9f4a397c;
case 0x000014d4:
return 0x7b8fba5a;
case 0x000014d8:
return 0x4b0bedea;
case 0x000014dc:
return 0xff7ad48c;
case 0x000014e0:
return 0xf921aa1c;
case 0x000014e4:
return 0x1b5971fb;
case 0x000014e8:
return 0xed2ec71a;
case 0x000014ec:
return 0xf7cdcfd1;
case 0x000014f0:
return 0xe3376fdb;
case 0x000014f4:
return 0xe377c5c4;
case 0x000014f8:
return 0x303391a0;
case 0x000014fc:
return 0x564752ff;
case 0x00001500:
return 0xa2f02fa8;
case 0x00001504:
return 0x9ae04766;
case 0x00001508:
return 0xae2263ac;
case 0x0000150c:
return 0x0784e029;
case 0x00001510:
return 0xab267b5a;
case 0x00001514:
return 0x808b209d;
case 0x00001518:
return 0x0ac85f6a;
case 0x0000151c:
return 0xd4178a11;
case 0x00001520:
return 0x7dea4c55;
case 0x00001524:
return 0xfd5d04e2;
case 0x00001528:
return 0xc5a54dc4;
case 0x0000152c:
return 0x51caa2e9;
case 0x00001530:
return 0x35bfc030;
case 0x00001534:
return 0xd80c236b;
case 0x00001538:
return 0x293db6e4;
case 0x0000153c:
return 0x75045416;
case 0x00001540:
return 0x09c7d1f4;
case 0x00001544:
return 0xfcbe357f;
case 0x00001548:
return 0x7ab01948;
case 0x0000154c:
return 0xcb0e2b34;
case 0x00001550:
return 0xef33a450;
case 0x00001554:
return 0xbd66b2a4;
case 0x00001558:
return 0x9813a42e;
case 0x0000155c:
return 0xdb3c72b3;
case 0x00001560:
return 0x426470b7;
case 0x00001564:
return 0x50c33e22;
case 0x00001568:
return 0x565b6975;
case 0x0000156c:
return 0xc534c6c4;
case 0x00001570:
return 0x780763ca;
case 0x00001574:
return 0x96b75d6b;
case 0x00001578:
return 0x2980147f;
case 0x0000157c:
return 0x9ecf52d2;
case 0x00001580:
return 0x6abde2da;
case 0x00001584:
return 0x040b9167;
case 0x00001588:
return 0x7cd7b93d;
case 0x0000158c:
return 0xd292a4f6;
case 0x00001590:
return 0x8cdb7ddf;
case 0x00001594:
return 0x1e5681a3;
case 0x00001598:
return 0xe639c6b7;
case 0x0000159c:
return 0x45c1d66d;
case 0x000015a0:
return 0xbe03e81b;
case 0x000015a4:
return 0x658f3def;
case 0x000015a8:
return 0x3a219775;
case 0x000015ac:
return 0x083cd326;
case 0x000015b0:
return 0x36380124;
case 0x000015b4:
return 0xd6d1f101;
case 0x000015b8:
return 0x26e1fb28;
case 0x000015bc:
return 0x4115cab1;
case 0x000015c0:
return 0x1430a27f;
case 0x000015c4:
return 0x57131433;
case 0x000015c8:
return 0x5208e297;
case 0x000015cc:
return 0x037da1ec;
case 0x000015d0:
return 0x96f6a6de;
case 0x000015d4:
return 0x0036483a;
case 0x000015d8:
return 0x02d10f28;
case 0x000015dc:
return 0x91ae389d;
case 0x000015e0:
return 0xcba91eca;
case 0x000015e4:
return 0x3831e704;
case 0x000015e8:
return 0xf4e571de;
case 0x000015ec:
return 0x1907ce72;
case 0x000015f0:
return 0x684c17d5;
case 0x000015f4:
return 0xd5f00a87;
case 0x000015f8:
return 0x161ab121;
case 0x000015fc:
return 0xeb7a4870;
case 0x00001600:
return 0xa20e7235;
case 0x00001604:
return 0x276519cb;
case 0x00001608:
return 0xb1bbd677;
case 0x0000160c:
return 0xc0d18b47;
case 0x00001610:
return 0x28583cda;
case 0x00001614:
return 0x2953327c;
case 0x00001618:
return 0x2074a162;
case 0x0000161c:
return 0x89ddb091;
case 0x00001620:
return 0xb7eac36f;
case 0x00001624:
return 0x38c11edf;
case 0x00001628:
return 0x62baf233;
case 0x0000162c:
return 0xb8f1407e;
case 0x00001630:
return 0x951a16d9;
case 0x00001634:
return 0x5552c0b2;
case 0x00001638:
return 0x98499826;
case 0x0000163c:
return 0x5603af9c;
case 0x00001640:
return 0x22db80ac;
case 0x00001644:
return 0xe25371eb;
case 0x00001648:
return 0x3290a832;
case 0x0000164c:
return 0x7bd18ab6;
case 0x00001650:
return 0xaa18e447;
case 0x00001654:
return 0x7f32bfc7;
case 0x00001658:
return 0x79b7b127;
case 0x0000165c:
return 0x4959e446;
case 0x00001660:
return 0xcdaf0f94;
case 0x00001664:
return 0xb204b4b1;
case 0x00001668:
return 0x502a7368;
case 0x0000166c:
return 0x4e330376;
case 0x00001670:
return 0x393007b4;
case 0x00001674:
return 0x01f8049a;
case 0x00001678:
return 0x3d5fe010;
case 0x0000167c:
return 0x8e69ac3f;
case 0x00001680:
return 0xe914859c;
case 0x00001684:
return 0x8af0df0a;
case 0x00001688:
return 0x72998a6d;
case 0x0000168c:
return 0x9621e3e4;
case 0x00001690:
return 0x54806591;
case 0x00001694:
return 0x4282694f;
case 0x00001698:
return 0x493204d7;
case 0x0000169c:
return 0x269c6ca6;
case 0x000016a0:
return 0x5e706ad1;
case 0x000016a4:
return 0x94d8f91f;
case 0x000016a8:
return 0xca09c083;
case 0x000016ac:
return 0xdbc8e0b3;
case 0x000016b0:
return 0xc682d182;
case 0x000016b4:
return 0x1eb75529;
case 0x000016b8:
return 0xe10058be;
case 0x000016bc:
return 0x4aee5078;
case 0x000016c0:
return 0x697bdd50;
case 0x000016c4:
return 0xd074009f;
case 0x000016c8:
return 0xf9327347;
case 0x000016cc:
return 0x2644c429;
case 0x000016d0:
return 0x82b3d55c;
case 0x000016d4:
return 0xad70d3c5;
case 0x000016d8:
return 0x0f8cf0f2;
case 0x000016dc:
return 0x5bb8cc59;
case 0x000016e0:
return 0xe837732d;
case 0x000016e4:
return 0x1d2f397c;
case 0x000016e8:
return 0xf7ac8f12;
case 0x000016ec:
return 0x6e8bae79;
case 0x000016f0:
return 0xc6fd8401;
case 0x000016f4:
return 0x3eb27862;
case 0x000016f8:
return 0x7592724d;
case 0x000016fc:
return 0x29fa5695;
case 0x00001700:
return 0xc67890ce;
case 0x00001704:
return 0xfb7f466d;
case 0x00001708:
return 0xe12eeff5;
case 0x0000170c:
return 0x5fd658e0;
case 0x00001710:
return 0x7c25e536;
case 0x00001714:
return 0x0f01263d;
case 0x00001718:
return 0x7cceaa11;
case 0x0000171c:
return 0x8c11aadb;
case 0x00001720:
return 0x69d32037;
case 0x00001724:
return 0xa77fb9c2;
case 0x00001728:
return 0xeda1317a;
case 0x0000172c:
return 0xf589d3b8;
case 0x00001730:
return 0x0868c4dd;
case 0x00001734:
return 0x96b1a2a3;
case 0x00001738:
return 0x05c56149;
case 0x0000173c:
return 0x3e347d5e;
case 0x00001740:
return 0x7b23a4fd;
case 0x00001744:
return 0xe00a58e7;
case 0x00001748:
return 0xcec94f47;
case 0x0000174c:
return 0x243fb0a8;
case 0x00001750:
return 0x060894f9;
case 0x00001754:
return 0x2cc575bd;
case 0x00001758:
return 0x885438b5;
case 0x0000175c:
return 0xfa852b0e;
case 0x00001760:
return 0x0cc0fb9a;
case 0x00001764:
return 0xac38b0ba;
case 0x00001768:
return 0xdaef85de;
case 0x0000176c:
return 0x7299bdbc;
case 0x00001770:
return 0x17728955;
case 0x00001774:
return 0x5e1b7319;
case 0x00001778:
return 0x11243e4c;
case 0x0000177c:
return 0xba56c31b;
case 0x00001780:
return 0xc648e894;
case 0x00001784:
return 0x81b05107;
case 0x00001788:
return 0xded3713b;
case 0x0000178c:
return 0xdbe9a524;
case 0x00001790:
return 0x2fe984d5;
case 0x00001794:
return 0x6e7b8c21;
case 0x00001798:
return 0xb26cf3c8;
case 0x0000179c:
return 0x56835e55;
case 0x000017a0:
return 0x243de6d3;
case 0x000017a4:
return 0xb6aaff49;
case 0x000017a8:
return 0x10974490;
case 0x000017ac:
return 0xbfc8e996;
case 0x000017b0:
return 0x19f4c2e9;
case 0x000017b4:
return 0x67e24888;
case 0x000017b8:
return 0xbbd7bc79;
case 0x000017bc:
return 0xabe3837c;
case 0x000017c0:
return 0xc5bcb850;
case 0x000017c4:
return 0xd512fd63;
case 0x000017c8:
return 0xe8b436f5;
case 0x000017cc:
return 0xafd57683;
case 0x000017d0:
return 0x066cecd8;
case 0x000017d4:
return 0xd5336f9c;
case 0x000017d8:
return 0xc2e348eb;
case 0x000017dc:
return 0x42a3d849;
case 0x000017e0:
return 0xfd6dd8c1;
case 0x000017e4:
return 0x958eb283;
case 0x000017e8:
return 0xcfce5365;
case 0x000017ec:
return 0x04254f12;
case 0x000017f0:
return 0xae167b37;
case 0x000017f4:
return 0x43109cce;
case 0x000017f8:
return 0x53eed7bc;
case 0x000017fc:
return 0xc57310a8;
case 0x00001800:
return 0x80bf6398;
case 0x00001804:
return 0xed5e1c81;
case 0x00001808:
return 0x876e51be;
case 0x0000180c:
return 0x91f9a167;
case 0x00001810:
return 0x08d2d23b;
case 0x00001814:
return 0x1a11f484;
case 0x00001818:
return 0x50a2a11d;
case 0x0000181c:
return 0x7ae56f10;
case 0x00001820:
return 0x6704de68;
case 0x00001824:
return 0xaf6966cc;
case 0x00001828:
return 0xcab0bdb7;
case 0x0000182c:
return 0x86a14580;
case 0x00001830:
return 0xa2e7abbb;
case 0x00001834:
return 0xd9e07794;
case 0x00001838:
return 0x1a1e6d23;
case 0x0000183c:
return 0x55b9045c;
case 0x00001840:
return 0x14a3675b;
case 0x00001844:
return 0x134b402a;
case 0x00001848:
return 0xe481399f;
case 0x0000184c:
return 0xfd8a4fa3;
case 0x00001850:
return 0x8b61d6c9;
case 0x00001854:
return 0xc34d647c;
case 0x00001858:
return 0x2d91261c;
case 0x0000185c:
return 0x80db38c3;
case 0x00001860:
return 0x2080179c;
case 0x00001864:
return 0x80ff0007;
case 0x00001868:
return 0xd065159c;
case 0x0000186c:
return 0xccd4b8d9;
case 0x00001870:
return 0x502a2551;
case 0x00001874:
return 0xfadf2fae;
case 0x00001878:
return 0x43b98030;
case 0x0000187c:
return 0x931422dc;
case 0x00001880:
return 0x474d08c7;
case 0x00001884:
return 0x85f13e30;
case 0x00001888:
return 0x8ab42665;
case 0x0000188c:
return 0xf30126ba;
case 0x00001890:
return 0xc82b884a;
case 0x00001894:
return 0x9895b94a;
case 0x00001898:
return 0xc7625e29;
case 0x0000189c:
return 0x74ec88e7;
case 0x000018a0:
return 0x51cd8916;
case 0x000018a4:
return 0x1bb1d196;
case 0x000018a8:
return 0x4d6c7df3;
case 0x000018ac:
return 0xb421312a;
case 0x000018b0:
return 0xf81f217a;
case 0x000018b4:
return 0x30fd2f38;
case 0x000018b8:
return 0x047ca46c;
case 0x000018bc:
return 0x20803834;
case 0x000018c0:
return 0x36e6238f;
case 0x000018c4:
return 0x7e821667;
case 0x000018c8:
return 0xf996c104;
case 0x000018cc:
return 0x8b9e71ee;
case 0x000018d0:
return 0x410e22e2;
case 0x000018d4:
return 0x08df3783;
case 0x000018d8:
return 0x257b3c9d;
case 0x000018dc:
return 0x2282fa3d;
case 0x000018e0:
return 0x5d7c312d;
case 0x000018e4:
return 0x599147d2;
case 0x000018e8:
return 0x169957d4;
case 0x000018ec:
return 0x38f985a1;
case 0x000018f0:
return 0x3a353b71;
case 0x000018f4:
return 0x6d1a235c;
case 0x000018f8:
return 0x6c49c073;
case 0x000018fc:
return 0x402e3e27;
case 0x00001900:
return 0x644e4620;
case 0x00001904:
return 0xcd4e22fe;
case 0x00001908:
return 0x15a3c14c;
case 0x0000190c:
return 0x8945e982;
case 0x00001910:
return 0xa341e336;
case 0x00001914:
return 0x025ac99a;
case 0x00001918:
return 0xfeb7225c;
case 0x0000191c:
return 0xcfeb3e51;
case 0x00001920:
return 0x36e35d92;
case 0x00001924:
return 0x14dd78d6;
case 0x00001928:
return 0x263eb519;
case 0x0000192c:
return 0xc52d8362;
case 0x00001930:
return 0x10aa855e;
case 0x00001934:
return 0xd48a9671;
case 0x00001938:
return 0x048343b5;
case 0x0000193c:
return 0x483fce35;
case 0x00001940:
return 0x3fa4d1fa;
case 0x00001944:
return 0x22ac7116;
case 0x00001948:
return 0xa629a30a;
case 0x0000194c:
return 0xb219715f;
case 0x00001950:
return 0xd42dbbf5;
case 0x00001954:
return 0x9f574c88;
case 0x00001958:
return 0x3ba4ff74;
case 0x0000195c:
return 0xb30084de;
case 0x00001960:
return 0x619842f8;
case 0x00001964:
return 0x9266448a;
case 0x00001968:
return 0xafa43816;
case 0x0000196c:
return 0x5afdbe33;
case 0x00001970:
return 0x95c82e7a;
case 0x00001974:
return 0xfa38adf6;
case 0x00001978:
return 0x05155484;
case 0x0000197c:
return 0x8b5faddb;
case 0x00001980:
return 0xdd06ad1d;
case 0x00001984:
return 0x28d38959;
case 0x00001988:
return 0x178f6ac3;
case 0x0000198c:
return 0x1b872525;
case 0x00001990:
return 0xaf368ac7;
case 0x00001994:
return 0xcac5b377;
case 0x00001998:
return 0xc231e12b;
case 0x0000199c:
return 0xadfd9c91;
case 0x000019a0:
return 0x89923199;
case 0x000019a4:
return 0xefb9755d;
case 0x000019a8:
return 0xd8b7e713;
case 0x000019ac:
return 0x7efc6c9d;
case 0x000019b0:
return 0x4c98762f;
case 0x000019b4:
return 0x700ac2eb;
case 0x000019b8:
return 0x47d9546f;
case 0x000019bc:
return 0x0588d490;
case 0x000019c0:
return 0xcc76525c;
case 0x000019c4:
return 0x5e63cedb;
case 0x000019c8:
return 0x9bcfc6dc;
case 0x000019cc:
return 0x5f3e8043;
case 0x000019d0:
return 0x512ec5f0;
case 0x000019d4:
return 0x87448eb4;
case 0x000019d8:
return 0x99be9867;
case 0x000019dc:
return 0x63e81976;
case 0x000019e0:
return 0x72716a1f;
case 0x000019e4:
return 0x127524e8;
case 0x000019e8:
return 0x435deaac;
case 0x000019ec:
return 0xd3cb23d4;
case 0x000019f0:
return 0x7a46b0d3;
case 0x000019f4:
return 0xdd52697f;
case 0x000019f8:
return 0x0a855888;
case 0x000019fc:
return 0x555ee98c;
case 0x00001a00:
return 0x30c7901b;
case 0x00001a04:
return 0x74f812a3;
case 0x00001a08:
return 0xcfc83f3d;
case 0x00001a0c:
return 0x6e587332;
case 0x00001a10:
return 0x19586d76;
case 0x00001a14:
return 0xa3c2b89d;
case 0x00001a18:
return 0xe393abaf;
case 0x00001a1c:
return 0xc7653347;
case 0x00001a20:
return 0xecbe370c;
case 0x00001a24:
return 0x810d72b2;
case 0x00001a28:
return 0x675ca055;
case 0x00001a2c:
return 0xff12dc6f;
case 0x00001a30:
return 0x5fea84f7;
case 0x00001a34:
return 0xf02d5a7f;
case 0x00001a38:
return 0x4e034bf7;
case 0x00001a3c:
return 0xb4f9b61f;
case 0x00001a40:
return 0xe619d58d;
case 0x00001a44:
return 0x94a4ec52;
case 0x00001a48:
return 0x6f620140;
case 0x00001a4c:
return 0xaa88b2e1;
case 0x00001a50:
return 0x43572327;
case 0x00001a54:
return 0x928fff75;
case 0x00001a58:
return 0xa19b69a3;
case 0x00001a5c:
return 0xbe657178;
case 0x00001a60:
return 0xa5724c88;
case 0x00001a64:
return 0x475b4b89;
case 0x00001a68:
return 0x6060a239;
case 0x00001a6c:
return 0x9acc79a6;
case 0x00001a70:
return 0x769e0d5d;
case 0x00001a74:
return 0x1f2380dd;
case 0x00001a78:
return 0x79973118;
case 0x00001a7c:
return 0x59d68c0f;
case 0x00001a80:
return 0x74f7b2be;
case 0x00001a84:
return 0x97886272;
case 0x00001a88:
return 0xbcd3de4c;
case 0x00001a8c:
return 0x2fd692fc;
case 0x00001a90:
return 0x4a596fe6;
case 0x00001a94:
return 0xec18ed6c;
case 0x00001a98:
return 0xa349c4fa;
case 0x00001a9c:
return 0x8a13dbae;
case 0x00001aa0:
return 0x881df5a4;
case 0x00001aa4:
return 0x3611197f;
case 0x00001aa8:
return 0x0b9a6d28;
case 0x00001aac:
return 0xc7329fb8;
case 0x00001ab0:
return 0xd9cc747c;
case 0x00001ab4:
return 0xd47886aa;
case 0x00001ab8:
return 0xda08425f;
case 0x00001abc:
return 0x7af522e4;
case 0x00001ac0:
return 0x08b52f88;
case 0x00001ac4:
return 0x92fa56c2;
case 0x00001ac8:
return 0x40217dd5;
case 0x00001acc:
return 0xc1fb14a7;
case 0x00001ad0:
return 0x0dd163e8;
case 0x00001ad4:
return 0xd6bcc22f;
case 0x00001ad8:
return 0xafe7ec81;
case 0x00001adc:
return 0xaa132b30;
case 0x00001ae0:
return 0xeed0a122;
case 0x00001ae4:
return 0x19a2b3d0;
case 0x00001ae8:
return 0x4c4ab31e;
case 0x00001aec:
return 0xd9e337e4;
case 0x00001af0:
return 0x3d4319fe;
case 0x00001af4:
return 0x3a275158;
case 0x00001af8:
return 0xa09a0b6f;
case 0x00001afc:
return 0x3a3291da;
case 0x00001b00:
return 0x5c1c375f;
case 0x00001b04:
return 0x6e90064d;
case 0x00001b08:
return 0x9e78549e;
case 0x00001b0c:
return 0x6ba49320;
case 0x00001b10:
return 0x623f7d97;
case 0x00001b14:
return 0x0b7c61ea;
case 0x00001b18:
return 0xd9741204;
case 0x00001b1c:
return 0x2dd99f8e;
case 0x00001b20:
return 0x4237449b;
case 0x00001b24:
return 0xb8f6eaa0;
case 0x00001b28:
return 0x71d850ff;
case 0x00001b2c:
return 0xb0d572c5;
case 0x00001b30:
return 0x40b2bf2a;
case 0x00001b34:
return 0x8fa97338;
case 0x00001b38:
return 0xd34cc073;
case 0x00001b3c:
return 0x21408d69;
case 0x00001b40:
return 0x280535f4;
case 0x00001b44:
return 0x5af54b7e;
case 0x00001b48:
return 0xf408410c;
case 0x00001b4c:
return 0xd73ee1d9;
case 0x00001b50:
return 0xbd803a3b;
case 0x00001b54:
return 0x7a6ba32d;
case 0x00001b58:
return 0xaad2d060;
case 0x00001b5c:
return 0xcd1031c6;
case 0x00001b60:
return 0x77049cd5;
case 0x00001b64:
return 0x4b4f3478;
case 0x00001b68:
return 0x0807103c;
case 0x00001b6c:
return 0x0f1f1d18;
case 0x00001b70:
return 0xab9cd293;
case 0x00001b74:
return 0x40a0036b;
case 0x00001b78:
return 0x026a35ed;
case 0x00001b7c:
return 0x337c1fbf;
case 0x00001b80:
return 0x5733b8fa;
case 0x00001b84:
return 0x4d7cf7d0;
case 0x00001b88:
return 0x59c17a24;
case 0x00001b8c:
return 0xc211c1e5;
case 0x00001b90:
return 0x72e9704e;
case 0x00001b94:
return 0xe8e22625;
case 0x00001b98:
return 0x8bdd25d4;
case 0x00001b9c:
return 0xcd96e869;
case 0x00001ba0:
return 0xce6b034c;
case 0x00001ba4:
return 0x8eb14266;
case 0x00001ba8:
return 0x79949131;
case 0x00001bac:
return 0x7e758faf;
case 0x00001bb0:
return 0x9850c9b6;
case 0x00001bb4:
return 0x263178fc;
case 0x00001bb8:
return 0xf09d6202;
case 0x00001bbc:
return 0x1f671be7;
case 0x00001bc0:
return 0x14ee1da4;
case 0x00001bc4:
return 0x0ce9b787;
case 0x00001bc8:
return 0xdb8f1dea;
case 0x00001bcc:
return 0xc2decd35;
case 0x00001bd0:
return 0x84fd0f03;
case 0x00001bd4:
return 0xc581f68f;
case 0x00001bd8:
return 0x84234678;
case 0x00001bdc:
return 0x29e411a2;
case 0x00001be0:
return 0xbfc0f5b9;
case 0x00001be4:
return 0xab965d82;
case 0x00001be8:
return 0x30f4b580;
case 0x00001bec:
return 0xb11c55a7;
case 0x00001bf0:
return 0xacfe24ba;
case 0x00001bf4:
return 0x81940922;
case 0x00001bf8:
return 0xd0e0dfa3;
case 0x00001bfc:
return 0x43116b21;
case 0x00001c00:
return 0x3eb17fd1;
case 0x00001c04:
return 0xa01ff740;
case 0x00001c08:
return 0x662e980c;
case 0x00001c0c:
return 0xfc7c410b;
case 0x00001c10:
return 0xcf666e46;
case 0x00001c14:
return 0xab30a6dc;
case 0x00001c18:
return 0x3c08c97c;
case 0x00001c1c:
return 0x7e052a29;
case 0x00001c20:
return 0x0dff586a;
case 0x00001c24:
return 0xdc1db7ca;
case 0x00001c28:
return 0xce465282;
case 0x00001c2c:
return 0x6347363b;
case 0x00001c30:
return 0x1a607687;
case 0x00001c34:
return 0xf9cf1f82;
case 0x00001c38:
return 0x4d3143d0;
case 0x00001c3c:
return 0x3a54222d;
case 0x00001c40:
return 0x10fc37a7;
case 0x00001c44:
return 0x5cd94709;
case 0x00001c48:
return 0xa05faed0;
case 0x00001c4c:
return 0xcc706944;
case 0x00001c50:
return 0x165e09ee;
case 0x00001c54:
return 0xca8b718e;
case 0x00001c58:
return 0x294189c7;
case 0x00001c5c:
return 0x07af19c5;
case 0x00001c60:
return 0x3d8b24ca;
case 0x00001c64:
return 0x7efbd5a6;
case 0x00001c68:
return 0xf65055c3;
case 0x00001c6c:
return 0x023a5958;
case 0x00001c70:
return 0x3694ef08;
case 0x00001c74:
return 0xc6dbd59f;
case 0x00001c78:
return 0xe3ae0e74;
case 0x00001c7c:
return 0x7084546c;
case 0x00001c80:
return 0x6a8653a4;
case 0x00001c84:
return 0xbdf46bae;
case 0x00001c88:
return 0x725693f0;
case 0x00001c8c:
return 0xbd1e183f;
case 0x00001c90:
return 0x99c48bcb;
case 0x00001c94:
return 0x8f455804;
case 0x00001c98:
return 0x837b322e;
case 0x00001c9c:
return 0x89e3a30d;
case 0x00001ca0:
return 0x7284165c;
case 0x00001ca4:
return 0x3cc8411f;
case 0x00001ca8:
return 0x660f0b68;
case 0x00001cac:
return 0x8458f286;
case 0x00001cb0:
return 0x2bda468b;
case 0x00001cb4:
return 0xe63e89a3;
case 0x00001cb8:
return 0x3c7f9d08;
case 0x00001cbc:
return 0x745509de;
case 0x00001cc0:
return 0xf765d5c4;
case 0x00001cc4:
return 0x27157d09;
case 0x00001cc8:
return 0x6224268b;
case 0x00001ccc:
return 0x553da3fd;
case 0x00001cd0:
return 0xaed37e0a;
case 0x00001cd4:
return 0xf99246fc;
case 0x00001cd8:
return 0xd4b007a4;
case 0x00001cdc:
return 0xdf0784ef;
case 0x00001ce0:
return 0x9d838d72;
case 0x00001ce4:
return 0x4bc4c3c4;
case 0x00001ce8:
return 0x0b4d4f97;
case 0x00001cec:
return 0x57b5133a;
case 0x00001cf0:
return 0x4834f286;
case 0x00001cf4:
return 0x017c80c9;
case 0x00001cf8:
return 0xe2dd4777;
case 0x00001cfc:
return 0x2072d520;
case 0x00001d00:
return 0x780245af;
case 0x00001d04:
return 0x01dba66a;
case 0x00001d08:
return 0x3789c412;
case 0x00001d0c:
return 0x6df5a31e;
case 0x00001d10:
return 0xb6a3660c;
case 0x00001d14:
return 0x630ba3db;
case 0x00001d18:
return 0xdf0b3150;
case 0x00001d1c:
return 0x6f115f90;
case 0x00001d20:
return 0x7106491c;
case 0x00001d24:
return 0x73f4aebd;
case 0x00001d28:
return 0x32a44299;
case 0x00001d2c:
return 0xe7499f35;
case 0x00001d30:
return 0xa97738d4;
case 0x00001d34:
return 0xd97acf3d;
case 0x00001d38:
return 0xb85c4132;
case 0x00001d3c:
return 0x35b68810;
case 0x00001d40:
return 0x1d311e91;
case 0x00001d44:
return 0x79d6eac2;
case 0x00001d48:
return 0xd3c7635d;
case 0x00001d4c:
return 0x2b51b1ff;
case 0x00001d50:
return 0x655003e9;
case 0x00001d54:
return 0x4b994d08;
case 0x00001d58:
return 0x02c81b99;
case 0x00001d5c:
return 0xf74c7fbf;
case 0x00001d60:
return 0xa58bf33e;
case 0x00001d64:
return 0xeb3ec477;
case 0x00001d68:
return 0x3e96a833;
case 0x00001d6c:
return 0x3820c83c;
case 0x00001d70:
return 0x28f325c1;
case 0x00001d74:
return 0xb3daf59f;
case 0x00001d78:
return 0x5c943985;
case 0x00001d7c:
return 0x35fb1973;
case 0x00001d80:
return 0xd1b59414;
case 0x00001d84:
return 0x9278554e;
case 0x00001d88:
return 0xdcd53d30;
case 0x00001d8c:
return 0x5332bdc8;
case 0x00001d90:
return 0xd4492845;
case 0x00001d94:
return 0x952ba332;
case 0x00001d98:
return 0x24773415;
case 0x00001d9c:
return 0x273deb70;
case 0x00001da0:
return 0x0af70055;
case 0x00001da4:
return 0x79947afe;
case 0x00001da8:
return 0x6aa0a348;
case 0x00001dac:
return 0x9682c579;
case 0x00001db0:
return 0x595c651d;
case 0x00001db4:
return 0xdb90e474;
case 0x00001db8:
return 0x25545cca;
case 0x00001dbc:
return 0x4869b217;
case 0x00001dc0:
return 0x2ab5cb97;
case 0x00001dc4:
return 0xee5a559b;
case 0x00001dc8:
return 0xaef60c53;
case 0x00001dcc:
return 0x645661de;
case 0x00001dd0:
return 0x800cfca7;
case 0x00001dd4:
return 0x5210acaf;
case 0x00001dd8:
return 0x409e9f66;
case 0x00001ddc:
return 0xe1de1997;
case 0x00001de0:
return 0x3594a8c2;
case 0x00001de4:
return 0x12f5cf40;
case 0x00001de8:
return 0x85c6f5a7;
case 0x00001dec:
return 0xecbebd50;
case 0x00001df0:
return 0x779d7ad3;
case 0x00001df4:
return 0x22f7030b;
case 0x00001df8:
return 0x1a9c8ed5;
case 0x00001dfc:
return 0x389f26bb;
case 0x00001e00:
return 0x1e7a0306;
case 0x00001e04:
return 0xf82292e1;
case 0x00001e08:
return 0x7e2bde1f;
case 0x00001e0c:
return 0x0aefb031;
case 0x00001e10:
return 0x32719b8a;
case 0x00001e14:
return 0x42470a66;
case 0x00001e18:
return 0x3160e049;
case 0x00001e1c:
return 0x4e93f853;
case 0x00001e20:
return 0xcf547e59;
case 0x00001e24:
return 0x9e6840aa;
case 0x00001e28:
return 0x9bf7c28b;
case 0x00001e2c:
return 0xb2ea0c78;
case 0x00001e30:
return 0x323afc4a;
case 0x00001e34:
return 0xce9e9e1a;
case 0x00001e38:
return 0xbea4659c;
case 0x00001e3c:
return 0x4b98cdf3;
case 0x00001e40:
return 0xe6470c9c;
case 0x00001e44:
return 0x16eaa018;
case 0x00001e48:
return 0xccdd9b1a;
case 0x00001e4c:
return 0x33b1891a;
case 0x00001e50:
return 0xd96969db;
case 0x00001e54:
return 0xe45b8e46;
case 0x00001e58:
return 0x0cd71815;
case 0x00001e5c:
return 0x416e549e;
case 0x00001e60:
return 0xa59c3e82;
case 0x00001e64:
return 0xced52907;
case 0x00001e68:
return 0x2b1ccd51;
case 0x00001e6c:
return 0xbed18022;
case 0x00001e70:
return 0xf2f1d21a;
case 0x00001e74:
return 0xb3a908e8;
case 0x00001e78:
return 0xaac2359e;
case 0x00001e7c:
return 0xf7fbf141;
case 0x00001e80:
return 0x0d55bd5d;
case 0x00001e84:
return 0x8358845f;
case 0x00001e88:
return 0x830101f2;
case 0x00001e8c:
return 0x8728c458;
case 0x00001e90:
return 0x284a49eb;
case 0x00001e94:
return 0x2586a64d;
case 0x00001e98:
return 0x7ee39c25;
case 0x00001e9c:
return 0xcaa0a3d2;
case 0x00001ea0:
return 0x71a3522e;
case 0x00001ea4:
return 0xc87d6c74;
case 0x00001ea8:
return 0x8ff35d0a;
case 0x00001eac:
return 0xdcf3ef55;
case 0x00001eb0:
return 0x5d8ccbf4;
case 0x00001eb4:
return 0xbbfcc5a3;
case 0x00001eb8:
return 0xc7f19f52;
case 0x00001ebc:
return 0xd19c3deb;
case 0x00001ec0:
return 0x9ab9818f;
case 0x00001ec4:
return 0x5383bcd5;
case 0x00001ec8:
return 0x5119a91e;
case 0x00001ecc:
return 0x1238d1ca;
case 0x00001ed0:
return 0x2c37bc2e;
case 0x00001ed4:
return 0xfe68c190;
case 0x00001ed8:
return 0x6d3233f4;
case 0x00001edc:
return 0xe87e886b;
case 0x00001ee0:
return 0x11d70234;
case 0x00001ee4:
return 0x928f1444;
case 0x00001ee8:
return 0x6922ced2;
case 0x00001eec:
return 0x24e09b90;
case 0x00001ef0:
return 0x64813c6e;
case 0x00001ef4:
return 0xb72578ca;
case 0x00001ef8:
return 0x2dab6776;
case 0x00001efc:
return 0x35de6079;
case 0x00001f00:
return 0x57faf561;
case 0x00001f04:
return 0xbddf68ab;
case 0x00001f08:
return 0xf49c0dec;
case 0x00001f0c:
return 0x9175740b;
case 0x00001f10:
return 0x4d5f5dfc;
case 0x00001f14:
return 0x80334fbf;
case 0x00001f18:
return 0xaeaaf441;
case 0x00001f1c:
return 0x1b5eb332;
case 0x00001f20:
return 0x2e02cb8b;
case 0x00001f24:
return 0x62e34bce;
case 0x00001f28:
return 0x5ed28dcc;
case 0x00001f2c:
return 0x2743f690;
case 0x00001f30:
return 0xdc99626a;
case 0x00001f34:
return 0x1ee05d49;
case 0x00001f38:
return 0xe8a24026;
case 0x00001f3c:
return 0x3d8d09b1;
case 0x00001f40:
return 0x07a10b9a;
case 0x00001f44:
return 0x355e45b0;
case 0x00001f48:
return 0x867a8120;
case 0x00001f4c:
return 0xaab7031f;
case 0x00001f50:
return 0xa47e1265;
case 0x00001f54:
return 0xfc2c14a3;
case 0x00001f58:
return 0x76e70293;
case 0x00001f5c:
return 0xa2e59952;
case 0x00001f60:
return 0xb2c68b09;
case 0x00001f64:
return 0x409fd0a9;
case 0x00001f68:
return 0x1723f06c;
case 0x00001f6c:
return 0x06b21fef;
case 0x00001f70:
return 0xb09c0afe;
case 0x00001f74:
return 0xaeed47cd;
case 0x00001f78:
return 0x497a7cee;
case 0x00001f7c:
return 0xdda7c48e;
case 0x00001f80:
return 0x1219860e;
case 0x00001f84:
return 0x90462039;
case 0x00001f88:
return 0xa3b40713;
case 0x00001f8c:
return 0x8d094739;
case 0x00001f90:
return 0x5965c456;
case 0x00001f94:
return 0x02aa1dd6;
case 0x00001f98:
return 0x5e8af4ed;
case 0x00001f9c:
return 0xd60981f5;
case 0x00001fa0:
return 0x90e397ce;
case 0x00001fa4:
return 0xcb16edeb;
case 0x00001fa8:
return 0xdcf89ba3;
case 0x00001fac:
return 0x7bef8777;
case 0x00001fb0:
return 0xb18a2740;
case 0x00001fb4:
return 0xb0e0c345;
case 0x00001fb8:
return 0xc0429f2b;
case 0x00001fbc:
return 0x0de405b5;
case 0x00001fc0:
return 0xd5965599;
case 0x00001fc4:
return 0x5556a5dd;
case 0x00001fc8:
return 0x5be97b33;
case 0x00001fcc:
return 0xec785007;
case 0x00001fd0:
return 0xe148e4d8;
case 0x00001fd4:
return 0xc34d92a1;
case 0x00001fd8:
return 0x23fcc811;
case 0x00001fdc:
return 0xc549c6a1;
case 0x00001fe0:
return 0x9a8de3b6;
case 0x00001fe4:
return 0xe1e9762d;
case 0x00001fe8:
return 0x95603643;
case 0x00001fec:
return 0x5b56aade;
case 0x00001ff0:
return 0xffe8abbe;
case 0x00001ff4:
return 0xa335bf0a;
case 0x00001ff8:
return 0x3a2479e1;
case 0x00001ffc:
return 0x0d8c906a;
case 0x00002000:
return 0x6df6ef57;
case 0x00002004:
return 0xa1b0b652;
case 0x00002008:
return 0xb8a8d582;
case 0x0000200c:
return 0xd7a0d5f0;
case 0x00002010:
return 0xd1602bf5;
case 0x00002014:
return 0x6a2aaec4;
case 0x00002018:
return 0x358189ce;
case 0x0000201c:
return 0x1468c676;
case 0x00002020:
return 0xffff5487;
case 0x00002024:
return 0x35452d5a;
case 0x00002028:
return 0xc96aaf14;
case 0x0000202c:
return 0xf2cd253a;
case 0x00002030:
return 0x5c3f5c0c;
case 0x00002034:
return 0x15459f56;
case 0x00002038:
return 0x6ab36b1d;
case 0x0000203c:
return 0x339e6b02;
case 0x00002040:
return 0x6f392da3;
case 0x00002044:
return 0xa9e2fba3;
case 0x00002048:
return 0x07c4d275;
case 0x0000204c:
return 0xac51cb1e;
case 0x00002050:
return 0x9a83f73e;
case 0x00002054:
return 0x12a9e7d6;
case 0x00002058:
return 0xdce0611d;
case 0x0000205c:
return 0x9c54c921;
case 0x00002060:
return 0x17acf323;
case 0x00002064:
return 0x268dad04;
case 0x00002068:
return 0x1cb5a325;
case 0x0000206c:
return 0xf2648952;
case 0x00002070:
return 0x0d0478b4;
case 0x00002074:
return 0x454edae0;
case 0x00002078:
return 0x7a4f544f;
case 0x0000207c:
return 0xe579028e;
case 0x00002080:
return 0x5040878a;
case 0x00002084:
return 0x9aca04b8;
case 0x00002088:
return 0x6ab9287b;
case 0x0000208c:
return 0x3d3324a3;
case 0x00002090:
return 0x60015bc0;
case 0x00002094:
return 0x821359a3;
case 0x00002098:
return 0x690706be;
case 0x0000209c:
return 0xa42204a3;
case 0x000020a0:
return 0x24351a60;
case 0x000020a4:
return 0xbeb14fb5;
case 0x000020a8:
return 0x60d612d8;
case 0x000020ac:
return 0xa3d52ca8;
case 0x000020b0:
return 0x9b1d3ade;
case 0x000020b4:
return 0xb523ed44;
case 0x000020b8:
return 0xba639ded;
case 0x000020bc:
return 0x90fd310e;
case 0x000020c0:
return 0xc6cf5abf;
case 0x000020c4:
return 0xbdbb46c8;
case 0x000020c8:
return 0x0b012987;
case 0x000020cc:
return 0xa359c52f;
case 0x000020d0:
return 0x51fd8344;
case 0x000020d4:
return 0xe066f8aa;
case 0x000020d8:
return 0xdc6f6078;
case 0x000020dc:
return 0xbd950ea1;
case 0x000020e0:
return 0xde9aa7f9;
case 0x000020e4:
return 0xb57efd0d;
case 0x000020e8:
return 0xc9f8fdc0;
case 0x000020ec:
return 0x5c073422;
case 0x000020f0:
return 0xd3ffcc25;
case 0x000020f4:
return 0x326a5dd4;
case 0x000020f8:
return 0xe5d8a9ff;
case 0x000020fc:
return 0x9a3e6ccd;
case 0x00002100:
return 0x3a141cdd;
case 0x00002104:
return 0x786faba0;
case 0x00002108:
return 0x853674b1;
case 0x0000210c:
return 0xa92cf78a;
case 0x00002110:
return 0x2861fde7;
case 0x00002114:
return 0xd8741ca3;
case 0x00002118:
return 0xad369181;
case 0x0000211c:
return 0x4921086d;
case 0x00002120:
return 0xf4c4baad;
case 0x00002124:
return 0x1ad59aa8;
case 0x00002128:
return 0x727b177a;
case 0x0000212c:
return 0x8128c332;
case 0x00002130:
return 0x681df7ae;
case 0x00002134:
return 0x0eec702f;
case 0x00002138:
return 0xcf5d3885;
case 0x0000213c:
return 0x24b49445;
case 0x00002140:
return 0x27cee761;
case 0x00002144:
return 0x23809f22;
case 0x00002148:
return 0x1df8eb2d;
case 0x0000214c:
return 0x16987514;
case 0x00002150:
return 0x32334715;
case 0x00002154:
return 0x3b9edd1e;
case 0x00002158:
return 0x5cf8ec87;
case 0x0000215c:
return 0x1af400dc;
case 0x00002160:
return 0x6dffe8ae;
case 0x00002164:
return 0x6950d9e8;
case 0x00002168:
return 0x98c8c1bf;
case 0x0000216c:
return 0xb80e31c6;
case 0x00002170:
return 0x90c47adb;
case 0x00002174:
return 0xd6be296e;
case 0x00002178:
return 0x6394caa3;
case 0x0000217c:
return 0x50f5d4f3;
case 0x00002180:
return 0xdd743854;
case 0x00002184:
return 0x37be8c7d;
case 0x00002188:
return 0x303e4c2d;
case 0x0000218c:
return 0xfc3fe91d;
case 0x00002190:
return 0x1c77c042;
case 0x00002194:
return 0xe56be12b;
case 0x00002198:
return 0x4fafd0c8;
case 0x0000219c:
return 0x799b84ce;
case 0x000021a0:
return 0xeb5c0c60;
case 0x000021a4:
return 0xab4eb00a;
case 0x000021a8:
return 0xfbb632ad;
case 0x000021ac:
return 0xfa8c3d0e;
case 0x000021b0:
return 0x92cb7d3b;
case 0x000021b4:
return 0x73ebd955;
case 0x000021b8:
return 0xa8a88cb3;
case 0x000021bc:
return 0xbc312bc9;
case 0x000021c0:
return 0x012b6fec;
case 0x000021c4:
return 0x9c201af9;
case 0x000021c8:
return 0xee34311c;
case 0x000021cc:
return 0xdeb7f69a;
case 0x000021d0:
return 0x1074fcda;
case 0x000021d4:
return 0xafe13346;
case 0x000021d8:
return 0xba83655b;
case 0x000021dc:
return 0x0ce7aee7;
case 0x000021e0:
return 0x0b4c365b;
case 0x000021e4:
return 0xc3277354;
case 0x000021e8:
return 0xd1a38190;
case 0x000021ec:
return 0x39dab539;
case 0x000021f0:
return 0x22663634;
case 0x000021f4:
return 0xd2c1430c;
case 0x000021f8:
return 0x2df00f41;
case 0x000021fc:
return 0xb08ce452;
case 0x00002200:
return 0xf8c6c77b;
case 0x00002204:
return 0xb809d7c4;
case 0x00002208:
return 0x6ed30905;
case 0x0000220c:
return 0x884e91dd;
case 0x00002210:
return 0xf9fb18b4;
case 0x00002214:
return 0x8cd1d140;
case 0x00002218:
return 0x7d5ef975;
case 0x0000221c:
return 0x3097d90d;
case 0x00002220:
return 0xbab7c85d;
case 0x00002224:
return 0x8e7df9fe;
case 0x00002228:
return 0x192f7536;
case 0x0000222c:
return 0x9b6c4236;
case 0x00002230:
return 0x764d28af;
case 0x00002234:
return 0xd6656479;
case 0x00002238:
return 0x8e873b91;
case 0x0000223c:
return 0x9a16fff0;
case 0x00002240:
return 0x10453cc3;
case 0x00002244:
return 0x6aec9d81;
case 0x00002248:
return 0x79972ad1;
case 0x0000224c:
return 0xf50ae13c;
case 0x00002250:
return 0xa44565e0;
case 0x00002254:
return 0x8a473021;
case 0x00002258:
return 0xbf45b4f7;
case 0x0000225c:
return 0x7c4c344a;
case 0x00002260:
return 0x4774781d;
case 0x00002264:
return 0x7f7efc3a;
case 0x00002268:
return 0xbe612a67;
case 0x0000226c:
return 0xc932b8a0;
case 0x00002270:
return 0xa9e675d3;
case 0x00002274:
return 0x1c3d1f17;
case 0x00002278:
return 0x4e27051a;
case 0x0000227c:
return 0xb5efc4b8;
case 0x00002280:
return 0x8681561d;
case 0x00002284:
return 0x0473b2ea;
case 0x00002288:
return 0x0534ec3e;
case 0x0000228c:
return 0xca6c6a6b;
case 0x00002290:
return 0x4b8598a7;
case 0x00002294:
return 0x34cc0447;
case 0x00002298:
return 0xe3854873;
case 0x0000229c:
return 0x7e0de1fe;
case 0x000022a0:
return 0xd09a6806;
case 0x000022a4:
return 0x768b13f5;
case 0x000022a8:
return 0xfcf109e0;
case 0x000022ac:
return 0xb7658b68;
case 0x000022b0:
return 0xf1605001;
case 0x000022b4:
return 0x131ea75c;
case 0x000022b8:
return 0x39d92641;
case 0x000022bc:
return 0xe48a4020;
case 0x000022c0:
return 0xeb5574ed;
case 0x000022c4:
return 0xc232cdb9;
case 0x000022c8:
return 0x6d11b7dc;
case 0x000022cc:
return 0x3c1608af;
case 0x000022d0:
return 0x59800ece;
case 0x000022d4:
return 0x859b3c42;
case 0x000022d8:
return 0x811ac91b;
case 0x000022dc:
return 0xef4c91d6;
case 0x000022e0:
return 0xda875cde;
case 0x000022e4:
return 0x2d974a32;
case 0x000022e8:
return 0x7cffb3e3;
case 0x000022ec:
return 0x3ebaec76;
case 0x000022f0:
return 0x2a2b20e7;
case 0x000022f4:
return 0x5c7e1229;
case 0x000022f8:
return 0x2ef0996e;
case 0x000022fc:
return 0xcdf73ed4;
case 0x00002300:
return 0xbce1958c;
case 0x00002304:
return 0xfb966cfd;
case 0x00002308:
return 0x9393656c;
case 0x0000230c:
return 0x379059e6;
case 0x00002310:
return 0x6977b54d;
case 0x00002314:
return 0x38e87718;
case 0x00002318:
return 0x176ce97a;
case 0x0000231c:
return 0xe6b1a116;
case 0x00002320:
return 0xef8f5ef0;
case 0x00002324:
return 0x74bb5b2b;
case 0x00002328:
return 0xda246a3a;
case 0x0000232c:
return 0x3a82a13c;
case 0x00002330:
return 0xcae9654b;
case 0x00002334:
return 0xbee14aee;
case 0x00002338:
return 0x3389f597;
case 0x0000233c:
return 0x362a759f;
case 0x00002340:
return 0x2ecd219f;
case 0x00002344:
return 0x0de2a3dc;
case 0x00002348:
return 0xc6fc10cf;
case 0x0000234c:
return 0x19d5ddfb;
case 0x00002350:
return 0x3e755cb9;
case 0x00002354:
return 0x37da49e6;
case 0x00002358:
return 0xb9adff07;
case 0x0000235c:
return 0x3c039d42;
case 0x00002360:
return 0x91b51d3d;
case 0x00002364:
return 0x0fe008e2;
case 0x00002368:
return 0x37570767;
case 0x0000236c:
return 0x76ef4fd1;
case 0x00002370:
return 0xe10a25b9;
case 0x00002374:
return 0x64d1b5ae;
case 0x00002378:
return 0x41987ac0;
case 0x0000237c:
return 0x4b9c1c0a;
case 0x00002380:
return 0x4e96205d;
case 0x00002384:
return 0xb237069c;
case 0x00002388:
return 0x113b2b38;
case 0x0000238c:
return 0x953a7948;
case 0x00002390:
return 0x0819111c;
case 0x00002394:
return 0xad29b478;
case 0x00002398:
return 0xd666554e;
case 0x0000239c:
return 0x1d9a4029;
case 0x000023a0:
return 0xd525e55b;
case 0x000023a4:
return 0x17e9c30a;
case 0x000023a8:
return 0x0511c14b;
case 0x000023ac:
return 0x6191fc8a;
case 0x000023b0:
return 0xaefd82df;
case 0x000023b4:
return 0x3ac043c6;
case 0x000023b8:
return 0x8eb075e3;
case 0x000023bc:
return 0x7b77e8d9;
case 0x000023c0:
return 0xc578f4b8;
case 0x000023c4:
return 0x5ff47e11;
case 0x000023c8:
return 0x7d951118;
case 0x000023cc:
return 0xb9865b0d;
case 0x000023d0:
return 0xd2133fb7;
case 0x000023d4:
return 0xc286453a;
case 0x000023d8:
return 0x469ccca1;
case 0x000023dc:
return 0x53082877;
case 0x000023e0:
return 0xb137071d;
case 0x000023e4:
return 0xc0efc5fd;
case 0x000023e8:
return 0xbc15465b;
case 0x000023ec:
return 0x54bace17;
case 0x000023f0:
return 0x79135505;
case 0x000023f4:
return 0xe85e4132;
case 0x000023f8:
return 0xd45eaf96;
case 0x000023fc:
return 0x0f6aa418;
case 0x00002400:
return 0xa1b2366e;
case 0x00002404:
return 0x33564a4f;
case 0x00002408:
return 0xc90cd244;
case 0x0000240c:
return 0x58beb8ec;
case 0x00002410:
return 0xa27200b3;
case 0x00002414:
return 0x103e62ec;
case 0x00002418:
return 0xb777145f;
case 0x0000241c:
return 0xb3f63e26;
case 0x00002420:
return 0x7441b9ba;
case 0x00002424:
return 0x96b07a72;
case 0x00002428:
return 0x1732966e;
case 0x0000242c:
return 0xe62ccc3c;
case 0x00002430:
return 0x00eef52e;
case 0x00002434:
return 0x6661a028;
case 0x00002438:
return 0xe5384e54;
case 0x0000243c:
return 0x0c0a6da8;
case 0x00002440:
return 0x51fe7431;
case 0x00002444:
return 0x26edb9fb;
case 0x00002448:
return 0xf245cb93;
case 0x0000244c:
return 0xf17f0757;
case 0x00002450:
return 0x0e876692;
case 0x00002454:
return 0xde3d4fb3;
case 0x00002458:
return 0x72112689;
case 0x0000245c:
return 0x63dfa517;
case 0x00002460:
return 0x44a5a527;
case 0x00002464:
return 0xf820f83f;
case 0x00002468:
return 0x2df0570e;
case 0x0000246c:
return 0x4cc2f446;
case 0x00002470:
return 0xf51a617c;
case 0x00002474:
return 0x0e1328da;
case 0x00002478:
return 0x8898fb17;
case 0x0000247c:
return 0x3a099627;
case 0x00002480:
return 0x1fcdef7d;
case 0x00002484:
return 0xa4cff29a;
case 0x00002488:
return 0x7ba4274e;
case 0x0000248c:
return 0x2ebf5ec7;
case 0x00002490:
return 0x09705f52;
case 0x00002494:
return 0x51311f3d;
case 0x00002498:
return 0x674a9d5e;
case 0x0000249c:
return 0x76a9e154;
case 0x000024a0:
return 0x501551a6;
case 0x000024a4:
return 0x6aeaa378;
case 0x000024a8:
return 0x0bafd701;
case 0x000024ac:
return 0x246eb548;
case 0x000024b0:
return 0x3afde020;
case 0x000024b4:
return 0xb590ec03;
case 0x000024b8:
return 0x83be3461;
case 0x000024bc:
return 0xea02ca00;
case 0x000024c0:
return 0x58e475a3;
case 0x000024c4:
return 0x100c534e;
case 0x000024c8:
return 0x33f625e9;
case 0x000024cc:
return 0x35bdd879;
case 0x000024d0:
return 0x2a8efaa2;
case 0x000024d4:
return 0xab86fbe8;
case 0x000024d8:
return 0x1e3009fb;
case 0x000024dc:
return 0x12eb3849;
case 0x000024e0:
return 0xafc7e33e;
case 0x000024e4:
return 0x903b9b10;
case 0x000024e8:
return 0xe403c5da;
case 0x000024ec:
return 0xdd836a7f;
case 0x000024f0:
return 0x6a292575;
case 0x000024f4:
return 0xfc951246;
case 0x000024f8:
return 0x2a7102f1;
case 0x000024fc:
return 0x37dd7905;
case 0x00002500:
return 0x13e6dc09;
case 0x00002504:
return 0x94ad9801;
case 0x00002508:
return 0x341f33b1;
case 0x0000250c:
return 0x87f3e43e;
case 0x00002510:
return 0x76db0c3e;
case 0x00002514:
return 0x9db7ca0e;
case 0x00002518:
return 0x2de4ab60;
case 0x0000251c:
return 0xb9b2ebda;
case 0x00002520:
return 0xbf9b3350;
case 0x00002524:
return 0x9b66f7f8;
case 0x00002528:
return 0xedb1f95b;
case 0x0000252c:
return 0xdf62a086;
case 0x00002530:
return 0x4e355c7c;
case 0x00002534:
return 0x5566f0d6;
case 0x00002538:
return 0x9cfa45a6;
case 0x0000253c:
return 0x40133696;
case 0x00002540:
return 0x7be81d8b;
case 0x00002544:
return 0x71e4e370;
case 0x00002548:
return 0x6a437c34;
case 0x0000254c:
return 0x5bbc291a;
case 0x00002550:
return 0xb6f0d099;
case 0x00002554:
return 0x00c828f3;
case 0x00002558:
return 0x7ae7e6b8;
case 0x0000255c:
return 0x40c265fa;
case 0x00002560:
return 0xdfa242ff;
case 0x00002564:
return 0x41c18023;
case 0x00002568:
return 0xdf72877d;
case 0x0000256c:
return 0x0d91fc22;
case 0x00002570:
return 0xee9267f7;
case 0x00002574:
return 0x447539ce;
case 0x00002578:
return 0x3d6f0d43;
case 0x0000257c:
return 0xb2a205cb;
case 0x00002580:
return 0x63a169ef;
case 0x00002584:
return 0xa694c25f;
case 0x00002588:
return 0x2daa4c8b;
case 0x0000258c:
return 0x7a11b40e;
case 0x00002590:
return 0x9df2fc54;
case 0x00002594:
return 0x181d10bf;
case 0x00002598:
return 0x5e7aa674;
case 0x0000259c:
return 0xb0213bf4;
case 0x000025a0:
return 0x34dd4b80;
case 0x000025a4:
return 0xf6ed3087;
case 0x000025a8:
return 0x2e3bc8f4;
case 0x000025ac:
return 0x0f26c528;
case 0x000025b0:
return 0x6635033b;
case 0x000025b4:
return 0x666d3d9b;
case 0x000025b8:
return 0xa9a8b124;
case 0x000025bc:
return 0xd2c56baf;
case 0x000025c0:
return 0xf80aef87;
case 0x000025c4:
return 0x85810128;
case 0x000025c8:
return 0x347e2b22;
case 0x000025cc:
return 0x20b6928d;
case 0x000025d0:
return 0x6f6f04f5;
case 0x000025d4:
return 0x4ba12cbe;
case 0x000025d8:
return 0x9728ea1a;
case 0x000025dc:
return 0x9df82732;
case 0x000025e0:
return 0x8e7870ee;
case 0x000025e4:
return 0xfad42ca2;
case 0x000025e8:
return 0x7ceafa0e;
case 0x000025ec:
return 0x30f1cc71;
case 0x000025f0:
return 0x83c29199;
case 0x000025f4:
return 0xc694737c;
case 0x000025f8:
return 0x98a57f27;
case 0x000025fc:
return 0x9253d61a;
case 0x00002600:
return 0x90313c6b;
case 0x00002604:
return 0x08fbc61a;
case 0x00002608:
return 0x6dc9428f;
case 0x0000260c:
return 0x565e07ca;
case 0x00002610:
return 0xe11be4b2;
case 0x00002614:
return 0x4f4e4135;
case 0x00002618:
return 0x60367ab9;
case 0x0000261c:
return 0x16e24876;
case 0x00002620:
return 0xf5a97c63;
case 0x00002624:
return 0x30a91111;
case 0x00002628:
return 0x923e37fd;
case 0x0000262c:
return 0x26551294;
case 0x00002630:
return 0xa080e17d;
case 0x00002634:
return 0x08f9b9a0;
case 0x00002638:
return 0x688c3954;
case 0x0000263c:
return 0x09397c8d;
case 0x00002640:
return 0x9ddf0468;
case 0x00002644:
return 0x964547a2;
case 0x00002648:
return 0x5fd91a01;
case 0x0000264c:
return 0x004bfab0;
case 0x00002650:
return 0x8c362461;
case 0x00002654:
return 0x8f51432d;
case 0x00002658:
return 0x8ffe5629;
case 0x0000265c:
return 0x9fa64087;
case 0x00002660:
return 0xe98f32c6;
case 0x00002664:
return 0x0dbf5d01;
case 0x00002668:
return 0xaf020bd1;
case 0x0000266c:
return 0xe79d0483;
case 0x00002670:
return 0x0d8c13e8;
case 0x00002674:
return 0xf53404dc;
case 0x00002678:
return 0x68f1b45c;
case 0x0000267c:
return 0xe9dce7b4;
case 0x00002680:
return 0x3b90f141;
case 0x00002684:
return 0x28fd1580;
case 0x00002688:
return 0x4b55d026;
case 0x0000268c:
return 0x556baea5;
case 0x00002690:
return 0xa26b7593;
case 0x00002694:
return 0xe9edb14d;
case 0x00002698:
return 0x7919dea9;
case 0x0000269c:
return 0xd040e0e6;
case 0x000026a0:
return 0xc18cd856;
case 0x000026a4:
return 0xce4a025a;
case 0x000026a8:
return 0xa8069ff6;
case 0x000026ac:
return 0x2fb9b477;
case 0x000026b0:
return 0xd34c3049;
case 0x000026b4:
return 0x8048e18d;
case 0x000026b8:
return 0xcc208a0a;
case 0x000026bc:
return 0xff83d18e;
case 0x000026c0:
return 0xe2774080;
case 0x000026c4:
return 0x211362c4;
case 0x000026c8:
return 0xf990c795;
case 0x000026cc:
return 0xfb0a8da8;
case 0x000026d0:
return 0x322abcca;
case 0x000026d4:
return 0x67514883;
case 0x000026d8:
return 0x2da5c6d5;
case 0x000026dc:
return 0xf0cd7423;
case 0x000026e0:
return 0xea153f2c;
case 0x000026e4:
return 0xa993330b;
case 0x000026e8:
return 0x28d72583;
case 0x000026ec:
return 0x4c4d8084;
case 0x000026f0:
return 0xcdf4374e;
case 0x000026f4:
return 0x8eb9881c;
case 0x000026f8:
return 0xca03dea9;
case 0x000026fc:
return 0x8787ee0f;
case 0x00002700:
return 0x65c1fa7f;
case 0x00002704:
return 0x35745e89;
case 0x00002708:
return 0xcebbe64d;
case 0x0000270c:
return 0x5a3dafa5;
case 0x00002710:
return 0xa531f436;
case 0x00002714:
return 0xc8652301;
case 0x00002718:
return 0x4c211c8b;
case 0x0000271c:
return 0x1a65c457;
case 0x00002720:
return 0xd5792f6b;
case 0x00002724:
return 0xe7efd2d3;
case 0x00002728:
return 0xd705b2cc;
case 0x0000272c:
return 0xeb382193;
case 0x00002730:
return 0x8551b923;
case 0x00002734:
return 0xd94ba6d1;
case 0x00002738:
return 0x46c04035;
case 0x0000273c:
return 0x82fa8af4;
case 0x00002740:
return 0x17811de3;
case 0x00002744:
return 0xfa1b6a3a;
case 0x00002748:
return 0xdde90408;
case 0x0000274c:
return 0x196120e9;
case 0x00002750:
return 0x0f070c4b;
case 0x00002754:
return 0xa62117bf;
case 0x00002758:
return 0x54f687ce;
case 0x0000275c:
return 0x45bf9a55;
case 0x00002760:
return 0xee62b781;
case 0x00002764:
return 0xd01795c2;
case 0x00002768:
return 0x5362eddd;
case 0x0000276c:
return 0x7cf4875c;
case 0x00002770:
return 0xe8973e92;
case 0x00002774:
return 0x3100adc7;
case 0x00002778:
return 0xc9c91f5c;
case 0x0000277c:
return 0xf6259a08;
case 0x00002780:
return 0xe5258598;
case 0x00002784:
return 0xb513d02d;
case 0x00002788:
return 0x7fbda3e7;
case 0x0000278c:
return 0x110ae948;
case 0x00002790:
return 0xeaa35cf4;
case 0x00002794:
return 0x90a2ef77;
case 0x00002798:
return 0xe2aa03d3;
case 0x0000279c:
return 0x36a2ba20;
case 0x000027a0:
return 0x844f2a9d;
case 0x000027a4:
return 0xae336602;
case 0x000027a8:
return 0x1281c0b1;
case 0x000027ac:
return 0x6f88116c;
case 0x000027b0:
return 0x939c5d5f;
case 0x000027b4:
return 0x4e53ef33;
case 0x000027b8:
return 0x8c3c46f6;
case 0x000027bc:
return 0x8a5063e1;
case 0x000027c0:
return 0xca7c714c;
case 0x000027c4:
return 0x9a79456c;
case 0x000027c8:
return 0xd8af0de4;
case 0x000027cc:
return 0xbe5dd322;
case 0x000027d0:
return 0x4ca6bf44;
case 0x000027d4:
return 0xfa618a5d;
case 0x000027d8:
return 0x35aca848;
case 0x000027dc:
return 0xc7d57b58;
case 0x000027e0:
return 0xd1d726c1;
case 0x000027e4:
return 0x3355c019;
case 0x000027e8:
return 0x27e43cf3;
case 0x000027ec:
return 0x23275fd6;
case 0x000027f0:
return 0x8a5dfaf5;
case 0x000027f4:
return 0xd3424f2a;
case 0x000027f8:
return 0xc5c02249;
case 0x000027fc:
return 0xa7a84e4f;
case 0x00002800:
return 0x093e8ef5;
case 0x00002804:
return 0x4b9b482d;
case 0x00002808:
return 0x0853c972;
case 0x0000280c:
return 0x2c5ff92f;
case 0x00002810:
return 0xb4373c5d;
case 0x00002814:
return 0xf9ffd496;
case 0x00002818:
return 0xce617ef8;
case 0x0000281c:
return 0x79d5fa46;
case 0x00002820:
return 0xc25ce3e0;
case 0x00002824:
return 0x9793f718;
case 0x00002828:
return 0xc893bf5f;
case 0x0000282c:
return 0xab658aa5;
case 0x00002830:
return 0xf69cae76;
case 0x00002834:
return 0x3a981365;
case 0x00002838:
return 0x8f16074e;
case 0x0000283c:
return 0x54ee040c;
case 0x00002840:
return 0xd4a24a37;
case 0x00002844:
return 0x3176af8b;
case 0x00002848:
return 0x7d989f1b;
case 0x0000284c:
return 0x846ff4fa;
case 0x00002850:
return 0x70940b24;
case 0x00002854:
return 0xa5e153ac;
case 0x00002858:
return 0xf13dd129;
case 0x0000285c:
return 0x7588a246;
case 0x00002860:
return 0xe3dc408a;
case 0x00002864:
return 0x5df3e56a;
case 0x00002868:
return 0xe068aa02;
case 0x0000286c:
return 0x038fc479;
case 0x00002870:
return 0x2c9c71f6;
case 0x00002874:
return 0xe49376cb;
case 0x00002878:
return 0x7e722b22;
case 0x0000287c:
return 0x3d6cf8df;
case 0x00002880:
return 0x79ea2e10;
case 0x00002884:
return 0xce036697;
case 0x00002888:
return 0x671b3f33;
case 0x0000288c:
return 0xfa8b0e6d;
case 0x00002890:
return 0x2d5f014e;
case 0x00002894:
return 0x1bc371b3;
case 0x00002898:
return 0x17e5057b;
case 0x0000289c:
return 0x600f32ef;
case 0x000028a0:
return 0x7faea61a;
case 0x000028a4:
return 0x168f8476;
case 0x000028a8:
return 0x16f7aac2;
case 0x000028ac:
return 0x7fa0206f;
case 0x000028b0:
return 0x50539920;
case 0x000028b4:
return 0xa3b8e384;
case 0x000028b8:
return 0x2b439fd5;
case 0x000028bc:
return 0x87679aa9;
case 0x000028c0:
return 0x8a075b53;
case 0x000028c4:
return 0xa3894204;
case 0x000028c8:
return 0x632f4150;
case 0x000028cc:
return 0x8428b75e;
case 0x000028d0:
return 0x19ae425a;
case 0x000028d4:
return 0x77a1239f;
case 0x000028d8:
return 0xa9ac51d6;
case 0x000028dc:
return 0x931b7739;
case 0x000028e0:
return 0x6db9f79b;
case 0x000028e4:
return 0x8fb0b103;
case 0x000028e8:
return 0xc5f3f906;
case 0x000028ec:
return 0x2f69f08b;
case 0x000028f0:
return 0xc861339b;
case 0x000028f4:
return 0x90c76431;
case 0x000028f8:
return 0x3a622c22;
case 0x000028fc:
return 0x18ecf4fe;
case 0x00002900:
return 0xa6522db6;
case 0x00002904:
return 0x7cab1abd;
case 0x00002908:
return 0x85de7ef8;
case 0x0000290c:
return 0x39734412;
case 0x00002910:
return 0xbd633ad7;
case 0x00002914:
return 0xfe1d5170;
case 0x00002918:
return 0x368ecd2d;
case 0x0000291c:
return 0xdfda58b0;
case 0x00002920:
return 0x3db1bf3d;
case 0x00002924:
return 0xdd3ad212;
case 0x00002928:
return 0x2a1bcdfc;
case 0x0000292c:
return 0x3e005e61;
case 0x00002930:
return 0x3258227f;
case 0x00002934:
return 0x8676b658;
case 0x00002938:
return 0xaaca782c;
case 0x0000293c:
return 0x36409480;
case 0x00002940:
return 0x7a4f8e3f;
case 0x00002944:
return 0x1e56d0b2;
case 0x00002948:
return 0x01532496;
case 0x0000294c:
return 0xed859b30;
case 0x00002950:
return 0x20b5e990;
case 0x00002954:
return 0x22651439;
case 0x00002958:
return 0xce0a7353;
case 0x0000295c:
return 0x5747d962;
case 0x00002960:
return 0x794a920c;
case 0x00002964:
return 0xb15ddb33;
case 0x00002968:
return 0x7f49de9c;
case 0x0000296c:
return 0xc4682469;
case 0x00002970:
return 0x0104f878;
case 0x00002974:
return 0x6ece930e;
case 0x00002978:
return 0xc82597aa;
case 0x0000297c:
return 0xa93739fe;
case 0x00002980:
return 0x971c0cd1;
case 0x00002984:
return 0x7a7a2b40;
case 0x00002988:
return 0x2681b26b;
case 0x0000298c:
return 0xcdaea75a;
case 0x00002990:
return 0x4a5ff38c;
case 0x00002994:
return 0xfa1d48bc;
case 0x00002998:
return 0x9f660fbf;
case 0x0000299c:
return 0x054e84a8;
case 0x000029a0:
return 0xdc580ccc;
case 0x000029a4:
return 0xf6eaea35;
case 0x000029a8:
return 0xaa3225ab;
case 0x000029ac:
return 0x1c273ede;
case 0x000029b0:
return 0xd0d447d1;
case 0x000029b4:
return 0xcc775d69;
case 0x000029b8:
return 0xbc7746f8;
case 0x000029bc:
return 0x105eac5e;
case 0x000029c0:
return 0x0a9a9b47;
case 0x000029c4:
return 0xab68a467;
case 0x000029c8:
return 0xccf66475;
case 0x000029cc:
return 0xd18d5c35;
case 0x000029d0:
return 0xe2dc9fc2;
case 0x000029d4:
return 0xb0826afd;
case 0x000029d8:
return 0x1d4447a6;
case 0x000029dc:
return 0x0aad1631;
case 0x000029e0:
return 0x4540ca01;
case 0x000029e4:
return 0xfd2faf6f;
case 0x000029e8:
return 0x6527603d;
case 0x000029ec:
return 0x81337a23;
case 0x000029f0:
return 0x7d7a833c;
case 0x000029f4:
return 0xfea53543;
case 0x000029f8:
return 0x9f9840e5;
case 0x000029fc:
return 0xc7ff6693;
case 0x00002a00:
return 0x67e80086;
case 0x00002a04:
return 0xd36a31e0;
case 0x00002a08:
return 0x905e9792;
case 0x00002a0c:
return 0x24833cb0;
case 0x00002a10:
return 0xd8a2e636;
case 0x00002a14:
return 0xd0f67ef5;
case 0x00002a18:
return 0x55c2ae1b;
case 0x00002a1c:
return 0x70122c0a;
case 0x00002a20:
return 0xe87e9e7f;
case 0x00002a24:
return 0x3cd6aba2;
case 0x00002a28:
return 0x1b99f910;
case 0x00002a2c:
return 0x8efd26a6;
case 0x00002a30:
return 0x71b873a3;
case 0x00002a34:
return 0xdf11ac85;
case 0x00002a38:
return 0xfd474231;
case 0x00002a3c:
return 0xc9cfe48b;
case 0x00002a40:
return 0xbd8cfde7;
case 0x00002a44:
return 0x99f33f60;
case 0x00002a48:
return 0x710c1707;
case 0x00002a4c:
return 0xdaf10c99;
case 0x00002a50:
return 0x7d58824f;
case 0x00002a54:
return 0x8195c6d3;
case 0x00002a58:
return 0x1974aa19;
case 0x00002a5c:
return 0x8e1ccac5;
case 0x00002a60:
return 0xf0bdf63b;
case 0x00002a64:
return 0x1d215510;
case 0x00002a68:
return 0x684ab7d5;
case 0x00002a6c:
return 0x8d3a4caf;
case 0x00002a70:
return 0xd30575bd;
case 0x00002a74:
return 0xa895c777;
case 0x00002a78:
return 0x789240b0;
case 0x00002a7c:
return 0xf17b3ada;
case 0x00002a80:
return 0x63b27a95;
case 0x00002a84:
return 0x5f6b5b37;
case 0x00002a88:
return 0x6c0036e7;
case 0x00002a8c:
return 0xff842837;
case 0x00002a90:
return 0xbd6eb9b0;
case 0x00002a94:
return 0xd54ae7f4;
case 0x00002a98:
return 0x54960b6f;
case 0x00002a9c:
return 0xd6bb5d9f;
case 0x00002aa0:
return 0x806d7f7a;
case 0x00002aa4:
return 0x73836e28;
case 0x00002aa8:
return 0x4c6ecd6a;
case 0x00002aac:
return 0xbd0a86f0;
case 0x00002ab0:
return 0x96e20fea;
case 0x00002ab4:
return 0xcb4fdc8b;
case 0x00002ab8:
return 0x3dbad48b;
case 0x00002abc:
return 0xea455e18;
case 0x00002ac0:
return 0x5c5e9e42;
case 0x00002ac4:
return 0x25b8713c;
case 0x00002ac8:
return 0x583cafd1;
case 0x00002acc:
return 0x57b9cf89;
case 0x00002ad0:
return 0x014ab32a;
case 0x00002ad4:
return 0x964b9eeb;
case 0x00002ad8:
return 0x812f1ba0;
case 0x00002adc:
return 0x4ae23755;
case 0x00002ae0:
return 0x88754328;
case 0x00002ae4:
return 0xf8fe54ca;
case 0x00002ae8:
return 0xb28c8867;
case 0x00002aec:
return 0x4430532c;
case 0x00002af0:
return 0xceea02e3;
case 0x00002af4:
return 0x0128ccd6;
case 0x00002af8:
return 0x54b5a6ad;
case 0x00002afc:
return 0x6732ead0;
case 0x00002b00:
return 0x1872186e;
case 0x00002b04:
return 0xe2819430;
case 0x00002b08:
return 0x33705e45;
case 0x00002b0c:
return 0x927de050;
case 0x00002b10:
return 0xcd037b69;
case 0x00002b14:
return 0xcd8e1b67;
case 0x00002b18:
return 0x6c0cf504;
case 0x00002b1c:
return 0x6fbca5f8;
case 0x00002b20:
return 0x937f3042;
case 0x00002b24:
return 0x25a4f800;
case 0x00002b28:
return 0x7340007f;
case 0x00002b2c:
return 0x8d8aa2ca;
case 0x00002b30:
return 0xf221ed30;
case 0x00002b34:
return 0x23e011e3;
case 0x00002b38:
return 0xb58d6250;
case 0x00002b3c:
return 0x4035f23c;
case 0x00002b40:
return 0x65325568;
case 0x00002b44:
return 0xa4188289;
case 0x00002b48:
return 0x696e59f3;
case 0x00002b4c:
return 0x4fc2e6af;
case 0x00002b50:
return 0x73216e56;
case 0x00002b54:
return 0x13e5a220;
case 0x00002b58:
return 0x96a2e283;
case 0x00002b5c:
return 0x5a43dff9;
case 0x00002b60:
return 0xc8583231;
case 0x00002b64:
return 0x9782b572;
case 0x00002b68:
return 0x3e5f3b98;
case 0x00002b6c:
return 0x412c8349;
case 0x00002b70:
return 0x1a087ea5;
case 0x00002b74:
return 0xf6a11dac;
case 0x00002b78:
return 0xbc881f26;
case 0x00002b7c:
return 0x81f12b0a;
case 0x00002b80:
return 0xb2fca720;
case 0x00002b84:
return 0x4481476b;
case 0x00002b88:
return 0x7481ede9;
case 0x00002b8c:
return 0x392a05cd;
case 0x00002b90:
return 0x5a6fc7f2;
case 0x00002b94:
return 0x96f761ea;
case 0x00002b98:
return 0x6fe53892;
case 0x00002b9c:
return 0xf3583c1a;
case 0x00002ba0:
return 0xdf272436;
case 0x00002ba4:
return 0xf910b979;
case 0x00002ba8:
return 0x21185e7d;
case 0x00002bac:
return 0xf3e4abde;
case 0x00002bb0:
return 0x4f888890;
case 0x00002bb4:
return 0x909e691b;
case 0x00002bb8:
return 0x7b4cb9c0;
case 0x00002bbc:
return 0x32ff4f97;
case 0x00002bc0:
return 0x888fa7ef;
case 0x00002bc4:
return 0x041d4c51;
case 0x00002bc8:
return 0xe3f12744;
case 0x00002bcc:
return 0x7cf1521a;
case 0x00002bd0:
return 0x0cd1e679;
case 0x00002bd4:
return 0x97836ec5;
case 0x00002bd8:
return 0xdf2a4da8;
case 0x00002bdc:
return 0x7f1690de;
case 0x00002be0:
return 0x748457b9;
case 0x00002be4:
return 0x0c7f977a;
case 0x00002be8:
return 0xa584834a;
case 0x00002bec:
return 0xd0b47dd7;
case 0x00002bf0:
return 0x8ca88f09;
case 0x00002bf4:
return 0xee2306da;
case 0x00002bf8:
return 0x3f8cb317;
case 0x00002bfc:
return 0x2e2e89a4;
case 0x00002c00:
return 0x43c26948;
case 0x00002c04:
return 0x38a12bdc;
case 0x00002c08:
return 0xd8e36d69;
case 0x00002c0c:
return 0xb85cd327;
case 0x00002c10:
return 0xe4742ab9;
case 0x00002c14:
return 0xafad7a69;
case 0x00002c18:
return 0x1f53853d;
case 0x00002c1c:
return 0xa05e298f;
case 0x00002c20:
return 0x3f04caaa;
case 0x00002c24:
return 0x1cc25d09;
case 0x00002c28:
return 0x3bc23a0e;
case 0x00002c2c:
return 0x1187a61a;
case 0x00002c30:
return 0xf0414982;
case 0x00002c34:
return 0x21ef644a;
case 0x00002c38:
return 0x5ba3b125;
case 0x00002c3c:
return 0x117790e0;
case 0x00002c40:
return 0xfda1bff4;
case 0x00002c44:
return 0x4b9b28af;
case 0x00002c48:
return 0xb7f6965c;
case 0x00002c4c:
return 0xbcabdae5;
case 0x00002c50:
return 0x9578da2a;
case 0x00002c54:
return 0x37a6976e;
case 0x00002c58:
return 0xbfad5917;
case 0x00002c5c:
return 0xb5c896d1;
case 0x00002c60:
return 0x40f1af6c;
case 0x00002c64:
return 0xe534457f;
case 0x00002c68:
return 0xca5046e5;
case 0x00002c6c:
return 0x0a215be6;
case 0x00002c70:
return 0xe65b79f5;
case 0x00002c74:
return 0x88dc1a90;
case 0x00002c78:
return 0xe41c1c31;
case 0x00002c7c:
return 0xb354a5a2;
case 0x00002c80:
return 0xab501407;
case 0x00002c84:
return 0x8e57194b;
case 0x00002c88:
return 0xbd84c047;
case 0x00002c8c:
return 0x004a1410;
case 0x00002c90:
return 0xe0190b52;
case 0x00002c94:
return 0x3010c155;
case 0x00002c98:
return 0xde266eea;
case 0x00002c9c:
return 0x8e80aba4;
case 0x00002ca0:
return 0x3919c443;
case 0x00002ca4:
return 0xd39c7e8c;
case 0x00002ca8:
return 0xb9c5e27c;
case 0x00002cac:
return 0x2ce7dec9;
case 0x00002cb0:
return 0xc9980673;
case 0x00002cb4:
return 0x37f465ee;
case 0x00002cb8:
return 0x4ed2f499;
case 0x00002cbc:
return 0xf4bedd3c;
case 0x00002cc0:
return 0x2b9f3834;
case 0x00002cc4:
return 0x2ab935b9;
case 0x00002cc8:
return 0x5db74177;
case 0x00002ccc:
return 0x41b8b834;
case 0x00002cd0:
return 0xd37f12d5;
case 0x00002cd4:
return 0x83d6c3f0;
case 0x00002cd8:
return 0x551c0bd0;
case 0x00002cdc:
return 0x9fa90a35;
case 0x00002ce0:
return 0x53b3a5e6;
case 0x00002ce4:
return 0x0cddea0c;
case 0x00002ce8:
return 0xb22dde08;
case 0x00002cec:
return 0x57c4e0d6;
case 0x00002cf0:
return 0xcf434644;
case 0x00002cf4:
return 0xe563a338;
case 0x00002cf8:
return 0x5bdcdd60;
case 0x00002cfc:
return 0x0e509ec6;
case 0x00002d00:
return 0x19157080;
case 0x00002d04:
return 0x05653bd3;
case 0x00002d08:
return 0xbe305c86;
case 0x00002d0c:
return 0xec581183;
case 0x00002d10:
return 0x7041730d;
case 0x00002d14:
return 0xdf9fcf30;
case 0x00002d18:
return 0xd38fdad7;
case 0x00002d1c:
return 0x1603d831;
case 0x00002d20:
return 0x50abe674;
case 0x00002d24:
return 0xb0623182;
case 0x00002d28:
return 0xd2403ff3;
case 0x00002d2c:
return 0x7a748537;
case 0x00002d30:
return 0x081c8cb0;
case 0x00002d34:
return 0xfa993923;
case 0x00002d38:
return 0x2a738e6c;
case 0x00002d3c:
return 0x0c407f7e;
case 0x00002d40:
return 0x9dbf61fa;
case 0x00002d44:
return 0xf46ed510;
case 0x00002d48:
return 0xbcfc786c;
case 0x00002d4c:
return 0xed0c1d46;
case 0x00002d50:
return 0x394c84cc;
case 0x00002d54:
return 0x632f3153;
case 0x00002d58:
return 0x29f4aaf7;
case 0x00002d5c:
return 0x8086601b;
case 0x00002d60:
return 0x9d409b61;
case 0x00002d64:
return 0x22af9eaf;
case 0x00002d68:
return 0xbe2e1b63;
case 0x00002d6c:
return 0xa0d0d1ae;
case 0x00002d70:
return 0xbee21bf7;
case 0x00002d74:
return 0x3fe35185;
case 0x00002d78:
return 0x06456479;
case 0x00002d7c:
return 0x696ce3a3;
case 0x00002d80:
return 0x944dc4f4;
case 0x00002d84:
return 0x9d615a8b;
case 0x00002d88:
return 0x247cd59f;
case 0x00002d8c:
return 0x127db255;
case 0x00002d90:
return 0xf04260fb;
case 0x00002d94:
return 0xe1ee721e;
case 0x00002d98:
return 0x0e8b8af9;
case 0x00002d9c:
return 0x1e2af0b0;
case 0x00002da0:
return 0x822e2233;
case 0x00002da4:
return 0xcde7b1c4;
case 0x00002da8:
return 0x769f6107;
case 0x00002dac:
return 0x0c68fe9a;
case 0x00002db0:
return 0xfb4bf557;
case 0x00002db4:
return 0x9a33609b;
case 0x00002db8:
return 0x4b48642d;
case 0x00002dbc:
return 0x43a33dab;
case 0x00002dc0:
return 0x3308bc57;
case 0x00002dc4:
return 0x9fc0a346;
case 0x00002dc8:
return 0x2b3fb8e9;
case 0x00002dcc:
return 0x06a202d5;
case 0x00002dd0:
return 0x8e9d4ebd;
case 0x00002dd4:
return 0xf5aa702a;
case 0x00002dd8:
return 0x2a55f3be;
case 0x00002ddc:
return 0xe0ccf652;
case 0x00002de0:
return 0x598e918d;
case 0x00002de4:
return 0x05ffc441;
case 0x00002de8:
return 0x680ecc61;
case 0x00002dec:
return 0xe366cda6;
case 0x00002df0:
return 0x6218cfed;
case 0x00002df4:
return 0xca13d7f5;
case 0x00002df8:
return 0x4651222a;
case 0x00002dfc:
return 0x2e8415b2;
case 0x00002e00:
return 0x0ee9fa8a;
case 0x00002e04:
return 0x5bfb6f81;
case 0x00002e08:
return 0x3a5ef7ae;
case 0x00002e0c:
return 0x19d28f8c;
case 0x00002e10:
return 0xf8594766;
case 0x00002e14:
return 0xd20e8170;
case 0x00002e18:
return 0x195e1b6b;
case 0x00002e1c:
return 0x34e29fcc;
case 0x00002e20:
return 0x67cd8938;
case 0x00002e24:
return 0x2bcd4f03;
case 0x00002e28:
return 0x88dbbc6c;
case 0x00002e2c:
return 0xd91327ed;
case 0x00002e30:
return 0x2db82ccd;
case 0x00002e34:
return 0x21593c7d;
case 0x00002e38:
return 0x21e6f026;
case 0x00002e3c:
return 0xd4af3f53;
case 0x00002e40:
return 0x57d5b54f;
case 0x00002e44:
return 0x6bfee4b3;
case 0x00002e48:
return 0xf96f8180;
case 0x00002e4c:
return 0xf94ad0c0;
case 0x00002e50:
return 0x44a261ad;
case 0x00002e54:
return 0x695fafe6;
case 0x00002e58:
return 0xdd784b7a;
case 0x00002e5c:
return 0xf5c5395f;
case 0x00002e60:
return 0x9433a8ea;
case 0x00002e64:
return 0x7b958000;
case 0x00002e68:
return 0xdc5e314a;
case 0x00002e6c:
return 0x0685f53c;
case 0x00002e70:
return 0x068e8183;
case 0x00002e74:
return 0x85010c6a;
case 0x00002e78:
return 0x1d4e7973;
case 0x00002e7c:
return 0xa11cee71;
case 0x00002e80:
return 0x908b9e70;
case 0x00002e84:
return 0x0a7be628;
case 0x00002e88:
return 0xfe17e770;
case 0x00002e8c:
return 0x562d7e64;
case 0x00002e90:
return 0x038dba84;
case 0x00002e94:
return 0xb09842cd;
case 0x00002e98:
return 0x0dfc01c7;
case 0x00002e9c:
return 0x2f2c0a7a;
case 0x00002ea0:
return 0xa1a0fc48;
case 0x00002ea4:
return 0x967587c8;
case 0x00002ea8:
return 0x45f45dc1;
case 0x00002eac:
return 0x1cf4bc4f;
case 0x00002eb0:
return 0x6bf98d8f;
case 0x00002eb4:
return 0x1d2d6393;
case 0x00002eb8:
return 0x29223322;
case 0x00002ebc:
return 0xdaf7ae5d;
case 0x00002ec0:
return 0x5aa0ab74;
case 0x00002ec4:
return 0x39bfb359;
case 0x00002ec8:
return 0xe519a813;
case 0x00002ecc:
return 0xbab36430;
case 0x00002ed0:
return 0xddecab5b;
case 0x00002ed4:
return 0xe1060255;
case 0x00002ed8:
return 0x4fb0a6dc;
case 0x00002edc:
return 0x598f932a;
case 0x00002ee0:
return 0x67c6db2b;
case 0x00002ee4:
return 0xc791d81d;
case 0x00002ee8:
return 0xef44c119;
case 0x00002eec:
return 0x2c1af213;
case 0x00002ef0:
return 0x094af88f;
case 0x00002ef4:
return 0xf18815a1;
case 0x00002ef8:
return 0x340a0ff5;
case 0x00002efc:
return 0xd196ea89;
case 0x00002f00:
return 0x025c02a9;
case 0x00002f04:
return 0xa6372bbd;
case 0x00002f08:
return 0xfe21e5de;
case 0x00002f0c:
return 0x1825fa76;
case 0x00002f10:
return 0xeb7f5d12;
case 0x00002f14:
return 0x0fc1afcd;
case 0x00002f18:
return 0x747aae2c;
case 0x00002f1c:
return 0xbf872fd8;
case 0x00002f20:
return 0x1bbe96a7;
case 0x00002f24:
return 0x204067d4;
case 0x00002f28:
return 0x3a2c8998;
case 0x00002f2c:
return 0x20d91222;
case 0x00002f30:
return 0x3d76ca09;
case 0x00002f34:
return 0x3161f35e;
case 0x00002f38:
return 0x34624600;
case 0x00002f3c:
return 0xb73f1ab9;
case 0x00002f40:
return 0x4095891b;
case 0x00002f44:
return 0x8494d2ce;
case 0x00002f48:
return 0xa6b7ec0c;
case 0x00002f4c:
return 0xc3ae3f74;
case 0x00002f50:
return 0xbd1263a8;
case 0x00002f54:
return 0xb00ed0f8;
case 0x00002f58:
return 0x309f438a;
case 0x00002f5c:
return 0x7321a222;
case 0x00002f60:
return 0xcec98b2e;
case 0x00002f64:
return 0x1dd7a0c0;
case 0x00002f68:
return 0xe9a44d31;
case 0x00002f6c:
return 0x5111383c;
case 0x00002f70:
return 0x362bf0a1;
case 0x00002f74:
return 0xfefb3281;
case 0x00002f78:
return 0x698ea3f3;
case 0x00002f7c:
return 0x9a7f675d;
case 0x00002f80:
return 0xf98dc9db;
case 0x00002f84:
return 0x78265872;
case 0x00002f88:
return 0xa36edf42;
case 0x00002f8c:
return 0xd54fdeee;
case 0x00002f90:
return 0x00a3daed;
case 0x00002f94:
return 0xcb7f0155;
case 0x00002f98:
return 0x9bfe3e2e;
case 0x00002f9c:
return 0x9f6faed7;
case 0x00002fa0:
return 0x33d0bbe8;
case 0x00002fa4:
return 0x8fd7d2cf;
case 0x00002fa8:
return 0xb209a0e4;
case 0x00002fac:
return 0x3ec718cd;
case 0x00002fb0:
return 0xc5855963;
case 0x00002fb4:
return 0x4647e087;
case 0x00002fb8:
return 0x7794ddb6;
case 0x00002fbc:
return 0xef5a0284;
case 0x00002fc0:
return 0x309b609a;
case 0x00002fc4:
return 0xac00adb9;
case 0x00002fc8:
return 0x73e93131;
case 0x00002fcc:
return 0x80d061ae;
case 0x00002fd0:
return 0x2948128a;
case 0x00002fd4:
return 0x919be6f2;
case 0x00002fd8:
return 0xf90c5b73;
case 0x00002fdc:
return 0x94342949;
case 0x00002fe0:
return 0x0daacdfb;
case 0x00002fe4:
return 0x68aab85d;
case 0x00002fe8:
return 0x82bb7468;
case 0x00002fec:
return 0x3f806035;
case 0x00002ff0:
return 0xf031f48f;
case 0x00002ff4:
return 0xbf6d8a22;
case 0x00002ff8:
return 0x0e526f0e;
case 0x00002ffc:
return 0x1983e26c;
case 0x00003000:
return 0x9c630c26;
case 0x00003004:
return 0x68190149;
case 0x00003008:
return 0x7a7a9321;
case 0x0000300c:
return 0xb12c1377;
case 0x00003010:
return 0x379e8bb3;
case 0x00003014:
return 0xe5cf06e6;
case 0x00003018:
return 0x3e45f7df;
case 0x0000301c:
return 0xde01aeb8;
case 0x00003020:
return 0xb1feb525;
case 0x00003024:
return 0x2213c41e;
case 0x00003028:
return 0x69237ded;
case 0x0000302c:
return 0x7b3a66ee;
case 0x00003030:
return 0x0126269e;
case 0x00003034:
return 0xbe25e40e;
case 0x00003038:
return 0x70b0576b;
case 0x0000303c:
return 0xd3afef4e;
case 0x00003040:
return 0x989084ae;
case 0x00003044:
return 0x856464e2;
case 0x00003048:
return 0xce9d021a;
case 0x0000304c:
return 0x1f956e20;
case 0x00003050:
return 0xf275babd;
case 0x00003054:
return 0x2d45b7a6;
case 0x00003058:
return 0xe61f3581;
case 0x0000305c:
return 0x99634e00;
case 0x00003060:
return 0x79d6c263;
case 0x00003064:
return 0x6a05b582;
case 0x00003068:
return 0x9c0cbc3a;
case 0x0000306c:
return 0x145b37b1;
case 0x00003070:
return 0xea0d8172;
case 0x00003074:
return 0x99e21409;
case 0x00003078:
return 0x69effafe;
case 0x0000307c:
return 0x15dca8e6;
case 0x00003080:
return 0x73f91026;
case 0x00003084:
return 0x0bb90bad;
case 0x00003088:
return 0x57cdc011;
case 0x0000308c:
return 0x9405f8bc;
case 0x00003090:
return 0x91620d3e;
case 0x00003094:
return 0x9a1e14c6;
case 0x00003098:
return 0x17541af9;
case 0x0000309c:
return 0xde4f33af;
case 0x000030a0:
return 0x62a21ef8;
case 0x000030a4:
return 0x5d0c97db;
case 0x000030a8:
return 0xc874f0ba;
case 0x000030ac:
return 0x1b6b13c1;
case 0x000030b0:
return 0x88e0edc0;
case 0x000030b4:
return 0xaccd1de1;
case 0x000030b8:
return 0xb2bcd37f;
case 0x000030bc:
return 0x60e409f1;
case 0x000030c0:
return 0x76ae5169;
case 0x000030c4:
return 0x966518c8;
case 0x000030c8:
return 0x64e8dde9;
case 0x000030cc:
return 0x884bed40;
case 0x000030d0:
return 0x26e5618d;
case 0x000030d4:
return 0xebc2a729;
case 0x000030d8:
return 0x1892be39;
case 0x000030dc:
return 0x96d03f5a;
case 0x000030e0:
return 0xcb5134f2;
case 0x000030e4:
return 0xc2f0ee7e;
case 0x000030e8:
return 0x8f11c8e8;
case 0x000030ec:
return 0x9d1b3453;
case 0x000030f0:
return 0xcfc4b7a5;
case 0x000030f4:
return 0x51b030c5;
case 0x000030f8:
return 0xa44402d3;
case 0x000030fc:
return 0xb7a400f9;
case 0x00003100:
return 0x1e0c9380;
case 0x00003104:
return 0x1b828b05;
case 0x00003108:
return 0x1fa8effa;
case 0x0000310c:
return 0x4fda0e9a;
case 0x00003110:
return 0x8b32c785;
case 0x00003114:
return 0x8efe4869;
case 0x00003118:
return 0xc6146a71;
case 0x0000311c:
return 0xe709e52f;
case 0x00003120:
return 0xbb6be3f2;
case 0x00003124:
return 0xbc56a047;
case 0x00003128:
return 0x06f85fb6;
case 0x0000312c:
return 0x731a5be9;
case 0x00003130:
return 0x1feea6f2;
case 0x00003134:
return 0x70f4e279;
case 0x00003138:
return 0x3fde5264;
case 0x0000313c:
return 0x5b367aae;
case 0x00003140:
return 0xb4142275;
case 0x00003144:
return 0xc7f09dc8;
case 0x00003148:
return 0x5be9796a;
case 0x0000314c:
return 0x89f4c028;
case 0x00003150:
return 0x66c0e80d;
case 0x00003154:
return 0x95baf6c8;
case 0x00003158:
return 0xa07e1ad3;
case 0x0000315c:
return 0xf8f7e437;
case 0x00003160:
return 0x4e9e8981;
case 0x00003164:
return 0x1a963cdd;
case 0x00003168:
return 0xb6a06dee;
case 0x0000316c:
return 0x2fd9778e;
case 0x00003170:
return 0xe5aee6a1;
case 0x00003174:
return 0xa0637ac4;
case 0x00003178:
return 0x8d6fb278;
case 0x0000317c:
return 0xc3e1fe4a;
case 0x00003180:
return 0xfbfa9661;
case 0x00003184:
return 0x7a5fe4d3;
case 0x00003188:
return 0x41b4ee41;
case 0x0000318c:
return 0x801bf660;
case 0x00003190:
return 0x5d0cb799;
case 0x00003194:
return 0xb7288fa5;
case 0x00003198:
return 0x95bcc1c4;
case 0x0000319c:
return 0x850103c4;
case 0x000031a0:
return 0x4ba2a62f;
case 0x000031a4:
return 0xc09417ad;
case 0x000031a8:
return 0x0cad04c6;
case 0x000031ac:
return 0xaa22d882;
case 0x000031b0:
return 0x8aa3f07b;
case 0x000031b4:
return 0x5e8004be;
case 0x000031b8:
return 0xdb8bf004;
case 0x000031bc:
return 0xc03e10a5;
case 0x000031c0:
return 0x71cc0363;
case 0x000031c4:
return 0x230c408e;
case 0x000031c8:
return 0x8efa6522;
case 0x000031cc:
return 0x6e5f0850;
case 0x000031d0:
return 0x1e826cf1;
case 0x000031d4:
return 0x6669a93c;
case 0x000031d8:
return 0x03fd6cce;
case 0x000031dc:
return 0x6f05e576;
case 0x000031e0:
return 0xb7ef88e8;
case 0x000031e4:
return 0xe02e1d47;
case 0x000031e8:
return 0x48c29446;
case 0x000031ec:
return 0x8df61553;
case 0x000031f0:
return 0xd66ebcb1;
case 0x000031f4:
return 0x79317efb;
case 0x000031f8:
return 0x7e0fcafd;
case 0x000031fc:
return 0x7ed6441e;
case 0x00003200:
return 0xe8800c1a;
case 0x00003204:
return 0x2d17abbb;
case 0x00003208:
return 0xce0f3ae8;
case 0x0000320c:
return 0x519ac699;
case 0x00003210:
return 0x2855db3e;
case 0x00003214:
return 0x45e17ed8;
case 0x00003218:
return 0x7fec17cb;
case 0x0000321c:
return 0xfc1a10a8;
case 0x00003220:
return 0x220b4786;
case 0x00003224:
return 0xef1663ac;
case 0x00003228:
return 0x8f1e980b;
case 0x0000322c:
return 0x1206cfc3;
case 0x00003230:
return 0x035469be;
case 0x00003234:
return 0x76e2b9f5;
case 0x00003238:
return 0x9b8632b5;
case 0x0000323c:
return 0x55803324;
case 0x00003240:
return 0xa3f28e65;
case 0x00003244:
return 0x8933fe8d;
case 0x00003248:
return 0x8618f62f;
case 0x0000324c:
return 0x63a72afa;
case 0x00003250:
return 0x3738e13a;
case 0x00003254:
return 0x0f9d8e99;
case 0x00003258:
return 0x001b0453;
case 0x0000325c:
return 0x87d06735;
case 0x00003260:
return 0x9ce56c50;
case 0x00003264:
return 0x1df03667;
case 0x00003268:
return 0xb00e45b0;
case 0x0000326c:
return 0x3435f00d;
case 0x00003270:
return 0x4d8bb2d2;
case 0x00003274:
return 0x4a2e55d9;
case 0x00003278:
return 0x74149ec0;
case 0x0000327c:
return 0x5111b1e3;
case 0x00003280:
return 0x89c70ead;
case 0x00003284:
return 0x51412217;
case 0x00003288:
return 0x13764795;
case 0x0000328c:
return 0x15d3efa6;
case 0x00003290:
return 0x9af4e80a;
case 0x00003294:
return 0xd6615a50;
case 0x00003298:
return 0xf00f20e9;
case 0x0000329c:
return 0xb7a861b5;
case 0x000032a0:
return 0xbe782699;
case 0x000032a4:
return 0x2774140f;
case 0x000032a8:
return 0x46f2795b;
case 0x000032ac:
return 0x6957826b;
case 0x000032b0:
return 0x33a2c2ce;
case 0x000032b4:
return 0x56eeab38;
case 0x000032b8:
return 0xb6acb123;
case 0x000032bc:
return 0x32b1bba1;
case 0x000032c0:
return 0x11c27034;
case 0x000032c4:
return 0x80868522;
case 0x000032c8:
return 0x410bcf8d;
case 0x000032cc:
return 0x031b92ab;
case 0x000032d0:
return 0xf5f69b5f;
case 0x000032d4:
return 0x01055add;
case 0x000032d8:
return 0x8407b436;
case 0x000032dc:
return 0xe5c2bc7c;
case 0x000032e0:
return 0xe17045cc;
case 0x000032e4:
return 0xb982d8fb;
case 0x000032e8:
return 0x196cfd8b;
case 0x000032ec:
return 0xcd803064;
case 0x000032f0:
return 0x266c77e0;
case 0x000032f4:
return 0x2dd0c20d;
case 0x000032f8:
return 0xbaf6ba58;
case 0x000032fc:
return 0x7c34c948;
case 0x00003300:
return 0xf33f9c0e;
case 0x00003304:
return 0x76b39e3c;
case 0x00003308:
return 0x737a16f4;
case 0x0000330c:
return 0xa5c5dcbc;
case 0x00003310:
return 0xdcb764af;
case 0x00003314:
return 0x0637ce58;
case 0x00003318:
return 0x02a42494;
case 0x0000331c:
return 0x15eb8694;
case 0x00003320:
return 0xe88c1094;
case 0x00003324:
return 0x09ff4f4b;
case 0x00003328:
return 0x6d78a890;
case 0x0000332c:
return 0xdf4468d3;
case 0x00003330:
return 0x27f59e29;
case 0x00003334:
return 0xd27d783c;
case 0x00003338:
return 0x571a12f5;
case 0x0000333c:
return 0xc7307fbb;
case 0x00003340:
return 0xc5461cc0;
case 0x00003344:
return 0x4abd0a34;
case 0x00003348:
return 0xa229a1d1;
case 0x0000334c:
return 0x0f786a57;
case 0x00003350:
return 0x69926e7a;
case 0x00003354:
return 0x95c8bb10;
case 0x00003358:
return 0x70db4186;
case 0x0000335c:
return 0x0620f335;
case 0x00003360:
return 0x76a3d211;
case 0x00003364:
return 0x34700d23;
case 0x00003368:
return 0x53d98d50;
case 0x0000336c:
return 0xe7ea51df;
case 0x00003370:
return 0xe719833d;
case 0x00003374:
return 0x9ba0396b;
case 0x00003378:
return 0x83fc7e5c;
case 0x0000337c:
return 0xe6133ec4;
case 0x00003380:
return 0x53003241;
case 0x00003384:
return 0x18df21c9;
case 0x00003388:
return 0xe189816f;
case 0x0000338c:
return 0xf494013b;
case 0x00003390:
return 0x8329759b;
case 0x00003394:
return 0x114206c3;
case 0x00003398:
return 0xd3163d26;
case 0x0000339c:
return 0xe238bc38;
case 0x000033a0:
return 0xdfdfb3ef;
case 0x000033a4:
return 0x610c1d3d;
case 0x000033a8:
return 0xd4d1cddb;
case 0x000033ac:
return 0x659cedea;
case 0x000033b0:
return 0xbb3da488;
case 0x000033b4:
return 0x7f27db85;
case 0x000033b8:
return 0x715f6c1b;
case 0x000033bc:
return 0x900dcd9e;
case 0x000033c0:
return 0x99e3d383;
case 0x000033c4:
return 0x12a7d423;
case 0x000033c8:
return 0xec3c0952;
case 0x000033cc:
return 0xc7982152;
case 0x000033d0:
return 0xfcda133f;
case 0x000033d4:
return 0x8ae008c3;
case 0x000033d8:
return 0x6e546d1a;
case 0x000033dc:
return 0x8392563f;
case 0x000033e0:
return 0x33cd452f;
case 0x000033e4:
return 0xa45e36cc;
case 0x000033e8:
return 0x1dc13426;
case 0x000033ec:
return 0x74767a1e;
case 0x000033f0:
return 0x4ba3a935;
case 0x000033f4:
return 0x4613420c;
case 0x000033f8:
return 0x693c9181;
case 0x000033fc:
return 0x920bfe3f;
case 0x00003400:
return 0x47838400;
case 0x00003404:
return 0x16c48971;
case 0x00003408:
return 0xd718df26;
case 0x0000340c:
return 0xa70b3594;
case 0x00003410:
return 0x99d32e0e;
case 0x00003414:
return 0x7c8dcb7c;
case 0x00003418:
return 0x19a52746;
case 0x0000341c:
return 0xc61027d8;
case 0x00003420:
return 0x11f04ae4;
case 0x00003424:
return 0x84369ef7;
case 0x00003428:
return 0x2b6e07e8;
case 0x0000342c:
return 0x76f0cce6;
case 0x00003430:
return 0x3c4a0aa6;
case 0x00003434:
return 0xa2b87b7f;
case 0x00003438:
return 0xf0319625;
case 0x0000343c:
return 0xd5c1bdcb;
case 0x00003440:
return 0xda741c29;
case 0x00003444:
return 0xbedf25df;
case 0x00003448:
return 0x13ffeed8;
case 0x0000344c:
return 0x1f77374c;
case 0x00003450:
return 0xf2d36e05;
case 0x00003454:
return 0x759f30f9;
case 0x00003458:
return 0xffc14d72;
case 0x0000345c:
return 0xd3fd4415;
case 0x00003460:
return 0x5a613011;
case 0x00003464:
return 0x0798f346;
case 0x00003468:
return 0xfacb27e4;
case 0x0000346c:
return 0xebb79757;
case 0x00003470:
return 0x6eb3f3b9;
case 0x00003474:
return 0x0cd75d95;
case 0x00003478:
return 0xb5d47e3b;
case 0x0000347c:
return 0x676e00d4;
case 0x00003480:
return 0x82f01596;
case 0x00003484:
return 0x579c007c;
case 0x00003488:
return 0xe7c82da9;
case 0x0000348c:
return 0x165341e5;
case 0x00003490:
return 0x49d57d04;
case 0x00003494:
return 0x9f7811d4;
case 0x00003498:
return 0x80008548;
case 0x0000349c:
return 0x3898c3b7;
case 0x000034a0:
return 0x86ef1eeb;
case 0x000034a4:
return 0x7224b24e;
case 0x000034a8:
return 0x41a39d3b;
case 0x000034ac:
return 0x45e8e0e9;
case 0x000034b0:
return 0x38050a63;
case 0x000034b4:
return 0x682f0823;
case 0x000034b8:
return 0x4b0000c2;
case 0x000034bc:
return 0x25e512a2;
case 0x000034c0:
return 0x35f88c11;
case 0x000034c4:
return 0x95fb33db;
case 0x000034c8:
return 0x71063490;
case 0x000034cc:
return 0x4f32d064;
case 0x000034d0:
return 0x19e8aae7;
case 0x000034d4:
return 0x01668a1b;
case 0x000034d8:
return 0xb6c17541;
case 0x000034dc:
return 0xdcc8d336;
case 0x000034e0:
return 0x2d9a8c51;
case 0x000034e4:
return 0xcffd2745;
case 0x000034e8:
return 0x17624973;
case 0x000034ec:
return 0x60f6124d;
case 0x000034f0:
return 0xc335c400;
case 0x000034f4:
return 0xd32c33a3;
case 0x000034f8:
return 0x6af133e3;
case 0x000034fc:
return 0x263f2523;
case 0x00003500:
return 0x6f34d1f6;
case 0x00003504:
return 0x8549fd23;
case 0x00003508:
return 0x61820ad7;
case 0x0000350c:
return 0x5dbef1c1;
case 0x00003510:
return 0x2b21c43d;
case 0x00003514:
return 0x33d1fcdd;
case 0x00003518:
return 0xd13f296e;
case 0x0000351c:
return 0x2b78d937;
case 0x00003520:
return 0x76d35d63;
case 0x00003524:
return 0xccf33c1c;
case 0x00003528:
return 0xaf71118d;
case 0x0000352c:
return 0x9fa8752c;
case 0x00003530:
return 0xa3bf6aa6;
case 0x00003534:
return 0x338b03fe;
case 0x00003538:
return 0xf70be1dd;
case 0x0000353c:
return 0x88f163f2;
case 0x00003540:
return 0xebb344e5;
case 0x00003544:
return 0xcf0e7e7d;
case 0x00003548:
return 0x6ddf7070;
case 0x0000354c:
return 0xc5edc942;
case 0x00003550:
return 0x9d9926d1;
case 0x00003554:
return 0xec8c066b;
case 0x00003558:
return 0x8ac745b8;
case 0x0000355c:
return 0xc655d9c9;
case 0x00003560:
return 0x6fe022c1;
case 0x00003564:
return 0xd2d364f9;
case 0x00003568:
return 0x709ab8b7;
case 0x0000356c:
return 0xdc358dbb;
case 0x00003570:
return 0x6fe6c19a;
case 0x00003574:
return 0x648a6c51;
case 0x00003578:
return 0x4352d4a1;
case 0x0000357c:
return 0xb06f959b;
case 0x00003580:
return 0xa7b2432a;
case 0x00003584:
return 0x26938373;
case 0x00003588:
return 0x37329afc;
case 0x0000358c:
return 0x2a89e1ca;
case 0x00003590:
return 0xc0c5e50c;
case 0x00003594:
return 0x011bc559;
case 0x00003598:
return 0x0dec266a;
case 0x0000359c:
return 0x5f697255;
case 0x000035a0:
return 0xc35050e9;
case 0x000035a4:
return 0x51ddb00e;
case 0x000035a8:
return 0x7555ce12;
case 0x000035ac:
return 0xa2f25717;
case 0x000035b0:
return 0x09f85286;
case 0x000035b4:
return 0x1438b65a;
case 0x000035b8:
return 0x26959df3;
case 0x000035bc:
return 0xa5b5d722;
case 0x000035c0:
return 0xf3f7a367;
case 0x000035c4:
return 0xcc59ccc9;
case 0x000035c8:
return 0x9a831b54;
case 0x000035cc:
return 0x21f94d72;
case 0x000035d0:
return 0x58d2f36d;
case 0x000035d4:
return 0xef38fd49;
case 0x000035d8:
return 0xb1e790f0;
case 0x000035dc:
return 0x4b452918;
case 0x000035e0:
return 0x2e9d1175;
case 0x000035e4:
return 0x04fe0cbb;
case 0x000035e8:
return 0x9c165964;
case 0x000035ec:
return 0x1aeecef7;
case 0x000035f0:
return 0x3efa41be;
case 0x000035f4:
return 0xcf3f1745;
case 0x000035f8:
return 0xae562002;
case 0x000035fc:
return 0xbb57c6b0;
case 0x00003600:
return 0x15fd5896;
case 0x00003604:
return 0xd4253034;
case 0x00003608:
return 0x38b559c7;
case 0x0000360c:
return 0xbaa08400;
case 0x00003610:
return 0xf2fc18db;
case 0x00003614:
return 0xca99d75c;
case 0x00003618:
return 0x474dc026;
case 0x0000361c:
return 0xa7924748;
case 0x00003620:
return 0x7d0077bc;
case 0x00003624:
return 0xd76f6909;
case 0x00003628:
return 0x934cbb40;
case 0x0000362c:
return 0x32205d0f;
case 0x00003630:
return 0xf15b8e7b;
case 0x00003634:
return 0x731a44c5;
case 0x00003638:
return 0xeff18e72;
case 0x0000363c:
return 0xa88a6e50;
case 0x00003640:
return 0x7404a642;
case 0x00003644:
return 0x6f0f4722;
case 0x00003648:
return 0x7bc49412;
case 0x0000364c:
return 0xcf76c371;
case 0x00003650:
return 0xd74bb7ec;
case 0x00003654:
return 0xa71ba7c6;
case 0x00003658:
return 0x2d7a96d2;
case 0x0000365c:
return 0xc053165f;
case 0x00003660:
return 0x3eb007ac;
case 0x00003664:
return 0xce6b3748;
case 0x00003668:
return 0x392a0a8c;
case 0x0000366c:
return 0xb4bab6d1;
case 0x00003670:
return 0xfafed534;
case 0x00003674:
return 0x441d6909;
case 0x00003678:
return 0xf89e8115;
case 0x0000367c:
return 0x28110901;
case 0x00003680:
return 0x9cfee56c;
case 0x00003684:
return 0xf61c8579;
case 0x00003688:
return 0x8f36117f;
case 0x0000368c:
return 0x8a31a9c6;
case 0x00003690:
return 0x58ecb45a;
case 0x00003694:
return 0xe9359ef0;
case 0x00003698:
return 0x577d299f;
case 0x0000369c:
return 0xb0c19195;
case 0x000036a0:
return 0x73ac3248;
case 0x000036a4:
return 0xab1508be;
case 0x000036a8:
return 0xefba77f1;
case 0x000036ac:
return 0xe33828cd;
case 0x000036b0:
return 0x9b598759;
case 0x000036b4:
return 0x5610ef14;
case 0x000036b8:
return 0x6a14717f;
case 0x000036bc:
return 0x43e40e3f;
case 0x000036c0:
return 0xdce85466;
case 0x000036c4:
return 0x68583bd4;
case 0x000036c8:
return 0xeb4d2007;
case 0x000036cc:
return 0xd8c88c94;
case 0x000036d0:
return 0xf52e94a5;
case 0x000036d4:
return 0xf95fda52;
case 0x000036d8:
return 0x92ba6142;
case 0x000036dc:
return 0x8fd22865;
case 0x000036e0:
return 0x0181976b;
case 0x000036e4:
return 0xbd476bbc;
case 0x000036e8:
return 0x65dcfa5f;
case 0x000036ec:
return 0xec936f75;
case 0x000036f0:
return 0x03ea35cf;
case 0x000036f4:
return 0x86e2d790;
case 0x000036f8:
return 0x61ae924e;
case 0x000036fc:
return 0x70f9df74;
case 0x00003700:
return 0x83382481;
case 0x00003704:
return 0x298e2484;
case 0x00003708:
return 0x37ccd68d;
case 0x0000370c:
return 0x0a05474e;
case 0x00003710:
return 0x788deb79;
case 0x00003714:
return 0x7a8985a1;
case 0x00003718:
return 0xc355e84f;
case 0x0000371c:
return 0xd7a857a2;
case 0x00003720:
return 0x5fd1c93c;
case 0x00003724:
return 0xfb382408;
case 0x00003728:
return 0x6e5c7129;
case 0x0000372c:
return 0xe56791bb;
case 0x00003730:
return 0x00018f79;
case 0x00003734:
return 0x9b5c4238;
case 0x00003738:
return 0x04ecce66;
case 0x0000373c:
return 0x7713137c;
case 0x00003740:
return 0xd2d153c6;
case 0x00003744:
return 0x46b858e2;
case 0x00003748:
return 0x0b8f4d5f;
case 0x0000374c:
return 0xe5ba4f2a;
case 0x00003750:
return 0x3d115e42;
case 0x00003754:
return 0x98682e31;
case 0x00003758:
return 0xe079e9c8;
case 0x0000375c:
return 0xd521b18d;
case 0x00003760:
return 0x7244e035;
case 0x00003764:
return 0xcad118d2;
case 0x00003768:
return 0x7ffebf78;
case 0x0000376c:
return 0xce3a48f4;
case 0x00003770:
return 0x3739b001;
case 0x00003774:
return 0x1f7b9b64;
case 0x00003778:
return 0xb34fcdad;
case 0x0000377c:
return 0xb44783de;
case 0x00003780:
return 0x4dae6b0f;
case 0x00003784:
return 0x40f542c5;
case 0x00003788:
return 0x462c9277;
case 0x0000378c:
return 0x6a4b1b6e;
case 0x00003790:
return 0x7846280f;
case 0x00003794:
return 0x58a853cb;
case 0x00003798:
return 0x0fb74c4c;
case 0x0000379c:
return 0x3386cfd3;
case 0x000037a0:
return 0x97d36136;
case 0x000037a4:
return 0x7edee189;
case 0x000037a8:
return 0x39d1b84b;
case 0x000037ac:
return 0x40ce2554;
case 0x000037b0:
return 0x80899c23;
case 0x000037b4:
return 0x0c565d71;
case 0x000037b8:
return 0xcc1f2db7;
case 0x000037bc:
return 0x5bd502fc;
case 0x000037c0:
return 0x9d5d6a35;
case 0x000037c4:
return 0x1b6d2876;
case 0x000037c8:
return 0x3221903d;
case 0x000037cc:
return 0xaa0b0b5e;
case 0x000037d0:
return 0x39ec007b;
case 0x000037d4:
return 0x491c1ad6;
case 0x000037d8:
return 0xd250b62f;
case 0x000037dc:
return 0x55bfaf0d;
case 0x000037e0:
return 0xb7edac6c;
case 0x000037e4:
return 0xd34324c9;
case 0x000037e8:
return 0xd9f88b9d;
case 0x000037ec:
return 0xc31f3c6d;
case 0x000037f0:
return 0x75c76aca;
case 0x000037f4:
return 0x8f08898e;
case 0x000037f8:
return 0x3932c54e;
case 0x000037fc:
return 0x6ccded08;
case 0x00003800:
return 0x90c666b1;
case 0x00003804:
return 0x1eea766d;
case 0x00003808:
return 0xbf4106aa;
case 0x0000380c:
return 0x63652439;
case 0x00003810:
return 0x87dae4f3;
case 0x00003814:
return 0x74b99cb9;
case 0x00003818:
return 0xbfe923e2;
case 0x0000381c:
return 0x3b395fc3;
case 0x00003820:
return 0x996d5e5c;
case 0x00003824:
return 0xfcb3622d;
case 0x00003828:
return 0x05bf1a84;
case 0x0000382c:
return 0xbc066738;
case 0x00003830:
return 0xf99e3096;
case 0x00003834:
return 0xc3844d2b;
case 0x00003838:
return 0x97639168;
case 0x0000383c:
return 0x3802e066;
case 0x00003840:
return 0xc9d08cbf;
case 0x00003844:
return 0x01efb0c0;
case 0x00003848:
return 0x62e873ca;
case 0x0000384c:
return 0x0de3bbb4;
case 0x00003850:
return 0x3a39aa0b;
case 0x00003854:
return 0x02015140;
case 0x00003858:
return 0x1b196a12;
case 0x0000385c:
return 0xaa02e751;
case 0x00003860:
return 0x0329c4fe;
case 0x00003864:
return 0xec8363dd;
case 0x00003868:
return 0x4ef014f6;
case 0x0000386c:
return 0x2eb4fe08;
case 0x00003870:
return 0x5aca1e9e;
case 0x00003874:
return 0x53956d0c;
case 0x00003878:
return 0x623ecd87;
case 0x0000387c:
return 0xd57d27c9;
case 0x00003880:
return 0xb3e55102;
case 0x00003884:
return 0x5fcc899b;
case 0x00003888:
return 0xbc707c14;
case 0x0000388c:
return 0x240f8960;
case 0x00003890:
return 0x758d30ae;
case 0x00003894:
return 0x7602d7a2;
case 0x00003898:
return 0xbd75f1bc;
case 0x0000389c:
return 0xa07a8330;
case 0x000038a0:
return 0xe2690df1;
case 0x000038a4:
return 0x460b023c;
case 0x000038a8:
return 0xa6628427;
case 0x000038ac:
return 0xe3e89700;
case 0x000038b0:
return 0x7c754b2e;
case 0x000038b4:
return 0xc67ca9e5;
case 0x000038b8:
return 0xafdb590a;
case 0x000038bc:
return 0x5b75e549;
case 0x000038c0:
return 0xfdcb208a;
case 0x000038c4:
return 0xbe0a9e3b;
case 0x000038c8:
return 0x6649b8a0;
case 0x000038cc:
return 0x51d709d1;
case 0x000038d0:
return 0xfeaa57b1;
case 0x000038d4:
return 0xcc9342f3;
case 0x000038d8:
return 0x246ee2fc;
case 0x000038dc:
return 0x7fec0118;
case 0x000038e0:
return 0x47bb65ec;
case 0x000038e4:
return 0x0a68e9d4;
case 0x000038e8:
return 0x6ed7dc5c;
case 0x000038ec:
return 0xb43b8824;
case 0x000038f0:
return 0xe48e12a6;
case 0x000038f4:
return 0x6824e9c1;
case 0x000038f8:
return 0x673cc33c;
case 0x000038fc:
return 0xe96ba8d7;
case 0x00003900:
return 0x2de78961;
case 0x00003904:
return 0x5f4b6208;
case 0x00003908:
return 0x93e93723;
case 0x0000390c:
return 0xffb8dfa9;
case 0x00003910:
return 0xc934d346;
case 0x00003914:
return 0xba0f8de4;
case 0x00003918:
return 0xa19a292e;
case 0x0000391c:
return 0xe6f33116;
case 0x00003920:
return 0xa3854cbb;
case 0x00003924:
return 0x2c4290dd;
case 0x00003928:
return 0x835c69bf;
case 0x0000392c:
return 0x7cdfbdfa;
case 0x00003930:
return 0x3208d9cd;
case 0x00003934:
return 0x25cad271;
case 0x00003938:
return 0x9e0ea7ee;
case 0x0000393c:
return 0x8c956bdc;
case 0x00003940:
return 0x26f155f6;
case 0x00003944:
return 0x493ec3ab;
case 0x00003948:
return 0x5bbd8e0a;
case 0x0000394c:
return 0x830c8c7b;
case 0x00003950:
return 0xec2c5363;
case 0x00003954:
return 0x59df2fb5;
case 0x00003958:
return 0xf84732b7;
case 0x0000395c:
return 0x8d732b09;
case 0x00003960:
return 0xb06264cc;
case 0x00003964:
return 0xedc2c3f3;
case 0x00003968:
return 0xee7cfcbc;
case 0x0000396c:
return 0x88c74673;
case 0x00003970:
return 0xc0ad3d03;
case 0x00003974:
return 0x2b19569c;
case 0x00003978:
return 0x1c7775bd;
case 0x0000397c:
return 0x956025d2;
case 0x00003980:
return 0x2609a252;
case 0x00003984:
return 0x56a5e6fd;
case 0x00003988:
return 0x17de0b9f;
case 0x0000398c:
return 0x491bd7e7;
case 0x00003990:
return 0xa8bf1247;
case 0x00003994:
return 0x343e01d4;
case 0x00003998:
return 0x5da02d85;
case 0x0000399c:
return 0xa81482e9;
case 0x000039a0:
return 0x40083ff1;
case 0x000039a4:
return 0x1278515c;
case 0x000039a8:
return 0x5c67348a;
case 0x000039ac:
return 0x61f4094c;
case 0x000039b0:
return 0x7baf7f4a;
case 0x000039b4:
return 0x6a356f44;
case 0x000039b8:
return 0xb11c8b4a;
case 0x000039bc:
return 0x6711cb9f;
case 0x000039c0:
return 0x7e9bd366;
case 0x000039c4:
return 0xe0e09e1e;
case 0x000039c8:
return 0xd7787f8f;
case 0x000039cc:
return 0x084854a1;
case 0x000039d0:
return 0x7fc84f93;
case 0x000039d4:
return 0xcb563817;
case 0x000039d8:
return 0x09c51b3a;
case 0x000039dc:
return 0x185bf0a0;
case 0x000039e0:
return 0x5c3fa7ff;
case 0x000039e4:
return 0x764f43fa;
case 0x000039e8:
return 0x0e02e788;
case 0x000039ec:
return 0x86946f70;
case 0x000039f0:
return 0x4511c5dc;
case 0x000039f4:
return 0x949f2a43;
case 0x000039f8:
return 0xdd566edf;
case 0x000039fc:
return 0x547a3484;
case 0x00003a00:
return 0x0e4a34bd;
case 0x00003a04:
return 0x71661a8b;
case 0x00003a08:
return 0xf400d850;
case 0x00003a0c:
return 0xca29b8bb;
case 0x00003a10:
return 0x7e1ce325;
case 0x00003a14:
return 0xbdc9aa3e;
case 0x00003a18:
return 0x0ae77956;
case 0x00003a1c:
return 0x46604f0d;
case 0x00003a20:
return 0x28c50464;
case 0x00003a24:
return 0x18518cb9;
case 0x00003a28:
return 0x215cb6f8;
case 0x00003a2c:
return 0xa27c7a37;
case 0x00003a30:
return 0xee40a978;
case 0x00003a34:
return 0xe642809d;
case 0x00003a38:
return 0xb557fd6a;
case 0x00003a3c:
return 0x4a49d33d;
case 0x00003a40:
return 0xd3e448b8;
case 0x00003a44:
return 0x507793e3;
case 0x00003a48:
return 0xaf84dcfb;
case 0x00003a4c:
return 0xdcddb1bb;
case 0x00003a50:
return 0x8b440f34;
case 0x00003a54:
return 0x9a114ded;
case 0x00003a58:
return 0x837092e9;
case 0x00003a5c:
return 0x73b221d7;
case 0x00003a60:
return 0xefe35200;
case 0x00003a64:
return 0xc9d1efe1;
case 0x00003a68:
return 0x076b15bf;
case 0x00003a6c:
return 0x18437912;
case 0x00003a70:
return 0xef69fcf4;
case 0x00003a74:
return 0x2ead13a3;
case 0x00003a78:
return 0xca0dac4f;
case 0x00003a7c:
return 0xd6e83ac6;
case 0x00003a80:
return 0xb8592edf;
case 0x00003a84:
return 0x2de22eeb;
case 0x00003a88:
return 0x08c5e5a3;
case 0x00003a8c:
return 0x3d5c802e;
case 0x00003a90:
return 0x2e74f4af;
case 0x00003a94:
return 0x4e51ef6b;
case 0x00003a98:
return 0x9a26b1dc;
case 0x00003a9c:
return 0x72fe076f;
case 0x00003aa0:
return 0xee4a63a8;
case 0x00003aa4:
return 0x855cdd6c;
case 0x00003aa8:
return 0xd4fd06db;
case 0x00003aac:
return 0x14c78458;
case 0x00003ab0:
return 0xb578fc43;
case 0x00003ab4:
return 0x2e1fb011;
case 0x00003ab8:
return 0x5653e6ef;
case 0x00003abc:
return 0x8bae77ae;
case 0x00003ac0:
return 0x45a40776;
case 0x00003ac4:
return 0x24e870d3;
case 0x00003ac8:
return 0xfdc4cfab;
case 0x00003acc:
return 0x702212d5;
case 0x00003ad0:
return 0x73a6025e;
case 0x00003ad4:
return 0xe3cc12b6;
case 0x00003ad8:
return 0x95922c0c;
case 0x00003adc:
return 0x130e32d5;
case 0x00003ae0:
return 0x8e9807b6;
case 0x00003ae4:
return 0x83e22537;
case 0x00003ae8:
return 0x250fe83d;
case 0x00003aec:
return 0xba179534;
case 0x00003af0:
return 0xbf493859;
case 0x00003af4:
return 0xfb4bc21c;
case 0x00003af8:
return 0xd8928424;
case 0x00003afc:
return 0x681a5ee9;
case 0x00003b00:
return 0x0b0ce946;
case 0x00003b04:
return 0x64d72625;
case 0x00003b08:
return 0xa28c217d;
case 0x00003b0c:
return 0xd13bbd34;
case 0x00003b10:
return 0x79197f55;
case 0x00003b14:
return 0x3a015cab;
case 0x00003b18:
return 0x7b95d44f;
case 0x00003b1c:
return 0xd4da88fa;
case 0x00003b20:
return 0xf0a47acb;
case 0x00003b24:
return 0xbf77168d;
case 0x00003b28:
return 0x69d11f98;
case 0x00003b2c:
return 0x06db1d8c;
case 0x00003b30:
return 0xf9610d83;
case 0x00003b34:
return 0x221ec287;
case 0x00003b38:
return 0x9cca7fe7;
case 0x00003b3c:
return 0x5314c72b;
case 0x00003b40:
return 0xc26a54e1;
case 0x00003b44:
return 0x22f81650;
case 0x00003b48:
return 0x139afcf4;
case 0x00003b4c:
return 0xdf3977b6;
case 0x00003b50:
return 0xb6d0bd2b;
case 0x00003b54:
return 0x2e45aa47;
case 0x00003b58:
return 0x8572fdbe;
case 0x00003b5c:
return 0x6752032a;
case 0x00003b60:
return 0xc286570b;
case 0x00003b64:
return 0x09bb0a77;
case 0x00003b68:
return 0x49f4e5c9;
case 0x00003b6c:
return 0xf6b9c89b;
case 0x00003b70:
return 0xc406c97b;
case 0x00003b74:
return 0x3ac2fcac;
case 0x00003b78:
return 0x02f5e333;
case 0x00003b7c:
return 0x53874a1f;
case 0x00003b80:
return 0x7d4ac776;
case 0x00003b84:
return 0x5f41f2d3;
case 0x00003b88:
return 0x1115f055;
case 0x00003b8c:
return 0xfba0f518;
case 0x00003b90:
return 0x2a5d5f51;
case 0x00003b94:
return 0x64e7555a;
case 0x00003b98:
return 0xd89b562f;
case 0x00003b9c:
return 0x8553817a;
case 0x00003ba0:
return 0xe42af543;
case 0x00003ba4:
return 0x91e59b87;
case 0x00003ba8:
return 0xb8ca8967;
case 0x00003bac:
return 0x3eb24a88;
case 0x00003bb0:
return 0x42abdc63;
case 0x00003bb4:
return 0x3d4337d2;
case 0x00003bb8:
return 0xd9d68bf4;
case 0x00003bbc:
return 0x54fa44f5;
case 0x00003bc0:
return 0xed1df273;
case 0x00003bc4:
return 0xbaea0f9a;
case 0x00003bc8:
return 0x9b15b589;
case 0x00003bcc:
return 0xaf0bda5d;
case 0x00003bd0:
return 0x3798fb19;
case 0x00003bd4:
return 0x815b1b72;
case 0x00003bd8:
return 0xae61b6da;
case 0x00003bdc:
return 0x78ae41d4;
case 0x00003be0:
return 0x9f45efd2;
case 0x00003be4:
return 0x0e35ee73;
case 0x00003be8:
return 0x3d2743e2;
case 0x00003bec:
return 0x1059275c;
case 0x00003bf0:
return 0x64a4e147;
case 0x00003bf4:
return 0x3155fe95;
case 0x00003bf8:
return 0xec09d9e9;
case 0x00003bfc:
return 0x2970f20d;
case 0x00003c00:
return 0xcf64e7b5;
case 0x00003c04:
return 0xf1d61ccd;
case 0x00003c08:
return 0xdfe54a82;
case 0x00003c0c:
return 0x76c69dc1;
case 0x00003c10:
return 0x4dfb7169;
case 0x00003c14:
return 0x09bf6732;
case 0x00003c18:
return 0xd5f95583;
case 0x00003c1c:
return 0x17c6337a;
case 0x00003c20:
return 0x563d947d;
case 0x00003c24:
return 0x8dcc0b09;
case 0x00003c28:
return 0x1415d444;
case 0x00003c2c:
return 0x6ce82c54;
case 0x00003c30:
return 0x01960a53;
case 0x00003c34:
return 0x1b2b89e8;
case 0x00003c38:
return 0x7b6fba91;
case 0x00003c3c:
return 0x1a82c66a;
case 0x00003c40:
return 0x69e679ed;
case 0x00003c44:
return 0x032fb63d;
case 0x00003c48:
return 0xfe56cf2e;
case 0x00003c4c:
return 0x7bf13f7e;
case 0x00003c50:
return 0xfe2469a9;
case 0x00003c54:
return 0x933ca04f;
case 0x00003c58:
return 0x322d074b;
case 0x00003c5c:
return 0xf27c2175;
case 0x00003c60:
return 0x70b0ccbf;
case 0x00003c64:
return 0x2430aa3c;
case 0x00003c68:
return 0x9276c20d;
case 0x00003c6c:
return 0xfa742abd;
case 0x00003c70:
return 0xad1f58d3;
case 0x00003c74:
return 0x029884be;
case 0x00003c78:
return 0xba9887e0;
case 0x00003c7c:
return 0x590f317b;
case 0x00003c80:
return 0x55a6f403;
case 0x00003c84:
return 0x464976b7;
case 0x00003c88:
return 0x849839d5;
case 0x00003c8c:
return 0x51b04dcb;
case 0x00003c90:
return 0xa1c0be29;
case 0x00003c94:
return 0x9f96ee5b;
case 0x00003c98:
return 0x2975d1b3;
case 0x00003c9c:
return 0xdf7f8784;
case 0x00003ca0:
return 0x23910a27;
case 0x00003ca4:
return 0x494e1dbe;
case 0x00003ca8:
return 0x697c125d;
case 0x00003cac:
return 0xa38aeb36;
case 0x00003cb0:
return 0x89e1cca8;
case 0x00003cb4:
return 0xc37edb65;
case 0x00003cb8:
return 0xc0391506;
case 0x00003cbc:
return 0x3746b7cf;
case 0x00003cc0:
return 0x5f72f605;
case 0x00003cc4:
return 0x3da2a2f2;
case 0x00003cc8:
return 0x154be745;
case 0x00003ccc:
return 0x851905ae;
case 0x00003cd0:
return 0xde6c3a41;
case 0x00003cd4:
return 0xd5574ab1;
case 0x00003cd8:
return 0x7541da9e;
case 0x00003cdc:
return 0xdae5d9fb;
case 0x00003ce0:
return 0x2208c8ef;
case 0x00003ce4:
return 0x135bf5aa;
case 0x00003ce8:
return 0xb553d782;
case 0x00003cec:
return 0xc04cdf21;
case 0x00003cf0:
return 0xb1816bf0;
case 0x00003cf4:
return 0x90a35a84;
case 0x00003cf8:
return 0x1c01cb80;
case 0x00003cfc:
return 0x8942e58b;
case 0x00003d00:
return 0x9229dfc6;
case 0x00003d04:
return 0xb9451aba;
case 0x00003d08:
return 0x2a2e4482;
case 0x00003d0c:
return 0x47831b4e;
case 0x00003d10:
return 0x91ff385d;
case 0x00003d14:
return 0xf219800c;
case 0x00003d18:
return 0x7b84d59a;
case 0x00003d1c:
return 0x6f0a227c;
case 0x00003d20:
return 0xcf7be443;
case 0x00003d24:
return 0xf7c2e278;
case 0x00003d28:
return 0x6aa8bba1;
case 0x00003d2c:
return 0xcf03e7bd;
case 0x00003d30:
return 0x6ba051ef;
case 0x00003d34:
return 0xda0c263b;
case 0x00003d38:
return 0x73efd86e;
case 0x00003d3c:
return 0x614aaeda;
case 0x00003d40:
return 0xa846f0eb;
case 0x00003d44:
return 0xa65e774d;
case 0x00003d48:
return 0x50448e07;
case 0x00003d4c:
return 0xc0cc66a9;
case 0x00003d50:
return 0xee0b1ac3;
case 0x00003d54:
return 0xfa277e63;
case 0x00003d58:
return 0x9e879014;
case 0x00003d5c:
return 0xe39f2978;
case 0x00003d60:
return 0xb81c7a31;
case 0x00003d64:
return 0x2023559d;
case 0x00003d68:
return 0xc9d62ac5;
case 0x00003d6c:
return 0x1e7e1a2a;
case 0x00003d70:
return 0xfbd47f31;
case 0x00003d74:
return 0xc108772c;
case 0x00003d78:
return 0x2c189aa0;
case 0x00003d7c:
return 0x73ee16e0;
case 0x00003d80:
return 0x366ca762;
case 0x00003d84:
return 0x67061445;
case 0x00003d88:
return 0xb4c22689;
case 0x00003d8c:
return 0x07d14ab4;
case 0x00003d90:
return 0xebf015ca;
case 0x00003d94:
return 0x5253aa9e;
case 0x00003d98:
return 0x0a208ffe;
case 0x00003d9c:
return 0x9dc52674;
case 0x00003da0:
return 0x5aa3d090;
case 0x00003da4:
return 0xbf979ff3;
case 0x00003da8:
return 0xb49a6261;
case 0x00003dac:
return 0xd752eb23;
case 0x00003db0:
return 0x0d80b764;
case 0x00003db4:
return 0x4c2b91a5;
case 0x00003db8:
return 0x8693f8a2;
case 0x00003dbc:
return 0x429d0e31;
case 0x00003dc0:
return 0x4aef2649;
case 0x00003dc4:
return 0xbd77b062;
case 0x00003dc8:
return 0xe949f0be;
case 0x00003dcc:
return 0x36f1bfe9;
case 0x00003dd0:
return 0x2a2f2c47;
case 0x00003dd4:
return 0xa4996d0e;
case 0x00003dd8:
return 0x2e07b3aa;
case 0x00003ddc:
return 0x21e203fe;
case 0x00003de0:
return 0x079d68c9;
case 0x00003de4:
return 0xd32c4ce5;
case 0x00003de8:
return 0xe0d17d16;
case 0x00003dec:
return 0x1e20e123;
case 0x00003df0:
return 0x3573c6f3;
case 0x00003df4:
return 0x4de3be5c;
case 0x00003df8:
return 0xecf4a687;
case 0x00003dfc:
return 0x5b17e6a4;
case 0x00003e00:
return 0xf1afd674;
case 0x00003e04:
return 0x4b5ae28a;
case 0x00003e08:
return 0xea93a576;
case 0x00003e0c:
return 0xafcffdca;
case 0x00003e10:
return 0xa273a08b;
case 0x00003e14:
return 0x20993372;
case 0x00003e18:
return 0x904fa34e;
case 0x00003e1c:
return 0xfc31d233;
case 0x00003e20:
return 0x210b4897;
case 0x00003e24:
return 0x25fdf7f0;
case 0x00003e28:
return 0x7546fd5a;
case 0x00003e2c:
return 0x3d43754d;
case 0x00003e30:
return 0xde8deb5f;
case 0x00003e34:
return 0xcc63d239;
case 0x00003e38:
return 0xc6bbd594;
case 0x00003e3c:
return 0x72c0a113;
case 0x00003e40:
return 0x594fc6e1;
case 0x00003e44:
return 0xa5c0f88c;
case 0x00003e48:
return 0xf1b9f6c6;
case 0x00003e4c:
return 0xba0f4934;
case 0x00003e50:
return 0x506dc3e5;
case 0x00003e54:
return 0x1ebfd2f2;
case 0x00003e58:
return 0x73540f1f;
case 0x00003e5c:
return 0x2961468f;
case 0x00003e60:
return 0xefec56ce;
case 0x00003e64:
return 0x2e728672;
case 0x00003e68:
return 0x3a7f0769;
case 0x00003e6c:
return 0x56f36f57;
case 0x00003e70:
return 0x62009eae;
case 0x00003e74:
return 0xd4626672;
case 0x00003e78:
return 0xc5a09fab;
case 0x00003e7c:
return 0x4722d16d;
case 0x00003e80:
return 0xa2a56cad;
case 0x00003e84:
return 0xa424f566;
case 0x00003e88:
return 0x9baa90f6;
case 0x00003e8c:
return 0x9a899de3;
case 0x00003e90:
return 0x58acdef0;
case 0x00003e94:
return 0xdc4b2e97;
case 0x00003e98:
return 0x040ddcca;
case 0x00003e9c:
return 0x50749b0f;
case 0x00003ea0:
return 0xcf09df55;
case 0x00003ea4:
return 0x57075ec6;
case 0x00003ea8:
return 0xae51d7f3;
case 0x00003eac:
return 0x1c165a2c;
case 0x00003eb0:
return 0xb199f1da;
case 0x00003eb4:
return 0xe6165c77;
case 0x00003eb8:
return 0xf29fb40a;
case 0x00003ebc:
return 0x8db2ac8d;
case 0x00003ec0:
return 0xad2f1ff3;
case 0x00003ec4:
return 0x027bcbe5;
case 0x00003ec8:
return 0x6665220e;
case 0x00003ecc:
return 0x12a089e6;
case 0x00003ed0:
return 0xb65977e2;
case 0x00003ed4:
return 0xd6a5592d;
case 0x00003ed8:
return 0x4c8cdeb4;
case 0x00003edc:
return 0x6f1890ca;
case 0x00003ee0:
return 0x6d20b5cf;
case 0x00003ee4:
return 0x991ee040;
case 0x00003ee8:
return 0x32c3b590;
case 0x00003eec:
return 0xeaa39d3b;
case 0x00003ef0:
return 0xdad4e30b;
case 0x00003ef4:
return 0x8f237090;
case 0x00003ef8:
return 0x145c36a9;
case 0x00003efc:
return 0x1f6f18fa;
case 0x00003f00:
return 0xf429ac2b;
case 0x00003f04:
return 0xb1a34e0f;
case 0x00003f08:
return 0xc2b367a4;
case 0x00003f0c:
return 0x45be77c6;
case 0x00003f10:
return 0x1b3a451f;
case 0x00003f14:
return 0x18e8723d;
case 0x00003f18:
return 0x5a43b231;
case 0x00003f1c:
return 0x4c70861a;
case 0x00003f20:
return 0x6d84d55b;
case 0x00003f24:
return 0xb2845ddf;
case 0x00003f28:
return 0x9392c991;
case 0x00003f2c:
return 0xdb28f053;
case 0x00003f30:
return 0xd18144a4;
case 0x00003f34:
return 0x91297a63;
case 0x00003f38:
return 0x8e101e5b;
case 0x00003f3c:
return 0xeecff3ed;
case 0x00003f40:
return 0xef8c2bdd;
case 0x00003f44:
return 0xeeaca2b8;
case 0x00003f48:
return 0x4b862a34;
case 0x00003f4c:
return 0x46449b86;
case 0x00003f50:
return 0x4573f4e7;
case 0x00003f54:
return 0x877428da;
case 0x00003f58:
return 0xe5708912;
case 0x00003f5c:
return 0xfdcf147b;
case 0x00003f60:
return 0x1ce3a508;
case 0x00003f64:
return 0xdb5c30c4;
case 0x00003f68:
return 0x51beb155;
case 0x00003f6c:
return 0xf1e1aba7;
case 0x00003f70:
return 0x27ac6af4;
case 0x00003f74:
return 0xd3ff41ec;
case 0x00003f78:
return 0x1d7fa0a2;
case 0x00003f7c:
return 0xca3d06e3;
case 0x00003f80:
return 0x2b4192b3;
case 0x00003f84:
return 0xcf081ae7;
case 0x00003f88:
return 0x52badd92;
case 0x00003f8c:
return 0x9961647c;
case 0x00003f90:
return 0xb5f6dc2e;
case 0x00003f94:
return 0x03dd05c9;
case 0x00003f98:
return 0xea8c5c0c;
case 0x00003f9c:
return 0xf21d36a2;
case 0x00003fa0:
return 0x58788aba;
case 0x00003fa4:
return 0xa78bd480;
case 0x00003fa8:
return 0x7ba1c2c1;
case 0x00003fac:
return 0xee791381;
case 0x00003fb0:
return 0x7ec2a7f3;
case 0x00003fb4:
return 0xcc18ba45;
case 0x00003fb8:
return 0x24211344;
case 0x00003fbc:
return 0x16ffe798;
case 0x00003fc0:
return 0x008da21d;
case 0x00003fc4:
return 0x3e09aa9c;
case 0x00003fc8:
return 0x50a80852;
case 0x00003fcc:
return 0xda5e209e;
case 0x00003fd0:
return 0x43e9ed2c;
case 0x00003fd4:
return 0x4bf1fcff;
case 0x00003fd8:
return 0xa6f40f54;
case 0x00003fdc:
return 0xe81d34ac;
case 0x00003fe0:
return 0x45436fd3;
case 0x00003fe4:
return 0x8e3d7da7;
case 0x00003fe8:
return 0x44d1a225;
case 0x00003fec:
return 0xad0c40eb;
case 0x00003ff0:
return 0xb3f0a484;
case 0x00003ff4:
return 0x2072a7a6;
case 0x00003ff8:
return 0x86dbccc8;
case 0x00003ffc:
return 0xce02ecc7;
case 0x00004000:
return 0xa57cba23;
case 0x00004004:
return 0x99ee46d9;
case 0x00004008:
return 0x6db7e83d;
case 0x0000400c:
return 0x19a69320;
case 0x00004010:
return 0xe35b2f7f;
case 0x00004014:
return 0x419227e3;
case 0x00004018:
return 0x17cc42cf;
case 0x0000401c:
return 0xe9da7fcd;
case 0x00004020:
return 0xe96d01e6;
case 0x00004024:
return 0x4e6666ff;
case 0x00004028:
return 0x2b8bdcfe;
case 0x0000402c:
return 0xb427d61e;
case 0x00004030:
return 0x509fee71;
case 0x00004034:
return 0x978417c8;
case 0x00004038:
return 0x0c2d7951;
case 0x0000403c:
return 0xf8239c72;
case 0x00004040:
return 0x049490bf;
case 0x00004044:
return 0xa2ac8e89;
case 0x00004048:
return 0x48934959;
case 0x0000404c:
return 0x04860e51;
case 0x00004050:
return 0x6927ec30;
case 0x00004054:
return 0x87471b99;
case 0x00004058:
return 0xdafb9abb;
case 0x0000405c:
return 0x8fd0e860;
case 0x00004060:
return 0x2eeb65b0;
case 0x00004064:
return 0x60167bb3;
case 0x00004068:
return 0x3a767dfb;
case 0x0000406c:
return 0x04af826a;
case 0x00004070:
return 0x4415cbc7;
case 0x00004074:
return 0xa5ef7d80;
case 0x00004078:
return 0xd970063c;
case 0x0000407c:
return 0x06173606;
case 0x00004080:
return 0xf1273f69;
case 0x00004084:
return 0x9cb8abbe;
case 0x00004088:
return 0xd2412638;
case 0x0000408c:
return 0x18b6065f;
case 0x00004090:
return 0x417e9311;
case 0x00004094:
return 0x57386f9a;
case 0x00004098:
return 0x69d398ed;
case 0x0000409c:
return 0x33ff9e56;
case 0x000040a0:
return 0x5993336e;
case 0x000040a4:
return 0xdff50b2b;
case 0x000040a8:
return 0xe0f070fa;
case 0x000040ac:
return 0xb0017c4d;
case 0x000040b0:
return 0xa2f5e943;
case 0x000040b4:
return 0xd707b253;
case 0x000040b8:
return 0x00955fab;
case 0x000040bc:
return 0xf3bf91c8;
case 0x000040c0:
return 0xcc8806a3;
case 0x000040c4:
return 0x2fba4f2b;
case 0x000040c8:
return 0x68e77897;
case 0x000040cc:
return 0xb2310c28;
case 0x000040d0:
return 0x048ad77a;
case 0x000040d4:
return 0xd2bb467d;
case 0x000040d8:
return 0xf9f484cb;
case 0x000040dc:
return 0xa9dba075;
case 0x000040e0:
return 0x34619603;
case 0x000040e4:
return 0x7de7f899;
case 0x000040e8:
return 0x678eaf04;
case 0x000040ec:
return 0xdac37b02;
case 0x000040f0:
return 0x34e0e627;
case 0x000040f4:
return 0x8fbd1de0;
case 0x000040f8:
return 0x5e223eb6;
case 0x000040fc:
return 0xe58e6541;
case 0x00004100:
return 0x1006ea77;
case 0x00004104:
return 0x06bf849c;
case 0x00004108:
return 0x2e92db62;
case 0x0000410c:
return 0x9dcb477c;
case 0x00004110:
return 0x2f6a5bda;
case 0x00004114:
return 0x0bf7f29d;
case 0x00004118:
return 0x4531ac83;
case 0x0000411c:
return 0x643a4aef;
case 0x00004120:
return 0xde822297;
case 0x00004124:
return 0x9b150906;
case 0x00004128:
return 0x2ea6566c;
case 0x0000412c:
return 0x31be70cd;
case 0x00004130:
return 0x69d25fe1;
case 0x00004134:
return 0x20eac1e2;
case 0x00004138:
return 0x461059b0;
case 0x0000413c:
return 0xde20836c;
case 0x00004140:
return 0x36d9c014;
case 0x00004144:
return 0x5a83c776;
case 0x00004148:
return 0x30173aaa;
case 0x0000414c:
return 0xec152f93;
case 0x00004150:
return 0xb6b6b886;
case 0x00004154:
return 0x158a7247;
case 0x00004158:
return 0x07c81797;
case 0x0000415c:
return 0x374a5cee;
case 0x00004160:
return 0x444f6aca;
case 0x00004164:
return 0x8eba8e79;
case 0x00004168:
return 0x63802ba9;
case 0x0000416c:
return 0x8d01df26;
case 0x00004170:
return 0x2d26bd4d;
case 0x00004174:
return 0xaf5d9c5c;
case 0x00004178:
return 0xfd8f558a;
case 0x0000417c:
return 0x9342286b;
case 0x00004180:
return 0xdf1201fc;
case 0x00004184:
return 0xb3dc02c2;
case 0x00004188:
return 0x1522a795;
case 0x0000418c:
return 0x09b07cdc;
case 0x00004190:
return 0x62c551c6;
case 0x00004194:
return 0x326aec87;
case 0x00004198:
return 0xcdf48355;
case 0x0000419c:
return 0xfa18014e;
case 0x000041a0:
return 0xe8fd2c4a;
case 0x000041a4:
return 0x2e56bba8;
case 0x000041a8:
return 0x74b90d71;
case 0x000041ac:
return 0x616cc0ab;
case 0x000041b0:
return 0xa1fb14a3;
case 0x000041b4:
return 0x260df89b;
case 0x000041b8:
return 0x59f7f5bc;
case 0x000041bc:
return 0x9a544a48;
case 0x000041c0:
return 0xff1c4bf3;
case 0x000041c4:
return 0xa9d80202;
case 0x000041c8:
return 0xb0916c25;
case 0x000041cc:
return 0x72c0ac63;
case 0x000041d0:
return 0xc0c77431;
case 0x000041d4:
return 0x2e8bf0f0;
case 0x000041d8:
return 0x549e9e24;
case 0x000041dc:
return 0xe42d845e;
case 0x000041e0:
return 0x4ae96ddf;
case 0x000041e4:
return 0x06380ae2;
case 0x000041e8:
return 0xf9952310;
case 0x000041ec:
return 0xd280b8b6;
case 0x000041f0:
return 0xc1008277;
case 0x000041f4:
return 0x52ba5b94;
case 0x000041f8:
return 0x1f0bed07;
case 0x000041fc:
return 0xf7a4266f;
case 0x00004200:
return 0x01089777;
case 0x00004204:
return 0x9d278968;
case 0x00004208:
return 0xa53e46db;
case 0x0000420c:
return 0xec8e6d15;
case 0x00004210:
return 0xffd1d555;
case 0x00004214:
return 0x1ce2e555;
case 0x00004218:
return 0x8042958c;
case 0x0000421c:
return 0xc69055cb;
case 0x00004220:
return 0xdff27857;
case 0x00004224:
return 0x0dc44563;
case 0x00004228:
return 0xb0469255;
case 0x0000422c:
return 0xa3474356;
case 0x00004230:
return 0xc9f63c71;
case 0x00004234:
return 0x9aabae69;
case 0x00004238:
return 0xf44348bc;
case 0x0000423c:
return 0x370350db;
case 0x00004240:
return 0xdc63e997;
case 0x00004244:
return 0xd60521dd;
case 0x00004248:
return 0x4093d4d0;
case 0x0000424c:
return 0x690b5abc;
case 0x00004250:
return 0x0ccccfb7;
case 0x00004254:
return 0x8f364cb0;
case 0x00004258:
return 0x0f6f312a;
case 0x0000425c:
return 0xd0e17f0b;
case 0x00004260:
return 0x9a27ef89;
case 0x00004264:
return 0x55a6c8e3;
case 0x00004268:
return 0xeb3657df;
case 0x0000426c:
return 0x089f2454;
case 0x00004270:
return 0x92921d61;
case 0x00004274:
return 0x2231c2cb;
case 0x00004278:
return 0x2c1a0c89;
case 0x0000427c:
return 0x4868e4d3;
case 0x00004280:
return 0x8f2fa335;
case 0x00004284:
return 0xc6e2e75f;
case 0x00004288:
return 0x33e8eb0a;
case 0x0000428c:
return 0xbf5cd5f1;
case 0x00004290:
return 0x75955be3;
case 0x00004294:
return 0x5c3e788f;
case 0x00004298:
return 0x90eff56f;
case 0x0000429c:
return 0xd29b5e5d;
case 0x000042a0:
return 0x8fba8bc3;
case 0x000042a4:
return 0x060db761;
case 0x000042a8:
return 0xd47fd172;
case 0x000042ac:
return 0x45813759;
case 0x000042b0:
return 0x53c12e7a;
case 0x000042b4:
return 0xffe52372;
case 0x000042b8:
return 0x84c5c82b;
case 0x000042bc:
return 0x610d8256;
case 0x000042c0:
return 0xd9fff7cf;
case 0x000042c4:
return 0xe2f50adf;
case 0x000042c8:
return 0x35c92d67;
case 0x000042cc:
return 0xbca14266;
case 0x000042d0:
return 0x99db9822;
case 0x000042d4:
return 0x0eb4378f;
case 0x000042d8:
return 0x563101a3;
case 0x000042dc:
return 0xa476cf88;
case 0x000042e0:
return 0x91d346e0;
case 0x000042e4:
return 0x54ec53bc;
case 0x000042e8:
return 0x6ea1059c;
case 0x000042ec:
return 0xd720d7b7;
case 0x000042f0:
return 0x5b828a1c;
case 0x000042f4:
return 0x7251c222;
case 0x000042f8:
return 0xb3a28f91;
case 0x000042fc:
return 0xa4ed106e;
case 0x00004300:
return 0xf0fc0026;
case 0x00004304:
return 0x111fa97b;
case 0x00004308:
return 0xe2f0ca7b;
case 0x0000430c:
return 0x3b13e58c;
case 0x00004310:
return 0x7fcce6c2;
case 0x00004314:
return 0x01f7a587;
case 0x00004318:
return 0x8a89bc5d;
case 0x0000431c:
return 0xed5fa336;
case 0x00004320:
return 0xd19894c8;
case 0x00004324:
return 0xbdd741b0;
case 0x00004328:
return 0x17290791;
case 0x0000432c:
return 0xd8a22462;
case 0x00004330:
return 0x2496cfe2;
case 0x00004334:
return 0xa2cb8dbc;
case 0x00004338:
return 0x98b6b5cc;
case 0x0000433c:
return 0xa8eb81fe;
case 0x00004340:
return 0x6c18d18b;
case 0x00004344:
return 0x1506af5c;
case 0x00004348:
return 0x8ee0da4e;
case 0x0000434c:
return 0xd6b22fef;
case 0x00004350:
return 0xd4a37613;
case 0x00004354:
return 0xdd4b5716;
case 0x00004358:
return 0x895b6857;
case 0x0000435c:
return 0xe38464bf;
case 0x00004360:
return 0x86e1abd6;
case 0x00004364:
return 0xdd328e4f;
case 0x00004368:
return 0x220aa71a;
case 0x0000436c:
return 0x079a66b7;
case 0x00004370:
return 0xebc913cc;
case 0x00004374:
return 0x0c7e27ee;
case 0x00004378:
return 0x7c3fbd8a;
case 0x0000437c:
return 0xe2cd4f7a;
case 0x00004380:
return 0xb912ef08;
case 0x00004384:
return 0x99935837;
case 0x00004388:
return 0xc3d18655;
case 0x0000438c:
return 0x83ccfc8e;
case 0x00004390:
return 0xfd0e8fc9;
case 0x00004394:
return 0xcbc88e36;
case 0x00004398:
return 0xacbfd92c;
case 0x0000439c:
return 0x6b0bc14e;
case 0x000043a0:
return 0x5922fb3a;
case 0x000043a4:
return 0x83fde0a0;
case 0x000043a8:
return 0xbe9adbae;
case 0x000043ac:
return 0xa46a0803;
case 0x000043b0:
return 0xb6ef7769;
case 0x000043b4:
return 0xa88196fe;
case 0x000043b8:
return 0xbbf5101f;
case 0x000043bc:
return 0x57629972;
case 0x000043c0:
return 0xf7994bf9;
case 0x000043c4:
return 0xaf3b2a67;
case 0x000043c8:
return 0x70416310;
case 0x000043cc:
return 0x18e400e2;
case 0x000043d0:
return 0xbfa9931c;
case 0x000043d4:
return 0xdce0e4b3;
case 0x000043d8:
return 0xfb7d092c;
case 0x000043dc:
return 0xdfc58edc;
case 0x000043e0:
return 0x9eb83426;
case 0x000043e4:
return 0xc0e2e2bf;
case 0x000043e8:
return 0xde9dafb2;
case 0x000043ec:
return 0xaa01954d;
case 0x000043f0:
return 0xf3967b7f;
case 0x000043f4:
return 0x4fb93c58;
case 0x000043f8:
return 0x87888e53;
case 0x000043fc:
return 0x4be23a63;
case 0x00004400:
return 0x65a72d7b;
case 0x00004404:
return 0x88ab4fa3;
case 0x00004408:
return 0xa3a9c328;
case 0x0000440c:
return 0x0039ff91;
case 0x00004410:
return 0xad3ac4da;
case 0x00004414:
return 0x62519064;
case 0x00004418:
return 0x3186cd8a;
case 0x0000441c:
return 0xc2795dde;
case 0x00004420:
return 0x9d7a38a1;
case 0x00004424:
return 0xfed81ade;
case 0x00004428:
return 0xdc968002;
case 0x0000442c:
return 0x42e4c61f;
case 0x00004430:
return 0x584ef9f7;
case 0x00004434:
return 0x77fa1072;
case 0x00004438:
return 0x8acfa82c;
case 0x0000443c:
return 0x87b28b26;
case 0x00004440:
return 0x09ef39ed;
case 0x00004444:
return 0xfd8564c6;
case 0x00004448:
return 0xf3db38bf;
case 0x0000444c:
return 0xbb966c64;
case 0x00004450:
return 0x7f78501d;
case 0x00004454:
return 0xec51e96b;
case 0x00004458:
return 0xc49a9713;
case 0x0000445c:
return 0x23288e22;
case 0x00004460:
return 0x397b0f29;
case 0x00004464:
return 0xd3fa5d49;
case 0x00004468:
return 0xb6440197;
case 0x0000446c:
return 0x2181b3ee;
case 0x00004470:
return 0x2afc7488;
case 0x00004474:
return 0xd55a5094;
case 0x00004478:
return 0x8fbeba57;
case 0x0000447c:
return 0xbd151313;
case 0x00004480:
return 0x533d71c8;
case 0x00004484:
return 0x2185be82;
case 0x00004488:
return 0x6470e3a8;
case 0x0000448c:
return 0xfa1305c4;
case 0x00004490:
return 0xe7362afd;
case 0x00004494:
return 0xd536721b;
case 0x00004498:
return 0xbad37183;
case 0x0000449c:
return 0xd2e4e3c2;
case 0x000044a0:
return 0xa6f125af;
case 0x000044a4:
return 0x19a381ec;
case 0x000044a8:
return 0x732ea6be;
case 0x000044ac:
return 0x04a6e251;
case 0x000044b0:
return 0x89ab6126;
case 0x000044b4:
return 0x1d007f7f;
case 0x000044b8:
return 0xd7c8f64c;
case 0x000044bc:
return 0x87ad0e5d;
case 0x000044c0:
return 0x8f965f4b;
case 0x000044c4:
return 0x97794e6c;
case 0x000044c8:
return 0xfe5359c3;
case 0x000044cc:
return 0xb9e0b3b8;
case 0x000044d0:
return 0xa8570c09;
case 0x000044d4:
return 0x6af20468;
case 0x000044d8:
return 0x258f887d;
case 0x000044dc:
return 0xf4667e18;
case 0x000044e0:
return 0x804d8806;
case 0x000044e4:
return 0xe83205c5;
case 0x000044e8:
return 0x43064b8f;
case 0x000044ec:
return 0x126686b5;
case 0x000044f0:
return 0xfd043d6c;
case 0x000044f4:
return 0x2c63f740;
case 0x000044f8:
return 0x84a18a30;
case 0x000044fc:
return 0x8d6361a2;
case 0x00004500:
return 0x6c123120;
case 0x00004504:
return 0xa1fc5fbb;
case 0x00004508:
return 0x5bc5e4ed;
case 0x0000450c:
return 0xb76c2385;
case 0x00004510:
return 0x9695e2d6;
case 0x00004514:
return 0x2311e112;
case 0x00004518:
return 0x131c6dd9;
case 0x0000451c:
return 0x03067b33;
case 0x00004520:
return 0x64d111f4;
case 0x00004524:
return 0x8296d8d2;
case 0x00004528:
return 0x1ac3cf90;
case 0x0000452c:
return 0xde98b969;
case 0x00004530:
return 0x46de3155;
case 0x00004534:
return 0x946d68c9;
case 0x00004538:
return 0x019590b6;
case 0x0000453c:
return 0xa1cde058;
case 0x00004540:
return 0x1f9ea6d6;
case 0x00004544:
return 0x1ce7cd9c;
case 0x00004548:
return 0xf758deef;
case 0x0000454c:
return 0xd5d325f9;
case 0x00004550:
return 0x15970a62;
case 0x00004554:
return 0xbf4ee593;
case 0x00004558:
return 0xd3ae8144;
case 0x0000455c:
return 0xf846d4d1;
case 0x00004560:
return 0x35ed1ec4;
case 0x00004564:
return 0x225adfb6;
case 0x00004568:
return 0x2458eb0e;
case 0x0000456c:
return 0xa77291c9;
case 0x00004570:
return 0xf9cb4edc;
case 0x00004574:
return 0xcf620eaf;
case 0x00004578:
return 0x18da6e8c;
case 0x0000457c:
return 0x4cb1ed83;
case 0x00004580:
return 0x116ffd1e;
case 0x00004584:
return 0x6f1a971e;
case 0x00004588:
return 0x4784f223;
case 0x0000458c:
return 0xbed7fba1;
case 0x00004590:
return 0x52dfae9c;
case 0x00004594:
return 0xde0e77e6;
case 0x00004598:
return 0xd5bced4e;
case 0x0000459c:
return 0x4ee377ff;
case 0x000045a0:
return 0x0b9711f7;
case 0x000045a4:
return 0xef1a841b;
case 0x000045a8:
return 0x6af2bfb4;
case 0x000045ac:
return 0x69c45acb;
case 0x000045b0:
return 0xa6989023;
case 0x000045b4:
return 0x66cff11e;
case 0x000045b8:
return 0x92c487a5;
case 0x000045bc:
return 0xf1e3463c;
case 0x000045c0:
return 0xa736b2a1;
case 0x000045c4:
return 0xb13aaa09;
case 0x000045c8:
return 0x4c4e6e1f;
case 0x000045cc:
return 0x457e32cc;
case 0x000045d0:
return 0x7c070c3c;
case 0x000045d4:
return 0x8d01bb25;
case 0x000045d8:
return 0xa942a063;
case 0x000045dc:
return 0x3e309c15;
case 0x000045e0:
return 0x81463c31;
case 0x000045e4:
return 0x462bc84f;
case 0x000045e8:
return 0x58b3ecb8;
case 0x000045ec:
return 0x4891883e;
case 0x000045f0:
return 0xbc2cb183;
case 0x000045f4:
return 0x44d4382c;
case 0x000045f8:
return 0x192c4f0e;
case 0x000045fc:
return 0x7e2d1875;
case 0x00004600:
return 0xce2e89ee;
case 0x00004604:
return 0xcdfea86b;
case 0x00004608:
return 0xc6850075;
case 0x0000460c:
return 0x17b3ee66;
case 0x00004610:
return 0x49025a61;
case 0x00004614:
return 0x02c64448;
case 0x00004618:
return 0xf7d87f92;
case 0x0000461c:
return 0x1224f74c;
case 0x00004620:
return 0x7cdeaa75;
case 0x00004624:
return 0x73edf4e2;
case 0x00004628:
return 0xa41085dc;
case 0x0000462c:
return 0x37e872ff;
case 0x00004630:
return 0x4ddad985;
case 0x00004634:
return 0x9e8069a7;
case 0x00004638:
return 0x5aa51b09;
case 0x0000463c:
return 0xb88ac57a;
case 0x00004640:
return 0x117e15eb;
case 0x00004644:
return 0x912f5bfc;
case 0x00004648:
return 0x818cc575;
case 0x0000464c:
return 0xdea807c1;
case 0x00004650:
return 0x52269e31;
case 0x00004654:
return 0x8f4c6ca7;
case 0x00004658:
return 0x4dbf063c;
case 0x0000465c:
return 0x2fe5d667;
case 0x00004660:
return 0x8a12bbee;
case 0x00004664:
return 0xc62730a1;
case 0x00004668:
return 0x112eba2d;
case 0x0000466c:
return 0x3943fcb3;
case 0x00004670:
return 0x7ab871c3;
case 0x00004674:
return 0x9862d7f6;
case 0x00004678:
return 0x438a356c;
case 0x0000467c:
return 0xc8f9bea4;
case 0x00004680:
return 0x73471db1;
case 0x00004684:
return 0x78b0d121;
case 0x00004688:
return 0x093c8ff3;
case 0x0000468c:
return 0x4c8f935f;
case 0x00004690:
return 0x70159dac;
case 0x00004694:
return 0xea0e8c6d;
case 0x00004698:
return 0x90cee545;
case 0x0000469c:
return 0xe87866c9;
case 0x000046a0:
return 0x77cdc58a;
case 0x000046a4:
return 0xced00cf1;
case 0x000046a8:
return 0xc7879c5c;
case 0x000046ac:
return 0x3973f92f;
case 0x000046b0:
return 0x75ba6d0b;
case 0x000046b4:
return 0x37208ba8;
case 0x000046b8:
return 0xdfe6f950;
case 0x000046bc:
return 0xfef43540;
case 0x000046c0:
return 0x1c2acedf;
case 0x000046c4:
return 0xc47dfdb3;
case 0x000046c8:
return 0x72fcd6ba;
case 0x000046cc:
return 0x4803e1b3;
case 0x000046d0:
return 0xa0e8e5cf;
case 0x000046d4:
return 0x0e2d99e1;
case 0x000046d8:
return 0x7a567efa;
case 0x000046dc:
return 0xda722db8;
case 0x000046e0:
return 0x1221c9ae;
case 0x000046e4:
return 0xba6aa7ab;
case 0x000046e8:
return 0x6204f0be;
case 0x000046ec:
return 0x60c71662;
case 0x000046f0:
return 0x9717d59f;
case 0x000046f4:
return 0x6c46ad2d;
case 0x000046f8:
return 0xbbc28fef;
case 0x000046fc:
return 0x933615a3;
case 0x00004700:
return 0x20291427;
case 0x00004704:
return 0x7a1dfbaf;
case 0x00004708:
return 0xc90274d0;
case 0x0000470c:
return 0x51c3f206;
case 0x00004710:
return 0xdf22f5ac;
case 0x00004714:
return 0xccc1c054;
case 0x00004718:
return 0xe03219bc;
case 0x0000471c:
return 0xd61cb1a8;
case 0x00004720:
return 0xf5b2b5dc;
case 0x00004724:
return 0xa937f837;
case 0x00004728:
return 0xe1e36799;
case 0x0000472c:
return 0x56307f07;
case 0x00004730:
return 0x8bb8505b;
case 0x00004734:
return 0x0b809c4c;
case 0x00004738:
return 0xcb716f5c;
case 0x0000473c:
return 0x718904fe;
case 0x00004740:
return 0xa9a936b2;
case 0x00004744:
return 0xa037ca19;
case 0x00004748:
return 0xca6a211b;
case 0x0000474c:
return 0x99d9113c;
case 0x00004750:
return 0x6ebf05c4;
case 0x00004754:
return 0xb067259e;
case 0x00004758:
return 0x19b67e3e;
case 0x0000475c:
return 0xd3fbc398;
case 0x00004760:
return 0x91f27c24;
case 0x00004764:
return 0x91c52098;
case 0x00004768:
return 0x0d33baca;
case 0x0000476c:
return 0x43b0ec9f;
case 0x00004770:
return 0x4ed058f3;
case 0x00004774:
return 0x0e0a573c;
case 0x00004778:
return 0x26b8e270;
case 0x0000477c:
return 0x462cdbe5;
case 0x00004780:
return 0x49d96a19;
case 0x00004784:
return 0x495e8fd0;
case 0x00004788:
return 0xf0325963;
case 0x0000478c:
return 0xa9511f70;
case 0x00004790:
return 0x92521c9c;
case 0x00004794:
return 0x01a127e4;
case 0x00004798:
return 0x50fece1f;
case 0x0000479c:
return 0x04634893;
case 0x000047a0:
return 0xa5d3c37a;
case 0x000047a4:
return 0x60f11f95;
case 0x000047a8:
return 0x1a966869;
case 0x000047ac:
return 0x4711faee;
case 0x000047b0:
return 0x4b66c609;
case 0x000047b4:
return 0xf465ec31;
case 0x000047b8:
return 0x543b6e3d;
case 0x000047bc:
return 0xa6d6b48f;
case 0x000047c0:
return 0x2d6d281b;
case 0x000047c4:
return 0x002e5926;
case 0x000047c8:
return 0x3f75e425;
case 0x000047cc:
return 0xa125f68d;
case 0x000047d0:
return 0xc7ba5bdd;
case 0x000047d4:
return 0xc314163d;
case 0x000047d8:
return 0x16f656f0;
case 0x000047dc:
return 0xa16ac8cd;
case 0x000047e0:
return 0x0732729d;
case 0x000047e4:
return 0x42bc64a2;
case 0x000047e8:
return 0xfc5fb062;
case 0x000047ec:
return 0x36206215;
case 0x000047f0:
return 0x9ff7743a;
case 0x000047f4:
return 0xbd9185a2;
case 0x000047f8:
return 0xc81d91a3;
case 0x000047fc:
return 0xfdc58981;
case 0x00004800:
return 0xf6f68bf0;
case 0x00004804:
return 0x045914ac;
case 0x00004808:
return 0xed6de959;
case 0x0000480c:
return 0xf551047d;
case 0x00004810:
return 0x1d4b3849;
case 0x00004814:
return 0x767f3fc6;
case 0x00004818:
return 0x3ad717bf;
case 0x0000481c:
return 0x8b84fc37;
case 0x00004820:
return 0x6f9c87bd;
case 0x00004824:
return 0x4161de05;
case 0x00004828:
return 0x758ca7d8;
case 0x0000482c:
return 0x96ec9c3f;
case 0x00004830:
return 0xf3b858b0;
case 0x00004834:
return 0x3f9c4f6b;
case 0x00004838:
return 0x1c99a65d;
case 0x0000483c:
return 0x2ffdba68;
case 0x00004840:
return 0x60567c51;
case 0x00004844:
return 0x74e7b1be;
case 0x00004848:
return 0x2eaaeaa9;
case 0x0000484c:
return 0xd0b0f316;
case 0x00004850:
return 0xd6493ab2;
case 0x00004854:
return 0xb48a9769;
case 0x00004858:
return 0x109dc462;
case 0x0000485c:
return 0x51029ba8;
case 0x00004860:
return 0xbae78be6;
case 0x00004864:
return 0x082f651f;
case 0x00004868:
return 0x384a205b;
case 0x0000486c:
return 0x41db3ed5;
case 0x00004870:
return 0x9f4e40b5;
case 0x00004874:
return 0x37899a38;
case 0x00004878:
return 0xec954c5d;
case 0x0000487c:
return 0x5b915ea6;
case 0x00004880:
return 0xca8f3165;
case 0x00004884:
return 0x8dc036b4;
case 0x00004888:
return 0xfdb3fdf5;
case 0x0000488c:
return 0x8630eae6;
case 0x00004890:
return 0xe36e930f;
case 0x00004894:
return 0xd520a162;
case 0x00004898:
return 0x47093475;
case 0x0000489c:
return 0xf05a2a0f;
case 0x000048a0:
return 0x84681bc2;
case 0x000048a4:
return 0x1b71a07e;
case 0x000048a8:
return 0xa6d5f295;
case 0x000048ac:
return 0xc9e65363;
case 0x000048b0:
return 0xdc09bb76;
case 0x000048b4:
return 0xffd724be;
case 0x000048b8:
return 0x967dd641;
case 0x000048bc:
return 0x9d74a0ea;
case 0x000048c0:
return 0xe6c18711;
case 0x000048c4:
return 0x34e9298d;
case 0x000048c8:
return 0xc2bfe754;
case 0x000048cc:
return 0xf1deb472;
case 0x000048d0:
return 0x1b06b6d8;
case 0x000048d4:
return 0x78900236;
case 0x000048d8:
return 0x90ff7bb8;
case 0x000048dc:
return 0x61a90db4;
case 0x000048e0:
return 0xe1388f08;
case 0x000048e4:
return 0x4d69ece6;
case 0x000048e8:
return 0xc8489a5a;
case 0x000048ec:
return 0x9080cd59;
case 0x000048f0:
return 0x73e759b4;
case 0x000048f4:
return 0x5edb5708;
case 0x000048f8:
return 0xab78c33d;
case 0x000048fc:
return 0xb501cec1;
case 0x00004900:
return 0xe926d32f;
case 0x00004904:
return 0xf194f2ff;
case 0x00004908:
return 0xa36192bf;
case 0x0000490c:
return 0x75cf0613;
case 0x00004910:
return 0xe7738a1d;
case 0x00004914:
return 0x1832778f;
case 0x00004918:
return 0x57807d53;
case 0x0000491c:
return 0xc686b8c7;
case 0x00004920:
return 0xe6949e90;
case 0x00004924:
return 0x82897d2b;
case 0x00004928:
return 0xa74d75d5;
case 0x0000492c:
return 0xec821cc7;
case 0x00004930:
return 0x701ad520;
case 0x00004934:
return 0xf4893500;
case 0x00004938:
return 0x46a3b92b;
case 0x0000493c:
return 0x67fa6b30;
case 0x00004940:
return 0x7455b86c;
case 0x00004944:
return 0xa00423b2;
case 0x00004948:
return 0x4ea1c1c7;
case 0x0000494c:
return 0xedb50df9;
case 0x00004950:
return 0x5e067339;
case 0x00004954:
return 0xa854766b;
case 0x00004958:
return 0x86a875a1;
case 0x0000495c:
return 0x5f829fbc;
case 0x00004960:
return 0x9fecf213;
case 0x00004964:
return 0xbf3846a8;
case 0x00004968:
return 0xb1f805e2;
case 0x0000496c:
return 0xe16df0ca;
case 0x00004970:
return 0x47435b42;
case 0x00004974:
return 0x463ddfa2;
case 0x00004978:
return 0x1b059f45;
case 0x0000497c:
return 0x23b1b24a;
case 0x00004980:
return 0x4e4e2df2;
case 0x00004984:
return 0x0de4840d;
case 0x00004988:
return 0x0c25f228;
case 0x0000498c:
return 0x66e5b08e;
case 0x00004990:
return 0x9e22bf7b;
case 0x00004994:
return 0x499b08cb;
case 0x00004998:
return 0x7eca826a;
case 0x0000499c:
return 0x35e1bc09;
case 0x000049a0:
return 0x0fe9fede;
case 0x000049a4:
return 0x102c28fa;
case 0x000049a8:
return 0x61f78245;
case 0x000049ac:
return 0x7194cbed;
case 0x000049b0:
return 0xbecece30;
case 0x000049b4:
return 0x82ad094f;
case 0x000049b8:
return 0x293983de;
case 0x000049bc:
return 0xf5783094;
case 0x000049c0:
return 0x2d47f50c;
case 0x000049c4:
return 0x9b3c5430;
case 0x000049c8:
return 0x134c67bb;
case 0x000049cc:
return 0x1b7c3441;
case 0x000049d0:
return 0x0ecf0c65;
case 0x000049d4:
return 0xf474ca4e;
case 0x000049d8:
return 0x938cfa57;
case 0x000049dc:
return 0xb6699e1c;
case 0x000049e0:
return 0x2c94df9f;
case 0x000049e4:
return 0x449b39c6;
case 0x000049e8:
return 0xb6c54723;
case 0x000049ec:
return 0x0d792b8d;
case 0x000049f0:
return 0x1ca1b48f;
case 0x000049f4:
return 0x30dd42fa;
case 0x000049f8:
return 0xba015821;
case 0x000049fc:
return 0xd46fafa9;
case 0x00004a00:
return 0x997084d4;
case 0x00004a04:
return 0x4abc3dbf;
case 0x00004a08:
return 0x550e536b;
case 0x00004a0c:
return 0x4b73ce87;
case 0x00004a10:
return 0xe2172d0d;
case 0x00004a14:
return 0xecdeab63;
case 0x00004a18:
return 0xcbc73ed1;
case 0x00004a1c:
return 0xa6ba4387;
case 0x00004a20:
return 0xa7f2634c;
case 0x00004a24:
return 0x2da1150a;
case 0x00004a28:
return 0xc7b6b382;
case 0x00004a2c:
return 0x335dd16b;
case 0x00004a30:
return 0x7f64217e;
case 0x00004a34:
return 0x179ba028;
case 0x00004a38:
return 0xb70bd5ec;
case 0x00004a3c:
return 0x0d74f60d;
case 0x00004a40:
return 0x2c100f86;
case 0x00004a44:
return 0x549218ef;
case 0x00004a48:
return 0x94e986cf;
case 0x00004a4c:
return 0xa005cf92;
case 0x00004a50:
return 0x3f9bc69c;
case 0x00004a54:
return 0x767adbc6;
case 0x00004a58:
return 0xacbc9a21;
case 0x00004a5c:
return 0xfffd1cbe;
case 0x00004a60:
return 0x80eb8c8d;
case 0x00004a64:
return 0xe3f38d89;
case 0x00004a68:
return 0x5d7e7804;
case 0x00004a6c:
return 0xa9f1ea51;
case 0x00004a70:
return 0x735dcc1c;
case 0x00004a74:
return 0x002843fe;
case 0x00004a78:
return 0x2c74a68f;
case 0x00004a7c:
return 0x16c76aa1;
case 0x00004a80:
return 0x5d369601;
case 0x00004a84:
return 0xea63d78c;
case 0x00004a88:
return 0x76b36c60;
case 0x00004a8c:
return 0x80a5784e;
case 0x00004a90:
return 0x248988bb;
case 0x00004a94:
return 0x9f8f9a14;
case 0x00004a98:
return 0xc97e8c9a;
case 0x00004a9c:
return 0x11bf5072;
case 0x00004aa0:
return 0x907e80d6;
case 0x00004aa4:
return 0xc499e0d2;
case 0x00004aa8:
return 0x81069ed1;
case 0x00004aac:
return 0xcc0398de;
case 0x00004ab0:
return 0x4bd2d20c;
case 0x00004ab4:
return 0xe8127540;
case 0x00004ab8:
return 0xaa523abe;
case 0x00004abc:
return 0x68b62e6f;
case 0x00004ac0:
return 0x662db081;
case 0x00004ac4:
return 0xcc0a145d;
case 0x00004ac8:
return 0xacb64990;
case 0x00004acc:
return 0x0abc2fd9;
case 0x00004ad0:
return 0xd514dd12;
case 0x00004ad4:
return 0xb6e115f5;
case 0x00004ad8:
return 0x31a4f9c6;
case 0x00004adc:
return 0x7e4b8934;
case 0x00004ae0:
return 0x597ae6b7;
case 0x00004ae4:
return 0x7bc21f95;
case 0x00004ae8:
return 0x21267e9d;
case 0x00004aec:
return 0xb0defc5c;
case 0x00004af0:
return 0xcbef5f63;
case 0x00004af4:
return 0xc1ad0fab;
case 0x00004af8:
return 0xec522de2;
case 0x00004afc:
return 0x65c5c729;
case 0x00004b00:
return 0xb732682b;
case 0x00004b04:
return 0x0274dcfb;
case 0x00004b08:
return 0x900982bf;
case 0x00004b0c:
return 0x11dd04a3;
case 0x00004b10:
return 0x30e8918d;
case 0x00004b14:
return 0x0494c26c;
case 0x00004b18:
return 0x56d09f4d;
case 0x00004b1c:
return 0x9648d4a9;
case 0x00004b20:
return 0xb85f77e9;
case 0x00004b24:
return 0x3f83f878;
case 0x00004b28:
return 0xa9e7b725;
case 0x00004b2c:
return 0x50749a6c;
case 0x00004b30:
return 0x20446079;
case 0x00004b34:
return 0xb9eb04b1;
case 0x00004b38:
return 0xcf30a7ca;
case 0x00004b3c:
return 0x1589c49d;
case 0x00004b40:
return 0xeac432da;
case 0x00004b44:
return 0x693f0028;
case 0x00004b48:
return 0x49f60334;
case 0x00004b4c:
return 0x7a51b8ee;
case 0x00004b50:
return 0x19df59cb;
case 0x00004b54:
return 0x34518abc;
case 0x00004b58:
return 0x3dbc74ff;
case 0x00004b5c:
return 0x49c49757;
case 0x00004b60:
return 0x4ba63c66;
case 0x00004b64:
return 0xb77ec45c;
case 0x00004b68:
return 0x05c22037;
case 0x00004b6c:
return 0xac9ef494;
case 0x00004b70:
return 0xfacf76be;
case 0x00004b74:
return 0xb1e561db;
case 0x00004b78:
return 0x69020c76;
case 0x00004b7c:
return 0xea27e835;
case 0x00004b80:
return 0xfec55a31;
case 0x00004b84:
return 0xaf769066;
case 0x00004b88:
return 0x3c3a5eed;
case 0x00004b8c:
return 0x396fc184;
case 0x00004b90:
return 0x27604e31;
case 0x00004b94:
return 0x2183d26e;
case 0x00004b98:
return 0x6bc37603;
case 0x00004b9c:
return 0xbbc73e7b;
case 0x00004ba0:
return 0xea56f128;
case 0x00004ba4:
return 0xa13959fb;
case 0x00004ba8:
return 0x712594f8;
case 0x00004bac:
return 0x81cfb75f;
case 0x00004bb0:
return 0x491e6673;
case 0x00004bb4:
return 0xde90db1d;
case 0x00004bb8:
return 0x46012da1;
case 0x00004bbc:
return 0x46600a31;
case 0x00004bc0:
return 0x70148694;
case 0x00004bc4:
return 0x8e9c1f6d;
case 0x00004bc8:
return 0x83e82f4d;
case 0x00004bcc:
return 0xb620e527;
case 0x00004bd0:
return 0xf91a20ee;
case 0x00004bd4:
return 0x01babadc;
case 0x00004bd8:
return 0x1d3b8e2c;
case 0x00004bdc:
return 0xc0d7fa0e;
case 0x00004be0:
return 0xd904ac55;
case 0x00004be4:
return 0xc737d0bb;
case 0x00004be8:
return 0xa05c32c3;
case 0x00004bec:
return 0x7c0c3b7b;
case 0x00004bf0:
return 0x69d8799b;
case 0x00004bf4:
return 0x173a2a25;
case 0x00004bf8:
return 0x528aa70b;
case 0x00004bfc:
return 0xac94ef2f;
case 0x00004c00:
return 0xf8fb9227;
case 0x00004c04:
return 0xa40908f6;
case 0x00004c08:
return 0x2d4cbe7e;
case 0x00004c0c:
return 0xf1651a5f;
case 0x00004c10:
return 0x362844b4;
case 0x00004c14:
return 0x963514f9;
case 0x00004c18:
return 0xf3140f24;
case 0x00004c1c:
return 0x7466daef;
case 0x00004c20:
return 0x5d43f6a2;
case 0x00004c24:
return 0x7eca7acb;
case 0x00004c28:
return 0xe4ca9f78;
case 0x00004c2c:
return 0xedf54c85;
case 0x00004c30:
return 0x7ee4fcbc;
case 0x00004c34:
return 0x15b4ff64;
case 0x00004c38:
return 0x7e450a93;
case 0x00004c3c:
return 0xc301cef1;
case 0x00004c40:
return 0x912cc365;
case 0x00004c44:
return 0x86164b03;
case 0x00004c48:
return 0x26e5325b;
case 0x00004c4c:
return 0x638558b9;
case 0x00004c50:
return 0x4884d4bf;
case 0x00004c54:
return 0x4e3e88e6;
case 0x00004c58:
return 0x71d640a3;
case 0x00004c5c:
return 0x088be327;
case 0x00004c60:
return 0xd0d7cc91;
case 0x00004c64:
return 0x596f8dfb;
case 0x00004c68:
return 0xc21c31c8;
case 0x00004c6c:
return 0x9f9a6847;
case 0x00004c70:
return 0x067a6fd0;
case 0x00004c74:
return 0xaafa0f2c;
case 0x00004c78:
return 0x3909ee5d;
case 0x00004c7c:
return 0x89d597e2;
case 0x00004c80:
return 0xb4d70ef8;
case 0x00004c84:
return 0x454804a0;
case 0x00004c88:
return 0x3151f236;
case 0x00004c8c:
return 0x3d6fdec5;
case 0x00004c90:
return 0x151eff5a;
case 0x00004c94:
return 0xb7653aa7;
case 0x00004c98:
return 0x622e8d85;
case 0x00004c9c:
return 0xb34959cd;
case 0x00004ca0:
return 0x1bb0c632;
case 0x00004ca4:
return 0x425fffee;
case 0x00004ca8:
return 0x48940663;
case 0x00004cac:
return 0x3dcb3018;
case 0x00004cb0:
return 0xb4f3862b;
case 0x00004cb4:
return 0x98f4dd8b;
case 0x00004cb8:
return 0x837823b4;
case 0x00004cbc:
return 0x62334df0;
case 0x00004cc0:
return 0x71c7c001;
case 0x00004cc4:
return 0x3218f61f;
case 0x00004cc8:
return 0x8b1473be;
case 0x00004ccc:
return 0x4344c569;
case 0x00004cd0:
return 0x79fa0b77;
case 0x00004cd4:
return 0xb13c382e;
case 0x00004cd8:
return 0x1151c19a;
case 0x00004cdc:
return 0x631f7706;
case 0x00004ce0:
return 0x24b59b41;
case 0x00004ce4:
return 0x0d52693e;
case 0x00004ce8:
return 0x0bba6b0f;
case 0x00004cec:
return 0xe814e05e;
case 0x00004cf0:
return 0x0c9e1bae;
case 0x00004cf4:
return 0xfb7ae034;
case 0x00004cf8:
return 0x5023e7f5;
case 0x00004cfc:
return 0x6cd5f9c7;
case 0x00004d00:
return 0xc7318868;
case 0x00004d04:
return 0x3bc7060b;
case 0x00004d08:
return 0x7bfd69a8;
case 0x00004d0c:
return 0xdd97277e;
case 0x00004d10:
return 0x74e832dc;
case 0x00004d14:
return 0x8266191c;
case 0x00004d18:
return 0xf266c15f;
case 0x00004d1c:
return 0x27a8d55c;
case 0x00004d20:
return 0x2eb5fcd2;
case 0x00004d24:
return 0x8a1cebc2;
case 0x00004d28:
return 0xe2bec148;
case 0x00004d2c:
return 0x3ea34b00;
case 0x00004d30:
return 0x58481cd7;
case 0x00004d34:
return 0x3a491ae6;
case 0x00004d38:
return 0x9fe81a19;
case 0x00004d3c:
return 0xbc1e66b4;
case 0x00004d40:
return 0x8838300c;
case 0x00004d44:
return 0xc62a088c;
case 0x00004d48:
return 0xa74a70d7;
case 0x00004d4c:
return 0xaa0df07d;
case 0x00004d50:
return 0xef2322cf;
case 0x00004d54:
return 0x0b171f7b;
case 0x00004d58:
return 0x22c14cfc;
case 0x00004d5c:
return 0xaa38387e;
case 0x00004d60:
return 0x4b153159;
case 0x00004d64:
return 0x9eb4b5b8;
case 0x00004d68:
return 0xd7d3cae6;
case 0x00004d6c:
return 0x3dbe817b;
case 0x00004d70:
return 0x16ee2fef;
case 0x00004d74:
return 0xe8e4b23d;
case 0x00004d78:
return 0xdd3816dc;
case 0x00004d7c:
return 0x2692c39d;
case 0x00004d80:
return 0xb74a777a;
case 0x00004d84:
return 0x140acab7;
case 0x00004d88:
return 0xce70bdeb;
case 0x00004d8c:
return 0xd55184b3;
case 0x00004d90:
return 0x400207f7;
case 0x00004d94:
return 0x5eb6fbdc;
case 0x00004d98:
return 0x806c8646;
case 0x00004d9c:
return 0x3e40bc5c;
case 0x00004da0:
return 0xfd36b7db;
case 0x00004da4:
return 0xa652c2c0;
case 0x00004da8:
return 0x4dba519c;
case 0x00004dac:
return 0xd1b7e5ea;
case 0x00004db0:
return 0xd105d038;
case 0x00004db4:
return 0x6b29d1fa;
case 0x00004db8:
return 0x8aa33e15;
case 0x00004dbc:
return 0x0c2252f4;
case 0x00004dc0:
return 0xba969a84;
case 0x00004dc4:
return 0x37dfd4ce;
case 0x00004dc8:
return 0x533b0c13;
case 0x00004dcc:
return 0xe9a5a466;
case 0x00004dd0:
return 0xd6a728ea;
case 0x00004dd4:
return 0x3bd6deb7;
case 0x00004dd8:
return 0xe8836344;
case 0x00004ddc:
return 0xb9fd8aa5;
case 0x00004de0:
return 0xf9051ab0;
case 0x00004de4:
return 0x59e52a95;
case 0x00004de8:
return 0x005a2ad8;
case 0x00004dec:
return 0xe8c5d134;
case 0x00004df0:
return 0x460a241d;
case 0x00004df4:
return 0xcf952286;
case 0x00004df8:
return 0xcf96c082;
case 0x00004dfc:
return 0x12238786;
case 0x00004e00:
return 0xdeeeb906;
case 0x00004e04:
return 0xe329de01;
case 0x00004e08:
return 0x8b7de824;
case 0x00004e0c:
return 0x2c26ae9f;
case 0x00004e10:
return 0x1c2ced21;
case 0x00004e14:
return 0x904f2b70;
case 0x00004e18:
return 0x68d642cc;
case 0x00004e1c:
return 0x5156182d;
case 0x00004e20:
return 0xcc19c2ed;
case 0x00004e24:
return 0x32523f99;
case 0x00004e28:
return 0xecedb231;
case 0x00004e2c:
return 0xd6c61bb4;
case 0x00004e30:
return 0x4c2998f6;
case 0x00004e34:
return 0x26bc2eb7;
case 0x00004e38:
return 0x8e8b898d;
case 0x00004e3c:
return 0x2e42cc6c;
case 0x00004e40:
return 0x28121335;
case 0x00004e44:
return 0x0feb61df;
case 0x00004e48:
return 0x69505ae4;
case 0x00004e4c:
return 0x09fd1c7e;
case 0x00004e50:
return 0x93e259c4;
case 0x00004e54:
return 0x08a07bb2;
case 0x00004e58:
return 0xd51673e8;
case 0x00004e5c:
return 0xfa178282;
case 0x00004e60:
return 0xafcf1182;
case 0x00004e64:
return 0x73ba4fd6;
case 0x00004e68:
return 0x7c946405;
case 0x00004e6c:
return 0x064d5d67;
case 0x00004e70:
return 0xec297c4d;
case 0x00004e74:
return 0x843b9b95;
case 0x00004e78:
return 0xef5b33d0;
case 0x00004e7c:
return 0x3960a372;
case 0x00004e80:
return 0xa5e6912c;
case 0x00004e84:
return 0x0e38e7de;
case 0x00004e88:
return 0xa22e01d8;
case 0x00004e8c:
return 0xa57bd023;
case 0x00004e90:
return 0x6ab0190c;
case 0x00004e94:
return 0xca7ea3e8;
case 0x00004e98:
return 0x14031980;
case 0x00004e9c:
return 0x3cf3eb03;
case 0x00004ea0:
return 0x45538489;
case 0x00004ea4:
return 0xdc1f1262;
case 0x00004ea8:
return 0x553120b8;
case 0x00004eac:
return 0xaa4154d7;
case 0x00004eb0:
return 0x74122246;
case 0x00004eb4:
return 0x5dae742c;
case 0x00004eb8:
return 0x5be3cc6b;
case 0x00004ebc:
return 0xeb2f589a;
case 0x00004ec0:
return 0x9b95aa02;
case 0x00004ec4:
return 0xe3198364;
case 0x00004ec8:
return 0xd5b2b82b;
case 0x00004ecc:
return 0xb77f5ef4;
case 0x00004ed0:
return 0x2b03ae39;
case 0x00004ed4:
return 0x1f4eddfb;
case 0x00004ed8:
return 0xee6ef7bb;
case 0x00004edc:
return 0x8997652b;
case 0x00004ee0:
return 0x9918b212;
case 0x00004ee4:
return 0xc6654fdb;
case 0x00004ee8:
return 0x4469311a;
case 0x00004eec:
return 0x72ed7741;
case 0x00004ef0:
return 0xb34db573;
case 0x00004ef4:
return 0x8d919f26;
case 0x00004ef8:
return 0xdde34527;
case 0x00004efc:
return 0xe94909f8;
case 0x00004f00:
return 0xc4508a7a;
case 0x00004f04:
return 0xaa6ff0c7;
case 0x00004f08:
return 0x8e3df5df;
case 0x00004f0c:
return 0xca4758d4;
case 0x00004f10:
return 0xe9582dd4;
case 0x00004f14:
return 0xb6a58d6d;
case 0x00004f18:
return 0x33a5e38f;
case 0x00004f1c:
return 0xad7b7f7d;
case 0x00004f20:
return 0xcada51ee;
case 0x00004f24:
return 0x4edbfa7d;
case 0x00004f28:
return 0xbd1370ba;
case 0x00004f2c:
return 0x72f90e30;
case 0x00004f30:
return 0x43bbb4f3;
case 0x00004f34:
return 0x7701cc05;
case 0x00004f38:
return 0xea124e32;
case 0x00004f3c:
return 0x0047a168;
case 0x00004f40:
return 0xb8c503ff;
case 0x00004f44:
return 0x888b0076;
case 0x00004f48:
return 0xbb755406;
case 0x00004f4c:
return 0xa5175af9;
case 0x00004f50:
return 0x2d09d6d1;
case 0x00004f54:
return 0x4f60b6a9;
case 0x00004f58:
return 0xc12b1d98;
case 0x00004f5c:
return 0x640af243;
case 0x00004f60:
return 0x8f16db90;
case 0x00004f64:
return 0x9317ff2d;
case 0x00004f68:
return 0x442dc0d5;
case 0x00004f6c:
return 0xee4c8137;
case 0x00004f70:
return 0x6b4a113d;
case 0x00004f74:
return 0x62af4270;
case 0x00004f78:
return 0xf51281b0;
case 0x00004f7c:
return 0x4e961f6c;
case 0x00004f80:
return 0xd30d3bd4;
case 0x00004f84:
return 0xa2139f1e;
case 0x00004f88:
return 0x781f9639;
case 0x00004f8c:
return 0x2bd9423f;
case 0x00004f90:
return 0xb463a54b;
case 0x00004f94:
return 0x3be0224f;
case 0x00004f98:
return 0x952cabc1;
case 0x00004f9c:
return 0xf9606fc2;
case 0x00004fa0:
return 0xdd7df826;
case 0x00004fa4:
return 0xa613b0fa;
case 0x00004fa8:
return 0x52403824;
case 0x00004fac:
return 0x405aaded;
case 0x00004fb0:
return 0x329159b0;
case 0x00004fb4:
return 0x0ea2813f;
case 0x00004fb8:
return 0x49baaee1;
case 0x00004fbc:
return 0xad7e6c34;
case 0x00004fc0:
return 0x21733c1a;
case 0x00004fc4:
return 0xd936f793;
case 0x00004fc8:
return 0x2f5d4ffa;
case 0x00004fcc:
return 0xa364d140;
case 0x00004fd0:
return 0xff8bad32;
case 0x00004fd4:
return 0xe906e3db;
case 0x00004fd8:
return 0xd7c80753;
case 0x00004fdc:
return 0xa85c9b72;
case 0x00004fe0:
return 0x969b96b7;
case 0x00004fe4:
return 0xd4062a53;
case 0x00004fe8:
return 0xaa828592;
case 0x00004fec:
return 0xdcf7442b;
case 0x00004ff0:
return 0xee167ef8;
case 0x00004ff4:
return 0x54e9c312;
case 0x00004ff8:
return 0xf45e31d6;
case 0x00004ffc:
return 0x64c0ee72;
case 0x00005000:
return 0x227e7b48;
case 0x00005004:
return 0x63cee783;
case 0x00005008:
return 0x73f59d87;
case 0x0000500c:
return 0xbb379591;
case 0x00005010:
return 0x00864d47;
case 0x00005014:
return 0x9ce336b5;
case 0x00005018:
return 0x19671c20;
case 0x0000501c:
return 0x25ea4a35;
case 0x00005020:
return 0xd5b644ba;
case 0x00005024:
return 0x698a49f2;
case 0x00005028:
return 0xdd291646;
case 0x0000502c:
return 0x61e414dc;
case 0x00005030:
return 0x4c79210f;
case 0x00005034:
return 0x7428f4c8;
case 0x00005038:
return 0x184a6fbb;
case 0x0000503c:
return 0x29f24974;
case 0x00005040:
return 0x2e9df728;
case 0x00005044:
return 0x622d3044;
case 0x00005048:
return 0x1a488808;
case 0x0000504c:
return 0xef00f254;
case 0x00005050:
return 0xf5cf1ae7;
case 0x00005054:
return 0x48cb5ad9;
case 0x00005058:
return 0x3cf3df5d;
case 0x0000505c:
return 0x23bcc612;
case 0x00005060:
return 0xe603cd00;
case 0x00005064:
return 0x47e9beda;
case 0x00005068:
return 0x626000c0;
case 0x0000506c:
return 0x92f128fe;
case 0x00005070:
return 0x0d822b39;
case 0x00005074:
return 0x4e5287ad;
case 0x00005078:
return 0x55f8875d;
case 0x0000507c:
return 0x1f25dc59;
case 0x00005080:
return 0x7aecdfff;
case 0x00005084:
return 0xa5795ecc;
case 0x00005088:
return 0x69b86e1d;
case 0x0000508c:
return 0x1e491e8d;
case 0x00005090:
return 0xca788024;
case 0x00005094:
return 0x1bd1195a;
case 0x00005098:
return 0x77b63aa9;
case 0x0000509c:
return 0xc4836e7e;
case 0x000050a0:
return 0x749b2f04;
case 0x000050a4:
return 0xd0330772;
case 0x000050a8:
return 0x01212ba9;
case 0x000050ac:
return 0xf2767404;
case 0x000050b0:
return 0x5d2ab928;
case 0x000050b4:
return 0xa0880d02;
case 0x000050b8:
return 0xf5da2f97;
case 0x000050bc:
return 0xbcf44e6f;
case 0x000050c0:
return 0x122de9b6;
case 0x000050c4:
return 0x09033053;
case 0x000050c8:
return 0x6e034229;
case 0x000050cc:
return 0x1a60bbb1;
case 0x000050d0:
return 0x18dceaa3;
case 0x000050d4:
return 0x26667ff9;
case 0x000050d8:
return 0xae6b587e;
case 0x000050dc:
return 0x89ca7f09;
case 0x000050e0:
return 0x8c509b27;
case 0x000050e4:
return 0xc6e62d9e;
case 0x000050e8:
return 0x5193da28;
case 0x000050ec:
return 0x23d7b40d;
case 0x000050f0:
return 0x5dc74e81;
case 0x000050f4:
return 0x8e32b1c9;
case 0x000050f8:
return 0x85245df8;
case 0x000050fc:
return 0x40cdcdc2;
case 0x00005100:
return 0x18631618;
case 0x00005104:
return 0xd01b9424;
case 0x00005108:
return 0x63e77aac;
case 0x0000510c:
return 0x93798af4;
case 0x00005110:
return 0xac71185d;
case 0x00005114:
return 0x95847a67;
case 0x00005118:
return 0x73f8b88d;
case 0x0000511c:
return 0xa425d370;
case 0x00005120:
return 0x46a52b73;
case 0x00005124:
return 0x21a3f4f3;
case 0x00005128:
return 0x4b006115;
case 0x0000512c:
return 0x7258b4a5;
case 0x00005130:
return 0xea7bdf51;
case 0x00005134:
return 0x746eb3ac;
case 0x00005138:
return 0xbb018364;
case 0x0000513c:
return 0xefab5481;
case 0x00005140:
return 0xe76e6edc;
case 0x00005144:
return 0x7d893c88;
case 0x00005148:
return 0xa2977f21;
case 0x0000514c:
return 0x2eac4bf1;
case 0x00005150:
return 0x19177fd4;
case 0x00005154:
return 0x8ed3a848;
case 0x00005158:
return 0xe5b9af69;
case 0x0000515c:
return 0xc4f4eb4d;
case 0x00005160:
return 0x793fdcf2;
case 0x00005164:
return 0x342816ba;
case 0x00005168:
return 0xfcda7030;
case 0x0000516c:
return 0xf3b1200b;
case 0x00005170:
return 0xc1a43418;
case 0x00005174:
return 0xd188735a;
case 0x00005178:
return 0x4674e6e5;
case 0x0000517c:
return 0xa7046d7d;
case 0x00005180:
return 0x7271468d;
case 0x00005184:
return 0x2b9a9775;
case 0x00005188:
return 0xf37a8d9d;
case 0x0000518c:
return 0x539eb907;
case 0x00005190:
return 0xe8c4a730;
case 0x00005194:
return 0xb3f65a66;
case 0x00005198:
return 0xc75132b9;
case 0x0000519c:
return 0x76eddb98;
case 0x000051a0:
return 0xf9f37b52;
case 0x000051a4:
return 0xd0cf4f3a;
case 0x000051a8:
return 0x859b0450;
case 0x000051ac:
return 0x832d2da2;
case 0x000051b0:
return 0x8f40426d;
case 0x000051b4:
return 0x6b9e1e86;
case 0x000051b8:
return 0xb383642d;
case 0x000051bc:
return 0x5be3dfb9;
case 0x000051c0:
return 0x39082249;
case 0x000051c4:
return 0x1cdde5fe;
case 0x000051c8:
return 0x7852fd7f;
case 0x000051cc:
return 0x4d80bcdf;
case 0x000051d0:
return 0x94b1ce4b;
case 0x000051d4:
return 0x4f3b0c35;
case 0x000051d8:
return 0x0d1df059;
case 0x000051dc:
return 0x743c2d29;
case 0x000051e0:
return 0x56ec9eb1;
case 0x000051e4:
return 0xfc98e45e;
case 0x000051e8:
return 0xf5851767;
case 0x000051ec:
return 0x91977423;
case 0x000051f0:
return 0x6261512d;
case 0x000051f4:
return 0x597ef967;
case 0x000051f8:
return 0x7b4d2473;
case 0x000051fc:
return 0xdc3db15d;
case 0x00005200:
return 0x6f46962b;
case 0x00005204:
return 0x0fce45c0;
case 0x00005208:
return 0xb14e73a0;
case 0x0000520c:
return 0xa65444d4;
case 0x00005210:
return 0x99be5d16;
case 0x00005214:
return 0x4dddc867;
case 0x00005218:
return 0x4c78f2b8;
case 0x0000521c:
return 0x40ebf096;
case 0x00005220:
return 0x52944010;
case 0x00005224:
return 0xc3ad8e81;
case 0x00005228:
return 0xe8903c86;
case 0x0000522c:
return 0x43c01f17;
case 0x00005230:
return 0xbdfd584b;
case 0x00005234:
return 0x393eee64;
case 0x00005238:
return 0x1148f8f3;
case 0x0000523c:
return 0xb5463ad0;
case 0x00005240:
return 0x40df6ef1;
case 0x00005244:
return 0x374bbab7;
case 0x00005248:
return 0x798e1714;
case 0x0000524c:
return 0xd05a512e;
case 0x00005250:
return 0x3ecd9b7a;
case 0x00005254:
return 0xb599a823;
case 0x00005258:
return 0x2929e21e;
case 0x0000525c:
return 0x689e5012;
case 0x00005260:
return 0x6eb6100f;
case 0x00005264:
return 0xe5b04664;
case 0x00005268:
return 0x540f0ffb;
case 0x0000526c:
return 0xd3cc89ad;
case 0x00005270:
return 0xe56f9898;
case 0x00005274:
return 0x6bb7a4a5;
case 0x00005278:
return 0x2defb856;
case 0x0000527c:
return 0xd11eaf7f;
case 0x00005280:
return 0x39b5ab03;
case 0x00005284:
return 0xf7e61f65;
case 0x00005288:
return 0x042ecd11;
case 0x0000528c:
return 0xd1a65a86;
case 0x00005290:
return 0xca13f8b1;
case 0x00005294:
return 0xb0044683;
case 0x00005298:
return 0xc45f0505;
case 0x0000529c:
return 0x5f607653;
case 0x000052a0:
return 0x2f9ec54b;
case 0x000052a4:
return 0xd9c1662b;
case 0x000052a8:
return 0x9ef7c22b;
case 0x000052ac:
return 0x2363debf;
case 0x000052b0:
return 0x5774458c;
case 0x000052b4:
return 0xa776cf0d;
case 0x000052b8:
return 0x51e3cf6a;
case 0x000052bc:
return 0x10268829;
case 0x000052c0:
return 0xfb2b0cab;
case 0x000052c4:
return 0xbb0def18;
case 0x000052c8:
return 0xc54f51c5;
case 0x000052cc:
return 0xbd547179;
case 0x000052d0:
return 0x098a5efa;
case 0x000052d4:
return 0xaee9c425;
case 0x000052d8:
return 0xc1949d88;
case 0x000052dc:
return 0x49e6434b;
case 0x000052e0:
return 0xdd867368;
case 0x000052e4:
return 0x84191ef5;
case 0x000052e8:
return 0xe070d7b0;
case 0x000052ec:
return 0x1ed8c841;
case 0x000052f0:
return 0xad878d51;
case 0x000052f4:
return 0x23f4e719;
case 0x000052f8:
return 0x4e9143fc;
case 0x000052fc:
return 0x4a3f5511;
case 0x00005300:
return 0xc7c9cb3a;
case 0x00005304:
return 0x8bb67833;
case 0x00005308:
return 0xb80fd6e3;
case 0x0000530c:
return 0x6a5bb717;
case 0x00005310:
return 0x8541831d;
case 0x00005314:
return 0x6e260f32;
case 0x00005318:
return 0x209ccf75;
case 0x0000531c:
return 0xb860a6ba;
case 0x00005320:
return 0xf7b75736;
case 0x00005324:
return 0x43ff46a6;
case 0x00005328:
return 0xad19e806;
case 0x0000532c:
return 0xb8594822;
case 0x00005330:
return 0x6fb1c445;
case 0x00005334:
return 0x7ad5c577;
case 0x00005338:
return 0x3711e9ae;
case 0x0000533c:
return 0x451c244a;
case 0x00005340:
return 0xbc3d7834;
case 0x00005344:
return 0x35aa8909;
case 0x00005348:
return 0xb6b2c550;
case 0x0000534c:
return 0xf8dbd6f8;
case 0x00005350:
return 0x352b0e93;
case 0x00005354:
return 0x902adf9c;
case 0x00005358:
return 0x0fa79d41;
case 0x0000535c:
return 0x55c7dd92;
case 0x00005360:
return 0x609695b1;
case 0x00005364:
return 0x1ce35bfa;
case 0x00005368:
return 0xda54b186;
case 0x0000536c:
return 0x5ed98cf0;
case 0x00005370:
return 0xbc77cd8b;
case 0x00005374:
return 0x6c31630d;
case 0x00005378:
return 0x51a4c6ef;
case 0x0000537c:
return 0xd4f702e2;
case 0x00005380:
return 0xa1b61eab;
case 0x00005384:
return 0x617c9e96;
case 0x00005388:
return 0xd9f104da;
case 0x0000538c:
return 0xec712c6a;
case 0x00005390:
return 0xe2c50ef6;
case 0x00005394:
return 0xcb8a0632;
case 0x00005398:
return 0x20b8d2ca;
case 0x0000539c:
return 0x100fdef7;
case 0x000053a0:
return 0xb8f3c7cd;
case 0x000053a4:
return 0xd6e4ed40;
case 0x000053a8:
return 0x047bd424;
case 0x000053ac:
return 0x028da57f;
case 0x000053b0:
return 0xf80bab45;
case 0x000053b4:
return 0xefe842a3;
case 0x000053b8:
return 0x7ad0333d;
case 0x000053bc:
return 0x639839c9;
case 0x000053c0:
return 0xa6f71d03;
case 0x000053c4:
return 0x3a474b96;
case 0x000053c8:
return 0x5daa81f6;
case 0x000053cc:
return 0x0fa049b5;
case 0x000053d0:
return 0x0702a999;
case 0x000053d4:
return 0x34b641bd;
case 0x000053d8:
return 0x936b206c;
case 0x000053dc:
return 0x937543c4;
case 0x000053e0:
return 0xc507db2d;
case 0x000053e4:
return 0x32621321;
case 0x000053e8:
return 0xead6cf44;
case 0x000053ec:
return 0x24b76dee;
case 0x000053f0:
return 0x95a4254b;
case 0x000053f4:
return 0x16f3cd99;
case 0x000053f8:
return 0xa461c79e;
case 0x000053fc:
return 0x60bedf88;
case 0x00005400:
return 0x2b1b53d1;
case 0x00005404:
return 0xf1b3c662;
case 0x00005408:
return 0xe29bb6bd;
case 0x0000540c:
return 0x31547962;
case 0x00005410:
return 0x8f1d5002;
case 0x00005414:
return 0xe8a9a5af;
case 0x00005418:
return 0x759a5247;
case 0x0000541c:
return 0x809a3b87;
case 0x00005420:
return 0x0e3973a1;
case 0x00005424:
return 0x3907cbce;
case 0x00005428:
return 0x9d1f2def;
case 0x0000542c:
return 0x58f3dca2;
case 0x00005430:
return 0x0ad0e410;
case 0x00005434:
return 0x9625ba1e;
case 0x00005438:
return 0xed65bd38;
case 0x0000543c:
return 0xe1d396a4;
case 0x00005440:
return 0x309f540c;
case 0x00005444:
return 0x3b2b48fb;
case 0x00005448:
return 0x0d401840;
case 0x0000544c:
return 0x1caea28d;
case 0x00005450:
return 0x3d004cf9;
case 0x00005454:
return 0xe02da2e9;
case 0x00005458:
return 0x52fa6843;
case 0x0000545c:
return 0xdd479375;
case 0x00005460:
return 0x3001d78d;
case 0x00005464:
return 0x88422d13;
case 0x00005468:
return 0x2d6152fb;
case 0x0000546c:
return 0x544ccd15;
case 0x00005470:
return 0x330d149f;
case 0x00005474:
return 0x2bb00a61;
case 0x00005478:
return 0x9c74a97f;
case 0x0000547c:
return 0x439f0340;
case 0x00005480:
return 0xed922288;
case 0x00005484:
return 0xe793f2e1;
case 0x00005488:
return 0x0a3a6207;
case 0x0000548c:
return 0x487f7a40;
case 0x00005490:
return 0x3ad066c9;
case 0x00005494:
return 0x079229a5;
case 0x00005498:
return 0x81146b36;
case 0x0000549c:
return 0x0279a109;
case 0x000054a0:
return 0x0c6924f3;
case 0x000054a4:
return 0x781e0584;
case 0x000054a8:
return 0x06d9f8bf;
case 0x000054ac:
return 0x57f0b73f;
case 0x000054b0:
return 0x53fdabe7;
case 0x000054b4:
return 0xc4afadd9;
case 0x000054b8:
return 0x6bc048f4;
case 0x000054bc:
return 0xbe18bb99;
case 0x000054c0:
return 0xf676cb41;
case 0x000054c4:
return 0x40d303ef;
case 0x000054c8:
return 0x9083cc2e;
case 0x000054cc:
return 0xba382fb2;
case 0x000054d0:
return 0xc0b49ea0;
case 0x000054d4:
return 0xac65b08a;
case 0x000054d8:
return 0xf09e53d6;
case 0x000054dc:
return 0x4fd945da;
case 0x000054e0:
return 0xabacda7b;
case 0x000054e4:
return 0x691caca6;
case 0x000054e8:
return 0x160ebd61;
case 0x000054ec:
return 0x3c93d77d;
case 0x000054f0:
return 0xd9c8ecf6;
case 0x000054f4:
return 0x01aa82e1;
case 0x000054f8:
return 0xe3c95cb2;
case 0x000054fc:
return 0xe8a53e80;
case 0x00005500:
return 0x92dc6ba1;
case 0x00005504:
return 0x98364215;
case 0x00005508:
return 0xf10038f2;
case 0x0000550c:
return 0x503ae577;
case 0x00005510:
return 0xa7880172;
case 0x00005514:
return 0x0c0eeabb;
case 0x00005518:
return 0x631d4cf6;
case 0x0000551c:
return 0x01bc3f37;
case 0x00005520:
return 0xa2a831be;
case 0x00005524:
return 0xc790b7f2;
case 0x00005528:
return 0x889b3215;
case 0x0000552c:
return 0x97e269a5;
case 0x00005530:
return 0x4f95d164;
case 0x00005534:
return 0xfff31354;
case 0x00005538:
return 0x1c3ab260;
case 0x0000553c:
return 0x0f75adce;
case 0x00005540:
return 0x4fd23276;
case 0x00005544:
return 0x3913ad6e;
case 0x00005548:
return 0xff9f0d95;
case 0x0000554c:
return 0xd67d13b0;
case 0x00005550:
return 0xc3148429;
case 0x00005554:
return 0x1f388486;
case 0x00005558:
return 0x6f4c197e;
case 0x0000555c:
return 0xcb87ab06;
case 0x00005560:
return 0xc081a64f;
case 0x00005564:
return 0x70480bec;
case 0x00005568:
return 0x9fbd0fc6;
case 0x0000556c:
return 0xe45e0c1d;
case 0x00005570:
return 0xc6eb230d;
case 0x00005574:
return 0x776d0615;
case 0x00005578:
return 0x2838920e;
case 0x0000557c:
return 0x93e2bc79;
case 0x00005580:
return 0x0db8d3f8;
case 0x00005584:
return 0x2b5fb2ce;
case 0x00005588:
return 0x828faa54;
case 0x0000558c:
return 0x6ac7112d;
case 0x00005590:
return 0x8471179a;
case 0x00005594:
return 0xfc8e0124;
case 0x00005598:
return 0x4dceeedc;
case 0x0000559c:
return 0x26974bb5;
case 0x000055a0:
return 0x71dfb0a7;
case 0x000055a4:
return 0xe4c8483f;
case 0x000055a8:
return 0xf48529e2;
case 0x000055ac:
return 0x6d5643d3;
case 0x000055b0:
return 0xbfcd7068;
case 0x000055b4:
return 0x8afc3a41;
case 0x000055b8:
return 0x7390be10;
case 0x000055bc:
return 0x2895273b;
case 0x000055c0:
return 0x0109603f;
case 0x000055c4:
return 0x179ac7f2;
case 0x000055c8:
return 0xb0474c62;
case 0x000055cc:
return 0x80dd560d;
case 0x000055d0:
return 0x41bac1a4;
case 0x000055d4:
return 0xa4002a2c;
case 0x000055d8:
return 0x2f2dfb97;
case 0x000055dc:
return 0xb691f8f6;
case 0x000055e0:
return 0x2374fb2b;
case 0x000055e4:
return 0x0c29f912;
case 0x000055e8:
return 0x23fff371;
case 0x000055ec:
return 0xf85c4c9d;
case 0x000055f0:
return 0x0ffdb073;
case 0x000055f4:
return 0x3320f00d;
case 0x000055f8:
return 0x175b7af8;
case 0x000055fc:
return 0xa0e1a481;
case 0x00005600:
return 0x70fb652c;
case 0x00005604:
return 0x22ff4a62;
case 0x00005608:
return 0x40fe3aaf;
case 0x0000560c:
return 0x63e07379;
case 0x00005610:
return 0x353cbd8a;
case 0x00005614:
return 0xc7169eef;
case 0x00005618:
return 0xe0da4163;
case 0x0000561c:
return 0x601a06e7;
case 0x00005620:
return 0xb4ea8d14;
case 0x00005624:
return 0x072789ba;
case 0x00005628:
return 0xf2e80b73;
case 0x0000562c:
return 0xcb666c8c;
case 0x00005630:
return 0x5259007d;
case 0x00005634:
return 0x7d916b6c;
case 0x00005638:
return 0x045fd65e;
case 0x0000563c:
return 0xe89429a3;
case 0x00005640:
return 0x86c99007;
case 0x00005644:
return 0x26b3b2b3;
case 0x00005648:
return 0xcc07e7df;
case 0x0000564c:
return 0x2fe4d6b7;
case 0x00005650:
return 0x73bfe405;
case 0x00005654:
return 0x13bec041;
case 0x00005658:
return 0x33f61131;
case 0x0000565c:
return 0x37ae7a16;
case 0x00005660:
return 0xb4f2a243;
case 0x00005664:
return 0xa6f37dc1;
case 0x00005668:
return 0xc7a308ff;
case 0x0000566c:
return 0x068afbb3;
case 0x00005670:
return 0x8a326a51;
case 0x00005674:
return 0x930028b6;
case 0x00005678:
return 0xeccf35a3;
case 0x0000567c:
return 0x47127f6c;
case 0x00005680:
return 0x79cb9dd0;
case 0x00005684:
return 0x69d20ee6;
case 0x00005688:
return 0xa8117e75;
case 0x0000568c:
return 0x7e73c976;
case 0x00005690:
return 0x8a27b0ed;
case 0x00005694:
return 0xbdb743d2;
case 0x00005698:
return 0x6dbecbe5;
case 0x0000569c:
return 0x8bb0b45c;
case 0x000056a0:
return 0x0d074dda;
case 0x000056a4:
return 0x7542097e;
case 0x000056a8:
return 0x119ec367;
case 0x000056ac:
return 0xdf7ecfc6;
case 0x000056b0:
return 0xea03fbbd;
case 0x000056b4:
return 0xbebe42ee;
case 0x000056b8:
return 0x309ebe52;
case 0x000056bc:
return 0x17542afe;
case 0x000056c0:
return 0x57528f21;
case 0x000056c4:
return 0xe99a4250;
case 0x000056c8:
return 0x2f96fe86;
case 0x000056cc:
return 0xa4c5f88c;
case 0x000056d0:
return 0x280f1585;
case 0x000056d4:
return 0x6f14886f;
case 0x000056d8:
return 0xd104b5b3;
case 0x000056dc:
return 0x08185ba8;
case 0x000056e0:
return 0x2c83d7b2;
case 0x000056e4:
return 0xf6c99f0a;
case 0x000056e8:
return 0xf61c6362;
case 0x000056ec:
return 0x6db0d8bf;
case 0x000056f0:
return 0x16ecaa02;
case 0x000056f4:
return 0xaff2b6a7;
case 0x000056f8:
return 0x73061e27;
case 0x000056fc:
return 0x0e3414df;
case 0x00005700:
return 0xa3aa3423;
case 0x00005704:
return 0x44251b44;
case 0x00005708:
return 0xf892becf;
case 0x0000570c:
return 0xed333a73;
case 0x00005710:
return 0xa76b5644;
case 0x00005714:
return 0xfb97e013;
case 0x00005718:
return 0x3a173cf2;
case 0x0000571c:
return 0xdf25d1f4;
case 0x00005720:
return 0xa1fd3519;
case 0x00005724:
return 0x598d381e;
case 0x00005728:
return 0xe1699fab;
case 0x0000572c:
return 0x51230ffd;
case 0x00005730:
return 0x4d19558f;
case 0x00005734:
return 0xa1855d77;
case 0x00005738:
return 0x99c41260;
case 0x0000573c:
return 0xa0a82f75;
case 0x00005740:
return 0x1b61ded1;
case 0x00005744:
return 0xe2397167;
case 0x00005748:
return 0x02124499;
case 0x0000574c:
return 0xbd613c4e;
case 0x00005750:
return 0x0c9dc3ec;
case 0x00005754:
return 0xea668441;
case 0x00005758:
return 0xfff996fd;
case 0x0000575c:
return 0x1ab7541d;
case 0x00005760:
return 0xd233238d;
case 0x00005764:
return 0x35fe77d3;
case 0x00005768:
return 0x42248187;
case 0x0000576c:
return 0xe4ebaefe;
case 0x00005770:
return 0xde31a2ec;
case 0x00005774:
return 0x768bf2e9;
case 0x00005778:
return 0x6c51359f;
case 0x0000577c:
return 0xc5462794;
case 0x00005780:
return 0x63373519;
case 0x00005784:
return 0xa7e4fef9;
case 0x00005788:
return 0x5c0744d9;
case 0x0000578c:
return 0x8902ad19;
case 0x00005790:
return 0xfdae0622;
case 0x00005794:
return 0x81542302;
case 0x00005798:
return 0xa7ada587;
case 0x0000579c:
return 0x065ed250;
case 0x000057a0:
return 0x57374a64;
case 0x000057a4:
return 0x66917e78;
case 0x000057a8:
return 0xdef8acc2;
case 0x000057ac:
return 0x258f98ff;
case 0x000057b0:
return 0xd28797b5;
case 0x000057b4:
return 0x766d6108;
case 0x000057b8:
return 0x423dd2f7;
case 0x000057bc:
return 0x4a10c5fc;
case 0x000057c0:
return 0xf4668381;
case 0x000057c4:
return 0x331ac0a1;
case 0x000057c8:
return 0xdecccad2;
case 0x000057cc:
return 0xa17c2223;
case 0x000057d0:
return 0x7eb417b0;
case 0x000057d4:
return 0xb4a832f6;
case 0x000057d8:
return 0xdb52c7dc;
case 0x000057dc:
return 0x222871f6;
case 0x000057e0:
return 0xff17a31c;
case 0x000057e4:
return 0xe221daa0;
case 0x000057e8:
return 0x23e09cce;
case 0x000057ec:
return 0x2222ff5f;
case 0x000057f0:
return 0x3ada0b26;
case 0x000057f4:
return 0x123c83b1;
case 0x000057f8:
return 0xec127e56;
case 0x000057fc:
return 0x334e3d76;
case 0x00005800:
return 0x5fa5dfdb;
case 0x00005804:
return 0xeb107951;
case 0x00005808:
return 0xc2560f56;
case 0x0000580c:
return 0xe26b3ca5;
case 0x00005810:
return 0x1fd99233;
case 0x00005814:
return 0x39b016d6;
case 0x00005818:
return 0xbf32c916;
case 0x0000581c:
return 0x4a11aaa8;
case 0x00005820:
return 0xeb9180dc;
case 0x00005824:
return 0x8b40c4f9;
case 0x00005828:
return 0x4ab3ae0b;
case 0x0000582c:
return 0x34319804;
case 0x00005830:
return 0x11fdddfc;
case 0x00005834:
return 0xe9b72232;
case 0x00005838:
return 0x35d8f43d;
case 0x0000583c:
return 0xeca00411;
case 0x00005840:
return 0x06c8e144;
case 0x00005844:
return 0x8dea39d1;
case 0x00005848:
return 0x78c7c354;
case 0x0000584c:
return 0x37349cb5;
case 0x00005850:
return 0xe52d65b8;
case 0x00005854:
return 0x18e8ddd0;
case 0x00005858:
return 0xdb355795;
case 0x0000585c:
return 0x5ccb5c28;
case 0x00005860:
return 0x817905d3;
case 0x00005864:
return 0xe3bd0354;
case 0x00005868:
return 0x415b2431;
case 0x0000586c:
return 0xec1b462e;
case 0x00005870:
return 0x66560140;
case 0x00005874:
return 0x1699f008;
case 0x00005878:
return 0x0c5e791a;
case 0x0000587c:
return 0xf093c1c1;
case 0x00005880:
return 0x0625b711;
case 0x00005884:
return 0x3a3f442d;
case 0x00005888:
return 0x9bc010a9;
case 0x0000588c:
return 0xa75ae2d2;
case 0x00005890:
return 0xf75f174f;
case 0x00005894:
return 0x268d49d2;
case 0x00005898:
return 0x3cd36bde;
case 0x0000589c:
return 0xd654d623;
case 0x000058a0:
return 0x1a717e3a;
case 0x000058a4:
return 0x5181e76c;
case 0x000058a8:
return 0x35f11aff;
case 0x000058ac:
return 0x38bb95b2;
case 0x000058b0:
return 0x624957ab;
case 0x000058b4:
return 0xa300d054;
case 0x000058b8:
return 0x81b7e8f4;
case 0x000058bc:
return 0xe2c716b5;
case 0x000058c0:
return 0x653fa6bf;
case 0x000058c4:
return 0x81b01222;
case 0x000058c8:
return 0xefd92c4a;
case 0x000058cc:
return 0x1c194cc0;
case 0x000058d0:
return 0x7dc35849;
case 0x000058d4:
return 0x7848d295;
case 0x000058d8:
return 0x14b8db31;
case 0x000058dc:
return 0x9d1c718d;
case 0x000058e0:
return 0x5a6667ce;
case 0x000058e4:
return 0x66179766;
case 0x000058e8:
return 0x03777f48;
case 0x000058ec:
return 0x3dde2fb8;
case 0x000058f0:
return 0x52323fd4;
case 0x000058f4:
return 0xbac49fd0;
case 0x000058f8:
return 0x7a51d36c;
case 0x000058fc:
return 0xd800bbc2;
case 0x00005900:
return 0x4bd0b002;
case 0x00005904:
return 0x9a754b87;
case 0x00005908:
return 0x6f850747;
case 0x0000590c:
return 0xc2035ea6;
case 0x00005910:
return 0xe471818f;
case 0x00005914:
return 0x73312e69;
case 0x00005918:
return 0x5c48b1c2;
case 0x0000591c:
return 0xe2670cff;
case 0x00005920:
return 0x31b44cc7;
case 0x00005924:
return 0x42277171;
case 0x00005928:
return 0x29b4dee1;
case 0x0000592c:
return 0xe17b8b7e;
case 0x00005930:
return 0x92aeb632;
case 0x00005934:
return 0xd4c81ed4;
case 0x00005938:
return 0x35efd990;
case 0x0000593c:
return 0xc84d8e7f;
case 0x00005940:
return 0x105da935;
case 0x00005944:
return 0x99927706;
case 0x00005948:
return 0x3cbbc66a;
case 0x0000594c:
return 0x4eb4c93d;
case 0x00005950:
return 0x1b0184e7;
case 0x00005954:
return 0x8d1ac07c;
case 0x00005958:
return 0x88503ef5;
case 0x0000595c:
return 0x6ce1f122;
case 0x00005960:
return 0xa4b34d84;
case 0x00005964:
return 0x82b83e10;
case 0x00005968:
return 0x5bbf0cbe;
case 0x0000596c:
return 0x9b1908d2;
case 0x00005970:
return 0xf0ad1557;
case 0x00005974:
return 0xb87c9921;
case 0x00005978:
return 0xa4a43d50;
case 0x0000597c:
return 0xc6b3cfe7;
case 0x00005980:
return 0xd31c85a1;
case 0x00005984:
return 0x85df0af9;
case 0x00005988:
return 0x194fc075;
case 0x0000598c:
return 0x7e696b40;
case 0x00005990:
return 0xc91352e0;
case 0x00005994:
return 0xa2b08d42;
case 0x00005998:
return 0xba8eb6b0;
case 0x0000599c:
return 0x81e45a62;
case 0x000059a0:
return 0x3ed1c008;
case 0x000059a4:
return 0xfd550acf;
case 0x000059a8:
return 0xd0af1358;
case 0x000059ac:
return 0xf66dfcc0;
case 0x000059b0:
return 0xe2205ac2;
case 0x000059b4:
return 0xedd6019d;
case 0x000059b8:
return 0xc8410580;
case 0x000059bc:
return 0xf57cf5d9;
case 0x000059c0:
return 0xb63af5ef;
case 0x000059c4:
return 0xbb0d9451;
case 0x000059c8:
return 0x338fad86;
case 0x000059cc:
return 0x977cd131;
case 0x000059d0:
return 0xb309d156;
case 0x000059d4:
return 0xcbd88e51;
case 0x000059d8:
return 0x89f16ed8;
case 0x000059dc:
return 0xbdd0e0ff;
case 0x000059e0:
return 0xa51e57c9;
case 0x000059e4:
return 0xa2825012;
case 0x000059e8:
return 0x950b7119;
case 0x000059ec:
return 0x58a11408;
case 0x000059f0:
return 0x76129010;
case 0x000059f4:
return 0xe2bbfb7e;
case 0x000059f8:
return 0xb0285554;
case 0x000059fc:
return 0xf9ecf780;
case 0x00005a00:
return 0x5971b670;
case 0x00005a04:
return 0xad7eb3e2;
case 0x00005a08:
return 0xf9abbd91;
case 0x00005a0c:
return 0x03c1e649;
case 0x00005a10:
return 0xaef54240;
case 0x00005a14:
return 0xcf80cea1;
case 0x00005a18:
return 0x770198b0;
case 0x00005a1c:
return 0x9f57c639;
case 0x00005a20:
return 0x261b179a;
case 0x00005a24:
return 0xa771fcb9;
case 0x00005a28:
return 0xbc233e56;
case 0x00005a2c:
return 0x84fb6626;
case 0x00005a30:
return 0xa32d9ff7;
case 0x00005a34:
return 0xd224f67b;
case 0x00005a38:
return 0x65de1ea1;
case 0x00005a3c:
return 0x34f2e7c0;
case 0x00005a40:
return 0x08c45302;
case 0x00005a44:
return 0xffc2583f;
case 0x00005a48:
return 0xcf8df07d;
case 0x00005a4c:
return 0x89cfbafb;
case 0x00005a50:
return 0x469e7c8e;
case 0x00005a54:
return 0x1f1f5226;
case 0x00005a58:
return 0x94aa327e;
case 0x00005a5c:
return 0xbbea1571;
case 0x00005a60:
return 0xdca3169a;
case 0x00005a64:
return 0x3bf6203c;
case 0x00005a68:
return 0xf7b2f37d;
case 0x00005a6c:
return 0xab513721;
case 0x00005a70:
return 0x70ebf24a;
case 0x00005a74:
return 0x21d6ba98;
case 0x00005a78:
return 0xa364d215;
case 0x00005a7c:
return 0xf17131cf;
case 0x00005a80:
return 0x37fcb074;
case 0x00005a84:
return 0xa225d22f;
case 0x00005a88:
return 0x0efbe415;
case 0x00005a8c:
return 0x13254c88;
case 0x00005a90:
return 0xb27242c4;
case 0x00005a94:
return 0x4a35b6e2;
case 0x00005a98:
return 0x9ac22034;
case 0x00005a9c:
return 0xf707a119;
case 0x00005aa0:
return 0x235c7f86;
case 0x00005aa4:
return 0x92a36d96;
case 0x00005aa8:
return 0x03e518d0;
case 0x00005aac:
return 0x699caa55;
case 0x00005ab0:
return 0xb1188464;
case 0x00005ab4:
return 0x0ea96485;
case 0x00005ab8:
return 0x75412f91;
case 0x00005abc:
return 0xe25123b0;
case 0x00005ac0:
return 0xf9daa010;
case 0x00005ac4:
return 0x23961261;
case 0x00005ac8:
return 0xbca4ce0b;
case 0x00005acc:
return 0x2b194c96;
case 0x00005ad0:
return 0xde90d7a8;
case 0x00005ad4:
return 0x3e722892;
case 0x00005ad8:
return 0x33ac6a25;
case 0x00005adc:
return 0xbc2de908;
case 0x00005ae0:
return 0x653cb05d;
case 0x00005ae4:
return 0x86da1ffe;
case 0x00005ae8:
return 0xbd311781;
case 0x00005aec:
return 0x4ffde820;
case 0x00005af0:
return 0x0d09772c;
case 0x00005af4:
return 0xd46a8c8c;
case 0x00005af8:
return 0x7c3fd36f;
case 0x00005afc:
return 0xe7cb5c66;
case 0x00005b00:
return 0xf6ba0bbf;
case 0x00005b04:
return 0xd775b340;
case 0x00005b08:
return 0x6b0003f6;
case 0x00005b0c:
return 0xdcbf1345;
case 0x00005b10:
return 0xc5d16384;
case 0x00005b14:
return 0x957fd4d2;
case 0x00005b18:
return 0x918cdd5c;
case 0x00005b1c:
return 0xc3346b68;
case 0x00005b20:
return 0x0f3ef3d4;
case 0x00005b24:
return 0xb9257ba7;
case 0x00005b28:
return 0x75d988df;
case 0x00005b2c:
return 0x53f46465;
case 0x00005b30:
return 0x556e4cab;
case 0x00005b34:
return 0xb24bed84;
case 0x00005b38:
return 0x11870151;
case 0x00005b3c:
return 0xda0b2d3c;
case 0x00005b40:
return 0xd7144755;
case 0x00005b44:
return 0xfa045185;
case 0x00005b48:
return 0xf419accd;
case 0x00005b4c:
return 0x4679122e;
case 0x00005b50:
return 0x056a3529;
case 0x00005b54:
return 0x51fba812;
case 0x00005b58:
return 0x8c2ce097;
case 0x00005b5c:
return 0x335c16ae;
case 0x00005b60:
return 0xcdc1ea9f;
case 0x00005b64:
return 0x997e4d6a;
case 0x00005b68:
return 0xbfacc6d5;
case 0x00005b6c:
return 0xcb21c5ef;
case 0x00005b70:
return 0x63224f93;
case 0x00005b74:
return 0x01b2176b;
case 0x00005b78:
return 0xd24053c6;
case 0x00005b7c:
return 0x5f66aa9c;
case 0x00005b80:
return 0xe73fa84a;
case 0x00005b84:
return 0x3ad2e805;
case 0x00005b88:
return 0xf2e4ab14;
case 0x00005b8c:
return 0x89f64aa6;
case 0x00005b90:
return 0x242ffc71;
case 0x00005b94:
return 0xe5c4ea8a;
case 0x00005b98:
return 0x079aeeef;
case 0x00005b9c:
return 0x69f8654a;
case 0x00005ba0:
return 0x3702814b;
case 0x00005ba4:
return 0x3f5a8bc2;
case 0x00005ba8:
return 0xabfc917e;
case 0x00005bac:
return 0x91120900;
case 0x00005bb0:
return 0x93138a03;
case 0x00005bb4:
return 0xc2989664;
case 0x00005bb8:
return 0x3e80a255;
case 0x00005bbc:
return 0x07c36c83;
case 0x00005bc0:
return 0x80c60a55;
case 0x00005bc4:
return 0xe3bbb36c;
case 0x00005bc8:
return 0x2c4d6570;
case 0x00005bcc:
return 0x2fa26d7b;
case 0x00005bd0:
return 0x15b0e39f;
case 0x00005bd4:
return 0xf9ebc00f;
case 0x00005bd8:
return 0xfa7843cc;
case 0x00005bdc:
return 0xd1d8e0f6;
case 0x00005be0:
return 0x5948cecf;
case 0x00005be4:
return 0x83187683;
case 0x00005be8:
return 0x3180753d;
case 0x00005bec:
return 0xf3b30412;
case 0x00005bf0:
return 0xecbbfa06;
case 0x00005bf4:
return 0x0f68ac86;
case 0x00005bf8:
return 0x91d7521a;
case 0x00005bfc:
return 0x4f1ffe87;
case 0x00005c00:
return 0x5a37cb71;
case 0x00005c04:
return 0x7e3f25a2;
case 0x00005c08:
return 0x57eab31c;
case 0x00005c0c:
return 0x2da3639c;
case 0x00005c10:
return 0x986a6607;
case 0x00005c14:
return 0xbb60673e;
case 0x00005c18:
return 0x18f3ba68;
case 0x00005c1c:
return 0x63d91ae4;
case 0x00005c20:
return 0x0b18d649;
case 0x00005c24:
return 0xe40ec5ba;
case 0x00005c28:
return 0x18dbee32;
case 0x00005c2c:
return 0xb81dd15f;
case 0x00005c30:
return 0x736ae4cb;
case 0x00005c34:
return 0x315a1553;
case 0x00005c38:
return 0x642cd90b;
case 0x00005c3c:
return 0x88c1b0bc;
case 0x00005c40:
return 0x5ca3dc82;
case 0x00005c44:
return 0xed7e1391;
case 0x00005c48:
return 0x499807ce;
case 0x00005c4c:
return 0x59b7abe2;
case 0x00005c50:
return 0xef304286;
case 0x00005c54:
return 0x5eeb4a5f;
case 0x00005c58:
return 0x1b9aecfe;
case 0x00005c5c:
return 0xba95e569;
case 0x00005c60:
return 0x6fe6ebc0;
case 0x00005c64:
return 0xe8082600;
case 0x00005c68:
return 0xfb364906;
case 0x00005c6c:
return 0xfa998457;
case 0x00005c70:
return 0x6a950b1d;
case 0x00005c74:
return 0x8ea994c5;
case 0x00005c78:
return 0x8d8ad13c;
case 0x00005c7c:
return 0x8087feec;
case 0x00005c80:
return 0x1dc20b63;
case 0x00005c84:
return 0xb725fd73;
case 0x00005c88:
return 0x4c51f0bd;
case 0x00005c8c:
return 0x3953cfe4;
case 0x00005c90:
return 0x1c88441e;
case 0x00005c94:
return 0x112f31a4;
case 0x00005c98:
return 0xca2867b0;
case 0x00005c9c:
return 0x0216d4db;
case 0x00005ca0:
return 0x0b2d2ab0;
case 0x00005ca4:
return 0xa4843604;
case 0x00005ca8:
return 0x8cba99dd;
case 0x00005cac:
return 0x0cbd91db;
case 0x00005cb0:
return 0x62ccfdd6;
case 0x00005cb4:
return 0x52713c60;
case 0x00005cb8:
return 0x7ca94c6d;
case 0x00005cbc:
return 0xb120ad51;
case 0x00005cc0:
return 0x57193d3c;
case 0x00005cc4:
return 0x2ce0784e;
case 0x00005cc8:
return 0xa1b413ee;
case 0x00005ccc:
return 0x5dc2fe0c;
case 0x00005cd0:
return 0x2f56b6d4;
case 0x00005cd4:
return 0x03f55026;
case 0x00005cd8:
return 0x17d83c1a;
case 0x00005cdc:
return 0xbbfed1f4;
case 0x00005ce0:
return 0x13b06f1c;
case 0x00005ce4:
return 0x9570766d;
case 0x00005ce8:
return 0xae7a5a03;
case 0x00005cec:
return 0x808a5320;
case 0x00005cf0:
return 0x68dd733d;
case 0x00005cf4:
return 0x91c65951;
case 0x00005cf8:
return 0xed934efb;
case 0x00005cfc:
return 0xc0177f2c;
case 0x00005d00:
return 0x6ce4eabd;
case 0x00005d04:
return 0x3869e560;
case 0x00005d08:
return 0x553e169e;
case 0x00005d0c:
return 0xd25794c5;
case 0x00005d10:
return 0x61e232a7;
case 0x00005d14:
return 0xf755b707;
case 0x00005d18:
return 0xc3ef9158;
case 0x00005d1c:
return 0xcdee5934;
case 0x00005d20:
return 0x6d60eb72;
case 0x00005d24:
return 0xf05aa0c6;
case 0x00005d28:
return 0x9e578321;
case 0x00005d2c:
return 0x64d7ef57;
case 0x00005d30:
return 0x61c1ebee;
case 0x00005d34:
return 0xa571b366;
case 0x00005d38:
return 0x06089e39;
case 0x00005d3c:
return 0x5a907e19;
case 0x00005d40:
return 0x955533b1;
case 0x00005d44:
return 0x5e10ce4a;
case 0x00005d48:
return 0xb9d2d74d;
case 0x00005d4c:
return 0x0f5cfbd5;
case 0x00005d50:
return 0x568b9ccd;
case 0x00005d54:
return 0x546b1b54;
case 0x00005d58:
return 0xb9f17821;
case 0x00005d5c:
return 0x08683763;
case 0x00005d60:
return 0x0961424b;
case 0x00005d64:
return 0xf8c0b4ad;
case 0x00005d68:
return 0x40a9c6a8;
case 0x00005d6c:
return 0xe4211a23;
case 0x00005d70:
return 0x0cf52313;
case 0x00005d74:
return 0xe7713d91;
case 0x00005d78:
return 0x32f58814;
case 0x00005d7c:
return 0x8b1a75f2;
case 0x00005d80:
return 0xcec47d87;
case 0x00005d84:
return 0xba59883b;
case 0x00005d88:
return 0x1c844223;
case 0x00005d8c:
return 0xb1f22374;
case 0x00005d90:
return 0x9dcfb079;
case 0x00005d94:
return 0x3174a326;
case 0x00005d98:
return 0x3bd145f1;
case 0x00005d9c:
return 0x75e908f1;
case 0x00005da0:
return 0xf6635edb;
case 0x00005da4:
return 0xc065b825;
case 0x00005da8:
return 0x6f98e23d;
case 0x00005dac:
return 0xdebb7df3;
case 0x00005db0:
return 0xf82b5b0e;
case 0x00005db4:
return 0x1101e58d;
case 0x00005db8:
return 0xf36ffba8;
case 0x00005dbc:
return 0x613f8828;
case 0x00005dc0:
return 0x3677d80d;
case 0x00005dc4:
return 0x680110a9;
case 0x00005dc8:
return 0x6e0d53ca;
case 0x00005dcc:
return 0x648ced1f;
case 0x00005dd0:
return 0x0b97cb9f;
case 0x00005dd4:
return 0xa2fd10cc;
case 0x00005dd8:
return 0x2fd7c331;
case 0x00005ddc:
return 0xef0dd701;
case 0x00005de0:
return 0xc030e230;
case 0x00005de4:
return 0x0298e745;
case 0x00005de8:
return 0x845d5cd2;
case 0x00005dec:
return 0x7fc72bf4;
case 0x00005df0:
return 0xbeb59c3d;
case 0x00005df4:
return 0x8967bd75;
case 0x00005df8:
return 0x5fd5f84c;
case 0x00005dfc:
return 0xd5fd5b9c;
case 0x00005e00:
return 0xd0c53700;
case 0x00005e04:
return 0x8e03d433;
case 0x00005e08:
return 0x50936196;
case 0x00005e0c:
return 0x3ba981f6;
case 0x00005e10:
return 0x752f941e;
case 0x00005e14:
return 0x0782283d;
case 0x00005e18:
return 0x076ba988;
case 0x00005e1c:
return 0x356818b1;
case 0x00005e20:
return 0x1f8aa82b;
case 0x00005e24:
return 0x29ef160d;
case 0x00005e28:
return 0x5dfe1733;
case 0x00005e2c:
return 0x87b41b7d;
case 0x00005e30:
return 0xa8507dfa;
case 0x00005e34:
return 0x8fb5baee;
case 0x00005e38:
return 0x16d4a003;
case 0x00005e3c:
return 0x88a90c28;
case 0x00005e40:
return 0x894d5b3b;
case 0x00005e44:
return 0x473a5d66;
case 0x00005e48:
return 0x391663ed;
case 0x00005e4c:
return 0x8330d06e;
case 0x00005e50:
return 0x1644352e;
case 0x00005e54:
return 0xe366d0e2;
case 0x00005e58:
return 0xbf39ab2f;
case 0x00005e5c:
return 0xa60f6728;
case 0x00005e60:
return 0xd1721843;
case 0x00005e64:
return 0xf99f0ff1;
case 0x00005e68:
return 0x1cf77302;
case 0x00005e6c:
return 0xc92394c8;
case 0x00005e70:
return 0x0ab8be4e;
case 0x00005e74:
return 0xed2d55fa;
case 0x00005e78:
return 0xcc046b8b;
case 0x00005e7c:
return 0xed9dabbd;
case 0x00005e80:
return 0x5d1ed809;
case 0x00005e84:
return 0x1480720e;
case 0x00005e88:
return 0x511bc940;
case 0x00005e8c:
return 0x313bfc66;
case 0x00005e90:
return 0xf5380336;
case 0x00005e94:
return 0x9183e7a7;
case 0x00005e98:
return 0x11b8549d;
case 0x00005e9c:
return 0xf8dd351f;
case 0x00005ea0:
return 0x32d5910d;
case 0x00005ea4:
return 0x4f921f04;
case 0x00005ea8:
return 0x44e34594;
case 0x00005eac:
return 0x671a59e0;
case 0x00005eb0:
return 0x528eb473;
case 0x00005eb4:
return 0xcfa360d8;
case 0x00005eb8:
return 0x708d7149;
case 0x00005ebc:
return 0x1a783fec;
case 0x00005ec0:
return 0x70a15882;
case 0x00005ec4:
return 0x84fb8f69;
case 0x00005ec8:
return 0x77992679;
case 0x00005ecc:
return 0x28ed7ddc;
case 0x00005ed0:
return 0x97e616be;
case 0x00005ed4:
return 0x26318f11;
case 0x00005ed8:
return 0xa3eb407e;
case 0x00005edc:
return 0xb4ba0531;
case 0x00005ee0:
return 0x33e069f4;
case 0x00005ee4:
return 0xdb602d50;
case 0x00005ee8:
return 0x3c4a29fd;
case 0x00005eec:
return 0x73c1d628;
case 0x00005ef0:
return 0x93ee8b06;
case 0x00005ef4:
return 0x37dd15a8;
case 0x00005ef8:
return 0xa353f136;
case 0x00005efc:
return 0x0e130673;
case 0x00005f00:
return 0x9c9324f8;
case 0x00005f04:
return 0xdc8071d5;
case 0x00005f08:
return 0x9e5d324a;
case 0x00005f0c:
return 0x8cdf5a28;
case 0x00005f10:
return 0x71c5bb2e;
case 0x00005f14:
return 0xfe1be736;
case 0x00005f18:
return 0x09fa0bd3;
case 0x00005f1c:
return 0x6c0e3c5a;
case 0x00005f20:
return 0x06336c3b;
case 0x00005f24:
return 0x98a1e300;
case 0x00005f28:
return 0x7fad3b9c;
case 0x00005f2c:
return 0xc4527723;
case 0x00005f30:
return 0xdd30e5d0;
case 0x00005f34:
return 0xd0460459;
case 0x00005f38:
return 0x0ec7392c;
case 0x00005f3c:
return 0x477a6c20;
case 0x00005f40:
return 0x86a78ae5;
case 0x00005f44:
return 0xf6e7acdc;
case 0x00005f48:
return 0x0493693b;
case 0x00005f4c:
return 0xeb037ed6;
case 0x00005f50:
return 0x7b4c81e2;
case 0x00005f54:
return 0xe7b9d0dd;
case 0x00005f58:
return 0xf1826776;
case 0x00005f5c:
return 0xfca9079a;
case 0x00005f60:
return 0xb8691b29;
case 0x00005f64:
return 0xa1e34b8b;
case 0x00005f68:
return 0xbe7c4e8f;
case 0x00005f6c:
return 0x7da10157;
case 0x00005f70:
return 0xfc7fe5fb;
case 0x00005f74:
return 0xc51d4973;
case 0x00005f78:
return 0x64790418;
case 0x00005f7c:
return 0x80631a5c;
case 0x00005f80:
return 0x8c7f3c65;
case 0x00005f84:
return 0xcb2f373e;
case 0x00005f88:
return 0x4ff4cb88;
case 0x00005f8c:
return 0x4beb3d76;
case 0x00005f90:
return 0x620fba74;
case 0x00005f94:
return 0x8cb2fdeb;
case 0x00005f98:
return 0xf81b36ae;
case 0x00005f9c:
return 0xf273bf4d;
case 0x00005fa0:
return 0x4a1e286b;
case 0x00005fa4:
return 0x150da1eb;
case 0x00005fa8:
return 0x0ebc46d9;
case 0x00005fac:
return 0xc070ea06;
case 0x00005fb0:
return 0x8a2e3340;
case 0x00005fb4:
return 0x1bea603d;
case 0x00005fb8:
return 0x4e0ff85c;
case 0x00005fbc:
return 0xa2aa9c02;
case 0x00005fc0:
return 0x23cd87d2;
case 0x00005fc4:
return 0x230c8e3e;
case 0x00005fc8:
return 0x34be08f9;
case 0x00005fcc:
return 0x164749fb;
case 0x00005fd0:
return 0xb6e7b18c;
case 0x00005fd4:
return 0xd59c8cf9;
case 0x00005fd8:
return 0xf5686f60;
case 0x00005fdc:
return 0x4eda978f;
case 0x00005fe0:
return 0xa0b0421b;
case 0x00005fe4:
return 0x6337c4be;
case 0x00005fe8:
return 0xc01a7b5c;
case 0x00005fec:
return 0x1968db2c;
case 0x00005ff0:
return 0x188b0da1;
case 0x00005ff4:
return 0xd0ea4416;
case 0x00005ff8:
return 0x95a9384c;
case 0x00005ffc:
return 0xd8654203;
case 0x00006000:
return 0x4d57fd19;
case 0x00006004:
return 0x396e1d53;
case 0x00006008:
return 0xa537f96a;
case 0x0000600c:
return 0xdd8c4040;
case 0x00006010:
return 0xf044bebf;
case 0x00006014:
return 0xcf9506aa;
case 0x00006018:
return 0xad1c7ed6;
case 0x0000601c:
return 0xdfd9f2fc;
case 0x00006020:
return 0xab86e918;
case 0x00006024:
return 0x7d14cca3;
case 0x00006028:
return 0x8b1f861c;
case 0x0000602c:
return 0x6cfbeb99;
case 0x00006030:
return 0x2a6ce44f;
case 0x00006034:
return 0xdb52d6e2;
case 0x00006038:
return 0x16de4a79;
case 0x0000603c:
return 0x384999de;
case 0x00006040:
return 0x2445aeea;
case 0x00006044:
return 0x945b08be;
case 0x00006048:
return 0x953e8584;
case 0x0000604c:
return 0x1b9ce1f3;
case 0x00006050:
return 0xab46cc65;
case 0x00006054:
return 0x987cdb48;
case 0x00006058:
return 0x2b449919;
case 0x0000605c:
return 0xa6a3ec6e;
case 0x00006060:
return 0x0973825d;
case 0x00006064:
return 0xff008f0e;
case 0x00006068:
return 0xed212e87;
case 0x0000606c:
return 0x8dbe3232;
case 0x00006070:
return 0x7b0fdf92;
case 0x00006074:
return 0x6a1f1038;
case 0x00006078:
return 0x2f94be5f;
case 0x0000607c:
return 0x2965ff56;
case 0x00006080:
return 0xadc04d72;
case 0x00006084:
return 0xdcba00ea;
case 0x00006088:
return 0x6dbf45a0;
case 0x0000608c:
return 0xb7bd5f1b;
case 0x00006090:
return 0x0e898064;
case 0x00006094:
return 0xce59cadf;
case 0x00006098:
return 0xa8aa672b;
case 0x0000609c:
return 0x9ceca5bd;
case 0x000060a0:
return 0x9c83b03e;
case 0x000060a4:
return 0xca4fee7a;
case 0x000060a8:
return 0xfe5b1cc1;
case 0x000060ac:
return 0x47fcc55c;
case 0x000060b0:
return 0x6ac9aece;
case 0x000060b4:
return 0xae5c8893;
case 0x000060b8:
return 0x2b1675fc;
case 0x000060bc:
return 0x6580682b;
case 0x000060c0:
return 0x2e586b25;
case 0x000060c4:
return 0x87e7d06a;
case 0x000060c8:
return 0x231cdc33;
case 0x000060cc:
return 0xfc1421cc;
case 0x000060d0:
return 0x9d947ead;
case 0x000060d4:
return 0x78708e42;
case 0x000060d8:
return 0xf7bc2dd3;
case 0x000060dc:
return 0x12c8228e;
case 0x000060e0:
return 0x00797585;
case 0x000060e4:
return 0x0ba7f70c;
case 0x000060e8:
return 0xf5c636fe;
case 0x000060ec:
return 0xb6a100de;
case 0x000060f0:
return 0xc20ab948;
case 0x000060f4:
return 0x4a649a80;
case 0x000060f8:
return 0x79f17c74;
case 0x000060fc:
return 0xa4bc7d13;
case 0x00006100:
return 0xcfbc2ad9;
case 0x00006104:
return 0xb86222c5;
case 0x00006108:
return 0xd0874547;
case 0x0000610c:
return 0x0df3f969;
case 0x00006110:
return 0x3686dcb0;
case 0x00006114:
return 0x877c7f34;
case 0x00006118:
return 0x60d984c9;
case 0x0000611c:
return 0xb2fea9b7;
case 0x00006120:
return 0x93e46919;
case 0x00006124:
return 0xc1646c88;
case 0x00006128:
return 0x087b2621;
case 0x0000612c:
return 0x98dd44b6;
case 0x00006130:
return 0xb00d6b04;
case 0x00006134:
return 0x5ccd190b;
case 0x00006138:
return 0x48a77ea6;
case 0x0000613c:
return 0xbe8c85b3;
case 0x00006140:
return 0xe09bdba0;
case 0x00006144:
return 0x056feec7;
case 0x00006148:
return 0xb16f4f00;
case 0x0000614c:
return 0x67aa3914;
case 0x00006150:
return 0x2f955fe8;
case 0x00006154:
return 0x51d095bd;
case 0x00006158:
return 0x6b68a26f;
case 0x0000615c:
return 0xdf79c163;
case 0x00006160:
return 0x8dde6526;
case 0x00006164:
return 0x8dd85e87;
case 0x00006168:
return 0xb07ba2c7;
case 0x0000616c:
return 0x65cd56b8;
case 0x00006170:
return 0xbd7ceb4d;
case 0x00006174:
return 0xe25c5eb4;
case 0x00006178:
return 0xed403a9b;
case 0x0000617c:
return 0xb65b9606;
case 0x00006180:
return 0xe9e14412;
case 0x00006184:
return 0x662fef37;
case 0x00006188:
return 0x42e5f4d0;
case 0x0000618c:
return 0xe6a51175;
case 0x00006190:
return 0x8d8796e7;
case 0x00006194:
return 0x3242afec;
case 0x00006198:
return 0x7ff2f721;
case 0x0000619c:
return 0x30955f75;
case 0x000061a0:
return 0xcca11655;
case 0x000061a4:
return 0xdefc8ffb;
case 0x000061a8:
return 0x21082ad2;
case 0x000061ac:
return 0xe2eddec1;
case 0x000061b0:
return 0xedc48d16;
case 0x000061b4:
return 0xedc74d94;
case 0x000061b8:
return 0xb0c9bc6d;
case 0x000061bc:
return 0x79177b3f;
case 0x000061c0:
return 0x60131145;
case 0x000061c4:
return 0xbb1ce772;
case 0x000061c8:
return 0x28afbe4a;
case 0x000061cc:
return 0x0d093396;
case 0x000061d0:
return 0xcff27b82;
case 0x000061d4:
return 0x732a8d90;
case 0x000061d8:
return 0xca767410;
case 0x000061dc:
return 0x1dd2ff27;
case 0x000061e0:
return 0x64bedd40;
case 0x000061e4:
return 0x2d21c6ff;
case 0x000061e8:
return 0xed9e7045;
case 0x000061ec:
return 0xbc676514;
case 0x000061f0:
return 0xb668ef62;
case 0x000061f4:
return 0x8d3512c1;
case 0x000061f8:
return 0x15d80979;
case 0x000061fc:
return 0xa8584b47;
case 0x00006200:
return 0x679e73e6;
case 0x00006204:
return 0xa93e5002;
case 0x00006208:
return 0xa8d7d8a9;
case 0x0000620c:
return 0x805933c7;
case 0x00006210:
return 0x27182118;
case 0x00006214:
return 0xafda3e45;
case 0x00006218:
return 0x12d5a9a4;
case 0x0000621c:
return 0xcbfed1c2;
case 0x00006220:
return 0xd9470d43;
case 0x00006224:
return 0xcb2d7a33;
case 0x00006228:
return 0xe10416ca;
case 0x0000622c:
return 0xc395661d;
case 0x00006230:
return 0x08dd2b7a;
case 0x00006234:
return 0xead1ca98;
case 0x00006238:
return 0xfb25ab4a;
case 0x0000623c:
return 0xff53b7ff;
case 0x00006240:
return 0x1c0814be;
case 0x00006244:
return 0x547f4674;
case 0x00006248:
return 0x883c5c56;
case 0x0000624c:
return 0x5b46f637;
case 0x00006250:
return 0xffcd32aa;
case 0x00006254:
return 0x88e5680c;
case 0x00006258:
return 0xd628e8eb;
case 0x0000625c:
return 0xfc353b8b;
case 0x00006260:
return 0x98bb1608;
case 0x00006264:
return 0xf63b6cb2;
case 0x00006268:
return 0x9b358747;
case 0x0000626c:
return 0xe1679f83;
case 0x00006270:
return 0xc93356a2;
case 0x00006274:
return 0x33acd0b9;
case 0x00006278:
return 0x45d338a8;
case 0x0000627c:
return 0xf2333c85;
case 0x00006280:
return 0xc3de83ff;
case 0x00006284:
return 0xf06a82da;
case 0x00006288:
return 0x1f91de9f;
case 0x0000628c:
return 0xda9d4272;
case 0x00006290:
return 0x84b1830d;
case 0x00006294:
return 0x7fc9b8be;
case 0x00006298:
return 0x3adff77a;
case 0x0000629c:
return 0xbbcf651b;
case 0x000062a0:
return 0xea19c54a;
case 0x000062a4:
return 0x1e5d7faa;
case 0x000062a8:
return 0x27160e5f;
case 0x000062ac:
return 0x3953696f;
case 0x000062b0:
return 0x2e9444be;
case 0x000062b4:
return 0xff648a0a;
case 0x000062b8:
return 0x6fdc35ac;
case 0x000062bc:
return 0x75a43eeb;
case 0x000062c0:
return 0x8307dd0c;
case 0x000062c4:
return 0x3aa10690;
case 0x000062c8:
return 0xf11f6199;
case 0x000062cc:
return 0x4d3a5a27;
case 0x000062d0:
return 0xe1ab04b8;
case 0x000062d4:
return 0xfe11309b;
case 0x000062d8:
return 0x66b1ce9c;
case 0x000062dc:
return 0x32a22abb;
case 0x000062e0:
return 0x2e5bc7b6;
case 0x000062e4:
return 0xd70104bc;
case 0x000062e8:
return 0xb3b69ece;
case 0x000062ec:
return 0x3d3ac85a;
case 0x000062f0:
return 0x6249fb98;
case 0x000062f4:
return 0xb6c659e0;
case 0x000062f8:
return 0x66571895;
case 0x000062fc:
return 0x47ef4adb;
case 0x00006300:
return 0xad9131c7;
case 0x00006304:
return 0x3a4a2a85;
case 0x00006308:
return 0x22e163b9;
case 0x0000630c:
return 0x9861c541;
case 0x00006310:
return 0xde866720;
case 0x00006314:
return 0x5d7774f8;
case 0x00006318:
return 0x159b28de;
case 0x0000631c:
return 0x62725206;
case 0x00006320:
return 0x2567e7c2;
case 0x00006324:
return 0x725c436a;
case 0x00006328:
return 0x05a98732;
case 0x0000632c:
return 0xd86d15aa;
case 0x00006330:
return 0xbe7fe2fe;
case 0x00006334:
return 0x1712f31e;
case 0x00006338:
return 0x028200e6;
case 0x0000633c:
return 0x916bb078;
case 0x00006340:
return 0xf54d2fe2;
case 0x00006344:
return 0x44c758f8;
case 0x00006348:
return 0x599b9445;
case 0x0000634c:
return 0xa152e419;
case 0x00006350:
return 0xff753449;
case 0x00006354:
return 0x16a32acc;
case 0x00006358:
return 0x14782e10;
case 0x0000635c:
return 0x14d70b40;
case 0x00006360:
return 0x674d38bd;
case 0x00006364:
return 0xa9773e3b;
case 0x00006368:
return 0xb4e9a0c2;
case 0x0000636c:
return 0x134490da;
case 0x00006370:
return 0xaf38c3b9;
case 0x00006374:
return 0xca493995;
case 0x00006378:
return 0xf499ddb2;
case 0x0000637c:
return 0xccf97ef0;
case 0x00006380:
return 0x40bc81ba;
case 0x00006384:
return 0xe8cd3986;
case 0x00006388:
return 0x44eb2983;
case 0x0000638c:
return 0xbb4f666a;
case 0x00006390:
return 0x1a928e81;
case 0x00006394:
return 0x3e091bc8;
case 0x00006398:
return 0xd1ba61c2;
case 0x0000639c:
return 0xeeccc223;
case 0x000063a0:
return 0x6d6034b9;
case 0x000063a4:
return 0x2e9be8ea;
case 0x000063a8:
return 0x65abadfc;
case 0x000063ac:
return 0xe98c9e23;
case 0x000063b0:
return 0xa952843a;
case 0x000063b4:
return 0x414a8228;
case 0x000063b8:
return 0x64428e8c;
case 0x000063bc:
return 0x9ed4353a;
case 0x000063c0:
return 0x7e2be87b;
case 0x000063c4:
return 0xfb80d4b8;
case 0x000063c8:
return 0xd8e3f5d4;
case 0x000063cc:
return 0x95d580bb;
case 0x000063d0:
return 0x74548c9f;
case 0x000063d4:
return 0x2570bac4;
case 0x000063d8:
return 0x1b78e181;
case 0x000063dc:
return 0x2fc4d4a7;
case 0x000063e0:
return 0x2b8a6a42;
case 0x000063e4:
return 0xab948026;
case 0x000063e8:
return 0xd2165a06;
case 0x000063ec:
return 0x42b568ce;
case 0x000063f0:
return 0x5ec823bc;
case 0x000063f4:
return 0x1b1a8a7a;
case 0x000063f8:
return 0x60df1892;
case 0x000063fc:
return 0x9a538981;
case 0x00006400:
return 0xc81d0542;
case 0x00006404:
return 0x74ca077b;
case 0x00006408:
return 0xf3e2a7d3;
case 0x0000640c:
return 0x288317f2;
case 0x00006410:
return 0xcd95fb1e;
case 0x00006414:
return 0x2782e4ef;
case 0x00006418:
return 0x30c965bd;
case 0x0000641c:
return 0x4900c9b9;
case 0x00006420:
return 0x71850fc0;
case 0x00006424:
return 0xeeb45ec5;
case 0x00006428:
return 0x63d14023;
case 0x0000642c:
return 0x74247daa;
case 0x00006430:
return 0x60c28883;
case 0x00006434:
return 0x38f0bf42;
case 0x00006438:
return 0x363cce13;
case 0x0000643c:
return 0x3ae7e632;
case 0x00006440:
return 0x18fb4eb6;
case 0x00006444:
return 0xad31645f;
case 0x00006448:
return 0xbc75e1ed;
case 0x0000644c:
return 0x8ef92127;
case 0x00006450:
return 0x57995ad7;
case 0x00006454:
return 0x78ee8bba;
case 0x00006458:
return 0x46fdd4b7;
case 0x0000645c:
return 0x9d132797;
case 0x00006460:
return 0xa3d23686;
case 0x00006464:
return 0x50b0de12;
case 0x00006468:
return 0x375be392;
case 0x0000646c:
return 0x53d6adb6;
case 0x00006470:
return 0x2de4cb15;
case 0x00006474:
return 0x5649ef5f;
case 0x00006478:
return 0xc18e0be6;
case 0x0000647c:
return 0xb92e47fe;
case 0x00006480:
return 0x04c7434e;
case 0x00006484:
return 0x2e03abc8;
case 0x00006488:
return 0x8bd69f73;
case 0x0000648c:
return 0x38e43651;
case 0x00006490:
return 0xe024c7dc;
case 0x00006494:
return 0x8d342cb7;
case 0x00006498:
return 0x6f57a1de;
case 0x0000649c:
return 0xbe000185;
case 0x000064a0:
return 0x4cc13a79;
case 0x000064a4:
return 0x668ead0e;
case 0x000064a8:
return 0xa4f6f507;
case 0x000064ac:
return 0x58b39dd1;
case 0x000064b0:
return 0x1226d93c;
case 0x000064b4:
return 0x29725408;
case 0x000064b8:
return 0x92699c74;
case 0x000064bc:
return 0x9f972abf;
case 0x000064c0:
return 0x254125c9;
case 0x000064c4:
return 0xbf18ae3a;
case 0x000064c8:
return 0xcd3df68b;
case 0x000064cc:
return 0x9283fc7b;
case 0x000064d0:
return 0x689d3fba;
case 0x000064d4:
return 0x49f8bc85;
case 0x000064d8:
return 0x71c6070d;
case 0x000064dc:
return 0x7a44226e;
case 0x000064e0:
return 0x1f5cbb25;
case 0x000064e4:
return 0xee705ce0;
case 0x000064e8:
return 0x60465318;
case 0x000064ec:
return 0xd3dae17a;
case 0x000064f0:
return 0x58412098;
case 0x000064f4:
return 0x70086add;
case 0x000064f8:
return 0x7f961f83;
case 0x000064fc:
return 0x4ec2aa54;
case 0x00006500:
return 0x53bd5622;
case 0x00006504:
return 0x1a8e0ef9;
case 0x00006508:
return 0xa8f6479f;
case 0x0000650c:
return 0x6680c1eb;
case 0x00006510:
return 0x2515f5ac;
case 0x00006514:
return 0xc6ce14f0;
case 0x00006518:
return 0x7b6ac7ab;
case 0x0000651c:
return 0xb3053289;
case 0x00006520:
return 0x41268b8c;
case 0x00006524:
return 0x2195215c;
case 0x00006528:
return 0x84908be8;
case 0x0000652c:
return 0xa2f06e1f;
case 0x00006530:
return 0xa2ca9de5;
case 0x00006534:
return 0x9ba6161a;
case 0x00006538:
return 0x8ee2fb7f;
case 0x0000653c:
return 0xef655188;
case 0x00006540:
return 0xaeced860;
case 0x00006544:
return 0x3e96591c;
case 0x00006548:
return 0xe7aff76a;
case 0x0000654c:
return 0x89532b26;
case 0x00006550:
return 0x63b05166;
case 0x00006554:
return 0xd034f48d;
case 0x00006558:
return 0x30116f93;
case 0x0000655c:
return 0x418cf011;
case 0x00006560:
return 0xc6adb6fe;
case 0x00006564:
return 0x0d3e118d;
case 0x00006568:
return 0x8ff8243e;
case 0x0000656c:
return 0x13c6421e;
case 0x00006570:
return 0xc6f996ea;
case 0x00006574:
return 0xc1f68c03;
case 0x00006578:
return 0xb1edb818;
case 0x0000657c:
return 0x0e14eaf7;
case 0x00006580:
return 0x9d3b7ceb;
case 0x00006584:
return 0x1fa53e10;
case 0x00006588:
return 0x32ba9ced;
case 0x0000658c:
return 0x2967a03d;
case 0x00006590:
return 0xffd1f4df;
case 0x00006594:
return 0xdd799f92;
case 0x00006598:
return 0xbe836156;
case 0x0000659c:
return 0xf85c2a03;
case 0x000065a0:
return 0x09e00f77;
case 0x000065a4:
return 0xc3d9513b;
case 0x000065a8:
return 0xb2d2e3b4;
case 0x000065ac:
return 0x2a105de3;
case 0x000065b0:
return 0xec8ab066;
case 0x000065b4:
return 0x7ab88a09;
case 0x000065b8:
return 0x4e1412d9;
case 0x000065bc:
return 0xff83eb0a;
case 0x000065c0:
return 0xf5a25460;
case 0x000065c4:
return 0xa3d1256d;
case 0x000065c8:
return 0x4d3c6a4c;
case 0x000065cc:
return 0xf38afb97;
case 0x000065d0:
return 0xbbc3b613;
case 0x000065d4:
return 0x5b792802;
case 0x000065d8:
return 0x2c9da78b;
case 0x000065dc:
return 0x6f5137a7;
case 0x000065e0:
return 0x549427e9;
case 0x000065e4:
return 0xe97ff0ab;
case 0x000065e8:
return 0x4903147f;
case 0x000065ec:
return 0x6ed70427;
case 0x000065f0:
return 0xa3d28680;
case 0x000065f4:
return 0xc014e34a;
case 0x000065f8:
return 0x356732b7;
case 0x000065fc:
return 0x3f2537b2;
case 0x00006600:
return 0x12625570;
case 0x00006604:
return 0x9cd0ebbb;
case 0x00006608:
return 0xa98c4276;
case 0x0000660c:
return 0x6c777fdf;
case 0x00006610:
return 0x4d0cd12a;
case 0x00006614:
return 0x6da61be1;
case 0x00006618:
return 0x340304c7;
case 0x0000661c:
return 0x8856f438;
case 0x00006620:
return 0xb8290dc0;
case 0x00006624:
return 0x62bcb40b;
case 0x00006628:
return 0x1ff22cb0;
case 0x0000662c:
return 0x8a7e4bfd;
case 0x00006630:
return 0x9556b569;
case 0x00006634:
return 0x2b13482a;
case 0x00006638:
return 0xf174a50f;
case 0x0000663c:
return 0xbca15d65;
case 0x00006640:
return 0xf090c69b;
case 0x00006644:
return 0xc2d8245e;
case 0x00006648:
return 0x09d70fb8;
case 0x0000664c:
return 0xd74fa414;
case 0x00006650:
return 0xa8a17a12;
case 0x00006654:
return 0x6a71af7e;
case 0x00006658:
return 0x1c6a1f81;
case 0x0000665c:
return 0x23976d55;
case 0x00006660:
return 0xc3e33612;
case 0x00006664:
return 0x6b1f4bb1;
case 0x00006668:
return 0xd00640fa;
case 0x0000666c:
return 0x0147ce49;
case 0x00006670:
return 0xb7af6cb9;
case 0x00006674:
return 0x2d5e74b2;
case 0x00006678:
return 0x1f7f0a2e;
case 0x0000667c:
return 0xa2e421f9;
case 0x00006680:
return 0x3b45f30a;
case 0x00006684:
return 0xd5eab6a5;
case 0x00006688:
return 0x932f484e;
case 0x0000668c:
return 0x7fc073fe;
case 0x00006690:
return 0x389d1be8;
case 0x00006694:
return 0xdadd385f;
case 0x00006698:
return 0x28dbcd87;
case 0x0000669c:
return 0x3d895ce5;
case 0x000066a0:
return 0x52e568b6;
case 0x000066a4:
return 0xe5956012;
case 0x000066a8:
return 0x2af18781;
case 0x000066ac:
return 0xf54fc7e0;
case 0x000066b0:
return 0x04aeb833;
case 0x000066b4:
return 0x6f3a43f1;
case 0x000066b8:
return 0x9fa08785;
case 0x000066bc:
return 0xb92848af;
case 0x000066c0:
return 0x5b7f884e;
case 0x000066c4:
return 0x5cec17cf;
case 0x000066c8:
return 0xc944c60b;
case 0x000066cc:
return 0xc9cf1740;
case 0x000066d0:
return 0x49eae1f2;
case 0x000066d4:
return 0x0f5e359c;
case 0x000066d8:
return 0x9dd00f5e;
case 0x000066dc:
return 0xc52a30bf;
case 0x000066e0:
return 0xa9dca93e;
case 0x000066e4:
return 0x8a0ef455;
case 0x000066e8:
return 0x08aa267a;
case 0x000066ec:
return 0xc093a70b;
case 0x000066f0:
return 0xe9011e6c;
case 0x000066f4:
return 0xe29eef96;
case 0x000066f8:
return 0xfa6bfdcc;
case 0x000066fc:
return 0x3f3bb514;
case 0x00006700:
return 0x27d1e0fd;
case 0x00006704:
return 0x2a120868;
case 0x00006708:
return 0xb20aa8d3;
case 0x0000670c:
return 0x70249b3f;
case 0x00006710:
return 0x55ce5d9f;
case 0x00006714:
return 0x6cc20216;
case 0x00006718:
return 0xe07c5a3a;
case 0x0000671c:
return 0x27c73b1d;
case 0x00006720:
return 0x56546094;
case 0x00006724:
return 0x5a335ac0;
case 0x00006728:
return 0x6ffd55d7;
case 0x0000672c:
return 0x5e9742f2;
case 0x00006730:
return 0xdc0f2948;
case 0x00006734:
return 0x3ad05a14;
case 0x00006738:
return 0xabe455b0;
case 0x0000673c:
return 0xb86133e5;
case 0x00006740:
return 0x93906474;
case 0x00006744:
return 0xc336e5f2;
case 0x00006748:
return 0x404540f0;
case 0x0000674c:
return 0x4270136d;
case 0x00006750:
return 0xbe2cafc9;
case 0x00006754:
return 0x642e889e;
case 0x00006758:
return 0x39d6ac8d;
case 0x0000675c:
return 0x18207853;
case 0x00006760:
return 0xa8881e32;
case 0x00006764:
return 0x998b00ac;
case 0x00006768:
return 0x9465b452;
case 0x0000676c:
return 0x9ceab0a8;
case 0x00006770:
return 0x59c4f81b;
case 0x00006774:
return 0xde8353e5;
case 0x00006778:
return 0x646ef784;
case 0x0000677c:
return 0x12e0840a;
case 0x00006780:
return 0x3c882f54;
case 0x00006784:
return 0x5ca4f627;
case 0x00006788:
return 0xbab38714;
case 0x0000678c:
return 0x934c13ef;
case 0x00006790:
return 0xc79e164a;
case 0x00006794:
return 0xf431d27a;
case 0x00006798:
return 0xa6a1dbda;
case 0x0000679c:
return 0x350e659d;
case 0x000067a0:
return 0x6d1f3c86;
case 0x000067a4:
return 0x11c8d387;
case 0x000067a8:
return 0xba748969;
case 0x000067ac:
return 0x23947386;
case 0x000067b0:
return 0x4f6c6827;
case 0x000067b4:
return 0x6bd72686;
case 0x000067b8:
return 0xec82b5d2;
case 0x000067bc:
return 0xd5f5b137;
case 0x000067c0:
return 0x59a1892e;
case 0x000067c4:
return 0x394b65a6;
case 0x000067c8:
return 0x706a0908;
case 0x000067cc:
return 0x14bab2a7;
case 0x000067d0:
return 0x43ac9c56;
case 0x000067d4:
return 0xd2b66662;
case 0x000067d8:
return 0xd18024c1;
case 0x000067dc:
return 0x61ee9c91;
case 0x000067e0:
return 0x50b81b72;
case 0x000067e4:
return 0x1bf0d1b0;
case 0x000067e8:
return 0x97d3aa5c;
case 0x000067ec:
return 0x4b8126bb;
case 0x000067f0:
return 0xd0ee6a26;
case 0x000067f4:
return 0x5eea39ae;
case 0x000067f8:
return 0xd0b029fb;
case 0x000067fc:
return 0xfeeb0ad3;
case 0x00006800:
return 0x1e7a0aff;
case 0x00006804:
return 0x9d04daad;
case 0x00006808:
return 0x2fcd7ddf;
case 0x0000680c:
return 0xaea9e68e;
case 0x00006810:
return 0xd1a5bd21;
case 0x00006814:
return 0x4f223b97;
case 0x00006818:
return 0x1fa81f07;
case 0x0000681c:
return 0xce15f07c;
case 0x00006820:
return 0x4367c348;
case 0x00006824:
return 0x107d8c21;
case 0x00006828:
return 0x07addb69;
case 0x0000682c:
return 0xcbb79a1e;
case 0x00006830:
return 0xd63c6c20;
case 0x00006834:
return 0xa5fa8155;
case 0x00006838:
return 0x0dfee6cf;
case 0x0000683c:
return 0x3f55f74e;
case 0x00006840:
return 0x1b91c6a9;
case 0x00006844:
return 0xbf233fd8;
case 0x00006848:
return 0x5b315676;
case 0x0000684c:
return 0x45f7c4ab;
case 0x00006850:
return 0x2eba2c2e;
case 0x00006854:
return 0x9d4369d2;
case 0x00006858:
return 0xe127cfec;
case 0x0000685c:
return 0x13ea17b1;
case 0x00006860:
return 0xaae7667e;
case 0x00006864:
return 0x71ecf52c;
case 0x00006868:
return 0x45079e49;
case 0x0000686c:
return 0xdb25ccde;
case 0x00006870:
return 0xa20cea08;
case 0x00006874:
return 0x2665d2e5;
case 0x00006878:
return 0x8003677e;
case 0x0000687c:
return 0xa6c87eb5;
case 0x00006880:
return 0xf36b6551;
case 0x00006884:
return 0x2830ef4e;
case 0x00006888:
return 0xc384662f;
case 0x0000688c:
return 0xfe4452ec;
case 0x00006890:
return 0xcfa37bc0;
case 0x00006894:
return 0xfea9e515;
case 0x00006898:
return 0x73f380cc;
case 0x0000689c:
return 0xaebb52ad;
case 0x000068a0:
return 0xe3516fe4;
case 0x000068a4:
return 0x88056c9b;
case 0x000068a8:
return 0x0a4f5196;
case 0x000068ac:
return 0xa26f3e18;
case 0x000068b0:
return 0xb45a1eba;
case 0x000068b4:
return 0x078928de;
case 0x000068b8:
return 0x2cb43a80;
case 0x000068bc:
return 0xa566e345;
case 0x000068c0:
return 0xc9f8f5a5;
case 0x000068c4:
return 0x136ae77f;
case 0x000068c8:
return 0x9354d7c2;
case 0x000068cc:
return 0x5620d279;
case 0x000068d0:
return 0x77ba2653;
case 0x000068d4:
return 0x2bf0ae83;
case 0x000068d8:
return 0x379bc499;
case 0x000068dc:
return 0x3d2da24b;
case 0x000068e0:
return 0x82a5de47;
case 0x000068e4:
return 0x494d763b;
case 0x000068e8:
return 0x0a21e25f;
case 0x000068ec:
return 0xfd1e6a50;
case 0x000068f0:
return 0x8324a94c;
case 0x000068f4:
return 0x60ceeaa8;
case 0x000068f8:
return 0x4182914f;
case 0x000068fc:
return 0x70342a3b;
case 0x00006900:
return 0x3752524c;
case 0x00006904:
return 0x198ef7de;
case 0x00006908:
return 0xec0cd92e;
case 0x0000690c:
return 0x2fd4d712;
case 0x00006910:
return 0x697b338c;
case 0x00006914:
return 0x2e5cd0bc;
case 0x00006918:
return 0x73d3977c;
case 0x0000691c:
return 0x23f283a4;
case 0x00006920:
return 0xe04131bd;
case 0x00006924:
return 0x4f45df2d;
case 0x00006928:
return 0xe4e3ef84;
case 0x0000692c:
return 0xbe567058;
case 0x00006930:
return 0x79512111;
case 0x00006934:
return 0xbf574ed9;
case 0x00006938:
return 0xb1c025d9;
case 0x0000693c:
return 0xe5c47dfa;
case 0x00006940:
return 0x1bd0a83e;
case 0x00006944:
return 0x211aaa2c;
case 0x00006948:
return 0xa8a9e87b;
case 0x0000694c:
return 0x6983cfb4;
case 0x00006950:
return 0x8ad583e2;
case 0x00006954:
return 0x6c4cf9d0;
case 0x00006958:
return 0x3cfd340d;
case 0x0000695c:
return 0x16e2e1ee;
case 0x00006960:
return 0x00d6c12a;
case 0x00006964:
return 0x11d2b2a0;
case 0x00006968:
return 0x39929c56;
case 0x0000696c:
return 0x5f4e646c;
case 0x00006970:
return 0x7c83fd0f;
case 0x00006974:
return 0x10963e5b;
case 0x00006978:
return 0xb10398a3;
case 0x0000697c:
return 0x3f3c0e1b;
case 0x00006980:
return 0xa894fac6;
case 0x00006984:
return 0x3c72c90d;
case 0x00006988:
return 0xeffafa2c;
case 0x0000698c:
return 0xb99d8fbb;
case 0x00006990:
return 0xf38be7d9;
case 0x00006994:
return 0xdf61cc0a;
case 0x00006998:
return 0x2d82a8d1;
case 0x0000699c:
return 0xcd7c0fd1;
case 0x000069a0:
return 0xe8b0022a;
case 0x000069a4:
return 0x6b14bc68;
case 0x000069a8:
return 0xd0dd65c3;
case 0x000069ac:
return 0xa7a580e3;
case 0x000069b0:
return 0xe2082e68;
case 0x000069b4:
return 0x83d8182a;
case 0x000069b8:
return 0xc69c1b4b;
case 0x000069bc:
return 0x36515a49;
case 0x000069c0:
return 0xbc665e0e;
case 0x000069c4:
return 0x2478553a;
case 0x000069c8:
return 0xa7a8718f;
case 0x000069cc:
return 0x3f69c9df;
case 0x000069d0:
return 0x95d19b3c;
case 0x000069d4:
return 0x1ff36f1c;
case 0x000069d8:
return 0x38ab8341;
case 0x000069dc:
return 0xb7e438a7;
case 0x000069e0:
return 0xb2cd22bc;
case 0x000069e4:
return 0xec73f83e;
case 0x000069e8:
return 0xbf511a7f;
case 0x000069ec:
return 0xf244b485;
case 0x000069f0:
return 0x8de7e924;
case 0x000069f4:
return 0x75a645bb;
case 0x000069f8:
return 0xa623e9a4;
case 0x000069fc:
return 0xb4654425;
case 0x00006a00:
return 0xd3b7fc3a;
case 0x00006a04:
return 0xa2dca7b9;
case 0x00006a08:
return 0x51bb80db;
case 0x00006a0c:
return 0x37dc709d;
case 0x00006a10:
return 0x6894d642;
case 0x00006a14:
return 0x1b46dce5;
case 0x00006a18:
return 0x66d2dc1f;
case 0x00006a1c:
return 0x86a576ea;
case 0x00006a20:
return 0x1ef634d2;
case 0x00006a24:
return 0xb4042520;
case 0x00006a28:
return 0x1d0d38e3;
case 0x00006a2c:
return 0x77f5bda9;
case 0x00006a30:
return 0x70324faf;
case 0x00006a34:
return 0x156a2373;
case 0x00006a38:
return 0x37e2c27d;
case 0x00006a3c:
return 0x3367aa22;
case 0x00006a40:
return 0x19cced31;
case 0x00006a44:
return 0x3c0daf21;
case 0x00006a48:
return 0x7a3fe58c;
case 0x00006a4c:
return 0xff92489d;
case 0x00006a50:
return 0x6512ccbb;
case 0x00006a54:
return 0x84b187ed;
case 0x00006a58:
return 0x33f72043;
case 0x00006a5c:
return 0x890b6a36;
case 0x00006a60:
return 0x05af304f;
case 0x00006a64:
return 0x78bead96;
case 0x00006a68:
return 0x5f7f682e;
case 0x00006a6c:
return 0xcd6a6378;
case 0x00006a70:
return 0xeb196a33;
case 0x00006a74:
return 0x41f0b246;
case 0x00006a78:
return 0x0b58aeee;
case 0x00006a7c:
return 0xac08e6b6;
case 0x00006a80:
return 0x9f2e6f20;
case 0x00006a84:
return 0xaa01817b;
case 0x00006a88:
return 0x72337e89;
case 0x00006a8c:
return 0xa03d9b9f;
case 0x00006a90:
return 0xd54ee33d;
case 0x00006a94:
return 0x2359b3f1;
case 0x00006a98:
return 0x9b7c69e2;
case 0x00006a9c:
return 0x7529d833;
case 0x00006aa0:
return 0xcc6d28cc;
case 0x00006aa4:
return 0x08effeb6;
case 0x00006aa8:
return 0xad4ef1ee;
case 0x00006aac:
return 0x447eecda;
case 0x00006ab0:
return 0xb11c5f36;
case 0x00006ab4:
return 0x4e27ab6e;
case 0x00006ab8:
return 0x9a5a163d;
case 0x00006abc:
return 0x8743b4e0;
case 0x00006ac0:
return 0x63cecf56;
case 0x00006ac4:
return 0x659984b8;
case 0x00006ac8:
return 0xbd348a71;
case 0x00006acc:
return 0xe6a7c631;
case 0x00006ad0:
return 0xc337c39a;
case 0x00006ad4:
return 0x2ff54f47;
case 0x00006ad8:
return 0xd4033285;
case 0x00006adc:
return 0x1c06e87c;
case 0x00006ae0:
return 0x7013da39;
case 0x00006ae4:
return 0x22e8afe9;
case 0x00006ae8:
return 0x1ca4385c;
case 0x00006aec:
return 0x509c9a4f;
case 0x00006af0:
return 0x532d5844;
case 0x00006af4:
return 0xb75c4e07;
case 0x00006af8:
return 0x122e3da4;
case 0x00006afc:
return 0xcb56c9e7;
case 0x00006b00:
return 0x5145099f;
case 0x00006b04:
return 0x3ad32705;
case 0x00006b08:
return 0x64ba3316;
case 0x00006b0c:
return 0x468d1d15;
case 0x00006b10:
return 0x451b6cfa;
case 0x00006b14:
return 0x4ec16dbc;
case 0x00006b18:
return 0xb97df097;
case 0x00006b1c:
return 0x171b5780;
case 0x00006b20:
return 0xcdbc6921;
case 0x00006b24:
return 0xf919fac7;
case 0x00006b28:
return 0x94591aa5;
case 0x00006b2c:
return 0x49e5d40f;
case 0x00006b30:
return 0x3fec77f1;
case 0x00006b34:
return 0x2a95956f;
case 0x00006b38:
return 0x6b167d0a;
case 0x00006b3c:
return 0xdeb440a1;
case 0x00006b40:
return 0xfc0ef188;
case 0x00006b44:
return 0x4c2f24ec;
case 0x00006b48:
return 0xddff5b2d;
case 0x00006b4c:
return 0xccca3a2e;
case 0x00006b50:
return 0x926d0b6a;
case 0x00006b54:
return 0xad834728;
case 0x00006b58:
return 0x55238b86;
case 0x00006b5c:
return 0xaf0bd210;
case 0x00006b60:
return 0x346c348d;
case 0x00006b64:
return 0x0dc22209;
case 0x00006b68:
return 0x34b468aa;
case 0x00006b6c:
return 0x49f13f68;
case 0x00006b70:
return 0x658a0de5;
case 0x00006b74:
return 0x67594a88;
case 0x00006b78:
return 0x23eef445;
case 0x00006b7c:
return 0x8ba93c8d;
case 0x00006b80:
return 0x8aa73ca8;
case 0x00006b84:
return 0xb5e23e8f;
case 0x00006b88:
return 0x901d4202;
case 0x00006b8c:
return 0x13882631;
case 0x00006b90:
return 0x1cb881e1;
case 0x00006b94:
return 0xb74866fc;
case 0x00006b98:
return 0xbc172dab;
case 0x00006b9c:
return 0x5f35e0ed;
case 0x00006ba0:
return 0xb51b3af9;
case 0x00006ba4:
return 0x0cd1bcc6;
case 0x00006ba8:
return 0xa5fb3f85;
case 0x00006bac:
return 0xe25a347e;
case 0x00006bb0:
return 0xc97c9fdc;
case 0x00006bb4:
return 0xa8b2a2c8;
case 0x00006bb8:
return 0xf860b459;
case 0x00006bbc:
return 0x3effae38;
case 0x00006bc0:
return 0xae178efc;
case 0x00006bc4:
return 0x3aae1a10;
case 0x00006bc8:
return 0x110ee652;
case 0x00006bcc:
return 0x886e19af;
case 0x00006bd0:
return 0xca1282c4;
case 0x00006bd4:
return 0x38656a09;
case 0x00006bd8:
return 0x99c700aa;
case 0x00006bdc:
return 0xb505082c;
case 0x00006be0:
return 0x503cb188;
case 0x00006be4:
return 0x5f1fd0a5;
case 0x00006be8:
return 0xad2ff9bb;
case 0x00006bec:
return 0xa3785cff;
case 0x00006bf0:
return 0x45a20d17;
case 0x00006bf4:
return 0xca86f78c;
case 0x00006bf8:
return 0x7b0f8282;
case 0x00006bfc:
return 0x5f002df8;
case 0x00006c00:
return 0xd5d5a144;
case 0x00006c04:
return 0x1f86e7a7;
case 0x00006c08:
return 0x1e94de9a;
case 0x00006c0c:
return 0x58c32e15;
case 0x00006c10:
return 0x04771e3f;
case 0x00006c14:
return 0xc90ec4a9;
case 0x00006c18:
return 0xb8f05f9a;
case 0x00006c1c:
return 0xb42132d5;
case 0x00006c20:
return 0x3fb5df33;
case 0x00006c24:
return 0x98f746fe;
case 0x00006c28:
return 0xe49fabb1;
case 0x00006c2c:
return 0x49e36f50;
case 0x00006c30:
return 0x686acfe3;
case 0x00006c34:
return 0x22653e13;
case 0x00006c38:
return 0x2353b0ab;
case 0x00006c3c:
return 0x707122ad;
case 0x00006c40:
return 0x03d254cb;
case 0x00006c44:
return 0xdfe40f4a;
case 0x00006c48:
return 0x25e38171;
case 0x00006c4c:
return 0xc580386c;
case 0x00006c50:
return 0x88bdfc54;
case 0x00006c54:
return 0xa0b52327;
case 0x00006c58:
return 0x890f2502;
case 0x00006c5c:
return 0xb0d92a8a;
case 0x00006c60:
return 0xff7cb350;
case 0x00006c64:
return 0x13daf243;
case 0x00006c68:
return 0x3ec2075f;
case 0x00006c6c:
return 0xc9bf8565;
case 0x00006c70:
return 0xc839b21d;
case 0x00006c74:
return 0x69b6e74f;
case 0x00006c78:
return 0xccfa79f9;
case 0x00006c7c:
return 0x022dc1ee;
case 0x00006c80:
return 0x7edc71cf;
case 0x00006c84:
return 0x1b094009;
case 0x00006c88:
return 0x05667b7a;
case 0x00006c8c:
return 0x4352ff06;
case 0x00006c90:
return 0x25964b9a;
case 0x00006c94:
return 0x26d5a031;
case 0x00006c98:
return 0xae5298bb;
case 0x00006c9c:
return 0x6a59e8a2;
case 0x00006ca0:
return 0xd275d7f2;
case 0x00006ca4:
return 0x457f3a30;
case 0x00006ca8:
return 0x28053c03;
case 0x00006cac:
return 0x1fc0f9d6;
case 0x00006cb0:
return 0x617048c1;
case 0x00006cb4:
return 0xb2248a17;
case 0x00006cb8:
return 0x024daeca;
case 0x00006cbc:
return 0x49f79683;
case 0x00006cc0:
return 0xf9d6ef56;
case 0x00006cc4:
return 0x3f2df7cc;
case 0x00006cc8:
return 0x4fa70211;
case 0x00006ccc:
return 0xdc8d72f9;
case 0x00006cd0:
return 0x785fe6e8;
case 0x00006cd4:
return 0xd75fb1ce;
case 0x00006cd8:
return 0xaed7564d;
case 0x00006cdc:
return 0x0e17f3cc;
case 0x00006ce0:
return 0x7454b2f6;
case 0x00006ce4:
return 0x524302f8;
case 0x00006ce8:
return 0xc4d88d8b;
case 0x00006cec:
return 0xea319788;
case 0x00006cf0:
return 0x0512c5ae;
case 0x00006cf4:
return 0x5fc77165;
case 0x00006cf8:
return 0x2e0d7271;
case 0x00006cfc:
return 0xee4c3bdb;
case 0x00006d00:
return 0xfb7ea58a;
case 0x00006d04:
return 0xbc0a5979;
case 0x00006d08:
return 0xe6ab6b85;
case 0x00006d0c:
return 0x633be859;
case 0x00006d10:
return 0xae3ba1aa;
case 0x00006d14:
return 0x911b2ae9;
case 0x00006d18:
return 0xaa4fd865;
case 0x00006d1c:
return 0x9bd28401;
case 0x00006d20:
return 0x186f217b;
case 0x00006d24:
return 0x47f9375b;
case 0x00006d28:
return 0x608507c7;
case 0x00006d2c:
return 0x6d555a73;
case 0x00006d30:
return 0xa17f3c36;
case 0x00006d34:
return 0xfd68448d;
case 0x00006d38:
return 0x45705632;
case 0x00006d3c:
return 0x83018321;
case 0x00006d40:
return 0xde57b8e5;
case 0x00006d44:
return 0xdcd2fe81;
case 0x00006d48:
return 0x78358da3;
case 0x00006d4c:
return 0xbfd5a9eb;
case 0x00006d50:
return 0x6a530b8b;
case 0x00006d54:
return 0x39f1328d;
case 0x00006d58:
return 0xb06c4344;
case 0x00006d5c:
return 0xc721a15d;
case 0x00006d60:
return 0xed74e0a9;
case 0x00006d64:
return 0xd7661132;
case 0x00006d68:
return 0x0445b330;
case 0x00006d6c:
return 0x79579105;
case 0x00006d70:
return 0x3bdcc0fc;
case 0x00006d74:
return 0x9387e3ec;
case 0x00006d78:
return 0x8f05116b;
case 0x00006d7c:
return 0xe0d11322;
case 0x00006d80:
return 0xfdbc2d24;
case 0x00006d84:
return 0x0894c3ee;
case 0x00006d88:
return 0x91e69905;
case 0x00006d8c:
return 0x986c2572;
case 0x00006d90:
return 0x6258ffbb;
case 0x00006d94:
return 0x62c45f2f;
case 0x00006d98:
return 0x62366cbc;
case 0x00006d9c:
return 0x796e8fdf;
case 0x00006da0:
return 0x57f7de8a;
case 0x00006da4:
return 0x1becc2c6;
case 0x00006da8:
return 0x30f05fff;
case 0x00006dac:
return 0x1050d470;
case 0x00006db0:
return 0x5479384d;
case 0x00006db4:
return 0xc71ecc69;
case 0x00006db8:
return 0xac3ef6ce;
case 0x00006dbc:
return 0x4cd5d715;
case 0x00006dc0:
return 0x7649267d;
case 0x00006dc4:
return 0x9453f8aa;
case 0x00006dc8:
return 0x3b4bdade;
case 0x00006dcc:
return 0xdad91383;
case 0x00006dd0:
return 0x30484689;
case 0x00006dd4:
return 0xe726277c;
case 0x00006dd8:
return 0xb762c532;
case 0x00006ddc:
return 0x94b5a68f;
case 0x00006de0:
return 0x1d04c6f3;
case 0x00006de4:
return 0x825a6572;
case 0x00006de8:
return 0x5fee429c;
case 0x00006dec:
return 0x3d326867;
case 0x00006df0:
return 0x8f1aecdc;
case 0x00006df4:
return 0x65a3c460;
case 0x00006df8:
return 0x918eef50;
case 0x00006dfc:
return 0xd69d9a96;
case 0x00006e00:
return 0xc9b490aa;
case 0x00006e04:
return 0x0b03e857;
case 0x00006e08:
return 0xf354adaa;
case 0x00006e0c:
return 0xaa63a89b;
case 0x00006e10:
return 0xe2407e32;
case 0x00006e14:
return 0x4a82f53e;
case 0x00006e18:
return 0x7e72ae2a;
case 0x00006e1c:
return 0x43f973d9;
case 0x00006e20:
return 0xafa59167;
case 0x00006e24:
return 0xcfd60762;
case 0x00006e28:
return 0x2e9fa39b;
case 0x00006e2c:
return 0xecce2f1a;
case 0x00006e30:
return 0xd41ea7ef;
case 0x00006e34:
return 0x00aa07f6;
case 0x00006e38:
return 0x06149672;
case 0x00006e3c:
return 0xf17f7234;
case 0x00006e40:
return 0x53646ad8;
case 0x00006e44:
return 0xcf4ad1b5;
case 0x00006e48:
return 0x8fda1bf9;
case 0x00006e4c:
return 0x73faf381;
case 0x00006e50:
return 0xc667f089;
case 0x00006e54:
return 0x77c5a2f0;
case 0x00006e58:
return 0xd3600747;
case 0x00006e5c:
return 0x73137738;
case 0x00006e60:
return 0x3e10349a;
case 0x00006e64:
return 0x70758fb9;
case 0x00006e68:
return 0x567db36a;
case 0x00006e6c:
return 0x95938ae1;
case 0x00006e70:
return 0xaab87308;
case 0x00006e74:
return 0xba126983;
case 0x00006e78:
return 0xe7a3c187;
case 0x00006e7c:
return 0x0dd87ac7;
case 0x00006e80:
return 0xc2a6652f;
case 0x00006e84:
return 0x6061b5fc;
case 0x00006e88:
return 0x50c03213;
case 0x00006e8c:
return 0x50f4b8d4;
case 0x00006e90:
return 0x1b06e1ec;
case 0x00006e94:
return 0xb67bbe45;
case 0x00006e98:
return 0x3759bb14;
case 0x00006e9c:
return 0xb5b79b1a;
case 0x00006ea0:
return 0xc7ca07e0;
case 0x00006ea4:
return 0xe924aed0;
case 0x00006ea8:
return 0x0500f1cd;
case 0x00006eac:
return 0x60dee276;
case 0x00006eb0:
return 0xe4b7f5c1;
case 0x00006eb4:
return 0x0891a6ec;
case 0x00006eb8:
return 0x4727c959;
case 0x00006ebc:
return 0x35a0242e;
case 0x00006ec0:
return 0x0be30ca8;
case 0x00006ec4:
return 0xd37f18d1;
case 0x00006ec8:
return 0xdd7f0837;
case 0x00006ecc:
return 0xb9d48aff;
case 0x00006ed0:
return 0x4bbcbd77;
case 0x00006ed4:
return 0x11a0b09b;
case 0x00006ed8:
return 0xbade5ede;
case 0x00006edc:
return 0xa435edb8;
case 0x00006ee0:
return 0x1d714800;
case 0x00006ee4:
return 0xae5a72c2;
case 0x00006ee8:
return 0xf0a8100e;
case 0x00006eec:
return 0xa7bb7835;
case 0x00006ef0:
return 0x07440e21;
case 0x00006ef4:
return 0x453516e5;
case 0x00006ef8:
return 0x76da6c0b;
case 0x00006efc:
return 0xf4debaca;
case 0x00006f00:
return 0x162bca39;
case 0x00006f04:
return 0xf923094b;
case 0x00006f08:
return 0x78d2223a;
case 0x00006f0c:
return 0x1b58e24f;
case 0x00006f10:
return 0x63267937;
case 0x00006f14:
return 0x11ef4a81;
case 0x00006f18:
return 0x79a3f4f3;
case 0x00006f1c:
return 0xf9670904;
case 0x00006f20:
return 0x3db019d0;
case 0x00006f24:
return 0xc66dd7c4;
case 0x00006f28:
return 0x70f55653;
case 0x00006f2c:
return 0xdf7b3938;
case 0x00006f30:
return 0xb04c3b70;
case 0x00006f34:
return 0xff566651;
case 0x00006f38:
return 0xea776ec9;
case 0x00006f3c:
return 0xac74c5b9;
case 0x00006f40:
return 0x20b0a785;
case 0x00006f44:
return 0x29db3466;
case 0x00006f48:
return 0xa54ba864;
case 0x00006f4c:
return 0x612a2455;
case 0x00006f50:
return 0x3f4415f4;
case 0x00006f54:
return 0x18bfb8ce;
case 0x00006f58:
return 0xab16b5dc;
case 0x00006f5c:
return 0x6dcdae85;
case 0x00006f60:
return 0x8a6850f5;
case 0x00006f64:
return 0x9fc4d5e6;
case 0x00006f68:
return 0x021c05dd;
case 0x00006f6c:
return 0xd17166a4;
case 0x00006f70:
return 0x83ba93ad;
case 0x00006f74:
return 0xf484de4c;
case 0x00006f78:
return 0xdbcfbfd8;
case 0x00006f7c:
return 0x21b1d481;
case 0x00006f80:
return 0xf7a46e9b;
case 0x00006f84:
return 0xa2c977ad;
case 0x00006f88:
return 0x56395705;
case 0x00006f8c:
return 0x91717b25;
case 0x00006f90:
return 0x35352d61;
case 0x00006f94:
return 0x07464df7;
case 0x00006f98:
return 0xff300036;
case 0x00006f9c:
return 0xd512f689;
case 0x00006fa0:
return 0x6682d7be;
case 0x00006fa4:
return 0xaffd0b1d;
case 0x00006fa8:
return 0x4746a07d;
case 0x00006fac:
return 0x4b8eb1e2;
case 0x00006fb0:
return 0x37670b6d;
case 0x00006fb4:
return 0xf6eb22e4;
case 0x00006fb8:
return 0xf25e4395;
case 0x00006fbc:
return 0x1d8cdb00;
case 0x00006fc0:
return 0x52372b94;
case 0x00006fc4:
return 0xa2fdb313;
case 0x00006fc8:
return 0x281ab51e;
case 0x00006fcc:
return 0x528a090d;
case 0x00006fd0:
return 0x3e598283;
case 0x00006fd4:
return 0x8d60c02d;
case 0x00006fd8:
return 0x1deaf992;
case 0x00006fdc:
return 0xfe1ae0d0;
case 0x00006fe0:
return 0x9bd7f58d;
case 0x00006fe4:
return 0x49e02e3a;
case 0x00006fe8:
return 0x34d3a217;
case 0x00006fec:
return 0x29835057;
case 0x00006ff0:
return 0x10a19d4c;
case 0x00006ff4:
return 0xd2eb5c0a;
case 0x00006ff8:
return 0xff38ab6b;
case 0x00006ffc:
return 0x170df8dd;
case 0x00007000:
return 0xb847f727;
case 0x00007004:
return 0x8c69ec01;
case 0x00007008:
return 0x08737d57;
case 0x0000700c:
return 0x96b5452d;
case 0x00007010:
return 0xef15ff0c;
case 0x00007014:
return 0xb270ca2d;
case 0x00007018:
return 0x0a87b76d;
case 0x0000701c:
return 0xfc313e6e;
case 0x00007020:
return 0xce87b8bb;
case 0x00007024:
return 0x5729450b;
case 0x00007028:
return 0x73013bf8;
case 0x0000702c:
return 0x7b54bfe9;
case 0x00007030:
return 0x7f1d17f7;
case 0x00007034:
return 0x04ee2ae1;
case 0x00007038:
return 0x93008e7c;
case 0x0000703c:
return 0x247f46df;
case 0x00007040:
return 0xf1eab85f;
case 0x00007044:
return 0xddaa0bad;
case 0x00007048:
return 0xc92d4b7e;
case 0x0000704c:
return 0x001e4f49;
case 0x00007050:
return 0x1dfdafc5;
case 0x00007054:
return 0x19882eae;
case 0x00007058:
return 0x2294b21e;
case 0x0000705c:
return 0xf7745251;
case 0x00007060:
return 0x12088a7c;
case 0x00007064:
return 0xeaba7422;
case 0x00007068:
return 0x1afcbcd6;
case 0x0000706c:
return 0x57331c86;
case 0x00007070:
return 0xdde234f1;
case 0x00007074:
return 0xd303f524;
case 0x00007078:
return 0xc84f1ae3;
case 0x0000707c:
return 0x78495a16;
case 0x00007080:
return 0x0b6c6d6b;
case 0x00007084:
return 0x4242dcbf;
case 0x00007088:
return 0x9ee36f58;
case 0x0000708c:
return 0xc9a76bcc;
case 0x00007090:
return 0x86700bd9;
case 0x00007094:
return 0x5cdaab22;
case 0x00007098:
return 0x21dec118;
case 0x0000709c:
return 0x62e5e860;
case 0x000070a0:
return 0x9e880f39;
case 0x000070a4:
return 0x9ea89e06;
case 0x000070a8:
return 0x425eea76;
case 0x000070ac:
return 0x42cfce48;
case 0x000070b0:
return 0x38ba970c;
case 0x000070b4:
return 0x1c120b14;
case 0x000070b8:
return 0xdd6b9b90;
case 0x000070bc:
return 0xc7dbcdb0;
case 0x000070c0:
return 0x5cc59a9f;
case 0x000070c4:
return 0x960cf040;
case 0x000070c8:
return 0xdd1f5634;
case 0x000070cc:
return 0xfcd36e0f;
case 0x000070d0:
return 0xcdc88691;
case 0x000070d4:
return 0x5677b849;
case 0x000070d8:
return 0x9615b8e2;
case 0x000070dc:
return 0x23f4e268;
case 0x000070e0:
return 0xad4dde07;
case 0x000070e4:
return 0x738727ff;
case 0x000070e8:
return 0x00a9ed36;
case 0x000070ec:
return 0xca48b951;
case 0x000070f0:
return 0xadba6d84;
case 0x000070f4:
return 0x067a2b87;
case 0x000070f8:
return 0x37e32a15;
case 0x000070fc:
return 0x4b7f0151;
case 0x00007100:
return 0x6bb58822;
case 0x00007104:
return 0x965d4797;
case 0x00007108:
return 0x5af8e669;
case 0x0000710c:
return 0x73c9d77f;
case 0x00007110:
return 0x678dfcf1;
case 0x00007114:
return 0xb179690f;
case 0x00007118:
return 0x96de0614;
case 0x0000711c:
return 0xed327b1f;
case 0x00007120:
return 0x2c1fbc4f;
case 0x00007124:
return 0x02e68250;
case 0x00007128:
return 0xddd5d68a;
case 0x0000712c:
return 0xce32f4b9;
case 0x00007130:
return 0x6e7371bf;
case 0x00007134:
return 0xab507f82;
case 0x00007138:
return 0xe002f655;
case 0x0000713c:
return 0x76c50a96;
case 0x00007140:
return 0x5f53d945;
case 0x00007144:
return 0xee980c83;
case 0x00007148:
return 0xc5ca3087;
case 0x0000714c:
return 0xb0683aef;
case 0x00007150:
return 0x181f64fe;
case 0x00007154:
return 0xd75f4111;
case 0x00007158:
return 0xa3005da8;
case 0x0000715c:
return 0xe5f586a6;
case 0x00007160:
return 0xbb8fa7ab;
case 0x00007164:
return 0xe6fd9f78;
case 0x00007168:
return 0x381ae1c3;
case 0x0000716c:
return 0x5c25f7af;
case 0x00007170:
return 0x88fd6ea2;
case 0x00007174:
return 0x0e5d93cb;
case 0x00007178:
return 0x27296ada;
case 0x0000717c:
return 0x7cb520d9;
case 0x00007180:
return 0x06292706;
case 0x00007184:
return 0x1418b5ca;
case 0x00007188:
return 0x7df27573;
case 0x0000718c:
return 0x5d0a7613;
case 0x00007190:
return 0xe8fcdf73;
case 0x00007194:
return 0x2cfefce2;
case 0x00007198:
return 0xa3469ce6;
case 0x0000719c:
return 0x8579ffb6;
case 0x000071a0:
return 0xc531d05a;
case 0x000071a4:
return 0xe8d5b6fc;
case 0x000071a8:
return 0xa3aee9e1;
case 0x000071ac:
return 0x988dbbec;
case 0x000071b0:
return 0x99d73a68;
case 0x000071b4:
return 0x7bf18a98;
case 0x000071b8:
return 0x79b56d55;
case 0x000071bc:
return 0xe8598190;
case 0x000071c0:
return 0xd7a02cb9;
case 0x000071c4:
return 0x6ea84ddb;
case 0x000071c8:
return 0x65bb7fb8;
case 0x000071cc:
return 0x77ff6778;
case 0x000071d0:
return 0xc234b44b;
case 0x000071d4:
return 0x7c08e2e1;
case 0x000071d8:
return 0x0849f109;
case 0x000071dc:
return 0x9180e172;
case 0x000071e0:
return 0xf4e649b4;
case 0x000071e4:
return 0x5b58bcb8;
case 0x000071e8:
return 0xf4466b96;
case 0x000071ec:
return 0x52eb1f27;
case 0x000071f0:
return 0x7d70c9b8;
case 0x000071f4:
return 0x6d5512fa;
case 0x000071f8:
return 0x94b6a1ee;
case 0x000071fc:
return 0x52f9c9e1;
case 0x00007200:
return 0x322516c5;
case 0x00007204:
return 0x9cb58e05;
case 0x00007208:
return 0x45e51e6b;
case 0x0000720c:
return 0x19bcce51;
case 0x00007210:
return 0x6705fd2e;
case 0x00007214:
return 0x5640f4b3;
case 0x00007218:
return 0xce04f95d;
case 0x0000721c:
return 0xba228d3a;
case 0x00007220:
return 0x88e64b71;
case 0x00007224:
return 0xfec3a309;
case 0x00007228:
return 0x51e53f36;
case 0x0000722c:
return 0x87750fef;
case 0x00007230:
return 0x05c14da0;
case 0x00007234:
return 0x7b6b7f9b;
case 0x00007238:
return 0x49529e17;
case 0x0000723c:
return 0xe252ce8f;
case 0x00007240:
return 0xa9066972;
case 0x00007244:
return 0xfaecdb90;
case 0x00007248:
return 0x2859c655;
case 0x0000724c:
return 0xf8442654;
case 0x00007250:
return 0xe4e55351;
case 0x00007254:
return 0xe05ae24a;
case 0x00007258:
return 0x83497e01;
case 0x0000725c:
return 0x390e4ee0;
case 0x00007260:
return 0xa233c0bc;
case 0x00007264:
return 0xc78befa7;
case 0x00007268:
return 0x4bb70d9c;
case 0x0000726c:
return 0xe46953ff;
case 0x00007270:
return 0x2b0bae3c;
case 0x00007274:
return 0xe6014d23;
case 0x00007278:
return 0x9d0b8ca8;
case 0x0000727c:
return 0x0b8c0ca7;
case 0x00007280:
return 0x80d89ed3;
case 0x00007284:
return 0xd9ee9f21;
case 0x00007288:
return 0x0e080749;
case 0x0000728c:
return 0x3908b1ee;
case 0x00007290:
return 0xb8cc2a2d;
case 0x00007294:
return 0x81f03412;
case 0x00007298:
return 0x09588bc5;
case 0x0000729c:
return 0x369b08c7;
case 0x000072a0:
return 0x6f1a02d0;
case 0x000072a4:
return 0x52de994d;
case 0x000072a8:
return 0x0e4c807c;
case 0x000072ac:
return 0x66c2f127;
case 0x000072b0:
return 0x9ee2e143;
case 0x000072b4:
return 0x7b348730;
case 0x000072b8:
return 0xb0441929;
case 0x000072bc:
return 0xe8893a6e;
case 0x000072c0:
return 0x8db87574;
case 0x000072c4:
return 0x636b4153;
case 0x000072c8:
return 0x2d5b050e;
case 0x000072cc:
return 0xab8ede0f;
case 0x000072d0:
return 0x76e71328;
case 0x000072d4:
return 0x36dbebff;
case 0x000072d8:
return 0xf2c9567e;
case 0x000072dc:
return 0xfb36dc69;
case 0x000072e0:
return 0x63a62290;
case 0x000072e4:
return 0x8de2e3fe;
case 0x000072e8:
return 0xda4eb032;
case 0x000072ec:
return 0x5c58277a;
case 0x000072f0:
return 0x621dcd77;
case 0x000072f4:
return 0x771ac91f;
case 0x000072f8:
return 0xeb24b02f;
case 0x000072fc:
return 0x2c0704b3;
case 0x00007300:
return 0xf77e5a45;
case 0x00007304:
return 0xc8bd3611;
case 0x00007308:
return 0x236d0fa9;
case 0x0000730c:
return 0x9e9eccfd;
case 0x00007310:
return 0xf82b7eee;
case 0x00007314:
return 0x4d564864;
case 0x00007318:
return 0x0b32ed9f;
case 0x0000731c:
return 0x65dbab75;
case 0x00007320:
return 0x268eec63;
case 0x00007324:
return 0xab0bf7f5;
case 0x00007328:
return 0x39bad883;
case 0x0000732c:
return 0xc557ffc6;
case 0x00007330:
return 0x7b47e1b1;
case 0x00007334:
return 0x8e03d6d2;
case 0x00007338:
return 0xb2f06c45;
case 0x0000733c:
return 0x3684e4b5;
case 0x00007340:
return 0x131f17d3;
case 0x00007344:
return 0xd9b66866;
case 0x00007348:
return 0x8e60047d;
case 0x0000734c:
return 0xdfa05f69;
case 0x00007350:
return 0xe2a2e366;
case 0x00007354:
return 0x9d0d2a81;
case 0x00007358:
return 0xb6915669;
case 0x0000735c:
return 0x438b8fbc;
case 0x00007360:
return 0x02f94de4;
case 0x00007364:
return 0x7b6f17a0;
case 0x00007368:
return 0x77a18763;
case 0x0000736c:
return 0xc3495659;
case 0x00007370:
return 0x79ea5280;
case 0x00007374:
return 0x3dfb9394;
case 0x00007378:
return 0xb354e690;
case 0x0000737c:
return 0x300142a4;
case 0x00007380:
return 0xbf911220;
case 0x00007384:
return 0xb3ece916;
case 0x00007388:
return 0xfcf5c988;
case 0x0000738c:
return 0xbab9ef79;
case 0x00007390:
return 0xe5f06e8e;
case 0x00007394:
return 0xbeb3be2c;
case 0x00007398:
return 0xb9ab66fb;
case 0x0000739c:
return 0x71913b7c;
case 0x000073a0:
return 0x39f29a45;
case 0x000073a4:
return 0x1fdaa5ca;
case 0x000073a8:
return 0x53252611;
case 0x000073ac:
return 0xcfe0fdc9;
case 0x000073b0:
return 0x13f36f88;
case 0x000073b4:
return 0x9d132df0;
case 0x000073b8:
return 0x456eb623;
case 0x000073bc:
return 0x423038f9;
case 0x000073c0:
return 0x95b9220e;
case 0x000073c4:
return 0xefa1b8d0;
case 0x000073c8:
return 0xbff10c31;
case 0x000073cc:
return 0x4f5d77fe;
case 0x000073d0:
return 0x06fefc4f;
case 0x000073d4:
return 0xafa47db6;
case 0x000073d8:
return 0x76592903;
case 0x000073dc:
return 0x04440847;
case 0x000073e0:
return 0x3e8aaf36;
case 0x000073e4:
return 0xa3ab5040;
case 0x000073e8:
return 0x17937e04;
case 0x000073ec:
return 0x7164ff30;
case 0x000073f0:
return 0xafd4d423;
case 0x000073f4:
return 0xf3015a79;
case 0x000073f8:
return 0xeff200e0;
case 0x000073fc:
return 0xb7d64704;
case 0x00007400:
return 0x1b75c089;
case 0x00007404:
return 0xe0029fc6;
case 0x00007408:
return 0x50de6df1;
case 0x0000740c:
return 0xe125ac09;
case 0x00007410:
return 0xe678f46c;
case 0x00007414:
return 0x26c8606a;
case 0x00007418:
return 0x86db07e7;
case 0x0000741c:
return 0x472bc3ce;
case 0x00007420:
return 0x01108305;
case 0x00007424:
return 0xb579f9d7;
case 0x00007428:
return 0x0dccb605;
case 0x0000742c:
return 0x0c8e34b7;
case 0x00007430:
return 0xbb0ff086;
case 0x00007434:
return 0xf9e1f34c;
case 0x00007438:
return 0x407210d3;
case 0x0000743c:
return 0xae2dbbaa;
case 0x00007440:
return 0xbbe747fd;
case 0x00007444:
return 0xbb8becf6;
case 0x00007448:
return 0xa317ab56;
case 0x0000744c:
return 0xad551b2c;
case 0x00007450:
return 0x6053ba06;
case 0x00007454:
return 0x4c4364c4;
case 0x00007458:
return 0x0806436a;
case 0x0000745c:
return 0x47d735e6;
case 0x00007460:
return 0xe2648541;
case 0x00007464:
return 0xc2758c46;
case 0x00007468:
return 0x846a6713;
case 0x0000746c:
return 0xd1c9b030;
case 0x00007470:
return 0xbfc22ac6;
case 0x00007474:
return 0xd1336a90;
case 0x00007478:
return 0xb9cb4b6f;
case 0x0000747c:
return 0xa6feb009;
case 0x00007480:
return 0x5f82fb9d;
case 0x00007484:
return 0x0b595849;
case 0x00007488:
return 0x16218b1d;
case 0x0000748c:
return 0xc082672f;
case 0x00007490:
return 0x18c6ef8b;
case 0x00007494:
return 0x9f3f4260;
case 0x00007498:
return 0xb4009488;
case 0x0000749c:
return 0xb39da81f;
case 0x000074a0:
return 0x8f486f0f;
case 0x000074a4:
return 0x03351635;
case 0x000074a8:
return 0x97277a0c;
case 0x000074ac:
return 0x054b9855;
case 0x000074b0:
return 0xf8edf83a;
case 0x000074b4:
return 0x95c5984f;
case 0x000074b8:
return 0x592cc221;
case 0x000074bc:
return 0xe088e045;
case 0x000074c0:
return 0x4a7762f2;
case 0x000074c4:
return 0x799bee62;
case 0x000074c8:
return 0x9c501dc7;
case 0x000074cc:
return 0x9ef9fcb0;
case 0x000074d0:
return 0xd9e4634d;
case 0x000074d4:
return 0x9fcb7efa;
case 0x000074d8:
return 0xf2d1bca9;
case 0x000074dc:
return 0x223a66e9;
case 0x000074e0:
return 0x7b8414d4;
case 0x000074e4:
return 0x3c2fb7e4;
case 0x000074e8:
return 0xade0bab5;
case 0x000074ec:
return 0xd67b176d;
case 0x000074f0:
return 0x32fe525c;
case 0x000074f4:
return 0x5cabcabc;
case 0x000074f8:
return 0xec7d0719;
case 0x000074fc:
return 0xde5a6748;
case 0x00007500:
return 0x4eb9cfe7;
case 0x00007504:
return 0x590489ae;
case 0x00007508:
return 0x19b3a4e3;
case 0x0000750c:
return 0x17f7378a;
case 0x00007510:
return 0x230b8bdc;
case 0x00007514:
return 0xb32a976a;
case 0x00007518:
return 0x0b3827b5;
case 0x0000751c:
return 0xc51d21bb;
case 0x00007520:
return 0x4cd07703;
case 0x00007524:
return 0x3eefa349;
case 0x00007528:
return 0x0265dc5c;
case 0x0000752c:
return 0xdc949a6c;
case 0x00007530:
return 0xfe8c58e3;
case 0x00007534:
return 0x2522846b;
case 0x00007538:
return 0xec9d49fe;
case 0x0000753c:
return 0xcc269821;
case 0x00007540:
return 0xb8830cbf;
case 0x00007544:
return 0x4aea5e88;
case 0x00007548:
return 0x1ef2ccda;
case 0x0000754c:
return 0x86e2cfd3;
case 0x00007550:
return 0x3556165d;
case 0x00007554:
return 0x08ab290a;
case 0x00007558:
return 0xcac56c42;
case 0x0000755c:
return 0xfbe846f2;
case 0x00007560:
return 0x2fa514c6;
case 0x00007564:
return 0x7c33cad2;
case 0x00007568:
return 0xc2118805;
case 0x0000756c:
return 0xae51c177;
case 0x00007570:
return 0x2ad58b0e;
case 0x00007574:
return 0x441d0565;
case 0x00007578:
return 0xe2f6014a;
case 0x0000757c:
return 0xd065f9f6;
case 0x00007580:
return 0x5db4e905;
case 0x00007584:
return 0x23e3627d;
case 0x00007588:
return 0x06adcef5;
case 0x0000758c:
return 0xc22f5b77;
case 0x00007590:
return 0x0215295a;
case 0x00007594:
return 0x288907e9;
case 0x00007598:
return 0x9c09fabe;
case 0x0000759c:
return 0x8c6a3a9a;
case 0x000075a0:
return 0x7db7a872;
case 0x000075a4:
return 0x9bd52887;
case 0x000075a8:
return 0x93137d36;
case 0x000075ac:
return 0xa946626e;
case 0x000075b0:
return 0x8f1498e0;
case 0x000075b4:
return 0x3361dfba;
case 0x000075b8:
return 0x758597fc;
case 0x000075bc:
return 0xf587807d;
case 0x000075c0:
return 0x2f078ce8;
case 0x000075c4:
return 0x99cda8b5;
case 0x000075c8:
return 0xdade6714;
case 0x000075cc:
return 0x36a8ec16;
case 0x000075d0:
return 0x68908bc2;
case 0x000075d4:
return 0x71d99694;
case 0x000075d8:
return 0xc38bb823;
case 0x000075dc:
return 0x6338d5ff;
case 0x000075e0:
return 0x5c0468d4;
case 0x000075e4:
return 0xa302bd0e;
case 0x000075e8:
return 0x1f3f0295;
case 0x000075ec:
return 0x13d7ca3f;
case 0x000075f0:
return 0x9d9654d8;
case 0x000075f4:
return 0x7afae637;
case 0x000075f8:
return 0xc03886f6;
case 0x000075fc:
return 0xdb95b241;
case 0x00007600:
return 0xa5c2f2a4;
case 0x00007604:
return 0x33d29f15;
case 0x00007608:
return 0xb7646f2b;
case 0x0000760c:
return 0x7c3a8a2c;
case 0x00007610:
return 0x1ff222ee;
case 0x00007614:
return 0xed85aad7;
case 0x00007618:
return 0x5fea1957;
case 0x0000761c:
return 0xe702d11a;
case 0x00007620:
return 0x5f367827;
case 0x00007624:
return 0xe98be33c;
case 0x00007628:
return 0xfb5d7d12;
case 0x0000762c:
return 0x07a67e92;
case 0x00007630:
return 0xa78030b9;
case 0x00007634:
return 0xb7e065d0;
case 0x00007638:
return 0x4ee7c046;
case 0x0000763c:
return 0x358f2bba;
case 0x00007640:
return 0x2c3ca208;
case 0x00007644:
return 0xcdc942bf;
case 0x00007648:
return 0x4d562eff;
case 0x0000764c:
return 0xd3b3604e;
case 0x00007650:
return 0x95216f78;
case 0x00007654:
return 0x3c142b6f;
case 0x00007658:
return 0x57ceaf65;
case 0x0000765c:
return 0xd634047f;
case 0x00007660:
return 0x1ce2e3ac;
case 0x00007664:
return 0xaf0e2654;
case 0x00007668:
return 0x8b32eef4;
case 0x0000766c:
return 0xd21fe9bc;
case 0x00007670:
return 0x54b0896d;
case 0x00007674:
return 0xe6abc193;
case 0x00007678:
return 0x21392c73;
case 0x0000767c:
return 0xa83c95fb;
case 0x00007680:
return 0x876a56fa;
case 0x00007684:
return 0xc91163ca;
case 0x00007688:
return 0xe2e7979f;
case 0x0000768c:
return 0xbcaa78f8;
case 0x00007690:
return 0xc44ae389;
case 0x00007694:
return 0x152708d0;
case 0x00007698:
return 0x99e716e9;
case 0x0000769c:
return 0xcdef32ed;
case 0x000076a0:
return 0x0f40747f;
case 0x000076a4:
return 0x7333d438;
case 0x000076a8:
return 0xcb5de12f;
case 0x000076ac:
return 0xc93dae25;
case 0x000076b0:
return 0xc622a005;
case 0x000076b4:
return 0x2c26634f;
case 0x000076b8:
return 0xe6b11cb4;
case 0x000076bc:
return 0xb1a4492d;
case 0x000076c0:
return 0x63fc70bf;
case 0x000076c4:
return 0x94c59daa;
case 0x000076c8:
return 0xb1dc31c0;
case 0x000076cc:
return 0xc6c02cdf;
case 0x000076d0:
return 0xea163ab4;
case 0x000076d4:
return 0x7398bd84;
case 0x000076d8:
return 0x9d4a6236;
case 0x000076dc:
return 0x1b6a1bbc;
case 0x000076e0:
return 0x940c3ef7;
case 0x000076e4:
return 0xfec78692;
case 0x000076e8:
return 0x2b2cb164;
case 0x000076ec:
return 0x69906602;
case 0x000076f0:
return 0x789d915a;
case 0x000076f4:
return 0x8aae08e6;
case 0x000076f8:
return 0x08348c35;
case 0x000076fc:
return 0xe6274dbd;
case 0x00007700:
return 0x220d24f3;
case 0x00007704:
return 0xed8d5314;
case 0x00007708:
return 0x49402a31;
case 0x0000770c:
return 0x7d1fd405;
case 0x00007710:
return 0xcf439049;
case 0x00007714:
return 0x80727a48;
case 0x00007718:
return 0x743dd1a1;
case 0x0000771c:
return 0xa4091ca1;
case 0x00007720:
return 0xa1cb0388;
case 0x00007724:
return 0x4986045f;
case 0x00007728:
return 0x9e222d1d;
case 0x0000772c:
return 0x64bde775;
case 0x00007730:
return 0x6d8503db;
case 0x00007734:
return 0xa01adab1;
case 0x00007738:
return 0x80a23cdf;
case 0x0000773c:
return 0xefa01522;
case 0x00007740:
return 0x7109b55b;
case 0x00007744:
return 0x918f0a65;
case 0x00007748:
return 0xdac1e9c1;
case 0x0000774c:
return 0x9d42fdc9;
case 0x00007750:
return 0x4c354883;
case 0x00007754:
return 0x9af7607a;
case 0x00007758:
return 0xc0b2f7a2;
case 0x0000775c:
return 0x7844e729;
case 0x00007760:
return 0x9976b16f;
case 0x00007764:
return 0x6a8e9d9c;
case 0x00007768:
return 0xd6a1df96;
case 0x0000776c:
return 0x59d7b5bc;
case 0x00007770:
return 0x0995a007;
case 0x00007774:
return 0x16b87f1a;
case 0x00007778:
return 0xab3601fb;
case 0x0000777c:
return 0x8bb96bb1;
case 0x00007780:
return 0xeff1575f;
case 0x00007784:
return 0x2f73836d;
case 0x00007788:
return 0xf2d9102e;
case 0x0000778c:
return 0x307f76d7;
case 0x00007790:
return 0xa6c7335a;
case 0x00007794:
return 0xe701975b;
case 0x00007798:
return 0xe68c4e08;
case 0x0000779c:
return 0x54903905;
case 0x000077a0:
return 0x296d423a;
case 0x000077a4:
return 0x50f38745;
case 0x000077a8:
return 0x00ef67dc;
case 0x000077ac:
return 0xe4e25e26;
case 0x000077b0:
return 0xc9923c21;
case 0x000077b4:
return 0xba49f81f;
case 0x000077b8:
return 0x352793fb;
case 0x000077bc:
return 0xcafcf286;
case 0x000077c0:
return 0xee07abb5;
case 0x000077c4:
return 0xec487ae3;
case 0x000077c8:
return 0x266b7f37;
case 0x000077cc:
return 0xba650969;
case 0x000077d0:
return 0xe985e3ad;
case 0x000077d4:
return 0x93c3434f;
case 0x000077d8:
return 0x56c878a4;
case 0x000077dc:
return 0x353f26f7;
case 0x000077e0:
return 0x1020c5c5;
case 0x000077e4:
return 0x3de1ae67;
case 0x000077e8:
return 0x42b42261;
case 0x000077ec:
return 0xbd9b2687;
case 0x000077f0:
return 0x5398349c;
case 0x000077f4:
return 0x60d71407;
case 0x000077f8:
return 0xebf101c6;
case 0x000077fc:
return 0x87ed704f;
case 0x00007800:
return 0xed0766fb;
case 0x00007804:
return 0x1be5343a;
case 0x00007808:
return 0x4db77bef;
case 0x0000780c:
return 0xfcab1d26;
case 0x00007810:
return 0x3abf17be;
case 0x00007814:
return 0xebdf4abd;
case 0x00007818:
return 0x07634533;
case 0x0000781c:
return 0x67052689;
case 0x00007820:
return 0x4af795a7;
case 0x00007824:
return 0xfdc0ae9a;
case 0x00007828:
return 0x7ecb5ffa;
case 0x0000782c:
return 0xe04cc507;
case 0x00007830:
return 0xa07e1929;
case 0x00007834:
return 0x27adcd5b;
case 0x00007838:
return 0x538035fe;
case 0x0000783c:
return 0xd58df55a;
case 0x00007840:
return 0x30dacc08;
case 0x00007844:
return 0x4b83db93;
case 0x00007848:
return 0xd9dd04ea;
case 0x0000784c:
return 0x417d4985;
case 0x00007850:
return 0x847ef82b;
case 0x00007854:
return 0x7bd5f0c9;
case 0x00007858:
return 0x39d56676;
case 0x0000785c:
return 0xb5617038;
case 0x00007860:
return 0xf615ea50;
case 0x00007864:
return 0x05529c0f;
case 0x00007868:
return 0x8b4f2cb0;
case 0x0000786c:
return 0x9cfbdac4;
case 0x00007870:
return 0xe848e037;
case 0x00007874:
return 0xb54cd309;
case 0x00007878:
return 0x7b97233d;
case 0x0000787c:
return 0x590c4934;
case 0x00007880:
return 0xcaaf801f;
case 0x00007884:
return 0x0ff0afa8;
case 0x00007888:
return 0x38a09476;
case 0x0000788c:
return 0x2b7c70ed;
case 0x00007890:
return 0x6f051de9;
case 0x00007894:
return 0x5fa8e2fc;
case 0x00007898:
return 0x3ab4e9b5;
case 0x0000789c:
return 0x9035c678;
case 0x000078a0:
return 0x0d591926;
case 0x000078a4:
return 0xa4bb4c69;
case 0x000078a8:
return 0x1f93c24b;
case 0x000078ac:
return 0xdb12d2af;
case 0x000078b0:
return 0xfb35aac2;
case 0x000078b4:
return 0x812efa91;
case 0x000078b8:
return 0x685f1bee;
case 0x000078bc:
return 0xc0563df5;
case 0x000078c0:
return 0xb04d519b;
case 0x000078c4:
return 0x28ee17c4;
case 0x000078c8:
return 0x551780f2;
case 0x000078cc:
return 0x8fada95a;
case 0x000078d0:
return 0xcfb928b2;
case 0x000078d4:
return 0xe634ea1d;
case 0x000078d8:
return 0x5f25f0a1;
case 0x000078dc:
return 0xa57008d5;
case 0x000078e0:
return 0x99c772cb;
case 0x000078e4:
return 0x3dd9aa8d;
case 0x000078e8:
return 0x38c6fdf3;
case 0x000078ec:
return 0xdca91520;
case 0x000078f0:
return 0x562f2a55;
case 0x000078f4:
return 0x4a9af087;
case 0x000078f8:
return 0xa024f907;
case 0x000078fc:
return 0xfb8e1ca2;
case 0x00007900:
return 0x03cdf510;
case 0x00007904:
return 0xac168b97;
case 0x00007908:
return 0x42c49f4e;
case 0x0000790c:
return 0x5dbbd0d1;
case 0x00007910:
return 0xc7e0d9d4;
case 0x00007914:
return 0xa4fbec51;
case 0x00007918:
return 0x848737ce;
case 0x0000791c:
return 0x7e2d7954;
case 0x00007920:
return 0xbfb6bfec;
case 0x00007924:
return 0xf97f1203;
case 0x00007928:
return 0x87e23ed1;
case 0x0000792c:
return 0x23a7697b;
case 0x00007930:
return 0xbab81ba3;
case 0x00007934:
return 0x37819750;
case 0x00007938:
return 0xddf4f80c;
case 0x0000793c:
return 0xefa5c1f0;
case 0x00007940:
return 0xd223485c;
case 0x00007944:
return 0x8ff6cd96;
case 0x00007948:
return 0x46da0d1e;
case 0x0000794c:
return 0xc6f6dca0;
case 0x00007950:
return 0xa7b0c5a1;
case 0x00007954:
return 0xcbdf4877;
case 0x00007958:
return 0xe50e05a7;
case 0x0000795c:
return 0xc32e2d52;
case 0x00007960:
return 0x7f4a7427;
case 0x00007964:
return 0xdb693e69;
case 0x00007968:
return 0xb2d28cb4;
case 0x0000796c:
return 0x7293efce;
case 0x00007970:
return 0xd4103a53;
case 0x00007974:
return 0xeb602715;
case 0x00007978:
return 0x92c88197;
case 0x0000797c:
return 0x231cadb6;
case 0x00007980:
return 0x8caee1eb;
case 0x00007984:
return 0x1f935b43;
case 0x00007988:
return 0xe372ee6a;
case 0x0000798c:
return 0xbf9da0b2;
case 0x00007990:
return 0x10cac68b;
case 0x00007994:
return 0xdf4d51c8;
case 0x00007998:
return 0x458ed3f9;
case 0x0000799c:
return 0xe073c007;
case 0x000079a0:
return 0x40790294;
case 0x000079a4:
return 0xfabbdabb;
case 0x000079a8:
return 0xfbf64dbd;
case 0x000079ac:
return 0x06ae2c2d;
case 0x000079b0:
return 0x78f34442;
case 0x000079b4:
return 0x29b31aba;
case 0x000079b8:
return 0x4a902adf;
case 0x000079bc:
return 0xd48902b3;
case 0x000079c0:
return 0x685da2df;
case 0x000079c4:
return 0x6d8b3e71;
case 0x000079c8:
return 0xd640f965;
case 0x000079cc:
return 0xf82dc1e2;
case 0x000079d0:
return 0x4737bbfb;
case 0x000079d4:
return 0x0df213c9;
case 0x000079d8:
return 0xb30d3c02;
case 0x000079dc:
return 0xbe8dced7;
case 0x000079e0:
return 0x1dab4844;
case 0x000079e4:
return 0x1d00ecd3;
case 0x000079e8:
return 0x56a24a36;
case 0x000079ec:
return 0x847cef3c;
case 0x000079f0:
return 0x8d71efd2;
case 0x000079f4:
return 0x327c9a28;
case 0x000079f8:
return 0xcd823726;
case 0x000079fc:
return 0x9fd9e105;
case 0x00007a00:
return 0xa47f9971;
case 0x00007a04:
return 0x09cf9a95;
case 0x00007a08:
return 0x39ad4ee0;
case 0x00007a0c:
return 0x74624077;
case 0x00007a10:
return 0x9cb4ca37;
case 0x00007a14:
return 0xbb8bf399;
case 0x00007a18:
return 0x55a75207;
case 0x00007a1c:
return 0x7a84fb58;
case 0x00007a20:
return 0xd7baf911;
case 0x00007a24:
return 0x0442f967;
case 0x00007a28:
return 0x078bad67;
case 0x00007a2c:
return 0x0bf20779;
case 0x00007a30:
return 0x2c473d76;
case 0x00007a34:
return 0x33182693;
case 0x00007a38:
return 0xd7ec7641;
case 0x00007a3c:
return 0x66e01674;
case 0x00007a40:
return 0x127956eb;
case 0x00007a44:
return 0x8339816f;
case 0x00007a48:
return 0xac70f1f5;
case 0x00007a4c:
return 0xfafcef55;
case 0x00007a50:
return 0x40975ae4;
case 0x00007a54:
return 0x7d7088b2;
case 0x00007a58:
return 0xe395dadb;
case 0x00007a5c:
return 0x8b75e5ea;
case 0x00007a60:
return 0xc3a3af0e;
case 0x00007a64:
return 0x5ed5ade0;
case 0x00007a68:
return 0x2c65c4e6;
case 0x00007a6c:
return 0x68f97bda;
case 0x00007a70:
return 0xac458dfc;
case 0x00007a74:
return 0x2dfbaa51;
case 0x00007a78:
return 0xe3907047;
case 0x00007a7c:
return 0x411c6ffa;
case 0x00007a80:
return 0x8ba9ba5e;
case 0x00007a84:
return 0xcbd0f647;
case 0x00007a88:
return 0xdb232554;
case 0x00007a8c:
return 0x920b3706;
case 0x00007a90:
return 0x15cd4bcb;
case 0x00007a94:
return 0xda3ab8af;
case 0x00007a98:
return 0x26117622;
case 0x00007a9c:
return 0xfd8c0b24;
case 0x00007aa0:
return 0x212441a0;
case 0x00007aa4:
return 0xa545c258;
case 0x00007aa8:
return 0xd86ede97;
case 0x00007aac:
return 0x8f7d6816;
case 0x00007ab0:
return 0x8608328e;
case 0x00007ab4:
return 0xd549e846;
case 0x00007ab8:
return 0x8e897109;
case 0x00007abc:
return 0xedf6d9f4;
case 0x00007ac0:
return 0x32f59171;
case 0x00007ac4:
return 0x867f6805;
case 0x00007ac8:
return 0x66af040c;
case 0x00007acc:
return 0xd508e219;
case 0x00007ad0:
return 0x53f0dd96;
case 0x00007ad4:
return 0xd080a90a;
case 0x00007ad8:
return 0x822962c9;
case 0x00007adc:
return 0x63eaef9b;
case 0x00007ae0:
return 0x1630b41d;
case 0x00007ae4:
return 0x0aaf1c4f;
case 0x00007ae8:
return 0x0de4d4fc;
case 0x00007aec:
return 0xf1d16354;
case 0x00007af0:
return 0x8af32f42;
case 0x00007af4:
return 0xb3a6bf72;
case 0x00007af8:
return 0x1f4fc93f;
case 0x00007afc:
return 0x1af6cb2e;
case 0x00007b00:
return 0xd19a98ab;
case 0x00007b04:
return 0x0e703d2d;
case 0x00007b08:
return 0xae92f9f8;
case 0x00007b0c:
return 0x03512e31;
case 0x00007b10:
return 0x8a028851;
case 0x00007b14:
return 0xb4a02a21;
case 0x00007b18:
return 0x63aec7f0;
case 0x00007b1c:
return 0x6ce6cb0a;
case 0x00007b20:
return 0x2fb19b25;
case 0x00007b24:
return 0x7347b039;
case 0x00007b28:
return 0xdb187cca;
case 0x00007b2c:
return 0x55186ff1;
case 0x00007b30:
return 0x91344bed;
case 0x00007b34:
return 0xe225241a;
case 0x00007b38:
return 0xf11aedff;
case 0x00007b3c:
return 0x8e950635;
case 0x00007b40:
return 0x60847147;
case 0x00007b44:
return 0xdf509234;
case 0x00007b48:
return 0x87b9af60;
case 0x00007b4c:
return 0x8a6a4121;
case 0x00007b50:
return 0xdbc2d81c;
case 0x00007b54:
return 0x63593c95;
case 0x00007b58:
return 0x0ed5f9c9;
case 0x00007b5c:
return 0x2e34d7dc;
case 0x00007b60:
return 0xc396e3ae;
case 0x00007b64:
return 0x121d04a1;
case 0x00007b68:
return 0x557b1f60;
case 0x00007b6c:
return 0x9695bc13;
case 0x00007b70:
return 0xd4dfe18b;
case 0x00007b74:
return 0x95ce3d45;
case 0x00007b78:
return 0x7f4615f6;
case 0x00007b7c:
return 0x8b89dd63;
case 0x00007b80:
return 0xad4fbdfc;
case 0x00007b84:
return 0xe24b7993;
case 0x00007b88:
return 0x8740a37b;
case 0x00007b8c:
return 0x47d12bd6;
case 0x00007b90:
return 0xecd5e133;
case 0x00007b94:
return 0x750d1765;
case 0x00007b98:
return 0x96e580ce;
case 0x00007b9c:
return 0x49d6162d;
case 0x00007ba0:
return 0x7cc7acd8;
case 0x00007ba4:
return 0xcacf6e92;
case 0x00007ba8:
return 0xf12d378a;
case 0x00007bac:
return 0xfd59aebc;
case 0x00007bb0:
return 0x249b8cca;
case 0x00007bb4:
return 0xc9082f6e;
case 0x00007bb8:
return 0xc8d4a172;
case 0x00007bbc:
return 0x3d843942;
case 0x00007bc0:
return 0x6d02bbad;
case 0x00007bc4:
return 0x963c1db5;
case 0x00007bc8:
return 0x180a209c;
case 0x00007bcc:
return 0xb3948a3a;
case 0x00007bd0:
return 0x4187eda0;
case 0x00007bd4:
return 0xa32e0aa4;
case 0x00007bd8:
return 0x8bc5fb4c;
case 0x00007bdc:
return 0xe1c7683e;
case 0x00007be0:
return 0xe54a61a9;
case 0x00007be4:
return 0xb3bdf72f;
case 0x00007be8:
return 0x74f63ccc;
case 0x00007bec:
return 0x73bae2ba;
case 0x00007bf0:
return 0x6e627e33;
case 0x00007bf4:
return 0x9c3e7b2f;
case 0x00007bf8:
return 0x91bcf8d3;
case 0x00007bfc:
return 0x1e3f4e51;
case 0x00007c00:
return 0x7f3bee4d;
case 0x00007c04:
return 0x50b4c882;
case 0x00007c08:
return 0xb0f23724;
case 0x00007c0c:
return 0xa9783f62;
case 0x00007c10:
return 0xa76b3c47;
case 0x00007c14:
return 0x3cdd0175;
case 0x00007c18:
return 0x8f5a46c0;
case 0x00007c1c:
return 0xc25c6d63;
case 0x00007c20:
return 0x6bba2f35;
case 0x00007c24:
return 0x06dc0082;
case 0x00007c28:
return 0x429497f1;
case 0x00007c2c:
return 0x8b0ef55c;
case 0x00007c30:
return 0x022ff327;
case 0x00007c34:
return 0x7178d3d1;
case 0x00007c38:
return 0xb27cb67e;
case 0x00007c3c:
return 0x67e595a4;
case 0x00007c40:
return 0xfd1b21a4;
case 0x00007c44:
return 0x2114a29d;
case 0x00007c48:
return 0xf8e68b8b;
case 0x00007c4c:
return 0xf372e280;
case 0x00007c50:
return 0x614fa72f;
case 0x00007c54:
return 0x38d1ad66;
case 0x00007c58:
return 0x9567663a;
case 0x00007c5c:
return 0x179ccf22;
case 0x00007c60:
return 0xc3c88f11;
case 0x00007c64:
return 0x1d8ef363;
case 0x00007c68:
return 0xacd4a123;
case 0x00007c6c:
return 0x34e2e08e;
case 0x00007c70:
return 0xad10fc6c;
case 0x00007c74:
return 0x94aac3f2;
case 0x00007c78:
return 0x8172d638;
case 0x00007c7c:
return 0xa8e2ac56;
case 0x00007c80:
return 0x21a415a7;
case 0x00007c84:
return 0xff1506ba;
case 0x00007c88:
return 0xfbd849f0;
case 0x00007c8c:
return 0x7433a067;
case 0x00007c90:
return 0xf086a629;
case 0x00007c94:
return 0x33c190d1;
case 0x00007c98:
return 0xc4ec4262;
case 0x00007c9c:
return 0xfa8c7179;
case 0x00007ca0:
return 0x5fc005df;
case 0x00007ca4:
return 0x037fe22d;
case 0x00007ca8:
return 0x29e08a43;
case 0x00007cac:
return 0xc23f3b33;
case 0x00007cb0:
return 0xdb708f18;
case 0x00007cb4:
return 0x1f97bf67;
case 0x00007cb8:
return 0xee6a46e1;
case 0x00007cbc:
return 0xb6fd7887;
case 0x00007cc0:
return 0xad9a66d2;
case 0x00007cc4:
return 0xb87a77c1;
case 0x00007cc8:
return 0x2f641ac3;
case 0x00007ccc:
return 0xc5c4d0f9;
case 0x00007cd0:
return 0x05f736a1;
case 0x00007cd4:
return 0xdfd82496;
case 0x00007cd8:
return 0xe5826296;
case 0x00007cdc:
return 0x710fcea7;
case 0x00007ce0:
return 0xdf54a9cd;
case 0x00007ce4:
return 0x8148ac91;
case 0x00007ce8:
return 0xfe70a4b9;
case 0x00007cec:
return 0xcbcca437;
case 0x00007cf0:
return 0xb4a7ed1f;
case 0x00007cf4:
return 0xd2e9c883;
case 0x00007cf8:
return 0x4a0c894a;
case 0x00007cfc:
return 0x96fd6163;
case 0x00007d00:
return 0x31ef1272;
case 0x00007d04:
return 0xb2f8085a;
case 0x00007d08:
return 0x65c9c4e0;
case 0x00007d0c:
return 0xa8a56ba7;
case 0x00007d10:
return 0x5e87eb29;
case 0x00007d14:
return 0x45a8da86;
case 0x00007d18:
return 0x83ec6f46;
case 0x00007d1c:
return 0xb50000f6;
case 0x00007d20:
return 0x6bc98c8f;
case 0x00007d24:
return 0x5b908d3d;
case 0x00007d28:
return 0x7155ed18;
case 0x00007d2c:
return 0x73f868da;
case 0x00007d30:
return 0x651a7fc2;
case 0x00007d34:
return 0x4323047d;
case 0x00007d38:
return 0xa486d0ab;
case 0x00007d3c:
return 0xe69c4e4f;
case 0x00007d40:
return 0x4b936235;
case 0x00007d44:
return 0xcaaaaa9a;
case 0x00007d48:
return 0x2ad3310f;
case 0x00007d4c:
return 0x8fcc7ad0;
case 0x00007d50:
return 0x7bc10eda;
case 0x00007d54:
return 0x7e47e1d9;
case 0x00007d58:
return 0x56b9500a;
case 0x00007d5c:
return 0xddec146e;
case 0x00007d60:
return 0x79ef2809;
case 0x00007d64:
return 0xa0802f31;
case 0x00007d68:
return 0x16e0074b;
case 0x00007d6c:
return 0xc7c94f8f;
case 0x00007d70:
return 0x73e56b5e;
case 0x00007d74:
return 0x3fbedf6d;
case 0x00007d78:
return 0x4f792da1;
case 0x00007d7c:
return 0x7ba24aab;
case 0x00007d80:
return 0xb698402d;
case 0x00007d84:
return 0xd677cc62;
case 0x00007d88:
return 0x00ff48be;
case 0x00007d8c:
return 0x4c419e52;
case 0x00007d90:
return 0x7277cc80;
case 0x00007d94:
return 0x558df448;
case 0x00007d98:
return 0x8e13e71a;
case 0x00007d9c:
return 0x3f7f1cc6;
case 0x00007da0:
return 0xfcbdf0c0;
case 0x00007da4:
return 0xc9678a32;
case 0x00007da8:
return 0x8815186f;
case 0x00007dac:
return 0x5885f004;
case 0x00007db0:
return 0x185106da;
case 0x00007db4:
return 0xdbc2c0ef;
case 0x00007db8:
return 0xbdd938c7;
case 0x00007dbc:
return 0xb5b4d9d2;
case 0x00007dc0:
return 0x2262d53d;
case 0x00007dc4:
return 0x48a471eb;
case 0x00007dc8:
return 0xbc76b3d1;
case 0x00007dcc:
return 0x183a7472;
case 0x00007dd0:
return 0x32bbcbb1;
case 0x00007dd4:
return 0x9c024cad;
case 0x00007dd8:
return 0x75248409;
case 0x00007ddc:
return 0x1eb271fa;
case 0x00007de0:
return 0x359d2cae;
case 0x00007de4:
return 0x53adf503;
case 0x00007de8:
return 0xcfa20307;
case 0x00007dec:
return 0xa209224b;
case 0x00007df0:
return 0x62cef6b6;
case 0x00007df4:
return 0xd946fe0c;
case 0x00007df8:
return 0x10463d62;
case 0x00007dfc:
return 0xb3ad1e1a;
case 0x00007e00:
return 0x5e010bcc;
case 0x00007e04:
return 0x69b28051;
case 0x00007e08:
return 0x104c2f7c;
case 0x00007e0c:
return 0x656b7758;
case 0x00007e10:
return 0x552af1f1;
case 0x00007e14:
return 0x947423a4;
case 0x00007e18:
return 0x555f6943;
case 0x00007e1c:
return 0x24c822a6;
case 0x00007e20:
return 0x93f81a00;
case 0x00007e24:
return 0x2998c631;
case 0x00007e28:
return 0x80730d5b;
case 0x00007e2c:
return 0xa192a460;
case 0x00007e30:
return 0xf6d0c7ca;
case 0x00007e34:
return 0x4753ac08;
case 0x00007e38:
return 0x4a898bc1;
case 0x00007e3c:
return 0x031b791d;
case 0x00007e40:
return 0xdd01a356;
case 0x00007e44:
return 0x87149cc3;
case 0x00007e48:
return 0x67c3204d;
case 0x00007e4c:
return 0x607c32e1;
case 0x00007e50:
return 0x484e7089;
case 0x00007e54:
return 0xf1539208;
case 0x00007e58:
return 0x17f1eb8b;
case 0x00007e5c:
return 0x91ef1f6f;
case 0x00007e60:
return 0x7b060135;
case 0x00007e64:
return 0xc24378d2;
case 0x00007e68:
return 0x5989b070;
case 0x00007e6c:
return 0x544a5f8f;
case 0x00007e70:
return 0x5409a2e0;
case 0x00007e74:
return 0xedee8c83;
case 0x00007e78:
return 0xa1261397;
case 0x00007e7c:
return 0x5668b9de;
case 0x00007e80:
return 0xb6fda720;
case 0x00007e84:
return 0x20a46a61;
case 0x00007e88:
return 0x91d186fe;
case 0x00007e8c:
return 0x55d0afab;
case 0x00007e90:
return 0x482c643d;
case 0x00007e94:
return 0xaa28fb7d;
case 0x00007e98:
return 0xb185237d;
case 0x00007e9c:
return 0xa9ac46ec;
case 0x00007ea0:
return 0x919a429e;
case 0x00007ea4:
return 0x7aae7783;
case 0x00007ea8:
return 0x960f6d38;
case 0x00007eac:
return 0x5c062bb4;
case 0x00007eb0:
return 0x69fff7cc;
case 0x00007eb4:
return 0x7e62b5dd;
case 0x00007eb8:
return 0xe562e0b6;
case 0x00007ebc:
return 0x936b4d77;
case 0x00007ec0:
return 0xd2f32777;
case 0x00007ec4:
return 0xc87968b0;
case 0x00007ec8:
return 0xb24497d1;
case 0x00007ecc:
return 0x9fc1d216;
case 0x00007ed0:
return 0x2b874bbb;
case 0x00007ed4:
return 0x18a8f409;
case 0x00007ed8:
return 0x9031b107;
case 0x00007edc:
return 0x6ebd434b;
case 0x00007ee0:
return 0xbe4a9588;
case 0x00007ee4:
return 0x35976f5b;
case 0x00007ee8:
return 0x459c40a5;
case 0x00007eec:
return 0x5f7c1211;
case 0x00007ef0:
return 0x0c7fe0ed;
case 0x00007ef4:
return 0x95410375;
case 0x00007ef8:
return 0x58f158d2;
case 0x00007efc:
return 0x38217ce3;
case 0x00007f00:
return 0x1914bf57;
case 0x00007f04:
return 0xb7fa9ded;
case 0x00007f08:
return 0x4073a161;
case 0x00007f0c:
return 0x19c6c43d;
case 0x00007f10:
return 0x17fe8f70;
case 0x00007f14:
return 0xf44b9384;
case 0x00007f18:
return 0x8da5d327;
case 0x00007f1c:
return 0x266f91be;
case 0x00007f20:
return 0xb71c71a7;
case 0x00007f24:
return 0x30cae4b7;
case 0x00007f28:
return 0xc185c1d8;
case 0x00007f2c:
return 0xbc1f820d;
case 0x00007f30:
return 0x1e6291f8;
case 0x00007f34:
return 0x6bedf54c;
case 0x00007f38:
return 0x88cd08ba;
case 0x00007f3c:
return 0x20e965fc;
case 0x00007f40:
return 0xad60b7b3;
case 0x00007f44:
return 0xb9917e8f;
case 0x00007f48:
return 0x1e545423;
case 0x00007f4c:
return 0x8dc553e2;
case 0x00007f50:
return 0x7b1fccd5;
case 0x00007f54:
return 0x407e1aac;
case 0x00007f58:
return 0x82788862;
case 0x00007f5c:
return 0xe100c20d;
case 0x00007f60:
return 0x2cb9fc53;
case 0x00007f64:
return 0x7fc4b12d;
case 0x00007f68:
return 0xcbc1cc66;
case 0x00007f6c:
return 0x633b9f20;
case 0x00007f70:
return 0x0cb2ab67;
case 0x00007f74:
return 0x6e8e8b93;
case 0x00007f78:
return 0x094ada01;
case 0x00007f7c:
return 0x59a3809c;
case 0x00007f80:
return 0xdcd79e57;
case 0x00007f84:
return 0xa2ee355b;
case 0x00007f88:
return 0xd559bb9a;
case 0x00007f8c:
return 0x83edc241;
case 0x00007f90:
return 0xb8d9f576;
case 0x00007f94:
return 0x556da211;
case 0x00007f98:
return 0xd0f8ae2c;
case 0x00007f9c:
return 0xf6a8c1af;
case 0x00007fa0:
return 0x0aaf2247;
case 0x00007fa4:
return 0xc4db21b0;
case 0x00007fa8:
return 0x1459ab30;
case 0x00007fac:
return 0x729808f3;
case 0x00007fb0:
return 0x046abd2f;
case 0x00007fb4:
return 0x4bb02018;
case 0x00007fb8:
return 0x22d5ec1a;
case 0x00007fbc:
return 0xb34206b5;
case 0x00007fc0:
return 0xfe39ebce;
case 0x00007fc4:
return 0xf543ca75;
case 0x00007fc8:
return 0xee9e1d03;
case 0x00007fcc:
return 0x1b610078;
case 0x00007fd0:
return 0xaf7d7b54;
case 0x00007fd4:
return 0x4f790b36;
case 0x00007fd8:
return 0xc05c8185;
case 0x00007fdc:
return 0xadb553eb;
case 0x00007fe0:
return 0x8f36c778;
case 0x00007fe4:
return 0x354fc6fa;
case 0x00007fe8:
return 0x424b6654;
case 0x00007fec:
return 0x5131bad8;
case 0x00007ff0:
return 0xa1a3371d;
case 0x00007ff4:
return 0x0003d49a;
case 0x00007ff8:
return 0x509f7719;
case 0x00007ffc:
return 0x299e487f;
case 0x00008000:
return 0x79c013b5;
case 0x00008004:
return 0x53cd8b1c;
case 0x00008008:
return 0xf48437a2;
case 0x0000800c:
return 0x899de37c;
case 0x00008010:
return 0x3a268f78;
case 0x00008014:
return 0x5aa340f7;
case 0x00008018:
return 0xa11338dd;
case 0x0000801c:
return 0xa9c60b43;
case 0x00008020:
return 0x011553bb;
case 0x00008024:
return 0x913a1b67;
case 0x00008028:
return 0x861e9ad4;
case 0x0000802c:
return 0xd76b15a5;
case 0x00008030:
return 0x78d5008f;
case 0x00008034:
return 0x7e4c7e06;
case 0x00008038:
return 0xebca357f;
case 0x0000803c:
return 0x57ceca3b;
case 0x00008040:
return 0xfe4fc5cf;
case 0x00008044:
return 0x3ace4b33;
case 0x00008048:
return 0x585d38f8;
case 0x0000804c:
return 0xbf58d76b;
case 0x00008050:
return 0x78623b1f;
case 0x00008054:
return 0x4695b706;
case 0x00008058:
return 0x557df36a;
case 0x0000805c:
return 0x354478f3;
case 0x00008060:
return 0xbb811be3;
case 0x00008064:
return 0x1e97e42f;
case 0x00008068:
return 0x97fe02e9;
case 0x0000806c:
return 0x24d0ea10;
case 0x00008070:
return 0xc9b02867;
case 0x00008074:
return 0xdfe0bafa;
case 0x00008078:
return 0x490285b6;
case 0x0000807c:
return 0xb33ecdc4;
case 0x00008080:
return 0x178e9cf9;
case 0x00008084:
return 0x38ade1cc;
case 0x00008088:
return 0x343e2835;
case 0x0000808c:
return 0x645c1543;
case 0x00008090:
return 0xa750d28b;
case 0x00008094:
return 0x36fc8286;
case 0x00008098:
return 0x1c0f5455;
case 0x0000809c:
return 0xac6ed0d8;
case 0x000080a0:
return 0x6f3c2722;
case 0x000080a4:
return 0xc8b0238b;
case 0x000080a8:
return 0x2ee241dd;
case 0x000080ac:
return 0xb3bb15e8;
case 0x000080b0:
return 0x2ab737ee;
case 0x000080b4:
return 0xda335a0d;
case 0x000080b8:
return 0xeee0293a;
case 0x000080bc:
return 0x5ef27a03;
case 0x000080c0:
return 0x4568d574;
case 0x000080c4:
return 0x37759681;
case 0x000080c8:
return 0xed2e01bd;
case 0x000080cc:
return 0xff695f25;
case 0x000080d0:
return 0x4bdd349a;
case 0x000080d4:
return 0xf1563c06;
case 0x000080d8:
return 0xc392c41a;
case 0x000080dc:
return 0xebb0fe63;
case 0x000080e0:
return 0x14f802cc;
case 0x000080e4:
return 0x9bb28a10;
case 0x000080e8:
return 0xba83d3b8;
case 0x000080ec:
return 0x0a955c2a;
case 0x000080f0:
return 0xbefa6645;
case 0x000080f4:
return 0xd3672d47;
case 0x000080f8:
return 0xde263d09;
case 0x000080fc:
return 0x8f99a9fb;
case 0x00008100:
return 0xf516af10;
case 0x00008104:
return 0x3a42a0f1;
case 0x00008108:
return 0x519d4b7d;
case 0x0000810c:
return 0x53ff3657;
case 0x00008110:
return 0xd1e55d29;
case 0x00008114:
return 0x535001dc;
case 0x00008118:
return 0xab1b56c0;
case 0x0000811c:
return 0x8d6f3f8c;
case 0x00008120:
return 0x98573116;
case 0x00008124:
return 0x43aba64d;
case 0x00008128:
return 0x47a76980;
case 0x0000812c:
return 0x318f5be2;
case 0x00008130:
return 0x5ee8b91f;
case 0x00008134:
return 0x820ebfc6;
case 0x00008138:
return 0x38be0aa3;
case 0x0000813c:
return 0x255f12dd;
case 0x00008140:
return 0x2a652765;
case 0x00008144:
return 0x0a1c7e43;
case 0x00008148:
return 0x484d09f0;
case 0x0000814c:
return 0xaa065f3a;
case 0x00008150:
return 0x9752d93c;
case 0x00008154:
return 0x7a47f89c;
case 0x00008158:
return 0x58079edf;
case 0x0000815c:
return 0x93a9b5b9;
case 0x00008160:
return 0x8e63ab87;
case 0x00008164:
return 0x145e554d;
case 0x00008168:
return 0xe5ef515b;
case 0x0000816c:
return 0x65ec4f70;
case 0x00008170:
return 0x04dad6d9;
case 0x00008174:
return 0x16469f14;
case 0x00008178:
return 0x2cd062a0;
case 0x0000817c:
return 0xa60d57ba;
case 0x00008180:
return 0xbd806db4;
case 0x00008184:
return 0x599697aa;
case 0x00008188:
return 0x15cc7dde;
case 0x0000818c:
return 0xc1022735;
case 0x00008190:
return 0xdfd82c7f;
case 0x00008194:
return 0xe57d5baa;
case 0x00008198:
return 0x4c403218;
case 0x0000819c:
return 0x9f6a6586;
case 0x000081a0:
return 0x49fcdd9e;
case 0x000081a4:
return 0x9c91278d;
case 0x000081a8:
return 0xb38929ff;
case 0x000081ac:
return 0x2dd2e44f;
case 0x000081b0:
return 0x03def2a4;
case 0x000081b4:
return 0x87c69d24;
case 0x000081b8:
return 0x8365da3c;
case 0x000081bc:
return 0xe43b7dba;
case 0x000081c0:
return 0x01699c7a;
case 0x000081c4:
return 0x61032817;
case 0x000081c8:
return 0x0832e000;
case 0x000081cc:
return 0xb07aaeb7;
case 0x000081d0:
return 0x9960b9dc;
case 0x000081d4:
return 0xe9030bdc;
case 0x000081d8:
return 0x9016df46;
case 0x000081dc:
return 0xb5def4cb;
case 0x000081e0:
return 0x5f7e5660;
case 0x000081e4:
return 0x8a764b9f;
case 0x000081e8:
return 0x5d8f8109;
case 0x000081ec:
return 0x0f2a941b;
case 0x000081f0:
return 0x60d45306;
case 0x000081f4:
return 0x04d8ce6e;
case 0x000081f8:
return 0x239fec29;
case 0x000081fc:
return 0x1419460c;
case 0x00008200:
return 0xa40a8471;
case 0x00008204:
return 0x15c9d8c6;
case 0x00008208:
return 0xb2d5ff98;
case 0x0000820c:
return 0x358b8180;
case 0x00008210:
return 0xd8acd2d5;
case 0x00008214:
return 0xdea9135e;
case 0x00008218:
return 0xcf94daaf;
case 0x0000821c:
return 0x682d3570;
case 0x00008220:
return 0x6f641e6b;
case 0x00008224:
return 0x3e43bf3f;
case 0x00008228:
return 0x39e8b04f;
case 0x0000822c:
return 0x73bd8235;
case 0x00008230:
return 0x2def65c8;
case 0x00008234:
return 0x84515b93;
case 0x00008238:
return 0x1383cd97;
case 0x0000823c:
return 0x3a9c31c9;
case 0x00008240:
return 0x3a4afaf2;
case 0x00008244:
return 0x1cc2c083;
case 0x00008248:
return 0x9acc8784;
case 0x0000824c:
return 0xbaff298d;
case 0x00008250:
return 0x4b980da1;
case 0x00008254:
return 0x6cb480d6;
case 0x00008258:
return 0xab5c636f;
case 0x0000825c:
return 0x50729637;
case 0x00008260:
return 0x93981c4b;
case 0x00008264:
return 0xd35b72c7;
case 0x00008268:
return 0x5c1cb917;
case 0x0000826c:
return 0x1a574048;
case 0x00008270:
return 0x131a0390;
case 0x00008274:
return 0x4ff8c014;
case 0x00008278:
return 0xb63361d9;
case 0x0000827c:
return 0x9d519ed1;
case 0x00008280:
return 0x2bbb6daf;
case 0x00008284:
return 0xe343ea64;
case 0x00008288:
return 0x6eb6f24e;
case 0x0000828c:
return 0x7751a283;
case 0x00008290:
return 0x12128f3e;
case 0x00008294:
return 0x2cb33a73;
case 0x00008298:
return 0xb6910b45;
case 0x0000829c:
return 0xd904905a;
case 0x000082a0:
return 0x81ff1577;
case 0x000082a4:
return 0x6dec5fbc;
case 0x000082a8:
return 0x7bb61894;
case 0x000082ac:
return 0x520ea045;
case 0x000082b0:
return 0x35ce023e;
case 0x000082b4:
return 0x482e4d3f;
case 0x000082b8:
return 0xa2415484;
case 0x000082bc:
return 0x004061ec;
case 0x000082c0:
return 0x1f51baca;
case 0x000082c4:
return 0x4b7ddc83;
case 0x000082c8:
return 0x21b0262d;
case 0x000082cc:
return 0xcea44b66;
case 0x000082d0:
return 0xa66a387b;
case 0x000082d4:
return 0x3e415107;
case 0x000082d8:
return 0xab04cb0c;
case 0x000082dc:
return 0xddfe53c4;
case 0x000082e0:
return 0x2923e164;
case 0x000082e4:
return 0x663ce69c;
case 0x000082e8:
return 0x90f24e8a;
case 0x000082ec:
return 0x904a69d2;
case 0x000082f0:
return 0x779fa26b;
case 0x000082f4:
return 0x4fe438d3;
case 0x000082f8:
return 0xd0f57883;
case 0x000082fc:
return 0x5d146841;
case 0x00008300:
return 0xeeaab4d1;
case 0x00008304:
return 0x6d6e7213;
case 0x00008308:
return 0xafff4d62;
case 0x0000830c:
return 0x4980722b;
case 0x00008310:
return 0x6214306a;
case 0x00008314:
return 0xc35f783d;
case 0x00008318:
return 0xc3fa8dcc;
case 0x0000831c:
return 0xd424c909;
case 0x00008320:
return 0x5dee3c18;
case 0x00008324:
return 0xb979854d;
case 0x00008328:
return 0x678b8b03;
case 0x0000832c:
return 0x49cc44d8;
case 0x00008330:
return 0xc4dbe6f7;
case 0x00008334:
return 0x67c19fe4;
case 0x00008338:
return 0x63c86f3b;
case 0x0000833c:
return 0xd52245b8;
case 0x00008340:
return 0xbf049358;
case 0x00008344:
return 0x02d084a4;
case 0x00008348:
return 0x83bae592;
case 0x0000834c:
return 0x71222c0c;
case 0x00008350:
return 0xdbbdca88;
case 0x00008354:
return 0x0c15b208;
case 0x00008358:
return 0x771243f4;
case 0x0000835c:
return 0xfe772b2e;
case 0x00008360:
return 0xed0056ab;
case 0x00008364:
return 0x5893af1f;
case 0x00008368:
return 0xc6ab118d;
case 0x0000836c:
return 0xe6567ede;
case 0x00008370:
return 0x9e1b9409;
case 0x00008374:
return 0xcea6ae02;
case 0x00008378:
return 0x45b48cf3;
case 0x0000837c:
return 0x3844bfdc;
case 0x00008380:
return 0xccdff21b;
case 0x00008384:
return 0x93cac6fb;
case 0x00008388:
return 0x0f467970;
case 0x0000838c:
return 0x911597ce;
case 0x00008390:
return 0x4811307e;
case 0x00008394:
return 0x5a14fb70;
case 0x00008398:
return 0x1bbb34d8;
case 0x0000839c:
return 0x522d62d3;
case 0x000083a0:
return 0x0bb2f7bc;
case 0x000083a4:
return 0x87599cea;
case 0x000083a8:
return 0x062aba18;
case 0x000083ac:
return 0xcec42d16;
case 0x000083b0:
return 0x5e894730;
case 0x000083b4:
return 0xad2a5498;
case 0x000083b8:
return 0x575e6135;
case 0x000083bc:
return 0x8af1f069;
case 0x000083c0:
return 0xe6176593;
case 0x000083c4:
return 0xfd640ba2;
case 0x000083c8:
return 0x9e433aeb;
case 0x000083cc:
return 0x6dd00225;
case 0x000083d0:
return 0xf2c66a05;
case 0x000083d4:
return 0xd0605da7;
case 0x000083d8:
return 0x8bae7fc7;
case 0x000083dc:
return 0xab85b7bd;
case 0x000083e0:
return 0x31b087ca;
case 0x000083e4:
return 0xd914d724;
case 0x000083e8:
return 0x48d46648;
case 0x000083ec:
return 0x2b7404a7;
case 0x000083f0:
return 0x0aed3928;
case 0x000083f4:
return 0xd665af40;
case 0x000083f8:
return 0x865c83c1;
case 0x000083fc:
return 0xf79c946c;
case 0x00008400:
return 0x5f277de0;
case 0x00008404:
return 0xa42288e8;
case 0x00008408:
return 0x35c2ec9c;
case 0x0000840c:
return 0x9f0f1724;
case 0x00008410:
return 0xa29c87f5;
case 0x00008414:
return 0x690fddfd;
case 0x00008418:
return 0x31e4c65b;
case 0x0000841c:
return 0x36c3298b;
case 0x00008420:
return 0x35f578ae;
case 0x00008424:
return 0x12d7d530;
case 0x00008428:
return 0xb1b219c7;
case 0x0000842c:
return 0x7291a55b;
case 0x00008430:
return 0x01f93dc6;
case 0x00008434:
return 0xb0a749c0;
case 0x00008438:
return 0xdb2b819d;
case 0x0000843c:
return 0xe2c835ec;
case 0x00008440:
return 0x2f3d08cb;
case 0x00008444:
return 0x4dc21852;
case 0x00008448:
return 0x3b4d4330;
case 0x0000844c:
return 0xcd17751f;
case 0x00008450:
return 0x24a92a33;
case 0x00008454:
return 0x0d5f8420;
case 0x00008458:
return 0x52641ec2;
case 0x0000845c:
return 0x9cc9d5a3;
case 0x00008460:
return 0x5fabb06a;
case 0x00008464:
return 0xf4793c26;
case 0x00008468:
return 0x8c8ca5ab;
case 0x0000846c:
return 0x3c051f2b;
case 0x00008470:
return 0xff72caa5;
case 0x00008474:
return 0x7b3c2a8d;
case 0x00008478:
return 0x7d51eba8;
case 0x0000847c:
return 0x03718689;
case 0x00008480:
return 0x3b0f38b4;
case 0x00008484:
return 0x74395002;
case 0x00008488:
return 0x8445b52a;
case 0x0000848c:
return 0xdb249d76;
case 0x00008490:
return 0xe4f10e94;
case 0x00008494:
return 0x8800e516;
case 0x00008498:
return 0x1fda4613;
case 0x0000849c:
return 0x816df1ec;
case 0x000084a0:
return 0x0f67ab15;
case 0x000084a4:
return 0x735b9fd3;
case 0x000084a8:
return 0x0fb0bde2;
case 0x000084ac:
return 0x8697689e;
case 0x000084b0:
return 0x22418b6a;
case 0x000084b4:
return 0x438b71c1;
case 0x000084b8:
return 0x52794054;
case 0x000084bc:
return 0xc467c992;
case 0x000084c0:
return 0xb25f910d;
case 0x000084c4:
return 0xab9e91c0;
case 0x000084c8:
return 0xf60ac283;
case 0x000084cc:
return 0xb686f614;
case 0x000084d0:
return 0xe06864b9;
case 0x000084d4:
return 0xd9743e57;
case 0x000084d8:
return 0x8e9342a3;
case 0x000084dc:
return 0xdefed693;
case 0x000084e0:
return 0xc59df5ea;
case 0x000084e4:
return 0x1aebc14d;
case 0x000084e8:
return 0x1a3df3f2;
case 0x000084ec:
return 0x956254b7;
case 0x000084f0:
return 0x8c199108;
case 0x000084f4:
return 0xfe1bb59f;
case 0x000084f8:
return 0x33385694;
case 0x000084fc:
return 0x30027c7c;
case 0x00008500:
return 0x95173344;
case 0x00008504:
return 0x54552200;
case 0x00008508:
return 0xcc4c0e21;
case 0x0000850c:
return 0xdf7e5d3d;
case 0x00008510:
return 0x975e8c56;
case 0x00008514:
return 0x4a8c8304;
case 0x00008518:
return 0x593565ba;
case 0x0000851c:
return 0xe8b85653;
case 0x00008520:
return 0x1b3ae4eb;
case 0x00008524:
return 0x9bb29a69;
case 0x00008528:
return 0xa1eb221f;
case 0x0000852c:
return 0xfaf650f0;
case 0x00008530:
return 0xe682380a;
case 0x00008534:
return 0x88d354e5;
case 0x00008538:
return 0xe085ce58;
case 0x0000853c:
return 0x3a5e247e;
case 0x00008540:
return 0x8c06e473;
case 0x00008544:
return 0x7f451319;
case 0x00008548:
return 0x6878ceeb;
case 0x0000854c:
return 0x6db06066;
case 0x00008550:
return 0x12dbc108;
case 0x00008554:
return 0xf3cbaf3f;
case 0x00008558:
return 0x1805143b;
case 0x0000855c:
return 0xedbe028d;
case 0x00008560:
return 0x1188ad98;
case 0x00008564:
return 0xd455c52d;
case 0x00008568:
return 0x32270188;
case 0x0000856c:
return 0xf7277fc6;
case 0x00008570:
return 0x9e9812c1;
case 0x00008574:
return 0x2aee689f;
case 0x00008578:
return 0x0dc8ce36;
case 0x0000857c:
return 0x2afd23b1;
case 0x00008580:
return 0xbf12da33;
case 0x00008584:
return 0xc826a1cc;
case 0x00008588:
return 0x1e6fd3f8;
case 0x0000858c:
return 0x477c3f36;
case 0x00008590:
return 0x4da95a72;
case 0x00008594:
return 0xa58318ad;
case 0x00008598:
return 0x5e6b4524;
case 0x0000859c:
return 0x51696b10;
case 0x000085a0:
return 0xf9a89d98;
case 0x000085a4:
return 0x8fc16de5;
case 0x000085a8:
return 0xdb92a0cd;
case 0x000085ac:
return 0xf6586581;
case 0x000085b0:
return 0x2c111877;
case 0x000085b4:
return 0xe52c0f99;
case 0x000085b8:
return 0xd0a5a5ea;
case 0x000085bc:
return 0x9436b17f;
case 0x000085c0:
return 0xad33f2df;
case 0x000085c4:
return 0x51b389e3;
case 0x000085c8:
return 0xf366e858;
case 0x000085cc:
return 0xac35453d;
case 0x000085d0:
return 0x908a85e9;
case 0x000085d4:
return 0x12709b32;
case 0x000085d8:
return 0x628ca908;
case 0x000085dc:
return 0x29914af3;
case 0x000085e0:
return 0x97e2739a;
case 0x000085e4:
return 0x50dfba95;
case 0x000085e8:
return 0x9c0209ea;
case 0x000085ec:
return 0xb0fdd3aa;
case 0x000085f0:
return 0x6dd847d1;
case 0x000085f4:
return 0x41c82058;
case 0x000085f8:
return 0x17190031;
case 0x000085fc:
return 0x353154c9;
case 0x00008600:
return 0x64c1b09f;
case 0x00008604:
return 0x049a2d96;
case 0x00008608:
return 0xf68326d2;
case 0x0000860c:
return 0x52f75d48;
case 0x00008610:
return 0x1a96c848;
case 0x00008614:
return 0xd3dfbf67;
case 0x00008618:
return 0x012fb18b;
case 0x0000861c:
return 0x2400fa56;
case 0x00008620:
return 0xc4cb103c;
case 0x00008624:
return 0xa5902fe4;
case 0x00008628:
return 0xe581a0df;
case 0x0000862c:
return 0x71fdd6c6;
case 0x00008630:
return 0xe4c93e75;
case 0x00008634:
return 0x2e3a5585;
case 0x00008638:
return 0x2b227a18;
case 0x0000863c:
return 0xc8c35c82;
case 0x00008640:
return 0x332f9a99;
case 0x00008644:
return 0x60283c4c;
case 0x00008648:
return 0x9b02e530;
case 0x0000864c:
return 0x33a1c9ac;
case 0x00008650:
return 0x02601af3;
case 0x00008654:
return 0xe1e53eee;
case 0x00008658:
return 0x77143ae2;
case 0x0000865c:
return 0x922149e8;
case 0x00008660:
return 0x00f309e4;
case 0x00008664:
return 0xd2cd0ea6;
case 0x00008668:
return 0xda7ecdc7;
case 0x0000866c:
return 0x2eba69fb;
case 0x00008670:
return 0x20ef2e7a;
case 0x00008674:
return 0xaee13b77;
case 0x00008678:
return 0x806ea1ba;
case 0x0000867c:
return 0xd4059fdd;
case 0x00008680:
return 0x00fd1923;
case 0x00008684:
return 0x3c825ba6;
case 0x00008688:
return 0xae2b670c;
case 0x0000868c:
return 0x4e015ee9;
case 0x00008690:
return 0x119f5bc5;
case 0x00008694:
return 0xecca412b;
case 0x00008698:
return 0x183fce2e;
case 0x0000869c:
return 0xfa764e1b;
case 0x000086a0:
return 0x71f73711;
case 0x000086a4:
return 0xc7023ddf;
case 0x000086a8:
return 0x0324a48e;
case 0x000086ac:
return 0x0c4bf386;
case 0x000086b0:
return 0x9958444a;
case 0x000086b4:
return 0xb494722e;
case 0x000086b8:
return 0x29cb9b05;
case 0x000086bc:
return 0xb69a7278;
case 0x000086c0:
return 0xfba740b2;
case 0x000086c4:
return 0xdf178ce1;
case 0x000086c8:
return 0x12fe8369;
case 0x000086cc:
return 0xc88f9e83;
case 0x000086d0:
return 0x571a5948;
case 0x000086d4:
return 0xc5f6af71;
case 0x000086d8:
return 0x632cf3d2;
case 0x000086dc:
return 0x67f7523d;
case 0x000086e0:
return 0x819f3102;
case 0x000086e4:
return 0x9806d5da;
case 0x000086e8:
return 0xb4cc04b7;
case 0x000086ec:
return 0x2eae9f4e;
case 0x000086f0:
return 0xdc6a861c;
case 0x000086f4:
return 0x70dc4817;
case 0x000086f8:
return 0x52628140;
case 0x000086fc:
return 0x76292962;
case 0x00008700:
return 0xb496a6a4;
case 0x00008704:
return 0xa3cb0647;
case 0x00008708:
return 0xabd82bbb;
case 0x0000870c:
return 0x15b434ea;
case 0x00008710:
return 0xf06f73ad;
case 0x00008714:
return 0x5b8b5228;
case 0x00008718:
return 0x24e77284;
case 0x0000871c:
return 0x4d94585a;
case 0x00008720:
return 0xb8e75072;
case 0x00008724:
return 0xe7acf360;
case 0x00008728:
return 0x92747b05;
case 0x0000872c:
return 0x8b7b7861;
case 0x00008730:
return 0xb3bd1f76;
case 0x00008734:
return 0xa8efd1db;
case 0x00008738:
return 0xb0c37182;
case 0x0000873c:
return 0xaa814f79;
case 0x00008740:
return 0x0f8647c5;
case 0x00008744:
return 0x6d716b03;
case 0x00008748:
return 0x4e691b91;
case 0x0000874c:
return 0x23cf2fdc;
case 0x00008750:
return 0x267da616;
case 0x00008754:
return 0xc80af1b9;
case 0x00008758:
return 0xc01f9fda;
case 0x0000875c:
return 0xe0dbe952;
case 0x00008760:
return 0x2de40f02;
case 0x00008764:
return 0x12905e9d;
case 0x00008768:
return 0x3ed7b723;
case 0x0000876c:
return 0x4380f814;
case 0x00008770:
return 0x3e99171c;
case 0x00008774:
return 0xbeca4554;
case 0x00008778:
return 0xe1523281;
case 0x0000877c:
return 0x08214ed6;
case 0x00008780:
return 0x304161f4;
case 0x00008784:
return 0x4932db71;
case 0x00008788:
return 0xca4e3645;
case 0x0000878c:
return 0xc287e11e;
case 0x00008790:
return 0x370fdd7d;
case 0x00008794:
return 0x83903c4d;
case 0x00008798:
return 0x70522f6e;
case 0x0000879c:
return 0x08beb58c;
case 0x000087a0:
return 0x8ae76e56;
case 0x000087a4:
return 0x27480b9b;
case 0x000087a8:
return 0x64d9f32c;
case 0x000087ac:
return 0x7072c2ce;
case 0x000087b0:
return 0xf90b2645;
case 0x000087b4:
return 0x08ba0c73;
case 0x000087b8:
return 0xc05edc4e;
case 0x000087bc:
return 0x6230d154;
case 0x000087c0:
return 0x78903c87;
case 0x000087c4:
return 0x648286db;
case 0x000087c8:
return 0x784d0863;
case 0x000087cc:
return 0x9f4b3ad9;
case 0x000087d0:
return 0x0e246658;
case 0x000087d4:
return 0xf64597b6;
case 0x000087d8:
return 0xf99b635f;
case 0x000087dc:
return 0x72400ccd;
case 0x000087e0:
return 0xc1206b36;
case 0x000087e4:
return 0x93d6b71a;
case 0x000087e8:
return 0xebe0f6e9;
case 0x000087ec:
return 0xf68dfe10;
case 0x000087f0:
return 0x2a81bd4a;
case 0x000087f4:
return 0x732e9cec;
case 0x000087f8:
return 0x17891b5f;
case 0x000087fc:
return 0xb5f394b3;
case 0x00008800:
return 0xc8ad9317;
case 0x00008804:
return 0xf1f6b426;
case 0x00008808:
return 0x25b35f52;
case 0x0000880c:
return 0x2e1f6c4c;
case 0x00008810:
return 0xe1622627;
case 0x00008814:
return 0xbd4abbf0;
case 0x00008818:
return 0xd865d299;
case 0x0000881c:
return 0x285ff3fd;
case 0x00008820:
return 0x53647572;
case 0x00008824:
return 0x0cf1a356;
case 0x00008828:
return 0xad4731fc;
case 0x0000882c:
return 0x02b13bd9;
case 0x00008830:
return 0x75b7bd59;
case 0x00008834:
return 0x533d7ae3;
case 0x00008838:
return 0xf89b26b7;
case 0x0000883c:
return 0xfd2e54aa;
case 0x00008840:
return 0x5e5662bf;
case 0x00008844:
return 0xb1acf5df;
case 0x00008848:
return 0xb23b2dff;
case 0x0000884c:
return 0x70202f44;
case 0x00008850:
return 0xea31b054;
case 0x00008854:
return 0x3e99017b;
case 0x00008858:
return 0x2ed51974;
case 0x0000885c:
return 0xa12997ce;
case 0x00008860:
return 0xff78f1c6;
case 0x00008864:
return 0x790065e9;
case 0x00008868:
return 0xf08cf246;
case 0x0000886c:
return 0x65a19282;
case 0x00008870:
return 0x8b83a9b1;
case 0x00008874:
return 0xae6c890d;
case 0x00008878:
return 0x042d8846;
case 0x0000887c:
return 0x2eeb75b5;
case 0x00008880:
return 0xa7a67c50;
case 0x00008884:
return 0xa899505f;
case 0x00008888:
return 0xbf4bbd03;
case 0x0000888c:
return 0xaad5716d;
case 0x00008890:
return 0x2aec2f95;
case 0x00008894:
return 0xf15eba6a;
case 0x00008898:
return 0xb16f4db4;
case 0x0000889c:
return 0xc177e346;
case 0x000088a0:
return 0x44f82688;
case 0x000088a4:
return 0xbd8a8d7b;
case 0x000088a8:
return 0x5607d41a;
case 0x000088ac:
return 0x166fedf3;
case 0x000088b0:
return 0x601d3c64;
case 0x000088b4:
return 0x607c87bf;
case 0x000088b8:
return 0xa6cd8e07;
case 0x000088bc:
return 0x2c6c694f;
case 0x000088c0:
return 0xf237bb95;
case 0x000088c4:
return 0x7eb49781;
case 0x000088c8:
return 0x375cc055;
case 0x000088cc:
return 0x8aad85e5;
case 0x000088d0:
return 0x4141d6b1;
case 0x000088d4:
return 0xf8636168;
case 0x000088d8:
return 0x49285222;
case 0x000088dc:
return 0x92837ae8;
case 0x000088e0:
return 0xb4049d07;
case 0x000088e4:
return 0xdd297da6;
case 0x000088e8:
return 0xdf4c0dfb;
case 0x000088ec:
return 0x8da68358;
case 0x000088f0:
return 0xe1d1f2be;
case 0x000088f4:
return 0x25dc2cda;
case 0x000088f8:
return 0x0e6dc6d5;
case 0x000088fc:
return 0xf9f0af36;
case 0x00008900:
return 0x0ba08ba1;
case 0x00008904:
return 0x2da3d9aa;
case 0x00008908:
return 0x1220b1e2;
case 0x0000890c:
return 0x7801e729;
case 0x00008910:
return 0x5afd4548;
case 0x00008914:
return 0xf4c01767;
case 0x00008918:
return 0xaa0bd498;
case 0x0000891c:
return 0x07bf81d8;
case 0x00008920:
return 0x1ce2f4f7;
case 0x00008924:
return 0xc4476df0;
case 0x00008928:
return 0xc23d373d;
case 0x0000892c:
return 0xc8d20475;
case 0x00008930:
return 0xa81c1893;
case 0x00008934:
return 0x69c0752a;
case 0x00008938:
return 0xb886b23c;
case 0x0000893c:
return 0x4819c9e3;
case 0x00008940:
return 0x8d7ee97b;
case 0x00008944:
return 0x2b36131f;
case 0x00008948:
return 0xbef4ab00;
case 0x0000894c:
return 0x00bcee11;
case 0x00008950:
return 0x7f1d6bcc;
case 0x00008954:
return 0xcdc9d241;
case 0x00008958:
return 0x3ec271d3;
case 0x0000895c:
return 0x48b18b1b;
case 0x00008960:
return 0x72bfbfe7;
case 0x00008964:
return 0x3551f6ec;
case 0x00008968:
return 0x0abdc10c;
case 0x0000896c:
return 0xb75c22d1;
case 0x00008970:
return 0x77e78f99;
case 0x00008974:
return 0x3980f615;
case 0x00008978:
return 0xa91ef933;
case 0x0000897c:
return 0x2c4328a8;
case 0x00008980:
return 0x76496416;
case 0x00008984:
return 0xb4891beb;
case 0x00008988:
return 0x8a77df88;
case 0x0000898c:
return 0x4ccef54a;
case 0x00008990:
return 0x6f0ce360;
case 0x00008994:
return 0xdb7d7c41;
case 0x00008998:
return 0xb6b0b212;
case 0x0000899c:
return 0x8d2b4320;
case 0x000089a0:
return 0x91e8f211;
case 0x000089a4:
return 0x59927cbd;
case 0x000089a8:
return 0xaa95e342;
case 0x000089ac:
return 0x9c3faaf1;
case 0x000089b0:
return 0x75a1808d;
case 0x000089b4:
return 0xb40c67cb;
case 0x000089b8:
return 0x1e7fd7b5;
case 0x000089bc:
return 0x617b9d17;
case 0x000089c0:
return 0x9bf2230c;
case 0x000089c4:
return 0xa299bca3;
case 0x000089c8:
return 0xfaa2b22c;
case 0x000089cc:
return 0x38348905;
case 0x000089d0:
return 0x1b425248;
case 0x000089d4:
return 0x3bf65d5f;
case 0x000089d8:
return 0x0513f263;
case 0x000089dc:
return 0x266a253a;
case 0x000089e0:
return 0x6aa3b761;
case 0x000089e4:
return 0xdece84a5;
case 0x000089e8:
return 0xc7f0ddbe;
case 0x000089ec:
return 0xb6a742e8;
case 0x000089f0:
return 0xa9c995ad;
case 0x000089f4:
return 0x839dc1ee;
case 0x000089f8:
return 0x496df294;
case 0x000089fc:
return 0xf620f222;
case 0x00008a00:
return 0x98873a90;
case 0x00008a04:
return 0x50243587;
case 0x00008a08:
return 0x5b3c61d4;
case 0x00008a0c:
return 0x024a26ef;
case 0x00008a10:
return 0xdab02914;
case 0x00008a14:
return 0xf8e72238;
case 0x00008a18:
return 0xee97e907;
case 0x00008a1c:
return 0xee734204;
case 0x00008a20:
return 0xa5e15dcf;
case 0x00008a24:
return 0x22a30f70;
case 0x00008a28:
return 0x8bc839da;
case 0x00008a2c:
return 0x2405c949;
case 0x00008a30:
return 0x132575e8;
case 0x00008a34:
return 0xe5f3a281;
case 0x00008a38:
return 0xc3845c23;
case 0x00008a3c:
return 0x0dbcff5e;
case 0x00008a40:
return 0xa74de75f;
case 0x00008a44:
return 0xbba6a384;
case 0x00008a48:
return 0x5cba1f2e;
case 0x00008a4c:
return 0xd246bc92;
case 0x00008a50:
return 0x6bb90b5c;
case 0x00008a54:
return 0xd477ab2a;
case 0x00008a58:
return 0x6b6c06ee;
case 0x00008a5c:
return 0x062c8180;
case 0x00008a60:
return 0x5d078efe;
case 0x00008a64:
return 0xcc791940;
case 0x00008a68:
return 0x759d7169;
case 0x00008a6c:
return 0x5f3c9c0c;
case 0x00008a70:
return 0x64e9ef6c;
case 0x00008a74:
return 0x0e9178df;
case 0x00008a78:
return 0x33fd66eb;
case 0x00008a7c:
return 0xfac6141e;
case 0x00008a80:
return 0xcdd5ca5f;
case 0x00008a84:
return 0x7cf64f0d;
case 0x00008a88:
return 0xe4cf4e21;
case 0x00008a8c:
return 0x180ff094;
case 0x00008a90:
return 0x7628a075;
case 0x00008a94:
return 0xb6da06f6;
case 0x00008a98:
return 0x4afaf875;
case 0x00008a9c:
return 0x6072004b;
case 0x00008aa0:
return 0xfb1c8851;
case 0x00008aa4:
return 0xb5b702d0;
case 0x00008aa8:
return 0x2a09ac73;
case 0x00008aac:
return 0x8d1f6727;
case 0x00008ab0:
return 0xebb5a2ec;
case 0x00008ab4:
return 0xcfe51544;
case 0x00008ab8:
return 0x1a3b1fd0;
case 0x00008abc:
return 0x5fc2ec18;
case 0x00008ac0:
return 0x2b241112;
case 0x00008ac4:
return 0x4c9f2b6b;
case 0x00008ac8:
return 0xdf7a4bac;
case 0x00008acc:
return 0xcfc9caef;
case 0x00008ad0:
return 0x2d8a1ac7;
case 0x00008ad4:
return 0x337a2b58;
case 0x00008ad8:
return 0xaea79e56;
case 0x00008adc:
return 0x135459e5;
case 0x00008ae0:
return 0x61ce7393;
case 0x00008ae4:
return 0x823fb274;
case 0x00008ae8:
return 0x3f745c63;
case 0x00008aec:
return 0xf0d7a74b;
case 0x00008af0:
return 0x0d0a4e05;
case 0x00008af4:
return 0x15f9fb30;
case 0x00008af8:
return 0x424b23d3;
case 0x00008afc:
return 0x2d09655d;
case 0x00008b00:
return 0x462550b4;
case 0x00008b04:
return 0x7a5bf49e;
case 0x00008b08:
return 0x819ef870;
case 0x00008b0c:
return 0x322a768c;
case 0x00008b10:
return 0xb01cfed1;
case 0x00008b14:
return 0x1f727a9e;
case 0x00008b18:
return 0x8b1989fe;
case 0x00008b1c:
return 0x90e7d10a;
case 0x00008b20:
return 0xf238662d;
case 0x00008b24:
return 0xa195d390;
case 0x00008b28:
return 0xa75c7461;
case 0x00008b2c:
return 0x69f78aee;
case 0x00008b30:
return 0x5f1eb0d2;
case 0x00008b34:
return 0x8192256f;
case 0x00008b38:
return 0x8f9db0bb;
case 0x00008b3c:
return 0xb3b0aa36;
case 0x00008b40:
return 0x16e49d9e;
case 0x00008b44:
return 0x1d1a7578;
case 0x00008b48:
return 0x2b5ef630;
case 0x00008b4c:
return 0x23a9b25c;
case 0x00008b50:
return 0x97482a7c;
case 0x00008b54:
return 0xa1c7fb90;
case 0x00008b58:
return 0x0ec52b91;
case 0x00008b5c:
return 0xea8bb503;
case 0x00008b60:
return 0xc69f313d;
case 0x00008b64:
return 0x709476af;
case 0x00008b68:
return 0xc1588fcc;
case 0x00008b6c:
return 0xfc8211f0;
case 0x00008b70:
return 0x17f1f602;
case 0x00008b74:
return 0xf2163a72;
case 0x00008b78:
return 0xda8cd958;
case 0x00008b7c:
return 0x67a3000e;
case 0x00008b80:
return 0x98582441;
case 0x00008b84:
return 0xd0b8cf6d;
case 0x00008b88:
return 0x1cbffcb6;
case 0x00008b8c:
return 0x8e915b3a;
case 0x00008b90:
return 0x6ef11735;
case 0x00008b94:
return 0x392bbc10;
case 0x00008b98:
return 0xd119423d;
case 0x00008b9c:
return 0x979ccf11;
case 0x00008ba0:
return 0xf2fb67cd;
case 0x00008ba4:
return 0xddbf1ef1;
case 0x00008ba8:
return 0xc7022d6d;
case 0x00008bac:
return 0x3e9d2ebd;
case 0x00008bb0:
return 0xd5b120ef;
case 0x00008bb4:
return 0xbd322551;
case 0x00008bb8:
return 0xf606f2c3;
case 0x00008bbc:
return 0x1ce58e52;
case 0x00008bc0:
return 0xc38ed9e6;
case 0x00008bc4:
return 0xf013fc3d;
case 0x00008bc8:
return 0x9e1c34c7;
case 0x00008bcc:
return 0x19e01e43;
case 0x00008bd0:
return 0x9132f594;
case 0x00008bd4:
return 0xa4b137b3;
case 0x00008bd8:
return 0xb650f918;
case 0x00008bdc:
return 0x0c75a09c;
case 0x00008be0:
return 0xdfc4f46f;
case 0x00008be4:
return 0x2f33d151;
case 0x00008be8:
return 0x2419011e;
case 0x00008bec:
return 0x59d78378;
case 0x00008bf0:
return 0x62500db5;
case 0x00008bf4:
return 0xf7fd1bb8;
case 0x00008bf8:
return 0x16d230a1;
case 0x00008bfc:
return 0x74967ec5;
case 0x00008c00:
return 0x779014a2;
case 0x00008c04:
return 0x7ed11e8c;
case 0x00008c08:
return 0x91844602;
case 0x00008c0c:
return 0x5c8a90c7;
case 0x00008c10:
return 0x5b6446ca;
case 0x00008c14:
return 0x8999c432;
case 0x00008c18:
return 0x294ca32f;
case 0x00008c1c:
return 0xc05cfa58;
case 0x00008c20:
return 0x33febf31;
case 0x00008c24:
return 0x48c9f29c;
case 0x00008c28:
return 0xf6d72f05;
case 0x00008c2c:
return 0x6e940b32;
case 0x00008c30:
return 0x3c28c4ba;
case 0x00008c34:
return 0xa3bc3d7b;
case 0x00008c38:
return 0x718f3ac0;
case 0x00008c3c:
return 0x8b2e3d8c;
case 0x00008c40:
return 0x5b47766d;
case 0x00008c44:
return 0xb5c3779c;
case 0x00008c48:
return 0x39bfc3c9;
case 0x00008c4c:
return 0x0f2f161b;
case 0x00008c50:
return 0x962693b7;
case 0x00008c54:
return 0xf8a8f0c0;
case 0x00008c58:
return 0x22fc5800;
case 0x00008c5c:
return 0x978b3b36;
case 0x00008c60:
return 0xf7c79fc9;
case 0x00008c64:
return 0x70bdd416;
case 0x00008c68:
return 0x5d7426f3;
case 0x00008c6c:
return 0xe1439a44;
case 0x00008c70:
return 0x58af68ac;
case 0x00008c74:
return 0xa34fb9b2;
case 0x00008c78:
return 0x7e549147;
case 0x00008c7c:
return 0x4f32ab99;
case 0x00008c80:
return 0xfcad24ec;
case 0x00008c84:
return 0xf7fd4407;
case 0x00008c88:
return 0xcba60471;
case 0x00008c8c:
return 0x4b4d42b2;
case 0x00008c90:
return 0xabd24e16;
case 0x00008c94:
return 0xfd8f73c5;
case 0x00008c98:
return 0xc821e101;
case 0x00008c9c:
return 0x6c7c0c5c;
case 0x00008ca0:
return 0x519098a5;
case 0x00008ca4:
return 0x223c1e7f;
case 0x00008ca8:
return 0xf63e980c;
case 0x00008cac:
return 0xd3d04e73;
case 0x00008cb0:
return 0x2d4e020e;
case 0x00008cb4:
return 0xa8b85ea5;
case 0x00008cb8:
return 0xe9e5398a;
case 0x00008cbc:
return 0x53a46e3c;
case 0x00008cc0:
return 0xf487b9b6;
case 0x00008cc4:
return 0xe9dd3de8;
case 0x00008cc8:
return 0x874db4d9;
case 0x00008ccc:
return 0xe9ad0f84;
case 0x00008cd0:
return 0x13242fce;
case 0x00008cd4:
return 0x5c8eadfc;
case 0x00008cd8:
return 0xac929c7f;
case 0x00008cdc:
return 0x060f4f37;
case 0x00008ce0:
return 0xf572a788;
case 0x00008ce4:
return 0x117da07e;
case 0x00008ce8:
return 0x1f7f5bc4;
case 0x00008cec:
return 0x80ffe79e;
case 0x00008cf0:
return 0xa0338bd3;
case 0x00008cf4:
return 0x46132c27;
case 0x00008cf8:
return 0xe3fe3cd6;
case 0x00008cfc:
return 0xfb8f4be6;
case 0x00008d00:
return 0x731c5662;
case 0x00008d04:
return 0x76d941c1;
case 0x00008d08:
return 0xe6c057f5;
case 0x00008d0c:
return 0xbecbad8c;
case 0x00008d10:
return 0xac876c01;
case 0x00008d14:
return 0xb41675f5;
case 0x00008d18:
return 0x09e9519f;
case 0x00008d1c:
return 0x370b3c2a;
case 0x00008d20:
return 0x54a75a4c;
case 0x00008d24:
return 0xcd1cab30;
case 0x00008d28:
return 0xd3d8ed25;
case 0x00008d2c:
return 0xc5874f39;
case 0x00008d30:
return 0x446192ee;
case 0x00008d34:
return 0x09476c46;
case 0x00008d38:
return 0x47bd8c6b;
case 0x00008d3c:
return 0x23f1cc18;
case 0x00008d40:
return 0xc653651f;
case 0x00008d44:
return 0x1917c65c;
case 0x00008d48:
return 0xd1339de1;
case 0x00008d4c:
return 0x6666b8a6;
case 0x00008d50:
return 0x583fde04;
case 0x00008d54:
return 0x1392a2f9;
case 0x00008d58:
return 0xc3136950;
case 0x00008d5c:
return 0x1bbbf6f6;
case 0x00008d60:
return 0x14a1f7cf;
case 0x00008d64:
return 0xf2bde85b;
case 0x00008d68:
return 0x980aae08;
case 0x00008d6c:
return 0xe0d76c52;
case 0x00008d70:
return 0x677ade5d;
case 0x00008d74:
return 0x0a4e26c0;
case 0x00008d78:
return 0xcf89ba03;
case 0x00008d7c:
return 0x30d2c86c;
case 0x00008d80:
return 0x987aa788;
case 0x00008d84:
return 0x70867eb5;
case 0x00008d88:
return 0xe39d72ed;
case 0x00008d8c:
return 0x3f13683c;
case 0x00008d90:
return 0x27c0dcee;
case 0x00008d94:
return 0xc2fc00f4;
case 0x00008d98:
return 0xc5bda2df;
case 0x00008d9c:
return 0x849b17ed;
case 0x00008da0:
return 0x526bf07a;
case 0x00008da4:
return 0x70682347;
case 0x00008da8:
return 0x157469c9;
case 0x00008dac:
return 0x6c58b1f1;
case 0x00008db0:
return 0x289084da;
case 0x00008db4:
return 0xf022659a;
case 0x00008db8:
return 0xef6a46c8;
case 0x00008dbc:
return 0xeaa2419f;
case 0x00008dc0:
return 0xd88fcdf4;
case 0x00008dc4:
return 0x467f4fd7;
case 0x00008dc8:
return 0x08ed9157;
case 0x00008dcc:
return 0x376a9a65;
case 0x00008dd0:
return 0x57dadac1;
case 0x00008dd4:
return 0xd1ad4776;
case 0x00008dd8:
return 0x7fc97a2a;
case 0x00008ddc:
return 0xa105d00e;
case 0x00008de0:
return 0x23ed6e9f;
case 0x00008de4:
return 0x6931979c;
case 0x00008de8:
return 0x96c5ad0c;
case 0x00008dec:
return 0xe6c97009;
case 0x00008df0:
return 0x7f800da0;
case 0x00008df4:
return 0x6c7d7062;
case 0x00008df8:
return 0xe9282fed;
case 0x00008dfc:
return 0x4b992932;
case 0x00008e00:
return 0xd55e2adb;
case 0x00008e04:
return 0xf770259b;
case 0x00008e08:
return 0x5f712e6d;
case 0x00008e0c:
return 0x30ac3de1;
case 0x00008e10:
return 0x9f4ab2dd;
case 0x00008e14:
return 0x8b38cc9d;
case 0x00008e18:
return 0x88439855;
case 0x00008e1c:
return 0x97eea5ef;
case 0x00008e20:
return 0x3df721bb;
case 0x00008e24:
return 0x26643ff0;
case 0x00008e28:
return 0x0201a879;
case 0x00008e2c:
return 0xa4b9d109;
case 0x00008e30:
return 0xfba78201;
case 0x00008e34:
return 0xd4b45d55;
case 0x00008e38:
return 0x73ebf260;
case 0x00008e3c:
return 0x1b45463d;
case 0x00008e40:
return 0xa5bc9aff;
case 0x00008e44:
return 0x82abf8c5;
case 0x00008e48:
return 0xe9d7868a;
case 0x00008e4c:
return 0xfc091879;
case 0x00008e50:
return 0xcf048c7c;
case 0x00008e54:
return 0xafa75c4f;
case 0x00008e58:
return 0x12c8fee5;
case 0x00008e5c:
return 0xfd914809;
case 0x00008e60:
return 0x0ecc8bb7;
case 0x00008e64:
return 0x8787cdb6;
case 0x00008e68:
return 0x76cff9f3;
case 0x00008e6c:
return 0xa05b9bae;
case 0x00008e70:
return 0xb1077a4f;
case 0x00008e74:
return 0xe586dfca;
case 0x00008e78:
return 0xa1d2d11f;
case 0x00008e7c:
return 0x66c54dca;
case 0x00008e80:
return 0x7362a966;
case 0x00008e84:
return 0xb4984d22;
case 0x00008e88:
return 0xc5533e6f;
case 0x00008e8c:
return 0x9d5dcd09;
case 0x00008e90:
return 0x16d43484;
case 0x00008e94:
return 0x3dadca3c;
case 0x00008e98:
return 0x59fc2d97;
case 0x00008e9c:
return 0x714e618e;
case 0x00008ea0:
return 0x8260f243;
case 0x00008ea4:
return 0x8b5e1d9d;
case 0x00008ea8:
return 0xdd1e398a;
case 0x00008eac:
return 0xdf39a8e9;
case 0x00008eb0:
return 0x2c154ae2;
case 0x00008eb4:
return 0x150ddcbf;
case 0x00008eb8:
return 0x5e696a7a;
case 0x00008ebc:
return 0x5a5e352c;
case 0x00008ec0:
return 0xf89b39d8;
case 0x00008ec4:
return 0x417f41bd;
case 0x00008ec8:
return 0x86e9b7db;
case 0x00008ecc:
return 0xf9a4d0f5;
case 0x00008ed0:
return 0x82268feb;
case 0x00008ed4:
return 0x82f44128;
case 0x00008ed8:
return 0x29b48b25;
case 0x00008edc:
return 0xa2870be1;
case 0x00008ee0:
return 0x55a7839f;
case 0x00008ee4:
return 0x5eee4541;
case 0x00008ee8:
return 0xf9d8fc69;
case 0x00008eec:
return 0xedc1808e;
case 0x00008ef0:
return 0x20829959;
case 0x00008ef4:
return 0x7cfad3a4;
case 0x00008ef8:
return 0x54853f53;
case 0x00008efc:
return 0xfbc5ab1c;
case 0x00008f00:
return 0x24485f15;
case 0x00008f04:
return 0x2f8a2099;
case 0x00008f08:
return 0x300c174a;
case 0x00008f0c:
return 0xa6aa96bf;
case 0x00008f10:
return 0x159825d3;
case 0x00008f14:
return 0x65438eec;
case 0x00008f18:
return 0xd290e3e8;
case 0x00008f1c:
return 0x20503ae1;
case 0x00008f20:
return 0xfdda5ad8;
case 0x00008f24:
return 0x2d50b1ba;
case 0x00008f28:
return 0xc0c7c345;
case 0x00008f2c:
return 0x6eeade57;
case 0x00008f30:
return 0x92ff17f9;
case 0x00008f34:
return 0x04d2a08e;
case 0x00008f38:
return 0x67e61092;
case 0x00008f3c:
return 0x537a470b;
case 0x00008f40:
return 0x2a2ab44c;
case 0x00008f44:
return 0x716c0890;
case 0x00008f48:
return 0x6f093d86;
case 0x00008f4c:
return 0xc661b861;
case 0x00008f50:
return 0xe8127c97;
case 0x00008f54:
return 0x9005074c;
case 0x00008f58:
return 0x4a69d964;
case 0x00008f5c:
return 0x5306d37c;
case 0x00008f60:
return 0xf80a2b12;
case 0x00008f64:
return 0x42090668;
case 0x00008f68:
return 0xa2a3a728;
case 0x00008f6c:
return 0xeb9bb6b2;
case 0x00008f70:
return 0x37958845;
case 0x00008f74:
return 0x291491e2;
case 0x00008f78:
return 0x8abfc197;
case 0x00008f7c:
return 0xaf41d1dc;
case 0x00008f80:
return 0xde79fa1f;
case 0x00008f84:
return 0xb68351ad;
case 0x00008f88:
return 0xc725d3d0;
case 0x00008f8c:
return 0xae12333a;
case 0x00008f90:
return 0xe887dec9;
case 0x00008f94:
return 0x16f8ce86;
case 0x00008f98:
return 0x5b79d371;
case 0x00008f9c:
return 0x8f282bcd;
case 0x00008fa0:
return 0x52d95ce3;
case 0x00008fa4:
return 0x2a514b2e;
case 0x00008fa8:
return 0x26380ae5;
case 0x00008fac:
return 0x8154ee4b;
case 0x00008fb0:
return 0xbcb09ee2;
case 0x00008fb4:
return 0x0482729c;
case 0x00008fb8:
return 0x9d665154;
case 0x00008fbc:
return 0x71a65a6f;
case 0x00008fc0:
return 0xfde632ae;
case 0x00008fc4:
return 0x8732ae5b;
case 0x00008fc8:
return 0xcd1c685c;
case 0x00008fcc:
return 0x11a69e14;
case 0x00008fd0:
return 0xaa79ec0f;
case 0x00008fd4:
return 0x1d8b4d00;
case 0x00008fd8:
return 0x2f49b825;
case 0x00008fdc:
return 0x5ce9ac89;
case 0x00008fe0:
return 0x718c03c4;
case 0x00008fe4:
return 0x46837ed1;
case 0x00008fe8:
return 0xc339120d;
case 0x00008fec:
return 0x38af82c0;
case 0x00008ff0:
return 0xc7a60982;
case 0x00008ff4:
return 0x7d5aaa4f;
case 0x00008ff8:
return 0x40e1a0d5;
case 0x00008ffc:
return 0xc10fad10;
case 0x00009000:
return 0x081fdfa7;
case 0x00009004:
return 0x191cd5f3;
case 0x00009008:
return 0xfff86d4f;
case 0x0000900c:
return 0x343f930a;
case 0x00009010:
return 0xf88e2fb6;
case 0x00009014:
return 0xcdcb56a8;
case 0x00009018:
return 0xac23a730;
case 0x0000901c:
return 0xe4c06469;
case 0x00009020:
return 0x319871b1;
case 0x00009024:
return 0x4907d27f;
case 0x00009028:
return 0x38de146f;
case 0x0000902c:
return 0xa9ef5ec1;
case 0x00009030:
return 0x59a37ba3;
case 0x00009034:
return 0x495aea35;
case 0x00009038:
return 0xae35efe1;
case 0x0000903c:
return 0x89207bf5;
case 0x00009040:
return 0x60425cc4;
case 0x00009044:
return 0x4a5001b2;
case 0x00009048:
return 0x44423c7e;
case 0x0000904c:
return 0x5ead8247;
case 0x00009050:
return 0x296b60bc;
case 0x00009054:
return 0x1832469f;
case 0x00009058:
return 0x57f4c1ef;
case 0x0000905c:
return 0x5366c3bb;
case 0x00009060:
return 0xbeea2036;
case 0x00009064:
return 0x3d94e277;
case 0x00009068:
return 0xa76b0ad0;
case 0x0000906c:
return 0x2bff36cb;
case 0x00009070:
return 0xcfba9945;
case 0x00009074:
return 0x9935c5b8;
case 0x00009078:
return 0xc313819a;
case 0x0000907c:
return 0x2ca02fae;
case 0x00009080:
return 0x6ee4ce8c;
case 0x00009084:
return 0x2eaf30c5;
case 0x00009088:
return 0x43c40060;
case 0x0000908c:
return 0x3bb0dd7a;
case 0x00009090:
return 0xdce732c2;
case 0x00009094:
return 0x6de55142;
case 0x00009098:
return 0x38272692;
case 0x0000909c:
return 0x54558071;
case 0x000090a0:
return 0x3d6a9d16;
case 0x000090a4:
return 0xb42c826b;
case 0x000090a8:
return 0xfb28eaa4;
case 0x000090ac:
return 0x6a0eacb2;
case 0x000090b0:
return 0x6208ba21;
case 0x000090b4:
return 0x2223c004;
case 0x000090b8:
return 0xbeb7fed8;
case 0x000090bc:
return 0x787ec804;
case 0x000090c0:
return 0x10f92494;
case 0x000090c4:
return 0x447e933a;
case 0x000090c8:
return 0xae523bd7;
case 0x000090cc:
return 0x623d511a;
case 0x000090d0:
return 0x3e803ad2;
case 0x000090d4:
return 0xfb904182;
case 0x000090d8:
return 0x6954c7bb;
case 0x000090dc:
return 0xd8c7ac77;
case 0x000090e0:
return 0xa2e22525;
case 0x000090e4:
return 0xaba48b3c;
case 0x000090e8:
return 0xd8bab007;
case 0x000090ec:
return 0xd3fd5ac6;
case 0x000090f0:
return 0xf730e9a6;
case 0x000090f4:
return 0x38da3582;
case 0x000090f8:
return 0xb0a6f50f;
case 0x000090fc:
return 0x204532fd;
case 0x00009100:
return 0x8c4474fa;
case 0x00009104:
return 0xba5c13a6;
case 0x00009108:
return 0x05543964;
case 0x0000910c:
return 0x3d6ac1dd;
case 0x00009110:
return 0xe5c60657;
case 0x00009114:
return 0xf304799c;
case 0x00009118:
return 0x800f63ba;
case 0x0000911c:
return 0x72a1bd5e;
case 0x00009120:
return 0xd27d74b5;
case 0x00009124:
return 0x7d08b794;
case 0x00009128:
return 0xc5e3ac7f;
case 0x0000912c:
return 0x00326e96;
case 0x00009130:
return 0x9ff52770;
case 0x00009134:
return 0x1fe438cf;
case 0x00009138:
return 0x4a4ab55f;
case 0x0000913c:
return 0xd22db3b2;
case 0x00009140:
return 0xa9d4f4d5;
case 0x00009144:
return 0x00517b0c;
case 0x00009148:
return 0x1721c78e;
case 0x0000914c:
return 0x0ac4f6a5;
case 0x00009150:
return 0x56f03e83;
case 0x00009154:
return 0x75ea7f94;
case 0x00009158:
return 0x0c836220;
case 0x0000915c:
return 0x1298449e;
case 0x00009160:
return 0x8aa6e098;
case 0x00009164:
return 0x6d255727;
case 0x00009168:
return 0x7714bfbb;
case 0x0000916c:
return 0x0453ff1e;
case 0x00009170:
return 0x656ccd7a;
case 0x00009174:
return 0xb0ea6ed1;
case 0x00009178:
return 0x091d108e;
case 0x0000917c:
return 0x23891c06;
case 0x00009180:
return 0x3a0c8d48;
case 0x00009184:
return 0x2764566d;
case 0x00009188:
return 0x6fc44ffb;
case 0x0000918c:
return 0x4713bc74;
case 0x00009190:
return 0x5b585864;
case 0x00009194:
return 0xa3167854;
case 0x00009198:
return 0x69a994b5;
case 0x0000919c:
return 0x989828fe;
case 0x000091a0:
return 0xb65b7f26;
case 0x000091a4:
return 0x8a09c7bf;
case 0x000091a8:
return 0x1269c186;
case 0x000091ac:
return 0xdb93494f;
case 0x000091b0:
return 0x8de4c8cc;
case 0x000091b4:
return 0x7e42c80b;
case 0x000091b8:
return 0x7182f04e;
case 0x000091bc:
return 0xeafe293e;
case 0x000091c0:
return 0x4682ad0d;
case 0x000091c4:
return 0x713b8774;
case 0x000091c8:
return 0x4a25f548;
case 0x000091cc:
return 0xb2bdc33f;
case 0x000091d0:
return 0x3ccc5490;
case 0x000091d4:
return 0x1808792f;
case 0x000091d8:
return 0x323af218;
case 0x000091dc:
return 0xca21b472;
case 0x000091e0:
return 0xeac26f79;
case 0x000091e4:
return 0x135a305c;
case 0x000091e8:
return 0x399b02ed;
case 0x000091ec:
return 0x0698d07b;
case 0x000091f0:
return 0xea5884fd;
case 0x000091f4:
return 0x6e4add4c;
case 0x000091f8:
return 0x6da1f201;
case 0x000091fc:
return 0xbefb2dee;
case 0x00009200:
return 0x9f933450;
case 0x00009204:
return 0xe9054d56;
case 0x00009208:
return 0x338cec78;
case 0x0000920c:
return 0xe2c926f5;
case 0x00009210:
return 0x8ed94d52;
case 0x00009214:
return 0xca7333c3;
case 0x00009218:
return 0xe92c8a33;
case 0x0000921c:
return 0x27c2083a;
case 0x00009220:
return 0x53d973ab;
case 0x00009224:
return 0xe11b7487;
case 0x00009228:
return 0xff2ea9f1;
case 0x0000922c:
return 0xe279944d;
case 0x00009230:
return 0x0244aa89;
case 0x00009234:
return 0x4210308c;
case 0x00009238:
return 0x81736693;
case 0x0000923c:
return 0xcb1f2fbf;
case 0x00009240:
return 0x756b7534;
case 0x00009244:
return 0x32135b59;
case 0x00009248:
return 0x40f92c61;
case 0x0000924c:
return 0xe91f50b2;
case 0x00009250:
return 0x9aef99da;
case 0x00009254:
return 0x6a4a1827;
case 0x00009258:
return 0xcab37cbd;
case 0x0000925c:
return 0x8661757f;
case 0x00009260:
return 0xcf652485;
case 0x00009264:
return 0xa7342299;
case 0x00009268:
return 0x15095f36;
case 0x0000926c:
return 0x3f8117ad;
case 0x00009270:
return 0x385998de;
case 0x00009274:
return 0x337a6bbf;
case 0x00009278:
return 0xf8e357b1;
case 0x0000927c:
return 0xe044a778;
case 0x00009280:
return 0xa841a528;
case 0x00009284:
return 0xbcd3ac35;
case 0x00009288:
return 0x06ffcb5c;
case 0x0000928c:
return 0x8cdface0;
case 0x00009290:
return 0x9ab3abb3;
case 0x00009294:
return 0x4ac9ee19;
case 0x00009298:
return 0x231e30d6;
case 0x0000929c:
return 0xed79b71e;
case 0x000092a0:
return 0xfd3b4724;
case 0x000092a4:
return 0xca1687b2;
case 0x000092a8:
return 0xafbbb9fd;
case 0x000092ac:
return 0xb806fb49;
case 0x000092b0:
return 0x54be619b;
case 0x000092b4:
return 0x597df487;
case 0x000092b8:
return 0xcfa6caa6;
case 0x000092bc:
return 0xf924b027;
case 0x000092c0:
return 0x6171aa52;
case 0x000092c4:
return 0x3bdebabd;
case 0x000092c8:
return 0x4234722d;
case 0x000092cc:
return 0x3359f199;
case 0x000092d0:
return 0x0cd7afb8;
case 0x000092d4:
return 0xd214f81a;
case 0x000092d8:
return 0x2f735e88;
case 0x000092dc:
return 0x8aa116a0;
case 0x000092e0:
return 0xbc8749de;
case 0x000092e4:
return 0xf742a2e8;
case 0x000092e8:
return 0xb140ec41;
case 0x000092ec:
return 0x7eb2c735;
case 0x000092f0:
return 0xc21391df;
case 0x000092f4:
return 0xd58a8bba;
case 0x000092f8:
return 0xd6532e36;
case 0x000092fc:
return 0xe6386ab9;
case 0x00009300:
return 0x53cbeb87;
case 0x00009304:
return 0xc38ae82e;
case 0x00009308:
return 0xbbedda0b;
case 0x0000930c:
return 0x9d5d8e09;
case 0x00009310:
return 0xa61bf7c3;
case 0x00009314:
return 0x589cc3ec;
case 0x00009318:
return 0x8b14ad03;
case 0x0000931c:
return 0x9b91085e;
case 0x00009320:
return 0xba2ebad0;
case 0x00009324:
return 0x37c1c479;
case 0x00009328:
return 0x409ad188;
case 0x0000932c:
return 0x1ff2eb3c;
case 0x00009330:
return 0x085cc85c;
case 0x00009334:
return 0x0d3f2480;
case 0x00009338:
return 0x8f323626;
case 0x0000933c:
return 0x570022c6;
case 0x00009340:
return 0x865d6548;
case 0x00009344:
return 0xc2da0498;
case 0x00009348:
return 0xa812aece;
case 0x0000934c:
return 0x89b4eaa6;
case 0x00009350:
return 0x2568e6b3;
case 0x00009354:
return 0xae5f8526;
case 0x00009358:
return 0xe388da7b;
case 0x0000935c:
return 0xe02341c9;
case 0x00009360:
return 0xea53b283;
case 0x00009364:
return 0xa1515bc1;
case 0x00009368:
return 0x28b29e45;
case 0x0000936c:
return 0xe639afce;
case 0x00009370:
return 0x5d3a9428;
case 0x00009374:
return 0xe3e7c559;
case 0x00009378:
return 0x75a870b9;
case 0x0000937c:
return 0xe9f1a0ae;
case 0x00009380:
return 0xfe126630;
case 0x00009384:
return 0xcb05716e;
case 0x00009388:
return 0xd73c70a0;
case 0x0000938c:
return 0x97399af0;
case 0x00009390:
return 0x68046daf;
case 0x00009394:
return 0x9226ee09;
case 0x00009398:
return 0x22f7853f;
case 0x0000939c:
return 0xa6575859;
case 0x000093a0:
return 0xd1c90250;
case 0x000093a4:
return 0x7741e4b1;
case 0x000093a8:
return 0xc06dd37b;
case 0x000093ac:
return 0x9c69ad07;
case 0x000093b0:
return 0xbe9d2831;
case 0x000093b4:
return 0x45b7f394;
case 0x000093b8:
return 0x7aae033b;
case 0x000093bc:
return 0x86421778;
case 0x000093c0:
return 0x9e1704da;
case 0x000093c4:
return 0x91f917c2;
case 0x000093c8:
return 0x6743d1d4;
case 0x000093cc:
return 0x4a174c02;
case 0x000093d0:
return 0xf35a53fd;
case 0x000093d4:
return 0x6cca3d13;
case 0x000093d8:
return 0xbd835a5b;
case 0x000093dc:
return 0x8ae3aac8;
case 0x000093e0:
return 0xfb77f66f;
case 0x000093e4:
return 0xd0f311b1;
case 0x000093e8:
return 0xd30b68d4;
case 0x000093ec:
return 0xfe9bfe18;
case 0x000093f0:
return 0xae306994;
case 0x000093f4:
return 0x13a08cde;
case 0x000093f8:
return 0xb85698f2;
case 0x000093fc:
return 0x2eeb47c2;
case 0x00009400:
return 0xe60b337f;
case 0x00009404:
return 0x732f1158;
case 0x00009408:
return 0xf017fdea;
case 0x0000940c:
return 0x9388c1d5;
case 0x00009410:
return 0x061aa8a7;
case 0x00009414:
return 0x737f87b1;
case 0x00009418:
return 0x322969f6;
case 0x0000941c:
return 0x11cbec67;
case 0x00009420:
return 0x6c8140ea;
case 0x00009424:
return 0xb91a0503;
case 0x00009428:
return 0x99bed360;
case 0x0000942c:
return 0xd5b975f4;
case 0x00009430:
return 0x8172680e;
case 0x00009434:
return 0xe8d5d547;
case 0x00009438:
return 0x7d313262;
case 0x0000943c:
return 0x77fb1ca2;
case 0x00009440:
return 0x17dab9b7;
case 0x00009444:
return 0x663226c3;
case 0x00009448:
return 0x8f315127;
case 0x0000944c:
return 0x353062bf;
case 0x00009450:
return 0x8112a837;
case 0x00009454:
return 0xc1833d55;
case 0x00009458:
return 0xdeeed5bf;
case 0x0000945c:
return 0x203c3be3;
case 0x00009460:
return 0x8ef963f8;
case 0x00009464:
return 0x96383ee1;
case 0x00009468:
return 0x9be1aee9;
case 0x0000946c:
return 0xbee54c7b;
case 0x00009470:
return 0x2480dbea;
case 0x00009474:
return 0x7060dd66;
case 0x00009478:
return 0x3f0b1c9f;
case 0x0000947c:
return 0x33544ec2;
case 0x00009480:
return 0x4076061b;
case 0x00009484:
return 0x4ab9819d;
case 0x00009488:
return 0x75626ae0;
case 0x0000948c:
return 0x406b05ea;
case 0x00009490:
return 0x30787219;
case 0x00009494:
return 0x44674314;
case 0x00009498:
return 0x512eb04d;
case 0x0000949c:
return 0xcaa95832;
case 0x000094a0:
return 0x1e07b9eb;
case 0x000094a4:
return 0xa0ec9fab;
case 0x000094a8:
return 0x4dcb4521;
case 0x000094ac:
return 0xd47a394b;
case 0x000094b0:
return 0x73965729;
case 0x000094b4:
return 0x786b4ed8;
case 0x000094b8:
return 0x8055357f;
case 0x000094bc:
return 0xf4b41f74;
case 0x000094c0:
return 0x7ca86281;
case 0x000094c4:
return 0x50a9bd76;
case 0x000094c8:
return 0x3f6dfa43;
case 0x000094cc:
return 0x948ae221;
case 0x000094d0:
return 0x073688c5;
case 0x000094d4:
return 0x5572d66e;
case 0x000094d8:
return 0x9e05ee5e;
case 0x000094dc:
return 0x84520b32;
case 0x000094e0:
return 0x0e29d3c0;
case 0x000094e4:
return 0xa6998dc7;
case 0x000094e8:
return 0x610093c2;
case 0x000094ec:
return 0xde8d6b08;
case 0x000094f0:
return 0x5dadf6fa;
case 0x000094f4:
return 0x4bd95438;
case 0x000094f8:
return 0x77043d61;
case 0x000094fc:
return 0x6b7e9546;
case 0x00009500:
return 0x087910ea;
case 0x00009504:
return 0xcbfdc777;
case 0x00009508:
return 0x32ad28c3;
case 0x0000950c:
return 0x0e510ff3;
case 0x00009510:
return 0x2e4ff778;
case 0x00009514:
return 0x702dbc46;
case 0x00009518:
return 0x5d8c57a0;
case 0x0000951c:
return 0x1b7f42f4;
case 0x00009520:
return 0xe034afbc;
case 0x00009524:
return 0x65b50fe5;
case 0x00009528:
return 0x99f1a4ea;
case 0x0000952c:
return 0x2fbbf76b;
case 0x00009530:
return 0x75db3672;
case 0x00009534:
return 0x8a4ccf56;
case 0x00009538:
return 0x8448a671;
case 0x0000953c:
return 0x744bc188;
case 0x00009540:
return 0x8e31cdf4;
case 0x00009544:
return 0xbb4d9ca8;
case 0x00009548:
return 0x5b15a47a;
case 0x0000954c:
return 0xcc3536ea;
case 0x00009550:
return 0xc9016544;
case 0x00009554:
return 0x1ae1a852;
case 0x00009558:
return 0xcba4b63a;
case 0x0000955c:
return 0xeb1df22a;
case 0x00009560:
return 0x59a45f68;
case 0x00009564:
return 0xee0e4018;
case 0x00009568:
return 0xfb1d0d77;
case 0x0000956c:
return 0x31fd5a7e;
case 0x00009570:
return 0x442e410e;
case 0x00009574:
return 0x877fb437;
case 0x00009578:
return 0x04962a1b;
case 0x0000957c:
return 0x1032b34c;
case 0x00009580:
return 0xdf38c87d;
case 0x00009584:
return 0x46733b03;
case 0x00009588:
return 0x03258559;
case 0x0000958c:
return 0x1ac5efd5;
case 0x00009590:
return 0xe9296dce;
case 0x00009594:
return 0x1438e4af;
case 0x00009598:
return 0x5a1030a5;
case 0x0000959c:
return 0xb837ec4a;
case 0x000095a0:
return 0xe4cda2e5;
case 0x000095a4:
return 0xace2a585;
case 0x000095a8:
return 0x832ea0d7;
case 0x000095ac:
return 0x0414f2c1;
case 0x000095b0:
return 0xf6cfe439;
case 0x000095b4:
return 0x5fb5f6ec;
case 0x000095b8:
return 0x1c48942a;
case 0x000095bc:
return 0x2e286837;
case 0x000095c0:
return 0x5c80e3e6;
case 0x000095c4:
return 0x11dc13f9;
case 0x000095c8:
return 0x23c8941d;
case 0x000095cc:
return 0x7af82120;
case 0x000095d0:
return 0x5acda64d;
case 0x000095d4:
return 0xab01cec6;
case 0x000095d8:
return 0x4a977a96;
case 0x000095dc:
return 0x13c0b359;
case 0x000095e0:
return 0x645f91d8;
case 0x000095e4:
return 0x7a7db3b2;
case 0x000095e8:
return 0xa74b0161;
case 0x000095ec:
return 0xe2b2bbcf;
case 0x000095f0:
return 0xeaa98f85;
case 0x000095f4:
return 0x70aa4cfd;
case 0x000095f8:
return 0x4cf053d9;
case 0x000095fc:
return 0x7d6ab03b;
case 0x00009600:
return 0xe63ab757;
case 0x00009604:
return 0x07e24a52;
case 0x00009608:
return 0x169859f1;
case 0x0000960c:
return 0x1aae916e;
case 0x00009610:
return 0x63769b5d;
case 0x00009614:
return 0x1fbea58d;
case 0x00009618:
return 0xce60d3d2;
case 0x0000961c:
return 0xa3b183bf;
case 0x00009620:
return 0xfc29699d;
case 0x00009624:
return 0xc706dea0;
case 0x00009628:
return 0x685381f1;
case 0x0000962c:
return 0x72f2b8f7;
case 0x00009630:
return 0x0c5bd545;
case 0x00009634:
return 0x6e6699c5;
case 0x00009638:
return 0x598d464d;
case 0x0000963c:
return 0x11c1f31b;
case 0x00009640:
return 0xa6c2c9b1;
case 0x00009644:
return 0xa4bcd4db;
case 0x00009648:
return 0x0692ecd8;
case 0x0000964c:
return 0xf61a15a9;
case 0x00009650:
return 0x6f2b037f;
case 0x00009654:
return 0xc5541ee5;
case 0x00009658:
return 0xd7b1b466;
case 0x0000965c:
return 0xec216294;
case 0x00009660:
return 0xfc2c28ea;
case 0x00009664:
return 0x90b635a6;
case 0x00009668:
return 0x83ff743c;
case 0x0000966c:
return 0x31bd7bc3;
case 0x00009670:
return 0x66f6ba79;
case 0x00009674:
return 0xf4bc076c;
case 0x00009678:
return 0xcc4b29bc;
case 0x0000967c:
return 0x08d43c6d;
case 0x00009680:
return 0x2b32c917;
case 0x00009684:
return 0xd2fcecd6;
case 0x00009688:
return 0x9cfd09c9;
case 0x0000968c:
return 0x724504c4;
case 0x00009690:
return 0xeb4809f4;
case 0x00009694:
return 0x0693c643;
case 0x00009698:
return 0xe1cd1699;
case 0x0000969c:
return 0xd9152e5e;
case 0x000096a0:
return 0xdc463f32;
case 0x000096a4:
return 0x6b28a70a;
case 0x000096a8:
return 0x0d438b0f;
case 0x000096ac:
return 0xfbdc34d3;
case 0x000096b0:
return 0x25e25fd2;
case 0x000096b4:
return 0x1a59bfc7;
case 0x000096b8:
return 0x6e34870a;
case 0x000096bc:
return 0xcecc6c72;
case 0x000096c0:
return 0xdbc47f8d;
case 0x000096c4:
return 0xb8a0bc3b;
case 0x000096c8:
return 0xfd9e7b4b;
case 0x000096cc:
return 0x0ba42f48;
case 0x000096d0:
return 0x4784bdf6;
case 0x000096d4:
return 0x80239719;
case 0x000096d8:
return 0x2e714acb;
case 0x000096dc:
return 0x65d23ea7;
case 0x000096e0:
return 0xf8263fff;
case 0x000096e4:
return 0xb82cf8da;
case 0x000096e8:
return 0xd711f748;
case 0x000096ec:
return 0xfe775e04;
case 0x000096f0:
return 0x9459dcb8;
case 0x000096f4:
return 0x21de6ef6;
case 0x000096f8:
return 0x006b00fd;
case 0x000096fc:
return 0x8de3636e;
case 0x00009700:
return 0xdc107a65;
case 0x00009704:
return 0x0c18c0b3;
case 0x00009708:
return 0x459954ac;
case 0x0000970c:
return 0xc392068a;
case 0x00009710:
return 0x097e74d0;
case 0x00009714:
return 0x83f880e9;
case 0x00009718:
return 0x90ea34b1;
case 0x0000971c:
return 0x966696d2;
case 0x00009720:
return 0xe22fd346;
case 0x00009724:
return 0xd1cc1221;
case 0x00009728:
return 0xc45ceaad;
case 0x0000972c:
return 0xaec79e04;
case 0x00009730:
return 0xb1b734ca;
case 0x00009734:
return 0x3c90e503;
case 0x00009738:
return 0xce84597b;
case 0x0000973c:
return 0x3e8dfe67;
case 0x00009740:
return 0x9f35203c;
case 0x00009744:
return 0xb4bf651a;
case 0x00009748:
return 0x721e8f8b;
case 0x0000974c:
return 0xa6791de1;
case 0x00009750:
return 0x1bf1596e;
case 0x00009754:
return 0x7be40b86;
case 0x00009758:
return 0xba78130c;
case 0x0000975c:
return 0x012929ae;
case 0x00009760:
return 0xd175f735;
case 0x00009764:
return 0xdbf8ee18;
case 0x00009768:
return 0x0692bb98;
case 0x0000976c:
return 0xc503308c;
case 0x00009770:
return 0x81bd5b53;
case 0x00009774:
return 0xd8cc9b37;
case 0x00009778:
return 0xb42d2c8b;
case 0x0000977c:
return 0x253e7c3a;
case 0x00009780:
return 0x7681bd20;
case 0x00009784:
return 0xe69be831;
case 0x00009788:
return 0xffb0ee4d;
case 0x0000978c:
return 0x76e53271;
case 0x00009790:
return 0xb24ccbc1;
case 0x00009794:
return 0x3d7c1555;
case 0x00009798:
return 0xab30dbb5;
case 0x0000979c:
return 0x9d7718bb;
case 0x000097a0:
return 0x46fee0c3;
case 0x000097a4:
return 0x0e42ed98;
case 0x000097a8:
return 0xafe0e81f;
case 0x000097ac:
return 0x3e5a6ba6;
case 0x000097b0:
return 0x005b9a3e;
case 0x000097b4:
return 0x1ddb5117;
case 0x000097b8:
return 0x0e144d0e;
case 0x000097bc:
return 0x23385e56;
case 0x000097c0:
return 0x9a8a1621;
case 0x000097c4:
return 0x5203d24d;
case 0x000097c8:
return 0xd1897c39;
case 0x000097cc:
return 0x34c79368;
case 0x000097d0:
return 0x3a2f5544;
case 0x000097d4:
return 0xefd425c7;
case 0x000097d8:
return 0x13f06937;
case 0x000097dc:
return 0x6b77dbd7;
case 0x000097e0:
return 0x6f18b1bc;
case 0x000097e4:
return 0xdd7c7828;
case 0x000097e8:
return 0x5f91240d;
case 0x000097ec:
return 0x2e20049a;
case 0x000097f0:
return 0xe21dc75d;
case 0x000097f4:
return 0xb463cb57;
case 0x000097f8:
return 0xa0f42ebf;
case 0x000097fc:
return 0x62a2f2cb;
case 0x00009800:
return 0xca853ee3;
case 0x00009804:
return 0x502f3986;
case 0x00009808:
return 0x774aea36;
case 0x0000980c:
return 0x9745b8f1;
case 0x00009810:
return 0x703f96da;
case 0x00009814:
return 0x7435aa63;
case 0x00009818:
return 0x78e2cdf4;
case 0x0000981c:
return 0xd0aa5fdf;
case 0x00009820:
return 0x786b1d1e;
case 0x00009824:
return 0x5175b9d5;
case 0x00009828:
return 0x3f8b18e9;
case 0x0000982c:
return 0x694ec022;
case 0x00009830:
return 0xe3f7babd;
case 0x00009834:
return 0x32325d94;
case 0x00009838:
return 0x92a477b5;
case 0x0000983c:
return 0x369e2ee7;
case 0x00009840:
return 0x3047fab6;
case 0x00009844:
return 0xec5f06e2;
case 0x00009848:
return 0xcba2ba05;
case 0x0000984c:
return 0xa4778139;
case 0x00009850:
return 0x3033c4e9;
case 0x00009854:
return 0x3e7be683;
case 0x00009858:
return 0xb4086d87;
case 0x0000985c:
return 0x78e194a6;
case 0x00009860:
return 0x8c63b227;
case 0x00009864:
return 0x40b5c0ad;
case 0x00009868:
return 0x0be7571b;
case 0x0000986c:
return 0xe09640f5;
case 0x00009870:
return 0x504357b1;
case 0x00009874:
return 0x66c1b78c;
case 0x00009878:
return 0x181c7581;
case 0x0000987c:
return 0x43fc5be0;
case 0x00009880:
return 0x5c26dc85;
case 0x00009884:
return 0xf52704ec;
case 0x00009888:
return 0x93bce6be;
case 0x0000988c:
return 0xb3f9cd02;
case 0x00009890:
return 0x15225a48;
case 0x00009894:
return 0x602eb252;
case 0x00009898:
return 0x4df08d79;
case 0x0000989c:
return 0x66967493;
case 0x000098a0:
return 0x020dda88;
case 0x000098a4:
return 0xe6b44b6e;
case 0x000098a8:
return 0x7bb30df3;
case 0x000098ac:
return 0x896833f2;
case 0x000098b0:
return 0xfcaeefe5;
case 0x000098b4:
return 0x90f986cc;
case 0x000098b8:
return 0x97b01874;
case 0x000098bc:
return 0x779db199;
case 0x000098c0:
return 0xe2077e6d;
case 0x000098c4:
return 0xf119a11e;
case 0x000098c8:
return 0xbfa0fed8;
case 0x000098cc:
return 0xedd535d4;
case 0x000098d0:
return 0x4831e07f;
case 0x000098d4:
return 0x1ce96cd6;
case 0x000098d8:
return 0x299d1663;
case 0x000098dc:
return 0xacb83595;
case 0x000098e0:
return 0x228a013a;
case 0x000098e4:
return 0xdbe7ef56;
case 0x000098e8:
return 0x61de5212;
case 0x000098ec:
return 0xbf621eec;
case 0x000098f0:
return 0x8e1d7526;
case 0x000098f4:
return 0xce734398;
case 0x000098f8:
return 0x81d21e40;
case 0x000098fc:
return 0x9502b1db;
case 0x00009900:
return 0x6165918c;
case 0x00009904:
return 0xf45aa3cd;
case 0x00009908:
return 0xb9fc1390;
case 0x0000990c:
return 0x35b9dc6f;
case 0x00009910:
return 0xf78f0fd2;
case 0x00009914:
return 0x52412b2d;
case 0x00009918:
return 0x7d493968;
case 0x0000991c:
return 0x79350d54;
case 0x00009920:
return 0x046ba38c;
case 0x00009924:
return 0x72228913;
case 0x00009928:
return 0x9ecc0a4c;
case 0x0000992c:
return 0xd5e8528c;
case 0x00009930:
return 0x28f9b97d;
case 0x00009934:
return 0x3bb36ee3;
case 0x00009938:
return 0xbc00c0d4;
case 0x0000993c:
return 0x1a094df2;
case 0x00009940:
return 0x9d1f6fc3;
case 0x00009944:
return 0x90427f1c;
case 0x00009948:
return 0x628127ec;
case 0x0000994c:
return 0x8f5f2b1b;
case 0x00009950:
return 0x98da8a57;
case 0x00009954:
return 0x87e6a5c6;
case 0x00009958:
return 0x7990b995;
case 0x0000995c:
return 0x133a2b37;
case 0x00009960:
return 0x70baabc6;
case 0x00009964:
return 0x0b95113b;
case 0x00009968:
return 0x99b9cef7;
case 0x0000996c:
return 0xce8813a9;
case 0x00009970:
return 0x361dbc23;
case 0x00009974:
return 0x47edbd68;
case 0x00009978:
return 0x250bafca;
case 0x0000997c:
return 0xe91478cb;
case 0x00009980:
return 0xfb81fdcb;
case 0x00009984:
return 0xc7804e24;
case 0x00009988:
return 0x8fd59a21;
case 0x0000998c:
return 0xe41ed02a;
case 0x00009990:
return 0x3e206e7a;
case 0x00009994:
return 0xe7d43388;
case 0x00009998:
return 0x6ba13c02;
case 0x0000999c:
return 0x56e14534;
case 0x000099a0:
return 0xf2e3c317;
case 0x000099a4:
return 0x572cede5;
case 0x000099a8:
return 0x85651df9;
case 0x000099ac:
return 0xe8bf7768;
case 0x000099b0:
return 0xb090c34c;
case 0x000099b4:
return 0xe10b2ff6;
case 0x000099b8:
return 0xc01bd80c;
case 0x000099bc:
return 0x4684a4ca;
case 0x000099c0:
return 0x9fb1c73a;
case 0x000099c4:
return 0xbaf7b527;
case 0x000099c8:
return 0x0ea03186;
case 0x000099cc:
return 0x820ecb2f;
case 0x000099d0:
return 0xb8587ee3;
case 0x000099d4:
return 0xc571cf31;
case 0x000099d8:
return 0x1c3197cd;
case 0x000099dc:
return 0x3d50142e;
case 0x000099e0:
return 0x0e30d3e8;
case 0x000099e4:
return 0x4324e147;
case 0x000099e8:
return 0x5579b0fc;
case 0x000099ec:
return 0x22ddff12;
case 0x000099f0:
return 0x7744e238;
case 0x000099f4:
return 0x90b73520;
case 0x000099f8:
return 0xd788ad4f;
case 0x000099fc:
return 0x5534ac3d;
case 0x00009a00:
return 0x06918a2e;
case 0x00009a04:
return 0x0a457d35;
case 0x00009a08:
return 0x48bb91ea;
case 0x00009a0c:
return 0x21731c64;
case 0x00009a10:
return 0xbc6d6b49;
case 0x00009a14:
return 0x022807ea;
case 0x00009a18:
return 0x2ac45720;
case 0x00009a1c:
return 0x3414d9e7;
case 0x00009a20:
return 0x7f9c53f8;
case 0x00009a24:
return 0xe61d69c5;
case 0x00009a28:
return 0x83860165;
case 0x00009a2c:
return 0x4df6f6fb;
case 0x00009a30:
return 0x3e2c056e;
case 0x00009a34:
return 0x6cf99e00;
case 0x00009a38:
return 0x1483f821;
case 0x00009a3c:
return 0x3db8d038;
case 0x00009a40:
return 0x3f21211f;
case 0x00009a44:
return 0x02b71283;
case 0x00009a48:
return 0x0920a803;
case 0x00009a4c:
return 0x5100a3f8;
case 0x00009a50:
return 0xf41ec18d;
case 0x00009a54:
return 0x94d2070b;
case 0x00009a58:
return 0x3e5af32f;
case 0x00009a5c:
return 0x9586c0ed;
case 0x00009a60:
return 0xb26a6e35;
case 0x00009a64:
return 0xd7299387;
case 0x00009a68:
return 0xadd0f72d;
case 0x00009a6c:
return 0x0ef2906f;
case 0x00009a70:
return 0x45040031;
case 0x00009a74:
return 0x24358a34;
case 0x00009a78:
return 0xcd3fef41;
case 0x00009a7c:
return 0x13ab2e4e;
case 0x00009a80:
return 0xb95029d4;
case 0x00009a84:
return 0xd25fec5e;
case 0x00009a88:
return 0x4c8989c3;
case 0x00009a8c:
return 0x38fa688a;
case 0x00009a90:
return 0x6ef871fe;
case 0x00009a94:
return 0xa0f3a7cf;
case 0x00009a98:
return 0xa85eedc6;
case 0x00009a9c:
return 0x6a950059;
case 0x00009aa0:
return 0x6d811d72;
case 0x00009aa4:
return 0xd5176722;
case 0x00009aa8:
return 0x2ca039ae;
case 0x00009aac:
return 0xb2211c0b;
case 0x00009ab0:
return 0xcc132196;
case 0x00009ab4:
return 0x1eb3b3c1;
case 0x00009ab8:
return 0xa5213401;
case 0x00009abc:
return 0x70b23925;
case 0x00009ac0:
return 0xddf67440;
case 0x00009ac4:
return 0xccc7784c;
case 0x00009ac8:
return 0x420bf3a6;
case 0x00009acc:
return 0xc6d8aa63;
case 0x00009ad0:
return 0xb81917de;
case 0x00009ad4:
return 0x549a8a77;
case 0x00009ad8:
return 0xd3cc5f2d;
case 0x00009adc:
return 0x761818c0;
case 0x00009ae0:
return 0x043af64f;
case 0x00009ae4:
return 0xd6e09c2a;
case 0x00009ae8:
return 0x5ab9a124;
case 0x00009aec:
return 0xedc6aa3f;
case 0x00009af0:
return 0x177ce10c;
case 0x00009af4:
return 0x6e72f3f8;
case 0x00009af8:
return 0x9f3248ea;
case 0x00009afc:
return 0x4ed3728c;
case 0x00009b00:
return 0x4a9c89a0;
case 0x00009b04:
return 0x5f93f7ec;
case 0x00009b08:
return 0x8637e86c;
case 0x00009b0c:
return 0xec688130;
case 0x00009b10:
return 0x8fff764c;
case 0x00009b14:
return 0x91cb7f88;
case 0x00009b18:
return 0x0f62a9e1;
case 0x00009b1c:
return 0x1f04679a;
case 0x00009b20:
return 0xe0e54897;
case 0x00009b24:
return 0x87cafcbb;
case 0x00009b28:
return 0xad1521ea;
case 0x00009b2c:
return 0x360b5f4a;
case 0x00009b30:
return 0x48a2a57c;
case 0x00009b34:
return 0xf611f044;
case 0x00009b38:
return 0x358e79a9;
case 0x00009b3c:
return 0xa923f77e;
case 0x00009b40:
return 0xb5b02581;
case 0x00009b44:
return 0xf9326448;
case 0x00009b48:
return 0x479cf271;
case 0x00009b4c:
return 0x7e3190c1;
case 0x00009b50:
return 0x773bea49;
case 0x00009b54:
return 0x172330a4;
case 0x00009b58:
return 0x4135e641;
case 0x00009b5c:
return 0xa746aa3d;
case 0x00009b60:
return 0x3a989b07;
case 0x00009b64:
return 0x4731e9ba;
case 0x00009b68:
return 0x877629fa;
case 0x00009b6c:
return 0x9577574c;
case 0x00009b70:
return 0xd673f2e3;
case 0x00009b74:
return 0x6213d9a3;
case 0x00009b78:
return 0xbe8dfbf6;
case 0x00009b7c:
return 0x3cdd4936;
case 0x00009b80:
return 0x90df60d2;
case 0x00009b84:
return 0x43dc722f;
case 0x00009b88:
return 0xff0482b7;
case 0x00009b8c:
return 0x6243e6fc;
case 0x00009b90:
return 0x17fd8314;
case 0x00009b94:
return 0x032ef080;
case 0x00009b98:
return 0xb366790b;
case 0x00009b9c:
return 0x0f37af55;
case 0x00009ba0:
return 0xbd183977;
case 0x00009ba4:
return 0x3ea380c4;
case 0x00009ba8:
return 0xe6227ac6;
case 0x00009bac:
return 0x7a69d6a1;
case 0x00009bb0:
return 0x11b10fea;
case 0x00009bb4:
return 0x3097977d;
case 0x00009bb8:
return 0xb1cfc2c0;
case 0x00009bbc:
return 0x81917971;
case 0x00009bc0:
return 0x7cc163cb;
case 0x00009bc4:
return 0x778ca6cd;
case 0x00009bc8:
return 0xb6332b97;
case 0x00009bcc:
return 0x9a3a629c;
case 0x00009bd0:
return 0x6a82c364;
case 0x00009bd4:
return 0x43b416ab;
case 0x00009bd8:
return 0xd56da569;
case 0x00009bdc:
return 0xa8fe80e7;
case 0x00009be0:
return 0xba4f4d37;
case 0x00009be4:
return 0x6e351095;
case 0x00009be8:
return 0x6195249b;
case 0x00009bec:
return 0x06bc4335;
case 0x00009bf0:
return 0xc02da6b9;
case 0x00009bf4:
return 0x157c8644;
case 0x00009bf8:
return 0xb7fe2e1d;
case 0x00009bfc:
return 0xc00c9cff;
case 0x00009c00:
return 0x49917ef9;
case 0x00009c04:
return 0x1e309385;
case 0x00009c08:
return 0x29d3100d;
case 0x00009c0c:
return 0xad964968;
case 0x00009c10:
return 0x6b675a7d;
case 0x00009c14:
return 0x40c1e529;
case 0x00009c18:
return 0xf77a7ac2;
case 0x00009c1c:
return 0x90f0d9b0;
case 0x00009c20:
return 0x8f84c098;
case 0x00009c24:
return 0x499e99d3;
case 0x00009c28:
return 0x4d5a39f6;
case 0x00009c2c:
return 0xf8ae3e46;
case 0x00009c30:
return 0x77eb23dc;
case 0x00009c34:
return 0xb6d620f0;
case 0x00009c38:
return 0xdf5c4a77;
case 0x00009c3c:
return 0xc40e6229;
case 0x00009c40:
return 0x216c4095;
case 0x00009c44:
return 0xff72410e;
case 0x00009c48:
return 0xed2ac64d;
case 0x00009c4c:
return 0x3d0f88cb;
case 0x00009c50:
return 0xf2c5cccc;
case 0x00009c54:
return 0xa27bd6c8;
case 0x00009c58:
return 0xd55ec25b;
case 0x00009c5c:
return 0xf1f0adbe;
case 0x00009c60:
return 0xacf9e999;
case 0x00009c64:
return 0x9053adf5;
case 0x00009c68:
return 0x6ed97df1;
case 0x00009c6c:
return 0x86421f66;
case 0x00009c70:
return 0x6876a21b;
case 0x00009c74:
return 0xfb2efbd9;
case 0x00009c78:
return 0x3cbf89b9;
case 0x00009c7c:
return 0x17fb01b0;
case 0x00009c80:
return 0xd55175c8;
case 0x00009c84:
return 0x4591ce2f;
case 0x00009c88:
return 0x2143a4c7;
case 0x00009c8c:
return 0xddcf0fe7;
case 0x00009c90:
return 0x9e9e521d;
case 0x00009c94:
return 0x5ab91583;
case 0x00009c98:
return 0xb9d89550;
case 0x00009c9c:
return 0x8fd83bab;
case 0x00009ca0:
return 0x8af7840f;
case 0x00009ca4:
return 0x8c6948b5;
case 0x00009ca8:
return 0x7a9ea139;
case 0x00009cac:
return 0x68deb03e;
case 0x00009cb0:
return 0x126c611c;
case 0x00009cb4:
return 0x81b628f2;
case 0x00009cb8:
return 0x6335e414;
case 0x00009cbc:
return 0xf73adf4b;
case 0x00009cc0:
return 0x1647ab46;
case 0x00009cc4:
return 0x29b42a4e;
case 0x00009cc8:
return 0xc1567d90;
case 0x00009ccc:
return 0x48000953;
case 0x00009cd0:
return 0x77b9867d;
case 0x00009cd4:
return 0x3874ff1b;
case 0x00009cd8:
return 0xed89323f;
case 0x00009cdc:
return 0x444f8320;
case 0x00009ce0:
return 0x65fba3b5;
case 0x00009ce4:
return 0x5c63a193;
case 0x00009ce8:
return 0xee42d616;
case 0x00009cec:
return 0x6d073e31;
case 0x00009cf0:
return 0x821fc423;
case 0x00009cf4:
return 0xa9e0f8c9;
case 0x00009cf8:
return 0x4b355c3f;
case 0x00009cfc:
return 0xd0fa2fb9;
case 0x00009d00:
return 0x9be4b8df;
case 0x00009d04:
return 0xde73e0fb;
case 0x00009d08:
return 0x8d91423f;
case 0x00009d0c:
return 0x64d0246a;
case 0x00009d10:
return 0xa10589bf;
case 0x00009d14:
return 0xa8cb8678;
case 0x00009d18:
return 0x9abd73ba;
case 0x00009d1c:
return 0x9b8d7901;
case 0x00009d20:
return 0xfb7fec77;
case 0x00009d24:
return 0xb9c7cfe6;
case 0x00009d28:
return 0xc378068c;
case 0x00009d2c:
return 0xd4fc5d93;
case 0x00009d30:
return 0x8064fe9b;
case 0x00009d34:
return 0x4d82dc55;
case 0x00009d38:
return 0x94072821;
case 0x00009d3c:
return 0x831a6ed6;
case 0x00009d40:
return 0xc9f2961d;
case 0x00009d44:
return 0x388808fb;
case 0x00009d48:
return 0x9c60f22e;
case 0x00009d4c:
return 0xaf8770b2;
case 0x00009d50:
return 0x9e30e1da;
case 0x00009d54:
return 0x8904dd66;
case 0x00009d58:
return 0x0aaa7b3e;
case 0x00009d5c:
return 0x6e17c94a;
case 0x00009d60:
return 0xe40a50f3;
case 0x00009d64:
return 0x74a6e6a5;
case 0x00009d68:
return 0xc2df1b26;
case 0x00009d6c:
return 0xc3aa3fae;
case 0x00009d70:
return 0x485efa91;
case 0x00009d74:
return 0xc9fa0472;
case 0x00009d78:
return 0xe6380827;
case 0x00009d7c:
return 0xc32d6359;
case 0x00009d80:
return 0x5aa72bcc;
case 0x00009d84:
return 0x45e1b5d3;
case 0x00009d88:
return 0xd2f3a0d5;
case 0x00009d8c:
return 0xfa4adaa5;
case 0x00009d90:
return 0x769845aa;
case 0x00009d94:
return 0xb6c11ad0;
case 0x00009d98:
return 0x1d7469b3;
case 0x00009d9c:
return 0x995d2ddf;
case 0x00009da0:
return 0x06c53a4f;
case 0x00009da4:
return 0x4efae069;
case 0x00009da8:
return 0x5ec46d67;
case 0x00009dac:
return 0xc34325ab;
case 0x00009db0:
return 0x59a49126;
case 0x00009db4:
return 0x088d5f39;
case 0x00009db8:
return 0xd75d99d3;
case 0x00009dbc:
return 0x6b8df913;
case 0x00009dc0:
return 0x3334cfef;
case 0x00009dc4:
return 0x7ecee807;
case 0x00009dc8:
return 0x54f908cb;
case 0x00009dcc:
return 0xd5d24dba;
case 0x00009dd0:
return 0x6673694a;
case 0x00009dd4:
return 0xee2cc096;
case 0x00009dd8:
return 0x2da4dc76;
case 0x00009ddc:
return 0xa42f439c;
case 0x00009de0:
return 0x30c2b312;
case 0x00009de4:
return 0xa5b776fd;
case 0x00009de8:
return 0x3b09e0c5;
case 0x00009dec:
return 0x59a35854;
case 0x00009df0:
return 0xe08e3c9a;
case 0x00009df4:
return 0x0497f1ba;
case 0x00009df8:
return 0xc9fd4bae;
case 0x00009dfc:
return 0x971b83f4;
case 0x00009e00:
return 0x03feba93;
case 0x00009e04:
return 0xff9ce2c8;
case 0x00009e08:
return 0x9a00c351;
case 0x00009e0c:
return 0x46806939;
case 0x00009e10:
return 0x77b22d14;
case 0x00009e14:
return 0x292d2dd6;
case 0x00009e18:
return 0xed02125c;
case 0x00009e1c:
return 0x4a33da3e;
case 0x00009e20:
return 0xccab5f75;
case 0x00009e24:
return 0x83cadd25;
case 0x00009e28:
return 0x0a543081;
case 0x00009e2c:
return 0x8caee953;
case 0x00009e30:
return 0x0a18881a;
case 0x00009e34:
return 0xdb4b9af5;
case 0x00009e38:
return 0x9b779c20;
case 0x00009e3c:
return 0x28214f9d;
case 0x00009e40:
return 0xc966bdd2;
case 0x00009e44:
return 0xbf344eb5;
case 0x00009e48:
return 0xdec780ff;
case 0x00009e4c:
return 0x27ff2dda;
case 0x00009e50:
return 0x6086bb43;
case 0x00009e54:
return 0xc55a4382;
case 0x00009e58:
return 0xeabc376b;
case 0x00009e5c:
return 0x2d746aaa;
case 0x00009e60:
return 0x1dfb90bf;
case 0x00009e64:
return 0xdd71861d;
case 0x00009e68:
return 0x9940a7b9;
case 0x00009e6c:
return 0x01be46c0;
case 0x00009e70:
return 0x70a51f10;
case 0x00009e74:
return 0x55d68a26;
case 0x00009e78:
return 0x59dd891c;
case 0x00009e7c:
return 0xf4ce7fd3;
case 0x00009e80:
return 0x92802f2f;
case 0x00009e84:
return 0x06c28b8a;
case 0x00009e88:
return 0x0002a273;
case 0x00009e8c:
return 0x755c05c7;
case 0x00009e90:
return 0x7a1aec18;
case 0x00009e94:
return 0x7fd24070;
case 0x00009e98:
return 0xb0821249;
case 0x00009e9c:
return 0x6d195f68;
case 0x00009ea0:
return 0x6bc1400f;
case 0x00009ea4:
return 0x7f389900;
case 0x00009ea8:
return 0xb08f4032;
case 0x00009eac:
return 0x6c8ba7f2;
case 0x00009eb0:
return 0xc099a375;
case 0x00009eb4:
return 0x8219923b;
case 0x00009eb8:
return 0x3eb974ff;
case 0x00009ebc:
return 0x0b11d920;
case 0x00009ec0:
return 0x5a428089;
case 0x00009ec4:
return 0x13f21c6b;
case 0x00009ec8:
return 0xa1db74f2;
case 0x00009ecc:
return 0x07715518;
case 0x00009ed0:
return 0xc1975590;
case 0x00009ed4:
return 0xdb126e34;
case 0x00009ed8:
return 0xc7e1ed86;
case 0x00009edc:
return 0x10ed586d;
case 0x00009ee0:
return 0xddb85c6d;
case 0x00009ee4:
return 0x0e91dcb9;
case 0x00009ee8:
return 0xa0fb80f9;
case 0x00009eec:
return 0xb3ea1366;
case 0x00009ef0:
return 0x057d24bd;
case 0x00009ef4:
return 0xcd322ecd;
case 0x00009ef8:
return 0xe2e9e024;
case 0x00009efc:
return 0x9c5d8c40;
case 0x00009f00:
return 0x2f2302c9;
case 0x00009f04:
return 0x809c253c;
case 0x00009f08:
return 0xaae413b7;
case 0x00009f0c:
return 0xd2746374;
case 0x00009f10:
return 0x5fe9d2fc;
case 0x00009f14:
return 0xa43190bf;
case 0x00009f18:
return 0x9ef64b4f;
case 0x00009f1c:
return 0x7c9d2b39;
case 0x00009f20:
return 0x5df1f665;
case 0x00009f24:
return 0x9ba4fd63;
case 0x00009f28:
return 0x534e5e9c;
case 0x00009f2c:
return 0xda355330;
case 0x00009f30:
return 0xffbbb483;
case 0x00009f34:
return 0x0ce452b4;
case 0x00009f38:
return 0x621db296;
case 0x00009f3c:
return 0x454bf59a;
case 0x00009f40:
return 0xf2d22e30;
case 0x00009f44:
return 0x125b01ee;
case 0x00009f48:
return 0xc86531a7;
case 0x00009f4c:
return 0x3cdf325c;
case 0x00009f50:
return 0x73074cca;
case 0x00009f54:
return 0xd7ddf147;
case 0x00009f58:
return 0xce9092fe;
case 0x00009f5c:
return 0x5a487431;
case 0x00009f60:
return 0xee5a0c68;
case 0x00009f64:
return 0x8d6a915b;
case 0x00009f68:
return 0xb1c678fa;
case 0x00009f6c:
return 0x03e22eb8;
case 0x00009f70:
return 0x23233240;
case 0x00009f74:
return 0x0320987f;
case 0x00009f78:
return 0x4e248ea2;
case 0x00009f7c:
return 0x1039c7d1;
case 0x00009f80:
return 0x7ce7934f;
case 0x00009f84:
return 0xe06854ef;
case 0x00009f88:
return 0xd0a1fac6;
case 0x00009f8c:
return 0x703e8286;
case 0x00009f90:
return 0xf0b54245;
case 0x00009f94:
return 0x2179543e;
case 0x00009f98:
return 0xba9a066f;
case 0x00009f9c:
return 0xea233b03;
case 0x00009fa0:
return 0x7b458af7;
case 0x00009fa4:
return 0xcda3e13d;
case 0x00009fa8:
return 0x5079f201;
case 0x00009fac:
return 0x333dce7f;
case 0x00009fb0:
return 0x469c5ad4;
case 0x00009fb4:
return 0x0174c19d;
case 0x00009fb8:
return 0x7054fc6c;
case 0x00009fbc:
return 0xa494809d;
case 0x00009fc0:
return 0xce03a9ba;
case 0x00009fc4:
return 0x888e6323;
case 0x00009fc8:
return 0x48868061;
case 0x00009fcc:
return 0x73944475;
case 0x00009fd0:
return 0x6b859582;
case 0x00009fd4:
return 0x8566af90;
case 0x00009fd8:
return 0xd5e49159;
case 0x00009fdc:
return 0x31ba724f;
case 0x00009fe0:
return 0x03855ae6;
case 0x00009fe4:
return 0x315ec1b9;
case 0x00009fe8:
return 0xf697d69e;
case 0x00009fec:
return 0x1c9b060a;
case 0x00009ff0:
return 0x930ef453;
case 0x00009ff4:
return 0x909cb28e;
case 0x00009ff8:
return 0x0ab67c2e;
case 0x00009ffc:
return 0x768589f9;
case 0x0000a000:
return 0x289c2dbf;
case 0x0000a004:
return 0x94c722cb;
case 0x0000a008:
return 0xd03b1b84;
case 0x0000a00c:
return 0x831b2579;
case 0x0000a010:
return 0x5ce60dad;
case 0x0000a014:
return 0x33d15d02;
case 0x0000a018:
return 0x5fc29ce8;
case 0x0000a01c:
return 0x21967fd8;
case 0x0000a020:
return 0x3c3ed993;
case 0x0000a024:
return 0x02b79127;
case 0x0000a028:
return 0x35027bb8;
case 0x0000a02c:
return 0x11d9fcc0;
case 0x0000a030:
return 0xb775acfd;
case 0x0000a034:
return 0x460e4d2a;
case 0x0000a038:
return 0xf00f5fc3;
case 0x0000a03c:
return 0xc165facb;
case 0x0000a040:
return 0x469ba9ec;
case 0x0000a044:
return 0x937ee6a5;
case 0x0000a048:
return 0x12378939;
case 0x0000a04c:
return 0x8d882671;
case 0x0000a050:
return 0x8044ef1b;
case 0x0000a054:
return 0xc360de10;
case 0x0000a058:
return 0x5b93ffbb;
case 0x0000a05c:
return 0xa1bfc4eb;
case 0x0000a060:
return 0x628d226e;
case 0x0000a064:
return 0x099162b6;
case 0x0000a068:
return 0xed976693;
case 0x0000a06c:
return 0x2b6cc782;
case 0x0000a070:
return 0xa7ce4b95;
case 0x0000a074:
return 0x1a5b37a6;
case 0x0000a078:
return 0x9edb8e98;
case 0x0000a07c:
return 0xc7664ad3;
case 0x0000a080:
return 0x367b2695;
case 0x0000a084:
return 0x571eb149;
case 0x0000a088:
return 0x76eebdfc;
case 0x0000a08c:
return 0x887e5ae6;
case 0x0000a090:
return 0x688ec1dc;
case 0x0000a094:
return 0x4dcb1bc3;
case 0x0000a098:
return 0x33f66f23;
case 0x0000a09c:
return 0xa538159c;
case 0x0000a0a0:
return 0xc9196005;
case 0x0000a0a4:
return 0x91c0bbe0;
case 0x0000a0a8:
return 0x449dd3fb;
case 0x0000a0ac:
return 0x3d09aa0d;
case 0x0000a0b0:
return 0x895557d8;
case 0x0000a0b4:
return 0xc8c0c679;
case 0x0000a0b8:
return 0x751d598b;
case 0x0000a0bc:
return 0xcfcbb8c7;
case 0x0000a0c0:
return 0x767be696;
case 0x0000a0c4:
return 0x02bae390;
case 0x0000a0c8:
return 0x5780affb;
case 0x0000a0cc:
return 0x4428d798;
case 0x0000a0d0:
return 0x3d7bbb0c;
case 0x0000a0d4:
return 0xc850bab4;
case 0x0000a0d8:
return 0x72d19ee6;
case 0x0000a0dc:
return 0xcf3f508a;
case 0x0000a0e0:
return 0x3714578f;
case 0x0000a0e4:
return 0x37b84291;
case 0x0000a0e8:
return 0x9fa8f9a8;
case 0x0000a0ec:
return 0xe6d0bd92;
case 0x0000a0f0:
return 0x314fe921;
case 0x0000a0f4:
return 0x51fb0798;
case 0x0000a0f8:
return 0xbd8cb0a5;
case 0x0000a0fc:
return 0xac60af65;
case 0x0000a100:
return 0xdff0e2f4;
case 0x0000a104:
return 0x5fe56c0a;
case 0x0000a108:
return 0x9afffa1c;
case 0x0000a10c:
return 0xd6d69588;
case 0x0000a110:
return 0x3e3df2f9;
case 0x0000a114:
return 0xaa4838ff;
case 0x0000a118:
return 0x81f28f77;
case 0x0000a11c:
return 0xa9d66e4d;
case 0x0000a120:
return 0xb78dccab;
case 0x0000a124:
return 0x383602d5;
case 0x0000a128:
return 0x50661d99;
case 0x0000a12c:
return 0x1b074d94;
case 0x0000a130:
return 0x778a7e8b;
case 0x0000a134:
return 0x2dfbba75;
case 0x0000a138:
return 0x3a7cf514;
case 0x0000a13c:
return 0x728e066f;
case 0x0000a140:
return 0x2c206a70;
case 0x0000a144:
return 0xfbd4cf6e;
case 0x0000a148:
return 0x316cc219;
case 0x0000a14c:
return 0x587ed6b1;
case 0x0000a150:
return 0x5dec5c3e;
case 0x0000a154:
return 0xe3f54689;
case 0x0000a158:
return 0xcc1d6844;
case 0x0000a15c:
return 0xe9d9a65f;
case 0x0000a160:
return 0x9d643afc;
case 0x0000a164:
return 0xf687ef96;
case 0x0000a168:
return 0xd279a04b;
case 0x0000a16c:
return 0xc27709cf;
case 0x0000a170:
return 0xf541066c;
case 0x0000a174:
return 0xf06ab94c;
case 0x0000a178:
return 0xb5c84300;
case 0x0000a17c:
return 0xc69ebd72;
case 0x0000a180:
return 0xcde29ef2;
case 0x0000a184:
return 0xca0dd83d;
case 0x0000a188:
return 0x8c69f034;
case 0x0000a18c:
return 0x63c77406;
case 0x0000a190:
return 0xe41a4d28;
case 0x0000a194:
return 0x4c12468d;
case 0x0000a198:
return 0xfa8bdc10;
case 0x0000a19c:
return 0x6362a9fb;
case 0x0000a1a0:
return 0xe7eaf0ba;
case 0x0000a1a4:
return 0xc556e73d;
case 0x0000a1a8:
return 0xe734f8c5;
case 0x0000a1ac:
return 0x41243fc6;
case 0x0000a1b0:
return 0x7e5506d6;
case 0x0000a1b4:
return 0x2ec536ad;
case 0x0000a1b8:
return 0xf238fe6d;
case 0x0000a1bc:
return 0x84580693;
case 0x0000a1c0:
return 0x05eb65bc;
case 0x0000a1c4:
return 0xfb902b99;
case 0x0000a1c8:
return 0xa85a2e29;
case 0x0000a1cc:
return 0x3fcad9cd;
case 0x0000a1d0:
return 0x64be8d1a;
case 0x0000a1d4:
return 0xa8e59e16;
case 0x0000a1d8:
return 0xd564ba2f;
case 0x0000a1dc:
return 0x6d0d4e31;
case 0x0000a1e0:
return 0x334d665d;
case 0x0000a1e4:
return 0x0bc8c461;
case 0x0000a1e8:
return 0x6ca4af07;
case 0x0000a1ec:
return 0x3ac6addb;
case 0x0000a1f0:
return 0x6cefdbd7;
case 0x0000a1f4:
return 0x3ce664f2;
case 0x0000a1f8:
return 0xdc7f95b7;
case 0x0000a1fc:
return 0x09d8a8f5;
case 0x0000a200:
return 0xf5c8de08;
case 0x0000a204:
return 0x44eca90e;
case 0x0000a208:
return 0xe421109f;
case 0x0000a20c:
return 0x4335b214;
case 0x0000a210:
return 0x9fee0e30;
case 0x0000a214:
return 0x8a0acc0a;
case 0x0000a218:
return 0x339b0c82;
case 0x0000a21c:
return 0x0db13f37;
case 0x0000a220:
return 0x6e88b52d;
case 0x0000a224:
return 0x782f265c;
case 0x0000a228:
return 0x8346e0e2;
case 0x0000a22c:
return 0x553314cc;
case 0x0000a230:
return 0xfae41231;
case 0x0000a234:
return 0x15e12255;
case 0x0000a238:
return 0x99ff5409;
case 0x0000a23c:
return 0x808d7535;
case 0x0000a240:
return 0xf642d37b;
case 0x0000a244:
return 0xf6c6990f;
case 0x0000a248:
return 0xcc239625;
case 0x0000a24c:
return 0x56b980cf;
case 0x0000a250:
return 0x105ea0da;
case 0x0000a254:
return 0x3d50126f;
case 0x0000a258:
return 0x9fc1caa4;
case 0x0000a25c:
return 0x4932f15b;
case 0x0000a260:
return 0x83723457;
case 0x0000a264:
return 0xec16f4db;
case 0x0000a268:
return 0x5f97e771;
case 0x0000a26c:
return 0x60fe38c4;
case 0x0000a270:
return 0x7250f87f;
case 0x0000a274:
return 0xc484264b;
case 0x0000a278:
return 0xc4be0aa9;
case 0x0000a27c:
return 0xf2f68dbb;
case 0x0000a280:
return 0x6c32be6c;
case 0x0000a284:
return 0xe6b9dcc7;
case 0x0000a288:
return 0x9ff7951f;
case 0x0000a28c:
return 0xa5089ddf;
case 0x0000a290:
return 0x31434b72;
case 0x0000a294:
return 0x05a73a6f;
case 0x0000a298:
return 0x72f06e88;
case 0x0000a29c:
return 0x1e3351ed;
case 0x0000a2a0:
return 0x96cdced1;
case 0x0000a2a4:
return 0x80b636bc;
case 0x0000a2a8:
return 0x0150da5e;
case 0x0000a2ac:
return 0x76e6a678;
case 0x0000a2b0:
return 0x2068c069;
case 0x0000a2b4:
return 0x93c50328;
case 0x0000a2b8:
return 0xc4f2285f;
case 0x0000a2bc:
return 0x70dcd294;
case 0x0000a2c0:
return 0x46a0c2ce;
case 0x0000a2c4:
return 0x956636f6;
case 0x0000a2c8:
return 0xd263c681;
case 0x0000a2cc:
return 0x9637b8f2;
case 0x0000a2d0:
return 0xa97684fb;
case 0x0000a2d4:
return 0x51a38207;
case 0x0000a2d8:
return 0xd7c8240d;
case 0x0000a2dc:
return 0x33f14409;
case 0x0000a2e0:
return 0x4fdedd7a;
case 0x0000a2e4:
return 0xc44f36ff;
case 0x0000a2e8:
return 0xab727b40;
case 0x0000a2ec:
return 0xdc3e69d8;
case 0x0000a2f0:
return 0xc682b568;
case 0x0000a2f4:
return 0x02109992;
case 0x0000a2f8:
return 0x666f74e5;
case 0x0000a2fc:
return 0xe6f779ec;
case 0x0000a300:
return 0x9652d16b;
case 0x0000a304:
return 0x54438c28;
case 0x0000a308:
return 0x795bc08c;
case 0x0000a30c:
return 0x7b5fb1db;
case 0x0000a310:
return 0x2cca2e62;
case 0x0000a314:
return 0x72d2312a;
case 0x0000a318:
return 0x060605b0;
case 0x0000a31c:
return 0xee1e03a9;
case 0x0000a320:
return 0x1311edd7;
case 0x0000a324:
return 0x4200603c;
case 0x0000a328:
return 0x4055933a;
case 0x0000a32c:
return 0x902545e0;
case 0x0000a330:
return 0xa5c35198;
case 0x0000a334:
return 0x7a394e30;
case 0x0000a338:
return 0x9bd2493b;
case 0x0000a33c:
return 0xc5185db0;
case 0x0000a340:
return 0x3a2d93c5;
case 0x0000a344:
return 0xcff4851c;
case 0x0000a348:
return 0x72f911ed;
case 0x0000a34c:
return 0xd285926a;
case 0x0000a350:
return 0x63f199db;
case 0x0000a354:
return 0x12b387d9;
case 0x0000a358:
return 0x3d4e7527;
case 0x0000a35c:
return 0x2a6bc0c9;
case 0x0000a360:
return 0x79264214;
case 0x0000a364:
return 0xad659374;
case 0x0000a368:
return 0xdca710ee;
case 0x0000a36c:
return 0x46851eb1;
case 0x0000a370:
return 0xf8baaadd;
case 0x0000a374:
return 0x98722abc;
case 0x0000a378:
return 0x68ab4ab3;
case 0x0000a37c:
return 0x9687491e;
case 0x0000a380:
return 0x4dba40fa;
case 0x0000a384:
return 0xc45980c4;
case 0x0000a388:
return 0x5c2f0b38;
case 0x0000a38c:
return 0xdc56a38f;
case 0x0000a390:
return 0xc66426c7;
case 0x0000a394:
return 0xaf6a9a12;
case 0x0000a398:
return 0x20ecc73c;
case 0x0000a39c:
return 0x84ad0ca6;
case 0x0000a3a0:
return 0xdc479bc9;
case 0x0000a3a4:
return 0x7b24e010;
case 0x0000a3a8:
return 0x458f6781;
case 0x0000a3ac:
return 0xc52c5396;
case 0x0000a3b0:
return 0x4870bab9;
case 0x0000a3b4:
return 0x484e2a62;
case 0x0000a3b8:
return 0xca576398;
case 0x0000a3bc:
return 0xe31af178;
case 0x0000a3c0:
return 0x00900683;
case 0x0000a3c4:
return 0x626cc4de;
case 0x0000a3c8:
return 0x5e1585bb;
case 0x0000a3cc:
return 0xcf0ce8d7;
case 0x0000a3d0:
return 0xb36cbd00;
case 0x0000a3d4:
return 0xf834768e;
case 0x0000a3d8:
return 0xddbd1469;
case 0x0000a3dc:
return 0xc0543f7c;
case 0x0000a3e0:
return 0x2bb10cb8;
case 0x0000a3e4:
return 0xc3d6fc64;
case 0x0000a3e8:
return 0xbca934e4;
case 0x0000a3ec:
return 0x4a24ad16;
case 0x0000a3f0:
return 0xfac0d4ab;
case 0x0000a3f4:
return 0xb5b65871;
case 0x0000a3f8:
return 0x42159137;
case 0x0000a3fc:
return 0x272cd9e0;
case 0x0000a400:
return 0xb757461d;
case 0x0000a404:
return 0x946ba6e7;
case 0x0000a408:
return 0x77a477ff;
case 0x0000a40c:
return 0xc3f58122;
case 0x0000a410:
return 0x58a4c914;
case 0x0000a414:
return 0xc75b8073;
case 0x0000a418:
return 0xad3e2946;
case 0x0000a41c:
return 0xb392c64a;
case 0x0000a420:
return 0x11b61c5f;
case 0x0000a424:
return 0x2cb0eadb;
case 0x0000a428:
return 0x177b9e4a;
case 0x0000a42c:
return 0xf442b6e9;
case 0x0000a430:
return 0xf0775537;
case 0x0000a434:
return 0xe4312f37;
case 0x0000a438:
return 0xbf064077;
case 0x0000a43c:
return 0xb530a4ec;
case 0x0000a440:
return 0xa9a2dca3;
case 0x0000a444:
return 0x0f06db06;
case 0x0000a448:
return 0xa4e4de9e;
case 0x0000a44c:
return 0x9a39dc75;
case 0x0000a450:
return 0x5cb4fff3;
case 0x0000a454:
return 0xad010bd0;
case 0x0000a458:
return 0x2bc0a8e3;
case 0x0000a45c:
return 0xb8121311;
case 0x0000a460:
return 0x1ced6643;
case 0x0000a464:
return 0x2ce03e03;
case 0x0000a468:
return 0xf2f08eaf;
case 0x0000a46c:
return 0xb5f9356c;
case 0x0000a470:
return 0x3a476291;
case 0x0000a474:
return 0x833f18bb;
case 0x0000a478:
return 0x9273ef46;
case 0x0000a47c:
return 0x14aa9f1d;
case 0x0000a480:
return 0x26c34946;
case 0x0000a484:
return 0xa5f47936;
case 0x0000a488:
return 0x2de04331;
case 0x0000a48c:
return 0xd197bde1;
case 0x0000a490:
return 0xd98383b4;
case 0x0000a494:
return 0xe21305c9;
case 0x0000a498:
return 0x96c72ae5;
case 0x0000a49c:
return 0x5f84a466;
case 0x0000a4a0:
return 0xa37059b6;
case 0x0000a4a4:
return 0x18021bae;
case 0x0000a4a8:
return 0xa2a552ab;
case 0x0000a4ac:
return 0x15792011;
case 0x0000a4b0:
return 0x0dcad133;
case 0x0000a4b4:
return 0xfe56f244;
case 0x0000a4b8:
return 0x7053066b;
case 0x0000a4bc:
return 0x39fe2022;
case 0x0000a4c0:
return 0x9657c80f;
case 0x0000a4c4:
return 0x72259b46;
case 0x0000a4c8:
return 0xf06f686f;
case 0x0000a4cc:
return 0x5da1c07b;
case 0x0000a4d0:
return 0x48cc1ab6;
case 0x0000a4d4:
return 0xb168534d;
case 0x0000a4d8:
return 0x1a3ff452;
case 0x0000a4dc:
return 0x94cd4b11;
case 0x0000a4e0:
return 0x2454b2f9;
case 0x0000a4e4:
return 0xd84c971a;
case 0x0000a4e8:
return 0x3e407fe2;
case 0x0000a4ec:
return 0x8dd501d2;
case 0x0000a4f0:
return 0xd65c91ee;
case 0x0000a4f4:
return 0xe66ea8c1;
case 0x0000a4f8:
return 0xb6530680;
case 0x0000a4fc:
return 0x30487525;
case 0x0000a500:
return 0xb294a80e;
case 0x0000a504:
return 0x75de7c57;
case 0x0000a508:
return 0x9b910f56;
case 0x0000a50c:
return 0x6cfa3c80;
case 0x0000a510:
return 0x2928233a;
case 0x0000a514:
return 0x6540359d;
case 0x0000a518:
return 0x5fb63e86;
case 0x0000a51c:
return 0xfbde9178;
case 0x0000a520:
return 0x2875a3c5;
case 0x0000a524:
return 0x00187da5;
case 0x0000a528:
return 0x1f9b50a9;
case 0x0000a52c:
return 0xd082b3b7;
case 0x0000a530:
return 0x41440894;
case 0x0000a534:
return 0x15fc4220;
case 0x0000a538:
return 0x7d4f300c;
case 0x0000a53c:
return 0xb6377095;
case 0x0000a540:
return 0x1974f39e;
case 0x0000a544:
return 0xf8fc40ca;
case 0x0000a548:
return 0x30d2510b;
case 0x0000a54c:
return 0xb6c0d511;
case 0x0000a550:
return 0x8dff73b9;
case 0x0000a554:
return 0xc01ef08a;
case 0x0000a558:
return 0x31ba75e8;
case 0x0000a55c:
return 0x51df440f;
case 0x0000a560:
return 0x3d6476be;
case 0x0000a564:
return 0x7b4b70cf;
case 0x0000a568:
return 0xd2f6dc8c;
case 0x0000a56c:
return 0xb99d5a7a;
case 0x0000a570:
return 0x0155a8b1;
case 0x0000a574:
return 0x9ed62ba2;
case 0x0000a578:
return 0xfbd225ea;
case 0x0000a57c:
return 0x2bddcdf5;
case 0x0000a580:
return 0x78d27487;
case 0x0000a584:
return 0xe00f2cb2;
case 0x0000a588:
return 0x0064b8d5;
case 0x0000a58c:
return 0x088cfa8c;
case 0x0000a590:
return 0x32b21453;
case 0x0000a594:
return 0x6a6cce6c;
case 0x0000a598:
return 0xa1702ce7;
case 0x0000a59c:
return 0x9810ce04;
case 0x0000a5a0:
return 0x45c71734;
case 0x0000a5a4:
return 0xb1596d66;
case 0x0000a5a8:
return 0x08e49dae;
case 0x0000a5ac:
return 0x47217805;
case 0x0000a5b0:
return 0x3542d888;
case 0x0000a5b4:
return 0xa840c11b;
case 0x0000a5b8:
return 0x2268d9a8;
case 0x0000a5bc:
return 0x9fee8972;
case 0x0000a5c0:
return 0x244c7a4b;
case 0x0000a5c4:
return 0xc52833b4;
case 0x0000a5c8:
return 0xa7593600;
case 0x0000a5cc:
return 0x2a0813b8;
case 0x0000a5d0:
return 0x017c8ac8;
case 0x0000a5d4:
return 0xe5716985;
case 0x0000a5d8:
return 0x8c484400;
case 0x0000a5dc:
return 0xda30717d;
case 0x0000a5e0:
return 0x9f31f908;
case 0x0000a5e4:
return 0x3eb893bb;
case 0x0000a5e8:
return 0x2061dc9a;
case 0x0000a5ec:
return 0xf59d9b86;
case 0x0000a5f0:
return 0xeda70472;
case 0x0000a5f4:
return 0x01905703;
case 0x0000a5f8:
return 0xc4446296;
case 0x0000a5fc:
return 0xa5cf06ff;
case 0x0000a600:
return 0x78afd514;
case 0x0000a604:
return 0x2197b23a;
case 0x0000a608:
return 0xd25a45eb;
case 0x0000a60c:
return 0x43e400b7;
case 0x0000a610:
return 0x9026b81c;
case 0x0000a614:
return 0xcd7ebaa1;
case 0x0000a618:
return 0xb101a2b1;
case 0x0000a61c:
return 0xb29b0108;
case 0x0000a620:
return 0xa130c0ac;
case 0x0000a624:
return 0x28542611;
case 0x0000a628:
return 0x1ab63e3f;
case 0x0000a62c:
return 0x5dfa7cc5;
case 0x0000a630:
return 0x3168090c;
case 0x0000a634:
return 0xbd5487d4;
case 0x0000a638:
return 0x28f68f7f;
case 0x0000a63c:
return 0xee59b20f;
case 0x0000a640:
return 0x6743491a;
case 0x0000a644:
return 0x50d3d529;
case 0x0000a648:
return 0x4bdcfab7;
case 0x0000a64c:
return 0x7a7053b0;
case 0x0000a650:
return 0xf24eab02;
case 0x0000a654:
return 0x9ef0da81;
case 0x0000a658:
return 0x9a822c22;
case 0x0000a65c:
return 0x385f627c;
case 0x0000a660:
return 0x9aae65b3;
case 0x0000a664:
return 0xe46d45c1;
case 0x0000a668:
return 0x383c604d;
case 0x0000a66c:
return 0x4c24a398;
case 0x0000a670:
return 0xf17adfa7;
case 0x0000a674:
return 0x5d7d5305;
case 0x0000a678:
return 0x8c6e1620;
case 0x0000a67c:
return 0x8ca24426;
case 0x0000a680:
return 0x9b6abf2c;
case 0x0000a684:
return 0x41cb2130;
case 0x0000a688:
return 0xeb800fa4;
case 0x0000a68c:
return 0x58e98829;
case 0x0000a690:
return 0xc7c4ee61;
case 0x0000a694:
return 0xb2a2e465;
case 0x0000a698:
return 0x881d9a67;
case 0x0000a69c:
return 0x302b6344;
case 0x0000a6a0:
return 0x27d677b4;
case 0x0000a6a4:
return 0xa417843a;
case 0x0000a6a8:
return 0xb7874a42;
case 0x0000a6ac:
return 0x6b0a03d5;
case 0x0000a6b0:
return 0xaa564307;
case 0x0000a6b4:
return 0xbaf69555;
case 0x0000a6b8:
return 0xe5f043bf;
case 0x0000a6bc:
return 0xc3bb0ac4;
case 0x0000a6c0:
return 0x7596c50c;
case 0x0000a6c4:
return 0xaadc6bd2;
case 0x0000a6c8:
return 0x873ac962;
case 0x0000a6cc:
return 0xbf4a54f0;
case 0x0000a6d0:
return 0xd7a8423e;
case 0x0000a6d4:
return 0x3c16e263;
case 0x0000a6d8:
return 0x41448449;
case 0x0000a6dc:
return 0x2b9ccd64;
case 0x0000a6e0:
return 0x255394d8;
case 0x0000a6e4:
return 0x379f7355;
case 0x0000a6e8:
return 0x43320854;
case 0x0000a6ec:
return 0x370540de;
case 0x0000a6f0:
return 0x81affed7;
case 0x0000a6f4:
return 0xcd437d73;
case 0x0000a6f8:
return 0x3f5c6272;
case 0x0000a6fc:
return 0x3275b6b1;
case 0x0000a700:
return 0xa8c26c99;
case 0x0000a704:
return 0xd1fc3e18;
case 0x0000a708:
return 0xceead528;
case 0x0000a70c:
return 0x0279342f;
case 0x0000a710:
return 0xf437f2c0;
case 0x0000a714:
return 0x6b011a50;
case 0x0000a718:
return 0x553bdb21;
case 0x0000a71c:
return 0xa0876e32;
case 0x0000a720:
return 0x5b9f1420;
case 0x0000a724:
return 0xa207b759;
case 0x0000a728:
return 0x0ac1bed4;
case 0x0000a72c:
return 0x21afa95b;
case 0x0000a730:
return 0xef2957db;
case 0x0000a734:
return 0x4b2cad9e;
case 0x0000a738:
return 0x46d8eda3;
case 0x0000a73c:
return 0x2b9bfe09;
case 0x0000a740:
return 0xa152f628;
case 0x0000a744:
return 0x1a53995d;
case 0x0000a748:
return 0x709eeabf;
case 0x0000a74c:
return 0xedf98f79;
case 0x0000a750:
return 0xea344d90;
case 0x0000a754:
return 0x6621b2df;
case 0x0000a758:
return 0x6a5cb080;
case 0x0000a75c:
return 0x88cba780;
case 0x0000a760:
return 0xbb61649a;
case 0x0000a764:
return 0xddf5e7d4;
case 0x0000a768:
return 0x4ead4633;
case 0x0000a76c:
return 0x2e7cfff1;
case 0x0000a770:
return 0x3f22f79b;
case 0x0000a774:
return 0x1c480959;
case 0x0000a778:
return 0x86112ad5;
case 0x0000a77c:
return 0x567a8859;
case 0x0000a780:
return 0xfa497b60;
case 0x0000a784:
return 0xaf261c1d;
case 0x0000a788:
return 0x1c0e04a3;
case 0x0000a78c:
return 0x3d694779;
case 0x0000a790:
return 0x67f0eb8e;
case 0x0000a794:
return 0x35ec8f35;
case 0x0000a798:
return 0x92734352;
case 0x0000a79c:
return 0x0faeb042;
case 0x0000a7a0:
return 0x4eee4c1b;
case 0x0000a7a4:
return 0x240ffc7c;
case 0x0000a7a8:
return 0x32c170f3;
case 0x0000a7ac:
return 0x0b448cc3;
case 0x0000a7b0:
return 0xfb39dd8d;
case 0x0000a7b4:
return 0x625db895;
case 0x0000a7b8:
return 0x332991f7;
case 0x0000a7bc:
return 0xa32d4569;
case 0x0000a7c0:
return 0x0f09c8b2;
case 0x0000a7c4:
return 0x5c18ff2a;
case 0x0000a7c8:
return 0xd5928fa9;
case 0x0000a7cc:
return 0x3a50bb0a;
case 0x0000a7d0:
return 0x290f8b17;
case 0x0000a7d4:
return 0x310ae439;
case 0x0000a7d8:
return 0x78a77228;
case 0x0000a7dc:
return 0x94be422b;
case 0x0000a7e0:
return 0xc9903a3d;
case 0x0000a7e4:
return 0x29fa8cbd;
case 0x0000a7e8:
return 0xb9cf3d48;
case 0x0000a7ec:
return 0x38037eed;
case 0x0000a7f0:
return 0x30ed2e09;
case 0x0000a7f4:
return 0x9c42cb4e;
case 0x0000a7f8:
return 0xf3fccb68;
case 0x0000a7fc:
return 0xab155b34;
case 0x0000a800:
return 0xde27c9ae;
case 0x0000a804:
return 0xe9d4955f;
case 0x0000a808:
return 0xb5e9671c;
case 0x0000a80c:
return 0xee18bb85;
case 0x0000a810:
return 0x7337bf6a;
case 0x0000a814:
return 0x1ba8dac7;
case 0x0000a818:
return 0x0708dbf1;
case 0x0000a81c:
return 0xcb3ac309;
case 0x0000a820:
return 0xc4d2c7b2;
case 0x0000a824:
return 0x1b2e8431;
case 0x0000a828:
return 0x805bbc2b;
case 0x0000a82c:
return 0x0d74db29;
case 0x0000a830:
return 0x276c638e;
case 0x0000a834:
return 0x84193001;
case 0x0000a838:
return 0xab20b0d5;
case 0x0000a83c:
return 0xb7e5396b;
case 0x0000a840:
return 0x3a290fb4;
case 0x0000a844:
return 0x9e0a18f7;
case 0x0000a848:
return 0x879b7f68;
case 0x0000a84c:
return 0xf26174e0;
case 0x0000a850:
return 0x719029c4;
case 0x0000a854:
return 0x8414aa93;
case 0x0000a858:
return 0xffd3afbc;
case 0x0000a85c:
return 0x37ab7eb1;
case 0x0000a860:
return 0x8bb4a6b5;
case 0x0000a864:
return 0x424639fb;
case 0x0000a868:
return 0x3f214426;
case 0x0000a86c:
return 0x761e111d;
case 0x0000a870:
return 0x5d698de8;
case 0x0000a874:
return 0xf023dc14;
case 0x0000a878:
return 0x65bf7e02;
case 0x0000a87c:
return 0x6e5e63af;
case 0x0000a880:
return 0xd821f9c7;
case 0x0000a884:
return 0x3f7fc1c5;
case 0x0000a888:
return 0x81f12b4a;
case 0x0000a88c:
return 0x6fd9a84e;
case 0x0000a890:
return 0x7f156011;
case 0x0000a894:
return 0xa1afd659;
case 0x0000a898:
return 0xceac56f6;
case 0x0000a89c:
return 0x7fa17037;
case 0x0000a8a0:
return 0x75afde68;
case 0x0000a8a4:
return 0xde9f8ad3;
case 0x0000a8a8:
return 0xcf7fad33;
case 0x0000a8ac:
return 0xbd5f9c65;
case 0x0000a8b0:
return 0x0b4a5a33;
case 0x0000a8b4:
return 0x06d85bd3;
case 0x0000a8b8:
return 0x2fb3f42f;
case 0x0000a8bc:
return 0x63d025ef;
case 0x0000a8c0:
return 0xafee49b4;
case 0x0000a8c4:
return 0x6b9b333c;
case 0x0000a8c8:
return 0xc08556ee;
case 0x0000a8cc:
return 0x2d88877c;
case 0x0000a8d0:
return 0xb1c425dd;
case 0x0000a8d4:
return 0xcec179b7;
case 0x0000a8d8:
return 0x83499006;
case 0x0000a8dc:
return 0xfcede918;
case 0x0000a8e0:
return 0x35f6400a;
case 0x0000a8e4:
return 0x219b74df;
case 0x0000a8e8:
return 0x8f1d0e66;
case 0x0000a8ec:
return 0x4b6f05ec;
case 0x0000a8f0:
return 0x31726961;
case 0x0000a8f4:
return 0xb3564094;
case 0x0000a8f8:
return 0x410e7376;
case 0x0000a8fc:
return 0xf12299c1;
case 0x0000a900:
return 0x21692111;
case 0x0000a904:
return 0x3fc2549c;
case 0x0000a908:
return 0x5ef5d978;
case 0x0000a90c:
return 0xbca2980a;
case 0x0000a910:
return 0x8633bb03;
case 0x0000a914:
return 0xb77b8a77;
case 0x0000a918:
return 0x0a2af428;
case 0x0000a91c:
return 0x970ffc75;
case 0x0000a920:
return 0x16603eed;
case 0x0000a924:
return 0xe2180d4a;
case 0x0000a928:
return 0x9de5965b;
case 0x0000a92c:
return 0x82a98ed9;
case 0x0000a930:
return 0x258cfb9f;
case 0x0000a934:
return 0x76837093;
case 0x0000a938:
return 0xa02edd9a;
case 0x0000a93c:
return 0x676ba146;
case 0x0000a940:
return 0xc4d3f8c3;
case 0x0000a944:
return 0xa99b3e0a;
case 0x0000a948:
return 0x59a51977;
case 0x0000a94c:
return 0xe237da50;
case 0x0000a950:
return 0x53279356;
case 0x0000a954:
return 0x260a7051;
case 0x0000a958:
return 0xdb669431;
case 0x0000a95c:
return 0x2e41a1cd;
case 0x0000a960:
return 0xd7fd5f56;
case 0x0000a964:
return 0x4e02ab80;
case 0x0000a968:
return 0xec4f0a11;
case 0x0000a96c:
return 0xea933514;
case 0x0000a970:
return 0x6f7481b4;
case 0x0000a974:
return 0x8ebcfdd9;
case 0x0000a978:
return 0xc5fd3f8e;
case 0x0000a97c:
return 0x6fa902e6;
case 0x0000a980:
return 0xff8ca0e0;
case 0x0000a984:
return 0xd7cd7b8c;
case 0x0000a988:
return 0x48cb35a4;
case 0x0000a98c:
return 0x6f2cecc2;
case 0x0000a990:
return 0x046ba9b9;
case 0x0000a994:
return 0x5f510d59;
case 0x0000a998:
return 0xdd3c1ba0;
case 0x0000a99c:
return 0xcd595f97;
case 0x0000a9a0:
return 0x5e707acb;
case 0x0000a9a4:
return 0x30815e6f;
case 0x0000a9a8:
return 0x0a125429;
case 0x0000a9ac:
return 0x7bf94593;
case 0x0000a9b0:
return 0xde3c351b;
case 0x0000a9b4:
return 0x9ff63a6f;
case 0x0000a9b8:
return 0xd80fb5f0;
case 0x0000a9bc:
return 0x1b9e2467;
case 0x0000a9c0:
return 0x9dfc4f6d;
case 0x0000a9c4:
return 0xa7aa0134;
case 0x0000a9c8:
return 0x3451f371;
case 0x0000a9cc:
return 0xf543132a;
case 0x0000a9d0:
return 0xb630b535;
case 0x0000a9d4:
return 0x24d340e0;
case 0x0000a9d8:
return 0xa99655e0;
case 0x0000a9dc:
return 0xac9471b7;
case 0x0000a9e0:
return 0x8d0f435c;
case 0x0000a9e4:
return 0x1c253948;
case 0x0000a9e8:
return 0x732b06b0;
case 0x0000a9ec:
return 0xec0ac5b2;
case 0x0000a9f0:
return 0x6c35e053;
case 0x0000a9f4:
return 0x0d96c49a;
case 0x0000a9f8:
return 0x879f5982;
case 0x0000a9fc:
return 0xb368d56d;
case 0x0000aa00:
return 0x1ce93c3d;
case 0x0000aa04:
return 0xc0bc7316;
case 0x0000aa08:
return 0xc15a3f00;
case 0x0000aa0c:
return 0x94e80462;
case 0x0000aa10:
return 0x3a523701;
case 0x0000aa14:
return 0xf85abfd0;
case 0x0000aa18:
return 0xfeee857d;
case 0x0000aa1c:
return 0x5abf6c93;
case 0x0000aa20:
return 0x843a8643;
case 0x0000aa24:
return 0xa91724b8;
case 0x0000aa28:
return 0x09d0f192;
case 0x0000aa2c:
return 0x711a022c;
case 0x0000aa30:
return 0x582f4989;
case 0x0000aa34:
return 0x019eb3f2;
case 0x0000aa38:
return 0x3ccae04f;
case 0x0000aa3c:
return 0x24d2deb1;
case 0x0000aa40:
return 0x0f1a1565;
case 0x0000aa44:
return 0xfd21b454;
case 0x0000aa48:
return 0x14d185d5;
case 0x0000aa4c:
return 0xfa81f8d3;
case 0x0000aa50:
return 0x72a8ac6e;
case 0x0000aa54:
return 0x45468b9a;
case 0x0000aa58:
return 0x2d022532;
case 0x0000aa5c:
return 0x458c6264;
case 0x0000aa60:
return 0x1fb6b87c;
case 0x0000aa64:
return 0xa91f155a;
case 0x0000aa68:
return 0xa2977619;
case 0x0000aa6c:
return 0x1c92e8a8;
case 0x0000aa70:
return 0xf8b20403;
case 0x0000aa74:
return 0x9130856f;
case 0x0000aa78:
return 0x175567ad;
case 0x0000aa7c:
return 0x4f474be9;
case 0x0000aa80:
return 0x6980715f;
case 0x0000aa84:
return 0xd8524df7;
case 0x0000aa88:
return 0x0c134c8f;
case 0x0000aa8c:
return 0xbdc2e937;
case 0x0000aa90:
return 0x1274ad44;
case 0x0000aa94:
return 0xb272df66;
case 0x0000aa98:
return 0xe0f4ed46;
case 0x0000aa9c:
return 0xfa261fba;
case 0x0000aaa0:
return 0x4e10c308;
case 0x0000aaa4:
return 0xc63ba5b2;
case 0x0000aaa8:
return 0xb8dfe46f;
case 0x0000aaac:
return 0x26e668e4;
case 0x0000aab0:
return 0x60970250;
case 0x0000aab4:
return 0x8cc40050;
case 0x0000aab8:
return 0x3c4cecf9;
case 0x0000aabc:
return 0xdac1c7cc;
case 0x0000aac0:
return 0x02d7d6cd;
case 0x0000aac4:
return 0x0cc06128;
case 0x0000aac8:
return 0x8fa1396f;
case 0x0000aacc:
return 0x3012d81c;
case 0x0000aad0:
return 0x63015dda;
case 0x0000aad4:
return 0x8254db40;
case 0x0000aad8:
return 0xfb40d930;
case 0x0000aadc:
return 0xe2902f60;
case 0x0000aae0:
return 0x55b69c30;
case 0x0000aae4:
return 0x7c0aaac5;
case 0x0000aae8:
return 0x61185e2d;
case 0x0000aaec:
return 0x873092e8;
case 0x0000aaf0:
return 0x56e53541;
case 0x0000aaf4:
return 0x27604293;
case 0x0000aaf8:
return 0x3c7fbacb;
case 0x0000aafc:
return 0x7aadeefd;
case 0x0000ab00:
return 0xcb708c67;
case 0x0000ab04:
return 0x4126c960;
case 0x0000ab08:
return 0x3f617797;
case 0x0000ab0c:
return 0x7f971733;
case 0x0000ab10:
return 0x369111b7;
case 0x0000ab14:
return 0x037522a3;
case 0x0000ab18:
return 0xa282a818;
case 0x0000ab1c:
return 0xf075b7be;
case 0x0000ab20:
return 0xdc6be1aa;
case 0x0000ab24:
return 0x1232c872;
case 0x0000ab28:
return 0x4954bf64;
case 0x0000ab2c:
return 0x33e92f3e;
case 0x0000ab30:
return 0xab914c58;
case 0x0000ab34:
return 0xf15a60f4;
case 0x0000ab38:
return 0xcf703fa3;
case 0x0000ab3c:
return 0x22a3a328;
case 0x0000ab40:
return 0x08eff904;
case 0x0000ab44:
return 0xcb0ef234;
case 0x0000ab48:
return 0x08946641;
case 0x0000ab4c:
return 0x6ed2c73c;
case 0x0000ab50:
return 0x3b2afb38;
case 0x0000ab54:
return 0x1feb54b1;
case 0x0000ab58:
return 0x85842dde;
case 0x0000ab5c:
return 0xd76e5ba9;
case 0x0000ab60:
return 0xf871fbdd;
case 0x0000ab64:
return 0xc87b8afe;
case 0x0000ab68:
return 0x95f06b23;
case 0x0000ab6c:
return 0x03639402;
case 0x0000ab70:
return 0x955e9512;
case 0x0000ab74:
return 0xee5badc1;
case 0x0000ab78:
return 0xe01de997;
case 0x0000ab7c:
return 0x91093019;
case 0x0000ab80:
return 0x4d7b9c4c;
case 0x0000ab84:
return 0xd582c7ce;
case 0x0000ab88:
return 0xb7d821e2;
case 0x0000ab8c:
return 0x0682badd;
case 0x0000ab90:
return 0x29ca71e9;
case 0x0000ab94:
return 0xb7306e60;
case 0x0000ab98:
return 0xc517e8f2;
case 0x0000ab9c:
return 0x56fb2c28;
case 0x0000aba0:
return 0x19049a55;
case 0x0000aba4:
return 0xe2109194;
case 0x0000aba8:
return 0xa1c77e35;
case 0x0000abac:
return 0x2e144bbf;
case 0x0000abb0:
return 0x0b4305c8;
case 0x0000abb4:
return 0x66572d67;
case 0x0000abb8:
return 0xd05bc784;
case 0x0000abbc:
return 0x9504b44c;
case 0x0000abc0:
return 0x94b3a0f6;
case 0x0000abc4:
return 0x4925ab33;
case 0x0000abc8:
return 0xb8c2a0cc;
case 0x0000abcc:
return 0x7d9a3d11;
case 0x0000abd0:
return 0x0e9dfb6f;
case 0x0000abd4:
return 0x7ae1bd33;
case 0x0000abd8:
return 0x7cb6855b;
case 0x0000abdc:
return 0x03a2d174;
case 0x0000abe0:
return 0x91e85a9a;
case 0x0000abe4:
return 0xc1948641;
case 0x0000abe8:
return 0x327c93bf;
case 0x0000abec:
return 0xb1c4cd10;
case 0x0000abf0:
return 0x0f8bf91f;
case 0x0000abf4:
return 0x2564f176;
case 0x0000abf8:
return 0x01367d3d;
case 0x0000abfc:
return 0x645ed0f1;
case 0x0000ac00:
return 0x110f1827;
case 0x0000ac04:
return 0xcf098694;
case 0x0000ac08:
return 0x94b5d5b8;
case 0x0000ac0c:
return 0xa2aca7ca;
case 0x0000ac10:
return 0x59da0b78;
case 0x0000ac14:
return 0x36bd9f1d;
case 0x0000ac18:
return 0x3040f188;
case 0x0000ac1c:
return 0x7db7b488;
case 0x0000ac20:
return 0x7973a4de;
case 0x0000ac24:
return 0xf75b31fa;
case 0x0000ac28:
return 0x25aa0178;
case 0x0000ac2c:
return 0xc2416292;
case 0x0000ac30:
return 0x37e9bcb2;
case 0x0000ac34:
return 0x7b8eb91b;
case 0x0000ac38:
return 0x75f51b2b;
case 0x0000ac3c:
return 0x76b7de00;
case 0x0000ac40:
return 0x12a1948e;
case 0x0000ac44:
return 0x4f590d04;
case 0x0000ac48:
return 0xbf79dd29;
case 0x0000ac4c:
return 0x02c11f57;
case 0x0000ac50:
return 0x4dd21fe2;
case 0x0000ac54:
return 0x5ef9a544;
case 0x0000ac58:
return 0xef36a014;
case 0x0000ac5c:
return 0x5510268f;
case 0x0000ac60:
return 0x304be38a;
case 0x0000ac64:
return 0x794fdc19;
case 0x0000ac68:
return 0xfd338ef9;
case 0x0000ac6c:
return 0x6d9a72a8;
case 0x0000ac70:
return 0x5fdcfaa0;
case 0x0000ac74:
return 0xefd3d8c8;
case 0x0000ac78:
return 0x89d00a1c;
case 0x0000ac7c:
return 0xd4e847b5;
case 0x0000ac80:
return 0xdf735bae;
case 0x0000ac84:
return 0x909ec947;
case 0x0000ac88:
return 0xdd652f0f;
case 0x0000ac8c:
return 0x8918be00;
case 0x0000ac90:
return 0x177b8e56;
case 0x0000ac94:
return 0x9c04a157;
case 0x0000ac98:
return 0xf2f0aeaf;
case 0x0000ac9c:
return 0x536ef870;
case 0x0000aca0:
return 0x97b79f10;
case 0x0000aca4:
return 0x03175ee0;
case 0x0000aca8:
return 0xbde0cdc4;
case 0x0000acac:
return 0x553a9c5d;
case 0x0000acb0:
return 0x6ac88110;
case 0x0000acb4:
return 0x5f900596;
case 0x0000acb8:
return 0xd75b9380;
case 0x0000acbc:
return 0x815ad196;
case 0x0000acc0:
return 0x9fb7e8ac;
case 0x0000acc4:
return 0xa73265ec;
case 0x0000acc8:
return 0x9504b4ca;
case 0x0000accc:
return 0xd6cccf21;
case 0x0000acd0:
return 0x79703944;
case 0x0000acd4:
return 0xafaff1c0;
case 0x0000acd8:
return 0x83c2bebd;
case 0x0000acdc:
return 0x9440592e;
case 0x0000ace0:
return 0xf83ae0cf;
case 0x0000ace4:
return 0x474ecb3f;
case 0x0000ace8:
return 0x22f94d7d;
case 0x0000acec:
return 0xfc676822;
case 0x0000acf0:
return 0xee7eb64b;
case 0x0000acf4:
return 0x9772f8dc;
case 0x0000acf8:
return 0x61e97766;
case 0x0000acfc:
return 0xd8a02a5a;
case 0x0000ad00:
return 0x51eef7dc;
case 0x0000ad04:
return 0x237bcf53;
case 0x0000ad08:
return 0x6355a123;
case 0x0000ad0c:
return 0x3d3724b0;
case 0x0000ad10:
return 0x8b241d73;
case 0x0000ad14:
return 0x24ded24b;
case 0x0000ad18:
return 0x41c77562;
case 0x0000ad1c:
return 0xf8738a52;
case 0x0000ad20:
return 0x5dc4c645;
case 0x0000ad24:
return 0x8580870c;
case 0x0000ad28:
return 0x83176bb7;
case 0x0000ad2c:
return 0x26b54914;
case 0x0000ad30:
return 0x7e55b69c;
case 0x0000ad34:
return 0x925fb71b;
case 0x0000ad38:
return 0x45c314ea;
case 0x0000ad3c:
return 0x5c5abc5a;
case 0x0000ad40:
return 0xf013ba24;
case 0x0000ad44:
return 0xb4e551f2;
case 0x0000ad48:
return 0xf39f158f;
case 0x0000ad4c:
return 0x30382147;
case 0x0000ad50:
return 0xb3436a08;
case 0x0000ad54:
return 0x1ee9744e;
case 0x0000ad58:
return 0xa24e21e6;
case 0x0000ad5c:
return 0xc44220d7;
case 0x0000ad60:
return 0xb228639f;
case 0x0000ad64:
return 0x259cf08c;
case 0x0000ad68:
return 0xcef30609;
case 0x0000ad6c:
return 0x1529bfc1;
case 0x0000ad70:
return 0xabdb630d;
case 0x0000ad74:
return 0x77d021e8;
case 0x0000ad78:
return 0xeaf687e3;
case 0x0000ad7c:
return 0x57b04d75;
case 0x0000ad80:
return 0xef85165a;
case 0x0000ad84:
return 0xa5709c52;
case 0x0000ad88:
return 0x65bfac81;
case 0x0000ad8c:
return 0xdd81d8b2;
case 0x0000ad90:
return 0xd532d18a;
case 0x0000ad94:
return 0xdd4ef6f3;
case 0x0000ad98:
return 0x0e56b54e;
case 0x0000ad9c:
return 0x71fdea35;
case 0x0000ada0:
return 0x92d30771;
case 0x0000ada4:
return 0x52f63aff;
case 0x0000ada8:
return 0xf010c050;
case 0x0000adac:
return 0x44c48456;
case 0x0000adb0:
return 0x44bb492c;
case 0x0000adb4:
return 0xb056aee2;
case 0x0000adb8:
return 0x3d2adb4e;
case 0x0000adbc:
return 0xd5a55302;
case 0x0000adc0:
return 0x29cde3fd;
case 0x0000adc4:
return 0x2dc1b281;
case 0x0000adc8:
return 0x84e33795;
case 0x0000adcc:
return 0x7ec4038f;
case 0x0000add0:
return 0x50e2ac7f;
case 0x0000add4:
return 0x1dbee6b1;
case 0x0000add8:
return 0x8368af6f;
case 0x0000addc:
return 0x16901703;
case 0x0000ade0:
return 0xb3bd0eca;
case 0x0000ade4:
return 0x3d2bf1d5;
case 0x0000ade8:
return 0x0cf7ee3c;
case 0x0000adec:
return 0x5a571c66;
case 0x0000adf0:
return 0xcfd4b05c;
case 0x0000adf4:
return 0x711d7ecc;
case 0x0000adf8:
return 0x0d12bf27;
case 0x0000adfc:
return 0x72b2d7e5;
case 0x0000ae00:
return 0xe6972698;
case 0x0000ae04:
return 0xf0bc55d5;
case 0x0000ae08:
return 0xb35d6dc2;
case 0x0000ae0c:
return 0x8bc6d98b;
case 0x0000ae10:
return 0xd445502a;
case 0x0000ae14:
return 0x8124c14d;
case 0x0000ae18:
return 0xc0d56fa8;
case 0x0000ae1c:
return 0x012fc256;
case 0x0000ae20:
return 0x48449573;
case 0x0000ae24:
return 0x012a4eba;
case 0x0000ae28:
return 0x79d8ca88;
case 0x0000ae2c:
return 0x42817fb0;
case 0x0000ae30:
return 0x372c7e64;
case 0x0000ae34:
return 0x42285c52;
case 0x0000ae38:
return 0x0184681b;
case 0x0000ae3c:
return 0x8a4cffac;
case 0x0000ae40:
return 0x46cfbcf5;
case 0x0000ae44:
return 0x002ae833;
case 0x0000ae48:
return 0x2be4e0c8;
case 0x0000ae4c:
return 0xe6a9b256;
case 0x0000ae50:
return 0x397af83e;
case 0x0000ae54:
return 0x1a7420d4;
case 0x0000ae58:
return 0x638bda7b;
case 0x0000ae5c:
return 0x6f8b66db;
case 0x0000ae60:
return 0x76b197de;
case 0x0000ae64:
return 0xa663d16d;
case 0x0000ae68:
return 0x28e5b331;
case 0x0000ae6c:
return 0x7849b6e2;
case 0x0000ae70:
return 0xa9dc8b7e;
case 0x0000ae74:
return 0x34be9b63;
case 0x0000ae78:
return 0x3098680b;
case 0x0000ae7c:
return 0x63c2739b;
case 0x0000ae80:
return 0xad2cc157;
case 0x0000ae84:
return 0x9bacc06b;
case 0x0000ae88:
return 0xf27e6103;
case 0x0000ae8c:
return 0xb5f4b24e;
case 0x0000ae90:
return 0x852590ad;
case 0x0000ae94:
return 0x5a90344d;
case 0x0000ae98:
return 0xb5910e7f;
case 0x0000ae9c:
return 0xde8eefe6;
case 0x0000aea0:
return 0x0b2fd94d;
case 0x0000aea4:
return 0x08d972be;
case 0x0000aea8:
return 0x3cc06b7d;
case 0x0000aeac:
return 0xc461e687;
case 0x0000aeb0:
return 0xd09a3cca;
case 0x0000aeb4:
return 0x7a77b796;
case 0x0000aeb8:
return 0x333e5d9d;
case 0x0000aebc:
return 0xba3da8ae;
case 0x0000aec0:
return 0xe63f3f1f;
case 0x0000aec4:
return 0x789f88d5;
case 0x0000aec8:
return 0x7cce8dd1;
case 0x0000aecc:
return 0xfb678438;
case 0x0000aed0:
return 0xf60348be;
case 0x0000aed4:
return 0x96eabc37;
case 0x0000aed8:
return 0x9be61ed6;
case 0x0000aedc:
return 0xb0710077;
case 0x0000aee0:
return 0x45cd8957;
case 0x0000aee4:
return 0x2082d8b3;
case 0x0000aee8:
return 0xd0b2e53f;
case 0x0000aeec:
return 0xbe8ad37a;
case 0x0000aef0:
return 0x92a7c8ba;
case 0x0000aef4:
return 0x9d3369a9;
case 0x0000aef8:
return 0x1394a00c;
case 0x0000aefc:
return 0x7b30df84;
case 0x0000af00:
return 0x814232a6;
case 0x0000af04:
return 0x12c34e0e;
case 0x0000af08:
return 0x3348ff5c;
case 0x0000af0c:
return 0xbe85fdb0;
case 0x0000af10:
return 0x301d8b10;
case 0x0000af14:
return 0xc84deb61;
case 0x0000af18:
return 0xdbf2f979;
case 0x0000af1c:
return 0x8c4a095b;
case 0x0000af20:
return 0xd496a89d;
case 0x0000af24:
return 0xc322251c;
case 0x0000af28:
return 0x2c6252b9;
case 0x0000af2c:
return 0x8e7bdf1f;
case 0x0000af30:
return 0x2cde4f52;
case 0x0000af34:
return 0xcfaa7c46;
case 0x0000af38:
return 0xd60be9c0;
case 0x0000af3c:
return 0xf46d5031;
case 0x0000af40:
return 0x66a9b5c9;
case 0x0000af44:
return 0xbb40ac64;
case 0x0000af48:
return 0x849fbf82;
case 0x0000af4c:
return 0x724b3b27;
case 0x0000af50:
return 0x713d30fd;
case 0x0000af54:
return 0xb44f6a3f;
case 0x0000af58:
return 0xbaae1f3e;
case 0x0000af5c:
return 0xedc81234;
case 0x0000af60:
return 0x8a3893c2;
case 0x0000af64:
return 0x4f33ab2b;
case 0x0000af68:
return 0x29e5e69a;
case 0x0000af6c:
return 0x32257d8d;
case 0x0000af70:
return 0x30a73d54;
case 0x0000af74:
return 0x4b964acd;
case 0x0000af78:
return 0xc16d00b7;
case 0x0000af7c:
return 0x156fbc21;
case 0x0000af80:
return 0x89a0d04f;
case 0x0000af84:
return 0x1b015c18;
case 0x0000af88:
return 0xa9726d04;
case 0x0000af8c:
return 0x2004609e;
case 0x0000af90:
return 0x85eb1abe;
case 0x0000af94:
return 0x456a7912;
case 0x0000af98:
return 0x1a352034;
case 0x0000af9c:
return 0x731e211b;
case 0x0000afa0:
return 0x63572e70;
case 0x0000afa4:
return 0xcb20c920;
case 0x0000afa8:
return 0xd00fb59b;
case 0x0000afac:
return 0x8f18721e;
case 0x0000afb0:
return 0x48b77b8a;
case 0x0000afb4:
return 0x9bdaf8b9;
case 0x0000afb8:
return 0x47cc1db1;
case 0x0000afbc:
return 0xca402a3a;
case 0x0000afc0:
return 0xb8fa5283;
case 0x0000afc4:
return 0x2241d9d9;
case 0x0000afc8:
return 0x3c3dee9a;
case 0x0000afcc:
return 0x954d40be;
case 0x0000afd0:
return 0xfd850826;
case 0x0000afd4:
return 0x3f096a2e;
case 0x0000afd8:
return 0x93aadac1;
case 0x0000afdc:
return 0xe41a0cbd;
case 0x0000afe0:
return 0xa7a42a84;
case 0x0000afe4:
return 0x529631fb;
case 0x0000afe8:
return 0x71182806;
case 0x0000afec:
return 0x1da05bdf;
case 0x0000aff0:
return 0x9765c0ff;
case 0x0000aff4:
return 0x892edc53;
case 0x0000aff8:
return 0x43023e18;
case 0x0000affc:
return 0xd4a88834;
case 0x0000b000:
return 0x326b0165;
case 0x0000b004:
return 0xb46e9a82;
case 0x0000b008:
return 0x8ae65032;
case 0x0000b00c:
return 0xadf3e719;
case 0x0000b010:
return 0x2ef47567;
case 0x0000b014:
return 0x2f887786;
case 0x0000b018:
return 0x6a4ccccd;
case 0x0000b01c:
return 0x96a41b2e;
case 0x0000b020:
return 0x0446cabc;
case 0x0000b024:
return 0xe28b659f;
case 0x0000b028:
return 0x587c8d64;
case 0x0000b02c:
return 0x821c828d;
case 0x0000b030:
return 0xaf060408;
case 0x0000b034:
return 0x68148d1b;
case 0x0000b038:
return 0x9a97dc38;
case 0x0000b03c:
return 0xab8de2d8;
case 0x0000b040:
return 0x4bb8a254;
case 0x0000b044:
return 0x4aecf49d;
case 0x0000b048:
return 0x306e1ec0;
case 0x0000b04c:
return 0xc9c95336;
case 0x0000b050:
return 0x7c86181a;
case 0x0000b054:
return 0x8ecf2f7a;
case 0x0000b058:
return 0x6aa6e0a4;
case 0x0000b05c:
return 0xb779a504;
case 0x0000b060:
return 0x4bd98082;
case 0x0000b064:
return 0x3db47759;
case 0x0000b068:
return 0xa450c8bc;
case 0x0000b06c:
return 0x4b40b16b;
case 0x0000b070:
return 0xb5f3d0b2;
case 0x0000b074:
return 0x5de9830f;
case 0x0000b078:
return 0x24d882f5;
case 0x0000b07c:
return 0x08288964;
case 0x0000b080:
return 0x2017dfaa;
case 0x0000b084:
return 0x5fd77efb;
case 0x0000b088:
return 0x15427257;
case 0x0000b08c:
return 0x8d0e2dbb;
case 0x0000b090:
return 0x92944358;
case 0x0000b094:
return 0x2471c420;
case 0x0000b098:
return 0xb285898d;
case 0x0000b09c:
return 0x104c7f70;
case 0x0000b0a0:
return 0x8cc2122a;
case 0x0000b0a4:
return 0x4805aa13;
case 0x0000b0a8:
return 0x28dcdf25;
case 0x0000b0ac:
return 0xe19c6516;
case 0x0000b0b0:
return 0xbc119912;
case 0x0000b0b4:
return 0xdf7fc31f;
case 0x0000b0b8:
return 0xb5d73839;
case 0x0000b0bc:
return 0x1b083d40;
case 0x0000b0c0:
return 0x6d93e14a;
case 0x0000b0c4:
return 0xd5c88acb;
case 0x0000b0c8:
return 0x0bee7db5;
case 0x0000b0cc:
return 0xcdd4ae34;
case 0x0000b0d0:
return 0xeef12de3;
case 0x0000b0d4:
return 0x0605eae8;
case 0x0000b0d8:
return 0x7c973774;
case 0x0000b0dc:
return 0xcdf05c16;
case 0x0000b0e0:
return 0xb0649fb6;
case 0x0000b0e4:
return 0x5471d71b;
case 0x0000b0e8:
return 0x7295386c;
case 0x0000b0ec:
return 0xcd3332e1;
case 0x0000b0f0:
return 0x682dccca;
case 0x0000b0f4:
return 0x902563bf;
case 0x0000b0f8:
return 0x7be6ecc8;
case 0x0000b0fc:
return 0xde01a238;
case 0x0000b100:
return 0x2a3aa58c;
case 0x0000b104:
return 0x944c6b35;
case 0x0000b108:
return 0x6ed963a0;
case 0x0000b10c:
return 0x7dcf0279;
case 0x0000b110:
return 0x2a5b5794;
case 0x0000b114:
return 0xf9fe5aa9;
case 0x0000b118:
return 0xc3c70fe3;
case 0x0000b11c:
return 0x6c15bc6d;
case 0x0000b120:
return 0x5b6ebdea;
case 0x0000b124:
return 0x9bfa7020;
case 0x0000b128:
return 0x5c6ac469;
case 0x0000b12c:
return 0xb3f7cc12;
case 0x0000b130:
return 0xd8ccac63;
case 0x0000b134:
return 0x3c257831;
case 0x0000b138:
return 0xf4deb167;
case 0x0000b13c:
return 0x7876e327;
case 0x0000b140:
return 0x22839460;
case 0x0000b144:
return 0xf0efcb2c;
case 0x0000b148:
return 0x225d42a8;
case 0x0000b14c:
return 0x1a37b3f3;
case 0x0000b150:
return 0xe7fb1d5c;
case 0x0000b154:
return 0xb0e33b1b;
case 0x0000b158:
return 0xd1b30297;
case 0x0000b15c:
return 0x9386b9f0;
case 0x0000b160:
return 0x3dca5ade;
case 0x0000b164:
return 0x64a812e7;
case 0x0000b168:
return 0xb0a89c8f;
case 0x0000b16c:
return 0x71426cfc;
case 0x0000b170:
return 0x185f3b59;
case 0x0000b174:
return 0x9e3fbe25;
case 0x0000b178:
return 0xab81b1f0;
case 0x0000b17c:
return 0x4c31e1ad;
case 0x0000b180:
return 0x880e4e27;
case 0x0000b184:
return 0x3376604e;
case 0x0000b188:
return 0xd92b1cf1;
case 0x0000b18c:
return 0xe9606737;
case 0x0000b190:
return 0x5ecaeb84;
case 0x0000b194:
return 0xc5125f56;
case 0x0000b198:
return 0x2e8adf06;
case 0x0000b19c:
return 0xb90597a4;
case 0x0000b1a0:
return 0x6fa54d2c;
case 0x0000b1a4:
return 0x67880d7a;
case 0x0000b1a8:
return 0xa8f1a38e;
case 0x0000b1ac:
return 0x603db0c4;
case 0x0000b1b0:
return 0x991bfcf5;
case 0x0000b1b4:
return 0x2b0b33e2;
case 0x0000b1b8:
return 0x3f5d7b51;
case 0x0000b1bc:
return 0x0b6eef77;
case 0x0000b1c0:
return 0xd2c60509;
case 0x0000b1c4:
return 0x2703d14b;
case 0x0000b1c8:
return 0x62f70de2;
case 0x0000b1cc:
return 0x78a3a3fb;
case 0x0000b1d0:
return 0x95029fb5;
case 0x0000b1d4:
return 0x7ab45fdd;
case 0x0000b1d8:
return 0x6ace80f0;
case 0x0000b1dc:
return 0xe73996e9;
case 0x0000b1e0:
return 0x30d29e26;
case 0x0000b1e4:
return 0x1317df23;
case 0x0000b1e8:
return 0x7c143d09;
case 0x0000b1ec:
return 0x726dd659;
case 0x0000b1f0:
return 0x3bfe52e4;
case 0x0000b1f4:
return 0x8c0831da;
case 0x0000b1f8:
return 0x014af48a;
case 0x0000b1fc:
return 0xce78dadb;
case 0x0000b200:
return 0xda8b3410;
case 0x0000b204:
return 0x5511fa6f;
case 0x0000b208:
return 0xe784bdf5;
case 0x0000b20c:
return 0x0958fbc3;
case 0x0000b210:
return 0xcec056d7;
case 0x0000b214:
return 0xc8738cb3;
case 0x0000b218:
return 0x95e062c5;
case 0x0000b21c:
return 0xf1de0518;
case 0x0000b220:
return 0xb29b4b43;
case 0x0000b224:
return 0x02f6ed1e;
case 0x0000b228:
return 0x0adf8e90;
case 0x0000b22c:
return 0xcb42695f;
case 0x0000b230:
return 0xa1f71bda;
case 0x0000b234:
return 0xe62e054e;
case 0x0000b238:
return 0x72e90ac0;
case 0x0000b23c:
return 0x41f20e56;
case 0x0000b240:
return 0x3e253c08;
case 0x0000b244:
return 0x084e3b01;
case 0x0000b248:
return 0x4e4450e8;
case 0x0000b24c:
return 0x87209ce4;
case 0x0000b250:
return 0x4b3d61c3;
case 0x0000b254:
return 0x31b2ebbb;
case 0x0000b258:
return 0x5c58530a;
case 0x0000b25c:
return 0x5c75108c;
case 0x0000b260:
return 0x895626ae;
case 0x0000b264:
return 0x9a827e55;
case 0x0000b268:
return 0xa8ed7d7b;
case 0x0000b26c:
return 0x570f1be3;
case 0x0000b270:
return 0x34845405;
case 0x0000b274:
return 0x3985ba33;
case 0x0000b278:
return 0xc57b4c50;
case 0x0000b27c:
return 0xe772e02f;
case 0x0000b280:
return 0x4c286ad0;
case 0x0000b284:
return 0x166bae29;
case 0x0000b288:
return 0x8f774870;
case 0x0000b28c:
return 0x8c3ddb5e;
case 0x0000b290:
return 0x3b900b69;
case 0x0000b294:
return 0x6b93c720;
case 0x0000b298:
return 0x9fecf15c;
case 0x0000b29c:
return 0x2c73d692;
case 0x0000b2a0:
return 0x717c66bd;
case 0x0000b2a4:
return 0x28a0509d;
case 0x0000b2a8:
return 0xf69a8c49;
case 0x0000b2ac:
return 0x5b3f14f2;
case 0x0000b2b0:
return 0x1cba8230;
case 0x0000b2b4:
return 0xdf6a7048;
case 0x0000b2b8:
return 0x01e44eb9;
case 0x0000b2bc:
return 0x8b5463d7;
case 0x0000b2c0:
return 0x6b80457b;
case 0x0000b2c4:
return 0x28945957;
case 0x0000b2c8:
return 0x08183342;
case 0x0000b2cc:
return 0x0db23ee1;
case 0x0000b2d0:
return 0xe6f383bc;
case 0x0000b2d4:
return 0xbdb50fc1;
case 0x0000b2d8:
return 0x3fb67421;
case 0x0000b2dc:
return 0xffc4a003;
case 0x0000b2e0:
return 0x11fb0885;
case 0x0000b2e4:
return 0x7560c934;
case 0x0000b2e8:
return 0x644e0172;
case 0x0000b2ec:
return 0xee1cb55d;
case 0x0000b2f0:
return 0x54fcc7be;
case 0x0000b2f4:
return 0x793887ea;
case 0x0000b2f8:
return 0xe10d6800;
case 0x0000b2fc:
return 0x0ffd2c90;
case 0x0000b300:
return 0x88c9d8fe;
case 0x0000b304:
return 0xe8659638;
case 0x0000b308:
return 0xf1817e8d;
case 0x0000b30c:
return 0x49418db8;
case 0x0000b310:
return 0xae5ade19;
case 0x0000b314:
return 0x7ac24fa2;
case 0x0000b318:
return 0xd53bac1b;
case 0x0000b31c:
return 0x1e22335d;
case 0x0000b320:
return 0x6ed5e5b4;
case 0x0000b324:
return 0xa850cbc4;
case 0x0000b328:
return 0xcd28d7ef;
case 0x0000b32c:
return 0xae7065d7;
case 0x0000b330:
return 0xa4d25ce5;
case 0x0000b334:
return 0x78f30286;
case 0x0000b338:
return 0x27146d79;
case 0x0000b33c:
return 0xc48d52e7;
case 0x0000b340:
return 0xe27f280a;
case 0x0000b344:
return 0xe256bc03;
case 0x0000b348:
return 0xb4a8ae2c;
case 0x0000b34c:
return 0x87945825;
case 0x0000b350:
return 0x8f5e02eb;
case 0x0000b354:
return 0x7b4eb9f5;
case 0x0000b358:
return 0x67c182a5;
case 0x0000b35c:
return 0xd4596c10;
case 0x0000b360:
return 0xdfe4bd9b;
case 0x0000b364:
return 0x390ef369;
case 0x0000b368:
return 0xc054e4b5;
case 0x0000b36c:
return 0x03488e48;
case 0x0000b370:
return 0x636fd666;
case 0x0000b374:
return 0xb514b93f;
case 0x0000b378:
return 0xccd10f9b;
case 0x0000b37c:
return 0x2e171b6f;
case 0x0000b380:
return 0x6bdc06a2;
case 0x0000b384:
return 0xdd7ece97;
case 0x0000b388:
return 0x6cb842d4;
case 0x0000b38c:
return 0x17be2f65;
case 0x0000b390:
return 0x89934d75;
case 0x0000b394:
return 0xff4b3183;
case 0x0000b398:
return 0xb32f3ef6;
case 0x0000b39c:
return 0xd70a3b1d;
case 0x0000b3a0:
return 0x0b7fe4dc;
case 0x0000b3a4:
return 0x26d3fb39;
case 0x0000b3a8:
return 0xf7498613;
case 0x0000b3ac:
return 0x219dff4c;
case 0x0000b3b0:
return 0xe603d04d;
case 0x0000b3b4:
return 0x28b5cacb;
case 0x0000b3b8:
return 0x0380cc42;
case 0x0000b3bc:
return 0x7ae52f49;
case 0x0000b3c0:
return 0x12314484;
case 0x0000b3c4:
return 0xc7539bb0;
case 0x0000b3c8:
return 0x9b81adcc;
case 0x0000b3cc:
return 0xf00f89de;
case 0x0000b3d0:
return 0x69059fe7;
case 0x0000b3d4:
return 0x4f83a55b;
case 0x0000b3d8:
return 0x99ed58aa;
case 0x0000b3dc:
return 0xa507d32b;
case 0x0000b3e0:
return 0x99ed9e3c;
case 0x0000b3e4:
return 0x3ebcfaa4;
case 0x0000b3e8:
return 0x7cde5f28;
case 0x0000b3ec:
return 0x302367dd;
case 0x0000b3f0:
return 0x4b3a26dc;
case 0x0000b3f4:
return 0x0ca6e085;
case 0x0000b3f8:
return 0xd3e098f9;
case 0x0000b3fc:
return 0x2b5e4cfb;
case 0x0000b400:
return 0x80f5a6a3;
case 0x0000b404:
return 0x92c9d87f;
case 0x0000b408:
return 0xf19270bd;
case 0x0000b40c:
return 0x800eeb21;
case 0x0000b410:
return 0xf3a058c4;
case 0x0000b414:
return 0xb0328c6d;
case 0x0000b418:
return 0x882c6892;
case 0x0000b41c:
return 0x99ab06f4;
case 0x0000b420:
return 0xfd3af4c1;
case 0x0000b424:
return 0x2bc4c58f;
case 0x0000b428:
return 0xb180c893;
case 0x0000b42c:
return 0xd6de64b8;
case 0x0000b430:
return 0x96db6b61;
case 0x0000b434:
return 0x015428a1;
case 0x0000b438:
return 0xd7a3ce0e;
case 0x0000b43c:
return 0xfc962e76;
case 0x0000b440:
return 0xdd67baf9;
case 0x0000b444:
return 0x4bf2886b;
case 0x0000b448:
return 0x7410b4ba;
case 0x0000b44c:
return 0x81cb680c;
case 0x0000b450:
return 0x96f635da;
case 0x0000b454:
return 0x90aefc52;
case 0x0000b458:
return 0xfdeb7e8a;
case 0x0000b45c:
return 0x93d778fb;
case 0x0000b460:
return 0x6beec559;
case 0x0000b464:
return 0xe8281ad8;
case 0x0000b468:
return 0x00bf69c5;
case 0x0000b46c:
return 0x1cb786d5;
case 0x0000b470:
return 0x097c1531;
case 0x0000b474:
return 0x8eb88b92;
case 0x0000b478:
return 0x4d1d3004;
case 0x0000b47c:
return 0xd79ee083;
case 0x0000b480:
return 0x32292b8d;
case 0x0000b484:
return 0x7f08a3dc;
case 0x0000b488:
return 0x312bc4e2;
case 0x0000b48c:
return 0xedb5a677;
case 0x0000b490:
return 0x6534c97a;
case 0x0000b494:
return 0xfafe4ff5;
case 0x0000b498:
return 0x28a29f0d;
case 0x0000b49c:
return 0x55e5a9b8;
case 0x0000b4a0:
return 0xb04bf232;
case 0x0000b4a4:
return 0x5561cc6d;
case 0x0000b4a8:
return 0x53e74f91;
case 0x0000b4ac:
return 0x5c5bcfac;
case 0x0000b4b0:
return 0x9155fcc1;
case 0x0000b4b4:
return 0x23fac3df;
case 0x0000b4b8:
return 0xb51b506a;
case 0x0000b4bc:
return 0xc2f65bae;
case 0x0000b4c0:
return 0x0f724246;
case 0x0000b4c4:
return 0x85bb00ed;
case 0x0000b4c8:
return 0x0ac29c8a;
case 0x0000b4cc:
return 0xe1600bbe;
case 0x0000b4d0:
return 0x0eb68aba;
case 0x0000b4d4:
return 0x620af894;
case 0x0000b4d8:
return 0xe2383a8d;
case 0x0000b4dc:
return 0xfd966bd9;
case 0x0000b4e0:
return 0x3a544169;
case 0x0000b4e4:
return 0x96961864;
case 0x0000b4e8:
return 0xddb06ef5;
case 0x0000b4ec:
return 0x107f06f5;
case 0x0000b4f0:
return 0x749534d9;
case 0x0000b4f4:
return 0x2c017d4b;
case 0x0000b4f8:
return 0x3d3637b2;
case 0x0000b4fc:
return 0x0a4cd539;
case 0x0000b500:
return 0xe63b7433;
case 0x0000b504:
return 0xc2af9ef9;
case 0x0000b508:
return 0x13d8e9ad;
case 0x0000b50c:
return 0xcd143c20;
case 0x0000b510:
return 0x69ebf1ff;
case 0x0000b514:
return 0xb0e3ed31;
case 0x0000b518:
return 0x15ef6bfe;
case 0x0000b51c:
return 0xf66db24b;
case 0x0000b520:
return 0xe26cf0fb;
case 0x0000b524:
return 0xf61161ba;
case 0x0000b528:
return 0x6c402c76;
case 0x0000b52c:
return 0x98ddc7f0;
case 0x0000b530:
return 0x55665ae6;
case 0x0000b534:
return 0x8bf71d61;
case 0x0000b538:
return 0x5a416351;
case 0x0000b53c:
return 0x75048e4c;
case 0x0000b540:
return 0x0fe7eaaf;
case 0x0000b544:
return 0xfae9811e;
case 0x0000b548:
return 0x8d2f492c;
case 0x0000b54c:
return 0xa920f348;
case 0x0000b550:
return 0x7a358b1a;
case 0x0000b554:
return 0xeacc45f0;
case 0x0000b558:
return 0xfb35b8f6;
case 0x0000b55c:
return 0xec9b49c5;
case 0x0000b560:
return 0x9f895ada;
case 0x0000b564:
return 0x74880624;
case 0x0000b568:
return 0x164c2c3c;
case 0x0000b56c:
return 0x00c1afe0;
case 0x0000b570:
return 0x5b214d5c;
case 0x0000b574:
return 0xc16e8450;
case 0x0000b578:
return 0x8c286517;
case 0x0000b57c:
return 0xaf6178e1;
case 0x0000b580:
return 0x3e7ddea6;
case 0x0000b584:
return 0xbe31127a;
case 0x0000b588:
return 0x2fbd105c;
case 0x0000b58c:
return 0xe5da6948;
case 0x0000b590:
return 0xad380e79;
case 0x0000b594:
return 0x59f4d79d;
case 0x0000b598:
return 0xd6a8aceb;
case 0x0000b59c:
return 0x21fff900;
case 0x0000b5a0:
return 0x789bc033;
case 0x0000b5a4:
return 0x8d6a514d;
case 0x0000b5a8:
return 0xd4b83504;
case 0x0000b5ac:
return 0x3293f645;
case 0x0000b5b0:
return 0x2977adfd;
case 0x0000b5b4:
return 0x7a4225c9;
case 0x0000b5b8:
return 0x246a8d05;
case 0x0000b5bc:
return 0x07796f89;
case 0x0000b5c0:
return 0x651084f2;
case 0x0000b5c4:
return 0x53e1c54b;
case 0x0000b5c8:
return 0x3d711892;
case 0x0000b5cc:
return 0x30510c46;
case 0x0000b5d0:
return 0xa3483636;
case 0x0000b5d4:
return 0xdfe59495;
case 0x0000b5d8:
return 0x808ea12d;
case 0x0000b5dc:
return 0x0086880c;
case 0x0000b5e0:
return 0xcf035c9e;
case 0x0000b5e4:
return 0x0a97ba9f;
case 0x0000b5e8:
return 0x60d4b325;
case 0x0000b5ec:
return 0x9995a253;
case 0x0000b5f0:
return 0xed5c0ca4;
case 0x0000b5f4:
return 0xb5affc26;
case 0x0000b5f8:
return 0x13d007c3;
case 0x0000b5fc:
return 0x96a36054;
case 0x0000b600:
return 0x28f06c3f;
case 0x0000b604:
return 0x357069d2;
case 0x0000b608:
return 0x326380f0;
case 0x0000b60c:
return 0x0deb94c5;
case 0x0000b610:
return 0x2d24c72a;
case 0x0000b614:
return 0x49ced82d;
case 0x0000b618:
return 0x9335b61c;
case 0x0000b61c:
return 0x8e0660dc;
case 0x0000b620:
return 0x97a6017b;
case 0x0000b624:
return 0x31a019b6;
case 0x0000b628:
return 0xdaa79e89;
case 0x0000b62c:
return 0x96ce1fda;
case 0x0000b630:
return 0x80e651a6;
case 0x0000b634:
return 0x4dc0e740;
case 0x0000b638:
return 0xc3f19fbb;
case 0x0000b63c:
return 0x6a4438ab;
case 0x0000b640:
return 0xca2e7d33;
case 0x0000b644:
return 0xfad01cdb;
case 0x0000b648:
return 0x5568707f;
case 0x0000b64c:
return 0x8ed87e76;
case 0x0000b650:
return 0x50895066;
case 0x0000b654:
return 0x610daf33;
case 0x0000b658:
return 0x1bb77e80;
case 0x0000b65c:
return 0xd483f8ca;
case 0x0000b660:
return 0x18609879;
case 0x0000b664:
return 0xaea09600;
case 0x0000b668:
return 0x0f611f9d;
case 0x0000b66c:
return 0x6c52ccd6;
case 0x0000b670:
return 0x706936e9;
case 0x0000b674:
return 0x76202aac;
case 0x0000b678:
return 0x78bd33ed;
case 0x0000b67c:
return 0x2f8a790a;
case 0x0000b680:
return 0x9612a268;
case 0x0000b684:
return 0x66b57c91;
case 0x0000b688:
return 0xf1fa7dd7;
case 0x0000b68c:
return 0x2ac3cd65;
case 0x0000b690:
return 0xacef756e;
case 0x0000b694:
return 0x867d41eb;
case 0x0000b698:
return 0xa7d67dbf;
case 0x0000b69c:
return 0x717d58ff;
case 0x0000b6a0:
return 0x8d4fb6e5;
case 0x0000b6a4:
return 0x5858759f;
case 0x0000b6a8:
return 0xec0f3c3c;
case 0x0000b6ac:
return 0x5304665c;
case 0x0000b6b0:
return 0xad01b1fb;
case 0x0000b6b4:
return 0xbe52df96;
case 0x0000b6b8:
return 0x75b26748;
case 0x0000b6bc:
return 0xc1a63999;
case 0x0000b6c0:
return 0xd2171032;
case 0x0000b6c4:
return 0x6de13aa9;
case 0x0000b6c8:
return 0x453be8e2;
case 0x0000b6cc:
return 0x921b6ad7;
case 0x0000b6d0:
return 0xa1b547b4;
case 0x0000b6d4:
return 0x9fea97bc;
case 0x0000b6d8:
return 0x89157cab;
case 0x0000b6dc:
return 0x556fadab;
case 0x0000b6e0:
return 0x9292efd5;
case 0x0000b6e4:
return 0x32ea7a4e;
case 0x0000b6e8:
return 0x9ca6c5ef;
case 0x0000b6ec:
return 0x0c7d4c05;
case 0x0000b6f0:
return 0xf9024802;
case 0x0000b6f4:
return 0x3e989ff2;
case 0x0000b6f8:
return 0xe3a7aafd;
case 0x0000b6fc:
return 0x2fc878d6;
case 0x0000b700:
return 0xc2ad1220;
case 0x0000b704:
return 0xf7ef42e1;
case 0x0000b708:
return 0xe8ce78ca;
case 0x0000b70c:
return 0x43f7eddb;
case 0x0000b710:
return 0x369d3627;
case 0x0000b714:
return 0x481143fa;
case 0x0000b718:
return 0xaed16952;
case 0x0000b71c:
return 0xc80f298d;
case 0x0000b720:
return 0xf2c2012e;
case 0x0000b724:
return 0xae2b65ee;
case 0x0000b728:
return 0xad58f247;
case 0x0000b72c:
return 0x58145188;
case 0x0000b730:
return 0xa2b52a31;
case 0x0000b734:
return 0x3d1c9fd9;
case 0x0000b738:
return 0xa8bc5be8;
case 0x0000b73c:
return 0x4218c947;
case 0x0000b740:
return 0xcc0d13cb;
case 0x0000b744:
return 0x2fea4bf1;
case 0x0000b748:
return 0xdbe12fe8;
case 0x0000b74c:
return 0x81dc504c;
case 0x0000b750:
return 0x92e681c3;
case 0x0000b754:
return 0xfadae252;
case 0x0000b758:
return 0x3b6ea8cc;
case 0x0000b75c:
return 0x2c00daf3;
case 0x0000b760:
return 0xd10444af;
case 0x0000b764:
return 0x5842691d;
case 0x0000b768:
return 0xe2e64eaa;
case 0x0000b76c:
return 0xe9e9bedf;
case 0x0000b770:
return 0xb04d21ab;
case 0x0000b774:
return 0x0f2f03f6;
case 0x0000b778:
return 0x09c014ca;
case 0x0000b77c:
return 0xebf6633f;
case 0x0000b780:
return 0x0113f9b8;
case 0x0000b784:
return 0xc5113792;
case 0x0000b788:
return 0xbb956dcf;
case 0x0000b78c:
return 0xef035391;
case 0x0000b790:
return 0x87ad2695;
case 0x0000b794:
return 0xe8e07668;
case 0x0000b798:
return 0x17884839;
case 0x0000b79c:
return 0xd5296055;
case 0x0000b7a0:
return 0x6789493f;
case 0x0000b7a4:
return 0x28088722;
case 0x0000b7a8:
return 0x93a01071;
case 0x0000b7ac:
return 0x497d892c;
case 0x0000b7b0:
return 0x4481e7b9;
case 0x0000b7b4:
return 0x84e4f4da;
case 0x0000b7b8:
return 0x76aac90d;
case 0x0000b7bc:
return 0xf76df8ab;
case 0x0000b7c0:
return 0x9d563794;
case 0x0000b7c4:
return 0xa20037c8;
case 0x0000b7c8:
return 0x6f1864f2;
case 0x0000b7cc:
return 0x139ec68b;
case 0x0000b7d0:
return 0x256cc1ef;
case 0x0000b7d4:
return 0x11343ae2;
case 0x0000b7d8:
return 0x862265c7;
case 0x0000b7dc:
return 0xb74134ec;
case 0x0000b7e0:
return 0xe69af0e3;
case 0x0000b7e4:
return 0x2d9c7209;
case 0x0000b7e8:
return 0xba640fb6;
case 0x0000b7ec:
return 0x267f2f1d;
case 0x0000b7f0:
return 0xa7ae55de;
case 0x0000b7f4:
return 0xb7a32d2b;
case 0x0000b7f8:
return 0xb2e2c85f;
case 0x0000b7fc:
return 0xf4593fe0;
case 0x0000b800:
return 0x812c7b63;
case 0x0000b804:
return 0xb32c6006;
case 0x0000b808:
return 0x7818f088;
case 0x0000b80c:
return 0x0fe333cc;
case 0x0000b810:
return 0x24fcfea0;
case 0x0000b814:
return 0x715d77dc;
case 0x0000b818:
return 0xfc615e3e;
case 0x0000b81c:
return 0x135bf0c0;
case 0x0000b820:
return 0x42a2c69c;
case 0x0000b824:
return 0xa5e0473a;
case 0x0000b828:
return 0xfa315966;
case 0x0000b82c:
return 0xd4acc85f;
case 0x0000b830:
return 0xdc6a7bbb;
case 0x0000b834:
return 0xe997315e;
case 0x0000b838:
return 0xc2655ff0;
case 0x0000b83c:
return 0xc6ed6af4;
case 0x0000b840:
return 0xd9672e34;
case 0x0000b844:
return 0x637862ad;
case 0x0000b848:
return 0x92442c02;
case 0x0000b84c:
return 0xc2e66fd5;
case 0x0000b850:
return 0x458f8dde;
case 0x0000b854:
return 0x5998b0b6;
case 0x0000b858:
return 0xc43b41db;
case 0x0000b85c:
return 0x4092eced;
case 0x0000b860:
return 0x433df427;
case 0x0000b864:
return 0x93ba07a0;
case 0x0000b868:
return 0x1fdefbfc;
case 0x0000b86c:
return 0xc8134f00;
case 0x0000b870:
return 0xb57347a6;
case 0x0000b874:
return 0xdb4b6a6d;
case 0x0000b878:
return 0xfee4f0e1;
case 0x0000b87c:
return 0xb31ebf9d;
case 0x0000b880:
return 0x0a4e0ee4;
case 0x0000b884:
return 0x40ac9f2b;
case 0x0000b888:
return 0x20be1b88;
case 0x0000b88c:
return 0xc39c6595;
case 0x0000b890:
return 0x24a7a3f3;
case 0x0000b894:
return 0x4f33a95f;
case 0x0000b898:
return 0xd48f8189;
case 0x0000b89c:
return 0x8095d75c;
case 0x0000b8a0:
return 0x8d541b21;
case 0x0000b8a4:
return 0x632ffc4c;
case 0x0000b8a8:
return 0x844b5c9e;
case 0x0000b8ac:
return 0x4089ad4f;
case 0x0000b8b0:
return 0x5a769f55;
case 0x0000b8b4:
return 0x554973ec;
case 0x0000b8b8:
return 0x961d558a;
case 0x0000b8bc:
return 0xaa68ef77;
case 0x0000b8c0:
return 0x41bb1e81;
case 0x0000b8c4:
return 0x7d36a644;
case 0x0000b8c8:
return 0xff444bfb;
case 0x0000b8cc:
return 0x3eaacac2;
case 0x0000b8d0:
return 0xf8715f3b;
case 0x0000b8d4:
return 0x0ac0ca69;
case 0x0000b8d8:
return 0x32753441;
case 0x0000b8dc:
return 0xbb10c4bd;
case 0x0000b8e0:
return 0x04e0808b;
case 0x0000b8e4:
return 0x701ec50c;
case 0x0000b8e8:
return 0x68ac50f9;
case 0x0000b8ec:
return 0x24e3d705;
case 0x0000b8f0:
return 0x1dbec455;
case 0x0000b8f4:
return 0xcfa4066e;
case 0x0000b8f8:
return 0x3eccd30e;
case 0x0000b8fc:
return 0x0a7f7d0d;
case 0x0000b900:
return 0xdd1be74a;
case 0x0000b904:
return 0xf9dab560;
case 0x0000b908:
return 0xc8d6ef18;
case 0x0000b90c:
return 0x86142760;
case 0x0000b910:
return 0xfec380c3;
case 0x0000b914:
return 0x2874c451;
case 0x0000b918:
return 0x1670f52b;
case 0x0000b91c:
return 0x825968e4;
case 0x0000b920:
return 0xace68e2f;
case 0x0000b924:
return 0xd79d30e7;
case 0x0000b928:
return 0xd197b9b4;
case 0x0000b92c:
return 0xaefbb065;
case 0x0000b930:
return 0x691286af;
case 0x0000b934:
return 0xf9623bf3;
case 0x0000b938:
return 0xd1cef38e;
case 0x0000b93c:
return 0x7c893d5f;
case 0x0000b940:
return 0x2ee91061;
case 0x0000b944:
return 0x2b1a63a1;
case 0x0000b948:
return 0x3b459b8a;
case 0x0000b94c:
return 0xa7c52eb0;
case 0x0000b950:
return 0xc0f6b98e;
case 0x0000b954:
return 0x7da77d9f;
case 0x0000b958:
return 0x1916646f;
case 0x0000b95c:
return 0xb6ee8afb;
case 0x0000b960:
return 0x9f52e6c0;
case 0x0000b964:
return 0x72f30f78;
case 0x0000b968:
return 0x6b49ff60;
case 0x0000b96c:
return 0xcd7f1af1;
case 0x0000b970:
return 0x1895c5b1;
case 0x0000b974:
return 0x73f8f4ab;
case 0x0000b978:
return 0xcfbb2080;
case 0x0000b97c:
return 0x4ba66ceb;
case 0x0000b980:
return 0x162ee359;
case 0x0000b984:
return 0xf2c8eebe;
case 0x0000b988:
return 0x3ea7f6ad;
case 0x0000b98c:
return 0xd236c4cd;
case 0x0000b990:
return 0xd0325c11;
case 0x0000b994:
return 0xee93f54c;
case 0x0000b998:
return 0xbf6adf7a;
case 0x0000b99c:
return 0xc61d945d;
case 0x0000b9a0:
return 0x63450404;
case 0x0000b9a4:
return 0x166f9c3f;
case 0x0000b9a8:
return 0x2cc12506;
case 0x0000b9ac:
return 0x86c56c7c;
case 0x0000b9b0:
return 0x7874befd;
case 0x0000b9b4:
return 0x357aa4e0;
case 0x0000b9b8:
return 0xc5b758a0;
case 0x0000b9bc:
return 0x73da13fc;
case 0x0000b9c0:
return 0x34dcb30c;
case 0x0000b9c4:
return 0x6026199f;
case 0x0000b9c8:
return 0xcefd027b;
case 0x0000b9cc:
return 0x65133249;
case 0x0000b9d0:
return 0xeea8a3c9;
case 0x0000b9d4:
return 0x7e794e23;
case 0x0000b9d8:
return 0x85ca7e5b;
case 0x0000b9dc:
return 0x896ab925;
case 0x0000b9e0:
return 0x87740e4a;
case 0x0000b9e4:
return 0x06bcd6a0;
case 0x0000b9e8:
return 0x8bc5add8;
case 0x0000b9ec:
return 0x5b7dc442;
case 0x0000b9f0:
return 0x817fad50;
case 0x0000b9f4:
return 0xa8827f2a;
case 0x0000b9f8:
return 0xe8b5747b;
case 0x0000b9fc:
return 0xb33af0f6;
case 0x0000ba00:
return 0xc73f626c;
case 0x0000ba04:
return 0x25032250;
case 0x0000ba08:
return 0x559c9bfe;
case 0x0000ba0c:
return 0x2de13701;
case 0x0000ba10:
return 0x7ba9da20;
case 0x0000ba14:
return 0xa40848e1;
case 0x0000ba18:
return 0x6ee0d4ae;
case 0x0000ba1c:
return 0x0b7527c1;
case 0x0000ba20:
return 0x9593b4b3;
case 0x0000ba24:
return 0x89f6623b;
case 0x0000ba28:
return 0xc0da9b6e;
case 0x0000ba2c:
return 0x11129042;
case 0x0000ba30:
return 0xc8d390fd;
case 0x0000ba34:
return 0xd160f9ee;
case 0x0000ba38:
return 0x0fc0e757;
case 0x0000ba3c:
return 0x188235c3;
case 0x0000ba40:
return 0x4a277724;
case 0x0000ba44:
return 0xbb5172cf;
case 0x0000ba48:
return 0x33dc8c90;
case 0x0000ba4c:
return 0x7e1ddbe0;
case 0x0000ba50:
return 0x3e3d7e48;
case 0x0000ba54:
return 0x3d6c0d4b;
case 0x0000ba58:
return 0x675587fe;
case 0x0000ba5c:
return 0xd8f26e5f;
case 0x0000ba60:
return 0xda05741a;
case 0x0000ba64:
return 0xca081f59;
case 0x0000ba68:
return 0x5e78ac6d;
case 0x0000ba6c:
return 0xe34fc136;
case 0x0000ba70:
return 0xb7f6a266;
case 0x0000ba74:
return 0x0f6873c7;
case 0x0000ba78:
return 0xdc13d0a9;
case 0x0000ba7c:
return 0xb5866415;
case 0x0000ba80:
return 0x67629981;
case 0x0000ba84:
return 0xef2af71b;
case 0x0000ba88:
return 0x90c05d03;
case 0x0000ba8c:
return 0x2de07b1b;
case 0x0000ba90:
return 0x039ff538;
case 0x0000ba94:
return 0xcfa0b6ca;
case 0x0000ba98:
return 0xe6a22bc4;
case 0x0000ba9c:
return 0xf3f63b13;
case 0x0000baa0:
return 0xc007e5f5;
case 0x0000baa4:
return 0xfb8a1b6e;
case 0x0000baa8:
return 0x1918c9aa;
case 0x0000baac:
return 0x239a2efd;
case 0x0000bab0:
return 0xa1de68ed;
case 0x0000bab4:
return 0xdde7964e;
case 0x0000bab8:
return 0x9fbee71f;
case 0x0000babc:
return 0x8b92b786;
case 0x0000bac0:
return 0xd7443032;
case 0x0000bac4:
return 0x88efc9d2;
case 0x0000bac8:
return 0x76a7a593;
case 0x0000bacc:
return 0x5377f8b3;
case 0x0000bad0:
return 0x2feba062;
case 0x0000bad4:
return 0x1edc26b6;
case 0x0000bad8:
return 0xd345db3d;
case 0x0000badc:
return 0x67eb6428;
case 0x0000bae0:
return 0x150a8371;
case 0x0000bae4:
return 0x24559b34;
case 0x0000bae8:
return 0x627da3ee;
case 0x0000baec:
return 0xff160c37;
case 0x0000baf0:
return 0x8c896d91;
case 0x0000baf4:
return 0xe35188e8;
case 0x0000baf8:
return 0x57a8cc90;
case 0x0000bafc:
return 0x26e206ff;
case 0x0000bb00:
return 0x6dfc0b1b;
case 0x0000bb04:
return 0x1927bb46;
case 0x0000bb08:
return 0x97c0eadd;
case 0x0000bb0c:
return 0x25648770;
case 0x0000bb10:
return 0x9e6405e0;
case 0x0000bb14:
return 0xc211672b;
case 0x0000bb18:
return 0xc7c7e4c2;
case 0x0000bb1c:
return 0x13a1fa73;
case 0x0000bb20:
return 0x4f59e998;
case 0x0000bb24:
return 0x9ae6df83;
case 0x0000bb28:
return 0xdb9aa94d;
case 0x0000bb2c:
return 0x82b60ab5;
case 0x0000bb30:
return 0x4ac257d2;
case 0x0000bb34:
return 0x4f0ed7bc;
case 0x0000bb38:
return 0xe7dcedc6;
case 0x0000bb3c:
return 0xa61114eb;
case 0x0000bb40:
return 0x807c6c83;
case 0x0000bb44:
return 0x32a2f615;
case 0x0000bb48:
return 0x0f15142f;
case 0x0000bb4c:
return 0x28c2ce92;
case 0x0000bb50:
return 0xdf84c136;
case 0x0000bb54:
return 0x80480934;
case 0x0000bb58:
return 0x445079cc;
case 0x0000bb5c:
return 0x16586a00;
case 0x0000bb60:
return 0x2822b3c3;
case 0x0000bb64:
return 0xef518d90;
case 0x0000bb68:
return 0x554fd698;
case 0x0000bb6c:
return 0x809f5bc7;
case 0x0000bb70:
return 0xd11e6bb2;
case 0x0000bb74:
return 0x9e1294b3;
case 0x0000bb78:
return 0x9b430871;
case 0x0000bb7c:
return 0x8e125e51;
case 0x0000bb80:
return 0x83048e30;
case 0x0000bb84:
return 0x82e906fa;
case 0x0000bb88:
return 0xd111d1c8;
case 0x0000bb8c:
return 0x89a10620;
case 0x0000bb90:
return 0xe2f01797;
case 0x0000bb94:
return 0x50dbca57;
case 0x0000bb98:
return 0xfdc125a0;
case 0x0000bb9c:
return 0x59ef44c0;
case 0x0000bba0:
return 0xe28bea7c;
case 0x0000bba4:
return 0xce4b3487;
case 0x0000bba8:
return 0x43400f29;
case 0x0000bbac:
return 0x26606f67;
case 0x0000bbb0:
return 0x6980e8d6;
case 0x0000bbb4:
return 0x9d3f2faa;
case 0x0000bbb8:
return 0x6087c271;
case 0x0000bbbc:
return 0xb5eb7b4b;
case 0x0000bbc0:
return 0x3b4de5b6;
case 0x0000bbc4:
return 0xe4d17607;
case 0x0000bbc8:
return 0x75c9f0d6;
case 0x0000bbcc:
return 0x3b10dc23;
case 0x0000bbd0:
return 0xb5318979;
case 0x0000bbd4:
return 0xd0e699f2;
case 0x0000bbd8:
return 0x56d97bfd;
case 0x0000bbdc:
return 0x13d88633;
case 0x0000bbe0:
return 0x65f280d5;
case 0x0000bbe4:
return 0x6799a872;
case 0x0000bbe8:
return 0x8ecd4ad6;
case 0x0000bbec:
return 0x6a123260;
case 0x0000bbf0:
return 0xeb6b0e7b;
case 0x0000bbf4:
return 0xcf518364;
case 0x0000bbf8:
return 0x77533e6f;
case 0x0000bbfc:
return 0xe34d1650;
case 0x0000bc00:
return 0x6bfd6bce;
case 0x0000bc04:
return 0x70a34b9b;
case 0x0000bc08:
return 0x6e5860bb;
case 0x0000bc0c:
return 0xabb73eb8;
case 0x0000bc10:
return 0xea83360c;
case 0x0000bc14:
return 0xd0950b69;
case 0x0000bc18:
return 0x8564e7cd;
case 0x0000bc1c:
return 0x2e12859f;
case 0x0000bc20:
return 0xc89a99ff;
case 0x0000bc24:
return 0xfd4227b8;
case 0x0000bc28:
return 0x8d4b9efb;
case 0x0000bc2c:
return 0x84de307f;
case 0x0000bc30:
return 0xc3c0fee4;
case 0x0000bc34:
return 0x21498271;
case 0x0000bc38:
return 0x3199b22d;
case 0x0000bc3c:
return 0x30e558c0;
case 0x0000bc40:
return 0x8365db13;
case 0x0000bc44:
return 0x757719a7;
case 0x0000bc48:
return 0x16582d92;
case 0x0000bc4c:
return 0x0bd87f22;
case 0x0000bc50:
return 0xabb39fda;
case 0x0000bc54:
return 0xa2fbeafd;
case 0x0000bc58:
return 0x6a8b468f;
case 0x0000bc5c:
return 0xfb75e638;
case 0x0000bc60:
return 0x2de745b3;
case 0x0000bc64:
return 0x76878d0e;
case 0x0000bc68:
return 0x491a01a1;
case 0x0000bc6c:
return 0x34ba56dd;
case 0x0000bc70:
return 0x142e7e4a;
case 0x0000bc74:
return 0x722233ec;
case 0x0000bc78:
return 0xaf12bcb5;
case 0x0000bc7c:
return 0x0fd0a4ec;
case 0x0000bc80:
return 0x70d01b2f;
case 0x0000bc84:
return 0xa6dce05f;
case 0x0000bc88:
return 0xf4a636ec;
case 0x0000bc8c:
return 0x3444691c;
case 0x0000bc90:
return 0x69ccdcba;
case 0x0000bc94:
return 0xa680e55c;
case 0x0000bc98:
return 0x57e7969b;
case 0x0000bc9c:
return 0x06dbada6;
case 0x0000bca0:
return 0xdaf1d158;
case 0x0000bca4:
return 0x5b3a7989;
case 0x0000bca8:
return 0x35fe13f9;
case 0x0000bcac:
return 0x58d935b6;
case 0x0000bcb0:
return 0x4d574ac8;
case 0x0000bcb4:
return 0x86faf880;
case 0x0000bcb8:
return 0x7169e455;
case 0x0000bcbc:
return 0x2232a8b0;
case 0x0000bcc0:
return 0x2664faa5;
case 0x0000bcc4:
return 0x8a89f904;
case 0x0000bcc8:
return 0xd2cac1ee;
case 0x0000bccc:
return 0x312fa40d;
case 0x0000bcd0:
return 0xa9923cd2;
case 0x0000bcd4:
return 0xa5fb97b5;
case 0x0000bcd8:
return 0x0f48b949;
case 0x0000bcdc:
return 0x06b135d4;
case 0x0000bce0:
return 0xf182559d;
case 0x0000bce4:
return 0x5ddcbd36;
case 0x0000bce8:
return 0x0eecd1a0;
case 0x0000bcec:
return 0xfc897656;
case 0x0000bcf0:
return 0x00d59f93;
case 0x0000bcf4:
return 0x1887f51b;
case 0x0000bcf8:
return 0xeb85a56d;
case 0x0000bcfc:
return 0x6cd0cddb;
case 0x0000bd00:
return 0x5e306530;
case 0x0000bd04:
return 0xd3cfb4a6;
case 0x0000bd08:
return 0x89c0e1a7;
case 0x0000bd0c:
return 0x26cb41b1;
case 0x0000bd10:
return 0x62092ec3;
case 0x0000bd14:
return 0x5d8c3a97;
case 0x0000bd18:
return 0x4930e269;
case 0x0000bd1c:
return 0x67e12d38;
case 0x0000bd20:
return 0xc9da9e28;
case 0x0000bd24:
return 0xa5e5b6bd;
case 0x0000bd28:
return 0x26e0633a;
case 0x0000bd2c:
return 0x7bc282e5;
case 0x0000bd30:
return 0x507a07ef;
case 0x0000bd34:
return 0xb185ab18;
case 0x0000bd38:
return 0x05953f57;
case 0x0000bd3c:
return 0xfa6a8795;
case 0x0000bd40:
return 0x4ed9cf7b;
case 0x0000bd44:
return 0xf2f55d92;
case 0x0000bd48:
return 0x2cc856ee;
case 0x0000bd4c:
return 0xbbc92cb9;
case 0x0000bd50:
return 0xd9c564cb;
case 0x0000bd54:
return 0x238a3f70;
case 0x0000bd58:
return 0x5f0f9ede;
case 0x0000bd5c:
return 0x27c55864;
case 0x0000bd60:
return 0xfccbff3f;
case 0x0000bd64:
return 0x652da44f;
case 0x0000bd68:
return 0x8f579048;
case 0x0000bd6c:
return 0x7cb467ba;
case 0x0000bd70:
return 0xf11b34f1;
case 0x0000bd74:
return 0x01ef4456;
case 0x0000bd78:
return 0x99a51ec0;
case 0x0000bd7c:
return 0x7afec5b2;
case 0x0000bd80:
return 0xb0164369;
case 0x0000bd84:
return 0x2a5c1638;
case 0x0000bd88:
return 0x0a12a167;
case 0x0000bd8c:
return 0x619643f6;
case 0x0000bd90:
return 0x287d48b3;
case 0x0000bd94:
return 0x03719f36;
case 0x0000bd98:
return 0x242e9975;
case 0x0000bd9c:
return 0x8fc52730;
case 0x0000bda0:
return 0x14ad4e59;
case 0x0000bda4:
return 0x029512af;
case 0x0000bda8:
return 0x31ba6d37;
case 0x0000bdac:
return 0x55472f26;
case 0x0000bdb0:
return 0xdc7fd1b0;
case 0x0000bdb4:
return 0x3f1c0c8d;
case 0x0000bdb8:
return 0x8842a905;
case 0x0000bdbc:
return 0xa72f6e47;
case 0x0000bdc0:
return 0xf23c6adc;
case 0x0000bdc4:
return 0x4c76bef6;
case 0x0000bdc8:
return 0xbca43ebb;
case 0x0000bdcc:
return 0x2c9d6e23;
case 0x0000bdd0:
return 0x65a7d8cd;
case 0x0000bdd4:
return 0xd08223e3;
case 0x0000bdd8:
return 0xae2131f8;
case 0x0000bddc:
return 0x972d2087;
case 0x0000bde0:
return 0x4c25429a;
case 0x0000bde4:
return 0xb212af1f;
case 0x0000bde8:
return 0xf7b37e0f;
case 0x0000bdec:
return 0x525697f8;
case 0x0000bdf0:
return 0x0c37202f;
case 0x0000bdf4:
return 0x82d3d1ed;
case 0x0000bdf8:
return 0xa8df2b58;
case 0x0000bdfc:
return 0xe2b01d99;
case 0x0000be00:
return 0xa0333e1c;
case 0x0000be04:
return 0x3f10d03d;
case 0x0000be08:
return 0x3dcf04d2;
case 0x0000be0c:
return 0xa31fdf66;
case 0x0000be10:
return 0xa6609c75;
case 0x0000be14:
return 0xa07b6342;
case 0x0000be18:
return 0x26e1d2fa;
case 0x0000be1c:
return 0xbfc7eb0d;
case 0x0000be20:
return 0x0a005fe0;
case 0x0000be24:
return 0x47747e35;
case 0x0000be28:
return 0x0891e4bb;
case 0x0000be2c:
return 0x44bf8a35;
case 0x0000be30:
return 0x161ef0fd;
case 0x0000be34:
return 0xf8d22294;
case 0x0000be38:
return 0xba989cc5;
case 0x0000be3c:
return 0xe4600346;
case 0x0000be40:
return 0x9f7a10f6;
case 0x0000be44:
return 0xa188a496;
case 0x0000be48:
return 0xb2735462;
case 0x0000be4c:
return 0xdd02e038;
case 0x0000be50:
return 0xd614bd28;
case 0x0000be54:
return 0x0dbdc4ef;
case 0x0000be58:
return 0xb8624e44;
case 0x0000be5c:
return 0x682f2efb;
case 0x0000be60:
return 0xb9d35f03;
case 0x0000be64:
return 0xaab6f624;
case 0x0000be68:
return 0x2d472297;
case 0x0000be6c:
return 0x320e7a1d;
case 0x0000be70:
return 0x472385fc;
case 0x0000be74:
return 0x1a73bfd2;
case 0x0000be78:
return 0xb5f3d70d;
case 0x0000be7c:
return 0x38387df6;
case 0x0000be80:
return 0x981ff234;
case 0x0000be84:
return 0xabbcbef5;
case 0x0000be88:
return 0x425a48ea;
case 0x0000be8c:
return 0x04abe2b6;
case 0x0000be90:
return 0x8a951391;
case 0x0000be94:
return 0xeb6e23df;
case 0x0000be98:
return 0xe78484a6;
case 0x0000be9c:
return 0x90e49817;
case 0x0000bea0:
return 0x565d5dc6;
case 0x0000bea4:
return 0xd80042e9;
case 0x0000bea8:
return 0xd29b86a0;
case 0x0000beac:
return 0x23585fc3;
case 0x0000beb0:
return 0x1abdd4a9;
case 0x0000beb4:
return 0x56c8d9e0;
case 0x0000beb8:
return 0x7db1d2f4;
case 0x0000bebc:
return 0xae4e3e72;
case 0x0000bec0:
return 0x95711d8b;
case 0x0000bec4:
return 0xa98dfc60;
case 0x0000bec8:
return 0x6abd58f4;
case 0x0000becc:
return 0x8fdacbea;
case 0x0000bed0:
return 0x02cf7306;
case 0x0000bed4:
return 0x4eca4f45;
case 0x0000bed8:
return 0xf0a87f89;
case 0x0000bedc:
return 0xe5f479f8;
case 0x0000bee0:
return 0x5427b474;
case 0x0000bee4:
return 0x064c1106;
case 0x0000bee8:
return 0x5c8ac2e4;
case 0x0000beec:
return 0x1087aec4;
case 0x0000bef0:
return 0x1eecfca6;
case 0x0000bef4:
return 0xf196c547;
case 0x0000bef8:
return 0x2098d887;
case 0x0000befc:
return 0xe48a854e;
case 0x0000bf00:
return 0x92d7d28d;
case 0x0000bf04:
return 0x61b6e372;
case 0x0000bf08:
return 0xacf6e9e5;
case 0x0000bf0c:
return 0x9f52c0da;
case 0x0000bf10:
return 0xe6d3a7e0;
case 0x0000bf14:
return 0xd278b24e;
case 0x0000bf18:
return 0xb9b9a4dc;
case 0x0000bf1c:
return 0x26479e2f;
case 0x0000bf20:
return 0xda32c195;
case 0x0000bf24:
return 0x29c1cafd;
case 0x0000bf28:
return 0x043e7bdb;
case 0x0000bf2c:
return 0x1be890c1;
case 0x0000bf30:
return 0x1c15da9a;
case 0x0000bf34:
return 0x6b762ed8;
case 0x0000bf38:
return 0x8063fe67;
case 0x0000bf3c:
return 0x1f35f3db;
case 0x0000bf40:
return 0xaae2a661;
case 0x0000bf44:
return 0xe694fd12;
case 0x0000bf48:
return 0x64bfc1b3;
case 0x0000bf4c:
return 0x1c0eb5e1;
case 0x0000bf50:
return 0x2c2cd322;
case 0x0000bf54:
return 0xc47a5715;
case 0x0000bf58:
return 0xb662ad38;
case 0x0000bf5c:
return 0x26ffad00;
case 0x0000bf60:
return 0xc9478278;
case 0x0000bf64:
return 0xc7232e44;
case 0x0000bf68:
return 0x18dcea7b;
case 0x0000bf6c:
return 0x53fc1701;
case 0x0000bf70:
return 0x57447962;
case 0x0000bf74:
return 0x656cd9a4;
case 0x0000bf78:
return 0xad4bbd07;
case 0x0000bf7c:
return 0x5645c091;
case 0x0000bf80:
return 0xa445e247;
case 0x0000bf84:
return 0x32e7a391;
case 0x0000bf88:
return 0x1991e73f;
case 0x0000bf8c:
return 0x62a7986e;
case 0x0000bf90:
return 0x632f4dbf;
case 0x0000bf94:
return 0x2967b636;
case 0x0000bf98:
return 0xb7e699c3;
case 0x0000bf9c:
return 0x460c55c5;
case 0x0000bfa0:
return 0x9cba0a69;
case 0x0000bfa4:
return 0xc2a953c4;
case 0x0000bfa8:
return 0xabba8ffb;
case 0x0000bfac:
return 0x38a8a7aa;
case 0x0000bfb0:
return 0x8f15a106;
case 0x0000bfb4:
return 0x25e63b6d;
case 0x0000bfb8:
return 0x9d934306;
case 0x0000bfbc:
return 0x19e59658;
case 0x0000bfc0:
return 0x095fffce;
case 0x0000bfc4:
return 0xc6c1d093;
case 0x0000bfc8:
return 0x2ac5293d;
case 0x0000bfcc:
return 0x4856342f;
case 0x0000bfd0:
return 0xfc900318;
case 0x0000bfd4:
return 0xc93630be;
case 0x0000bfd8:
return 0x9c01b7e3;
case 0x0000bfdc:
return 0x97f8dd5b;
case 0x0000bfe0:
return 0xed5febaf;
case 0x0000bfe4:
return 0x117b0ebc;
case 0x0000bfe8:
return 0xf2975a2e;
case 0x0000bfec:
return 0x06f9e03c;
case 0x0000bff0:
return 0x2901ca95;
case 0x0000bff4:
return 0x7023d132;
case 0x0000bff8:
return 0xffcbd638;
case 0x0000bffc:
return 0x98f03016;
case 0x0000c000:
return 0xc7614012;
case 0x0000c004:
return 0x58251d5a;
case 0x0000c008:
return 0xf7df261c;
case 0x0000c00c:
return 0xba5b0f4a;
case 0x0000c010:
return 0x5c50e0c6;
case 0x0000c014:
return 0xb8bb70ae;
case 0x0000c018:
return 0x6a1bba4a;
case 0x0000c01c:
return 0x7183e38c;
case 0x0000c020:
return 0x71d44db1;
case 0x0000c024:
return 0xf4c0daae;
case 0x0000c028:
return 0xbad5e507;
case 0x0000c02c:
return 0xc1327dc9;
case 0x0000c030:
return 0x996ec2e6;
case 0x0000c034:
return 0xaf19bdba;
case 0x0000c038:
return 0x6cdd33ef;
case 0x0000c03c:
return 0xb4509b89;
case 0x0000c040:
return 0x9b9cce2d;
case 0x0000c044:
return 0xd91e9624;
case 0x0000c048:
return 0x8fb7cbd9;
case 0x0000c04c:
return 0xea8e9ad8;
case 0x0000c050:
return 0x6899761c;
case 0x0000c054:
return 0x3d818332;
case 0x0000c058:
return 0x4bcb5aee;
case 0x0000c05c:
return 0x749e8f3e;
case 0x0000c060:
return 0xe15ac92f;
case 0x0000c064:
return 0xc5da16c1;
case 0x0000c068:
return 0x1b0057c0;
case 0x0000c06c:
return 0x64404bd7;
case 0x0000c070:
return 0x04bc8108;
case 0x0000c074:
return 0xdee20742;
case 0x0000c078:
return 0xf51c1ac3;
case 0x0000c07c:
return 0x6b2c2f8a;
case 0x0000c080:
return 0x81120fba;
case 0x0000c084:
return 0xad5c8b61;
case 0x0000c088:
return 0xb89f03d9;
case 0x0000c08c:
return 0xc7898d37;
case 0x0000c090:
return 0x2a2d4ecb;
case 0x0000c094:
return 0x5e482e95;
case 0x0000c098:
return 0xed41d4da;
case 0x0000c09c:
return 0x6c78aaef;
case 0x0000c0a0:
return 0xb5d8c46d;
case 0x0000c0a4:
return 0xe9973bf8;
case 0x0000c0a8:
return 0xaaedce61;
case 0x0000c0ac:
return 0x14edc59d;
case 0x0000c0b0:
return 0x8af08148;
case 0x0000c0b4:
return 0x2629f7bf;
case 0x0000c0b8:
return 0xb0f3ab31;
case 0x0000c0bc:
return 0xf968908b;
case 0x0000c0c0:
return 0xa76edbef;
case 0x0000c0c4:
return 0x1247fb28;
case 0x0000c0c8:
return 0xac50c6cf;
case 0x0000c0cc:
return 0xe1df8d6b;
case 0x0000c0d0:
return 0xe9c86b3e;
case 0x0000c0d4:
return 0x0f74b342;
case 0x0000c0d8:
return 0xb8abc2e5;
case 0x0000c0dc:
return 0x6220a15b;
case 0x0000c0e0:
return 0xf238a51d;
case 0x0000c0e4:
return 0x2418beb1;
case 0x0000c0e8:
return 0x57b7ea59;
case 0x0000c0ec:
return 0x21c33dc8;
case 0x0000c0f0:
return 0xccadf20f;
case 0x0000c0f4:
return 0x5c974113;
case 0x0000c0f8:
return 0x07a8bc0b;
case 0x0000c0fc:
return 0xffccac8f;
case 0x0000c100:
return 0x683e22bc;
case 0x0000c104:
return 0x1f9434ce;
case 0x0000c108:
return 0x1583542e;
case 0x0000c10c:
return 0x2060a28f;
case 0x0000c110:
return 0xc5f43134;
case 0x0000c114:
return 0xe48079d7;
case 0x0000c118:
return 0xca4ea2d0;
case 0x0000c11c:
return 0x0aeb4825;
case 0x0000c120:
return 0xac5392cd;
case 0x0000c124:
return 0x21f16800;
case 0x0000c128:
return 0xf43c24c4;
case 0x0000c12c:
return 0xda088f3a;
case 0x0000c130:
return 0xa80c711e;
case 0x0000c134:
return 0x50d57fb8;
case 0x0000c138:
return 0x0d58305a;
case 0x0000c13c:
return 0x9b3ba5a1;
case 0x0000c140:
return 0xe85d9e7c;
case 0x0000c144:
return 0x395f1b6f;
case 0x0000c148:
return 0xb92fea39;
case 0x0000c14c:
return 0x0dfa15f7;
case 0x0000c150:
return 0x32db043f;
case 0x0000c154:
return 0x8067df1d;
case 0x0000c158:
return 0x9545fda2;
case 0x0000c15c:
return 0x8e3e86b6;
case 0x0000c160:
return 0xa0b62fd6;
case 0x0000c164:
return 0x3636f12a;
case 0x0000c168:
return 0xf169a2e8;
case 0x0000c16c:
return 0x0006ee51;
case 0x0000c170:
return 0x4b61c959;
case 0x0000c174:
return 0xed4f6a39;
case 0x0000c178:
return 0x44785ffd;
case 0x0000c17c:
return 0xaed015dc;
case 0x0000c180:
return 0x97f1d32f;
case 0x0000c184:
return 0xf7ebb822;
case 0x0000c188:
return 0xd3c294f0;
case 0x0000c18c:
return 0x12fca77a;
case 0x0000c190:
return 0x119e5ae8;
case 0x0000c194:
return 0x2211a43e;
case 0x0000c198:
return 0xc71dbe68;
case 0x0000c19c:
return 0x90e5183a;
case 0x0000c1a0:
return 0x89cabc9d;
case 0x0000c1a4:
return 0x214f5d0a;
case 0x0000c1a8:
return 0xb24402af;
case 0x0000c1ac:
return 0xb54b93f4;
case 0x0000c1b0:
return 0x40af66a3;
case 0x0000c1b4:
return 0x08dc0b82;
case 0x0000c1b8:
return 0x0703f3b9;
case 0x0000c1bc:
return 0xa70bcdf1;
case 0x0000c1c0:
return 0x3876f65d;
case 0x0000c1c4:
return 0x63fa47e3;
case 0x0000c1c8:
return 0x7480d4d8;
case 0x0000c1cc:
return 0xeeab95a1;
case 0x0000c1d0:
return 0x1c16614d;
case 0x0000c1d4:
return 0x604512f6;
case 0x0000c1d8:
return 0xfc6303bf;
case 0x0000c1dc:
return 0x597adb33;
case 0x0000c1e0:
return 0x8d8ed612;
case 0x0000c1e4:
return 0xd6e61619;
case 0x0000c1e8:
return 0xd0ea64f9;
case 0x0000c1ec:
return 0x4bc69a17;
case 0x0000c1f0:
return 0xcaaef224;
case 0x0000c1f4:
return 0xef55113d;
case 0x0000c1f8:
return 0x7e483a89;
case 0x0000c1fc:
return 0xc49b9347;
case 0x0000c200:
return 0x3f44a44e;
case 0x0000c204:
return 0xbfd7aeaa;
case 0x0000c208:
return 0xc1981c8f;
case 0x0000c20c:
return 0x0201b58d;
case 0x0000c210:
return 0xacec61f2;
case 0x0000c214:
return 0x05223b65;
case 0x0000c218:
return 0x6a340305;
case 0x0000c21c:
return 0x305684e7;
case 0x0000c220:
return 0x34055e9f;
case 0x0000c224:
return 0x63e0650c;
case 0x0000c228:
return 0xb6f5fec5;
case 0x0000c22c:
return 0xb9941943;
case 0x0000c230:
return 0x9c81b160;
case 0x0000c234:
return 0x7e696069;
case 0x0000c238:
return 0x4fe4229f;
case 0x0000c23c:
return 0x6d33147e;
case 0x0000c240:
return 0x4cdb8dd7;
case 0x0000c244:
return 0x9c897f5b;
case 0x0000c248:
return 0x91cccc3c;
case 0x0000c24c:
return 0x3780e95b;
case 0x0000c250:
return 0xb7964435;
case 0x0000c254:
return 0xbf289eb8;
case 0x0000c258:
return 0xe42c2920;
case 0x0000c25c:
return 0xd6fe1fc6;
case 0x0000c260:
return 0xc62ab380;
case 0x0000c264:
return 0x820a9903;
case 0x0000c268:
return 0x60f9d61b;
case 0x0000c26c:
return 0xac22192a;
case 0x0000c270:
return 0x1236bf0c;
case 0x0000c274:
return 0x67595d82;
case 0x0000c278:
return 0x31c4a634;
case 0x0000c27c:
return 0xd228d55e;
case 0x0000c280:
return 0x126f37d5;
case 0x0000c284:
return 0xfbd03058;
case 0x0000c288:
return 0x0c82b6e6;
case 0x0000c28c:
return 0xf79552e7;
case 0x0000c290:
return 0xd34a6181;
case 0x0000c294:
return 0xae04f723;
case 0x0000c298:
return 0x45fd34a9;
case 0x0000c29c:
return 0x16073845;
case 0x0000c2a0:
return 0x2c0d3072;
case 0x0000c2a4:
return 0xa1c6b3be;
case 0x0000c2a8:
return 0xd782d65e;
case 0x0000c2ac:
return 0xeb64b3b4;
case 0x0000c2b0:
return 0xc38e4a25;
case 0x0000c2b4:
return 0x57e6dd23;
case 0x0000c2b8:
return 0x68716c7a;
case 0x0000c2bc:
return 0x8a0a6384;
case 0x0000c2c0:
return 0x94883cad;
case 0x0000c2c4:
return 0xc5afc5ee;
case 0x0000c2c8:
return 0x7f21d95c;
case 0x0000c2cc:
return 0xa3ac2c72;
case 0x0000c2d0:
return 0x9e9d4258;
case 0x0000c2d4:
return 0x6755c6c0;
case 0x0000c2d8:
return 0x3ad1c15d;
case 0x0000c2dc:
return 0x9670dce0;
case 0x0000c2e0:
return 0x938dacf3;
case 0x0000c2e4:
return 0x57a2593a;
case 0x0000c2e8:
return 0xa3e52bb4;
case 0x0000c2ec:
return 0xf37f8b58;
case 0x0000c2f0:
return 0xa2b1ba8e;
case 0x0000c2f4:
return 0x7973b5f8;
case 0x0000c2f8:
return 0xd8c4eded;
case 0x0000c2fc:
return 0x27e9c0c2;
case 0x0000c300:
return 0x07cfffb7;
case 0x0000c304:
return 0xbd6e047c;
case 0x0000c308:
return 0x949e9ee0;
case 0x0000c30c:
return 0x05ebdb04;
case 0x0000c310:
return 0x3517a2cc;
case 0x0000c314:
return 0x6cc9ce86;
case 0x0000c318:
return 0x538cd6c2;
case 0x0000c31c:
return 0xc09c4b1f;
case 0x0000c320:
return 0x35cdd47b;
case 0x0000c324:
return 0x4da0bc71;
case 0x0000c328:
return 0x9e96d9d9;
case 0x0000c32c:
return 0x077dda93;
case 0x0000c330:
return 0x4e0bec22;
case 0x0000c334:
return 0xb6ba0fe2;
case 0x0000c338:
return 0xd0e8d41c;
case 0x0000c33c:
return 0x900b563d;
case 0x0000c340:
return 0x37fa8d68;
case 0x0000c344:
return 0x9ba4d78d;
case 0x0000c348:
return 0x5f64e113;
case 0x0000c34c:
return 0xbbb9fa77;
case 0x0000c350:
return 0xd9244ee2;
case 0x0000c354:
return 0x09ef8240;
case 0x0000c358:
return 0xd5aadd06;
case 0x0000c35c:
return 0xb5c86d01;
case 0x0000c360:
return 0xc6a4b1f0;
case 0x0000c364:
return 0xe6ec0fb1;
case 0x0000c368:
return 0x61047d3f;
case 0x0000c36c:
return 0xf987e943;
case 0x0000c370:
return 0xcc74a463;
case 0x0000c374:
return 0xbc9fad60;
case 0x0000c378:
return 0xf6ea1590;
case 0x0000c37c:
return 0x86be3027;
case 0x0000c380:
return 0x358396ba;
case 0x0000c384:
return 0x742ffdea;
case 0x0000c388:
return 0x1e4fe32a;
case 0x0000c38c:
return 0xe1e09d3a;
case 0x0000c390:
return 0xdc04e990;
case 0x0000c394:
return 0x5ba9c0f6;
case 0x0000c398:
return 0x3e621f60;
case 0x0000c39c:
return 0x28358c13;
case 0x0000c3a0:
return 0x4532f510;
case 0x0000c3a4:
return 0x68033305;
case 0x0000c3a8:
return 0x451c2140;
case 0x0000c3ac:
return 0xadeca778;
case 0x0000c3b0:
return 0xc29e0a0b;
case 0x0000c3b4:
return 0xc7c040f9;
case 0x0000c3b8:
return 0xa95c7c7a;
case 0x0000c3bc:
return 0xb344de66;
case 0x0000c3c0:
return 0xb7479ee4;
case 0x0000c3c4:
return 0xdfe35de5;
case 0x0000c3c8:
return 0x8e509815;
case 0x0000c3cc:
return 0x42dd53e5;
case 0x0000c3d0:
return 0x36f8c48c;
case 0x0000c3d4:
return 0x93c782d7;
case 0x0000c3d8:
return 0xfe7917e1;
case 0x0000c3dc:
return 0xb73034a1;
case 0x0000c3e0:
return 0x24a69b12;
case 0x0000c3e4:
return 0xfa6a623e;
case 0x0000c3e8:
return 0x6edaf846;
case 0x0000c3ec:
return 0x061f6e5f;
case 0x0000c3f0:
return 0x4d15450a;
case 0x0000c3f4:
return 0x31b309f8;
case 0x0000c3f8:
return 0x089886e6;
case 0x0000c3fc:
return 0x165cc010;
case 0x0000c400:
return 0x3acac0ea;
case 0x0000c404:
return 0xd32e856a;
case 0x0000c408:
return 0xf1ede45a;
case 0x0000c40c:
return 0xdea45997;
case 0x0000c410:
return 0x5b0142e8;
case 0x0000c414:
return 0xad5365dd;
case 0x0000c418:
return 0x61745dd8;
case 0x0000c41c:
return 0x2c9eba6a;
case 0x0000c420:
return 0x4e52f0d9;
case 0x0000c424:
return 0x5feba316;
case 0x0000c428:
return 0x28877ac4;
case 0x0000c42c:
return 0xebda2f03;
case 0x0000c430:
return 0x8daae201;
case 0x0000c434:
return 0xb087b9b4;
case 0x0000c438:
return 0xd2fdd2e5;
case 0x0000c43c:
return 0x0c1055fc;
case 0x0000c440:
return 0x77ed3091;
case 0x0000c444:
return 0x58889ba0;
case 0x0000c448:
return 0x1f058195;
case 0x0000c44c:
return 0x7e6d7d81;
case 0x0000c450:
return 0xae596b5b;
case 0x0000c454:
return 0x726a0fb9;
case 0x0000c458:
return 0x02b8de55;
case 0x0000c45c:
return 0xa3cb2e8a;
case 0x0000c460:
return 0x217d2527;
case 0x0000c464:
return 0xaa3e73f7;
case 0x0000c468:
return 0x0faad647;
case 0x0000c46c:
return 0xe94ceeff;
case 0x0000c470:
return 0x84483934;
case 0x0000c474:
return 0xe369a93f;
case 0x0000c478:
return 0x2ebf7524;
case 0x0000c47c:
return 0xd2abac6a;
case 0x0000c480:
return 0x23e6d6d7;
case 0x0000c484:
return 0x9d2400aa;
case 0x0000c488:
return 0x98f89516;
case 0x0000c48c:
return 0x7ca40710;
case 0x0000c490:
return 0x989d9fb3;
case 0x0000c494:
return 0x9e7daf1f;
case 0x0000c498:
return 0x06a71389;
case 0x0000c49c:
return 0x9b1cca99;
case 0x0000c4a0:
return 0xcde8fb89;
case 0x0000c4a4:
return 0x698d3112;
case 0x0000c4a8:
return 0x8cbd13ab;
case 0x0000c4ac:
return 0x17bfa5b9;
case 0x0000c4b0:
return 0xee536242;
case 0x0000c4b4:
return 0x5545e831;
case 0x0000c4b8:
return 0x0a884bd2;
case 0x0000c4bc:
return 0xc16f7fdf;
case 0x0000c4c0:
return 0x641f00ca;
case 0x0000c4c4:
return 0x541f7f9d;
case 0x0000c4c8:
return 0x31afbcf1;
case 0x0000c4cc:
return 0xf4d37b6c;
case 0x0000c4d0:
return 0xbefe80ba;
case 0x0000c4d4:
return 0x2e034716;
case 0x0000c4d8:
return 0xf07868b8;
case 0x0000c4dc:
return 0x3c223221;
case 0x0000c4e0:
return 0x77982855;
case 0x0000c4e4:
return 0x77c6f847;
case 0x0000c4e8:
return 0x74b24803;
case 0x0000c4ec:
return 0x2a6e5ee1;
case 0x0000c4f0:
return 0xbd38a238;
case 0x0000c4f4:
return 0x25a46f94;
case 0x0000c4f8:
return 0xc22ff78f;
case 0x0000c4fc:
return 0xeafae296;
case 0x0000c500:
return 0xe28e3b65;
case 0x0000c504:
return 0xf061ddf1;
case 0x0000c508:
return 0x1a62246f;
case 0x0000c50c:
return 0xf0ad3f06;
case 0x0000c510:
return 0xc7fe8f9a;
case 0x0000c514:
return 0x590096c4;
case 0x0000c518:
return 0xe050fbee;
case 0x0000c51c:
return 0xf09d9673;
case 0x0000c520:
return 0x935cfa25;
case 0x0000c524:
return 0xcd494b75;
case 0x0000c528:
return 0x6798377f;
case 0x0000c52c:
return 0x747a51fd;
case 0x0000c530:
return 0xf9c212f5;
case 0x0000c534:
return 0xb53211b5;
case 0x0000c538:
return 0xe465b9b8;
case 0x0000c53c:
return 0xed5474e2;
case 0x0000c540:
return 0x5402adb0;
case 0x0000c544:
return 0x04b67914;
case 0x0000c548:
return 0x8a2d75e8;
case 0x0000c54c:
return 0x6d92320e;
case 0x0000c550:
return 0xdee89522;
case 0x0000c554:
return 0x4bb67991;
case 0x0000c558:
return 0xf9f2f390;
case 0x0000c55c:
return 0x59da9621;
case 0x0000c560:
return 0x9bae0517;
case 0x0000c564:
return 0x1ae8c8f4;
case 0x0000c568:
return 0x3b2954f3;
case 0x0000c56c:
return 0xfd261bf0;
case 0x0000c570:
return 0x54ae1d09;
case 0x0000c574:
return 0xcb88cb0c;
case 0x0000c578:
return 0x8758d877;
case 0x0000c57c:
return 0xfae092b4;
case 0x0000c580:
return 0xf38c2f95;
case 0x0000c584:
return 0xcd288de1;
case 0x0000c588:
return 0x120dc1f8;
case 0x0000c58c:
return 0x84e11e6b;
case 0x0000c590:
return 0xcac2cd81;
case 0x0000c594:
return 0x83a63aea;
case 0x0000c598:
return 0xea18bad1;
case 0x0000c59c:
return 0x4d50f341;
case 0x0000c5a0:
return 0x247a6dc4;
case 0x0000c5a4:
return 0xc90e09ac;
case 0x0000c5a8:
return 0x15e72675;
case 0x0000c5ac:
return 0xcea396fc;
case 0x0000c5b0:
return 0xa16ad4bf;
case 0x0000c5b4:
return 0xfbf37ff3;
case 0x0000c5b8:
return 0x4fb6197f;
case 0x0000c5bc:
return 0xe921bc82;
case 0x0000c5c0:
return 0x3f33186d;
case 0x0000c5c4:
return 0x1d8fada3;
case 0x0000c5c8:
return 0x2017eba8;
case 0x0000c5cc:
return 0xe6592ed8;
case 0x0000c5d0:
return 0x278c115a;
case 0x0000c5d4:
return 0xad62bece;
case 0x0000c5d8:
return 0x9b895c42;
case 0x0000c5dc:
return 0x674dcb5a;
case 0x0000c5e0:
return 0x33ebdeb2;
case 0x0000c5e4:
return 0xb778fe73;
case 0x0000c5e8:
return 0xf465d332;
case 0x0000c5ec:
return 0xd0bf8253;
case 0x0000c5f0:
return 0x256d129b;
case 0x0000c5f4:
return 0xffb0d6c9;
case 0x0000c5f8:
return 0x677d8594;
case 0x0000c5fc:
return 0x0e72528b;
case 0x0000c600:
return 0xeeb920fe;
case 0x0000c604:
return 0x1b95b2c9;
case 0x0000c608:
return 0x02042512;
case 0x0000c60c:
return 0xadadb195;
case 0x0000c610:
return 0x8d3ddd1f;
case 0x0000c614:
return 0x7b9526cb;
case 0x0000c618:
return 0x0217117a;
case 0x0000c61c:
return 0xdf417b4e;
case 0x0000c620:
return 0xcc4e61c9;
case 0x0000c624:
return 0x680ec04e;
case 0x0000c628:
return 0xdd1400a6;
case 0x0000c62c:
return 0x92ccd8a7;
case 0x0000c630:
return 0xdb993444;
case 0x0000c634:
return 0x339fca33;
case 0x0000c638:
return 0x45a6be19;
case 0x0000c63c:
return 0x592c7cbb;
case 0x0000c640:
return 0x00709976;
case 0x0000c644:
return 0xe181f2c5;
case 0x0000c648:
return 0x0468288f;
case 0x0000c64c:
return 0x2c4ec2be;
case 0x0000c650:
return 0xee9e89ae;
case 0x0000c654:
return 0xaeed5b74;
case 0x0000c658:
return 0x244a539c;
case 0x0000c65c:
return 0x37921cd6;
case 0x0000c660:
return 0xaef9aefd;
case 0x0000c664:
return 0x1eb84155;
case 0x0000c668:
return 0x6227fd87;
case 0x0000c66c:
return 0x24d2d03d;
case 0x0000c670:
return 0x91cb8214;
case 0x0000c674:
return 0xf4c1b38c;
case 0x0000c678:
return 0xde9a6e06;
case 0x0000c67c:
return 0x50bffddd;
case 0x0000c680:
return 0x96ad7460;
case 0x0000c684:
return 0x5007cdf8;
case 0x0000c688:
return 0x367edafe;
case 0x0000c68c:
return 0x670eb765;
case 0x0000c690:
return 0x9dc4c46b;
case 0x0000c694:
return 0xda6838b3;
case 0x0000c698:
return 0x54e95a7f;
case 0x0000c69c:
return 0xc3dacb80;
case 0x0000c6a0:
return 0x42aa696a;
case 0x0000c6a4:
return 0x79711029;
case 0x0000c6a8:
return 0x11a110d9;
case 0x0000c6ac:
return 0x83a90f9c;
case 0x0000c6b0:
return 0xcc03365d;
case 0x0000c6b4:
return 0x55e91698;
case 0x0000c6b8:
return 0x3992058f;
case 0x0000c6bc:
return 0xbaf65d75;
case 0x0000c6c0:
return 0x5cec318e;
case 0x0000c6c4:
return 0xcf475590;
case 0x0000c6c8:
return 0x8364dcb5;
case 0x0000c6cc:
return 0xb70630c5;
case 0x0000c6d0:
return 0xd5927718;
case 0x0000c6d4:
return 0x92ac02a3;
case 0x0000c6d8:
return 0xeddcf83e;
case 0x0000c6dc:
return 0x6e10d605;
case 0x0000c6e0:
return 0xe3cad9fd;
case 0x0000c6e4:
return 0x59cf5347;
case 0x0000c6e8:
return 0x0681f85e;
case 0x0000c6ec:
return 0xf75d57d9;
case 0x0000c6f0:
return 0xf305c193;
case 0x0000c6f4:
return 0x6aaf1391;
case 0x0000c6f8:
return 0x52367717;
case 0x0000c6fc:
return 0xdee7f9c8;
case 0x0000c700:
return 0x35e8a519;
case 0x0000c704:
return 0x42f070ee;
case 0x0000c708:
return 0x7a82fd3d;
case 0x0000c70c:
return 0xb45afeb4;
case 0x0000c710:
return 0x680c4492;
case 0x0000c714:
return 0x2bc60a58;
case 0x0000c718:
return 0x68e70fd5;
case 0x0000c71c:
return 0x8b2e56ba;
case 0x0000c720:
return 0x3ce2633c;
case 0x0000c724:
return 0x38fbe573;
case 0x0000c728:
return 0x714ffff1;
case 0x0000c72c:
return 0xd7007b3b;
case 0x0000c730:
return 0xdbdc7af6;
case 0x0000c734:
return 0xb6aa6b63;
case 0x0000c738:
return 0xd6e729f6;
case 0x0000c73c:
return 0xc049b2ac;
case 0x0000c740:
return 0xc1254a44;
case 0x0000c744:
return 0xc1d261d5;
case 0x0000c748:
return 0xbab032ce;
case 0x0000c74c:
return 0xd69ddbca;
case 0x0000c750:
return 0xef36b258;
case 0x0000c754:
return 0x926cb697;
case 0x0000c758:
return 0x9239b7d6;
case 0x0000c75c:
return 0x67c37c5c;
case 0x0000c760:
return 0x977d1d57;
case 0x0000c764:
return 0xf0fd2902;
case 0x0000c768:
return 0xb26e7c37;
case 0x0000c76c:
return 0x027fc839;
case 0x0000c770:
return 0xa9858004;
case 0x0000c774:
return 0x6ce08243;
case 0x0000c778:
return 0xd73b84d4;
case 0x0000c77c:
return 0xa086e478;
case 0x0000c780:
return 0x95fee645;
case 0x0000c784:
return 0xa152be71;
case 0x0000c788:
return 0x3a9d958e;
case 0x0000c78c:
return 0x2daade4b;
case 0x0000c790:
return 0xfc44d158;
case 0x0000c794:
return 0xf75638a2;
case 0x0000c798:
return 0xe6b15021;
case 0x0000c79c:
return 0x7e6aa791;
case 0x0000c7a0:
return 0xb807818b;
case 0x0000c7a4:
return 0x7dba4119;
case 0x0000c7a8:
return 0x2f9c5fcc;
case 0x0000c7ac:
return 0x0463c298;
case 0x0000c7b0:
return 0xf10fde6f;
case 0x0000c7b4:
return 0xfba07538;
case 0x0000c7b8:
return 0x8802f244;
case 0x0000c7bc:
return 0x77b229e8;
case 0x0000c7c0:
return 0x2dbe2c5c;
case 0x0000c7c4:
return 0xf02e5f63;
case 0x0000c7c8:
return 0x531f3dcd;
case 0x0000c7cc:
return 0xd1f83c45;
case 0x0000c7d0:
return 0x6ff202a4;
case 0x0000c7d4:
return 0xdfae3dc6;
case 0x0000c7d8:
return 0x599e6bd9;
case 0x0000c7dc:
return 0x69d70d62;
case 0x0000c7e0:
return 0x07a11fa9;
case 0x0000c7e4:
return 0x21c93e07;
case 0x0000c7e8:
return 0xa203fc09;
case 0x0000c7ec:
return 0x877a5038;
case 0x0000c7f0:
return 0x037673f5;
case 0x0000c7f4:
return 0x3565354f;
case 0x0000c7f8:
return 0x44ebb7d2;
case 0x0000c7fc:
return 0x7bd25b8b;
case 0x0000c800:
return 0x0df014a9;
case 0x0000c804:
return 0x42616acd;
case 0x0000c808:
return 0x2ee91a81;
case 0x0000c80c:
return 0x23b780e4;
case 0x0000c810:
return 0x7ffe4659;
case 0x0000c814:
return 0xdf1a4b8e;
case 0x0000c818:
return 0x19612dea;
case 0x0000c81c:
return 0xb6de335a;
case 0x0000c820:
return 0x32985f02;
case 0x0000c824:
return 0x9f68dd83;
case 0x0000c828:
return 0x3350c75f;
case 0x0000c82c:
return 0x06d26641;
case 0x0000c830:
return 0xf4b537b4;
case 0x0000c834:
return 0xc83b6fd3;
case 0x0000c838:
return 0xb400b68f;
case 0x0000c83c:
return 0x64ba663d;
case 0x0000c840:
return 0x87e36fac;
case 0x0000c844:
return 0x79733187;
case 0x0000c848:
return 0x5f22a373;
case 0x0000c84c:
return 0xedfe9b68;
case 0x0000c850:
return 0x88818213;
case 0x0000c854:
return 0xcc06c3c8;
case 0x0000c858:
return 0xdf0d8c60;
case 0x0000c85c:
return 0xcbc62cc1;
case 0x0000c860:
return 0xc6f612e5;
case 0x0000c864:
return 0xdef47733;
case 0x0000c868:
return 0x379a9ad0;
case 0x0000c86c:
return 0x53244e66;
case 0x0000c870:
return 0xb7492cba;
case 0x0000c874:
return 0x273516ad;
case 0x0000c878:
return 0xef518897;
case 0x0000c87c:
return 0x1bb5ecb6;
case 0x0000c880:
return 0x39219538;
case 0x0000c884:
return 0x054cb0f4;
case 0x0000c888:
return 0x99dad710;
case 0x0000c88c:
return 0x196db12f;
case 0x0000c890:
return 0x76f6cc79;
case 0x0000c894:
return 0x7809f77a;
case 0x0000c898:
return 0x2fdb2e64;
case 0x0000c89c:
return 0x9ef8c90a;
case 0x0000c8a0:
return 0xd5386600;
case 0x0000c8a4:
return 0x89d3b27a;
case 0x0000c8a8:
return 0x586ca132;
case 0x0000c8ac:
return 0xc4aadf74;
case 0x0000c8b0:
return 0x6a6a894e;
case 0x0000c8b4:
return 0x32ee866b;
case 0x0000c8b8:
return 0x83583385;
case 0x0000c8bc:
return 0xea780f6e;
case 0x0000c8c0:
return 0x3ab026b5;
case 0x0000c8c4:
return 0xf445a2e8;
case 0x0000c8c8:
return 0xd8aad38a;
case 0x0000c8cc:
return 0xd3fd3865;
case 0x0000c8d0:
return 0x3bd5d537;
case 0x0000c8d4:
return 0xd0b9766e;
case 0x0000c8d8:
return 0xe949d1d8;
case 0x0000c8dc:
return 0x5de326cf;
case 0x0000c8e0:
return 0xfc4a29a6;
case 0x0000c8e4:
return 0xe17dde88;
case 0x0000c8e8:
return 0xf5424508;
case 0x0000c8ec:
return 0x8ade4abb;
case 0x0000c8f0:
return 0x7909c237;
case 0x0000c8f4:
return 0x1d1c3e07;
case 0x0000c8f8:
return 0xbefbb9ec;
case 0x0000c8fc:
return 0x62a33bc1;
case 0x0000c900:
return 0x42dd7278;
case 0x0000c904:
return 0x79bdecf9;
case 0x0000c908:
return 0xea60daef;
case 0x0000c90c:
return 0x4d2acf7e;
case 0x0000c910:
return 0xa3745777;
case 0x0000c914:
return 0x89d76346;
case 0x0000c918:
return 0x5d4dbbcc;
case 0x0000c91c:
return 0x0c1a9fdd;
case 0x0000c920:
return 0x78ec303b;
case 0x0000c924:
return 0x330c49bd;
case 0x0000c928:
return 0x61a2c103;
case 0x0000c92c:
return 0x0f03959b;
case 0x0000c930:
return 0x1bd5148c;
case 0x0000c934:
return 0x8b0fe012;
case 0x0000c938:
return 0xfea8463c;
case 0x0000c93c:
return 0x11c313db;
case 0x0000c940:
return 0xd78425f5;
case 0x0000c944:
return 0x7160bda8;
case 0x0000c948:
return 0x390145d0;
case 0x0000c94c:
return 0x22f4b636;
case 0x0000c950:
return 0x26599194;
case 0x0000c954:
return 0x3c7dcc35;
case 0x0000c958:
return 0x53ec894e;
case 0x0000c95c:
return 0xe0445969;
case 0x0000c960:
return 0x57e510ef;
case 0x0000c964:
return 0xfb5cf9d2;
case 0x0000c968:
return 0xca59e354;
case 0x0000c96c:
return 0x3374f3b7;
case 0x0000c970:
return 0x6ff26365;
case 0x0000c974:
return 0xa4b2dc95;
case 0x0000c978:
return 0xcc40134c;
case 0x0000c97c:
return 0x70f39c37;
case 0x0000c980:
return 0xf44a2f01;
case 0x0000c984:
return 0xe7abddb8;
case 0x0000c988:
return 0x77f40516;
case 0x0000c98c:
return 0xd16e8dc1;
case 0x0000c990:
return 0xd61e86f7;
case 0x0000c994:
return 0xe99571c4;
case 0x0000c998:
return 0x0e9ba693;
case 0x0000c99c:
return 0xb8920c88;
case 0x0000c9a0:
return 0x0b6fe233;
case 0x0000c9a4:
return 0x384cf6dc;
case 0x0000c9a8:
return 0xdb690d1a;
case 0x0000c9ac:
return 0xcde93e9f;
case 0x0000c9b0:
return 0x95b73d91;
case 0x0000c9b4:
return 0x3530742d;
case 0x0000c9b8:
return 0x3196884d;
case 0x0000c9bc:
return 0x8cbd0b1d;
case 0x0000c9c0:
return 0x7cebde43;
case 0x0000c9c4:
return 0x4605c76b;
case 0x0000c9c8:
return 0x9392584c;
case 0x0000c9cc:
return 0xfadfa8fa;
case 0x0000c9d0:
return 0x268b11d0;
case 0x0000c9d4:
return 0x40b4255f;
case 0x0000c9d8:
return 0xb34bcaa7;
case 0x0000c9dc:
return 0xf7a260fc;
case 0x0000c9e0:
return 0x033d94a2;
case 0x0000c9e4:
return 0xa6e75bae;
case 0x0000c9e8:
return 0xacbcc0fe;
case 0x0000c9ec:
return 0xc232aaf2;
case 0x0000c9f0:
return 0x8b0e2e4d;
case 0x0000c9f4:
return 0x37a2519d;
case 0x0000c9f8:
return 0x77ddce5f;
case 0x0000c9fc:
return 0xeefe55a7;
case 0x0000ca00:
return 0xd73c43d5;
case 0x0000ca04:
return 0x348a94ed;
case 0x0000ca08:
return 0x961aeb26;
case 0x0000ca0c:
return 0xfa0a3598;
case 0x0000ca10:
return 0x7531954a;
case 0x0000ca14:
return 0x8bc9342d;
case 0x0000ca18:
return 0x1907a086;
case 0x0000ca1c:
return 0x22fa2acd;
case 0x0000ca20:
return 0x020f3d33;
case 0x0000ca24:
return 0x9b19c690;
case 0x0000ca28:
return 0x41847a4e;
case 0x0000ca2c:
return 0x94bea402;
case 0x0000ca30:
return 0x3de9a6e5;
case 0x0000ca34:
return 0x78a4fd6d;
case 0x0000ca38:
return 0x09b7b39a;
case 0x0000ca3c:
return 0xa2481b27;
case 0x0000ca40:
return 0x56257526;
case 0x0000ca44:
return 0xba3abedc;
case 0x0000ca48:
return 0xa99a7d18;
case 0x0000ca4c:
return 0xb108dd52;
case 0x0000ca50:
return 0x379e9e26;
case 0x0000ca54:
return 0x8afe6b07;
case 0x0000ca58:
return 0x85d1a87a;
case 0x0000ca5c:
return 0x29198dc1;
case 0x0000ca60:
return 0x9ae28bd1;
case 0x0000ca64:
return 0x88bb1a96;
case 0x0000ca68:
return 0x69380a14;
case 0x0000ca6c:
return 0xa556a185;
case 0x0000ca70:
return 0x156c514d;
case 0x0000ca74:
return 0x717af4d2;
case 0x0000ca78:
return 0x27e94c64;
case 0x0000ca7c:
return 0xd19da38c;
case 0x0000ca80:
return 0x1934a158;
case 0x0000ca84:
return 0xa342d38b;
case 0x0000ca88:
return 0x664bf1f7;
case 0x0000ca8c:
return 0x0f2c273e;
case 0x0000ca90:
return 0x4e5d35bf;
case 0x0000ca94:
return 0x1dc7758e;
case 0x0000ca98:
return 0xb569e6e8;
case 0x0000ca9c:
return 0x06c48109;
case 0x0000caa0:
return 0x6ed5ed06;
case 0x0000caa4:
return 0xc4ffa543;
case 0x0000caa8:
return 0xdf128027;
case 0x0000caac:
return 0xa6e9f088;
case 0x0000cab0:
return 0x525a4f30;
case 0x0000cab4:
return 0x0141d3bf;
case 0x0000cab8:
return 0xcbd75a69;
case 0x0000cabc:
return 0x57580077;
case 0x0000cac0:
return 0x27d93e12;
case 0x0000cac4:
return 0x7d7b7f65;
case 0x0000cac8:
return 0x7535a6b8;
case 0x0000cacc:
return 0xb6ebacf9;
case 0x0000cad0:
return 0xfa5c63c9;
case 0x0000cad4:
return 0x567c3534;
case 0x0000cad8:
return 0x4de30486;
case 0x0000cadc:
return 0x04df2561;
case 0x0000cae0:
return 0xf74e00da;
case 0x0000cae4:
return 0x35d1f202;
case 0x0000cae8:
return 0x98cda51d;
case 0x0000caec:
return 0x0aa93d66;
case 0x0000caf0:
return 0x422716fe;
case 0x0000caf4:
return 0x7874e7e0;
case 0x0000caf8:
return 0xf1c95c32;
case 0x0000cafc:
return 0x35bcec0a;
case 0x0000cb00:
return 0xac4b1084;
case 0x0000cb04:
return 0xab6cb216;
case 0x0000cb08:
return 0xba02a493;
case 0x0000cb0c:
return 0xbf364d6d;
case 0x0000cb10:
return 0x807ee397;
case 0x0000cb14:
return 0x7ff012d5;
case 0x0000cb18:
return 0xbc5aa399;
case 0x0000cb1c:
return 0xdabcd244;
case 0x0000cb20:
return 0x55b161c1;
case 0x0000cb24:
return 0x4bd724c0;
case 0x0000cb28:
return 0x715354d6;
case 0x0000cb2c:
return 0xd25ef7b2;
case 0x0000cb30:
return 0xb8db7344;
case 0x0000cb34:
return 0x14370a6c;
case 0x0000cb38:
return 0x82e2e2c7;
case 0x0000cb3c:
return 0x3c3f35b7;
case 0x0000cb40:
return 0x655eaddf;
case 0x0000cb44:
return 0xec9c896d;
case 0x0000cb48:
return 0x6930c57f;
case 0x0000cb4c:
return 0x5fb9f722;
case 0x0000cb50:
return 0x633ab488;
case 0x0000cb54:
return 0xf953af1b;
case 0x0000cb58:
return 0xb875af77;
case 0x0000cb5c:
return 0x58a0a20b;
case 0x0000cb60:
return 0x46e97f3b;
case 0x0000cb64:
return 0xc7d84c42;
case 0x0000cb68:
return 0xfc9693f6;
case 0x0000cb6c:
return 0x528964c3;
case 0x0000cb70:
return 0x364202a1;
case 0x0000cb74:
return 0xa61b28d0;
case 0x0000cb78:
return 0x29ab16ee;
case 0x0000cb7c:
return 0xacf69e2e;
case 0x0000cb80:
return 0x22c344ba;
case 0x0000cb84:
return 0xc23a4947;
case 0x0000cb88:
return 0x6a2443d6;
case 0x0000cb8c:
return 0x8acca8ae;
case 0x0000cb90:
return 0xfd445bc6;
case 0x0000cb94:
return 0xdaa607e8;
case 0x0000cb98:
return 0x3a8c7484;
case 0x0000cb9c:
return 0xbadfa7ba;
case 0x0000cba0:
return 0xc6de2f9e;
case 0x0000cba4:
return 0x7a9de282;
case 0x0000cba8:
return 0x0142039b;
case 0x0000cbac:
return 0x52d8d2fc;
case 0x0000cbb0:
return 0xdb7a3f37;
case 0x0000cbb4:
return 0x7f888229;
case 0x0000cbb8:
return 0xd0c910fa;
case 0x0000cbbc:
return 0xf2b15458;
case 0x0000cbc0:
return 0x65617f7e;
case 0x0000cbc4:
return 0x91e88b7c;
case 0x0000cbc8:
return 0x4b27aca9;
case 0x0000cbcc:
return 0x37fb14ec;
case 0x0000cbd0:
return 0x9b857516;
case 0x0000cbd4:
return 0xf874c08c;
case 0x0000cbd8:
return 0x1310c1b7;
case 0x0000cbdc:
return 0x848f76c8;
case 0x0000cbe0:
return 0xf53d41de;
case 0x0000cbe4:
return 0x0801c01c;
case 0x0000cbe8:
return 0x2634d118;
case 0x0000cbec:
return 0xd50a22b1;
case 0x0000cbf0:
return 0xb2b3e92e;
case 0x0000cbf4:
return 0x8ab40fe1;
case 0x0000cbf8:
return 0xa60485b6;
case 0x0000cbfc:
return 0xe8fe27bd;
case 0x0000cc00:
return 0x0d5c5b45;
case 0x0000cc04:
return 0x8569b05a;
case 0x0000cc08:
return 0x6f30530f;
case 0x0000cc0c:
return 0xc3899db3;
case 0x0000cc10:
return 0x7459ede8;
case 0x0000cc14:
return 0x7a387e9a;
case 0x0000cc18:
return 0x63587edf;
case 0x0000cc1c:
return 0xd83a5b26;
case 0x0000cc20:
return 0xcb3ebf7a;
case 0x0000cc24:
return 0xcc3f137d;
case 0x0000cc28:
return 0x23c02870;
case 0x0000cc2c:
return 0x65dda415;
case 0x0000cc30:
return 0xaab31b84;
case 0x0000cc34:
return 0x1f1ac721;
case 0x0000cc38:
return 0xd9aec38b;
case 0x0000cc3c:
return 0x1d764a49;
case 0x0000cc40:
return 0xa78a7b12;
case 0x0000cc44:
return 0xbf018306;
case 0x0000cc48:
return 0xfb9d719f;
case 0x0000cc4c:
return 0x9056e42d;
case 0x0000cc50:
return 0xa5366b2b;
case 0x0000cc54:
return 0x5e40b9b5;
case 0x0000cc58:
return 0xaf9a1adf;
case 0x0000cc5c:
return 0xd41be42b;
case 0x0000cc60:
return 0xf9c7345b;
case 0x0000cc64:
return 0xc5c7e6ab;
case 0x0000cc68:
return 0x4e342cc4;
case 0x0000cc6c:
return 0x7f756ccb;
case 0x0000cc70:
return 0x5229fc82;
case 0x0000cc74:
return 0x43b376dd;
case 0x0000cc78:
return 0x544fc22b;
case 0x0000cc7c:
return 0xcc24a629;
case 0x0000cc80:
return 0xdcf0ae56;
case 0x0000cc84:
return 0x9173706b;
case 0x0000cc88:
return 0x14319822;
case 0x0000cc8c:
return 0xeb90d154;
case 0x0000cc90:
return 0x14990027;
case 0x0000cc94:
return 0x7f36c5bd;
case 0x0000cc98:
return 0xf9bb2352;
case 0x0000cc9c:
return 0x37ab2f62;
case 0x0000cca0:
return 0xcfe52cb7;
case 0x0000cca4:
return 0x6c0cc5d6;
case 0x0000cca8:
return 0xd5804e8d;
case 0x0000ccac:
return 0xba520f75;
case 0x0000ccb0:
return 0xf489d65f;
case 0x0000ccb4:
return 0x8a734075;
case 0x0000ccb8:
return 0xec611b80;
case 0x0000ccbc:
return 0xdbd9621d;
case 0x0000ccc0:
return 0x4221bda8;
case 0x0000ccc4:
return 0x4a2c8c39;
case 0x0000ccc8:
return 0xb7a3ed77;
case 0x0000cccc:
return 0x37e3a0f3;
case 0x0000ccd0:
return 0xfa52f4df;
case 0x0000ccd4:
return 0xcc513ec2;
case 0x0000ccd8:
return 0x51ecd8f9;
case 0x0000ccdc:
return 0x2c449a59;
case 0x0000cce0:
return 0xc4a42cc0;
case 0x0000cce4:
return 0xfeff81ce;
case 0x0000cce8:
return 0xdaf3ac74;
case 0x0000ccec:
return 0x97116da8;
case 0x0000ccf0:
return 0x95d3c775;
case 0x0000ccf4:
return 0x1b8df95d;
case 0x0000ccf8:
return 0x7d770ff0;
case 0x0000ccfc:
return 0xbb2e8ba4;
case 0x0000cd00:
return 0x511637db;
case 0x0000cd04:
return 0x8ad54ab5;
case 0x0000cd08:
return 0x042afa64;
case 0x0000cd0c:
return 0xfbd73e30;
case 0x0000cd10:
return 0x52bb8eae;
case 0x0000cd14:
return 0x6acf1004;
case 0x0000cd18:
return 0x70f08750;
case 0x0000cd1c:
return 0x4a9706c4;
case 0x0000cd20:
return 0xd38169cf;
case 0x0000cd24:
return 0xce5a04ce;
case 0x0000cd28:
return 0x932e29ad;
case 0x0000cd2c:
return 0x93fc5a94;
case 0x0000cd30:
return 0x20946d75;
case 0x0000cd34:
return 0x6df853a4;
case 0x0000cd38:
return 0x79902d93;
case 0x0000cd3c:
return 0xa867269a;
case 0x0000cd40:
return 0x5b3cec6d;
case 0x0000cd44:
return 0x1ede2304;
case 0x0000cd48:
return 0x0188a471;
case 0x0000cd4c:
return 0x199aaee5;
case 0x0000cd50:
return 0x5fc8fa25;
case 0x0000cd54:
return 0x79d91b1b;
case 0x0000cd58:
return 0x2f62d32d;
case 0x0000cd5c:
return 0x061d7d77;
case 0x0000cd60:
return 0x2bbc74de;
case 0x0000cd64:
return 0xf9c967df;
case 0x0000cd68:
return 0x3e6f30aa;
case 0x0000cd6c:
return 0xfe7bff5d;
case 0x0000cd70:
return 0x1f2ad5c6;
case 0x0000cd74:
return 0xf0cc7cd7;
case 0x0000cd78:
return 0xbca42a96;
case 0x0000cd7c:
return 0x17749e2c;
case 0x0000cd80:
return 0xb31a7a42;
case 0x0000cd84:
return 0x52b171c5;
case 0x0000cd88:
return 0xb3d79ae5;
case 0x0000cd8c:
return 0x559af8cd;
case 0x0000cd90:
return 0xafe2ed1b;
case 0x0000cd94:
return 0x5347b150;
case 0x0000cd98:
return 0x6ce71442;
case 0x0000cd9c:
return 0x6113e3ff;
case 0x0000cda0:
return 0xbfb89deb;
case 0x0000cda4:
return 0x91d1693d;
case 0x0000cda8:
return 0xa395b453;
case 0x0000cdac:
return 0xdbb574ea;
case 0x0000cdb0:
return 0x121a6414;
case 0x0000cdb4:
return 0xa2c2e7fb;
case 0x0000cdb8:
return 0x72ee3bd0;
case 0x0000cdbc:
return 0x5b87df52;
case 0x0000cdc0:
return 0xfdf6b851;
case 0x0000cdc4:
return 0x34c2db69;
case 0x0000cdc8:
return 0x17f34bbe;
case 0x0000cdcc:
return 0x02f8273d;
case 0x0000cdd0:
return 0x9e7b695d;
case 0x0000cdd4:
return 0xdc3b7f9f;
case 0x0000cdd8:
return 0x48133f47;
case 0x0000cddc:
return 0xf75d3a80;
case 0x0000cde0:
return 0x1bd75307;
case 0x0000cde4:
return 0xbd634e60;
case 0x0000cde8:
return 0xb1790b07;
case 0x0000cdec:
return 0x327893d5;
case 0x0000cdf0:
return 0x7f57e3c8;
case 0x0000cdf4:
return 0x61658664;
case 0x0000cdf8:
return 0x10e7f414;
case 0x0000cdfc:
return 0xa4626970;
case 0x0000ce00:
return 0xd1c1941c;
case 0x0000ce04:
return 0xe106f78d;
case 0x0000ce08:
return 0x1821a51c;
case 0x0000ce0c:
return 0xad494a2f;
case 0x0000ce10:
return 0x93f14461;
case 0x0000ce14:
return 0xb1098304;
case 0x0000ce18:
return 0x74b92e37;
case 0x0000ce1c:
return 0x314ac4cf;
case 0x0000ce20:
return 0x7a04bf99;
case 0x0000ce24:
return 0xfd64b513;
case 0x0000ce28:
return 0x4a9f459a;
case 0x0000ce2c:
return 0x2bf0974d;
case 0x0000ce30:
return 0xb4b944cb;
case 0x0000ce34:
return 0x9f0ddff7;
case 0x0000ce38:
return 0xed01f574;
case 0x0000ce3c:
return 0x7266ccc9;
case 0x0000ce40:
return 0x74360673;
case 0x0000ce44:
return 0x7ff68ccd;
case 0x0000ce48:
return 0x0914c7ba;
case 0x0000ce4c:
return 0x493306aa;
case 0x0000ce50:
return 0x3125c1d3;
case 0x0000ce54:
return 0xc7abfcce;
case 0x0000ce58:
return 0x1ec19394;
case 0x0000ce5c:
return 0xfc25c32b;
case 0x0000ce60:
return 0x731bd27e;
case 0x0000ce64:
return 0x0ea1eafa;
case 0x0000ce68:
return 0x89418869;
case 0x0000ce6c:
return 0xc75f2957;
case 0x0000ce70:
return 0xa9e922ac;
case 0x0000ce74:
return 0x44ef4a0c;
case 0x0000ce78:
return 0x9ca27e21;
case 0x0000ce7c:
return 0xadc3aba6;
case 0x0000ce80:
return 0x083a87b2;
case 0x0000ce84:
return 0x56fa8a9b;
case 0x0000ce88:
return 0xd5d54968;
case 0x0000ce8c:
return 0x632e9fb4;
case 0x0000ce90:
return 0x3309f0bd;
case 0x0000ce94:
return 0x56ab617f;
case 0x0000ce98:
return 0x28cb9965;
case 0x0000ce9c:
return 0x27e3447d;
case 0x0000cea0:
return 0x4f3f1175;
case 0x0000cea4:
return 0xe8c960e9;
case 0x0000cea8:
return 0xf88d2bd4;
case 0x0000ceac:
return 0x6cb3e51a;
case 0x0000ceb0:
return 0x431dcb75;
case 0x0000ceb4:
return 0xf9b1516e;
case 0x0000ceb8:
return 0x8b5fd027;
case 0x0000cebc:
return 0x4f1dd098;
case 0x0000cec0:
return 0xfda055c9;
case 0x0000cec4:
return 0xe19a1303;
case 0x0000cec8:
return 0xf3000c40;
case 0x0000cecc:
return 0xd841bc86;
case 0x0000ced0:
return 0x0bca3298;
case 0x0000ced4:
return 0x21babad6;
case 0x0000ced8:
return 0x1cc07ff4;
case 0x0000cedc:
return 0x6240c2de;
case 0x0000cee0:
return 0x867ebae5;
case 0x0000cee4:
return 0x15eab5d3;
case 0x0000cee8:
return 0x9c8b3646;
case 0x0000ceec:
return 0x5e4888f2;
case 0x0000cef0:
return 0x2775a481;
case 0x0000cef4:
return 0x48ba29ea;
case 0x0000cef8:
return 0xbc521d1b;
case 0x0000cefc:
return 0xac75d715;
case 0x0000cf00:
return 0x30fb3211;
case 0x0000cf04:
return 0xb0d30b17;
case 0x0000cf08:
return 0x5a54d08d;
case 0x0000cf0c:
return 0xa6d398ce;
case 0x0000cf10:
return 0xb4dd4ba8;
case 0x0000cf14:
return 0x5d579241;
case 0x0000cf18:
return 0x3827a096;
case 0x0000cf1c:
return 0xe7110f60;
case 0x0000cf20:
return 0xd16a8d25;
case 0x0000cf24:
return 0x47851d40;
case 0x0000cf28:
return 0x3d4b6870;
case 0x0000cf2c:
return 0x0bebaa1f;
case 0x0000cf30:
return 0x71621ad8;
case 0x0000cf34:
return 0x4ce853be;
case 0x0000cf38:
return 0x44d984f9;
case 0x0000cf3c:
return 0xa89e3011;
case 0x0000cf40:
return 0xb2a08bf7;
case 0x0000cf44:
return 0x2ed45b28;
case 0x0000cf48:
return 0xd9a8f1bb;
case 0x0000cf4c:
return 0x80924e56;
case 0x0000cf50:
return 0x8cbd7d81;
case 0x0000cf54:
return 0x2bd51c4a;
case 0x0000cf58:
return 0x7be02ff7;
case 0x0000cf5c:
return 0x3a2b18bc;
case 0x0000cf60:
return 0x3e1cdc10;
case 0x0000cf64:
return 0x3aae8ea1;
case 0x0000cf68:
return 0x23dfe080;
case 0x0000cf6c:
return 0xa0648de3;
case 0x0000cf70:
return 0x5979e2df;
case 0x0000cf74:
return 0xf6d20637;
case 0x0000cf78:
return 0x1c9877c5;
case 0x0000cf7c:
return 0xe09b9085;
case 0x0000cf80:
return 0xea6643a2;
case 0x0000cf84:
return 0xa92f45f8;
case 0x0000cf88:
return 0x22497495;
case 0x0000cf8c:
return 0x12876bb9;
case 0x0000cf90:
return 0x39f7a802;
case 0x0000cf94:
return 0xd720e9f2;
case 0x0000cf98:
return 0x10108a32;
case 0x0000cf9c:
return 0x7ff66cf7;
case 0x0000cfa0:
return 0x97d6dead;
case 0x0000cfa4:
return 0xd4dda830;
case 0x0000cfa8:
return 0xd2d1feae;
case 0x0000cfac:
return 0x1494e91f;
case 0x0000cfb0:
return 0x3e100569;
case 0x0000cfb4:
return 0x026f8978;
case 0x0000cfb8:
return 0x5214951d;
case 0x0000cfbc:
return 0x62bec44a;
case 0x0000cfc0:
return 0xfe9c7971;
case 0x0000cfc4:
return 0xd98c152d;
case 0x0000cfc8:
return 0xc1baca50;
case 0x0000cfcc:
return 0x56a120f7;
case 0x0000cfd0:
return 0xbd41be14;
case 0x0000cfd4:
return 0xf3f87878;
case 0x0000cfd8:
return 0x02a57733;
case 0x0000cfdc:
return 0x55316e90;
case 0x0000cfe0:
return 0x6094cfb9;
case 0x0000cfe4:
return 0x208e3af8;
case 0x0000cfe8:
return 0x6fc0fb7a;
case 0x0000cfec:
return 0xe8544070;
case 0x0000cff0:
return 0x0ec0274f;
case 0x0000cff4:
return 0x4e1e21e6;
case 0x0000cff8:
return 0x4522f5f6;
case 0x0000cffc:
return 0x801a13b3;
case 0x0000d000:
return 0x0d935424;
case 0x0000d004:
return 0x0734b577;
case 0x0000d008:
return 0x50170a1f;
case 0x0000d00c:
return 0xbef81db7;
case 0x0000d010:
return 0x8ee4c84a;
case 0x0000d014:
return 0xfc87fa79;
case 0x0000d018:
return 0x47b9bdca;
case 0x0000d01c:
return 0xaf25e692;
case 0x0000d020:
return 0x909539db;
case 0x0000d024:
return 0x33b94807;
case 0x0000d028:
return 0x0569a339;
case 0x0000d02c:
return 0x9729a301;
case 0x0000d030:
return 0xafe5d16d;
case 0x0000d034:
return 0x2e004fe8;
case 0x0000d038:
return 0xac78c138;
case 0x0000d03c:
return 0xa7b32e02;
case 0x0000d040:
return 0xffa0463e;
case 0x0000d044:
return 0xb4482ea0;
case 0x0000d048:
return 0x7f6056ce;
case 0x0000d04c:
return 0x9ccd4e3e;
case 0x0000d050:
return 0xff82021f;
case 0x0000d054:
return 0xf37a6b7c;
case 0x0000d058:
return 0xca396365;
case 0x0000d05c:
return 0xe4538d24;
case 0x0000d060:
return 0xb07a9bab;
case 0x0000d064:
return 0x203a08ad;
case 0x0000d068:
return 0xceeb2fd9;
case 0x0000d06c:
return 0xd408f3fd;
case 0x0000d070:
return 0x2238b3c3;
case 0x0000d074:
return 0xc4092a03;
case 0x0000d078:
return 0x0c9d5429;
case 0x0000d07c:
return 0x2ccdb6ee;
case 0x0000d080:
return 0x2956412f;
case 0x0000d084:
return 0x0e750eaa;
case 0x0000d088:
return 0x81dd1b84;
case 0x0000d08c:
return 0x1954d02c;
case 0x0000d090:
return 0xfe688e16;
case 0x0000d094:
return 0x87ef13dc;
case 0x0000d098:
return 0xca0b8404;
case 0x0000d09c:
return 0xe26ee39a;
case 0x0000d0a0:
return 0x20088609;
case 0x0000d0a4:
return 0xda49a0f1;
case 0x0000d0a8:
return 0xcb178de7;
case 0x0000d0ac:
return 0x170105e4;
case 0x0000d0b0:
return 0x8e6ff648;
case 0x0000d0b4:
return 0xe9db97b5;
case 0x0000d0b8:
return 0x29d91ef1;
case 0x0000d0bc:
return 0x09a5d3cf;
case 0x0000d0c0:
return 0xb17216e4;
case 0x0000d0c4:
return 0x201bf2dc;
case 0x0000d0c8:
return 0x7bd6e62f;
case 0x0000d0cc:
return 0x076deb8d;
case 0x0000d0d0:
return 0xff97f867;
case 0x0000d0d4:
return 0x6d017560;
case 0x0000d0d8:
return 0xcb232f05;
case 0x0000d0dc:
return 0xbf7cf39d;
case 0x0000d0e0:
return 0x124adc11;
case 0x0000d0e4:
return 0xeeaf439a;
case 0x0000d0e8:
return 0xa72aab27;
case 0x0000d0ec:
return 0xd13812c2;
case 0x0000d0f0:
return 0xd851ff54;
case 0x0000d0f4:
return 0xb8f9c814;
case 0x0000d0f8:
return 0x6a142782;
case 0x0000d0fc:
return 0x2010875e;
case 0x0000d100:
return 0xa7688b7b;
case 0x0000d104:
return 0x2afcbe04;
case 0x0000d108:
return 0xf2e546cb;
case 0x0000d10c:
return 0x24b0b227;
case 0x0000d110:
return 0x345aaada;
case 0x0000d114:
return 0xfe34f8e8;
case 0x0000d118:
return 0x5bcd2a54;
case 0x0000d11c:
return 0x29d55ba5;
case 0x0000d120:
return 0x0a38eec9;
case 0x0000d124:
return 0xb6cccb29;
case 0x0000d128:
return 0x8ab10f13;
case 0x0000d12c:
return 0xf2e129d8;
case 0x0000d130:
return 0x3ba6d380;
case 0x0000d134:
return 0xea5d7487;
case 0x0000d138:
return 0xb993b89e;
case 0x0000d13c:
return 0x49d49dbf;
case 0x0000d140:
return 0x8aa2aeae;
case 0x0000d144:
return 0x5e4465f1;
case 0x0000d148:
return 0x0804e696;
case 0x0000d14c:
return 0xdf04405f;
case 0x0000d150:
return 0x77d89e35;
case 0x0000d154:
return 0x3b7d3e23;
case 0x0000d158:
return 0x684c1a7c;
case 0x0000d15c:
return 0x7ea14c95;
case 0x0000d160:
return 0x2ff5794f;
case 0x0000d164:
return 0xdf3465bf;
case 0x0000d168:
return 0x12368e6a;
case 0x0000d16c:
return 0xcb398005;
case 0x0000d170:
return 0xbac4bdcb;
case 0x0000d174:
return 0x09d05a91;
case 0x0000d178:
return 0xba4e3939;
case 0x0000d17c:
return 0x69253dbe;
case 0x0000d180:
return 0x7ed40fcc;
case 0x0000d184:
return 0xf5d3cfb8;
case 0x0000d188:
return 0x12e2ea20;
case 0x0000d18c:
return 0x565a2842;
case 0x0000d190:
return 0xcd052d4a;
case 0x0000d194:
return 0xd169a9fa;
case 0x0000d198:
return 0x28be7967;
case 0x0000d19c:
return 0xe442b73b;
case 0x0000d1a0:
return 0x0bcc13da;
case 0x0000d1a4:
return 0xa5537883;
case 0x0000d1a8:
return 0x874c32e2;
case 0x0000d1ac:
return 0xaa4f5bb9;
case 0x0000d1b0:
return 0xda6f9a13;
case 0x0000d1b4:
return 0xd58d4b5f;
case 0x0000d1b8:
return 0xabeba83e;
case 0x0000d1bc:
return 0x96721904;
case 0x0000d1c0:
return 0xf06b9bf7;
case 0x0000d1c4:
return 0x23ea6d4b;
case 0x0000d1c8:
return 0xa8ddcf30;
case 0x0000d1cc:
return 0xdad31bb8;
case 0x0000d1d0:
return 0xa39265cc;
case 0x0000d1d4:
return 0xfeff658e;
case 0x0000d1d8:
return 0xdae5eb32;
case 0x0000d1dc:
return 0x16196770;
case 0x0000d1e0:
return 0x59a5253a;
case 0x0000d1e4:
return 0x337c4c81;
case 0x0000d1e8:
return 0x02155224;
case 0x0000d1ec:
return 0x874096cf;
case 0x0000d1f0:
return 0x93ebb80e;
case 0x0000d1f4:
return 0xada1cd75;
case 0x0000d1f8:
return 0xc980e6aa;
case 0x0000d1fc:
return 0xa42a495f;
case 0x0000d200:
return 0xc770cd77;
case 0x0000d204:
return 0xdfbe2f4c;
case 0x0000d208:
return 0x17f66cfe;
case 0x0000d20c:
return 0xa6032f77;
case 0x0000d210:
return 0x5c47ee04;
case 0x0000d214:
return 0xffb53579;
case 0x0000d218:
return 0x0e578143;
case 0x0000d21c:
return 0x4c54ae5d;
case 0x0000d220:
return 0xb1bd6910;
case 0x0000d224:
return 0x4d4dd5bb;
case 0x0000d228:
return 0x407727f1;
case 0x0000d22c:
return 0xcb759f36;
case 0x0000d230:
return 0x30cbd06f;
case 0x0000d234:
return 0x7994a17e;
case 0x0000d238:
return 0x95858d97;
case 0x0000d23c:
return 0xa8db87cb;
case 0x0000d240:
return 0x76170a71;
case 0x0000d244:
return 0x2b131e35;
case 0x0000d248:
return 0xea0090fc;
case 0x0000d24c:
return 0xf813402a;
case 0x0000d250:
return 0x53ddb584;
case 0x0000d254:
return 0x25d8ccf4;
case 0x0000d258:
return 0x129dc692;
case 0x0000d25c:
return 0xa43e7926;
case 0x0000d260:
return 0xf4de7a77;
case 0x0000d264:
return 0x05cb0ac2;
case 0x0000d268:
return 0xa29714f2;
case 0x0000d26c:
return 0x43e04f07;
case 0x0000d270:
return 0x042c4323;
case 0x0000d274:
return 0xbfdcabf8;
case 0x0000d278:
return 0x78be9fc0;
case 0x0000d27c:
return 0x04911f6a;
case 0x0000d280:
return 0xa025784d;
case 0x0000d284:
return 0xc0946ce7;
case 0x0000d288:
return 0xcbb4533c;
case 0x0000d28c:
return 0xefb7b9a1;
case 0x0000d290:
return 0xed681d5b;
case 0x0000d294:
return 0xd5556139;
case 0x0000d298:
return 0x05474477;
case 0x0000d29c:
return 0x6775b4da;
case 0x0000d2a0:
return 0x7e9ea9e2;
case 0x0000d2a4:
return 0x1e3a09a3;
case 0x0000d2a8:
return 0x6ad4085f;
case 0x0000d2ac:
return 0xe726f68a;
case 0x0000d2b0:
return 0x06307c83;
case 0x0000d2b4:
return 0x5a80f5b1;
case 0x0000d2b8:
return 0x942d5e8f;
case 0x0000d2bc:
return 0x65a057cc;
case 0x0000d2c0:
return 0xb359c3eb;
case 0x0000d2c4:
return 0x8323f01f;
case 0x0000d2c8:
return 0x9b78e74e;
case 0x0000d2cc:
return 0xd9678018;
case 0x0000d2d0:
return 0xca0f4376;
case 0x0000d2d4:
return 0xd01d40e6;
case 0x0000d2d8:
return 0xe6ba7cf7;
case 0x0000d2dc:
return 0x602851da;
case 0x0000d2e0:
return 0xa5593780;
case 0x0000d2e4:
return 0x595c9e44;
case 0x0000d2e8:
return 0x7d5201b2;
case 0x0000d2ec:
return 0xa8d37c77;
case 0x0000d2f0:
return 0x858aecfa;
case 0x0000d2f4:
return 0x3b0eb767;
case 0x0000d2f8:
return 0x1f9da30c;
case 0x0000d2fc:
return 0x223aede8;
case 0x0000d300:
return 0xf510b1e1;
case 0x0000d304:
return 0xf8f63f8f;
case 0x0000d308:
return 0x0fbc7b98;
case 0x0000d30c:
return 0x584bf8ed;
case 0x0000d310:
return 0xc481214a;
case 0x0000d314:
return 0xaf7cae21;
case 0x0000d318:
return 0x78f36d75;
case 0x0000d31c:
return 0x62db6995;
case 0x0000d320:
return 0x14383886;
case 0x0000d324:
return 0xd5b4a7ae;
case 0x0000d328:
return 0xbd97b716;
case 0x0000d32c:
return 0xc0c2551e;
case 0x0000d330:
return 0x8b8d2a61;
case 0x0000d334:
return 0x2607603a;
case 0x0000d338:
return 0xd65f6914;
case 0x0000d33c:
return 0x9e728ac7;
case 0x0000d340:
return 0x619b5588;
case 0x0000d344:
return 0xfbbc9971;
case 0x0000d348:
return 0x4ac7f7aa;
case 0x0000d34c:
return 0xa9b121e6;
case 0x0000d350:
return 0x76467ea1;
case 0x0000d354:
return 0x204d1eab;
case 0x0000d358:
return 0x9726863b;
case 0x0000d35c:
return 0x447b822c;
case 0x0000d360:
return 0x3d7bd8c8;
case 0x0000d364:
return 0x84755429;
case 0x0000d368:
return 0x6f83d226;
case 0x0000d36c:
return 0x8e5b8206;
case 0x0000d370:
return 0xbda73411;
case 0x0000d374:
return 0xf67ad3c7;
case 0x0000d378:
return 0x02fa8085;
case 0x0000d37c:
return 0x7e954cf8;
case 0x0000d380:
return 0xd03a88a1;
case 0x0000d384:
return 0x81cd152c;
case 0x0000d388:
return 0x6e09f285;
case 0x0000d38c:
return 0x7c730717;
case 0x0000d390:
return 0xd357ecd3;
case 0x0000d394:
return 0xf791ded9;
case 0x0000d398:
return 0x00e24bba;
case 0x0000d39c:
return 0x02118873;
case 0x0000d3a0:
return 0xa66f87f5;
case 0x0000d3a4:
return 0xb58a1d30;
case 0x0000d3a8:
return 0x2bc12860;
case 0x0000d3ac:
return 0x37ee3762;
case 0x0000d3b0:
return 0x20c6af2a;
case 0x0000d3b4:
return 0xfb6320d9;
case 0x0000d3b8:
return 0xec035e47;
case 0x0000d3bc:
return 0x3dae5b81;
case 0x0000d3c0:
return 0x5f6d776e;
case 0x0000d3c4:
return 0x7446907f;
case 0x0000d3c8:
return 0x79946370;
case 0x0000d3cc:
return 0xde0c8d01;
case 0x0000d3d0:
return 0x9f237a3f;
case 0x0000d3d4:
return 0x801123ad;
case 0x0000d3d8:
return 0xe7e26e5b;
case 0x0000d3dc:
return 0x5e3563a3;
case 0x0000d3e0:
return 0xfc2e4dd1;
case 0x0000d3e4:
return 0x3b550f11;
case 0x0000d3e8:
return 0x68f3bff7;
case 0x0000d3ec:
return 0xa5dc287b;
case 0x0000d3f0:
return 0x393eb72a;
case 0x0000d3f4:
return 0xf26ef65e;
case 0x0000d3f8:
return 0x4860ada2;
case 0x0000d3fc:
return 0x4546776c;
case 0x0000d400:
return 0xe69d6216;
case 0x0000d404:
return 0xfa15b02d;
case 0x0000d408:
return 0x9cab276b;
case 0x0000d40c:
return 0x51fa6e16;
case 0x0000d410:
return 0x5be0e276;
case 0x0000d414:
return 0x659bcc4b;
case 0x0000d418:
return 0x8766b5bd;
case 0x0000d41c:
return 0x95c40174;
case 0x0000d420:
return 0xacf61494;
case 0x0000d424:
return 0x52540e3c;
case 0x0000d428:
return 0xb13f6e70;
case 0x0000d42c:
return 0xfa6bdbdd;
case 0x0000d430:
return 0x48819173;
case 0x0000d434:
return 0xf7494de8;
case 0x0000d438:
return 0x3a25c7a2;
case 0x0000d43c:
return 0x662ce080;
case 0x0000d440:
return 0xc012db13;
case 0x0000d444:
return 0x07d63f16;
case 0x0000d448:
return 0x246715ea;
case 0x0000d44c:
return 0x5c7e2043;
case 0x0000d450:
return 0x2c98b080;
case 0x0000d454:
return 0x4c10b181;
case 0x0000d458:
return 0x4b4e2bd9;
case 0x0000d45c:
return 0x96e2a4d4;
case 0x0000d460:
return 0x2370958f;
case 0x0000d464:
return 0x0fcf6125;
case 0x0000d468:
return 0x30d06a45;
case 0x0000d46c:
return 0x71ca2465;
case 0x0000d470:
return 0x73843792;
case 0x0000d474:
return 0x6f6515d5;
case 0x0000d478:
return 0x24db1891;
case 0x0000d47c:
return 0x25f7c0b9;
case 0x0000d480:
return 0x37eeaadc;
case 0x0000d484:
return 0x23727503;
case 0x0000d488:
return 0xbb819f8b;
case 0x0000d48c:
return 0xe5d1b975;
case 0x0000d490:
return 0xe017204d;
case 0x0000d494:
return 0x59b9b1af;
case 0x0000d498:
return 0xbd69a94e;
case 0x0000d49c:
return 0xd53809ab;
case 0x0000d4a0:
return 0xd83ba88f;
case 0x0000d4a4:
return 0x18160cc4;
case 0x0000d4a8:
return 0xb525b560;
case 0x0000d4ac:
return 0x9c3e75cd;
case 0x0000d4b0:
return 0x3fd4ac49;
case 0x0000d4b4:
return 0x83656616;
case 0x0000d4b8:
return 0xd8e90ef4;
case 0x0000d4bc:
return 0x30a5a0e2;
case 0x0000d4c0:
return 0x555f35ee;
case 0x0000d4c4:
return 0x424b85b0;
case 0x0000d4c8:
return 0x0d637d36;
case 0x0000d4cc:
return 0x02ca466f;
case 0x0000d4d0:
return 0xf1b3b147;
case 0x0000d4d4:
return 0xc2ae9cfe;
case 0x0000d4d8:
return 0x474bd533;
case 0x0000d4dc:
return 0xc9211a09;
case 0x0000d4e0:
return 0x89865a87;
case 0x0000d4e4:
return 0x91f08075;
case 0x0000d4e8:
return 0x6a15278e;
case 0x0000d4ec:
return 0xefe7f098;
case 0x0000d4f0:
return 0x7855f38b;
case 0x0000d4f4:
return 0xce75a7c4;
case 0x0000d4f8:
return 0xdc659212;
case 0x0000d4fc:
return 0x2fbe0e9b;
case 0x0000d500:
return 0x19ae5b5a;
case 0x0000d504:
return 0xbc6ad8ba;
case 0x0000d508:
return 0x039d8178;
case 0x0000d50c:
return 0x75beaaa2;
case 0x0000d510:
return 0x46c52bf9;
case 0x0000d514:
return 0x959870b1;
case 0x0000d518:
return 0x6504c2a9;
case 0x0000d51c:
return 0x48196452;
case 0x0000d520:
return 0x875995ff;
case 0x0000d524:
return 0x704bc4e1;
case 0x0000d528:
return 0x6abb7632;
case 0x0000d52c:
return 0x1d1b0e2b;
case 0x0000d530:
return 0x9fb67d21;
case 0x0000d534:
return 0x8901bdd6;
case 0x0000d538:
return 0x9aa7c77a;
case 0x0000d53c:
return 0x0b2a932a;
case 0x0000d540:
return 0x64a6275c;
case 0x0000d544:
return 0xf49cfda1;
case 0x0000d548:
return 0xa68c98d5;
case 0x0000d54c:
return 0x584f1c59;
case 0x0000d550:
return 0x45a1039a;
case 0x0000d554:
return 0x33210b37;
case 0x0000d558:
return 0xcafed30f;
case 0x0000d55c:
return 0x8b806f15;
case 0x0000d560:
return 0x42ba032f;
case 0x0000d564:
return 0xf5ccaa0a;
case 0x0000d568:
return 0xd4c1993b;
case 0x0000d56c:
return 0xba97fc94;
case 0x0000d570:
return 0x3932fa37;
case 0x0000d574:
return 0x4dd66f9b;
case 0x0000d578:
return 0x8afde314;
case 0x0000d57c:
return 0x2df5b1ed;
case 0x0000d580:
return 0x0af39671;
case 0x0000d584:
return 0xa5b15892;
case 0x0000d588:
return 0x2edd8e3c;
case 0x0000d58c:
return 0xc0571a05;
case 0x0000d590:
return 0xcee14d87;
case 0x0000d594:
return 0x1c87c200;
case 0x0000d598:
return 0x420052e4;
case 0x0000d59c:
return 0xeb022fd7;
case 0x0000d5a0:
return 0x7de54ba9;
case 0x0000d5a4:
return 0x36feec17;
case 0x0000d5a8:
return 0x2bdb5323;
case 0x0000d5ac:
return 0xc0da894d;
case 0x0000d5b0:
return 0x0458aa2f;
case 0x0000d5b4:
return 0x19841fe8;
case 0x0000d5b8:
return 0x561e9392;
case 0x0000d5bc:
return 0x9e367c4d;
case 0x0000d5c0:
return 0xdf52e535;
case 0x0000d5c4:
return 0xdbb848fd;
case 0x0000d5c8:
return 0xc0018c2e;
case 0x0000d5cc:
return 0xeb0bbbff;
case 0x0000d5d0:
return 0xe4c61e28;
case 0x0000d5d4:
return 0x95263e72;
case 0x0000d5d8:
return 0xe9d24da6;
case 0x0000d5dc:
return 0xa6c5c3e3;
case 0x0000d5e0:
return 0x3d758c79;
case 0x0000d5e4:
return 0x4d792bd1;
case 0x0000d5e8:
return 0xb3c28dfc;
case 0x0000d5ec:
return 0x0ffaf770;
case 0x0000d5f0:
return 0xaa8e9e18;
case 0x0000d5f4:
return 0x4b9a239b;
case 0x0000d5f8:
return 0xbc9a6179;
case 0x0000d5fc:
return 0xf74d3a27;
case 0x0000d600:
return 0xb3e007da;
case 0x0000d604:
return 0x24d0d99a;
case 0x0000d608:
return 0x997b50d9;
case 0x0000d60c:
return 0x615835dc;
case 0x0000d610:
return 0x7df31838;
case 0x0000d614:
return 0x838233d5;
case 0x0000d618:
return 0xd5d64085;
case 0x0000d61c:
return 0xe66ad493;
case 0x0000d620:
return 0xc4716aae;
case 0x0000d624:
return 0x5660b348;
case 0x0000d628:
return 0x5a342112;
case 0x0000d62c:
return 0x7d3a3a0b;
case 0x0000d630:
return 0xfaaccf38;
case 0x0000d634:
return 0x49c68b0e;
case 0x0000d638:
return 0x26e6df54;
case 0x0000d63c:
return 0xb3eb7770;
case 0x0000d640:
return 0x6e672390;
case 0x0000d644:
return 0x25255eed;
case 0x0000d648:
return 0x94889e49;
case 0x0000d64c:
return 0xf730c073;
case 0x0000d650:
return 0x29da1636;
case 0x0000d654:
return 0xd18a1b77;
case 0x0000d658:
return 0x6b3dbbb7;
case 0x0000d65c:
return 0x538ee8bb;
case 0x0000d660:
return 0x5bf8f0ab;
case 0x0000d664:
return 0x48aaf3de;
case 0x0000d668:
return 0xfccbfd08;
case 0x0000d66c:
return 0x05fbcfb6;
case 0x0000d670:
return 0xc8453383;
case 0x0000d674:
return 0xad38df5d;
case 0x0000d678:
return 0x9e309e4d;
case 0x0000d67c:
return 0xe7fcb05f;
case 0x0000d680:
return 0xf30cb552;
case 0x0000d684:
return 0xfdd32cb4;
case 0x0000d688:
return 0xc014e2a1;
case 0x0000d68c:
return 0xb1f95c1e;
case 0x0000d690:
return 0xfec464d3;
case 0x0000d694:
return 0x731e7fbf;
case 0x0000d698:
return 0xba28b94d;
case 0x0000d69c:
return 0xa5d235d4;
case 0x0000d6a0:
return 0x7f165c26;
case 0x0000d6a4:
return 0xd45da5f5;
case 0x0000d6a8:
return 0xcc833202;
case 0x0000d6ac:
return 0xc9c97f4d;
case 0x0000d6b0:
return 0x62503be9;
case 0x0000d6b4:
return 0xba4dba37;
case 0x0000d6b8:
return 0xa58799a6;
case 0x0000d6bc:
return 0xed7d65e8;
case 0x0000d6c0:
return 0x914bcb6b;
case 0x0000d6c4:
return 0x5f286d58;
case 0x0000d6c8:
return 0xfa0a04cb;
case 0x0000d6cc:
return 0x53583c21;
case 0x0000d6d0:
return 0xac624d01;
case 0x0000d6d4:
return 0xfd255b94;
case 0x0000d6d8:
return 0x3417002d;
case 0x0000d6dc:
return 0x3d40fd6b;
case 0x0000d6e0:
return 0x889a35a6;
case 0x0000d6e4:
return 0x36f2d494;
case 0x0000d6e8:
return 0xab4472a0;
case 0x0000d6ec:
return 0xf913d75c;
case 0x0000d6f0:
return 0x04c604e7;
case 0x0000d6f4:
return 0xd03ba655;
case 0x0000d6f8:
return 0x8a061681;
case 0x0000d6fc:
return 0xd0190b76;
case 0x0000d700:
return 0x3c210c4e;
case 0x0000d704:
return 0xc29ed674;
case 0x0000d708:
return 0x7560284f;
case 0x0000d70c:
return 0x033bed4f;
case 0x0000d710:
return 0xde4395e2;
case 0x0000d714:
return 0x1ea1f9d9;
case 0x0000d718:
return 0x3292e006;
case 0x0000d71c:
return 0xd936d1e2;
case 0x0000d720:
return 0x27e8a3b0;
case 0x0000d724:
return 0x33602e2c;
case 0x0000d728:
return 0xa329c4e8;
case 0x0000d72c:
return 0x4012e72b;
case 0x0000d730:
return 0x687cc3c5;
case 0x0000d734:
return 0x213cef4d;
case 0x0000d738:
return 0x80dd0549;
case 0x0000d73c:
return 0xb37aab06;
case 0x0000d740:
return 0xde117edd;
case 0x0000d744:
return 0xee05e975;
case 0x0000d748:
return 0x97f5218c;
case 0x0000d74c:
return 0x9873fc6b;
case 0x0000d750:
return 0xc17b3d85;
case 0x0000d754:
return 0xeab064f4;
case 0x0000d758:
return 0xf96a81b0;
case 0x0000d75c:
return 0x6b8b622d;
case 0x0000d760:
return 0xa69cd308;
case 0x0000d764:
return 0x44c11237;
case 0x0000d768:
return 0x5c0afc1b;
case 0x0000d76c:
return 0x01c78659;
case 0x0000d770:
return 0x7a010f7c;
case 0x0000d774:
return 0xb69710b1;
case 0x0000d778:
return 0x0489f665;
case 0x0000d77c:
return 0xc923dbe7;
case 0x0000d780:
return 0x20abf3b9;
case 0x0000d784:
return 0xdbdbaef6;
case 0x0000d788:
return 0x64106890;
case 0x0000d78c:
return 0x0f4771c6;
case 0x0000d790:
return 0x72881a87;
case 0x0000d794:
return 0x0b5459b2;
case 0x0000d798:
return 0x52c8ce79;
case 0x0000d79c:
return 0xcb122798;
case 0x0000d7a0:
return 0xaf9a8852;
case 0x0000d7a4:
return 0xee5c66b1;
case 0x0000d7a8:
return 0x2491a822;
case 0x0000d7ac:
return 0xacb2a2ad;
case 0x0000d7b0:
return 0x7ce5cc33;
case 0x0000d7b4:
return 0x50952433;
case 0x0000d7b8:
return 0xdd7b6b2a;
case 0x0000d7bc:
return 0xb82a1a97;
case 0x0000d7c0:
return 0x007bcdc0;
case 0x0000d7c4:
return 0x34251cba;
case 0x0000d7c8:
return 0x05ca0120;
case 0x0000d7cc:
return 0x8f7f03f2;
case 0x0000d7d0:
return 0x05f0b845;
case 0x0000d7d4:
return 0x47cea350;
case 0x0000d7d8:
return 0x29cbe454;
case 0x0000d7dc:
return 0x30ba4d8f;
case 0x0000d7e0:
return 0x195aee0e;
case 0x0000d7e4:
return 0xc7d0089f;
case 0x0000d7e8:
return 0x6973fd35;
case 0x0000d7ec:
return 0x086e1053;
case 0x0000d7f0:
return 0xc8651fd4;
case 0x0000d7f4:
return 0x97024647;
case 0x0000d7f8:
return 0x530403e1;
case 0x0000d7fc:
return 0xd3e6ea37;
case 0x0000d800:
return 0xd86cc952;
case 0x0000d804:
return 0x557224dc;
case 0x0000d808:
return 0xaa7eba92;
case 0x0000d80c:
return 0x1f948092;
case 0x0000d810:
return 0x49b12497;
case 0x0000d814:
return 0x43cc634e;
case 0x0000d818:
return 0x3252bb3b;
case 0x0000d81c:
return 0x22c2fe91;
case 0x0000d820:
return 0xda228f41;
case 0x0000d824:
return 0x9be6b763;
case 0x0000d828:
return 0x5a3795b8;
case 0x0000d82c:
return 0x3a82e581;
case 0x0000d830:
return 0x5e00f988;
case 0x0000d834:
return 0xddf519d9;
case 0x0000d838:
return 0x685787f4;
case 0x0000d83c:
return 0xc634b2f1;
case 0x0000d840:
return 0x184f5a33;
case 0x0000d844:
return 0x77e644f7;
case 0x0000d848:
return 0x3ca8b13b;
case 0x0000d84c:
return 0x841d7362;
case 0x0000d850:
return 0x35e1cb80;
case 0x0000d854:
return 0x3b7755eb;
case 0x0000d858:
return 0x0be787de;
case 0x0000d85c:
return 0x6c1622b0;
case 0x0000d860:
return 0xdb4d94e8;
case 0x0000d864:
return 0x6c82d0e4;
case 0x0000d868:
return 0x8aec10cd;
case 0x0000d86c:
return 0x9e7e5e31;
case 0x0000d870:
return 0x82ddc9eb;
case 0x0000d874:
return 0x0fcfa37d;
case 0x0000d878:
return 0xf8b4da31;
case 0x0000d87c:
return 0xf05125cc;
case 0x0000d880:
return 0xd360942e;
case 0x0000d884:
return 0x35f229ca;
case 0x0000d888:
return 0xae88d821;
case 0x0000d88c:
return 0x209657a9;
case 0x0000d890:
return 0x8b189ab9;
case 0x0000d894:
return 0x00896c25;
case 0x0000d898:
return 0x55ec5991;
case 0x0000d89c:
return 0x4a5d3773;
case 0x0000d8a0:
return 0x4de5db67;
case 0x0000d8a4:
return 0xd9b0c139;
case 0x0000d8a8:
return 0x344d11e8;
case 0x0000d8ac:
return 0x1e6f1f31;
case 0x0000d8b0:
return 0x720f4a72;
case 0x0000d8b4:
return 0xffc9e086;
case 0x0000d8b8:
return 0xee9fb3c0;
case 0x0000d8bc:
return 0x20ba0110;
case 0x0000d8c0:
return 0x59f0f881;
case 0x0000d8c4:
return 0x7b4e7295;
case 0x0000d8c8:
return 0x8f8aa879;
case 0x0000d8cc:
return 0xbcca1ea3;
case 0x0000d8d0:
return 0x2d39f230;
case 0x0000d8d4:
return 0x730ec6f8;
case 0x0000d8d8:
return 0x512b3a06;
case 0x0000d8dc:
return 0x3e85694d;
case 0x0000d8e0:
return 0x56d7e9f6;
case 0x0000d8e4:
return 0xb3c6ed16;
case 0x0000d8e8:
return 0x1e41dc91;
case 0x0000d8ec:
return 0x951992af;
case 0x0000d8f0:
return 0xcdd5610a;
case 0x0000d8f4:
return 0x4d91dbfa;
case 0x0000d8f8:
return 0xcca1d275;
case 0x0000d8fc:
return 0x6bed7b2b;
case 0x0000d900:
return 0x885620ff;
case 0x0000d904:
return 0xe80b5854;
case 0x0000d908:
return 0xb7a4386a;
case 0x0000d90c:
return 0x5915dc22;
case 0x0000d910:
return 0x04372477;
case 0x0000d914:
return 0xd10c0479;
case 0x0000d918:
return 0xe10fbf51;
case 0x0000d91c:
return 0x9119450a;
case 0x0000d920:
return 0xb63acc2f;
case 0x0000d924:
return 0x9ae66bf4;
case 0x0000d928:
return 0xd70f0304;
case 0x0000d92c:
return 0x8ddced49;
case 0x0000d930:
return 0x60c590f4;
case 0x0000d934:
return 0x59b89a77;
case 0x0000d938:
return 0xf790b680;
case 0x0000d93c:
return 0x651b8dd0;
case 0x0000d940:
return 0x6464418b;
case 0x0000d944:
return 0x52faa37b;
case 0x0000d948:
return 0x49d58b23;
case 0x0000d94c:
return 0x716066da;
case 0x0000d950:
return 0x3d68dc24;
case 0x0000d954:
return 0x8e70e99f;
case 0x0000d958:
return 0xb8aa225a;
case 0x0000d95c:
return 0xd7cc2eec;
case 0x0000d960:
return 0x01ec4250;
case 0x0000d964:
return 0x21d2a3f6;
case 0x0000d968:
return 0x85df30b9;
case 0x0000d96c:
return 0x16af88d8;
case 0x0000d970:
return 0xd72d4b0e;
case 0x0000d974:
return 0x9f88e7ca;
case 0x0000d978:
return 0x8787bdf1;
case 0x0000d97c:
return 0x8fad6ba7;
case 0x0000d980:
return 0x4bd76a8b;
case 0x0000d984:
return 0xd4497c0d;
case 0x0000d988:
return 0x424959d9;
case 0x0000d98c:
return 0x58da8bd0;
case 0x0000d990:
return 0x81ad64d9;
case 0x0000d994:
return 0x14c055f6;
case 0x0000d998:
return 0x6d6c3e74;
case 0x0000d99c:
return 0x4d8831fa;
case 0x0000d9a0:
return 0xc3b8ea35;
case 0x0000d9a4:
return 0xe04722fa;
case 0x0000d9a8:
return 0x85b21d97;
case 0x0000d9ac:
return 0xd55515b4;
case 0x0000d9b0:
return 0x1f0b873c;
case 0x0000d9b4:
return 0x199d0623;
case 0x0000d9b8:
return 0xb8cb77ec;
case 0x0000d9bc:
return 0xd4c59f58;
case 0x0000d9c0:
return 0x46572ab3;
case 0x0000d9c4:
return 0x068b1430;
case 0x0000d9c8:
return 0x5b34b19e;
case 0x0000d9cc:
return 0xf1e180ca;
case 0x0000d9d0:
return 0x0c734e71;
case 0x0000d9d4:
return 0xf7eacb59;
case 0x0000d9d8:
return 0x0f3e7ebd;
case 0x0000d9dc:
return 0x839af3af;
case 0x0000d9e0:
return 0x7ac68877;
case 0x0000d9e4:
return 0x8a871a89;
case 0x0000d9e8:
return 0x3103f829;
case 0x0000d9ec:
return 0x7e1e7458;
case 0x0000d9f0:
return 0x06934509;
case 0x0000d9f4:
return 0x8d2f404c;
case 0x0000d9f8:
return 0xbb45460d;
case 0x0000d9fc:
return 0xe79f8400;
case 0x0000da00:
return 0x055fe62d;
case 0x0000da04:
return 0xf5403f57;
case 0x0000da08:
return 0x3bbd96e8;
case 0x0000da0c:
return 0x07bd1f09;
case 0x0000da10:
return 0x008a343c;
case 0x0000da14:
return 0x285ee722;
case 0x0000da18:
return 0x2948d57c;
case 0x0000da1c:
return 0x8b6a033e;
case 0x0000da20:
return 0xef89c679;
case 0x0000da24:
return 0xd1eefb08;
case 0x0000da28:
return 0x2f967d70;
case 0x0000da2c:
return 0xe60a5c42;
case 0x0000da30:
return 0x5d83c15e;
case 0x0000da34:
return 0x8bf83f5a;
case 0x0000da38:
return 0x24682a34;
case 0x0000da3c:
return 0x770b0103;
case 0x0000da40:
return 0xf1629782;
case 0x0000da44:
return 0x599728c4;
case 0x0000da48:
return 0x8f8d9fac;
case 0x0000da4c:
return 0x3cfdcd75;
case 0x0000da50:
return 0x92d34d45;
case 0x0000da54:
return 0x52c83fb0;
case 0x0000da58:
return 0x79306942;
case 0x0000da5c:
return 0x22a5f2cd;
case 0x0000da60:
return 0xf270c650;
case 0x0000da64:
return 0x077661c2;
case 0x0000da68:
return 0xee5ded92;
case 0x0000da6c:
return 0x73a4f8ff;
case 0x0000da70:
return 0xc7c31884;
case 0x0000da74:
return 0x25cf36d2;
case 0x0000da78:
return 0xed9b08e3;
case 0x0000da7c:
return 0xa9b6f54f;
case 0x0000da80:
return 0xff658b31;
case 0x0000da84:
return 0xdc62f3ae;
case 0x0000da88:
return 0xd42410f5;
case 0x0000da8c:
return 0x4b3d74ad;
case 0x0000da90:
return 0x9700065c;
case 0x0000da94:
return 0x7250e325;
case 0x0000da98:
return 0xe95195f4;
case 0x0000da9c:
return 0x9aee6dc2;
case 0x0000daa0:
return 0x762c23d7;
case 0x0000daa4:
return 0xfc9a0325;
case 0x0000daa8:
return 0x3ca37d62;
case 0x0000daac:
return 0xb7d55d89;
case 0x0000dab0:
return 0x434b01a1;
case 0x0000dab4:
return 0x7b493e8a;
case 0x0000dab8:
return 0xb62cfd92;
case 0x0000dabc:
return 0x6b436a76;
case 0x0000dac0:
return 0x72b202c0;
case 0x0000dac4:
return 0x5ad12d39;
case 0x0000dac8:
return 0xbeb1bca2;
case 0x0000dacc:
return 0xa3146320;
case 0x0000dad0:
return 0x6dc65660;
case 0x0000dad4:
return 0xd262a5ce;
case 0x0000dad8:
return 0x643b9a1e;
case 0x0000dadc:
return 0xed095dab;
case 0x0000dae0:
return 0x76447cd5;
case 0x0000dae4:
return 0x9c79fff4;
case 0x0000dae8:
return 0x91be7c96;
case 0x0000daec:
return 0xd2cc8df4;
case 0x0000daf0:
return 0x45c56e6a;
case 0x0000daf4:
return 0xe531bac0;
case 0x0000daf8:
return 0x88931c7a;
case 0x0000dafc:
return 0x2940feb0;
case 0x0000db00:
return 0x6304d253;
case 0x0000db04:
return 0x5d8858af;
case 0x0000db08:
return 0x41a17d43;
case 0x0000db0c:
return 0x9517345f;
case 0x0000db10:
return 0x4392c781;
case 0x0000db14:
return 0x5b6c9d01;
case 0x0000db18:
return 0xc7202ed3;
case 0x0000db1c:
return 0x588a4c79;
case 0x0000db20:
return 0xc637e503;
case 0x0000db24:
return 0xf779d71b;
case 0x0000db28:
return 0xff29e2c7;
case 0x0000db2c:
return 0xf72f97f2;
case 0x0000db30:
return 0x5a7d2ee9;
case 0x0000db34:
return 0x426d7e2d;
case 0x0000db38:
return 0xc18545ed;
case 0x0000db3c:
return 0x8782ff5d;
case 0x0000db40:
return 0x87ad426e;
case 0x0000db44:
return 0x0dd9e7f3;
case 0x0000db48:
return 0xfbad74ff;
case 0x0000db4c:
return 0x14107e41;
case 0x0000db50:
return 0x23c5e43a;
case 0x0000db54:
return 0x65a29dad;
case 0x0000db58:
return 0x1c4a4ecd;
case 0x0000db5c:
return 0x0cd9adfe;
case 0x0000db60:
return 0xa2624723;
case 0x0000db64:
return 0x7196836a;
case 0x0000db68:
return 0x1ae1f255;
case 0x0000db6c:
return 0xd0ca4c87;
case 0x0000db70:
return 0xaee1e0b4;
case 0x0000db74:
return 0x1a53173d;
case 0x0000db78:
return 0x90ef4e0b;
case 0x0000db7c:
return 0xe5eba706;
case 0x0000db80:
return 0x208968ea;
case 0x0000db84:
return 0x51b17f16;
case 0x0000db88:
return 0xe8b2b9fb;
case 0x0000db8c:
return 0x3420e956;
case 0x0000db90:
return 0xb438e17e;
case 0x0000db94:
return 0x4aa51f98;
case 0x0000db98:
return 0x5287c0eb;
case 0x0000db9c:
return 0x80bde1e9;
case 0x0000dba0:
return 0x14e0ed62;
case 0x0000dba4:
return 0xd09d0504;
case 0x0000dba8:
return 0x413f8feb;
case 0x0000dbac:
return 0x8ab06096;
case 0x0000dbb0:
return 0x344953c2;
case 0x0000dbb4:
return 0x46c750df;
case 0x0000dbb8:
return 0x5f23016f;
case 0x0000dbbc:
return 0x87d213cc;
case 0x0000dbc0:
return 0x2e48c1f4;
case 0x0000dbc4:
return 0xbaa2aecb;
case 0x0000dbc8:
return 0xab872876;
case 0x0000dbcc:
return 0x26fd74cf;
case 0x0000dbd0:
return 0x1013f451;
case 0x0000dbd4:
return 0xb276a13f;
case 0x0000dbd8:
return 0xef3d1d4a;
case 0x0000dbdc:
return 0x4bc95c7e;
case 0x0000dbe0:
return 0xfec7d6fb;
case 0x0000dbe4:
return 0x893dc4e6;
case 0x0000dbe8:
return 0xb10b828c;
case 0x0000dbec:
return 0x13ea4b6a;
case 0x0000dbf0:
return 0xab151a03;
case 0x0000dbf4:
return 0x13e5762c;
case 0x0000dbf8:
return 0x9a25e5eb;
case 0x0000dbfc:
return 0xc7a2debb;
case 0x0000dc00:
return 0x96f5b626;
case 0x0000dc04:
return 0xf2283511;
case 0x0000dc08:
return 0x6b2cfef1;
case 0x0000dc0c:
return 0x04d626d6;
case 0x0000dc10:
return 0xa4f05522;
case 0x0000dc14:
return 0xdb828c63;
case 0x0000dc18:
return 0x4c54ae47;
case 0x0000dc1c:
return 0x86d42119;
case 0x0000dc20:
return 0xd749c211;
case 0x0000dc24:
return 0xf3707587;
case 0x0000dc28:
return 0x8df19a1f;
case 0x0000dc2c:
return 0x104ad8d7;
case 0x0000dc30:
return 0x85e39746;
case 0x0000dc34:
return 0xf53f8668;
case 0x0000dc38:
return 0x548c802b;
case 0x0000dc3c:
return 0x570d9131;
case 0x0000dc40:
return 0xb9c13eb9;
case 0x0000dc44:
return 0xe6fc9d1f;
case 0x0000dc48:
return 0xf9057b22;
case 0x0000dc4c:
return 0x1fe34e7e;
case 0x0000dc50:
return 0xf473e9c0;
case 0x0000dc54:
return 0x296d5ecb;
case 0x0000dc58:
return 0xa39950d6;
case 0x0000dc5c:
return 0x791fbfcb;
case 0x0000dc60:
return 0x2c9df8eb;
case 0x0000dc64:
return 0x05a6e6d7;
case 0x0000dc68:
return 0x5b271aab;
case 0x0000dc6c:
return 0x5472f6f8;
case 0x0000dc70:
return 0xc3538f11;
case 0x0000dc74:
return 0x2326dc33;
case 0x0000dc78:
return 0x05355a46;
case 0x0000dc7c:
return 0x0999779d;
case 0x0000dc80:
return 0x891e976b;
case 0x0000dc84:
return 0x1b10e5c9;
case 0x0000dc88:
return 0x638fbfb7;
case 0x0000dc8c:
return 0xb0eab4ca;
case 0x0000dc90:
return 0xf048b086;
case 0x0000dc94:
return 0x82ddd21d;
case 0x0000dc98:
return 0x2466d609;
case 0x0000dc9c:
return 0x170c753b;
case 0x0000dca0:
return 0x939d9db3;
case 0x0000dca4:
return 0x37873c2b;
case 0x0000dca8:
return 0xabb29a1a;
case 0x0000dcac:
return 0xd7cd78b3;
case 0x0000dcb0:
return 0x4647c444;
case 0x0000dcb4:
return 0x64517280;
case 0x0000dcb8:
return 0x742269a6;
case 0x0000dcbc:
return 0x3f9e437e;
case 0x0000dcc0:
return 0xcf7d2ae5;
case 0x0000dcc4:
return 0x1b1e7de4;
case 0x0000dcc8:
return 0x790c47a4;
case 0x0000dccc:
return 0x0a983f26;
case 0x0000dcd0:
return 0x4804299d;
case 0x0000dcd4:
return 0x0263afc9;
case 0x0000dcd8:
return 0x1a6d5cae;
case 0x0000dcdc:
return 0x9661afc6;
case 0x0000dce0:
return 0x8e08eb37;
case 0x0000dce4:
return 0x61a169b5;
case 0x0000dce8:
return 0x40379a8a;
case 0x0000dcec:
return 0x07853f8f;
case 0x0000dcf0:
return 0x5247eb66;
case 0x0000dcf4:
return 0xa8eff578;
case 0x0000dcf8:
return 0x251f5a0a;
case 0x0000dcfc:
return 0x168e2020;
case 0x0000dd00:
return 0x70e32dd2;
case 0x0000dd04:
return 0x81e91ca9;
case 0x0000dd08:
return 0xff6ec574;
case 0x0000dd0c:
return 0xe0a62ef5;
case 0x0000dd10:
return 0x5677150d;
case 0x0000dd14:
return 0xeaa631c2;
case 0x0000dd18:
return 0xa296c938;
case 0x0000dd1c:
return 0xee8340c3;
case 0x0000dd20:
return 0x66f5012b;
case 0x0000dd24:
return 0x2f48a38d;
case 0x0000dd28:
return 0x5091e57c;
case 0x0000dd2c:
return 0xe4c75762;
case 0x0000dd30:
return 0xac231051;
case 0x0000dd34:
return 0x32534224;
case 0x0000dd38:
return 0x2b9acaa0;
case 0x0000dd3c:
return 0xb36c952e;
case 0x0000dd40:
return 0xcd621414;
case 0x0000dd44:
return 0x6e23750c;
case 0x0000dd48:
return 0xe32c7347;
case 0x0000dd4c:
return 0x1ad91a5b;
case 0x0000dd50:
return 0x9c2da6ca;
case 0x0000dd54:
return 0x3f2bbb47;
case 0x0000dd58:
return 0xa208cbb9;
case 0x0000dd5c:
return 0xe1b84df2;
case 0x0000dd60:
return 0x598d26ba;
case 0x0000dd64:
return 0x5f6ae44c;
case 0x0000dd68:
return 0xb453a69a;
case 0x0000dd6c:
return 0x28bda310;
case 0x0000dd70:
return 0x1fcdaec1;
case 0x0000dd74:
return 0xb9ded839;
case 0x0000dd78:
return 0x2f8ab609;
case 0x0000dd7c:
return 0xdcf0d1ae;
case 0x0000dd80:
return 0x4467ded3;
case 0x0000dd84:
return 0x1a1ab4a9;
case 0x0000dd88:
return 0xe5582786;
case 0x0000dd8c:
return 0x2a64c591;
case 0x0000dd90:
return 0x3eacd04a;
case 0x0000dd94:
return 0x42b6914c;
case 0x0000dd98:
return 0xb7e29631;
case 0x0000dd9c:
return 0x54d1d0a5;
case 0x0000dda0:
return 0xbaa1718b;
case 0x0000dda4:
return 0xb18780f9;
case 0x0000dda8:
return 0xcfb7f68b;
case 0x0000ddac:
return 0xc95acda1;
case 0x0000ddb0:
return 0xb88c293e;
case 0x0000ddb4:
return 0x143adead;
case 0x0000ddb8:
return 0x7a4bd105;
case 0x0000ddbc:
return 0x15adb4b0;
case 0x0000ddc0:
return 0x569a3864;
case 0x0000ddc4:
return 0x43d3b905;
case 0x0000ddc8:
return 0xfe2c6ff7;
case 0x0000ddcc:
return 0x2c1ca1dc;
case 0x0000ddd0:
return 0x2781be19;
case 0x0000ddd4:
return 0xc1eef165;
case 0x0000ddd8:
return 0x41b2e3ed;
case 0x0000dddc:
return 0xc71c3b76;
case 0x0000dde0:
return 0x5c3688c6;
case 0x0000dde4:
return 0x6621465d;
case 0x0000dde8:
return 0xfd2be0f3;
case 0x0000ddec:
return 0xf8aae2ce;
case 0x0000ddf0:
return 0x9f5cc75e;
case 0x0000ddf4:
return 0x09fa8122;
case 0x0000ddf8:
return 0x1fa8c948;
case 0x0000ddfc:
return 0x2d1b023f;
case 0x0000de00:
return 0x0fb3247a;
case 0x0000de04:
return 0xce8e9273;
case 0x0000de08:
return 0x22c76eb7;
case 0x0000de0c:
return 0x8e2bbd65;
case 0x0000de10:
return 0x22692bdd;
case 0x0000de14:
return 0xfb1b6866;
case 0x0000de18:
return 0xe7ceff58;
case 0x0000de1c:
return 0x48e9a611;
case 0x0000de20:
return 0xe1dd2ae0;
case 0x0000de24:
return 0x4b476b14;
case 0x0000de28:
return 0xe4e0a811;
case 0x0000de2c:
return 0xac740943;
case 0x0000de30:
return 0x8a695c2e;
case 0x0000de34:
return 0x0b6bc265;
case 0x0000de38:
return 0xca62dcd5;
case 0x0000de3c:
return 0x9920562a;
case 0x0000de40:
return 0x7beba014;
case 0x0000de44:
return 0xd066c30d;
case 0x0000de48:
return 0x60c5c7a7;
case 0x0000de4c:
return 0x679b200e;
case 0x0000de50:
return 0x854b9c1b;
case 0x0000de54:
return 0x9a5ebdce;
case 0x0000de58:
return 0x90f5b4c4;
case 0x0000de5c:
return 0xc813fa1c;
case 0x0000de60:
return 0x6713dfbd;
case 0x0000de64:
return 0x6d3ac129;
case 0x0000de68:
return 0x2c5e58a8;
case 0x0000de6c:
return 0x798ecbc6;
case 0x0000de70:
return 0xe2c85930;
case 0x0000de74:
return 0xf4f14968;
case 0x0000de78:
return 0x696f93ca;
case 0x0000de7c:
return 0xaf645d63;
case 0x0000de80:
return 0x7fb9878b;
case 0x0000de84:
return 0x4c2427af;
case 0x0000de88:
return 0x11236b9e;
case 0x0000de8c:
return 0xf2aae6e1;
case 0x0000de90:
return 0x147f114d;
case 0x0000de94:
return 0x811f0b30;
case 0x0000de98:
return 0x48847f09;
case 0x0000de9c:
return 0x7a45ffde;
case 0x0000dea0:
return 0x97eb9101;
case 0x0000dea4:
return 0x8db9e659;
case 0x0000dea8:
return 0xb957480f;
case 0x0000deac:
return 0xa2955c79;
case 0x0000deb0:
return 0xe22dde64;
case 0x0000deb4:
return 0x53bab1ef;
case 0x0000deb8:
return 0xe1e8058e;
case 0x0000debc:
return 0x9621bb75;
case 0x0000dec0:
return 0xa4584798;
case 0x0000dec4:
return 0x61ce8941;
case 0x0000dec8:
return 0x3b87ed94;
case 0x0000decc:
return 0x2d6f4eb4;
case 0x0000ded0:
return 0xbcae1165;
case 0x0000ded4:
return 0xa73a15f4;
case 0x0000ded8:
return 0x3c2eab73;
case 0x0000dedc:
return 0x0fdd22ab;
case 0x0000dee0:
return 0x2a9c0576;
case 0x0000dee4:
return 0x9fd16180;
case 0x0000dee8:
return 0x430c9a8b;
case 0x0000deec:
return 0x82baca6f;
case 0x0000def0:
return 0xcecd602e;
case 0x0000def4:
return 0xa46ccf96;
case 0x0000def8:
return 0x53d91203;
case 0x0000defc:
return 0x2fa2cd5c;
case 0x0000df00:
return 0x76b960ce;
case 0x0000df04:
return 0x0da06749;
case 0x0000df08:
return 0x4b88d40b;
case 0x0000df0c:
return 0xa2d8b103;
case 0x0000df10:
return 0x3670b036;
case 0x0000df14:
return 0xfe9b6152;
case 0x0000df18:
return 0x1d84b63c;
case 0x0000df1c:
return 0xe0b88302;
case 0x0000df20:
return 0x90aef55b;
case 0x0000df24:
return 0xf247f921;
case 0x0000df28:
return 0xf9c735da;
case 0x0000df2c:
return 0x132bf6d9;
case 0x0000df30:
return 0x0fa04801;
case 0x0000df34:
return 0x8ff611f2;
case 0x0000df38:
return 0x7c28976e;
case 0x0000df3c:
return 0x38c0b199;
case 0x0000df40:
return 0x64e7fb8d;
case 0x0000df44:
return 0xa9da5973;
case 0x0000df48:
return 0x7b45ec7c;
case 0x0000df4c:
return 0x981e7a68;
case 0x0000df50:
return 0xdb9aa310;
case 0x0000df54:
return 0xc6189aeb;
case 0x0000df58:
return 0x5acbe10c;
case 0x0000df5c:
return 0xa090fcba;
case 0x0000df60:
return 0x1c7a5707;
case 0x0000df64:
return 0xeeb4e98a;
case 0x0000df68:
return 0x421c9a13;
case 0x0000df6c:
return 0x1cb9eb16;
case 0x0000df70:
return 0x21a58af0;
case 0x0000df74:
return 0x290e8c1b;
case 0x0000df78:
return 0x49b936d6;
case 0x0000df7c:
return 0x1233291c;
case 0x0000df80:
return 0x97a9da39;
case 0x0000df84:
return 0x710814ef;
case 0x0000df88:
return 0xf779c0fd;
case 0x0000df8c:
return 0x12f3f49d;
case 0x0000df90:
return 0x453e765d;
case 0x0000df94:
return 0x5d710176;
case 0x0000df98:
return 0x52d18e74;
case 0x0000df9c:
return 0x15403252;
case 0x0000dfa0:
return 0x91a3b71c;
case 0x0000dfa4:
return 0xe61663c6;
case 0x0000dfa8:
return 0x682508b9;
case 0x0000dfac:
return 0x6a9f1f6b;
case 0x0000dfb0:
return 0xb9ec312f;
case 0x0000dfb4:
return 0x02d81ac4;
case 0x0000dfb8:
return 0x92646700;
case 0x0000dfbc:
return 0xb5b67486;
case 0x0000dfc0:
return 0x8f4523e5;
case 0x0000dfc4:
return 0x66326eb5;
case 0x0000dfc8:
return 0xb05f8280;
case 0x0000dfcc:
return 0x782ba5c1;
case 0x0000dfd0:
return 0xaa4854ae;
case 0x0000dfd4:
return 0xfb02b9c2;
case 0x0000dfd8:
return 0x68a9f05c;
case 0x0000dfdc:
return 0xe9902077;
case 0x0000dfe0:
return 0x5189e1b6;
case 0x0000dfe4:
return 0x4d2d912a;
case 0x0000dfe8:
return 0xdaa109d3;
case 0x0000dfec:
return 0x235ff33b;
case 0x0000dff0:
return 0x70a86573;
case 0x0000dff4:
return 0xde6b0bea;
case 0x0000dff8:
return 0x4294caec;
case 0x0000dffc:
return 0x2d3c91d6;
case 0x0000e000:
return 0x269eabd5;
case 0x0000e004:
return 0x2f83d6e3;
case 0x0000e008:
return 0x01bd1f21;
case 0x0000e00c:
return 0x5f682067;
case 0x0000e010:
return 0x0fc58e4f;
case 0x0000e014:
return 0x4698ece3;
case 0x0000e018:
return 0x2b44b0a6;
case 0x0000e01c:
return 0xb8d2bc4a;
case 0x0000e020:
return 0x71182f98;
case 0x0000e024:
return 0xe0092d65;
case 0x0000e028:
return 0x22999551;
case 0x0000e02c:
return 0x914dc32a;
case 0x0000e030:
return 0xdf83bf6d;
case 0x0000e034:
return 0x3fa040b5;
case 0x0000e038:
return 0x5c3afaf1;
case 0x0000e03c:
return 0x79a902a4;
case 0x0000e040:
return 0x318cf359;
case 0x0000e044:
return 0xb1a47244;
case 0x0000e048:
return 0x7ca59ceb;
case 0x0000e04c:
return 0xf1b7e44d;
case 0x0000e050:
return 0x5cc37982;
case 0x0000e054:
return 0xef2d8fc7;
case 0x0000e058:
return 0xbb46f1fc;
case 0x0000e05c:
return 0xb487d8b4;
case 0x0000e060:
return 0x37d62c39;
case 0x0000e064:
return 0xde43e3f1;
case 0x0000e068:
return 0xb2d7974f;
case 0x0000e06c:
return 0x310de8cd;
case 0x0000e070:
return 0x4f15bb3d;
case 0x0000e074:
return 0x2a4c3a26;
case 0x0000e078:
return 0x5b345f33;
case 0x0000e07c:
return 0x487b0042;
case 0x0000e080:
return 0x35f832d1;
case 0x0000e084:
return 0x985fc82c;
case 0x0000e088:
return 0xb5499461;
case 0x0000e08c:
return 0x9e631cf8;
case 0x0000e090:
return 0xd5ec530f;
case 0x0000e094:
return 0xddea212f;
case 0x0000e098:
return 0x8eee5a5f;
case 0x0000e09c:
return 0x99d948d7;
case 0x0000e0a0:
return 0xe946d901;
case 0x0000e0a4:
return 0x9bd905cc;
case 0x0000e0a8:
return 0x47b718b0;
case 0x0000e0ac:
return 0x132c95e6;
case 0x0000e0b0:
return 0x5a19ca6c;
case 0x0000e0b4:
return 0x6eb7176a;
case 0x0000e0b8:
return 0x9f1d702c;
case 0x0000e0bc:
return 0xdfc082f8;
case 0x0000e0c0:
return 0x0aeecabd;
case 0x0000e0c4:
return 0x3e251ac5;
case 0x0000e0c8:
return 0xf94722f0;
case 0x0000e0cc:
return 0x129b2612;
case 0x0000e0d0:
return 0xf83277d1;
case 0x0000e0d4:
return 0x6db78eaf;
case 0x0000e0d8:
return 0xa81ac5c9;
case 0x0000e0dc:
return 0xa2274e19;
case 0x0000e0e0:
return 0x138589c2;
case 0x0000e0e4:
return 0xb63f9fe5;
case 0x0000e0e8:
return 0xf937dda4;
case 0x0000e0ec:
return 0xcf3d5c87;
case 0x0000e0f0:
return 0x9b8b1c04;
case 0x0000e0f4:
return 0xd56072c7;
case 0x0000e0f8:
return 0xcd0c935f;
case 0x0000e0fc:
return 0x05c22ed5;
case 0x0000e100:
return 0xbd5337a8;
case 0x0000e104:
return 0xe8f3ed5d;
case 0x0000e108:
return 0xfbf62270;
case 0x0000e10c:
return 0x72ef6ac4;
case 0x0000e110:
return 0xa34c2820;
case 0x0000e114:
return 0xf648d65b;
case 0x0000e118:
return 0xc3317943;
case 0x0000e11c:
return 0x733c9424;
case 0x0000e120:
return 0x47f3089e;
case 0x0000e124:
return 0x7e505648;
case 0x0000e128:
return 0x084ce826;
case 0x0000e12c:
return 0xd51c6596;
case 0x0000e130:
return 0xca2aaf93;
case 0x0000e134:
return 0xd308450c;
case 0x0000e138:
return 0xcc6b928b;
case 0x0000e13c:
return 0xcc381293;
case 0x0000e140:
return 0xaad4b0e8;
case 0x0000e144:
return 0x23cf22c8;
case 0x0000e148:
return 0x9153e376;
case 0x0000e14c:
return 0xcc5e7cc7;
case 0x0000e150:
return 0x47df2bf2;
case 0x0000e154:
return 0x7baecc05;
case 0x0000e158:
return 0x737b76ec;
case 0x0000e15c:
return 0x99f58427;
case 0x0000e160:
return 0x7e5bccab;
case 0x0000e164:
return 0x8cc7cede;
case 0x0000e168:
return 0xa9e05a08;
case 0x0000e16c:
return 0x6a51b15d;
case 0x0000e170:
return 0xab1919a5;
case 0x0000e174:
return 0x14d36d72;
case 0x0000e178:
return 0x8ac3cd4c;
case 0x0000e17c:
return 0x16f05f87;
case 0x0000e180:
return 0x1be95ad9;
case 0x0000e184:
return 0xb1ab5cc7;
case 0x0000e188:
return 0xba3d232d;
case 0x0000e18c:
return 0xad804b86;
case 0x0000e190:
return 0xec6e73b4;
case 0x0000e194:
return 0x93447167;
case 0x0000e198:
return 0x0eac164c;
case 0x0000e19c:
return 0xecd86c69;
case 0x0000e1a0:
return 0x6d1a3bf4;
case 0x0000e1a4:
return 0xbab1dcf4;
case 0x0000e1a8:
return 0x80648287;
case 0x0000e1ac:
return 0x7080cd4c;
case 0x0000e1b0:
return 0x9978e4ad;
case 0x0000e1b4:
return 0xe264e83d;
case 0x0000e1b8:
return 0x27270e88;
case 0x0000e1bc:
return 0x016968f9;
case 0x0000e1c0:
return 0x7fbec428;
case 0x0000e1c4:
return 0xc6f8e112;
case 0x0000e1c8:
return 0xbadfe5a7;
case 0x0000e1cc:
return 0x94fdd67f;
case 0x0000e1d0:
return 0x7ec1c824;
case 0x0000e1d4:
return 0xb55dc81b;
case 0x0000e1d8:
return 0x9106b7c2;
case 0x0000e1dc:
return 0xa862cfb7;
case 0x0000e1e0:
return 0xd7ea0919;
case 0x0000e1e4:
return 0xc7d81033;
case 0x0000e1e8:
return 0x58963e5c;
case 0x0000e1ec:
return 0x0e8bcbd5;
case 0x0000e1f0:
return 0xfee11c9a;
case 0x0000e1f4:
return 0xc93434ec;
case 0x0000e1f8:
return 0xc5c51da3;
case 0x0000e1fc:
return 0x8616f0ed;
case 0x0000e200:
return 0xb15b12bf;
case 0x0000e204:
return 0xad59105b;
case 0x0000e208:
return 0xbc30445d;
case 0x0000e20c:
return 0xec2d9daa;
case 0x0000e210:
return 0xc2d2ea52;
case 0x0000e214:
return 0x0c9fb350;
case 0x0000e218:
return 0xfa441fbe;
case 0x0000e21c:
return 0x15cd36b3;
case 0x0000e220:
return 0x7ce9d267;
case 0x0000e224:
return 0x47838760;
case 0x0000e228:
return 0x51134200;
case 0x0000e22c:
return 0x272510ba;
case 0x0000e230:
return 0x6b4c4ecd;
case 0x0000e234:
return 0xff394f33;
case 0x0000e238:
return 0x05f933a1;
case 0x0000e23c:
return 0xce93302b;
case 0x0000e240:
return 0xbe0c0cfa;
case 0x0000e244:
return 0x5cb8f789;
case 0x0000e248:
return 0xf69cd4bb;
case 0x0000e24c:
return 0x01e4b7ff;
case 0x0000e250:
return 0x3f17cfa6;
case 0x0000e254:
return 0x1814e8f6;
case 0x0000e258:
return 0x0c416834;
case 0x0000e25c:
return 0x36f1504d;
case 0x0000e260:
return 0xbe51fe09;
case 0x0000e264:
return 0xaa0813a8;
case 0x0000e268:
return 0x756e1a58;
case 0x0000e26c:
return 0x12ac4efb;
case 0x0000e270:
return 0xaa7974d8;
case 0x0000e274:
return 0x1985265b;
case 0x0000e278:
return 0x776cff8b;
case 0x0000e27c:
return 0xea919b2b;
case 0x0000e280:
return 0x6d5ee79f;
case 0x0000e284:
return 0x89535743;
case 0x0000e288:
return 0x9c9d1ab1;
case 0x0000e28c:
return 0xa4055619;
case 0x0000e290:
return 0x9dae6fa6;
case 0x0000e294:
return 0x2e3fd95c;
case 0x0000e298:
return 0x6e6e7185;
case 0x0000e29c:
return 0x16ec964f;
case 0x0000e2a0:
return 0x39f8f23b;
case 0x0000e2a4:
return 0xae7a095b;
case 0x0000e2a8:
return 0xdf41bcf6;
case 0x0000e2ac:
return 0xf3e8fe9f;
case 0x0000e2b0:
return 0x8ce879a0;
case 0x0000e2b4:
return 0x07169c5b;
case 0x0000e2b8:
return 0x65e82496;
case 0x0000e2bc:
return 0xc317b2ea;
case 0x0000e2c0:
return 0x592ab677;
case 0x0000e2c4:
return 0xd3423924;
case 0x0000e2c8:
return 0x54ed9c6f;
case 0x0000e2cc:
return 0xf8032ba4;
case 0x0000e2d0:
return 0xc2011ac1;
case 0x0000e2d4:
return 0x970a18a0;
case 0x0000e2d8:
return 0x7cc7ba65;
case 0x0000e2dc:
return 0xab064f50;
case 0x0000e2e0:
return 0xf84b8ec0;
case 0x0000e2e4:
return 0x929f95e2;
case 0x0000e2e8:
return 0x15ebaeba;
case 0x0000e2ec:
return 0xd9d429a6;
case 0x0000e2f0:
return 0x385434d4;
case 0x0000e2f4:
return 0x4e94bcad;
case 0x0000e2f8:
return 0x142f76c5;
case 0x0000e2fc:
return 0x587f299b;
case 0x0000e300:
return 0xa466b0d9;
case 0x0000e304:
return 0x16e6b1e7;
case 0x0000e308:
return 0xa0b7d677;
case 0x0000e30c:
return 0xd75d9a61;
case 0x0000e310:
return 0x0908d0ed;
case 0x0000e314:
return 0x4ec6e340;
case 0x0000e318:
return 0x618d299b;
case 0x0000e31c:
return 0xe603bf3c;
case 0x0000e320:
return 0x9c40e2ee;
case 0x0000e324:
return 0x27457368;
case 0x0000e328:
return 0x892fa7b8;
case 0x0000e32c:
return 0x996391b0;
case 0x0000e330:
return 0xa9714326;
case 0x0000e334:
return 0x9b6f4c75;
case 0x0000e338:
return 0xdbd6c1ac;
case 0x0000e33c:
return 0x11edc705;
case 0x0000e340:
return 0xf4de5fbc;
case 0x0000e344:
return 0xfd139385;
case 0x0000e348:
return 0x61cfec8b;
case 0x0000e34c:
return 0xc96f9d5b;
case 0x0000e350:
return 0x8ec34dde;
case 0x0000e354:
return 0x1a95256d;
case 0x0000e358:
return 0xcb7c17e3;
case 0x0000e35c:
return 0xae0284a1;
case 0x0000e360:
return 0xca74862b;
case 0x0000e364:
return 0x5e157f08;
case 0x0000e368:
return 0x67f5a77c;
case 0x0000e36c:
return 0xb1fcacc2;
case 0x0000e370:
return 0xba38c1a7;
case 0x0000e374:
return 0x48d96992;
case 0x0000e378:
return 0xbe1606d6;
case 0x0000e37c:
return 0x325ee48c;
case 0x0000e380:
return 0x259dda05;
case 0x0000e384:
return 0x6796f6c1;
case 0x0000e388:
return 0x41870e7c;
case 0x0000e38c:
return 0x50b7dc1b;
case 0x0000e390:
return 0x21056770;
case 0x0000e394:
return 0xa05a4a8f;
case 0x0000e398:
return 0x0b335508;
case 0x0000e39c:
return 0x2782b111;
case 0x0000e3a0:
return 0xbff02130;
case 0x0000e3a4:
return 0x3ab45e41;
case 0x0000e3a8:
return 0xf2124b68;
case 0x0000e3ac:
return 0xcaf273d7;
case 0x0000e3b0:
return 0xa34282cc;
case 0x0000e3b4:
return 0xfb765110;
case 0x0000e3b8:
return 0x330f15d3;
case 0x0000e3bc:
return 0x6a2d3db3;
case 0x0000e3c0:
return 0xd9d8ae4b;
case 0x0000e3c4:
return 0x8c4ab608;
case 0x0000e3c8:
return 0x13c50a46;
case 0x0000e3cc:
return 0xb4ea121f;
case 0x0000e3d0:
return 0xf6d54a5f;
case 0x0000e3d4:
return 0x7fbe374a;
case 0x0000e3d8:
return 0x07e68f6c;
case 0x0000e3dc:
return 0x6dec110a;
case 0x0000e3e0:
return 0x1bb7389b;
case 0x0000e3e4:
return 0x055d21bd;
case 0x0000e3e8:
return 0x3931fcbf;
case 0x0000e3ec:
return 0xf2069fe6;
case 0x0000e3f0:
return 0x8ef46434;
case 0x0000e3f4:
return 0x84dd35fe;
case 0x0000e3f8:
return 0x2dfe1ea3;
case 0x0000e3fc:
return 0xd2672b92;
case 0x0000e400:
return 0x82c565f6;
case 0x0000e404:
return 0x54ec8371;
case 0x0000e408:
return 0x54c592ef;
case 0x0000e40c:
return 0x3be998be;
case 0x0000e410:
return 0x69cdc6ba;
case 0x0000e414:
return 0x0c9c57b3;
case 0x0000e418:
return 0xa76dd5cf;
case 0x0000e41c:
return 0x676028ff;
case 0x0000e420:
return 0x52136234;
case 0x0000e424:
return 0x0b1475c7;
case 0x0000e428:
return 0x7a76dcd6;
case 0x0000e42c:
return 0x9c995726;
case 0x0000e430:
return 0x048d4869;
case 0x0000e434:
return 0x78df0306;
case 0x0000e438:
return 0x0071bd8f;
case 0x0000e43c:
return 0x0ca947a1;
case 0x0000e440:
return 0xd2942016;
case 0x0000e444:
return 0xf06df11c;
case 0x0000e448:
return 0x6e4d9406;
case 0x0000e44c:
return 0xc9be08fb;
case 0x0000e450:
return 0x560a66cf;
case 0x0000e454:
return 0xe6147b6b;
case 0x0000e458:
return 0xbad1e82a;
case 0x0000e45c:
return 0x8980d42f;
case 0x0000e460:
return 0xb848b3b2;
case 0x0000e464:
return 0xd8ee88ce;
case 0x0000e468:
return 0xb3b5b6d5;
case 0x0000e46c:
return 0xa6bdfb30;
case 0x0000e470:
return 0x2b448ea7;
case 0x0000e474:
return 0x06f9cfc8;
case 0x0000e478:
return 0x1fd46b17;
case 0x0000e47c:
return 0x385b9aa3;
case 0x0000e480:
return 0x4ab1c6af;
case 0x0000e484:
return 0xb9894e31;
case 0x0000e488:
return 0x93feaaf5;
case 0x0000e48c:
return 0x1bd8a005;
case 0x0000e490:
return 0x7263dcd7;
case 0x0000e494:
return 0x30e4b87d;
case 0x0000e498:
return 0xdc6e50fc;
case 0x0000e49c:
return 0xd5fa5ef2;
case 0x0000e4a0:
return 0x488eec8c;
case 0x0000e4a4:
return 0x189f26f8;
case 0x0000e4a8:
return 0x68a18272;
case 0x0000e4ac:
return 0x05f23070;
case 0x0000e4b0:
return 0x4648660a;
case 0x0000e4b4:
return 0x128eeb27;
case 0x0000e4b8:
return 0xa3b9869d;
case 0x0000e4bc:
return 0xedd6d475;
case 0x0000e4c0:
return 0x719602d4;
case 0x0000e4c4:
return 0xd7c3e4af;
case 0x0000e4c8:
return 0x48d21b5a;
case 0x0000e4cc:
return 0xe0eb3eb2;
case 0x0000e4d0:
return 0x651ccf3f;
case 0x0000e4d4:
return 0xedb17931;
case 0x0000e4d8:
return 0xa6c19891;
case 0x0000e4dc:
return 0xfabe60a3;
case 0x0000e4e0:
return 0xaf29ed68;
case 0x0000e4e4:
return 0x47504dbc;
case 0x0000e4e8:
return 0xe4f6eb24;
case 0x0000e4ec:
return 0xf1a6925b;
case 0x0000e4f0:
return 0x14b04689;
case 0x0000e4f4:
return 0x028b7d97;
case 0x0000e4f8:
return 0x536d41a3;
case 0x0000e4fc:
return 0xd20f456a;
case 0x0000e500:
return 0xe59b17bc;
case 0x0000e504:
return 0xb60f9393;
case 0x0000e508:
return 0x79e6cd4b;
case 0x0000e50c:
return 0x951c1b4c;
case 0x0000e510:
return 0x8b0a41ae;
case 0x0000e514:
return 0x681cdcd1;
case 0x0000e518:
return 0xf47a6085;
case 0x0000e51c:
return 0x6929d570;
case 0x0000e520:
return 0x2bf45c05;
case 0x0000e524:
return 0x153a1798;
case 0x0000e528:
return 0xf2c356f4;
case 0x0000e52c:
return 0xd44b6622;
case 0x0000e530:
return 0xd77e5294;
case 0x0000e534:
return 0x1216f281;
case 0x0000e538:
return 0x6b69ee16;
case 0x0000e53c:
return 0xb9799f9f;
case 0x0000e540:
return 0x67cb3a0f;
case 0x0000e544:
return 0xcc8bee6c;
case 0x0000e548:
return 0x8920d879;
case 0x0000e54c:
return 0xb31aae33;
case 0x0000e550:
return 0xc3a0341c;
case 0x0000e554:
return 0x63eac044;
case 0x0000e558:
return 0x8553e978;
case 0x0000e55c:
return 0x445ac47d;
case 0x0000e560:
return 0xff2534ff;
case 0x0000e564:
return 0x2ae75f70;
case 0x0000e568:
return 0x25f8113b;
case 0x0000e56c:
return 0xf7bf23c4;
case 0x0000e570:
return 0x96248c11;
case 0x0000e574:
return 0xbf03c29c;
case 0x0000e578:
return 0x4fa1339e;
case 0x0000e57c:
return 0xfa7ee820;
case 0x0000e580:
return 0x8465af24;
case 0x0000e584:
return 0xd52a1e3e;
case 0x0000e588:
return 0x70a8f5ca;
case 0x0000e58c:
return 0x7d2481ee;
case 0x0000e590:
return 0x20df6809;
case 0x0000e594:
return 0x81d4450c;
case 0x0000e598:
return 0xf6e2112f;
case 0x0000e59c:
return 0x3b212d31;
case 0x0000e5a0:
return 0x477f53cb;
case 0x0000e5a4:
return 0x6023ca8b;
case 0x0000e5a8:
return 0x7ebc57fa;
case 0x0000e5ac:
return 0xa683fab7;
case 0x0000e5b0:
return 0x945a240d;
case 0x0000e5b4:
return 0x9f44d7be;
case 0x0000e5b8:
return 0x90bf30ba;
case 0x0000e5bc:
return 0x4767cfd8;
case 0x0000e5c0:
return 0x7f983065;
case 0x0000e5c4:
return 0x71c87939;
case 0x0000e5c8:
return 0x0dec5b69;
case 0x0000e5cc:
return 0x427c0c76;
case 0x0000e5d0:
return 0x3ae16153;
case 0x0000e5d4:
return 0x898f8930;
case 0x0000e5d8:
return 0xec7df77b;
case 0x0000e5dc:
return 0x7dcab8b3;
case 0x0000e5e0:
return 0xe7726fc2;
case 0x0000e5e4:
return 0xd6eabc84;
case 0x0000e5e8:
return 0x1fb8ab8d;
case 0x0000e5ec:
return 0x04b98846;
case 0x0000e5f0:
return 0xa8c874a0;
case 0x0000e5f4:
return 0x3f45767f;
case 0x0000e5f8:
return 0x21ca43e9;
case 0x0000e5fc:
return 0xa028c663;
case 0x0000e600:
return 0xd547e5d7;
case 0x0000e604:
return 0x2e65e7ef;
case 0x0000e608:
return 0x8c9b2e18;
case 0x0000e60c:
return 0xc893f389;
case 0x0000e610:
return 0x803985bf;
case 0x0000e614:
return 0xca4350e3;
case 0x0000e618:
return 0xc5257432;
case 0x0000e61c:
return 0x60d1b327;
case 0x0000e620:
return 0x88eb72a7;
case 0x0000e624:
return 0x9b5a0e8d;
case 0x0000e628:
return 0xf3134cd8;
case 0x0000e62c:
return 0x75bda650;
case 0x0000e630:
return 0x3a43c513;
case 0x0000e634:
return 0x9c1c3e9b;
case 0x0000e638:
return 0xb8b29de6;
case 0x0000e63c:
return 0x53198595;
case 0x0000e640:
return 0x360973e6;
case 0x0000e644:
return 0x178d0f10;
case 0x0000e648:
return 0xc8f0f87f;
case 0x0000e64c:
return 0xbf667702;
case 0x0000e650:
return 0x1bf686ea;
case 0x0000e654:
return 0x79b83ca3;
case 0x0000e658:
return 0x025deb3e;
case 0x0000e65c:
return 0xccfcf179;
case 0x0000e660:
return 0xddaf84cb;
case 0x0000e664:
return 0x9ab482ef;
case 0x0000e668:
return 0x7e286a61;
case 0x0000e66c:
return 0xcbe719fb;
case 0x0000e670:
return 0xf600e0fa;
case 0x0000e674:
return 0x8ed6def3;
case 0x0000e678:
return 0x046c9a0d;
case 0x0000e67c:
return 0x82cc012e;
case 0x0000e680:
return 0x3a565746;
case 0x0000e684:
return 0x654a32ed;
case 0x0000e688:
return 0x9feec3d2;
case 0x0000e68c:
return 0x1c5a172a;
case 0x0000e690:
return 0x427df95c;
case 0x0000e694:
return 0xe988370d;
case 0x0000e698:
return 0x03a02fd1;
case 0x0000e69c:
return 0xe02a7ef0;
case 0x0000e6a0:
return 0x019916d6;
case 0x0000e6a4:
return 0x525de382;
case 0x0000e6a8:
return 0xb2f1e1eb;
case 0x0000e6ac:
return 0x54577652;
case 0x0000e6b0:
return 0x8e064c13;
case 0x0000e6b4:
return 0x9b381960;
case 0x0000e6b8:
return 0x8a0c35e3;
case 0x0000e6bc:
return 0xc04c5165;
case 0x0000e6c0:
return 0xa6f36b7e;
case 0x0000e6c4:
return 0xb412883c;
case 0x0000e6c8:
return 0x7074359e;
case 0x0000e6cc:
return 0xadbf44b5;
case 0x0000e6d0:
return 0x53db4bb2;
case 0x0000e6d4:
return 0x1c76aebd;
case 0x0000e6d8:
return 0x9843fdf7;
case 0x0000e6dc:
return 0xaaa9160e;
case 0x0000e6e0:
return 0x5015ac45;
case 0x0000e6e4:
return 0xfef3a1d3;
case 0x0000e6e8:
return 0x3de8cbb4;
case 0x0000e6ec:
return 0x846f7c94;
case 0x0000e6f0:
return 0xe2bf0d22;
case 0x0000e6f4:
return 0xf9602eaa;
case 0x0000e6f8:
return 0xe1634f7b;
case 0x0000e6fc:
return 0xb8cdd377;
case 0x0000e700:
return 0xa70e9791;
case 0x0000e704:
return 0xdb685a6b;
case 0x0000e708:
return 0x4cdb53f3;
case 0x0000e70c:
return 0x25bb6cf5;
case 0x0000e710:
return 0x2b2f30cf;
case 0x0000e714:
return 0xac5175c8;
case 0x0000e718:
return 0x5f0590fe;
case 0x0000e71c:
return 0x94d34296;
case 0x0000e720:
return 0x816db876;
case 0x0000e724:
return 0x90d68587;
case 0x0000e728:
return 0xd3ddc562;
case 0x0000e72c:
return 0x494952f6;
case 0x0000e730:
return 0xd96d6d8f;
case 0x0000e734:
return 0x21ca5207;
case 0x0000e738:
return 0x673fe25f;
case 0x0000e73c:
return 0x85978c65;
case 0x0000e740:
return 0x7c6885d0;
case 0x0000e744:
return 0x06f0584a;
case 0x0000e748:
return 0xebbdd5c9;
case 0x0000e74c:
return 0xbc8cd232;
case 0x0000e750:
return 0x066193f2;
case 0x0000e754:
return 0xf1b4ab2a;
case 0x0000e758:
return 0x2ad94e0b;
case 0x0000e75c:
return 0x95eb5828;
case 0x0000e760:
return 0x14a45473;
case 0x0000e764:
return 0x854943b5;
case 0x0000e768:
return 0x222c4afa;
case 0x0000e76c:
return 0x719df33a;
case 0x0000e770:
return 0x8847bc4c;
case 0x0000e774:
return 0x5c572ad2;
case 0x0000e778:
return 0x79e684a4;
case 0x0000e77c:
return 0x6249e906;
case 0x0000e780:
return 0xfa3d220d;
case 0x0000e784:
return 0x7fea0b7e;
case 0x0000e788:
return 0x1df65896;
case 0x0000e78c:
return 0xed8d1122;
case 0x0000e790:
return 0xb55b54c8;
case 0x0000e794:
return 0xdf2ba3e6;
case 0x0000e798:
return 0x26c9ab72;
case 0x0000e79c:
return 0x699f282b;
case 0x0000e7a0:
return 0x958306ac;
case 0x0000e7a4:
return 0x2f00c58d;
case 0x0000e7a8:
return 0x07f6f67b;
case 0x0000e7ac:
return 0xa4fd3e3f;
case 0x0000e7b0:
return 0x607ab25d;
case 0x0000e7b4:
return 0x486e8bab;
case 0x0000e7b8:
return 0x43b77a2d;
case 0x0000e7bc:
return 0x15d90ce1;
case 0x0000e7c0:
return 0xbb59aab8;
case 0x0000e7c4:
return 0x95292a47;
case 0x0000e7c8:
return 0x16d15db1;
case 0x0000e7cc:
return 0xcf237502;
case 0x0000e7d0:
return 0x6afbdd70;
case 0x0000e7d4:
return 0x23ea2d95;
case 0x0000e7d8:
return 0xa3f28b2d;
case 0x0000e7dc:
return 0x2227408e;
case 0x0000e7e0:
return 0xde6085fc;
case 0x0000e7e4:
return 0x41bce296;
case 0x0000e7e8:
return 0x127c080c;
case 0x0000e7ec:
return 0xe75274a7;
case 0x0000e7f0:
return 0xe410a35c;
case 0x0000e7f4:
return 0xf2def148;
case 0x0000e7f8:
return 0xdff8ee87;
case 0x0000e7fc:
return 0xa991540e;
case 0x0000e800:
return 0x58dc2688;
case 0x0000e804:
return 0xab4234c2;
case 0x0000e808:
return 0x37ef5a97;
case 0x0000e80c:
return 0xe0682b9f;
case 0x0000e810:
return 0x49ad37eb;
case 0x0000e814:
return 0x3a154514;
case 0x0000e818:
return 0xe7f1ed52;
case 0x0000e81c:
return 0x6f84cfc5;
case 0x0000e820:
return 0xefd12881;
case 0x0000e824:
return 0x3fc078a3;
case 0x0000e828:
return 0xbbca8d64;
case 0x0000e82c:
return 0x5eb3e04b;
case 0x0000e830:
return 0x02fa8204;
case 0x0000e834:
return 0x09d9cb42;
case 0x0000e838:
return 0x42d23d6b;
case 0x0000e83c:
return 0x7f2d97a4;
case 0x0000e840:
return 0x26e726a2;
case 0x0000e844:
return 0xbcc2f093;
case 0x0000e848:
return 0xf798b1f6;
case 0x0000e84c:
return 0xcff49a97;
case 0x0000e850:
return 0x74cb9f91;
case 0x0000e854:
return 0xbbe8e7cb;
case 0x0000e858:
return 0x29bae445;
case 0x0000e85c:
return 0x1a609088;
case 0x0000e860:
return 0x42b5f22c;
case 0x0000e864:
return 0x72f91f3f;
case 0x0000e868:
return 0xdceda565;
case 0x0000e86c:
return 0xd35916fb;
case 0x0000e870:
return 0x0587aadc;
case 0x0000e874:
return 0x8837f951;
case 0x0000e878:
return 0xd162746a;
case 0x0000e87c:
return 0xfefb56df;
case 0x0000e880:
return 0xd75decd5;
case 0x0000e884:
return 0xc511a94a;
case 0x0000e888:
return 0x924c15fa;
case 0x0000e88c:
return 0xd67f4897;
case 0x0000e890:
return 0x28bb8402;
case 0x0000e894:
return 0xf79ece6b;
case 0x0000e898:
return 0xa6b3d4df;
case 0x0000e89c:
return 0x49c3823b;
case 0x0000e8a0:
return 0xa87ff769;
case 0x0000e8a4:
return 0x0f2ef28b;
case 0x0000e8a8:
return 0x495fba3e;
case 0x0000e8ac:
return 0xd7bd8917;
case 0x0000e8b0:
return 0x7966f286;
case 0x0000e8b4:
return 0x162f166f;
case 0x0000e8b8:
return 0x845f15f8;
case 0x0000e8bc:
return 0xb8cbea7b;
case 0x0000e8c0:
return 0x6582a5a0;
case 0x0000e8c4:
return 0x1a7176e4;
case 0x0000e8c8:
return 0x545eb6d5;
case 0x0000e8cc:
return 0xe3f7ffec;
case 0x0000e8d0:
return 0x3638c0ad;
case 0x0000e8d4:
return 0xfd0f534d;
case 0x0000e8d8:
return 0xdc069338;
case 0x0000e8dc:
return 0x7e2a3fe3;
case 0x0000e8e0:
return 0x18c5e21a;
case 0x0000e8e4:
return 0x5dbeee03;
case 0x0000e8e8:
return 0xd5b1086b;
case 0x0000e8ec:
return 0xeae05b9a;
case 0x0000e8f0:
return 0xb7aa549e;
case 0x0000e8f4:
return 0x8651974d;
case 0x0000e8f8:
return 0x4dacbe39;
case 0x0000e8fc:
return 0x277f5744;
case 0x0000e900:
return 0x96182446;
case 0x0000e904:
return 0x73ef1bee;
case 0x0000e908:
return 0xad8f1fed;
case 0x0000e90c:
return 0xea68ee64;
case 0x0000e910:
return 0xbd242af5;
case 0x0000e914:
return 0x30b25bd7;
case 0x0000e918:
return 0x5bd0c225;
case 0x0000e91c:
return 0x1cb1ae12;
case 0x0000e920:
return 0x29720f79;
case 0x0000e924:
return 0x4ceac5f3;
case 0x0000e928:
return 0x157ce4ad;
case 0x0000e92c:
return 0x82d576a7;
case 0x0000e930:
return 0x5afefaee;
case 0x0000e934:
return 0xabfe51d0;
case 0x0000e938:
return 0x1e27235e;
case 0x0000e93c:
return 0x919f63fa;
case 0x0000e940:
return 0x6fd67db1;
case 0x0000e944:
return 0xa002747e;
case 0x0000e948:
return 0xc285d95a;
case 0x0000e94c:
return 0x38301149;
case 0x0000e950:
return 0xe88f5c8c;
case 0x0000e954:
return 0x9eb0e788;
case 0x0000e958:
return 0xc62715ee;
case 0x0000e95c:
return 0x82784c80;
case 0x0000e960:
return 0x5aff19a6;
case 0x0000e964:
return 0x2528f06b;
case 0x0000e968:
return 0xbd60d8a4;
case 0x0000e96c:
return 0x678e4143;
case 0x0000e970:
return 0x9b55756f;
case 0x0000e974:
return 0x12d4e6b7;
case 0x0000e978:
return 0x980585a5;
case 0x0000e97c:
return 0xedf339a8;
case 0x0000e980:
return 0x54537f19;
case 0x0000e984:
return 0xfd26a771;
case 0x0000e988:
return 0x878d7c56;
case 0x0000e98c:
return 0x49d803fa;
case 0x0000e990:
return 0x66e9780f;
case 0x0000e994:
return 0x053c8edb;
case 0x0000e998:
return 0xb7dc894f;
case 0x0000e99c:
return 0x14787813;
case 0x0000e9a0:
return 0x185d326e;
case 0x0000e9a4:
return 0x26771f63;
case 0x0000e9a8:
return 0x245fdf4c;
case 0x0000e9ac:
return 0xc8d8a84f;
case 0x0000e9b0:
return 0xb61f92a8;
case 0x0000e9b4:
return 0xafac5627;
case 0x0000e9b8:
return 0x37911213;
case 0x0000e9bc:
return 0xfd298f48;
case 0x0000e9c0:
return 0x66bdfda7;
case 0x0000e9c4:
return 0xa8dd8433;
case 0x0000e9c8:
return 0xc2627147;
case 0x0000e9cc:
return 0xb54db5ee;
case 0x0000e9d0:
return 0x4f1d61f2;
case 0x0000e9d4:
return 0x048953e2;
case 0x0000e9d8:
return 0x8e182122;
case 0x0000e9dc:
return 0xb0831842;
case 0x0000e9e0:
return 0xca617673;
case 0x0000e9e4:
return 0x2ad343b4;
case 0x0000e9e8:
return 0x7464aa1b;
case 0x0000e9ec:
return 0xa0449f07;
case 0x0000e9f0:
return 0x34e6ac71;
case 0x0000e9f4:
return 0x0145c19b;
case 0x0000e9f8:
return 0xc70785cc;
case 0x0000e9fc:
return 0x2980cf7d;
case 0x0000ea00:
return 0x43b5fb9c;
case 0x0000ea04:
return 0xffa3f508;
case 0x0000ea08:
return 0xa1477ab4;
case 0x0000ea0c:
return 0xd3bfe03a;
case 0x0000ea10:
return 0x41d15db3;
case 0x0000ea14:
return 0xec0983b4;
case 0x0000ea18:
return 0x464dbd92;
case 0x0000ea1c:
return 0xa2387c96;
case 0x0000ea20:
return 0x33588daf;
case 0x0000ea24:
return 0x3e9f50c2;
case 0x0000ea28:
return 0xdf2c171d;
case 0x0000ea2c:
return 0x31d6df5c;
case 0x0000ea30:
return 0x93dbe2f2;
case 0x0000ea34:
return 0xf0360a7b;
case 0x0000ea38:
return 0xc397bf34;
case 0x0000ea3c:
return 0x73855af7;
case 0x0000ea40:
return 0xf4959b25;
case 0x0000ea44:
return 0xfe6868d1;
case 0x0000ea48:
return 0x54a3894e;
case 0x0000ea4c:
return 0x60369af3;
case 0x0000ea50:
return 0x9355a4e0;
case 0x0000ea54:
return 0xf098d165;
case 0x0000ea58:
return 0xcf02ac52;
case 0x0000ea5c:
return 0x24c2d1dd;
case 0x0000ea60:
return 0x4f266d02;
case 0x0000ea64:
return 0xc40bbfc2;
case 0x0000ea68:
return 0x1ad44a87;
case 0x0000ea6c:
return 0x1153ba73;
case 0x0000ea70:
return 0xaf2bc70d;
case 0x0000ea74:
return 0xc3d3f29e;
case 0x0000ea78:
return 0xe877381b;
case 0x0000ea7c:
return 0x8e0c11d5;
case 0x0000ea80:
return 0xe0bb52c8;
case 0x0000ea84:
return 0x3520a68e;
case 0x0000ea88:
return 0x7ac51529;
case 0x0000ea8c:
return 0xfb4ef4c3;
case 0x0000ea90:
return 0x99e3d900;
case 0x0000ea94:
return 0x1f39b56b;
case 0x0000ea98:
return 0xb6981b0b;
case 0x0000ea9c:
return 0x31a7bc06;
case 0x0000eaa0:
return 0xfa16eedd;
case 0x0000eaa4:
return 0xe021601b;
case 0x0000eaa8:
return 0x49d2d8ee;
case 0x0000eaac:
return 0x55f6d3b3;
case 0x0000eab0:
return 0x6f8fccd9;
case 0x0000eab4:
return 0x5a3abf48;
case 0x0000eab8:
return 0x2acf5bae;
case 0x0000eabc:
return 0xcb062ada;
case 0x0000eac0:
return 0xbb3611e3;
case 0x0000eac4:
return 0x63d2eb82;
case 0x0000eac8:
return 0x1f31c451;
case 0x0000eacc:
return 0x054a7da1;
case 0x0000ead0:
return 0x556e1fc3;
case 0x0000ead4:
return 0x6c10fb5c;
case 0x0000ead8:
return 0xec66c804;
case 0x0000eadc:
return 0x8944fcc5;
case 0x0000eae0:
return 0x8ef3c994;
case 0x0000eae4:
return 0x61905842;
case 0x0000eae8:
return 0x063baa0f;
case 0x0000eaec:
return 0xac3fa468;
case 0x0000eaf0:
return 0xd6d377ab;
case 0x0000eaf4:
return 0x4c43d2f2;
case 0x0000eaf8:
return 0xf1a08d2c;
case 0x0000eafc:
return 0xd6624ecd;
case 0x0000eb00:
return 0x04e7c0e3;
case 0x0000eb04:
return 0xbc9ea6f8;
case 0x0000eb08:
return 0xb93ef628;
case 0x0000eb0c:
return 0xfa67b084;
case 0x0000eb10:
return 0x5b19614a;
case 0x0000eb14:
return 0x11505128;
case 0x0000eb18:
return 0x65ecdd31;
case 0x0000eb1c:
return 0x9d74bea5;
case 0x0000eb20:
return 0x1a9c83a8;
case 0x0000eb24:
return 0x593b2945;
case 0x0000eb28:
return 0x73bb4cdf;
case 0x0000eb2c:
return 0x5b2d5b1c;
case 0x0000eb30:
return 0x603212e6;
case 0x0000eb34:
return 0xc73558b7;
case 0x0000eb38:
return 0xc91d0d95;
case 0x0000eb3c:
return 0x4ef21fdd;
case 0x0000eb40:
return 0xd4b54ff0;
case 0x0000eb44:
return 0x6de3d0b8;
case 0x0000eb48:
return 0xadec5fd8;
case 0x0000eb4c:
return 0xc3f62a05;
case 0x0000eb50:
return 0xdb27a1da;
case 0x0000eb54:
return 0x743684a9;
case 0x0000eb58:
return 0x87e195f3;
case 0x0000eb5c:
return 0xce6f4add;
case 0x0000eb60:
return 0xa12563a0;
case 0x0000eb64:
return 0xb514929a;
case 0x0000eb68:
return 0x81e981af;
case 0x0000eb6c:
return 0xa4e8d175;
case 0x0000eb70:
return 0x5f352e31;
case 0x0000eb74:
return 0x645d09dc;
case 0x0000eb78:
return 0x53057769;
case 0x0000eb7c:
return 0xfe88995e;
case 0x0000eb80:
return 0xb3e58ce1;
case 0x0000eb84:
return 0xae45af39;
case 0x0000eb88:
return 0x3fea6a10;
case 0x0000eb8c:
return 0x52ab8693;
case 0x0000eb90:
return 0x28aec09d;
case 0x0000eb94:
return 0xf0e7e00a;
case 0x0000eb98:
return 0x19019486;
case 0x0000eb9c:
return 0xaae16280;
case 0x0000eba0:
return 0x00fffcce;
case 0x0000eba4:
return 0x2bbee0b9;
case 0x0000eba8:
return 0xd6de13e6;
case 0x0000ebac:
return 0x7b1a6904;
case 0x0000ebb0:
return 0xa4bb6416;
case 0x0000ebb4:
return 0xbe4b12b1;
case 0x0000ebb8:
return 0x1a94dfa9;
case 0x0000ebbc:
return 0x6e6aef28;
case 0x0000ebc0:
return 0x6c52c703;
case 0x0000ebc4:
return 0x43c965c2;
case 0x0000ebc8:
return 0x3c9c55d2;
case 0x0000ebcc:
return 0xc675f9d2;
case 0x0000ebd0:
return 0x4add7154;
case 0x0000ebd4:
return 0x3de0599a;
case 0x0000ebd8:
return 0x08fa341a;
case 0x0000ebdc:
return 0x181dc74e;
case 0x0000ebe0:
return 0xf15ba6f2;
case 0x0000ebe4:
return 0xebe71a39;
case 0x0000ebe8:
return 0xaa0c69f1;
case 0x0000ebec:
return 0x99c3e659;
case 0x0000ebf0:
return 0xd56e76a2;
case 0x0000ebf4:
return 0x6de24b45;
case 0x0000ebf8:
return 0x979c2f14;
case 0x0000ebfc:
return 0x729c30bb;
case 0x0000ec00:
return 0x96374584;
case 0x0000ec04:
return 0xd9dda789;
case 0x0000ec08:
return 0x2835b8b6;
case 0x0000ec0c:
return 0x5509fd10;
case 0x0000ec10:
return 0x3022006f;
case 0x0000ec14:
return 0x94df7c80;
case 0x0000ec18:
return 0x09527822;
case 0x0000ec1c:
return 0x1f45c9da;
case 0x0000ec20:
return 0x34996e29;
case 0x0000ec24:
return 0x02aec9d9;
case 0x0000ec28:
return 0x2b1856a3;
case 0x0000ec2c:
return 0x38f7d8c5;
case 0x0000ec30:
return 0x64988aeb;
case 0x0000ec34:
return 0xc369290a;
case 0x0000ec38:
return 0xd3ca8f72;
case 0x0000ec3c:
return 0xd6855094;
case 0x0000ec40:
return 0xa7ae0bc8;
case 0x0000ec44:
return 0xa1215c2b;
case 0x0000ec48:
return 0xf2dc4442;
case 0x0000ec4c:
return 0x2ace96c9;
case 0x0000ec50:
return 0x3ed602ed;
case 0x0000ec54:
return 0x3749d292;
case 0x0000ec58:
return 0x8d1d69b3;
case 0x0000ec5c:
return 0xc717e607;
case 0x0000ec60:
return 0x5ed1f21c;
case 0x0000ec64:
return 0x13213ffe;
case 0x0000ec68:
return 0xc8cec031;
case 0x0000ec6c:
return 0x7d7f4688;
case 0x0000ec70:
return 0xb7d428d8;
case 0x0000ec74:
return 0x25f86248;
case 0x0000ec78:
return 0xd761d68e;
case 0x0000ec7c:
return 0xc416218f;
case 0x0000ec80:
return 0xe71646ae;
case 0x0000ec84:
return 0x2d4ce5d9;
case 0x0000ec88:
return 0x2e22f054;
case 0x0000ec8c:
return 0x31550b2c;
case 0x0000ec90:
return 0x91041ed6;
case 0x0000ec94:
return 0x5a720ce0;
case 0x0000ec98:
return 0xe3df2ef3;
case 0x0000ec9c:
return 0xf86c29c6;
case 0x0000eca0:
return 0x014633c3;
case 0x0000eca4:
return 0x1d630134;
case 0x0000eca8:
return 0x8562fab8;
case 0x0000ecac:
return 0xd13806a6;
case 0x0000ecb0:
return 0xebc2a09d;
case 0x0000ecb4:
return 0x2d6ced09;
case 0x0000ecb8:
return 0x24e4e075;
case 0x0000ecbc:
return 0xe19c41cc;
case 0x0000ecc0:
return 0x76c92c3e;
case 0x0000ecc4:
return 0xcd0b795e;
case 0x0000ecc8:
return 0x2e2ae407;
case 0x0000eccc:
return 0xdb6bebb8;
case 0x0000ecd0:
return 0xf265ae07;
case 0x0000ecd4:
return 0x39023779;
case 0x0000ecd8:
return 0x9daef8df;
case 0x0000ecdc:
return 0x37a13d1a;
case 0x0000ece0:
return 0x8dfdabc1;
case 0x0000ece4:
return 0x80a90053;
case 0x0000ece8:
return 0x08c3d372;
case 0x0000ecec:
return 0x713adc87;
case 0x0000ecf0:
return 0xaa53de0b;
case 0x0000ecf4:
return 0x54b3d5ff;
case 0x0000ecf8:
return 0x080bfab6;
case 0x0000ecfc:
return 0xe5e92316;
case 0x0000ed00:
return 0xc00155d1;
case 0x0000ed04:
return 0x56f46511;
case 0x0000ed08:
return 0x85c28722;
case 0x0000ed0c:
return 0x7d4029ce;
case 0x0000ed10:
return 0x9e9f2243;
case 0x0000ed14:
return 0x561e4044;
case 0x0000ed18:
return 0xeda217e3;
case 0x0000ed1c:
return 0x49d941ea;
case 0x0000ed20:
return 0x4fb5ed32;
case 0x0000ed24:
return 0x09867b6b;
case 0x0000ed28:
return 0x34ef3e4f;
case 0x0000ed2c:
return 0x7b9f0125;
case 0x0000ed30:
return 0xc7a7a77d;
case 0x0000ed34:
return 0x79d0313b;
case 0x0000ed38:
return 0x4c8ed39d;
case 0x0000ed3c:
return 0x0cdd17aa;
case 0x0000ed40:
return 0x40232927;
case 0x0000ed44:
return 0xfabe784c;
case 0x0000ed48:
return 0x5c8a8912;
case 0x0000ed4c:
return 0x208b3b7b;
case 0x0000ed50:
return 0x7f4443cb;
case 0x0000ed54:
return 0x16140a9e;
case 0x0000ed58:
return 0xd94ee612;
case 0x0000ed5c:
return 0x13787eec;
case 0x0000ed60:
return 0xecc428bc;
case 0x0000ed64:
return 0xfbdb12f7;
case 0x0000ed68:
return 0x0b6389c5;
case 0x0000ed6c:
return 0xbad069fe;
case 0x0000ed70:
return 0x6f295db5;
case 0x0000ed74:
return 0xfd910bb4;
case 0x0000ed78:
return 0x9bdad7f4;
case 0x0000ed7c:
return 0x9d1456fc;
case 0x0000ed80:
return 0x931d3670;
case 0x0000ed84:
return 0xa4ecac19;
case 0x0000ed88:
return 0xb5b00c9e;
case 0x0000ed8c:
return 0xc0d2fd75;
case 0x0000ed90:
return 0x23da5e05;
case 0x0000ed94:
return 0xb6a50384;
case 0x0000ed98:
return 0x0d91a1ff;
case 0x0000ed9c:
return 0x58781eb9;
case 0x0000eda0:
return 0x93404889;
case 0x0000eda4:
return 0x6adf6356;
case 0x0000eda8:
return 0x662fd092;
case 0x0000edac:
return 0xf070d27c;
case 0x0000edb0:
return 0x03bfa42d;
case 0x0000edb4:
return 0x2750c44b;
case 0x0000edb8:
return 0x914da25e;
case 0x0000edbc:
return 0xfd958c9c;
case 0x0000edc0:
return 0x97792990;
case 0x0000edc4:
return 0x165a5ed1;
case 0x0000edc8:
return 0x892e3e98;
case 0x0000edcc:
return 0x115b602e;
case 0x0000edd0:
return 0x7f9c5548;
case 0x0000edd4:
return 0x93c6f053;
case 0x0000edd8:
return 0x9efe1999;
case 0x0000eddc:
return 0x2046e41a;
case 0x0000ede0:
return 0x0bf7b95e;
case 0x0000ede4:
return 0xf7a1d32f;
case 0x0000ede8:
return 0xb4948513;
case 0x0000edec:
return 0xc9aeae15;
case 0x0000edf0:
return 0x480433a0;
case 0x0000edf4:
return 0x3f8ab84d;
case 0x0000edf8:
return 0x5ac8887e;
case 0x0000edfc:
return 0x4f9694ed;
case 0x0000ee00:
return 0x19d02045;
case 0x0000ee04:
return 0xcdf0ad78;
case 0x0000ee08:
return 0x1f94cb42;
case 0x0000ee0c:
return 0x6dc81d77;
case 0x0000ee10:
return 0xaba16cf7;
case 0x0000ee14:
return 0x76efc88a;
case 0x0000ee18:
return 0x08799a84;
case 0x0000ee1c:
return 0xa5b8ae11;
case 0x0000ee20:
return 0xcab74db7;
case 0x0000ee24:
return 0xf22503c3;
case 0x0000ee28:
return 0x1176d0e1;
case 0x0000ee2c:
return 0x7ed8105d;
case 0x0000ee30:
return 0x56cda7c7;
case 0x0000ee34:
return 0x52542e7a;
case 0x0000ee38:
return 0xdb4b27a9;
case 0x0000ee3c:
return 0x453a5701;
case 0x0000ee40:
return 0x1e2a5d2f;
case 0x0000ee44:
return 0xe8ff49a2;
case 0x0000ee48:
return 0x87710e74;
case 0x0000ee4c:
return 0x09fecf41;
case 0x0000ee50:
return 0x9cc0d6c9;
case 0x0000ee54:
return 0x7ce7e07a;
case 0x0000ee58:
return 0x7ce10e9a;
case 0x0000ee5c:
return 0xbf4fc880;
case 0x0000ee60:
return 0xa227db9b;
case 0x0000ee64:
return 0x779e4629;
case 0x0000ee68:
return 0xa51f857e;
case 0x0000ee6c:
return 0xec347522;
case 0x0000ee70:
return 0x50aa577d;
case 0x0000ee74:
return 0xaf142f70;
case 0x0000ee78:
return 0x3510d1ad;
case 0x0000ee7c:
return 0xdff84b01;
case 0x0000ee80:
return 0xe1a52d28;
case 0x0000ee84:
return 0x60d139c6;
case 0x0000ee88:
return 0x2476651d;
case 0x0000ee8c:
return 0x6eb4d5aa;
case 0x0000ee90:
return 0x659cc157;
case 0x0000ee94:
return 0x20da22d6;
case 0x0000ee98:
return 0xcc0e94d4;
case 0x0000ee9c:
return 0x14657f24;
case 0x0000eea0:
return 0xbb6def17;
case 0x0000eea4:
return 0x71454378;
case 0x0000eea8:
return 0x1426e776;
case 0x0000eeac:
return 0x3cddbfb6;
case 0x0000eeb0:
return 0x46171de3;
case 0x0000eeb4:
return 0xfce72d15;
case 0x0000eeb8:
return 0x42f41e04;
case 0x0000eebc:
return 0x6e88b545;
case 0x0000eec0:
return 0x951ebc88;
case 0x0000eec4:
return 0xba53e2d1;
case 0x0000eec8:
return 0xd583f1ea;
case 0x0000eecc:
return 0xbf0ffc0c;
case 0x0000eed0:
return 0x5b130eea;
case 0x0000eed4:
return 0x0d2c7e66;
case 0x0000eed8:
return 0x5203dab0;
case 0x0000eedc:
return 0xfca1339d;
case 0x0000eee0:
return 0x6faefd45;
case 0x0000eee4:
return 0x22bbe200;
case 0x0000eee8:
return 0x18f5db91;
case 0x0000eeec:
return 0x3156b679;
case 0x0000eef0:
return 0xe9c7e473;
case 0x0000eef4:
return 0x6c19dcd1;
case 0x0000eef8:
return 0x3d1c2d4e;
case 0x0000eefc:
return 0x5ea4f84d;
case 0x0000ef00:
return 0x5148bf87;
case 0x0000ef04:
return 0x7d7babdd;
case 0x0000ef08:
return 0xc830c6c1;
case 0x0000ef0c:
return 0xd354de99;
case 0x0000ef10:
return 0x854419ce;
case 0x0000ef14:
return 0x49da0710;
case 0x0000ef18:
return 0xc4c464b9;
case 0x0000ef1c:
return 0x820272bd;
case 0x0000ef20:
return 0x45310862;
case 0x0000ef24:
return 0xe58dab71;
case 0x0000ef28:
return 0xa4ff7d77;
case 0x0000ef2c:
return 0xd5170996;
case 0x0000ef30:
return 0x1d3d057e;
case 0x0000ef34:
return 0xeab9bc1c;
case 0x0000ef38:
return 0xaeb2f909;
case 0x0000ef3c:
return 0xf6745739;
case 0x0000ef40:
return 0x6d12b6df;
case 0x0000ef44:
return 0x84872199;
case 0x0000ef48:
return 0x0dcdb23a;
case 0x0000ef4c:
return 0x95fc4518;
case 0x0000ef50:
return 0xe6863fc8;
case 0x0000ef54:
return 0xed41f72e;
case 0x0000ef58:
return 0xe5068897;
case 0x0000ef5c:
return 0xb23402bf;
case 0x0000ef60:
return 0x7589ee21;
case 0x0000ef64:
return 0x349ed48d;
case 0x0000ef68:
return 0x836305b5;
case 0x0000ef6c:
return 0x6efbbcc0;
case 0x0000ef70:
return 0x6ed600b0;
case 0x0000ef74:
return 0xc08e1ffa;
case 0x0000ef78:
return 0xfac77c2e;
case 0x0000ef7c:
return 0x27e92fa4;
case 0x0000ef80:
return 0x8a3c5f1f;
case 0x0000ef84:
return 0x7b79dde3;
case 0x0000ef88:
return 0xa027b3c4;
case 0x0000ef8c:
return 0xec553e2a;
case 0x0000ef90:
return 0xef8324a4;
case 0x0000ef94:
return 0xbf686d10;
case 0x0000ef98:
return 0x54718cf5;
case 0x0000ef9c:
return 0x0fcf4787;
case 0x0000efa0:
return 0x89e0b51f;
case 0x0000efa4:
return 0x5262481a;
case 0x0000efa8:
return 0x8efd94bc;
case 0x0000efac:
return 0x74542ad0;
case 0x0000efb0:
return 0xa88a30d8;
case 0x0000efb4:
return 0x2791c68c;
case 0x0000efb8:
return 0x0dbab467;
case 0x0000efbc:
return 0xdb7112a7;
case 0x0000efc0:
return 0x44221375;
case 0x0000efc4:
return 0x922af447;
case 0x0000efc8:
return 0x785db974;
case 0x0000efcc:
return 0xd3cbd3ae;
case 0x0000efd0:
return 0x7f9ddd7f;
case 0x0000efd4:
return 0x00c8a07d;
case 0x0000efd8:
return 0x9d78db68;
case 0x0000efdc:
return 0x92176dd4;
case 0x0000efe0:
return 0x1e015a91;
case 0x0000efe4:
return 0x2418d0de;
case 0x0000efe8:
return 0x5c1de524;
case 0x0000efec:
return 0x90d40954;
case 0x0000eff0:
return 0xf4092b91;
case 0x0000eff4:
return 0x32a7eb10;
case 0x0000eff8:
return 0xc224d7a8;
case 0x0000effc:
return 0xf09554f1;
case 0x0000f000:
return 0x419df8af;
case 0x0000f004:
return 0x78c7f455;
case 0x0000f008:
return 0x78e9942a;
case 0x0000f00c:
return 0x2ba4198e;
case 0x0000f010:
return 0x73caada5;
case 0x0000f014:
return 0x2ccf3bcc;
case 0x0000f018:
return 0xa75103e4;
case 0x0000f01c:
return 0x79dd8d54;
case 0x0000f020:
return 0x1dc084b2;
case 0x0000f024:
return 0x49bca3de;
case 0x0000f028:
return 0x49224d2f;
case 0x0000f02c:
return 0xcd1733c0;
case 0x0000f030:
return 0xba432bcb;
case 0x0000f034:
return 0xf3bccc3b;
case 0x0000f038:
return 0x0e24cd2a;
case 0x0000f03c:
return 0xc60675a3;
case 0x0000f040:
return 0x5848de1d;
case 0x0000f044:
return 0x98b306e5;
case 0x0000f048:
return 0x23eb412a;
case 0x0000f04c:
return 0xbd080ee5;
case 0x0000f050:
return 0x4f876f5b;
case 0x0000f054:
return 0xb2b2a45c;
case 0x0000f058:
return 0x039bec1f;
case 0x0000f05c:
return 0x8b4a23af;
case 0x0000f060:
return 0xcf9ca591;
case 0x0000f064:
return 0x49c14369;
case 0x0000f068:
return 0x6ed930d1;
case 0x0000f06c:
return 0xaa1eece4;
case 0x0000f070:
return 0x9a9f8cb6;
case 0x0000f074:
return 0xd31ebf32;
case 0x0000f078:
return 0xb08d455e;
case 0x0000f07c:
return 0x969c2a0b;
case 0x0000f080:
return 0x6f38a6dc;
case 0x0000f084:
return 0x35771ce1;
case 0x0000f088:
return 0x09012a36;
case 0x0000f08c:
return 0x4aca992b;
case 0x0000f090:
return 0x2d0e0f92;
case 0x0000f094:
return 0x681c7504;
case 0x0000f098:
return 0x37bb16c4;
case 0x0000f09c:
return 0x53424c83;
case 0x0000f0a0:
return 0x17395249;
case 0x0000f0a4:
return 0x96db8368;
case 0x0000f0a8:
return 0xc0a4e50a;
case 0x0000f0ac:
return 0x0d427b43;
case 0x0000f0b0:
return 0x7f0274f2;
case 0x0000f0b4:
return 0x7d334e5f;
case 0x0000f0b8:
return 0xabb3ea31;
case 0x0000f0bc:
return 0x0f37fa1a;
case 0x0000f0c0:
return 0xac0d218d;
case 0x0000f0c4:
return 0xfd4e7daf;
case 0x0000f0c8:
return 0x5846aeac;
case 0x0000f0cc:
return 0xb6088ef4;
case 0x0000f0d0:
return 0x8321591f;
case 0x0000f0d4:
return 0xd654dd8f;
case 0x0000f0d8:
return 0x569047b4;
case 0x0000f0dc:
return 0xaabe1799;
case 0x0000f0e0:
return 0xa1c8e159;
case 0x0000f0e4:
return 0xecb08618;
case 0x0000f0e8:
return 0xe873b555;
case 0x0000f0ec:
return 0x4435aa99;
case 0x0000f0f0:
return 0xc30ab0d0;
case 0x0000f0f4:
return 0x93f0589a;
case 0x0000f0f8:
return 0xd807275b;
case 0x0000f0fc:
return 0xf9404f19;
case 0x0000f100:
return 0x82f56d07;
case 0x0000f104:
return 0x4ecdf35f;
case 0x0000f108:
return 0x8af2ee18;
case 0x0000f10c:
return 0x869ec6e1;
case 0x0000f110:
return 0x63675c45;
case 0x0000f114:
return 0x7edbbd16;
case 0x0000f118:
return 0x03752ca2;
case 0x0000f11c:
return 0x0255c7bc;
case 0x0000f120:
return 0x9af73dcc;
case 0x0000f124:
return 0xa1e58dd4;
case 0x0000f128:
return 0xa70a25c7;
case 0x0000f12c:
return 0xd631b596;
case 0x0000f130:
return 0x4ac7e2cb;
case 0x0000f134:
return 0xe98e97d5;
case 0x0000f138:
return 0x1f0a55ee;
case 0x0000f13c:
return 0x2826f188;
case 0x0000f140:
return 0xd03e427b;
case 0x0000f144:
return 0x74ef7e28;
case 0x0000f148:
return 0xe4ebbf63;
case 0x0000f14c:
return 0xed007755;
case 0x0000f150:
return 0x863d9297;
case 0x0000f154:
return 0x6577065d;
case 0x0000f158:
return 0xd81c542f;
case 0x0000f15c:
return 0x6ae889e7;
case 0x0000f160:
return 0x2db65a9f;
case 0x0000f164:
return 0x4643160b;
case 0x0000f168:
return 0xdc447a98;
case 0x0000f16c:
return 0x2ebe5949;
case 0x0000f170:
return 0x0de6ccc3;
case 0x0000f174:
return 0x744ee916;
case 0x0000f178:
return 0x6a5cb83d;
case 0x0000f17c:
return 0x1e2e754c;
case 0x0000f180:
return 0xfd2ddde3;
case 0x0000f184:
return 0xef3c4e73;
case 0x0000f188:
return 0x5b96a66a;
case 0x0000f18c:
return 0x1b66adf8;
case 0x0000f190:
return 0xa0286bf5;
case 0x0000f194:
return 0x2c0c7032;
case 0x0000f198:
return 0x49c47774;
case 0x0000f19c:
return 0xacfdd97c;
case 0x0000f1a0:
return 0x4083ed70;
case 0x0000f1a4:
return 0x6c7e0cba;
case 0x0000f1a8:
return 0xf2826000;
case 0x0000f1ac:
return 0x80da2417;
case 0x0000f1b0:
return 0xcb5dcc37;
case 0x0000f1b4:
return 0x2e386626;
case 0x0000f1b8:
return 0x44a34439;
case 0x0000f1bc:
return 0xa8604bb4;
case 0x0000f1c0:
return 0x73673a73;
case 0x0000f1c4:
return 0x0495af09;
case 0x0000f1c8:
return 0xe146ca3a;
case 0x0000f1cc:
return 0x843c8601;
case 0x0000f1d0:
return 0x1b4c52d2;
case 0x0000f1d4:
return 0x7fc31d74;
case 0x0000f1d8:
return 0xb0bd8217;
case 0x0000f1dc:
return 0xae52ff3f;
case 0x0000f1e0:
return 0x5f9cb88e;
case 0x0000f1e4:
return 0xfdfa651d;
case 0x0000f1e8:
return 0xd62517a9;
case 0x0000f1ec:
return 0xa16923dd;
case 0x0000f1f0:
return 0x6447c3ae;
case 0x0000f1f4:
return 0xde2dda2f;
case 0x0000f1f8:
return 0x2f28fe09;
case 0x0000f1fc:
return 0xc4c0c567;
case 0x0000f200:
return 0x743fa7c2;
case 0x0000f204:
return 0x420ba439;
case 0x0000f208:
return 0xdcd4c2c3;
case 0x0000f20c:
return 0xf5b6b3fe;
case 0x0000f210:
return 0xb0407d85;
case 0x0000f214:
return 0x693f3d76;
case 0x0000f218:
return 0xc45e6c85;
case 0x0000f21c:
return 0x10490c61;
case 0x0000f220:
return 0x7f1064bd;
case 0x0000f224:
return 0x7f2d9c40;
case 0x0000f228:
return 0x0f6d58c6;
case 0x0000f22c:
return 0xe0f63932;
case 0x0000f230:
return 0xaa08499b;
case 0x0000f234:
return 0x3c799dce;
case 0x0000f238:
return 0x238e2340;
case 0x0000f23c:
return 0x2bf3337b;
case 0x0000f240:
return 0x598b4dc6;
case 0x0000f244:
return 0x1dd7657b;
case 0x0000f248:
return 0xed704701;
case 0x0000f24c:
return 0x46d24cec;
case 0x0000f250:
return 0x51a44145;
case 0x0000f254:
return 0x67189932;
case 0x0000f258:
return 0xdcf83bfd;
case 0x0000f25c:
return 0x2a527b04;
case 0x0000f260:
return 0x56205735;
case 0x0000f264:
return 0x0a925426;
case 0x0000f268:
return 0x7154dfa7;
case 0x0000f26c:
return 0x98e47bb5;
case 0x0000f270:
return 0x2747a2ce;
case 0x0000f274:
return 0x6d750c18;
case 0x0000f278:
return 0x3a75fbe7;
case 0x0000f27c:
return 0x7f3e7a13;
case 0x0000f280:
return 0x4ab9c311;
case 0x0000f284:
return 0xce9c96e6;
case 0x0000f288:
return 0x9053248a;
case 0x0000f28c:
return 0xfd87b9a9;
case 0x0000f290:
return 0xc6232f3b;
case 0x0000f294:
return 0x42d89c44;
case 0x0000f298:
return 0xbdeb6340;
case 0x0000f29c:
return 0x1cb6b179;
case 0x0000f2a0:
return 0xf388aec9;
case 0x0000f2a4:
return 0xa0f818c6;
case 0x0000f2a8:
return 0x8f8d6a3b;
case 0x0000f2ac:
return 0x745a3a41;
case 0x0000f2b0:
return 0x11cd761b;
case 0x0000f2b4:
return 0xa5d4aff3;
case 0x0000f2b8:
return 0x2992c6b2;
case 0x0000f2bc:
return 0x3b03ce25;
case 0x0000f2c0:
return 0xa165f5b7;
case 0x0000f2c4:
return 0x862b67eb;
case 0x0000f2c8:
return 0xbeb6c46b;
case 0x0000f2cc:
return 0x40793aa6;
case 0x0000f2d0:
return 0xda776a4c;
case 0x0000f2d4:
return 0x9d52b41d;
case 0x0000f2d8:
return 0x618eb39f;
case 0x0000f2dc:
return 0x1fb15ead;
case 0x0000f2e0:
return 0x57ecdb0e;
case 0x0000f2e4:
return 0x0f146acc;
case 0x0000f2e8:
return 0x8f5ea1d3;
case 0x0000f2ec:
return 0x89c0a024;
case 0x0000f2f0:
return 0x9578da61;
case 0x0000f2f4:
return 0x3d331ae5;
case 0x0000f2f8:
return 0x7726394f;
case 0x0000f2fc:
return 0x7ca7a5ca;
case 0x0000f300:
return 0x9e6b57c4;
case 0x0000f304:
return 0x45a22559;
case 0x0000f308:
return 0xac22ea80;
case 0x0000f30c:
return 0xa6edfdb3;
case 0x0000f310:
return 0x18e150c7;
case 0x0000f314:
return 0x94e07a9f;
case 0x0000f318:
return 0x44b532f4;
case 0x0000f31c:
return 0xac30cf3e;
case 0x0000f320:
return 0xad6dd3f1;
case 0x0000f324:
return 0x329fd24d;
case 0x0000f328:
return 0x6d8c2412;
case 0x0000f32c:
return 0x0e8aacda;
case 0x0000f330:
return 0xb535e0ea;
case 0x0000f334:
return 0x8efbff87;
case 0x0000f338:
return 0x5314c9fc;
case 0x0000f33c:
return 0x9d927854;
case 0x0000f340:
return 0x906d3127;
case 0x0000f344:
return 0xc6878887;
case 0x0000f348:
return 0x543cbf47;
case 0x0000f34c:
return 0xda2c01a8;
case 0x0000f350:
return 0x08af59bd;
case 0x0000f354:
return 0xdddab27d;
case 0x0000f358:
return 0xb180fb10;
case 0x0000f35c:
return 0x165ea918;
case 0x0000f360:
return 0xa80bfcf0;
case 0x0000f364:
return 0xc48c7f79;
case 0x0000f368:
return 0xb20bb6f6;
case 0x0000f36c:
return 0x50b6cafa;
case 0x0000f370:
return 0xfb8e6870;
case 0x0000f374:
return 0xf2036538;
case 0x0000f378:
return 0x6a3cbe6b;
case 0x0000f37c:
return 0xa9839607;
case 0x0000f380:
return 0x0a4dd7e4;
case 0x0000f384:
return 0x9274cf05;
case 0x0000f388:
return 0x25d6acef;
case 0x0000f38c:
return 0x33e13d09;
case 0x0000f390:
return 0xab5435ba;
case 0x0000f394:
return 0xb5a58853;
case 0x0000f398:
return 0x650c071c;
case 0x0000f39c:
return 0xcff45c74;
case 0x0000f3a0:
return 0x1ecfb0f8;
case 0x0000f3a4:
return 0x841ad26e;
case 0x0000f3a8:
return 0xc8725f62;
case 0x0000f3ac:
return 0x76c7234f;
case 0x0000f3b0:
return 0xef0a9a16;
case 0x0000f3b4:
return 0x4956b5d4;
case 0x0000f3b8:
return 0xda89d09f;
case 0x0000f3bc:
return 0x48234515;
case 0x0000f3c0:
return 0x0b0cf990;
case 0x0000f3c4:
return 0xf0025bab;
case 0x0000f3c8:
return 0xccf12aef;
case 0x0000f3cc:
return 0x30b0b2d3;
case 0x0000f3d0:
return 0x88d0d3cb;
case 0x0000f3d4:
return 0x66ec6b93;
case 0x0000f3d8:
return 0x6d444756;
case 0x0000f3dc:
return 0x2da38997;
case 0x0000f3e0:
return 0xf01093fd;
case 0x0000f3e4:
return 0x79da9cd1;
case 0x0000f3e8:
return 0x68b55235;
case 0x0000f3ec:
return 0x3a1bb2ff;
case 0x0000f3f0:
return 0x1a1a1e95;
case 0x0000f3f4:
return 0x77afbec6;
case 0x0000f3f8:
return 0xb90cc9f1;
case 0x0000f3fc:
return 0x8cd2b0e5;
case 0x0000f400:
return 0x98b53fb1;
case 0x0000f404:
return 0x0fbc6915;
case 0x0000f408:
return 0xdad7f23d;
case 0x0000f40c:
return 0x0a0f12ea;
case 0x0000f410:
return 0xe3fd10ad;
case 0x0000f414:
return 0x6fe9e1bd;
case 0x0000f418:
return 0x134a079e;
case 0x0000f41c:
return 0x9bddd4d6;
case 0x0000f420:
return 0x9c04997c;
case 0x0000f424:
return 0xc3d6a4f7;
case 0x0000f428:
return 0x36dd9afe;
case 0x0000f42c:
return 0x26012c05;
case 0x0000f430:
return 0x78df98e3;
case 0x0000f434:
return 0x23d7b5ac;
case 0x0000f438:
return 0x30d4f5af;
case 0x0000f43c:
return 0x3c8ec6d2;
case 0x0000f440:
return 0xa9066bb9;
case 0x0000f444:
return 0x9edd0bc6;
case 0x0000f448:
return 0x0b08768c;
case 0x0000f44c:
return 0x03998491;
case 0x0000f450:
return 0xb46d9ead;
case 0x0000f454:
return 0xba764882;
case 0x0000f458:
return 0x4f8cd9f2;
case 0x0000f45c:
return 0x63417f44;
case 0x0000f460:
return 0xce4ebee3;
case 0x0000f464:
return 0xdd635f50;
case 0x0000f468:
return 0x4e3ebcc8;
case 0x0000f46c:
return 0x307b2fc6;
case 0x0000f470:
return 0x37b3553b;
case 0x0000f474:
return 0xb02b98cc;
case 0x0000f478:
return 0xd05e5801;
case 0x0000f47c:
return 0x5d5ca793;
case 0x0000f480:
return 0xa80aeff7;
case 0x0000f484:
return 0x29006a6a;
case 0x0000f488:
return 0xdc956453;
case 0x0000f48c:
return 0xf3933850;
case 0x0000f490:
return 0xf86222d4;
case 0x0000f494:
return 0x0d7483fa;
case 0x0000f498:
return 0x1a7d3c7e;
case 0x0000f49c:
return 0xc6943f01;
case 0x0000f4a0:
return 0x39d7c54d;
case 0x0000f4a4:
return 0x4575b8bd;
case 0x0000f4a8:
return 0x796be8a2;
case 0x0000f4ac:
return 0x49614b7b;
case 0x0000f4b0:
return 0x7615ad66;
case 0x0000f4b4:
return 0x7b0a1d06;
case 0x0000f4b8:
return 0xfbe73ff6;
case 0x0000f4bc:
return 0xdfdab317;
case 0x0000f4c0:
return 0xcafe0370;
case 0x0000f4c4:
return 0x507071a4;
case 0x0000f4c8:
return 0xa9dac919;
case 0x0000f4cc:
return 0x4ac6eae3;
case 0x0000f4d0:
return 0xe8823c8e;
case 0x0000f4d4:
return 0x5290aa2f;
case 0x0000f4d8:
return 0x894a871f;
case 0x0000f4dc:
return 0x86630ad4;
case 0x0000f4e0:
return 0xbfb80454;
case 0x0000f4e4:
return 0xf7c9e79a;
case 0x0000f4e8:
return 0xf43a9f4b;
case 0x0000f4ec:
return 0xd27e8789;
case 0x0000f4f0:
return 0x2e292a3d;
case 0x0000f4f4:
return 0x9211a11d;
case 0x0000f4f8:
return 0x9bd32d8b;
case 0x0000f4fc:
return 0xdf65d35c;
case 0x0000f500:
return 0xa09d3ccd;
case 0x0000f504:
return 0xcbb14d85;
case 0x0000f508:
return 0xb8f34f30;
case 0x0000f50c:
return 0x25e37c39;
case 0x0000f510:
return 0x92a78a90;
case 0x0000f514:
return 0x3ecc3037;
case 0x0000f518:
return 0x583b49e9;
case 0x0000f51c:
return 0x5041c168;
case 0x0000f520:
return 0xc4081c0a;
case 0x0000f524:
return 0xa6a64271;
case 0x0000f528:
return 0x15044876;
case 0x0000f52c:
return 0xe76d2284;
case 0x0000f530:
return 0x5eaa2dc8;
case 0x0000f534:
return 0x60433748;
case 0x0000f538:
return 0x2e8827c2;
case 0x0000f53c:
return 0xbee225d7;
case 0x0000f540:
return 0xb75aec33;
case 0x0000f544:
return 0x62590cf4;
case 0x0000f548:
return 0xb4e7f9b5;
case 0x0000f54c:
return 0x992e09e8;
case 0x0000f550:
return 0xd6f0cb8b;
case 0x0000f554:
return 0x7240f468;
case 0x0000f558:
return 0x09f831b4;
case 0x0000f55c:
return 0x87d4ed01;
case 0x0000f560:
return 0x39c64c81;
case 0x0000f564:
return 0x81abd2ec;
case 0x0000f568:
return 0xae6122f9;
case 0x0000f56c:
return 0x63217891;
case 0x0000f570:
return 0xab4d2de5;
case 0x0000f574:
return 0xc27f087b;
case 0x0000f578:
return 0xddac8c16;
case 0x0000f57c:
return 0x42d2d1c8;
case 0x0000f580:
return 0x6452b261;
case 0x0000f584:
return 0x0c70e1aa;
case 0x0000f588:
return 0xd39ead0d;
case 0x0000f58c:
return 0x3438f032;
case 0x0000f590:
return 0x2244409e;
case 0x0000f594:
return 0x96aa4498;
case 0x0000f598:
return 0x45a85033;
case 0x0000f59c:
return 0xff3f0b15;
case 0x0000f5a0:
return 0xaf9fcf46;
case 0x0000f5a4:
return 0x1441a3b4;
case 0x0000f5a8:
return 0x89e52209;
case 0x0000f5ac:
return 0xc2a395a3;
case 0x0000f5b0:
return 0xdf3eb875;
case 0x0000f5b4:
return 0xc45dfcff;
case 0x0000f5b8:
return 0x73f3383b;
case 0x0000f5bc:
return 0xdd78fe25;
case 0x0000f5c0:
return 0x9f4d31f6;
case 0x0000f5c4:
return 0xc83dba02;
case 0x0000f5c8:
return 0x50806933;
case 0x0000f5cc:
return 0x55efb065;
case 0x0000f5d0:
return 0xd75a55b0;
case 0x0000f5d4:
return 0xc70cacf4;
case 0x0000f5d8:
return 0x0be6fd2a;
case 0x0000f5dc:
return 0xb68e1184;
case 0x0000f5e0:
return 0xb08258dc;
case 0x0000f5e4:
return 0xf7f3be83;
case 0x0000f5e8:
return 0xc3724a26;
case 0x0000f5ec:
return 0xe28326e7;
case 0x0000f5f0:
return 0x9ca7bf55;
case 0x0000f5f4:
return 0x25e1386d;
case 0x0000f5f8:
return 0xcc5c28dc;
case 0x0000f5fc:
return 0x84344496;
case 0x0000f600:
return 0x0c564946;
case 0x0000f604:
return 0x12e014da;
case 0x0000f608:
return 0x4ea6ea25;
case 0x0000f60c:
return 0x465377c4;
case 0x0000f610:
return 0x0196387b;
case 0x0000f614:
return 0x7ce2669d;
case 0x0000f618:
return 0xcfad202c;
case 0x0000f61c:
return 0xd0be95aa;
case 0x0000f620:
return 0xae1b01ec;
case 0x0000f624:
return 0x7ee0e7f2;
case 0x0000f628:
return 0x115464f2;
case 0x0000f62c:
return 0xa5376cb0;
case 0x0000f630:
return 0x699e808a;
case 0x0000f634:
return 0x57691f0d;
case 0x0000f638:
return 0xe37db430;
case 0x0000f63c:
return 0x29fea754;
case 0x0000f640:
return 0xe7cdc419;
case 0x0000f644:
return 0xa8135138;
case 0x0000f648:
return 0x6b049452;
case 0x0000f64c:
return 0x22d33fcb;
case 0x0000f650:
return 0x7b53a0c7;
case 0x0000f654:
return 0x87baf90a;
case 0x0000f658:
return 0x9f0272a4;
case 0x0000f65c:
return 0x1e08d5e1;
case 0x0000f660:
return 0x0bbf61ed;
case 0x0000f664:
return 0x4d52fc2a;
case 0x0000f668:
return 0x8002409d;
case 0x0000f66c:
return 0x63b0f500;
case 0x0000f670:
return 0x58deaa8c;
case 0x0000f674:
return 0xc1c3dd79;
case 0x0000f678:
return 0xe7e61d76;
case 0x0000f67c:
return 0x05bdb127;
case 0x0000f680:
return 0x7fb3e90f;
case 0x0000f684:
return 0x69b7e4ab;
case 0x0000f688:
return 0xd7d0f9b5;
case 0x0000f68c:
return 0xfb3d047c;
case 0x0000f690:
return 0x9fde0ff1;
case 0x0000f694:
return 0xed8303f9;
case 0x0000f698:
return 0x722610fc;
case 0x0000f69c:
return 0x065661e3;
case 0x0000f6a0:
return 0xae800c3e;
case 0x0000f6a4:
return 0x51d48339;
case 0x0000f6a8:
return 0x3c91b019;
case 0x0000f6ac:
return 0xebdbb2c2;
case 0x0000f6b0:
return 0x38239db0;
case 0x0000f6b4:
return 0xa1bdc352;
case 0x0000f6b8:
return 0x8989e522;
case 0x0000f6bc:
return 0x9c22d4f8;
case 0x0000f6c0:
return 0x92faf815;
case 0x0000f6c4:
return 0xa60644c6;
case 0x0000f6c8:
return 0x551ac393;
case 0x0000f6cc:
return 0xa9cbc3e8;
case 0x0000f6d0:
return 0x5498873a;
case 0x0000f6d4:
return 0x93d54e56;
case 0x0000f6d8:
return 0x81aea9c0;
case 0x0000f6dc:
return 0x9b844332;
case 0x0000f6e0:
return 0x29eee61b;
case 0x0000f6e4:
return 0xd3888618;
case 0x0000f6e8:
return 0xc50209b9;
case 0x0000f6ec:
return 0xbf8576e8;
case 0x0000f6f0:
return 0x594d060f;
case 0x0000f6f4:
return 0xf777f011;
case 0x0000f6f8:
return 0x5a0aa35b;
case 0x0000f6fc:
return 0x57e8a1bd;
case 0x0000f700:
return 0xfdac571b;
case 0x0000f704:
return 0x0c7ef184;
case 0x0000f708:
return 0xdfcb6954;
case 0x0000f70c:
return 0xcbd1dc28;
case 0x0000f710:
return 0x34ba19a4;
case 0x0000f714:
return 0x26c4f21c;
case 0x0000f718:
return 0x8fb8b928;
case 0x0000f71c:
return 0x66af1130;
case 0x0000f720:
return 0xfe6278b2;
case 0x0000f724:
return 0x88c67875;
case 0x0000f728:
return 0x79ffa3a1;
case 0x0000f72c:
return 0x9e66bc17;
case 0x0000f730:
return 0x5b885143;
case 0x0000f734:
return 0x2b612276;
case 0x0000f738:
return 0x7074133f;
case 0x0000f73c:
return 0xfb0c5d55;
case 0x0000f740:
return 0x4a42205d;
case 0x0000f744:
return 0x6019440d;
case 0x0000f748:
return 0xad704bfb;
case 0x0000f74c:
return 0x79866e9a;
case 0x0000f750:
return 0xba57f390;
case 0x0000f754:
return 0xb8f081b3;
case 0x0000f758:
return 0xdf9fe297;
case 0x0000f75c:
return 0xd60dba46;
case 0x0000f760:
return 0x6deea4b6;
case 0x0000f764:
return 0xed16e53c;
case 0x0000f768:
return 0xc9eebf4a;
case 0x0000f76c:
return 0x887b423d;
case 0x0000f770:
return 0xcca92cc1;
case 0x0000f774:
return 0x0cb7d3fb;
case 0x0000f778:
return 0x55149234;
case 0x0000f77c:
return 0xffc00e3a;
case 0x0000f780:
return 0x29428ede;
case 0x0000f784:
return 0xad305f28;
case 0x0000f788:
return 0xaa1f2828;
case 0x0000f78c:
return 0x46facdb5;
case 0x0000f790:
return 0x1a80cecb;
case 0x0000f794:
return 0x547d76ab;
case 0x0000f798:
return 0x47830565;
case 0x0000f79c:
return 0xa67e1338;
case 0x0000f7a0:
return 0x1cc55e2a;
case 0x0000f7a4:
return 0x02df9116;
case 0x0000f7a8:
return 0x1604cf66;
case 0x0000f7ac:
return 0x03ebfa9a;
case 0x0000f7b0:
return 0x26c91069;
case 0x0000f7b4:
return 0x9e4b3f50;
case 0x0000f7b8:
return 0x5b7353cb;
case 0x0000f7bc:
return 0x1d3183a4;
case 0x0000f7c0:
return 0xe9282bbc;
case 0x0000f7c4:
return 0x0bb6c8c2;
case 0x0000f7c8:
return 0xe8fddc11;
case 0x0000f7cc:
return 0x622e57e7;
case 0x0000f7d0:
return 0x6f762dc6;
case 0x0000f7d4:
return 0x6b9cc07f;
case 0x0000f7d8:
return 0x03cccde0;
case 0x0000f7dc:
return 0x10a64583;
case 0x0000f7e0:
return 0x11ee6d02;
case 0x0000f7e4:
return 0x9fcee31d;
case 0x0000f7e8:
return 0x87673b5d;
case 0x0000f7ec:
return 0x91085e1b;
case 0x0000f7f0:
return 0x32291024;
case 0x0000f7f4:
return 0xf9d8f247;
case 0x0000f7f8:
return 0xe78610ce;
case 0x0000f7fc:
return 0xdea6c7aa;
case 0x0000f800:
return 0x1bfc38c6;
case 0x0000f804:
return 0x5bf980f5;
case 0x0000f808:
return 0x0929f279;
case 0x0000f80c:
return 0x4cb8b8e9;
case 0x0000f810:
return 0x7d10f91e;
case 0x0000f814:
return 0xeb913936;
case 0x0000f818:
return 0x90693f29;
case 0x0000f81c:
return 0x6b008b68;
case 0x0000f820:
return 0xad1eb00e;
case 0x0000f824:
return 0x10fae31b;
case 0x0000f828:
return 0x7746db6d;
case 0x0000f82c:
return 0x70d63106;
case 0x0000f830:
return 0x5b4c1cf9;
case 0x0000f834:
return 0x8de588ff;
case 0x0000f838:
return 0x9a9c191a;
case 0x0000f83c:
return 0x472638f1;
case 0x0000f840:
return 0x26efdf10;
case 0x0000f844:
return 0x64cb8eae;
case 0x0000f848:
return 0xd2da6dd3;
case 0x0000f84c:
return 0x49ab3b6f;
case 0x0000f850:
return 0x5f81f9ca;
case 0x0000f854:
return 0x23da5984;
case 0x0000f858:
return 0x1b87da6c;
case 0x0000f85c:
return 0x60b21d86;
case 0x0000f860:
return 0xa5d79a29;
case 0x0000f864:
return 0xfec74927;
case 0x0000f868:
return 0x477c324a;
case 0x0000f86c:
return 0xd45d58b0;
case 0x0000f870:
return 0xec5d90f3;
case 0x0000f874:
return 0x83526724;
case 0x0000f878:
return 0xd9fe4387;
case 0x0000f87c:
return 0xffc50c93;
case 0x0000f880:
return 0xf1475413;
case 0x0000f884:
return 0x542fb123;
case 0x0000f888:
return 0x3a8ffcb0;
case 0x0000f88c:
return 0x257aa9a2;
case 0x0000f890:
return 0x4701b784;
case 0x0000f894:
return 0x96911b39;
case 0x0000f898:
return 0x4f302f8e;
case 0x0000f89c:
return 0x7a8bcbc8;
case 0x0000f8a0:
return 0x6c0b1ffa;
case 0x0000f8a4:
return 0x209663d2;
case 0x0000f8a8:
return 0x4b94028b;
case 0x0000f8ac:
return 0x238062fc;
case 0x0000f8b0:
return 0xbec11948;
case 0x0000f8b4:
return 0x514654a9;
case 0x0000f8b8:
return 0xd624c205;
case 0x0000f8bc:
return 0x7a696830;
case 0x0000f8c0:
return 0x63782c71;
case 0x0000f8c4:
return 0xf402b93e;
case 0x0000f8c8:
return 0x832eac9c;
case 0x0000f8cc:
return 0xdaa7e370;
case 0x0000f8d0:
return 0x3e528771;
case 0x0000f8d4:
return 0x38d0b7bb;
case 0x0000f8d8:
return 0x80bf5fb5;
case 0x0000f8dc:
return 0x64419df8;
case 0x0000f8e0:
return 0xd053cd9e;
case 0x0000f8e4:
return 0xc4693809;
case 0x0000f8e8:
return 0xd28219f3;
case 0x0000f8ec:
return 0xc200c42c;
case 0x0000f8f0:
return 0x39e18e70;
case 0x0000f8f4:
return 0xd00b435b;
case 0x0000f8f8:
return 0xd29f1682;
case 0x0000f8fc:
return 0x03785c63;
case 0x0000f900:
return 0x747861b9;
case 0x0000f904:
return 0x729eddb8;
case 0x0000f908:
return 0x0996c4dd;
case 0x0000f90c:
return 0xb3c2cddf;
case 0x0000f910:
return 0x86c3d56a;
case 0x0000f914:
return 0xd899b22f;
case 0x0000f918:
return 0x298c880a;
case 0x0000f91c:
return 0xb34aaf5e;
case 0x0000f920:
return 0x32c246c6;
case 0x0000f924:
return 0x1e0c17f2;
case 0x0000f928:
return 0x51fcc022;
case 0x0000f92c:
return 0x50000937;
case 0x0000f930:
return 0xb1b83e49;
case 0x0000f934:
return 0x2c91313e;
case 0x0000f938:
return 0x2ac739af;
case 0x0000f93c:
return 0xd037829f;
case 0x0000f940:
return 0x4a44220f;
case 0x0000f944:
return 0x8ffc260b;
case 0x0000f948:
return 0x312440c7;
case 0x0000f94c:
return 0x70408484;
case 0x0000f950:
return 0xd1858306;
case 0x0000f954:
return 0xe71f0b5e;
case 0x0000f958:
return 0x81f6bc4f;
case 0x0000f95c:
return 0xf584198c;
case 0x0000f960:
return 0x431a0551;
case 0x0000f964:
return 0x6faa6c60;
case 0x0000f968:
return 0xeed0b172;
case 0x0000f96c:
return 0x1c91c106;
case 0x0000f970:
return 0x9c11daec;
case 0x0000f974:
return 0xe7b17e34;
case 0x0000f978:
return 0xcb3d2b43;
case 0x0000f97c:
return 0x02eacc08;
case 0x0000f980:
return 0x11a725fb;
case 0x0000f984:
return 0xd1a31406;
case 0x0000f988:
return 0x75992abd;
case 0x0000f98c:
return 0xea666872;
case 0x0000f990:
return 0x06f11a6c;
case 0x0000f994:
return 0x074aac34;
case 0x0000f998:
return 0x5a9ff856;
case 0x0000f99c:
return 0x71dc3e57;
case 0x0000f9a0:
return 0x924eba73;
case 0x0000f9a4:
return 0x4a259c20;
case 0x0000f9a8:
return 0x772c5349;
case 0x0000f9ac:
return 0x7ac8a9b4;
case 0x0000f9b0:
return 0xb3e91a90;
case 0x0000f9b4:
return 0xdb5b6102;
case 0x0000f9b8:
return 0xa03b1936;
case 0x0000f9bc:
return 0xa9b6f91b;
case 0x0000f9c0:
return 0xd92f8b25;
case 0x0000f9c4:
return 0x87b1fcab;
case 0x0000f9c8:
return 0xed1acf5d;
case 0x0000f9cc:
return 0x1b8bf2cc;
case 0x0000f9d0:
return 0xd9fe94b7;
case 0x0000f9d4:
return 0x9ad98825;
case 0x0000f9d8:
return 0x1f84986b;
case 0x0000f9dc:
return 0x9939415e;
case 0x0000f9e0:
return 0x20a69b38;
case 0x0000f9e4:
return 0x79ef10f0;
case 0x0000f9e8:
return 0x74a62ec4;
case 0x0000f9ec:
return 0x75ef54de;
case 0x0000f9f0:
return 0x931532a0;
case 0x0000f9f4:
return 0x03b4e19c;
case 0x0000f9f8:
return 0x46aaea65;
case 0x0000f9fc:
return 0xa4fd56fd;
case 0x0000fa00:
return 0xce41a776;
case 0x0000fa04:
return 0x24c65053;
case 0x0000fa08:
return 0xd79777a7;
case 0x0000fa0c:
return 0x59bf6274;
case 0x0000fa10:
return 0x02834183;
case 0x0000fa14:
return 0xbe980906;
case 0x0000fa18:
return 0xd8d069db;
case 0x0000fa1c:
return 0x2a5a5de8;
case 0x0000fa20:
return 0x2f128afb;
case 0x0000fa24:
return 0x6f9a8625;
case 0x0000fa28:
return 0x440ae7a8;
case 0x0000fa2c:
return 0x0139cd7a;
case 0x0000fa30:
return 0x13e8b7ea;
case 0x0000fa34:
return 0x5a5862b8;
case 0x0000fa38:
return 0xa35a9b38;
case 0x0000fa3c:
return 0x9c67d543;
case 0x0000fa40:
return 0x813c4293;
case 0x0000fa44:
return 0x58df3b97;
case 0x0000fa48:
return 0x470e4a88;
case 0x0000fa4c:
return 0xe74ebf73;
case 0x0000fa50:
return 0x838654e0;
case 0x0000fa54:
return 0xecf4139c;
case 0x0000fa58:
return 0xa9550e74;
case 0x0000fa5c:
return 0x84d99dc4;
case 0x0000fa60:
return 0x3f7553f1;
case 0x0000fa64:
return 0xad7c8070;
case 0x0000fa68:
return 0x29a218fb;
case 0x0000fa6c:
return 0x2692bcf2;
case 0x0000fa70:
return 0x37e3892f;
case 0x0000fa74:
return 0x310da53e;
case 0x0000fa78:
return 0x9cd3a257;
case 0x0000fa7c:
return 0x8f520497;
case 0x0000fa80:
return 0x4ce16f42;
case 0x0000fa84:
return 0xcd27d8a0;
case 0x0000fa88:
return 0xe31795fe;
case 0x0000fa8c:
return 0x38a35ad1;
case 0x0000fa90:
return 0x6f2f6000;
case 0x0000fa94:
return 0x9cac0039;
case 0x0000fa98:
return 0xa60aff68;
case 0x0000fa9c:
return 0x5844a09a;
case 0x0000faa0:
return 0x37280a75;
case 0x0000faa4:
return 0x331a51c0;
case 0x0000faa8:
return 0x34b0deaa;
case 0x0000faac:
return 0xd01e8496;
case 0x0000fab0:
return 0x12b767f9;
case 0x0000fab4:
return 0xd4dbf949;
case 0x0000fab8:
return 0x79d9a387;
case 0x0000fabc:
return 0x3ed4f0fb;
case 0x0000fac0:
return 0x0bde8023;
case 0x0000fac4:
return 0x57895fbc;
case 0x0000fac8:
return 0xb8dbf23a;
case 0x0000facc:
return 0x793ffd10;
case 0x0000fad0:
return 0x1458a976;
case 0x0000fad4:
return 0x10da7799;
case 0x0000fad8:
return 0x7d63ecf8;
case 0x0000fadc:
return 0xb1b03b40;
case 0x0000fae0:
return 0xc11a8e71;
case 0x0000fae4:
return 0x3f9beb31;
case 0x0000fae8:
return 0xca700c2d;
case 0x0000faec:
return 0xfc615315;
case 0x0000faf0:
return 0x4f57ab40;
case 0x0000faf4:
return 0xb27342fe;
case 0x0000faf8:
return 0x4b385abb;
case 0x0000fafc:
return 0xfd9e6c83;
case 0x0000fb00:
return 0x92ae0a77;
case 0x0000fb04:
return 0x5cbcbb8e;
case 0x0000fb08:
return 0x5c5439f3;
case 0x0000fb0c:
return 0x3cb3b56d;
case 0x0000fb10:
return 0x00f6e1c4;
case 0x0000fb14:
return 0x25349836;
case 0x0000fb18:
return 0xbb33bed1;
case 0x0000fb1c:
return 0x81159744;
case 0x0000fb20:
return 0xb0ea0fec;
case 0x0000fb24:
return 0x41fe936d;
case 0x0000fb28:
return 0x069525ab;
case 0x0000fb2c:
return 0x0d421847;
case 0x0000fb30:
return 0x17708f3c;
case 0x0000fb34:
return 0x758b248d;
case 0x0000fb38:
return 0xa9ed9109;
case 0x0000fb3c:
return 0x7b792171;
case 0x0000fb40:
return 0xce83dd89;
case 0x0000fb44:
return 0xc3933c3f;
case 0x0000fb48:
return 0x17ce1f35;
case 0x0000fb4c:
return 0x77f1c457;
case 0x0000fb50:
return 0xeb2c41a5;
case 0x0000fb54:
return 0x605c55c7;
case 0x0000fb58:
return 0xd332ea8d;
case 0x0000fb5c:
return 0xe506cc7d;
case 0x0000fb60:
return 0xdec3bc47;
case 0x0000fb64:
return 0x7893acea;
case 0x0000fb68:
return 0x40730297;
case 0x0000fb6c:
return 0x881be10f;
case 0x0000fb70:
return 0x06fae748;
case 0x0000fb74:
return 0x1ca42aa4;
case 0x0000fb78:
return 0x94698506;
case 0x0000fb7c:
return 0xa5ff7f3a;
case 0x0000fb80:
return 0xde51cf1d;
case 0x0000fb84:
return 0xddf6fcf8;
case 0x0000fb88:
return 0x7c3a6f17;
case 0x0000fb8c:
return 0x3258d28d;
case 0x0000fb90:
return 0x8b130c63;
case 0x0000fb94:
return 0x26ae5929;
case 0x0000fb98:
return 0x2530b82c;
case 0x0000fb9c:
return 0x519c789b;
case 0x0000fba0:
return 0x65a28e40;
case 0x0000fba4:
return 0x29c72a01;
case 0x0000fba8:
return 0xba33fb23;
case 0x0000fbac:
return 0xcfa85039;
case 0x0000fbb0:
return 0xeb40dce6;
case 0x0000fbb4:
return 0x94b71955;
case 0x0000fbb8:
return 0x1c9a30c2;
case 0x0000fbbc:
return 0x239c64be;
case 0x0000fbc0:
return 0xb853bff6;
case 0x0000fbc4:
return 0xee844b32;
case 0x0000fbc8:
return 0x51f81bad;
case 0x0000fbcc:
return 0xa8d6e9d4;
case 0x0000fbd0:
return 0x46487b4f;
case 0x0000fbd4:
return 0x85fda962;
case 0x0000fbd8:
return 0x09e2c887;
case 0x0000fbdc:
return 0x70ff3cca;
case 0x0000fbe0:
return 0x6b6f5810;
case 0x0000fbe4:
return 0xaef2e495;
case 0x0000fbe8:
return 0x93b03821;
case 0x0000fbec:
return 0x08e21126;
case 0x0000fbf0:
return 0xd11e8d81;
case 0x0000fbf4:
return 0x7b7d820b;
case 0x0000fbf8:
return 0x49887cf8;
case 0x0000fbfc:
return 0xad3460ef;
case 0x0000fc00:
return 0xc0094e98;
case 0x0000fc04:
return 0x9afc9d48;
case 0x0000fc08:
return 0x3f3baafb;
case 0x0000fc0c:
return 0x4ad9abf6;
case 0x0000fc10:
return 0xe22cc090;
case 0x0000fc14:
return 0x983ee020;
case 0x0000fc18:
return 0x3bf73d44;
case 0x0000fc1c:
return 0x685e3c84;
case 0x0000fc20:
return 0x732d4db3;
case 0x0000fc24:
return 0xe45a0bbd;
case 0x0000fc28:
return 0xe92a6ae1;
case 0x0000fc2c:
return 0x991ede5a;
case 0x0000fc30:
return 0x890da72b;
case 0x0000fc34:
return 0x5c3f82fe;
case 0x0000fc38:
return 0x59624d82;
case 0x0000fc3c:
return 0x31d51fd0;
case 0x0000fc40:
return 0x9643ded4;
case 0x0000fc44:
return 0xac595658;
case 0x0000fc48:
return 0x90fa8944;
case 0x0000fc4c:
return 0x65df3db8;
case 0x0000fc50:
return 0xe5fa501f;
case 0x0000fc54:
return 0x5dba55c4;
case 0x0000fc58:
return 0x76678340;
case 0x0000fc5c:
return 0xe2705fd7;
case 0x0000fc60:
return 0x8454d74d;
case 0x0000fc64:
return 0xf6e4090e;
case 0x0000fc68:
return 0x975de038;
case 0x0000fc6c:
return 0x9996368a;
case 0x0000fc70:
return 0xd82d68ac;
case 0x0000fc74:
return 0x7795e662;
case 0x0000fc78:
return 0xae2951d5;
case 0x0000fc7c:
return 0x9c9e606f;
case 0x0000fc80:
return 0xcd661e9f;
case 0x0000fc84:
return 0xd16eb934;
case 0x0000fc88:
return 0x44449f5e;
case 0x0000fc8c:
return 0x8ee1b030;
case 0x0000fc90:
return 0xedd44403;
case 0x0000fc94:
return 0x9dd6746a;
case 0x0000fc98:
return 0x96c9ec74;
case 0x0000fc9c:
return 0x0883b3ce;
case 0x0000fca0:
return 0x835cdfe2;
case 0x0000fca4:
return 0xf5c99e68;
case 0x0000fca8:
return 0x68d80c9c;
case 0x0000fcac:
return 0x941dae67;
case 0x0000fcb0:
return 0x6e773086;
case 0x0000fcb4:
return 0x889223f2;
case 0x0000fcb8:
return 0xe664a198;
case 0x0000fcbc:
return 0x47912441;
case 0x0000fcc0:
return 0x458b2b1f;
case 0x0000fcc4:
return 0x4caffafd;
case 0x0000fcc8:
return 0x53dc5765;
case 0x0000fccc:
return 0xf5993596;
case 0x0000fcd0:
return 0xf5476c62;
case 0x0000fcd4:
return 0xc528f4df;
case 0x0000fcd8:
return 0x83626c0e;
case 0x0000fcdc:
return 0x50a168cb;
case 0x0000fce0:
return 0xaa9beb92;
case 0x0000fce4:
return 0x61fe9fc7;
case 0x0000fce8:
return 0x55bd50ca;
case 0x0000fcec:
return 0x6d29de7a;
case 0x0000fcf0:
return 0xc594af62;
case 0x0000fcf4:
return 0x70b9f760;
case 0x0000fcf8:
return 0x98de8ae3;
case 0x0000fcfc:
return 0x5f2c93e2;
case 0x0000fd00:
return 0xc066b332;
case 0x0000fd04:
return 0x684129bb;
case 0x0000fd08:
return 0x37807f7b;
case 0x0000fd0c:
return 0xa91927bb;
case 0x0000fd10:
return 0xa8bb1222;
case 0x0000fd14:
return 0xdb099bcd;
case 0x0000fd18:
return 0xb067a9f9;
case 0x0000fd1c:
return 0xa288dc40;
case 0x0000fd20:
return 0x65e4948c;
case 0x0000fd24:
return 0xad71dde1;
case 0x0000fd28:
return 0x52b1c3eb;
case 0x0000fd2c:
return 0xb193accd;
case 0x0000fd30:
return 0x4dab9a34;
case 0x0000fd34:
return 0x84dc44a7;
case 0x0000fd38:
return 0x0e8b786d;
case 0x0000fd3c:
return 0x4876be1f;
case 0x0000fd40:
return 0xe8ee66ad;
case 0x0000fd44:
return 0xced317ed;
case 0x0000fd48:
return 0x94782de0;
case 0x0000fd4c:
return 0x0654856d;
case 0x0000fd50:
return 0xea2e2bd8;
case 0x0000fd54:
return 0x6ffdc7ed;
case 0x0000fd58:
return 0x51076fe1;
case 0x0000fd5c:
return 0x9b7ca9c2;
case 0x0000fd60:
return 0xdd075f79;
case 0x0000fd64:
return 0xd38fbf3d;
case 0x0000fd68:
return 0x38b039c7;
case 0x0000fd6c:
return 0xc35e752c;
case 0x0000fd70:
return 0x72c2e945;
case 0x0000fd74:
return 0xc509c48c;
case 0x0000fd78:
return 0x7f84bade;
case 0x0000fd7c:
return 0xb78b88b0;
case 0x0000fd80:
return 0x657050ff;
case 0x0000fd84:
return 0x64357011;
case 0x0000fd88:
return 0xc84b6cd5;
case 0x0000fd8c:
return 0x558110ee;
case 0x0000fd90:
return 0xbce7507e;
case 0x0000fd94:
return 0xba37815e;
case 0x0000fd98:
return 0x0f3511ba;
case 0x0000fd9c:
return 0x8721cb7e;
case 0x0000fda0:
return 0x2fdab77b;
case 0x0000fda4:
return 0xf829ad3f;
case 0x0000fda8:
return 0xb78efa75;
case 0x0000fdac:
return 0xba537612;
case 0x0000fdb0:
return 0xd3611031;
case 0x0000fdb4:
return 0xbfb2c5b8;
case 0x0000fdb8:
return 0xac1c2b5b;
case 0x0000fdbc:
return 0x96ba9fe3;
case 0x0000fdc0:
return 0x4f933360;
case 0x0000fdc4:
return 0x72e4eaa3;
case 0x0000fdc8:
return 0xb42e2aee;
case 0x0000fdcc:
return 0xa8bbb885;
case 0x0000fdd0:
return 0xa9bd3f2e;
case 0x0000fdd4:
return 0x3c00b0c4;
case 0x0000fdd8:
return 0x57326fce;
case 0x0000fddc:
return 0x8b930af1;
case 0x0000fde0:
return 0x0db37c87;
case 0x0000fde4:
return 0x66674c9e;
case 0x0000fde8:
return 0x49e686d4;
case 0x0000fdec:
return 0xb9a731d9;
case 0x0000fdf0:
return 0xf6bfc5f1;
case 0x0000fdf4:
return 0x1fb42c01;
case 0x0000fdf8:
return 0x915a97d9;
case 0x0000fdfc:
return 0xc3fcfdeb;
case 0x0000fe00:
return 0xbc8f9350;
case 0x0000fe04:
return 0x66beded0;
case 0x0000fe08:
return 0xbeca7a48;
case 0x0000fe0c:
return 0x5ab20ef7;
case 0x0000fe10:
return 0xe512f9dc;
case 0x0000fe14:
return 0x0c9586e2;
case 0x0000fe18:
return 0xe158866a;
case 0x0000fe1c:
return 0xa821a195;
case 0x0000fe20:
return 0xcd2c9ddd;
case 0x0000fe24:
return 0xcd08c2a3;
case 0x0000fe28:
return 0xa863dc85;
case 0x0000fe2c:
return 0xd72b7996;
case 0x0000fe30:
return 0xef2462d8;
case 0x0000fe34:
return 0x866dd6fc;
case 0x0000fe38:
return 0xa334dad0;
case 0x0000fe3c:
return 0x63e2e4b6;
case 0x0000fe40:
return 0xfb785135;
case 0x0000fe44:
return 0x581c0877;
case 0x0000fe48:
return 0x422d41cd;
case 0x0000fe4c:
return 0x189dd073;
case 0x0000fe50:
return 0xf7262d20;
case 0x0000fe54:
return 0x67af8162;
case 0x0000fe58:
return 0x32ac05a1;
case 0x0000fe5c:
return 0x31fc4fde;
case 0x0000fe60:
return 0x016cc388;
case 0x0000fe64:
return 0xf9661997;
case 0x0000fe68:
return 0x58906526;
case 0x0000fe6c:
return 0x33ada52e;
case 0x0000fe70:
return 0x46a56edc;
case 0x0000fe74:
return 0x6ca71adf;
case 0x0000fe78:
return 0x66442be8;
case 0x0000fe7c:
return 0x2aeda8e9;
case 0x0000fe80:
return 0x25883acf;
case 0x0000fe84:
return 0xcddbefbb;
case 0x0000fe88:
return 0x282ec7aa;
case 0x0000fe8c:
return 0xe99a5e1b;
case 0x0000fe90:
return 0x483fe0bf;
case 0x0000fe94:
return 0x8497e59e;
case 0x0000fe98:
return 0xaa1f1211;
case 0x0000fe9c:
return 0x786c05a6;
case 0x0000fea0:
return 0x291953a8;
case 0x0000fea4:
return 0x53c7251e;
case 0x0000fea8:
return 0xb9ec2fa2;
case 0x0000feac:
return 0x0d4c2eb9;
case 0x0000feb0:
return 0xd99be26d;
case 0x0000feb4:
return 0x05a1944d;
case 0x0000feb8:
return 0x919cd95b;
case 0x0000febc:
return 0x1e42f01b;
case 0x0000fec0:
return 0x5de3671c;
case 0x0000fec4:
return 0x064e397a;
case 0x0000fec8:
return 0xb97503f9;
case 0x0000fecc:
return 0xa52b2635;
case 0x0000fed0:
return 0x67d6f649;
case 0x0000fed4:
return 0x2f13fe76;
case 0x0000fed8:
return 0x0e68279b;
case 0x0000fedc:
return 0xe5701c17;
case 0x0000fee0:
return 0x9198c0de;
case 0x0000fee4:
return 0xcb7782c9;
case 0x0000fee8:
return 0x689c8bab;
case 0x0000feec:
return 0x7f367ef5;
case 0x0000fef0:
return 0x3ad047af;
case 0x0000fef4:
return 0x28adc99d;
case 0x0000fef8:
return 0x048297ab;
case 0x0000fefc:
return 0x3f073786;
case 0x0000ff00:
return 0xb661d26c;
case 0x0000ff04:
return 0xb4ee3a5d;
case 0x0000ff08:
return 0xbe780411;
case 0x0000ff0c:
return 0x0efa472c;
case 0x0000ff10:
return 0xe72e21cc;
case 0x0000ff14:
return 0xe2e38c52;
case 0x0000ff18:
return 0x85f9175a;
case 0x0000ff1c:
return 0xe7e0875c;
case 0x0000ff20:
return 0xb929a2fd;
case 0x0000ff24:
return 0x5e5de602;
case 0x0000ff28:
return 0x320081c1;
case 0x0000ff2c:
return 0xa745ea27;
case 0x0000ff30:
return 0xd511018f;
case 0x0000ff34:
return 0x769ead7b;
case 0x0000ff38:
return 0x698ea2fe;
case 0x0000ff3c:
return 0x31875fda;
case 0x0000ff40:
return 0x017b906d;
case 0x0000ff44:
return 0x3afa0ab4;
case 0x0000ff48:
return 0x176fd226;
case 0x0000ff4c:
return 0xb7ae11b6;
case 0x0000ff50:
return 0x7b59382a;
case 0x0000ff54:
return 0x1b34d765;
case 0x0000ff58:
return 0x6a31e4a8;
case 0x0000ff5c:
return 0x962ae05f;
case 0x0000ff60:
return 0xd01698b2;
case 0x0000ff64:
return 0xcb570a79;
case 0x0000ff68:
return 0x1e8e36c3;
case 0x0000ff6c:
return 0x1698f517;
case 0x0000ff70:
return 0x76c984d6;
case 0x0000ff74:
return 0xb17d00ca;
case 0x0000ff78:
return 0x055a0d47;
case 0x0000ff7c:
return 0x060a7e51;
case 0x0000ff80:
return 0xa96997e6;
case 0x0000ff84:
return 0xac75df10;
case 0x0000ff88:
return 0x0b603ca1;
case 0x0000ff8c:
return 0x05b426b7;
case 0x0000ff90:
return 0x99049907;
case 0x0000ff94:
return 0x63671d51;
case 0x0000ff98:
return 0xb43fbf35;
case 0x0000ff9c:
return 0x9ea177d4;
case 0x0000ffa0:
return 0xcd5b1a24;
case 0x0000ffa4:
return 0x0fd34ace;
case 0x0000ffa8:
return 0xaefa46e6;
case 0x0000ffac:
return 0x1beb31ff;
case 0x0000ffb0:
return 0xe303a570;
case 0x0000ffb4:
return 0xb311c8b2;
case 0x0000ffb8:
return 0x8c120d0f;
case 0x0000ffbc:
return 0xe1895877;
case 0x0000ffc0:
return 0xf6ac18d8;
case 0x0000ffc4:
return 0xddd01b06;
case 0x0000ffc8:
return 0x004191d3;
case 0x0000ffcc:
return 0x32325817;
case 0x0000ffd0:
return 0x7a243d97;
case 0x0000ffd4:
return 0xadd43292;
case 0x0000ffd8:
return 0x7b4df67d;
case 0x0000ffdc:
return 0x7423d731;
case 0x0000ffe0:
return 0x4a91fc77;
case 0x0000ffe4:
return 0x3b9cce56;
case 0x0000ffe8:
return 0xdf6ba5af;
case 0x0000ffec:
return 0x2935e93c;
case 0x0000fff0:
return 0x28f1b15a;
case 0x0000fff4:
return 0x9d60508b;
case 0x0000fff8:
return 0x1923c317;
case 0x0000fffc:
return 0x134bd6b0;
default:
return 0xdeadbeef;
}
}
|
6a9452a89faac0b145276037c9ae9614a4986b6d
|
3a2071c34e3c35847b2bcc2a5d3b3a74114daa0f
|
/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb__pre_ruby.h
|
bc8eb6e0a1df55963f23983aac367c1a2cebdeb1
|
[
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"LicenseRef-scancode-other-permissive",
"X11",
"BSD-2-Clause",
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"HPND-Markus-Kuhn",
"LicenseRef-scancode-unicode",
"Apache-2.0",
"FSFAP"
] |
permissive
|
apache/subversion
|
18a9142afe63f060ffc0814fe0c758c91ad8bd31
|
dd957c4991e61bde23cc60d13449ea8b65f80c43
|
refs/heads/trunk
| 2023-09-04T15:22:36.755177
| 2023-08-29T19:55:03
| 2023-08-29T19:55:03
| 454,263
| 520
| 207
|
Apache-2.0
| 2023-08-26T14:17:30
| 2009-12-31T09:00:10
|
C
|
UTF-8
|
C
| false
| false
| 2,833
|
h
|
swigutil_rb__pre_ruby.h
|
/*
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
#ifndef SVN_SWIG_SWIGUTIL_RB__PRE_RUBY_H
#define SVN_SWIG_SWIGUTIL_RB__PRE_RUBY_H
#if defined(SVN_SWIG_RUBY__CUSTOM_RUBY_CONFIG) && defined(_MSC_VER)
/* The standard install of Ruby on Windows 1.9 expects to be build with MINGW,
a gcc compatible toolchain. Since 1.8 they removed much of the compatibility
with Visual C++, but we can't build with MingW as that would break APR
binary compatibility.
*/
#include <ruby/config.h>
#undef NORETURN
#undef DEPRECATED
#undef FUNC_STDCALL
#undef FUNC_CDECL
#undef FUNC_FASTCALL
#undef RUBY_ALIAS_FUNCTION_TYPE
#undef RUBY_ALIAS_FUNCTION_VOID
#undef HAVE_GCC_ATOMIC_BUILTINS
#undef RUBY_FUNC_EXPORTED
#undef RUBY_FUNC_EXPORTED
#undef RUBY_EXTERN
#define NORETURN(x) __declspec(noreturn) x
#define RUBY_EXTERN extern __declspec(dllimport)
/* Yuck. But this makes ruby happy */
#undef pid_t
#undef uid_t
#undef gid_t
typedef int pid_t;
typedef int uid_t;
typedef int gid_t;
#if !defined(__cplusplus) && !defined(inline)
#define inline __inline
#endif
typedef long ssize_t;
/* Don't define iovec when including APR */
#define APR_IOVEC_DEFINED
/* Undefine headers that aren't available in Visual C++, but config.h says
are available. */
#undef HAVE_UNISTD_H
/* Visual C++ >= 2010 has <stdint.h> */
#if _MSC_VER < 1600
#undef HAVE_STDINT_H
typedef signed __int8 int8_t;
typedef signed __int16 int16_t;
typedef signed __int32 int32_t;
typedef signed __int64 int64_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
#endif
/* Visual C++ >= 2013 has <inttypes.h> */
#if _MSC_VER < 1800
#undef HAVE_INTTYPES_H
#endif
/* Visual Studio >= 2015 has timespec defined */
#if _MSC_VER >= 1900
#define HAVE_STRUCT_TIMESPEC
#endif
#ifdef _MSC_VER
#pragma warning(disable: 4702) /* warning C4702: unreachable code */
#endif
#endif /* defined(SVN_SWIG_RUBY__CUSTOM_RUBY_CONFIG) && defined(_MSC_VER) */
#endif /* SVN_SWIG_SWIGUTIL_RB__PRE_RUBY_H */
|
96237f5e6d4fb1eb8d6393073a2cfd691d61d993
|
79d343002bb63a44f8ab0dbac0c9f4ec54078c3a
|
/lib/libc/include/any-windows-any/npapi.h
|
7439e8cd1acafa519f11a52baf8fa44a875ea380
|
[
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain"
] |
permissive
|
ziglang/zig
|
4aa75d8d3bcc9e39bf61d265fd84b7f005623fc5
|
f4c9e19bc3213c2bc7e03d7b06d7129882f39f6c
|
refs/heads/master
| 2023-08-31T13:16:45.980913
| 2023-08-31T05:50:29
| 2023-08-31T05:50:29
| 40,276,274
| 25,560
| 2,399
|
MIT
| 2023-09-14T21:09:50
| 2015-08-06T00:51:28
|
Zig
|
UTF-8
|
C
| false
| false
| 9,116
|
h
|
npapi.h
|
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#ifndef _NPAPI_INCLUDED
#define _NPAPI_INCLUDED
#include <_mingw_unicode.h>
typedef DWORD (WINAPI *PF_NPAddConnection)(LPNETRESOURCEW lpNetResource,LPWSTR lpPassword,LPWSTR lpUserName);
typedef DWORD (WINAPI *PF_NPAddConnection3)(HWND hwndOwner,LPNETRESOURCEW lpNetResource,LPWSTR lpPassword,LPWSTR lpUserName,DWORD dwFlags);
typedef DWORD (WINAPI *PF_NPCancelConnection)(LPWSTR lpName,WINBOOL fForce);
typedef DWORD (WINAPI *PF_NPGetConnection)(LPWSTR lpLocalName,LPWSTR lpRemoteName,LPDWORD lpnBufferLen);
#define WNGETCON_CONNECTED 0x00000000
#define WNGETCON_DISCONNECTED 0x00000001
typedef DWORD (WINAPI *PF_NPGetConnection3)(LPCWSTR lpLocalName,DWORD dwLevel,LPVOID lpBuffer,LPDWORD lpBufferSize);
typedef DWORD (WINAPI *PF_NPGetConnectionPerformance)(LPCWSTR lpRemoteName,LPNETCONNECTINFOSTRUCT lpNetConnectInfo);
typedef DWORD (WINAPI *PF_NPGetUniversalName)(LPWSTR lpLocalPath,DWORD dwInfoLevel,LPVOID lpBuffer,LPDWORD lpnBufferSize);
typedef DWORD (WINAPI *PF_NPOpenEnum)(DWORD dwScope,DWORD dwType,DWORD dwUsage,LPNETRESOURCEW lpNetResource,LPHANDLE lphEnum);
typedef DWORD (WINAPI *PF_NPEnumResource)(HANDLE hEnum,LPDWORD lpcCount,LPVOID lpBuffer,LPDWORD lpBufferSize);
DWORD WINAPI NPAddConnection(LPNETRESOURCEW lpNetResource,LPWSTR lpPassword,LPWSTR lpUserName);
DWORD WINAPI NPAddConnection3(HWND hwndOwner,LPNETRESOURCEW lpNetResource,LPTSTR lpPassword,LPTSTR lpUserName,DWORD dwFlags);
DWORD WINAPI NPCancelConnection(LPWSTR lpName,WINBOOL fForce);
DWORD WINAPI NPGetConnection(LPWSTR lpLocalName,LPWSTR lpRemoteName,LPDWORD lpnBufferLen);
DWORD WINAPI NPGetConnection3(LPCWSTR lpLocalName,DWORD dwLevel,LPVOID lpBuffer,LPDWORD lpBufferSize);
DWORD WINAPI NPGetConnectionPerformance(LPCWSTR lpRemoteName,LPNETCONNECTINFOSTRUCT lpNetConnectInfo);
DWORD WINAPI NPGetUniversalName(LPWSTR lpLocalPath,DWORD dwInfoLevel,LPVOID lpBuffer,LPDWORD lpBufferSize);
DWORD WINAPI NPOpenEnum(DWORD dwScope,DWORD dwType,DWORD dwUsage,LPNETRESOURCEW lpNetResource,LPHANDLE lphEnum);
DWORD WINAPI NPEnumResource(HANDLE hEnum,LPDWORD lpcCount,LPVOID lpBuffer,LPDWORD lpBufferSize);
DWORD WINAPI NPCloseEnum(HANDLE hEnum);
typedef DWORD (*PF_NPCloseEnum)(HANDLE hEnum);
#define WNNC_SPEC_VERSION 0x00000001
#define WNNC_SPEC_VERSION51 0x00050001
#define WNNC_NET_TYPE 0x00000002
#define WNNC_NET_NONE 0x00000000
#define WNNC_DRIVER_VERSION 0x00000003
#define WNNC_USER 0x00000004
#define WNNC_USR_GETUSER 0x00000001
#define WNNC_CONNECTION 0x00000006
#define WNNC_CON_ADDCONNECTION 0x00000001
#define WNNC_CON_CANCELCONNECTION 0x00000002
#define WNNC_CON_GETCONNECTIONS 0x00000004
#define WNNC_CON_ADDCONNECTION3 0x00000008
#define WNNC_CON_GETPERFORMANCE 0x00000040
#define WNNC_CON_DEFER 0x00000080
#define WNNC_DIALOG 0x00000008
#define WNNC_DLG_DEVICEMODE 0x00000001
#define WNNC_DLG_PROPERTYDIALOG 0x00000020
#define WNNC_DLG_SEARCHDIALOG 0x00000040
#define WNNC_DLG_FORMATNETWORKNAME 0x00000080
#define WNNC_DLG_PERMISSIONEDITOR 0x00000100
#define WNNC_DLG_GETRESOURCEPARENT 0x00000200
#define WNNC_DLG_GETRESOURCEINFORMATION 0x00000800
#define WNNC_ADMIN 0x00000009
#define WNNC_ADM_GETDIRECTORYTYPE 0x00000001
#define WNNC_ADM_DIRECTORYNOTIFY 0x00000002
#define WNNC_ENUMERATION 0x0000000B
#define WNNC_ENUM_GLOBAL 0x00000001
#define WNNC_ENUM_LOCAL 0x00000002
#define WNNC_ENUM_CONTEXT 0x00000004
#define WNNC_ENUM_SHAREABLE 0x00000008
#define WNNC_START 0x0000000C
#define WNNC_WAIT_FOR_START 0x00000001
typedef DWORD (WINAPI *PF_NPGetCaps)(DWORD ndex);
typedef DWORD (WINAPI *PF_NPGetUser)(LPWSTR lpName,LPWSTR lpUserName,LPDWORD lpnBufferLen);
DWORD WINAPI NPGetCaps (DWORD ndex);
DWORD WINAPI NPGetUser(LPWSTR lpName,LPWSTR lpUserName,LPDWORD lpnBufferLen);
#define WNTYPE_DRIVE 1
#define WNTYPE_FILE 2
#define WNTYPE_PRINTER 3
#define WNTYPE_COMM 4
#define WNPS_FILE 0
#define WNPS_DIR 1
#define WNPS_MULT 2
#define WNSRCH_REFRESH_FIRST_LEVEL 0x00000001
typedef DWORD (WINAPI *PF_NPDeviceMode)(HWND hParent);
typedef DWORD (WINAPI *PF_NPSearchDialog)(HWND hwndParent,LPNETRESOURCEW lpNetResource,LPVOID lpBuffer,DWORD cbBuffer,LPDWORD lpnFlags);
typedef DWORD (WINAPI *PF_NPGetResourceParent)(LPNETRESOURCEW lpNetResource,LPVOID lpBuffer,LPDWORD lpBufferSize);
typedef DWORD (WINAPI *PF_NPGetResourceInformation)(LPNETRESOURCEW lpNetResource,LPVOID lpBuffer,LPDWORD lpBufferSize,LPWSTR *lplpSystem);
typedef DWORD (WINAPI *PF_NPFormatNetworkName)(LPWSTR lpRemoteName,LPWSTR lpFormattedName,LPDWORD lpnLength,DWORD dwFlags,DWORD dwAveCharPerLine);
typedef DWORD (WINAPI *PF_NPGetPropertyText)(DWORD iButton,DWORD nPropSel,LPWSTR lpName,LPWSTR lpButtonName,DWORD nButtonNameLen,DWORD nType);
typedef DWORD (WINAPI *PF_NPPropertyDialog)(HWND hwndParent,DWORD iButtonDlg,DWORD nPropSel,LPWSTR lpFileName,DWORD nType);
DWORD WINAPI NPDeviceMode(HWND hParent);
DWORD WINAPI NPSearchDialog(HWND hwndParent,LPNETRESOURCEW lpNetResource,LPVOID lpBuffer,DWORD cbBuffer,LPDWORD lpnFlags);
DWORD WINAPI NPGetResourceParent(LPNETRESOURCEW lpNetResource,LPVOID lpBuffer,LPDWORD lpBufferSize);
DWORD WINAPI NPGetResourceInformation(LPNETRESOURCEW lpNetResource,LPVOID lpBuffer,LPDWORD lpBufferSize,LPWSTR *lplpSystem);
DWORD WINAPI NPFormatNetworkName(LPWSTR lpRemoteName,LPWSTR lpFormattedName,LPDWORD lpnLength,DWORD dwFlags,DWORD dwAveCharPerLine);
DWORD WINAPI NPGetPropertyText(DWORD iButton,DWORD nPropSel,LPWSTR lpName,LPWSTR lpButtonName,DWORD nButtonNameLen,DWORD nType);
DWORD WINAPI NPPropertyDialog(HWND hwndParent,DWORD iButtonDlg,DWORD nPropSel,LPWSTR lpFileName,DWORD nType);
#define WNDT_NORMAL 0
#define WNDT_NETWORK 1
#define WNDN_MKDIR 1
#define WNDN_RMDIR 2
#define WNDN_MVDIR 3
typedef DWORD (WINAPI *PF_NPGetDirectoryType)(LPWSTR lpName,LPINT lpType,WINBOOL bFlushCache);
typedef DWORD (WINAPI *PF_NPDirectoryNotify)(HWND hwnd,LPWSTR lpDir,DWORD dwOper);
DWORD WINAPI NPGetDirectoryType(LPWSTR lpName,LPINT lpType,WINBOOL bFlushCache);
DWORD WINAPI NPDirectoryNotify(HWND hwnd,LPWSTR lpDir,DWORD dwOper);
VOID WNetSetLastErrorA(DWORD err,LPSTR lpError,LPSTR lpProviders);
VOID WNetSetLastErrorW(DWORD err,LPWSTR lpError,LPWSTR lpProviders);
#define WNetSetLastError __MINGW_NAME_AW(WNetSetLastError)
#define WN_NETWORK_CLASS 0x00000001
#define WN_CREDENTIAL_CLASS 0x00000002
#define WN_PRIMARY_AUTHENT_CLASS 0x00000004
#define WN_SERVICE_CLASS 0x00000008
#define WN_VALID_LOGON_ACCOUNT 0x00000001
#define WN_NT_PASSWORD_CHANGED 0x00000002
typedef DWORD (WINAPI *PF_NPLogonNotify) (PLUID lpLogonId,LPCWSTR lpAuthentInfoType,LPVOID lpAuthentInfo,LPCWSTR lpPreviousAuthentInfoType,LPVOID lpPreviousAuthentInfo,LPWSTR lpStationName,LPVOID StationHandle,LPWSTR *lpLogonScript);
typedef DWORD (WINAPI *PF_NPPasswordChangeNotify) (LPCWSTR lpAuthentInfoType,LPVOID lpAuthentInfo,LPCWSTR lpPreviousAuthentInfoType,LPVOID lpPreviousAuthentInfo,LPWSTR lpStationName,LPVOID StationHandle,DWORD dwChangeInfo);
DWORD WINAPI NPLogonNotify (PLUID lpLogonId,LPCWSTR lpAuthentInfoType,LPVOID lpAuthentInfo,LPCWSTR lpPreviousAuthentInfoType,LPVOID lpPreviousAuthentInfo,LPWSTR lpStationName,LPVOID StationHandle,LPWSTR *lpLogonScript);
DWORD WINAPI NPPasswordChangeNotify (LPCWSTR lpAuthentInfoType,LPVOID lpAuthentInfo,LPCWSTR lpPreviousAuthentInfoType,LPVOID lpPreviousAuthentInfo,LPWSTR lpStationName,LPVOID StationHandle,DWORD dwChangeInfo);
#define NOTIFY_PRE 0x00000001
#define NOTIFY_POST 0x00000002
#define WNPERMC_PERM 0x00000001
#define WNPERMC_AUDIT 0x00000002
#define WNPERMC_OWNER 0x00000004
#define WNPERM_DLG_PERM 0
#define WNPERM_DLG_AUDIT 1
#define WNPERM_DLG_OWNER 2
typedef struct _NOTIFYINFO {
DWORD dwNotifyStatus;
DWORD dwOperationStatus;
LPVOID lpContext;
} NOTIFYINFO,*LPNOTIFYINFO;
typedef struct _NOTIFYADD {
HWND hwndOwner;
NETRESOURCE NetResource;
DWORD dwAddFlags;
} NOTIFYADD,*LPNOTIFYADD;
typedef struct _NOTIFYCANCEL {
LPTSTR lpName;
LPTSTR lpProvider;
DWORD dwFlags;
WINBOOL fForce;
} NOTIFYCANCEL,*LPNOTIFYCANCEL;
typedef DWORD (WINAPI *PF_AddConnectNotify) (LPNOTIFYINFO lpNotifyInfo,LPNOTIFYADD lpAddInfo);
typedef DWORD (WINAPI *PF_CancelConnectNotify) (LPNOTIFYINFO lpNotifyInfo,LPNOTIFYCANCEL lpCancelInfo);
typedef DWORD (WINAPI *PF_NPFMXGetPermCaps)(LPWSTR lpDriveName);
typedef DWORD (WINAPI *PF_NPFMXEditPerm)(LPWSTR lpDriveName,HWND hwndFMX,DWORD nDialogType);
typedef DWORD (WINAPI *PF_NPFMXGetPermHelp)(LPWSTR lpDriveName,DWORD nDialogType,WINBOOL fDirectory,LPVOID lpFileNameBuffer,LPDWORD lpBufferSize,LPDWORD lpnHelpContext);
DWORD WINAPI AddConnectNotify (LPNOTIFYINFO lpNotifyInfo,LPNOTIFYADD lpAddInfo);
DWORD WINAPI CancelConnectNotify (LPNOTIFYINFO lpNotifyInfo,LPNOTIFYCANCEL lpCancelInfo);
DWORD WINAPI NPFMXGetPermCaps(LPWSTR lpDriveName);
DWORD WINAPI NPFMXEditPerm(LPWSTR lpDriveName,HWND hwndFMX,DWORD nDialogType);
DWORD WINAPI NPFMXGetPermHelp(LPWSTR lpDriveName,DWORD nDialogType,WINBOOL fDirectory,LPVOID lpFileNameBuffer,LPDWORD lpBufferSize,LPDWORD lpnHelpContext);
#endif
|
c47065858a6a2dd65ec37e8986cee9cec4b19b37
|
cf56b5fcf51fddb219c47f5f006d8595a4483c57
|
/src/components/cl/basic/cl_basic_team.c
|
04ca156c73e6dfe08c5d4c0a8c44cf06aac24a2b
|
[
"BSD-3-Clause"
] |
permissive
|
openucx/ucc
|
3b39fbd849a7850c559b60eaec7882292f8a5eca
|
f89cd7557e6ebb19b4c6ebd529647d8b42c30657
|
refs/heads/master
| 2023-08-18T03:18:54.072899
| 2023-08-17T18:05:44
| 2023-08-17T18:05:44
| 282,490,868
| 150
| 57
|
BSD-3-Clause
| 2023-09-12T09:49:18
| 2020-07-25T17:18:51
|
C
|
UTF-8
|
C
| false
| false
| 7,979
|
c
|
cl_basic_team.c
|
/**
* Copyright (c) 2020-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
*
* See file LICENSE for terms.
*/
#include "cl_basic.h"
#include "utils/ucc_malloc.h"
#include "core/ucc_team.h"
UCC_CLASS_INIT_FUNC(ucc_cl_basic_team_t, ucc_base_context_t *cl_context,
const ucc_base_team_params_t *params)
{
ucc_cl_basic_context_t *ctx =
ucc_derived_of(cl_context, ucc_cl_basic_context_t);
unsigned n_tl_ctxs = ctx->super.n_tl_ctxs;
int i;
ucc_status_t status;
UCC_CLASS_CALL_SUPER_INIT(ucc_cl_team_t, &ctx->super, params);
self->tl_teams = ucc_malloc(sizeof(ucc_tl_team_t *) * n_tl_ctxs,
"cl_basic_tl_teams");
if (!self->tl_teams) {
cl_error(cl_context->lib, "failed to allocate %zd bytes for tl_teams",
sizeof(ucc_tl_team_t *) * n_tl_ctxs);
status = UCC_ERR_NO_MEMORY;
goto err;
}
self->n_tl_teams = 0;
self->score_map = NULL;
status = ucc_team_multiple_req_alloc(&self->team_create_req,
n_tl_ctxs);
if (UCC_OK != status) {
cl_error(cl_context->lib, "failed to allocate team req multiple");
goto err;
}
for (i = 0; i < n_tl_ctxs; i++) {
memcpy(&self->team_create_req->descs[i].param, params,
sizeof(ucc_base_team_params_t));
self->team_create_req->descs[i].ctx = ctx->super.tl_ctxs[i];
self->team_create_req->descs[i].param.scope = UCC_CL_BASIC;
self->team_create_req->descs[i].param.scope_id = 0;
}
self->team_create_req->n_teams = n_tl_ctxs;
status = ucc_tl_team_create_multiple(self->team_create_req);
if (status < 0) {
cl_error(cl_context->lib, "failed to post tl team create (%d)",
status);
goto err;
}
cl_debug(cl_context->lib, "posted cl team: %p", self);
return UCC_OK;
err:
ucc_free(self->tl_teams);
return status;
}
UCC_CLASS_CLEANUP_FUNC(ucc_cl_basic_team_t)
{
cl_debug(self->super.super.context->lib, "finalizing cl team: %p", self);
}
UCC_CLASS_DEFINE_DELETE_FUNC(ucc_cl_basic_team_t, ucc_base_team_t);
UCC_CLASS_DEFINE(ucc_cl_basic_team_t, ucc_cl_team_t);
ucc_status_t ucc_cl_basic_team_destroy(ucc_base_team_t *cl_team)
{
ucc_cl_basic_team_t *team = ucc_derived_of(cl_team, ucc_cl_basic_team_t);
ucc_cl_basic_context_t *ctx = UCC_CL_BASIC_TEAM_CTX(team);
ucc_status_t status = UCC_OK;
int i;
if (NULL == team->team_create_req) {
status = ucc_team_multiple_req_alloc(&team->team_create_req,
team->n_tl_teams);
if (UCC_OK != status) {
cl_error(ctx->super.super.lib, "failed to allocate team req multiple");
return status;
}
team->team_create_req->n_teams = team->n_tl_teams;
for (i = 0; i < team->n_tl_teams; i++) {
team->team_create_req->descs[i].team = team->tl_teams[i];
}
}
status = ucc_tl_team_destroy_multiple(team->team_create_req);
if (UCC_INPROGRESS == status) {
return status;
}
for (i = 0; i < team->n_tl_teams; i++) {
if (team->team_create_req->descs[i].status != UCC_OK) {
cl_error(ctx->super.super.lib, "tl team destroy failed (%d)",
status);
status = team->team_create_req->descs[i].status;
}
}
ucc_team_multiple_req_free(team->team_create_req);
if (team->score_map) {
ucc_coll_score_free_map(team->score_map);
}
ucc_free(team->tl_teams);
UCC_CLASS_DELETE_FUNC_NAME(ucc_cl_basic_team_t)(cl_team);
return status;
}
ucc_status_t ucc_cl_basic_team_create_test(ucc_base_team_t *cl_team)
{
ucc_cl_basic_team_t *team = ucc_derived_of(cl_team, ucc_cl_basic_team_t);
ucc_cl_basic_context_t *ctx = UCC_CL_BASIC_TEAM_CTX(team);
ucc_status_t status;
int i;
ucc_coll_score_t *score, *score_next, *score_merge;
status = ucc_tl_team_create_multiple(team->team_create_req);
if (status == UCC_OK) {
for (i = 0; i < ctx->super.n_tl_ctxs; i++) {
if (team->team_create_req->descs[i].status == UCC_OK) {
team->tl_teams[team->n_tl_teams++] =
team->team_create_req->descs[i].team;
cl_debug(ctx->super.super.lib, "initialized tl %s team",
UCC_TL_CTX_IFACE(team->team_create_req->descs[i].ctx)->
super.name);
} else {
cl_debug(ctx->super.super.lib, "failed to create tl %s team: (%d)",
UCC_TL_CTX_IFACE(team->team_create_req->descs[i].ctx)->
super.name, team->team_create_req->descs[i].status);
}
}
ucc_team_multiple_req_free(team->team_create_req);
team->team_create_req = NULL;
if (0 == team->n_tl_teams) {
cl_error(ctx->super.super.lib, "no tl teams were created");
return UCC_ERR_NOT_FOUND;
}
status =
UCC_TL_TEAM_IFACE(team->tl_teams[0])
->team.get_scores(&team->tl_teams[0]->super, &score);
if (UCC_OK != status) {
cl_error(ctx->super.super.lib, "failed to get tl %s scores",
UCC_TL_TEAM_IFACE(team->tl_teams[0])->super.name);
return status;
}
for (i = 1; i < team->n_tl_teams; i++) {
status =
UCC_TL_TEAM_IFACE(team->tl_teams[i])
->team.get_scores(&team->tl_teams[i]->super, &score_next);
if (UCC_OK != status) {
cl_error(ctx->super.super.lib, "failed to get tl %s scores",
UCC_TL_TEAM_IFACE(team->tl_teams[i])->super.name);
return status;
}
status =
ucc_coll_score_merge(score, score_next, &score_merge, 1);
if (UCC_OK != status) {
cl_error(ctx->super.super.lib, "failed to merge scores");
return status;
}
score = score_merge;
}
status = ucc_coll_score_build_map(score, &team->score_map);
if (UCC_OK != status) {
cl_error(ctx->super.super.lib, "failed to build score map");
}
team->score = score;
ucc_coll_score_set(team->score, UCC_CL_BASIC_DEFAULT_SCORE);
}
return status;
}
ucc_status_t ucc_cl_basic_team_get_scores(ucc_base_team_t *cl_team,
ucc_coll_score_t **score)
{
ucc_cl_basic_team_t *team = ucc_derived_of(cl_team, ucc_cl_basic_team_t);
ucc_base_context_t *ctx = UCC_CL_TEAM_CTX(team);
ucc_status_t status;
ucc_coll_score_team_info_t team_info;
status = ucc_coll_score_dup(team->score, score);
if (UCC_OK != status) {
return status;
}
if (strlen(ctx->score_str) > 0) {
team_info.alg_fn = NULL;
team_info.default_score = UCC_CL_BASIC_DEFAULT_SCORE;
team_info.init = NULL;
team_info.num_mem_types = 0;
team_info.supported_mem_types = NULL; /* all memory types supported*/
team_info.supported_colls = UCC_COLL_TYPE_ALL;
team_info.size = UCC_CL_TEAM_SIZE(team);
status = ucc_coll_score_update_from_str(ctx->score_str, &team_info,
&team->super.super, *score);
/* If INVALID_PARAM - User provided incorrect input - try to proceed */
if ((status < 0) && (status != UCC_ERR_INVALID_PARAM) &&
(status != UCC_ERR_NOT_SUPPORTED)) {
goto err;
}
}
return UCC_OK;
err:
ucc_coll_score_free(*score);
*score = NULL;
return status;
}
|
983817b79ffeeebf7946b799a2b8f9642125579a
|
229a28fc18c13bfe1ba7fc81c38b03651ed8e93b
|
/sw/benchmark/src/matmul/main_ssr.c
|
08d0047669323f9739cf2063979893f373fd1583
|
[
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
pulp-platform/snitch
|
d3967742434fa21e8af71afa6be35ea5420166ca
|
d026f47843f0ea6c269244c4e6851e0e09141ec3
|
refs/heads/master
| 2023-08-24T08:42:36.230951
| 2023-06-19T09:34:05
| 2023-06-19T09:34:05
| 289,236,605
| 194
| 44
|
Apache-2.0
| 2023-07-11T12:46:26
| 2020-08-21T09:57:34
|
SystemVerilog
|
UTF-8
|
C
| false
| false
| 425
|
c
|
main_ssr.c
|
// Copyright 2020 ETH Zurich and University of Bologna.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
#include "matmul.h"
int main() {
gemm_result_t result = gemm_bench(gemm_seq_ssr);
if (snrt_global_core_idx() == 0) {
printf("Cycles (SSR): %u\n", result.cycles_total);
return result.errors;
} else {
return 0;
}
}
|
0cf007e24a854a826a29a956c1883e181ac3aacb
|
085ebef8125d212c13d2aa3a0aed9e1c169d1471
|
/src/lib/fy-types.c
|
1649e04c15b9cb02d7c1469c264da0b2bdbae103
|
[
"MIT"
] |
permissive
|
pantoniou/libfyaml
|
b908e72e4a773c2b947e9db0ea08a781246d00b8
|
ce5149953e043541fb7ecca21691423aaad90513
|
refs/heads/master
| 2023-08-08T20:13:24.056555
| 2023-04-27T06:11:22
| 2023-05-01T11:13:37
| 208,780,361
| 219
| 67
|
MIT
| 2023-07-26T23:38:51
| 2019-09-16T11:13:33
|
C
|
UTF-8
|
C
| false
| false
| 719
|
c
|
fy-types.c
|
/*
* fy-types.c - types definition
*
* Copyright (c) 2019 Pantelis Antoniou <pantelis.antoniou@konsulko.com>
*
* SPDX-License-Identifier: MIT
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <stdarg.h>
#include <limits.h>
#include <libfyaml.h>
#include "fy-parse.h"
/* parse only types */
FY_PARSE_TYPE_DEFINE_SIMPLE(indent);
FY_PARSE_TYPE_DEFINE_SIMPLE(simple_key);
FY_PARSE_TYPE_DEFINE_SIMPLE(parse_state_log);
FY_PARSE_TYPE_DEFINE_SIMPLE(flow);
FY_PARSE_TYPE_DEFINE_SIMPLE(streaming_alias);
|
ba0ed150c240bed491e6ebdf9b60d271e026cdc3
|
20e1c2f5cfac01f6b007124fa7792dd69751a6bb
|
/src/os/shared/inc/os-shared-timebase.h
|
a1445a5757d5f06aa12acb3421823453a8bae594
|
[
"Apache-2.0"
] |
permissive
|
nasa/osal
|
71f159b767ba4a8c39df48f238b4f296cc571ac8
|
99e3b4007da51031b521d90390526e123ff740b4
|
refs/heads/main
| 2023-09-01T06:33:53.932829
| 2023-08-18T14:27:02
| 2023-08-18T14:27:02
| 4,814,601
| 493
| 229
|
Apache-2.0
| 2023-09-13T13:57:40
| 2012-06-27T23:10:37
|
C
|
UTF-8
|
C
| false
| false
| 5,295
|
h
|
os-shared-timebase.h
|
/************************************************************************
* NASA Docket No. GSC-18,719-1, and identified as “core Flight System: Bootes”
*
* Copyright (c) 2020 United States Government as represented by the
* Administrator of the National Aeronautics and Space Administration.
* All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
************************************************************************/
/**
* \file
*
* \ingroup shared
*
*/
#ifndef OS_SHARED_TIMEBASE_H
#define OS_SHARED_TIMEBASE_H
#include "osapi-timebase.h"
#include "os-shared-globaldefs.h"
typedef struct
{
char timebase_name[OS_MAX_API_NAME];
OS_TimerSync_t external_sync;
uint32 accuracy_usec;
osal_id_t first_cb;
uint32 freerun_time;
uint32 nominal_start_time;
uint32 nominal_interval_time;
} OS_timebase_internal_record_t;
/*
* These record types have extra information with each entry. These tables are used
* to share extra data between the common layer and the OS-specific implementation.
*/
extern OS_timebase_internal_record_t OS_timebase_table[OS_MAX_TIMEBASES];
/****************************************************************************************
CLOCK / TIME API LOW-LEVEL IMPLEMENTATION FUNCTIONS
****************************************************************************************/
/*---------------------------------------------------------------------------------------
Name: OS_TimeBaseAPI_Init
Purpose: Initialize the OS-independent layer for timebase objects
returns: OS_SUCCESS on success, or relevant error code
---------------------------------------------------------------------------------------*/
int32 OS_TimeBaseAPI_Init(void);
/*
* TimeBase routines implement a low-level timer tick/interrupt;
* no callbacks to user code here. All application callbacks are
* done in the shared layer timer API.
*/
/*----------------------------------------------------------------
Purpose: Prepare OS resources for a time base
Returns: OS_SUCCESS on success, or relevant error code
------------------------------------------------------------------*/
int32 OS_TimeBaseCreate_Impl(const OS_object_token_t *token);
/*----------------------------------------------------------------
Purpose: Configure the OS resources to provide a timer tick
Returns: OS_SUCCESS on success, or relevant error code
------------------------------------------------------------------*/
int32 OS_TimeBaseSet_Impl(const OS_object_token_t *token, uint32 start_time, uint32 interval_time);
/*----------------------------------------------------------------
Purpose: Free the OS resources associated with the time base
Returns: OS_SUCCESS on success, or relevant error code
------------------------------------------------------------------*/
int32 OS_TimeBaseDelete_Impl(const OS_object_token_t *token);
/****************************************************************************************
INTERNAL FUNCTIONS
****************************************************************************************/
/*----------------------------------------------------------------
Purpose: Get exclusive access to the given timebase
Add/remove of application callbacks is prevented
------------------------------------------------------------------*/
void OS_TimeBaseLock_Impl(const OS_object_token_t *token);
/*----------------------------------------------------------------
Purpose: Release exclusive access to the given timebase
Add/remove of application callbacks is allowed
------------------------------------------------------------------*/
void OS_TimeBaseUnlock_Impl(const OS_object_token_t *token);
/*----------------------------------------------------------------
Purpose: Obtain the OS-specific time base information, if any
Returns: OS_SUCCESS on success, or relevant error code
------------------------------------------------------------------*/
int32 OS_TimeBaseGetInfo_Impl(const OS_object_token_t *token, OS_timebase_prop_t *timer_prop);
/*----------------------------------------------------------------
Purpose: Implement the time base helper thread
This is the context for providing application callbacks
------------------------------------------------------------------*/
void OS_TimeBase_CallbackThread(osal_id_t timebase_id);
/*----------------------------------------------------------------
Purpose: Convert milliseconds to ticks
------------------------------------------------------------------*/
int32 OS_Milli2Ticks(uint32 milli_seconds, int *ticks);
#endif /* OS_SHARED_TIMEBASE_H */
|
ab5315c1144941550d3de1266df726e533bd8469
|
8447eb38a4fc71b32b6b82a99f7828a2c50621aa
|
/ppu/sprx/libvdec/config.h
|
fd96e756caa053f888776cdf100817be95882020
|
[
"MIT"
] |
permissive
|
ps3dev/PSL1GHT
|
9ecc1f0a2996b39d35cc98303c58c79966b9388b
|
5bc0961c66a3615c74f15e0c29bbeaa33f867ab3
|
refs/heads/master
| 2023-08-04T06:50:55.256801
| 2023-07-30T13:34:19
| 2023-07-30T13:34:19
| 1,541,223
| 159
| 357
|
MIT
| 2023-07-23T07:26:09
| 2011-03-29T12:34:15
|
C
|
UTF-8
|
C
| false
| false
| 133
|
h
|
config.h
|
#define LIBRARY_NAME "libvdec"
#define LIBRARY_SYMBOL libvdec
#define LIBRARY_HEADER_1 0x2c000001
#define LIBRARY_HEADER_2 0x0009
|
c1138b09a59fe231050782e06e52bab89b63b4e2
|
bece8b97cdb15988562c8c8dc27a5b58cd3acb90
|
/fin7/Resources/Step5/samcats-source/mimikatz/modules/lsadump/kuhl_m_lsadump_dc.h
|
f4bf55284bccfa81c1cf3876acf436bdcbfedb5b
|
[
"Apache-2.0",
"CC-BY-4.0",
"LicenseRef-scancode-warranty-disclaimer"
] |
permissive
|
center-for-threat-informed-defense/adversary_emulation_library
|
4382e78f56faa635d5a6cc89bce5b36f3b74476c
|
4b1d1327ebfbd550ba7e5f1b5562c1f3db61311e
|
refs/heads/master
| 2023-08-12T20:08:57.078612
| 2023-07-17T16:54:16
| 2023-07-17T16:54:16
| 259,753,257
| 1,220
| 243
|
Apache-2.0
| 2023-09-06T16:23:00
| 2020-04-28T21:16:54
|
C
|
UTF-8
|
C
| false
| false
| 5,359
|
h
|
kuhl_m_lsadump_dc.h
|
/* Benjamin DELPY `gentilkiwi`
http://blog.gentilkiwi.com
benjamin@gentilkiwi.com
Vincent LE TOUX
http://pingcastle.com / http://mysmartlogon.com
vincent.letoux@gmail.com
Licence : https://creativecommons.org/licenses/by/4.0/
*/
#pragma once
#include "../modules/rpc/kull_m_rpc_drsr.h"
#include "../kuhl_m.h"
#include "../kuhl_m_lsadump.h" // to move
NTSTATUS kuhl_m_lsadump_dcsync(int argc, wchar_t * argv[]);
NTSTATUS kuhl_m_lsadump_dcshadow(int argc, wchar_t * argv[]);
#pragma pack(push, 1)
typedef struct _USER_PROPERTY {
USHORT NameLength;
USHORT ValueLength;
USHORT Reserved;
wchar_t PropertyName[ANYSIZE_ARRAY];
// PropertyValue in HEX !
} USER_PROPERTY, *PUSER_PROPERTY;
typedef struct _USER_PROPERTIES {
DWORD Reserved1;
DWORD Length;
USHORT Reserved2;
USHORT Reserved3;
BYTE Reserved4[96];
wchar_t PropertySignature;
USHORT PropertyCount;
USER_PROPERTY UserProperties[ANYSIZE_ARRAY];
} USER_PROPERTIES, *PUSER_PROPERTIES;
#pragma pack(pop)
const wchar_t * KUHL_M_LSADUMP_UF_FLAG[32];
BOOL kuhl_m_lsadump_dcsync_decrypt(PBYTE encodedData, DWORD encodedDataSize, DWORD rid, LPCWSTR prefix, BOOL isHistory);
void kuhl_m_lsadump_dcsync_descrObject(SCHEMA_PREFIX_TABLE *prefixTable, ATTRBLOCK *attributes, LPCWSTR szSrcDomain, BOOL someExport);
void kuhl_m_lsadump_dcsync_descrUser(SCHEMA_PREFIX_TABLE *prefixTable, ATTRBLOCK *attributes);
void kuhl_m_lsadump_dcsync_descrUserProperties(PUSER_PROPERTIES properties);
void kuhl_m_lsadump_dcsync_descrTrust(SCHEMA_PREFIX_TABLE *prefixTable, ATTRBLOCK *attributes, LPCWSTR szSrcDomain);
void kuhl_m_lsadump_dcsync_descrTrustAuthentication(SCHEMA_PREFIX_TABLE *prefixTable, ATTRBLOCK *attributes, PCUNICODE_STRING domain, PCUNICODE_STRING partner, BOOL isIn);
void kuhl_m_lsadump_dcsync_descrSecret(SCHEMA_PREFIX_TABLE *prefixTable, ATTRBLOCK *attributes, BOOL someExport);
void kuhl_m_lsadump_dcsync_descrObject_csv(SCHEMA_PREFIX_TABLE *prefixTable, ATTRBLOCK *attributes, BOOL withDeleted, BOOL decodeUAC);
typedef BOOL (*DCSHADOW_SYNTAX_ENCODER) (ATTRVAL* pVal, PWSTR szValue);
typedef struct _DS_REPL_ATTRTYP_META_DATA {
ATTRTYP attrType;
DWORD dwVersion;
FILETIME ftimeLastOriginatingChange;
UUID uuidLastOriginatingDsaInvocationID;
USN usnOriginatingChange;
USN usnLocalChange;
} DS_REPL_ATTRTYP_META_DATA, *PDS_REPL_ATTRTYP_META_DATA;
typedef struct _DS_REPL_OBJ_TYPE_META_DATA {
DWORD cNumEntries;
DWORD dwReserved;
DS_REPL_ATTRTYP_META_DATA rgMetaData[ANYSIZE_ARRAY];
} DS_REPL_OBJ_TYPE_META_DATA, *PDS_REPL_OBJ_TYPE_META_DATA;
typedef struct _DS_REPL_OBJ_TYPE_META_DATA_BLOB {
DWORD dwVersion;
DWORD dwReserved;
DS_REPL_OBJ_TYPE_META_DATA ctr;
} DS_REPL_OBJ_TYPE_META_DATA_BLOB, *PDS_REPL_OBJ_TYPE_META_DATA_BLOB;
typedef struct _DCSHADOW_OBJECT_ATTRIBUTE {
PWSTR szAttributeName;
PSTR Oid;
DWORD dwSyntax;
BOOL fIsSensitive;
} DCSHADOW_OBJECT_ATTRIBUTE, *PDCSHADOW_OBJECT_ATTRIBUTE;
#define REPLICATION_UID_SET (1)
#define REPLICATION_USN_SET (1 << 1)
#define REPLICATION_TIME_SET (1 << 2)
#define OBJECT_TO_ADD (1)
#define OBJECT_DYNAMIC (1 << 1)
typedef struct _DCSHADOW_OBJECT_ATTRIBUTE_METADATA {
DWORD dwFlag;
GUID uidOriginatingDsa;
DWORD usnOriginating;
FILETIME usnTimeChanged;
DWORD curRevision;
FILETIME curTimeChanged;
} DCSHADOW_OBJECT_ATTRIBUTE_METADATA, *PDCSHADOW_OBJECT_ATTRIBUTE_METADATA;
typedef struct _DCSHADOW_PUSH_REQUEST_OBJECT_ATTRIBUTE {
PDCSHADOW_OBJECT_ATTRIBUTE pAttribute;
DCSHADOW_OBJECT_ATTRIBUTE_METADATA MetaData;
ATTRVALBLOCK AttrVal;
PWSTR * pszValue;
} DCSHADOW_PUSH_REQUEST_OBJECT_ATTRIBUTE, *PDCSHADOW_PUSH_REQUEST_OBJECT_ATTRIBUTE;
typedef struct _DCSHADOW_PUSH_REQUEST_OBJECT {
PWSTR szObjectDN;
// mandatory for object creation and/or password encoding
NT4SID pSid;
// mandatory for object creation
GUID ObjectGUID;
GUID ParentGuid;
ULONG cbAttributes;
PDCSHADOW_PUSH_REQUEST_OBJECT_ATTRIBUTE pAttributes;
DWORD dwFlag;
} DCSHADOW_PUSH_REQUEST_OBJECT, *PDCSHADOW_PUSH_REQUEST_OBJECT;
typedef struct _DCSHADOW_PUSH_REQUEST {
ULONG cNumObjects;
PDCSHADOW_PUSH_REQUEST_OBJECT pObjects;
ULONG cNumAttributes;
PDCSHADOW_OBJECT_ATTRIBUTE pAttributes;
} DCSHADOW_PUSH_REQUEST, *PDCSHADOW_PUSH_REQUEST;
typedef struct _DCSHADOW_DOMAIN_DC_INFO {
BOOL isInstanceId;
GUID InstanceId;
BOOL isInvocationId;
GUID InvocationId;
} DCSHADOW_DOMAIN_DC_INFO, *PDCSHADOW_DOMAIN_DC_INFO;
#define DOMAIN_INFO_PUSH_FLAGS_ROOT 1
#define DOMAIN_INFO_PUSH_FLAGS_CONFIG 2
#define DOMAIN_INFO_PUSH_FLAGS_SCHEMA 4
#define DOMAIN_INFO_PUSH_REMOTE_MODIFY 8
typedef struct _DCSHADOW_DOMAIN_INFO {
// dns name - arg or local assigned var freed
PWSTR szDomainName;
PWSTR szDCFQDN;
// not to be freed - arg or static var
PWSTR szFakeDCNetBIOS;
PWSTR szFakeFQDN;
PWSTR szFakeDN;
// naming context of the AD
PWSTR szDomainNamingContext;
PWSTR szConfigurationNamingContext;
PWSTR szSchemaNamingContext;
// The site (first-or-default in general)
PWSTR szDsServiceName;
PWSTR szDCDsServiceName;
DWORD dwDomainControllerFunctionality;
DWORD dwReplEpoch;
DWORD maxDCUsn;
BOOL fUseSchemaSignature;
BYTE pbSchemaSignature[21];
DWORD dwPushFlags;
DCSHADOW_DOMAIN_DC_INFO realDc;
DCSHADOW_DOMAIN_DC_INFO mimiDc;
LDAP* ld;
HANDLE hGetNCChangeCalled;
// the only attribute which can be there in a next call
PDCSHADOW_PUSH_REQUEST request;
} DCSHADOW_DOMAIN_INFO, *PDCSHADOW_DOMAIN_INFO;
|
842e860925f23463756ce62d3a9bd2eaa7d2276d
|
6f006cc43df343e44494fab7b693366ff587be7f
|
/components/timeline.c
|
6aea0456e9c3035df7d1276b232ffcec1476dda4
|
[
"MIT"
] |
permissive
|
EvilPudding/candle
|
a78cb0101a650c94755ca34ccb0eadf34e97feb8
|
a58afb0403776b1e52c90345baf9985f6931244e
|
refs/heads/master
| 2023-09-04T05:45:24.501633
| 2022-11-12T23:02:27
| 2022-11-12T23:02:27
| 117,313,783
| 402
| 20
|
MIT
| 2019-09-15T21:06:54
| 2018-01-13T04:26:37
|
C
|
UTF-8
|
C
| false
| false
| 4,377
|
c
|
timeline.c
|
#include "timeline.h"
#include "../candle.h"
#include "../systems/keyboard.h"
#include "../components/spatial.h"
#include "../components/node.h"
#include <math.h>
struct frame_vec
{
float t;
vec3_t vec;
};
struct frame_quat
{
float t;
vec4_t quat;
};
struct frame_script
{
float t;
};
void c_timeline_clear(c_timeline_t *self)
{
vector_clear(self->keys_scale);
vector_clear(self->keys_pos);
vector_clear(self->keys_rot);
vector_clear(self->keys_scripts);
}
void c_timeline_insert_scale(c_timeline_t *self,
vec3_t scale, float time)
{
struct frame_vec frame;
frame.vec = scale;
frame.t = time;
vector_add(self->keys_scale, &frame);
}
void c_timeline_insert_pos(c_timeline_t *self,
vec3_t pos, float time)
{
struct frame_vec frame;
frame.vec = pos;
frame.t = time;
vector_add(self->keys_pos, &frame);
}
void c_timeline_insert_rot(c_timeline_t *self,
vec4_t rot, float time)
{
struct frame_quat frame;
frame.quat = rot;
frame.t = time;
vector_add(self->keys_rot, &frame);
}
static int c_timeline_find(c_timeline_t *self, vector_t *vec)
{
int i;
for(i = 1; i < vector_count(vec); i++)
{
float *t = vector_get(vec, i);
if(self->t < *t)
{
return i-1;
}
}
printf("Couldn't find timeline point\n");
exit(1);
return 0;
}
static void c_timeline_update_rot(c_timeline_t *self)
{
float factor;
int start_key;
c_spatial_t *sc = c_spatial(self);
struct frame_quat *start = NULL;
struct frame_quat *end = NULL;
int keys_num = vector_count(self->keys_rot);
if(keys_num == 0) return;
if(keys_num == 1)
{
start = vector_get(self->keys_rot, 0);
sc->rot_quat = start->quat;
sc->modified = 1;
return;
}
start_key = c_timeline_find(self, self->keys_rot);
start = vector_get(self->keys_rot, start_key);
end = vector_get(self->keys_rot, start_key + 1);
factor = (self->t - start->t) / (end->t - start->t);
sc->rot_quat = quat_clerp(start->quat, end->quat, factor);
sc->modified = 1;
/* c_spatial_set_rot */
}
static void c_timeline_update_scale(c_timeline_t *self)
{
int start_key;
float factor;
c_spatial_t *sc = c_spatial(self);
struct frame_vec *start = NULL;
struct frame_vec *end = NULL;
int keys_num = vector_count(self->keys_scale);
if(keys_num == 0) return;
if(keys_num == 1)
{
start = vector_get(self->keys_scale, 0);
c_spatial_set_scale(sc, start->vec);
return;
}
start_key = c_timeline_find(self, self->keys_scale);
start = vector_get(self->keys_scale, start_key);
end = vector_get(self->keys_scale, start_key + 1);
factor = (self->t - start->t) / (end->t - start->t);
c_spatial_set_scale(sc, vec3_mix(start->vec, end->vec, factor));
}
static void c_timeline_update_pos(c_timeline_t *self)
{
int start_key;
float factor;
c_spatial_t *sc = c_spatial(self);
struct frame_vec *start = NULL;
struct frame_vec *end = NULL;
int keys_num = vector_count(self->keys_pos);
if(keys_num == 0) return;
if(keys_num == 1)
{
start = vector_get(self->keys_pos, 0);
c_spatial_set_pos(sc, start->vec);
return;
}
start_key = c_timeline_find(self, self->keys_pos);
start = vector_get(self->keys_pos, start_key);
end = vector_get(self->keys_pos, start_key + 1);
factor = (self->t - start->t) / (end->t - start->t);
c_spatial_set_pos(sc, vec3_mix(start->vec, end->vec, factor));
}
static int c_timeline_update(c_timeline_t *self, float *dt)
{
if(self->playing)
{
c_spatial_t *sc;
self->global_time += *dt;
self->t = fmod(self->global_time * self->ticks_per_sec, self->duration);
sc = c_spatial(self);
c_spatial_lock(sc);
c_timeline_update_scale(self);
c_timeline_update_pos(self);
c_timeline_update_rot(self);
/* c_timeline_update_scripts(self); */
c_spatial_unlock(sc);
}
return CONTINUE;
}
void ct_timeline(ct_t *self)
{
ct_init(self, "timeline", sizeof(c_timeline_t));
ct_add_dependency(self, ct_node);
ct_add_listener(self, WORLD, 0, sig("world_update"), c_timeline_update);
}
c_timeline_t *c_timeline_new()
{
c_timeline_t *self = component_new(ct_timeline);
self->playing = 1;
self->keys_pos = vector_new(sizeof(struct frame_vec),
FIXED_ORDER, NULL, NULL);
self->keys_scale = vector_new(sizeof(struct frame_vec),
FIXED_ORDER, NULL, NULL);
self->keys_rot = vector_new(sizeof(struct frame_quat),
FIXED_ORDER, NULL, NULL);
self->keys_scripts = vector_new(sizeof(struct frame_script),
FIXED_ORDER, NULL, NULL);
return self;
}
|
70747d7d0024c8a411e46cf6fcc7267174a6ee96
|
89db60818afeb3dc7c3b7abe9ceae155f074f7f2
|
/src/lib9/cistrstr.c
|
0a113226637a13f65335efeeb54f89e3db371a4b
|
[
"bzip2-1.0.6",
"LPL-1.02",
"MIT"
] |
permissive
|
9fans/plan9port
|
63c3d01928c6f8a8617d3ea6ecc05bac72391132
|
65c090346a38a8c30cb242d345aa71060116340c
|
refs/heads/master
| 2023-08-25T17:14:26.233105
| 2023-08-23T13:21:37
| 2023-08-23T18:47:08
| 26,095,474
| 1,645
| 468
|
NOASSERTION
| 2023-09-05T16:55:41
| 2014-11-02T22:40:13
|
C
|
UTF-8
|
C
| false
| false
| 357
|
c
|
cistrstr.c
|
#include <u.h>
#include <libc.h>
char*
cistrstr(char *s, char *sub)
{
int c, csub, n;
csub = *sub;
if(csub == '\0')
return s;
if(csub >= 'A' && csub <= 'Z')
csub -= 'A' - 'a';
sub++;
n = strlen(sub);
for(; c = *s; s++){
if(c >= 'A' && c <= 'Z')
c -= 'A' - 'a';
if(c == csub && cistrncmp(s+1, sub, n) == 0)
return s;
}
return nil;
}
|
b3a958b6c193e60d994ab47ed2f1fb2f6b1094d3
|
7df190df28da7e4ff166e55dc8ce780f11236a9f
|
/src/router/rstats/misc.c
|
9351152b0e83bc45599368f3801d0f2d0827798b
|
[] |
no_license
|
mirror/dd-wrt
|
25416946e6132aa54b35809de61834a1825a9a36
|
8f2934a5a2adfbb59b471375aa3a38de5d036531
|
refs/heads/master
| 2023-08-31T14:54:47.496685
| 2023-08-30T17:40:54
| 2023-08-30T17:40:54
| 7,470,282
| 520
| 281
| null | 2023-05-29T20:56:24
| 2013-01-06T17:21:29
| null |
UTF-8
|
C
| false
| false
| 4,120
|
c
|
misc.c
|
/*
Tomato Firmware
Copyright (C) 2006 Jonathan Zarate
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdarg.h>
#include <syslog.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <bcmnvram.h>
#include "shutils.h"
#include "shared.h"
#include "utils.h"
int get_wan_proto(void)
{
const char *names[] = { // order must be synced with def at shared.h
"static",
"dhcp",
"heartbeat",
"l2tp",
"pppoe",
"pptp"
};
int i;
const char *p;
p = nvram_safe_get("wan_proto");
for (i = 0; i < 6; ++i) {
if (strcmp(p, names[i]) == 0) return i + 1;
}
return WP_DISABLED;
}
int using_dhcpc(void)
{
const char *proto = nvram_safe_get("wan_proto");
return (strcmp(proto, "dhcp") == 0) || (strcmp(proto, "l2tp") == 0) || (strcmp(proto, "heartbeat") == 0);
}
void notice_set(const char *path, const char *format, ...)
{
char p[256];
char buf[2048];
va_list args;
mkdir("/var/notice", 0755);
snprintf(p, sizeof(p), "/var/notice/%s", path);
va_start(args, format);
vsnprintf(buf, sizeof(buf), format, args);
va_end(args);
f_write_string(p, buf, 0, 0);
if (buf[0]) syslog(LOG_INFO, "notice: %s", buf);
}
int check_wanup(void)
{
int up = 0;
int proto;
char buf1[64];
char buf2[64];
const char *name;
int f;
struct ifreq ifr;
proto = get_wan_proto();
if (proto == WP_DISABLED) return 0;
if ((proto == WP_PPTP) || (proto == WP_L2TP) || (proto == WP_PPPOE) || (proto == WP_HEARTBEAT)) {
if (f_read_string("/tmp/ppp/link", buf1, sizeof(buf1)) > 0) {
if (proto == WP_HEARTBEAT) {
// contains pid of bpalogin
if (strcmp(psname(atoi(buf1), buf2, sizeof(buf2)), "bpalogin") == 0) {
up = 1;
}
}
else {
// contains the base name of a file in /var/run/ containing pid of a daemon
snprintf(buf2, sizeof(buf2), "/var/run/%s.pid", buf1);
if (f_read_string(buf2, buf1, sizeof(buf1)) > 0) {
name = psname(atoi(buf1), buf2, sizeof(buf2));
if (proto == WP_PPPOE) {
if (strcmp(name, "pppoecd") == 0) up = 1;
}
else {
if (strcmp(name, "pppd") == 0) up = 1;
}
}
}
if (!up) {
unlink("/tmp/ppp/link");
cprintf("required daemon not found, assuming link is dead\n");
}
}
}
else if (!nvram_match("wan_ipaddr", "0.0.0.0")) {
up = 1;
}
if ((up) && ((f = socket(AF_INET, SOCK_DGRAM, 0)) >= 0)) {
strlcpy(ifr.ifr_name, nvram_safe_get("wan_iface"), sizeof(ifr.ifr_name));
if (ioctl(f, SIOCGIFFLAGS, &ifr) < 0) up = 0;
close(f);
if ((ifr.ifr_flags & IFF_UP) == 0) up = 0;
}
return up;
}
const dns_list_t *get_dns(void)
{
static dns_list_t dns;
char s[512];
int n;
int i, j;
struct in_addr ia;
char d[4][16];
dns.count = 0;
strlcpy(s, nvram_safe_get("wan_dns"), sizeof(s));
if ((nvram_match("dns_addget", "1")) || (s[0] == 0)) {
n = strlen(s);
snprintf(s + n, sizeof(s) - n, " %s", nvram_safe_get("wan_get_dns"));
}
n = sscanf(s, "%15s %15s %15s %15s", d[0], d[1], d[2], d[3]);
for (i = 0; i < n; ++i) {
if (inet_pton(AF_INET, d[i], &ia) > 0) {
for (j = dns.count - 1; j >= 0; --j) {
if (dns.dns[j].s_addr == ia.s_addr) break;
}
if (j < 0) {
dns.dns[dns.count++].s_addr = ia.s_addr;
if (dns.count == 3) break;
}
}
}
return &dns;
}
// -----------------------------------------------------------------------------
void set_action(int a)
{
int r = 3;
while (f_write("/var/lock/action", &a, sizeof(a), 0, 0) != sizeof(a)) {
sleep(1);
if (--r == 0) return;
}
if (a != ACT_IDLE) sleep(2);
}
int check_action(void)
{
int a;
int r = 3;
while (f_read("/var/lock/action", &a, sizeof(a)) != sizeof(a)) {
sleep(1);
if (--r == 0) return ACT_UNKNOWN;
}
return a;
}
int wait_action_idle(int n)
{
return 1;
/*
while (n-- > 0) {
if (check_action() == ACT_IDLE) return 1;
sleep(1);
}
return 0;*/
}
// -----------------------------------------------------------------------------
int wl_client(void)
{
return ((nvram_match("wl_mode", "sta")) || (nvram_match("wl_mode", "wet")));
}
|
621fa171ad2b98e21a349470a26fb555402c78cd
|
99bdb3251fecee538e0630f15f6574054dfc1468
|
/bsp/lpc55sxx/lpc55s69_nxp_evk/board/ports/rw007_port.c
|
f7c5e5e8f5b1c34c129d64ce0adc7cfc7fae0cd5
|
[
"Zlib",
"LicenseRef-scancode-proprietary-license",
"MIT",
"BSD-3-Clause",
"X11",
"BSD-4-Clause-UC",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
RT-Thread/rt-thread
|
03a7c52c2aeb1b06a544143b0e803d72f47d1ece
|
3602f891211904a27dcbd51e5ba72fefce7326b2
|
refs/heads/master
| 2023-09-01T04:10:20.295801
| 2023-08-31T16:20:55
| 2023-08-31T16:20:55
| 7,408,108
| 9,599
| 5,805
|
Apache-2.0
| 2023-09-14T13:37:26
| 2013-01-02T14:49:21
|
C
|
UTF-8
|
C
| false
| false
| 1,822
|
c
|
rw007_port.c
|
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-05-06 ChuShicheng the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#include <drv_pin.h>
#include <drv_spi.h>
#include <board.h>
#include <spi_wifi_rw007.h>
extern void spi_wifi_isr(int vector);
#define RW007_INT_BUSY_PIN GET_PINS(1, 5)
#define RW007_RST_PIN GET_PINS(1, 8)
static void rw007_gpio_init(void)
{
/* Configure IO */
rt_pin_mode(RW007_RST_PIN, PIN_MODE_OUTPUT);
rt_pin_mode(RW007_INT_BUSY_PIN, PIN_MODE_INPUT_PULLDOWN);
/* Reset rw007 and config mode */
rt_pin_write(RW007_RST_PIN, PIN_LOW);
rt_thread_delay(rt_tick_from_millisecond(100));
rt_pin_write(RW007_RST_PIN, PIN_HIGH);
/* Wait rw007 ready(exit busy stat) */
while(!rt_pin_read(RW007_INT_BUSY_PIN))
{
rt_thread_delay(5);
}
rt_thread_delay(rt_tick_from_millisecond(200));
rt_pin_mode(RW007_INT_BUSY_PIN, PIN_MODE_INPUT_PULLUP);
}
int wifi_spi_device_init(void)
{
char sn_version[32];
rw007_gpio_init();
rt_hw_spi_device_attach("spi8", "wspi", GET_PINS(1, 1));
rt_hw_wifi_init("wspi");
rt_wlan_set_mode(RT_WLAN_DEVICE_STA_NAME, RT_WLAN_STATION);
rt_wlan_set_mode(RT_WLAN_DEVICE_AP_NAME, RT_WLAN_AP);
rw007_sn_get(sn_version);
rt_kprintf("\nrw007 sn: [%s]\n", sn_version);
rw007_version_get(sn_version);
rt_kprintf("rw007 ver: [%s]\n\n", sn_version);
return 0;
}
INIT_APP_EXPORT(wifi_spi_device_init);
static void int_wifi_irq(void * p)
{
((void)p);
spi_wifi_isr(0);
}
void spi_wifi_hw_init(void)
{
rt_pin_attach_irq(RW007_INT_BUSY_PIN, PIN_IRQ_MODE_FALLING, int_wifi_irq, 0);
rt_pin_irq_enable(RW007_INT_BUSY_PIN, RT_TRUE);
}
|
721f1c5e837eec22b74cc54c9d226d48f3781e65
|
fc89df5d65edcfada41a5bcc3b5c52d7b00d9d13
|
/components/telnet/telnet.h
|
255fa3d62817031e07ebbc3915ddc569542223dd
|
[] |
no_license
|
sle118/squeezelite-esp32
|
b83f580b4de4a517be87ca1db8fead2223694068
|
149c9d8142d7a3f8679efc73985609eb6dee73a5
|
refs/heads/master-v4.3
| 2023-08-23T05:06:18.461579
| 2023-08-22T23:30:18
| 2023-08-22T23:30:18
| 187,874,998
| 698
| 84
| null | 2023-09-09T22:58:50
| 2019-05-21T16:25:56
|
C
|
UTF-8
|
C
| false
| false
| 60
|
h
|
telnet.h
|
void init_telnet();
void start_telnet(void * pvParameter);
|
8f952b61eae55dcd29640c180c7be1940f738627
|
d2e0fb3fdad7fc2cb70894591d358f40d8db13d2
|
/kernel/include/dennix/display.h
|
55f369935c87fdde74ecc8fdd8ff2a5ce34d7906
|
[
"ISC",
"MIT"
] |
permissive
|
dennis95/dennix
|
54c568485862a0799664033eb0717abb028d3924
|
f898bb2d27346f6257df1650a002ee929e66e7fa
|
refs/heads/master
| 2023-08-17T06:54:17.274650
| 2023-07-10T16:06:35
| 2023-07-10T16:06:35
| 55,073,371
| 168
| 15
| null | null | null | null |
UTF-8
|
C
| false
| false
| 2,323
|
h
|
display.h
|
/* Copyright (c) 2020, 2021, 2022 Dennis Wölfing
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* kernel/include/dennix/display.h
* Display.
*/
#ifndef _DENNIX_DISPLAY_H
#define _DENNIX_DISPLAY_H
#include <stddef.h>
#include <dennix/devctl.h>
/* Set the display mode. The new mode is returned in info. */
#define DISPLAY_SET_MODE _DEVCTL(_IOCTL_INT, 0)
/* Get the display resolution. */
#define DISPLAY_GET_RESOLUTION _DEVCTL(_IOCTL_PTR, 3)
/* Draw to the screen. Only supported in LFB mode. */
#define DISPLAY_DRAW _DEVCTL(_IOCTL_PTR, 4)
/* Get the current video mode. */
#define DISPLAY_GET_VIDEO_MODE _DEVCTL(_IOCTL_PTR, 5)
/* Set the video mode. */
#define DISPLAY_SET_VIDEO_MODE _DEVCTL(_IOCTL_PTR, 6)
/* Make the current process the display owner. */
#define DISPLAY_ACQUIRE _DEVCTL(_IOCTL_VOID, 1)
/* Stop owning the display. */
#define DISPLAY_RELEASE _DEVCTL(_IOCTL_VOID, 2)
#define DISPLAY_MODE_QUERY 0
#define DISPLAY_MODE_TEXT 1
#define DISPLAY_MODE_LFB 2
struct display_resolution {
unsigned int width;
unsigned int height;
};
struct display_draw {
void* lfb;
size_t lfb_pitch;
unsigned int lfb_x;
unsigned int lfb_y;
unsigned int draw_x;
unsigned int draw_y;
unsigned int draw_width;
unsigned int draw_height;
};
struct video_mode {
unsigned int video_height;
unsigned int video_width;
unsigned int video_bpp; /* 0 for text mode */
};
#undef RGB
#undef RGBA
/* Supported alpha values are 0 (transparent) and 255 (not transparent). */
#define RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
#define RGB(r, g, b) RGBA(r, g, b, 255U)
#endif
|
aad1e7f8f37dce3fc538894670c5b93cf8774a5b
|
6fc66dfe9c818e0295df74e11d132cdc400243ca
|
/lib/freertos/include/osdefs.h
|
5975a18a4ef2039b6b1fa126cb4fcea017399cf7
|
[
"Apache-2.0"
] |
permissive
|
kendryte/kendryte-freertos-sdk
|
600d8acc5900f532bf44823ad758e602dbac8d38
|
b9dd7678f4c6549b0458a8ba9d80198691a2504d
|
refs/heads/develop
| 2022-07-15T22:45:47.458472
| 2021-02-01T02:23:27
| 2021-02-01T02:23:27
| 147,630,962
| 206
| 75
|
Apache-2.0
| 2020-09-26T14:44:26
| 2018-09-06T06:56:36
|
C
|
UTF-8
|
C
| false
| false
| 7,829
|
h
|
osdefs.h
|
/* Copyright 2018 Canaan Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _FREERTOS_OSDEFS_H
#define _FREERTOS_OSDEFS_H
#include <platform.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>
#include "FreeRTOS.h"
#include "semphr.h"
#ifdef __cplusplus
extern "C"
{
#endif
#define NULL_HANDLE 0
#define MAX_PATH 256
typedef uintptr_t handle_t;
typedef enum _uart_stopbits
{
UART_STOP_1,
UART_STOP_1_5,
UART_STOP_2
} uart_stopbits_t;
typedef enum _uart_parity
{
UART_PARITY_NONE,
UART_PARITY_ODD,
UART_PARITY_EVEN
} uart_parity_t;
typedef enum _gpio_drive_mode
{
GPIO_DM_INPUT,
GPIO_DM_INPUT_PULL_DOWN,
GPIO_DM_INPUT_PULL_UP,
GPIO_DM_OUTPUT
} gpio_drive_mode_t;
typedef enum _gpio_pin_edge
{
GPIO_PE_NONE,
GPIO_PE_FALLING,
GPIO_PE_RISING,
GPIO_PE_BOTH
} gpio_pin_edge_t;
typedef enum _gpio_pin_value
{
GPIO_PV_LOW,
GPIO_PV_HIGH
} gpio_pin_value_t;
typedef void(*gpio_on_changed_t)(uint32_t pin, void *userdata);
typedef enum _i2c_event
{
I2C_EV_START,
I2C_EV_RESTART,
I2C_EV_STOP
} i2c_event_t;
typedef struct _i2c_slave_handler
{
void(*on_receive)(uint32_t data);
uint32_t(*on_transmit)();
void(*on_event)(i2c_event_t event);
} i2c_slave_handler_t;
typedef enum _audio_format_type
{
AUDIO_FMT_PCM
} audio_format_type_t;
typedef struct _audio_format
{
audio_format_type_t type;
uint32_t bits_per_sample;
uint32_t sample_rate;
uint32_t channels;
} audio_format_t;
typedef enum _i2s_align_mode
{
I2S_AM_STANDARD,
I2S_AM_RIGHT,
I2S_AM_LEFT
} i2s_align_mode_t;
typedef enum _spi_mode
{
SPI_MODE_0,
SPI_MODE_1,
SPI_MODE_2,
SPI_MODE_3,
} spi_mode_t;
typedef enum _spi_frame_format
{
SPI_FF_STANDARD,
SPI_FF_DUAL,
SPI_FF_QUAD,
SPI_FF_OCTAL
} spi_frame_format_t;
typedef enum _spi_inst_addr_trans_mode
{
SPI_AITM_STANDARD,
SPI_AITM_ADDR_STANDARD,
SPI_AITM_AS_FRAME_FORMAT
} spi_inst_addr_trans_mode_t;
typedef enum {
WRITE_CONFIG,
READ_CONFIG,
WRITE_DATA_BYTE,
READ_DATA_BYTE,
WRITE_DATA_BLOCK,
READ_DATA_BLOCK,
} spi_slave_command_e;
typedef struct
{
uint8_t cmd;
uint8_t err;
uint32_t addr;
uint32_t len;
} spi_slave_command_t;
typedef int (*spi_slave_receive_callback_t)(void *ctx);
typedef enum _video_format
{
VIDEO_FMT_RGB565,
VIDEO_FMT_RGB24_PLANAR
} video_format_t;
typedef enum _video_frame_event
{
VIDEO_FE_BEGIN,
VIDEO_FE_END
} dvp_frame_event_t;
typedef enum _dvp_signal_type
{
DVP_SIG_POWER_DOWN,
DVP_SIG_RESET
} dvp_signal_type_t;
typedef void(*dvp_on_frame_event_t)(dvp_frame_event_t event, void *userdata);
typedef struct tag_fft_data
{
int16_t I1;
int16_t R1;
int16_t I2;
int16_t R2;
} fft_data_t;
typedef enum tag_fft_direction
{
FFT_DIR_BACKWARD,
FFT_DIR_FORWARD,
FFT_DIR_MAX,
} fft_direction_t;
typedef enum
{
AES_ECB = 0,
AES_CBC = 1,
AES_GCM = 2,
AES_CIPHER_MAX
} aes_cipher_mode_t;
typedef enum
{
AES_128 = 16,
AES_192 = 24,
AES_256 = 32,
} aes_kmode;
typedef enum
{
AES_HARD_ENCRYPTION = 0,
AES_HARD_DECRYPTION = 1,
} aes_encrypt_sel_t;
typedef struct _gcm_context
{
/* The buffer holding the encryption or decryption key. */
uint8_t *input_key;
/* The initialization vector. must be 96 bit */
uint8_t *iv;
/* The buffer holding the Additional authenticated data. or NULL */
uint8_t *gcm_aad;
/* The length of the Additional authenticated data. or 0L */
size_t gcm_aad_len;
} gcm_context_t;
typedef struct _cbc_context
{
/* The buffer holding the encryption or decryption key. */
uint8_t *input_key;
/* The initialization vector. must be 128 bit */
uint8_t *iv;
} cbc_context_t;
typedef void(*timer_on_tick_t)(void* userdata);
typedef enum _wdt_response_mode
{
WDT_RESP_RESET,
WDT_RESP_INTERRUPT
} wdt_response_mode_t;
typedef int(*wdt_on_timeout_t)(void *userdata);
typedef void(*pic_irq_handler_t)(void *userdata);
typedef void(*dma_stage_completion_handler_t)(void *userdata);
typedef enum _file_access
{
FILE_ACCESS_READ = 1,
FILE_ACCESS_WRITE = 2,
FILE_ACCESS_READ_WRITE = 3
} file_access_t;
typedef enum _file_mode
{
/* Opens the file. The function fails if the file is not existing. (Default) */
FILE_MODE_OPEN_EXISTING,
/* Creates a new file. The function fails with FR_EXIST if the file is existing. */
FILE_MODE_CREATE_NEW,
/* Creates a new file. If the file is existing, it will be truncated and overwritten. */
FILE_MODE_CREATE_ALWAYS,
/* Opens the file if it is existing. If not, a new file will be created. */
FILE_MODE_OPEN_ALWAYS,
/* Same as FILE_MODE_OPEN_ALWAYS except the read/write pointer is set end of the file. */
FILE_MODE_APPEND,
FILE_MODE_TRUNCATE
} file_mode_t;
typedef struct _find_file_data
{
char filename[MAX_PATH];
} find_find_data_t;
typedef enum _address_family
{
AF_UNSPECIFIED,
AF_INTERNETWORK
} address_family_t;
typedef enum _socket_type
{
SOCKET_STREAM,
SOCKET_DATAGRAM
} socket_type_t;
typedef enum _socket_message_flag
{
MESSAGE_NORMAL = 0x00,
MESSAGE_PEEK = 0x01,
MESSAGE_WAITALL = 0x02,
MESSAGE_OOB = 0x04,
MESSAGE_DONTWAIT = 0x08,
MESSAGE_MORE = 0x10
} socket_message_flag_t;
typedef enum _protocol_type
{
PROTCL_IP
} protocol_type_t;
typedef struct _socket_address
{
uint8_t size;
address_family_t family;
uint8_t data[14];
} socket_address_t;
typedef enum _socket_shutdown
{
SOCKSHTDN_RECEIVE,
SOCKSHTDN_SEND,
SOCKSHTDN_BOTH
} socket_shutdown_t;
typedef struct _ip_address
{
address_family_t family;
uint8_t data[16];
} ip_address_t;
typedef struct _mac_address
{
uint8_t data[6];
} mac_address_t;
typedef struct _hostent
{
/* Official name of the host. */
char *h_name;
/* A pointer to an array of pointers to alternative host names, terminated by a null pointer. */
char **h_aliases;
/* Address type. */
uint32_t h_addrtype;
/* The length, in bytes, of the address. */
uint32_t h_length;
/* A pointer to an array of pointers to network addresses (in
network byte order) for the host, terminated by a null pointer. */
uint8_t **h_addr_list;
} hostent_t;
typedef enum _dhcp_state
{
DHCP_START = 0,
DHCP_WAIT_ADDRESS,
DHCP_ADDRESS_ASSIGNED,
DHCP_TIMEOUT,
DHCP_FAIL
} dhcp_state_t;
#define SYS_IOCPARM_MASK 0x7fU /* parameters must be < 128 bytes */
#define SYS_IOC_VOID 0x20000000UL /* no parameters */
#define SYS_IOC_OUT 0x40000000UL /* copy out parameters */
#define SYS_IOC_IN 0x80000000UL /* copy in parameters */
#define SYS_IOC_INOUT (SYS_IOC_IN | SYS_IOC_OUT) /* 0x20000000 distinguishes new & old ioctl's */
#define SYS_IO(x, y) (SYS_IOC_VOID | ((x) << 8) | (y))
#define SYS_IOR(x, y, t) (SYS_IOC_OUT | (((uint32_t)sizeof(t) & SYS_IOCPARM_MASK) << 16) | ((x) << 8) | (y))
#define SYS_IOW(x, y, t) (SYS_IOC_IN | (((uint32_t)sizeof(t) & SYS_IOCPARM_MASK) << 16) | ((x) << 8) | (y))
#define SYS_FIONBIO SYS_IOW('f', 126, uint32_t) /* set/clear non-blocking i/o */
#ifdef __cplusplus
}
#endif
#endif /* _FREERTOS_OSDEFS_H */
|
a31f6344cbe88e303bb10485b40b211c633e9721
|
cf56b5fcf51fddb219c47f5f006d8595a4483c57
|
/src/ucc/api/ucc_def.h
|
66005375be255f7c7c53df6cf0ed4b2846b9e13b
|
[
"BSD-3-Clause"
] |
permissive
|
openucx/ucc
|
3b39fbd849a7850c559b60eaec7882292f8a5eca
|
f89cd7557e6ebb19b4c6ebd529647d8b42c30657
|
refs/heads/master
| 2023-08-18T03:18:54.072899
| 2023-08-17T18:05:44
| 2023-08-17T18:05:44
| 282,490,868
| 150
| 57
|
BSD-3-Clause
| 2023-09-12T09:49:18
| 2020-07-25T17:18:51
|
C
|
UTF-8
|
C
| false
| false
| 4,802
|
h
|
ucc_def.h
|
/**
* @file ucc_def.h
* @date 2020
* @copyright (c) 2020, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* @copyright Copyright (C) Huawei Technologies Co., Ltd. 2020. ALL RIGHTS RESERVED.
*
* See file LICENSE for terms.
*/
#ifndef UCC_DEF_H_
#define UCC_DEF_H_
#include <ucc/api/ucc_status.h>
#include <stddef.h>
#include <stdint.h>
/**
* @ingroup UCC_LIB_INIT_DT
* @brief UCC library handle
*
* The ucc library handle is an opaque handle created by the library. It
* abstracts the collective library. It holds the global information and
* resources associated with the library. The library handle cannot be passed
* from one library instance to another.
*/
typedef struct ucc_lib_info* ucc_lib_h;
/**
* @ingroup UCC_CONTEXT_DT
* @brief UCC context
*
* The UCC context is an opaque handle to abstract the network resources for
* collective operations. The network resources could be either software or
* hardware. Based on the type of the context, the resources can be shared or
* either be exclusively used. The UCC context is required but not sufficient to
* execute a collective operation.
*/
typedef struct ucc_context* ucc_context_h;
/**
* @ingroup UCC_TEAM_DT
* @brief UCC team handle
*
* The UCC team handle is an opaque handle created by the library. It abstracts
* the group resources required for the collective operations and participants
* of the collective operation. The participants of the collective operation can
* be an OS process or thread.
*/
typedef struct ucc_team* ucc_team_h;
/**
* @ingroup UCC_COLLECTIVES_DT
* @brief UCC collective request handle
*
* The UCC request handle is an opaque handle created by the library during the
* invocation of the collective operation. The request may be used to learn the
* status of the collective operation, progress, or complete the collective
* operation.
*/
typedef struct ucc_coll_req* ucc_coll_req_h;
typedef struct ucc_coll_req {
ucc_status_t status;
} ucc_coll_req_t;
/**
* @ingroup UCC_COLLECTIVES_DT
* @brief UCC collective completion callback
*
* The callback is invoked whenever the collective operation is completed.
* It is not allowed to call UCC APIs from the completion callback except
* for @ref ucc_collective_finalize.
*/
typedef struct ucc_coll_callback {
void (*cb)(void *data, ucc_status_t status);
void *data;
} ucc_coll_callback_t;
/**
* @ingroup UCC_COLLECTIVES
* @brief UCC memory handle
*
* The UCC memory handle is an opaque handle created by the library representing
* the buffer and address.
*/
typedef struct ucc_mem_handle* ucc_mem_h;
/**
* @ingroup UCC_LIB_INIT_DT
*
* @brief UCC library configuration handle
*/
typedef struct ucc_lib_config* ucc_lib_config_h;
/**
* @ingroup UCC_CONTEXT_DT
*
* @brief UCC context configuration handle
*/
typedef struct ucc_context_config* ucc_context_config_h;
/**
* @ingroup UCC_COLLECTIVES_DT
* @brief Count datatype to support both small (32 bit) and large counts (64 bit)
*/
typedef uint64_t ucc_count_t;
/**
* @ingroup UCC_COLLECTIVES_DT
* @brief Datatype to support both small (32 bit) and large address offsets (64 bit)
*/
typedef uint64_t ucc_aint_t;
/* Reflects the definition in UCS - The i-th bit */
#define UCC_BIT(i) (1ul << (i))
#define UCC_MASK(i) (UCC_BIT(i) - 1)
/* Reflects the definition in UCS */
/**
* @ingroup UCC_UTILS
* @brief Print configurations
*/
typedef enum {
UCC_CONFIG_PRINT_CONFIG = UCC_BIT(0),
UCC_CONFIG_PRINT_HEADER = UCC_BIT(1),
UCC_CONFIG_PRINT_DOC = UCC_BIT(2),
UCC_CONFIG_PRINT_HIDDEN = UCC_BIT(3)
} ucc_config_print_flags_t;
/**
* @ingroup UCC_COLLECTIVES_DT
* @brief Datatype for collective tags
*/
typedef uint16_t ucc_coll_id_t ;
/**
* @ingroup UCC_TEAM_DT
*/
typedef void *ucc_p2p_conn_t;
/**
* @ingroup UCC_TEAM_DT
*/
typedef void* ucc_context_addr_h;
/**
* @ingroup UCC_TEAM_DT
*/
typedef size_t ucc_context_addr_len_t;
/**
* @ingroup UCC_EVENTS_DT
* @brief UCC execution engine handle
*
* The UCC execution engine handle is an opaque handle created by the library representing
* the execution context and related queues.
*/
typedef struct ucc_ee* ucc_ee_h;
typedef struct ucc_dt_generic ucc_dt_generic_t;
/**
* @ingroup UCC_DATATYPES
* @brief Helper enum for generic/predefined datatype representation
*
*/
typedef enum {
UCC_DATATYPE_PREDEFINED = 0,
UCC_DATATYPE_GENERIC = UCC_BIT(0),
UCC_DATATYPE_SHIFT = 3,
UCC_DATATYPE_CLASS_MASK = UCC_MASK(UCC_DATATYPE_SHIFT)
} ucc_dt_type_t;
#define UCC_PREDEFINED_DT(_id) \
(ucc_datatype_t)((((uint64_t)(_id)) << UCC_DATATYPE_SHIFT) | \
(UCC_DATATYPE_PREDEFINED))
#endif
|
f417035fe527d02353886247879393c597853cb7
|
28d0f8c01599f8f6c711bdde0b59f9c2cd221203
|
/sys/arch/emips/ebus/ebusvar.h
|
bfc140418651201739fafbcb052c76a18fca1be9
|
[] |
no_license
|
NetBSD/src
|
1a9cbc22ed778be638b37869ed4fb5c8dd616166
|
23ee83f7c0aea0777bd89d8ebd7f0cde9880d13c
|
refs/heads/trunk
| 2023-08-31T13:24:58.105962
| 2023-08-27T15:50:47
| 2023-08-27T15:50:47
| 88,439,547
| 656
| 348
| null | 2023-07-20T20:07:24
| 2017-04-16T20:03:43
| null |
UTF-8
|
C
| false
| false
| 961
|
h
|
ebusvar.h
|
/* $NetBSD: ebusvar.h,v 1.3 2011/06/12 04:00:33 tsutsui Exp $ */
#ifndef _EMIPS_EBUS_EBUSVAR_H_
#define _EMIPS_EBUS_EBUSVAR_H_
#include <machine/bus.h>
struct ebus_attach_args;
/*
* Arguments used to attach an ebus "device" to its parent
*/
struct ebus_dev_attach_args {
const char *ida_busname; /* XXX should be common */
bus_space_tag_t ida_memt;
int ida_ndevs;
struct ebus_attach_args *ida_devs;
};
/*
* Arguments used to attach devices to an ebus
*/
struct ebus_attach_args {
const char *ia_name; /* device name */
int ia_cookie; /* device cookie */
uint32_t ia_paddr; /* device address (PHYSICAL) */
void *ia_vaddr; /* device address (VIRTUAL) */
int ia_basz; /* device size
(for min regset at probe, else 0) */
};
void ebusattach(device_t , device_t , void *);
int ebusprint(void *, const char *);
void ebus_intr_establish(device_t , void *, int,
int (*)(void *, void *), void *);
#endif /* !_EMIPS_EBUS_EBUSVAR_H_ */
|
4ec4c75c4fe69ec5d7422bfd13d6171a6e41f29a
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/u-boot_new/drivers/video/sunxi/disp2/disp/lcd/t27p06.h
|
e364acb8a31fbcad8118f42fea0b9a45dd6e9aa9
|
[
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"GPL-2.0-or-later"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 121
|
h
|
t27p06.h
|
#ifndef __T27P06_PANEL_H__
#define __T27P06_PANEL_H__
#include "panels.h"
extern __lcd_panel_t t27p06_panel;
#endif
|
f751c1e7698065bffbd259e8a75160a2d5bf5d94
|
74fd7631c0367958583b5d455f185ffca25d70f7
|
/amqp_envelope_exception.c
|
debd5b07914ab18e6790f356ec045ce225f65d96
|
[
"PHP-3.01"
] |
permissive
|
php-amqp/php-amqp
|
fe1dd539f8c0d681fa045af9ff7c3925bbc128cd
|
e339a5fbabeec5cf8508990f67fc883911d8d30a
|
refs/heads/latest
| 2023-09-04T22:26:58.649384
| 2023-08-26T23:31:15
| 2023-08-26T23:31:15
| 5,734,668
| 132
| 28
|
NOASSERTION
| 2023-09-08T22:41:20
| 2012-09-09T03:43:19
|
C
|
UTF-8
|
C
| false
| false
| 2,832
|
c
|
amqp_envelope_exception.c
|
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2007 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Alexandre Kalendarev akalend@mail.ru Copyright (c) 2009-2010 |
| Lead: |
| - Pieter de Zwart |
| Maintainers: |
| - Brad Rodriguez |
| - Jonathan Tansavatdi |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "zend_exceptions.h"
#include "php_amqp.h"
zend_class_entry *amqp_envelope_exception_class_entry;
#define this_ce amqp_envelope_exception_class_entry
/* {{{ proto float AMQPEnvelopeException::getEnvelope()
Get AMQPEnvelope object */
static PHP_METHOD(amqp_envelope_exception_class, getEnvelope)
{
zval rv;
PHP_AMQP_NOPARAMS()
PHP_AMQP_RETURN_THIS_PROP("envelope");
}
/* }}} */
ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(
arginfo_amqp_envelope_exception_class_getEnvelope,
ZEND_SEND_BY_VAL,
0,
AMQPEnvelope,
0
)
ZEND_END_ARG_INFO()
zend_function_entry amqp_envelope_exception_class_functions[] = {
PHP_ME(amqp_envelope_exception_class, getEnvelope, arginfo_amqp_envelope_exception_class_getEnvelope, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
PHP_MINIT_FUNCTION(amqp_envelope_exception)
{
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, "AMQPEnvelopeException", amqp_envelope_exception_class_functions);
amqp_envelope_exception_class_entry = zend_register_internal_class_ex(&ce, amqp_exception_class_entry);
PHP_AMQP_DECLARE_TYPED_PROPERTY_OBJ(
amqp_envelope_exception_class_entry,
"envelope",
ZEND_ACC_PRIVATE,
AMQPEnvelope,
0
);
return SUCCESS;
}
|
6fde6f05fbac2d8c39c67ab64edf6e1350d1bbff
|
5eff7a36d9a9917dce9111f0c3074375fe6f7656
|
/lib/mesa/src/amd/vulkan/radv_meta_fmask_expand.c
|
1f3df57b12b6f75704425c6d037b4e5b76547ea5
|
[] |
no_license
|
openbsd/xenocara
|
cb392d02ebba06f6ff7d826fd8a89aa3b8401779
|
a012b5de33ea0b977095d77316a521195b26cc6b
|
refs/heads/master
| 2023-08-25T12:16:58.862008
| 2023-08-12T16:16:25
| 2023-08-12T16:16:25
| 66,967,384
| 177
| 66
| null | 2023-07-22T18:12:37
| 2016-08-30T18:36:01
|
C
|
UTF-8
|
C
| false
| false
| 11,089
|
c
|
radv_meta_fmask_expand.c
|
/*
* Copyright © 2019 Valve Corporation
* Copyright © 2018 Red Hat
*
* 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 (including the next
* paragraph) 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.
*/
#include "radv_meta.h"
#include "radv_private.h"
#include "vk_format.h"
static nir_shader *
build_fmask_expand_compute_shader(struct radv_device *device, int samples)
{
const struct glsl_type *type =
glsl_sampler_type(GLSL_SAMPLER_DIM_MS, false, true, GLSL_TYPE_FLOAT);
const struct glsl_type *img_type = glsl_image_type(GLSL_SAMPLER_DIM_MS, true, GLSL_TYPE_FLOAT);
nir_builder b =
radv_meta_init_shader(device, MESA_SHADER_COMPUTE, "meta_fmask_expand_cs-%d", samples);
b.shader->info.workgroup_size[0] = 8;
b.shader->info.workgroup_size[1] = 8;
nir_variable *input_img = nir_variable_create(b.shader, nir_var_uniform, type, "s_tex");
input_img->data.descriptor_set = 0;
input_img->data.binding = 0;
nir_variable *output_img = nir_variable_create(b.shader, nir_var_image, img_type, "out_img");
output_img->data.descriptor_set = 0;
output_img->data.binding = 1;
output_img->data.access = ACCESS_NON_READABLE;
nir_ssa_def *input_img_deref = &nir_build_deref_var(&b, input_img)->dest.ssa;
nir_ssa_def *output_img_deref = &nir_build_deref_var(&b, output_img)->dest.ssa;
nir_ssa_def *tex_coord = get_global_ids(&b, 3);
nir_tex_instr *tex_instr[8];
for (uint32_t i = 0; i < samples; i++) {
tex_instr[i] = nir_tex_instr_create(b.shader, 3);
nir_tex_instr *tex = tex_instr[i];
tex->sampler_dim = GLSL_SAMPLER_DIM_MS;
tex->op = nir_texop_txf_ms;
tex->src[0].src_type = nir_tex_src_coord;
tex->src[0].src = nir_src_for_ssa(tex_coord);
tex->src[1].src_type = nir_tex_src_ms_index;
tex->src[1].src = nir_src_for_ssa(nir_imm_int(&b, i));
tex->src[2].src_type = nir_tex_src_texture_deref;
tex->src[2].src = nir_src_for_ssa(input_img_deref);
tex->dest_type = nir_type_float32;
tex->is_array = true;
tex->coord_components = 3;
nir_ssa_dest_init(&tex->instr, &tex->dest, 4, 32, "tex");
nir_builder_instr_insert(&b, &tex->instr);
}
nir_ssa_def *img_coord =
nir_vec4(&b, nir_channel(&b, tex_coord, 0), nir_channel(&b, tex_coord, 1),
nir_channel(&b, tex_coord, 2), nir_ssa_undef(&b, 1, 32));
for (uint32_t i = 0; i < samples; i++) {
nir_ssa_def *outval = &tex_instr[i]->dest.ssa;
nir_image_deref_store(&b, output_img_deref, img_coord, nir_imm_int(&b, i), outval,
nir_imm_int(&b, 0), .image_dim = GLSL_SAMPLER_DIM_MS, .image_array = true);
}
return b.shader;
}
void
radv_expand_fmask_image_inplace(struct radv_cmd_buffer *cmd_buffer, struct radv_image *image,
const VkImageSubresourceRange *subresourceRange)
{
struct radv_device *device = cmd_buffer->device;
struct radv_meta_saved_state saved_state;
const uint32_t samples = image->info.samples;
const uint32_t samples_log2 = ffs(samples) - 1;
unsigned layer_count = radv_get_layerCount(image, subresourceRange);
struct radv_image_view iview;
radv_meta_save(&saved_state, cmd_buffer,
RADV_META_SAVE_COMPUTE_PIPELINE | RADV_META_SAVE_DESCRIPTORS);
VkPipeline pipeline = device->meta_state.fmask_expand.pipeline[samples_log2];
radv_CmdBindPipeline(radv_cmd_buffer_to_handle(cmd_buffer), VK_PIPELINE_BIND_POINT_COMPUTE,
pipeline);
cmd_buffer->state.flush_bits |= radv_dst_access_flush(
cmd_buffer, VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT, image);
radv_image_view_init(&iview, device,
&(VkImageViewCreateInfo){
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = radv_image_to_handle(image),
.viewType = radv_meta_get_view_type(image),
.format = vk_format_no_srgb(image->vk.format),
.subresourceRange =
{
.aspectMask = subresourceRange->aspectMask,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = subresourceRange->baseArrayLayer,
.layerCount = layer_count,
},
},
0, NULL);
radv_meta_push_descriptor_set(
cmd_buffer, VK_PIPELINE_BIND_POINT_COMPUTE,
cmd_buffer->device->meta_state.fmask_expand.p_layout, 0, /* set */
2, /* descriptorWriteCount */
(VkWriteDescriptorSet[]){{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
.pImageInfo =
(VkDescriptorImageInfo[]){
{.sampler = VK_NULL_HANDLE,
.imageView = radv_image_view_to_handle(&iview),
.imageLayout = VK_IMAGE_LAYOUT_GENERAL},
}},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstBinding = 1,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.pImageInfo = (VkDescriptorImageInfo[]){
{.sampler = VK_NULL_HANDLE,
.imageView = radv_image_view_to_handle(&iview),
.imageLayout = VK_IMAGE_LAYOUT_GENERAL},
}}});
radv_unaligned_dispatch(cmd_buffer, image->info.width, image->info.height, layer_count);
radv_image_view_finish(&iview);
radv_meta_restore(&saved_state, cmd_buffer);
cmd_buffer->state.flush_bits |=
RADV_CMD_FLAG_CS_PARTIAL_FLUSH |
radv_src_access_flush(cmd_buffer, VK_ACCESS_2_SHADER_WRITE_BIT, image);
/* Re-initialize FMASK in fully expanded mode. */
cmd_buffer->state.flush_bits |= radv_init_fmask(cmd_buffer, image, subresourceRange);
}
void
radv_device_finish_meta_fmask_expand_state(struct radv_device *device)
{
struct radv_meta_state *state = &device->meta_state;
for (uint32_t i = 0; i < MAX_SAMPLES_LOG2; ++i) {
radv_DestroyPipeline(radv_device_to_handle(device), state->fmask_expand.pipeline[i],
&state->alloc);
}
radv_DestroyPipelineLayout(radv_device_to_handle(device), state->fmask_expand.p_layout,
&state->alloc);
device->vk.dispatch_table.DestroyDescriptorSetLayout(
radv_device_to_handle(device), state->fmask_expand.ds_layout, &state->alloc);
}
static VkResult
create_fmask_expand_pipeline(struct radv_device *device, int samples, VkPipeline *pipeline)
{
struct radv_meta_state *state = &device->meta_state;
VkResult result;
nir_shader *cs = build_fmask_expand_compute_shader(device, samples);
;
VkPipelineShaderStageCreateInfo pipeline_shader_stage = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_COMPUTE_BIT,
.module = vk_shader_module_handle_from_nir(cs),
.pName = "main",
.pSpecializationInfo = NULL,
};
VkComputePipelineCreateInfo vk_pipeline_info = {
.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
.stage = pipeline_shader_stage,
.flags = 0,
.layout = state->fmask_expand.p_layout,
};
result = radv_CreateComputePipelines(radv_device_to_handle(device),
state->cache, 1,
&vk_pipeline_info, NULL, pipeline);
ralloc_free(cs);
return result;
}
VkResult
radv_device_init_meta_fmask_expand_state(struct radv_device *device)
{
struct radv_meta_state *state = &device->meta_state;
VkResult result;
VkDescriptorSetLayoutCreateInfo ds_create_info = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
.bindingCount = 2,
.pBindings = (VkDescriptorSetLayoutBinding[]){
{.binding = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.pImmutableSamplers = NULL},
{.binding = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.pImmutableSamplers = NULL},
}};
result = radv_CreateDescriptorSetLayout(radv_device_to_handle(device), &ds_create_info,
&state->alloc, &state->fmask_expand.ds_layout);
if (result != VK_SUCCESS)
return result;
VkPipelineLayoutCreateInfo color_create_info = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.setLayoutCount = 1,
.pSetLayouts = &state->fmask_expand.ds_layout,
.pushConstantRangeCount = 0,
.pPushConstantRanges = NULL,
};
result = radv_CreatePipelineLayout(radv_device_to_handle(device), &color_create_info,
&state->alloc, &state->fmask_expand.p_layout);
if (result != VK_SUCCESS)
return result;
for (uint32_t i = 0; i < MAX_SAMPLES_LOG2; i++) {
uint32_t samples = 1 << i;
result = create_fmask_expand_pipeline(device, samples, &state->fmask_expand.pipeline[i]);
if (result != VK_SUCCESS)
return result;
}
return VK_SUCCESS;
}
|
9dfdc910b16336f06bfd13025068ff7d27bd3ade
|
60a4e210ab8a37d23cde5007bd9325aff06c3fc6
|
/_fixtures/cgostacktest/hello.c
|
b779bf96aa3c741d011e33f007b0a4c78346b468
|
[
"MIT"
] |
permissive
|
go-delve/delve
|
56fe6722543a55ae55e0a500d71a0b12c4f96ac3
|
7f094c81e9fe4c83a218a6de73a2a63e99faa4f3
|
refs/heads/master
| 2023-08-28T21:54:33.745660
| 2023-08-28T19:46:19
| 2023-08-28T19:46:19
| 19,994,257
| 11,813
| 1,423
|
MIT
| 2023-09-14T17:08:30
| 2014-05-20T19:24:43
|
Go
|
UTF-8
|
C
| false
| false
| 548
|
c
|
hello.c
|
#include <stdio.h>
#include "_cgo_export.h"
#ifdef __amd64__
#define BREAKPOINT asm("int3;")
#elif __i386__
#define BREAKPOINT asm("int3;")
#elif __PPC64__
#define BREAKPOINT asm("tw 31,0,0;")
#elif __aarch64__
#ifdef WIN32
#define BREAKPOINT asm("brk 0xF000;")
#else
#define BREAKPOINT asm("brk 0;")
#endif
#endif
void helloworld_pt2(int x) {
BREAKPOINT;
helloWorld(x+1);
}
void helloworld(int x) {
helloworld_pt2(x+1);
}
void helloworld_pt4(int x) {
BREAKPOINT;
helloWorld2(x+1);
}
void helloworld_pt3(int x) {
helloworld_pt4(x+1);
}
|
05081c27fd4b1a408fa35cc90b46d7c8811fd219
|
40195e6f86bf8620850f0c56e98eae5693e88277
|
/deps/protobuf/ruby/ext/google/protobuf_c/encode_decode.c
|
d86a1145d07d3140acc3737a3eb246d619c85463
|
[
"MIT",
"BSD-3-Clause",
"LicenseRef-scancode-protobuf"
] |
permissive
|
apple/coremltools
|
009dfa7154d34cab8edcafa618e689e407521f50
|
feed174188f7773631a3d574e1ff9889a135c986
|
refs/heads/main
| 2023-09-01T23:26:13.491955
| 2023-08-31T18:44:31
| 2023-08-31T18:44:31
| 95,862,535
| 3,742
| 705
|
BSD-3-Clause
| 2023-09-14T17:33:58
| 2017-06-30T07:39:02
|
Python
|
UTF-8
|
C
| false
| false
| 45,371
|
c
|
encode_decode.c
|
// Protocol Buffers - Google's data interchange format
// Copyright 2014 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "protobuf.h"
// This function is equivalent to rb_str_cat(), but unlike the real
// rb_str_cat(), it doesn't leak memory in some versions of Ruby.
// For more information, see:
// https://bugs.ruby-lang.org/issues/11328
VALUE noleak_rb_str_cat(VALUE rb_str, const char *str, long len) {
char *p;
size_t oldlen = RSTRING_LEN(rb_str);
rb_str_modify_expand(rb_str, len);
p = RSTRING_PTR(rb_str);
memcpy(p + oldlen, str, len);
rb_str_set_len(rb_str, oldlen + len);
return rb_str;
}
// -----------------------------------------------------------------------------
// Parsing.
// -----------------------------------------------------------------------------
#define DEREF(msg, ofs, type) *(type*)(((uint8_t *)msg) + ofs)
// Creates a handlerdata that simply contains the offset for this field.
static const void* newhandlerdata(upb_handlers* h, uint32_t ofs) {
size_t* hd_ofs = ALLOC(size_t);
*hd_ofs = ofs;
upb_handlers_addcleanup(h, hd_ofs, xfree);
return hd_ofs;
}
typedef struct {
size_t ofs;
const upb_msgdef *md;
} submsg_handlerdata_t;
// Creates a handlerdata that contains offset and submessage type information.
static const void *newsubmsghandlerdata(upb_handlers* h, uint32_t ofs,
const upb_fielddef* f) {
submsg_handlerdata_t *hd = ALLOC(submsg_handlerdata_t);
hd->ofs = ofs;
hd->md = upb_fielddef_msgsubdef(f);
upb_handlers_addcleanup(h, hd, xfree);
return hd;
}
typedef struct {
size_t ofs; // union data slot
size_t case_ofs; // oneof_case field
uint32_t oneof_case_num; // oneof-case number to place in oneof_case field
const upb_msgdef *md; // msgdef, for oneof submessage handler
} oneof_handlerdata_t;
static const void *newoneofhandlerdata(upb_handlers *h,
uint32_t ofs,
uint32_t case_ofs,
const upb_fielddef *f) {
oneof_handlerdata_t *hd = ALLOC(oneof_handlerdata_t);
hd->ofs = ofs;
hd->case_ofs = case_ofs;
// We reuse the field tag number as a oneof union discriminant tag. Note that
// we don't expose these numbers to the user, so the only requirement is that
// we have some unique ID for each union case/possibility. The field tag
// numbers are already present and are easy to use so there's no reason to
// create a separate ID space. In addition, using the field tag number here
// lets us easily look up the field in the oneof accessor.
hd->oneof_case_num = upb_fielddef_number(f);
if (upb_fielddef_type(f) == UPB_TYPE_MESSAGE) {
hd->md = upb_fielddef_msgsubdef(f);
} else {
hd->md = NULL;
}
upb_handlers_addcleanup(h, hd, xfree);
return hd;
}
// A handler that starts a repeated field. Gets the Repeated*Field instance for
// this field (such an instance always exists even in an empty message).
static void *startseq_handler(void* closure, const void* hd) {
MessageHeader* msg = closure;
const size_t *ofs = hd;
return (void*)DEREF(msg, *ofs, VALUE);
}
// Handlers that append primitive values to a repeated field.
#define DEFINE_APPEND_HANDLER(type, ctype) \
static bool append##type##_handler(void *closure, const void *hd, \
ctype val) { \
VALUE ary = (VALUE)closure; \
RepeatedField_push_native(ary, &val); \
return true; \
}
DEFINE_APPEND_HANDLER(bool, bool)
DEFINE_APPEND_HANDLER(int32, int32_t)
DEFINE_APPEND_HANDLER(uint32, uint32_t)
DEFINE_APPEND_HANDLER(float, float)
DEFINE_APPEND_HANDLER(int64, int64_t)
DEFINE_APPEND_HANDLER(uint64, uint64_t)
DEFINE_APPEND_HANDLER(double, double)
// Appends a string to a repeated field.
static void* appendstr_handler(void *closure,
const void *hd,
size_t size_hint) {
VALUE ary = (VALUE)closure;
VALUE str = rb_str_new2("");
rb_enc_associate(str, kRubyStringUtf8Encoding);
RepeatedField_push_native(ary, &str);
return (void*)str;
}
// Appends a 'bytes' string to a repeated field.
static void* appendbytes_handler(void *closure,
const void *hd,
size_t size_hint) {
VALUE ary = (VALUE)closure;
VALUE str = rb_str_new2("");
rb_enc_associate(str, kRubyString8bitEncoding);
RepeatedField_push_native(ary, &str);
return (void*)str;
}
// Sets a non-repeated string field in a message.
static void* str_handler(void *closure,
const void *hd,
size_t size_hint) {
MessageHeader* msg = closure;
const size_t *ofs = hd;
VALUE str = rb_str_new2("");
rb_enc_associate(str, kRubyStringUtf8Encoding);
DEREF(msg, *ofs, VALUE) = str;
return (void*)str;
}
// Sets a non-repeated 'bytes' field in a message.
static void* bytes_handler(void *closure,
const void *hd,
size_t size_hint) {
MessageHeader* msg = closure;
const size_t *ofs = hd;
VALUE str = rb_str_new2("");
rb_enc_associate(str, kRubyString8bitEncoding);
DEREF(msg, *ofs, VALUE) = str;
return (void*)str;
}
static size_t stringdata_handler(void* closure, const void* hd,
const char* str, size_t len,
const upb_bufhandle* handle) {
VALUE rb_str = (VALUE)closure;
noleak_rb_str_cat(rb_str, str, len);
return len;
}
static bool stringdata_end_handler(void* closure, const void* hd) {
MessageHeader* msg = closure;
const size_t *ofs = hd;
VALUE rb_str = DEREF(msg, *ofs, VALUE);
rb_obj_freeze(rb_str);
return true;
}
static bool appendstring_end_handler(void* closure, const void* hd) {
VALUE ary = (VALUE)closure;
int size = RepeatedField_size(ary);
VALUE* last = RepeatedField_index_native(ary, size - 1);
VALUE rb_str = *last;
rb_obj_freeze(rb_str);
return true;
}
// Appends a submessage to a repeated field (a regular Ruby array for now).
static void *appendsubmsg_handler(void *closure, const void *hd) {
VALUE ary = (VALUE)closure;
const submsg_handlerdata_t *submsgdata = hd;
VALUE subdesc =
get_def_obj((void*)submsgdata->md);
VALUE subklass = Descriptor_msgclass(subdesc);
MessageHeader* submsg;
VALUE submsg_rb = rb_class_new_instance(0, NULL, subklass);
RepeatedField_push(ary, submsg_rb);
TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
return submsg;
}
// Sets a non-repeated submessage field in a message.
static void *submsg_handler(void *closure, const void *hd) {
MessageHeader* msg = closure;
const submsg_handlerdata_t* submsgdata = hd;
VALUE subdesc =
get_def_obj((void*)submsgdata->md);
VALUE subklass = Descriptor_msgclass(subdesc);
VALUE submsg_rb;
MessageHeader* submsg;
if (DEREF(msg, submsgdata->ofs, VALUE) == Qnil) {
DEREF(msg, submsgdata->ofs, VALUE) =
rb_class_new_instance(0, NULL, subklass);
}
submsg_rb = DEREF(msg, submsgdata->ofs, VALUE);
TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
return submsg;
}
// Handler data for startmap/endmap handlers.
typedef struct {
size_t ofs;
upb_fieldtype_t key_field_type;
upb_fieldtype_t value_field_type;
// We know that we can hold this reference because the handlerdata has the
// same lifetime as the upb_handlers struct, and the upb_handlers struct holds
// a reference to the upb_msgdef, which in turn has references to its subdefs.
const upb_def* value_field_subdef;
} map_handlerdata_t;
// Temporary frame for map parsing: at the beginning of a map entry message, a
// submsg handler allocates a frame to hold (i) a reference to the Map object
// into which this message will be inserted and (ii) storage slots to
// temporarily hold the key and value for this map entry until the end of the
// submessage. When the submessage ends, another handler is called to insert the
// value into the map.
typedef struct {
VALUE map;
const map_handlerdata_t* handlerdata;
char key_storage[NATIVE_SLOT_MAX_SIZE];
char value_storage[NATIVE_SLOT_MAX_SIZE];
} map_parse_frame_t;
static void MapParseFrame_mark(void* _self) {
map_parse_frame_t* frame = _self;
// This shouldn't strictly be necessary since this should be rooted by the
// message itself, but it can't hurt.
rb_gc_mark(frame->map);
native_slot_mark(frame->handlerdata->key_field_type, &frame->key_storage);
native_slot_mark(frame->handlerdata->value_field_type, &frame->value_storage);
}
void MapParseFrame_free(void* self) {
xfree(self);
}
rb_data_type_t MapParseFrame_type = {
"MapParseFrame",
{ MapParseFrame_mark, MapParseFrame_free, NULL },
};
// Array of Ruby objects wrapping map_parse_frame_t.
// We don't allow multiple concurrent decodes, so we assume that this global
// variable is specific to the "current" decode.
VALUE map_parse_frames;
static map_parse_frame_t* map_push_frame(VALUE map,
const map_handlerdata_t* handlerdata) {
map_parse_frame_t* frame = ALLOC(map_parse_frame_t);
frame->handlerdata = handlerdata;
frame->map = map;
native_slot_init(handlerdata->key_field_type, &frame->key_storage);
native_slot_init(handlerdata->value_field_type, &frame->value_storage);
rb_ary_push(map_parse_frames,
TypedData_Wrap_Struct(rb_cObject, &MapParseFrame_type, frame));
return frame;
}
static void map_pop_frame() {
rb_ary_pop(map_parse_frames);
}
// Handler to begin a map entry: allocates a temporary frame. This is the
// 'startsubmsg' handler on the msgdef that contains the map field.
static void *startmapentry_handler(void *closure, const void *hd) {
MessageHeader* msg = closure;
const map_handlerdata_t* mapdata = hd;
VALUE map_rb = DEREF(msg, mapdata->ofs, VALUE);
return map_push_frame(map_rb, mapdata);
}
// Handler to end a map entry: inserts the value defined during the message into
// the map. This is the 'endmsg' handler on the map entry msgdef.
static bool endmap_handler(void *closure, const void *hd, upb_status* s) {
map_parse_frame_t* frame = closure;
const map_handlerdata_t* mapdata = hd;
VALUE key = native_slot_get(
mapdata->key_field_type, Qnil,
&frame->key_storage);
VALUE value_field_typeclass = Qnil;
VALUE value;
if (mapdata->value_field_type == UPB_TYPE_MESSAGE ||
mapdata->value_field_type == UPB_TYPE_ENUM) {
value_field_typeclass = get_def_obj(mapdata->value_field_subdef);
}
value = native_slot_get(
mapdata->value_field_type, value_field_typeclass,
&frame->value_storage);
Map_index_set(frame->map, key, value);
map_pop_frame();
return true;
}
// Allocates a new map_handlerdata_t given the map entry message definition. If
// the offset of the field within the parent message is also given, that is
// added to the handler data as well. Note that this is called *twice* per map
// field: once in the parent message handler setup when setting the startsubmsg
// handler and once in the map entry message handler setup when setting the
// key/value and endmsg handlers. The reason is that there is no easy way to
// pass the handlerdata down to the sub-message handler setup.
static map_handlerdata_t* new_map_handlerdata(
size_t ofs,
const upb_msgdef* mapentry_def,
Descriptor* desc) {
const upb_fielddef* key_field;
const upb_fielddef* value_field;
map_handlerdata_t* hd = ALLOC(map_handlerdata_t);
hd->ofs = ofs;
key_field = upb_msgdef_itof(mapentry_def, MAP_KEY_FIELD);
assert(key_field != NULL);
hd->key_field_type = upb_fielddef_type(key_field);
value_field = upb_msgdef_itof(mapentry_def, MAP_VALUE_FIELD);
assert(value_field != NULL);
hd->value_field_type = upb_fielddef_type(value_field);
hd->value_field_subdef = upb_fielddef_subdef(value_field);
return hd;
}
// Handlers that set primitive values in oneofs.
#define DEFINE_ONEOF_HANDLER(type, ctype) \
static bool oneof##type##_handler(void *closure, const void *hd, \
ctype val) { \
const oneof_handlerdata_t *oneofdata = hd; \
DEREF(closure, oneofdata->case_ofs, uint32_t) = \
oneofdata->oneof_case_num; \
DEREF(closure, oneofdata->ofs, ctype) = val; \
return true; \
}
DEFINE_ONEOF_HANDLER(bool, bool)
DEFINE_ONEOF_HANDLER(int32, int32_t)
DEFINE_ONEOF_HANDLER(uint32, uint32_t)
DEFINE_ONEOF_HANDLER(float, float)
DEFINE_ONEOF_HANDLER(int64, int64_t)
DEFINE_ONEOF_HANDLER(uint64, uint64_t)
DEFINE_ONEOF_HANDLER(double, double)
#undef DEFINE_ONEOF_HANDLER
// Handlers for strings in a oneof.
static void *oneofstr_handler(void *closure,
const void *hd,
size_t size_hint) {
MessageHeader* msg = closure;
const oneof_handlerdata_t *oneofdata = hd;
VALUE str = rb_str_new2("");
rb_enc_associate(str, kRubyStringUtf8Encoding);
DEREF(msg, oneofdata->case_ofs, uint32_t) =
oneofdata->oneof_case_num;
DEREF(msg, oneofdata->ofs, VALUE) = str;
return (void*)str;
}
static void *oneofbytes_handler(void *closure,
const void *hd,
size_t size_hint) {
MessageHeader* msg = closure;
const oneof_handlerdata_t *oneofdata = hd;
VALUE str = rb_str_new2("");
rb_enc_associate(str, kRubyString8bitEncoding);
DEREF(msg, oneofdata->case_ofs, uint32_t) =
oneofdata->oneof_case_num;
DEREF(msg, oneofdata->ofs, VALUE) = str;
return (void*)str;
}
static bool oneofstring_end_handler(void* closure, const void* hd) {
MessageHeader* msg = closure;
const oneof_handlerdata_t *oneofdata = hd;
rb_obj_freeze(DEREF(msg, oneofdata->ofs, VALUE));
return true;
}
// Handler for a submessage field in a oneof.
static void *oneofsubmsg_handler(void *closure,
const void *hd) {
MessageHeader* msg = closure;
const oneof_handlerdata_t *oneofdata = hd;
uint32_t oldcase = DEREF(msg, oneofdata->case_ofs, uint32_t);
VALUE subdesc =
get_def_obj((void*)oneofdata->md);
VALUE subklass = Descriptor_msgclass(subdesc);
VALUE submsg_rb;
MessageHeader* submsg;
if (oldcase != oneofdata->oneof_case_num ||
DEREF(msg, oneofdata->ofs, VALUE) == Qnil) {
DEREF(msg, oneofdata->ofs, VALUE) =
rb_class_new_instance(0, NULL, subklass);
}
// Set the oneof case *after* allocating the new class instance -- otherwise,
// if the Ruby GC is invoked as part of a call into the VM, it might invoke
// our mark routines, and our mark routines might see the case value
// indicating a VALUE is present and expect a valid VALUE. See comment in
// layout_set() for more detail: basically, the change to the value and the
// case must be atomic w.r.t. the Ruby VM.
DEREF(msg, oneofdata->case_ofs, uint32_t) =
oneofdata->oneof_case_num;
submsg_rb = DEREF(msg, oneofdata->ofs, VALUE);
TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
return submsg;
}
// Set up handlers for a repeated field.
static void add_handlers_for_repeated_field(upb_handlers *h,
const upb_fielddef *f,
size_t offset) {
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newhandlerdata(h, offset));
upb_handlers_setstartseq(h, f, startseq_handler, &attr);
upb_handlerattr_uninit(&attr);
switch (upb_fielddef_type(f)) {
#define SET_HANDLER(utype, ltype) \
case utype: \
upb_handlers_set##ltype(h, f, append##ltype##_handler, NULL); \
break;
SET_HANDLER(UPB_TYPE_BOOL, bool);
SET_HANDLER(UPB_TYPE_INT32, int32);
SET_HANDLER(UPB_TYPE_UINT32, uint32);
SET_HANDLER(UPB_TYPE_ENUM, int32);
SET_HANDLER(UPB_TYPE_FLOAT, float);
SET_HANDLER(UPB_TYPE_INT64, int64);
SET_HANDLER(UPB_TYPE_UINT64, uint64);
SET_HANDLER(UPB_TYPE_DOUBLE, double);
#undef SET_HANDLER
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
upb_handlers_setstartstr(h, f, is_bytes ?
appendbytes_handler : appendstr_handler,
NULL);
upb_handlers_setstring(h, f, stringdata_handler, NULL);
upb_handlers_setendstr(h, f, appendstring_end_handler, NULL);
break;
}
case UPB_TYPE_MESSAGE: {
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newsubmsghandlerdata(h, 0, f));
upb_handlers_setstartsubmsg(h, f, appendsubmsg_handler, &attr);
upb_handlerattr_uninit(&attr);
break;
}
}
}
// Set up handlers for a singular field.
static void add_handlers_for_singular_field(upb_handlers *h,
const upb_fielddef *f,
size_t offset) {
switch (upb_fielddef_type(f)) {
case UPB_TYPE_BOOL:
case UPB_TYPE_INT32:
case UPB_TYPE_UINT32:
case UPB_TYPE_ENUM:
case UPB_TYPE_FLOAT:
case UPB_TYPE_INT64:
case UPB_TYPE_UINT64:
case UPB_TYPE_DOUBLE:
upb_msg_setscalarhandler(h, f, offset, -1);
break;
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newhandlerdata(h, offset));
upb_handlers_setstartstr(h, f,
is_bytes ? bytes_handler : str_handler,
&attr);
upb_handlers_setstring(h, f, stringdata_handler, &attr);
upb_handlers_setendstr(h, f, stringdata_end_handler, &attr);
upb_handlerattr_uninit(&attr);
break;
}
case UPB_TYPE_MESSAGE: {
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newsubmsghandlerdata(h, offset, f));
upb_handlers_setstartsubmsg(h, f, submsg_handler, &attr);
upb_handlerattr_uninit(&attr);
break;
}
}
}
// Adds handlers to a map field.
static void add_handlers_for_mapfield(upb_handlers* h,
const upb_fielddef* fielddef,
size_t offset,
Descriptor* desc) {
const upb_msgdef* map_msgdef = upb_fielddef_msgsubdef(fielddef);
map_handlerdata_t* hd = new_map_handlerdata(offset, map_msgdef, desc);
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlers_addcleanup(h, hd, xfree);
upb_handlerattr_sethandlerdata(&attr, hd);
upb_handlers_setstartsubmsg(h, fielddef, startmapentry_handler, &attr);
upb_handlerattr_uninit(&attr);
}
// Adds handlers to a map-entry msgdef.
static void add_handlers_for_mapentry(const upb_msgdef* msgdef,
upb_handlers* h,
Descriptor* desc) {
const upb_fielddef* key_field = map_entry_key(msgdef);
const upb_fielddef* value_field = map_entry_value(msgdef);
map_handlerdata_t* hd = new_map_handlerdata(0, msgdef, desc);
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlers_addcleanup(h, hd, xfree);
upb_handlerattr_sethandlerdata(&attr, hd);
upb_handlers_setendmsg(h, endmap_handler, &attr);
add_handlers_for_singular_field(
h, key_field,
offsetof(map_parse_frame_t, key_storage));
add_handlers_for_singular_field(
h, value_field,
offsetof(map_parse_frame_t, value_storage));
}
// Set up handlers for a oneof field.
static void add_handlers_for_oneof_field(upb_handlers *h,
const upb_fielddef *f,
size_t offset,
size_t oneof_case_offset) {
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(
&attr, newoneofhandlerdata(h, offset, oneof_case_offset, f));
switch (upb_fielddef_type(f)) {
#define SET_HANDLER(utype, ltype) \
case utype: \
upb_handlers_set##ltype(h, f, oneof##ltype##_handler, &attr); \
break;
SET_HANDLER(UPB_TYPE_BOOL, bool);
SET_HANDLER(UPB_TYPE_INT32, int32);
SET_HANDLER(UPB_TYPE_UINT32, uint32);
SET_HANDLER(UPB_TYPE_ENUM, int32);
SET_HANDLER(UPB_TYPE_FLOAT, float);
SET_HANDLER(UPB_TYPE_INT64, int64);
SET_HANDLER(UPB_TYPE_UINT64, uint64);
SET_HANDLER(UPB_TYPE_DOUBLE, double);
#undef SET_HANDLER
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
upb_handlers_setstartstr(h, f, is_bytes ?
oneofbytes_handler : oneofstr_handler,
&attr);
upb_handlers_setstring(h, f, stringdata_handler, NULL);
upb_handlers_setendstr(h, f, oneofstring_end_handler, &attr);
break;
}
case UPB_TYPE_MESSAGE: {
upb_handlers_setstartsubmsg(h, f, oneofsubmsg_handler, &attr);
break;
}
}
upb_handlerattr_uninit(&attr);
}
static void add_handlers_for_message(const void *closure, upb_handlers *h) {
const upb_msgdef* msgdef = upb_handlers_msgdef(h);
Descriptor* desc = ruby_to_Descriptor(get_def_obj((void*)msgdef));
upb_msg_field_iter i;
// If this is a mapentry message type, set up a special set of handlers and
// bail out of the normal (user-defined) message type handling.
if (upb_msgdef_mapentry(msgdef)) {
add_handlers_for_mapentry(msgdef, h, desc);
return;
}
// Ensure layout exists. We may be invoked to create handlers for a given
// message if we are included as a submsg of another message type before our
// class is actually built, so to work around this, we just create the layout
// (and handlers, in the class-building function) on-demand.
if (desc->layout == NULL) {
desc->layout = create_layout(desc->msgdef);
}
for (upb_msg_field_begin(&i, desc->msgdef);
!upb_msg_field_done(&i);
upb_msg_field_next(&i)) {
const upb_fielddef *f = upb_msg_iter_field(&i);
size_t offset = desc->layout->fields[upb_fielddef_index(f)].offset +
sizeof(MessageHeader);
if (upb_fielddef_containingoneof(f)) {
size_t oneof_case_offset =
desc->layout->fields[upb_fielddef_index(f)].case_offset +
sizeof(MessageHeader);
add_handlers_for_oneof_field(h, f, offset, oneof_case_offset);
} else if (is_map_field(f)) {
add_handlers_for_mapfield(h, f, offset, desc);
} else if (upb_fielddef_isseq(f)) {
add_handlers_for_repeated_field(h, f, offset);
} else {
add_handlers_for_singular_field(h, f, offset);
}
}
}
// Creates upb handlers for populating a message.
static const upb_handlers *new_fill_handlers(Descriptor* desc,
const void* owner) {
// TODO(cfallin, haberman): once upb gets a caching/memoization layer for
// handlers, reuse subdef handlers so that e.g. if we already parse
// B-with-field-of-type-C, we don't have to rebuild the whole hierarchy to
// parse A-with-field-of-type-B-with-field-of-type-C.
return upb_handlers_newfrozen(desc->msgdef, owner,
add_handlers_for_message, NULL);
}
// Constructs the handlers for filling a message's data into an in-memory
// object.
const upb_handlers* get_fill_handlers(Descriptor* desc) {
if (!desc->fill_handlers) {
desc->fill_handlers =
new_fill_handlers(desc, &desc->fill_handlers);
}
return desc->fill_handlers;
}
// Constructs the upb decoder method for parsing messages of this type.
// This is called from the message class creation code.
const upb_pbdecodermethod *new_fillmsg_decodermethod(Descriptor* desc,
const void* owner) {
const upb_handlers* handlers = get_fill_handlers(desc);
upb_pbdecodermethodopts opts;
upb_pbdecodermethodopts_init(&opts, handlers);
return upb_pbdecodermethod_new(&opts, owner);
}
static const upb_pbdecodermethod *msgdef_decodermethod(Descriptor* desc) {
if (desc->fill_method == NULL) {
desc->fill_method = new_fillmsg_decodermethod(
desc, &desc->fill_method);
}
return desc->fill_method;
}
static const upb_json_parsermethod *msgdef_jsonparsermethod(Descriptor* desc) {
if (desc->json_fill_method == NULL) {
desc->json_fill_method =
upb_json_parsermethod_new(desc->msgdef, &desc->json_fill_method);
}
return desc->json_fill_method;
}
// Stack-allocated context during an encode/decode operation. Contains the upb
// environment and its stack-based allocator, an initial buffer for allocations
// to avoid malloc() when possible, and a template for Ruby exception messages
// if any error occurs.
#define STACK_ENV_STACKBYTES 4096
typedef struct {
upb_env env;
const char* ruby_error_template;
char allocbuf[STACK_ENV_STACKBYTES];
} stackenv;
static void stackenv_init(stackenv* se, const char* errmsg);
static void stackenv_uninit(stackenv* se);
// Callback invoked by upb if any error occurs during parsing or serialization.
static bool env_error_func(void* ud, const upb_status* status) {
stackenv* se = ud;
// Free the env -- rb_raise will longjmp up the stack past the encode/decode
// function so it would not otherwise have been freed.
stackenv_uninit(se);
// TODO(haberman): have a way to verify that this is actually a parse error,
// instead of just throwing "parse error" unconditionally.
rb_raise(cParseError, se->ruby_error_template, upb_status_errmsg(status));
// Never reached: rb_raise() always longjmp()s up the stack, past all of our
// code, back to Ruby.
return false;
}
static void stackenv_init(stackenv* se, const char* errmsg) {
se->ruby_error_template = errmsg;
upb_env_init2(&se->env, se->allocbuf, sizeof(se->allocbuf), NULL);
upb_env_seterrorfunc(&se->env, env_error_func, se);
}
static void stackenv_uninit(stackenv* se) {
upb_env_uninit(&se->env);
}
/*
* call-seq:
* MessageClass.decode(data) => message
*
* Decodes the given data (as a string containing bytes in protocol buffers wire
* format) under the interpretration given by this message class's definition
* and returns a message object with the corresponding field values.
*/
VALUE Message_decode(VALUE klass, VALUE data) {
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
Descriptor* desc = ruby_to_Descriptor(descriptor);
VALUE msgklass = Descriptor_msgclass(descriptor);
VALUE msg_rb;
MessageHeader* msg;
if (TYPE(data) != T_STRING) {
rb_raise(rb_eArgError, "Expected string for binary protobuf data.");
}
msg_rb = rb_class_new_instance(0, NULL, msgklass);
TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
// We generally expect this to be clear already, but clear it in case parsing
// previously got interrupted somehow.
rb_ary_clear(map_parse_frames);
{
const upb_pbdecodermethod* method = msgdef_decodermethod(desc);
const upb_handlers* h = upb_pbdecodermethod_desthandlers(method);
stackenv se;
upb_sink sink;
upb_pbdecoder* decoder;
stackenv_init(&se, "Error occurred during parsing: %s");
upb_sink_reset(&sink, h, msg);
decoder = upb_pbdecoder_create(&se.env, method, &sink);
upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data),
upb_pbdecoder_input(decoder));
stackenv_uninit(&se);
}
return msg_rb;
}
/*
* call-seq:
* MessageClass.decode_json(data) => message
*
* Decodes the given data (as a string containing bytes in protocol buffers wire
* format) under the interpretration given by this message class's definition
* and returns a message object with the corresponding field values.
*/
VALUE Message_decode_json(VALUE klass, VALUE data) {
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
Descriptor* desc = ruby_to_Descriptor(descriptor);
VALUE msgklass = Descriptor_msgclass(descriptor);
VALUE msg_rb;
MessageHeader* msg;
if (TYPE(data) != T_STRING) {
rb_raise(rb_eArgError, "Expected string for JSON data.");
}
// TODO(cfallin): Check and respect string encoding. If not UTF-8, we need to
// convert, because string handlers pass data directly to message string
// fields.
msg_rb = rb_class_new_instance(0, NULL, msgklass);
TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
// We generally expect this to be clear already, but clear it in case parsing
// previously got interrupted somehow.
rb_ary_clear(map_parse_frames);
{
const upb_json_parsermethod* method = msgdef_jsonparsermethod(desc);
stackenv se;
upb_sink sink;
upb_json_parser* parser;
stackenv_init(&se, "Error occurred during parsing: %s");
upb_sink_reset(&sink, get_fill_handlers(desc), msg);
parser = upb_json_parser_create(&se.env, method, &sink);
upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data),
upb_json_parser_input(parser));
stackenv_uninit(&se);
}
return msg_rb;
}
// -----------------------------------------------------------------------------
// Serializing.
// -----------------------------------------------------------------------------
//
// The code below also comes from upb's prototype Ruby binding, developed by
// haberman@.
/* stringsink *****************************************************************/
// This should probably be factored into a common upb component.
typedef struct {
upb_byteshandler handler;
upb_bytessink sink;
char *ptr;
size_t len, size;
} stringsink;
static void *stringsink_start(void *_sink, const void *hd, size_t size_hint) {
stringsink *sink = _sink;
sink->len = 0;
return sink;
}
static size_t stringsink_string(void *_sink, const void *hd, const char *ptr,
size_t len, const upb_bufhandle *handle) {
stringsink *sink = _sink;
size_t new_size = sink->size;
UPB_UNUSED(hd);
UPB_UNUSED(handle);
while (sink->len + len > new_size) {
new_size *= 2;
}
if (new_size != sink->size) {
sink->ptr = realloc(sink->ptr, new_size);
sink->size = new_size;
}
memcpy(sink->ptr + sink->len, ptr, len);
sink->len += len;
return len;
}
void stringsink_init(stringsink *sink) {
upb_byteshandler_init(&sink->handler);
upb_byteshandler_setstartstr(&sink->handler, stringsink_start, NULL);
upb_byteshandler_setstring(&sink->handler, stringsink_string, NULL);
upb_bytessink_reset(&sink->sink, &sink->handler, sink);
sink->size = 32;
sink->ptr = malloc(sink->size);
sink->len = 0;
}
void stringsink_uninit(stringsink *sink) {
free(sink->ptr);
}
/* msgvisitor *****************************************************************/
// TODO: If/when we support proto2 semantics in addition to the current proto3
// semantics, which means that we have true field presence, we will want to
// modify msgvisitor so that it emits all present fields rather than all
// non-default-value fields.
//
// Likewise, when implementing JSON serialization, we may need to have a
// 'verbose' mode that outputs all fields and a 'concise' mode that outputs only
// those with non-default values.
static void putmsg(VALUE msg, const Descriptor* desc,
upb_sink *sink, int depth);
static upb_selector_t getsel(const upb_fielddef *f, upb_handlertype_t type) {
upb_selector_t ret;
bool ok = upb_handlers_getselector(f, type, &ret);
UPB_ASSERT(ok);
return ret;
}
static void putstr(VALUE str, const upb_fielddef *f, upb_sink *sink) {
upb_sink subsink;
if (str == Qnil) return;
assert(BUILTIN_TYPE(str) == RUBY_T_STRING);
// We should be guaranteed that the string has the correct encoding because
// we ensured this at assignment time and then froze the string.
if (upb_fielddef_type(f) == UPB_TYPE_STRING) {
assert(rb_enc_from_index(ENCODING_GET(str)) == kRubyStringUtf8Encoding);
} else {
assert(rb_enc_from_index(ENCODING_GET(str)) == kRubyString8bitEncoding);
}
upb_sink_startstr(sink, getsel(f, UPB_HANDLER_STARTSTR), RSTRING_LEN(str),
&subsink);
upb_sink_putstring(&subsink, getsel(f, UPB_HANDLER_STRING), RSTRING_PTR(str),
RSTRING_LEN(str), NULL);
upb_sink_endstr(sink, getsel(f, UPB_HANDLER_ENDSTR));
}
static void putsubmsg(VALUE submsg, const upb_fielddef *f, upb_sink *sink,
int depth) {
upb_sink subsink;
VALUE descriptor;
Descriptor* subdesc;
if (submsg == Qnil) return;
descriptor = rb_ivar_get(submsg, descriptor_instancevar_interned);
subdesc = ruby_to_Descriptor(descriptor);
upb_sink_startsubmsg(sink, getsel(f, UPB_HANDLER_STARTSUBMSG), &subsink);
putmsg(submsg, subdesc, &subsink, depth + 1);
upb_sink_endsubmsg(sink, getsel(f, UPB_HANDLER_ENDSUBMSG));
}
static void putary(VALUE ary, const upb_fielddef *f, upb_sink *sink,
int depth) {
upb_sink subsink;
upb_fieldtype_t type = upb_fielddef_type(f);
upb_selector_t sel = 0;
int size;
if (ary == Qnil) return;
upb_sink_startseq(sink, getsel(f, UPB_HANDLER_STARTSEQ), &subsink);
if (upb_fielddef_isprimitive(f)) {
sel = getsel(f, upb_handlers_getprimitivehandlertype(f));
}
size = NUM2INT(RepeatedField_length(ary));
for (int i = 0; i < size; i++) {
void* memory = RepeatedField_index_native(ary, i);
switch (type) {
#define T(upbtypeconst, upbtype, ctype) \
case upbtypeconst: \
upb_sink_put##upbtype(&subsink, sel, *((ctype *)memory)); \
break;
T(UPB_TYPE_FLOAT, float, float)
T(UPB_TYPE_DOUBLE, double, double)
T(UPB_TYPE_BOOL, bool, int8_t)
case UPB_TYPE_ENUM:
T(UPB_TYPE_INT32, int32, int32_t)
T(UPB_TYPE_UINT32, uint32, uint32_t)
T(UPB_TYPE_INT64, int64, int64_t)
T(UPB_TYPE_UINT64, uint64, uint64_t)
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES:
putstr(*((VALUE *)memory), f, &subsink);
break;
case UPB_TYPE_MESSAGE:
putsubmsg(*((VALUE *)memory), f, &subsink, depth);
break;
#undef T
}
}
upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
}
static void put_ruby_value(VALUE value,
const upb_fielddef *f,
VALUE type_class,
int depth,
upb_sink *sink) {
upb_selector_t sel = 0;
if (upb_fielddef_isprimitive(f)) {
sel = getsel(f, upb_handlers_getprimitivehandlertype(f));
}
switch (upb_fielddef_type(f)) {
case UPB_TYPE_INT32:
upb_sink_putint32(sink, sel, NUM2INT(value));
break;
case UPB_TYPE_INT64:
upb_sink_putint64(sink, sel, NUM2LL(value));
break;
case UPB_TYPE_UINT32:
upb_sink_putuint32(sink, sel, NUM2UINT(value));
break;
case UPB_TYPE_UINT64:
upb_sink_putuint64(sink, sel, NUM2ULL(value));
break;
case UPB_TYPE_FLOAT:
upb_sink_putfloat(sink, sel, NUM2DBL(value));
break;
case UPB_TYPE_DOUBLE:
upb_sink_putdouble(sink, sel, NUM2DBL(value));
break;
case UPB_TYPE_ENUM: {
if (TYPE(value) == T_SYMBOL) {
value = rb_funcall(type_class, rb_intern("resolve"), 1, value);
}
upb_sink_putint32(sink, sel, NUM2INT(value));
break;
}
case UPB_TYPE_BOOL:
upb_sink_putbool(sink, sel, value == Qtrue);
break;
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES:
putstr(value, f, sink);
break;
case UPB_TYPE_MESSAGE:
putsubmsg(value, f, sink, depth);
}
}
static void putmap(VALUE map, const upb_fielddef *f, upb_sink *sink,
int depth) {
Map* self;
upb_sink subsink;
const upb_fielddef* key_field;
const upb_fielddef* value_field;
Map_iter it;
if (map == Qnil) return;
self = ruby_to_Map(map);
upb_sink_startseq(sink, getsel(f, UPB_HANDLER_STARTSEQ), &subsink);
assert(upb_fielddef_type(f) == UPB_TYPE_MESSAGE);
key_field = map_field_key(f);
value_field = map_field_value(f);
for (Map_begin(map, &it); !Map_done(&it); Map_next(&it)) {
VALUE key = Map_iter_key(&it);
VALUE value = Map_iter_value(&it);
upb_status status;
upb_sink entry_sink;
upb_sink_startsubmsg(&subsink, getsel(f, UPB_HANDLER_STARTSUBMSG),
&entry_sink);
upb_sink_startmsg(&entry_sink);
put_ruby_value(key, key_field, Qnil, depth + 1, &entry_sink);
put_ruby_value(value, value_field, self->value_type_class, depth + 1,
&entry_sink);
upb_sink_endmsg(&entry_sink, &status);
upb_sink_endsubmsg(&subsink, getsel(f, UPB_HANDLER_ENDSUBMSG));
}
upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
}
static void putmsg(VALUE msg_rb, const Descriptor* desc,
upb_sink *sink, int depth) {
MessageHeader* msg;
upb_msg_field_iter i;
upb_status status;
upb_sink_startmsg(sink);
// Protect against cycles (possible because users may freely reassign message
// and repeated fields) by imposing a maximum recursion depth.
if (depth > ENCODE_MAX_NESTING) {
rb_raise(rb_eRuntimeError,
"Maximum recursion depth exceeded during encoding.");
}
TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
for (upb_msg_field_begin(&i, desc->msgdef);
!upb_msg_field_done(&i);
upb_msg_field_next(&i)) {
upb_fielddef *f = upb_msg_iter_field(&i);
bool is_matching_oneof = false;
uint32_t offset =
desc->layout->fields[upb_fielddef_index(f)].offset +
sizeof(MessageHeader);
if (upb_fielddef_containingoneof(f)) {
uint32_t oneof_case_offset =
desc->layout->fields[upb_fielddef_index(f)].case_offset +
sizeof(MessageHeader);
// For a oneof, check that this field is actually present -- skip all the
// below if not.
if (DEREF(msg, oneof_case_offset, uint32_t) !=
upb_fielddef_number(f)) {
continue;
}
// Otherwise, fall through to the appropriate singular-field handler
// below.
is_matching_oneof = true;
}
if (is_map_field(f)) {
VALUE map = DEREF(msg, offset, VALUE);
if (map != Qnil) {
putmap(map, f, sink, depth);
}
} else if (upb_fielddef_isseq(f)) {
VALUE ary = DEREF(msg, offset, VALUE);
if (ary != Qnil) {
putary(ary, f, sink, depth);
}
} else if (upb_fielddef_isstring(f)) {
VALUE str = DEREF(msg, offset, VALUE);
if (is_matching_oneof || RSTRING_LEN(str) > 0) {
putstr(str, f, sink);
}
} else if (upb_fielddef_issubmsg(f)) {
putsubmsg(DEREF(msg, offset, VALUE), f, sink, depth);
} else {
upb_selector_t sel = getsel(f, upb_handlers_getprimitivehandlertype(f));
#define T(upbtypeconst, upbtype, ctype, default_value) \
case upbtypeconst: { \
ctype value = DEREF(msg, offset, ctype); \
if (is_matching_oneof || value != default_value) { \
upb_sink_put##upbtype(sink, sel, value); \
} \
} \
break;
switch (upb_fielddef_type(f)) {
T(UPB_TYPE_FLOAT, float, float, 0.0)
T(UPB_TYPE_DOUBLE, double, double, 0.0)
T(UPB_TYPE_BOOL, bool, uint8_t, 0)
case UPB_TYPE_ENUM:
T(UPB_TYPE_INT32, int32, int32_t, 0)
T(UPB_TYPE_UINT32, uint32, uint32_t, 0)
T(UPB_TYPE_INT64, int64, int64_t, 0)
T(UPB_TYPE_UINT64, uint64, uint64_t, 0)
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES:
case UPB_TYPE_MESSAGE: rb_raise(rb_eRuntimeError, "Internal error.");
}
#undef T
}
}
upb_sink_endmsg(sink, &status);
}
static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
if (desc->pb_serialize_handlers == NULL) {
desc->pb_serialize_handlers =
upb_pb_encoder_newhandlers(desc->msgdef, &desc->pb_serialize_handlers);
}
return desc->pb_serialize_handlers;
}
static const upb_handlers* msgdef_json_serialize_handlers(
Descriptor* desc, bool preserve_proto_fieldnames) {
if (preserve_proto_fieldnames) {
if (desc->json_serialize_handlers == NULL) {
desc->json_serialize_handlers =
upb_json_printer_newhandlers(
desc->msgdef, true, &desc->json_serialize_handlers);
}
return desc->json_serialize_handlers;
} else {
if (desc->json_serialize_handlers_preserve == NULL) {
desc->json_serialize_handlers_preserve =
upb_json_printer_newhandlers(
desc->msgdef, false, &desc->json_serialize_handlers_preserve);
}
return desc->json_serialize_handlers_preserve;
}
}
/*
* call-seq:
* MessageClass.encode(msg) => bytes
*
* Encodes the given message object to its serialized form in protocol buffers
* wire format.
*/
VALUE Message_encode(VALUE klass, VALUE msg_rb) {
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
Descriptor* desc = ruby_to_Descriptor(descriptor);
stringsink sink;
stringsink_init(&sink);
{
const upb_handlers* serialize_handlers =
msgdef_pb_serialize_handlers(desc);
stackenv se;
upb_pb_encoder* encoder;
VALUE ret;
stackenv_init(&se, "Error occurred during encoding: %s");
encoder = upb_pb_encoder_create(&se.env, serialize_handlers, &sink.sink);
putmsg(msg_rb, desc, upb_pb_encoder_input(encoder), 0);
ret = rb_str_new(sink.ptr, sink.len);
stackenv_uninit(&se);
stringsink_uninit(&sink);
return ret;
}
}
/*
* call-seq:
* MessageClass.encode_json(msg) => json_string
*
* Encodes the given message object into its serialized JSON representation.
*/
VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
Descriptor* desc = ruby_to_Descriptor(descriptor);
VALUE msg_rb;
VALUE preserve_proto_fieldnames = Qfalse;
stringsink sink;
if (argc < 1 || argc > 2) {
rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
}
msg_rb = argv[0];
if (argc == 2) {
VALUE hash_args = argv[1];
if (TYPE(hash_args) != T_HASH) {
rb_raise(rb_eArgError, "Expected hash arguments.");
}
preserve_proto_fieldnames = rb_hash_lookup2(
hash_args, ID2SYM(rb_intern("preserve_proto_fieldnames")), Qfalse);
}
stringsink_init(&sink);
{
const upb_handlers* serialize_handlers =
msgdef_json_serialize_handlers(desc, RTEST(preserve_proto_fieldnames));
upb_json_printer* printer;
stackenv se;
VALUE ret;
stackenv_init(&se, "Error occurred during encoding: %s");
printer = upb_json_printer_create(&se.env, serialize_handlers, &sink.sink);
putmsg(msg_rb, desc, upb_json_printer_input(printer), 0);
ret = rb_enc_str_new(sink.ptr, sink.len, rb_utf8_encoding());
stackenv_uninit(&se);
stringsink_uninit(&sink);
return ret;
}
}
|
e91e836ab285df48454fd378b84c2fcce78e0930
|
fa7ba9dc69c3d1c47f2caab8b6012c4003eff852
|
/source/htslib/cram/cram.h
|
0b8b2916ddefd91c97176a7450c79e384c9c3444
|
[
"MIT"
] |
permissive
|
alexdobin/STAR
|
22d6c771b6346b8ec19f89751f21a56fd42549df
|
79affaae7d5e70221287762eab4e40679fad87f7
|
refs/heads/master
| 2023-08-23T07:32:52.945974
| 2023-08-15T19:21:58
| 2023-08-15T19:21:58
| 17,778,869
| 1,686
| 594
|
MIT
| 2023-08-16T15:49:57
| 2014-03-15T15:47:05
|
C
|
UTF-8
|
C
| false
| false
| 2,304
|
h
|
cram.h
|
/*
Copyright (c) 2012-2013 Genome Research Ltd.
Author: James Bonfield <jkb@sanger.ac.uk>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the names Genome Research Ltd and Wellcome Trust Sanger
Institute nor the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH LTD OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* CRAM interface.
*
* Consider using the higher level scram_*() API for programs that wish to
* be file format agnostic.
*
* This API should be used for CRAM specific code. The specifics of the
* public API are implemented in cram_io.h, cram_encode.h and cram_decode.h
* although these should not be included directly (use this file instead).
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifdef SAMTOOLS
# include "cram/cram_samtools.h"
#endif
#ifndef _CRAM_H_
#define _CRAM_H_
#include "cram/sam_header.h"
#include "cram_structs.h"
#include "cram_io.h"
#include "cram_encode.h"
#include "cram_decode.h"
#include "cram_stats.h"
#include "cram_codecs.h"
#include "cram_index.h"
#endif
#ifdef __cplusplus
}
#endif
|
1d37b9ae8d51c18245e8be53fce615bd3451e0b7
|
8838eb997879add5759b6dfb23f9a646464e53ca
|
/src/drivers/gpio/dwapb/dwapb_gpio.c
|
94b201aec111aa693e3508b19dbfb223e4fbc72d
|
[
"BSD-2-Clause"
] |
permissive
|
embox/embox
|
d6aacec876978522f01cdc4b8de37a668c6f4c80
|
98e3c06e33f3fdac10a29c069c20775568e0a6d1
|
refs/heads/master
| 2023-09-04T03:02:20.165042
| 2023-09-02T14:55:31
| 2023-09-02T14:55:31
| 33,078,138
| 1,087
| 325
|
BSD-2-Clause
| 2023-09-14T16:58:34
| 2015-03-29T15:27:48
|
C
|
UTF-8
|
C
| false
| false
| 2,258
|
c
|
dwapb_gpio.c
|
/**
* @file
*
* @date 20.01.2017
* @author Anton Bondarev
*/
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <assert.h>
#include <sys/mman.h>
#include <util/log.h>
#include <embox/unit.h>
#include <hal/reg.h>
#include <drivers/common/memory.h>
#include <drivers/gpio/gpio_driver.h>
#include <framework/mod/options.h>
#define GPIO_CHIP_ID OPTION_GET(NUMBER,gpio_chip_id)
#define BASE_CTRL_ADDR(i) \
((uintptr_t) OPTION_GET(NUMBER,base_addr) + (i) * 0x1000)
#define DWAPB_GPIO_PORTS_COUNT OPTION_GET(NUMBER,gpio_ports)
EMBOX_UNIT_INIT(dwapb_gpio_init);
struct gpio_dwapb_port {
uint32_t dr; /* data */
uint32_t ddr; /* direction */
uint32_t ctl;
};
static int dwapb_gpio_setup_mode(unsigned char port, gpio_mask_t mask, int mode) {
struct gpio_dwapb_port *gpio_port;
uint32_t direction;
uint32_t ctl;
gpio_port = (struct gpio_dwapb_port *) BASE_CTRL_ADDR(port);
log_debug("port %d mask 0x%X mode %d", port, mask, mode);
ctl = REG32_LOAD(&gpio_port->ctl);
ctl &= ~mask;
REG32_STORE(&gpio_port->ctl, ctl); /* all hardware pins */
switch (mode) {
case GPIO_MODE_OUT:
break;
default:
log_error("wrong gpio mode");
return -EINVAL;
}
direction = REG32_LOAD(&gpio_port->ddr);
REG32_STORE(&gpio_port->ddr, direction | mask);
return 0;
}
static void dwapb_gpio_set(unsigned char port, gpio_mask_t mask, char level) {
struct gpio_dwapb_port *gpio_port;
uint32_t dr;
gpio_port = (struct gpio_dwapb_port *) BASE_CTRL_ADDR(port);
dr = REG32_LOAD(&gpio_port->dr);
if (level) {
dr |= mask;
} else {
dr &= ~mask;
}
log_debug("%d mask 0x%X mode %d", port, mask, level);
REG32_STORE(&gpio_port->dr, dr);
}
static gpio_mask_t dwapb_gpio_get(unsigned char port, gpio_mask_t mask) {
struct gpio_dwapb_port *gpio_port;
uint32_t dr;
gpio_port = (struct gpio_dwapb_port *) BASE_CTRL_ADDR(port);
dr = REG32_LOAD(&gpio_port->dr);
return dr & mask;
}
static struct gpio_chip dwapb_gpio_chip = {
.setup_mode = dwapb_gpio_setup_mode,
.get = dwapb_gpio_get,
.set = dwapb_gpio_set,
.nports = DWAPB_GPIO_PORTS_COUNT
};
static int dwapb_gpio_init(void) {
return gpio_register_chip(&dwapb_gpio_chip, GPIO_CHIP_ID);
}
PERIPH_MEMORY_DEFINE(arasan, BASE_CTRL_ADDR(0), 0x1000 * DWAPB_GPIO_PORTS_COUNT);
|
15af22cad79e999e977607efa72d69bdc00ec08b
|
9b5791d17168c9c8fd049bf78d8a4d8c7db4aa35
|
/src/ks_tables.h
|
c96afad37ad810755218ad78eb048995c9ff1122
|
[
"LicenseRef-scancode-warranty-disclaimer",
"MIT",
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-mit-old-style",
"HPND",
"HPND-sell-variant",
"LicenseRef-scancode-xfree86-1.0"
] |
permissive
|
xkbcommon/libxkbcommon
|
b6c53ed15e3fb545dfea99ffd9c0605114579672
|
c1b6c79abab77185fe52f4117c18377fe0e72a5d
|
refs/heads/master
| 2023-09-03T08:10:32.420701
| 2023-07-31T19:35:16
| 2023-08-05T19:29:56
| 9,152,006
| 212
| 127
|
NOASSERTION
| 2023-08-05T19:29:57
| 2013-04-01T17:31:10
|
C
|
UTF-8
|
C
| false
| false
| 299,138
|
h
|
ks_tables.h
|
/**
* This file comes from libxkbcommon and was generated by makekeys.py
* You can always fetch the latest version from:
* https://raw.github.com/xkbcommon/libxkbcommon/master/src/ks_tables.h
*/
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverlength-strings"
#endif
static const char *keysym_names =
"0\0"
"1\0"
"2\0"
"3\0"
"3270_AltCursor\0"
"3270_Attn\0"
"3270_BackTab\0"
"3270_ChangeScreen\0"
"3270_Copy\0"
"3270_CursorBlink\0"
"3270_CursorSelect\0"
"3270_DeleteWord\0"
"3270_Duplicate\0"
"3270_Enter\0"
"3270_EraseEOF\0"
"3270_EraseInput\0"
"3270_ExSelect\0"
"3270_FieldMark\0"
"3270_Ident\0"
"3270_Jump\0"
"3270_KeyClick\0"
"3270_Left2\0"
"3270_PA1\0"
"3270_PA2\0"
"3270_PA3\0"
"3270_Play\0"
"3270_PrintScreen\0"
"3270_Quit\0"
"3270_Record\0"
"3270_Reset\0"
"3270_Right2\0"
"3270_Rule\0"
"3270_Setup\0"
"3270_Test\0"
"4\0"
"5\0"
"6\0"
"7\0"
"8\0"
"9\0"
"A\0"
"a\0"
"Aacute\0"
"aacute\0"
"Abelowdot\0"
"abelowdot\0"
"abovedot\0"
"Abreve\0"
"abreve\0"
"Abreveacute\0"
"abreveacute\0"
"Abrevebelowdot\0"
"abrevebelowdot\0"
"Abrevegrave\0"
"abrevegrave\0"
"Abrevehook\0"
"abrevehook\0"
"Abrevetilde\0"
"abrevetilde\0"
"AccessX_Enable\0"
"AccessX_Feedback_Enable\0"
"Acircumflex\0"
"acircumflex\0"
"Acircumflexacute\0"
"acircumflexacute\0"
"Acircumflexbelowdot\0"
"acircumflexbelowdot\0"
"Acircumflexgrave\0"
"acircumflexgrave\0"
"Acircumflexhook\0"
"acircumflexhook\0"
"Acircumflextilde\0"
"acircumflextilde\0"
"acute\0"
"Adiaeresis\0"
"adiaeresis\0"
"AE\0"
"ae\0"
"Agrave\0"
"agrave\0"
"Ahook\0"
"ahook\0"
"Alt_L\0"
"Alt_R\0"
"Amacron\0"
"amacron\0"
"ampersand\0"
"Aogonek\0"
"aogonek\0"
"apostrophe\0"
"approxeq\0"
"approximate\0"
"Arabic_0\0"
"Arabic_1\0"
"Arabic_2\0"
"Arabic_3\0"
"Arabic_4\0"
"Arabic_5\0"
"Arabic_6\0"
"Arabic_7\0"
"Arabic_8\0"
"Arabic_9\0"
"Arabic_ain\0"
"Arabic_alef\0"
"Arabic_alefmaksura\0"
"Arabic_beh\0"
"Arabic_comma\0"
"Arabic_dad\0"
"Arabic_dal\0"
"Arabic_damma\0"
"Arabic_dammatan\0"
"Arabic_ddal\0"
"Arabic_farsi_yeh\0"
"Arabic_fatha\0"
"Arabic_fathatan\0"
"Arabic_feh\0"
"Arabic_fullstop\0"
"Arabic_gaf\0"
"Arabic_ghain\0"
"Arabic_ha\0"
"Arabic_hah\0"
"Arabic_hamza\0"
"Arabic_hamza_above\0"
"Arabic_hamza_below\0"
"Arabic_hamzaonalef\0"
"Arabic_hamzaonwaw\0"
"Arabic_hamzaonyeh\0"
"Arabic_hamzaunderalef\0"
"Arabic_heh\0"
"Arabic_heh_doachashmee\0"
"Arabic_heh_goal\0"
"Arabic_jeem\0"
"Arabic_jeh\0"
"Arabic_kaf\0"
"Arabic_kasra\0"
"Arabic_kasratan\0"
"Arabic_keheh\0"
"Arabic_khah\0"
"Arabic_lam\0"
"Arabic_madda_above\0"
"Arabic_maddaonalef\0"
"Arabic_meem\0"
"Arabic_noon\0"
"Arabic_noon_ghunna\0"
"Arabic_peh\0"
"Arabic_percent\0"
"Arabic_qaf\0"
"Arabic_question_mark\0"
"Arabic_ra\0"
"Arabic_rreh\0"
"Arabic_sad\0"
"Arabic_seen\0"
"Arabic_semicolon\0"
"Arabic_shadda\0"
"Arabic_sheen\0"
"Arabic_sukun\0"
"Arabic_superscript_alef\0"
"Arabic_switch\0"
"Arabic_tah\0"
"Arabic_tatweel\0"
"Arabic_tcheh\0"
"Arabic_teh\0"
"Arabic_tehmarbuta\0"
"Arabic_thal\0"
"Arabic_theh\0"
"Arabic_tteh\0"
"Arabic_veh\0"
"Arabic_waw\0"
"Arabic_yeh\0"
"Arabic_yeh_baree\0"
"Arabic_zah\0"
"Arabic_zain\0"
"Aring\0"
"aring\0"
"Armenian_accent\0"
"Armenian_amanak\0"
"Armenian_apostrophe\0"
"Armenian_AT\0"
"Armenian_at\0"
"Armenian_AYB\0"
"Armenian_ayb\0"
"Armenian_BEN\0"
"Armenian_ben\0"
"Armenian_but\0"
"Armenian_CHA\0"
"Armenian_cha\0"
"Armenian_DA\0"
"Armenian_da\0"
"Armenian_DZA\0"
"Armenian_dza\0"
"Armenian_E\0"
"Armenian_e\0"
"Armenian_exclam\0"
"Armenian_FE\0"
"Armenian_fe\0"
"Armenian_full_stop\0"
"Armenian_GHAT\0"
"Armenian_ghat\0"
"Armenian_GIM\0"
"Armenian_gim\0"
"Armenian_HI\0"
"Armenian_hi\0"
"Armenian_HO\0"
"Armenian_ho\0"
"Armenian_hyphen\0"
"Armenian_INI\0"
"Armenian_ini\0"
"Armenian_JE\0"
"Armenian_je\0"
"Armenian_KE\0"
"Armenian_ke\0"
"Armenian_KEN\0"
"Armenian_ken\0"
"Armenian_KHE\0"
"Armenian_khe\0"
"Armenian_ligature_ew\0"
"Armenian_LYUN\0"
"Armenian_lyun\0"
"Armenian_MEN\0"
"Armenian_men\0"
"Armenian_NU\0"
"Armenian_nu\0"
"Armenian_O\0"
"Armenian_o\0"
"Armenian_paruyk\0"
"Armenian_PE\0"
"Armenian_pe\0"
"Armenian_PYUR\0"
"Armenian_pyur\0"
"Armenian_question\0"
"Armenian_RA\0"
"Armenian_ra\0"
"Armenian_RE\0"
"Armenian_re\0"
"Armenian_SE\0"
"Armenian_se\0"
"Armenian_separation_mark\0"
"Armenian_SHA\0"
"Armenian_sha\0"
"Armenian_shesht\0"
"Armenian_TCHE\0"
"Armenian_tche\0"
"Armenian_TO\0"
"Armenian_to\0"
"Armenian_TSA\0"
"Armenian_tsa\0"
"Armenian_TSO\0"
"Armenian_tso\0"
"Armenian_TYUN\0"
"Armenian_tyun\0"
"Armenian_verjaket\0"
"Armenian_VEV\0"
"Armenian_vev\0"
"Armenian_VO\0"
"Armenian_vo\0"
"Armenian_VYUN\0"
"Armenian_vyun\0"
"Armenian_YECH\0"
"Armenian_yech\0"
"Armenian_yentamna\0"
"Armenian_ZA\0"
"Armenian_za\0"
"Armenian_ZHE\0"
"Armenian_zhe\0"
"asciicircum\0"
"asciitilde\0"
"asterisk\0"
"at\0"
"Atilde\0"
"atilde\0"
"AudibleBell_Enable\0"
"B\0"
"b\0"
"Babovedot\0"
"babovedot\0"
"backslash\0"
"BackSpace\0"
"BackTab\0"
"ballotcross\0"
"bar\0"
"because\0"
"Begin\0"
"blank\0"
"block\0"
"botintegral\0"
"botleftparens\0"
"botleftsqbracket\0"
"botleftsummation\0"
"botrightparens\0"
"botrightsqbracket\0"
"botrightsummation\0"
"bott\0"
"botvertsummationconnector\0"
"BounceKeys_Enable\0"
"braceleft\0"
"braceright\0"
"bracketleft\0"
"bracketright\0"
"braille_blank\0"
"braille_dot_1\0"
"braille_dot_10\0"
"braille_dot_2\0"
"braille_dot_3\0"
"braille_dot_4\0"
"braille_dot_5\0"
"braille_dot_6\0"
"braille_dot_7\0"
"braille_dot_8\0"
"braille_dot_9\0"
"braille_dots_1\0"
"braille_dots_12\0"
"braille_dots_123\0"
"braille_dots_1234\0"
"braille_dots_12345\0"
"braille_dots_123456\0"
"braille_dots_1234567\0"
"braille_dots_12345678\0"
"braille_dots_1234568\0"
"braille_dots_123457\0"
"braille_dots_1234578\0"
"braille_dots_123458\0"
"braille_dots_12346\0"
"braille_dots_123467\0"
"braille_dots_1234678\0"
"braille_dots_123468\0"
"braille_dots_12347\0"
"braille_dots_123478\0"
"braille_dots_12348\0"
"braille_dots_1235\0"
"braille_dots_12356\0"
"braille_dots_123567\0"
"braille_dots_1235678\0"
"braille_dots_123568\0"
"braille_dots_12357\0"
"braille_dots_123578\0"
"braille_dots_12358\0"
"braille_dots_1236\0"
"braille_dots_12367\0"
"braille_dots_123678\0"
"braille_dots_12368\0"
"braille_dots_1237\0"
"braille_dots_12378\0"
"braille_dots_1238\0"
"braille_dots_124\0"
"braille_dots_1245\0"
"braille_dots_12456\0"
"braille_dots_124567\0"
"braille_dots_1245678\0"
"braille_dots_124568\0"
"braille_dots_12457\0"
"braille_dots_124578\0"
"braille_dots_12458\0"
"braille_dots_1246\0"
"braille_dots_12467\0"
"braille_dots_124678\0"
"braille_dots_12468\0"
"braille_dots_1247\0"
"braille_dots_12478\0"
"braille_dots_1248\0"
"braille_dots_125\0"
"braille_dots_1256\0"
"braille_dots_12567\0"
"braille_dots_125678\0"
"braille_dots_12568\0"
"braille_dots_1257\0"
"braille_dots_12578\0"
"braille_dots_1258\0"
"braille_dots_126\0"
"braille_dots_1267\0"
"braille_dots_12678\0"
"braille_dots_1268\0"
"braille_dots_127\0"
"braille_dots_1278\0"
"braille_dots_128\0"
"braille_dots_13\0"
"braille_dots_134\0"
"braille_dots_1345\0"
"braille_dots_13456\0"
"braille_dots_134567\0"
"braille_dots_1345678\0"
"braille_dots_134568\0"
"braille_dots_13457\0"
"braille_dots_134578\0"
"braille_dots_13458\0"
"braille_dots_1346\0"
"braille_dots_13467\0"
"braille_dots_134678\0"
"braille_dots_13468\0"
"braille_dots_1347\0"
"braille_dots_13478\0"
"braille_dots_1348\0"
"braille_dots_135\0"
"braille_dots_1356\0"
"braille_dots_13567\0"
"braille_dots_135678\0"
"braille_dots_13568\0"
"braille_dots_1357\0"
"braille_dots_13578\0"
"braille_dots_1358\0"
"braille_dots_136\0"
"braille_dots_1367\0"
"braille_dots_13678\0"
"braille_dots_1368\0"
"braille_dots_137\0"
"braille_dots_1378\0"
"braille_dots_138\0"
"braille_dots_14\0"
"braille_dots_145\0"
"braille_dots_1456\0"
"braille_dots_14567\0"
"braille_dots_145678\0"
"braille_dots_14568\0"
"braille_dots_1457\0"
"braille_dots_14578\0"
"braille_dots_1458\0"
"braille_dots_146\0"
"braille_dots_1467\0"
"braille_dots_14678\0"
"braille_dots_1468\0"
"braille_dots_147\0"
"braille_dots_1478\0"
"braille_dots_148\0"
"braille_dots_15\0"
"braille_dots_156\0"
"braille_dots_1567\0"
"braille_dots_15678\0"
"braille_dots_1568\0"
"braille_dots_157\0"
"braille_dots_1578\0"
"braille_dots_158\0"
"braille_dots_16\0"
"braille_dots_167\0"
"braille_dots_1678\0"
"braille_dots_168\0"
"braille_dots_17\0"
"braille_dots_178\0"
"braille_dots_18\0"
"braille_dots_2\0"
"braille_dots_23\0"
"braille_dots_234\0"
"braille_dots_2345\0"
"braille_dots_23456\0"
"braille_dots_234567\0"
"braille_dots_2345678\0"
"braille_dots_234568\0"
"braille_dots_23457\0"
"braille_dots_234578\0"
"braille_dots_23458\0"
"braille_dots_2346\0"
"braille_dots_23467\0"
"braille_dots_234678\0"
"braille_dots_23468\0"
"braille_dots_2347\0"
"braille_dots_23478\0"
"braille_dots_2348\0"
"braille_dots_235\0"
"braille_dots_2356\0"
"braille_dots_23567\0"
"braille_dots_235678\0"
"braille_dots_23568\0"
"braille_dots_2357\0"
"braille_dots_23578\0"
"braille_dots_2358\0"
"braille_dots_236\0"
"braille_dots_2367\0"
"braille_dots_23678\0"
"braille_dots_2368\0"
"braille_dots_237\0"
"braille_dots_2378\0"
"braille_dots_238\0"
"braille_dots_24\0"
"braille_dots_245\0"
"braille_dots_2456\0"
"braille_dots_24567\0"
"braille_dots_245678\0"
"braille_dots_24568\0"
"braille_dots_2457\0"
"braille_dots_24578\0"
"braille_dots_2458\0"
"braille_dots_246\0"
"braille_dots_2467\0"
"braille_dots_24678\0"
"braille_dots_2468\0"
"braille_dots_247\0"
"braille_dots_2478\0"
"braille_dots_248\0"
"braille_dots_25\0"
"braille_dots_256\0"
"braille_dots_2567\0"
"braille_dots_25678\0"
"braille_dots_2568\0"
"braille_dots_257\0"
"braille_dots_2578\0"
"braille_dots_258\0"
"braille_dots_26\0"
"braille_dots_267\0"
"braille_dots_2678\0"
"braille_dots_268\0"
"braille_dots_27\0"
"braille_dots_278\0"
"braille_dots_28\0"
"braille_dots_3\0"
"braille_dots_34\0"
"braille_dots_345\0"
"braille_dots_3456\0"
"braille_dots_34567\0"
"braille_dots_345678\0"
"braille_dots_34568\0"
"braille_dots_3457\0"
"braille_dots_34578\0"
"braille_dots_3458\0"
"braille_dots_346\0"
"braille_dots_3467\0"
"braille_dots_34678\0"
"braille_dots_3468\0"
"braille_dots_347\0"
"braille_dots_3478\0"
"braille_dots_348\0"
"braille_dots_35\0"
"braille_dots_356\0"
"braille_dots_3567\0"
"braille_dots_35678\0"
"braille_dots_3568\0"
"braille_dots_357\0"
"braille_dots_3578\0"
"braille_dots_358\0"
"braille_dots_36\0"
"braille_dots_367\0"
"braille_dots_3678\0"
"braille_dots_368\0"
"braille_dots_37\0"
"braille_dots_378\0"
"braille_dots_38\0"
"braille_dots_4\0"
"braille_dots_45\0"
"braille_dots_456\0"
"braille_dots_4567\0"
"braille_dots_45678\0"
"braille_dots_4568\0"
"braille_dots_457\0"
"braille_dots_4578\0"
"braille_dots_458\0"
"braille_dots_46\0"
"braille_dots_467\0"
"braille_dots_4678\0"
"braille_dots_468\0"
"braille_dots_47\0"
"braille_dots_478\0"
"braille_dots_48\0"
"braille_dots_5\0"
"braille_dots_56\0"
"braille_dots_567\0"
"braille_dots_5678\0"
"braille_dots_568\0"
"braille_dots_57\0"
"braille_dots_578\0"
"braille_dots_58\0"
"braille_dots_6\0"
"braille_dots_67\0"
"braille_dots_678\0"
"braille_dots_68\0"
"braille_dots_7\0"
"braille_dots_78\0"
"braille_dots_8\0"
"Break\0"
"breve\0"
"brokenbar\0"
"Byelorussian_shortu\0"
"Byelorussian_SHORTU\0"
"C\0"
"c\0"
"c_h\0"
"C_h\0"
"C_H\0"
"Cabovedot\0"
"cabovedot\0"
"Cacute\0"
"cacute\0"
"Cancel\0"
"Caps_Lock\0"
"careof\0"
"caret\0"
"caron\0"
"Ccaron\0"
"ccaron\0"
"Ccedilla\0"
"ccedilla\0"
"Ccircumflex\0"
"ccircumflex\0"
"cedilla\0"
"cent\0"
"ch\0"
"Ch\0"
"CH\0"
"checkerboard\0"
"checkmark\0"
"circle\0"
"Clear\0"
"ClearLine\0"
"club\0"
"Codeinput\0"
"colon\0"
"ColonSign\0"
"combining_acute\0"
"combining_belowdot\0"
"combining_grave\0"
"combining_hook\0"
"combining_tilde\0"
"comma\0"
"containsas\0"
"Control_L\0"
"Control_R\0"
"copyright\0"
"cr\0"
"crossinglines\0"
"CruzeiroSign\0"
"cuberoot\0"
"currency\0"
"cursor\0"
"Cyrillic_a\0"
"Cyrillic_A\0"
"Cyrillic_be\0"
"Cyrillic_BE\0"
"Cyrillic_che\0"
"Cyrillic_CHE\0"
"Cyrillic_CHE_descender\0"
"Cyrillic_che_descender\0"
"Cyrillic_CHE_vertstroke\0"
"Cyrillic_che_vertstroke\0"
"Cyrillic_de\0"
"Cyrillic_DE\0"
"Cyrillic_dzhe\0"
"Cyrillic_DZHE\0"
"Cyrillic_e\0"
"Cyrillic_E\0"
"Cyrillic_ef\0"
"Cyrillic_EF\0"
"Cyrillic_el\0"
"Cyrillic_EL\0"
"Cyrillic_em\0"
"Cyrillic_EM\0"
"Cyrillic_en\0"
"Cyrillic_EN\0"
"Cyrillic_EN_descender\0"
"Cyrillic_en_descender\0"
"Cyrillic_er\0"
"Cyrillic_ER\0"
"Cyrillic_es\0"
"Cyrillic_ES\0"
"Cyrillic_ghe\0"
"Cyrillic_GHE\0"
"Cyrillic_GHE_bar\0"
"Cyrillic_ghe_bar\0"
"Cyrillic_ha\0"
"Cyrillic_HA\0"
"Cyrillic_HA_descender\0"
"Cyrillic_ha_descender\0"
"Cyrillic_hardsign\0"
"Cyrillic_HARDSIGN\0"
"Cyrillic_i\0"
"Cyrillic_I\0"
"Cyrillic_I_macron\0"
"Cyrillic_i_macron\0"
"Cyrillic_ie\0"
"Cyrillic_IE\0"
"Cyrillic_io\0"
"Cyrillic_IO\0"
"Cyrillic_je\0"
"Cyrillic_JE\0"
"Cyrillic_ka\0"
"Cyrillic_KA\0"
"Cyrillic_KA_descender\0"
"Cyrillic_ka_descender\0"
"Cyrillic_KA_vertstroke\0"
"Cyrillic_ka_vertstroke\0"
"Cyrillic_lje\0"
"Cyrillic_LJE\0"
"Cyrillic_nje\0"
"Cyrillic_NJE\0"
"Cyrillic_o\0"
"Cyrillic_O\0"
"Cyrillic_O_bar\0"
"Cyrillic_o_bar\0"
"Cyrillic_pe\0"
"Cyrillic_PE\0"
"Cyrillic_SCHWA\0"
"Cyrillic_schwa\0"
"Cyrillic_sha\0"
"Cyrillic_SHA\0"
"Cyrillic_shcha\0"
"Cyrillic_SHCHA\0"
"Cyrillic_SHHA\0"
"Cyrillic_shha\0"
"Cyrillic_shorti\0"
"Cyrillic_SHORTI\0"
"Cyrillic_softsign\0"
"Cyrillic_SOFTSIGN\0"
"Cyrillic_te\0"
"Cyrillic_TE\0"
"Cyrillic_tse\0"
"Cyrillic_TSE\0"
"Cyrillic_u\0"
"Cyrillic_U\0"
"Cyrillic_U_macron\0"
"Cyrillic_u_macron\0"
"Cyrillic_U_straight\0"
"Cyrillic_u_straight\0"
"Cyrillic_U_straight_bar\0"
"Cyrillic_u_straight_bar\0"
"Cyrillic_ve\0"
"Cyrillic_VE\0"
"Cyrillic_ya\0"
"Cyrillic_YA\0"
"Cyrillic_yeru\0"
"Cyrillic_YERU\0"
"Cyrillic_yu\0"
"Cyrillic_YU\0"
"Cyrillic_ze\0"
"Cyrillic_ZE\0"
"Cyrillic_zhe\0"
"Cyrillic_ZHE\0"
"Cyrillic_ZHE_descender\0"
"Cyrillic_zhe_descender\0"
"D\0"
"d\0"
"Dabovedot\0"
"dabovedot\0"
"Dacute_accent\0"
"dagger\0"
"Dcaron\0"
"dcaron\0"
"Dcedilla_accent\0"
"Dcircumflex_accent\0"
"Ddiaeresis\0"
"dead_a\0"
"dead_A\0"
"dead_abovecomma\0"
"dead_abovedot\0"
"dead_abovereversedcomma\0"
"dead_abovering\0"
"dead_aboveverticalline\0"
"dead_acute\0"
"dead_belowbreve\0"
"dead_belowcircumflex\0"
"dead_belowcomma\0"
"dead_belowdiaeresis\0"
"dead_belowdot\0"
"dead_belowmacron\0"
"dead_belowring\0"
"dead_belowtilde\0"
"dead_belowverticalline\0"
"dead_breve\0"
"dead_capital_schwa\0"
"dead_caron\0"
"dead_cedilla\0"
"dead_circumflex\0"
"dead_currency\0"
"dead_dasia\0"
"dead_diaeresis\0"
"dead_doubleacute\0"
"dead_doublegrave\0"
"dead_e\0"
"dead_E\0"
"dead_grave\0"
"dead_greek\0"
"dead_hook\0"
"dead_horn\0"
"dead_i\0"
"dead_I\0"
"dead_invertedbreve\0"
"dead_iota\0"
"dead_longsolidusoverlay\0"
"dead_lowline\0"
"dead_macron\0"
"dead_o\0"
"dead_O\0"
"dead_ogonek\0"
"dead_perispomeni\0"
"dead_psili\0"
"dead_semivoiced_sound\0"
"dead_small_schwa\0"
"dead_stroke\0"
"dead_tilde\0"
"dead_u\0"
"dead_U\0"
"dead_voiced_sound\0"
"decimalpoint\0"
"degree\0"
"Delete\0"
"DeleteChar\0"
"DeleteLine\0"
"Dgrave_accent\0"
"diaeresis\0"
"diamond\0"
"digitspace\0"
"dintegral\0"
"division\0"
"dollar\0"
"DongSign\0"
"doubbaselinedot\0"
"doubleacute\0"
"doubledagger\0"
"doublelowquotemark\0"
"Down\0"
"downarrow\0"
"downcaret\0"
"downshoe\0"
"downstile\0"
"downtack\0"
"DRemove\0"
"Dring_accent\0"
"Dstroke\0"
"dstroke\0"
"Dtilde\0"
"E\0"
"e\0"
"Eabovedot\0"
"eabovedot\0"
"Eacute\0"
"eacute\0"
"Ebelowdot\0"
"ebelowdot\0"
"Ecaron\0"
"ecaron\0"
"Ecircumflex\0"
"ecircumflex\0"
"Ecircumflexacute\0"
"ecircumflexacute\0"
"Ecircumflexbelowdot\0"
"ecircumflexbelowdot\0"
"Ecircumflexgrave\0"
"ecircumflexgrave\0"
"Ecircumflexhook\0"
"ecircumflexhook\0"
"Ecircumflextilde\0"
"ecircumflextilde\0"
"EcuSign\0"
"Ediaeresis\0"
"ediaeresis\0"
"Egrave\0"
"egrave\0"
"Ehook\0"
"ehook\0"
"eightsubscript\0"
"eightsuperior\0"
"Eisu_Shift\0"
"Eisu_toggle\0"
"elementof\0"
"ellipsis\0"
"em3space\0"
"em4space\0"
"Emacron\0"
"emacron\0"
"emdash\0"
"emfilledcircle\0"
"emfilledrect\0"
"emopencircle\0"
"emopenrectangle\0"
"emptyset\0"
"emspace\0"
"End\0"
"endash\0"
"enfilledcircbullet\0"
"enfilledsqbullet\0"
"ENG\0"
"eng\0"
"enopencircbullet\0"
"enopensquarebullet\0"
"enspace\0"
"Eogonek\0"
"eogonek\0"
"equal\0"
"Escape\0"
"ETH\0"
"Eth\0"
"eth\0"
"Etilde\0"
"etilde\0"
"EuroSign\0"
"exclam\0"
"exclamdown\0"
"Execute\0"
"Ext16bit_L\0"
"Ext16bit_R\0"
"EZH\0"
"ezh\0"
"F\0"
"f\0"
"F1\0"
"F10\0"
"F11\0"
"F12\0"
"F13\0"
"F14\0"
"F15\0"
"F16\0"
"F17\0"
"F18\0"
"F19\0"
"F2\0"
"F20\0"
"F21\0"
"F22\0"
"F23\0"
"F24\0"
"F25\0"
"F26\0"
"F27\0"
"F28\0"
"F29\0"
"F3\0"
"F30\0"
"F31\0"
"F32\0"
"F33\0"
"F34\0"
"F35\0"
"F4\0"
"F5\0"
"F6\0"
"F7\0"
"F8\0"
"F9\0"
"Fabovedot\0"
"fabovedot\0"
"Farsi_0\0"
"Farsi_1\0"
"Farsi_2\0"
"Farsi_3\0"
"Farsi_4\0"
"Farsi_5\0"
"Farsi_6\0"
"Farsi_7\0"
"Farsi_8\0"
"Farsi_9\0"
"Farsi_yeh\0"
"femalesymbol\0"
"ff\0"
"FFrancSign\0"
"figdash\0"
"filledlefttribullet\0"
"filledrectbullet\0"
"filledrighttribullet\0"
"filledtribulletdown\0"
"filledtribulletup\0"
"Find\0"
"First_Virtual_Screen\0"
"fiveeighths\0"
"fivesixths\0"
"fivesubscript\0"
"fivesuperior\0"
"fourfifths\0"
"foursubscript\0"
"foursuperior\0"
"fourthroot\0"
"function\0"
"G\0"
"g\0"
"Gabovedot\0"
"gabovedot\0"
"Gbreve\0"
"gbreve\0"
"Gcaron\0"
"gcaron\0"
"Gcedilla\0"
"gcedilla\0"
"Gcircumflex\0"
"gcircumflex\0"
"Georgian_an\0"
"Georgian_ban\0"
"Georgian_can\0"
"Georgian_char\0"
"Georgian_chin\0"
"Georgian_cil\0"
"Georgian_don\0"
"Georgian_en\0"
"Georgian_fi\0"
"Georgian_gan\0"
"Georgian_ghan\0"
"Georgian_hae\0"
"Georgian_har\0"
"Georgian_he\0"
"Georgian_hie\0"
"Georgian_hoe\0"
"Georgian_in\0"
"Georgian_jhan\0"
"Georgian_jil\0"
"Georgian_kan\0"
"Georgian_khar\0"
"Georgian_las\0"
"Georgian_man\0"
"Georgian_nar\0"
"Georgian_on\0"
"Georgian_par\0"
"Georgian_phar\0"
"Georgian_qar\0"
"Georgian_rae\0"
"Georgian_san\0"
"Georgian_shin\0"
"Georgian_tan\0"
"Georgian_tar\0"
"Georgian_un\0"
"Georgian_vin\0"
"Georgian_we\0"
"Georgian_xan\0"
"Georgian_zen\0"
"Georgian_zhar\0"
"grave\0"
"greater\0"
"greaterthanequal\0"
"Greek_accentdieresis\0"
"Greek_ALPHA\0"
"Greek_alpha\0"
"Greek_ALPHAaccent\0"
"Greek_alphaaccent\0"
"Greek_BETA\0"
"Greek_beta\0"
"Greek_CHI\0"
"Greek_chi\0"
"Greek_DELTA\0"
"Greek_delta\0"
"Greek_EPSILON\0"
"Greek_epsilon\0"
"Greek_EPSILONaccent\0"
"Greek_epsilonaccent\0"
"Greek_ETA\0"
"Greek_eta\0"
"Greek_ETAaccent\0"
"Greek_etaaccent\0"
"Greek_finalsmallsigma\0"
"Greek_GAMMA\0"
"Greek_gamma\0"
"Greek_horizbar\0"
"Greek_IOTA\0"
"Greek_iota\0"
"Greek_IOTAaccent\0"
"Greek_iotaaccent\0"
"Greek_iotaaccentdieresis\0"
"Greek_IOTAdiaeresis\0"
"Greek_IOTAdieresis\0"
"Greek_iotadieresis\0"
"Greek_KAPPA\0"
"Greek_kappa\0"
"Greek_LAMBDA\0"
"Greek_lambda\0"
"Greek_LAMDA\0"
"Greek_lamda\0"
"Greek_MU\0"
"Greek_mu\0"
"Greek_NU\0"
"Greek_nu\0"
"Greek_OMEGA\0"
"Greek_omega\0"
"Greek_OMEGAaccent\0"
"Greek_omegaaccent\0"
"Greek_OMICRON\0"
"Greek_omicron\0"
"Greek_OMICRONaccent\0"
"Greek_omicronaccent\0"
"Greek_PHI\0"
"Greek_phi\0"
"Greek_PI\0"
"Greek_pi\0"
"Greek_PSI\0"
"Greek_psi\0"
"Greek_RHO\0"
"Greek_rho\0"
"Greek_SIGMA\0"
"Greek_sigma\0"
"Greek_switch\0"
"Greek_TAU\0"
"Greek_tau\0"
"Greek_THETA\0"
"Greek_theta\0"
"Greek_UPSILON\0"
"Greek_upsilon\0"
"Greek_UPSILONaccent\0"
"Greek_upsilonaccent\0"
"Greek_upsilonaccentdieresis\0"
"Greek_UPSILONdieresis\0"
"Greek_upsilondieresis\0"
"Greek_XI\0"
"Greek_xi\0"
"Greek_ZETA\0"
"Greek_zeta\0"
"guilder\0"
"guillemotleft\0"
"guillemotright\0"
"H\0"
"h\0"
"hairspace\0"
"Hangul\0"
"Hangul_A\0"
"Hangul_AE\0"
"Hangul_AraeA\0"
"Hangul_AraeAE\0"
"Hangul_Banja\0"
"Hangul_Cieuc\0"
"Hangul_Codeinput\0"
"Hangul_Dikeud\0"
"Hangul_E\0"
"Hangul_End\0"
"Hangul_EO\0"
"Hangul_EU\0"
"Hangul_Hanja\0"
"Hangul_Hieuh\0"
"Hangul_I\0"
"Hangul_Ieung\0"
"Hangul_J_Cieuc\0"
"Hangul_J_Dikeud\0"
"Hangul_J_Hieuh\0"
"Hangul_J_Ieung\0"
"Hangul_J_Jieuj\0"
"Hangul_J_Khieuq\0"
"Hangul_J_Kiyeog\0"
"Hangul_J_KiyeogSios\0"
"Hangul_J_KkogjiDalrinIeung\0"
"Hangul_J_Mieum\0"
"Hangul_J_Nieun\0"
"Hangul_J_NieunHieuh\0"
"Hangul_J_NieunJieuj\0"
"Hangul_J_PanSios\0"
"Hangul_J_Phieuf\0"
"Hangul_J_Pieub\0"
"Hangul_J_PieubSios\0"
"Hangul_J_Rieul\0"
"Hangul_J_RieulHieuh\0"
"Hangul_J_RieulKiyeog\0"
"Hangul_J_RieulMieum\0"
"Hangul_J_RieulPhieuf\0"
"Hangul_J_RieulPieub\0"
"Hangul_J_RieulSios\0"
"Hangul_J_RieulTieut\0"
"Hangul_J_Sios\0"
"Hangul_J_SsangKiyeog\0"
"Hangul_J_SsangSios\0"
"Hangul_J_Tieut\0"
"Hangul_J_YeorinHieuh\0"
"Hangul_Jamo\0"
"Hangul_Jeonja\0"
"Hangul_Jieuj\0"
"Hangul_Khieuq\0"
"Hangul_Kiyeog\0"
"Hangul_KiyeogSios\0"
"Hangul_KkogjiDalrinIeung\0"
"Hangul_Mieum\0"
"Hangul_MultipleCandidate\0"
"Hangul_Nieun\0"
"Hangul_NieunHieuh\0"
"Hangul_NieunJieuj\0"
"Hangul_O\0"
"Hangul_OE\0"
"Hangul_PanSios\0"
"Hangul_Phieuf\0"
"Hangul_Pieub\0"
"Hangul_PieubSios\0"
"Hangul_PostHanja\0"
"Hangul_PreHanja\0"
"Hangul_PreviousCandidate\0"
"Hangul_Rieul\0"
"Hangul_RieulHieuh\0"
"Hangul_RieulKiyeog\0"
"Hangul_RieulMieum\0"
"Hangul_RieulPhieuf\0"
"Hangul_RieulPieub\0"
"Hangul_RieulSios\0"
"Hangul_RieulTieut\0"
"Hangul_RieulYeorinHieuh\0"
"Hangul_Romaja\0"
"Hangul_SingleCandidate\0"
"Hangul_Sios\0"
"Hangul_Special\0"
"Hangul_SsangDikeud\0"
"Hangul_SsangJieuj\0"
"Hangul_SsangKiyeog\0"
"Hangul_SsangPieub\0"
"Hangul_SsangSios\0"
"Hangul_Start\0"
"Hangul_SunkyeongeumMieum\0"
"Hangul_SunkyeongeumPhieuf\0"
"Hangul_SunkyeongeumPieub\0"
"Hangul_switch\0"
"Hangul_Tieut\0"
"Hangul_U\0"
"Hangul_WA\0"
"Hangul_WAE\0"
"Hangul_WE\0"
"Hangul_WEO\0"
"Hangul_WI\0"
"Hangul_YA\0"
"Hangul_YAE\0"
"Hangul_YE\0"
"Hangul_YEO\0"
"Hangul_YeorinHieuh\0"
"Hangul_YI\0"
"Hangul_YO\0"
"Hangul_YU\0"
"Hankaku\0"
"Hcircumflex\0"
"hcircumflex\0"
"heart\0"
"hebrew_aleph\0"
"hebrew_ayin\0"
"hebrew_bet\0"
"hebrew_beth\0"
"hebrew_chet\0"
"hebrew_dalet\0"
"hebrew_daleth\0"
"hebrew_doublelowline\0"
"hebrew_finalkaph\0"
"hebrew_finalmem\0"
"hebrew_finalnun\0"
"hebrew_finalpe\0"
"hebrew_finalzade\0"
"hebrew_finalzadi\0"
"hebrew_gimel\0"
"hebrew_gimmel\0"
"hebrew_he\0"
"hebrew_het\0"
"hebrew_kaph\0"
"hebrew_kuf\0"
"hebrew_lamed\0"
"hebrew_mem\0"
"hebrew_nun\0"
"hebrew_pe\0"
"hebrew_qoph\0"
"hebrew_resh\0"
"hebrew_samech\0"
"hebrew_samekh\0"
"hebrew_shin\0"
"Hebrew_switch\0"
"hebrew_taf\0"
"hebrew_taw\0"
"hebrew_tet\0"
"hebrew_teth\0"
"hebrew_waw\0"
"hebrew_yod\0"
"hebrew_zade\0"
"hebrew_zadi\0"
"hebrew_zain\0"
"hebrew_zayin\0"
"Help\0"
"Henkan\0"
"Henkan_Mode\0"
"hexagram\0"
"Hiragana\0"
"Hiragana_Katakana\0"
"Home\0"
"horizconnector\0"
"horizlinescan1\0"
"horizlinescan3\0"
"horizlinescan5\0"
"horizlinescan7\0"
"horizlinescan9\0"
"hpBackTab\0"
"hpblock\0"
"hpClearLine\0"
"hpDeleteChar\0"
"hpDeleteLine\0"
"hpguilder\0"
"hpInsertChar\0"
"hpInsertLine\0"
"hpIO\0"
"hpKP_BackTab\0"
"hplira\0"
"hplongminus\0"
"hpModelock1\0"
"hpModelock2\0"
"hpmute_acute\0"
"hpmute_asciicircum\0"
"hpmute_asciitilde\0"
"hpmute_diaeresis\0"
"hpmute_grave\0"
"hpReset\0"
"hpSystem\0"
"hpUser\0"
"hpYdiaeresis\0"
"Hstroke\0"
"hstroke\0"
"ht\0"
"Hyper_L\0"
"Hyper_R\0"
"hyphen\0"
"I\0"
"i\0"
"Iabovedot\0"
"Iacute\0"
"iacute\0"
"Ibelowdot\0"
"ibelowdot\0"
"Ibreve\0"
"ibreve\0"
"Icircumflex\0"
"icircumflex\0"
"identical\0"
"Idiaeresis\0"
"idiaeresis\0"
"idotless\0"
"ifonlyif\0"
"Igrave\0"
"igrave\0"
"Ihook\0"
"ihook\0"
"Imacron\0"
"imacron\0"
"implies\0"
"includedin\0"
"includes\0"
"infinity\0"
"Insert\0"
"InsertChar\0"
"InsertLine\0"
"integral\0"
"intersection\0"
"IO\0"
"Iogonek\0"
"iogonek\0"
"ISO_Center_Object\0"
"ISO_Continuous_Underline\0"
"ISO_Discontinuous_Underline\0"
"ISO_Emphasize\0"
"ISO_Enter\0"
"ISO_Fast_Cursor_Down\0"
"ISO_Fast_Cursor_Left\0"
"ISO_Fast_Cursor_Right\0"
"ISO_Fast_Cursor_Up\0"
"ISO_First_Group\0"
"ISO_First_Group_Lock\0"
"ISO_Group_Latch\0"
"ISO_Group_Lock\0"
"ISO_Group_Shift\0"
"ISO_Last_Group\0"
"ISO_Last_Group_Lock\0"
"ISO_Left_Tab\0"
"ISO_Level2_Latch\0"
"ISO_Level3_Latch\0"
"ISO_Level3_Lock\0"
"ISO_Level3_Shift\0"
"ISO_Level5_Latch\0"
"ISO_Level5_Lock\0"
"ISO_Level5_Shift\0"
"ISO_Lock\0"
"ISO_Move_Line_Down\0"
"ISO_Move_Line_Up\0"
"ISO_Next_Group\0"
"ISO_Next_Group_Lock\0"
"ISO_Partial_Line_Down\0"
"ISO_Partial_Line_Up\0"
"ISO_Partial_Space_Left\0"
"ISO_Partial_Space_Right\0"
"ISO_Prev_Group\0"
"ISO_Prev_Group_Lock\0"
"ISO_Release_Both_Margins\0"
"ISO_Release_Margin_Left\0"
"ISO_Release_Margin_Right\0"
"ISO_Set_Margin_Left\0"
"ISO_Set_Margin_Right\0"
"Itilde\0"
"itilde\0"
"J\0"
"j\0"
"Jcircumflex\0"
"jcircumflex\0"
"jot\0"
"K\0"
"k\0"
"kana_a\0"
"kana_A\0"
"kana_CHI\0"
"kana_closingbracket\0"
"kana_comma\0"
"kana_conjunctive\0"
"kana_e\0"
"kana_E\0"
"kana_FU\0"
"kana_fullstop\0"
"kana_HA\0"
"kana_HE\0"
"kana_HI\0"
"kana_HO\0"
"kana_HU\0"
"kana_i\0"
"kana_I\0"
"kana_KA\0"
"kana_KE\0"
"kana_KI\0"
"kana_KO\0"
"kana_KU\0"
"Kana_Lock\0"
"kana_MA\0"
"kana_ME\0"
"kana_MI\0"
"kana_middledot\0"
"kana_MO\0"
"kana_MU\0"
"kana_N\0"
"kana_NA\0"
"kana_NE\0"
"kana_NI\0"
"kana_NO\0"
"kana_NU\0"
"kana_o\0"
"kana_O\0"
"kana_openingbracket\0"
"kana_RA\0"
"kana_RE\0"
"kana_RI\0"
"kana_RO\0"
"kana_RU\0"
"kana_SA\0"
"kana_SE\0"
"kana_SHI\0"
"Kana_Shift\0"
"kana_SO\0"
"kana_SU\0"
"kana_switch\0"
"kana_TA\0"
"kana_TE\0"
"kana_TI\0"
"kana_TO\0"
"kana_tsu\0"
"kana_TSU\0"
"kana_tu\0"
"kana_TU\0"
"kana_u\0"
"kana_U\0"
"kana_WA\0"
"kana_WO\0"
"kana_ya\0"
"kana_YA\0"
"kana_yo\0"
"kana_YO\0"
"kana_yu\0"
"kana_YU\0"
"Kanji\0"
"Kanji_Bangou\0"
"kappa\0"
"Katakana\0"
"Kcedilla\0"
"kcedilla\0"
"Korean_Won\0"
"KP_0\0"
"KP_1\0"
"KP_2\0"
"KP_3\0"
"KP_4\0"
"KP_5\0"
"KP_6\0"
"KP_7\0"
"KP_8\0"
"KP_9\0"
"KP_Add\0"
"KP_BackTab\0"
"KP_Begin\0"
"KP_Decimal\0"
"KP_Delete\0"
"KP_Divide\0"
"KP_Down\0"
"KP_End\0"
"KP_Enter\0"
"KP_Equal\0"
"KP_F1\0"
"KP_F2\0"
"KP_F3\0"
"KP_F4\0"
"KP_Home\0"
"KP_Insert\0"
"KP_Left\0"
"KP_Multiply\0"
"KP_Next\0"
"KP_Page_Down\0"
"KP_Page_Up\0"
"KP_Prior\0"
"KP_Right\0"
"KP_Separator\0"
"KP_Space\0"
"KP_Subtract\0"
"KP_Tab\0"
"KP_Up\0"
"kra\0"
"L\0"
"l\0"
"L1\0"
"L10\0"
"L2\0"
"L3\0"
"L4\0"
"L5\0"
"L6\0"
"L7\0"
"L8\0"
"L9\0"
"Lacute\0"
"lacute\0"
"Last_Virtual_Screen\0"
"latincross\0"
"Lbelowdot\0"
"lbelowdot\0"
"Lcaron\0"
"lcaron\0"
"Lcedilla\0"
"lcedilla\0"
"Left\0"
"leftanglebracket\0"
"leftarrow\0"
"leftcaret\0"
"leftdoublequotemark\0"
"leftmiddlecurlybrace\0"
"leftopentriangle\0"
"leftpointer\0"
"leftradical\0"
"leftshoe\0"
"leftsinglequotemark\0"
"leftt\0"
"lefttack\0"
"less\0"
"lessthanequal\0"
"lf\0"
"Linefeed\0"
"lira\0"
"LiraSign\0"
"logicaland\0"
"logicalor\0"
"longminus\0"
"lowleftcorner\0"
"lowrightcorner\0"
"Lstroke\0"
"lstroke\0"
"M\0"
"m\0"
"Mabovedot\0"
"mabovedot\0"
"Macedonia_dse\0"
"Macedonia_DSE\0"
"Macedonia_gje\0"
"Macedonia_GJE\0"
"Macedonia_kje\0"
"Macedonia_KJE\0"
"macron\0"
"Mae_Koho\0"
"malesymbol\0"
"maltesecross\0"
"marker\0"
"masculine\0"
"Massyo\0"
"Menu\0"
"Meta_L\0"
"Meta_R\0"
"MillSign\0"
"minus\0"
"minutes\0"
"Mode_switch\0"
"MouseKeys_Accel_Enable\0"
"MouseKeys_Enable\0"
"mu\0"
"Muhenkan\0"
"Multi_key\0"
"MultipleCandidate\0"
"multiply\0"
"musicalflat\0"
"musicalsharp\0"
"mute_acute\0"
"mute_asciicircum\0"
"mute_asciitilde\0"
"mute_diaeresis\0"
"mute_grave\0"
"N\0"
"n\0"
"nabla\0"
"Nacute\0"
"nacute\0"
"NairaSign\0"
"Ncaron\0"
"ncaron\0"
"Ncedilla\0"
"ncedilla\0"
"NewSheqelSign\0"
"Next\0"
"Next_Virtual_Screen\0"
"ninesubscript\0"
"ninesuperior\0"
"nl\0"
"nobreakspace\0"
"NoSymbol\0"
"notapproxeq\0"
"notelementof\0"
"notequal\0"
"notidentical\0"
"notsign\0"
"Ntilde\0"
"ntilde\0"
"Num_Lock\0"
"numbersign\0"
"numerosign\0"
"O\0"
"o\0"
"Oacute\0"
"oacute\0"
"Obarred\0"
"obarred\0"
"Obelowdot\0"
"obelowdot\0"
"Ocaron\0"
"ocaron\0"
"Ocircumflex\0"
"ocircumflex\0"
"Ocircumflexacute\0"
"ocircumflexacute\0"
"Ocircumflexbelowdot\0"
"ocircumflexbelowdot\0"
"Ocircumflexgrave\0"
"ocircumflexgrave\0"
"Ocircumflexhook\0"
"ocircumflexhook\0"
"Ocircumflextilde\0"
"ocircumflextilde\0"
"Odiaeresis\0"
"odiaeresis\0"
"Odoubleacute\0"
"odoubleacute\0"
"OE\0"
"oe\0"
"ogonek\0"
"Ograve\0"
"ograve\0"
"Ohook\0"
"ohook\0"
"Ohorn\0"
"ohorn\0"
"Ohornacute\0"
"ohornacute\0"
"Ohornbelowdot\0"
"ohornbelowdot\0"
"Ohorngrave\0"
"ohorngrave\0"
"Ohornhook\0"
"ohornhook\0"
"Ohorntilde\0"
"ohorntilde\0"
"Omacron\0"
"omacron\0"
"oneeighth\0"
"onefifth\0"
"onehalf\0"
"onequarter\0"
"onesixth\0"
"onesubscript\0"
"onesuperior\0"
"onethird\0"
"Ooblique\0"
"ooblique\0"
"openrectbullet\0"
"openstar\0"
"opentribulletdown\0"
"opentribulletup\0"
"ordfeminine\0"
"osfActivate\0"
"osfAddMode\0"
"osfBackSpace\0"
"osfBackTab\0"
"osfBeginData\0"
"osfBeginLine\0"
"osfCancel\0"
"osfClear\0"
"osfCopy\0"
"osfCut\0"
"osfDelete\0"
"osfDeselectAll\0"
"osfDown\0"
"osfEndData\0"
"osfEndLine\0"
"osfEscape\0"
"osfExtend\0"
"osfHelp\0"
"osfInsert\0"
"osfLeft\0"
"osfMenu\0"
"osfMenuBar\0"
"osfNextField\0"
"osfNextMenu\0"
"osfPageDown\0"
"osfPageLeft\0"
"osfPageRight\0"
"osfPageUp\0"
"osfPaste\0"
"osfPrevField\0"
"osfPrevMenu\0"
"osfPrimaryPaste\0"
"osfQuickPaste\0"
"osfReselect\0"
"osfRestore\0"
"osfRight\0"
"osfSelect\0"
"osfSelectAll\0"
"osfUndo\0"
"osfUp\0"
"Oslash\0"
"oslash\0"
"Otilde\0"
"otilde\0"
"overbar\0"
"Overlay1_Enable\0"
"Overlay2_Enable\0"
"overline\0"
"P\0"
"p\0"
"Pabovedot\0"
"pabovedot\0"
"Page_Down\0"
"Page_Up\0"
"paragraph\0"
"parenleft\0"
"parenright\0"
"partdifferential\0"
"partialderivative\0"
"Pause\0"
"percent\0"
"period\0"
"periodcentered\0"
"permille\0"
"PesetaSign\0"
"phonographcopyright\0"
"plus\0"
"plusminus\0"
"Pointer_Accelerate\0"
"Pointer_Button1\0"
"Pointer_Button2\0"
"Pointer_Button3\0"
"Pointer_Button4\0"
"Pointer_Button5\0"
"Pointer_Button_Dflt\0"
"Pointer_DblClick1\0"
"Pointer_DblClick2\0"
"Pointer_DblClick3\0"
"Pointer_DblClick4\0"
"Pointer_DblClick5\0"
"Pointer_DblClick_Dflt\0"
"Pointer_DfltBtnNext\0"
"Pointer_DfltBtnPrev\0"
"Pointer_Down\0"
"Pointer_DownLeft\0"
"Pointer_DownRight\0"
"Pointer_Drag1\0"
"Pointer_Drag2\0"
"Pointer_Drag3\0"
"Pointer_Drag4\0"
"Pointer_Drag5\0"
"Pointer_Drag_Dflt\0"
"Pointer_EnableKeys\0"
"Pointer_Left\0"
"Pointer_Right\0"
"Pointer_Up\0"
"Pointer_UpLeft\0"
"Pointer_UpRight\0"
"prescription\0"
"Prev_Virtual_Screen\0"
"PreviousCandidate\0"
"Print\0"
"Prior\0"
"prolongedsound\0"
"punctspace\0"
"Q\0"
"q\0"
"quad\0"
"question\0"
"questiondown\0"
"quotedbl\0"
"quoteleft\0"
"quoteright\0"
"R\0"
"r\0"
"R1\0"
"R10\0"
"R11\0"
"R12\0"
"R13\0"
"R14\0"
"R15\0"
"R2\0"
"R3\0"
"R4\0"
"R5\0"
"R6\0"
"R7\0"
"R8\0"
"R9\0"
"Racute\0"
"racute\0"
"radical\0"
"Rcaron\0"
"rcaron\0"
"Rcedilla\0"
"rcedilla\0"
"Redo\0"
"registered\0"
"RepeatKeys_Enable\0"
"Reset\0"
"Return\0"
"Right\0"
"rightanglebracket\0"
"rightarrow\0"
"rightcaret\0"
"rightdoublequotemark\0"
"rightmiddlecurlybrace\0"
"rightmiddlesummation\0"
"rightopentriangle\0"
"rightpointer\0"
"rightshoe\0"
"rightsinglequotemark\0"
"rightt\0"
"righttack\0"
"Romaji\0"
"RupeeSign\0"
"S\0"
"s\0"
"Sabovedot\0"
"sabovedot\0"
"Sacute\0"
"sacute\0"
"Scaron\0"
"scaron\0"
"Scedilla\0"
"scedilla\0"
"SCHWA\0"
"schwa\0"
"Scircumflex\0"
"scircumflex\0"
"script_switch\0"
"Scroll_Lock\0"
"seconds\0"
"section\0"
"Select\0"
"semicolon\0"
"semivoicedsound\0"
"Serbian_dje\0"
"Serbian_DJE\0"
"Serbian_dze\0"
"Serbian_DZE\0"
"Serbian_je\0"
"Serbian_JE\0"
"Serbian_lje\0"
"Serbian_LJE\0"
"Serbian_nje\0"
"Serbian_NJE\0"
"Serbian_tshe\0"
"Serbian_TSHE\0"
"seveneighths\0"
"sevensubscript\0"
"sevensuperior\0"
"Shift_L\0"
"Shift_Lock\0"
"Shift_R\0"
"signaturemark\0"
"signifblank\0"
"similarequal\0"
"SingleCandidate\0"
"singlelowquotemark\0"
"Sinh_a\0"
"Sinh_aa\0"
"Sinh_aa2\0"
"Sinh_ae\0"
"Sinh_ae2\0"
"Sinh_aee\0"
"Sinh_aee2\0"
"Sinh_ai\0"
"Sinh_ai2\0"
"Sinh_al\0"
"Sinh_au\0"
"Sinh_au2\0"
"Sinh_ba\0"
"Sinh_bha\0"
"Sinh_ca\0"
"Sinh_cha\0"
"Sinh_dda\0"
"Sinh_ddha\0"
"Sinh_dha\0"
"Sinh_dhha\0"
"Sinh_e\0"
"Sinh_e2\0"
"Sinh_ee\0"
"Sinh_ee2\0"
"Sinh_fa\0"
"Sinh_ga\0"
"Sinh_gha\0"
"Sinh_h2\0"
"Sinh_ha\0"
"Sinh_i\0"
"Sinh_i2\0"
"Sinh_ii\0"
"Sinh_ii2\0"
"Sinh_ja\0"
"Sinh_jha\0"
"Sinh_jnya\0"
"Sinh_ka\0"
"Sinh_kha\0"
"Sinh_kunddaliya\0"
"Sinh_la\0"
"Sinh_lla\0"
"Sinh_lu\0"
"Sinh_lu2\0"
"Sinh_luu\0"
"Sinh_luu2\0"
"Sinh_ma\0"
"Sinh_mba\0"
"Sinh_na\0"
"Sinh_ndda\0"
"Sinh_ndha\0"
"Sinh_ng\0"
"Sinh_ng2\0"
"Sinh_nga\0"
"Sinh_nja\0"
"Sinh_nna\0"
"Sinh_nya\0"
"Sinh_o\0"
"Sinh_o2\0"
"Sinh_oo\0"
"Sinh_oo2\0"
"Sinh_pa\0"
"Sinh_pha\0"
"Sinh_ra\0"
"Sinh_ri\0"
"Sinh_rii\0"
"Sinh_ru2\0"
"Sinh_ruu2\0"
"Sinh_sa\0"
"Sinh_sha\0"
"Sinh_ssha\0"
"Sinh_tha\0"
"Sinh_thha\0"
"Sinh_tta\0"
"Sinh_ttha\0"
"Sinh_u\0"
"Sinh_u2\0"
"Sinh_uu\0"
"Sinh_uu2\0"
"Sinh_va\0"
"Sinh_ya\0"
"sixsubscript\0"
"sixsuperior\0"
"slash\0"
"SlowKeys_Enable\0"
"soliddiamond\0"
"space\0"
"squareroot\0"
"ssharp\0"
"sterling\0"
"StickyKeys_Enable\0"
"stricteq\0"
"SunAgain\0"
"SunAltGraph\0"
"SunAudioLowerVolume\0"
"SunAudioMute\0"
"SunAudioRaiseVolume\0"
"SunCompose\0"
"SunCopy\0"
"SunCut\0"
"SunF36\0"
"SunF37\0"
"SunFA_Acute\0"
"SunFA_Cedilla\0"
"SunFA_Circum\0"
"SunFA_Diaeresis\0"
"SunFA_Grave\0"
"SunFA_Tilde\0"
"SunFind\0"
"SunFront\0"
"SunOpen\0"
"SunPageDown\0"
"SunPageUp\0"
"SunPaste\0"
"SunPowerSwitch\0"
"SunPowerSwitchShift\0"
"SunPrint_Screen\0"
"SunProps\0"
"SunStop\0"
"SunSys_Req\0"
"SunUndo\0"
"SunVideoDegauss\0"
"SunVideoLowerBrightness\0"
"SunVideoRaiseBrightness\0"
"Super_L\0"
"Super_R\0"
"Sys_Req\0"
"System\0"
"T\0"
"t\0"
"Tab\0"
"Tabovedot\0"
"tabovedot\0"
"Tcaron\0"
"tcaron\0"
"Tcedilla\0"
"tcedilla\0"
"telephone\0"
"telephonerecorder\0"
"Terminate_Server\0"
"Thai_baht\0"
"Thai_bobaimai\0"
"Thai_chochan\0"
"Thai_chochang\0"
"Thai_choching\0"
"Thai_chochoe\0"
"Thai_dochada\0"
"Thai_dodek\0"
"Thai_fofa\0"
"Thai_fofan\0"
"Thai_hohip\0"
"Thai_honokhuk\0"
"Thai_khokhai\0"
"Thai_khokhon\0"
"Thai_khokhuat\0"
"Thai_khokhwai\0"
"Thai_khorakhang\0"
"Thai_kokai\0"
"Thai_lakkhangyao\0"
"Thai_lekchet\0"
"Thai_lekha\0"
"Thai_lekhok\0"
"Thai_lekkao\0"
"Thai_leknung\0"
"Thai_lekpaet\0"
"Thai_leksam\0"
"Thai_leksi\0"
"Thai_leksong\0"
"Thai_leksun\0"
"Thai_lochula\0"
"Thai_loling\0"
"Thai_lu\0"
"Thai_maichattawa\0"
"Thai_maiek\0"
"Thai_maihanakat\0"
"Thai_maihanakat_maitho\0"
"Thai_maitaikhu\0"
"Thai_maitho\0"
"Thai_maitri\0"
"Thai_maiyamok\0"
"Thai_moma\0"
"Thai_ngongu\0"
"Thai_nikhahit\0"
"Thai_nonen\0"
"Thai_nonu\0"
"Thai_oang\0"
"Thai_paiyannoi\0"
"Thai_phinthu\0"
"Thai_phophan\0"
"Thai_phophung\0"
"Thai_phosamphao\0"
"Thai_popla\0"
"Thai_rorua\0"
"Thai_ru\0"
"Thai_saraa\0"
"Thai_saraaa\0"
"Thai_saraae\0"
"Thai_saraaimaimalai\0"
"Thai_saraaimaimuan\0"
"Thai_saraam\0"
"Thai_sarae\0"
"Thai_sarai\0"
"Thai_saraii\0"
"Thai_sarao\0"
"Thai_sarau\0"
"Thai_saraue\0"
"Thai_sarauee\0"
"Thai_sarauu\0"
"Thai_sorusi\0"
"Thai_sosala\0"
"Thai_soso\0"
"Thai_sosua\0"
"Thai_thanthakhat\0"
"Thai_thonangmontho\0"
"Thai_thophuthao\0"
"Thai_thothahan\0"
"Thai_thothan\0"
"Thai_thothong\0"
"Thai_thothung\0"
"Thai_topatak\0"
"Thai_totao\0"
"Thai_wowaen\0"
"Thai_yoyak\0"
"Thai_yoying\0"
"therefore\0"
"thinspace\0"
"THORN\0"
"Thorn\0"
"thorn\0"
"threeeighths\0"
"threefifths\0"
"threequarters\0"
"threesubscript\0"
"threesuperior\0"
"tintegral\0"
"topintegral\0"
"topleftparens\0"
"topleftradical\0"
"topleftsqbracket\0"
"topleftsummation\0"
"toprightparens\0"
"toprightsqbracket\0"
"toprightsummation\0"
"topt\0"
"topvertsummationconnector\0"
"Touroku\0"
"trademark\0"
"trademarkincircle\0"
"Tslash\0"
"tslash\0"
"twofifths\0"
"twosubscript\0"
"twosuperior\0"
"twothirds\0"
"U\0"
"u\0"
"Uacute\0"
"uacute\0"
"Ubelowdot\0"
"ubelowdot\0"
"Ubreve\0"
"ubreve\0"
"Ucircumflex\0"
"ucircumflex\0"
"Udiaeresis\0"
"udiaeresis\0"
"Udoubleacute\0"
"udoubleacute\0"
"Ugrave\0"
"ugrave\0"
"Uhook\0"
"uhook\0"
"Uhorn\0"
"uhorn\0"
"Uhornacute\0"
"uhornacute\0"
"Uhornbelowdot\0"
"uhornbelowdot\0"
"Uhorngrave\0"
"uhorngrave\0"
"Uhornhook\0"
"uhornhook\0"
"Uhorntilde\0"
"uhorntilde\0"
"Ukrainian_ghe_with_upturn\0"
"Ukrainian_GHE_WITH_UPTURN\0"
"Ukrainian_i\0"
"Ukrainian_I\0"
"Ukrainian_ie\0"
"Ukrainian_IE\0"
"Ukrainian_yi\0"
"Ukrainian_YI\0"
"Ukranian_i\0"
"Ukranian_I\0"
"Ukranian_je\0"
"Ukranian_JE\0"
"Ukranian_yi\0"
"Ukranian_YI\0"
"Umacron\0"
"umacron\0"
"underbar\0"
"underscore\0"
"Undo\0"
"union\0"
"Uogonek\0"
"uogonek\0"
"Up\0"
"uparrow\0"
"upcaret\0"
"upleftcorner\0"
"uprightcorner\0"
"upshoe\0"
"upstile\0"
"uptack\0"
"Uring\0"
"uring\0"
"User\0"
"Utilde\0"
"utilde\0"
"V\0"
"v\0"
"variation\0"
"vertbar\0"
"vertconnector\0"
"voicedsound\0"
"VoidSymbol\0"
"vt\0"
"W\0"
"w\0"
"Wacute\0"
"wacute\0"
"Wcircumflex\0"
"wcircumflex\0"
"Wdiaeresis\0"
"wdiaeresis\0"
"Wgrave\0"
"wgrave\0"
"WonSign\0"
"X\0"
"x\0"
"Xabovedot\0"
"xabovedot\0"
"XF8610ChannelsDown\0"
"XF8610ChannelsUp\0"
"XF863DMode\0"
"XF86AddFavorite\0"
"XF86Addressbook\0"
"XF86ALSToggle\0"
"XF86ApplicationLeft\0"
"XF86ApplicationRight\0"
"XF86AppSelect\0"
"XF86AspectRatio\0"
"XF86Assistant\0"
"XF86AttendantOff\0"
"XF86AttendantOn\0"
"XF86AttendantToggle\0"
"XF86Audio\0"
"XF86AudioCycleTrack\0"
"XF86AudioDesc\0"
"XF86AudioForward\0"
"XF86AudioLowerVolume\0"
"XF86AudioMedia\0"
"XF86AudioMicMute\0"
"XF86AudioMute\0"
"XF86AudioNext\0"
"XF86AudioPause\0"
"XF86AudioPlay\0"
"XF86AudioPreset\0"
"XF86AudioPrev\0"
"XF86AudioRaiseVolume\0"
"XF86AudioRandomPlay\0"
"XF86AudioRecord\0"
"XF86AudioRepeat\0"
"XF86AudioRewind\0"
"XF86AudioStop\0"
"XF86Away\0"
"XF86Back\0"
"XF86BackForward\0"
"XF86Battery\0"
"XF86Blue\0"
"XF86Bluetooth\0"
"XF86Book\0"
"XF86Break\0"
"XF86BrightnessAdjust\0"
"XF86BrightnessAuto\0"
"XF86BrightnessMax\0"
"XF86BrightnessMin\0"
"XF86Buttonconfig\0"
"XF86Calculater\0"
"XF86Calculator\0"
"XF86Calendar\0"
"XF86CameraDown\0"
"XF86CameraFocus\0"
"XF86CameraLeft\0"
"XF86CameraRight\0"
"XF86CameraUp\0"
"XF86CameraZoomIn\0"
"XF86CameraZoomOut\0"
"XF86CD\0"
"XF86ChannelDown\0"
"XF86ChannelUp\0"
"XF86Clear\0"
"XF86ClearGrab\0"
"XF86Close\0"
"XF86Community\0"
"XF86ContextMenu\0"
"XF86ContrastAdjust\0"
"XF86ControlPanel\0"
"XF86Copy\0"
"XF86Cut\0"
"XF86CycleAngle\0"
"XF86Data\0"
"XF86Database\0"
"XF86Dictate\0"
"XF86Display\0"
"XF86DisplayOff\0"
"XF86DisplayToggle\0"
"XF86Documents\0"
"XF86DOS\0"
"XF86DVD\0"
"XF86Editor\0"
"XF86Eject\0"
"XF86EmojiPicker\0"
"XF86Excel\0"
"XF86Explorer\0"
"XF86FastReverse\0"
"XF86Favorites\0"
"XF86Finance\0"
"XF86Fn\0"
"XF86Fn_Esc\0"
"XF86FnRightShift\0"
"XF86Forward\0"
"XF86FrameBack\0"
"XF86FrameForward\0"
"XF86FullScreen\0"
"XF86Game\0"
"XF86Go\0"
"XF86GraphicsEditor\0"
"XF86Green\0"
"XF86HangupPhone\0"
"XF86Hibernate\0"
"XF86History\0"
"XF86HomePage\0"
"XF86HotLinks\0"
"XF86Images\0"
"XF86Info\0"
"XF86iTouch\0"
"XF86Journal\0"
"XF86KbdBrightnessDown\0"
"XF86KbdBrightnessUp\0"
"XF86KbdInputAssistAccept\0"
"XF86KbdInputAssistCancel\0"
"XF86KbdInputAssistNext\0"
"XF86KbdInputAssistNextgroup\0"
"XF86KbdInputAssistPrev\0"
"XF86KbdInputAssistPrevgroup\0"
"XF86KbdLcdMenu1\0"
"XF86KbdLcdMenu2\0"
"XF86KbdLcdMenu3\0"
"XF86KbdLcdMenu4\0"
"XF86KbdLcdMenu5\0"
"XF86KbdLightOnOff\0"
"XF86Keyboard\0"
"XF86Launch0\0"
"XF86Launch1\0"
"XF86Launch2\0"
"XF86Launch3\0"
"XF86Launch4\0"
"XF86Launch5\0"
"XF86Launch6\0"
"XF86Launch7\0"
"XF86Launch8\0"
"XF86Launch9\0"
"XF86LaunchA\0"
"XF86LaunchB\0"
"XF86LaunchC\0"
"XF86LaunchD\0"
"XF86LaunchE\0"
"XF86LaunchF\0"
"XF86LeftDown\0"
"XF86LeftUp\0"
"XF86LightBulb\0"
"XF86LightsToggle\0"
"XF86LogGrabInfo\0"
"XF86LogOff\0"
"XF86LogWindowTree\0"
"XF86Macro1\0"
"XF86Macro10\0"
"XF86Macro11\0"
"XF86Macro12\0"
"XF86Macro13\0"
"XF86Macro14\0"
"XF86Macro15\0"
"XF86Macro16\0"
"XF86Macro17\0"
"XF86Macro18\0"
"XF86Macro19\0"
"XF86Macro2\0"
"XF86Macro20\0"
"XF86Macro21\0"
"XF86Macro22\0"
"XF86Macro23\0"
"XF86Macro24\0"
"XF86Macro25\0"
"XF86Macro26\0"
"XF86Macro27\0"
"XF86Macro28\0"
"XF86Macro29\0"
"XF86Macro3\0"
"XF86Macro30\0"
"XF86Macro4\0"
"XF86Macro5\0"
"XF86Macro6\0"
"XF86Macro7\0"
"XF86Macro8\0"
"XF86Macro9\0"
"XF86MacroPreset1\0"
"XF86MacroPreset2\0"
"XF86MacroPreset3\0"
"XF86MacroPresetCycle\0"
"XF86MacroRecordStart\0"
"XF86MacroRecordStop\0"
"XF86Mail\0"
"XF86MailForward\0"
"XF86Market\0"
"XF86MediaRepeat\0"
"XF86MediaTopMenu\0"
"XF86Meeting\0"
"XF86Memo\0"
"XF86MenuKB\0"
"XF86MenuPB\0"
"XF86Messenger\0"
"XF86ModeLock\0"
"XF86MonBrightnessCycle\0"
"XF86MonBrightnessDown\0"
"XF86MonBrightnessUp\0"
"XF86Music\0"
"XF86MyComputer\0"
"XF86MySites\0"
"XF86New\0"
"XF86News\0"
"XF86Next_VMode\0"
"XF86NextFavorite\0"
"XF86NotificationCenter\0"
"XF86Numeric0\0"
"XF86Numeric1\0"
"XF86Numeric11\0"
"XF86Numeric12\0"
"XF86Numeric2\0"
"XF86Numeric3\0"
"XF86Numeric4\0"
"XF86Numeric5\0"
"XF86Numeric6\0"
"XF86Numeric7\0"
"XF86Numeric8\0"
"XF86Numeric9\0"
"XF86NumericA\0"
"XF86NumericB\0"
"XF86NumericC\0"
"XF86NumericD\0"
"XF86NumericPound\0"
"XF86NumericStar\0"
"XF86OfficeHome\0"
"XF86OnScreenKeyboard\0"
"XF86Open\0"
"XF86OpenURL\0"
"XF86Option\0"
"XF86Paste\0"
"XF86PauseRecord\0"
"XF86Phone\0"
"XF86PickupPhone\0"
"XF86Pictures\0"
"XF86PowerDown\0"
"XF86PowerOff\0"
"XF86Presentation\0"
"XF86Prev_VMode\0"
"XF86PrivacyScreenToggle\0"
"XF86Q\0"
"XF86Red\0"
"XF86Refresh\0"
"XF86Reload\0"
"XF86Reply\0"
"XF86RFKill\0"
"XF86RightDown\0"
"XF86RightUp\0"
"XF86RockerDown\0"
"XF86RockerEnter\0"
"XF86RockerUp\0"
"XF86RootMenu\0"
"XF86RotateWindows\0"
"XF86RotationKB\0"
"XF86RotationLockToggle\0"
"XF86RotationPB\0"
"XF86Save\0"
"XF86ScreenSaver\0"
"XF86Screensaver\0"
"XF86ScrollClick\0"
"XF86ScrollDown\0"
"XF86ScrollUp\0"
"XF86Search\0"
"XF86Select\0"
"XF86SelectiveScreenshot\0"
"XF86Send\0"
"XF86Shop\0"
"XF86Sleep\0"
"XF86SlowReverse\0"
"XF86Spell\0"
"XF86SpellCheck\0"
"XF86SplitScreen\0"
"XF86Standby\0"
"XF86Start\0"
"XF86Stop\0"
"XF86StopRecord\0"
"XF86Subtitle\0"
"XF86Support\0"
"XF86Suspend\0"
"XF86Switch_VT_1\0"
"XF86Switch_VT_10\0"
"XF86Switch_VT_11\0"
"XF86Switch_VT_12\0"
"XF86Switch_VT_2\0"
"XF86Switch_VT_3\0"
"XF86Switch_VT_4\0"
"XF86Switch_VT_5\0"
"XF86Switch_VT_6\0"
"XF86Switch_VT_7\0"
"XF86Switch_VT_8\0"
"XF86Switch_VT_9\0"
"XF86Taskmanager\0"
"XF86TaskPane\0"
"XF86Terminal\0"
"XF86Time\0"
"XF86ToDoList\0"
"XF86Tools\0"
"XF86TopMenu\0"
"XF86TouchpadOff\0"
"XF86TouchpadOn\0"
"XF86TouchpadToggle\0"
"XF86Travel\0"
"XF86Ungrab\0"
"XF86Unmute\0"
"XF86User1KB\0"
"XF86User2KB\0"
"XF86UserPB\0"
"XF86UWB\0"
"XF86VendorHome\0"
"XF86Video\0"
"XF86VideoPhone\0"
"XF86View\0"
"XF86VOD\0"
"XF86VoiceCommand\0"
"XF86Voicemail\0"
"XF86WakeUp\0"
"XF86WebCam\0"
"XF86WheelButton\0"
"XF86WLAN\0"
"XF86Word\0"
"XF86WPSButton\0"
"XF86WWAN\0"
"XF86WWW\0"
"XF86Xfer\0"
"XF86Yellow\0"
"XF86ZoomIn\0"
"XF86ZoomOut\0"
"XF86ZoomReset\0"
"Y\0"
"y\0"
"Yacute\0"
"yacute\0"
"Ybelowdot\0"
"ybelowdot\0"
"Ycircumflex\0"
"ycircumflex\0"
"ydiaeresis\0"
"Ydiaeresis\0"
"yen\0"
"Ygrave\0"
"ygrave\0"
"Yhook\0"
"yhook\0"
"Ytilde\0"
"ytilde\0"
"Z\0"
"z\0"
"Zabovedot\0"
"zabovedot\0"
"Zacute\0"
"zacute\0"
"Zcaron\0"
"zcaron\0"
"Zen_Koho\0"
"Zenkaku\0"
"Zenkaku_Hankaku\0"
"zerosubscript\0"
"zerosuperior\0"
"Zstroke\0"
"zstroke\0"
;
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
static const uint16_t keysym_name_G[] = {
0, 4563, 0, 0, 0, 2484, 2083, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 3420, 0, 3962, 0, 0, 0, 0, 0, 0, 2097, 96, 0, 0,
0, 0, 0, 3368, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3572, 408, 0,
1013, 1971, 0, 371, 1609, 0, 0, 0, 0, 0, 0, 273, 407, 0, 0, 0, 0, 0, 0,
1940, 4382, 0, 455, 0, 0, 499, 1170, 0, 2533, 0, 0, 0, 0, 3968, 0, 0,
0, 0, 0, 0, 1385, 4046, 1302, 0, 0, 0, 0, 0, 0, 2752, 0, 0, 0, 0, 0, 0,
3754, 0, 0, 1648, 0, 1359, 2082, 0, 0, 0, 0, 0, 0, 3646, 345, 0, 0, 0,
0, 284, 0, 2566, 983, 403, 2955, 0, 826, 2528, 0, 3912, 0, 0, 0, 745,
0, 0, 0, 2038, 362, 3338, 0, 0, 0, 0, 1899, 0, 0, 4215, 2690, 0, 0,
2011, 0, 0, 0, 74, 3838, 0, 0, 4412, 574, 0, 0, 454, 4069, 2898, 0, 0,
1826, 0, 3104, 0, 0, 0, 0, 0, 1581, 2521, 0, 0, 0, 0, 0, 0, 0, 0, 800,
0, 184, 0, 0, 4401, 3776, 0, 4431, 0, 0, 0, 221, 1934, 3309, 0, 0, 0,
0, 533, 0, 0, 0, 0, 3912, 2426, 0, 0, 0, 0, 0, 0, 3063, 0, 1133, 1015,
0, 0, 0, 0, 0, 0, 467, 0, 1035, 2487, 1866, 50, 3959, 0, 2851, 0, 0, 0,
1140, 0, 3620, 2760, 2178, 4119, 0, 3941, 1692, 0, 4566, 0, 685, 862,
3302, 0, 0, 719, 479, 0, 0, 693, 0, 0, 0, 2001, 0, 2396, 0, 0, 3492,
298, 0, 0, 0, 0, 3129, 180, 4143, 742, 45, 0, 3340, 0, 0, 0, 0, 973, 0,
0, 0, 0, 2700, 0, 2799, 0, 1056, 1071, 4548, 421, 266, 0, 0, 0, 0, 0,
1429, 1022, 0, 1918, 3084, 0, 0, 1225, 2225, 1657, 852, 0, 0, 0, 1581,
0, 0, 4197, 0, 0, 234, 0, 3748, 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 303,
216, 3998, 0, 0, 0, 0, 1652, 0, 0, 0, 0, 1510, 776, 4426, 0, 380, 0, 0,
0, 0, 0, 0, 0, 0, 1507, 0, 1405, 0, 0, 922, 816, 1828, 0, 3745, 1803,
0, 1195, 0, 0, 466, 0, 2229, 0, 0, 1054, 220, 0, 0, 2587, 0, 1687, 0,
0, 814, 430, 1676, 0, 2584, 1323, 0, 2346, 0, 3935, 0, 305, 0, 0, 0, 0,
0, 429, 0, 612, 614, 0, 2226, 0, 1075, 0, 0, 4287, 0, 2862, 0, 0, 1809,
4425, 3368, 1573, 1803, 0, 2337, 0, 0, 3506, 0, 0, 663, 0, 3025, 3499,
0, 0, 0, 0, 3971, 44, 0, 0, 0, 643, 0, 0, 1468, 0, 2120, 1133, 3189, 0,
1808, 135, 0, 3353, 0, 0, 0, 0, 0, 383, 0, 0, 0, 2247, 0, 2705, 2148,
0, 51, 55, 0, 0, 0, 1458, 0, 0, 2380, 0, 0, 0, 0, 519, 0, 3136, 3343,
0, 0, 0, 4386, 0, 3718, 26, 0, 0, 0, 1863, 0, 4117, 2751, 2014, 3441,
4026, 0, 3425, 0, 0, 2210, 0, 2015, 4206, 0, 0, 586, 0, 0, 0, 2240,
2247, 0, 0, 4262, 1831, 3498, 0, 222, 0, 0, 0, 0, 334, 2627, 0, 517, 0,
0, 0, 0, 1622, 0, 0, 0, 4276, 0, 0, 2391, 0, 462, 3652, 0, 1963, 0, 0,
3270, 3012, 1027, 0, 0, 0, 0, 660, 2871, 4388, 2764, 0, 0, 1035, 2266,
3917, 0, 0, 2824, 958, 1810, 1002, 0, 3932, 0, 0, 0, 0, 0, 0, 4495, 0,
0, 0, 1505, 2354, 4437, 828, 0, 0, 0, 3688, 2633, 0, 2420, 128, 0,
3023, 0, 1829, 1607, 360, 750, 0, 2479, 0, 1456, 3284, 2173, 0, 2740,
1816, 603, 1862, 0, 0, 0, 3784, 1511, 4507, 0, 435, 0, 0, 0, 0, 0, 616,
785, 2747, 0, 3212, 0, 3699, 0, 0, 1815, 1823, 0, 0, 0, 986, 0, 3506,
0, 0, 0, 0, 0, 2751, 0, 0, 4211, 138, 0, 3343, 0, 635, 0, 992, 0, 868,
282, 0, 0, 0, 2142, 0, 0, 1016, 0, 2354, 4010, 2169, 0, 0, 0, 644, 0,
385, 2897, 1676, 3788, 2724, 0, 2625, 1785, 0, 0, 1893, 0, 0, 973, 0,
0, 0, 2189, 0, 1133, 3698, 0, 3865, 0, 0, 4356, 0, 4297, 2087, 554, 0,
178, 2236, 0, 0, 0, 398, 1353, 422, 0, 1695, 1323, 777, 1129, 0, 0, 75,
0, 330, 0, 303, 0, 1816, 0, 0, 0, 0, 0, 0, 576, 198, 4415, 2297, 4119,
0, 0, 1245, 0, 0, 0, 1388, 0, 0, 4105, 0, 3, 0, 380, 0, 0, 3321, 0, 0,
1187, 2874, 0, 0, 0, 0, 0, 848, 2021, 4363, 0, 1056, 0, 0, 0, 1174, 0,
2989, 365, 0, 876, 390, 0, 1762, 0, 0, 1957, 0, 0, 1441, 543, 3981,
3986, 486, 617, 502, 923, 0, 1039, 0, 2668, 0, 792, 0, 0, 4049, 0, 0,
1345, 0, 3993, 4283, 0, 776, 1157, 1562, 0, 406, 122, 784, 4093, 765,
4148, 0, 2481, 0, 605, 0, 0, 4057, 0, 4070, 3307, 1537, 0, 1371, 0,
2855, 0, 627, 0, 0, 0, 4140, 0, 2414, 0, 852, 2331, 929, 1938, 0, 0, 0,
0, 0, 0, 563, 0, 0, 0, 531, 0, 1728, 0, 1694, 0, 434, 2481, 2903, 0,
2372, 0, 3230, 0, 0, 0, 0, 0, 0, 804, 68, 636, 764, 0, 0, 2545, 748, 0,
0, 899, 812, 0, 0, 2828, 2208, 0, 0, 2428, 0, 0, 0, 3828, 1380, 639, 0,
0, 0, 0, 157, 0, 918, 0, 271, 0, 0, 0, 3084, 0, 4525, 85, 0, 0, 586,
3452, 446, 0, 0, 0, 0, 0, 0, 316, 0, 0, 2003, 2060, 0, 0, 0, 1103, 59,
0, 436, 0, 498, 0, 1118, 711, 4320, 0, 96, 0, 0, 0, 955, 0, 4488, 0,
2774, 0, 0, 4456, 635, 0, 0, 0, 2167, 70, 4548, 474, 30, 0, 887, 213,
0, 0, 0, 0, 3025, 0, 537, 472, 0, 943, 0, 0, 0, 0, 146, 0, 0, 223, 680,
0, 0, 0, 0, 1993, 0, 0, 225, 1752, 0, 41, 0, 0, 2967, 1682, 3608, 1204,
2925, 0, 2764, 3286, 0, 0, 0, 0, 961, 0, 500, 0, 3728, 3671, 271, 0, 0,
267, 0, 0, 0, 0, 0, 4573, 496, 3346, 0, 2449, 2606, 0, 717, 0, 798, 0,
4397, 2483, 0, 0, 0, 170, 0, 2091, 2534, 0, 3356, 0, 0, 0, 4350, 193,
0, 745, 0, 58, 0, 0, 1850, 0, 2955, 1722, 0, 0, 0, 1063, 0, 2108, 1135,
4314, 0, 4108, 2721, 3534, 0, 2054, 2012, 0, 0, 0, 0, 1552, 0, 234, 0,
1477, 0, 3961, 0, 0, 1824, 856, 1453, 195, 555, 0, 0, 0, 3012, 3904,
1925, 610, 2914, 1200, 2318, 2979, 3606, 0, 0, 192, 0, 0, 0, 1410,
3067, 1971, 0, 791, 256, 2511, 2369, 2644, 2840, 0, 3667, 2197, 0, 0,
2210, 872, 2100, 1361, 0, 0, 0, 0, 1214, 2750, 697, 0, 0, 4228, 1828,
4257, 2486, 3279, 0, 0, 1526, 0, 0, 3694, 0, 147, 0, 0, 0, 0, 3370, 0,
5, 0, 2197, 37, 0, 0, 1108, 0, 548, 0, 3918, 0, 0, 2726, 1767, 2360, 0,
0, 0, 1270, 1080, 0, 0, 2405, 2542, 0, 548, 0, 982, 0, 3873, 0, 1349,
0, 3582, 0, 1722, 0, 0, 0, 0, 0, 2257, 2350, 0, 1542, 0, 0, 0, 3583,
2794, 0, 3942, 0, 2388, 559, 2149, 0, 0, 0, 0, 870, 0, 801, 1944, 4170,
0, 0, 0, 0, 0, 4470, 2332, 2749, 0, 0, 0, 0, 0, 0, 3527, 0, 175, 1805,
4141, 2028, 155, 401, 0, 1170, 0, 996, 3706, 4328, 0, 0, 4079, 558,
1304, 0, 0, 1731, 0, 2165, 0, 0, 0, 2209, 674, 0, 2912, 456, 153, 4084,
0, 1164, 2287, 0, 0, 1901, 2329, 1388, 1454, 736, 450, 3850, 0, 542,
1637, 1732, 350, 0, 0, 0, 0, 908, 1581, 0, 0, 0, 0, 4059, 1660, 4393,
2351, 0, 254, 0, 0, 0, 2508, 0, 0, 3451, 3716, 0, 3301, 0, 4197, 0, 0,
191, 1408, 3273, 1816, 3759, 0, 0, 4374, 0, 0, 2536, 780, 0, 1415,
4207, 703, 0, 4338, 1079, 0, 0, 0, 0, 0, 0, 0, 2640, 0, 2878, 0, 0,
1330, 0, 0, 0, 1516, 0, 0, 0, 1838, 2396, 0, 0, 0, 194, 0, 0, 3322, 0,
2060, 0, 641, 1316, 890, 2706, 0, 3811, 0, 376, 860, 2471, 0, 0, 1951,
0, 655, 4033, 0, 0, 3550, 0, 53, 0, 0, 589, 1366, 2862, 0, 0, 0, 0,
3566, 0, 0, 2136, 3800, 0, 0, 0, 0, 1415, 2700, 1497, 4360, 1677, 244,
0, 289, 3689, 0, 0, 702, 3832, 0, 0, 0, 0, 119, 4408, 942, 0, 0, 0,
743, 0, 3789, 2828, 2330, 2034, 0, 0, 3961, 0, 976, 2705, 154, 0, 1196,
4540, 0, 0, 3631, 286, 0, 0, 666, 0, 1479, 158, 1721, 0, 0, 2187, 1550,
0, 2250, 443, 0, 1033, 2383, 2198, 0, 0, 0, 1302, 4467, 0, 4357, 1713,
357, 0, 244, 1582, 453, 0, 4344, 2475, 0, 1574, 2840, 0, 0, 0, 0, 0, 0,
0, 0, 4460, 256, 736, 0, 1349, 0, 2398, 1318, 3631, 0, 0, 1027, 876,
2121, 0, 0, 0, 0, 0, 0, 1233, 598, 0, 988, 0, 1512, 0, 1383, 2291, 0,
0, 0, 2251, 4178, 2310, 1482, 752, 0, 0, 794, 12, 3214, 809, 0, 686, 0,
2081, 0, 2907, 698, 0, 1885, 6, 191, 0, 0, 0, 0, 1947, 483, 0, 0, 1250,
4527, 1159, 0, 0, 1411, 0, 3332, 2547, 0, 1817, 0, 0, 3642, 0, 221, 0,
2642, 2016, 0, 4274, 0, 1727, 0, 0, 66, 0, 3957, 0, 4512, 124, 3158,
2453, 2684, 0, 0, 0, 0, 1306, 0, 1831, 356, 0, 2008, 1317, 0, 0, 1178,
2193, 0, 2410, 565, 0, 0, 0, 2279, 1198, 0, 2029, 0, 445, 2935, 1357,
0, 4547, 3044, 227, 0, 2634, 4295, 0, 0, 2837, 0, 2376, 3282, 392,
1848, 0, 907, 1648, 587, 4304, 0, 4350, 252, 2665, 2409, 1854, 624, 0,
0, 0, 3021, 0, 0, 0, 0, 0, 2647, 3, 654, 0, 0, 0, 1010, 3006, 0, 0, 0,
0, 0, 0, 1881, 1563, 2167, 364, 3643, 0, 0, 688, 0, 0, 1215, 2859, 769,
0, 1093, 286, 4260, 829, 0, 3137, 0, 0, 3326, 0, 899, 0, 0, 0, 2422, 0,
1464, 1153, 2980, 0, 0, 0, 1037, 0, 0, 703, 1918, 4269, 776, 0, 4382,
0, 1336, 3014, 1582, 0, 3564, 0, 2834, 0, 2548, 207, 2623, 851, 0,
2410, 0, 1196, 0, 1034, 3215, 2632, 740, 3176, 0, 0, 0, 0, 0, 48, 328,
1209, 0, 87, 583, 396, 0, 0, 4403, 2253, 3431, 98, 2405, 0, 4162, 3940,
0, 4196, 0, 1835, 0, 0, 0, 0, 0, 0, 305, 2423, 1227, 2581, 3750, 362,
1414, 0, 4338, 1882, 0, 2334, 2223, 0, 0, 4151, 0, 156, 1891, 366,
4562, 0, 4475, 2379, 0, 3863, 1997, 2355, 3058, 1251, 0, 491, 0, 1331,
188, 0, 600, 2274, 0, 0, 273, 3561, 0, 0, 4502, 0, 3515, 2552, 3947, 0,
504, 3488, 3633, 0, 4174, 412, 2344, 375, 1515, 0, 1339, 3239, 673, 0,
0, 0, 0, 0, 0, 0, 430, 2685, 0, 1260, 0, 2211, 0, 0, 2169, 0, 2333,
2970, 645, 0, 0, 0, 0, 0, 1546, 1999, 291, 1879, 0, 0, 2467, 2548,
3435, 0, 454, 232, 1258, 4219, 746, 1956, 1665, 0, 0, 0, 0, 0, 0, 0, 0,
590, 4293, 327, 0, 217, 1885, 1986, 1202, 0, 166, 0, 0, 4058, 0, 983,
0, 3113, 416, 0, 239, 476, 0, 0, 930, 2575, 0, 0, 0, 0, 2050, 0, 0,
1850, 0, 1993, 0, 1821, 0, 0, 1506, 1085, 0, 0, 0, 277, 2531, 1489, 0,
4270, 2571, 3114, 1623, 2104, 21, 332, 650, 630, 1955, 1384, 0, 4079,
346, 0, 0, 0, 0, 2125, 3620, 0, 2892, 1765, 0, 0, 0, 461, 0, 4168,
2265, 1861, 0, 4103, 0, 0, 3485, 0, 0, 0, 4355, 1995, 3576, 1882, 1943,
0, 229, 1529, 3858, 0, 1490, 829, 1957, 4332, 3371, 0, 0, 1759, 2551,
1230, 0, 3404, 0, 929, 0, 4555, 0, 1821, 1892, 0, 0, 2700, 2460, 0,
4041, 0, 4101, 581, 3240, 206, 567, 1069, 348, 0, 0, 211, 3444, 0,
4188, 2412, 378, 1378, 0, 0, 0, 1785, 4399, 0, 2266, 0, 1863, 1767, 0,
0, 0, 0, 0, 0, 1956, 4052, 100, 4320, 186, 0, 303, 0, 1316, 2007, 2787,
0, 4004, 450, 2921, 129, 2678, 0, 3146, 0, 0, 0, 0, 703, 2801, 0, 0,
1718, 3509, 3786, 2399, 436, 0, 0, 1212, 2159, 48, 0, 1164, 0, 0, 3608,
2296, 2244, 0, 2529, 0, 0, 0, 0, 1172, 0, 0, 2801, 3655, 468, 2803,
914, 691, 335, 2621, 0, 0, 297, 130, 0, 872, 0, 1890, 0, 4474, 3688,
2537, 735, 0, 2710, 1146, 0, 3231, 3179, 304, 1715, 0, 0, 0, 3065, 0,
0, 1782, 2536, 0, 0, 0, 0, 891, 0, 0, 631, 0, 0, 0, 0, 159, 0, 3306,
1159, 4419, 0, 4103, 0, 0, 0, 904, 861, 0, 0, 0, 0, 0, 0, 718, 268,
1771, 0, 0, 2692, 2129, 0, 0, 922, 3529, 4326, 1617, 4236, 1819, 0, 0,
0, 0, 0, 0, 0, 4479, 1136, 0, 0, 591, 2647, 3881, 2768, 444, 0, 983, 0,
255, 3221, 585, 0, 0, 0, 1648, 382, 0, 0, 0, 4213, 4087, 3501, 915, 0,
0, 199, 4448, 0, 0, 1305, 0, 3731, 1778, 0, 3827, 0, 0, 0, 3997, 0,
4369, 1931, 2514, 0, 0, 0, 3360, 7, 0, 1525, 2612, 4026, 0, 1037, 1117,
354, 3208, 0, 0, 3059, 831, 492, 3067, 516, 4357, 0, 0, 2801, 0, 1722,
2230, 0, 185, 452, 657, 0, 0, 1729, 615, 1671, 1792, 2424, 306, 2092,
0, 3287, 0, 0, 1779, 4274, 0, 3232, 1016, 4409, 1227, 480, 4143, 0,
1696, 3080, 4047, 615, 0, 2965, 3569, 0, 0, 3859, 2143, 0, 1865, 3297,
0, 0, 0, 3003, 4382, 0, 0, 0, 115, 0, 382, 0, 0, 0, 0, 1524, 1240, 57,
492, 1756, 895, 842, 3903, 3914, 0, 2676, 1130, 524, 4238, 0, 538, 0,
1195, 1704, 0, 0, 0, 0, 3717, 1489, 534, 3274, 0, 2196, 2548, 1440,
747, 569, 0, 3115, 0, 0, 1679, 0, 1182, 835, 3065, 4193, 903, 0, 3078,
4368, 0, 2105, 0, 954, 0, 0, 0, 0, 1189, 2073, 750, 0, 3057, 1202, 906,
1034, 3711, 0, 2305, 2184, 0, 0, 306, 0, 2676, 1377, 1781, 2022, 1040,
1418, 0, 245, 2296, 0, 0, 4074, 4228, 3779, 0, 0, 0, 2062, 0, 1836,
4392, 0, 0, 0, 3736, 0, 0, 0, 591, 0, 0, 0, 3055, 2165, 0, 3497, 0,
2082, 0, 0, 0, 0, 1719, 273, 2216, 896, 3924, 3597, 555, 2995, 944,
2487, 0, 831, 0, 0, 0, 0, 1667, 0, 2759, 1265, 0, 2101, 0, 4338, 0, 81,
449, 0, 0, 0, 2503, 0, 340, 0, 0, 1021, 0, 413, 0, 0, 2913, 0, 4044,
2359, 2277, 2496, 0, 591, 3047, 1313, 225, 0, 0, 496, 154, 1689, 0, 0,
0, 3307, 1697, 3556, 0, 2369, 875, 0, 0, 3439, 1072, 0, 4240, 0, 4256,
2658, 241, 0, 2296, 0, 0, 951, 0, 10, 0, 1540, 0, 1732, 0, 3971, 1123,
0, 3169, 4365, 528, 0, 2392, 0, 1153, 2069, 0, 0, 383, 0, 0, 0, 0, 0,
1575, 4384, 3577, 2372, 0, 0, 0, 0, 204, 0, 0, 1028, 986, 1966, 273, 0,
4498, 0, 3460, 2012, 0, 0, 3307, 201, 0, 2663, 3861, 0, 2124, 0, 469,
1276, 0, 36, 0, 1126, 3780, 0, 252, 603, 1533, 0, 2958, 650, 3466,
4452, 409, 0, 2028, 2663, 0, 3399, 2611, 1721, 0, 0, 736, 1315, 561,
3771, 1666, 4145, 0, 0, 56, 0, 0, 1278, 0, 0, 0, 2084, 107, 0, 0, 0,
3748, 1979, 3867, 2095, 0, 1115, 0, 3788, 3267, 2334, 3607, 4219, 2542,
1380, 0, 0, 0, 2787, 2305, 3567, 2721, 456, 1348, 345, 2353, 690, 2249,
1146, 0, 2237, 1517, 934, 296, 0, 231, 0, 4400, 1983, 0, 0, 4361, 0, 0,
898, 937, 678, 1537, 0, 0, 0, 2244, 70, 0, 0, 0, 0, 1209, 0, 2414, 0,
1828, 2869, 0, 0, 0, 4216, 0, 0, 506, 0, 4391, 1259, 3787, 3463, 978,
0, 1017, 2374, 0, 0, 0, 1934, 0, 0, 3067, 1532, 1650, 581, 1084, 127,
403, 0, 2980, 1509, 3941, 0, 1384, 0, 0, 2900, 0, 436, 0, 472, 2683,
4510, 27, 0, 530, 1193, 1162, 2540, 0, 3885, 3815, 0, 1018, 691, 0,
709, 1860, 0, 3696, 3786, 2894, 0, 1513, 0, 3050, 1830, 0, 1396, 4256,
0, 0, 0, 2777, 582, 2366, 2128, 193, 1434, 0, 2415, 66, 3570, 883,
1142, 1220, 1064, 0, 876, 1084, 0, 4177, 3486, 1918, 1570, 0, 680,
2941, 0, 0, 25, 0, 0, 99, 0, 1651, 50, 561, 1986, 514, 4576, 2084, 366,
4552, 0, 961, 0, 2289, 0, 0, 1407, 3872, 940, 1270, 0, 0, 227, 0, 1354,
784, 2204, 3139, 2367, 1183, 0, 0, 0, 3916, 3709, 0, 0, 175, 4392,
1048, 0, 0, 0, 2271, 4548, 0, 0, 0, 2509, 0, 1291, 13, 791, 4469, 0, 0,
1101, 0, 2230, 1376, 275, 2298, 3150, 0, 0, 0, 956, 2815, 2451, 0, 0,
2608, 1483, 0, 22, 700, 0, 1363, 0, 3532, 3464, 0, 0, 967, 1689, 1618,
0, 0, 0, 1786, 3664, 3612, 1979, 2888, 0, 1609, 0, 0, 0, 0, 1672, 110,
0, 2948, 0, 281, 2459, 2103, 3451, 0, 0, 1358, 0, 0, 173, 2355, 293, 0,
0, 1521, 3704, 2668, 732, 0, 312, 0, 1696, 1905, 0, 0, 0, 0, 536, 1962,
1364, 11, 4442, 1687, 2302, 0, 0, 1994, 2369, 0, 0, 0, 0, 0, 0, 0,
2531, 4337, 4514, 4105, 0, 3328, 350, 3008, 1155, 0, 0, 1428, 906,
2486, 1200, 0, 0, 717, 496, 3198, 0, 1088, 0, 1792, 2222, 0, 1584, 92,
1619, 0, 0, 2036, 863, 0, 4204, 0, 269, 0, 0, 0, 0, 3648, 1650, 39, 0,
0, 381, 1366, 0, 2370, 2074, 1332, 3338, 4366, 0, 1665, 0, 0, 281, 0,
3951, 0, 3105, 1985, 203, 1004, 0, 0, 0, 965, 0, 1856, 0, 1538, 714,
162, 0, 0, 2434, 1024, 4116, 351, 0, 3948, 613, 0, 353, 1385, 0, 0,
2267, 0, 3047, 3928, 0, 0, 0, 85, 1550, 0, 0, 0, 643, 0, 2239, 0, 1587,
0, 519, 3012, 125, 3607, 0, 683, 201, 3299, 2823, 3003, 1455, 67, 0,
1025, 339, 2199, 445, 1719, 1495, 4134, 362, 742, 2218, 583, 1737, 0,
0, 0, 0, 1452, 2820, 2111, 29, 1973, 4351, 863, 0, 0, 0, 0, 3889, 0, 0,
0, 1334, 205, 0, 2010, 0, 383, 4351, 1158, 609, 361, 2008, 3549, 1924,
30, 4383, 0, 779, 1382, 871, 0, 0, 1603, 0, 1198, 1851, 4049, 2505,
1639, 0, 0, 808, 1646, 0, 1489, 240, 712, 0, 0, 0, 75, 3647, 0, 0, 0,
0, 355, 1526, 748, 0, 3240, 0, 0, 0, 3896, 2446, 0, 2758, 1716, 4375,
1827, 607, 2043, 0, 2383, 0, 3081, 2563, 0, 0, 1722, 1176, 0, 0, 3269,
1245, 1636, 0, 0, 0, 976, 0, 759, 2793, 3892, 113, 4438, 3560, 0, 908,
1141, 2042, 1309, 2077, 0, 0, 0, 0, 2135, 1148, 0, 0, 0, 1357, 3972,
943, 0, 4269, 310, 3353, 0, 0, 0, 0, 0, 0, 1565, 0, 0, 1578, 0, 3115,
166, 4458, 2853, 0, 1165, 3157, 1956, 1993, 0, 0, 3832, 0, 873, 199,
225, 0, 3343, 826, 1184, 2599, 0, 111, 597, 2174, 0, 0, 4537, 541, 0,
0, 1690, 0, 1391, 3002, 0, 0, 3855, 1427, 3441, 50, 4135, 1862, 223, 0,
2210, 3917, 3768, 1775, 2290, 1104, 2336, 2391, 1799, 1182, 0, 0, 926,
712, 0, 0, 3420, 1855, 0, 1364, 4386, 0, 1518, 0, 3584, 4518, 0, 0,
825, 3890, 0, 4231, 4287, 0, 451, 0, 0, 0, 0, 3083, 1517, 1302, 4156,
3792, 0, 3614, 1531, 1215, 3053, 0, 2921, 2236, 1206, 157, 1338, 0,
260, 1564, 0, 0, 2094, 1874, 0, 0, 0, 0, 4220, 0, 0, 1042, 1758, 2547,
3896, 1164, 4388, 1160, 679, 2501, 0, 0, 1040, 0, 433, 0, 2134, 2058,
2494, 790, 0, 1411, 0, 0, 0, 0, 713, 4157, 4195, 3979, 876, 3590, 0, 0,
83, 0, 1083, 0, 1055, 3302, 638, 2691, 0, 1731, 1742, 775, 1776, 715,
0, 379, 0, 1548, 0, 0, 4012, 0, 3005, 1071, 0, 0, 988, 0, 0, 4426,
1564, 2506, 0, 191, 0, 0, 3582, 1996, 0, 584, 0, 0, 2802, 0, 369, 397,
0, 4214, 453, 3572, 3120, 0, 0, 97, 0, 1441, 3588, 806, 0, 1615, 4340,
780, 3139, 0, 664, 0, 2188, 2504, 0, 2298, 621, 0, 898, 0, 0, 0, 0, 0,
838, 172, 117, 1622, 487, 475, 314, 0, 2048, 2704, 0, 867, 0, 3792,
3641, 2503, 0, 594, 2039, 0, 452, 0, 1877, 89, 0, 4014, 653, 1614,
1292, 566, 0, 0, 198, 0, 0, 2338, 4136, 937, 1120, 0, 8, 3698, 3171,
413, 1439, 1321, 0, 2417, 335, 2986, 0, 566, 0, 3814, 962, 0, 0, 242,
0, 0, 505, 183, 1965, 812, 98, 655, 0, 0, 0, 0, 1978, 848, 396, 0, 377,
0, 1684, 0, 1582, 3969, 1744, 0, 810, 72, 0, 107, 0, 4433, 2286, 3522,
0, 2069, 0, 0, 0, 2094, 4395, 2067, 0, 1149, 0, 662, 0, 2107, 4389, 0,
849, 0, 0, 0, 69, 0, 0, 0, 0, 0, 313, 0, 607, 831, 4085, 3226, 0, 0, 0,
340, 4136, 1223, 2021, 0, 2091, 3801, 212, 0, 12, 0, 3915, 1805, 3515,
4315, 0, 0, 2099, 0, 0, 4090, 0, 0, 622, 834, 2437, 2296, 1681, 4547,
4460, 2079, 2324, 839, 2397, 2145, 1619, 401, 3863, 2891, 0, 103, 1457,
0, 1047, 0, 1405, 2950, 3099, 2255, 0, 0, 968, 670, 2120, 1389, 643, 0,
1752, 1342, 0, 3330, 0, 1282, 1561, 3036, 0, 0, 1219, 2129, 425, 0,
2162, 0, 0, 3764, 2134, 3962, 0, 919, 0, 0, 2044, 0, 0, 769, 2243, 0,
0, 4575, 1751, 0, 0, 0, 585, 1638, 0, 0, 2438, 0, 792, 220, 0, 3802,
3691, 0, 1032, 1344, 0, 3968, 0, 0, 147, 1059, 2411, 1074, 1608, 0,
199, 0, 0, 215, 0, 0, 840, 3390, 712, 0, 3209, 3282, 0, 2266, 2514, 0,
1393, 951, 4351, 0, 378, 0, 1015, 4263, 2644, 2511, 1953, 0, 0, 1991,
3626, 0, 513, 0, 2139, 2502, 0, 808, 2899, 1908, 1589, 113, 3787, 0, 0,
882, 3809, 0, 4350, 890, 0, 0, 240, 632, 3047, 1547, 3304, 874, 0, 669,
1138, 1326, 2034, 4147, 2172, 3490, 1660, 0, 1542, 0, 788, 3236, 557,
0, 290, 1687, 0, 1655, 4087, 1730, 3798, 2362, 875, 442, 2048, 0, 0, 0,
2419, 4022, 2726, 0, 701, 294, 0, 1955, 3941, 571, 0, 0, 1450, 1985,
1874, 2584, 1062, 3965, 0, 0, 521, 384, 0, 1406, 1272, 0, 0, 0, 0,
2642, 1419, 280, 0, 0, 2495, 0, 603, 1739, 2740, 105, 0, 1768, 1049, 0,
1901, 4127, 1550, 0, 4479, 1750, 693, 2089, 0, 2715, 4357, 0, 4027,
842, 3047, 3628, 145, 1240, 0, 617, 847, 4400, 620, 1496, 4204, 1912,
3600, 2399, 1839, 751, 1558, 433, 20, 0, 2449, 4367, 0, 902, 3803,
2277, 0, 214, 584, 2380, 0, 1983, 0, 331, 0, 1752, 171, 1643, 556, 627,
537, 0, 3772, 2097, 0, 3603, 0, 1704, 0, 0, 0, 0, 2437, 227, 3368, 0,
2128, 0, 0, 965, 4212, 0, 0, 568, 127, 1903, 4433, 0, 0, 0, 1886, 153,
2830, 0, 1450, 0, 129, 0, 0, 0, 975, 3292, 105, 0, 0, 202, 0, 1727, 0,
4241, 2087, 2073, 430, 0, 3605, 823, 440, 1626, 11, 3226, 0, 0, 3953,
0, 593, 0, 1325, 0, 0, 2227, 1850, 270, 0, 0, 2085, 441, 171, 2251, 0,
2430, 0, 0, 4544, 0, 1330, 0, 0, 0, 1794, 1653, 213, 1513, 3924, 2379,
2023, 666, 55, 3647, 832, 3275, 739, 4117, 2141, 1233, 4483, 0, 3836,
2907, 826, 781, 3445, 784, 3728, 3751, 1226, 3639, 2696, 1066, 1170,
664, 785, 733, 293, 1603, 0, 1942, 0, 0, 1, 0, 661, 0, 0, 679, 1368, 0,
0, 1179, 208, 0, 0, 0, 0, 1604, 2525, 4309, 1176, 1285, 667, 2161,
4564, 302, 4097, 3038, 2549, 266, 0, 0, 2443, 0, 0, 562, 0, 0, 697,
247, 2408, 2433, 0, 3858, 0, 1599, 578, 3041, 4043, 1902, 1298, 0, 0,
1652, 0, 1493, 0, 0, 0, 379, 4453, 0, 0, 0, 0, 2125, 0, 3703, 0, 1649,
4085, 2345, 0, 7, 4099, 0, 0, 0, 0, 2921, 0, 2745, 58, 0, 2706, 587,
2328, 0, 2271, 0, 121, 0, 1939, 1027, 226, 0, 1473, 4235, 0, 0, 0,
2618, 1043, 4158, 0, 0, 0, 0, 0, 386, 3847, 0, 1817, 2405, 0, 1142,
1906, 1254, 1734, 4182, 4530, 0, 0, 0, 1995, 1813, 0, 0, 1480, 1886,
3796, 2487, 4066, 0, 1511, 0, 0, 0, 3807, 2978, 2283, 4266, 4360, 2172,
0, 135, 1662, 0, 247, 956, 525, 0, 0, 0, 2402, 0, 0, 0, 0, 0, 515,
2301, 0, 2319, 313, 0, 3101, 0, 0, 0, 3870, 0, 3544, 0, 0, 0, 4490, 0,
4509, 0, 2734, 3317, 0, 0, 0, 2770, 0, 0, 2263, 986, 0, 2529, 1001, 0,
0, 2249, 177, 0, 2289, 4304, 4242, 0, 0, 0, 170, 0, 4576, 195, 0, 1795,
4271, 0, 0, 0, 4180, 34, 0, 0, 0, 0, 0, 2475, 781, 1461, 3400, 1894, 0,
2337, 0, 2406, 322, 0, 948, 0, 3838, 1572, 2546, 0, 754, 1234, 1323,
805, 0, 1694, 1164, 706, 1972, 2608, 3313, 2289, 838, 1252, 0, 3641, 0,
3427, 0, 1847, 2807, 1135, 992, 0, 0, 2446, 938, 0, 0, 846, 1825, 0, 0,
0, 0, 0, 1094, 1594, 643, 4102, 778, 4529, 0, 2035, 811, 0, 1156, 0, 0,
0, 3400, 2456, 1869, 3613, 0, 0, 0, 0, 2961, 2076, 1836, 0, 0, 239,
1058, 926, 2472, 0, 564, 3784, 2615, 2719, 0, 0, 3519, 2190, 2339,
1072, 1244, 1003, 4441, 1003, 0, 0, 0, 0, 0, 4051, 1821, 1264, 652, 0,
305, 2559, 1001, 0, 0, 1272, 0, 4471, 0, 1637, 3775, 0, 1834, 0, 959,
2628, 2040, 0, 3716, 0, 0, 0, 193, 0, 2762, 0, 2464, 571, 312, 284,
849, 2472, 0, 2326, 3115, 1495, 0, 2439, 1097, 0, 1886, 0, 1207, 911,
0, 0, 141, 1221, 1341, 2482, 3714, 0, 1674, 0, 4503, 2208, 327, 0, 0,
1950, 2927, 3809, 684, 1463, 3080, 0, 0, 1502, 0, 0, 2362, 0, 0, 0,
4307, 1751, 0, 145, 0, 845, 0, 333, 3872, 2291, 0, 301, 0, 0, 371, 0,
0, 2788, 0, 704, 379, 1098, 1702, 1786, 2426, 0, 1245, 2245, 2269, 0,
1144, 2221, 1077, 3063, 0, 0, 3991, 2506, 402, 2061, 0, 3534, 3505,
3917, 284, 0, 3421, 1575, 0, 927, 1418, 3498, 1663, 285, 1630, 2377,
736, 1249, 2949, 2482, 1227, 4221, 1609, 2989, 2264, 1584, 0, 0, 0, 7,
1710, 1065, 4551, 726, 596, 1138, 0, 0, 0, 0, 0, 4563, 0, 0, 1348, 386,
181, 2359, 1223, 3472, 2181, 0, 1082, 0, 0, 4210, 0, 0, 0, 0, 2096,
1174, 0, 0, 2215, 4392, 3487, 0, 53, 0, 525, 0, 1292, 2120, 1531, 0, 0,
677, 103, 2301, 3554, 2011, 0, 0, 0, 3337, 0, 1728, 615, 0, 1429, 813,
49, 1134, 3922, 0, 3313, 2030, 0, 62, 0, 553, 0, 3854, 0, 57, 1473,
2668, 753, 0, 4306, 4013, 0, 1301, 556, 1049, 0, 318, 4239, 711, 862,
0
};
static size_t
keysym_name_hash_f(const char *key, const char *T)
{
size_t sum = 0;
for (size_t i = 0; key[i] != '\0'; i++)
sum += T[i % 32] * key[i];
return sum % 4578;
}
static size_t
keysym_name_perfect_hash(const char *key)
{
return (
keysym_name_G[keysym_name_hash_f(key, "i8oQPmKYkIetcNLKtoDCVlX1nn1CvPDv")] +
keysym_name_G[keysym_name_hash_f(key, "h7H8UeXN09yUJyoQcJxwuidtVj4cA0a7")]
) % 4578;
}
struct name_keysym {
xkb_keysym_t keysym;
uint32_t offset;
};
static const struct name_keysym name_to_keysym[] = {
{ 0x00000030, 0 }, /* 0 */
{ 0x00000031, 2 }, /* 1 */
{ 0x00000032, 4 }, /* 2 */
{ 0x00000033, 6 }, /* 3 */
{ 0x0000fd10, 8 }, /* 3270_AltCursor */
{ 0x0000fd0e, 23 }, /* 3270_Attn */
{ 0x0000fd05, 33 }, /* 3270_BackTab */
{ 0x0000fd19, 46 }, /* 3270_ChangeScreen */
{ 0x0000fd15, 64 }, /* 3270_Copy */
{ 0x0000fd0f, 74 }, /* 3270_CursorBlink */
{ 0x0000fd1c, 91 }, /* 3270_CursorSelect */
{ 0x0000fd1a, 109 }, /* 3270_DeleteWord */
{ 0x0000fd01, 125 }, /* 3270_Duplicate */
{ 0x0000fd1e, 140 }, /* 3270_Enter */
{ 0x0000fd06, 151 }, /* 3270_EraseEOF */
{ 0x0000fd07, 165 }, /* 3270_EraseInput */
{ 0x0000fd1b, 181 }, /* 3270_ExSelect */
{ 0x0000fd02, 195 }, /* 3270_FieldMark */
{ 0x0000fd13, 210 }, /* 3270_Ident */
{ 0x0000fd12, 221 }, /* 3270_Jump */
{ 0x0000fd11, 231 }, /* 3270_KeyClick */
{ 0x0000fd04, 245 }, /* 3270_Left2 */
{ 0x0000fd0a, 256 }, /* 3270_PA1 */
{ 0x0000fd0b, 265 }, /* 3270_PA2 */
{ 0x0000fd0c, 274 }, /* 3270_PA3 */
{ 0x0000fd16, 283 }, /* 3270_Play */
{ 0x0000fd1d, 293 }, /* 3270_PrintScreen */
{ 0x0000fd09, 310 }, /* 3270_Quit */
{ 0x0000fd18, 320 }, /* 3270_Record */
{ 0x0000fd08, 332 }, /* 3270_Reset */
{ 0x0000fd03, 343 }, /* 3270_Right2 */
{ 0x0000fd14, 355 }, /* 3270_Rule */
{ 0x0000fd17, 365 }, /* 3270_Setup */
{ 0x0000fd0d, 376 }, /* 3270_Test */
{ 0x00000034, 386 }, /* 4 */
{ 0x00000035, 388 }, /* 5 */
{ 0x00000036, 390 }, /* 6 */
{ 0x00000037, 392 }, /* 7 */
{ 0x00000038, 394 }, /* 8 */
{ 0x00000039, 396 }, /* 9 */
{ 0x00000041, 398 }, /* A */
{ 0x00000061, 400 }, /* a */
{ 0x000000c1, 402 }, /* Aacute */
{ 0x000000e1, 409 }, /* aacute */
{ 0x01001ea0, 416 }, /* Abelowdot */
{ 0x01001ea1, 426 }, /* abelowdot */
{ 0x000001ff, 436 }, /* abovedot */
{ 0x000001c3, 445 }, /* Abreve */
{ 0x000001e3, 452 }, /* abreve */
{ 0x01001eae, 459 }, /* Abreveacute */
{ 0x01001eaf, 471 }, /* abreveacute */
{ 0x01001eb6, 483 }, /* Abrevebelowdot */
{ 0x01001eb7, 498 }, /* abrevebelowdot */
{ 0x01001eb0, 513 }, /* Abrevegrave */
{ 0x01001eb1, 525 }, /* abrevegrave */
{ 0x01001eb2, 537 }, /* Abrevehook */
{ 0x01001eb3, 548 }, /* abrevehook */
{ 0x01001eb4, 559 }, /* Abrevetilde */
{ 0x01001eb5, 571 }, /* abrevetilde */
{ 0x0000fe70, 583 }, /* AccessX_Enable */
{ 0x0000fe71, 598 }, /* AccessX_Feedback_Enable */
{ 0x000000c2, 622 }, /* Acircumflex */
{ 0x000000e2, 634 }, /* acircumflex */
{ 0x01001ea4, 646 }, /* Acircumflexacute */
{ 0x01001ea5, 663 }, /* acircumflexacute */
{ 0x01001eac, 680 }, /* Acircumflexbelowdot */
{ 0x01001ead, 700 }, /* acircumflexbelowdot */
{ 0x01001ea6, 720 }, /* Acircumflexgrave */
{ 0x01001ea7, 737 }, /* acircumflexgrave */
{ 0x01001ea8, 754 }, /* Acircumflexhook */
{ 0x01001ea9, 770 }, /* acircumflexhook */
{ 0x01001eaa, 786 }, /* Acircumflextilde */
{ 0x01001eab, 803 }, /* acircumflextilde */
{ 0x000000b4, 820 }, /* acute */
{ 0x000000c4, 826 }, /* Adiaeresis */
{ 0x000000e4, 837 }, /* adiaeresis */
{ 0x000000c6, 848 }, /* AE */
{ 0x000000e6, 851 }, /* ae */
{ 0x000000c0, 854 }, /* Agrave */
{ 0x000000e0, 861 }, /* agrave */
{ 0x01001ea2, 868 }, /* Ahook */
{ 0x01001ea3, 874 }, /* ahook */
{ 0x0000ffe9, 880 }, /* Alt_L */
{ 0x0000ffea, 886 }, /* Alt_R */
{ 0x000003c0, 892 }, /* Amacron */
{ 0x000003e0, 900 }, /* amacron */
{ 0x00000026, 908 }, /* ampersand */
{ 0x000001a1, 918 }, /* Aogonek */
{ 0x000001b1, 926 }, /* aogonek */
{ 0x00000027, 934 }, /* apostrophe */
{ 0x01002248, 945 }, /* approxeq */
{ 0x000008c8, 954 }, /* approximate */
{ 0x01000660, 966 }, /* Arabic_0 */
{ 0x01000661, 975 }, /* Arabic_1 */
{ 0x01000662, 984 }, /* Arabic_2 */
{ 0x01000663, 993 }, /* Arabic_3 */
{ 0x01000664, 1002 }, /* Arabic_4 */
{ 0x01000665, 1011 }, /* Arabic_5 */
{ 0x01000666, 1020 }, /* Arabic_6 */
{ 0x01000667, 1029 }, /* Arabic_7 */
{ 0x01000668, 1038 }, /* Arabic_8 */
{ 0x01000669, 1047 }, /* Arabic_9 */
{ 0x000005d9, 1056 }, /* Arabic_ain */
{ 0x000005c7, 1067 }, /* Arabic_alef */
{ 0x000005e9, 1079 }, /* Arabic_alefmaksura */
{ 0x000005c8, 1098 }, /* Arabic_beh */
{ 0x000005ac, 1109 }, /* Arabic_comma */
{ 0x000005d6, 1122 }, /* Arabic_dad */
{ 0x000005cf, 1133 }, /* Arabic_dal */
{ 0x000005ef, 1144 }, /* Arabic_damma */
{ 0x000005ec, 1157 }, /* Arabic_dammatan */
{ 0x01000688, 1173 }, /* Arabic_ddal */
{ 0x010006cc, 1185 }, /* Arabic_farsi_yeh */
{ 0x000005ee, 1202 }, /* Arabic_fatha */
{ 0x000005eb, 1215 }, /* Arabic_fathatan */
{ 0x000005e1, 1231 }, /* Arabic_feh */
{ 0x010006d4, 1242 }, /* Arabic_fullstop */
{ 0x010006af, 1258 }, /* Arabic_gaf */
{ 0x000005da, 1269 }, /* Arabic_ghain */
{ 0x000005e7, 1282 }, /* Arabic_ha */
{ 0x000005cd, 1292 }, /* Arabic_hah */
{ 0x000005c1, 1303 }, /* Arabic_hamza */
{ 0x01000654, 1316 }, /* Arabic_hamza_above */
{ 0x01000655, 1335 }, /* Arabic_hamza_below */
{ 0x000005c3, 1354 }, /* Arabic_hamzaonalef */
{ 0x000005c4, 1373 }, /* Arabic_hamzaonwaw */
{ 0x000005c6, 1391 }, /* Arabic_hamzaonyeh */
{ 0x000005c5, 1409 }, /* Arabic_hamzaunderalef */
{ 0x000005e7, 1431 }, /* Arabic_heh */
{ 0x010006be, 1442 }, /* Arabic_heh_doachashmee */
{ 0x010006c1, 1465 }, /* Arabic_heh_goal */
{ 0x000005cc, 1481 }, /* Arabic_jeem */
{ 0x01000698, 1493 }, /* Arabic_jeh */
{ 0x000005e3, 1504 }, /* Arabic_kaf */
{ 0x000005f0, 1515 }, /* Arabic_kasra */
{ 0x000005ed, 1528 }, /* Arabic_kasratan */
{ 0x010006a9, 1544 }, /* Arabic_keheh */
{ 0x000005ce, 1557 }, /* Arabic_khah */
{ 0x000005e4, 1569 }, /* Arabic_lam */
{ 0x01000653, 1580 }, /* Arabic_madda_above */
{ 0x000005c2, 1599 }, /* Arabic_maddaonalef */
{ 0x000005e5, 1618 }, /* Arabic_meem */
{ 0x000005e6, 1630 }, /* Arabic_noon */
{ 0x010006ba, 1642 }, /* Arabic_noon_ghunna */
{ 0x0100067e, 1661 }, /* Arabic_peh */
{ 0x0100066a, 1672 }, /* Arabic_percent */
{ 0x000005e2, 1687 }, /* Arabic_qaf */
{ 0x000005bf, 1698 }, /* Arabic_question_mark */
{ 0x000005d1, 1719 }, /* Arabic_ra */
{ 0x01000691, 1729 }, /* Arabic_rreh */
{ 0x000005d5, 1741 }, /* Arabic_sad */
{ 0x000005d3, 1752 }, /* Arabic_seen */
{ 0x000005bb, 1764 }, /* Arabic_semicolon */
{ 0x000005f1, 1781 }, /* Arabic_shadda */
{ 0x000005d4, 1795 }, /* Arabic_sheen */
{ 0x000005f2, 1808 }, /* Arabic_sukun */
{ 0x01000670, 1821 }, /* Arabic_superscript_alef */
{ 0x0000ff7e, 1845 }, /* Arabic_switch */
{ 0x000005d7, 1859 }, /* Arabic_tah */
{ 0x000005e0, 1870 }, /* Arabic_tatweel */
{ 0x01000686, 1885 }, /* Arabic_tcheh */
{ 0x000005ca, 1898 }, /* Arabic_teh */
{ 0x000005c9, 1909 }, /* Arabic_tehmarbuta */
{ 0x000005d0, 1927 }, /* Arabic_thal */
{ 0x000005cb, 1939 }, /* Arabic_theh */
{ 0x01000679, 1951 }, /* Arabic_tteh */
{ 0x010006a4, 1963 }, /* Arabic_veh */
{ 0x000005e8, 1974 }, /* Arabic_waw */
{ 0x000005ea, 1985 }, /* Arabic_yeh */
{ 0x010006d2, 1996 }, /* Arabic_yeh_baree */
{ 0x000005d8, 2013 }, /* Arabic_zah */
{ 0x000005d2, 2024 }, /* Arabic_zain */
{ 0x000000c5, 2036 }, /* Aring */
{ 0x000000e5, 2042 }, /* aring */
{ 0x0100055b, 2048 }, /* Armenian_accent */
{ 0x0100055c, 2064 }, /* Armenian_amanak */
{ 0x0100055a, 2080 }, /* Armenian_apostrophe */
{ 0x01000538, 2100 }, /* Armenian_AT */
{ 0x01000568, 2112 }, /* Armenian_at */
{ 0x01000531, 2124 }, /* Armenian_AYB */
{ 0x01000561, 2137 }, /* Armenian_ayb */
{ 0x01000532, 2150 }, /* Armenian_BEN */
{ 0x01000562, 2163 }, /* Armenian_ben */
{ 0x0100055d, 2176 }, /* Armenian_but */
{ 0x01000549, 2189 }, /* Armenian_CHA */
{ 0x01000579, 2202 }, /* Armenian_cha */
{ 0x01000534, 2215 }, /* Armenian_DA */
{ 0x01000564, 2227 }, /* Armenian_da */
{ 0x01000541, 2239 }, /* Armenian_DZA */
{ 0x01000571, 2252 }, /* Armenian_dza */
{ 0x01000537, 2265 }, /* Armenian_E */
{ 0x01000567, 2276 }, /* Armenian_e */
{ 0x0100055c, 2287 }, /* Armenian_exclam */
{ 0x01000556, 2303 }, /* Armenian_FE */
{ 0x01000586, 2315 }, /* Armenian_fe */
{ 0x01000589, 2327 }, /* Armenian_full_stop */
{ 0x01000542, 2346 }, /* Armenian_GHAT */
{ 0x01000572, 2360 }, /* Armenian_ghat */
{ 0x01000533, 2374 }, /* Armenian_GIM */
{ 0x01000563, 2387 }, /* Armenian_gim */
{ 0x01000545, 2400 }, /* Armenian_HI */
{ 0x01000575, 2412 }, /* Armenian_hi */
{ 0x01000540, 2424 }, /* Armenian_HO */
{ 0x01000570, 2436 }, /* Armenian_ho */
{ 0x0100058a, 2448 }, /* Armenian_hyphen */
{ 0x0100053b, 2464 }, /* Armenian_INI */
{ 0x0100056b, 2477 }, /* Armenian_ini */
{ 0x0100054b, 2490 }, /* Armenian_JE */
{ 0x0100057b, 2502 }, /* Armenian_je */
{ 0x01000554, 2514 }, /* Armenian_KE */
{ 0x01000584, 2526 }, /* Armenian_ke */
{ 0x0100053f, 2538 }, /* Armenian_KEN */
{ 0x0100056f, 2551 }, /* Armenian_ken */
{ 0x0100053d, 2564 }, /* Armenian_KHE */
{ 0x0100056d, 2577 }, /* Armenian_khe */
{ 0x01000587, 2590 }, /* Armenian_ligature_ew */
{ 0x0100053c, 2611 }, /* Armenian_LYUN */
{ 0x0100056c, 2625 }, /* Armenian_lyun */
{ 0x01000544, 2639 }, /* Armenian_MEN */
{ 0x01000574, 2652 }, /* Armenian_men */
{ 0x01000546, 2665 }, /* Armenian_NU */
{ 0x01000576, 2677 }, /* Armenian_nu */
{ 0x01000555, 2689 }, /* Armenian_O */
{ 0x01000585, 2700 }, /* Armenian_o */
{ 0x0100055e, 2711 }, /* Armenian_paruyk */
{ 0x0100054a, 2727 }, /* Armenian_PE */
{ 0x0100057a, 2739 }, /* Armenian_pe */
{ 0x01000553, 2751 }, /* Armenian_PYUR */
{ 0x01000583, 2765 }, /* Armenian_pyur */
{ 0x0100055e, 2779 }, /* Armenian_question */
{ 0x0100054c, 2797 }, /* Armenian_RA */
{ 0x0100057c, 2809 }, /* Armenian_ra */
{ 0x01000550, 2821 }, /* Armenian_RE */
{ 0x01000580, 2833 }, /* Armenian_re */
{ 0x0100054d, 2845 }, /* Armenian_SE */
{ 0x0100057d, 2857 }, /* Armenian_se */
{ 0x0100055d, 2869 }, /* Armenian_separation_mark */
{ 0x01000547, 2894 }, /* Armenian_SHA */
{ 0x01000577, 2907 }, /* Armenian_sha */
{ 0x0100055b, 2920 }, /* Armenian_shesht */
{ 0x01000543, 2936 }, /* Armenian_TCHE */
{ 0x01000573, 2950 }, /* Armenian_tche */
{ 0x01000539, 2964 }, /* Armenian_TO */
{ 0x01000569, 2976 }, /* Armenian_to */
{ 0x0100053e, 2988 }, /* Armenian_TSA */
{ 0x0100056e, 3001 }, /* Armenian_tsa */
{ 0x01000551, 3014 }, /* Armenian_TSO */
{ 0x01000581, 3027 }, /* Armenian_tso */
{ 0x0100054f, 3040 }, /* Armenian_TYUN */
{ 0x0100057f, 3054 }, /* Armenian_tyun */
{ 0x01000589, 3068 }, /* Armenian_verjaket */
{ 0x0100054e, 3086 }, /* Armenian_VEV */
{ 0x0100057e, 3099 }, /* Armenian_vev */
{ 0x01000548, 3112 }, /* Armenian_VO */
{ 0x01000578, 3124 }, /* Armenian_vo */
{ 0x01000552, 3136 }, /* Armenian_VYUN */
{ 0x01000582, 3150 }, /* Armenian_vyun */
{ 0x01000535, 3164 }, /* Armenian_YECH */
{ 0x01000565, 3178 }, /* Armenian_yech */
{ 0x0100058a, 3192 }, /* Armenian_yentamna */
{ 0x01000536, 3210 }, /* Armenian_ZA */
{ 0x01000566, 3222 }, /* Armenian_za */
{ 0x0100053a, 3234 }, /* Armenian_ZHE */
{ 0x0100056a, 3247 }, /* Armenian_zhe */
{ 0x0000005e, 3260 }, /* asciicircum */
{ 0x0000007e, 3272 }, /* asciitilde */
{ 0x0000002a, 3283 }, /* asterisk */
{ 0x00000040, 3292 }, /* at */
{ 0x000000c3, 3295 }, /* Atilde */
{ 0x000000e3, 3302 }, /* atilde */
{ 0x0000fe7a, 3309 }, /* AudibleBell_Enable */
{ 0x00000042, 3328 }, /* B */
{ 0x00000062, 3330 }, /* b */
{ 0x01001e02, 3332 }, /* Babovedot */
{ 0x01001e03, 3342 }, /* babovedot */
{ 0x0000005c, 3352 }, /* backslash */
{ 0x0000ff08, 3362 }, /* BackSpace */
{ 0x1000ff74, 3372 }, /* BackTab */
{ 0x00000af4, 3380 }, /* ballotcross */
{ 0x0000007c, 3392 }, /* bar */
{ 0x01002235, 3396 }, /* because */
{ 0x0000ff58, 3404 }, /* Begin */
{ 0x000009df, 3410 }, /* blank */
{ 0x100000fc, 3416 }, /* block */
{ 0x000008a5, 3422 }, /* botintegral */
{ 0x000008ac, 3434 }, /* botleftparens */
{ 0x000008a8, 3448 }, /* botleftsqbracket */
{ 0x000008b2, 3465 }, /* botleftsummation */
{ 0x000008ae, 3482 }, /* botrightparens */
{ 0x000008aa, 3497 }, /* botrightsqbracket */
{ 0x000008b6, 3515 }, /* botrightsummation */
{ 0x000009f6, 3533 }, /* bott */
{ 0x000008b4, 3538 }, /* botvertsummationconnector */
{ 0x0000fe74, 3564 }, /* BounceKeys_Enable */
{ 0x0000007b, 3582 }, /* braceleft */
{ 0x0000007d, 3592 }, /* braceright */
{ 0x0000005b, 3603 }, /* bracketleft */
{ 0x0000005d, 3615 }, /* bracketright */
{ 0x01002800, 3628 }, /* braille_blank */
{ 0x0000fff1, 3642 }, /* braille_dot_1 */
{ 0x0000fffa, 3656 }, /* braille_dot_10 */
{ 0x0000fff2, 3671 }, /* braille_dot_2 */
{ 0x0000fff3, 3685 }, /* braille_dot_3 */
{ 0x0000fff4, 3699 }, /* braille_dot_4 */
{ 0x0000fff5, 3713 }, /* braille_dot_5 */
{ 0x0000fff6, 3727 }, /* braille_dot_6 */
{ 0x0000fff7, 3741 }, /* braille_dot_7 */
{ 0x0000fff8, 3755 }, /* braille_dot_8 */
{ 0x0000fff9, 3769 }, /* braille_dot_9 */
{ 0x01002801, 3783 }, /* braille_dots_1 */
{ 0x01002803, 3798 }, /* braille_dots_12 */
{ 0x01002807, 3814 }, /* braille_dots_123 */
{ 0x0100280f, 3831 }, /* braille_dots_1234 */
{ 0x0100281f, 3849 }, /* braille_dots_12345 */
{ 0x0100283f, 3868 }, /* braille_dots_123456 */
{ 0x0100287f, 3888 }, /* braille_dots_1234567 */
{ 0x010028ff, 3909 }, /* braille_dots_12345678 */
{ 0x010028bf, 3931 }, /* braille_dots_1234568 */
{ 0x0100285f, 3952 }, /* braille_dots_123457 */
{ 0x010028df, 3972 }, /* braille_dots_1234578 */
{ 0x0100289f, 3993 }, /* braille_dots_123458 */
{ 0x0100282f, 4013 }, /* braille_dots_12346 */
{ 0x0100286f, 4032 }, /* braille_dots_123467 */
{ 0x010028ef, 4052 }, /* braille_dots_1234678 */
{ 0x010028af, 4073 }, /* braille_dots_123468 */
{ 0x0100284f, 4093 }, /* braille_dots_12347 */
{ 0x010028cf, 4112 }, /* braille_dots_123478 */
{ 0x0100288f, 4132 }, /* braille_dots_12348 */
{ 0x01002817, 4151 }, /* braille_dots_1235 */
{ 0x01002837, 4169 }, /* braille_dots_12356 */
{ 0x01002877, 4188 }, /* braille_dots_123567 */
{ 0x010028f7, 4208 }, /* braille_dots_1235678 */
{ 0x010028b7, 4229 }, /* braille_dots_123568 */
{ 0x01002857, 4249 }, /* braille_dots_12357 */
{ 0x010028d7, 4268 }, /* braille_dots_123578 */
{ 0x01002897, 4288 }, /* braille_dots_12358 */
{ 0x01002827, 4307 }, /* braille_dots_1236 */
{ 0x01002867, 4325 }, /* braille_dots_12367 */
{ 0x010028e7, 4344 }, /* braille_dots_123678 */
{ 0x010028a7, 4364 }, /* braille_dots_12368 */
{ 0x01002847, 4383 }, /* braille_dots_1237 */
{ 0x010028c7, 4401 }, /* braille_dots_12378 */
{ 0x01002887, 4420 }, /* braille_dots_1238 */
{ 0x0100280b, 4438 }, /* braille_dots_124 */
{ 0x0100281b, 4455 }, /* braille_dots_1245 */
{ 0x0100283b, 4473 }, /* braille_dots_12456 */
{ 0x0100287b, 4492 }, /* braille_dots_124567 */
{ 0x010028fb, 4512 }, /* braille_dots_1245678 */
{ 0x010028bb, 4533 }, /* braille_dots_124568 */
{ 0x0100285b, 4553 }, /* braille_dots_12457 */
{ 0x010028db, 4572 }, /* braille_dots_124578 */
{ 0x0100289b, 4592 }, /* braille_dots_12458 */
{ 0x0100282b, 4611 }, /* braille_dots_1246 */
{ 0x0100286b, 4629 }, /* braille_dots_12467 */
{ 0x010028eb, 4648 }, /* braille_dots_124678 */
{ 0x010028ab, 4668 }, /* braille_dots_12468 */
{ 0x0100284b, 4687 }, /* braille_dots_1247 */
{ 0x010028cb, 4705 }, /* braille_dots_12478 */
{ 0x0100288b, 4724 }, /* braille_dots_1248 */
{ 0x01002813, 4742 }, /* braille_dots_125 */
{ 0x01002833, 4759 }, /* braille_dots_1256 */
{ 0x01002873, 4777 }, /* braille_dots_12567 */
{ 0x010028f3, 4796 }, /* braille_dots_125678 */
{ 0x010028b3, 4816 }, /* braille_dots_12568 */
{ 0x01002853, 4835 }, /* braille_dots_1257 */
{ 0x010028d3, 4853 }, /* braille_dots_12578 */
{ 0x01002893, 4872 }, /* braille_dots_1258 */
{ 0x01002823, 4890 }, /* braille_dots_126 */
{ 0x01002863, 4907 }, /* braille_dots_1267 */
{ 0x010028e3, 4925 }, /* braille_dots_12678 */
{ 0x010028a3, 4944 }, /* braille_dots_1268 */
{ 0x01002843, 4962 }, /* braille_dots_127 */
{ 0x010028c3, 4979 }, /* braille_dots_1278 */
{ 0x01002883, 4997 }, /* braille_dots_128 */
{ 0x01002805, 5014 }, /* braille_dots_13 */
{ 0x0100280d, 5030 }, /* braille_dots_134 */
{ 0x0100281d, 5047 }, /* braille_dots_1345 */
{ 0x0100283d, 5065 }, /* braille_dots_13456 */
{ 0x0100287d, 5084 }, /* braille_dots_134567 */
{ 0x010028fd, 5104 }, /* braille_dots_1345678 */
{ 0x010028bd, 5125 }, /* braille_dots_134568 */
{ 0x0100285d, 5145 }, /* braille_dots_13457 */
{ 0x010028dd, 5164 }, /* braille_dots_134578 */
{ 0x0100289d, 5184 }, /* braille_dots_13458 */
{ 0x0100282d, 5203 }, /* braille_dots_1346 */
{ 0x0100286d, 5221 }, /* braille_dots_13467 */
{ 0x010028ed, 5240 }, /* braille_dots_134678 */
{ 0x010028ad, 5260 }, /* braille_dots_13468 */
{ 0x0100284d, 5279 }, /* braille_dots_1347 */
{ 0x010028cd, 5297 }, /* braille_dots_13478 */
{ 0x0100288d, 5316 }, /* braille_dots_1348 */
{ 0x01002815, 5334 }, /* braille_dots_135 */
{ 0x01002835, 5351 }, /* braille_dots_1356 */
{ 0x01002875, 5369 }, /* braille_dots_13567 */
{ 0x010028f5, 5388 }, /* braille_dots_135678 */
{ 0x010028b5, 5408 }, /* braille_dots_13568 */
{ 0x01002855, 5427 }, /* braille_dots_1357 */
{ 0x010028d5, 5445 }, /* braille_dots_13578 */
{ 0x01002895, 5464 }, /* braille_dots_1358 */
{ 0x01002825, 5482 }, /* braille_dots_136 */
{ 0x01002865, 5499 }, /* braille_dots_1367 */
{ 0x010028e5, 5517 }, /* braille_dots_13678 */
{ 0x010028a5, 5536 }, /* braille_dots_1368 */
{ 0x01002845, 5554 }, /* braille_dots_137 */
{ 0x010028c5, 5571 }, /* braille_dots_1378 */
{ 0x01002885, 5589 }, /* braille_dots_138 */
{ 0x01002809, 5606 }, /* braille_dots_14 */
{ 0x01002819, 5622 }, /* braille_dots_145 */
{ 0x01002839, 5639 }, /* braille_dots_1456 */
{ 0x01002879, 5657 }, /* braille_dots_14567 */
{ 0x010028f9, 5676 }, /* braille_dots_145678 */
{ 0x010028b9, 5696 }, /* braille_dots_14568 */
{ 0x01002859, 5715 }, /* braille_dots_1457 */
{ 0x010028d9, 5733 }, /* braille_dots_14578 */
{ 0x01002899, 5752 }, /* braille_dots_1458 */
{ 0x01002829, 5770 }, /* braille_dots_146 */
{ 0x01002869, 5787 }, /* braille_dots_1467 */
{ 0x010028e9, 5805 }, /* braille_dots_14678 */
{ 0x010028a9, 5824 }, /* braille_dots_1468 */
{ 0x01002849, 5842 }, /* braille_dots_147 */
{ 0x010028c9, 5859 }, /* braille_dots_1478 */
{ 0x01002889, 5877 }, /* braille_dots_148 */
{ 0x01002811, 5894 }, /* braille_dots_15 */
{ 0x01002831, 5910 }, /* braille_dots_156 */
{ 0x01002871, 5927 }, /* braille_dots_1567 */
{ 0x010028f1, 5945 }, /* braille_dots_15678 */
{ 0x010028b1, 5964 }, /* braille_dots_1568 */
{ 0x01002851, 5982 }, /* braille_dots_157 */
{ 0x010028d1, 5999 }, /* braille_dots_1578 */
{ 0x01002891, 6017 }, /* braille_dots_158 */
{ 0x01002821, 6034 }, /* braille_dots_16 */
{ 0x01002861, 6050 }, /* braille_dots_167 */
{ 0x010028e1, 6067 }, /* braille_dots_1678 */
{ 0x010028a1, 6085 }, /* braille_dots_168 */
{ 0x01002841, 6102 }, /* braille_dots_17 */
{ 0x010028c1, 6118 }, /* braille_dots_178 */
{ 0x01002881, 6135 }, /* braille_dots_18 */
{ 0x01002802, 6151 }, /* braille_dots_2 */
{ 0x01002806, 6166 }, /* braille_dots_23 */
{ 0x0100280e, 6182 }, /* braille_dots_234 */
{ 0x0100281e, 6199 }, /* braille_dots_2345 */
{ 0x0100283e, 6217 }, /* braille_dots_23456 */
{ 0x0100287e, 6236 }, /* braille_dots_234567 */
{ 0x010028fe, 6256 }, /* braille_dots_2345678 */
{ 0x010028be, 6277 }, /* braille_dots_234568 */
{ 0x0100285e, 6297 }, /* braille_dots_23457 */
{ 0x010028de, 6316 }, /* braille_dots_234578 */
{ 0x0100289e, 6336 }, /* braille_dots_23458 */
{ 0x0100282e, 6355 }, /* braille_dots_2346 */
{ 0x0100286e, 6373 }, /* braille_dots_23467 */
{ 0x010028ee, 6392 }, /* braille_dots_234678 */
{ 0x010028ae, 6412 }, /* braille_dots_23468 */
{ 0x0100284e, 6431 }, /* braille_dots_2347 */
{ 0x010028ce, 6449 }, /* braille_dots_23478 */
{ 0x0100288e, 6468 }, /* braille_dots_2348 */
{ 0x01002816, 6486 }, /* braille_dots_235 */
{ 0x01002836, 6503 }, /* braille_dots_2356 */
{ 0x01002876, 6521 }, /* braille_dots_23567 */
{ 0x010028f6, 6540 }, /* braille_dots_235678 */
{ 0x010028b6, 6560 }, /* braille_dots_23568 */
{ 0x01002856, 6579 }, /* braille_dots_2357 */
{ 0x010028d6, 6597 }, /* braille_dots_23578 */
{ 0x01002896, 6616 }, /* braille_dots_2358 */
{ 0x01002826, 6634 }, /* braille_dots_236 */
{ 0x01002866, 6651 }, /* braille_dots_2367 */
{ 0x010028e6, 6669 }, /* braille_dots_23678 */
{ 0x010028a6, 6688 }, /* braille_dots_2368 */
{ 0x01002846, 6706 }, /* braille_dots_237 */
{ 0x010028c6, 6723 }, /* braille_dots_2378 */
{ 0x01002886, 6741 }, /* braille_dots_238 */
{ 0x0100280a, 6758 }, /* braille_dots_24 */
{ 0x0100281a, 6774 }, /* braille_dots_245 */
{ 0x0100283a, 6791 }, /* braille_dots_2456 */
{ 0x0100287a, 6809 }, /* braille_dots_24567 */
{ 0x010028fa, 6828 }, /* braille_dots_245678 */
{ 0x010028ba, 6848 }, /* braille_dots_24568 */
{ 0x0100285a, 6867 }, /* braille_dots_2457 */
{ 0x010028da, 6885 }, /* braille_dots_24578 */
{ 0x0100289a, 6904 }, /* braille_dots_2458 */
{ 0x0100282a, 6922 }, /* braille_dots_246 */
{ 0x0100286a, 6939 }, /* braille_dots_2467 */
{ 0x010028ea, 6957 }, /* braille_dots_24678 */
{ 0x010028aa, 6976 }, /* braille_dots_2468 */
{ 0x0100284a, 6994 }, /* braille_dots_247 */
{ 0x010028ca, 7011 }, /* braille_dots_2478 */
{ 0x0100288a, 7029 }, /* braille_dots_248 */
{ 0x01002812, 7046 }, /* braille_dots_25 */
{ 0x01002832, 7062 }, /* braille_dots_256 */
{ 0x01002872, 7079 }, /* braille_dots_2567 */
{ 0x010028f2, 7097 }, /* braille_dots_25678 */
{ 0x010028b2, 7116 }, /* braille_dots_2568 */
{ 0x01002852, 7134 }, /* braille_dots_257 */
{ 0x010028d2, 7151 }, /* braille_dots_2578 */
{ 0x01002892, 7169 }, /* braille_dots_258 */
{ 0x01002822, 7186 }, /* braille_dots_26 */
{ 0x01002862, 7202 }, /* braille_dots_267 */
{ 0x010028e2, 7219 }, /* braille_dots_2678 */
{ 0x010028a2, 7237 }, /* braille_dots_268 */
{ 0x01002842, 7254 }, /* braille_dots_27 */
{ 0x010028c2, 7270 }, /* braille_dots_278 */
{ 0x01002882, 7287 }, /* braille_dots_28 */
{ 0x01002804, 7303 }, /* braille_dots_3 */
{ 0x0100280c, 7318 }, /* braille_dots_34 */
{ 0x0100281c, 7334 }, /* braille_dots_345 */
{ 0x0100283c, 7351 }, /* braille_dots_3456 */
{ 0x0100287c, 7369 }, /* braille_dots_34567 */
{ 0x010028fc, 7388 }, /* braille_dots_345678 */
{ 0x010028bc, 7408 }, /* braille_dots_34568 */
{ 0x0100285c, 7427 }, /* braille_dots_3457 */
{ 0x010028dc, 7445 }, /* braille_dots_34578 */
{ 0x0100289c, 7464 }, /* braille_dots_3458 */
{ 0x0100282c, 7482 }, /* braille_dots_346 */
{ 0x0100286c, 7499 }, /* braille_dots_3467 */
{ 0x010028ec, 7517 }, /* braille_dots_34678 */
{ 0x010028ac, 7536 }, /* braille_dots_3468 */
{ 0x0100284c, 7554 }, /* braille_dots_347 */
{ 0x010028cc, 7571 }, /* braille_dots_3478 */
{ 0x0100288c, 7589 }, /* braille_dots_348 */
{ 0x01002814, 7606 }, /* braille_dots_35 */
{ 0x01002834, 7622 }, /* braille_dots_356 */
{ 0x01002874, 7639 }, /* braille_dots_3567 */
{ 0x010028f4, 7657 }, /* braille_dots_35678 */
{ 0x010028b4, 7676 }, /* braille_dots_3568 */
{ 0x01002854, 7694 }, /* braille_dots_357 */
{ 0x010028d4, 7711 }, /* braille_dots_3578 */
{ 0x01002894, 7729 }, /* braille_dots_358 */
{ 0x01002824, 7746 }, /* braille_dots_36 */
{ 0x01002864, 7762 }, /* braille_dots_367 */
{ 0x010028e4, 7779 }, /* braille_dots_3678 */
{ 0x010028a4, 7797 }, /* braille_dots_368 */
{ 0x01002844, 7814 }, /* braille_dots_37 */
{ 0x010028c4, 7830 }, /* braille_dots_378 */
{ 0x01002884, 7847 }, /* braille_dots_38 */
{ 0x01002808, 7863 }, /* braille_dots_4 */
{ 0x01002818, 7878 }, /* braille_dots_45 */
{ 0x01002838, 7894 }, /* braille_dots_456 */
{ 0x01002878, 7911 }, /* braille_dots_4567 */
{ 0x010028f8, 7929 }, /* braille_dots_45678 */
{ 0x010028b8, 7948 }, /* braille_dots_4568 */
{ 0x01002858, 7966 }, /* braille_dots_457 */
{ 0x010028d8, 7983 }, /* braille_dots_4578 */
{ 0x01002898, 8001 }, /* braille_dots_458 */
{ 0x01002828, 8018 }, /* braille_dots_46 */
{ 0x01002868, 8034 }, /* braille_dots_467 */
{ 0x010028e8, 8051 }, /* braille_dots_4678 */
{ 0x010028a8, 8069 }, /* braille_dots_468 */
{ 0x01002848, 8086 }, /* braille_dots_47 */
{ 0x010028c8, 8102 }, /* braille_dots_478 */
{ 0x01002888, 8119 }, /* braille_dots_48 */
{ 0x01002810, 8135 }, /* braille_dots_5 */
{ 0x01002830, 8150 }, /* braille_dots_56 */
{ 0x01002870, 8166 }, /* braille_dots_567 */
{ 0x010028f0, 8183 }, /* braille_dots_5678 */
{ 0x010028b0, 8201 }, /* braille_dots_568 */
{ 0x01002850, 8218 }, /* braille_dots_57 */
{ 0x010028d0, 8234 }, /* braille_dots_578 */
{ 0x01002890, 8251 }, /* braille_dots_58 */
{ 0x01002820, 8267 }, /* braille_dots_6 */
{ 0x01002860, 8282 }, /* braille_dots_67 */
{ 0x010028e0, 8298 }, /* braille_dots_678 */
{ 0x010028a0, 8315 }, /* braille_dots_68 */
{ 0x01002840, 8331 }, /* braille_dots_7 */
{ 0x010028c0, 8346 }, /* braille_dots_78 */
{ 0x01002880, 8362 }, /* braille_dots_8 */
{ 0x0000ff6b, 8377 }, /* Break */
{ 0x000001a2, 8383 }, /* breve */
{ 0x000000a6, 8389 }, /* brokenbar */
{ 0x000006ae, 8399 }, /* Byelorussian_shortu */
{ 0x000006be, 8419 }, /* Byelorussian_SHORTU */
{ 0x00000043, 8439 }, /* C */
{ 0x00000063, 8441 }, /* c */
{ 0x0000fea3, 8443 }, /* c_h */
{ 0x0000fea4, 8447 }, /* C_h */
{ 0x0000fea5, 8451 }, /* C_H */
{ 0x000002c5, 8455 }, /* Cabovedot */
{ 0x000002e5, 8465 }, /* cabovedot */
{ 0x000001c6, 8475 }, /* Cacute */
{ 0x000001e6, 8482 }, /* cacute */
{ 0x0000ff69, 8489 }, /* Cancel */
{ 0x0000ffe5, 8496 }, /* Caps_Lock */
{ 0x00000ab8, 8506 }, /* careof */
{ 0x00000afc, 8513 }, /* caret */
{ 0x000001b7, 8519 }, /* caron */
{ 0x000001c8, 8525 }, /* Ccaron */
{ 0x000001e8, 8532 }, /* ccaron */
{ 0x000000c7, 8539 }, /* Ccedilla */
{ 0x000000e7, 8548 }, /* ccedilla */
{ 0x000002c6, 8557 }, /* Ccircumflex */
{ 0x000002e6, 8569 }, /* ccircumflex */
{ 0x000000b8, 8581 }, /* cedilla */
{ 0x000000a2, 8589 }, /* cent */
{ 0x0000fea0, 8594 }, /* ch */
{ 0x0000fea1, 8597 }, /* Ch */
{ 0x0000fea2, 8600 }, /* CH */
{ 0x000009e1, 8603 }, /* checkerboard */
{ 0x00000af3, 8616 }, /* checkmark */
{ 0x00000bcf, 8626 }, /* circle */
{ 0x0000ff0b, 8633 }, /* Clear */
{ 0x1000ff6f, 8639 }, /* ClearLine */
{ 0x00000aec, 8649 }, /* club */
{ 0x0000ff37, 8654 }, /* Codeinput */
{ 0x0000003a, 8664 }, /* colon */
{ 0x010020a1, 8670 }, /* ColonSign */
{ 0x01000301, 8680 }, /* combining_acute */
{ 0x01000323, 8696 }, /* combining_belowdot */
{ 0x01000300, 8715 }, /* combining_grave */
{ 0x01000309, 8731 }, /* combining_hook */
{ 0x01000303, 8746 }, /* combining_tilde */
{ 0x0000002c, 8762 }, /* comma */
{ 0x0100220b, 8768 }, /* containsas */
{ 0x0000ffe3, 8779 }, /* Control_L */
{ 0x0000ffe4, 8789 }, /* Control_R */
{ 0x000000a9, 8799 }, /* copyright */
{ 0x000009e4, 8809 }, /* cr */
{ 0x000009ee, 8812 }, /* crossinglines */
{ 0x010020a2, 8826 }, /* CruzeiroSign */
{ 0x0100221b, 8839 }, /* cuberoot */
{ 0x000000a4, 8848 }, /* currency */
{ 0x00000aff, 8857 }, /* cursor */
{ 0x000006c1, 8864 }, /* Cyrillic_a */
{ 0x000006e1, 8875 }, /* Cyrillic_A */
{ 0x000006c2, 8886 }, /* Cyrillic_be */
{ 0x000006e2, 8898 }, /* Cyrillic_BE */
{ 0x000006de, 8910 }, /* Cyrillic_che */
{ 0x000006fe, 8923 }, /* Cyrillic_CHE */
{ 0x010004b6, 8936 }, /* Cyrillic_CHE_descender */
{ 0x010004b7, 8959 }, /* Cyrillic_che_descender */
{ 0x010004b8, 8982 }, /* Cyrillic_CHE_vertstroke */
{ 0x010004b9, 9006 }, /* Cyrillic_che_vertstroke */
{ 0x000006c4, 9030 }, /* Cyrillic_de */
{ 0x000006e4, 9042 }, /* Cyrillic_DE */
{ 0x000006af, 9054 }, /* Cyrillic_dzhe */
{ 0x000006bf, 9068 }, /* Cyrillic_DZHE */
{ 0x000006dc, 9082 }, /* Cyrillic_e */
{ 0x000006fc, 9093 }, /* Cyrillic_E */
{ 0x000006c6, 9104 }, /* Cyrillic_ef */
{ 0x000006e6, 9116 }, /* Cyrillic_EF */
{ 0x000006cc, 9128 }, /* Cyrillic_el */
{ 0x000006ec, 9140 }, /* Cyrillic_EL */
{ 0x000006cd, 9152 }, /* Cyrillic_em */
{ 0x000006ed, 9164 }, /* Cyrillic_EM */
{ 0x000006ce, 9176 }, /* Cyrillic_en */
{ 0x000006ee, 9188 }, /* Cyrillic_EN */
{ 0x010004a2, 9200 }, /* Cyrillic_EN_descender */
{ 0x010004a3, 9222 }, /* Cyrillic_en_descender */
{ 0x000006d2, 9244 }, /* Cyrillic_er */
{ 0x000006f2, 9256 }, /* Cyrillic_ER */
{ 0x000006d3, 9268 }, /* Cyrillic_es */
{ 0x000006f3, 9280 }, /* Cyrillic_ES */
{ 0x000006c7, 9292 }, /* Cyrillic_ghe */
{ 0x000006e7, 9305 }, /* Cyrillic_GHE */
{ 0x01000492, 9318 }, /* Cyrillic_GHE_bar */
{ 0x01000493, 9335 }, /* Cyrillic_ghe_bar */
{ 0x000006c8, 9352 }, /* Cyrillic_ha */
{ 0x000006e8, 9364 }, /* Cyrillic_HA */
{ 0x010004b2, 9376 }, /* Cyrillic_HA_descender */
{ 0x010004b3, 9398 }, /* Cyrillic_ha_descender */
{ 0x000006df, 9420 }, /* Cyrillic_hardsign */
{ 0x000006ff, 9438 }, /* Cyrillic_HARDSIGN */
{ 0x000006c9, 9456 }, /* Cyrillic_i */
{ 0x000006e9, 9467 }, /* Cyrillic_I */
{ 0x010004e2, 9478 }, /* Cyrillic_I_macron */
{ 0x010004e3, 9496 }, /* Cyrillic_i_macron */
{ 0x000006c5, 9514 }, /* Cyrillic_ie */
{ 0x000006e5, 9526 }, /* Cyrillic_IE */
{ 0x000006a3, 9538 }, /* Cyrillic_io */
{ 0x000006b3, 9550 }, /* Cyrillic_IO */
{ 0x000006a8, 9562 }, /* Cyrillic_je */
{ 0x000006b8, 9574 }, /* Cyrillic_JE */
{ 0x000006cb, 9586 }, /* Cyrillic_ka */
{ 0x000006eb, 9598 }, /* Cyrillic_KA */
{ 0x0100049a, 9610 }, /* Cyrillic_KA_descender */
{ 0x0100049b, 9632 }, /* Cyrillic_ka_descender */
{ 0x0100049c, 9654 }, /* Cyrillic_KA_vertstroke */
{ 0x0100049d, 9677 }, /* Cyrillic_ka_vertstroke */
{ 0x000006a9, 9700 }, /* Cyrillic_lje */
{ 0x000006b9, 9713 }, /* Cyrillic_LJE */
{ 0x000006aa, 9726 }, /* Cyrillic_nje */
{ 0x000006ba, 9739 }, /* Cyrillic_NJE */
{ 0x000006cf, 9752 }, /* Cyrillic_o */
{ 0x000006ef, 9763 }, /* Cyrillic_O */
{ 0x010004e8, 9774 }, /* Cyrillic_O_bar */
{ 0x010004e9, 9789 }, /* Cyrillic_o_bar */
{ 0x000006d0, 9804 }, /* Cyrillic_pe */
{ 0x000006f0, 9816 }, /* Cyrillic_PE */
{ 0x010004d8, 9828 }, /* Cyrillic_SCHWA */
{ 0x010004d9, 9843 }, /* Cyrillic_schwa */
{ 0x000006db, 9858 }, /* Cyrillic_sha */
{ 0x000006fb, 9871 }, /* Cyrillic_SHA */
{ 0x000006dd, 9884 }, /* Cyrillic_shcha */
{ 0x000006fd, 9899 }, /* Cyrillic_SHCHA */
{ 0x010004ba, 9914 }, /* Cyrillic_SHHA */
{ 0x010004bb, 9928 }, /* Cyrillic_shha */
{ 0x000006ca, 9942 }, /* Cyrillic_shorti */
{ 0x000006ea, 9958 }, /* Cyrillic_SHORTI */
{ 0x000006d8, 9974 }, /* Cyrillic_softsign */
{ 0x000006f8, 9992 }, /* Cyrillic_SOFTSIGN */
{ 0x000006d4, 10010 }, /* Cyrillic_te */
{ 0x000006f4, 10022 }, /* Cyrillic_TE */
{ 0x000006c3, 10034 }, /* Cyrillic_tse */
{ 0x000006e3, 10047 }, /* Cyrillic_TSE */
{ 0x000006d5, 10060 }, /* Cyrillic_u */
{ 0x000006f5, 10071 }, /* Cyrillic_U */
{ 0x010004ee, 10082 }, /* Cyrillic_U_macron */
{ 0x010004ef, 10100 }, /* Cyrillic_u_macron */
{ 0x010004ae, 10118 }, /* Cyrillic_U_straight */
{ 0x010004af, 10138 }, /* Cyrillic_u_straight */
{ 0x010004b0, 10158 }, /* Cyrillic_U_straight_bar */
{ 0x010004b1, 10182 }, /* Cyrillic_u_straight_bar */
{ 0x000006d7, 10206 }, /* Cyrillic_ve */
{ 0x000006f7, 10218 }, /* Cyrillic_VE */
{ 0x000006d1, 10230 }, /* Cyrillic_ya */
{ 0x000006f1, 10242 }, /* Cyrillic_YA */
{ 0x000006d9, 10254 }, /* Cyrillic_yeru */
{ 0x000006f9, 10268 }, /* Cyrillic_YERU */
{ 0x000006c0, 10282 }, /* Cyrillic_yu */
{ 0x000006e0, 10294 }, /* Cyrillic_YU */
{ 0x000006da, 10306 }, /* Cyrillic_ze */
{ 0x000006fa, 10318 }, /* Cyrillic_ZE */
{ 0x000006d6, 10330 }, /* Cyrillic_zhe */
{ 0x000006f6, 10343 }, /* Cyrillic_ZHE */
{ 0x01000496, 10356 }, /* Cyrillic_ZHE_descender */
{ 0x01000497, 10379 }, /* Cyrillic_zhe_descender */
{ 0x00000044, 10402 }, /* D */
{ 0x00000064, 10404 }, /* d */
{ 0x01001e0a, 10406 }, /* Dabovedot */
{ 0x01001e0b, 10416 }, /* dabovedot */
{ 0x1000fe27, 10426 }, /* Dacute_accent */
{ 0x00000af1, 10440 }, /* dagger */
{ 0x000001cf, 10447 }, /* Dcaron */
{ 0x000001ef, 10454 }, /* dcaron */
{ 0x1000fe2c, 10461 }, /* Dcedilla_accent */
{ 0x1000fe5e, 10477 }, /* Dcircumflex_accent */
{ 0x1000fe22, 10496 }, /* Ddiaeresis */
{ 0x0000fe80, 10507 }, /* dead_a */
{ 0x0000fe81, 10514 }, /* dead_A */
{ 0x0000fe64, 10521 }, /* dead_abovecomma */
{ 0x0000fe56, 10537 }, /* dead_abovedot */
{ 0x0000fe65, 10551 }, /* dead_abovereversedcomma */
{ 0x0000fe58, 10575 }, /* dead_abovering */
{ 0x0000fe91, 10590 }, /* dead_aboveverticalline */
{ 0x0000fe51, 10613 }, /* dead_acute */
{ 0x0000fe6b, 10624 }, /* dead_belowbreve */
{ 0x0000fe69, 10640 }, /* dead_belowcircumflex */
{ 0x0000fe6e, 10661 }, /* dead_belowcomma */
{ 0x0000fe6c, 10677 }, /* dead_belowdiaeresis */
{ 0x0000fe60, 10697 }, /* dead_belowdot */
{ 0x0000fe68, 10711 }, /* dead_belowmacron */
{ 0x0000fe67, 10728 }, /* dead_belowring */
{ 0x0000fe6a, 10743 }, /* dead_belowtilde */
{ 0x0000fe92, 10759 }, /* dead_belowverticalline */
{ 0x0000fe55, 10782 }, /* dead_breve */
{ 0x0000fe8b, 10793 }, /* dead_capital_schwa */
{ 0x0000fe5a, 10812 }, /* dead_caron */
{ 0x0000fe5b, 10823 }, /* dead_cedilla */
{ 0x0000fe52, 10836 }, /* dead_circumflex */
{ 0x0000fe6f, 10852 }, /* dead_currency */
{ 0x0000fe65, 10866 }, /* dead_dasia */
{ 0x0000fe57, 10877 }, /* dead_diaeresis */
{ 0x0000fe59, 10892 }, /* dead_doubleacute */
{ 0x0000fe66, 10909 }, /* dead_doublegrave */
{ 0x0000fe82, 10926 }, /* dead_e */
{ 0x0000fe83, 10933 }, /* dead_E */
{ 0x0000fe50, 10940 }, /* dead_grave */
{ 0x0000fe8c, 10951 }, /* dead_greek */
{ 0x0000fe61, 10962 }, /* dead_hook */
{ 0x0000fe62, 10972 }, /* dead_horn */
{ 0x0000fe84, 10982 }, /* dead_i */
{ 0x0000fe85, 10989 }, /* dead_I */
{ 0x0000fe6d, 10996 }, /* dead_invertedbreve */
{ 0x0000fe5d, 11015 }, /* dead_iota */
{ 0x0000fe93, 11025 }, /* dead_longsolidusoverlay */
{ 0x0000fe90, 11049 }, /* dead_lowline */
{ 0x0000fe54, 11062 }, /* dead_macron */
{ 0x0000fe86, 11074 }, /* dead_o */
{ 0x0000fe87, 11081 }, /* dead_O */
{ 0x0000fe5c, 11088 }, /* dead_ogonek */
{ 0x0000fe53, 11100 }, /* dead_perispomeni */
{ 0x0000fe64, 11117 }, /* dead_psili */
{ 0x0000fe5f, 11128 }, /* dead_semivoiced_sound */
{ 0x0000fe8a, 11150 }, /* dead_small_schwa */
{ 0x0000fe63, 11167 }, /* dead_stroke */
{ 0x0000fe53, 11179 }, /* dead_tilde */
{ 0x0000fe88, 11190 }, /* dead_u */
{ 0x0000fe89, 11197 }, /* dead_U */
{ 0x0000fe5e, 11204 }, /* dead_voiced_sound */
{ 0x00000abd, 11222 }, /* decimalpoint */
{ 0x000000b0, 11235 }, /* degree */
{ 0x0000ffff, 11242 }, /* Delete */
{ 0x1000ff73, 11249 }, /* DeleteChar */
{ 0x1000ff71, 11260 }, /* DeleteLine */
{ 0x1000fe60, 11271 }, /* Dgrave_accent */
{ 0x000000a8, 11285 }, /* diaeresis */
{ 0x00000aed, 11295 }, /* diamond */
{ 0x00000aa5, 11303 }, /* digitspace */
{ 0x0100222c, 11314 }, /* dintegral */
{ 0x000000f7, 11324 }, /* division */
{ 0x00000024, 11333 }, /* dollar */
{ 0x010020ab, 11340 }, /* DongSign */
{ 0x00000aaf, 11349 }, /* doubbaselinedot */
{ 0x000001bd, 11365 }, /* doubleacute */
{ 0x00000af2, 11377 }, /* doubledagger */
{ 0x00000afe, 11390 }, /* doublelowquotemark */
{ 0x0000ff54, 11409 }, /* Down */
{ 0x000008fe, 11414 }, /* downarrow */
{ 0x00000ba8, 11424 }, /* downcaret */
{ 0x00000bd6, 11434 }, /* downshoe */
{ 0x00000bc4, 11443 }, /* downstile */
{ 0x00000bc2, 11453 }, /* downtack */
{ 0x1000ff00, 11462 }, /* DRemove */
{ 0x1000feb0, 11470 }, /* Dring_accent */
{ 0x000001d0, 11483 }, /* Dstroke */
{ 0x000001f0, 11491 }, /* dstroke */
{ 0x1000fe7e, 11499 }, /* Dtilde */
{ 0x00000045, 11506 }, /* E */
{ 0x00000065, 11508 }, /* e */
{ 0x000003cc, 11510 }, /* Eabovedot */
{ 0x000003ec, 11520 }, /* eabovedot */
{ 0x000000c9, 11530 }, /* Eacute */
{ 0x000000e9, 11537 }, /* eacute */
{ 0x01001eb8, 11544 }, /* Ebelowdot */
{ 0x01001eb9, 11554 }, /* ebelowdot */
{ 0x000001cc, 11564 }, /* Ecaron */
{ 0x000001ec, 11571 }, /* ecaron */
{ 0x000000ca, 11578 }, /* Ecircumflex */
{ 0x000000ea, 11590 }, /* ecircumflex */
{ 0x01001ebe, 11602 }, /* Ecircumflexacute */
{ 0x01001ebf, 11619 }, /* ecircumflexacute */
{ 0x01001ec6, 11636 }, /* Ecircumflexbelowdot */
{ 0x01001ec7, 11656 }, /* ecircumflexbelowdot */
{ 0x01001ec0, 11676 }, /* Ecircumflexgrave */
{ 0x01001ec1, 11693 }, /* ecircumflexgrave */
{ 0x01001ec2, 11710 }, /* Ecircumflexhook */
{ 0x01001ec3, 11726 }, /* ecircumflexhook */
{ 0x01001ec4, 11742 }, /* Ecircumflextilde */
{ 0x01001ec5, 11759 }, /* ecircumflextilde */
{ 0x010020a0, 11776 }, /* EcuSign */
{ 0x000000cb, 11784 }, /* Ediaeresis */
{ 0x000000eb, 11795 }, /* ediaeresis */
{ 0x000000c8, 11806 }, /* Egrave */
{ 0x000000e8, 11813 }, /* egrave */
{ 0x01001eba, 11820 }, /* Ehook */
{ 0x01001ebb, 11826 }, /* ehook */
{ 0x01002088, 11832 }, /* eightsubscript */
{ 0x01002078, 11847 }, /* eightsuperior */
{ 0x0000ff2f, 11861 }, /* Eisu_Shift */
{ 0x0000ff30, 11872 }, /* Eisu_toggle */
{ 0x01002208, 11884 }, /* elementof */
{ 0x00000aae, 11894 }, /* ellipsis */
{ 0x00000aa3, 11903 }, /* em3space */
{ 0x00000aa4, 11912 }, /* em4space */
{ 0x000003aa, 11921 }, /* Emacron */
{ 0x000003ba, 11929 }, /* emacron */
{ 0x00000aa9, 11937 }, /* emdash */
{ 0x00000ade, 11944 }, /* emfilledcircle */
{ 0x00000adf, 11959 }, /* emfilledrect */
{ 0x00000ace, 11972 }, /* emopencircle */
{ 0x00000acf, 11985 }, /* emopenrectangle */
{ 0x01002205, 12001 }, /* emptyset */
{ 0x00000aa1, 12010 }, /* emspace */
{ 0x0000ff57, 12018 }, /* End */
{ 0x00000aaa, 12022 }, /* endash */
{ 0x00000ae6, 12029 }, /* enfilledcircbullet */
{ 0x00000ae7, 12048 }, /* enfilledsqbullet */
{ 0x000003bd, 12065 }, /* ENG */
{ 0x000003bf, 12069 }, /* eng */
{ 0x00000ae0, 12073 }, /* enopencircbullet */
{ 0x00000ae1, 12090 }, /* enopensquarebullet */
{ 0x00000aa2, 12109 }, /* enspace */
{ 0x000001ca, 12117 }, /* Eogonek */
{ 0x000001ea, 12125 }, /* eogonek */
{ 0x0000003d, 12133 }, /* equal */
{ 0x0000ff1b, 12139 }, /* Escape */
{ 0x000000d0, 12146 }, /* ETH */
{ 0x000000d0, 12150 }, /* Eth */
{ 0x000000f0, 12154 }, /* eth */
{ 0x01001ebc, 12158 }, /* Etilde */
{ 0x01001ebd, 12165 }, /* etilde */
{ 0x000020ac, 12172 }, /* EuroSign */
{ 0x00000021, 12181 }, /* exclam */
{ 0x000000a1, 12188 }, /* exclamdown */
{ 0x0000ff62, 12199 }, /* Execute */
{ 0x1000ff76, 12207 }, /* Ext16bit_L */
{ 0x1000ff77, 12218 }, /* Ext16bit_R */
{ 0x010001b7, 12229 }, /* EZH */
{ 0x01000292, 12233 }, /* ezh */
{ 0x00000046, 12237 }, /* F */
{ 0x00000066, 12239 }, /* f */
{ 0x0000ffbe, 12241 }, /* F1 */
{ 0x0000ffc7, 12244 }, /* F10 */
{ 0x0000ffc8, 12248 }, /* F11 */
{ 0x0000ffc9, 12252 }, /* F12 */
{ 0x0000ffca, 12256 }, /* F13 */
{ 0x0000ffcb, 12260 }, /* F14 */
{ 0x0000ffcc, 12264 }, /* F15 */
{ 0x0000ffcd, 12268 }, /* F16 */
{ 0x0000ffce, 12272 }, /* F17 */
{ 0x0000ffcf, 12276 }, /* F18 */
{ 0x0000ffd0, 12280 }, /* F19 */
{ 0x0000ffbf, 12284 }, /* F2 */
{ 0x0000ffd1, 12287 }, /* F20 */
{ 0x0000ffd2, 12291 }, /* F21 */
{ 0x0000ffd3, 12295 }, /* F22 */
{ 0x0000ffd4, 12299 }, /* F23 */
{ 0x0000ffd5, 12303 }, /* F24 */
{ 0x0000ffd6, 12307 }, /* F25 */
{ 0x0000ffd7, 12311 }, /* F26 */
{ 0x0000ffd8, 12315 }, /* F27 */
{ 0x0000ffd9, 12319 }, /* F28 */
{ 0x0000ffda, 12323 }, /* F29 */
{ 0x0000ffc0, 12327 }, /* F3 */
{ 0x0000ffdb, 12330 }, /* F30 */
{ 0x0000ffdc, 12334 }, /* F31 */
{ 0x0000ffdd, 12338 }, /* F32 */
{ 0x0000ffde, 12342 }, /* F33 */
{ 0x0000ffdf, 12346 }, /* F34 */
{ 0x0000ffe0, 12350 }, /* F35 */
{ 0x0000ffc1, 12354 }, /* F4 */
{ 0x0000ffc2, 12357 }, /* F5 */
{ 0x0000ffc3, 12360 }, /* F6 */
{ 0x0000ffc4, 12363 }, /* F7 */
{ 0x0000ffc5, 12366 }, /* F8 */
{ 0x0000ffc6, 12369 }, /* F9 */
{ 0x01001e1e, 12372 }, /* Fabovedot */
{ 0x01001e1f, 12382 }, /* fabovedot */
{ 0x010006f0, 12392 }, /* Farsi_0 */
{ 0x010006f1, 12400 }, /* Farsi_1 */
{ 0x010006f2, 12408 }, /* Farsi_2 */
{ 0x010006f3, 12416 }, /* Farsi_3 */
{ 0x010006f4, 12424 }, /* Farsi_4 */
{ 0x010006f5, 12432 }, /* Farsi_5 */
{ 0x010006f6, 12440 }, /* Farsi_6 */
{ 0x010006f7, 12448 }, /* Farsi_7 */
{ 0x010006f8, 12456 }, /* Farsi_8 */
{ 0x010006f9, 12464 }, /* Farsi_9 */
{ 0x010006cc, 12472 }, /* Farsi_yeh */
{ 0x00000af8, 12482 }, /* femalesymbol */
{ 0x000009e3, 12495 }, /* ff */
{ 0x010020a3, 12498 }, /* FFrancSign */
{ 0x00000abb, 12509 }, /* figdash */
{ 0x00000adc, 12517 }, /* filledlefttribullet */
{ 0x00000adb, 12537 }, /* filledrectbullet */
{ 0x00000add, 12554 }, /* filledrighttribullet */
{ 0x00000ae9, 12575 }, /* filledtribulletdown */
{ 0x00000ae8, 12595 }, /* filledtribulletup */
{ 0x0000ff68, 12613 }, /* Find */
{ 0x0000fed0, 12618 }, /* First_Virtual_Screen */
{ 0x00000ac5, 12639 }, /* fiveeighths */
{ 0x00000ab7, 12651 }, /* fivesixths */
{ 0x01002085, 12662 }, /* fivesubscript */
{ 0x01002075, 12676 }, /* fivesuperior */
{ 0x00000ab5, 12689 }, /* fourfifths */
{ 0x01002084, 12700 }, /* foursubscript */
{ 0x01002074, 12714 }, /* foursuperior */
{ 0x0100221c, 12727 }, /* fourthroot */
{ 0x000008f6, 12738 }, /* function */
{ 0x00000047, 12747 }, /* G */
{ 0x00000067, 12749 }, /* g */
{ 0x000002d5, 12751 }, /* Gabovedot */
{ 0x000002f5, 12761 }, /* gabovedot */
{ 0x000002ab, 12771 }, /* Gbreve */
{ 0x000002bb, 12778 }, /* gbreve */
{ 0x010001e6, 12785 }, /* Gcaron */
{ 0x010001e7, 12792 }, /* gcaron */
{ 0x000003ab, 12799 }, /* Gcedilla */
{ 0x000003bb, 12808 }, /* gcedilla */
{ 0x000002d8, 12817 }, /* Gcircumflex */
{ 0x000002f8, 12829 }, /* gcircumflex */
{ 0x010010d0, 12841 }, /* Georgian_an */
{ 0x010010d1, 12853 }, /* Georgian_ban */
{ 0x010010ea, 12866 }, /* Georgian_can */
{ 0x010010ed, 12879 }, /* Georgian_char */
{ 0x010010e9, 12893 }, /* Georgian_chin */
{ 0x010010ec, 12907 }, /* Georgian_cil */
{ 0x010010d3, 12920 }, /* Georgian_don */
{ 0x010010d4, 12933 }, /* Georgian_en */
{ 0x010010f6, 12945 }, /* Georgian_fi */
{ 0x010010d2, 12957 }, /* Georgian_gan */
{ 0x010010e6, 12970 }, /* Georgian_ghan */
{ 0x010010f0, 12984 }, /* Georgian_hae */
{ 0x010010f4, 12997 }, /* Georgian_har */
{ 0x010010f1, 13010 }, /* Georgian_he */
{ 0x010010f2, 13022 }, /* Georgian_hie */
{ 0x010010f5, 13035 }, /* Georgian_hoe */
{ 0x010010d8, 13048 }, /* Georgian_in */
{ 0x010010ef, 13060 }, /* Georgian_jhan */
{ 0x010010eb, 13074 }, /* Georgian_jil */
{ 0x010010d9, 13087 }, /* Georgian_kan */
{ 0x010010e5, 13100 }, /* Georgian_khar */
{ 0x010010da, 13114 }, /* Georgian_las */
{ 0x010010db, 13127 }, /* Georgian_man */
{ 0x010010dc, 13140 }, /* Georgian_nar */
{ 0x010010dd, 13153 }, /* Georgian_on */
{ 0x010010de, 13165 }, /* Georgian_par */
{ 0x010010e4, 13178 }, /* Georgian_phar */
{ 0x010010e7, 13192 }, /* Georgian_qar */
{ 0x010010e0, 13205 }, /* Georgian_rae */
{ 0x010010e1, 13218 }, /* Georgian_san */
{ 0x010010e8, 13231 }, /* Georgian_shin */
{ 0x010010d7, 13245 }, /* Georgian_tan */
{ 0x010010e2, 13258 }, /* Georgian_tar */
{ 0x010010e3, 13271 }, /* Georgian_un */
{ 0x010010d5, 13283 }, /* Georgian_vin */
{ 0x010010f3, 13296 }, /* Georgian_we */
{ 0x010010ee, 13308 }, /* Georgian_xan */
{ 0x010010d6, 13321 }, /* Georgian_zen */
{ 0x010010df, 13334 }, /* Georgian_zhar */
{ 0x00000060, 13348 }, /* grave */
{ 0x0000003e, 13354 }, /* greater */
{ 0x000008be, 13362 }, /* greaterthanequal */
{ 0x000007ae, 13379 }, /* Greek_accentdieresis */
{ 0x000007c1, 13400 }, /* Greek_ALPHA */
{ 0x000007e1, 13412 }, /* Greek_alpha */
{ 0x000007a1, 13424 }, /* Greek_ALPHAaccent */
{ 0x000007b1, 13442 }, /* Greek_alphaaccent */
{ 0x000007c2, 13460 }, /* Greek_BETA */
{ 0x000007e2, 13471 }, /* Greek_beta */
{ 0x000007d7, 13482 }, /* Greek_CHI */
{ 0x000007f7, 13492 }, /* Greek_chi */
{ 0x000007c4, 13502 }, /* Greek_DELTA */
{ 0x000007e4, 13514 }, /* Greek_delta */
{ 0x000007c5, 13526 }, /* Greek_EPSILON */
{ 0x000007e5, 13540 }, /* Greek_epsilon */
{ 0x000007a2, 13554 }, /* Greek_EPSILONaccent */
{ 0x000007b2, 13574 }, /* Greek_epsilonaccent */
{ 0x000007c7, 13594 }, /* Greek_ETA */
{ 0x000007e7, 13604 }, /* Greek_eta */
{ 0x000007a3, 13614 }, /* Greek_ETAaccent */
{ 0x000007b3, 13630 }, /* Greek_etaaccent */
{ 0x000007f3, 13646 }, /* Greek_finalsmallsigma */
{ 0x000007c3, 13668 }, /* Greek_GAMMA */
{ 0x000007e3, 13680 }, /* Greek_gamma */
{ 0x000007af, 13692 }, /* Greek_horizbar */
{ 0x000007c9, 13707 }, /* Greek_IOTA */
{ 0x000007e9, 13718 }, /* Greek_iota */
{ 0x000007a4, 13729 }, /* Greek_IOTAaccent */
{ 0x000007b4, 13746 }, /* Greek_iotaaccent */
{ 0x000007b6, 13763 }, /* Greek_iotaaccentdieresis */
{ 0x000007a5, 13788 }, /* Greek_IOTAdiaeresis */
{ 0x000007a5, 13808 }, /* Greek_IOTAdieresis */
{ 0x000007b5, 13827 }, /* Greek_iotadieresis */
{ 0x000007ca, 13846 }, /* Greek_KAPPA */
{ 0x000007ea, 13858 }, /* Greek_kappa */
{ 0x000007cb, 13870 }, /* Greek_LAMBDA */
{ 0x000007eb, 13883 }, /* Greek_lambda */
{ 0x000007cb, 13896 }, /* Greek_LAMDA */
{ 0x000007eb, 13908 }, /* Greek_lamda */
{ 0x000007cc, 13920 }, /* Greek_MU */
{ 0x000007ec, 13929 }, /* Greek_mu */
{ 0x000007cd, 13938 }, /* Greek_NU */
{ 0x000007ed, 13947 }, /* Greek_nu */
{ 0x000007d9, 13956 }, /* Greek_OMEGA */
{ 0x000007f9, 13968 }, /* Greek_omega */
{ 0x000007ab, 13980 }, /* Greek_OMEGAaccent */
{ 0x000007bb, 13998 }, /* Greek_omegaaccent */
{ 0x000007cf, 14016 }, /* Greek_OMICRON */
{ 0x000007ef, 14030 }, /* Greek_omicron */
{ 0x000007a7, 14044 }, /* Greek_OMICRONaccent */
{ 0x000007b7, 14064 }, /* Greek_omicronaccent */
{ 0x000007d6, 14084 }, /* Greek_PHI */
{ 0x000007f6, 14094 }, /* Greek_phi */
{ 0x000007d0, 14104 }, /* Greek_PI */
{ 0x000007f0, 14113 }, /* Greek_pi */
{ 0x000007d8, 14122 }, /* Greek_PSI */
{ 0x000007f8, 14132 }, /* Greek_psi */
{ 0x000007d1, 14142 }, /* Greek_RHO */
{ 0x000007f1, 14152 }, /* Greek_rho */
{ 0x000007d2, 14162 }, /* Greek_SIGMA */
{ 0x000007f2, 14174 }, /* Greek_sigma */
{ 0x0000ff7e, 14186 }, /* Greek_switch */
{ 0x000007d4, 14199 }, /* Greek_TAU */
{ 0x000007f4, 14209 }, /* Greek_tau */
{ 0x000007c8, 14219 }, /* Greek_THETA */
{ 0x000007e8, 14231 }, /* Greek_theta */
{ 0x000007d5, 14243 }, /* Greek_UPSILON */
{ 0x000007f5, 14257 }, /* Greek_upsilon */
{ 0x000007a8, 14271 }, /* Greek_UPSILONaccent */
{ 0x000007b8, 14291 }, /* Greek_upsilonaccent */
{ 0x000007ba, 14311 }, /* Greek_upsilonaccentdieresis */
{ 0x000007a9, 14339 }, /* Greek_UPSILONdieresis */
{ 0x000007b9, 14361 }, /* Greek_upsilondieresis */
{ 0x000007ce, 14383 }, /* Greek_XI */
{ 0x000007ee, 14392 }, /* Greek_xi */
{ 0x000007c6, 14401 }, /* Greek_ZETA */
{ 0x000007e6, 14412 }, /* Greek_zeta */
{ 0x100000be, 14423 }, /* guilder */
{ 0x000000ab, 14431 }, /* guillemotleft */
{ 0x000000bb, 14445 }, /* guillemotright */
{ 0x00000048, 14460 }, /* H */
{ 0x00000068, 14462 }, /* h */
{ 0x00000aa8, 14464 }, /* hairspace */
{ 0x0000ff31, 14474 }, /* Hangul */
{ 0x00000ebf, 14481 }, /* Hangul_A */
{ 0x00000ec0, 14490 }, /* Hangul_AE */
{ 0x00000ef6, 14500 }, /* Hangul_AraeA */
{ 0x00000ef7, 14513 }, /* Hangul_AraeAE */
{ 0x0000ff39, 14527 }, /* Hangul_Banja */
{ 0x00000eba, 14540 }, /* Hangul_Cieuc */
{ 0x0000ff37, 14553 }, /* Hangul_Codeinput */
{ 0x00000ea7, 14570 }, /* Hangul_Dikeud */
{ 0x00000ec4, 14584 }, /* Hangul_E */
{ 0x0000ff33, 14593 }, /* Hangul_End */
{ 0x00000ec3, 14604 }, /* Hangul_EO */
{ 0x00000ed1, 14614 }, /* Hangul_EU */
{ 0x0000ff34, 14624 }, /* Hangul_Hanja */
{ 0x00000ebe, 14637 }, /* Hangul_Hieuh */
{ 0x00000ed3, 14650 }, /* Hangul_I */
{ 0x00000eb7, 14659 }, /* Hangul_Ieung */
{ 0x00000eea, 14672 }, /* Hangul_J_Cieuc */
{ 0x00000eda, 14687 }, /* Hangul_J_Dikeud */
{ 0x00000eee, 14703 }, /* Hangul_J_Hieuh */
{ 0x00000ee8, 14718 }, /* Hangul_J_Ieung */
{ 0x00000ee9, 14733 }, /* Hangul_J_Jieuj */
{ 0x00000eeb, 14748 }, /* Hangul_J_Khieuq */
{ 0x00000ed4, 14764 }, /* Hangul_J_Kiyeog */
{ 0x00000ed6, 14780 }, /* Hangul_J_KiyeogSios */
{ 0x00000ef9, 14800 }, /* Hangul_J_KkogjiDalrinIeung */
{ 0x00000ee3, 14827 }, /* Hangul_J_Mieum */
{ 0x00000ed7, 14842 }, /* Hangul_J_Nieun */
{ 0x00000ed9, 14857 }, /* Hangul_J_NieunHieuh */
{ 0x00000ed8, 14877 }, /* Hangul_J_NieunJieuj */
{ 0x00000ef8, 14897 }, /* Hangul_J_PanSios */
{ 0x00000eed, 14914 }, /* Hangul_J_Phieuf */
{ 0x00000ee4, 14930 }, /* Hangul_J_Pieub */
{ 0x00000ee5, 14945 }, /* Hangul_J_PieubSios */
{ 0x00000edb, 14964 }, /* Hangul_J_Rieul */
{ 0x00000ee2, 14979 }, /* Hangul_J_RieulHieuh */
{ 0x00000edc, 14999 }, /* Hangul_J_RieulKiyeog */
{ 0x00000edd, 15020 }, /* Hangul_J_RieulMieum */
{ 0x00000ee1, 15040 }, /* Hangul_J_RieulPhieuf */
{ 0x00000ede, 15061 }, /* Hangul_J_RieulPieub */
{ 0x00000edf, 15081 }, /* Hangul_J_RieulSios */
{ 0x00000ee0, 15100 }, /* Hangul_J_RieulTieut */
{ 0x00000ee6, 15120 }, /* Hangul_J_Sios */
{ 0x00000ed5, 15134 }, /* Hangul_J_SsangKiyeog */
{ 0x00000ee7, 15155 }, /* Hangul_J_SsangSios */
{ 0x00000eec, 15174 }, /* Hangul_J_Tieut */
{ 0x00000efa, 15189 }, /* Hangul_J_YeorinHieuh */
{ 0x0000ff35, 15210 }, /* Hangul_Jamo */
{ 0x0000ff38, 15222 }, /* Hangul_Jeonja */
{ 0x00000eb8, 15236 }, /* Hangul_Jieuj */
{ 0x00000ebb, 15249 }, /* Hangul_Khieuq */
{ 0x00000ea1, 15263 }, /* Hangul_Kiyeog */
{ 0x00000ea3, 15277 }, /* Hangul_KiyeogSios */
{ 0x00000ef3, 15295 }, /* Hangul_KkogjiDalrinIeung */
{ 0x00000eb1, 15320 }, /* Hangul_Mieum */
{ 0x0000ff3d, 15333 }, /* Hangul_MultipleCandidate */
{ 0x00000ea4, 15358 }, /* Hangul_Nieun */
{ 0x00000ea6, 15371 }, /* Hangul_NieunHieuh */
{ 0x00000ea5, 15389 }, /* Hangul_NieunJieuj */
{ 0x00000ec7, 15407 }, /* Hangul_O */
{ 0x00000eca, 15416 }, /* Hangul_OE */
{ 0x00000ef2, 15426 }, /* Hangul_PanSios */
{ 0x00000ebd, 15441 }, /* Hangul_Phieuf */
{ 0x00000eb2, 15455 }, /* Hangul_Pieub */
{ 0x00000eb4, 15468 }, /* Hangul_PieubSios */
{ 0x0000ff3b, 15485 }, /* Hangul_PostHanja */
{ 0x0000ff3a, 15502 }, /* Hangul_PreHanja */
{ 0x0000ff3e, 15518 }, /* Hangul_PreviousCandidate */
{ 0x00000ea9, 15543 }, /* Hangul_Rieul */
{ 0x00000eb0, 15556 }, /* Hangul_RieulHieuh */
{ 0x00000eaa, 15574 }, /* Hangul_RieulKiyeog */
{ 0x00000eab, 15593 }, /* Hangul_RieulMieum */
{ 0x00000eaf, 15611 }, /* Hangul_RieulPhieuf */
{ 0x00000eac, 15630 }, /* Hangul_RieulPieub */
{ 0x00000ead, 15648 }, /* Hangul_RieulSios */
{ 0x00000eae, 15665 }, /* Hangul_RieulTieut */
{ 0x00000eef, 15683 }, /* Hangul_RieulYeorinHieuh */
{ 0x0000ff36, 15707 }, /* Hangul_Romaja */
{ 0x0000ff3c, 15721 }, /* Hangul_SingleCandidate */
{ 0x00000eb5, 15744 }, /* Hangul_Sios */
{ 0x0000ff3f, 15756 }, /* Hangul_Special */
{ 0x00000ea8, 15771 }, /* Hangul_SsangDikeud */
{ 0x00000eb9, 15790 }, /* Hangul_SsangJieuj */
{ 0x00000ea2, 15808 }, /* Hangul_SsangKiyeog */
{ 0x00000eb3, 15827 }, /* Hangul_SsangPieub */
{ 0x00000eb6, 15845 }, /* Hangul_SsangSios */
{ 0x0000ff32, 15862 }, /* Hangul_Start */
{ 0x00000ef0, 15875 }, /* Hangul_SunkyeongeumMieum */
{ 0x00000ef4, 15900 }, /* Hangul_SunkyeongeumPhieuf */
{ 0x00000ef1, 15926 }, /* Hangul_SunkyeongeumPieub */
{ 0x0000ff7e, 15951 }, /* Hangul_switch */
{ 0x00000ebc, 15965 }, /* Hangul_Tieut */
{ 0x00000ecc, 15978 }, /* Hangul_U */
{ 0x00000ec8, 15987 }, /* Hangul_WA */
{ 0x00000ec9, 15997 }, /* Hangul_WAE */
{ 0x00000ece, 16008 }, /* Hangul_WE */
{ 0x00000ecd, 16018 }, /* Hangul_WEO */
{ 0x00000ecf, 16029 }, /* Hangul_WI */
{ 0x00000ec1, 16039 }, /* Hangul_YA */
{ 0x00000ec2, 16049 }, /* Hangul_YAE */
{ 0x00000ec6, 16060 }, /* Hangul_YE */
{ 0x00000ec5, 16070 }, /* Hangul_YEO */
{ 0x00000ef5, 16081 }, /* Hangul_YeorinHieuh */
{ 0x00000ed2, 16100 }, /* Hangul_YI */
{ 0x00000ecb, 16110 }, /* Hangul_YO */
{ 0x00000ed0, 16120 }, /* Hangul_YU */
{ 0x0000ff29, 16130 }, /* Hankaku */
{ 0x000002a6, 16138 }, /* Hcircumflex */
{ 0x000002b6, 16150 }, /* hcircumflex */
{ 0x00000aee, 16162 }, /* heart */
{ 0x00000ce0, 16168 }, /* hebrew_aleph */
{ 0x00000cf2, 16181 }, /* hebrew_ayin */
{ 0x00000ce1, 16193 }, /* hebrew_bet */
{ 0x00000ce1, 16204 }, /* hebrew_beth */
{ 0x00000ce7, 16216 }, /* hebrew_chet */
{ 0x00000ce3, 16228 }, /* hebrew_dalet */
{ 0x00000ce3, 16241 }, /* hebrew_daleth */
{ 0x00000cdf, 16255 }, /* hebrew_doublelowline */
{ 0x00000cea, 16276 }, /* hebrew_finalkaph */
{ 0x00000ced, 16293 }, /* hebrew_finalmem */
{ 0x00000cef, 16309 }, /* hebrew_finalnun */
{ 0x00000cf3, 16325 }, /* hebrew_finalpe */
{ 0x00000cf5, 16340 }, /* hebrew_finalzade */
{ 0x00000cf5, 16357 }, /* hebrew_finalzadi */
{ 0x00000ce2, 16374 }, /* hebrew_gimel */
{ 0x00000ce2, 16387 }, /* hebrew_gimmel */
{ 0x00000ce4, 16401 }, /* hebrew_he */
{ 0x00000ce7, 16411 }, /* hebrew_het */
{ 0x00000ceb, 16422 }, /* hebrew_kaph */
{ 0x00000cf7, 16434 }, /* hebrew_kuf */
{ 0x00000cec, 16445 }, /* hebrew_lamed */
{ 0x00000cee, 16458 }, /* hebrew_mem */
{ 0x00000cf0, 16469 }, /* hebrew_nun */
{ 0x00000cf4, 16480 }, /* hebrew_pe */
{ 0x00000cf7, 16490 }, /* hebrew_qoph */
{ 0x00000cf8, 16502 }, /* hebrew_resh */
{ 0x00000cf1, 16514 }, /* hebrew_samech */
{ 0x00000cf1, 16528 }, /* hebrew_samekh */
{ 0x00000cf9, 16542 }, /* hebrew_shin */
{ 0x0000ff7e, 16554 }, /* Hebrew_switch */
{ 0x00000cfa, 16568 }, /* hebrew_taf */
{ 0x00000cfa, 16579 }, /* hebrew_taw */
{ 0x00000ce8, 16590 }, /* hebrew_tet */
{ 0x00000ce8, 16601 }, /* hebrew_teth */
{ 0x00000ce5, 16613 }, /* hebrew_waw */
{ 0x00000ce9, 16624 }, /* hebrew_yod */
{ 0x00000cf6, 16635 }, /* hebrew_zade */
{ 0x00000cf6, 16647 }, /* hebrew_zadi */
{ 0x00000ce6, 16659 }, /* hebrew_zain */
{ 0x00000ce6, 16671 }, /* hebrew_zayin */
{ 0x0000ff6a, 16684 }, /* Help */
{ 0x0000ff23, 16689 }, /* Henkan */
{ 0x0000ff23, 16696 }, /* Henkan_Mode */
{ 0x00000ada, 16708 }, /* hexagram */
{ 0x0000ff25, 16717 }, /* Hiragana */
{ 0x0000ff27, 16726 }, /* Hiragana_Katakana */
{ 0x0000ff50, 16744 }, /* Home */
{ 0x000008a3, 16749 }, /* horizconnector */
{ 0x000009ef, 16764 }, /* horizlinescan1 */
{ 0x000009f0, 16779 }, /* horizlinescan3 */
{ 0x000009f1, 16794 }, /* horizlinescan5 */
{ 0x000009f2, 16809 }, /* horizlinescan7 */
{ 0x000009f3, 16824 }, /* horizlinescan9 */
{ 0x1000ff74, 16839 }, /* hpBackTab */
{ 0x100000fc, 16849 }, /* hpblock */
{ 0x1000ff6f, 16857 }, /* hpClearLine */
{ 0x1000ff73, 16869 }, /* hpDeleteChar */
{ 0x1000ff71, 16882 }, /* hpDeleteLine */
{ 0x100000be, 16895 }, /* hpguilder */
{ 0x1000ff72, 16905 }, /* hpInsertChar */
{ 0x1000ff70, 16918 }, /* hpInsertLine */
{ 0x100000ee, 16931 }, /* hpIO */
{ 0x1000ff75, 16936 }, /* hpKP_BackTab */
{ 0x100000af, 16949 }, /* hplira */
{ 0x100000f6, 16956 }, /* hplongminus */
{ 0x1000ff48, 16968 }, /* hpModelock1 */
{ 0x1000ff49, 16980 }, /* hpModelock2 */
{ 0x100000a8, 16992 }, /* hpmute_acute */
{ 0x100000aa, 17005 }, /* hpmute_asciicircum */
{ 0x100000ac, 17024 }, /* hpmute_asciitilde */
{ 0x100000ab, 17042 }, /* hpmute_diaeresis */
{ 0x100000a9, 17059 }, /* hpmute_grave */
{ 0x1000ff6c, 17072 }, /* hpReset */
{ 0x1000ff6d, 17080 }, /* hpSystem */
{ 0x1000ff6e, 17089 }, /* hpUser */
{ 0x100000ee, 17096 }, /* hpYdiaeresis */
{ 0x000002a1, 17109 }, /* Hstroke */
{ 0x000002b1, 17117 }, /* hstroke */
{ 0x000009e2, 17125 }, /* ht */
{ 0x0000ffed, 17128 }, /* Hyper_L */
{ 0x0000ffee, 17136 }, /* Hyper_R */
{ 0x000000ad, 17144 }, /* hyphen */
{ 0x00000049, 17151 }, /* I */
{ 0x00000069, 17153 }, /* i */
{ 0x000002a9, 17155 }, /* Iabovedot */
{ 0x000000cd, 17165 }, /* Iacute */
{ 0x000000ed, 17172 }, /* iacute */
{ 0x01001eca, 17179 }, /* Ibelowdot */
{ 0x01001ecb, 17189 }, /* ibelowdot */
{ 0x0100012c, 17199 }, /* Ibreve */
{ 0x0100012d, 17206 }, /* ibreve */
{ 0x000000ce, 17213 }, /* Icircumflex */
{ 0x000000ee, 17225 }, /* icircumflex */
{ 0x000008cf, 17237 }, /* identical */
{ 0x000000cf, 17247 }, /* Idiaeresis */
{ 0x000000ef, 17258 }, /* idiaeresis */
{ 0x000002b9, 17269 }, /* idotless */
{ 0x000008cd, 17278 }, /* ifonlyif */
{ 0x000000cc, 17287 }, /* Igrave */
{ 0x000000ec, 17294 }, /* igrave */
{ 0x01001ec8, 17301 }, /* Ihook */
{ 0x01001ec9, 17307 }, /* ihook */
{ 0x000003cf, 17313 }, /* Imacron */
{ 0x000003ef, 17321 }, /* imacron */
{ 0x000008ce, 17329 }, /* implies */
{ 0x000008da, 17337 }, /* includedin */
{ 0x000008db, 17348 }, /* includes */
{ 0x000008c2, 17357 }, /* infinity */
{ 0x0000ff63, 17366 }, /* Insert */
{ 0x1000ff72, 17373 }, /* InsertChar */
{ 0x1000ff70, 17384 }, /* InsertLine */
{ 0x000008bf, 17395 }, /* integral */
{ 0x000008dc, 17404 }, /* intersection */
{ 0x100000ee, 17417 }, /* IO */
{ 0x000003c7, 17420 }, /* Iogonek */
{ 0x000003e7, 17428 }, /* iogonek */
{ 0x0000fe33, 17436 }, /* ISO_Center_Object */
{ 0x0000fe30, 17454 }, /* ISO_Continuous_Underline */
{ 0x0000fe31, 17479 }, /* ISO_Discontinuous_Underline */
{ 0x0000fe32, 17507 }, /* ISO_Emphasize */
{ 0x0000fe34, 17521 }, /* ISO_Enter */
{ 0x0000fe2f, 17531 }, /* ISO_Fast_Cursor_Down */
{ 0x0000fe2c, 17552 }, /* ISO_Fast_Cursor_Left */
{ 0x0000fe2d, 17573 }, /* ISO_Fast_Cursor_Right */
{ 0x0000fe2e, 17595 }, /* ISO_Fast_Cursor_Up */
{ 0x0000fe0c, 17614 }, /* ISO_First_Group */
{ 0x0000fe0d, 17630 }, /* ISO_First_Group_Lock */
{ 0x0000fe06, 17651 }, /* ISO_Group_Latch */
{ 0x0000fe07, 17667 }, /* ISO_Group_Lock */
{ 0x0000ff7e, 17682 }, /* ISO_Group_Shift */
{ 0x0000fe0e, 17698 }, /* ISO_Last_Group */
{ 0x0000fe0f, 17713 }, /* ISO_Last_Group_Lock */
{ 0x0000fe20, 17733 }, /* ISO_Left_Tab */
{ 0x0000fe02, 17746 }, /* ISO_Level2_Latch */
{ 0x0000fe04, 17763 }, /* ISO_Level3_Latch */
{ 0x0000fe05, 17780 }, /* ISO_Level3_Lock */
{ 0x0000fe03, 17796 }, /* ISO_Level3_Shift */
{ 0x0000fe12, 17813 }, /* ISO_Level5_Latch */
{ 0x0000fe13, 17830 }, /* ISO_Level5_Lock */
{ 0x0000fe11, 17846 }, /* ISO_Level5_Shift */
{ 0x0000fe01, 17863 }, /* ISO_Lock */
{ 0x0000fe22, 17872 }, /* ISO_Move_Line_Down */
{ 0x0000fe21, 17891 }, /* ISO_Move_Line_Up */
{ 0x0000fe08, 17908 }, /* ISO_Next_Group */
{ 0x0000fe09, 17923 }, /* ISO_Next_Group_Lock */
{ 0x0000fe24, 17943 }, /* ISO_Partial_Line_Down */
{ 0x0000fe23, 17965 }, /* ISO_Partial_Line_Up */
{ 0x0000fe25, 17985 }, /* ISO_Partial_Space_Left */
{ 0x0000fe26, 18008 }, /* ISO_Partial_Space_Right */
{ 0x0000fe0a, 18032 }, /* ISO_Prev_Group */
{ 0x0000fe0b, 18047 }, /* ISO_Prev_Group_Lock */
{ 0x0000fe2b, 18067 }, /* ISO_Release_Both_Margins */
{ 0x0000fe29, 18092 }, /* ISO_Release_Margin_Left */
{ 0x0000fe2a, 18116 }, /* ISO_Release_Margin_Right */
{ 0x0000fe27, 18141 }, /* ISO_Set_Margin_Left */
{ 0x0000fe28, 18161 }, /* ISO_Set_Margin_Right */
{ 0x000003a5, 18182 }, /* Itilde */
{ 0x000003b5, 18189 }, /* itilde */
{ 0x0000004a, 18196 }, /* J */
{ 0x0000006a, 18198 }, /* j */
{ 0x000002ac, 18200 }, /* Jcircumflex */
{ 0x000002bc, 18212 }, /* jcircumflex */
{ 0x00000bca, 18224 }, /* jot */
{ 0x0000004b, 18228 }, /* K */
{ 0x0000006b, 18230 }, /* k */
{ 0x000004a7, 18232 }, /* kana_a */
{ 0x000004b1, 18239 }, /* kana_A */
{ 0x000004c1, 18246 }, /* kana_CHI */
{ 0x000004a3, 18255 }, /* kana_closingbracket */
{ 0x000004a4, 18275 }, /* kana_comma */
{ 0x000004a5, 18286 }, /* kana_conjunctive */
{ 0x000004aa, 18303 }, /* kana_e */
{ 0x000004b4, 18310 }, /* kana_E */
{ 0x000004cc, 18317 }, /* kana_FU */
{ 0x000004a1, 18325 }, /* kana_fullstop */
{ 0x000004ca, 18339 }, /* kana_HA */
{ 0x000004cd, 18347 }, /* kana_HE */
{ 0x000004cb, 18355 }, /* kana_HI */
{ 0x000004ce, 18363 }, /* kana_HO */
{ 0x000004cc, 18371 }, /* kana_HU */
{ 0x000004a8, 18379 }, /* kana_i */
{ 0x000004b2, 18386 }, /* kana_I */
{ 0x000004b6, 18393 }, /* kana_KA */
{ 0x000004b9, 18401 }, /* kana_KE */
{ 0x000004b7, 18409 }, /* kana_KI */
{ 0x000004ba, 18417 }, /* kana_KO */
{ 0x000004b8, 18425 }, /* kana_KU */
{ 0x0000ff2d, 18433 }, /* Kana_Lock */
{ 0x000004cf, 18443 }, /* kana_MA */
{ 0x000004d2, 18451 }, /* kana_ME */
{ 0x000004d0, 18459 }, /* kana_MI */
{ 0x000004a5, 18467 }, /* kana_middledot */
{ 0x000004d3, 18482 }, /* kana_MO */
{ 0x000004d1, 18490 }, /* kana_MU */
{ 0x000004dd, 18498 }, /* kana_N */
{ 0x000004c5, 18505 }, /* kana_NA */
{ 0x000004c8, 18513 }, /* kana_NE */
{ 0x000004c6, 18521 }, /* kana_NI */
{ 0x000004c9, 18529 }, /* kana_NO */
{ 0x000004c7, 18537 }, /* kana_NU */
{ 0x000004ab, 18545 }, /* kana_o */
{ 0x000004b5, 18552 }, /* kana_O */
{ 0x000004a2, 18559 }, /* kana_openingbracket */
{ 0x000004d7, 18579 }, /* kana_RA */
{ 0x000004da, 18587 }, /* kana_RE */
{ 0x000004d8, 18595 }, /* kana_RI */
{ 0x000004db, 18603 }, /* kana_RO */
{ 0x000004d9, 18611 }, /* kana_RU */
{ 0x000004bb, 18619 }, /* kana_SA */
{ 0x000004be, 18627 }, /* kana_SE */
{ 0x000004bc, 18635 }, /* kana_SHI */
{ 0x0000ff2e, 18644 }, /* Kana_Shift */
{ 0x000004bf, 18655 }, /* kana_SO */
{ 0x000004bd, 18663 }, /* kana_SU */
{ 0x0000ff7e, 18671 }, /* kana_switch */
{ 0x000004c0, 18683 }, /* kana_TA */
{ 0x000004c3, 18691 }, /* kana_TE */
{ 0x000004c1, 18699 }, /* kana_TI */
{ 0x000004c4, 18707 }, /* kana_TO */
{ 0x000004af, 18715 }, /* kana_tsu */
{ 0x000004c2, 18724 }, /* kana_TSU */
{ 0x000004af, 18733 }, /* kana_tu */
{ 0x000004c2, 18741 }, /* kana_TU */
{ 0x000004a9, 18749 }, /* kana_u */
{ 0x000004b3, 18756 }, /* kana_U */
{ 0x000004dc, 18763 }, /* kana_WA */
{ 0x000004a6, 18771 }, /* kana_WO */
{ 0x000004ac, 18779 }, /* kana_ya */
{ 0x000004d4, 18787 }, /* kana_YA */
{ 0x000004ae, 18795 }, /* kana_yo */
{ 0x000004d6, 18803 }, /* kana_YO */
{ 0x000004ad, 18811 }, /* kana_yu */
{ 0x000004d5, 18819 }, /* kana_YU */
{ 0x0000ff21, 18827 }, /* Kanji */
{ 0x0000ff37, 18833 }, /* Kanji_Bangou */
{ 0x000003a2, 18846 }, /* kappa */
{ 0x0000ff26, 18852 }, /* Katakana */
{ 0x000003d3, 18861 }, /* Kcedilla */
{ 0x000003f3, 18870 }, /* kcedilla */
{ 0x00000eff, 18879 }, /* Korean_Won */
{ 0x0000ffb0, 18890 }, /* KP_0 */
{ 0x0000ffb1, 18895 }, /* KP_1 */
{ 0x0000ffb2, 18900 }, /* KP_2 */
{ 0x0000ffb3, 18905 }, /* KP_3 */
{ 0x0000ffb4, 18910 }, /* KP_4 */
{ 0x0000ffb5, 18915 }, /* KP_5 */
{ 0x0000ffb6, 18920 }, /* KP_6 */
{ 0x0000ffb7, 18925 }, /* KP_7 */
{ 0x0000ffb8, 18930 }, /* KP_8 */
{ 0x0000ffb9, 18935 }, /* KP_9 */
{ 0x0000ffab, 18940 }, /* KP_Add */
{ 0x1000ff75, 18947 }, /* KP_BackTab */
{ 0x0000ff9d, 18958 }, /* KP_Begin */
{ 0x0000ffae, 18967 }, /* KP_Decimal */
{ 0x0000ff9f, 18978 }, /* KP_Delete */
{ 0x0000ffaf, 18988 }, /* KP_Divide */
{ 0x0000ff99, 18998 }, /* KP_Down */
{ 0x0000ff9c, 19006 }, /* KP_End */
{ 0x0000ff8d, 19013 }, /* KP_Enter */
{ 0x0000ffbd, 19022 }, /* KP_Equal */
{ 0x0000ff91, 19031 }, /* KP_F1 */
{ 0x0000ff92, 19037 }, /* KP_F2 */
{ 0x0000ff93, 19043 }, /* KP_F3 */
{ 0x0000ff94, 19049 }, /* KP_F4 */
{ 0x0000ff95, 19055 }, /* KP_Home */
{ 0x0000ff9e, 19063 }, /* KP_Insert */
{ 0x0000ff96, 19073 }, /* KP_Left */
{ 0x0000ffaa, 19081 }, /* KP_Multiply */
{ 0x0000ff9b, 19093 }, /* KP_Next */
{ 0x0000ff9b, 19101 }, /* KP_Page_Down */
{ 0x0000ff9a, 19114 }, /* KP_Page_Up */
{ 0x0000ff9a, 19125 }, /* KP_Prior */
{ 0x0000ff98, 19134 }, /* KP_Right */
{ 0x0000ffac, 19143 }, /* KP_Separator */
{ 0x0000ff80, 19156 }, /* KP_Space */
{ 0x0000ffad, 19165 }, /* KP_Subtract */
{ 0x0000ff89, 19177 }, /* KP_Tab */
{ 0x0000ff97, 19184 }, /* KP_Up */
{ 0x000003a2, 19190 }, /* kra */
{ 0x0000004c, 19194 }, /* L */
{ 0x0000006c, 19196 }, /* l */
{ 0x0000ffc8, 19198 }, /* L1 */
{ 0x0000ffd1, 19201 }, /* L10 */
{ 0x0000ffc9, 19205 }, /* L2 */
{ 0x0000ffca, 19208 }, /* L3 */
{ 0x0000ffcb, 19211 }, /* L4 */
{ 0x0000ffcc, 19214 }, /* L5 */
{ 0x0000ffcd, 19217 }, /* L6 */
{ 0x0000ffce, 19220 }, /* L7 */
{ 0x0000ffcf, 19223 }, /* L8 */
{ 0x0000ffd0, 19226 }, /* L9 */
{ 0x000001c5, 19229 }, /* Lacute */
{ 0x000001e5, 19236 }, /* lacute */
{ 0x0000fed4, 19243 }, /* Last_Virtual_Screen */
{ 0x00000ad9, 19263 }, /* latincross */
{ 0x01001e36, 19274 }, /* Lbelowdot */
{ 0x01001e37, 19284 }, /* lbelowdot */
{ 0x000001a5, 19294 }, /* Lcaron */
{ 0x000001b5, 19301 }, /* lcaron */
{ 0x000003a6, 19308 }, /* Lcedilla */
{ 0x000003b6, 19317 }, /* lcedilla */
{ 0x0000ff51, 19326 }, /* Left */
{ 0x00000abc, 19331 }, /* leftanglebracket */
{ 0x000008fb, 19348 }, /* leftarrow */
{ 0x00000ba3, 19358 }, /* leftcaret */
{ 0x00000ad2, 19368 }, /* leftdoublequotemark */
{ 0x000008af, 19388 }, /* leftmiddlecurlybrace */
{ 0x00000acc, 19409 }, /* leftopentriangle */
{ 0x00000aea, 19426 }, /* leftpointer */
{ 0x000008a1, 19438 }, /* leftradical */
{ 0x00000bda, 19450 }, /* leftshoe */
{ 0x00000ad0, 19459 }, /* leftsinglequotemark */
{ 0x000009f4, 19479 }, /* leftt */
{ 0x00000bdc, 19485 }, /* lefttack */
{ 0x0000003c, 19494 }, /* less */
{ 0x000008bc, 19499 }, /* lessthanequal */
{ 0x000009e5, 19513 }, /* lf */
{ 0x0000ff0a, 19516 }, /* Linefeed */
{ 0x100000af, 19525 }, /* lira */
{ 0x010020a4, 19530 }, /* LiraSign */
{ 0x000008de, 19539 }, /* logicaland */
{ 0x000008df, 19550 }, /* logicalor */
{ 0x100000f6, 19560 }, /* longminus */
{ 0x000009ed, 19570 }, /* lowleftcorner */
{ 0x000009ea, 19584 }, /* lowrightcorner */
{ 0x000001a3, 19599 }, /* Lstroke */
{ 0x000001b3, 19607 }, /* lstroke */
{ 0x0000004d, 19615 }, /* M */
{ 0x0000006d, 19617 }, /* m */
{ 0x01001e40, 19619 }, /* Mabovedot */
{ 0x01001e41, 19629 }, /* mabovedot */
{ 0x000006a5, 19639 }, /* Macedonia_dse */
{ 0x000006b5, 19653 }, /* Macedonia_DSE */
{ 0x000006a2, 19667 }, /* Macedonia_gje */
{ 0x000006b2, 19681 }, /* Macedonia_GJE */
{ 0x000006ac, 19695 }, /* Macedonia_kje */
{ 0x000006bc, 19709 }, /* Macedonia_KJE */
{ 0x000000af, 19723 }, /* macron */
{ 0x0000ff3e, 19730 }, /* Mae_Koho */
{ 0x00000af7, 19739 }, /* malesymbol */
{ 0x00000af0, 19750 }, /* maltesecross */
{ 0x00000abf, 19763 }, /* marker */
{ 0x000000ba, 19770 }, /* masculine */
{ 0x0000ff2c, 19780 }, /* Massyo */
{ 0x0000ff67, 19787 }, /* Menu */
{ 0x0000ffe7, 19792 }, /* Meta_L */
{ 0x0000ffe8, 19799 }, /* Meta_R */
{ 0x010020a5, 19806 }, /* MillSign */
{ 0x0000002d, 19815 }, /* minus */
{ 0x00000ad6, 19821 }, /* minutes */
{ 0x0000ff7e, 19829 }, /* Mode_switch */
{ 0x0000fe77, 19841 }, /* MouseKeys_Accel_Enable */
{ 0x0000fe76, 19864 }, /* MouseKeys_Enable */
{ 0x000000b5, 19881 }, /* mu */
{ 0x0000ff22, 19884 }, /* Muhenkan */
{ 0x0000ff20, 19893 }, /* Multi_key */
{ 0x0000ff3d, 19903 }, /* MultipleCandidate */
{ 0x000000d7, 19921 }, /* multiply */
{ 0x00000af6, 19930 }, /* musicalflat */
{ 0x00000af5, 19942 }, /* musicalsharp */
{ 0x100000a8, 19955 }, /* mute_acute */
{ 0x100000aa, 19966 }, /* mute_asciicircum */
{ 0x100000ac, 19983 }, /* mute_asciitilde */
{ 0x100000ab, 19999 }, /* mute_diaeresis */
{ 0x100000a9, 20014 }, /* mute_grave */
{ 0x0000004e, 20025 }, /* N */
{ 0x0000006e, 20027 }, /* n */
{ 0x000008c5, 20029 }, /* nabla */
{ 0x000001d1, 20035 }, /* Nacute */
{ 0x000001f1, 20042 }, /* nacute */
{ 0x010020a6, 20049 }, /* NairaSign */
{ 0x000001d2, 20059 }, /* Ncaron */
{ 0x000001f2, 20066 }, /* ncaron */
{ 0x000003d1, 20073 }, /* Ncedilla */
{ 0x000003f1, 20082 }, /* ncedilla */
{ 0x010020aa, 20091 }, /* NewSheqelSign */
{ 0x0000ff56, 20105 }, /* Next */
{ 0x0000fed2, 20110 }, /* Next_Virtual_Screen */
{ 0x01002089, 20130 }, /* ninesubscript */
{ 0x01002079, 20144 }, /* ninesuperior */
{ 0x000009e8, 20157 }, /* nl */
{ 0x000000a0, 20160 }, /* nobreakspace */
{ 0x00000000, 20173 }, /* NoSymbol */
{ 0x01002247, 20182 }, /* notapproxeq */
{ 0x01002209, 20194 }, /* notelementof */
{ 0x000008bd, 20207 }, /* notequal */
{ 0x01002262, 20216 }, /* notidentical */
{ 0x000000ac, 20229 }, /* notsign */
{ 0x000000d1, 20237 }, /* Ntilde */
{ 0x000000f1, 20244 }, /* ntilde */
{ 0x0000ff7f, 20251 }, /* Num_Lock */
{ 0x00000023, 20260 }, /* numbersign */
{ 0x000006b0, 20271 }, /* numerosign */
{ 0x0000004f, 20282 }, /* O */
{ 0x0000006f, 20284 }, /* o */
{ 0x000000d3, 20286 }, /* Oacute */
{ 0x000000f3, 20293 }, /* oacute */
{ 0x0100019f, 20300 }, /* Obarred */
{ 0x01000275, 20308 }, /* obarred */
{ 0x01001ecc, 20316 }, /* Obelowdot */
{ 0x01001ecd, 20326 }, /* obelowdot */
{ 0x010001d1, 20336 }, /* Ocaron */
{ 0x010001d2, 20343 }, /* ocaron */
{ 0x000000d4, 20350 }, /* Ocircumflex */
{ 0x000000f4, 20362 }, /* ocircumflex */
{ 0x01001ed0, 20374 }, /* Ocircumflexacute */
{ 0x01001ed1, 20391 }, /* ocircumflexacute */
{ 0x01001ed8, 20408 }, /* Ocircumflexbelowdot */
{ 0x01001ed9, 20428 }, /* ocircumflexbelowdot */
{ 0x01001ed2, 20448 }, /* Ocircumflexgrave */
{ 0x01001ed3, 20465 }, /* ocircumflexgrave */
{ 0x01001ed4, 20482 }, /* Ocircumflexhook */
{ 0x01001ed5, 20498 }, /* ocircumflexhook */
{ 0x01001ed6, 20514 }, /* Ocircumflextilde */
{ 0x01001ed7, 20531 }, /* ocircumflextilde */
{ 0x000000d6, 20548 }, /* Odiaeresis */
{ 0x000000f6, 20559 }, /* odiaeresis */
{ 0x000001d5, 20570 }, /* Odoubleacute */
{ 0x000001f5, 20583 }, /* odoubleacute */
{ 0x000013bc, 20596 }, /* OE */
{ 0x000013bd, 20599 }, /* oe */
{ 0x000001b2, 20602 }, /* ogonek */
{ 0x000000d2, 20609 }, /* Ograve */
{ 0x000000f2, 20616 }, /* ograve */
{ 0x01001ece, 20623 }, /* Ohook */
{ 0x01001ecf, 20629 }, /* ohook */
{ 0x010001a0, 20635 }, /* Ohorn */
{ 0x010001a1, 20641 }, /* ohorn */
{ 0x01001eda, 20647 }, /* Ohornacute */
{ 0x01001edb, 20658 }, /* ohornacute */
{ 0x01001ee2, 20669 }, /* Ohornbelowdot */
{ 0x01001ee3, 20683 }, /* ohornbelowdot */
{ 0x01001edc, 20697 }, /* Ohorngrave */
{ 0x01001edd, 20708 }, /* ohorngrave */
{ 0x01001ede, 20719 }, /* Ohornhook */
{ 0x01001edf, 20729 }, /* ohornhook */
{ 0x01001ee0, 20739 }, /* Ohorntilde */
{ 0x01001ee1, 20750 }, /* ohorntilde */
{ 0x000003d2, 20761 }, /* Omacron */
{ 0x000003f2, 20769 }, /* omacron */
{ 0x00000ac3, 20777 }, /* oneeighth */
{ 0x00000ab2, 20787 }, /* onefifth */
{ 0x000000bd, 20796 }, /* onehalf */
{ 0x000000bc, 20804 }, /* onequarter */
{ 0x00000ab6, 20815 }, /* onesixth */
{ 0x01002081, 20824 }, /* onesubscript */
{ 0x000000b9, 20837 }, /* onesuperior */
{ 0x00000ab0, 20849 }, /* onethird */
{ 0x000000d8, 20858 }, /* Ooblique */
{ 0x000000f8, 20867 }, /* ooblique */
{ 0x00000ae2, 20876 }, /* openrectbullet */
{ 0x00000ae5, 20891 }, /* openstar */
{ 0x00000ae4, 20900 }, /* opentribulletdown */
{ 0x00000ae3, 20918 }, /* opentribulletup */
{ 0x000000aa, 20934 }, /* ordfeminine */
{ 0x1004ff44, 20946 }, /* osfActivate */
{ 0x1004ff31, 20958 }, /* osfAddMode */
{ 0x1004ff08, 20969 }, /* osfBackSpace */
{ 0x1004ff07, 20982 }, /* osfBackTab */
{ 0x1004ff5a, 20993 }, /* osfBeginData */
{ 0x1004ff58, 21006 }, /* osfBeginLine */
{ 0x1004ff69, 21019 }, /* osfCancel */
{ 0x1004ff0b, 21029 }, /* osfClear */
{ 0x1004ff02, 21038 }, /* osfCopy */
{ 0x1004ff03, 21046 }, /* osfCut */
{ 0x1004ffff, 21053 }, /* osfDelete */
{ 0x1004ff72, 21063 }, /* osfDeselectAll */
{ 0x1004ff54, 21078 }, /* osfDown */
{ 0x1004ff59, 21086 }, /* osfEndData */
{ 0x1004ff57, 21097 }, /* osfEndLine */
{ 0x1004ff1b, 21108 }, /* osfEscape */
{ 0x1004ff74, 21118 }, /* osfExtend */
{ 0x1004ff6a, 21128 }, /* osfHelp */
{ 0x1004ff63, 21136 }, /* osfInsert */
{ 0x1004ff51, 21146 }, /* osfLeft */
{ 0x1004ff67, 21154 }, /* osfMenu */
{ 0x1004ff45, 21162 }, /* osfMenuBar */
{ 0x1004ff5e, 21173 }, /* osfNextField */
{ 0x1004ff5c, 21186 }, /* osfNextMenu */
{ 0x1004ff42, 21198 }, /* osfPageDown */
{ 0x1004ff40, 21210 }, /* osfPageLeft */
{ 0x1004ff43, 21222 }, /* osfPageRight */
{ 0x1004ff41, 21235 }, /* osfPageUp */
{ 0x1004ff04, 21245 }, /* osfPaste */
{ 0x1004ff5d, 21254 }, /* osfPrevField */
{ 0x1004ff5b, 21267 }, /* osfPrevMenu */
{ 0x1004ff32, 21279 }, /* osfPrimaryPaste */
{ 0x1004ff33, 21295 }, /* osfQuickPaste */
{ 0x1004ff73, 21309 }, /* osfReselect */
{ 0x1004ff78, 21321 }, /* osfRestore */
{ 0x1004ff53, 21332 }, /* osfRight */
{ 0x1004ff60, 21341 }, /* osfSelect */
{ 0x1004ff71, 21351 }, /* osfSelectAll */
{ 0x1004ff65, 21364 }, /* osfUndo */
{ 0x1004ff52, 21372 }, /* osfUp */
{ 0x000000d8, 21378 }, /* Oslash */
{ 0x000000f8, 21385 }, /* oslash */
{ 0x000000d5, 21392 }, /* Otilde */
{ 0x000000f5, 21399 }, /* otilde */
{ 0x00000bc0, 21406 }, /* overbar */
{ 0x0000fe78, 21414 }, /* Overlay1_Enable */
{ 0x0000fe79, 21430 }, /* Overlay2_Enable */
{ 0x0000047e, 21446 }, /* overline */
{ 0x00000050, 21455 }, /* P */
{ 0x00000070, 21457 }, /* p */
{ 0x01001e56, 21459 }, /* Pabovedot */
{ 0x01001e57, 21469 }, /* pabovedot */
{ 0x0000ff56, 21479 }, /* Page_Down */
{ 0x0000ff55, 21489 }, /* Page_Up */
{ 0x000000b6, 21497 }, /* paragraph */
{ 0x00000028, 21507 }, /* parenleft */
{ 0x00000029, 21517 }, /* parenright */
{ 0x01002202, 21528 }, /* partdifferential */
{ 0x000008ef, 21545 }, /* partialderivative */
{ 0x0000ff13, 21563 }, /* Pause */
{ 0x00000025, 21569 }, /* percent */
{ 0x0000002e, 21577 }, /* period */
{ 0x000000b7, 21584 }, /* periodcentered */
{ 0x00000ad5, 21599 }, /* permille */
{ 0x010020a7, 21608 }, /* PesetaSign */
{ 0x00000afb, 21619 }, /* phonographcopyright */
{ 0x0000002b, 21639 }, /* plus */
{ 0x000000b1, 21644 }, /* plusminus */
{ 0x0000fefa, 21654 }, /* Pointer_Accelerate */
{ 0x0000fee9, 21673 }, /* Pointer_Button1 */
{ 0x0000feea, 21689 }, /* Pointer_Button2 */
{ 0x0000feeb, 21705 }, /* Pointer_Button3 */
{ 0x0000feec, 21721 }, /* Pointer_Button4 */
{ 0x0000feed, 21737 }, /* Pointer_Button5 */
{ 0x0000fee8, 21753 }, /* Pointer_Button_Dflt */
{ 0x0000feef, 21773 }, /* Pointer_DblClick1 */
{ 0x0000fef0, 21791 }, /* Pointer_DblClick2 */
{ 0x0000fef1, 21809 }, /* Pointer_DblClick3 */
{ 0x0000fef2, 21827 }, /* Pointer_DblClick4 */
{ 0x0000fef3, 21845 }, /* Pointer_DblClick5 */
{ 0x0000feee, 21863 }, /* Pointer_DblClick_Dflt */
{ 0x0000fefb, 21885 }, /* Pointer_DfltBtnNext */
{ 0x0000fefc, 21905 }, /* Pointer_DfltBtnPrev */
{ 0x0000fee3, 21925 }, /* Pointer_Down */
{ 0x0000fee6, 21938 }, /* Pointer_DownLeft */
{ 0x0000fee7, 21955 }, /* Pointer_DownRight */
{ 0x0000fef5, 21973 }, /* Pointer_Drag1 */
{ 0x0000fef6, 21987 }, /* Pointer_Drag2 */
{ 0x0000fef7, 22001 }, /* Pointer_Drag3 */
{ 0x0000fef8, 22015 }, /* Pointer_Drag4 */
{ 0x0000fefd, 22029 }, /* Pointer_Drag5 */
{ 0x0000fef4, 22043 }, /* Pointer_Drag_Dflt */
{ 0x0000fef9, 22061 }, /* Pointer_EnableKeys */
{ 0x0000fee0, 22080 }, /* Pointer_Left */
{ 0x0000fee1, 22093 }, /* Pointer_Right */
{ 0x0000fee2, 22107 }, /* Pointer_Up */
{ 0x0000fee4, 22118 }, /* Pointer_UpLeft */
{ 0x0000fee5, 22133 }, /* Pointer_UpRight */
{ 0x00000ad4, 22149 }, /* prescription */
{ 0x0000fed1, 22162 }, /* Prev_Virtual_Screen */
{ 0x0000ff3e, 22182 }, /* PreviousCandidate */
{ 0x0000ff61, 22200 }, /* Print */
{ 0x0000ff55, 22206 }, /* Prior */
{ 0x000004b0, 22212 }, /* prolongedsound */
{ 0x00000aa6, 22227 }, /* punctspace */
{ 0x00000051, 22238 }, /* Q */
{ 0x00000071, 22240 }, /* q */
{ 0x00000bcc, 22242 }, /* quad */
{ 0x0000003f, 22247 }, /* question */
{ 0x000000bf, 22256 }, /* questiondown */
{ 0x00000022, 22269 }, /* quotedbl */
{ 0x00000060, 22278 }, /* quoteleft */
{ 0x00000027, 22288 }, /* quoteright */
{ 0x00000052, 22299 }, /* R */
{ 0x00000072, 22301 }, /* r */
{ 0x0000ffd2, 22303 }, /* R1 */
{ 0x0000ffdb, 22306 }, /* R10 */
{ 0x0000ffdc, 22310 }, /* R11 */
{ 0x0000ffdd, 22314 }, /* R12 */
{ 0x0000ffde, 22318 }, /* R13 */
{ 0x0000ffdf, 22322 }, /* R14 */
{ 0x0000ffe0, 22326 }, /* R15 */
{ 0x0000ffd3, 22330 }, /* R2 */
{ 0x0000ffd4, 22333 }, /* R3 */
{ 0x0000ffd5, 22336 }, /* R4 */
{ 0x0000ffd6, 22339 }, /* R5 */
{ 0x0000ffd7, 22342 }, /* R6 */
{ 0x0000ffd8, 22345 }, /* R7 */
{ 0x0000ffd9, 22348 }, /* R8 */
{ 0x0000ffda, 22351 }, /* R9 */
{ 0x000001c0, 22354 }, /* Racute */
{ 0x000001e0, 22361 }, /* racute */
{ 0x000008d6, 22368 }, /* radical */
{ 0x000001d8, 22376 }, /* Rcaron */
{ 0x000001f8, 22383 }, /* rcaron */
{ 0x000003a3, 22390 }, /* Rcedilla */
{ 0x000003b3, 22399 }, /* rcedilla */
{ 0x0000ff66, 22408 }, /* Redo */
{ 0x000000ae, 22413 }, /* registered */
{ 0x0000fe72, 22424 }, /* RepeatKeys_Enable */
{ 0x1000ff6c, 22442 }, /* Reset */
{ 0x0000ff0d, 22448 }, /* Return */
{ 0x0000ff53, 22455 }, /* Right */
{ 0x00000abe, 22461 }, /* rightanglebracket */
{ 0x000008fd, 22479 }, /* rightarrow */
{ 0x00000ba6, 22490 }, /* rightcaret */
{ 0x00000ad3, 22501 }, /* rightdoublequotemark */
{ 0x000008b0, 22522 }, /* rightmiddlecurlybrace */
{ 0x000008b7, 22544 }, /* rightmiddlesummation */
{ 0x00000acd, 22565 }, /* rightopentriangle */
{ 0x00000aeb, 22583 }, /* rightpointer */
{ 0x00000bd8, 22596 }, /* rightshoe */
{ 0x00000ad1, 22606 }, /* rightsinglequotemark */
{ 0x000009f5, 22627 }, /* rightt */
{ 0x00000bfc, 22634 }, /* righttack */
{ 0x0000ff24, 22644 }, /* Romaji */
{ 0x010020a8, 22651 }, /* RupeeSign */
{ 0x00000053, 22661 }, /* S */
{ 0x00000073, 22663 }, /* s */
{ 0x01001e60, 22665 }, /* Sabovedot */
{ 0x01001e61, 22675 }, /* sabovedot */
{ 0x000001a6, 22685 }, /* Sacute */
{ 0x000001b6, 22692 }, /* sacute */
{ 0x000001a9, 22699 }, /* Scaron */
{ 0x000001b9, 22706 }, /* scaron */
{ 0x000001aa, 22713 }, /* Scedilla */
{ 0x000001ba, 22722 }, /* scedilla */
{ 0x0100018f, 22731 }, /* SCHWA */
{ 0x01000259, 22737 }, /* schwa */
{ 0x000002de, 22743 }, /* Scircumflex */
{ 0x000002fe, 22755 }, /* scircumflex */
{ 0x0000ff7e, 22767 }, /* script_switch */
{ 0x0000ff14, 22781 }, /* Scroll_Lock */
{ 0x00000ad7, 22793 }, /* seconds */
{ 0x000000a7, 22801 }, /* section */
{ 0x0000ff60, 22809 }, /* Select */
{ 0x0000003b, 22816 }, /* semicolon */
{ 0x000004df, 22826 }, /* semivoicedsound */
{ 0x000006a1, 22842 }, /* Serbian_dje */
{ 0x000006b1, 22854 }, /* Serbian_DJE */
{ 0x000006af, 22866 }, /* Serbian_dze */
{ 0x000006bf, 22878 }, /* Serbian_DZE */
{ 0x000006a8, 22890 }, /* Serbian_je */
{ 0x000006b8, 22901 }, /* Serbian_JE */
{ 0x000006a9, 22912 }, /* Serbian_lje */
{ 0x000006b9, 22924 }, /* Serbian_LJE */
{ 0x000006aa, 22936 }, /* Serbian_nje */
{ 0x000006ba, 22948 }, /* Serbian_NJE */
{ 0x000006ab, 22960 }, /* Serbian_tshe */
{ 0x000006bb, 22973 }, /* Serbian_TSHE */
{ 0x00000ac6, 22986 }, /* seveneighths */
{ 0x01002087, 22999 }, /* sevensubscript */
{ 0x01002077, 23014 }, /* sevensuperior */
{ 0x0000ffe1, 23028 }, /* Shift_L */
{ 0x0000ffe6, 23036 }, /* Shift_Lock */
{ 0x0000ffe2, 23047 }, /* Shift_R */
{ 0x00000aca, 23055 }, /* signaturemark */
{ 0x00000aac, 23069 }, /* signifblank */
{ 0x000008c9, 23081 }, /* similarequal */
{ 0x0000ff3c, 23094 }, /* SingleCandidate */
{ 0x00000afd, 23110 }, /* singlelowquotemark */
{ 0x01000d85, 23129 }, /* Sinh_a */
{ 0x01000d86, 23136 }, /* Sinh_aa */
{ 0x01000dcf, 23144 }, /* Sinh_aa2 */
{ 0x01000d87, 23153 }, /* Sinh_ae */
{ 0x01000dd0, 23161 }, /* Sinh_ae2 */
{ 0x01000d88, 23170 }, /* Sinh_aee */
{ 0x01000dd1, 23179 }, /* Sinh_aee2 */
{ 0x01000d93, 23189 }, /* Sinh_ai */
{ 0x01000ddb, 23197 }, /* Sinh_ai2 */
{ 0x01000dca, 23206 }, /* Sinh_al */
{ 0x01000d96, 23214 }, /* Sinh_au */
{ 0x01000dde, 23222 }, /* Sinh_au2 */
{ 0x01000db6, 23231 }, /* Sinh_ba */
{ 0x01000db7, 23239 }, /* Sinh_bha */
{ 0x01000da0, 23248 }, /* Sinh_ca */
{ 0x01000da1, 23256 }, /* Sinh_cha */
{ 0x01000da9, 23265 }, /* Sinh_dda */
{ 0x01000daa, 23274 }, /* Sinh_ddha */
{ 0x01000daf, 23284 }, /* Sinh_dha */
{ 0x01000db0, 23293 }, /* Sinh_dhha */
{ 0x01000d91, 23303 }, /* Sinh_e */
{ 0x01000dd9, 23310 }, /* Sinh_e2 */
{ 0x01000d92, 23318 }, /* Sinh_ee */
{ 0x01000dda, 23326 }, /* Sinh_ee2 */
{ 0x01000dc6, 23335 }, /* Sinh_fa */
{ 0x01000d9c, 23343 }, /* Sinh_ga */
{ 0x01000d9d, 23351 }, /* Sinh_gha */
{ 0x01000d83, 23360 }, /* Sinh_h2 */
{ 0x01000dc4, 23368 }, /* Sinh_ha */
{ 0x01000d89, 23376 }, /* Sinh_i */
{ 0x01000dd2, 23383 }, /* Sinh_i2 */
{ 0x01000d8a, 23391 }, /* Sinh_ii */
{ 0x01000dd3, 23399 }, /* Sinh_ii2 */
{ 0x01000da2, 23408 }, /* Sinh_ja */
{ 0x01000da3, 23416 }, /* Sinh_jha */
{ 0x01000da5, 23425 }, /* Sinh_jnya */
{ 0x01000d9a, 23435 }, /* Sinh_ka */
{ 0x01000d9b, 23443 }, /* Sinh_kha */
{ 0x01000df4, 23452 }, /* Sinh_kunddaliya */
{ 0x01000dbd, 23468 }, /* Sinh_la */
{ 0x01000dc5, 23476 }, /* Sinh_lla */
{ 0x01000d8f, 23485 }, /* Sinh_lu */
{ 0x01000ddf, 23493 }, /* Sinh_lu2 */
{ 0x01000d90, 23502 }, /* Sinh_luu */
{ 0x01000df3, 23511 }, /* Sinh_luu2 */
{ 0x01000db8, 23521 }, /* Sinh_ma */
{ 0x01000db9, 23529 }, /* Sinh_mba */
{ 0x01000db1, 23538 }, /* Sinh_na */
{ 0x01000dac, 23546 }, /* Sinh_ndda */
{ 0x01000db3, 23556 }, /* Sinh_ndha */
{ 0x01000d82, 23566 }, /* Sinh_ng */
{ 0x01000d9e, 23574 }, /* Sinh_ng2 */
{ 0x01000d9f, 23583 }, /* Sinh_nga */
{ 0x01000da6, 23592 }, /* Sinh_nja */
{ 0x01000dab, 23601 }, /* Sinh_nna */
{ 0x01000da4, 23610 }, /* Sinh_nya */
{ 0x01000d94, 23619 }, /* Sinh_o */
{ 0x01000ddc, 23626 }, /* Sinh_o2 */
{ 0x01000d95, 23634 }, /* Sinh_oo */
{ 0x01000ddd, 23642 }, /* Sinh_oo2 */
{ 0x01000db4, 23651 }, /* Sinh_pa */
{ 0x01000db5, 23659 }, /* Sinh_pha */
{ 0x01000dbb, 23668 }, /* Sinh_ra */
{ 0x01000d8d, 23676 }, /* Sinh_ri */
{ 0x01000d8e, 23684 }, /* Sinh_rii */
{ 0x01000dd8, 23693 }, /* Sinh_ru2 */
{ 0x01000df2, 23702 }, /* Sinh_ruu2 */
{ 0x01000dc3, 23712 }, /* Sinh_sa */
{ 0x01000dc1, 23720 }, /* Sinh_sha */
{ 0x01000dc2, 23729 }, /* Sinh_ssha */
{ 0x01000dad, 23739 }, /* Sinh_tha */
{ 0x01000dae, 23748 }, /* Sinh_thha */
{ 0x01000da7, 23758 }, /* Sinh_tta */
{ 0x01000da8, 23767 }, /* Sinh_ttha */
{ 0x01000d8b, 23777 }, /* Sinh_u */
{ 0x01000dd4, 23784 }, /* Sinh_u2 */
{ 0x01000d8c, 23792 }, /* Sinh_uu */
{ 0x01000dd6, 23800 }, /* Sinh_uu2 */
{ 0x01000dc0, 23809 }, /* Sinh_va */
{ 0x01000dba, 23817 }, /* Sinh_ya */
{ 0x01002086, 23825 }, /* sixsubscript */
{ 0x01002076, 23838 }, /* sixsuperior */
{ 0x0000002f, 23850 }, /* slash */
{ 0x0000fe73, 23856 }, /* SlowKeys_Enable */
{ 0x000009e0, 23872 }, /* soliddiamond */
{ 0x00000020, 23885 }, /* space */
{ 0x0100221a, 23891 }, /* squareroot */
{ 0x000000df, 23902 }, /* ssharp */
{ 0x000000a3, 23909 }, /* sterling */
{ 0x0000fe75, 23918 }, /* StickyKeys_Enable */
{ 0x01002263, 23936 }, /* stricteq */
{ 0x0000ff66, 23945 }, /* SunAgain */
{ 0x0000ff7e, 23954 }, /* SunAltGraph */
{ 0x1005ff77, 23966 }, /* SunAudioLowerVolume */
{ 0x1005ff78, 23986 }, /* SunAudioMute */
{ 0x1005ff79, 23999 }, /* SunAudioRaiseVolume */
{ 0x0000ff20, 24019 }, /* SunCompose */
{ 0x1005ff72, 24030 }, /* SunCopy */
{ 0x1005ff75, 24038 }, /* SunCut */
{ 0x1005ff10, 24045 }, /* SunF36 */
{ 0x1005ff11, 24052 }, /* SunF37 */
{ 0x1005ff03, 24059 }, /* SunFA_Acute */
{ 0x1005ff05, 24071 }, /* SunFA_Cedilla */
{ 0x1005ff01, 24085 }, /* SunFA_Circum */
{ 0x1005ff04, 24098 }, /* SunFA_Diaeresis */
{ 0x1005ff00, 24114 }, /* SunFA_Grave */
{ 0x1005ff02, 24126 }, /* SunFA_Tilde */
{ 0x0000ff68, 24138 }, /* SunFind */
{ 0x1005ff71, 24146 }, /* SunFront */
{ 0x1005ff73, 24155 }, /* SunOpen */
{ 0x0000ff56, 24163 }, /* SunPageDown */
{ 0x0000ff55, 24175 }, /* SunPageUp */
{ 0x1005ff74, 24185 }, /* SunPaste */
{ 0x1005ff76, 24194 }, /* SunPowerSwitch */
{ 0x1005ff7d, 24209 }, /* SunPowerSwitchShift */
{ 0x0000ff61, 24229 }, /* SunPrint_Screen */
{ 0x1005ff70, 24245 }, /* SunProps */
{ 0x0000ff69, 24254 }, /* SunStop */
{ 0x1005ff60, 24262 }, /* SunSys_Req */
{ 0x0000ff65, 24273 }, /* SunUndo */
{ 0x1005ff7a, 24281 }, /* SunVideoDegauss */
{ 0x1005ff7b, 24297 }, /* SunVideoLowerBrightness */
{ 0x1005ff7c, 24321 }, /* SunVideoRaiseBrightness */
{ 0x0000ffeb, 24345 }, /* Super_L */
{ 0x0000ffec, 24353 }, /* Super_R */
{ 0x0000ff15, 24361 }, /* Sys_Req */
{ 0x1000ff6d, 24369 }, /* System */
{ 0x00000054, 24376 }, /* T */
{ 0x00000074, 24378 }, /* t */
{ 0x0000ff09, 24380 }, /* Tab */
{ 0x01001e6a, 24384 }, /* Tabovedot */
{ 0x01001e6b, 24394 }, /* tabovedot */
{ 0x000001ab, 24404 }, /* Tcaron */
{ 0x000001bb, 24411 }, /* tcaron */
{ 0x000001de, 24418 }, /* Tcedilla */
{ 0x000001fe, 24427 }, /* tcedilla */
{ 0x00000af9, 24436 }, /* telephone */
{ 0x00000afa, 24446 }, /* telephonerecorder */
{ 0x0000fed5, 24464 }, /* Terminate_Server */
{ 0x00000ddf, 24481 }, /* Thai_baht */
{ 0x00000dba, 24491 }, /* Thai_bobaimai */
{ 0x00000da8, 24505 }, /* Thai_chochan */
{ 0x00000daa, 24518 }, /* Thai_chochang */
{ 0x00000da9, 24532 }, /* Thai_choching */
{ 0x00000dac, 24546 }, /* Thai_chochoe */
{ 0x00000dae, 24559 }, /* Thai_dochada */
{ 0x00000db4, 24572 }, /* Thai_dodek */
{ 0x00000dbd, 24583 }, /* Thai_fofa */
{ 0x00000dbf, 24593 }, /* Thai_fofan */
{ 0x00000dcb, 24604 }, /* Thai_hohip */
{ 0x00000dce, 24615 }, /* Thai_honokhuk */
{ 0x00000da2, 24629 }, /* Thai_khokhai */
{ 0x00000da5, 24642 }, /* Thai_khokhon */
{ 0x00000da3, 24655 }, /* Thai_khokhuat */
{ 0x00000da4, 24669 }, /* Thai_khokhwai */
{ 0x00000da6, 24683 }, /* Thai_khorakhang */
{ 0x00000da1, 24699 }, /* Thai_kokai */
{ 0x00000de5, 24710 }, /* Thai_lakkhangyao */
{ 0x00000df7, 24727 }, /* Thai_lekchet */
{ 0x00000df5, 24740 }, /* Thai_lekha */
{ 0x00000df6, 24751 }, /* Thai_lekhok */
{ 0x00000df9, 24763 }, /* Thai_lekkao */
{ 0x00000df1, 24775 }, /* Thai_leknung */
{ 0x00000df8, 24788 }, /* Thai_lekpaet */
{ 0x00000df3, 24801 }, /* Thai_leksam */
{ 0x00000df4, 24813 }, /* Thai_leksi */
{ 0x00000df2, 24824 }, /* Thai_leksong */
{ 0x00000df0, 24837 }, /* Thai_leksun */
{ 0x00000dcc, 24849 }, /* Thai_lochula */
{ 0x00000dc5, 24862 }, /* Thai_loling */
{ 0x00000dc6, 24874 }, /* Thai_lu */
{ 0x00000deb, 24882 }, /* Thai_maichattawa */
{ 0x00000de8, 24899 }, /* Thai_maiek */
{ 0x00000dd1, 24910 }, /* Thai_maihanakat */
{ 0x00000dde, 24926 }, /* Thai_maihanakat_maitho */
{ 0x00000de7, 24949 }, /* Thai_maitaikhu */
{ 0x00000de9, 24964 }, /* Thai_maitho */
{ 0x00000dea, 24976 }, /* Thai_maitri */
{ 0x00000de6, 24988 }, /* Thai_maiyamok */
{ 0x00000dc1, 25002 }, /* Thai_moma */
{ 0x00000da7, 25012 }, /* Thai_ngongu */
{ 0x00000ded, 25024 }, /* Thai_nikhahit */
{ 0x00000db3, 25038 }, /* Thai_nonen */
{ 0x00000db9, 25049 }, /* Thai_nonu */
{ 0x00000dcd, 25059 }, /* Thai_oang */
{ 0x00000dcf, 25069 }, /* Thai_paiyannoi */
{ 0x00000dda, 25084 }, /* Thai_phinthu */
{ 0x00000dbe, 25097 }, /* Thai_phophan */
{ 0x00000dbc, 25110 }, /* Thai_phophung */
{ 0x00000dc0, 25124 }, /* Thai_phosamphao */
{ 0x00000dbb, 25140 }, /* Thai_popla */
{ 0x00000dc3, 25151 }, /* Thai_rorua */
{ 0x00000dc4, 25162 }, /* Thai_ru */
{ 0x00000dd0, 25170 }, /* Thai_saraa */
{ 0x00000dd2, 25181 }, /* Thai_saraaa */
{ 0x00000de1, 25193 }, /* Thai_saraae */
{ 0x00000de4, 25205 }, /* Thai_saraaimaimalai */
{ 0x00000de3, 25225 }, /* Thai_saraaimaimuan */
{ 0x00000dd3, 25244 }, /* Thai_saraam */
{ 0x00000de0, 25256 }, /* Thai_sarae */
{ 0x00000dd4, 25267 }, /* Thai_sarai */
{ 0x00000dd5, 25278 }, /* Thai_saraii */
{ 0x00000de2, 25290 }, /* Thai_sarao */
{ 0x00000dd8, 25301 }, /* Thai_sarau */
{ 0x00000dd6, 25312 }, /* Thai_saraue */
{ 0x00000dd7, 25324 }, /* Thai_sarauee */
{ 0x00000dd9, 25337 }, /* Thai_sarauu */
{ 0x00000dc9, 25349 }, /* Thai_sorusi */
{ 0x00000dc8, 25361 }, /* Thai_sosala */
{ 0x00000dab, 25373 }, /* Thai_soso */
{ 0x00000dca, 25383 }, /* Thai_sosua */
{ 0x00000dec, 25394 }, /* Thai_thanthakhat */
{ 0x00000db1, 25411 }, /* Thai_thonangmontho */
{ 0x00000db2, 25430 }, /* Thai_thophuthao */
{ 0x00000db7, 25446 }, /* Thai_thothahan */
{ 0x00000db0, 25461 }, /* Thai_thothan */
{ 0x00000db8, 25474 }, /* Thai_thothong */
{ 0x00000db6, 25488 }, /* Thai_thothung */
{ 0x00000daf, 25502 }, /* Thai_topatak */
{ 0x00000db5, 25515 }, /* Thai_totao */
{ 0x00000dc7, 25526 }, /* Thai_wowaen */
{ 0x00000dc2, 25538 }, /* Thai_yoyak */
{ 0x00000dad, 25549 }, /* Thai_yoying */
{ 0x000008c0, 25561 }, /* therefore */
{ 0x00000aa7, 25571 }, /* thinspace */
{ 0x000000de, 25581 }, /* THORN */
{ 0x000000de, 25587 }, /* Thorn */
{ 0x000000fe, 25593 }, /* thorn */
{ 0x00000ac4, 25599 }, /* threeeighths */
{ 0x00000ab4, 25612 }, /* threefifths */
{ 0x000000be, 25624 }, /* threequarters */
{ 0x01002083, 25638 }, /* threesubscript */
{ 0x000000b3, 25653 }, /* threesuperior */
{ 0x0100222d, 25667 }, /* tintegral */
{ 0x000008a4, 25677 }, /* topintegral */
{ 0x000008ab, 25689 }, /* topleftparens */
{ 0x000008a2, 25703 }, /* topleftradical */
{ 0x000008a7, 25718 }, /* topleftsqbracket */
{ 0x000008b1, 25735 }, /* topleftsummation */
{ 0x000008ad, 25752 }, /* toprightparens */
{ 0x000008a9, 25767 }, /* toprightsqbracket */
{ 0x000008b5, 25785 }, /* toprightsummation */
{ 0x000009f7, 25803 }, /* topt */
{ 0x000008b3, 25808 }, /* topvertsummationconnector */
{ 0x0000ff2b, 25834 }, /* Touroku */
{ 0x00000ac9, 25842 }, /* trademark */
{ 0x00000acb, 25852 }, /* trademarkincircle */
{ 0x000003ac, 25870 }, /* Tslash */
{ 0x000003bc, 25877 }, /* tslash */
{ 0x00000ab3, 25884 }, /* twofifths */
{ 0x01002082, 25894 }, /* twosubscript */
{ 0x000000b2, 25907 }, /* twosuperior */
{ 0x00000ab1, 25919 }, /* twothirds */
{ 0x00000055, 25929 }, /* U */
{ 0x00000075, 25931 }, /* u */
{ 0x000000da, 25933 }, /* Uacute */
{ 0x000000fa, 25940 }, /* uacute */
{ 0x01001ee4, 25947 }, /* Ubelowdot */
{ 0x01001ee5, 25957 }, /* ubelowdot */
{ 0x000002dd, 25967 }, /* Ubreve */
{ 0x000002fd, 25974 }, /* ubreve */
{ 0x000000db, 25981 }, /* Ucircumflex */
{ 0x000000fb, 25993 }, /* ucircumflex */
{ 0x000000dc, 26005 }, /* Udiaeresis */
{ 0x000000fc, 26016 }, /* udiaeresis */
{ 0x000001db, 26027 }, /* Udoubleacute */
{ 0x000001fb, 26040 }, /* udoubleacute */
{ 0x000000d9, 26053 }, /* Ugrave */
{ 0x000000f9, 26060 }, /* ugrave */
{ 0x01001ee6, 26067 }, /* Uhook */
{ 0x01001ee7, 26073 }, /* uhook */
{ 0x010001af, 26079 }, /* Uhorn */
{ 0x010001b0, 26085 }, /* uhorn */
{ 0x01001ee8, 26091 }, /* Uhornacute */
{ 0x01001ee9, 26102 }, /* uhornacute */
{ 0x01001ef0, 26113 }, /* Uhornbelowdot */
{ 0x01001ef1, 26127 }, /* uhornbelowdot */
{ 0x01001eea, 26141 }, /* Uhorngrave */
{ 0x01001eeb, 26152 }, /* uhorngrave */
{ 0x01001eec, 26163 }, /* Uhornhook */
{ 0x01001eed, 26173 }, /* uhornhook */
{ 0x01001eee, 26183 }, /* Uhorntilde */
{ 0x01001eef, 26194 }, /* uhorntilde */
{ 0x000006ad, 26205 }, /* Ukrainian_ghe_with_upturn */
{ 0x000006bd, 26231 }, /* Ukrainian_GHE_WITH_UPTURN */
{ 0x000006a6, 26257 }, /* Ukrainian_i */
{ 0x000006b6, 26269 }, /* Ukrainian_I */
{ 0x000006a4, 26281 }, /* Ukrainian_ie */
{ 0x000006b4, 26294 }, /* Ukrainian_IE */
{ 0x000006a7, 26307 }, /* Ukrainian_yi */
{ 0x000006b7, 26320 }, /* Ukrainian_YI */
{ 0x000006a6, 26333 }, /* Ukranian_i */
{ 0x000006b6, 26344 }, /* Ukranian_I */
{ 0x000006a4, 26355 }, /* Ukranian_je */
{ 0x000006b4, 26367 }, /* Ukranian_JE */
{ 0x000006a7, 26379 }, /* Ukranian_yi */
{ 0x000006b7, 26391 }, /* Ukranian_YI */
{ 0x000003de, 26403 }, /* Umacron */
{ 0x000003fe, 26411 }, /* umacron */
{ 0x00000bc6, 26419 }, /* underbar */
{ 0x0000005f, 26428 }, /* underscore */
{ 0x0000ff65, 26439 }, /* Undo */
{ 0x000008dd, 26444 }, /* union */
{ 0x000003d9, 26450 }, /* Uogonek */
{ 0x000003f9, 26458 }, /* uogonek */
{ 0x0000ff52, 26466 }, /* Up */
{ 0x000008fc, 26469 }, /* uparrow */
{ 0x00000ba9, 26477 }, /* upcaret */
{ 0x000009ec, 26485 }, /* upleftcorner */
{ 0x000009eb, 26498 }, /* uprightcorner */
{ 0x00000bc3, 26512 }, /* upshoe */
{ 0x00000bd3, 26519 }, /* upstile */
{ 0x00000bce, 26527 }, /* uptack */
{ 0x000001d9, 26534 }, /* Uring */
{ 0x000001f9, 26540 }, /* uring */
{ 0x1000ff6e, 26546 }, /* User */
{ 0x000003dd, 26551 }, /* Utilde */
{ 0x000003fd, 26558 }, /* utilde */
{ 0x00000056, 26565 }, /* V */
{ 0x00000076, 26567 }, /* v */
{ 0x000008c1, 26569 }, /* variation */
{ 0x000009f8, 26579 }, /* vertbar */
{ 0x000008a6, 26587 }, /* vertconnector */
{ 0x000004de, 26601 }, /* voicedsound */
{ 0x00ffffff, 26613 }, /* VoidSymbol */
{ 0x000009e9, 26624 }, /* vt */
{ 0x00000057, 26627 }, /* W */
{ 0x00000077, 26629 }, /* w */
{ 0x01001e82, 26631 }, /* Wacute */
{ 0x01001e83, 26638 }, /* wacute */
{ 0x01000174, 26645 }, /* Wcircumflex */
{ 0x01000175, 26657 }, /* wcircumflex */
{ 0x01001e84, 26669 }, /* Wdiaeresis */
{ 0x01001e85, 26680 }, /* wdiaeresis */
{ 0x01001e80, 26691 }, /* Wgrave */
{ 0x01001e81, 26698 }, /* wgrave */
{ 0x010020a9, 26705 }, /* WonSign */
{ 0x00000058, 26713 }, /* X */
{ 0x00000078, 26715 }, /* x */
{ 0x01001e8a, 26717 }, /* Xabovedot */
{ 0x01001e8b, 26727 }, /* xabovedot */
{ 0x100811b9, 26737 }, /* XF8610ChannelsDown */
{ 0x100811b8, 26756 }, /* XF8610ChannelsUp */
{ 0x1008126f, 26773 }, /* XF863DMode */
{ 0x1008ff39, 26784 }, /* XF86AddFavorite */
{ 0x100811ad, 26800 }, /* XF86Addressbook */
{ 0x10081230, 26816 }, /* XF86ALSToggle */
{ 0x1008ff50, 26830 }, /* XF86ApplicationLeft */
{ 0x1008ff51, 26850 }, /* XF86ApplicationRight */
{ 0x10081244, 26871 }, /* XF86AppSelect */
{ 0x10081177, 26885 }, /* XF86AspectRatio */
{ 0x10081247, 26901 }, /* XF86Assistant */
{ 0x1008121c, 26915 }, /* XF86AttendantOff */
{ 0x1008121b, 26932 }, /* XF86AttendantOn */
{ 0x1008121d, 26948 }, /* XF86AttendantToggle */
{ 0x10081188, 26968 }, /* XF86Audio */
{ 0x1008ff9b, 26978 }, /* XF86AudioCycleTrack */
{ 0x1008126e, 26998 }, /* XF86AudioDesc */
{ 0x1008ff97, 27012 }, /* XF86AudioForward */
{ 0x1008ff11, 27029 }, /* XF86AudioLowerVolume */
{ 0x1008ff32, 27050 }, /* XF86AudioMedia */
{ 0x1008ffb2, 27065 }, /* XF86AudioMicMute */
{ 0x1008ff12, 27082 }, /* XF86AudioMute */
{ 0x1008ff17, 27096 }, /* XF86AudioNext */
{ 0x1008ff31, 27110 }, /* XF86AudioPause */
{ 0x1008ff14, 27125 }, /* XF86AudioPlay */
{ 0x1008ffb6, 27139 }, /* XF86AudioPreset */
{ 0x1008ff16, 27155 }, /* XF86AudioPrev */
{ 0x1008ff13, 27169 }, /* XF86AudioRaiseVolume */
{ 0x1008ff99, 27190 }, /* XF86AudioRandomPlay */
{ 0x1008ff1c, 27210 }, /* XF86AudioRecord */
{ 0x1008ff98, 27226 }, /* XF86AudioRepeat */
{ 0x1008ff3e, 27242 }, /* XF86AudioRewind */
{ 0x1008ff15, 27258 }, /* XF86AudioStop */
{ 0x1008ff8d, 27272 }, /* XF86Away */
{ 0x1008ff26, 27281 }, /* XF86Back */
{ 0x1008ff3f, 27290 }, /* XF86BackForward */
{ 0x1008ff93, 27306 }, /* XF86Battery */
{ 0x1008ffa6, 27318 }, /* XF86Blue */
{ 0x1008ff94, 27327 }, /* XF86Bluetooth */
{ 0x1008ff52, 27341 }, /* XF86Book */
{ 0x1008119b, 27350 }, /* XF86Break */
{ 0x1008ff3b, 27360 }, /* XF86BrightnessAdjust */
{ 0x100810f4, 27381 }, /* XF86BrightnessAuto */
{ 0x10081251, 27400 }, /* XF86BrightnessMax */
{ 0x10081250, 27418 }, /* XF86BrightnessMin */
{ 0x10081240, 27436 }, /* XF86Buttonconfig */
{ 0x1008ff54, 27453 }, /* XF86Calculater */
{ 0x1008ff1d, 27468 }, /* XF86Calculator */
{ 0x1008ff20, 27483 }, /* XF86Calendar */
{ 0x10081218, 27496 }, /* XF86CameraDown */
{ 0x10081210, 27511 }, /* XF86CameraFocus */
{ 0x10081219, 27527 }, /* XF86CameraLeft */
{ 0x1008121a, 27542 }, /* XF86CameraRight */
{ 0x10081217, 27558 }, /* XF86CameraUp */
{ 0x10081215, 27571 }, /* XF86CameraZoomIn */
{ 0x10081216, 27588 }, /* XF86CameraZoomOut */
{ 0x1008ff53, 27606 }, /* XF86CD */
{ 0x10081193, 27613 }, /* XF86ChannelDown */
{ 0x10081192, 27629 }, /* XF86ChannelUp */
{ 0x1008ff55, 27643 }, /* XF86Clear */
{ 0x1008fe21, 27653 }, /* XF86ClearGrab */
{ 0x1008ff56, 27667 }, /* XF86Close */
{ 0x1008ff3d, 27677 }, /* XF86Community */
{ 0x100811b6, 27691 }, /* XF86ContextMenu */
{ 0x1008ff22, 27707 }, /* XF86ContrastAdjust */
{ 0x10081243, 27726 }, /* XF86ControlPanel */
{ 0x1008ff57, 27743 }, /* XF86Copy */
{ 0x1008ff58, 27752 }, /* XF86Cut */
{ 0x1008ff9c, 27760 }, /* XF86CycleAngle */
{ 0x10081277, 27775 }, /* XF86Data */
{ 0x100811aa, 27784 }, /* XF86Database */
{ 0x1008124a, 27797 }, /* XF86Dictate */
{ 0x1008ff59, 27809 }, /* XF86Display */
{ 0x100810f5, 27821 }, /* XF86DisplayOff */
{ 0x100811af, 27836 }, /* XF86DisplayToggle */
{ 0x1008ff5b, 27854 }, /* XF86Documents */
{ 0x1008ff5a, 27868 }, /* XF86DOS */
{ 0x10081185, 27876 }, /* XF86DVD */
{ 0x100811a6, 27884 }, /* XF86Editor */
{ 0x1008ff2c, 27895 }, /* XF86Eject */
{ 0x10081249, 27905 }, /* XF86EmojiPicker */
{ 0x1008ff5c, 27921 }, /* XF86Excel */
{ 0x1008ff5d, 27931 }, /* XF86Explorer */
{ 0x10081275, 27944 }, /* XF86FastReverse */
{ 0x1008ff30, 27960 }, /* XF86Favorites */
{ 0x1008ff3c, 27974 }, /* XF86Finance */
{ 0x100811d0, 27986 }, /* XF86Fn */
{ 0x100811d1, 27993 }, /* XF86Fn_Esc */
{ 0x100811e5, 28004 }, /* XF86FnRightShift */
{ 0x1008ff27, 28021 }, /* XF86Forward */
{ 0x1008ff9d, 28033 }, /* XF86FrameBack */
{ 0x1008ff9e, 28047 }, /* XF86FrameForward */
{ 0x1008ffb8, 28064 }, /* XF86FullScreen */
{ 0x1008ff5e, 28079 }, /* XF86Game */
{ 0x1008ff5f, 28088 }, /* XF86Go */
{ 0x100811a8, 28095 }, /* XF86GraphicsEditor */
{ 0x1008ffa4, 28114 }, /* XF86Green */
{ 0x100811be, 28124 }, /* XF86HangupPhone */
{ 0x1008ffa8, 28140 }, /* XF86Hibernate */
{ 0x1008ff37, 28154 }, /* XF86History */
{ 0x1008ff18, 28166 }, /* XF86HomePage */
{ 0x1008ff3a, 28179 }, /* XF86HotLinks */
{ 0x100811ba, 28192 }, /* XF86Images */
{ 0x10081166, 28203 }, /* XF86Info */
{ 0x1008ff60, 28212 }, /* XF86iTouch */
{ 0x10081242, 28223 }, /* XF86Journal */
{ 0x1008ff06, 28235 }, /* XF86KbdBrightnessDown */
{ 0x1008ff05, 28257 }, /* XF86KbdBrightnessUp */
{ 0x10081264, 28277 }, /* XF86KbdInputAssistAccept */
{ 0x10081265, 28302 }, /* XF86KbdInputAssistCancel */
{ 0x10081261, 28327 }, /* XF86KbdInputAssistNext */
{ 0x10081263, 28350 }, /* XF86KbdInputAssistNextgroup */
{ 0x10081260, 28378 }, /* XF86KbdInputAssistPrev */
{ 0x10081262, 28401 }, /* XF86KbdInputAssistPrevgroup */
{ 0x100812b8, 28429 }, /* XF86KbdLcdMenu1 */
{ 0x100812b9, 28445 }, /* XF86KbdLcdMenu2 */
{ 0x100812ba, 28461 }, /* XF86KbdLcdMenu3 */
{ 0x100812bb, 28477 }, /* XF86KbdLcdMenu4 */
{ 0x100812bc, 28493 }, /* XF86KbdLcdMenu5 */
{ 0x1008ff04, 28509 }, /* XF86KbdLightOnOff */
{ 0x1008ffb3, 28527 }, /* XF86Keyboard */
{ 0x1008ff40, 28540 }, /* XF86Launch0 */
{ 0x1008ff41, 28552 }, /* XF86Launch1 */
{ 0x1008ff42, 28564 }, /* XF86Launch2 */
{ 0x1008ff43, 28576 }, /* XF86Launch3 */
{ 0x1008ff44, 28588 }, /* XF86Launch4 */
{ 0x1008ff45, 28600 }, /* XF86Launch5 */
{ 0x1008ff46, 28612 }, /* XF86Launch6 */
{ 0x1008ff47, 28624 }, /* XF86Launch7 */
{ 0x1008ff48, 28636 }, /* XF86Launch8 */
{ 0x1008ff49, 28648 }, /* XF86Launch9 */
{ 0x1008ff4a, 28660 }, /* XF86LaunchA */
{ 0x1008ff4b, 28672 }, /* XF86LaunchB */
{ 0x1008ff4c, 28684 }, /* XF86LaunchC */
{ 0x1008ff4d, 28696 }, /* XF86LaunchD */
{ 0x1008ff4e, 28708 }, /* XF86LaunchE */
{ 0x1008ff4f, 28720 }, /* XF86LaunchF */
{ 0x10081269, 28732 }, /* XF86LeftDown */
{ 0x10081268, 28745 }, /* XF86LeftUp */
{ 0x1008ff35, 28756 }, /* XF86LightBulb */
{ 0x1008121e, 28770 }, /* XF86LightsToggle */
{ 0x1008fe25, 28787 }, /* XF86LogGrabInfo */
{ 0x1008ff61, 28803 }, /* XF86LogOff */
{ 0x1008fe24, 28814 }, /* XF86LogWindowTree */
{ 0x10081290, 28832 }, /* XF86Macro1 */
{ 0x10081299, 28843 }, /* XF86Macro10 */
{ 0x1008129a, 28855 }, /* XF86Macro11 */
{ 0x1008129b, 28867 }, /* XF86Macro12 */
{ 0x1008129c, 28879 }, /* XF86Macro13 */
{ 0x1008129d, 28891 }, /* XF86Macro14 */
{ 0x1008129e, 28903 }, /* XF86Macro15 */
{ 0x1008129f, 28915 }, /* XF86Macro16 */
{ 0x100812a0, 28927 }, /* XF86Macro17 */
{ 0x100812a1, 28939 }, /* XF86Macro18 */
{ 0x100812a2, 28951 }, /* XF86Macro19 */
{ 0x10081291, 28963 }, /* XF86Macro2 */
{ 0x100812a3, 28974 }, /* XF86Macro20 */
{ 0x100812a4, 28986 }, /* XF86Macro21 */
{ 0x100812a5, 28998 }, /* XF86Macro22 */
{ 0x100812a6, 29010 }, /* XF86Macro23 */
{ 0x100812a7, 29022 }, /* XF86Macro24 */
{ 0x100812a8, 29034 }, /* XF86Macro25 */
{ 0x100812a9, 29046 }, /* XF86Macro26 */
{ 0x100812aa, 29058 }, /* XF86Macro27 */
{ 0x100812ab, 29070 }, /* XF86Macro28 */
{ 0x100812ac, 29082 }, /* XF86Macro29 */
{ 0x10081292, 29094 }, /* XF86Macro3 */
{ 0x100812ad, 29105 }, /* XF86Macro30 */
{ 0x10081293, 29117 }, /* XF86Macro4 */
{ 0x10081294, 29128 }, /* XF86Macro5 */
{ 0x10081295, 29139 }, /* XF86Macro6 */
{ 0x10081296, 29150 }, /* XF86Macro7 */
{ 0x10081297, 29161 }, /* XF86Macro8 */
{ 0x10081298, 29172 }, /* XF86Macro9 */
{ 0x100812b3, 29183 }, /* XF86MacroPreset1 */
{ 0x100812b4, 29200 }, /* XF86MacroPreset2 */
{ 0x100812b5, 29217 }, /* XF86MacroPreset3 */
{ 0x100812b2, 29234 }, /* XF86MacroPresetCycle */
{ 0x100812b0, 29255 }, /* XF86MacroRecordStart */
{ 0x100812b1, 29276 }, /* XF86MacroRecordStop */
{ 0x1008ff19, 29296 }, /* XF86Mail */
{ 0x1008ff90, 29305 }, /* XF86MailForward */
{ 0x1008ff62, 29321 }, /* XF86Market */
{ 0x100811b7, 29332 }, /* XF86MediaRepeat */
{ 0x1008126b, 29348 }, /* XF86MediaTopMenu */
{ 0x1008ff63, 29365 }, /* XF86Meeting */
{ 0x1008ff1e, 29377 }, /* XF86Memo */
{ 0x1008ff65, 29386 }, /* XF86MenuKB */
{ 0x1008ff66, 29397 }, /* XF86MenuPB */
{ 0x1008ff8e, 29408 }, /* XF86Messenger */
{ 0x1008ff01, 29422 }, /* XF86ModeLock */
{ 0x1008ff07, 29435 }, /* XF86MonBrightnessCycle */
{ 0x1008ff03, 29458 }, /* XF86MonBrightnessDown */
{ 0x1008ff02, 29480 }, /* XF86MonBrightnessUp */
{ 0x1008ff92, 29500 }, /* XF86Music */
{ 0x1008ff33, 29510 }, /* XF86MyComputer */
{ 0x1008ff67, 29525 }, /* XF86MySites */
{ 0x1008ff68, 29537 }, /* XF86New */
{ 0x1008ff69, 29545 }, /* XF86News */
{ 0x1008fe22, 29554 }, /* XF86Next_VMode */
{ 0x10081270, 29569 }, /* XF86NextFavorite */
{ 0x100811bc, 29586 }, /* XF86NotificationCenter */
{ 0x10081200, 29609 }, /* XF86Numeric0 */
{ 0x10081201, 29622 }, /* XF86Numeric1 */
{ 0x1008126c, 29635 }, /* XF86Numeric11 */
{ 0x1008126d, 29649 }, /* XF86Numeric12 */
{ 0x10081202, 29663 }, /* XF86Numeric2 */
{ 0x10081203, 29676 }, /* XF86Numeric3 */
{ 0x10081204, 29689 }, /* XF86Numeric4 */
{ 0x10081205, 29702 }, /* XF86Numeric5 */
{ 0x10081206, 29715 }, /* XF86Numeric6 */
{ 0x10081207, 29728 }, /* XF86Numeric7 */
{ 0x10081208, 29741 }, /* XF86Numeric8 */
{ 0x10081209, 29754 }, /* XF86Numeric9 */
{ 0x1008120c, 29767 }, /* XF86NumericA */
{ 0x1008120d, 29780 }, /* XF86NumericB */
{ 0x1008120e, 29793 }, /* XF86NumericC */
{ 0x1008120f, 29806 }, /* XF86NumericD */
{ 0x1008120b, 29819 }, /* XF86NumericPound */
{ 0x1008120a, 29836 }, /* XF86NumericStar */
{ 0x1008ff6a, 29852 }, /* XF86OfficeHome */
{ 0x10081278, 29867 }, /* XF86OnScreenKeyboard */
{ 0x1008ff6b, 29888 }, /* XF86Open */
{ 0x1008ff38, 29897 }, /* XF86OpenURL */
{ 0x1008ff6c, 29909 }, /* XF86Option */
{ 0x1008ff6d, 29920 }, /* XF86Paste */
{ 0x10081272, 29930 }, /* XF86PauseRecord */
{ 0x1008ff6e, 29946 }, /* XF86Phone */
{ 0x100811bd, 29956 }, /* XF86PickupPhone */
{ 0x1008ff91, 29972 }, /* XF86Pictures */
{ 0x1008ff21, 29985 }, /* XF86PowerDown */
{ 0x1008ff2a, 29999 }, /* XF86PowerOff */
{ 0x100811a9, 30012 }, /* XF86Presentation */
{ 0x1008fe23, 30029 }, /* XF86Prev_VMode */
{ 0x10081279, 30044 }, /* XF86PrivacyScreenToggle */
{ 0x1008ff70, 30068 }, /* XF86Q */
{ 0x1008ffa3, 30074 }, /* XF86Red */
{ 0x1008ff29, 30082 }, /* XF86Refresh */
{ 0x1008ff73, 30094 }, /* XF86Reload */
{ 0x1008ff72, 30105 }, /* XF86Reply */
{ 0x1008ffb5, 30115 }, /* XF86RFKill */
{ 0x10081267, 30126 }, /* XF86RightDown */
{ 0x10081266, 30140 }, /* XF86RightUp */
{ 0x1008ff24, 30152 }, /* XF86RockerDown */
{ 0x1008ff25, 30167 }, /* XF86RockerEnter */
{ 0x1008ff23, 30183 }, /* XF86RockerUp */
{ 0x1008126a, 30196 }, /* XF86RootMenu */
{ 0x1008ff74, 30209 }, /* XF86RotateWindows */
{ 0x1008ff76, 30227 }, /* XF86RotationKB */
{ 0x1008ffb7, 30242 }, /* XF86RotationLockToggle */
{ 0x1008ff75, 30265 }, /* XF86RotationPB */
{ 0x1008ff77, 30280 }, /* XF86Save */
{ 0x1008ff2d, 30289 }, /* XF86ScreenSaver */
{ 0x10081245, 30305 }, /* XF86Screensaver */
{ 0x1008ff7a, 30321 }, /* XF86ScrollClick */
{ 0x1008ff79, 30337 }, /* XF86ScrollDown */
{ 0x1008ff78, 30352 }, /* XF86ScrollUp */
{ 0x1008ff1b, 30365 }, /* XF86Search */
{ 0x1008ffa0, 30376 }, /* XF86Select */
{ 0x1008127a, 30387 }, /* XF86SelectiveScreenshot */
{ 0x1008ff7b, 30411 }, /* XF86Send */
{ 0x1008ff36, 30420 }, /* XF86Shop */
{ 0x1008ff2f, 30429 }, /* XF86Sleep */
{ 0x10081276, 30439 }, /* XF86SlowReverse */
{ 0x1008ff7c, 30455 }, /* XF86Spell */
{ 0x100811b0, 30465 }, /* XF86SpellCheck */
{ 0x1008ff7d, 30480 }, /* XF86SplitScreen */
{ 0x1008ff10, 30496 }, /* XF86Standby */
{ 0x1008ff1a, 30508 }, /* XF86Start */
{ 0x1008ff28, 30518 }, /* XF86Stop */
{ 0x10081271, 30527 }, /* XF86StopRecord */
{ 0x1008ff9a, 30542 }, /* XF86Subtitle */
{ 0x1008ff7e, 30555 }, /* XF86Support */
{ 0x1008ffa7, 30567 }, /* XF86Suspend */
{ 0x1008fe01, 30579 }, /* XF86Switch_VT_1 */
{ 0x1008fe0a, 30595 }, /* XF86Switch_VT_10 */
{ 0x1008fe0b, 30612 }, /* XF86Switch_VT_11 */
{ 0x1008fe0c, 30629 }, /* XF86Switch_VT_12 */
{ 0x1008fe02, 30646 }, /* XF86Switch_VT_2 */
{ 0x1008fe03, 30662 }, /* XF86Switch_VT_3 */
{ 0x1008fe04, 30678 }, /* XF86Switch_VT_4 */
{ 0x1008fe05, 30694 }, /* XF86Switch_VT_5 */
{ 0x1008fe06, 30710 }, /* XF86Switch_VT_6 */
{ 0x1008fe07, 30726 }, /* XF86Switch_VT_7 */
{ 0x1008fe08, 30742 }, /* XF86Switch_VT_8 */
{ 0x1008fe09, 30758 }, /* XF86Switch_VT_9 */
{ 0x10081241, 30774 }, /* XF86Taskmanager */
{ 0x1008ff7f, 30790 }, /* XF86TaskPane */
{ 0x1008ff80, 30803 }, /* XF86Terminal */
{ 0x1008ff9f, 30816 }, /* XF86Time */
{ 0x1008ff1f, 30825 }, /* XF86ToDoList */
{ 0x1008ff81, 30838 }, /* XF86Tools */
{ 0x1008ffa2, 30848 }, /* XF86TopMenu */
{ 0x1008ffb1, 30860 }, /* XF86TouchpadOff */
{ 0x1008ffb0, 30876 }, /* XF86TouchpadOn */
{ 0x1008ffa9, 30891 }, /* XF86TouchpadToggle */
{ 0x1008ff82, 30910 }, /* XF86Travel */
{ 0x1008fe20, 30921 }, /* XF86Ungrab */
{ 0x10081274, 30932 }, /* XF86Unmute */
{ 0x1008ff85, 30943 }, /* XF86User1KB */
{ 0x1008ff86, 30955 }, /* XF86User2KB */
{ 0x1008ff84, 30967 }, /* XF86UserPB */
{ 0x1008ff96, 30978 }, /* XF86UWB */
{ 0x1008ff34, 30986 }, /* XF86VendorHome */
{ 0x1008ff87, 31001 }, /* XF86Video */
{ 0x100811a0, 31011 }, /* XF86VideoPhone */
{ 0x1008ffa1, 31026 }, /* XF86View */
{ 0x10081273, 31035 }, /* XF86VOD */
{ 0x10081246, 31043 }, /* XF86VoiceCommand */
{ 0x100811ac, 31060 }, /* XF86Voicemail */
{ 0x1008ff2b, 31074 }, /* XF86WakeUp */
{ 0x1008ff8f, 31085 }, /* XF86WebCam */
{ 0x1008ff88, 31096 }, /* XF86WheelButton */
{ 0x1008ff95, 31112 }, /* XF86WLAN */
{ 0x1008ff89, 31121 }, /* XF86Word */
{ 0x10081211, 31130 }, /* XF86WPSButton */
{ 0x1008ffb4, 31144 }, /* XF86WWAN */
{ 0x1008ff2e, 31153 }, /* XF86WWW */
{ 0x1008ff8a, 31161 }, /* XF86Xfer */
{ 0x1008ffa5, 31170 }, /* XF86Yellow */
{ 0x1008ff8b, 31181 }, /* XF86ZoomIn */
{ 0x1008ff8c, 31192 }, /* XF86ZoomOut */
{ 0x100811a4, 31204 }, /* XF86ZoomReset */
{ 0x00000059, 31218 }, /* Y */
{ 0x00000079, 31220 }, /* y */
{ 0x000000dd, 31222 }, /* Yacute */
{ 0x000000fd, 31229 }, /* yacute */
{ 0x01001ef4, 31236 }, /* Ybelowdot */
{ 0x01001ef5, 31246 }, /* ybelowdot */
{ 0x01000176, 31256 }, /* Ycircumflex */
{ 0x01000177, 31268 }, /* ycircumflex */
{ 0x000000ff, 31280 }, /* ydiaeresis */
{ 0x000013be, 31291 }, /* Ydiaeresis */
{ 0x000000a5, 31302 }, /* yen */
{ 0x01001ef2, 31306 }, /* Ygrave */
{ 0x01001ef3, 31313 }, /* ygrave */
{ 0x01001ef6, 31320 }, /* Yhook */
{ 0x01001ef7, 31326 }, /* yhook */
{ 0x01001ef8, 31332 }, /* Ytilde */
{ 0x01001ef9, 31339 }, /* ytilde */
{ 0x0000005a, 31346 }, /* Z */
{ 0x0000007a, 31348 }, /* z */
{ 0x000001af, 31350 }, /* Zabovedot */
{ 0x000001bf, 31360 }, /* zabovedot */
{ 0x000001ac, 31370 }, /* Zacute */
{ 0x000001bc, 31377 }, /* zacute */
{ 0x000001ae, 31384 }, /* Zcaron */
{ 0x000001be, 31391 }, /* zcaron */
{ 0x0000ff3d, 31398 }, /* Zen_Koho */
{ 0x0000ff28, 31407 }, /* Zenkaku */
{ 0x0000ff2a, 31415 }, /* Zenkaku_Hankaku */
{ 0x01002080, 31431 }, /* zerosubscript */
{ 0x01002070, 31445 }, /* zerosuperior */
{ 0x010001b5, 31458 }, /* Zstroke */
{ 0x010001b6, 31466 }, /* zstroke */
};
static const struct name_keysym keysym_to_name[] = {
{ 0x00000000, 20173 }, /* NoSymbol */
{ 0x00000020, 23885 }, /* space */
{ 0x00000021, 12181 }, /* exclam */
{ 0x00000022, 22269 }, /* quotedbl */
{ 0x00000023, 20260 }, /* numbersign */
{ 0x00000024, 11333 }, /* dollar */
{ 0x00000025, 21569 }, /* percent */
{ 0x00000026, 908 }, /* ampersand */
{ 0x00000027, 934 }, /* apostrophe */
{ 0x00000028, 21507 }, /* parenleft */
{ 0x00000029, 21517 }, /* parenright */
{ 0x0000002a, 3283 }, /* asterisk */
{ 0x0000002b, 21639 }, /* plus */
{ 0x0000002c, 8762 }, /* comma */
{ 0x0000002d, 19815 }, /* minus */
{ 0x0000002e, 21577 }, /* period */
{ 0x0000002f, 23850 }, /* slash */
{ 0x00000030, 0 }, /* 0 */
{ 0x00000031, 2 }, /* 1 */
{ 0x00000032, 4 }, /* 2 */
{ 0x00000033, 6 }, /* 3 */
{ 0x00000034, 386 }, /* 4 */
{ 0x00000035, 388 }, /* 5 */
{ 0x00000036, 390 }, /* 6 */
{ 0x00000037, 392 }, /* 7 */
{ 0x00000038, 394 }, /* 8 */
{ 0x00000039, 396 }, /* 9 */
{ 0x0000003a, 8664 }, /* colon */
{ 0x0000003b, 22816 }, /* semicolon */
{ 0x0000003c, 19494 }, /* less */
{ 0x0000003d, 12133 }, /* equal */
{ 0x0000003e, 13354 }, /* greater */
{ 0x0000003f, 22247 }, /* question */
{ 0x00000040, 3292 }, /* at */
{ 0x00000041, 398 }, /* A */
{ 0x00000042, 3328 }, /* B */
{ 0x00000043, 8439 }, /* C */
{ 0x00000044, 10402 }, /* D */
{ 0x00000045, 11506 }, /* E */
{ 0x00000046, 12237 }, /* F */
{ 0x00000047, 12747 }, /* G */
{ 0x00000048, 14460 }, /* H */
{ 0x00000049, 17151 }, /* I */
{ 0x0000004a, 18196 }, /* J */
{ 0x0000004b, 18228 }, /* K */
{ 0x0000004c, 19194 }, /* L */
{ 0x0000004d, 19615 }, /* M */
{ 0x0000004e, 20025 }, /* N */
{ 0x0000004f, 20282 }, /* O */
{ 0x00000050, 21455 }, /* P */
{ 0x00000051, 22238 }, /* Q */
{ 0x00000052, 22299 }, /* R */
{ 0x00000053, 22661 }, /* S */
{ 0x00000054, 24376 }, /* T */
{ 0x00000055, 25929 }, /* U */
{ 0x00000056, 26565 }, /* V */
{ 0x00000057, 26627 }, /* W */
{ 0x00000058, 26713 }, /* X */
{ 0x00000059, 31218 }, /* Y */
{ 0x0000005a, 31346 }, /* Z */
{ 0x0000005b, 3603 }, /* bracketleft */
{ 0x0000005c, 3352 }, /* backslash */
{ 0x0000005d, 3615 }, /* bracketright */
{ 0x0000005e, 3260 }, /* asciicircum */
{ 0x0000005f, 26428 }, /* underscore */
{ 0x00000060, 13348 }, /* grave */
{ 0x00000061, 400 }, /* a */
{ 0x00000062, 3330 }, /* b */
{ 0x00000063, 8441 }, /* c */
{ 0x00000064, 10404 }, /* d */
{ 0x00000065, 11508 }, /* e */
{ 0x00000066, 12239 }, /* f */
{ 0x00000067, 12749 }, /* g */
{ 0x00000068, 14462 }, /* h */
{ 0x00000069, 17153 }, /* i */
{ 0x0000006a, 18198 }, /* j */
{ 0x0000006b, 18230 }, /* k */
{ 0x0000006c, 19196 }, /* l */
{ 0x0000006d, 19617 }, /* m */
{ 0x0000006e, 20027 }, /* n */
{ 0x0000006f, 20284 }, /* o */
{ 0x00000070, 21457 }, /* p */
{ 0x00000071, 22240 }, /* q */
{ 0x00000072, 22301 }, /* r */
{ 0x00000073, 22663 }, /* s */
{ 0x00000074, 24378 }, /* t */
{ 0x00000075, 25931 }, /* u */
{ 0x00000076, 26567 }, /* v */
{ 0x00000077, 26629 }, /* w */
{ 0x00000078, 26715 }, /* x */
{ 0x00000079, 31220 }, /* y */
{ 0x0000007a, 31348 }, /* z */
{ 0x0000007b, 3582 }, /* braceleft */
{ 0x0000007c, 3392 }, /* bar */
{ 0x0000007d, 3592 }, /* braceright */
{ 0x0000007e, 3272 }, /* asciitilde */
{ 0x000000a0, 20160 }, /* nobreakspace */
{ 0x000000a1, 12188 }, /* exclamdown */
{ 0x000000a2, 8589 }, /* cent */
{ 0x000000a3, 23909 }, /* sterling */
{ 0x000000a4, 8848 }, /* currency */
{ 0x000000a5, 31302 }, /* yen */
{ 0x000000a6, 8389 }, /* brokenbar */
{ 0x000000a7, 22801 }, /* section */
{ 0x000000a8, 11285 }, /* diaeresis */
{ 0x000000a9, 8799 }, /* copyright */
{ 0x000000aa, 20934 }, /* ordfeminine */
{ 0x000000ab, 14431 }, /* guillemotleft */
{ 0x000000ac, 20229 }, /* notsign */
{ 0x000000ad, 17144 }, /* hyphen */
{ 0x000000ae, 22413 }, /* registered */
{ 0x000000af, 19723 }, /* macron */
{ 0x000000b0, 11235 }, /* degree */
{ 0x000000b1, 21644 }, /* plusminus */
{ 0x000000b2, 25907 }, /* twosuperior */
{ 0x000000b3, 25653 }, /* threesuperior */
{ 0x000000b4, 820 }, /* acute */
{ 0x000000b5, 19881 }, /* mu */
{ 0x000000b6, 21497 }, /* paragraph */
{ 0x000000b7, 21584 }, /* periodcentered */
{ 0x000000b8, 8581 }, /* cedilla */
{ 0x000000b9, 20837 }, /* onesuperior */
{ 0x000000ba, 19770 }, /* masculine */
{ 0x000000bb, 14445 }, /* guillemotright */
{ 0x000000bc, 20804 }, /* onequarter */
{ 0x000000bd, 20796 }, /* onehalf */
{ 0x000000be, 25624 }, /* threequarters */
{ 0x000000bf, 22256 }, /* questiondown */
{ 0x000000c0, 854 }, /* Agrave */
{ 0x000000c1, 402 }, /* Aacute */
{ 0x000000c2, 622 }, /* Acircumflex */
{ 0x000000c3, 3295 }, /* Atilde */
{ 0x000000c4, 826 }, /* Adiaeresis */
{ 0x000000c5, 2036 }, /* Aring */
{ 0x000000c6, 848 }, /* AE */
{ 0x000000c7, 8539 }, /* Ccedilla */
{ 0x000000c8, 11806 }, /* Egrave */
{ 0x000000c9, 11530 }, /* Eacute */
{ 0x000000ca, 11578 }, /* Ecircumflex */
{ 0x000000cb, 11784 }, /* Ediaeresis */
{ 0x000000cc, 17287 }, /* Igrave */
{ 0x000000cd, 17165 }, /* Iacute */
{ 0x000000ce, 17213 }, /* Icircumflex */
{ 0x000000cf, 17247 }, /* Idiaeresis */
{ 0x000000d0, 12146 }, /* ETH */
{ 0x000000d1, 20237 }, /* Ntilde */
{ 0x000000d2, 20609 }, /* Ograve */
{ 0x000000d3, 20286 }, /* Oacute */
{ 0x000000d4, 20350 }, /* Ocircumflex */
{ 0x000000d5, 21392 }, /* Otilde */
{ 0x000000d6, 20548 }, /* Odiaeresis */
{ 0x000000d7, 19921 }, /* multiply */
{ 0x000000d8, 21378 }, /* Oslash */
{ 0x000000d9, 26053 }, /* Ugrave */
{ 0x000000da, 25933 }, /* Uacute */
{ 0x000000db, 25981 }, /* Ucircumflex */
{ 0x000000dc, 26005 }, /* Udiaeresis */
{ 0x000000dd, 31222 }, /* Yacute */
{ 0x000000de, 25581 }, /* THORN */
{ 0x000000df, 23902 }, /* ssharp */
{ 0x000000e0, 861 }, /* agrave */
{ 0x000000e1, 409 }, /* aacute */
{ 0x000000e2, 634 }, /* acircumflex */
{ 0x000000e3, 3302 }, /* atilde */
{ 0x000000e4, 837 }, /* adiaeresis */
{ 0x000000e5, 2042 }, /* aring */
{ 0x000000e6, 851 }, /* ae */
{ 0x000000e7, 8548 }, /* ccedilla */
{ 0x000000e8, 11813 }, /* egrave */
{ 0x000000e9, 11537 }, /* eacute */
{ 0x000000ea, 11590 }, /* ecircumflex */
{ 0x000000eb, 11795 }, /* ediaeresis */
{ 0x000000ec, 17294 }, /* igrave */
{ 0x000000ed, 17172 }, /* iacute */
{ 0x000000ee, 17225 }, /* icircumflex */
{ 0x000000ef, 17258 }, /* idiaeresis */
{ 0x000000f0, 12154 }, /* eth */
{ 0x000000f1, 20244 }, /* ntilde */
{ 0x000000f2, 20616 }, /* ograve */
{ 0x000000f3, 20293 }, /* oacute */
{ 0x000000f4, 20362 }, /* ocircumflex */
{ 0x000000f5, 21399 }, /* otilde */
{ 0x000000f6, 20559 }, /* odiaeresis */
{ 0x000000f7, 11324 }, /* division */
{ 0x000000f8, 21385 }, /* oslash */
{ 0x000000f9, 26060 }, /* ugrave */
{ 0x000000fa, 25940 }, /* uacute */
{ 0x000000fb, 25993 }, /* ucircumflex */
{ 0x000000fc, 26016 }, /* udiaeresis */
{ 0x000000fd, 31229 }, /* yacute */
{ 0x000000fe, 25593 }, /* thorn */
{ 0x000000ff, 31280 }, /* ydiaeresis */
{ 0x000001a1, 918 }, /* Aogonek */
{ 0x000001a2, 8383 }, /* breve */
{ 0x000001a3, 19599 }, /* Lstroke */
{ 0x000001a5, 19294 }, /* Lcaron */
{ 0x000001a6, 22685 }, /* Sacute */
{ 0x000001a9, 22699 }, /* Scaron */
{ 0x000001aa, 22713 }, /* Scedilla */
{ 0x000001ab, 24404 }, /* Tcaron */
{ 0x000001ac, 31370 }, /* Zacute */
{ 0x000001ae, 31384 }, /* Zcaron */
{ 0x000001af, 31350 }, /* Zabovedot */
{ 0x000001b1, 926 }, /* aogonek */
{ 0x000001b2, 20602 }, /* ogonek */
{ 0x000001b3, 19607 }, /* lstroke */
{ 0x000001b5, 19301 }, /* lcaron */
{ 0x000001b6, 22692 }, /* sacute */
{ 0x000001b7, 8519 }, /* caron */
{ 0x000001b9, 22706 }, /* scaron */
{ 0x000001ba, 22722 }, /* scedilla */
{ 0x000001bb, 24411 }, /* tcaron */
{ 0x000001bc, 31377 }, /* zacute */
{ 0x000001bd, 11365 }, /* doubleacute */
{ 0x000001be, 31391 }, /* zcaron */
{ 0x000001bf, 31360 }, /* zabovedot */
{ 0x000001c0, 22354 }, /* Racute */
{ 0x000001c3, 445 }, /* Abreve */
{ 0x000001c5, 19229 }, /* Lacute */
{ 0x000001c6, 8475 }, /* Cacute */
{ 0x000001c8, 8525 }, /* Ccaron */
{ 0x000001ca, 12117 }, /* Eogonek */
{ 0x000001cc, 11564 }, /* Ecaron */
{ 0x000001cf, 10447 }, /* Dcaron */
{ 0x000001d0, 11483 }, /* Dstroke */
{ 0x000001d1, 20035 }, /* Nacute */
{ 0x000001d2, 20059 }, /* Ncaron */
{ 0x000001d5, 20570 }, /* Odoubleacute */
{ 0x000001d8, 22376 }, /* Rcaron */
{ 0x000001d9, 26534 }, /* Uring */
{ 0x000001db, 26027 }, /* Udoubleacute */
{ 0x000001de, 24418 }, /* Tcedilla */
{ 0x000001e0, 22361 }, /* racute */
{ 0x000001e3, 452 }, /* abreve */
{ 0x000001e5, 19236 }, /* lacute */
{ 0x000001e6, 8482 }, /* cacute */
{ 0x000001e8, 8532 }, /* ccaron */
{ 0x000001ea, 12125 }, /* eogonek */
{ 0x000001ec, 11571 }, /* ecaron */
{ 0x000001ef, 10454 }, /* dcaron */
{ 0x000001f0, 11491 }, /* dstroke */
{ 0x000001f1, 20042 }, /* nacute */
{ 0x000001f2, 20066 }, /* ncaron */
{ 0x000001f5, 20583 }, /* odoubleacute */
{ 0x000001f8, 22383 }, /* rcaron */
{ 0x000001f9, 26540 }, /* uring */
{ 0x000001fb, 26040 }, /* udoubleacute */
{ 0x000001fe, 24427 }, /* tcedilla */
{ 0x000001ff, 436 }, /* abovedot */
{ 0x000002a1, 17109 }, /* Hstroke */
{ 0x000002a6, 16138 }, /* Hcircumflex */
{ 0x000002a9, 17155 }, /* Iabovedot */
{ 0x000002ab, 12771 }, /* Gbreve */
{ 0x000002ac, 18200 }, /* Jcircumflex */
{ 0x000002b1, 17117 }, /* hstroke */
{ 0x000002b6, 16150 }, /* hcircumflex */
{ 0x000002b9, 17269 }, /* idotless */
{ 0x000002bb, 12778 }, /* gbreve */
{ 0x000002bc, 18212 }, /* jcircumflex */
{ 0x000002c5, 8455 }, /* Cabovedot */
{ 0x000002c6, 8557 }, /* Ccircumflex */
{ 0x000002d5, 12751 }, /* Gabovedot */
{ 0x000002d8, 12817 }, /* Gcircumflex */
{ 0x000002dd, 25967 }, /* Ubreve */
{ 0x000002de, 22743 }, /* Scircumflex */
{ 0x000002e5, 8465 }, /* cabovedot */
{ 0x000002e6, 8569 }, /* ccircumflex */
{ 0x000002f5, 12761 }, /* gabovedot */
{ 0x000002f8, 12829 }, /* gcircumflex */
{ 0x000002fd, 25974 }, /* ubreve */
{ 0x000002fe, 22755 }, /* scircumflex */
{ 0x000003a2, 19190 }, /* kra */
{ 0x000003a3, 22390 }, /* Rcedilla */
{ 0x000003a5, 18182 }, /* Itilde */
{ 0x000003a6, 19308 }, /* Lcedilla */
{ 0x000003aa, 11921 }, /* Emacron */
{ 0x000003ab, 12799 }, /* Gcedilla */
{ 0x000003ac, 25870 }, /* Tslash */
{ 0x000003b3, 22399 }, /* rcedilla */
{ 0x000003b5, 18189 }, /* itilde */
{ 0x000003b6, 19317 }, /* lcedilla */
{ 0x000003ba, 11929 }, /* emacron */
{ 0x000003bb, 12808 }, /* gcedilla */
{ 0x000003bc, 25877 }, /* tslash */
{ 0x000003bd, 12065 }, /* ENG */
{ 0x000003bf, 12069 }, /* eng */
{ 0x000003c0, 892 }, /* Amacron */
{ 0x000003c7, 17420 }, /* Iogonek */
{ 0x000003cc, 11510 }, /* Eabovedot */
{ 0x000003cf, 17313 }, /* Imacron */
{ 0x000003d1, 20073 }, /* Ncedilla */
{ 0x000003d2, 20761 }, /* Omacron */
{ 0x000003d3, 18861 }, /* Kcedilla */
{ 0x000003d9, 26450 }, /* Uogonek */
{ 0x000003dd, 26551 }, /* Utilde */
{ 0x000003de, 26403 }, /* Umacron */
{ 0x000003e0, 900 }, /* amacron */
{ 0x000003e7, 17428 }, /* iogonek */
{ 0x000003ec, 11520 }, /* eabovedot */
{ 0x000003ef, 17321 }, /* imacron */
{ 0x000003f1, 20082 }, /* ncedilla */
{ 0x000003f2, 20769 }, /* omacron */
{ 0x000003f3, 18870 }, /* kcedilla */
{ 0x000003f9, 26458 }, /* uogonek */
{ 0x000003fd, 26558 }, /* utilde */
{ 0x000003fe, 26411 }, /* umacron */
{ 0x0000047e, 21446 }, /* overline */
{ 0x000004a1, 18325 }, /* kana_fullstop */
{ 0x000004a2, 18559 }, /* kana_openingbracket */
{ 0x000004a3, 18255 }, /* kana_closingbracket */
{ 0x000004a4, 18275 }, /* kana_comma */
{ 0x000004a5, 18286 }, /* kana_conjunctive */
{ 0x000004a6, 18771 }, /* kana_WO */
{ 0x000004a7, 18232 }, /* kana_a */
{ 0x000004a8, 18379 }, /* kana_i */
{ 0x000004a9, 18749 }, /* kana_u */
{ 0x000004aa, 18303 }, /* kana_e */
{ 0x000004ab, 18545 }, /* kana_o */
{ 0x000004ac, 18779 }, /* kana_ya */
{ 0x000004ad, 18811 }, /* kana_yu */
{ 0x000004ae, 18795 }, /* kana_yo */
{ 0x000004af, 18715 }, /* kana_tsu */
{ 0x000004b0, 22212 }, /* prolongedsound */
{ 0x000004b1, 18239 }, /* kana_A */
{ 0x000004b2, 18386 }, /* kana_I */
{ 0x000004b3, 18756 }, /* kana_U */
{ 0x000004b4, 18310 }, /* kana_E */
{ 0x000004b5, 18552 }, /* kana_O */
{ 0x000004b6, 18393 }, /* kana_KA */
{ 0x000004b7, 18409 }, /* kana_KI */
{ 0x000004b8, 18425 }, /* kana_KU */
{ 0x000004b9, 18401 }, /* kana_KE */
{ 0x000004ba, 18417 }, /* kana_KO */
{ 0x000004bb, 18619 }, /* kana_SA */
{ 0x000004bc, 18635 }, /* kana_SHI */
{ 0x000004bd, 18663 }, /* kana_SU */
{ 0x000004be, 18627 }, /* kana_SE */
{ 0x000004bf, 18655 }, /* kana_SO */
{ 0x000004c0, 18683 }, /* kana_TA */
{ 0x000004c1, 18246 }, /* kana_CHI */
{ 0x000004c2, 18724 }, /* kana_TSU */
{ 0x000004c3, 18691 }, /* kana_TE */
{ 0x000004c4, 18707 }, /* kana_TO */
{ 0x000004c5, 18505 }, /* kana_NA */
{ 0x000004c6, 18521 }, /* kana_NI */
{ 0x000004c7, 18537 }, /* kana_NU */
{ 0x000004c8, 18513 }, /* kana_NE */
{ 0x000004c9, 18529 }, /* kana_NO */
{ 0x000004ca, 18339 }, /* kana_HA */
{ 0x000004cb, 18355 }, /* kana_HI */
{ 0x000004cc, 18317 }, /* kana_FU */
{ 0x000004cd, 18347 }, /* kana_HE */
{ 0x000004ce, 18363 }, /* kana_HO */
{ 0x000004cf, 18443 }, /* kana_MA */
{ 0x000004d0, 18459 }, /* kana_MI */
{ 0x000004d1, 18490 }, /* kana_MU */
{ 0x000004d2, 18451 }, /* kana_ME */
{ 0x000004d3, 18482 }, /* kana_MO */
{ 0x000004d4, 18787 }, /* kana_YA */
{ 0x000004d5, 18819 }, /* kana_YU */
{ 0x000004d6, 18803 }, /* kana_YO */
{ 0x000004d7, 18579 }, /* kana_RA */
{ 0x000004d8, 18595 }, /* kana_RI */
{ 0x000004d9, 18611 }, /* kana_RU */
{ 0x000004da, 18587 }, /* kana_RE */
{ 0x000004db, 18603 }, /* kana_RO */
{ 0x000004dc, 18763 }, /* kana_WA */
{ 0x000004dd, 18498 }, /* kana_N */
{ 0x000004de, 26601 }, /* voicedsound */
{ 0x000004df, 22826 }, /* semivoicedsound */
{ 0x000005ac, 1109 }, /* Arabic_comma */
{ 0x000005bb, 1764 }, /* Arabic_semicolon */
{ 0x000005bf, 1698 }, /* Arabic_question_mark */
{ 0x000005c1, 1303 }, /* Arabic_hamza */
{ 0x000005c2, 1599 }, /* Arabic_maddaonalef */
{ 0x000005c3, 1354 }, /* Arabic_hamzaonalef */
{ 0x000005c4, 1373 }, /* Arabic_hamzaonwaw */
{ 0x000005c5, 1409 }, /* Arabic_hamzaunderalef */
{ 0x000005c6, 1391 }, /* Arabic_hamzaonyeh */
{ 0x000005c7, 1067 }, /* Arabic_alef */
{ 0x000005c8, 1098 }, /* Arabic_beh */
{ 0x000005c9, 1909 }, /* Arabic_tehmarbuta */
{ 0x000005ca, 1898 }, /* Arabic_teh */
{ 0x000005cb, 1939 }, /* Arabic_theh */
{ 0x000005cc, 1481 }, /* Arabic_jeem */
{ 0x000005cd, 1292 }, /* Arabic_hah */
{ 0x000005ce, 1557 }, /* Arabic_khah */
{ 0x000005cf, 1133 }, /* Arabic_dal */
{ 0x000005d0, 1927 }, /* Arabic_thal */
{ 0x000005d1, 1719 }, /* Arabic_ra */
{ 0x000005d2, 2024 }, /* Arabic_zain */
{ 0x000005d3, 1752 }, /* Arabic_seen */
{ 0x000005d4, 1795 }, /* Arabic_sheen */
{ 0x000005d5, 1741 }, /* Arabic_sad */
{ 0x000005d6, 1122 }, /* Arabic_dad */
{ 0x000005d7, 1859 }, /* Arabic_tah */
{ 0x000005d8, 2013 }, /* Arabic_zah */
{ 0x000005d9, 1056 }, /* Arabic_ain */
{ 0x000005da, 1269 }, /* Arabic_ghain */
{ 0x000005e0, 1870 }, /* Arabic_tatweel */
{ 0x000005e1, 1231 }, /* Arabic_feh */
{ 0x000005e2, 1687 }, /* Arabic_qaf */
{ 0x000005e3, 1504 }, /* Arabic_kaf */
{ 0x000005e4, 1569 }, /* Arabic_lam */
{ 0x000005e5, 1618 }, /* Arabic_meem */
{ 0x000005e6, 1630 }, /* Arabic_noon */
{ 0x000005e7, 1282 }, /* Arabic_ha */
{ 0x000005e8, 1974 }, /* Arabic_waw */
{ 0x000005e9, 1079 }, /* Arabic_alefmaksura */
{ 0x000005ea, 1985 }, /* Arabic_yeh */
{ 0x000005eb, 1215 }, /* Arabic_fathatan */
{ 0x000005ec, 1157 }, /* Arabic_dammatan */
{ 0x000005ed, 1528 }, /* Arabic_kasratan */
{ 0x000005ee, 1202 }, /* Arabic_fatha */
{ 0x000005ef, 1144 }, /* Arabic_damma */
{ 0x000005f0, 1515 }, /* Arabic_kasra */
{ 0x000005f1, 1781 }, /* Arabic_shadda */
{ 0x000005f2, 1808 }, /* Arabic_sukun */
{ 0x000006a1, 22842 }, /* Serbian_dje */
{ 0x000006a2, 19667 }, /* Macedonia_gje */
{ 0x000006a3, 9538 }, /* Cyrillic_io */
{ 0x000006a4, 26281 }, /* Ukrainian_ie */
{ 0x000006a5, 19639 }, /* Macedonia_dse */
{ 0x000006a6, 26257 }, /* Ukrainian_i */
{ 0x000006a7, 26307 }, /* Ukrainian_yi */
{ 0x000006a8, 9562 }, /* Cyrillic_je */
{ 0x000006a9, 9700 }, /* Cyrillic_lje */
{ 0x000006aa, 9726 }, /* Cyrillic_nje */
{ 0x000006ab, 22960 }, /* Serbian_tshe */
{ 0x000006ac, 19695 }, /* Macedonia_kje */
{ 0x000006ad, 26205 }, /* Ukrainian_ghe_with_upturn */
{ 0x000006ae, 8399 }, /* Byelorussian_shortu */
{ 0x000006af, 9054 }, /* Cyrillic_dzhe */
{ 0x000006b0, 20271 }, /* numerosign */
{ 0x000006b1, 22854 }, /* Serbian_DJE */
{ 0x000006b2, 19681 }, /* Macedonia_GJE */
{ 0x000006b3, 9550 }, /* Cyrillic_IO */
{ 0x000006b4, 26294 }, /* Ukrainian_IE */
{ 0x000006b5, 19653 }, /* Macedonia_DSE */
{ 0x000006b6, 26269 }, /* Ukrainian_I */
{ 0x000006b7, 26320 }, /* Ukrainian_YI */
{ 0x000006b8, 9574 }, /* Cyrillic_JE */
{ 0x000006b9, 9713 }, /* Cyrillic_LJE */
{ 0x000006ba, 9739 }, /* Cyrillic_NJE */
{ 0x000006bb, 22973 }, /* Serbian_TSHE */
{ 0x000006bc, 19709 }, /* Macedonia_KJE */
{ 0x000006bd, 26231 }, /* Ukrainian_GHE_WITH_UPTURN */
{ 0x000006be, 8419 }, /* Byelorussian_SHORTU */
{ 0x000006bf, 9068 }, /* Cyrillic_DZHE */
{ 0x000006c0, 10282 }, /* Cyrillic_yu */
{ 0x000006c1, 8864 }, /* Cyrillic_a */
{ 0x000006c2, 8886 }, /* Cyrillic_be */
{ 0x000006c3, 10034 }, /* Cyrillic_tse */
{ 0x000006c4, 9030 }, /* Cyrillic_de */
{ 0x000006c5, 9514 }, /* Cyrillic_ie */
{ 0x000006c6, 9104 }, /* Cyrillic_ef */
{ 0x000006c7, 9292 }, /* Cyrillic_ghe */
{ 0x000006c8, 9352 }, /* Cyrillic_ha */
{ 0x000006c9, 9456 }, /* Cyrillic_i */
{ 0x000006ca, 9942 }, /* Cyrillic_shorti */
{ 0x000006cb, 9586 }, /* Cyrillic_ka */
{ 0x000006cc, 9128 }, /* Cyrillic_el */
{ 0x000006cd, 9152 }, /* Cyrillic_em */
{ 0x000006ce, 9176 }, /* Cyrillic_en */
{ 0x000006cf, 9752 }, /* Cyrillic_o */
{ 0x000006d0, 9804 }, /* Cyrillic_pe */
{ 0x000006d1, 10230 }, /* Cyrillic_ya */
{ 0x000006d2, 9244 }, /* Cyrillic_er */
{ 0x000006d3, 9268 }, /* Cyrillic_es */
{ 0x000006d4, 10010 }, /* Cyrillic_te */
{ 0x000006d5, 10060 }, /* Cyrillic_u */
{ 0x000006d6, 10330 }, /* Cyrillic_zhe */
{ 0x000006d7, 10206 }, /* Cyrillic_ve */
{ 0x000006d8, 9974 }, /* Cyrillic_softsign */
{ 0x000006d9, 10254 }, /* Cyrillic_yeru */
{ 0x000006da, 10306 }, /* Cyrillic_ze */
{ 0x000006db, 9858 }, /* Cyrillic_sha */
{ 0x000006dc, 9082 }, /* Cyrillic_e */
{ 0x000006dd, 9884 }, /* Cyrillic_shcha */
{ 0x000006de, 8910 }, /* Cyrillic_che */
{ 0x000006df, 9420 }, /* Cyrillic_hardsign */
{ 0x000006e0, 10294 }, /* Cyrillic_YU */
{ 0x000006e1, 8875 }, /* Cyrillic_A */
{ 0x000006e2, 8898 }, /* Cyrillic_BE */
{ 0x000006e3, 10047 }, /* Cyrillic_TSE */
{ 0x000006e4, 9042 }, /* Cyrillic_DE */
{ 0x000006e5, 9526 }, /* Cyrillic_IE */
{ 0x000006e6, 9116 }, /* Cyrillic_EF */
{ 0x000006e7, 9305 }, /* Cyrillic_GHE */
{ 0x000006e8, 9364 }, /* Cyrillic_HA */
{ 0x000006e9, 9467 }, /* Cyrillic_I */
{ 0x000006ea, 9958 }, /* Cyrillic_SHORTI */
{ 0x000006eb, 9598 }, /* Cyrillic_KA */
{ 0x000006ec, 9140 }, /* Cyrillic_EL */
{ 0x000006ed, 9164 }, /* Cyrillic_EM */
{ 0x000006ee, 9188 }, /* Cyrillic_EN */
{ 0x000006ef, 9763 }, /* Cyrillic_O */
{ 0x000006f0, 9816 }, /* Cyrillic_PE */
{ 0x000006f1, 10242 }, /* Cyrillic_YA */
{ 0x000006f2, 9256 }, /* Cyrillic_ER */
{ 0x000006f3, 9280 }, /* Cyrillic_ES */
{ 0x000006f4, 10022 }, /* Cyrillic_TE */
{ 0x000006f5, 10071 }, /* Cyrillic_U */
{ 0x000006f6, 10343 }, /* Cyrillic_ZHE */
{ 0x000006f7, 10218 }, /* Cyrillic_VE */
{ 0x000006f8, 9992 }, /* Cyrillic_SOFTSIGN */
{ 0x000006f9, 10268 }, /* Cyrillic_YERU */
{ 0x000006fa, 10318 }, /* Cyrillic_ZE */
{ 0x000006fb, 9871 }, /* Cyrillic_SHA */
{ 0x000006fc, 9093 }, /* Cyrillic_E */
{ 0x000006fd, 9899 }, /* Cyrillic_SHCHA */
{ 0x000006fe, 8923 }, /* Cyrillic_CHE */
{ 0x000006ff, 9438 }, /* Cyrillic_HARDSIGN */
{ 0x000007a1, 13424 }, /* Greek_ALPHAaccent */
{ 0x000007a2, 13554 }, /* Greek_EPSILONaccent */
{ 0x000007a3, 13614 }, /* Greek_ETAaccent */
{ 0x000007a4, 13729 }, /* Greek_IOTAaccent */
{ 0x000007a5, 13808 }, /* Greek_IOTAdieresis */
{ 0x000007a7, 14044 }, /* Greek_OMICRONaccent */
{ 0x000007a8, 14271 }, /* Greek_UPSILONaccent */
{ 0x000007a9, 14339 }, /* Greek_UPSILONdieresis */
{ 0x000007ab, 13980 }, /* Greek_OMEGAaccent */
{ 0x000007ae, 13379 }, /* Greek_accentdieresis */
{ 0x000007af, 13692 }, /* Greek_horizbar */
{ 0x000007b1, 13442 }, /* Greek_alphaaccent */
{ 0x000007b2, 13574 }, /* Greek_epsilonaccent */
{ 0x000007b3, 13630 }, /* Greek_etaaccent */
{ 0x000007b4, 13746 }, /* Greek_iotaaccent */
{ 0x000007b5, 13827 }, /* Greek_iotadieresis */
{ 0x000007b6, 13763 }, /* Greek_iotaaccentdieresis */
{ 0x000007b7, 14064 }, /* Greek_omicronaccent */
{ 0x000007b8, 14291 }, /* Greek_upsilonaccent */
{ 0x000007b9, 14361 }, /* Greek_upsilondieresis */
{ 0x000007ba, 14311 }, /* Greek_upsilonaccentdieresis */
{ 0x000007bb, 13998 }, /* Greek_omegaaccent */
{ 0x000007c1, 13400 }, /* Greek_ALPHA */
{ 0x000007c2, 13460 }, /* Greek_BETA */
{ 0x000007c3, 13668 }, /* Greek_GAMMA */
{ 0x000007c4, 13502 }, /* Greek_DELTA */
{ 0x000007c5, 13526 }, /* Greek_EPSILON */
{ 0x000007c6, 14401 }, /* Greek_ZETA */
{ 0x000007c7, 13594 }, /* Greek_ETA */
{ 0x000007c8, 14219 }, /* Greek_THETA */
{ 0x000007c9, 13707 }, /* Greek_IOTA */
{ 0x000007ca, 13846 }, /* Greek_KAPPA */
{ 0x000007cb, 13896 }, /* Greek_LAMDA */
{ 0x000007cc, 13920 }, /* Greek_MU */
{ 0x000007cd, 13938 }, /* Greek_NU */
{ 0x000007ce, 14383 }, /* Greek_XI */
{ 0x000007cf, 14016 }, /* Greek_OMICRON */
{ 0x000007d0, 14104 }, /* Greek_PI */
{ 0x000007d1, 14142 }, /* Greek_RHO */
{ 0x000007d2, 14162 }, /* Greek_SIGMA */
{ 0x000007d4, 14199 }, /* Greek_TAU */
{ 0x000007d5, 14243 }, /* Greek_UPSILON */
{ 0x000007d6, 14084 }, /* Greek_PHI */
{ 0x000007d7, 13482 }, /* Greek_CHI */
{ 0x000007d8, 14122 }, /* Greek_PSI */
{ 0x000007d9, 13956 }, /* Greek_OMEGA */
{ 0x000007e1, 13412 }, /* Greek_alpha */
{ 0x000007e2, 13471 }, /* Greek_beta */
{ 0x000007e3, 13680 }, /* Greek_gamma */
{ 0x000007e4, 13514 }, /* Greek_delta */
{ 0x000007e5, 13540 }, /* Greek_epsilon */
{ 0x000007e6, 14412 }, /* Greek_zeta */
{ 0x000007e7, 13604 }, /* Greek_eta */
{ 0x000007e8, 14231 }, /* Greek_theta */
{ 0x000007e9, 13718 }, /* Greek_iota */
{ 0x000007ea, 13858 }, /* Greek_kappa */
{ 0x000007eb, 13908 }, /* Greek_lamda */
{ 0x000007ec, 13929 }, /* Greek_mu */
{ 0x000007ed, 13947 }, /* Greek_nu */
{ 0x000007ee, 14392 }, /* Greek_xi */
{ 0x000007ef, 14030 }, /* Greek_omicron */
{ 0x000007f0, 14113 }, /* Greek_pi */
{ 0x000007f1, 14152 }, /* Greek_rho */
{ 0x000007f2, 14174 }, /* Greek_sigma */
{ 0x000007f3, 13646 }, /* Greek_finalsmallsigma */
{ 0x000007f4, 14209 }, /* Greek_tau */
{ 0x000007f5, 14257 }, /* Greek_upsilon */
{ 0x000007f6, 14094 }, /* Greek_phi */
{ 0x000007f7, 13492 }, /* Greek_chi */
{ 0x000007f8, 14132 }, /* Greek_psi */
{ 0x000007f9, 13968 }, /* Greek_omega */
{ 0x000008a1, 19438 }, /* leftradical */
{ 0x000008a2, 25703 }, /* topleftradical */
{ 0x000008a3, 16749 }, /* horizconnector */
{ 0x000008a4, 25677 }, /* topintegral */
{ 0x000008a5, 3422 }, /* botintegral */
{ 0x000008a6, 26587 }, /* vertconnector */
{ 0x000008a7, 25718 }, /* topleftsqbracket */
{ 0x000008a8, 3448 }, /* botleftsqbracket */
{ 0x000008a9, 25767 }, /* toprightsqbracket */
{ 0x000008aa, 3497 }, /* botrightsqbracket */
{ 0x000008ab, 25689 }, /* topleftparens */
{ 0x000008ac, 3434 }, /* botleftparens */
{ 0x000008ad, 25752 }, /* toprightparens */
{ 0x000008ae, 3482 }, /* botrightparens */
{ 0x000008af, 19388 }, /* leftmiddlecurlybrace */
{ 0x000008b0, 22522 }, /* rightmiddlecurlybrace */
{ 0x000008b1, 25735 }, /* topleftsummation */
{ 0x000008b2, 3465 }, /* botleftsummation */
{ 0x000008b3, 25808 }, /* topvertsummationconnector */
{ 0x000008b4, 3538 }, /* botvertsummationconnector */
{ 0x000008b5, 25785 }, /* toprightsummation */
{ 0x000008b6, 3515 }, /* botrightsummation */
{ 0x000008b7, 22544 }, /* rightmiddlesummation */
{ 0x000008bc, 19499 }, /* lessthanequal */
{ 0x000008bd, 20207 }, /* notequal */
{ 0x000008be, 13362 }, /* greaterthanequal */
{ 0x000008bf, 17395 }, /* integral */
{ 0x000008c0, 25561 }, /* therefore */
{ 0x000008c1, 26569 }, /* variation */
{ 0x000008c2, 17357 }, /* infinity */
{ 0x000008c5, 20029 }, /* nabla */
{ 0x000008c8, 954 }, /* approximate */
{ 0x000008c9, 23081 }, /* similarequal */
{ 0x000008cd, 17278 }, /* ifonlyif */
{ 0x000008ce, 17329 }, /* implies */
{ 0x000008cf, 17237 }, /* identical */
{ 0x000008d6, 22368 }, /* radical */
{ 0x000008da, 17337 }, /* includedin */
{ 0x000008db, 17348 }, /* includes */
{ 0x000008dc, 17404 }, /* intersection */
{ 0x000008dd, 26444 }, /* union */
{ 0x000008de, 19539 }, /* logicaland */
{ 0x000008df, 19550 }, /* logicalor */
{ 0x000008ef, 21545 }, /* partialderivative */
{ 0x000008f6, 12738 }, /* function */
{ 0x000008fb, 19348 }, /* leftarrow */
{ 0x000008fc, 26469 }, /* uparrow */
{ 0x000008fd, 22479 }, /* rightarrow */
{ 0x000008fe, 11414 }, /* downarrow */
{ 0x000009df, 3410 }, /* blank */
{ 0x000009e0, 23872 }, /* soliddiamond */
{ 0x000009e1, 8603 }, /* checkerboard */
{ 0x000009e2, 17125 }, /* ht */
{ 0x000009e3, 12495 }, /* ff */
{ 0x000009e4, 8809 }, /* cr */
{ 0x000009e5, 19513 }, /* lf */
{ 0x000009e8, 20157 }, /* nl */
{ 0x000009e9, 26624 }, /* vt */
{ 0x000009ea, 19584 }, /* lowrightcorner */
{ 0x000009eb, 26498 }, /* uprightcorner */
{ 0x000009ec, 26485 }, /* upleftcorner */
{ 0x000009ed, 19570 }, /* lowleftcorner */
{ 0x000009ee, 8812 }, /* crossinglines */
{ 0x000009ef, 16764 }, /* horizlinescan1 */
{ 0x000009f0, 16779 }, /* horizlinescan3 */
{ 0x000009f1, 16794 }, /* horizlinescan5 */
{ 0x000009f2, 16809 }, /* horizlinescan7 */
{ 0x000009f3, 16824 }, /* horizlinescan9 */
{ 0x000009f4, 19479 }, /* leftt */
{ 0x000009f5, 22627 }, /* rightt */
{ 0x000009f6, 3533 }, /* bott */
{ 0x000009f7, 25803 }, /* topt */
{ 0x000009f8, 26579 }, /* vertbar */
{ 0x00000aa1, 12010 }, /* emspace */
{ 0x00000aa2, 12109 }, /* enspace */
{ 0x00000aa3, 11903 }, /* em3space */
{ 0x00000aa4, 11912 }, /* em4space */
{ 0x00000aa5, 11303 }, /* digitspace */
{ 0x00000aa6, 22227 }, /* punctspace */
{ 0x00000aa7, 25571 }, /* thinspace */
{ 0x00000aa8, 14464 }, /* hairspace */
{ 0x00000aa9, 11937 }, /* emdash */
{ 0x00000aaa, 12022 }, /* endash */
{ 0x00000aac, 23069 }, /* signifblank */
{ 0x00000aae, 11894 }, /* ellipsis */
{ 0x00000aaf, 11349 }, /* doubbaselinedot */
{ 0x00000ab0, 20849 }, /* onethird */
{ 0x00000ab1, 25919 }, /* twothirds */
{ 0x00000ab2, 20787 }, /* onefifth */
{ 0x00000ab3, 25884 }, /* twofifths */
{ 0x00000ab4, 25612 }, /* threefifths */
{ 0x00000ab5, 12689 }, /* fourfifths */
{ 0x00000ab6, 20815 }, /* onesixth */
{ 0x00000ab7, 12651 }, /* fivesixths */
{ 0x00000ab8, 8506 }, /* careof */
{ 0x00000abb, 12509 }, /* figdash */
{ 0x00000abc, 19331 }, /* leftanglebracket */
{ 0x00000abd, 11222 }, /* decimalpoint */
{ 0x00000abe, 22461 }, /* rightanglebracket */
{ 0x00000abf, 19763 }, /* marker */
{ 0x00000ac3, 20777 }, /* oneeighth */
{ 0x00000ac4, 25599 }, /* threeeighths */
{ 0x00000ac5, 12639 }, /* fiveeighths */
{ 0x00000ac6, 22986 }, /* seveneighths */
{ 0x00000ac9, 25842 }, /* trademark */
{ 0x00000aca, 23055 }, /* signaturemark */
{ 0x00000acb, 25852 }, /* trademarkincircle */
{ 0x00000acc, 19409 }, /* leftopentriangle */
{ 0x00000acd, 22565 }, /* rightopentriangle */
{ 0x00000ace, 11972 }, /* emopencircle */
{ 0x00000acf, 11985 }, /* emopenrectangle */
{ 0x00000ad0, 19459 }, /* leftsinglequotemark */
{ 0x00000ad1, 22606 }, /* rightsinglequotemark */
{ 0x00000ad2, 19368 }, /* leftdoublequotemark */
{ 0x00000ad3, 22501 }, /* rightdoublequotemark */
{ 0x00000ad4, 22149 }, /* prescription */
{ 0x00000ad5, 21599 }, /* permille */
{ 0x00000ad6, 19821 }, /* minutes */
{ 0x00000ad7, 22793 }, /* seconds */
{ 0x00000ad9, 19263 }, /* latincross */
{ 0x00000ada, 16708 }, /* hexagram */
{ 0x00000adb, 12537 }, /* filledrectbullet */
{ 0x00000adc, 12517 }, /* filledlefttribullet */
{ 0x00000add, 12554 }, /* filledrighttribullet */
{ 0x00000ade, 11944 }, /* emfilledcircle */
{ 0x00000adf, 11959 }, /* emfilledrect */
{ 0x00000ae0, 12073 }, /* enopencircbullet */
{ 0x00000ae1, 12090 }, /* enopensquarebullet */
{ 0x00000ae2, 20876 }, /* openrectbullet */
{ 0x00000ae3, 20918 }, /* opentribulletup */
{ 0x00000ae4, 20900 }, /* opentribulletdown */
{ 0x00000ae5, 20891 }, /* openstar */
{ 0x00000ae6, 12029 }, /* enfilledcircbullet */
{ 0x00000ae7, 12048 }, /* enfilledsqbullet */
{ 0x00000ae8, 12595 }, /* filledtribulletup */
{ 0x00000ae9, 12575 }, /* filledtribulletdown */
{ 0x00000aea, 19426 }, /* leftpointer */
{ 0x00000aeb, 22583 }, /* rightpointer */
{ 0x00000aec, 8649 }, /* club */
{ 0x00000aed, 11295 }, /* diamond */
{ 0x00000aee, 16162 }, /* heart */
{ 0x00000af0, 19750 }, /* maltesecross */
{ 0x00000af1, 10440 }, /* dagger */
{ 0x00000af2, 11377 }, /* doubledagger */
{ 0x00000af3, 8616 }, /* checkmark */
{ 0x00000af4, 3380 }, /* ballotcross */
{ 0x00000af5, 19942 }, /* musicalsharp */
{ 0x00000af6, 19930 }, /* musicalflat */
{ 0x00000af7, 19739 }, /* malesymbol */
{ 0x00000af8, 12482 }, /* femalesymbol */
{ 0x00000af9, 24436 }, /* telephone */
{ 0x00000afa, 24446 }, /* telephonerecorder */
{ 0x00000afb, 21619 }, /* phonographcopyright */
{ 0x00000afc, 8513 }, /* caret */
{ 0x00000afd, 23110 }, /* singlelowquotemark */
{ 0x00000afe, 11390 }, /* doublelowquotemark */
{ 0x00000aff, 8857 }, /* cursor */
{ 0x00000ba3, 19358 }, /* leftcaret */
{ 0x00000ba6, 22490 }, /* rightcaret */
{ 0x00000ba8, 11424 }, /* downcaret */
{ 0x00000ba9, 26477 }, /* upcaret */
{ 0x00000bc0, 21406 }, /* overbar */
{ 0x00000bc2, 11453 }, /* downtack */
{ 0x00000bc3, 26512 }, /* upshoe */
{ 0x00000bc4, 11443 }, /* downstile */
{ 0x00000bc6, 26419 }, /* underbar */
{ 0x00000bca, 18224 }, /* jot */
{ 0x00000bcc, 22242 }, /* quad */
{ 0x00000bce, 26527 }, /* uptack */
{ 0x00000bcf, 8626 }, /* circle */
{ 0x00000bd3, 26519 }, /* upstile */
{ 0x00000bd6, 11434 }, /* downshoe */
{ 0x00000bd8, 22596 }, /* rightshoe */
{ 0x00000bda, 19450 }, /* leftshoe */
{ 0x00000bdc, 19485 }, /* lefttack */
{ 0x00000bfc, 22634 }, /* righttack */
{ 0x00000cdf, 16255 }, /* hebrew_doublelowline */
{ 0x00000ce0, 16168 }, /* hebrew_aleph */
{ 0x00000ce1, 16193 }, /* hebrew_bet */
{ 0x00000ce2, 16374 }, /* hebrew_gimel */
{ 0x00000ce3, 16228 }, /* hebrew_dalet */
{ 0x00000ce4, 16401 }, /* hebrew_he */
{ 0x00000ce5, 16613 }, /* hebrew_waw */
{ 0x00000ce6, 16659 }, /* hebrew_zain */
{ 0x00000ce7, 16216 }, /* hebrew_chet */
{ 0x00000ce8, 16590 }, /* hebrew_tet */
{ 0x00000ce9, 16624 }, /* hebrew_yod */
{ 0x00000cea, 16276 }, /* hebrew_finalkaph */
{ 0x00000ceb, 16422 }, /* hebrew_kaph */
{ 0x00000cec, 16445 }, /* hebrew_lamed */
{ 0x00000ced, 16293 }, /* hebrew_finalmem */
{ 0x00000cee, 16458 }, /* hebrew_mem */
{ 0x00000cef, 16309 }, /* hebrew_finalnun */
{ 0x00000cf0, 16469 }, /* hebrew_nun */
{ 0x00000cf1, 16514 }, /* hebrew_samech */
{ 0x00000cf2, 16181 }, /* hebrew_ayin */
{ 0x00000cf3, 16325 }, /* hebrew_finalpe */
{ 0x00000cf4, 16480 }, /* hebrew_pe */
{ 0x00000cf5, 16340 }, /* hebrew_finalzade */
{ 0x00000cf6, 16635 }, /* hebrew_zade */
{ 0x00000cf7, 16490 }, /* hebrew_qoph */
{ 0x00000cf8, 16502 }, /* hebrew_resh */
{ 0x00000cf9, 16542 }, /* hebrew_shin */
{ 0x00000cfa, 16579 }, /* hebrew_taw */
{ 0x00000da1, 24699 }, /* Thai_kokai */
{ 0x00000da2, 24629 }, /* Thai_khokhai */
{ 0x00000da3, 24655 }, /* Thai_khokhuat */
{ 0x00000da4, 24669 }, /* Thai_khokhwai */
{ 0x00000da5, 24642 }, /* Thai_khokhon */
{ 0x00000da6, 24683 }, /* Thai_khorakhang */
{ 0x00000da7, 25012 }, /* Thai_ngongu */
{ 0x00000da8, 24505 }, /* Thai_chochan */
{ 0x00000da9, 24532 }, /* Thai_choching */
{ 0x00000daa, 24518 }, /* Thai_chochang */
{ 0x00000dab, 25373 }, /* Thai_soso */
{ 0x00000dac, 24546 }, /* Thai_chochoe */
{ 0x00000dad, 25549 }, /* Thai_yoying */
{ 0x00000dae, 24559 }, /* Thai_dochada */
{ 0x00000daf, 25502 }, /* Thai_topatak */
{ 0x00000db0, 25461 }, /* Thai_thothan */
{ 0x00000db1, 25411 }, /* Thai_thonangmontho */
{ 0x00000db2, 25430 }, /* Thai_thophuthao */
{ 0x00000db3, 25038 }, /* Thai_nonen */
{ 0x00000db4, 24572 }, /* Thai_dodek */
{ 0x00000db5, 25515 }, /* Thai_totao */
{ 0x00000db6, 25488 }, /* Thai_thothung */
{ 0x00000db7, 25446 }, /* Thai_thothahan */
{ 0x00000db8, 25474 }, /* Thai_thothong */
{ 0x00000db9, 25049 }, /* Thai_nonu */
{ 0x00000dba, 24491 }, /* Thai_bobaimai */
{ 0x00000dbb, 25140 }, /* Thai_popla */
{ 0x00000dbc, 25110 }, /* Thai_phophung */
{ 0x00000dbd, 24583 }, /* Thai_fofa */
{ 0x00000dbe, 25097 }, /* Thai_phophan */
{ 0x00000dbf, 24593 }, /* Thai_fofan */
{ 0x00000dc0, 25124 }, /* Thai_phosamphao */
{ 0x00000dc1, 25002 }, /* Thai_moma */
{ 0x00000dc2, 25538 }, /* Thai_yoyak */
{ 0x00000dc3, 25151 }, /* Thai_rorua */
{ 0x00000dc4, 25162 }, /* Thai_ru */
{ 0x00000dc5, 24862 }, /* Thai_loling */
{ 0x00000dc6, 24874 }, /* Thai_lu */
{ 0x00000dc7, 25526 }, /* Thai_wowaen */
{ 0x00000dc8, 25361 }, /* Thai_sosala */
{ 0x00000dc9, 25349 }, /* Thai_sorusi */
{ 0x00000dca, 25383 }, /* Thai_sosua */
{ 0x00000dcb, 24604 }, /* Thai_hohip */
{ 0x00000dcc, 24849 }, /* Thai_lochula */
{ 0x00000dcd, 25059 }, /* Thai_oang */
{ 0x00000dce, 24615 }, /* Thai_honokhuk */
{ 0x00000dcf, 25069 }, /* Thai_paiyannoi */
{ 0x00000dd0, 25170 }, /* Thai_saraa */
{ 0x00000dd1, 24910 }, /* Thai_maihanakat */
{ 0x00000dd2, 25181 }, /* Thai_saraaa */
{ 0x00000dd3, 25244 }, /* Thai_saraam */
{ 0x00000dd4, 25267 }, /* Thai_sarai */
{ 0x00000dd5, 25278 }, /* Thai_saraii */
{ 0x00000dd6, 25312 }, /* Thai_saraue */
{ 0x00000dd7, 25324 }, /* Thai_sarauee */
{ 0x00000dd8, 25301 }, /* Thai_sarau */
{ 0x00000dd9, 25337 }, /* Thai_sarauu */
{ 0x00000dda, 25084 }, /* Thai_phinthu */
{ 0x00000dde, 24926 }, /* Thai_maihanakat_maitho */
{ 0x00000ddf, 24481 }, /* Thai_baht */
{ 0x00000de0, 25256 }, /* Thai_sarae */
{ 0x00000de1, 25193 }, /* Thai_saraae */
{ 0x00000de2, 25290 }, /* Thai_sarao */
{ 0x00000de3, 25225 }, /* Thai_saraaimaimuan */
{ 0x00000de4, 25205 }, /* Thai_saraaimaimalai */
{ 0x00000de5, 24710 }, /* Thai_lakkhangyao */
{ 0x00000de6, 24988 }, /* Thai_maiyamok */
{ 0x00000de7, 24949 }, /* Thai_maitaikhu */
{ 0x00000de8, 24899 }, /* Thai_maiek */
{ 0x00000de9, 24964 }, /* Thai_maitho */
{ 0x00000dea, 24976 }, /* Thai_maitri */
{ 0x00000deb, 24882 }, /* Thai_maichattawa */
{ 0x00000dec, 25394 }, /* Thai_thanthakhat */
{ 0x00000ded, 25024 }, /* Thai_nikhahit */
{ 0x00000df0, 24837 }, /* Thai_leksun */
{ 0x00000df1, 24775 }, /* Thai_leknung */
{ 0x00000df2, 24824 }, /* Thai_leksong */
{ 0x00000df3, 24801 }, /* Thai_leksam */
{ 0x00000df4, 24813 }, /* Thai_leksi */
{ 0x00000df5, 24740 }, /* Thai_lekha */
{ 0x00000df6, 24751 }, /* Thai_lekhok */
{ 0x00000df7, 24727 }, /* Thai_lekchet */
{ 0x00000df8, 24788 }, /* Thai_lekpaet */
{ 0x00000df9, 24763 }, /* Thai_lekkao */
{ 0x00000ea1, 15263 }, /* Hangul_Kiyeog */
{ 0x00000ea2, 15808 }, /* Hangul_SsangKiyeog */
{ 0x00000ea3, 15277 }, /* Hangul_KiyeogSios */
{ 0x00000ea4, 15358 }, /* Hangul_Nieun */
{ 0x00000ea5, 15389 }, /* Hangul_NieunJieuj */
{ 0x00000ea6, 15371 }, /* Hangul_NieunHieuh */
{ 0x00000ea7, 14570 }, /* Hangul_Dikeud */
{ 0x00000ea8, 15771 }, /* Hangul_SsangDikeud */
{ 0x00000ea9, 15543 }, /* Hangul_Rieul */
{ 0x00000eaa, 15574 }, /* Hangul_RieulKiyeog */
{ 0x00000eab, 15593 }, /* Hangul_RieulMieum */
{ 0x00000eac, 15630 }, /* Hangul_RieulPieub */
{ 0x00000ead, 15648 }, /* Hangul_RieulSios */
{ 0x00000eae, 15665 }, /* Hangul_RieulTieut */
{ 0x00000eaf, 15611 }, /* Hangul_RieulPhieuf */
{ 0x00000eb0, 15556 }, /* Hangul_RieulHieuh */
{ 0x00000eb1, 15320 }, /* Hangul_Mieum */
{ 0x00000eb2, 15455 }, /* Hangul_Pieub */
{ 0x00000eb3, 15827 }, /* Hangul_SsangPieub */
{ 0x00000eb4, 15468 }, /* Hangul_PieubSios */
{ 0x00000eb5, 15744 }, /* Hangul_Sios */
{ 0x00000eb6, 15845 }, /* Hangul_SsangSios */
{ 0x00000eb7, 14659 }, /* Hangul_Ieung */
{ 0x00000eb8, 15236 }, /* Hangul_Jieuj */
{ 0x00000eb9, 15790 }, /* Hangul_SsangJieuj */
{ 0x00000eba, 14540 }, /* Hangul_Cieuc */
{ 0x00000ebb, 15249 }, /* Hangul_Khieuq */
{ 0x00000ebc, 15965 }, /* Hangul_Tieut */
{ 0x00000ebd, 15441 }, /* Hangul_Phieuf */
{ 0x00000ebe, 14637 }, /* Hangul_Hieuh */
{ 0x00000ebf, 14481 }, /* Hangul_A */
{ 0x00000ec0, 14490 }, /* Hangul_AE */
{ 0x00000ec1, 16039 }, /* Hangul_YA */
{ 0x00000ec2, 16049 }, /* Hangul_YAE */
{ 0x00000ec3, 14604 }, /* Hangul_EO */
{ 0x00000ec4, 14584 }, /* Hangul_E */
{ 0x00000ec5, 16070 }, /* Hangul_YEO */
{ 0x00000ec6, 16060 }, /* Hangul_YE */
{ 0x00000ec7, 15407 }, /* Hangul_O */
{ 0x00000ec8, 15987 }, /* Hangul_WA */
{ 0x00000ec9, 15997 }, /* Hangul_WAE */
{ 0x00000eca, 15416 }, /* Hangul_OE */
{ 0x00000ecb, 16110 }, /* Hangul_YO */
{ 0x00000ecc, 15978 }, /* Hangul_U */
{ 0x00000ecd, 16018 }, /* Hangul_WEO */
{ 0x00000ece, 16008 }, /* Hangul_WE */
{ 0x00000ecf, 16029 }, /* Hangul_WI */
{ 0x00000ed0, 16120 }, /* Hangul_YU */
{ 0x00000ed1, 14614 }, /* Hangul_EU */
{ 0x00000ed2, 16100 }, /* Hangul_YI */
{ 0x00000ed3, 14650 }, /* Hangul_I */
{ 0x00000ed4, 14764 }, /* Hangul_J_Kiyeog */
{ 0x00000ed5, 15134 }, /* Hangul_J_SsangKiyeog */
{ 0x00000ed6, 14780 }, /* Hangul_J_KiyeogSios */
{ 0x00000ed7, 14842 }, /* Hangul_J_Nieun */
{ 0x00000ed8, 14877 }, /* Hangul_J_NieunJieuj */
{ 0x00000ed9, 14857 }, /* Hangul_J_NieunHieuh */
{ 0x00000eda, 14687 }, /* Hangul_J_Dikeud */
{ 0x00000edb, 14964 }, /* Hangul_J_Rieul */
{ 0x00000edc, 14999 }, /* Hangul_J_RieulKiyeog */
{ 0x00000edd, 15020 }, /* Hangul_J_RieulMieum */
{ 0x00000ede, 15061 }, /* Hangul_J_RieulPieub */
{ 0x00000edf, 15081 }, /* Hangul_J_RieulSios */
{ 0x00000ee0, 15100 }, /* Hangul_J_RieulTieut */
{ 0x00000ee1, 15040 }, /* Hangul_J_RieulPhieuf */
{ 0x00000ee2, 14979 }, /* Hangul_J_RieulHieuh */
{ 0x00000ee3, 14827 }, /* Hangul_J_Mieum */
{ 0x00000ee4, 14930 }, /* Hangul_J_Pieub */
{ 0x00000ee5, 14945 }, /* Hangul_J_PieubSios */
{ 0x00000ee6, 15120 }, /* Hangul_J_Sios */
{ 0x00000ee7, 15155 }, /* Hangul_J_SsangSios */
{ 0x00000ee8, 14718 }, /* Hangul_J_Ieung */
{ 0x00000ee9, 14733 }, /* Hangul_J_Jieuj */
{ 0x00000eea, 14672 }, /* Hangul_J_Cieuc */
{ 0x00000eeb, 14748 }, /* Hangul_J_Khieuq */
{ 0x00000eec, 15174 }, /* Hangul_J_Tieut */
{ 0x00000eed, 14914 }, /* Hangul_J_Phieuf */
{ 0x00000eee, 14703 }, /* Hangul_J_Hieuh */
{ 0x00000eef, 15683 }, /* Hangul_RieulYeorinHieuh */
{ 0x00000ef0, 15875 }, /* Hangul_SunkyeongeumMieum */
{ 0x00000ef1, 15926 }, /* Hangul_SunkyeongeumPieub */
{ 0x00000ef2, 15426 }, /* Hangul_PanSios */
{ 0x00000ef3, 15295 }, /* Hangul_KkogjiDalrinIeung */
{ 0x00000ef4, 15900 }, /* Hangul_SunkyeongeumPhieuf */
{ 0x00000ef5, 16081 }, /* Hangul_YeorinHieuh */
{ 0x00000ef6, 14500 }, /* Hangul_AraeA */
{ 0x00000ef7, 14513 }, /* Hangul_AraeAE */
{ 0x00000ef8, 14897 }, /* Hangul_J_PanSios */
{ 0x00000ef9, 14800 }, /* Hangul_J_KkogjiDalrinIeung */
{ 0x00000efa, 15189 }, /* Hangul_J_YeorinHieuh */
{ 0x00000eff, 18879 }, /* Korean_Won */
{ 0x000013bc, 20596 }, /* OE */
{ 0x000013bd, 20599 }, /* oe */
{ 0x000013be, 31291 }, /* Ydiaeresis */
{ 0x000020ac, 12172 }, /* EuroSign */
{ 0x0000fd01, 125 }, /* 3270_Duplicate */
{ 0x0000fd02, 195 }, /* 3270_FieldMark */
{ 0x0000fd03, 343 }, /* 3270_Right2 */
{ 0x0000fd04, 245 }, /* 3270_Left2 */
{ 0x0000fd05, 33 }, /* 3270_BackTab */
{ 0x0000fd06, 151 }, /* 3270_EraseEOF */
{ 0x0000fd07, 165 }, /* 3270_EraseInput */
{ 0x0000fd08, 332 }, /* 3270_Reset */
{ 0x0000fd09, 310 }, /* 3270_Quit */
{ 0x0000fd0a, 256 }, /* 3270_PA1 */
{ 0x0000fd0b, 265 }, /* 3270_PA2 */
{ 0x0000fd0c, 274 }, /* 3270_PA3 */
{ 0x0000fd0d, 376 }, /* 3270_Test */
{ 0x0000fd0e, 23 }, /* 3270_Attn */
{ 0x0000fd0f, 74 }, /* 3270_CursorBlink */
{ 0x0000fd10, 8 }, /* 3270_AltCursor */
{ 0x0000fd11, 231 }, /* 3270_KeyClick */
{ 0x0000fd12, 221 }, /* 3270_Jump */
{ 0x0000fd13, 210 }, /* 3270_Ident */
{ 0x0000fd14, 355 }, /* 3270_Rule */
{ 0x0000fd15, 64 }, /* 3270_Copy */
{ 0x0000fd16, 283 }, /* 3270_Play */
{ 0x0000fd17, 365 }, /* 3270_Setup */
{ 0x0000fd18, 320 }, /* 3270_Record */
{ 0x0000fd19, 46 }, /* 3270_ChangeScreen */
{ 0x0000fd1a, 109 }, /* 3270_DeleteWord */
{ 0x0000fd1b, 181 }, /* 3270_ExSelect */
{ 0x0000fd1c, 91 }, /* 3270_CursorSelect */
{ 0x0000fd1d, 293 }, /* 3270_PrintScreen */
{ 0x0000fd1e, 140 }, /* 3270_Enter */
{ 0x0000fe01, 17863 }, /* ISO_Lock */
{ 0x0000fe02, 17746 }, /* ISO_Level2_Latch */
{ 0x0000fe03, 17796 }, /* ISO_Level3_Shift */
{ 0x0000fe04, 17763 }, /* ISO_Level3_Latch */
{ 0x0000fe05, 17780 }, /* ISO_Level3_Lock */
{ 0x0000fe06, 17651 }, /* ISO_Group_Latch */
{ 0x0000fe07, 17667 }, /* ISO_Group_Lock */
{ 0x0000fe08, 17908 }, /* ISO_Next_Group */
{ 0x0000fe09, 17923 }, /* ISO_Next_Group_Lock */
{ 0x0000fe0a, 18032 }, /* ISO_Prev_Group */
{ 0x0000fe0b, 18047 }, /* ISO_Prev_Group_Lock */
{ 0x0000fe0c, 17614 }, /* ISO_First_Group */
{ 0x0000fe0d, 17630 }, /* ISO_First_Group_Lock */
{ 0x0000fe0e, 17698 }, /* ISO_Last_Group */
{ 0x0000fe0f, 17713 }, /* ISO_Last_Group_Lock */
{ 0x0000fe11, 17846 }, /* ISO_Level5_Shift */
{ 0x0000fe12, 17813 }, /* ISO_Level5_Latch */
{ 0x0000fe13, 17830 }, /* ISO_Level5_Lock */
{ 0x0000fe20, 17733 }, /* ISO_Left_Tab */
{ 0x0000fe21, 17891 }, /* ISO_Move_Line_Up */
{ 0x0000fe22, 17872 }, /* ISO_Move_Line_Down */
{ 0x0000fe23, 17965 }, /* ISO_Partial_Line_Up */
{ 0x0000fe24, 17943 }, /* ISO_Partial_Line_Down */
{ 0x0000fe25, 17985 }, /* ISO_Partial_Space_Left */
{ 0x0000fe26, 18008 }, /* ISO_Partial_Space_Right */
{ 0x0000fe27, 18141 }, /* ISO_Set_Margin_Left */
{ 0x0000fe28, 18161 }, /* ISO_Set_Margin_Right */
{ 0x0000fe29, 18092 }, /* ISO_Release_Margin_Left */
{ 0x0000fe2a, 18116 }, /* ISO_Release_Margin_Right */
{ 0x0000fe2b, 18067 }, /* ISO_Release_Both_Margins */
{ 0x0000fe2c, 17552 }, /* ISO_Fast_Cursor_Left */
{ 0x0000fe2d, 17573 }, /* ISO_Fast_Cursor_Right */
{ 0x0000fe2e, 17595 }, /* ISO_Fast_Cursor_Up */
{ 0x0000fe2f, 17531 }, /* ISO_Fast_Cursor_Down */
{ 0x0000fe30, 17454 }, /* ISO_Continuous_Underline */
{ 0x0000fe31, 17479 }, /* ISO_Discontinuous_Underline */
{ 0x0000fe32, 17507 }, /* ISO_Emphasize */
{ 0x0000fe33, 17436 }, /* ISO_Center_Object */
{ 0x0000fe34, 17521 }, /* ISO_Enter */
{ 0x0000fe50, 10940 }, /* dead_grave */
{ 0x0000fe51, 10613 }, /* dead_acute */
{ 0x0000fe52, 10836 }, /* dead_circumflex */
{ 0x0000fe53, 11179 }, /* dead_tilde */
{ 0x0000fe54, 11062 }, /* dead_macron */
{ 0x0000fe55, 10782 }, /* dead_breve */
{ 0x0000fe56, 10537 }, /* dead_abovedot */
{ 0x0000fe57, 10877 }, /* dead_diaeresis */
{ 0x0000fe58, 10575 }, /* dead_abovering */
{ 0x0000fe59, 10892 }, /* dead_doubleacute */
{ 0x0000fe5a, 10812 }, /* dead_caron */
{ 0x0000fe5b, 10823 }, /* dead_cedilla */
{ 0x0000fe5c, 11088 }, /* dead_ogonek */
{ 0x0000fe5d, 11015 }, /* dead_iota */
{ 0x0000fe5e, 11204 }, /* dead_voiced_sound */
{ 0x0000fe5f, 11128 }, /* dead_semivoiced_sound */
{ 0x0000fe60, 10697 }, /* dead_belowdot */
{ 0x0000fe61, 10962 }, /* dead_hook */
{ 0x0000fe62, 10972 }, /* dead_horn */
{ 0x0000fe63, 11167 }, /* dead_stroke */
{ 0x0000fe64, 10521 }, /* dead_abovecomma */
{ 0x0000fe65, 10551 }, /* dead_abovereversedcomma */
{ 0x0000fe66, 10909 }, /* dead_doublegrave */
{ 0x0000fe67, 10728 }, /* dead_belowring */
{ 0x0000fe68, 10711 }, /* dead_belowmacron */
{ 0x0000fe69, 10640 }, /* dead_belowcircumflex */
{ 0x0000fe6a, 10743 }, /* dead_belowtilde */
{ 0x0000fe6b, 10624 }, /* dead_belowbreve */
{ 0x0000fe6c, 10677 }, /* dead_belowdiaeresis */
{ 0x0000fe6d, 10996 }, /* dead_invertedbreve */
{ 0x0000fe6e, 10661 }, /* dead_belowcomma */
{ 0x0000fe6f, 10852 }, /* dead_currency */
{ 0x0000fe70, 583 }, /* AccessX_Enable */
{ 0x0000fe71, 598 }, /* AccessX_Feedback_Enable */
{ 0x0000fe72, 22424 }, /* RepeatKeys_Enable */
{ 0x0000fe73, 23856 }, /* SlowKeys_Enable */
{ 0x0000fe74, 3564 }, /* BounceKeys_Enable */
{ 0x0000fe75, 23918 }, /* StickyKeys_Enable */
{ 0x0000fe76, 19864 }, /* MouseKeys_Enable */
{ 0x0000fe77, 19841 }, /* MouseKeys_Accel_Enable */
{ 0x0000fe78, 21414 }, /* Overlay1_Enable */
{ 0x0000fe79, 21430 }, /* Overlay2_Enable */
{ 0x0000fe7a, 3309 }, /* AudibleBell_Enable */
{ 0x0000fe80, 10507 }, /* dead_a */
{ 0x0000fe81, 10514 }, /* dead_A */
{ 0x0000fe82, 10926 }, /* dead_e */
{ 0x0000fe83, 10933 }, /* dead_E */
{ 0x0000fe84, 10982 }, /* dead_i */
{ 0x0000fe85, 10989 }, /* dead_I */
{ 0x0000fe86, 11074 }, /* dead_o */
{ 0x0000fe87, 11081 }, /* dead_O */
{ 0x0000fe88, 11190 }, /* dead_u */
{ 0x0000fe89, 11197 }, /* dead_U */
{ 0x0000fe8a, 11150 }, /* dead_small_schwa */
{ 0x0000fe8b, 10793 }, /* dead_capital_schwa */
{ 0x0000fe8c, 10951 }, /* dead_greek */
{ 0x0000fe90, 11049 }, /* dead_lowline */
{ 0x0000fe91, 10590 }, /* dead_aboveverticalline */
{ 0x0000fe92, 10759 }, /* dead_belowverticalline */
{ 0x0000fe93, 11025 }, /* dead_longsolidusoverlay */
{ 0x0000fea0, 8594 }, /* ch */
{ 0x0000fea1, 8597 }, /* Ch */
{ 0x0000fea2, 8600 }, /* CH */
{ 0x0000fea3, 8443 }, /* c_h */
{ 0x0000fea4, 8447 }, /* C_h */
{ 0x0000fea5, 8451 }, /* C_H */
{ 0x0000fed0, 12618 }, /* First_Virtual_Screen */
{ 0x0000fed1, 22162 }, /* Prev_Virtual_Screen */
{ 0x0000fed2, 20110 }, /* Next_Virtual_Screen */
{ 0x0000fed4, 19243 }, /* Last_Virtual_Screen */
{ 0x0000fed5, 24464 }, /* Terminate_Server */
{ 0x0000fee0, 22080 }, /* Pointer_Left */
{ 0x0000fee1, 22093 }, /* Pointer_Right */
{ 0x0000fee2, 22107 }, /* Pointer_Up */
{ 0x0000fee3, 21925 }, /* Pointer_Down */
{ 0x0000fee4, 22118 }, /* Pointer_UpLeft */
{ 0x0000fee5, 22133 }, /* Pointer_UpRight */
{ 0x0000fee6, 21938 }, /* Pointer_DownLeft */
{ 0x0000fee7, 21955 }, /* Pointer_DownRight */
{ 0x0000fee8, 21753 }, /* Pointer_Button_Dflt */
{ 0x0000fee9, 21673 }, /* Pointer_Button1 */
{ 0x0000feea, 21689 }, /* Pointer_Button2 */
{ 0x0000feeb, 21705 }, /* Pointer_Button3 */
{ 0x0000feec, 21721 }, /* Pointer_Button4 */
{ 0x0000feed, 21737 }, /* Pointer_Button5 */
{ 0x0000feee, 21863 }, /* Pointer_DblClick_Dflt */
{ 0x0000feef, 21773 }, /* Pointer_DblClick1 */
{ 0x0000fef0, 21791 }, /* Pointer_DblClick2 */
{ 0x0000fef1, 21809 }, /* Pointer_DblClick3 */
{ 0x0000fef2, 21827 }, /* Pointer_DblClick4 */
{ 0x0000fef3, 21845 }, /* Pointer_DblClick5 */
{ 0x0000fef4, 22043 }, /* Pointer_Drag_Dflt */
{ 0x0000fef5, 21973 }, /* Pointer_Drag1 */
{ 0x0000fef6, 21987 }, /* Pointer_Drag2 */
{ 0x0000fef7, 22001 }, /* Pointer_Drag3 */
{ 0x0000fef8, 22015 }, /* Pointer_Drag4 */
{ 0x0000fef9, 22061 }, /* Pointer_EnableKeys */
{ 0x0000fefa, 21654 }, /* Pointer_Accelerate */
{ 0x0000fefb, 21885 }, /* Pointer_DfltBtnNext */
{ 0x0000fefc, 21905 }, /* Pointer_DfltBtnPrev */
{ 0x0000fefd, 22029 }, /* Pointer_Drag5 */
{ 0x0000ff08, 3362 }, /* BackSpace */
{ 0x0000ff09, 24380 }, /* Tab */
{ 0x0000ff0a, 19516 }, /* Linefeed */
{ 0x0000ff0b, 8633 }, /* Clear */
{ 0x0000ff0d, 22448 }, /* Return */
{ 0x0000ff13, 21563 }, /* Pause */
{ 0x0000ff14, 22781 }, /* Scroll_Lock */
{ 0x0000ff15, 24361 }, /* Sys_Req */
{ 0x0000ff1b, 12139 }, /* Escape */
{ 0x0000ff20, 19893 }, /* Multi_key */
{ 0x0000ff21, 18827 }, /* Kanji */
{ 0x0000ff22, 19884 }, /* Muhenkan */
{ 0x0000ff23, 16696 }, /* Henkan_Mode */
{ 0x0000ff24, 22644 }, /* Romaji */
{ 0x0000ff25, 16717 }, /* Hiragana */
{ 0x0000ff26, 18852 }, /* Katakana */
{ 0x0000ff27, 16726 }, /* Hiragana_Katakana */
{ 0x0000ff28, 31407 }, /* Zenkaku */
{ 0x0000ff29, 16130 }, /* Hankaku */
{ 0x0000ff2a, 31415 }, /* Zenkaku_Hankaku */
{ 0x0000ff2b, 25834 }, /* Touroku */
{ 0x0000ff2c, 19780 }, /* Massyo */
{ 0x0000ff2d, 18433 }, /* Kana_Lock */
{ 0x0000ff2e, 18644 }, /* Kana_Shift */
{ 0x0000ff2f, 11861 }, /* Eisu_Shift */
{ 0x0000ff30, 11872 }, /* Eisu_toggle */
{ 0x0000ff31, 14474 }, /* Hangul */
{ 0x0000ff32, 15862 }, /* Hangul_Start */
{ 0x0000ff33, 14593 }, /* Hangul_End */
{ 0x0000ff34, 14624 }, /* Hangul_Hanja */
{ 0x0000ff35, 15210 }, /* Hangul_Jamo */
{ 0x0000ff36, 15707 }, /* Hangul_Romaja */
{ 0x0000ff37, 8654 }, /* Codeinput */
{ 0x0000ff38, 15222 }, /* Hangul_Jeonja */
{ 0x0000ff39, 14527 }, /* Hangul_Banja */
{ 0x0000ff3a, 15502 }, /* Hangul_PreHanja */
{ 0x0000ff3b, 15485 }, /* Hangul_PostHanja */
{ 0x0000ff3c, 23094 }, /* SingleCandidate */
{ 0x0000ff3d, 19903 }, /* MultipleCandidate */
{ 0x0000ff3e, 22182 }, /* PreviousCandidate */
{ 0x0000ff3f, 15756 }, /* Hangul_Special */
{ 0x0000ff50, 16744 }, /* Home */
{ 0x0000ff51, 19326 }, /* Left */
{ 0x0000ff52, 26466 }, /* Up */
{ 0x0000ff53, 22455 }, /* Right */
{ 0x0000ff54, 11409 }, /* Down */
{ 0x0000ff55, 22206 }, /* Prior */
{ 0x0000ff56, 20105 }, /* Next */
{ 0x0000ff57, 12018 }, /* End */
{ 0x0000ff58, 3404 }, /* Begin */
{ 0x0000ff60, 22809 }, /* Select */
{ 0x0000ff61, 22200 }, /* Print */
{ 0x0000ff62, 12199 }, /* Execute */
{ 0x0000ff63, 17366 }, /* Insert */
{ 0x0000ff65, 26439 }, /* Undo */
{ 0x0000ff66, 22408 }, /* Redo */
{ 0x0000ff67, 19787 }, /* Menu */
{ 0x0000ff68, 12613 }, /* Find */
{ 0x0000ff69, 8489 }, /* Cancel */
{ 0x0000ff6a, 16684 }, /* Help */
{ 0x0000ff6b, 8377 }, /* Break */
{ 0x0000ff7e, 19829 }, /* Mode_switch */
{ 0x0000ff7f, 20251 }, /* Num_Lock */
{ 0x0000ff80, 19156 }, /* KP_Space */
{ 0x0000ff89, 19177 }, /* KP_Tab */
{ 0x0000ff8d, 19013 }, /* KP_Enter */
{ 0x0000ff91, 19031 }, /* KP_F1 */
{ 0x0000ff92, 19037 }, /* KP_F2 */
{ 0x0000ff93, 19043 }, /* KP_F3 */
{ 0x0000ff94, 19049 }, /* KP_F4 */
{ 0x0000ff95, 19055 }, /* KP_Home */
{ 0x0000ff96, 19073 }, /* KP_Left */
{ 0x0000ff97, 19184 }, /* KP_Up */
{ 0x0000ff98, 19134 }, /* KP_Right */
{ 0x0000ff99, 18998 }, /* KP_Down */
{ 0x0000ff9a, 19125 }, /* KP_Prior */
{ 0x0000ff9b, 19093 }, /* KP_Next */
{ 0x0000ff9c, 19006 }, /* KP_End */
{ 0x0000ff9d, 18958 }, /* KP_Begin */
{ 0x0000ff9e, 19063 }, /* KP_Insert */
{ 0x0000ff9f, 18978 }, /* KP_Delete */
{ 0x0000ffaa, 19081 }, /* KP_Multiply */
{ 0x0000ffab, 18940 }, /* KP_Add */
{ 0x0000ffac, 19143 }, /* KP_Separator */
{ 0x0000ffad, 19165 }, /* KP_Subtract */
{ 0x0000ffae, 18967 }, /* KP_Decimal */
{ 0x0000ffaf, 18988 }, /* KP_Divide */
{ 0x0000ffb0, 18890 }, /* KP_0 */
{ 0x0000ffb1, 18895 }, /* KP_1 */
{ 0x0000ffb2, 18900 }, /* KP_2 */
{ 0x0000ffb3, 18905 }, /* KP_3 */
{ 0x0000ffb4, 18910 }, /* KP_4 */
{ 0x0000ffb5, 18915 }, /* KP_5 */
{ 0x0000ffb6, 18920 }, /* KP_6 */
{ 0x0000ffb7, 18925 }, /* KP_7 */
{ 0x0000ffb8, 18930 }, /* KP_8 */
{ 0x0000ffb9, 18935 }, /* KP_9 */
{ 0x0000ffbd, 19022 }, /* KP_Equal */
{ 0x0000ffbe, 12241 }, /* F1 */
{ 0x0000ffbf, 12284 }, /* F2 */
{ 0x0000ffc0, 12327 }, /* F3 */
{ 0x0000ffc1, 12354 }, /* F4 */
{ 0x0000ffc2, 12357 }, /* F5 */
{ 0x0000ffc3, 12360 }, /* F6 */
{ 0x0000ffc4, 12363 }, /* F7 */
{ 0x0000ffc5, 12366 }, /* F8 */
{ 0x0000ffc6, 12369 }, /* F9 */
{ 0x0000ffc7, 12244 }, /* F10 */
{ 0x0000ffc8, 12248 }, /* F11 */
{ 0x0000ffc9, 12252 }, /* F12 */
{ 0x0000ffca, 12256 }, /* F13 */
{ 0x0000ffcb, 12260 }, /* F14 */
{ 0x0000ffcc, 12264 }, /* F15 */
{ 0x0000ffcd, 12268 }, /* F16 */
{ 0x0000ffce, 12272 }, /* F17 */
{ 0x0000ffcf, 12276 }, /* F18 */
{ 0x0000ffd0, 12280 }, /* F19 */
{ 0x0000ffd1, 12287 }, /* F20 */
{ 0x0000ffd2, 12291 }, /* F21 */
{ 0x0000ffd3, 12295 }, /* F22 */
{ 0x0000ffd4, 12299 }, /* F23 */
{ 0x0000ffd5, 12303 }, /* F24 */
{ 0x0000ffd6, 12307 }, /* F25 */
{ 0x0000ffd7, 12311 }, /* F26 */
{ 0x0000ffd8, 12315 }, /* F27 */
{ 0x0000ffd9, 12319 }, /* F28 */
{ 0x0000ffda, 12323 }, /* F29 */
{ 0x0000ffdb, 12330 }, /* F30 */
{ 0x0000ffdc, 12334 }, /* F31 */
{ 0x0000ffdd, 12338 }, /* F32 */
{ 0x0000ffde, 12342 }, /* F33 */
{ 0x0000ffdf, 12346 }, /* F34 */
{ 0x0000ffe0, 12350 }, /* F35 */
{ 0x0000ffe1, 23028 }, /* Shift_L */
{ 0x0000ffe2, 23047 }, /* Shift_R */
{ 0x0000ffe3, 8779 }, /* Control_L */
{ 0x0000ffe4, 8789 }, /* Control_R */
{ 0x0000ffe5, 8496 }, /* Caps_Lock */
{ 0x0000ffe6, 23036 }, /* Shift_Lock */
{ 0x0000ffe7, 19792 }, /* Meta_L */
{ 0x0000ffe8, 19799 }, /* Meta_R */
{ 0x0000ffe9, 880 }, /* Alt_L */
{ 0x0000ffea, 886 }, /* Alt_R */
{ 0x0000ffeb, 24345 }, /* Super_L */
{ 0x0000ffec, 24353 }, /* Super_R */
{ 0x0000ffed, 17128 }, /* Hyper_L */
{ 0x0000ffee, 17136 }, /* Hyper_R */
{ 0x0000fff1, 3642 }, /* braille_dot_1 */
{ 0x0000fff2, 3671 }, /* braille_dot_2 */
{ 0x0000fff3, 3685 }, /* braille_dot_3 */
{ 0x0000fff4, 3699 }, /* braille_dot_4 */
{ 0x0000fff5, 3713 }, /* braille_dot_5 */
{ 0x0000fff6, 3727 }, /* braille_dot_6 */
{ 0x0000fff7, 3741 }, /* braille_dot_7 */
{ 0x0000fff8, 3755 }, /* braille_dot_8 */
{ 0x0000fff9, 3769 }, /* braille_dot_9 */
{ 0x0000fffa, 3656 }, /* braille_dot_10 */
{ 0x0000ffff, 11242 }, /* Delete */
{ 0x00ffffff, 26613 }, /* VoidSymbol */
{ 0x0100012c, 17199 }, /* Ibreve */
{ 0x0100012d, 17206 }, /* ibreve */
{ 0x01000174, 26645 }, /* Wcircumflex */
{ 0x01000175, 26657 }, /* wcircumflex */
{ 0x01000176, 31256 }, /* Ycircumflex */
{ 0x01000177, 31268 }, /* ycircumflex */
{ 0x0100018f, 22731 }, /* SCHWA */
{ 0x0100019f, 20300 }, /* Obarred */
{ 0x010001a0, 20635 }, /* Ohorn */
{ 0x010001a1, 20641 }, /* ohorn */
{ 0x010001af, 26079 }, /* Uhorn */
{ 0x010001b0, 26085 }, /* uhorn */
{ 0x010001b5, 31458 }, /* Zstroke */
{ 0x010001b6, 31466 }, /* zstroke */
{ 0x010001b7, 12229 }, /* EZH */
{ 0x010001d1, 20336 }, /* Ocaron */
{ 0x010001d2, 20343 }, /* ocaron */
{ 0x010001e6, 12785 }, /* Gcaron */
{ 0x010001e7, 12792 }, /* gcaron */
{ 0x01000259, 22737 }, /* schwa */
{ 0x01000275, 20308 }, /* obarred */
{ 0x01000292, 12233 }, /* ezh */
{ 0x01000300, 8715 }, /* combining_grave */
{ 0x01000301, 8680 }, /* combining_acute */
{ 0x01000303, 8746 }, /* combining_tilde */
{ 0x01000309, 8731 }, /* combining_hook */
{ 0x01000323, 8696 }, /* combining_belowdot */
{ 0x01000492, 9318 }, /* Cyrillic_GHE_bar */
{ 0x01000493, 9335 }, /* Cyrillic_ghe_bar */
{ 0x01000496, 10356 }, /* Cyrillic_ZHE_descender */
{ 0x01000497, 10379 }, /* Cyrillic_zhe_descender */
{ 0x0100049a, 9610 }, /* Cyrillic_KA_descender */
{ 0x0100049b, 9632 }, /* Cyrillic_ka_descender */
{ 0x0100049c, 9654 }, /* Cyrillic_KA_vertstroke */
{ 0x0100049d, 9677 }, /* Cyrillic_ka_vertstroke */
{ 0x010004a2, 9200 }, /* Cyrillic_EN_descender */
{ 0x010004a3, 9222 }, /* Cyrillic_en_descender */
{ 0x010004ae, 10118 }, /* Cyrillic_U_straight */
{ 0x010004af, 10138 }, /* Cyrillic_u_straight */
{ 0x010004b0, 10158 }, /* Cyrillic_U_straight_bar */
{ 0x010004b1, 10182 }, /* Cyrillic_u_straight_bar */
{ 0x010004b2, 9376 }, /* Cyrillic_HA_descender */
{ 0x010004b3, 9398 }, /* Cyrillic_ha_descender */
{ 0x010004b6, 8936 }, /* Cyrillic_CHE_descender */
{ 0x010004b7, 8959 }, /* Cyrillic_che_descender */
{ 0x010004b8, 8982 }, /* Cyrillic_CHE_vertstroke */
{ 0x010004b9, 9006 }, /* Cyrillic_che_vertstroke */
{ 0x010004ba, 9914 }, /* Cyrillic_SHHA */
{ 0x010004bb, 9928 }, /* Cyrillic_shha */
{ 0x010004d8, 9828 }, /* Cyrillic_SCHWA */
{ 0x010004d9, 9843 }, /* Cyrillic_schwa */
{ 0x010004e2, 9478 }, /* Cyrillic_I_macron */
{ 0x010004e3, 9496 }, /* Cyrillic_i_macron */
{ 0x010004e8, 9774 }, /* Cyrillic_O_bar */
{ 0x010004e9, 9789 }, /* Cyrillic_o_bar */
{ 0x010004ee, 10082 }, /* Cyrillic_U_macron */
{ 0x010004ef, 10100 }, /* Cyrillic_u_macron */
{ 0x01000531, 2124 }, /* Armenian_AYB */
{ 0x01000532, 2150 }, /* Armenian_BEN */
{ 0x01000533, 2374 }, /* Armenian_GIM */
{ 0x01000534, 2215 }, /* Armenian_DA */
{ 0x01000535, 3164 }, /* Armenian_YECH */
{ 0x01000536, 3210 }, /* Armenian_ZA */
{ 0x01000537, 2265 }, /* Armenian_E */
{ 0x01000538, 2100 }, /* Armenian_AT */
{ 0x01000539, 2964 }, /* Armenian_TO */
{ 0x0100053a, 3234 }, /* Armenian_ZHE */
{ 0x0100053b, 2464 }, /* Armenian_INI */
{ 0x0100053c, 2611 }, /* Armenian_LYUN */
{ 0x0100053d, 2564 }, /* Armenian_KHE */
{ 0x0100053e, 2988 }, /* Armenian_TSA */
{ 0x0100053f, 2538 }, /* Armenian_KEN */
{ 0x01000540, 2424 }, /* Armenian_HO */
{ 0x01000541, 2239 }, /* Armenian_DZA */
{ 0x01000542, 2346 }, /* Armenian_GHAT */
{ 0x01000543, 2936 }, /* Armenian_TCHE */
{ 0x01000544, 2639 }, /* Armenian_MEN */
{ 0x01000545, 2400 }, /* Armenian_HI */
{ 0x01000546, 2665 }, /* Armenian_NU */
{ 0x01000547, 2894 }, /* Armenian_SHA */
{ 0x01000548, 3112 }, /* Armenian_VO */
{ 0x01000549, 2189 }, /* Armenian_CHA */
{ 0x0100054a, 2727 }, /* Armenian_PE */
{ 0x0100054b, 2490 }, /* Armenian_JE */
{ 0x0100054c, 2797 }, /* Armenian_RA */
{ 0x0100054d, 2845 }, /* Armenian_SE */
{ 0x0100054e, 3086 }, /* Armenian_VEV */
{ 0x0100054f, 3040 }, /* Armenian_TYUN */
{ 0x01000550, 2821 }, /* Armenian_RE */
{ 0x01000551, 3014 }, /* Armenian_TSO */
{ 0x01000552, 3136 }, /* Armenian_VYUN */
{ 0x01000553, 2751 }, /* Armenian_PYUR */
{ 0x01000554, 2514 }, /* Armenian_KE */
{ 0x01000555, 2689 }, /* Armenian_O */
{ 0x01000556, 2303 }, /* Armenian_FE */
{ 0x0100055a, 2080 }, /* Armenian_apostrophe */
{ 0x0100055b, 2048 }, /* Armenian_accent */
{ 0x0100055c, 2287 }, /* Armenian_exclam */
{ 0x0100055d, 2869 }, /* Armenian_separation_mark */
{ 0x0100055e, 2779 }, /* Armenian_question */
{ 0x01000561, 2137 }, /* Armenian_ayb */
{ 0x01000562, 2163 }, /* Armenian_ben */
{ 0x01000563, 2387 }, /* Armenian_gim */
{ 0x01000564, 2227 }, /* Armenian_da */
{ 0x01000565, 3178 }, /* Armenian_yech */
{ 0x01000566, 3222 }, /* Armenian_za */
{ 0x01000567, 2276 }, /* Armenian_e */
{ 0x01000568, 2112 }, /* Armenian_at */
{ 0x01000569, 2976 }, /* Armenian_to */
{ 0x0100056a, 3247 }, /* Armenian_zhe */
{ 0x0100056b, 2477 }, /* Armenian_ini */
{ 0x0100056c, 2625 }, /* Armenian_lyun */
{ 0x0100056d, 2577 }, /* Armenian_khe */
{ 0x0100056e, 3001 }, /* Armenian_tsa */
{ 0x0100056f, 2551 }, /* Armenian_ken */
{ 0x01000570, 2436 }, /* Armenian_ho */
{ 0x01000571, 2252 }, /* Armenian_dza */
{ 0x01000572, 2360 }, /* Armenian_ghat */
{ 0x01000573, 2950 }, /* Armenian_tche */
{ 0x01000574, 2652 }, /* Armenian_men */
{ 0x01000575, 2412 }, /* Armenian_hi */
{ 0x01000576, 2677 }, /* Armenian_nu */
{ 0x01000577, 2907 }, /* Armenian_sha */
{ 0x01000578, 3124 }, /* Armenian_vo */
{ 0x01000579, 2202 }, /* Armenian_cha */
{ 0x0100057a, 2739 }, /* Armenian_pe */
{ 0x0100057b, 2502 }, /* Armenian_je */
{ 0x0100057c, 2809 }, /* Armenian_ra */
{ 0x0100057d, 2857 }, /* Armenian_se */
{ 0x0100057e, 3099 }, /* Armenian_vev */
{ 0x0100057f, 3054 }, /* Armenian_tyun */
{ 0x01000580, 2833 }, /* Armenian_re */
{ 0x01000581, 3027 }, /* Armenian_tso */
{ 0x01000582, 3150 }, /* Armenian_vyun */
{ 0x01000583, 2765 }, /* Armenian_pyur */
{ 0x01000584, 2526 }, /* Armenian_ke */
{ 0x01000585, 2700 }, /* Armenian_o */
{ 0x01000586, 2315 }, /* Armenian_fe */
{ 0x01000587, 2590 }, /* Armenian_ligature_ew */
{ 0x01000589, 2327 }, /* Armenian_full_stop */
{ 0x0100058a, 2448 }, /* Armenian_hyphen */
{ 0x01000653, 1580 }, /* Arabic_madda_above */
{ 0x01000654, 1316 }, /* Arabic_hamza_above */
{ 0x01000655, 1335 }, /* Arabic_hamza_below */
{ 0x01000660, 966 }, /* Arabic_0 */
{ 0x01000661, 975 }, /* Arabic_1 */
{ 0x01000662, 984 }, /* Arabic_2 */
{ 0x01000663, 993 }, /* Arabic_3 */
{ 0x01000664, 1002 }, /* Arabic_4 */
{ 0x01000665, 1011 }, /* Arabic_5 */
{ 0x01000666, 1020 }, /* Arabic_6 */
{ 0x01000667, 1029 }, /* Arabic_7 */
{ 0x01000668, 1038 }, /* Arabic_8 */
{ 0x01000669, 1047 }, /* Arabic_9 */
{ 0x0100066a, 1672 }, /* Arabic_percent */
{ 0x01000670, 1821 }, /* Arabic_superscript_alef */
{ 0x01000679, 1951 }, /* Arabic_tteh */
{ 0x0100067e, 1661 }, /* Arabic_peh */
{ 0x01000686, 1885 }, /* Arabic_tcheh */
{ 0x01000688, 1173 }, /* Arabic_ddal */
{ 0x01000691, 1729 }, /* Arabic_rreh */
{ 0x01000698, 1493 }, /* Arabic_jeh */
{ 0x010006a4, 1963 }, /* Arabic_veh */
{ 0x010006a9, 1544 }, /* Arabic_keheh */
{ 0x010006af, 1258 }, /* Arabic_gaf */
{ 0x010006ba, 1642 }, /* Arabic_noon_ghunna */
{ 0x010006be, 1442 }, /* Arabic_heh_doachashmee */
{ 0x010006c1, 1465 }, /* Arabic_heh_goal */
{ 0x010006cc, 12472 }, /* Farsi_yeh */
{ 0x010006d2, 1996 }, /* Arabic_yeh_baree */
{ 0x010006d4, 1242 }, /* Arabic_fullstop */
{ 0x010006f0, 12392 }, /* Farsi_0 */
{ 0x010006f1, 12400 }, /* Farsi_1 */
{ 0x010006f2, 12408 }, /* Farsi_2 */
{ 0x010006f3, 12416 }, /* Farsi_3 */
{ 0x010006f4, 12424 }, /* Farsi_4 */
{ 0x010006f5, 12432 }, /* Farsi_5 */
{ 0x010006f6, 12440 }, /* Farsi_6 */
{ 0x010006f7, 12448 }, /* Farsi_7 */
{ 0x010006f8, 12456 }, /* Farsi_8 */
{ 0x010006f9, 12464 }, /* Farsi_9 */
{ 0x01000d82, 23566 }, /* Sinh_ng */
{ 0x01000d83, 23360 }, /* Sinh_h2 */
{ 0x01000d85, 23129 }, /* Sinh_a */
{ 0x01000d86, 23136 }, /* Sinh_aa */
{ 0x01000d87, 23153 }, /* Sinh_ae */
{ 0x01000d88, 23170 }, /* Sinh_aee */
{ 0x01000d89, 23376 }, /* Sinh_i */
{ 0x01000d8a, 23391 }, /* Sinh_ii */
{ 0x01000d8b, 23777 }, /* Sinh_u */
{ 0x01000d8c, 23792 }, /* Sinh_uu */
{ 0x01000d8d, 23676 }, /* Sinh_ri */
{ 0x01000d8e, 23684 }, /* Sinh_rii */
{ 0x01000d8f, 23485 }, /* Sinh_lu */
{ 0x01000d90, 23502 }, /* Sinh_luu */
{ 0x01000d91, 23303 }, /* Sinh_e */
{ 0x01000d92, 23318 }, /* Sinh_ee */
{ 0x01000d93, 23189 }, /* Sinh_ai */
{ 0x01000d94, 23619 }, /* Sinh_o */
{ 0x01000d95, 23634 }, /* Sinh_oo */
{ 0x01000d96, 23214 }, /* Sinh_au */
{ 0x01000d9a, 23435 }, /* Sinh_ka */
{ 0x01000d9b, 23443 }, /* Sinh_kha */
{ 0x01000d9c, 23343 }, /* Sinh_ga */
{ 0x01000d9d, 23351 }, /* Sinh_gha */
{ 0x01000d9e, 23574 }, /* Sinh_ng2 */
{ 0x01000d9f, 23583 }, /* Sinh_nga */
{ 0x01000da0, 23248 }, /* Sinh_ca */
{ 0x01000da1, 23256 }, /* Sinh_cha */
{ 0x01000da2, 23408 }, /* Sinh_ja */
{ 0x01000da3, 23416 }, /* Sinh_jha */
{ 0x01000da4, 23610 }, /* Sinh_nya */
{ 0x01000da5, 23425 }, /* Sinh_jnya */
{ 0x01000da6, 23592 }, /* Sinh_nja */
{ 0x01000da7, 23758 }, /* Sinh_tta */
{ 0x01000da8, 23767 }, /* Sinh_ttha */
{ 0x01000da9, 23265 }, /* Sinh_dda */
{ 0x01000daa, 23274 }, /* Sinh_ddha */
{ 0x01000dab, 23601 }, /* Sinh_nna */
{ 0x01000dac, 23546 }, /* Sinh_ndda */
{ 0x01000dad, 23739 }, /* Sinh_tha */
{ 0x01000dae, 23748 }, /* Sinh_thha */
{ 0x01000daf, 23284 }, /* Sinh_dha */
{ 0x01000db0, 23293 }, /* Sinh_dhha */
{ 0x01000db1, 23538 }, /* Sinh_na */
{ 0x01000db3, 23556 }, /* Sinh_ndha */
{ 0x01000db4, 23651 }, /* Sinh_pa */
{ 0x01000db5, 23659 }, /* Sinh_pha */
{ 0x01000db6, 23231 }, /* Sinh_ba */
{ 0x01000db7, 23239 }, /* Sinh_bha */
{ 0x01000db8, 23521 }, /* Sinh_ma */
{ 0x01000db9, 23529 }, /* Sinh_mba */
{ 0x01000dba, 23817 }, /* Sinh_ya */
{ 0x01000dbb, 23668 }, /* Sinh_ra */
{ 0x01000dbd, 23468 }, /* Sinh_la */
{ 0x01000dc0, 23809 }, /* Sinh_va */
{ 0x01000dc1, 23720 }, /* Sinh_sha */
{ 0x01000dc2, 23729 }, /* Sinh_ssha */
{ 0x01000dc3, 23712 }, /* Sinh_sa */
{ 0x01000dc4, 23368 }, /* Sinh_ha */
{ 0x01000dc5, 23476 }, /* Sinh_lla */
{ 0x01000dc6, 23335 }, /* Sinh_fa */
{ 0x01000dca, 23206 }, /* Sinh_al */
{ 0x01000dcf, 23144 }, /* Sinh_aa2 */
{ 0x01000dd0, 23161 }, /* Sinh_ae2 */
{ 0x01000dd1, 23179 }, /* Sinh_aee2 */
{ 0x01000dd2, 23383 }, /* Sinh_i2 */
{ 0x01000dd3, 23399 }, /* Sinh_ii2 */
{ 0x01000dd4, 23784 }, /* Sinh_u2 */
{ 0x01000dd6, 23800 }, /* Sinh_uu2 */
{ 0x01000dd8, 23693 }, /* Sinh_ru2 */
{ 0x01000dd9, 23310 }, /* Sinh_e2 */
{ 0x01000dda, 23326 }, /* Sinh_ee2 */
{ 0x01000ddb, 23197 }, /* Sinh_ai2 */
{ 0x01000ddc, 23626 }, /* Sinh_o2 */
{ 0x01000ddd, 23642 }, /* Sinh_oo2 */
{ 0x01000dde, 23222 }, /* Sinh_au2 */
{ 0x01000ddf, 23493 }, /* Sinh_lu2 */
{ 0x01000df2, 23702 }, /* Sinh_ruu2 */
{ 0x01000df3, 23511 }, /* Sinh_luu2 */
{ 0x01000df4, 23452 }, /* Sinh_kunddaliya */
{ 0x010010d0, 12841 }, /* Georgian_an */
{ 0x010010d1, 12853 }, /* Georgian_ban */
{ 0x010010d2, 12957 }, /* Georgian_gan */
{ 0x010010d3, 12920 }, /* Georgian_don */
{ 0x010010d4, 12933 }, /* Georgian_en */
{ 0x010010d5, 13283 }, /* Georgian_vin */
{ 0x010010d6, 13321 }, /* Georgian_zen */
{ 0x010010d7, 13245 }, /* Georgian_tan */
{ 0x010010d8, 13048 }, /* Georgian_in */
{ 0x010010d9, 13087 }, /* Georgian_kan */
{ 0x010010da, 13114 }, /* Georgian_las */
{ 0x010010db, 13127 }, /* Georgian_man */
{ 0x010010dc, 13140 }, /* Georgian_nar */
{ 0x010010dd, 13153 }, /* Georgian_on */
{ 0x010010de, 13165 }, /* Georgian_par */
{ 0x010010df, 13334 }, /* Georgian_zhar */
{ 0x010010e0, 13205 }, /* Georgian_rae */
{ 0x010010e1, 13218 }, /* Georgian_san */
{ 0x010010e2, 13258 }, /* Georgian_tar */
{ 0x010010e3, 13271 }, /* Georgian_un */
{ 0x010010e4, 13178 }, /* Georgian_phar */
{ 0x010010e5, 13100 }, /* Georgian_khar */
{ 0x010010e6, 12970 }, /* Georgian_ghan */
{ 0x010010e7, 13192 }, /* Georgian_qar */
{ 0x010010e8, 13231 }, /* Georgian_shin */
{ 0x010010e9, 12893 }, /* Georgian_chin */
{ 0x010010ea, 12866 }, /* Georgian_can */
{ 0x010010eb, 13074 }, /* Georgian_jil */
{ 0x010010ec, 12907 }, /* Georgian_cil */
{ 0x010010ed, 12879 }, /* Georgian_char */
{ 0x010010ee, 13308 }, /* Georgian_xan */
{ 0x010010ef, 13060 }, /* Georgian_jhan */
{ 0x010010f0, 12984 }, /* Georgian_hae */
{ 0x010010f1, 13010 }, /* Georgian_he */
{ 0x010010f2, 13022 }, /* Georgian_hie */
{ 0x010010f3, 13296 }, /* Georgian_we */
{ 0x010010f4, 12997 }, /* Georgian_har */
{ 0x010010f5, 13035 }, /* Georgian_hoe */
{ 0x010010f6, 12945 }, /* Georgian_fi */
{ 0x01001e02, 3332 }, /* Babovedot */
{ 0x01001e03, 3342 }, /* babovedot */
{ 0x01001e0a, 10406 }, /* Dabovedot */
{ 0x01001e0b, 10416 }, /* dabovedot */
{ 0x01001e1e, 12372 }, /* Fabovedot */
{ 0x01001e1f, 12382 }, /* fabovedot */
{ 0x01001e36, 19274 }, /* Lbelowdot */
{ 0x01001e37, 19284 }, /* lbelowdot */
{ 0x01001e40, 19619 }, /* Mabovedot */
{ 0x01001e41, 19629 }, /* mabovedot */
{ 0x01001e56, 21459 }, /* Pabovedot */
{ 0x01001e57, 21469 }, /* pabovedot */
{ 0x01001e60, 22665 }, /* Sabovedot */
{ 0x01001e61, 22675 }, /* sabovedot */
{ 0x01001e6a, 24384 }, /* Tabovedot */
{ 0x01001e6b, 24394 }, /* tabovedot */
{ 0x01001e80, 26691 }, /* Wgrave */
{ 0x01001e81, 26698 }, /* wgrave */
{ 0x01001e82, 26631 }, /* Wacute */
{ 0x01001e83, 26638 }, /* wacute */
{ 0x01001e84, 26669 }, /* Wdiaeresis */
{ 0x01001e85, 26680 }, /* wdiaeresis */
{ 0x01001e8a, 26717 }, /* Xabovedot */
{ 0x01001e8b, 26727 }, /* xabovedot */
{ 0x01001ea0, 416 }, /* Abelowdot */
{ 0x01001ea1, 426 }, /* abelowdot */
{ 0x01001ea2, 868 }, /* Ahook */
{ 0x01001ea3, 874 }, /* ahook */
{ 0x01001ea4, 646 }, /* Acircumflexacute */
{ 0x01001ea5, 663 }, /* acircumflexacute */
{ 0x01001ea6, 720 }, /* Acircumflexgrave */
{ 0x01001ea7, 737 }, /* acircumflexgrave */
{ 0x01001ea8, 754 }, /* Acircumflexhook */
{ 0x01001ea9, 770 }, /* acircumflexhook */
{ 0x01001eaa, 786 }, /* Acircumflextilde */
{ 0x01001eab, 803 }, /* acircumflextilde */
{ 0x01001eac, 680 }, /* Acircumflexbelowdot */
{ 0x01001ead, 700 }, /* acircumflexbelowdot */
{ 0x01001eae, 459 }, /* Abreveacute */
{ 0x01001eaf, 471 }, /* abreveacute */
{ 0x01001eb0, 513 }, /* Abrevegrave */
{ 0x01001eb1, 525 }, /* abrevegrave */
{ 0x01001eb2, 537 }, /* Abrevehook */
{ 0x01001eb3, 548 }, /* abrevehook */
{ 0x01001eb4, 559 }, /* Abrevetilde */
{ 0x01001eb5, 571 }, /* abrevetilde */
{ 0x01001eb6, 483 }, /* Abrevebelowdot */
{ 0x01001eb7, 498 }, /* abrevebelowdot */
{ 0x01001eb8, 11544 }, /* Ebelowdot */
{ 0x01001eb9, 11554 }, /* ebelowdot */
{ 0x01001eba, 11820 }, /* Ehook */
{ 0x01001ebb, 11826 }, /* ehook */
{ 0x01001ebc, 12158 }, /* Etilde */
{ 0x01001ebd, 12165 }, /* etilde */
{ 0x01001ebe, 11602 }, /* Ecircumflexacute */
{ 0x01001ebf, 11619 }, /* ecircumflexacute */
{ 0x01001ec0, 11676 }, /* Ecircumflexgrave */
{ 0x01001ec1, 11693 }, /* ecircumflexgrave */
{ 0x01001ec2, 11710 }, /* Ecircumflexhook */
{ 0x01001ec3, 11726 }, /* ecircumflexhook */
{ 0x01001ec4, 11742 }, /* Ecircumflextilde */
{ 0x01001ec5, 11759 }, /* ecircumflextilde */
{ 0x01001ec6, 11636 }, /* Ecircumflexbelowdot */
{ 0x01001ec7, 11656 }, /* ecircumflexbelowdot */
{ 0x01001ec8, 17301 }, /* Ihook */
{ 0x01001ec9, 17307 }, /* ihook */
{ 0x01001eca, 17179 }, /* Ibelowdot */
{ 0x01001ecb, 17189 }, /* ibelowdot */
{ 0x01001ecc, 20316 }, /* Obelowdot */
{ 0x01001ecd, 20326 }, /* obelowdot */
{ 0x01001ece, 20623 }, /* Ohook */
{ 0x01001ecf, 20629 }, /* ohook */
{ 0x01001ed0, 20374 }, /* Ocircumflexacute */
{ 0x01001ed1, 20391 }, /* ocircumflexacute */
{ 0x01001ed2, 20448 }, /* Ocircumflexgrave */
{ 0x01001ed3, 20465 }, /* ocircumflexgrave */
{ 0x01001ed4, 20482 }, /* Ocircumflexhook */
{ 0x01001ed5, 20498 }, /* ocircumflexhook */
{ 0x01001ed6, 20514 }, /* Ocircumflextilde */
{ 0x01001ed7, 20531 }, /* ocircumflextilde */
{ 0x01001ed8, 20408 }, /* Ocircumflexbelowdot */
{ 0x01001ed9, 20428 }, /* ocircumflexbelowdot */
{ 0x01001eda, 20647 }, /* Ohornacute */
{ 0x01001edb, 20658 }, /* ohornacute */
{ 0x01001edc, 20697 }, /* Ohorngrave */
{ 0x01001edd, 20708 }, /* ohorngrave */
{ 0x01001ede, 20719 }, /* Ohornhook */
{ 0x01001edf, 20729 }, /* ohornhook */
{ 0x01001ee0, 20739 }, /* Ohorntilde */
{ 0x01001ee1, 20750 }, /* ohorntilde */
{ 0x01001ee2, 20669 }, /* Ohornbelowdot */
{ 0x01001ee3, 20683 }, /* ohornbelowdot */
{ 0x01001ee4, 25947 }, /* Ubelowdot */
{ 0x01001ee5, 25957 }, /* ubelowdot */
{ 0x01001ee6, 26067 }, /* Uhook */
{ 0x01001ee7, 26073 }, /* uhook */
{ 0x01001ee8, 26091 }, /* Uhornacute */
{ 0x01001ee9, 26102 }, /* uhornacute */
{ 0x01001eea, 26141 }, /* Uhorngrave */
{ 0x01001eeb, 26152 }, /* uhorngrave */
{ 0x01001eec, 26163 }, /* Uhornhook */
{ 0x01001eed, 26173 }, /* uhornhook */
{ 0x01001eee, 26183 }, /* Uhorntilde */
{ 0x01001eef, 26194 }, /* uhorntilde */
{ 0x01001ef0, 26113 }, /* Uhornbelowdot */
{ 0x01001ef1, 26127 }, /* uhornbelowdot */
{ 0x01001ef2, 31306 }, /* Ygrave */
{ 0x01001ef3, 31313 }, /* ygrave */
{ 0x01001ef4, 31236 }, /* Ybelowdot */
{ 0x01001ef5, 31246 }, /* ybelowdot */
{ 0x01001ef6, 31320 }, /* Yhook */
{ 0x01001ef7, 31326 }, /* yhook */
{ 0x01001ef8, 31332 }, /* Ytilde */
{ 0x01001ef9, 31339 }, /* ytilde */
{ 0x01002070, 31445 }, /* zerosuperior */
{ 0x01002074, 12714 }, /* foursuperior */
{ 0x01002075, 12676 }, /* fivesuperior */
{ 0x01002076, 23838 }, /* sixsuperior */
{ 0x01002077, 23014 }, /* sevensuperior */
{ 0x01002078, 11847 }, /* eightsuperior */
{ 0x01002079, 20144 }, /* ninesuperior */
{ 0x01002080, 31431 }, /* zerosubscript */
{ 0x01002081, 20824 }, /* onesubscript */
{ 0x01002082, 25894 }, /* twosubscript */
{ 0x01002083, 25638 }, /* threesubscript */
{ 0x01002084, 12700 }, /* foursubscript */
{ 0x01002085, 12662 }, /* fivesubscript */
{ 0x01002086, 23825 }, /* sixsubscript */
{ 0x01002087, 22999 }, /* sevensubscript */
{ 0x01002088, 11832 }, /* eightsubscript */
{ 0x01002089, 20130 }, /* ninesubscript */
{ 0x010020a0, 11776 }, /* EcuSign */
{ 0x010020a1, 8670 }, /* ColonSign */
{ 0x010020a2, 8826 }, /* CruzeiroSign */
{ 0x010020a3, 12498 }, /* FFrancSign */
{ 0x010020a4, 19530 }, /* LiraSign */
{ 0x010020a5, 19806 }, /* MillSign */
{ 0x010020a6, 20049 }, /* NairaSign */
{ 0x010020a7, 21608 }, /* PesetaSign */
{ 0x010020a8, 22651 }, /* RupeeSign */
{ 0x010020a9, 26705 }, /* WonSign */
{ 0x010020aa, 20091 }, /* NewSheqelSign */
{ 0x010020ab, 11340 }, /* DongSign */
{ 0x01002202, 21528 }, /* partdifferential */
{ 0x01002205, 12001 }, /* emptyset */
{ 0x01002208, 11884 }, /* elementof */
{ 0x01002209, 20194 }, /* notelementof */
{ 0x0100220b, 8768 }, /* containsas */
{ 0x0100221a, 23891 }, /* squareroot */
{ 0x0100221b, 8839 }, /* cuberoot */
{ 0x0100221c, 12727 }, /* fourthroot */
{ 0x0100222c, 11314 }, /* dintegral */
{ 0x0100222d, 25667 }, /* tintegral */
{ 0x01002235, 3396 }, /* because */
{ 0x01002247, 20182 }, /* notapproxeq */
{ 0x01002248, 945 }, /* approxeq */
{ 0x01002262, 20216 }, /* notidentical */
{ 0x01002263, 23936 }, /* stricteq */
{ 0x01002800, 3628 }, /* braille_blank */
{ 0x01002801, 3783 }, /* braille_dots_1 */
{ 0x01002802, 6151 }, /* braille_dots_2 */
{ 0x01002803, 3798 }, /* braille_dots_12 */
{ 0x01002804, 7303 }, /* braille_dots_3 */
{ 0x01002805, 5014 }, /* braille_dots_13 */
{ 0x01002806, 6166 }, /* braille_dots_23 */
{ 0x01002807, 3814 }, /* braille_dots_123 */
{ 0x01002808, 7863 }, /* braille_dots_4 */
{ 0x01002809, 5606 }, /* braille_dots_14 */
{ 0x0100280a, 6758 }, /* braille_dots_24 */
{ 0x0100280b, 4438 }, /* braille_dots_124 */
{ 0x0100280c, 7318 }, /* braille_dots_34 */
{ 0x0100280d, 5030 }, /* braille_dots_134 */
{ 0x0100280e, 6182 }, /* braille_dots_234 */
{ 0x0100280f, 3831 }, /* braille_dots_1234 */
{ 0x01002810, 8135 }, /* braille_dots_5 */
{ 0x01002811, 5894 }, /* braille_dots_15 */
{ 0x01002812, 7046 }, /* braille_dots_25 */
{ 0x01002813, 4742 }, /* braille_dots_125 */
{ 0x01002814, 7606 }, /* braille_dots_35 */
{ 0x01002815, 5334 }, /* braille_dots_135 */
{ 0x01002816, 6486 }, /* braille_dots_235 */
{ 0x01002817, 4151 }, /* braille_dots_1235 */
{ 0x01002818, 7878 }, /* braille_dots_45 */
{ 0x01002819, 5622 }, /* braille_dots_145 */
{ 0x0100281a, 6774 }, /* braille_dots_245 */
{ 0x0100281b, 4455 }, /* braille_dots_1245 */
{ 0x0100281c, 7334 }, /* braille_dots_345 */
{ 0x0100281d, 5047 }, /* braille_dots_1345 */
{ 0x0100281e, 6199 }, /* braille_dots_2345 */
{ 0x0100281f, 3849 }, /* braille_dots_12345 */
{ 0x01002820, 8267 }, /* braille_dots_6 */
{ 0x01002821, 6034 }, /* braille_dots_16 */
{ 0x01002822, 7186 }, /* braille_dots_26 */
{ 0x01002823, 4890 }, /* braille_dots_126 */
{ 0x01002824, 7746 }, /* braille_dots_36 */
{ 0x01002825, 5482 }, /* braille_dots_136 */
{ 0x01002826, 6634 }, /* braille_dots_236 */
{ 0x01002827, 4307 }, /* braille_dots_1236 */
{ 0x01002828, 8018 }, /* braille_dots_46 */
{ 0x01002829, 5770 }, /* braille_dots_146 */
{ 0x0100282a, 6922 }, /* braille_dots_246 */
{ 0x0100282b, 4611 }, /* braille_dots_1246 */
{ 0x0100282c, 7482 }, /* braille_dots_346 */
{ 0x0100282d, 5203 }, /* braille_dots_1346 */
{ 0x0100282e, 6355 }, /* braille_dots_2346 */
{ 0x0100282f, 4013 }, /* braille_dots_12346 */
{ 0x01002830, 8150 }, /* braille_dots_56 */
{ 0x01002831, 5910 }, /* braille_dots_156 */
{ 0x01002832, 7062 }, /* braille_dots_256 */
{ 0x01002833, 4759 }, /* braille_dots_1256 */
{ 0x01002834, 7622 }, /* braille_dots_356 */
{ 0x01002835, 5351 }, /* braille_dots_1356 */
{ 0x01002836, 6503 }, /* braille_dots_2356 */
{ 0x01002837, 4169 }, /* braille_dots_12356 */
{ 0x01002838, 7894 }, /* braille_dots_456 */
{ 0x01002839, 5639 }, /* braille_dots_1456 */
{ 0x0100283a, 6791 }, /* braille_dots_2456 */
{ 0x0100283b, 4473 }, /* braille_dots_12456 */
{ 0x0100283c, 7351 }, /* braille_dots_3456 */
{ 0x0100283d, 5065 }, /* braille_dots_13456 */
{ 0x0100283e, 6217 }, /* braille_dots_23456 */
{ 0x0100283f, 3868 }, /* braille_dots_123456 */
{ 0x01002840, 8331 }, /* braille_dots_7 */
{ 0x01002841, 6102 }, /* braille_dots_17 */
{ 0x01002842, 7254 }, /* braille_dots_27 */
{ 0x01002843, 4962 }, /* braille_dots_127 */
{ 0x01002844, 7814 }, /* braille_dots_37 */
{ 0x01002845, 5554 }, /* braille_dots_137 */
{ 0x01002846, 6706 }, /* braille_dots_237 */
{ 0x01002847, 4383 }, /* braille_dots_1237 */
{ 0x01002848, 8086 }, /* braille_dots_47 */
{ 0x01002849, 5842 }, /* braille_dots_147 */
{ 0x0100284a, 6994 }, /* braille_dots_247 */
{ 0x0100284b, 4687 }, /* braille_dots_1247 */
{ 0x0100284c, 7554 }, /* braille_dots_347 */
{ 0x0100284d, 5279 }, /* braille_dots_1347 */
{ 0x0100284e, 6431 }, /* braille_dots_2347 */
{ 0x0100284f, 4093 }, /* braille_dots_12347 */
{ 0x01002850, 8218 }, /* braille_dots_57 */
{ 0x01002851, 5982 }, /* braille_dots_157 */
{ 0x01002852, 7134 }, /* braille_dots_257 */
{ 0x01002853, 4835 }, /* braille_dots_1257 */
{ 0x01002854, 7694 }, /* braille_dots_357 */
{ 0x01002855, 5427 }, /* braille_dots_1357 */
{ 0x01002856, 6579 }, /* braille_dots_2357 */
{ 0x01002857, 4249 }, /* braille_dots_12357 */
{ 0x01002858, 7966 }, /* braille_dots_457 */
{ 0x01002859, 5715 }, /* braille_dots_1457 */
{ 0x0100285a, 6867 }, /* braille_dots_2457 */
{ 0x0100285b, 4553 }, /* braille_dots_12457 */
{ 0x0100285c, 7427 }, /* braille_dots_3457 */
{ 0x0100285d, 5145 }, /* braille_dots_13457 */
{ 0x0100285e, 6297 }, /* braille_dots_23457 */
{ 0x0100285f, 3952 }, /* braille_dots_123457 */
{ 0x01002860, 8282 }, /* braille_dots_67 */
{ 0x01002861, 6050 }, /* braille_dots_167 */
{ 0x01002862, 7202 }, /* braille_dots_267 */
{ 0x01002863, 4907 }, /* braille_dots_1267 */
{ 0x01002864, 7762 }, /* braille_dots_367 */
{ 0x01002865, 5499 }, /* braille_dots_1367 */
{ 0x01002866, 6651 }, /* braille_dots_2367 */
{ 0x01002867, 4325 }, /* braille_dots_12367 */
{ 0x01002868, 8034 }, /* braille_dots_467 */
{ 0x01002869, 5787 }, /* braille_dots_1467 */
{ 0x0100286a, 6939 }, /* braille_dots_2467 */
{ 0x0100286b, 4629 }, /* braille_dots_12467 */
{ 0x0100286c, 7499 }, /* braille_dots_3467 */
{ 0x0100286d, 5221 }, /* braille_dots_13467 */
{ 0x0100286e, 6373 }, /* braille_dots_23467 */
{ 0x0100286f, 4032 }, /* braille_dots_123467 */
{ 0x01002870, 8166 }, /* braille_dots_567 */
{ 0x01002871, 5927 }, /* braille_dots_1567 */
{ 0x01002872, 7079 }, /* braille_dots_2567 */
{ 0x01002873, 4777 }, /* braille_dots_12567 */
{ 0x01002874, 7639 }, /* braille_dots_3567 */
{ 0x01002875, 5369 }, /* braille_dots_13567 */
{ 0x01002876, 6521 }, /* braille_dots_23567 */
{ 0x01002877, 4188 }, /* braille_dots_123567 */
{ 0x01002878, 7911 }, /* braille_dots_4567 */
{ 0x01002879, 5657 }, /* braille_dots_14567 */
{ 0x0100287a, 6809 }, /* braille_dots_24567 */
{ 0x0100287b, 4492 }, /* braille_dots_124567 */
{ 0x0100287c, 7369 }, /* braille_dots_34567 */
{ 0x0100287d, 5084 }, /* braille_dots_134567 */
{ 0x0100287e, 6236 }, /* braille_dots_234567 */
{ 0x0100287f, 3888 }, /* braille_dots_1234567 */
{ 0x01002880, 8362 }, /* braille_dots_8 */
{ 0x01002881, 6135 }, /* braille_dots_18 */
{ 0x01002882, 7287 }, /* braille_dots_28 */
{ 0x01002883, 4997 }, /* braille_dots_128 */
{ 0x01002884, 7847 }, /* braille_dots_38 */
{ 0x01002885, 5589 }, /* braille_dots_138 */
{ 0x01002886, 6741 }, /* braille_dots_238 */
{ 0x01002887, 4420 }, /* braille_dots_1238 */
{ 0x01002888, 8119 }, /* braille_dots_48 */
{ 0x01002889, 5877 }, /* braille_dots_148 */
{ 0x0100288a, 7029 }, /* braille_dots_248 */
{ 0x0100288b, 4724 }, /* braille_dots_1248 */
{ 0x0100288c, 7589 }, /* braille_dots_348 */
{ 0x0100288d, 5316 }, /* braille_dots_1348 */
{ 0x0100288e, 6468 }, /* braille_dots_2348 */
{ 0x0100288f, 4132 }, /* braille_dots_12348 */
{ 0x01002890, 8251 }, /* braille_dots_58 */
{ 0x01002891, 6017 }, /* braille_dots_158 */
{ 0x01002892, 7169 }, /* braille_dots_258 */
{ 0x01002893, 4872 }, /* braille_dots_1258 */
{ 0x01002894, 7729 }, /* braille_dots_358 */
{ 0x01002895, 5464 }, /* braille_dots_1358 */
{ 0x01002896, 6616 }, /* braille_dots_2358 */
{ 0x01002897, 4288 }, /* braille_dots_12358 */
{ 0x01002898, 8001 }, /* braille_dots_458 */
{ 0x01002899, 5752 }, /* braille_dots_1458 */
{ 0x0100289a, 6904 }, /* braille_dots_2458 */
{ 0x0100289b, 4592 }, /* braille_dots_12458 */
{ 0x0100289c, 7464 }, /* braille_dots_3458 */
{ 0x0100289d, 5184 }, /* braille_dots_13458 */
{ 0x0100289e, 6336 }, /* braille_dots_23458 */
{ 0x0100289f, 3993 }, /* braille_dots_123458 */
{ 0x010028a0, 8315 }, /* braille_dots_68 */
{ 0x010028a1, 6085 }, /* braille_dots_168 */
{ 0x010028a2, 7237 }, /* braille_dots_268 */
{ 0x010028a3, 4944 }, /* braille_dots_1268 */
{ 0x010028a4, 7797 }, /* braille_dots_368 */
{ 0x010028a5, 5536 }, /* braille_dots_1368 */
{ 0x010028a6, 6688 }, /* braille_dots_2368 */
{ 0x010028a7, 4364 }, /* braille_dots_12368 */
{ 0x010028a8, 8069 }, /* braille_dots_468 */
{ 0x010028a9, 5824 }, /* braille_dots_1468 */
{ 0x010028aa, 6976 }, /* braille_dots_2468 */
{ 0x010028ab, 4668 }, /* braille_dots_12468 */
{ 0x010028ac, 7536 }, /* braille_dots_3468 */
{ 0x010028ad, 5260 }, /* braille_dots_13468 */
{ 0x010028ae, 6412 }, /* braille_dots_23468 */
{ 0x010028af, 4073 }, /* braille_dots_123468 */
{ 0x010028b0, 8201 }, /* braille_dots_568 */
{ 0x010028b1, 5964 }, /* braille_dots_1568 */
{ 0x010028b2, 7116 }, /* braille_dots_2568 */
{ 0x010028b3, 4816 }, /* braille_dots_12568 */
{ 0x010028b4, 7676 }, /* braille_dots_3568 */
{ 0x010028b5, 5408 }, /* braille_dots_13568 */
{ 0x010028b6, 6560 }, /* braille_dots_23568 */
{ 0x010028b7, 4229 }, /* braille_dots_123568 */
{ 0x010028b8, 7948 }, /* braille_dots_4568 */
{ 0x010028b9, 5696 }, /* braille_dots_14568 */
{ 0x010028ba, 6848 }, /* braille_dots_24568 */
{ 0x010028bb, 4533 }, /* braille_dots_124568 */
{ 0x010028bc, 7408 }, /* braille_dots_34568 */
{ 0x010028bd, 5125 }, /* braille_dots_134568 */
{ 0x010028be, 6277 }, /* braille_dots_234568 */
{ 0x010028bf, 3931 }, /* braille_dots_1234568 */
{ 0x010028c0, 8346 }, /* braille_dots_78 */
{ 0x010028c1, 6118 }, /* braille_dots_178 */
{ 0x010028c2, 7270 }, /* braille_dots_278 */
{ 0x010028c3, 4979 }, /* braille_dots_1278 */
{ 0x010028c4, 7830 }, /* braille_dots_378 */
{ 0x010028c5, 5571 }, /* braille_dots_1378 */
{ 0x010028c6, 6723 }, /* braille_dots_2378 */
{ 0x010028c7, 4401 }, /* braille_dots_12378 */
{ 0x010028c8, 8102 }, /* braille_dots_478 */
{ 0x010028c9, 5859 }, /* braille_dots_1478 */
{ 0x010028ca, 7011 }, /* braille_dots_2478 */
{ 0x010028cb, 4705 }, /* braille_dots_12478 */
{ 0x010028cc, 7571 }, /* braille_dots_3478 */
{ 0x010028cd, 5297 }, /* braille_dots_13478 */
{ 0x010028ce, 6449 }, /* braille_dots_23478 */
{ 0x010028cf, 4112 }, /* braille_dots_123478 */
{ 0x010028d0, 8234 }, /* braille_dots_578 */
{ 0x010028d1, 5999 }, /* braille_dots_1578 */
{ 0x010028d2, 7151 }, /* braille_dots_2578 */
{ 0x010028d3, 4853 }, /* braille_dots_12578 */
{ 0x010028d4, 7711 }, /* braille_dots_3578 */
{ 0x010028d5, 5445 }, /* braille_dots_13578 */
{ 0x010028d6, 6597 }, /* braille_dots_23578 */
{ 0x010028d7, 4268 }, /* braille_dots_123578 */
{ 0x010028d8, 7983 }, /* braille_dots_4578 */
{ 0x010028d9, 5733 }, /* braille_dots_14578 */
{ 0x010028da, 6885 }, /* braille_dots_24578 */
{ 0x010028db, 4572 }, /* braille_dots_124578 */
{ 0x010028dc, 7445 }, /* braille_dots_34578 */
{ 0x010028dd, 5164 }, /* braille_dots_134578 */
{ 0x010028de, 6316 }, /* braille_dots_234578 */
{ 0x010028df, 3972 }, /* braille_dots_1234578 */
{ 0x010028e0, 8298 }, /* braille_dots_678 */
{ 0x010028e1, 6067 }, /* braille_dots_1678 */
{ 0x010028e2, 7219 }, /* braille_dots_2678 */
{ 0x010028e3, 4925 }, /* braille_dots_12678 */
{ 0x010028e4, 7779 }, /* braille_dots_3678 */
{ 0x010028e5, 5517 }, /* braille_dots_13678 */
{ 0x010028e6, 6669 }, /* braille_dots_23678 */
{ 0x010028e7, 4344 }, /* braille_dots_123678 */
{ 0x010028e8, 8051 }, /* braille_dots_4678 */
{ 0x010028e9, 5805 }, /* braille_dots_14678 */
{ 0x010028ea, 6957 }, /* braille_dots_24678 */
{ 0x010028eb, 4648 }, /* braille_dots_124678 */
{ 0x010028ec, 7517 }, /* braille_dots_34678 */
{ 0x010028ed, 5240 }, /* braille_dots_134678 */
{ 0x010028ee, 6392 }, /* braille_dots_234678 */
{ 0x010028ef, 4052 }, /* braille_dots_1234678 */
{ 0x010028f0, 8183 }, /* braille_dots_5678 */
{ 0x010028f1, 5945 }, /* braille_dots_15678 */
{ 0x010028f2, 7097 }, /* braille_dots_25678 */
{ 0x010028f3, 4796 }, /* braille_dots_125678 */
{ 0x010028f4, 7657 }, /* braille_dots_35678 */
{ 0x010028f5, 5388 }, /* braille_dots_135678 */
{ 0x010028f6, 6540 }, /* braille_dots_235678 */
{ 0x010028f7, 4208 }, /* braille_dots_1235678 */
{ 0x010028f8, 7929 }, /* braille_dots_45678 */
{ 0x010028f9, 5676 }, /* braille_dots_145678 */
{ 0x010028fa, 6828 }, /* braille_dots_245678 */
{ 0x010028fb, 4512 }, /* braille_dots_1245678 */
{ 0x010028fc, 7388 }, /* braille_dots_345678 */
{ 0x010028fd, 5104 }, /* braille_dots_1345678 */
{ 0x010028fe, 6256 }, /* braille_dots_2345678 */
{ 0x010028ff, 3909 }, /* braille_dots_12345678 */
{ 0x100000a8, 16992 }, /* hpmute_acute */
{ 0x100000a9, 17059 }, /* hpmute_grave */
{ 0x100000aa, 17005 }, /* hpmute_asciicircum */
{ 0x100000ab, 17042 }, /* hpmute_diaeresis */
{ 0x100000ac, 17024 }, /* hpmute_asciitilde */
{ 0x100000af, 16949 }, /* hplira */
{ 0x100000be, 16895 }, /* hpguilder */
{ 0x100000ee, 17096 }, /* hpYdiaeresis */
{ 0x100000f6, 16956 }, /* hplongminus */
{ 0x100000fc, 16849 }, /* hpblock */
{ 0x1000fe22, 10496 }, /* Ddiaeresis */
{ 0x1000fe27, 10426 }, /* Dacute_accent */
{ 0x1000fe2c, 10461 }, /* Dcedilla_accent */
{ 0x1000fe5e, 10477 }, /* Dcircumflex_accent */
{ 0x1000fe60, 11271 }, /* Dgrave_accent */
{ 0x1000fe7e, 11499 }, /* Dtilde */
{ 0x1000feb0, 11470 }, /* Dring_accent */
{ 0x1000ff00, 11462 }, /* DRemove */
{ 0x1000ff48, 16968 }, /* hpModelock1 */
{ 0x1000ff49, 16980 }, /* hpModelock2 */
{ 0x1000ff6c, 17072 }, /* hpReset */
{ 0x1000ff6d, 17080 }, /* hpSystem */
{ 0x1000ff6e, 17089 }, /* hpUser */
{ 0x1000ff6f, 16857 }, /* hpClearLine */
{ 0x1000ff70, 16918 }, /* hpInsertLine */
{ 0x1000ff71, 16882 }, /* hpDeleteLine */
{ 0x1000ff72, 16905 }, /* hpInsertChar */
{ 0x1000ff73, 16869 }, /* hpDeleteChar */
{ 0x1000ff74, 16839 }, /* hpBackTab */
{ 0x1000ff75, 16936 }, /* hpKP_BackTab */
{ 0x1000ff76, 12207 }, /* Ext16bit_L */
{ 0x1000ff77, 12218 }, /* Ext16bit_R */
{ 0x1004ff02, 21038 }, /* osfCopy */
{ 0x1004ff03, 21046 }, /* osfCut */
{ 0x1004ff04, 21245 }, /* osfPaste */
{ 0x1004ff07, 20982 }, /* osfBackTab */
{ 0x1004ff08, 20969 }, /* osfBackSpace */
{ 0x1004ff0b, 21029 }, /* osfClear */
{ 0x1004ff1b, 21108 }, /* osfEscape */
{ 0x1004ff31, 20958 }, /* osfAddMode */
{ 0x1004ff32, 21279 }, /* osfPrimaryPaste */
{ 0x1004ff33, 21295 }, /* osfQuickPaste */
{ 0x1004ff40, 21210 }, /* osfPageLeft */
{ 0x1004ff41, 21235 }, /* osfPageUp */
{ 0x1004ff42, 21198 }, /* osfPageDown */
{ 0x1004ff43, 21222 }, /* osfPageRight */
{ 0x1004ff44, 20946 }, /* osfActivate */
{ 0x1004ff45, 21162 }, /* osfMenuBar */
{ 0x1004ff51, 21146 }, /* osfLeft */
{ 0x1004ff52, 21372 }, /* osfUp */
{ 0x1004ff53, 21332 }, /* osfRight */
{ 0x1004ff54, 21078 }, /* osfDown */
{ 0x1004ff57, 21097 }, /* osfEndLine */
{ 0x1004ff58, 21006 }, /* osfBeginLine */
{ 0x1004ff59, 21086 }, /* osfEndData */
{ 0x1004ff5a, 20993 }, /* osfBeginData */
{ 0x1004ff5b, 21267 }, /* osfPrevMenu */
{ 0x1004ff5c, 21186 }, /* osfNextMenu */
{ 0x1004ff5d, 21254 }, /* osfPrevField */
{ 0x1004ff5e, 21173 }, /* osfNextField */
{ 0x1004ff60, 21341 }, /* osfSelect */
{ 0x1004ff63, 21136 }, /* osfInsert */
{ 0x1004ff65, 21364 }, /* osfUndo */
{ 0x1004ff67, 21154 }, /* osfMenu */
{ 0x1004ff69, 21019 }, /* osfCancel */
{ 0x1004ff6a, 21128 }, /* osfHelp */
{ 0x1004ff71, 21351 }, /* osfSelectAll */
{ 0x1004ff72, 21063 }, /* osfDeselectAll */
{ 0x1004ff73, 21309 }, /* osfReselect */
{ 0x1004ff74, 21118 }, /* osfExtend */
{ 0x1004ff78, 21321 }, /* osfRestore */
{ 0x1004ffff, 21053 }, /* osfDelete */
{ 0x1005ff00, 24114 }, /* SunFA_Grave */
{ 0x1005ff01, 24085 }, /* SunFA_Circum */
{ 0x1005ff02, 24126 }, /* SunFA_Tilde */
{ 0x1005ff03, 24059 }, /* SunFA_Acute */
{ 0x1005ff04, 24098 }, /* SunFA_Diaeresis */
{ 0x1005ff05, 24071 }, /* SunFA_Cedilla */
{ 0x1005ff10, 24045 }, /* SunF36 */
{ 0x1005ff11, 24052 }, /* SunF37 */
{ 0x1005ff60, 24262 }, /* SunSys_Req */
{ 0x1005ff70, 24245 }, /* SunProps */
{ 0x1005ff71, 24146 }, /* SunFront */
{ 0x1005ff72, 24030 }, /* SunCopy */
{ 0x1005ff73, 24155 }, /* SunOpen */
{ 0x1005ff74, 24185 }, /* SunPaste */
{ 0x1005ff75, 24038 }, /* SunCut */
{ 0x1005ff76, 24194 }, /* SunPowerSwitch */
{ 0x1005ff77, 23966 }, /* SunAudioLowerVolume */
{ 0x1005ff78, 23986 }, /* SunAudioMute */
{ 0x1005ff79, 23999 }, /* SunAudioRaiseVolume */
{ 0x1005ff7a, 24281 }, /* SunVideoDegauss */
{ 0x1005ff7b, 24297 }, /* SunVideoLowerBrightness */
{ 0x1005ff7c, 24321 }, /* SunVideoRaiseBrightness */
{ 0x1005ff7d, 24209 }, /* SunPowerSwitchShift */
{ 0x100810f4, 27381 }, /* XF86BrightnessAuto */
{ 0x100810f5, 27821 }, /* XF86DisplayOff */
{ 0x10081166, 28203 }, /* XF86Info */
{ 0x10081177, 26885 }, /* XF86AspectRatio */
{ 0x10081185, 27876 }, /* XF86DVD */
{ 0x10081188, 26968 }, /* XF86Audio */
{ 0x10081192, 27629 }, /* XF86ChannelUp */
{ 0x10081193, 27613 }, /* XF86ChannelDown */
{ 0x1008119b, 27350 }, /* XF86Break */
{ 0x100811a0, 31011 }, /* XF86VideoPhone */
{ 0x100811a4, 31204 }, /* XF86ZoomReset */
{ 0x100811a6, 27884 }, /* XF86Editor */
{ 0x100811a8, 28095 }, /* XF86GraphicsEditor */
{ 0x100811a9, 30012 }, /* XF86Presentation */
{ 0x100811aa, 27784 }, /* XF86Database */
{ 0x100811ac, 31060 }, /* XF86Voicemail */
{ 0x100811ad, 26800 }, /* XF86Addressbook */
{ 0x100811af, 27836 }, /* XF86DisplayToggle */
{ 0x100811b0, 30465 }, /* XF86SpellCheck */
{ 0x100811b6, 27691 }, /* XF86ContextMenu */
{ 0x100811b7, 29332 }, /* XF86MediaRepeat */
{ 0x100811b8, 26756 }, /* XF8610ChannelsUp */
{ 0x100811b9, 26737 }, /* XF8610ChannelsDown */
{ 0x100811ba, 28192 }, /* XF86Images */
{ 0x100811bc, 29586 }, /* XF86NotificationCenter */
{ 0x100811bd, 29956 }, /* XF86PickupPhone */
{ 0x100811be, 28124 }, /* XF86HangupPhone */
{ 0x100811d0, 27986 }, /* XF86Fn */
{ 0x100811d1, 27993 }, /* XF86Fn_Esc */
{ 0x100811e5, 28004 }, /* XF86FnRightShift */
{ 0x10081200, 29609 }, /* XF86Numeric0 */
{ 0x10081201, 29622 }, /* XF86Numeric1 */
{ 0x10081202, 29663 }, /* XF86Numeric2 */
{ 0x10081203, 29676 }, /* XF86Numeric3 */
{ 0x10081204, 29689 }, /* XF86Numeric4 */
{ 0x10081205, 29702 }, /* XF86Numeric5 */
{ 0x10081206, 29715 }, /* XF86Numeric6 */
{ 0x10081207, 29728 }, /* XF86Numeric7 */
{ 0x10081208, 29741 }, /* XF86Numeric8 */
{ 0x10081209, 29754 }, /* XF86Numeric9 */
{ 0x1008120a, 29836 }, /* XF86NumericStar */
{ 0x1008120b, 29819 }, /* XF86NumericPound */
{ 0x1008120c, 29767 }, /* XF86NumericA */
{ 0x1008120d, 29780 }, /* XF86NumericB */
{ 0x1008120e, 29793 }, /* XF86NumericC */
{ 0x1008120f, 29806 }, /* XF86NumericD */
{ 0x10081210, 27511 }, /* XF86CameraFocus */
{ 0x10081211, 31130 }, /* XF86WPSButton */
{ 0x10081215, 27571 }, /* XF86CameraZoomIn */
{ 0x10081216, 27588 }, /* XF86CameraZoomOut */
{ 0x10081217, 27558 }, /* XF86CameraUp */
{ 0x10081218, 27496 }, /* XF86CameraDown */
{ 0x10081219, 27527 }, /* XF86CameraLeft */
{ 0x1008121a, 27542 }, /* XF86CameraRight */
{ 0x1008121b, 26932 }, /* XF86AttendantOn */
{ 0x1008121c, 26915 }, /* XF86AttendantOff */
{ 0x1008121d, 26948 }, /* XF86AttendantToggle */
{ 0x1008121e, 28770 }, /* XF86LightsToggle */
{ 0x10081230, 26816 }, /* XF86ALSToggle */
{ 0x10081240, 27436 }, /* XF86Buttonconfig */
{ 0x10081241, 30774 }, /* XF86Taskmanager */
{ 0x10081242, 28223 }, /* XF86Journal */
{ 0x10081243, 27726 }, /* XF86ControlPanel */
{ 0x10081244, 26871 }, /* XF86AppSelect */
{ 0x10081245, 30305 }, /* XF86Screensaver */
{ 0x10081246, 31043 }, /* XF86VoiceCommand */
{ 0x10081247, 26901 }, /* XF86Assistant */
{ 0x10081249, 27905 }, /* XF86EmojiPicker */
{ 0x1008124a, 27797 }, /* XF86Dictate */
{ 0x10081250, 27418 }, /* XF86BrightnessMin */
{ 0x10081251, 27400 }, /* XF86BrightnessMax */
{ 0x10081260, 28378 }, /* XF86KbdInputAssistPrev */
{ 0x10081261, 28327 }, /* XF86KbdInputAssistNext */
{ 0x10081262, 28401 }, /* XF86KbdInputAssistPrevgroup */
{ 0x10081263, 28350 }, /* XF86KbdInputAssistNextgroup */
{ 0x10081264, 28277 }, /* XF86KbdInputAssistAccept */
{ 0x10081265, 28302 }, /* XF86KbdInputAssistCancel */
{ 0x10081266, 30140 }, /* XF86RightUp */
{ 0x10081267, 30126 }, /* XF86RightDown */
{ 0x10081268, 28745 }, /* XF86LeftUp */
{ 0x10081269, 28732 }, /* XF86LeftDown */
{ 0x1008126a, 30196 }, /* XF86RootMenu */
{ 0x1008126b, 29348 }, /* XF86MediaTopMenu */
{ 0x1008126c, 29635 }, /* XF86Numeric11 */
{ 0x1008126d, 29649 }, /* XF86Numeric12 */
{ 0x1008126e, 26998 }, /* XF86AudioDesc */
{ 0x1008126f, 26773 }, /* XF863DMode */
{ 0x10081270, 29569 }, /* XF86NextFavorite */
{ 0x10081271, 30527 }, /* XF86StopRecord */
{ 0x10081272, 29930 }, /* XF86PauseRecord */
{ 0x10081273, 31035 }, /* XF86VOD */
{ 0x10081274, 30932 }, /* XF86Unmute */
{ 0x10081275, 27944 }, /* XF86FastReverse */
{ 0x10081276, 30439 }, /* XF86SlowReverse */
{ 0x10081277, 27775 }, /* XF86Data */
{ 0x10081278, 29867 }, /* XF86OnScreenKeyboard */
{ 0x10081279, 30044 }, /* XF86PrivacyScreenToggle */
{ 0x1008127a, 30387 }, /* XF86SelectiveScreenshot */
{ 0x10081290, 28832 }, /* XF86Macro1 */
{ 0x10081291, 28963 }, /* XF86Macro2 */
{ 0x10081292, 29094 }, /* XF86Macro3 */
{ 0x10081293, 29117 }, /* XF86Macro4 */
{ 0x10081294, 29128 }, /* XF86Macro5 */
{ 0x10081295, 29139 }, /* XF86Macro6 */
{ 0x10081296, 29150 }, /* XF86Macro7 */
{ 0x10081297, 29161 }, /* XF86Macro8 */
{ 0x10081298, 29172 }, /* XF86Macro9 */
{ 0x10081299, 28843 }, /* XF86Macro10 */
{ 0x1008129a, 28855 }, /* XF86Macro11 */
{ 0x1008129b, 28867 }, /* XF86Macro12 */
{ 0x1008129c, 28879 }, /* XF86Macro13 */
{ 0x1008129d, 28891 }, /* XF86Macro14 */
{ 0x1008129e, 28903 }, /* XF86Macro15 */
{ 0x1008129f, 28915 }, /* XF86Macro16 */
{ 0x100812a0, 28927 }, /* XF86Macro17 */
{ 0x100812a1, 28939 }, /* XF86Macro18 */
{ 0x100812a2, 28951 }, /* XF86Macro19 */
{ 0x100812a3, 28974 }, /* XF86Macro20 */
{ 0x100812a4, 28986 }, /* XF86Macro21 */
{ 0x100812a5, 28998 }, /* XF86Macro22 */
{ 0x100812a6, 29010 }, /* XF86Macro23 */
{ 0x100812a7, 29022 }, /* XF86Macro24 */
{ 0x100812a8, 29034 }, /* XF86Macro25 */
{ 0x100812a9, 29046 }, /* XF86Macro26 */
{ 0x100812aa, 29058 }, /* XF86Macro27 */
{ 0x100812ab, 29070 }, /* XF86Macro28 */
{ 0x100812ac, 29082 }, /* XF86Macro29 */
{ 0x100812ad, 29105 }, /* XF86Macro30 */
{ 0x100812b0, 29255 }, /* XF86MacroRecordStart */
{ 0x100812b1, 29276 }, /* XF86MacroRecordStop */
{ 0x100812b2, 29234 }, /* XF86MacroPresetCycle */
{ 0x100812b3, 29183 }, /* XF86MacroPreset1 */
{ 0x100812b4, 29200 }, /* XF86MacroPreset2 */
{ 0x100812b5, 29217 }, /* XF86MacroPreset3 */
{ 0x100812b8, 28429 }, /* XF86KbdLcdMenu1 */
{ 0x100812b9, 28445 }, /* XF86KbdLcdMenu2 */
{ 0x100812ba, 28461 }, /* XF86KbdLcdMenu3 */
{ 0x100812bb, 28477 }, /* XF86KbdLcdMenu4 */
{ 0x100812bc, 28493 }, /* XF86KbdLcdMenu5 */
{ 0x1008fe01, 30579 }, /* XF86Switch_VT_1 */
{ 0x1008fe02, 30646 }, /* XF86Switch_VT_2 */
{ 0x1008fe03, 30662 }, /* XF86Switch_VT_3 */
{ 0x1008fe04, 30678 }, /* XF86Switch_VT_4 */
{ 0x1008fe05, 30694 }, /* XF86Switch_VT_5 */
{ 0x1008fe06, 30710 }, /* XF86Switch_VT_6 */
{ 0x1008fe07, 30726 }, /* XF86Switch_VT_7 */
{ 0x1008fe08, 30742 }, /* XF86Switch_VT_8 */
{ 0x1008fe09, 30758 }, /* XF86Switch_VT_9 */
{ 0x1008fe0a, 30595 }, /* XF86Switch_VT_10 */
{ 0x1008fe0b, 30612 }, /* XF86Switch_VT_11 */
{ 0x1008fe0c, 30629 }, /* XF86Switch_VT_12 */
{ 0x1008fe20, 30921 }, /* XF86Ungrab */
{ 0x1008fe21, 27653 }, /* XF86ClearGrab */
{ 0x1008fe22, 29554 }, /* XF86Next_VMode */
{ 0x1008fe23, 30029 }, /* XF86Prev_VMode */
{ 0x1008fe24, 28814 }, /* XF86LogWindowTree */
{ 0x1008fe25, 28787 }, /* XF86LogGrabInfo */
{ 0x1008ff01, 29422 }, /* XF86ModeLock */
{ 0x1008ff02, 29480 }, /* XF86MonBrightnessUp */
{ 0x1008ff03, 29458 }, /* XF86MonBrightnessDown */
{ 0x1008ff04, 28509 }, /* XF86KbdLightOnOff */
{ 0x1008ff05, 28257 }, /* XF86KbdBrightnessUp */
{ 0x1008ff06, 28235 }, /* XF86KbdBrightnessDown */
{ 0x1008ff07, 29435 }, /* XF86MonBrightnessCycle */
{ 0x1008ff10, 30496 }, /* XF86Standby */
{ 0x1008ff11, 27029 }, /* XF86AudioLowerVolume */
{ 0x1008ff12, 27082 }, /* XF86AudioMute */
{ 0x1008ff13, 27169 }, /* XF86AudioRaiseVolume */
{ 0x1008ff14, 27125 }, /* XF86AudioPlay */
{ 0x1008ff15, 27258 }, /* XF86AudioStop */
{ 0x1008ff16, 27155 }, /* XF86AudioPrev */
{ 0x1008ff17, 27096 }, /* XF86AudioNext */
{ 0x1008ff18, 28166 }, /* XF86HomePage */
{ 0x1008ff19, 29296 }, /* XF86Mail */
{ 0x1008ff1a, 30508 }, /* XF86Start */
{ 0x1008ff1b, 30365 }, /* XF86Search */
{ 0x1008ff1c, 27210 }, /* XF86AudioRecord */
{ 0x1008ff1d, 27468 }, /* XF86Calculator */
{ 0x1008ff1e, 29377 }, /* XF86Memo */
{ 0x1008ff1f, 30825 }, /* XF86ToDoList */
{ 0x1008ff20, 27483 }, /* XF86Calendar */
{ 0x1008ff21, 29985 }, /* XF86PowerDown */
{ 0x1008ff22, 27707 }, /* XF86ContrastAdjust */
{ 0x1008ff23, 30183 }, /* XF86RockerUp */
{ 0x1008ff24, 30152 }, /* XF86RockerDown */
{ 0x1008ff25, 30167 }, /* XF86RockerEnter */
{ 0x1008ff26, 27281 }, /* XF86Back */
{ 0x1008ff27, 28021 }, /* XF86Forward */
{ 0x1008ff28, 30518 }, /* XF86Stop */
{ 0x1008ff29, 30082 }, /* XF86Refresh */
{ 0x1008ff2a, 29999 }, /* XF86PowerOff */
{ 0x1008ff2b, 31074 }, /* XF86WakeUp */
{ 0x1008ff2c, 27895 }, /* XF86Eject */
{ 0x1008ff2d, 30289 }, /* XF86ScreenSaver */
{ 0x1008ff2e, 31153 }, /* XF86WWW */
{ 0x1008ff2f, 30429 }, /* XF86Sleep */
{ 0x1008ff30, 27960 }, /* XF86Favorites */
{ 0x1008ff31, 27110 }, /* XF86AudioPause */
{ 0x1008ff32, 27050 }, /* XF86AudioMedia */
{ 0x1008ff33, 29510 }, /* XF86MyComputer */
{ 0x1008ff34, 30986 }, /* XF86VendorHome */
{ 0x1008ff35, 28756 }, /* XF86LightBulb */
{ 0x1008ff36, 30420 }, /* XF86Shop */
{ 0x1008ff37, 28154 }, /* XF86History */
{ 0x1008ff38, 29897 }, /* XF86OpenURL */
{ 0x1008ff39, 26784 }, /* XF86AddFavorite */
{ 0x1008ff3a, 28179 }, /* XF86HotLinks */
{ 0x1008ff3b, 27360 }, /* XF86BrightnessAdjust */
{ 0x1008ff3c, 27974 }, /* XF86Finance */
{ 0x1008ff3d, 27677 }, /* XF86Community */
{ 0x1008ff3e, 27242 }, /* XF86AudioRewind */
{ 0x1008ff3f, 27290 }, /* XF86BackForward */
{ 0x1008ff40, 28540 }, /* XF86Launch0 */
{ 0x1008ff41, 28552 }, /* XF86Launch1 */
{ 0x1008ff42, 28564 }, /* XF86Launch2 */
{ 0x1008ff43, 28576 }, /* XF86Launch3 */
{ 0x1008ff44, 28588 }, /* XF86Launch4 */
{ 0x1008ff45, 28600 }, /* XF86Launch5 */
{ 0x1008ff46, 28612 }, /* XF86Launch6 */
{ 0x1008ff47, 28624 }, /* XF86Launch7 */
{ 0x1008ff48, 28636 }, /* XF86Launch8 */
{ 0x1008ff49, 28648 }, /* XF86Launch9 */
{ 0x1008ff4a, 28660 }, /* XF86LaunchA */
{ 0x1008ff4b, 28672 }, /* XF86LaunchB */
{ 0x1008ff4c, 28684 }, /* XF86LaunchC */
{ 0x1008ff4d, 28696 }, /* XF86LaunchD */
{ 0x1008ff4e, 28708 }, /* XF86LaunchE */
{ 0x1008ff4f, 28720 }, /* XF86LaunchF */
{ 0x1008ff50, 26830 }, /* XF86ApplicationLeft */
{ 0x1008ff51, 26850 }, /* XF86ApplicationRight */
{ 0x1008ff52, 27341 }, /* XF86Book */
{ 0x1008ff53, 27606 }, /* XF86CD */
{ 0x1008ff54, 27453 }, /* XF86Calculater */
{ 0x1008ff55, 27643 }, /* XF86Clear */
{ 0x1008ff56, 27667 }, /* XF86Close */
{ 0x1008ff57, 27743 }, /* XF86Copy */
{ 0x1008ff58, 27752 }, /* XF86Cut */
{ 0x1008ff59, 27809 }, /* XF86Display */
{ 0x1008ff5a, 27868 }, /* XF86DOS */
{ 0x1008ff5b, 27854 }, /* XF86Documents */
{ 0x1008ff5c, 27921 }, /* XF86Excel */
{ 0x1008ff5d, 27931 }, /* XF86Explorer */
{ 0x1008ff5e, 28079 }, /* XF86Game */
{ 0x1008ff5f, 28088 }, /* XF86Go */
{ 0x1008ff60, 28212 }, /* XF86iTouch */
{ 0x1008ff61, 28803 }, /* XF86LogOff */
{ 0x1008ff62, 29321 }, /* XF86Market */
{ 0x1008ff63, 29365 }, /* XF86Meeting */
{ 0x1008ff65, 29386 }, /* XF86MenuKB */
{ 0x1008ff66, 29397 }, /* XF86MenuPB */
{ 0x1008ff67, 29525 }, /* XF86MySites */
{ 0x1008ff68, 29537 }, /* XF86New */
{ 0x1008ff69, 29545 }, /* XF86News */
{ 0x1008ff6a, 29852 }, /* XF86OfficeHome */
{ 0x1008ff6b, 29888 }, /* XF86Open */
{ 0x1008ff6c, 29909 }, /* XF86Option */
{ 0x1008ff6d, 29920 }, /* XF86Paste */
{ 0x1008ff6e, 29946 }, /* XF86Phone */
{ 0x1008ff70, 30068 }, /* XF86Q */
{ 0x1008ff72, 30105 }, /* XF86Reply */
{ 0x1008ff73, 30094 }, /* XF86Reload */
{ 0x1008ff74, 30209 }, /* XF86RotateWindows */
{ 0x1008ff75, 30265 }, /* XF86RotationPB */
{ 0x1008ff76, 30227 }, /* XF86RotationKB */
{ 0x1008ff77, 30280 }, /* XF86Save */
{ 0x1008ff78, 30352 }, /* XF86ScrollUp */
{ 0x1008ff79, 30337 }, /* XF86ScrollDown */
{ 0x1008ff7a, 30321 }, /* XF86ScrollClick */
{ 0x1008ff7b, 30411 }, /* XF86Send */
{ 0x1008ff7c, 30455 }, /* XF86Spell */
{ 0x1008ff7d, 30480 }, /* XF86SplitScreen */
{ 0x1008ff7e, 30555 }, /* XF86Support */
{ 0x1008ff7f, 30790 }, /* XF86TaskPane */
{ 0x1008ff80, 30803 }, /* XF86Terminal */
{ 0x1008ff81, 30838 }, /* XF86Tools */
{ 0x1008ff82, 30910 }, /* XF86Travel */
{ 0x1008ff84, 30967 }, /* XF86UserPB */
{ 0x1008ff85, 30943 }, /* XF86User1KB */
{ 0x1008ff86, 30955 }, /* XF86User2KB */
{ 0x1008ff87, 31001 }, /* XF86Video */
{ 0x1008ff88, 31096 }, /* XF86WheelButton */
{ 0x1008ff89, 31121 }, /* XF86Word */
{ 0x1008ff8a, 31161 }, /* XF86Xfer */
{ 0x1008ff8b, 31181 }, /* XF86ZoomIn */
{ 0x1008ff8c, 31192 }, /* XF86ZoomOut */
{ 0x1008ff8d, 27272 }, /* XF86Away */
{ 0x1008ff8e, 29408 }, /* XF86Messenger */
{ 0x1008ff8f, 31085 }, /* XF86WebCam */
{ 0x1008ff90, 29305 }, /* XF86MailForward */
{ 0x1008ff91, 29972 }, /* XF86Pictures */
{ 0x1008ff92, 29500 }, /* XF86Music */
{ 0x1008ff93, 27306 }, /* XF86Battery */
{ 0x1008ff94, 27327 }, /* XF86Bluetooth */
{ 0x1008ff95, 31112 }, /* XF86WLAN */
{ 0x1008ff96, 30978 }, /* XF86UWB */
{ 0x1008ff97, 27012 }, /* XF86AudioForward */
{ 0x1008ff98, 27226 }, /* XF86AudioRepeat */
{ 0x1008ff99, 27190 }, /* XF86AudioRandomPlay */
{ 0x1008ff9a, 30542 }, /* XF86Subtitle */
{ 0x1008ff9b, 26978 }, /* XF86AudioCycleTrack */
{ 0x1008ff9c, 27760 }, /* XF86CycleAngle */
{ 0x1008ff9d, 28033 }, /* XF86FrameBack */
{ 0x1008ff9e, 28047 }, /* XF86FrameForward */
{ 0x1008ff9f, 30816 }, /* XF86Time */
{ 0x1008ffa0, 30376 }, /* XF86Select */
{ 0x1008ffa1, 31026 }, /* XF86View */
{ 0x1008ffa2, 30848 }, /* XF86TopMenu */
{ 0x1008ffa3, 30074 }, /* XF86Red */
{ 0x1008ffa4, 28114 }, /* XF86Green */
{ 0x1008ffa5, 31170 }, /* XF86Yellow */
{ 0x1008ffa6, 27318 }, /* XF86Blue */
{ 0x1008ffa7, 30567 }, /* XF86Suspend */
{ 0x1008ffa8, 28140 }, /* XF86Hibernate */
{ 0x1008ffa9, 30891 }, /* XF86TouchpadToggle */
{ 0x1008ffb0, 30876 }, /* XF86TouchpadOn */
{ 0x1008ffb1, 30860 }, /* XF86TouchpadOff */
{ 0x1008ffb2, 27065 }, /* XF86AudioMicMute */
{ 0x1008ffb3, 28527 }, /* XF86Keyboard */
{ 0x1008ffb4, 31144 }, /* XF86WWAN */
{ 0x1008ffb5, 30115 }, /* XF86RFKill */
{ 0x1008ffb6, 27139 }, /* XF86AudioPreset */
{ 0x1008ffb7, 30242 }, /* XF86RotationLockToggle */
{ 0x1008ffb8, 28064 }, /* XF86FullScreen */
};
|
3396fd3724b14783c882ceb42c43b5401e24d7be
|
bb38c44037a99d0a12a12d92059678f2faebbc80
|
/src/include/optimizer/subselect.h
|
f5ccba85b480dbe3b6e781f5f76e4b5091c743ea
|
[
"LicenseRef-scancode-mulanpsl-2.0-en",
"LicenseRef-scancode-unknown-license-reference",
"PostgreSQL",
"BSD-3-Clause",
"LGPL-2.0-or-later",
"LicenseRef-scancode-unicode",
"LicenseRef-scancode-warranty-disclaimer",
"curl",
"GPL-1.0-or-later",
"LGPL-2.1-or-later",
"LGPL-2.1-only",
"CC-BY-4.0",
"LicenseRef-scancode-protobuf",
"OpenSSL",
"LicenseRef-scancode-generic-export-compliance",
"X11-distribute-modifications-variant",
"LicenseRef-scancode-other-permissive",
"MIT",
"NCSA",
"Python-2.0",
"LicenseRef-scancode-openssl",
"LicenseRef-scancode-ssleay-windows",
"CC-BY-3.0",
"LicenseRef-scancode-other-copyleft",
"GPL-2.0-only",
"BSL-1.0",
"Apache-2.0",
"LGPL-2.0-only",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"Zlib"
] |
permissive
|
opengauss-mirror/openGauss-server
|
a9c5a62908643492347830826c56da49f0942796
|
310e84631c68c8bf37b004148b66f94064f701e4
|
refs/heads/master
| 2023-07-26T19:29:12.495484
| 2023-07-17T12:23:32
| 2023-07-17T12:23:32
| 276,117,477
| 591
| 208
|
MulanPSL-2.0
| 2023-04-28T12:30:18
| 2020-06-30T14:08:59
|
C++
|
UTF-8
|
C
| false
| false
| 3,253
|
h
|
subselect.h
|
/* -------------------------------------------------------------------------
*
* subselect.h
*
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/include/optimizer/subselect.h
*
* -------------------------------------------------------------------------
*/
#ifndef SUBSELECT_H
#define SUBSELECT_H
#include "nodes/plannodes.h"
#include "nodes/relation.h"
#define SUBLINK_COUNTER 100
typedef struct
{
List *aggFuncsList;
} fetch_agg_funcs_context;
extern void SS_process_ctes(PlannerInfo* root);
extern JoinExpr* convert_ANY_sublink_to_join(
PlannerInfo* root, SubLink* sublink, bool under_not, Relids available_rels);
extern JoinExpr* convert_EXISTS_sublink_to_join(
PlannerInfo* root, SubLink* sublink, bool under_not, Relids available_rels);
extern Node* convert_EXPR_sublink_to_join(PlannerInfo* root, Node** jtlink1, Node* inout_quals, SubLink* sublink,
Relids *available_rels, Node* all_quals, const char *refname = NULL);
extern void convert_OREXISTS_to_join(
PlannerInfo* root, BoolExpr* or_clause, SubLink* exists_sublink, Node** jtlink1, Relids available_rels1, bool isnull);
extern void convert_ORANY_to_join(
PlannerInfo* root, BoolExpr* or_clause, SubLink* any_sublink, Node** jtlink1, Relids available_rels);
extern Node* convert_OREXPR_to_join(PlannerInfo* root, BoolExpr* or_clause, OpExpr* op_expr, SubLink* expr_sublink,
Node** jtlink1, Relids *available_rels);
extern Node *generate_filter_on_opexpr_sublink(PlannerInfo *root, int rtIndex, Node *targetExpr, Query *subQuery);
extern void convert_ORCLAUSE_to_join(PlannerInfo* root, BoolExpr* or_clause, Node** jtlink1, Relids *available_rels1);
extern Node* SS_replace_correlation_vars(PlannerInfo* root, Node* expr);
extern Node* SS_process_sublinks(PlannerInfo* root, Node* expr, bool isQual);
extern void SS_finalize_plan(PlannerInfo* root, Plan* plan, bool attach_initplans);
extern Param* SS_make_initplan_from_plan(
PlannerInfo* root, Plan* plan, Oid resulttype, int32 resulttypmod, Oid resultcollation);
extern Param* assign_nestloop_param_var(PlannerInfo* root, Var* var);
extern Param* assign_nestloop_param_placeholdervar(PlannerInfo* root, PlaceHolderVar* phv);
extern int assignPartIteratorParam(PlannerInfo* root);
extern int SS_assign_special_param(PlannerInfo* root);
extern bool check_var_nonnullable(Query* query, Node* node);
#ifdef STREAMPLAN
extern void convert_multi_count_distinct(PlannerInfo* root);
#endif
extern List* pull_sublink(Node* node, int flag, bool is_name, bool recurse = false);
extern List* pull_opExpr(Node* node);
extern List* pull_aggref(Node* node);
extern void push_down_one_query(PlannerInfo* root, Query** subquery);
extern void pull_up_sort_limit_clause(Query* query, Query* subquery, bool set_refs);
extern bool safe_pullup_op_expr_sublink(OpExpr* expr);
extern bool safe_apply_winmagic(PlannerInfo* root, Node* sublink_qual, SubLink* sublink, Relids* available_rels);
extern Node* convert_expr_sublink_with_winmagic(PlannerInfo* root, Node** jtlink1, Node* sublink_qual,
SubLink* sublink, Relids* available_rels);
#endif /* SUBSELECT_H */
|
8faf92c511591725047156c503905e9122f41ff9
|
3fe78c7fda8265db8335de4e5b17cde1ee7990e3
|
/code/include/object/orxObject.h
|
cf9df4eeb5f062fb9a7222aa961183591e2ac12f
|
[
"Zlib"
] |
permissive
|
orx/orx
|
c0628258025e63e59319c8126c5a5c2da9755420
|
7163f753f970b28818c7064dfd9b52a29c701967
|
refs/heads/master
| 2023-08-30T03:08:52.575944
| 2023-08-23T17:53:22
| 2023-08-23T17:53:22
| 39,714,458
| 1,358
| 118
|
Zlib
| 2023-07-26T00:27:33
| 2015-07-26T05:15:23
|
C
|
UTF-8
|
C
| false
| false
| 60,554
|
h
|
orxObject.h
|
/* Orx - Portable Game Engine
*
* Copyright (c) 2008-2022 Orx-Project
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
/**
* @file orxObject.h
* @date 01/12/2003
* @author iarwain@orx-project.org
*
* @todo
*/
/**
* @addtogroup orxObject
*
* Object module
* Allows to creates and handle objects
* Objects are structure containers that can be linked to many other structures such as frames, graphics, etc...
*
* @{
*/
#ifndef _orxOBJECT_H_
#define _orxOBJECT_H_
#include "orxInclude.h"
#include "anim/orxAnimSet.h"
#include "core/orxClock.h"
#include "display/orxDisplay.h"
#include "display/orxGraphic.h"
#include "display/orxTexture.h"
#include "math/orxOBox.h"
#include "memory/orxBank.h"
#include "object/orxStructure.h"
#include "sound/orxSound.h"
/** Defines */
#define orxOBJECT_GET_STRUCTURE(OBJECT, TYPE) orx##TYPE(_orxObject_GetStructure(OBJECT, orxSTRUCTURE_ID_##TYPE))
#define orxOBJECT_KZ_DEFAULT_GROUP "default"
/** Event enum
*/
typedef enum __orxOBJECT_EVENT_t
{
orxOBJECT_EVENT_CREATE = 0,
orxOBJECT_EVENT_DELETE,
orxOBJECT_EVENT_PREPARE,
orxOBJECT_EVENT_ENABLE,
orxOBJECT_EVENT_DISABLE,
orxOBJECT_EVENT_PAUSE,
orxOBJECT_EVENT_UNPAUSE,
orxOBJECT_EVENT_NUMBER,
orxOBJECT_EVENT_NONE = orxENUM_NONE
} orxOBJECT_EVENT;
/** Internal object structure */
typedef struct __orxOBJECT_t orxOBJECT;
/** @name Internal module function
* @{ */
/** Object module setup
*/
extern orxDLLAPI void orxFASTCALL orxObject_Setup();
/** Inits the object module.
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Init();
/** Exits from the object module.
*/
extern orxDLLAPI void orxFASTCALL orxObject_Exit();
/** @} */
/** @name Basic handling
* @{ */
/** Creates an empty object.
* @return orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_Create();
/** Creates an object from config.
* @param[in] _zConfigID Config ID
* @ return orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_CreateFromConfig(const orxSTRING _zConfigID);
/** Deletes an object, *unsafe* when called from an event handler: call orxObject_SetLifeTime(orxFLOAT_0) instead
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Delete(orxOBJECT *_pstObject);
/** Updates an object.
* @param[in] _pstObject Concerned object
* @param[in] _pstClockInfo Clock information used to compute new object's state
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Update(orxOBJECT *_pstObject, const orxCLOCK_INFO *_pstClockInfo);
/** Enables/disables an object. Note that enabling/disabling an object is not recursive, so its children will not be affected, see orxObject_EnableRecursive().
* @param[in] _pstObject Concerned object
* @param[in] _bEnable Enable / disable
*/
extern orxDLLAPI void orxFASTCALL orxObject_Enable(orxOBJECT *_pstObject, orxBOOL _bEnable);
/** Enables/disables an object and all its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _bEnable Enable / disable
*/
extern orxDLLAPI void orxFASTCALL orxObject_EnableRecursive(orxOBJECT *_pstObject, orxBOOL _bEnable);
/** Is object enabled?
* @param[in] _pstObject Concerned object
* @return orxTRUE if enabled, orxFALSE otherwise
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_IsEnabled(const orxOBJECT *_pstObject);
/** Pauses/unpauses an object. Note that pausing an object is not recursive, so its children will not be affected, see orxObject_PauseRecursive().
* @param[in] _pstObject Concerned object
* @param[in] _bPause Pause / unpause
*/
extern orxDLLAPI void orxFASTCALL orxObject_Pause(orxOBJECT *_pstObject, orxBOOL _bPause);
/** Pauses/unpauses an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _bPause Pause / unpause
*/
extern orxDLLAPI void orxFASTCALL orxObject_PauseRecursive(orxOBJECT *_pstObject, orxBOOL _bPause);
/** Is object paused?
* @param[in] _pstObject Concerned object
* @return orxTRUE if paused, orxFALSE otherwise
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_IsPaused(const orxOBJECT *_pstObject);
/** @} */
/** @name User data
* @{ */
/** Sets user data for an object. Orx ignores the user data, this is a mechanism for attaching custom
* data to be used later by user code.
* @param[in] _pstObject Concerned object
* @param[in] _pUserData User data to store / orxNULL
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetUserData(orxOBJECT *_pstObject, void *_pUserData);
/** Gets object's user data.
* @param[in] _pstObject Concerned object
* @return Stored user data / orxNULL
*/
extern orxDLLAPI void *orxFASTCALL orxObject_GetUserData(const orxOBJECT *_pstObject);
/** @} */
/** @name Ownership
* @{ */
/** Sets owner for an object. Ownership in Orx is only about lifetime management. That is, when an object
* dies, it also kills its owned children. Compare this with orxObject_SetParent().
*
* Note that the "ChildList" field of an object's config section implies two things; that the object is both
* the owner (orxObject_SetOwner()) and the parent (orxObject_SetParent()) of its owned children. There is an
* exception to this though; when an object's child has a parent camera, the object is only the owner, and
* the camera is the parent.
* @param[in] _pstObject Concerned object
* @param[in] _pOwner Owner to set / orxNULL, if owner is an orxOBJECT, the owned object will be added to it as a children
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetOwner(orxOBJECT *_pstObject, void *_pOwner);
/** Gets object's owner. See orxObject_SetOwner().
* @param[in] _pstObject Concerned object
* @return Owner / orxNULL
*/
extern orxDLLAPI orxSTRUCTURE *orxFASTCALL orxObject_GetOwner(const orxOBJECT *_pstObject);
/** Gets object's first owned child (only if created with a config ChildList / has an owner set with orxObject_SetOwner)
* see orxObject_SetOwner() and orxObject_SetParent() for a comparison of ownership and parenthood in Orx.
*
* This function is typically used to iterate over the owned children of an object. For example;
* @code
* for(orxOBJECT * pstChild = orxObject_GetOwnedChild(pstObject);
* pstChild;
* pstChild = orxObject_GetOwnedSibling(pstChild))
* {
* do_something(pstChild);
* } @endcode
* @param[in] _pstObject Concerned object
* @return First owned child object / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_GetOwnedChild(const orxOBJECT *_pstObject);
/** Gets object's next owned sibling (only if created with a config ChildList / has an owner set with orxObject_SetOwner)
* This function is typically used to iterate over the owned children of an object, see orxObject_GetOwnedChild() for an example.
* @param[in] _pstObject Concerned object
* @return Next sibling object / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_GetOwnedSibling(const orxOBJECT *_pstObject);
/** @} */
/** @name Clock
* @{ */
/** Sets associated clock for an object.
* @param[in] _pstObject Concerned object
* @param[in] _pstClock Clock to associate / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetClock(orxOBJECT *_pstObject, orxCLOCK *_pstClock);
/** Sets associated clock for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _pstClock Clock to associate / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetClockRecursive(orxOBJECT *_pstObject, orxCLOCK *_pstClock);
/** Gets object's clock.
* @param[in] _pstObject Concerned object
* @return Associated clock / orxNULL
*/
extern orxDLLAPI orxCLOCK *orxFASTCALL orxObject_GetClock(const orxOBJECT *_pstObject);
/** @} */
/** @name Linked Structures
* @{ */
/** Links a structure to an object.
* @param[in] _pstObject Concerned object
* @param[in] _pstStructure Structure to link
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_LinkStructure(orxOBJECT *_pstObject, orxSTRUCTURE *_pstStructure);
/** Unlinks structure from an object, given its structure ID.
* @param[in] _pstObject Concerned object
* @param[in] _eStructureID ID of structure to unlink
*/
extern orxDLLAPI void orxFASTCALL orxObject_UnlinkStructure(orxOBJECT *_pstObject, orxSTRUCTURE_ID _eStructureID);
/** Structure used by an object get accessor, given its structure ID. Structure must then be cast correctly. (see helper macro
* #orxOBJECT_GET_STRUCTURE())
* @param[in] _pstObject Concerned object
* @param[in] _eStructureID ID of the structure to get
* @return orxSTRUCTURE / orxNULL
*/
extern orxDLLAPI orxSTRUCTURE *orxFASTCALL _orxObject_GetStructure(const orxOBJECT *_pstObject, orxSTRUCTURE_ID _eStructureID);
/** @} */
/** @name Flip
* @{ */
/** Sets object flipping.
* @param[in] _pstObject Concerned object
* @param[in] _bFlipX Flip it on X axis
* @param[in] _bFlipY Flip it on Y axis
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetFlip(orxOBJECT *_pstObject, orxBOOL _bFlipX, orxBOOL _bFlipY);
/** Gets object flipping.
* @param[in] _pstObject Concerned object
* @param[in] _pbFlipX X axis flipping
* @param[in] _pbFlipY Y axis flipping
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_GetFlip(const orxOBJECT *_pstObject, orxBOOL *_pbFlipX, orxBOOL *_pbFlipY);
/** @} */
/** @name Graphic
* @{ */
/** Sets object pivot. This is a convenience wrapper around orxGraphic_SetPivot(). The "pivot" is essentially
* what is indicated by the "Pivot" field of a config graphic section.
* @param[in] _pstObject Concerned object
* @param[in] _pvPivot Object pivot
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetPivot(orxOBJECT *_pstObject, const orxVECTOR *_pvPivot);
/** Sets object relative pivot.
* @param[in] _pstObject Concerned object
* @param[in] _u32AlignFlags Graphic alignment flags
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetRelativePivot(orxOBJECT *_pstObject, orxU32 _u32AlignFlags);
/** Sets object origin. This is a convenience wrapper around orxGraphic_SetOrigin(). The "origin" of a graphic is
* essentially what is indicated by the "TextureOrigin" field of a config graphic section. The "origin" together with
* "size" (see orxObject_SetSize()) defines the sprite of an object.
* @param[in] _pstObject Concerned object
* @param[in] _pvOrigin Object origin
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetOrigin(orxOBJECT *_pstObject, const orxVECTOR *_pvOrigin);
/** Sets object size. For objects that have a graphic attached it's simply a convenience wrapper for orxGraphic_SetSize(),
* but an object can also have a size without a graphic.
*
* Note the difference between "Scale" and "Size". The size of an object with a non-text graphic is the sprite size in
* pixels on its texture. The object's effective size for rendering and intersection purposes (see orxObject_Pick()
* and friends) is proportional to its "size" multiplied by its "scale". Another important distinction is that the
* scale of an object also affects its children (see orxObject_SetParent() and note the distinction between
* parenthood and ownership).
* @param[in] _pstObject Concerned object
* @param[in] _pvSize Object size
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetSize(orxOBJECT *_pstObject, const orxVECTOR *_pvSize);
/** Get object pivot. See orxObject_SetPivot() for a more detailed explanation.
* @param[in] _pstObject Concerned object
* @param[out] _pvPivot Object pivot
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetPivot(const orxOBJECT *_pstObject, orxVECTOR *_pvPivot);
/** Get object origin. See orxObject_SetOrigin() for a more detailed explanation.
* @param[in] _pstObject Concerned object
* @param[out] _pvOrigin Object origin
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetOrigin(const orxOBJECT *_pstObject, orxVECTOR *_pvOrigin);
/** Gets object size. See orxObject_SetSize() for a more detailed explanation.
* @param[in] _pstObject Concerned object
* @param[out] _pvSize Object's size
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetSize(const orxOBJECT *_pstObject, orxVECTOR *_pvSize);
/** @} */
/** @name Frame
* @{ */
/** Sets object position in its parent's reference frame. See orxObject_SetWorldPosition() for setting an object's
* position in the global reference frame.
* @param[in] _pstObject Concerned object
* @param[in] _pvPosition Object position
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetPosition(orxOBJECT *_pstObject, const orxVECTOR *_pvPosition);
/** Sets object position in the global reference frame. See orxObject_SetPosition() for setting an object's position
* in its parent's reference frame.
* @param[in] _pstObject Concerned object
* @param[in] _pvPosition Object world position
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetWorldPosition(orxOBJECT *_pstObject, const orxVECTOR *_pvPosition);
/** Sets object rotation in its parent's reference frame. See orxObject_SetWorldRotation() for setting an object's
* rotation in the global reference frame.
* @param[in] _pstObject Concerned object
* @param[in] _fRotation Object rotation (radians)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetRotation(orxOBJECT *_pstObject, orxFLOAT _fRotation);
/** Sets object rotation in the global reference frame. See orxObject_SetRotation() for setting an object's rotation
* in its parent's reference frame.
* @param[in] _pstObject Concerned object
* @param[in] _fRotation Object world rotation (radians)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetWorldRotation(orxOBJECT *_pstObject, orxFLOAT _fRotation);
/** Sets object scale in its parent's reference frame. See orxObject_SetWorldScale() for setting an object's scale
* in the global reference frame.
* See orxObject_SetSize() for a deeper explanation of the "size" of an object.
* @param[in] _pstObject Concerned object
* @param[in] _pvScale Object scale vector
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetScale(orxOBJECT *_pstObject, const orxVECTOR *_pvScale);
/** Sets object scale in the global reference frame. See orxObject_SetScale() for setting an object's scale in its
* parent's reference frame.
* @param[in] _pstObject Concerned object
* @param[in] _pvScale Object world scale vector
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetWorldScale(orxOBJECT *_pstObject, const orxVECTOR *_pvScale);
/** Get object position. See orxObject_SetPosition().
* @param[in] _pstObject Concerned object
* @param[out] _pvPosition Object position
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetPosition(const orxOBJECT *_pstObject, orxVECTOR *_pvPosition);
/** Get object world position. See orxObject_SetWorldPosition().
* @param[in] _pstObject Concerned object
* @param[out] _pvPosition Object world position
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetWorldPosition(const orxOBJECT *_pstObject, orxVECTOR *_pvPosition);
/** Get object rotation. See orxObject_SetRotation().
* @param[in] _pstObject Concerned object
* @return orxFLOAT (radians)
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetRotation(const orxOBJECT *_pstObject);
/** Get object world rotation. See orxObject_SetWorldRotation().
* @param[in] _pstObject Concerned object
* @return orxFLOAT (radians)
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetWorldRotation(const orxOBJECT *_pstObject);
/** Get object scale. See orxObject_SetScale().
* @param[in] _pstObject Concerned object
* @param[out] _pvScale Object scale vector
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetScale(const orxOBJECT *_pstObject, orxVECTOR *_pvScale);
/** Gets object world scale. See orxObject_SetWorldScale().
* @param[in] _pstObject Concerned object
* @param[out] _pvScale Object world scale
* @return orxVECTOR / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetWorldScale(const orxOBJECT *_pstObject, orxVECTOR *_pvScale);
/** @} */
/** @name Parent
* @{ */
/** Sets an object parent (in the frame hierarchy). Parenthood in orx is about the transformation (position,
* rotation, scale) of objects. Transformation of objects are compounded in a frame hierarchy. Compare this
* with orxObject_SetOwner()
*
* Note that the "ChildList" field of an object's config section implies two things; that the object is both
* the owner (orxObject_SetOwner()) and the parent (orxObject_SetParent()) of its children. There is an
* exception to this though; when an object's child has a parent camera, the object is only the owner, and
* the camera is the parent.
* @param[in] _pstObject Concerned object
* @param[in] _pParent Parent structure to set (object, spawner, camera or frame) / orxNULL
* @return orsSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetParent(orxOBJECT *_pstObject, void *_pParent);
/** Gets object's parent. See orxObject_SetParent() for a more detailed explanation.
* @param[in] _pstObject Concerned object
* @return Parent (object, spawner, camera or frame) / orxNULL
*/
extern orxDLLAPI orxSTRUCTURE *orxFASTCALL orxObject_GetParent(const orxOBJECT *_pstObject);
/** Gets object's first child object. See orxObject_SetOwner() and orxObject_SetParent() for a comparison of
* ownership and parenthood in Orx.
* Note: this function will filter out any camera or spawner and retrieve the first child object.
* This function is typically used to iterate over the children objects of an object.
* For example:
* @code
* for(orxOBJECT *pstChild = orxObject_GetChild(pstObject);
* pstChild != orxNULL;
* pstChild = orxObject_GetSibling(pstChild))
* {
* DoSomething(pstChild); // DoSomething() can recurse into the children of pstChild for a depth-first traversal
* }
* @endcode
* @param[in] _pstObject Concerned object
* @return First child object / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_GetChild(const orxOBJECT *_pstObject);
/** Gets object's next sibling object. This function is typically used for iterating over the children objects of an object,
* see orxObject_GetChild() for an iteration example.
* Note: this function will filter out any camera or spawner and retrieve the next sibling object.
* @param[in] _pstObject Concerned object
* @return Next sibling object / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_GetSibling(const orxOBJECT *_pstObject);
/** Gets object's next child structure of a given type (camera, object or spawner).
* See orxObject_SetOwner() and orxObject_SetParent() for a comparison of
* ownership and parenthood in Orx.
* See orxObject_GetChild()/orxObject_GetSibling() if you want to only consider children objects.
* This function is typically used to iterate over the children of an object.
* For example, iterating over the immediate children cameras:
* @code
* for(orxCAMERA *pstChild = orxCAMERA(orxObject_GetNextChild(pstObject, orxNULL, orxSTRUCTURE_ID_CAMERA));
* pstChild != orxNULL;
* pstChild = orxCAMERA(orxObject_GetNextChild(pstObject, pstChild, orxSTRUCTURE_ID_CAMERA)))
* {
* DoSomethingWithCamera(pstChild);
* }
* @endcode
* @param[in] _pstObject Concerned object
* @param[in] _pChild Concerned child to retrieve the next sibling, orxNULL to retrieve the first child
* @param[in] _eStructureID ID of the structure to consider (camera, spawner, object or frame)
* @return Next child/sibling structure (camera, spawner, object or frame) / orxNULL
*/
extern orxDLLAPI orxSTRUCTURE *orxFASTCALL orxObject_GetNextChild(const orxOBJECT *_pstObject, void *_pChild, orxSTRUCTURE_ID _eStructureID);
/** Attaches an object to a parent while maintaining the object's world position.
* @param[in] _pstObject Concerned object
* @param[in] _pParent Parent structure to attach to (object, spawner, camera or frame)
* @return orsSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Attach(orxOBJECT *_pstObject, void *_pParent);
/** Detaches an object from a parent while maintaining the object's world position.
* @param[in] _pstObject Concerned object
* @return orsSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Detach(orxOBJECT *_pstObject);
/** Sets object's ignore flags.
* @param[in] _pstObject Concerned object
* @param[out] _u32IgnoreFlags Ignore flags to set (all other ignore flags will get cleared)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetIgnoreFlags(orxOBJECT *_pstObject, orxU32 _u32IgnoreFlags);
/** Sets object's ignore flags using literals.
* @param[in] _pstObject Concerned object
* @param[out] _zIgnoreFlags Literals of the ignore flags to set (all other ignore flags will get cleared)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetLiteralIgnoreFlags(orxOBJECT *_pstObject, const orxSTRING _zIgnoreFlags);
/** Gets object's ignore flags.
* @param[in] _pstObject Concerned object
* @return Ignore flags
*/
extern orxDLLAPI orxU32 orxFASTCALL orxObject_GetIgnoreFlags(const orxOBJECT *_pstObject);
/** Gets object's ignore flags literals. The result will not persist through other calls to this function or to orxFrame_GetIgnoreFlagNames().
* @param[in] _pstObject Concerned object
* @return Ignore flags literals
*/
extern orxDLLAPI const orxSTRING orxFASTCALL orxObject_GetLiteralIgnoreFlags(const orxOBJECT *_pstObject);
/** Logs all parents of an object, including their frame data.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_LogParents(const orxOBJECT *_pstObject);
/** @} */
/** @name Animation
* @{ */
/** Sets an object animset.
* @param[in] _pstObject Concerned object
* @param[in] _pstAnimSet Animation set to set / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetAnimSet(orxOBJECT *_pstObject, orxANIMSET *_pstAnimSet);
/** Sets an object's relative animation frequency.
* @param[in] _pstObject Concerned object
* @param[in] _fFrequency Frequency to set: < 1.0 for slower than initial, > 1.0 for faster than initial
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetAnimFrequency(orxOBJECT *_pstObject, orxFLOAT _fFrequency);
/** Sets the relative animation frequency for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _fFrequency Frequency to set: < 1.0 for slower than initial, > 1.0 for faster than initial
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetAnimFrequencyRecursive(orxOBJECT *_pstObject, orxFLOAT _fFrequency);
/** Gets an object's relative animation frequency.
* @param[in] _pstObject Concerned object
* @return Animation frequency / -orxFLOAT_1
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetAnimFrequency(const orxOBJECT *_pstObject);
/** Sets an object's animation time.
* @param[in] _pstObject Concerned object
* @param[in] _fTime Time to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetAnimTime(orxOBJECT *_pstObject, orxFLOAT _fTime);
/** Sets the animation time for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _fTime Time to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetAnimTimeRecursive(orxOBJECT *_pstObject, orxFLOAT _fTime);
/** Gets an object's animation time.
* @param[in] _pstObject Concerned object
* @return Animation time / -orxFLOAT_1
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetAnimTime(const orxOBJECT *_pstObject);
/** Sets current animation for an object. This function switches the currently displayed animation of the object
* immediately. Compare this with orxObject_SetTargetAnim().
* @param[in] _pstObject Concerned object
* @param[in] _zAnimName Animation name (config's one) to set / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetCurrentAnim(orxOBJECT *_pstObject, const orxSTRING _zAnimName);
/** Sets current animation for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zAnimName Animation name (config's one) to set / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetCurrentAnimRecursive(orxOBJECT *_pstObject, const orxSTRING _zAnimName);
/** Sets target animation for an object. The animations are sequenced on an object according to the animation link graph
* defined by its AnimationSet. The sequence follows the graph and tries to reach the target animation. Use
* orxObject_SetCurrentAnim() to switch the animation without using the link graph.
* @param[in] _pstObject Concerned object
* @param[in] _zAnimName Animation name (config's one) to set / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetTargetAnim(orxOBJECT *_pstObject, const orxSTRING _zAnimName);
/** Sets target animation for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zAnimName Animation name (config's one) to set / orxNULL
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetTargetAnimRecursive(orxOBJECT *_pstObject, const orxSTRING _zAnimName);
/** Gets current animation.
* @param[in] _pstObject Concerned object
* @return Current animation / orxSTRING_EMPTY
*/
extern orxDLLAPI const orxSTRING orxFASTCALL orxObject_GetCurrentAnim(const orxOBJECT *_pstObject);
/** Gets target animation.
* @param[in] _pstObject Concerned object
* @return Target animation / orxSTRING_EMPTY
*/
extern orxDLLAPI const orxSTRING orxFASTCALL orxObject_GetTargetAnim(const orxOBJECT *_pstObject);
/** Is current animation test.
* @param[in] _pstObject Concerned object
* @param[in] _zAnimName Animation name (config's one) to test
* @return orxTRUE / orxFALSE
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_IsCurrentAnim(const orxOBJECT *_pstObject, const orxSTRING _zAnimName);
/** Is target animation test.
* @param[in] _pstObject Concerned object
* @param[in] _zAnimName Animation name (config's one) to test
* @return orxTRUE / orxFALSE
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_IsTargetAnim(const orxOBJECT *_pstObject, const orxSTRING _zAnimName);
/** @} */
/** @name Physics / Dynamics
* @{ */
/** Sets an object speed.
* @param[in] _pstObject Concerned object
* @param[in] _pvSpeed Speed to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetSpeed(orxOBJECT *_pstObject, const orxVECTOR *_pvSpeed);
/** Sets an object speed relative to its rotation/scale.
* @param[in] _pstObject Concerned object
* @param[in] _pvRelativeSpeed Relative speed to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetRelativeSpeed(orxOBJECT *_pstObject, const orxVECTOR *_pvRelativeSpeed);
/** Sets an object angular velocity.
* @param[in] _pstObject Concerned object
* @param[in] _fVelocity Angular velocity to set (radians/seconds)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetAngularVelocity(orxOBJECT *_pstObject, orxFLOAT _fVelocity);
/** Sets an object custom gravity.
* @param[in] _pstObject Concerned object
* @param[in] _pvCustomGravity Custom gravity to set / orxNULL to remove it
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetCustomGravity(orxOBJECT *_pstObject, const orxVECTOR *_pvCustomGravity);
/** Gets an object speed.
* @param[in] _pstObject Concerned object
* @param[out] _pvSpeed Speed to get
* @return Object speed / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetSpeed(const orxOBJECT *_pstObject, orxVECTOR *_pvSpeed);
/** Gets an object relative speed.
* @param[in] _pstObject Concerned object
* @param[out] _pvRelativeSpeed Relative speed to get
* @return Object relative speed / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetRelativeSpeed(const orxOBJECT *_pstObject, orxVECTOR *_pvRelativeSpeed);
/** Gets an object angular velocity.
* @param[in] _pstObject Concerned object
* @return Object angular velocity (radians/seconds)
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetAngularVelocity(const orxOBJECT *_pstObject);
/** Gets an object custom gravity.
* @param[in] _pstObject Concerned object
* @param[out] _pvCustomGravity Custom gravity to get
* @return Object custom gravity / orxNULL is object doesn't have any
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetCustomGravity(const orxOBJECT *_pstObject, orxVECTOR *_pvCustomGravity);
/** Gets an object mass.
* @param[in] _pstObject Concerned object
* @return Object mass
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetMass(const orxOBJECT *_pstObject);
/** Gets an object center of mass (object space).
* @param[in] _pstObject Concerned object
* @param[out] _pvMassCenter Mass center to get
* @return Mass center / orxNULL
*/
extern orxDLLAPI orxVECTOR *orxFASTCALL orxObject_GetMassCenter(const orxOBJECT *_pstObject, orxVECTOR *_pvMassCenter);
/** Applies a torque.
* @param[in] _pstObject Concerned object
* @param[in] _fTorque Torque to apply
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_ApplyTorque(orxOBJECT *_pstObject, orxFLOAT _fTorque);
/** Applies a force.
* @param[in] _pstObject Concerned object
* @param[in] _pvForce Force to apply
* @param[in] _pvPoint Point (world coordinates) where the force will be applied, if orxNULL, center of mass will be used
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_ApplyForce(orxOBJECT *_pstObject, const orxVECTOR *_pvForce, const orxVECTOR *_pvPoint);
/** Applies an impulse.
* @param[in] _pstObject Concerned object
* @param[in] _pvImpulse Impulse to apply
* @param[in] _pvPoint Point (world coordinates) where the impulse will be applied, if orxNULL, center of mass will be used
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_ApplyImpulse(orxOBJECT *_pstObject, const orxVECTOR *_pvImpulse, const orxVECTOR *_pvPoint);
/** Issues a raycast to test for potential objects in the way.
* @param[in] _pvBegin Beginning of raycast
* @param[in] _pvEnd End of raycast
* @param[in] _u16SelfFlags Selfs flags used for filtering (0xFFFF for no filtering)
* @param[in] _u16CheckMask Check mask used for filtering (0xFFFF for no filtering)
* @param[in] _bEarlyExit Should stop as soon as an object has been hit (which might not be the closest)
* @param[in] _pvContact If non-null and a contact is found it will be stored here
* @param[in] _pvNormal If non-null and a contact is found, its normal will be stored here
* @return Colliding orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_Raycast(const orxVECTOR *_pvBegin, const orxVECTOR *_pvEnd, orxU16 _u16SelfFlags, orxU16 _u16CheckMask, orxBOOL _bEarlyExit, orxVECTOR *_pvContact, orxVECTOR *_pvNormal);
/** @} */
/** @name Text
* @{ */
/** Sets object text string, if object is associated to a text.
* @param[in] _pstObject Concerned object
* @param[in] _zString String to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetTextString(orxOBJECT *_pstObject, const orxSTRING _zString);
/** Gets object text string, if object is associated to a text.
* @param[in] _pstObject Concerned object
* @return orxSTRING / orxSTRING_EMPTY
*/
extern orxDLLAPI const orxSTRING orxFASTCALL orxObject_GetTextString(orxOBJECT *_pstObject);
/** @} */
/** @name Bounding Box
* @{ */
/** Gets object's bounding box (OBB).
* @param[in] _pstObject Concerned object
* @param[out] _pstBoundingBox Bounding box result
* @return Bounding box / orxNULL
*/
extern orxDLLAPI orxOBOX *orxFASTCALL orxObject_GetBoundingBox(const orxOBJECT *_pstObject, orxOBOX *_pstBoundingBox);
/** @} */
/** @name FX
* @{ */
/** Adds an FX using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zFXConfigID Config ID of the FX to add
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_AddFX(orxOBJECT *_pstObject, const orxSTRING _zFXConfigID);
/** Adds an FX to an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zFXConfigID Config ID of the FX to add
* @param[in] _fPropagationDelay Propagation delay for each child
*/
extern orxDLLAPI void orxFASTCALL orxObject_AddFXRecursive(orxOBJECT *_pstObject, const orxSTRING _zFXConfigID, orxFLOAT _fPropagationDelay);
/** Adds a unique FX using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zFXConfigID Config ID of the FX to add
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_AddUniqueFX(orxOBJECT *_pstObject, const orxSTRING _zFXConfigID);
/** Adds a unique FX to an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zFXConfigID Config ID of the FX to add
* @param[in] _fPropagationDelay Propagation delay for each child
*/
extern orxDLLAPI void orxFASTCALL orxObject_AddUniqueFXRecursive(orxOBJECT *_pstObject, const orxSTRING _zFXConfigID, orxFLOAT _fPropagationDelay);
/** Removes an FX using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zFXConfigID Config ID of the FX to remove
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveFX(orxOBJECT *_pstObject, const orxSTRING _zFXConfigID);
/** Removes an FX from an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zFXConfigID Config ID of the FX to remove
*/
extern orxDLLAPI void orxFASTCALL orxObject_RemoveFXRecursive(orxOBJECT *_pstObject, const orxSTRING _zFXConfigID);
/** Removes all FXs.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveAllFXs(orxOBJECT *_pstObject);
/** Removes all FXs from an object and its owned children.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveAllFXsRecursive(orxOBJECT *_pstObject);
/** Sets an object's relative FX frequency.
* @param[in] _pstObject Concerned object
* @param[in] _fFrequency Frequency to set: < 1.0 for slower than initial, > 1.0 for faster than initial
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetFXFrequency(orxOBJECT *_pstObject, orxFLOAT _fFrequency);
/** Sets the relative FX frequency for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _fFrequency Frequency to set: < 1.0 for slower than initial, > 1.0 for faster than initial
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetFXFrequencyRecursive(orxOBJECT *_pstObject, orxFLOAT _fFrequency);
/** Gets an object's relative FX frequency.
* @param[in] _pstObject Concerned object
* @return FX frequency / -orxFLOAT_1
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetFXFrequency(const orxOBJECT *_pstObject);
/** Synchronizes FXs with another object's ones (if FXs are not matching on both objects the behavior is undefined).
* @param[in] _pstObject Concerned object
* @param[in] _pstModel Model object on which to synchronize FXs
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SynchronizeFX(orxOBJECT *_pstObject, const orxOBJECT *_pstModel);
/** @} */
/** @name Sound
* @{ */
/** Adds a sound using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zSoundConfigID Config ID of the sound to add
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_AddSound(orxOBJECT *_pstObject, const orxSTRING _zSoundConfigID);
/** Removes a sound using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zSoundConfigID Config ID of the sound to remove
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveSound(orxOBJECT *_pstObject, const orxSTRING _zSoundConfigID);
/** Gets last added sound (Do *NOT* destroy it directly before removing it!!!).
* @param[in] _pstObject Concerned object
* @return orxSOUND / orxNULL
*/
extern orxDLLAPI orxSOUND *orxFASTCALL orxObject_GetLastAddedSound(const orxOBJECT *_pstObject);
/** Sets volume for all sounds of an object.
* @param[in] _pstObject Concerned object
* @param[in] _fVolume Desired volume (0.0 - 1.0)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetVolume(orxOBJECT *_pstObject, orxFLOAT _fVolume);
/** Sets pitch for all sounds of an object.
* @param[in] _pstObject Concerned object
* @param[in] _fPitch Desired pitch (< 1.0 => lower pitch, = 1.0 => original pitch, > 1.0 => higher pitch). 0.0 is ignored.
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetPitch(orxOBJECT *_pstObject, orxFLOAT _fPitch);
/** Sets panning of all sounds of an object.
* @param[in] _pstObject Concerned object
* @param[in] _fPanning Sound panning, -1.0f for full left, 0.0f for center, 1.0f for full right
* @param[in] _bMix Left/Right channels will be mixed if orxTRUE or act like a balance otherwise
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetPanning(orxOBJECT *_pstObject, orxFLOAT _fPanning, orxBOOL _bMix);
/** Plays all the sounds of an object.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Play(orxOBJECT *_pstObject);
/** Stops all the sounds of an object.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_Stop(orxOBJECT *_pstObject);
/** Adds a filter to the sounds of an object (cascading).
* @param[in] _pstObject Concerned object
* @param[in] _zFilterConfigID Config ID of the filter to add
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_AddFilter(orxOBJECT *_pstObject, const orxSTRING _zFilterConfigID);
/** Removes last added filter from the sounds of an object.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveLastFilter(orxOBJECT *_pstObject);
/** Removes all filters from the sounds of an object.
* @param[in] _pstObject Concerned object
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveAllFilters(orxOBJECT *_pstObject);
/** @} */
/** @name Shader
* @{ */
/** Adds a shader to an object using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zShaderConfigID Config ID of the shader to add
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_AddShader(orxOBJECT *_pstObject, const orxSTRING _zShaderConfigID);
/** Adds a shader to an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zShaderConfigID Config ID of the shader to add
*/
extern orxDLLAPI void orxFASTCALL orxObject_AddShaderRecursive(orxOBJECT *_pstObject, const orxSTRING _zShaderConfigID);
/** Removes a shader using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zShaderConfigID Config ID of the shader to remove
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveShader(orxOBJECT *_pstObject, const orxSTRING _zShaderConfigID);
/** Removes a shader from an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zShaderConfigID Config ID of the shader to remove
*/
extern orxDLLAPI void orxFASTCALL orxObject_RemoveShaderRecursive(orxOBJECT *_pstObject, const orxSTRING _zShaderConfigID);
/** Enables an object's shader.
* @param[in] _pstObject Concerned object
* @param[in] _bEnable Enable / disable
*/
extern orxDLLAPI void orxFASTCALL orxObject_EnableShader(orxOBJECT *_pstObject, orxBOOL _bEnable);
/** Is an object's shader enabled?
* @param[in] _pstObject Concerned object
* @return orxTRUE if enabled, orxFALSE otherwise
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_IsShaderEnabled(const orxOBJECT *_pstObject);
/** @} */
/** @name TimeLine
* @{ */
/** Adds a timeline track to an object using its config ID.
* @param[in] _pstObject Concerned object
* @param[in] _zTrackConfigID Config ID of the timeline track to add
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_AddTimeLineTrack(orxOBJECT *_pstObject, const orxSTRING _zTrackConfigID);
/** Adds a timeline track to an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zTrackConfigID Config ID of the timeline track to add
*/
extern orxDLLAPI void orxFASTCALL orxObject_AddTimeLineTrackRecursive(orxOBJECT *_pstObject, const orxSTRING _zTrackConfigID);
/** Removes a timeline track using its config ID
* @param[in] _pstObject Concerned object
* @param[in] _zTrackConfigID Config ID of the timeline track to remove
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_RemoveTimeLineTrack(orxOBJECT *_pstObject, const orxSTRING _zTrackConfigID);
/** Removes a timeline track from an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _zTrackConfigID Config ID of the timeline track to remove
*/
extern orxDLLAPI void orxFASTCALL orxObject_RemoveTimeLineTrackRecursive(orxOBJECT *_pstObject, const orxSTRING _zTrackConfigID);
/** Enables an object's timeline.
* @param[in] _pstObject Concerned object
* @param[in] _bEnable Enable / disable
*/
extern orxDLLAPI void orxFASTCALL orxObject_EnableTimeLine(orxOBJECT *_pstObject, orxBOOL _bEnable);
/** Is an object's timeline enabled?
* @param[in] _pstObject Concerned object
* @return orxTRUE if enabled, orxFALSE otherwise
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_IsTimeLineEnabled(const orxOBJECT *_pstObject);
/** @} */
/** @name Name
* @{ */
/** Gets object config name.
* @param[in] _pstObject Concerned object
* @return orxSTRING / orxSTRING_EMPTY
*/
extern orxDLLAPI const orxSTRING orxFASTCALL orxObject_GetName(const orxOBJECT *_pstObject);
/** @} */
/** @name Neighboring
* @{ */
/** Creates a list of object at neighboring of the given box (ie. whose bounding volume intersects this box).
* The following is an example for iterating over a neighbor list:
* @code
* orxVECTOR vPosition; // The world position of the neighborhood area
* // set_position(vPosition);
* orxVECTOR vSize; // The size of the neighborhood area
* // set_size(vSize);
* orxVECTOR vPivot; // The pivot of the neighborhood area
* // set_pivot(vPivot);
*
* orxOBOX stBox;
* orxOBox_2DSet(&stBox, &vPosition, &vPivot, &vSize, 0);
*
* orxBANK * pstBank = orxObject_CreateNeighborList(&stBox, orxSTRINGID_UNDEFINED);
* if(pstBank) {
* for(int i=0; i < orxBank_GetCount(pstBank); ++i)
* {
* orxOBJECT * pstObject = *((orxOBJECT **) orxBank_GetAtIndex(pstBank, i));
* do_something_with(pstObject);
* }
* orxObject_DeleteNeighborList(pstBank);
* }
* @endcode
* @param[in] _pstCheckBox Box to check intersection with
* @param[in] _stGroupID Group ID to consider, orxSTRINGID_UNDEFINED for all
* @return orxBANK / orxNULL
*/
extern orxDLLAPI orxBANK *orxFASTCALL orxObject_CreateNeighborList(const orxOBOX *_pstCheckBox, orxSTRINGID _stGroupID);
/** Deletes an object list created with orxObject_CreateNeighborList().
* @param[in] _pstObjectList Concerned object list
*/
extern orxDLLAPI void orxFASTCALL orxObject_DeleteNeighborList(orxBANK *_pstObjectList);
/** @} */
/** @name Smoothing
* @{ */
/** Sets object smoothing.
* @param[in] _pstObject Concerned object
* @param[in] _eSmoothing Smoothing type (enabled, default or none)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetSmoothing(orxOBJECT *_pstObject, orxDISPLAY_SMOOTHING _eSmoothing);
/** Sets smoothing for an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _eSmoothing Smoothing type (enabled, default or none)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetSmoothingRecursive(orxOBJECT *_pstObject, orxDISPLAY_SMOOTHING _eSmoothing);
/** Gets object smoothing.
* @param[in] _pstObject Concerned object
* @return Smoothing type (enabled, default or none)
*/
extern orxDLLAPI orxDISPLAY_SMOOTHING orxFASTCALL orxObject_GetSmoothing(const orxOBJECT *_pstObject);
/** @} */
/** @name Texture
* @{ */
/** Gets object working texture.
* @param[in] _pstObject Concerned object
* @return orxTEXTURE / orxNULL
*/
extern orxDLLAPI orxTEXTURE *orxFASTCALL orxObject_GetWorkingTexture(const orxOBJECT *_pstObject);
/** @} */
/** @name Graphic
* @{ */
/** Gets object working graphic.
* @param[in] _pstObject Concerned object
* @return orxGRAPHIC / orxNULL
*/
extern orxDLLAPI orxGRAPHIC *orxFASTCALL orxObject_GetWorkingGraphic(const orxOBJECT *_pstObject);
/** Sets object color.
* @param[in] _pstObject Concerned object
* @param[in] _pstColor Color to set, orxNULL to remove any specific color
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetColor(orxOBJECT *_pstObject, const orxCOLOR *_pstColor);
/** Sets color of an object and all its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _pstColor Color to set, orxNULL to remove any specific color
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetColorRecursive(orxOBJECT *_pstObject, const orxCOLOR *_pstColor);
/** Object has color accessor?
* @param[in] _pstObject Concerned object
* @return orxTRUE / orxFALSE
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_HasColor(const orxOBJECT *_pstObject);
/** Gets object color.
* @param[in] _pstObject Concerned object
* @param[out] _pstColor Object's color
* @return orxCOLOR / orxNULL
*/
extern orxDLLAPI orxCOLOR *orxFASTCALL orxObject_GetColor(const orxOBJECT *_pstObject, orxCOLOR *_pstColor);
/** Sets object RGB values.
* @param[in] _pstObject Concerned object
* @param[in] _pvRGB RGB values to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetRGB(orxOBJECT *_pstObject, const orxVECTOR *_pvRGB);
/** Sets color of an object and all its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _pvRGB RGB values to set
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetRGBRecursive(orxOBJECT *_pstObject, const orxVECTOR *_pvRGB);
/** Sets object alpha.
* @param[in] _pstObject Concerned object
* @param[in] _fAlpha Alpha value to set
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetAlpha(orxOBJECT *_pstObject, orxFLOAT _fAlpha);
/** Sets alpha of an object and all its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _fAlpha Alpha value to set
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetAlphaRecursive(orxOBJECT *_pstObject, orxFLOAT _fAlpha);
/** Sets object repeat (wrap) values.
* @param[in] _pstObject Concerned object
* @param[in] _fRepeatX X-axis repeat value
* @param[in] _fRepeatY Y-axis repeat value
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetRepeat(orxOBJECT *_pstObject, orxFLOAT _fRepeatX, orxFLOAT _fRepeatY);
/** Gets object repeat (wrap) values.
* @param[in] _pstObject Concerned object
* @param[out] _pfRepeatX X-axis repeat value
* @param[out] _pfRepeatY Y-axis repeat value
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_GetRepeat(const orxOBJECT *_pstObject, orxFLOAT *_pfRepeatX, orxFLOAT *_pfRepeatY);
/** Sets object blend mode.
* @param[in] _pstObject Concerned object
* @param[in] _eBlendMode Blend mode (alpha, multiply, add or none)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetBlendMode(orxOBJECT *_pstObject, orxDISPLAY_BLEND_MODE _eBlendMode);
/** Sets blend mode of an object and its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _eBlendMode Blend mode (alpha, multiply, add or none)
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetBlendModeRecursive(orxOBJECT *_pstObject, orxDISPLAY_BLEND_MODE _eBlendMode);
/** Object has blend mode accessor?
* @param[in] _pstObject Concerned object
* @return orxTRUE / orxFALSE
*/
extern orxDLLAPI orxBOOL orxFASTCALL orxObject_HasBlendMode(const orxOBJECT *_pstObject);
/** Gets object blend mode.
* @param[in] _pstObject Concerned object
* @return Blend mode (alpha, multiply, add or none)
*/
extern orxDLLAPI orxDISPLAY_BLEND_MODE orxFASTCALL orxObject_GetBlendMode(const orxOBJECT *_pstObject);
/** @} */
/** @name Life time / Active time
* @{ */
/** Sets object literal lifetime.
* @param[in] _pstObject Concerned object
* @param[in] _zLifeTime Lifetime to set, can be composed of multiple tags, separated by space: anim, child, fx, sound, spawner and track
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetLiteralLifeTime(orxOBJECT *_pstObject, const orxSTRING _zLifeTime);
/** Sets object lifetime.
* @param[in] _pstObject Concerned object
* @param[in] _fLifeTime Lifetime to set, negative value to disable it
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetLifeTime(orxOBJECT *_pstObject, orxFLOAT _fLifeTime);
/** Gets object lifetime.
* @param[in] _pstObject Concerned object
* @return Lifetime / negative value if none
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetLifeTime(const orxOBJECT *_pstObject);
/** Gets object active time, i.e. the amount of time that the object has been alive taking into account
* the object's clock multiplier and object's periods of pause.
* @param[in] _pstObject Concerned object
* @return Active time
*/
extern orxDLLAPI orxFLOAT orxFASTCALL orxObject_GetActiveTime(const orxOBJECT *_pstObject);
/** @} */
/** @name Group
* @{ */
/** Gets default group ID.
* @return Default group ID
*/
extern orxDLLAPI orxSTRINGID orxFASTCALL orxObject_GetDefaultGroupID();
/** Gets object's group ID.
* @param[in] _pstObject Concerned object
* @return Object's group ID. This is the string ID (see orxString_GetFromID()) of the object's group name.
*/
extern orxDLLAPI orxSTRINGID orxFASTCALL orxObject_GetGroupID(const orxOBJECT *_pstObject);
/** Sets object's group ID.
* @param[in] _pstObject Concerned object
* @param[in] _stGroupID Group ID to set. This is the string ID (see orxString_GetID()) of the object's group name.
* @return orxSTATUS_SUCCESS / orxSTATUS_FAILURE
*/
extern orxDLLAPI orxSTATUS orxFASTCALL orxObject_SetGroupID(orxOBJECT *_pstObject, orxSTRINGID _stGroupID);
/** Sets group ID of an object and all its owned children.
* @param[in] _pstObject Concerned object
* @param[in] _stGroupID Group ID to set. This is the string ID (see orxString_GetID()) of the object's group name.
*/
extern orxDLLAPI void orxFASTCALL orxObject_SetGroupIDRecursive(orxOBJECT *_pstObject, orxSTRINGID _stGroupID);
/** Gets next object in group.
* @param[in] _pstObject Concerned object, orxNULL to get the first one
* @param[in] _stGroupID Group ID to consider, orxSTRINGID_UNDEFINED for all
* @return orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_GetNext(const orxOBJECT *_pstObject, orxSTRINGID _stGroupID);
/** Gets next enabled object.
* @param[in] _pstObject Concerned object, orxNULL to get the first one
* @param[in] _stGroupID Group ID to consider, orxSTRINGID_UNDEFINED for all
* @return orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_GetNextEnabled(const orxOBJECT *_pstObject, orxSTRINGID _stGroupID);
/** @} */
/** @name Picking
* @{ */
/** Picks the first active object with size "under" the given position, within a given group. See
* orxObject_BoxPick(), orxObject_CreateNeighborList() and orxObject_Raycast for other ways of picking
* objects.
* @param[in] _pvPosition Position to pick from
* @param[in] _stGroupID Group ID to consider, orxSTRINGID_UNDEFINED for all
* @return orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_Pick(const orxVECTOR *_pvPosition, orxSTRINGID _stGroupID);
/** Picks the first active object with size in contact with the given box, withing a given group. Use
* orxObject_CreateNeighborList() to get all the objects in the box.
* @param[in] _pstBox Box to use for picking
* @param[in] _stGroupID Group ID to consider, orxSTRINGID_UNDEFINED for all
* @return orxOBJECT / orxNULL
*/
extern orxDLLAPI orxOBJECT *orxFASTCALL orxObject_BoxPick(const orxOBOX *_pstBox, orxSTRINGID _stGroupID);
/** @} */
#endif /* _orxOBJECT_H_ */
/** @} */
|
eca0fa638febdce033d8dc70a375af36bc58c91c
|
fe2c2c0b23fa5dcdfbdf53261c49aabde5760819
|
/utils/xcvr_gthe3.h
|
0a1ba2b2561ef72f04f1673b9c2a5557156b1681
|
[
"BSD-2-Clause-Views",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
corundum/corundum
|
fde50818fa2ea64ee311db22cecb1da578760a03
|
ed4a26e2cbc0a429c45d5cd5ddf1177f86838914
|
refs/heads/master
| 2023-08-11T02:37:40.480657
| 2023-07-14T01:45:01
| 2023-07-14T01:45:01
| 197,059,490
| 828
| 194
|
NOASSERTION
| 2023-07-07T07:30:53
| 2019-07-15T19:27:33
|
Verilog
|
UTF-8
|
C
| false
| false
| 29,636
|
h
|
xcvr_gthe3.h
|
// SPDX-License-Identifier: BSD-2-Clause-Views
/*
* Copyright (c) 2022-2023 The Regents of the University of California
*/
#ifndef XCVR_GTHE3_H
#define XCVR_GTHE3_H
#include "xcvr_gt.h"
#include "gt/gthe3_regs.h"
// signals
#define GTHE3_COM_QPLL0_RESET_ADDR 0x10000
#define GTHE3_COM_QPLL0_RESET_MSB 0
#define GTHE3_COM_QPLL0_RESET_LSB 0
#define GTHE3_COM_QPLL0_RESET_MASK BIT_MASK(GTHE3_COM_QPLL0_RESET_MSB, GTHE3_COM_QPLL0_RESET_LSB)
#define GTHE3_COM_QPLL0_LOCK_ADDR 0x10000
#define GTHE3_COM_QPLL0_LOCK_MSB 8
#define GTHE3_COM_QPLL0_LOCK_LSB 8
#define GTHE3_COM_QPLL0_LOCK_MASK BIT_MASK(GTHE3_COM_QPLL0_LOCK_MSB, GTHE3_COM_QPLL0_LOCK_LSB)
#define GTHE3_COM_QPLL0_PD_ADDR 0x10001
#define GTHE3_COM_QPLL0_PD_MSB 0
#define GTHE3_COM_QPLL0_PD_LSB 0
#define GTHE3_COM_QPLL0_PD_MASK BIT_MASK(GTHE3_COM_QPLL0_PD_MSB, GTHE3_COM_QPLL0_PD_LSB)
#define GTHE3_COM_QPLL1_RESET_ADDR 0x11000
#define GTHE3_COM_QPLL1_RESET_MSB 0
#define GTHE3_COM_QPLL1_RESET_LSB 0
#define GTHE3_COM_QPLL1_RESET_MASK BIT_MASK(GTHE3_COM_QPLL0_RESET_MSB, GTHE3_COM_QPLL0_RESET_LSB)
#define GTHE3_COM_QPLL1_LOCK_ADDR 0x11000
#define GTHE3_COM_QPLL1_LOCK_MSB 8
#define GTHE3_COM_QPLL1_LOCK_LSB 8
#define GTHE3_COM_QPLL1_LOCK_MASK BIT_MASK(GTHE3_COM_QPLL0_LOCK_MSB, GTHE3_COM_QPLL0_LOCK_LSB)
#define GTHE3_COM_QPLL1_PD_ADDR 0x11001
#define GTHE3_COM_QPLL1_PD_MSB 0
#define GTHE3_COM_QPLL1_PD_LSB 0
#define GTHE3_COM_QPLL1_PD_MASK BIT_MASK(GTHE3_COM_QPLL1_PD_MSB, GTHE3_COM_QPLL1_PD_LSB)
#define GTHE3_CH_TX_RESET_ADDR 0x10000
#define GTHE3_CH_TX_RESET_MSB 0
#define GTHE3_CH_TX_RESET_LSB 0
#define GTHE3_CH_TX_RESET_MASK BIT_MASK(GTHE3_CH_TX_RESET_MSB, GTHE3_CH_TX_RESET_LSB)
#define GTHE3_CH_TX_PMA_RESET_ADDR 0x10000
#define GTHE3_CH_TX_PMA_RESET_MSB 1
#define GTHE3_CH_TX_PMA_RESET_LSB 1
#define GTHE3_CH_TX_PMA_RESET_MASK BIT_MASK(GTHE3_CH_TX_PMA_RESET_MSB, GTHE3_CH_TX_PMA_RESET_LSB)
#define GTHE3_CH_TX_PCS_RESET_ADDR 0x10000
#define GTHE3_CH_TX_PCS_RESET_MSB 2
#define GTHE3_CH_TX_PCS_RESET_LSB 2
#define GTHE3_CH_TX_PCS_RESET_MASK BIT_MASK(GTHE3_CH_TX_PCS_RESET_MSB, GTHE3_CH_TX_PCS_RESET_LSB)
#define GTHE3_CH_TX_RESET_DONE_ADDR 0x10000
#define GTHE3_CH_TX_RESET_DONE_MSB 8
#define GTHE3_CH_TX_RESET_DONE_LSB 8
#define GTHE3_CH_TX_RESET_DONE_MASK BIT_MASK(GTHE3_CH_TX_RESET_DONE_MSB, GTHE3_CH_TX_RESET_DONE_LSB)
#define GTHE3_CH_TX_GT_RESET_DONE_ADDR 0x10000
#define GTHE3_CH_TX_GT_RESET_DONE_MSB 9
#define GTHE3_CH_TX_GT_RESET_DONE_LSB 9
#define GTHE3_CH_TX_GT_RESET_DONE_MASK BIT_MASK(GTHE3_CH_TX_GT_RESET_DONE_MSB, GTHE3_CH_TX_GT_RESET_DONE_LSB)
#define GTHE3_CH_TX_PMA_RESET_DONE_ADDR 0x10000
#define GTHE3_CH_TX_PMA_RESET_DONE_MSB 10
#define GTHE3_CH_TX_PMA_RESET_DONE_LSB 10
#define GTHE3_CH_TX_PMA_RESET_DONE_MASK BIT_MASK(GTHE3_CH_TX_PMA_RESET_DONE_MSB, GTHE3_CH_TX_PMA_RESET_DONE_LSB)
#define GTHE3_CH_TX_PRGDIV_RESET_DONE_ADDR 0x10000
#define GTHE3_CH_TX_PRGDIV_RESET_DONE_MSB 11
#define GTHE3_CH_TX_PRGDIV_RESET_DONE_LSB 11
#define GTHE3_CH_TX_PRGDIV_RESET_DONE_MASK BIT_MASK(GTHE3_CH_TX_PRGDIV_RESET_DONE_MSB, GTHE3_CH_TX_PRGDIV_RESET_DONE_LSB)
#define GTHE3_CH_TX_USRCLK_ACT_ADDR 0x10000
#define GTHE3_CH_TX_USRCLK_ACT_MSB 12
#define GTHE3_CH_TX_USRCLK_ACT_LSB 12
#define GTHE3_CH_TX_USRCLK_ACT_MASK BIT_MASK(GTHE3_CH_TX_USRCLK_ACT_MSB, GTHE3_CH_TX_USRCLK_ACT_LSB)
#define GTHE3_CH_TX_PD_ADDR 0x10001
#define GTHE3_CH_TX_PD_MSB 0
#define GTHE3_CH_TX_PD_LSB 0
#define GTHE3_CH_TX_PD_MASK BIT_MASK(GTHE3_CH_TX_PD_MSB, GTHE3_CH_TX_PD_LSB)
#define GTHE3_CH_TX_QPLL_SEL_ADDR 0x10001
#define GTHE3_CH_TX_QPLL_SEL_MSB 1
#define GTHE3_CH_TX_QPLL_SEL_LSB 1
#define GTHE3_CH_TX_QPLL_SEL_MASK BIT_MASK(GTHE3_CH_TX_QPLL_SEL_MSB, GTHE3_CH_TX_QPLL_SEL_LSB)
#define GTHE3_CH_TX_POLARITY_ADDR 0x10010
#define GTHE3_CH_TX_POLARITY_MSB 0
#define GTHE3_CH_TX_POLARITY_LSB 0
#define GTHE3_CH_TX_POLARITY_MASK BIT_MASK(GTHE3_CH_TX_POLARITY_MSB, GTHE3_CH_TX_POLARITY_LSB)
#define GTHE3_CH_TX_ELECIDLE_ADDR 0x10010
#define GTHE3_CH_TX_ELECIDLE_MSB 1
#define GTHE3_CH_TX_ELECIDLE_LSB 1
#define GTHE3_CH_TX_ELECIDLE_MASK BIT_MASK(GTHE3_CH_TX_ELECIDLE_MSB, GTHE3_CH_TX_ELECIDLE_LSB)
#define GTHE3_CH_TX_INHIBIT_ADDR 0x10010
#define GTHE3_CH_TX_INHIBIT_MSB 2
#define GTHE3_CH_TX_INHIBIT_LSB 2
#define GTHE3_CH_TX_INHIBIT_MASK BIT_MASK(GTHE3_CH_TX_INHIBIT_MSB, GTHE3_CH_TX_INHIBIT_LSB)
#define GTHE3_CH_TX_DIFFCTRL_ADDR 0x10011
#define GTHE3_CH_TX_DIFFCTRL_MSB 4
#define GTHE3_CH_TX_DIFFCTRL_LSB 0
#define GTHE3_CH_TX_DIFFCTRL_MASK BIT_MASK(GTHE3_CH_TX_DIFFCTRL_MSB, GTHE3_CH_TX_DIFFCTRL_LSB)
#define GTHE3_CH_TX_MAINCURSOR_ADDR 0x10012
#define GTHE3_CH_TX_MAINCURSOR_MSB 6
#define GTHE3_CH_TX_MAINCURSOR_LSB 0
#define GTHE3_CH_TX_MAINCURSOR_MASK BIT_MASK(GTHE3_CH_TX_MAINCURSOR_MSB, GTHE3_CH_TX_MAINCURSOR_LSB)
#define GTHE3_CH_TX_PRECURSOR_ADDR 0x10013
#define GTHE3_CH_TX_PRECURSOR_MSB 4
#define GTHE3_CH_TX_PRECURSOR_LSB 0
#define GTHE3_CH_TX_PRECURSOR_MASK BIT_MASK(GTHE3_CH_TX_PRECURSOR_MSB, GTHE3_CH_TX_PRECURSOR_LSB)
#define GTHE3_CH_TX_POSTCURSOR_ADDR 0x10014
#define GTHE3_CH_TX_POSTCURSOR_MSB 4
#define GTHE3_CH_TX_POSTCURSOR_LSB 0
#define GTHE3_CH_TX_POSTCURSOR_MASK BIT_MASK(GTHE3_CH_TX_POSTCURSOR_MSB, GTHE3_CH_TX_POSTCURSOR_LSB)
#define GTHE3_CH_TX_PRBS_SEL_ADDR 0x10040
#define GTHE3_CH_TX_PRBS_SEL_MSB 3
#define GTHE3_CH_TX_PRBS_SEL_LSB 0
#define GTHE3_CH_TX_PRBS_SEL_MASK BIT_MASK(GTHE3_CH_TX_PRBS_SEL_MSB, GTHE3_CH_TX_PRBS_SEL_LSB)
#define GTHE3_CH_TX_PRBS_FORCERR_ADDR 0x10040
#define GTHE3_CH_TX_PRBS_FORCERR_MSB 15
#define GTHE3_CH_TX_PRBS_FORCERR_LSB 0
#define GTHE3_CH_TX_PRBS_FORCERR_MASK BIT_MASK(GTHE3_CH_TX_PRBS_FORCERR_MSB, GTHE3_CH_TX_PRBS_FORCERR_LSB)
#define GTHE3_CH_RX_RESET_ADDR 0x11000
#define GTHE3_CH_RX_RESET_MSB 0
#define GTHE3_CH_RX_RESET_LSB 0
#define GTHE3_CH_RX_RESET_MASK BIT_MASK(GTHE3_CH_RX_RESET_MSB, GTHE3_CH_RX_RESET_LSB)
#define GTHE3_CH_RX_PMA_RESET_ADDR 0x11000
#define GTHE3_CH_RX_PMA_RESET_MSB 1
#define GTHE3_CH_RX_PMA_RESET_LSB 1
#define GTHE3_CH_RX_PMA_RESET_MASK BIT_MASK(GTHE3_CH_RX_PMA_RESET_MSB, GTHE3_CH_RX_PMA_RESET_LSB)
#define GTHE3_CH_RX_PCS_RESET_ADDR 0x11000
#define GTHE3_CH_RX_PCS_RESET_MSB 2
#define GTHE3_CH_RX_PCS_RESET_LSB 2
#define GTHE3_CH_RX_PCS_RESET_MASK BIT_MASK(GTHE3_CH_RX_PCS_RESET_MSB, GTHE3_CH_RX_PCS_RESET_LSB)
#define GTHE3_CH_RX_DFE_LPM_RESET_ADDR 0x11000
#define GTHE3_CH_RX_DFE_LPM_RESET_MSB 3
#define GTHE3_CH_RX_DFE_LPM_RESET_LSB 3
#define GTHE3_CH_RX_DFE_LPM_RESET_MASK BIT_MASK(GTHE3_CH_RX_DFE_LPM_RESET_MSB, GTHE3_CH_RX_DFE_LPM_RESET_LSB)
#define GTHE3_CH_EYESCAN_RESET_ADDR 0x11000
#define GTHE3_CH_EYESCAN_RESET_MSB 4
#define GTHE3_CH_EYESCAN_RESET_LSB 4
#define GTHE3_CH_EYESCAN_RESET_MASK BIT_MASK(GTHE3_CH_EYESCAN_RESET_MSB, GTHE3_CH_EYESCAN_RESET_LSB)
#define GTHE3_CH_RX_RESET_DONE_ADDR 0x11000
#define GTHE3_CH_RX_RESET_DONE_MSB 8
#define GTHE3_CH_RX_RESET_DONE_LSB 8
#define GTHE3_CH_RX_RESET_DONE_MASK BIT_MASK(GTHE3_CH_RX_RESET_DONE_MSB, GTHE3_CH_RX_RESET_DONE_LSB)
#define GTHE3_CH_RX_GT_RESET_DONE_ADDR 0x11000
#define GTHE3_CH_RX_GT_RESET_DONE_MSB 9
#define GTHE3_CH_RX_GT_RESET_DONE_LSB 9
#define GTHE3_CH_RX_GT_RESET_DONE_MASK BIT_MASK(GTHE3_CH_RX_GT_RESET_DONE_MSB, GTHE3_CH_RX_GT_RESET_DONE_LSB)
#define GTHE3_CH_RX_PMA_RESET_DONE_ADDR 0x11000
#define GTHE3_CH_RX_PMA_RESET_DONE_MSB 10
#define GTHE3_CH_RX_PMA_RESET_DONE_LSB 10
#define GTHE3_CH_RX_PMA_RESET_DONE_MASK BIT_MASK(GTHE3_CH_RX_PMA_RESET_DONE_MSB, GTHE3_CH_RX_PMA_RESET_DONE_LSB)
#define GTHE3_CH_RX_PRGDIV_RESET_DONE_ADDR 0x11000
#define GTHE3_CH_RX_PRGDIV_RESET_DONE_MSB 11
#define GTHE3_CH_RX_PRGDIV_RESET_DONE_LSB 11
#define GTHE3_CH_RX_PRGDIV_RESET_DONE_MASK BIT_MASK(GTHE3_CH_RX_PRGDIV_RESET_DONE_MSB, GTHE3_CH_RX_PRGDIV_RESET_DONE_LSB)
#define GTHE3_CH_RX_USRCLK_ACT_ADDR 0x11000
#define GTHE3_CH_RX_USRCLK_ACT_MSB 12
#define GTHE3_CH_RX_USRCLK_ACT_LSB 12
#define GTHE3_CH_RX_USRCLK_ACT_MASK BIT_MASK(GTHE3_CH_RX_USRCLK_ACT_MSB, GTHE3_CH_RX_USRCLK_ACT_LSB)
#define GTHE3_CH_RX_PD_ADDR 0x11001
#define GTHE3_CH_RX_PD_MSB 0
#define GTHE3_CH_RX_PD_LSB 0
#define GTHE3_CH_RX_PD_MASK BIT_MASK(GTHE3_CH_RX_PD_MSB, GTHE3_CH_RX_PD_LSB)
#define GTHE3_CH_RX_QPLL_SEL_ADDR 0x11001
#define GTHE3_CH_RX_QPLL_SEL_MSB 1
#define GTHE3_CH_RX_QPLL_SEL_LSB 1
#define GTHE3_CH_RX_QPLL_SEL_MASK BIT_MASK(GTHE3_CH_RX_QPLL_SEL_MSB, GTHE3_CH_RX_QPLL_SEL_LSB)
#define GTHE3_CH_LOOPBACK_ADDR 0x11002
#define GTHE3_CH_LOOPBACK_MSB 2
#define GTHE3_CH_LOOPBACK_LSB 0
#define GTHE3_CH_LOOPBACK_MASK BIT_MASK(GTHE3_CH_LOOPBACK_MSB, GTHE3_CH_LOOPBACK_LSB)
#define GTHE3_CH_RX_POLARITY_ADDR 0x11010
#define GTHE3_CH_RX_POLARITY_MSB 0
#define GTHE3_CH_RX_POLARITY_LSB 0
#define GTHE3_CH_RX_POLARITY_MASK BIT_MASK(GTHE3_CH_RX_POLARITY_MSB, GTHE3_CH_RX_POLARITY_LSB)
#define GTHE3_CH_RX_CDR_HOLD_ADDR 0x11020
#define GTHE3_CH_RX_CDR_HOLD_MSB 0
#define GTHE3_CH_RX_CDR_HOLD_LSB 0
#define GTHE3_CH_RX_CDR_HOLD_MASK BIT_MASK(GTHE3_CH_RX_CDR_HOLD_MSB, GTHE3_CH_RX_CDR_HOLD_LSB)
#define GTHE3_CH_RX_CDR_LOCK_ADDR 0x11020
#define GTHE3_CH_RX_CDR_LOCK_MSB 8
#define GTHE3_CH_RX_CDR_LOCK_LSB 8
#define GTHE3_CH_RX_CDR_LOCK_MASK BIT_MASK(GTHE3_CH_RX_CDR_LOCK_MSB, GTHE3_CH_RX_CDR_LOCK_LSB)
#define GTHE3_CH_RX_LPM_EN_ADDR 0x11024
#define GTHE3_CH_RX_LPM_EN_MSB 0
#define GTHE3_CH_RX_LPM_EN_LSB 0
#define GTHE3_CH_RX_LPM_EN_MASK BIT_MASK(GTHE3_CH_RX_LPM_EN_MSB, GTHE3_CH_RX_LPM_EN_LSB)
#define GTHE3_CH_RX_DMONITOR_ADDR 0x11028
#define GTHE3_CH_RX_DMONITOR_MSB 7
#define GTHE3_CH_RX_DMONITOR_LSB 0
#define GTHE3_CH_RX_DMONITOR_MASK BIT_MASK(GTHE3_CH_RX_DMONITOR_MSB, GTHE3_CH_RX_DMONITOR_LSB)
#define GTHE3_CH_RX_PRBS_SEL_ADDR 0x11040
#define GTHE3_CH_RX_PRBS_SEL_MSB 3
#define GTHE3_CH_RX_PRBS_SEL_LSB 0
#define GTHE3_CH_RX_PRBS_SEL_MASK BIT_MASK(GTHE3_CH_RX_PRBS_SEL_MSB, GTHE3_CH_RX_PRBS_SEL_LSB)
#define GTHE3_CH_RX_PRBS_CNT_RESET_ADDR 0x11041
#define GTHE3_CH_RX_PRBS_CNT_RESET_MSB 0
#define GTHE3_CH_RX_PRBS_CNT_RESET_LSB 0
#define GTHE3_CH_RX_PRBS_CNT_RESET_MASK BIT_MASK(GTHE3_CH_RX_PRBS_CNT_RESET_MSB, GTHE3_CH_RX_PRBS_CNT_RESET_LSB)
#define GTHE3_CH_RX_PRBS_LOCKED_ADDR 0x11041
#define GTHE3_CH_RX_PRBS_LOCKED_MSB 8
#define GTHE3_CH_RX_PRBS_LOCKED_LSB 8
#define GTHE3_CH_RX_PRBS_LOCKED_MASK BIT_MASK(GTHE3_CH_RX_PRBS_LOCKED_MSB, GTHE3_CH_RX_PRBS_LOCKED_LSB)
#define GTHE3_CH_RX_PRBS_ERROR_ADDR 0x11041
#define GTHE3_CH_RX_PRBS_ERROR_MSB 9
#define GTHE3_CH_RX_PRBS_ERROR_LSB 9
#define GTHE3_CH_RX_PRBS_ERROR_MASK BIT_MASK(GTHE3_CH_RX_PRBS_ERROR_MSB, GTHE3_CH_RX_PRBS_ERROR_LSB)
def_gt_pll_masked_reg_rw16(gthe3, qpll0_reset, GTHE3_COM_QPLL0_RESET_ADDR, GTHE3_COM_QPLL0_RESET_MASK, GTHE3_COM_QPLL0_RESET_LSB);
int gthe3_pll_qpll0_reset(struct gt_pll *pll);
def_gt_pll_masked_reg_read16(gthe3, qpll0_lock, GTHE3_COM_QPLL0_LOCK_ADDR, GTHE3_COM_QPLL0_LOCK_MASK, GTHE3_COM_QPLL0_LOCK_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_pd, GTHE3_COM_QPLL0_PD_ADDR, GTHE3_COM_QPLL0_PD_MASK, GTHE3_COM_QPLL0_PD_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_reset, GTHE3_COM_QPLL1_RESET_ADDR, GTHE3_COM_QPLL1_RESET_MASK, GTHE3_COM_QPLL1_RESET_LSB);
int gthe3_pll_qpll1_reset(struct gt_pll *pll);
def_gt_pll_masked_reg_read16(gthe3, qpll1_lock, GTHE3_COM_QPLL1_LOCK_ADDR, GTHE3_COM_QPLL1_LOCK_MASK, GTHE3_COM_QPLL1_LOCK_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_pd, GTHE3_COM_QPLL1_PD_ADDR, GTHE3_COM_QPLL1_PD_MASK, GTHE3_COM_QPLL1_PD_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_reset, GTHE3_CH_TX_RESET_ADDR, GTHE3_CH_TX_RESET_MASK, GTHE3_CH_TX_RESET_LSB);
int gthe3_ch_tx_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_rw16(gthe3, tx_pma_reset, GTHE3_CH_TX_PMA_RESET_ADDR, GTHE3_CH_TX_PMA_RESET_MASK, GTHE3_CH_TX_PMA_RESET_LSB);
int gthe3_ch_tx_pma_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_rw16(gthe3, tx_pcs_reset, GTHE3_CH_TX_PCS_RESET_ADDR, GTHE3_CH_TX_PCS_RESET_MASK, GTHE3_CH_TX_PCS_RESET_LSB);
int gthe3_ch_tx_pcs_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_read16(gthe3, tx_reset_done, GTHE3_CH_TX_RESET_DONE_ADDR, GTHE3_CH_TX_RESET_DONE_MASK, GTHE3_CH_TX_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, tx_gt_reset_done, GTHE3_CH_TX_GT_RESET_DONE_ADDR, GTHE3_CH_TX_GT_RESET_DONE_MASK, GTHE3_CH_TX_GT_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, tx_pma_reset_done, GTHE3_CH_TX_PMA_RESET_DONE_ADDR, GTHE3_CH_TX_PMA_RESET_DONE_MASK, GTHE3_CH_TX_PMA_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, tx_prgdiv_reset_done, GTHE3_CH_TX_PRGDIV_RESET_DONE_ADDR, GTHE3_CH_TX_PRGDIV_RESET_DONE_MASK, GTHE3_CH_TX_PRGDIV_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, tx_usrclk_act, GTHE3_CH_TX_USRCLK_ACT_ADDR, GTHE3_CH_TX_USRCLK_ACT_MASK, GTHE3_CH_TX_USRCLK_ACT_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_pd, GTHE3_CH_TX_PD_ADDR, GTHE3_CH_TX_PD_MASK, GTHE3_CH_TX_PD_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_qpll_sel, GTHE3_CH_TX_QPLL_SEL_ADDR, GTHE3_CH_TX_QPLL_SEL_MASK, GTHE3_CH_TX_QPLL_SEL_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_polarity, GTHE3_CH_TX_POLARITY_ADDR, GTHE3_CH_TX_POLARITY_MASK, GTHE3_CH_TX_POLARITY_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_elecidle, GTHE3_CH_TX_ELECIDLE_ADDR, GTHE3_CH_TX_ELECIDLE_MASK, GTHE3_CH_TX_ELECIDLE_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_inhibit, GTHE3_CH_TX_INHIBIT_ADDR, GTHE3_CH_TX_INHIBIT_MASK, GTHE3_CH_TX_INHIBIT_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_diffctrl, GTHE3_CH_TX_DIFFCTRL_ADDR, GTHE3_CH_TX_DIFFCTRL_MASK, GTHE3_CH_TX_DIFFCTRL_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_maincursor, GTHE3_CH_TX_MAINCURSOR_ADDR, GTHE3_CH_TX_MAINCURSOR_MASK, GTHE3_CH_TX_MAINCURSOR_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_precursor, GTHE3_CH_TX_PRECURSOR_ADDR, GTHE3_CH_TX_PRECURSOR_MASK, GTHE3_CH_TX_PRECURSOR_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_postcursor, GTHE3_CH_TX_POSTCURSOR_ADDR, GTHE3_CH_TX_POSTCURSOR_MASK, GTHE3_CH_TX_POSTCURSOR_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_prbs_sel, GTHE3_CH_TX_PRBS_SEL_ADDR, GTHE3_CH_TX_PRBS_SEL_MASK, GTHE3_CH_TX_PRBS_SEL_LSB);
def_gt_ch_masked_reg_rw16(gthe3, tx_prbs_forcerr, GTHE3_CH_TX_PRBS_FORCERR_ADDR, GTHE3_CH_TX_PRBS_FORCERR_MASK, GTHE3_CH_TX_PRBS_FORCERR_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_reset, GTHE3_CH_RX_RESET_ADDR, GTHE3_CH_RX_RESET_MASK, GTHE3_CH_RX_RESET_LSB);
int gthe3_ch_rx_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_rw16(gthe3, rx_pma_reset, GTHE3_CH_RX_PMA_RESET_ADDR, GTHE3_CH_RX_PMA_RESET_MASK, GTHE3_CH_RX_PMA_RESET_LSB);
int gthe3_ch_rx_pma_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_rw16(gthe3, rx_pcs_reset, GTHE3_CH_RX_PCS_RESET_ADDR, GTHE3_CH_RX_PCS_RESET_MASK, GTHE3_CH_RX_PCS_RESET_LSB);
int gthe3_ch_rx_pcs_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_rw16(gthe3, rx_dfe_lpm_reset, GTHE3_CH_RX_DFE_LPM_RESET_ADDR, GTHE3_CH_RX_DFE_LPM_RESET_MASK, GTHE3_CH_RX_DFE_LPM_RESET_LSB);
int gthe3_ch_rx_dfe_lpm_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_rw16(gthe3, eyescan_reset, GTHE3_CH_EYESCAN_RESET_ADDR, GTHE3_CH_EYESCAN_RESET_MASK, GTHE3_CH_EYESCAN_RESET_LSB);
int gthe3_ch_eyescan_reset(struct gt_ch *ch);
def_gt_ch_masked_reg_read16(gthe3, rx_reset_done, GTHE3_CH_RX_RESET_DONE_ADDR, GTHE3_CH_RX_RESET_DONE_MASK, GTHE3_CH_RX_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_gt_reset_done, GTHE3_CH_RX_GT_RESET_DONE_ADDR, GTHE3_CH_RX_GT_RESET_DONE_MASK, GTHE3_CH_RX_GT_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_pma_reset_done, GTHE3_CH_RX_PMA_RESET_DONE_ADDR, GTHE3_CH_RX_PMA_RESET_DONE_MASK, GTHE3_CH_RX_PMA_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_prgdiv_reset_done, GTHE3_CH_RX_PRGDIV_RESET_DONE_ADDR, GTHE3_CH_RX_PRGDIV_RESET_DONE_MASK, GTHE3_CH_RX_PRGDIV_RESET_DONE_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_usrclk_act, GTHE3_CH_RX_USRCLK_ACT_ADDR, GTHE3_CH_RX_USRCLK_ACT_MASK, GTHE3_CH_RX_USRCLK_ACT_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_pd, GTHE3_CH_RX_PD_ADDR, GTHE3_CH_RX_PD_MASK, GTHE3_CH_RX_PD_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_qpll_sel, GTHE3_CH_RX_QPLL_SEL_ADDR, GTHE3_CH_RX_QPLL_SEL_MASK, GTHE3_CH_RX_QPLL_SEL_LSB);
def_gt_ch_masked_reg_rw16(gthe3, loopback, GTHE3_CH_LOOPBACK_ADDR, GTHE3_CH_LOOPBACK_MASK, GTHE3_CH_LOOPBACK_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_polarity, GTHE3_CH_RX_POLARITY_ADDR, GTHE3_CH_RX_POLARITY_MASK, GTHE3_CH_RX_POLARITY_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_cdr_hold, GTHE3_CH_RX_CDR_HOLD_ADDR, GTHE3_CH_RX_CDR_HOLD_MASK, GTHE3_CH_RX_CDR_HOLD_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_cdr_lock, GTHE3_CH_RX_CDR_LOCK_ADDR, GTHE3_CH_RX_CDR_LOCK_MASK, GTHE3_CH_RX_CDR_LOCK_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_lpm_en, GTHE3_CH_RX_LPM_EN_ADDR, GTHE3_CH_RX_LPM_EN_MASK, GTHE3_CH_RX_LPM_EN_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_dmonitor, GTHE3_CH_RX_DMONITOR_ADDR, GTHE3_CH_RX_DMONITOR_MASK, GTHE3_CH_RX_DMONITOR_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_prbs_sel, GTHE3_CH_RX_PRBS_SEL_ADDR, GTHE3_CH_RX_PRBS_SEL_MASK, GTHE3_CH_RX_PRBS_SEL_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_prbs_cnt_reset, GTHE3_CH_RX_PRBS_CNT_RESET_ADDR, GTHE3_CH_RX_PRBS_CNT_RESET_MASK, GTHE3_CH_RX_PRBS_CNT_RESET_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_prbs_locked, GTHE3_CH_RX_PRBS_LOCKED_ADDR, GTHE3_CH_RX_PRBS_LOCKED_MASK, GTHE3_CH_RX_PRBS_LOCKED_LSB);
def_gt_ch_masked_reg_read16(gthe3, rx_prbs_error, GTHE3_CH_RX_PRBS_ERROR_ADDR, GTHE3_CH_RX_PRBS_ERROR_MASK, GTHE3_CH_RX_PRBS_ERROR_LSB);
// common
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg0, GTHE3_COM_QPLL0_CFG0_ADDR, GTHE3_COM_QPLL0_CFG0_MASK, GTHE3_COM_QPLL0_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, common_cfg0, GTHE3_COM_COMMON_CFG0_ADDR, GTHE3_COM_COMMON_CFG0_MASK, GTHE3_COM_COMMON_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, rsvd_attr0, GTHE3_COM_RSVD_ATTR0_ADDR, GTHE3_COM_RSVD_ATTR0_MASK, GTHE3_COM_RSVD_ATTR0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg1, GTHE3_COM_QPLL0_CFG1_ADDR, GTHE3_COM_QPLL0_CFG1_MASK, GTHE3_COM_QPLL0_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg2, GTHE3_COM_QPLL0_CFG2_ADDR, GTHE3_COM_QPLL0_CFG2_MASK, GTHE3_COM_QPLL0_CFG2_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_lock_cfg, GTHE3_COM_QPLL0_LOCK_CFG_ADDR, GTHE3_COM_QPLL0_LOCK_CFG_MASK, GTHE3_COM_QPLL0_LOCK_CFG_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_init_cfg0, GTHE3_COM_QPLL0_INIT_CFG0_ADDR, GTHE3_COM_QPLL0_INIT_CFG0_MASK, GTHE3_COM_QPLL0_INIT_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_init_cfg1, GTHE3_COM_QPLL0_INIT_CFG1_ADDR, GTHE3_COM_QPLL0_INIT_CFG1_MASK, GTHE3_COM_QPLL0_INIT_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_fbdiv, GTHE3_COM_QPLL0_FBDIV_ADDR, GTHE3_COM_QPLL0_FBDIV_MASK, GTHE3_COM_QPLL0_FBDIV_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg3, GTHE3_COM_QPLL0_CFG3_ADDR, GTHE3_COM_QPLL0_CFG3_MASK, GTHE3_COM_QPLL0_CFG3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cp, GTHE3_COM_QPLL0_CP_ADDR, GTHE3_COM_QPLL0_CP_MASK, GTHE3_COM_QPLL0_CP_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_refclk_div, GTHE3_COM_QPLL0_REFCLK_DIV_ADDR, GTHE3_COM_QPLL0_REFCLK_DIV_MASK, GTHE3_COM_QPLL0_REFCLK_DIV_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_lpf, GTHE3_COM_QPLL0_LPF_ADDR, GTHE3_COM_QPLL0_LPF_MASK, GTHE3_COM_QPLL0_LPF_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg1_g3, GTHE3_COM_QPLL0_CFG1_G3_ADDR, GTHE3_COM_QPLL0_CFG1_G3_MASK, GTHE3_COM_QPLL0_CFG1_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg2_g3, GTHE3_COM_QPLL0_CFG2_G3_ADDR, GTHE3_COM_QPLL0_CFG2_G3_MASK, GTHE3_COM_QPLL0_CFG2_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_lpf_g3, GTHE3_COM_QPLL0_LPF_G3_ADDR, GTHE3_COM_QPLL0_LPF_G3_MASK, GTHE3_COM_QPLL0_LPF_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_lock_cfg_g3, GTHE3_COM_QPLL0_LOCK_CFG_G3_ADDR, GTHE3_COM_QPLL0_LOCK_CFG_G3_MASK, GTHE3_COM_QPLL0_LOCK_CFG_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, rsvd_attr1, GTHE3_COM_RSVD_ATTR1_ADDR, GTHE3_COM_RSVD_ATTR1_MASK, GTHE3_COM_RSVD_ATTR1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_fbdiv_g3, GTHE3_COM_QPLL0_FBDIV_G3_ADDR, GTHE3_COM_QPLL0_FBDIV_G3_MASK, GTHE3_COM_QPLL0_FBDIV_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, rxrecclkout0_sel, GTHE3_COM_RXRECCLKOUT0_SEL_ADDR, GTHE3_COM_RXRECCLKOUT0_SEL_MASK, GTHE3_COM_RXRECCLKOUT0_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_sdm_cfg0, GTHE3_COM_QPLL0_SDM_CFG0_ADDR, GTHE3_COM_QPLL0_SDM_CFG0_MASK, GTHE3_COM_QPLL0_SDM_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_sdm_cfg1, GTHE3_COM_QPLL0_SDM_CFG1_ADDR, GTHE3_COM_QPLL0_SDM_CFG1_MASK, GTHE3_COM_QPLL0_SDM_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm0initseed0_0, GTHE3_COM_SDM0INITSEED0_0_ADDR, GTHE3_COM_SDM0INITSEED0_0_MASK, GTHE3_COM_SDM0INITSEED0_0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm0initseed0_1, GTHE3_COM_SDM0INITSEED0_1_ADDR, GTHE3_COM_SDM0INITSEED0_1_MASK, GTHE3_COM_SDM0INITSEED0_1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_sdm_cfg2, GTHE3_COM_QPLL0_SDM_CFG2_ADDR, GTHE3_COM_QPLL0_SDM_CFG2_MASK, GTHE3_COM_QPLL0_SDM_CFG2_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cp_g3, GTHE3_COM_QPLL0_CP_G3_ADDR, GTHE3_COM_QPLL0_CP_G3_MASK, GTHE3_COM_QPLL0_CP_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm0data1_0, GTHE3_COM_SDM0DATA1_0_ADDR, GTHE3_COM_SDM0DATA1_0_MASK, GTHE3_COM_SDM0DATA1_0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm0_width_pin_sel, GTHE3_COM_SDM0_WIDTH_PIN_SEL_ADDR, GTHE3_COM_SDM0_WIDTH_PIN_SEL_MASK, GTHE3_COM_SDM0_WIDTH_PIN_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm0_data_pin_sel, GTHE3_COM_SDM0_DATA_PIN_SEL_ADDR, GTHE3_COM_SDM0_DATA_PIN_SEL_MASK, GTHE3_COM_SDM0_DATA_PIN_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm0data1_1, GTHE3_COM_SDM0DATA1_1_ADDR, GTHE3_COM_SDM0DATA1_1_MASK, GTHE3_COM_SDM0DATA1_1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll0_cfg4, GTHE3_COM_QPLL0_CFG4_ADDR, GTHE3_COM_QPLL0_CFG4_MASK, GTHE3_COM_QPLL0_CFG4_LSB);
def_gt_pll_masked_reg_rw16(gthe3, bias_cfg0, GTHE3_COM_BIAS_CFG0_ADDR, GTHE3_COM_BIAS_CFG0_MASK, GTHE3_COM_BIAS_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, bias_cfg1, GTHE3_COM_BIAS_CFG1_ADDR, GTHE3_COM_BIAS_CFG1_MASK, GTHE3_COM_BIAS_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, bias_cfg2, GTHE3_COM_BIAS_CFG2_ADDR, GTHE3_COM_BIAS_CFG2_MASK, GTHE3_COM_BIAS_CFG2_LSB);
def_gt_pll_masked_reg_rw16(gthe3, bias_cfg3, GTHE3_COM_BIAS_CFG3_ADDR, GTHE3_COM_BIAS_CFG3_MASK, GTHE3_COM_BIAS_CFG3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, bias_cfg_rsvd, GTHE3_COM_BIAS_CFG_RSVD_ADDR, GTHE3_COM_BIAS_CFG_RSVD_MASK, GTHE3_COM_BIAS_CFG_RSVD_LSB);
def_gt_pll_masked_reg_rw16(gthe3, bias_cfg4, GTHE3_COM_BIAS_CFG4_ADDR, GTHE3_COM_BIAS_CFG4_MASK, GTHE3_COM_BIAS_CFG4_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg0, GTHE3_COM_QPLL1_CFG0_ADDR, GTHE3_COM_QPLL1_CFG0_MASK, GTHE3_COM_QPLL1_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, common_cfg1, GTHE3_COM_COMMON_CFG1_ADDR, GTHE3_COM_COMMON_CFG1_MASK, GTHE3_COM_COMMON_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, por_cfg, GTHE3_COM_POR_CFG_ADDR, GTHE3_COM_POR_CFG_MASK, GTHE3_COM_POR_CFG_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg1, GTHE3_COM_QPLL1_CFG1_ADDR, GTHE3_COM_QPLL1_CFG1_MASK, GTHE3_COM_QPLL1_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg2, GTHE3_COM_QPLL1_CFG2_ADDR, GTHE3_COM_QPLL1_CFG2_MASK, GTHE3_COM_QPLL1_CFG2_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_lock_cfg, GTHE3_COM_QPLL1_LOCK_CFG_ADDR, GTHE3_COM_QPLL1_LOCK_CFG_MASK, GTHE3_COM_QPLL1_LOCK_CFG_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_init_cfg0, GTHE3_COM_QPLL1_INIT_CFG0_ADDR, GTHE3_COM_QPLL1_INIT_CFG0_MASK, GTHE3_COM_QPLL1_INIT_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_init_cfg1, GTHE3_COM_QPLL1_INIT_CFG1_ADDR, GTHE3_COM_QPLL1_INIT_CFG1_MASK, GTHE3_COM_QPLL1_INIT_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_fbdiv, GTHE3_COM_QPLL1_FBDIV_ADDR, GTHE3_COM_QPLL1_FBDIV_MASK, GTHE3_COM_QPLL1_FBDIV_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg3, GTHE3_COM_QPLL1_CFG3_ADDR, GTHE3_COM_QPLL1_CFG3_MASK, GTHE3_COM_QPLL1_CFG3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cp, GTHE3_COM_QPLL1_CP_ADDR, GTHE3_COM_QPLL1_CP_MASK, GTHE3_COM_QPLL1_CP_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sarc_sel, GTHE3_COM_SARC_SEL_ADDR, GTHE3_COM_SARC_SEL_MASK, GTHE3_COM_SARC_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sarc_en, GTHE3_COM_SARC_EN_ADDR, GTHE3_COM_SARC_EN_MASK, GTHE3_COM_SARC_EN_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_refclk_div, GTHE3_COM_QPLL1_REFCLK_DIV_ADDR, GTHE3_COM_QPLL1_REFCLK_DIV_MASK, GTHE3_COM_QPLL1_REFCLK_DIV_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_lpf, GTHE3_COM_QPLL1_LPF_ADDR, GTHE3_COM_QPLL1_LPF_MASK, GTHE3_COM_QPLL1_LPF_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg1_g3, GTHE3_COM_QPLL1_CFG1_G3_ADDR, GTHE3_COM_QPLL1_CFG1_G3_MASK, GTHE3_COM_QPLL1_CFG1_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg2_g3, GTHE3_COM_QPLL1_CFG2_G3_ADDR, GTHE3_COM_QPLL1_CFG2_G3_MASK, GTHE3_COM_QPLL1_CFG2_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_lpf_g3, GTHE3_COM_QPLL1_LPF_G3_ADDR, GTHE3_COM_QPLL1_LPF_G3_MASK, GTHE3_COM_QPLL1_LPF_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_lock_cfg_g3, GTHE3_COM_QPLL1_LOCK_CFG_G3_ADDR, GTHE3_COM_QPLL1_LOCK_CFG_G3_MASK, GTHE3_COM_QPLL1_LOCK_CFG_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, rsvd_attr2, GTHE3_COM_RSVD_ATTR2_ADDR, GTHE3_COM_RSVD_ATTR2_MASK, GTHE3_COM_RSVD_ATTR2_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_fbdiv_g3, GTHE3_COM_QPLL1_FBDIV_G3_ADDR, GTHE3_COM_QPLL1_FBDIV_G3_MASK, GTHE3_COM_QPLL1_FBDIV_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, rxrecclkout1_sel, GTHE3_COM_RXRECCLKOUT1_SEL_ADDR, GTHE3_COM_RXRECCLKOUT1_SEL_MASK, GTHE3_COM_RXRECCLKOUT1_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_sdm_cfg0, GTHE3_COM_QPLL1_SDM_CFG0_ADDR, GTHE3_COM_QPLL1_SDM_CFG0_MASK, GTHE3_COM_QPLL1_SDM_CFG0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_sdm_cfg1, GTHE3_COM_QPLL1_SDM_CFG1_ADDR, GTHE3_COM_QPLL1_SDM_CFG1_MASK, GTHE3_COM_QPLL1_SDM_CFG1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm1initseed0_0, GTHE3_COM_SDM1INITSEED0_0_ADDR, GTHE3_COM_SDM1INITSEED0_0_MASK, GTHE3_COM_SDM1INITSEED0_0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm1initseed0_1, GTHE3_COM_SDM1INITSEED0_1_ADDR, GTHE3_COM_SDM1INITSEED0_1_MASK, GTHE3_COM_SDM1INITSEED0_1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_sdm_cfg2, GTHE3_COM_QPLL1_SDM_CFG2_ADDR, GTHE3_COM_QPLL1_SDM_CFG2_MASK, GTHE3_COM_QPLL1_SDM_CFG2_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cp_g3, GTHE3_COM_QPLL1_CP_G3_ADDR, GTHE3_COM_QPLL1_CP_G3_MASK, GTHE3_COM_QPLL1_CP_G3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm1data1_0, GTHE3_COM_SDM1DATA1_0_ADDR, GTHE3_COM_SDM1DATA1_0_MASK, GTHE3_COM_SDM1DATA1_0_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm1_width_pin_sel, GTHE3_COM_SDM1_WIDTH_PIN_SEL_ADDR, GTHE3_COM_SDM1_WIDTH_PIN_SEL_MASK, GTHE3_COM_SDM1_WIDTH_PIN_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm1_data_pin_sel, GTHE3_COM_SDM1_DATA_PIN_SEL_ADDR, GTHE3_COM_SDM1_DATA_PIN_SEL_MASK, GTHE3_COM_SDM1_DATA_PIN_SEL_LSB);
def_gt_pll_masked_reg_rw16(gthe3, sdm1data1_1, GTHE3_COM_SDM1DATA1_1_ADDR, GTHE3_COM_SDM1DATA1_1_MASK, GTHE3_COM_SDM1DATA1_1_LSB);
def_gt_pll_masked_reg_rw16(gthe3, rsvd_attr3, GTHE3_COM_RSVD_ATTR3_ADDR, GTHE3_COM_RSVD_ATTR3_MASK, GTHE3_COM_RSVD_ATTR3_LSB);
def_gt_pll_masked_reg_rw16(gthe3, qpll1_cfg4, GTHE3_COM_QPLL1_CFG4_ADDR, GTHE3_COM_QPLL1_CFG4_MASK, GTHE3_COM_QPLL1_CFG4_LSB);
// RX
def_gt_ch_masked_reg_rw16(gthe3, rx_data_width_raw, GTHE3_CH_RX_DATA_WIDTH_ADDR, GTHE3_CH_RX_DATA_WIDTH_MASK, GTHE3_CH_RX_DATA_WIDTH_LSB);
int gthe3_ch_get_rx_data_width(struct gt_ch *ch, uint32_t *val);
def_gt_ch_masked_reg_rw16(gthe3, rx_int_data_width_raw, GTHE3_CH_RX_INT_DATAWIDTH_ADDR, GTHE3_CH_RX_INT_DATAWIDTH_MASK, GTHE3_CH_RX_INT_DATAWIDTH_LSB);
int gthe3_ch_get_rx_int_data_width(struct gt_ch *ch, uint32_t *val);
def_gt_ch_masked_reg_rw16(gthe3, es_prescale, GTHE3_CH_ES_PRESCALE_ADDR, GTHE3_CH_ES_PRESCALE_MASK, GTHE3_CH_ES_PRESCALE_LSB);
def_gt_ch_masked_reg_rw16(gthe3, es_eye_scan_en, GTHE3_CH_ES_EYE_SCAN_EN_ADDR, GTHE3_CH_ES_EYE_SCAN_EN_MASK, GTHE3_CH_ES_EYE_SCAN_EN_LSB);
def_gt_ch_masked_reg_rw16(gthe3, es_errdet_en, GTHE3_CH_ES_ERRDET_EN_ADDR, GTHE3_CH_ES_ERRDET_EN_MASK, GTHE3_CH_ES_ERRDET_EN_LSB);
def_gt_ch_masked_reg_rw16(gthe3, es_control, GTHE3_CH_ES_CONTROL_ADDR, GTHE3_CH_ES_CONTROL_MASK, GTHE3_CH_ES_CONTROL_LSB);
int gthe3_ch_set_es_qual_mask(struct gt_ch *ch, uint8_t *mask);
int gthe3_ch_set_es_qual_mask_clear(struct gt_ch *ch);
int gthe3_ch_set_es_sdata_mask(struct gt_ch *ch, uint8_t *mask);
int gthe3_ch_set_es_sdata_mask_width(struct gt_ch *ch, int width);
def_gt_ch_masked_reg_rw16(gthe3, es_horz_offset, GTHE3_CH_ES_HORZ_OFFSET_ADDR, GTHE3_CH_ES_HORZ_OFFSET_MASK, GTHE3_CH_ES_HORZ_OFFSET_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_eyescan_vs_range, GTHE3_CH_RX_EYESCAN_VS_RANGE_ADDR, GTHE3_CH_RX_EYESCAN_VS_RANGE_MASK, GTHE3_CH_RX_EYESCAN_VS_RANGE_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_eyescan_vs_code, GTHE3_CH_RX_EYESCAN_VS_CODE_ADDR, GTHE3_CH_RX_EYESCAN_VS_CODE_MASK, GTHE3_CH_RX_EYESCAN_VS_CODE_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_eyescan_vs_ut_sign, GTHE3_CH_RX_EYESCAN_VS_UT_SIGN_ADDR, GTHE3_CH_RX_EYESCAN_VS_UT_SIGN_MASK, GTHE3_CH_RX_EYESCAN_VS_UT_SIGN_LSB);
def_gt_ch_masked_reg_rw16(gthe3, rx_eyescan_vs_neg_dir, GTHE3_CH_RX_EYESCAN_VS_NEG_DIR_ADDR, GTHE3_CH_RX_EYESCAN_VS_NEG_DIR_MASK, GTHE3_CH_RX_EYESCAN_VS_NEG_DIR_LSB);
def_gt_ch_masked_reg_read16(gthe3, es_error_count, GTHE3_CH_ES_ERROR_COUNT_ADDR, GTHE3_CH_ES_ERROR_COUNT_MASK, GTHE3_CH_ES_ERROR_COUNT_LSB);
def_gt_ch_masked_reg_read16(gthe3, es_sample_count, GTHE3_CH_ES_SAMPLE_COUNT_ADDR, GTHE3_CH_ES_SAMPLE_COUNT_MASK, GTHE3_CH_ES_SAMPLE_COUNT_LSB);
def_gt_ch_masked_reg_read16(gthe3, es_control_status, GTHE3_CH_ES_CONTROL_STATUS_ADDR, GTHE3_CH_ES_CONTROL_STATUS_MASK, GTHE3_CH_ES_CONTROL_STATUS_LSB);
int gthe3_ch_get_rx_prbs_error_count(struct gt_ch *ch, uint32_t *val);
// TX
def_gt_ch_masked_reg_rw16(gthe3, tx_data_width_raw, GTHE3_CH_TX_DATA_WIDTH_ADDR, GTHE3_CH_TX_DATA_WIDTH_MASK, GTHE3_CH_TX_DATA_WIDTH_LSB);
int gthe3_ch_get_tx_data_width(struct gt_ch *ch, uint32_t *val);
def_gt_ch_masked_reg_rw16(gthe3, tx_int_data_width_raw, GTHE3_CH_TX_INT_DATAWIDTH_ADDR, GTHE3_CH_TX_INT_DATAWIDTH_MASK, GTHE3_CH_TX_INT_DATAWIDTH_LSB);
int gthe3_ch_get_tx_int_data_width(struct gt_ch *ch, uint32_t *val);
extern const struct gt_quad_ops gthe3_gt_quad_ops;
#endif /* XCVR_GTHE3_H */
|
8b384226368e8759be2f8f93cbc427da8e3edae5
|
f367e4b66a1ee42e85830b31df88f63723c36a47
|
/tests/internal/include/sp_select_keys.h
|
ba3c809f3ad832bf30c726f412a7197f3150cbf0
|
[
"Apache-2.0"
] |
permissive
|
fluent/fluent-bit
|
06873e441162b92941024e9a7e9e8fc934150bf7
|
1a41f49dc2f3ae31a780caa9ffd6137b1d703065
|
refs/heads/master
| 2023-09-05T13:44:55.347372
| 2023-09-05T10:14:33
| 2023-09-05T10:14:33
| 29,933,948
| 4,907
| 1,565
|
Apache-2.0
| 2023-09-14T10:17:02
| 2015-01-27T20:41:52
|
C
|
UTF-8
|
C
| false
| false
| 3,236
|
h
|
sp_select_keys.h
|
#include "sp_cb_functions.h"
#ifndef FLB_TEST_SP_SELECT_KEYS
#define FLB_TEST_SP_SELECT_KEYS
/* Tests for 'test_select_keys' */
struct task_check select_keys_checks[] = {
{
0, 0, 0, 0,
"select_all",
"SELECT * FROM STREAM:FLB;",
cb_select_all
},
{
1, 0, 0, 0,
"select_id",
"SELECT id, word2 FROM STREAM:FLB;",
cb_select_id
},
/* Conditionals */
{
2, 0, 0, 0,
"select_cond_1",
"SELECT * FROM STREAM:FLB WHERE bytes > 10.290;",
cb_select_cond_1
},
{
3, 0, 0, 0,
"select_cond_2",
"SELECT * FROM STREAM:FLB WHERE word2 = 'rlz' or word3 = 'rlz';",
cb_select_cond_2
},
{
4, 0, 0, 0,
"select_cond_not_null",
"SELECT * FROM STREAM:FLB WHERE word2 = 'rlz' and word3 IS NOT NULL;",
cb_select_cond_not_null
},
{
5, 0, 0, 0,
"select_cond_null",
"SELECT * FROM STREAM:FLB WHERE word3 IS NULL;",
cb_select_cond_null
},
{
6, 0, 0, 0,
"select_not_equal_1",
"SELECT * FROM STREAM:FLB WHERE bool != true;",
cb_select_not_equal_1
},
{
7, 0, 0, 0,
"select_not_equal_2",
"SELECT * FROM STREAM:FLB WHERE bytes <> 10;",
cb_select_not_equal_2
},
/* Aggregation functions */
{
8, 0, 0, 0,
"select_aggr",
"SELECT MIN(id), MAX(id), COUNT(*), SUM(bytes), AVG(bytes) " \
"FROM STREAM:FLB;",
cb_select_aggr,
},
{
9, 0, 0, 0,
"select_aggr_coount",
"SELECT COUNT(*) " \
"FROM STREAM:FLB;",
cb_select_aggr_count,
},
{
10, 0, 0, 0,
"select_aggr_window_tumbling",
"SELECT MIN(id), MAX(id), COUNT(*), SUM(bytes), AVG(bytes) FROM STREAM:FLB;",
cb_select_aggr,
},
{
11, 0, 0, 0,
"select_aggr_window_tumbling_groupby",
"SELECT bool, MIN(id), MAX(id), COUNT(*), SUM(bytes), AVG(bytes) " \
"FROM STREAM:FLB WHERE word3 IS NOT NULL GROUP BY bool;",
cb_select_groupby,
},
/* Time functions */
{
12, 0, 0, 0,
"func_time_now",
"SELECT NOW(), NOW() as tnow FROM STREAM:FLB WHERE bytes > 10;",
cb_func_time_now,
},
{
13, 0, 0, 0,
"func_time_unix_timestamp",
"SELECT UNIX_TIMESTAMP(), UNIX_TIMESTAMP() as ts " \
"FROM STREAM:FLB WHERE bytes > 10;",
cb_func_time_unix_timestamp,
},
/* Stream selection using Tag rules */
{
14, 0, 0, 0,
"select_from_tag_error",
"SELECT id FROM TAG:'no-matches' WHERE bytes > 10;",
cb_select_tag_error,
},
{
15, 0, 0, 0,
"select_from_tag",
"SELECT id FROM TAG:'samples' WHERE bytes > 10;",
cb_select_tag_ok,
},
{
16, 0, 0, 0,
"@recond.contains",
"SELECT id FROM TAG:'samples' WHERE bytes = 10 AND @record.contains(word2);",
cb_record_contains,
},
{
17, 0, 0, 0,
"@recond.contains",
"SELECT id FROM TAG:'samples' WHERE @record.contains(x);",
cb_record_not_contains,
},
};
#endif
|
d75019c3b94d28065af120bc07797c2389b2971b
|
09ad211d426e093aec7e674334834f1de188548e
|
/Chapter06/06_multigpu/04_gaussian_multi_node/gaussian_multi_gpu_rdma.h
|
5d139d2105dfa71980dab1d4d65c6dcc978f1ebc
|
[
"MIT"
] |
permissive
|
PacktPublishing/Learn-CUDA-Programming
|
b818f4766304bfe7b45719ad7c11c4d4dc08a2f5
|
2d0abbeeea9fbba79ef6cd63bef4148e4c00b1ac
|
refs/heads/master
| 2023-08-29T10:12:33.682703
| 2023-04-04T18:20:33
| 2023-04-04T18:20:33
| 140,380,398
| 722
| 201
|
MIT
| 2023-04-04T18:20:34
| 2018-07-10T05:14:55
|
Cuda
|
UTF-8
|
C
| false
| false
| 10,664
|
h
|
gaussian_multi_gpu_rdma.h
|
#pragma once
#ifndef _GE_SOLVER_H_
#define _GE_SOLVER_H_
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <vector_types.h>
#include "config.h"
//Sanity check on config parameters
#if (defined(ELEMENT_TYPE_UINT) && defined(ELEMENT_TYPE_UINT4))
#error Enable only one of the two ELEMENT_TYPE_UINT and ELEMENT_TYPE_UINT4
#endif
#if !defined(ELEMENT_TYPE_UINT) && !defined(ELEMENT_TYPE_UINT4)
#error Enable at least one of the two ELEMENT_TYPE_UINT and ELEMENT_TYPE_UINT4
#endif
#if defined(ELEMENT_TYPE_UINT)
typedef unsigned int elemtype;
// Number of bits clubbed together to form a pack. All the packed its are processed together.
#define PACK_SIZE (8*4)
#define VEC_LEN 1
#elif defined(ELEMENT_TYPE_UINT4)
typedef uint4 elemtype;
// Number of bits clubbed together to form a pack. All the packed its are processed together.
#define PACK_SIZE (8*16)
#define VEC_LEN 4
#endif
typedef struct
{
/*
At any point during Gaussian elimination, the results of intermediate computations are
kept in the elements of this structure. In short this structure serves as context for
all the solver. This structure holds information that changes on every iteration, such
as pivot row, multipliers etc. It also holds iteration invariant information such as
number of rows and number of columns in the linear system.
Keeping all the information in a single structure makes it easy to pass it to multiple
functions.
*/
// Iteration invariant parameters
int rowCount; // Number of rows in linear system
int columnCount; // Number of columns in linear system
int packedColumnCount; // Number of packed columns = ceil(columnCount/PACK_SIZE)
elemtype* h_packedAB; // Packed linear system on host, this is valid only on rank 0 process
elemtype* h_packedTransposeAB; // Packed transposed linear system on host,valid only on rank 0
elemtype* h_myPartOfPackedTransposeAB; // Each process holds its portition of the packed data
int myPackedColumnCount; // Number of packed columns of the transposed linear system with the current process, since we do only column partitioning, there is no myRowCount
int myNumChunks;
int myLastChunkSize;
int numProcs;
int myRank;
elemtype* d_packedTransposeAB; // device pointer to the packed transposed linear system
// Specific to current reduction iteration
int columnPack; // Packed column index of current column under reduction = floor(iteration/PACK_SIZE)
int columnBit; // Bit index of of current column under reduction = iteration % PACK_SIZE
unsigned char* isRowReduced; // isRowReduced[i] is true iff i^th row is already reduced
#ifdef PIVOTPACK
unsigned int *multipliers;
#else
unsigned char* multipliers; // multipliers[i] is 1 if ith row needs to undergo reduction for current iteration
#endif
int* pivotRowIndex; // Index of current pivot row
elemtype* pivotRow; // pivot row that should be use for current reduction iteration
} stSolverState;
#define CHUNK_SIZE 16 //Data (packed columns) is distributed among the processes using cyclic column partitioning
#ifdef PIVOTPACK
#define PIVOT_PACK_SIZE (8*4)
#endif
// Ceil of numerator divided by denominator.
#define intCeilDiv(numerator, denominator) (((numerator) + (denominator) - 1)/ (denominator))
// CUDA error reporting.
#define checkCudaErrors(val) _report( (val), #val, __FILE__, __LINE__ )
// Generates a linear system with pseudo-random entries.
// 'A' is generated as a matrix with 'rowCount' rows and 'columnCount' columns.
// 'x' is generated as a vector with 'columnCount' entries.
// vector 'B' has 'rowCount' entries and is computed as B = A*x.
// Value of percent can be 0 to 100. The generated matrix 'A' has 'percent' % non-zero entries.
void generateLinearSystem(unsigned char *A, unsigned char* B, unsigned char* x, int rowCount, int columnCount, int percent);
// Write entries 'vector' to file with name 'filename'. Number of entries equal to 'length' are
// written to file. The entries are written in plain-text format. Each entry is written on a
// new line.
int writeVectorToFile(const char* filename, unsigned char* vector, int length);
// Prints matrix 'matrixA' to standard output. The arguments 'rowCount' and 'columnCount' are
// used to specify the dimensions of the matrix.
void printMatrix(unsigned char* matrixA, int rowCount, int columnCount);
// Converts the linear system given by 'A' and 'B' to augmented packed form.
// Augmented system is obtained by appending one vector 'B' as a column to matrix 'B'.
// Columns of the augmented system are packed together to form augmented packed linear system.
// Consecutive entries from each row are grouped together to form packed columns.
// The augmented packed system is returned in the output argument 'packedAB'.
void packLinearSystem(elemtype* packedAB, unsigned char* A, unsigned char* B, int rowCount, int columnCount);
// Unpacks the linear linear system.
// This function reverses the action of pack linear system function.
void unpackLinearSystem(unsigned char* A, unsigned char* B, elemtype* packedAB, int rowCount, int columnCount);
// Transposes matrix 'A'. Output argument 'transposeA' holds the result.
// Matrix dimension are specified using 'rowcount' and 'columnCount' argument.
void transposeMatrixCPU(elemtype *transposeA, elemtype *A, int rowCount, int columnCount);
// Reads a linear system given by 'matrixA' and 'B' from the file with name 'filename'.
// The file should be in plain text format.
// Each line of the file represents one row of the matrix 'A'. Last entry on the row is entry
// from the vector 'B'.
void readLinearSystemFromFile(const char* filename, unsigned char* matrixA, unsigned char* B, int rowCount, int columnCount);
// Writes linear system given by 'matrixA' and vector 'B' to the file with name 'filename'.
// The format of writing is as specified in readLinearSystemFromFile().
void writeLinearSystemFromFile(const char* filename, unsigned char* matrixA, unsigned char* B, int rowCount, int columnCount);
// This function is called by rank 0. It internally calls packLinearSystem() and transposeMatrixCPU()
int prepareDataforGaussianElimination(unsigned char* A, unsigned char* B, int rowCount, int columnCount, stSolverState *solverState);
// Top level wrapper for Gaussian elimination.
int gaussianElimination(stSolverState *solverState, int myRank, int nodeLocalRank, int numProcs);
// Gaussian elimination on GPU
void gaussianEliminationOnGPU(stSolverState *solverState, int numProcs, int myRank, int myNodeLocalRank);
void distributeInputs(stSolverState *solverState, int myRank, int nodeLocalRank, int numProcs); // Rank 0 distributes input data to all procs
void gatherResult(stSolverState *solverState, int myRank, int nodeLocalRank, int numProcs); // Rank 0 gathers result from all procs
// This function broadcasts the pivotRow index and multipliers
void bcastPivotRow(int pivotProc, int myRank, int numProcs, stSolverState *solverState, void **commReq, void **commStatus);
void waitForPivotBcast(int pivotProc, void *req, void *status, int numProcs, int myRank);
// This function is called by rank 0. It internally calls transposeMatrixCPU() and unpackLinearSystem()
void prepareResultFromGaussianElimination(unsigned char* A, unsigned char* B, int rowCount, int columnCount, stSolverState *solverState);
// Performs backsubstitution operation.
// Argument 'matrixA' is assumed to be upper triangular matrix.
// Argument 'B' is a vector with 'number_of_equations' entries.
// Output argument 'x' is solution vector
int backsubstitution(unsigned char* matrixA, unsigned char* B, unsigned char* x, int number_of_equations, int number_of_variables);
// Allocates GPU memory for fields of 'solverState' and also initializes them
void initializeSolver(stSolverState* solverState, int rowCount, int columnCount, int rank, int nodeLocalRank, int numProcs);
// Free GPU memory allocated for fields of 'solverState'
void freeSolver(stSolverState* solverState);
void launchFindPivotRowKernel(stSolverState *solverState);
void launchExtractPivotRowKernel(stSolverState *solverState);
void launchRowEliminationKernel(stSolverState *solverState);
// Utitlities for operating bits of elemtype
// Make all bits zero
void resetElement(elemtype* e);
// Make 'bitIndex' bit 1
void setElementBit(elemtype* e, int bitIndex);
// Get 'bitIndex' bit
unsigned char getElementBit(elemtype* e, int bitIndex);
#ifdef __NVCC__
// Extract bit-field. Bits of 'x' are numbered 0-31.
// Bit-field with 'numBits' number of bits starting from 'bit' bit is returned
// for example 'bit' = 0 and 'numBits' = 5, returns five least significant bits of 'x'
__device__ unsigned int bfe(unsigned int x, unsigned int bit, unsigned int numBits);
// Same as bfe() but for elemtype datatype
__device__ unsigned int bfew(elemtype* e, int bitIndex);
// CUDA error reporting
void _report(cudaError_t result, char const *const func, const char *const file, int const line);
// Block level reduction operation to find max.
// 'sData' is array with 'blockSize' entries.
// 'tid' is local thread index.
// After execution sData[0] contains the largest entry from 'sData'.
__device__ void findMax(int* sData, const unsigned int tid, const unsigned int blockSize);
__global__ void findPivotRowAndMultipliers(stSolverState solverState, elemtype* const __restrict__ d_packedTransposeAB);
__global__ void extractPivotRow(stSolverState solverState, elemtype* d_packedTransposeAB);
__global__ void rowElimination(elemtype* d_packedTransposeAB, stSolverState solverState);
#endif
#endif
|
bab380304ae683741a8c9fa23ab936ac711d833d
|
89e36105f3a39e9ca051e3e63a51dc855ec55559
|
/randomcode/shebang.c
|
9555fb76540e5c1d34a429a2811c979a0d032949
|
[] |
no_license
|
jordansissel/experiments
|
771e062cfbc3a64ce67ad827e31c6c7256bba65a
|
1b969a86fe2eea515edf6fa0e4c0c83e146495f2
|
refs/heads/master
| 2023-08-21T22:47:57.022936
| 2023-03-14T04:47:38
| 2023-03-14T04:47:38
| 1,790,809
| 103
| 22
| null | 2023-03-06T12:27:59
| 2011-05-23T23:49:43
|
JavaScript
|
UTF-8
|
C
| false
| false
| 865
|
c
|
shebang.c
|
/* shebang helper.
*
* This tool lets you sanely execute things from the shebang line
* at the top of a script.
*
* Problem solved by this program:
* This line won't work like you might expect:
* #!/usr/bin/env scriptname arg1 arg2 ...
*
* When executed, this will run this:
* /usr/bin/env "scriptname arg1 arg2 ..."
*
* This is likely not what you wanted, you wanted:
* /usr/bin/env "scriptname" "arg1" "arg2" ...
*
* If you use this program, it'll work as expected:
* #!/usr/bin/shebang scriptname arg1 arg2
*/
#include <stdio.h>
#include <unistd.h>
char *const *environ;
int main(int argc, char **argv) {
int i;
char *cmd;
char *newargv[4];
asprintf(&cmd, "%s %s", argv[1], argv[2]);
newargv[0] = "/bin/sh";
newargv[1] = "-c";
newargv[2] = cmd;
newargv[3] = NULL;
execve("/bin/sh", newargv, environ);
return -1;
}
|
b7a87a2e6f8fb7198e2f831aa13b07c29b12d788
|
7c857119fe1505b1d80d6e62969661c06dc1a2f4
|
/MdePkg/Include/Protocol/SmmAccess2.h
|
cc71de4752e0a7010c8439ef306331e805f4febd
|
[
"BSD-2-Clause"
] |
permissive
|
CloverHackyColor/CloverBootloader
|
7042ca7dd6b513d22be591a295e49071ae1482ee
|
2711170df4f60b2ae5aa20add3e00f35cf57b7e5
|
refs/heads/master
| 2023-08-30T22:14:34.590134
| 2023-08-27T19:14:02
| 2023-08-27T19:14:02
| 205,810,121
| 4,734
| 770
|
BSD-2-Clause
| 2023-09-03T12:41:33
| 2019-09-02T08:22:14
|
C
|
UTF-8
|
C
| false
| false
| 1,276
|
h
|
SmmAccess2.h
|
/** @file
EFI SMM Access2 Protocol as defined in the PI 1.2 specification.
This protocol is used to control the visibility of the SMRAM on the platform.
It abstracts the location and characteristics of SMRAM. The expectation is
that the north bridge or memory controller would publish this protocol.
The principal functionality found in the memory controller includes the following:
- Exposing the SMRAM to all non-SMM agents, or the "open" state
- Shrouding the SMRAM to all but the SMM agents, or the "closed" state
- Preserving the system integrity, or "locking" the SMRAM, such that the settings cannot be
perturbed by either boot service or runtime agents
Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef _SMM_ACCESS2_H_
#define _SMM_ACCESS2_H_
#include <Protocol/MmAccess.h>
#define EFI_SMM_ACCESS2_PROTOCOL_GUID EFI_MM_ACCESS_PROTOCOL_GUID
typedef EFI_MM_ACCESS_PROTOCOL EFI_SMM_ACCESS2_PROTOCOL;
typedef EFI_MM_OPEN EFI_SMM_OPEN2;
typedef EFI_MM_CLOSE EFI_SMM_CLOSE2;
typedef EFI_MM_LOCK EFI_SMM_LOCK2;
typedef EFI_MM_CAPABILITIES EFI_SMM_CAPABILITIES2;
extern EFI_GUID gEfiSmmAccess2ProtocolGuid;
#endif
|
97b06a0157a27c2d32303f97b6fb42eca3d14a47
|
12091b1c0723759464f949b0a47b305c76549278
|
/src/binomial.h
|
d6a2951f440dbecdd557bb28948b5dd70658ee04
|
[
"MIT"
] |
permissive
|
whatshap/whatshap
|
6311e13d36210f395206683bb00b2054ef639653
|
15c9ff8c4f5b04b86195396dbc6620c874b5ceb8
|
refs/heads/main
| 2023-09-04T07:58:09.567203
| 2023-08-31T08:45:45
| 2023-08-31T08:45:45
| 276,673,862
| 254
| 27
|
MIT
| 2023-09-10T06:47:19
| 2020-07-02T14:53:00
|
Python
|
UTF-8
|
C
| false
| false
| 344
|
h
|
binomial.h
|
#ifndef BINOMIAL_H
#define BINOMIAL_H
/**
* Computes the Binomial Coefficient.
* Use implementation here: https://www.geeksforgeeks.org/space-and-time-efficient-binomial-coefficient
*/
int binomial_coefficient(int n, int k);
double binomial_coefficient_large(int n, int k);
double binom_pmf(int n, int k, double p);
# endif // BINOMIAL_H
|
328eda4e54bfafff55c6b4c3b0b773c5b40e73ef
|
7df190df28da7e4ff166e55dc8ce780f11236a9f
|
/src/router/openssl/include/executive/cvmx-key.h
|
5f3e30ce0b85ae2303aabeb8cc72860184503a2f
|
[
"OpenSSL"
] |
permissive
|
mirror/dd-wrt
|
25416946e6132aa54b35809de61834a1825a9a36
|
8f2934a5a2adfbb59b471375aa3a38de5d036531
|
refs/heads/master
| 2023-08-31T14:54:47.496685
| 2023-08-30T17:40:54
| 2023-08-30T17:40:54
| 7,470,282
| 520
| 281
| null | 2023-05-29T20:56:24
| 2013-01-06T17:21:29
| null |
UTF-8
|
C
| false
| false
| 3,362
|
h
|
cvmx-key.h
|
/***********************license start***************
* Copyright (c) 2003-2010 Cavium Inc. (support@cavium.com). All rights
* reserved.
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Cavium Inc. nor the names of
* its contributors may be used to endorse or promote products
* derived from this software without specific prior written
* permission.
* This Software, including technical data, may be subject to U.S. export control
* laws, including the U.S. Export Administration Act and its associated
* regulations, and may be subject to export or import regulations in other
* countries.
* TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
* AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS OR
* WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
* THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR
* DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM
* SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE,
* MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF
* VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR
* CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR
* PERFORMANCE OF THE SOFTWARE LIES WITH YOU.
***********************license end**************************************/
/**
* @file
*
* Interface to the on chip key memory. Key memory is
* 8k on chip that is inaccessible from off chip. It can
* also be cleared using an external hardware pin.
*
* <hr>$Revision: 73845 $<hr>
*
*/
#ifndef __CVMX_KEY_H__
#define __CVMX_KEY_H__
#ifdef __cplusplus
/* *INDENT-OFF* */
extern "C" {
/* *INDENT-ON* */
#endif
#define CVMX_KEY_MEM_SIZE 8192 /* Size in bytes */
#if 0
/**
* Read from KEY memory
*
* @param address Address (byte) in key memory to read
* 0 <= address < CVMX_KEY_MEM_SIZE
* @return Value from key memory
*/
static inline uint64_t cvmx_key_read(uint64_t address)
{
cvmx_addr_t ptr;
ptr.u64 = 0;
ptr.sio.mem_region = CVMX_IO_SEG;
ptr.sio.is_io = 1;
ptr.sio.did = CVMX_OCT_DID_KEY_RW;
ptr.sio.offset = address;
return cvmx_read_csr(ptr.u64);
}
/**
* Write to KEY memory
*
* @param address Address (byte) in key memory to write
* 0 <= address < CVMX_KEY_MEM_SIZE
* @param value Value to write to key memory
*/ static inline void cvmx_key_write(uint64_t address, uint64_t value)
{
cvmx_addr_t ptr;
ptr.u64 = 0;
ptr.sio.mem_region = CVMX_IO_SEG;
ptr.sio.is_io = 1;
ptr.sio.did = CVMX_OCT_DID_KEY_RW;
ptr.sio.offset = address;
cvmx_write_io(ptr.u64, value);
}
#endif
/* CSR typedefs have been moved to cvmx-key-defs.h */
#ifdef __cplusplus
/* *INDENT-OFF* */
}
/* *INDENT-ON* */
#endif
#endif /* __CVMX_KEY_H__ */
|
fad64fe0d330178be62e709149832b4a31fe0453
|
f3eed0234b4d0ad2bbb2abd700cf1e2c7a0e8a1d
|
/AKWF-c/AKWF_oscchip/AKWF_oscchip_0104.h
|
5d47ed5d2c9c92da0443b9a7d239e6df9fbd1d5a
|
[
"CC0-1.0"
] |
permissive
|
KristofferKarlAxelEkstrand/AKWF-FREE
|
b2defa1a2d389d309be6dd2e9f968923daf80d1b
|
cf8171df36e9fec25416b5f568b72a6e2cb69194
|
refs/heads/master
| 2023-07-23T18:22:36.939705
| 2023-07-10T17:14:40
| 2023-07-10T17:14:40
| 145,817,187
| 359
| 59
|
CC0-1.0
| 2023-07-10T17:14:41
| 2018-08-23T07:26:56
| null |
UTF-8
|
C
| false
| false
| 4,688
|
h
|
AKWF_oscchip_0104.h
|
/* Adventure Kid Waveforms (AKWF) converted for use with Teensy Audio Library
*
* Adventure Kid Waveforms(AKWF) Open waveforms library
* https://www.adventurekid.se/akrt/waveforms/adventure-kid-waveforms/
*
* This code is in the public domain, CC0 1.0 Universal (CC0 1.0)
* https://creativecommons.org/publicdomain/zero/1.0/
*
* Converted by Brad Roy, https://github.com/prosper00
*/
/* AKWF_oscchip_0104 256 samples
+-----------------------------------------------------------------------------------------------------------------+
| ************************** * |
|********** ************ * |
| ************************************ * |
| * |
| * |
| * |
| * |
| * |
| * |
| * |
| * |
| * |
| * |
| * |
| * **************|
+-----------------------------------------------------------------------------------------------------------------+
*/
const uint16_t AKWF_oscchip_0104 [] = {
37042, 38896, 38233, 38689, 38346, 38633, 38400, 38604, 38438, 38581, 38467, 38563, 38490, 38546, 38509, 38531,
38524, 38520, 38538, 38510, 38548, 38494, 38568, 38386, 37818, 37751, 37793, 37751, 37790, 37750, 37787, 37749,
37782, 37752, 37776, 37752, 37772, 37753, 37766, 37754, 37761, 37755, 37757, 37754, 37753, 37752, 37749, 37752,
37745, 37748, 37743, 37746, 37742, 37742, 37739, 37737, 37740, 37733, 37739, 37728, 37740, 37719, 37751, 37638,
37345, 37353, 37348, 37348, 37349, 37343, 37347, 37338, 37349, 37335, 37347, 37332, 37343, 37328, 37342, 37327,
37340, 37324, 37336, 37321, 37332, 37323, 37327, 37322, 37322, 37324, 37315, 37325, 37308, 37329, 37297, 37334,
37286, 37342, 37271, 37357, 37244, 37395, 37151, 38000, 39634, 39518, 39572, 39548, 39549, 39563, 39524, 39637,
39907, 39933, 39900, 39935, 39891, 39936, 39878, 39978, 40238, 40309, 40249, 40309, 40239, 40317, 40205, 40512,
41037, 41016, 41011, 41023, 40998, 41029, 40981, 41091, 41367, 41388, 41360, 41391, 41346, 41402, 41306, 41664,
42161, 42081, 42126, 42089, 42115, 42088, 42109, 42085, 42103, 42080, 42098, 42075, 42092, 42072, 42084, 42072,
42074, 42075, 42060, 42084, 42037, 42104, 41985, 42373, 42814, 42821, 42763, 42852, 42727, 42881, 42673, 43081,
43470, 43613, 43439, 43627, 43416, 43640, 43375, 43877, 44940, 45053, 44991, 45013, 45030, 44950, 45106, 44634,
44313, 44113, 44411, 44013, 44499, 43916, 44570, 43979, 45511, 44362, 45652, 44164, 45923, 43685, 47010, 36970,
1592, 416, 827, 370, 911, 309, 959, 289, 975, 298, 971, 331, 948, 383, 898, 607,
1694, 1197, 1644, 1261, 1608, 1326, 1573, 1389, 1539, 1453, 1504, 1519, 1464, 1598, 1395, 1908,
2212, 2436, 2141, 2528, 2083, 2620, 2016, 2727, 1933, 2858, 1809, 3056, 1562, 3518, 553, 9183,
};
|
c9445251ff45e28b48b108847df9df9188cf8d53
|
0ec5caf3d1fd25d9863dbe275bfadcd7b117a3e6
|
/2020_03_31/Source/dead.h
|
aeb95c18077c7d4cf94b69bf9d1de27ead15c753
|
[
"LicenseRef-scancode-public-domain",
"Unlicense"
] |
permissive
|
galaxyhaxz/devilution
|
11923308131e172cd7b50cb357f0c2839cd7d5f4
|
28d71e3f1233ce3a27b48aaa2a07c56be19c39c3
|
refs/heads/master
| 2023-06-29T21:13:06.627943
| 2022-04-09T02:02:59
| 2022-04-09T02:02:59
| 150,687,332
| 346
| 58
|
Unlicense
| 2020-03-29T22:47:43
| 2018-09-28T04:49:38
|
C++
|
UTF-8
|
C
| false
| false
| 241
|
h
|
dead.h
|
//HEADER_GOES_HERE
#ifndef __DEAD_H__
#define __DEAD_H__
extern int spurtndx;
extern DeadStruct dead[MAXDEAD];
extern int stonendx;
void InitDead();
void AddDead(int dx, int dy, char dv, int ddir);
void SetDead();
#endif /* __DEAD_H__ */
|
c2ef8b56d36763d83c38f14e8e2525cfcd8a0d47
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/arch/avr32/mm/dma-coherent.c
|
50cdb5b10f0fc7b8bdfae25ffb9b32d5655463de
|
[
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 3,716
|
c
|
dma-coherent.c
|
/*
* Copyright (C) 2004-2006 Atmel Corporation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/dma-mapping.h>
#include <linux/gfp.h>
#include <linux/export.h>
#include <asm/addrspace.h>
#include <asm/cacheflush.h>
void dma_cache_sync(struct device *dev, void *vaddr, size_t size, int direction)
{
/*
* No need to sync an uncached area
*/
if (PXSEG(vaddr) == P2SEG)
return;
switch (direction) {
case DMA_FROM_DEVICE: /* invalidate only */
invalidate_dcache_region(vaddr, size);
break;
case DMA_TO_DEVICE: /* writeback only */
clean_dcache_region(vaddr, size);
break;
case DMA_BIDIRECTIONAL: /* writeback and invalidate */
flush_dcache_region(vaddr, size);
break;
default:
BUG();
}
}
EXPORT_SYMBOL(dma_cache_sync);
static struct page *__dma_alloc(struct device *dev, size_t size,
dma_addr_t *handle, gfp_t gfp)
{
struct page *page, *free, *end;
int order;
/* Following is a work-around (a.k.a. hack) to prevent pages
* with __GFP_COMP being passed to split_page() which cannot
* handle them. The real problem is that this flag probably
* should be 0 on AVR32 as it is not supported on this
* platform--see CONFIG_HUGETLB_PAGE. */
gfp &= ~(__GFP_COMP);
size = PAGE_ALIGN(size);
order = get_order(size);
page = alloc_pages(gfp, order);
if (!page)
return NULL;
split_page(page, order);
/*
* When accessing physical memory with valid cache data, we
* get a cache hit even if the virtual memory region is marked
* as uncached.
*
* Since the memory is newly allocated, there is no point in
* doing a writeback. If the previous owner cares, he should
* have flushed the cache before releasing the memory.
*/
invalidate_dcache_region(phys_to_virt(page_to_phys(page)), size);
*handle = page_to_bus(page);
free = page + (size >> PAGE_SHIFT);
end = page + (1 << order);
/*
* Free any unused pages
*/
while (free < end) {
__free_page(free);
free++;
}
return page;
}
static void __dma_free(struct device *dev, size_t size,
struct page *page, dma_addr_t handle)
{
struct page *end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT);
while (page < end)
__free_page(page++);
}
void *dma_alloc_coherent(struct device *dev, size_t size,
dma_addr_t *handle, gfp_t gfp)
{
struct page *page;
void *ret = NULL;
page = __dma_alloc(dev, size, handle, gfp);
if (page)
ret = phys_to_uncached(page_to_phys(page));
return ret;
}
EXPORT_SYMBOL(dma_alloc_coherent);
void dma_free_coherent(struct device *dev, size_t size,
void *cpu_addr, dma_addr_t handle)
{
void *addr = phys_to_cached(uncached_to_phys(cpu_addr));
struct page *page;
pr_debug("dma_free_coherent addr %p (phys %08lx) size %u\n",
cpu_addr, (unsigned long)handle, (unsigned)size);
BUG_ON(!virt_addr_valid(addr));
page = virt_to_page(addr);
__dma_free(dev, size, page, handle);
}
EXPORT_SYMBOL(dma_free_coherent);
void *dma_alloc_writecombine(struct device *dev, size_t size,
dma_addr_t *handle, gfp_t gfp)
{
struct page *page;
dma_addr_t phys;
page = __dma_alloc(dev, size, handle, gfp);
if (!page)
return NULL;
phys = page_to_phys(page);
*handle = phys;
/* Now, map the page into P3 with write-combining turned on */
return __ioremap(phys, size, _PAGE_BUFFER);
}
EXPORT_SYMBOL(dma_alloc_writecombine);
void dma_free_writecombine(struct device *dev, size_t size,
void *cpu_addr, dma_addr_t handle)
{
struct page *page;
iounmap(cpu_addr);
page = phys_to_page(handle);
__dma_free(dev, size, page, handle);
}
EXPORT_SYMBOL(dma_free_writecombine);
|
53d6a8d2b6210d0f36529d110fc3c940a8027687
|
e65a4dbfbfb0e54e59787ba7741efee12f7687f3
|
/devel/libdispatch/files/patch-src_init.c
|
33af1ade1a36d71d0a21f3fc825f106fa22440d2
|
[
"BSD-2-Clause"
] |
permissive
|
freebsd/freebsd-ports
|
86f2e89d43913412c4f6b2be3e255bc0945eac12
|
605a2983f245ac63f5420e023e7dce56898ad801
|
refs/heads/main
| 2023-08-30T21:46:28.720924
| 2023-08-30T19:33:44
| 2023-08-30T19:33:44
| 1,803,961
| 916
| 918
|
NOASSERTION
| 2023-09-08T04:06:26
| 2011-05-26T11:15:35
| null |
UTF-8
|
C
| false
| false
| 1,253
|
c
|
patch-src_init.c
|
--- src/init.c.orig 2021-09-17 04:54:52 UTC
+++ src/init.c
@@ -961,7 +961,6 @@ _dispatch_continuation_get_function_symbol(dispatch_co
return dc->dc_func;
}
-#if HAVE_MACH
void
_dispatch_bug_kevent_client(const char *msg, const char *filter,
const char *operation, int err, uint64_t ident, uint64_t udata,
@@ -1005,7 +1004,6 @@ _dispatch_bug_kevent_client(const char *msg, const cha
msg, strerror(err), err, udata, filter, ident, ident, func);
}
}
-#endif // HAVE_MACH
#if RDAR_49023449
@@ -1048,7 +1046,7 @@ _dispatch_bug_kevent_vanished(dispatch_unote_t du)
"{ %p[%s], ident: %" PRIdPTR " / 0x%" PRIxPTR ", handler: %p }",
dux_type(du._du)->dst_kind, dou._dq,
dou._dq->dq_label ? dou._dq->dq_label : "<unknown>",
- du._du->du_ident, du._du->du_ident, func);
+ (intptr_t)du._du->du_ident, (uintptr_t)du._du->du_ident, func);
}
#endif // RDAR_49023449
@@ -1153,8 +1151,8 @@ _dispatch_logv_init(void *context DISPATCH_UNUSED)
}
#else
dprintf(dispatch_logfile, "=== log file opened for %s[%u] at "
- "%ld.%06u ===\n", getprogname() ?: "", getpid(),
- tv.tv_sec, (int)tv.tv_usec);
+ "%lld.%06u ===\n", getprogname() ?: "", getpid(),
+ (time_t)tv.tv_sec, (int)tv.tv_usec);
#endif
}
}
|
e6ebd471f56d3f6f4ceaa55559c00ae448aefed4
|
88ae8695987ada722184307301e221e1ba3cc2fa
|
/third_party/ffmpeg/libavcodec/vaapi_mpeg4.c
|
4e74e0382b69c2ad382d945e6427a0ed7924151d
|
[
"Apache-2.0",
"LGPL-2.0-or-later",
"MIT",
"GPL-1.0-or-later",
"BSD-3-Clause",
"LGPL-2.1-only",
"LGPL-3.0-only",
"GPL-2.0-only",
"LGPL-2.1-or-later",
"GPL-3.0-or-later",
"LGPL-3.0-or-later",
"IJG",
"LicenseRef-scancode-other-permissive",
"GPL-2.0-or-later",
"GPL-3.0-only"
] |
permissive
|
iridium-browser/iridium-browser
|
71d9c5ff76e014e6900b825f67389ab0ccd01329
|
5ee297f53dc7f8e70183031cff62f37b0f19d25f
|
refs/heads/master
| 2023-08-03T16:44:16.844552
| 2023-07-20T15:17:00
| 2023-07-23T16:09:30
| 220,016,632
| 341
| 40
|
BSD-3-Clause
| 2021-08-13T13:54:45
| 2019-11-06T14:32:31
| null |
UTF-8
|
C
| false
| false
| 8,385
|
c
|
vaapi_mpeg4.c
|
/*
* MPEG-4 / H.263 HW decode acceleration through VA API
*
* Copyright (C) 2008-2009 Splitted-Desktop Systems
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config_components.h"
#include "h263.h"
#include "hwconfig.h"
#include "mpeg4videodec.h"
#include "mpegvideo.h"
#include "mpegvideodec.h"
#include "vaapi_decode.h"
/** Reconstruct bitstream intra_dc_vlc_thr */
static int mpeg4_get_intra_dc_vlc_thr(Mpeg4DecContext *s)
{
switch (s->intra_dc_threshold) {
case 99: return 0;
case 13: return 1;
case 15: return 2;
case 17: return 3;
case 19: return 4;
case 21: return 5;
case 23: return 6;
case 0: return 7;
}
return 0;
}
static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
{
Mpeg4DecContext *ctx = avctx->priv_data;
MpegEncContext *s = &ctx->m;
VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
VAPictureParameterBufferMPEG4 pic_param;
int i, err;
pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);
pic_param = (VAPictureParameterBufferMPEG4) {
.vop_width = s->width,
.vop_height = s->height,
.forward_reference_picture = VA_INVALID_ID,
.backward_reference_picture = VA_INVALID_ID,
.vol_fields.bits = {
.short_video_header = avctx->codec->id == AV_CODEC_ID_H263,
.chroma_format = CHROMA_420,
.interlaced = !s->progressive_sequence,
.obmc_disable = 1,
.sprite_enable = ctx->vol_sprite_usage,
.sprite_warping_accuracy = ctx->sprite_warping_accuracy,
.quant_type = s->mpeg_quant,
.quarter_sample = s->quarter_sample,
.data_partitioned = s->data_partitioning,
.reversible_vlc = ctx->rvlc,
.resync_marker_disable = !ctx->resync_marker,
},
.no_of_sprite_warping_points = ctx->num_sprite_warping_points,
.quant_precision = s->quant_precision,
.vop_fields.bits = {
.vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I,
.backward_reference_vop_coding_type =
s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f->pict_type - AV_PICTURE_TYPE_I : 0,
.vop_rounding_type = s->no_rounding,
.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(ctx),
.top_field_first = s->top_field_first,
.alternate_vertical_scan_flag = s->alternate_scan,
},
.vop_fcode_forward = s->f_code,
.vop_fcode_backward = s->b_code,
.vop_time_increment_resolution = avctx->framerate.num,
.num_macroblocks_in_gob = s->mb_width * H263_GOB_HEIGHT(s->height),
.num_gobs_in_vop =
(s->mb_width * s->mb_height) / (s->mb_width * H263_GOB_HEIGHT(s->height)),
.TRB = s->pb_time,
.TRD = s->pp_time,
};
for (i = 0; i < ctx->num_sprite_warping_points && i < 3; i++) {
pic_param.sprite_trajectory_du[i] = ctx->sprite_traj[i][0];
pic_param.sprite_trajectory_dv[i] = ctx->sprite_traj[i][1];
}
if (s->pict_type == AV_PICTURE_TYPE_B)
pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
if (s->pict_type != AV_PICTURE_TYPE_I)
pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
err = ff_vaapi_decode_make_param_buffer(avctx, pic,
VAPictureParameterBufferType,
&pic_param, sizeof(pic_param));
if (err < 0)
goto fail;
/* Only the first inverse quantisation method uses the weighting matrices */
if (pic_param.vol_fields.bits.quant_type) {
VAIQMatrixBufferMPEG4 iq_matrix;
iq_matrix.load_intra_quant_mat = 1;
iq_matrix.load_non_intra_quant_mat = 1;
for (i = 0; i < 64; i++) {
int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
iq_matrix.intra_quant_mat[i] = s->intra_matrix[n];
iq_matrix.non_intra_quant_mat[i] = s->inter_matrix[n];
}
err = ff_vaapi_decode_make_param_buffer(avctx, pic,
VAIQMatrixBufferType,
&iq_matrix, sizeof(iq_matrix));
if (err < 0)
goto fail;
}
return 0;
fail:
ff_vaapi_decode_cancel(avctx, pic);
return err;
}
static int vaapi_mpeg4_end_frame(AVCodecContext *avctx)
{
MpegEncContext *s = avctx->priv_data;
VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
int ret;
ret = ff_vaapi_decode_issue(avctx, pic);
if (ret < 0)
goto fail;
ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
fail:
return ret;
}
static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
{
MpegEncContext *s = avctx->priv_data;
VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
VASliceParameterBufferMPEG4 slice_param;
int err;
slice_param = (VASliceParameterBufferMPEG4) {
.slice_data_size = size,
.slice_data_offset = 0,
.slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
.macroblock_offset = get_bits_count(&s->gb) % 8,
.macroblock_number = 0,
.quant_scale = s->qscale,
};
err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
&slice_param, sizeof(slice_param),
buffer, size);
if (err < 0) {
ff_vaapi_decode_cancel(avctx, pic);
return err;
}
return 0;
}
#if CONFIG_MPEG4_VAAPI_HWACCEL
const AVHWAccel ff_mpeg4_vaapi_hwaccel = {
.name = "mpeg4_vaapi",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG4,
.pix_fmt = AV_PIX_FMT_VAAPI,
.start_frame = &vaapi_mpeg4_start_frame,
.end_frame = &vaapi_mpeg4_end_frame,
.decode_slice = &vaapi_mpeg4_decode_slice,
.frame_priv_data_size = sizeof(VAAPIDecodePicture),
.init = &ff_vaapi_decode_init,
.uninit = &ff_vaapi_decode_uninit,
.frame_params = &ff_vaapi_common_frame_params,
.priv_data_size = sizeof(VAAPIDecodeContext),
.caps_internal = HWACCEL_CAP_ASYNC_SAFE,
};
#endif
#if CONFIG_H263_VAAPI_HWACCEL
const AVHWAccel ff_h263_vaapi_hwaccel = {
.name = "h263_vaapi",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_H263,
.pix_fmt = AV_PIX_FMT_VAAPI,
.start_frame = &vaapi_mpeg4_start_frame,
.end_frame = &vaapi_mpeg4_end_frame,
.decode_slice = &vaapi_mpeg4_decode_slice,
.frame_priv_data_size = sizeof(VAAPIDecodePicture),
.init = &ff_vaapi_decode_init,
.uninit = &ff_vaapi_decode_uninit,
.frame_params = &ff_vaapi_common_frame_params,
.priv_data_size = sizeof(VAAPIDecodeContext),
.caps_internal = HWACCEL_CAP_ASYNC_SAFE,
};
#endif
|
8c159cda4740b0f755a30e87b7d8153ba55dd43f
|
e65a4dbfbfb0e54e59787ba7741efee12f7687f3
|
/converters/uulib/files/patch-uulib_uuscan.c
|
55bafa7aba46ea6e8abd96624921a0e58ca36626
|
[
"BSD-2-Clause"
] |
permissive
|
freebsd/freebsd-ports
|
86f2e89d43913412c4f6b2be3e255bc0945eac12
|
605a2983f245ac63f5420e023e7dce56898ad801
|
refs/heads/main
| 2023-08-30T21:46:28.720924
| 2023-08-30T19:33:44
| 2023-08-30T19:33:44
| 1,803,961
| 916
| 918
|
NOASSERTION
| 2023-09-08T04:06:26
| 2011-05-26T11:15:35
| null |
UTF-8
|
C
| false
| false
| 610
|
c
|
patch-uulib_uuscan.c
|
--- uulib/uuscan.c.orig Tue Mar 2 01:52:27 2004
+++ uulib/uuscan.c Sun Jul 3 16:50:37 2005
@@ -251,8 +251,9 @@
/*
* see if line was terminated with CR. Otherwise, it continues ...
*/
- c = strlen (ptr);
- if (c>0 && (ptr[c-1] == '\012' || ptr[c-1] == '\015'))
+ c = strlen (uugen_inbuffer);
+ if (c>0 &&
+ (uugen_inbuffer[c-1] == '\012' || uugen_inbuffer[c-1] == '\015'))
hadcr = 1;
else
hadcr = 0;
@@ -261,6 +262,7 @@
* strip whitespace
*/
+ c = strlen (ptr);
ptr += c;
llength += c;
while (llength && isspace(*(ptr-1))) {
|
2d9f3a9dd61244d3f6e136d30bec7d228d6a7f24
|
d9c343e0c7824b827f23c41b2c603b5eb59d3f4b
|
/SM2/Linux/include/xy_ecpoint.h
|
52d6c55adfcaa42f56f6b727f5a7bd339ebec1b9
|
[] |
no_license
|
NEWPLAN/SMx
|
d4a609687aa7338f96426470def4abf9527e6144
|
703ba41e52d73a0a496c0d0df06aa686299e98ea
|
refs/heads/master
| 2023-02-22T04:06:11.522348
| 2023-02-11T14:24:19
| 2023-02-11T14:24:19
| 91,858,424
| 377
| 188
| null | 2019-09-17T08:22:55
| 2017-05-20T01:57:38
|
C
|
UTF-8
|
C
| false
| false
| 937
|
h
|
xy_ecpoint.h
|
/*************************************************************************
> File Name: xy_ecpoint.h
> Author:NEWPLAN
> E-mail:newplan001@163.com
> Created Time: Thu Apr 13 23:55:50 2017
************************************************************************/
#ifndef XY_ECPOINT_H
#define XY_ECPOINT_H
#include <openssl/ec.h>
#include "ec_param.h"
xy_ecpoint * xy_ecpoint_new(ec_param *);
void xy_ecpoint_free(xy_ecpoint *);
int xy_ecpoint_mul_bignum(xy_ecpoint *result, xy_ecpoint *a, BIGNUM *number
, ec_param *ecp);
int xy_ecpoint_add_xy_ecpoint(xy_ecpoint *result, xy_ecpoint *a, xy_ecpoint *b
, ec_param *ecp);
int xy_ecpoint_init_xy(xy_ecpoint *result, BIGNUM *x, BIGNUM *y
, ec_param *ecp);
int xy_ecpoint_init_ec_point(xy_ecpoint *result, EC_POINT *ec_point
, ec_param *ecp);
#endif
|
ac42bd6cf76da87f46a7ca203479889091087463
|
88ae8695987ada722184307301e221e1ba3cc2fa
|
/third_party/xnnpack/src/src/s8-vclamp/s8-vclamp-scalar-x4.c
|
db77119fcb0b8712eb74bf5a01931c15b4837ab3
|
[
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"Apache-2.0",
"LGPL-2.0-or-later",
"MIT",
"GPL-1.0-or-later"
] |
permissive
|
iridium-browser/iridium-browser
|
71d9c5ff76e014e6900b825f67389ab0ccd01329
|
5ee297f53dc7f8e70183031cff62f37b0f19d25f
|
refs/heads/master
| 2023-08-03T16:44:16.844552
| 2023-07-20T15:17:00
| 2023-07-23T16:09:30
| 220,016,632
| 341
| 40
|
BSD-3-Clause
| 2021-08-13T13:54:45
| 2019-11-06T14:32:31
| null |
UTF-8
|
C
| false
| false
| 1,612
|
c
|
s8-vclamp-scalar-x4.c
|
// Copyright 2021 Google LLC
//
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree.
#include <assert.h>
#include <xnnpack/math.h>
#include <xnnpack/vunary.h>
void xnn_s8_vclamp_ukernel__scalar_x4(
size_t batch,
const int8_t* input,
int8_t* output,
const union xnn_s8_minmax_params params[restrict XNN_MIN_ELEMENTS(1)])
{
assert(batch != 0);
assert(batch % sizeof(int8_t) == 0);
assert(input != NULL);
assert(output != NULL);
const int32_t voutput_max = params->scalar.max;
const int32_t voutput_min = params->scalar.min;
for (; batch >= 4 * sizeof(int8_t); batch -= 4 * sizeof(int8_t)) {
int32_t vt0 = (int32_t) input[0];
int32_t vt1 = (int32_t) input[1];
int32_t vt2 = (int32_t) input[2];
int32_t vt3 = (int32_t) input[3];
input += 4;
vt0 = math_max_s32(vt0, voutput_min);
vt1 = math_max_s32(vt1, voutput_min);
vt2 = math_max_s32(vt2, voutput_min);
vt3 = math_max_s32(vt3, voutput_min);
vt0 = math_min_s32(vt0, voutput_max);
vt1 = math_min_s32(vt1, voutput_max);
vt2 = math_min_s32(vt2, voutput_max);
vt3 = math_min_s32(vt3, voutput_max);
output[0] = (int8_t) vt0;
output[1] = (int8_t) vt1;
output[2] = (int8_t) vt2;
output[3] = (int8_t) vt3;
output += 4;
}
if XNN_UNLIKELY(batch != 0) {
do {
int32_t vt = (int32_t) *input++;
vt = math_max_s32(vt, voutput_min);
vt = math_min_s32(vt, voutput_max);
*output++ = (int8_t) vt;
batch -= sizeof(int8_t);
} while (batch != 0);
}
}
|
d32574fc9bf0fbf4faaf7857fb560f010890ec9e
|
9de0cec678bc4a3bec2b4adabef9f39ff5b4afac
|
/PWGHF/hfe/macros/AddTaskHFEreducedEvent.C
|
0dcb92a5493beb90ad689c4a680d34524f5763f1
|
[] |
permissive
|
alisw/AliPhysics
|
91bf1bd01ab2af656a25ff10b25e618a63667d3e
|
5df28b2b415e78e81273b0d9bf5c1b99feda3348
|
refs/heads/master
| 2023-08-31T20:41:44.927176
| 2023-08-31T14:51:12
| 2023-08-31T14:51:12
| 61,661,378
| 129
| 1,150
|
BSD-3-Clause
| 2023-09-14T18:48:45
| 2016-06-21T19:31:29
|
C++
|
UTF-8
|
C
| false
| false
| 1,841
|
c
|
AddTaskHFEreducedEvent.C
|
AliAnalysisTask *AddTaskHFEreducedEvent(UInt_t trigger=131073,Int_t minnbTPC=70,Int_t minnbTPCPID=80,Int_t minnbITS=3,Float_t nbOfSigmaTOF=3.){
//
// Produce reduced events
//
// Name
TString appendixx(TString::Format("HFEreducedEventt%dTPCcl%dpidcl%dITScl%dTOFsigma%d",(Int_t)trigger,(Int_t) minnbTPC,(Int_t) minnbTPCPID,(Int_t) minnbITS,(Int_t) nbOfSigmaTOF));
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
// task
AliHFEreducedEventCreatorAOD *reducedEventCreator = new AliHFEreducedEventCreatorAOD("HFEreducedEventCreator");
reducedEventCreator->SetMinNclustersTPC(minnbTPC);
reducedEventCreator->SetMinNclustersTPCPID(minnbTPCPID);
reducedEventCreator->SetMinNclustersITS(minnbITS);
reducedEventCreator->SetNbOfTOFSigma(nbOfSigmaTOF);
reducedEventCreator->SelectCollisionCandidates(trigger);
//AliHFEpidTPC *tpcpid = reducedEventCreator->GetTPCResponse();
/*
TF1 *etaCorrection = GetEtaCorrection();
if(etaCorrection){
tpcpid->SetEtaCorrection(etaCorrection);
}
*/
/*
TF1 *centralityCorrection = new TF1("centralityCorrection", "pol1", 0., 10000.);
centralityCorrection->SetParameter(0, 1.0);
centralityCorrection->SetParameter(1, -0.00002);
tpcpid->SetCentralityCorrection(centralityCorrection);
*/
mgr->AddTask(reducedEventCreator);
TString containerName = mgr->GetCommonFileName();
containerName += ":";
containerName += appendixx.Data();
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
mgr->ConnectOutput(reducedEventCreator,1, mgr->CreateContainer(Form("list_%s",appendixx.Data()), TTree::Class(),AliAnalysisManager::kOutputContainer,containerName.Data()));
mgr->ConnectInput(reducedEventCreator,0, cinput );
return NULL;
}
|
452d87c71a23cfef60b22be6eca79ed57c80257d
|
28d0f8c01599f8f6c711bdde0b59f9c2cd221203
|
/sys/arch/ofppc/include/bus_defs.h
|
687b09065f299b3e9e2351b1dfbc12fa5d089f88
|
[] |
no_license
|
NetBSD/src
|
1a9cbc22ed778be638b37869ed4fb5c8dd616166
|
23ee83f7c0aea0777bd89d8ebd7f0cde9880d13c
|
refs/heads/trunk
| 2023-08-31T13:24:58.105962
| 2023-08-27T15:50:47
| 2023-08-27T15:50:47
| 88,439,547
| 656
| 348
| null | 2023-07-20T20:07:24
| 2017-04-16T20:03:43
| null |
UTF-8
|
C
| false
| false
| 285
|
h
|
bus_defs.h
|
/* $NetBSD: bus_defs.h,v 1.1 2011/07/01 17:10:00 dyoung Exp $ */
#ifndef _OFPPC_BUS_DEFS_H_
#define _OFPPC_BUS_DEFS_H_
#define PHYS_TO_BUS_MEM(t,x) (x)
#define BUS_MEM_TO_PHYS(t,x) (x)
#include <powerpc/ofw_bus_defs.h>
#include <powerpc/bus_defs.h>
#endif /* _OFPPC_BUS_DEFS_H_ */
|
f82d971b17445952f270f64cf0508f063e421965
|
de21f9075f55640514c29ef0f1fe3f0690845764
|
/regression/strings/test5/test.c
|
812a20f344229a05aa2e44be7046b4f7b4e3dc71
|
[
"BSD-2-Clause",
"LicenseRef-scancode-unknown-license-reference",
"BSD-4-Clause"
] |
permissive
|
diffblue/cbmc
|
975a074ac445febb3b5715f8792beb545522dc18
|
decd2839c2f51a54b2ad0f3e89fdc1b4bf78cd16
|
refs/heads/develop
| 2023-08-31T05:52:05.342195
| 2023-08-30T13:31:51
| 2023-08-30T13:31:51
| 51,877,056
| 589
| 309
|
NOASSERTION
| 2023-09-14T18:49:17
| 2016-02-16T23:03:52
|
C++
|
UTF-8
|
C
| false
| false
| 533
|
c
|
test.c
|
#include <assert.h>
#include "../cprover-string-hack.h"
void main()
{
__CPROVER_string x, y, z, w;
if (__CPROVER_string_equal(z, __CPROVER_string_concat(x, y)) &&
__CPROVER_string_equal(z, __CPROVER_string_concat(w, __CPROVER_string_literal("c"))) &&
__CPROVER_string_equal(__CPROVER_string_concat(__CPROVER_string_literal("c"), y), __CPROVER_string_concat(__CPROVER_string_literal("c"), __CPROVER_string_concat(__CPROVER_string_literal("b"), __CPROVER_string_literal("c"))))) {
assert(0);
}
}
|
7ca497f3bd55d5d95c4acf6a69be86da663b2aae
|
50dd46b8ece33f3cdd174284b15d1d51f89669d4
|
/third_party/edk2/EdkCompatibilityPkg/Foundation/Guid/PrimaryConsoleOutDevice/PrimaryConsoleOutDevice.h
|
09d1e0fd21b823c38f75eda2a1b45a1138b079e3
|
[
"LicenseRef-scancode-generic-cla",
"Apache-2.0",
"BSD-2-Clause",
"OpenSSL"
] |
permissive
|
google/google-ctf
|
f99da1ee07729bbccb869fff1cbaed6a80e43bcc
|
df02323eaf945d15e124801c74abaadca2749dc7
|
refs/heads/master
| 2023-08-31T14:30:27.548081
| 2023-08-29T13:04:20
| 2023-08-29T13:04:20
| 131,317,137
| 4,136
| 607
|
Apache-2.0
| 2023-08-30T22:17:02
| 2018-04-27T15:56:03
|
Go
|
UTF-8
|
C
| false
| false
| 1,047
|
h
|
PrimaryConsoleOutDevice.h
|
/*++
Copyright (c) 2004, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
PrimaryConsoleOutDevice.h
Abstract:
--*/
#ifndef _PRIMARY_CONSOLE_OUT_DEVICE_H_
#define _PRIMARY_CONSOLE_OUT_DEVICE_H_
#define EFI_PRIMARY_CONSOLE_OUT_DEVICE_GUID \
{ 0x62bdf38a, 0xe3d5, 0x492c, {0x95, 0xc, 0x23, 0xa7, 0xf6, 0x6e, 0x67, 0x2e} }
extern EFI_GUID gEfiPrimaryConsoleOutDeviceGuid;
#endif
|
65a13b44d718cffafb5fe2719441e9948294ad38
|
1f399edf85d995443d01f66d77eca0723886d0ff
|
/hypervisor/include/arch/x86/asm/rtct.h
|
c9819f514fa6241f0adb60f38247e4032d2407ff
|
[
"BSD-3-Clause"
] |
permissive
|
projectacrn/acrn-hypervisor
|
f9c5864d54929a5d2fa36b5e78c08f19b46b8f98
|
390740aa1b1e9d62c51f8e3afa0c29e07e43fa23
|
refs/heads/master
| 2023-08-18T05:07:01.310327
| 2023-08-11T07:49:36
| 2023-08-16T13:20:27
| 123,983,554
| 1,059
| 686
|
BSD-3-Clause
| 2023-09-14T09:51:10
| 2018-03-05T21:52:25
|
C
|
UTF-8
|
C
| false
| false
| 2,008
|
h
|
rtct.h
|
/*
* Copyright (C) 2020-2022 Intel Corporation.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef RTCT_H
#define RTCT_H
#include <acpi.h>
#include <ptdev.h>
#include "misc_cfg.h"
#define RTCT_ENTRY_TYPE_RTCD_LIMIT 1U
#define RTCT_ENTRY_TYPE_RTCM_BINARY 2U
#define RTCT_ENTRY_TYPE_WRC_L3_MASKS 3U
#define RTCT_ENTRY_TYPE_GT_L3_MASKS 4U
#define RTCT_ENTRY_TYPE_SOFTWARE_SRAM 5U
#define RTCT_ENTRY_TYPE_STREAM_DATAPATH 6U
#define RTCT_ENTRY_TYPE_TIMEAWARE_SUBSYS 7U
#define RTCT_ENTRY_TYPE_RT_IOMMU 8U
#define RTCT_ENTRY_TYPE_MEM_HIERARCHY_LATENCY 9U
#define RTCT_V2_COMPATIBILITY 0U
#define RTCT_V2_RTCD_LIMIT 1U
#define RTCT_V2_CRL_BINARY 2U
#define RTCT_V2_IA_WAYMASK 3U
#define RTCT_V2_WRC_WAYMASK 4U
#define RTCT_V2_GT_WAYMASK 5U
#define RTCT_V2_SSRAM_WAYMASK 6U
#define RTCT_V2_SSRAM 7U
#define RTCT_V2_MEMORY_HIERARCHY_LATENCY 8U
#define RTCT_V2_ERROR_LOG_ADDRESS 9U
/*
* PRE_RTVM_SW_SRAM_MAX_SIZE is for Prelaunch VM only and
* is generated by config tool on platform that Software SRAM is configured.
*
* For cases that Software SRAM is not configured, PRE_RTVM_SW_SRAM_MAX_SIZE is defined as 0
*/
#define PRE_RTVM_SW_SRAM_BASE_GPA (GPU_OPREGION_GPA - PRE_RTVM_SW_SRAM_MAX_SIZE)
struct rtct_entry {
uint16_t size;
uint16_t format;
uint32_t type;
uint32_t data[64];
} __packed;
struct rtct_entry_data_compatibility {
uint32_t rtct_ver_major;
uint32_t rtct_ver_minor;
uint32_t rtcd_ver_major;
uint32_t rtcd_ver_minor;
} __packed;
struct rtct_entry_data_rtcm_binary
{
uint64_t address;
uint32_t size;
} __packed;
struct rtct_entry_data_ssram
{
uint32_t cache_level;
uint64_t base;
uint32_t ways;
uint32_t size;
uint32_t apic_id_0; /*only the first core is responsible for initialization of L3 mem region*/
} __packed;
struct rtct_entry_data_ssram_v2 {
uint32_t cache_level;
uint32_t cache_id;
uint64_t base;
uint32_t size;
uint32_t shared;
} __packed;
uint64_t get_software_sram_base(void);
uint64_t get_software_sram_size(void);
#endif /* RTCT_H */
|
70128bd2c875a16b24c28752c61d48a21d13a318
|
79d343002bb63a44f8ab0dbac0c9f4ec54078c3a
|
/lib/libc/include/any-windows-any/dxdiag.h
|
6f42979aa3d715152ca2888c38a8de118faacd74
|
[
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain",
"MIT"
] |
permissive
|
ziglang/zig
|
4aa75d8d3bcc9e39bf61d265fd84b7f005623fc5
|
f4c9e19bc3213c2bc7e03d7b06d7129882f39f6c
|
refs/heads/master
| 2023-08-31T13:16:45.980913
| 2023-08-31T05:50:29
| 2023-08-31T05:50:29
| 40,276,274
| 25,560
| 2,399
|
MIT
| 2023-09-14T21:09:50
| 2015-08-06T00:51:28
|
Zig
|
UTF-8
|
C
| false
| false
| 6,699
|
h
|
dxdiag.h
|
#undef INTERFACE
/*
* Copyright (C) 2004 Raphael Junqueira
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_DXDIAG_H
#define __WINE_DXDIAG_H
#include <ole2.h>
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
/*****************************************************************************
* #defines and error codes
*/
#define DXDIAG_DX9_SDK_VERSION 111
#define _FACDXDIAG 0x007
#define MAKE_DXDIAGHRESULT( code ) MAKE_HRESULT( 1, _FACDXDIAG, code )
/*
* DXDiag Errors
*/
#define DXDIAG_E_INSUFFICIENT_BUFFER MAKE_DXDIAGHRESULT(0x007A)
/*****************************************************************************
* DXDiag structures Typedefs
*/
typedef struct _DXDIAG_INIT_PARAMS {
DWORD dwSize;
DWORD dwDxDiagHeaderVersion;
WINBOOL bAllowWHQLChecks;
VOID* pReserved;
} DXDIAG_INIT_PARAMS;
/*****************************************************************************
* Predeclare the interfaces
*/
/* CLSIDs */
DEFINE_GUID(CLSID_DxDiagProvider, 0xA65B8071, 0x3BFE, 0x4213, 0x9A, 0x5B, 0x49, 0x1D, 0xA4, 0x46, 0x1C, 0xA7);
/* IIDs */
DEFINE_GUID(IID_IDxDiagProvider, 0x9C6B4CB0, 0x23F8, 0x49CC, 0xA3, 0xED, 0x45, 0xA5, 0x50, 0x00, 0xA6, 0xD2);
DEFINE_GUID(IID_IDxDiagContainer, 0x7D0F462F, 0x4064, 0x4862, 0xBC, 0x7F, 0x93, 0x3E, 0x50, 0x58, 0xC1, 0x0F);
/* typedef definitions */
typedef struct IDxDiagProvider *LPDXDIAGPROVIDER, *PDXDIAGPROVIDER;
typedef struct IDxDiagContainer *LPDXDIAGCONTAINER, *PDXDIAGCONTAINER;
/*****************************************************************************
* IDxDiagContainer interface
*/
#ifdef WINE_NO_UNICODE_MACROS
#undef GetProp
#endif
#define INTERFACE IDxDiagContainer
DECLARE_INTERFACE_(IDxDiagContainer,IUnknown)
{
/*** IUnknown methods ***/
STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
STDMETHOD_(ULONG,AddRef)(THIS) PURE;
STDMETHOD_(ULONG,Release)(THIS) PURE;
/*** IDxDiagContainer methods ***/
STDMETHOD(GetNumberOfChildContainers)(THIS_ DWORD* pdwCount) PURE;
STDMETHOD(EnumChildContainerNames)(THIS_ DWORD dwIndex, LPWSTR pwszContainer, DWORD cchContainer) PURE;
STDMETHOD(GetChildContainer)(THIS_ LPCWSTR pwszContainer, IDxDiagContainer** ppInstance) PURE;
STDMETHOD(GetNumberOfProps)(THIS_ DWORD* pdwCount) PURE;
STDMETHOD(EnumPropNames)(THIS_ DWORD dwIndex, LPWSTR pwszPropName, DWORD cchPropName) PURE;
STDMETHOD(GetProp)(THIS_ LPCWSTR pwszPropName, VARIANT* pvarProp) PURE;
};
#undef INTERFACE
#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IDxDiagContainer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDxDiagContainer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDxDiagContainer_Release(p) (p)->lpVtbl->Release(p)
/*** IDxDiagContainer methods ***/
#define IDxDiagContainer_GetNumberOfChildContainers(p,a) (p)->lpVtbl->GetNumberOfChildContainers(p,a)
#define IDxDiagContainer_EnumChildContainerNames(p,a,b,c) (p)->lpVtbl->EnumChildContainerNames(p,a,b,c)
#define IDxDiagContainer_GetChildContainer(p,a,b) (p)->lpVtbl->GetChildContainer(p,a,b)
#define IDxDiagContainer_GetNumberOfProps(p,a) (p)->lpVtbl->GetNumberOfProps(p,a)
#define IDxDiagContainer_EnumPropNames(p,a,b,c) (p)->lpVtbl->EnumPropNames(p,a,b,c)
#define IDxDiagContainer_GetProp(p,a,b) (p)->lpVtbl->GetProp(p,a,b)
#else
/*** IUnknown methods ***/
#define IDxDiagContainer_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
#define IDxDiagContainer_AddRef(p) (p)->AddRef()
#define IDxDiagContainer_Release(p) (p)->Release()
/*** IDxDiagContainer methods ***/
#define IDxDiagContainer_GetNumberOfChildContainers(p,a) (p)->GetNumberOfChildContainers(a)
#define IDxDiagContainer_EnumChildContainerNames(p,a,b,c) (p)->EnumChildContainerNames(a,b,c)
#define IDxDiagContainer_GetChildContainer(p,a,b) (p)->GetChildContainer(a,b)
#define IDxDiagContainer_GetNumberOfProps(p,a) (p)->GetNumberOfProps(a)
#define IDxDiagContainer_EnumPropNames(p,a,b,c) (p)->EnumPropNames(a,b,c)
#define IDxDiagContainer_GetProp(p,a,b) (p)->GetProp(a,b)
#endif
/*****************************************************************************
* IDxDiagProvider interface
*/
#define INTERFACE IDxDiagProvider
DECLARE_INTERFACE_(IDxDiagProvider,IUnknown)
{
/*** IUnknown methods ***/
STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
STDMETHOD_(ULONG,AddRef)(THIS) PURE;
STDMETHOD_(ULONG,Release)(THIS) PURE;
/*** IDxDiagProvider methods ***/
STDMETHOD(Initialize)(THIS_ DXDIAG_INIT_PARAMS* pParams) PURE;
STDMETHOD(GetRootContainer)(THIS_ IDxDiagContainer** ppInstance) PURE;
};
#undef INTERFACE
#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IDxDiagProvider_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDxDiagProvider_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDxDiagProvider_Release(p) (p)->lpVtbl->Release(p)
/*** IDxDiagProvider methods ***/
#define IDxDiagProvider_Initialize(p,a) (p)->lpVtbl->Initialize(p,a)
#define IDxDiagProvider_GetRootContainer(p,a) (p)->lpVtbl->GetRootContainer(p,a)
#else
/*** IUnknown methods ***/
#define IDxDiagProvider_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
#define IDxDiagProvider_AddRef(p) (p)->AddRef()
#define IDxDiagProvider_Release(p) (p)->Release()
/*** IDxDiagProvider methods ***/
#define IDxDiagProvider_Initialize(p,a) (p)->Initialize(a)
#define IDxDiagProvider_GetRootContainer(p,a) (p)->GetRootContainer(a)
#endif
#ifdef __cplusplus
}
#endif
#endif
|
ae632aae848c4e919bea696bbad3ce2f61297a5e
|
53360319eaf69ff75f34e1c2c45cbcdfd12842c9
|
/thirdparty/ryu/blp_d2cpp.c
|
134d6f169e21f85d07123e82a3040f6016d31517
|
[
"Apache-2.0",
"BSL-1.0"
] |
permissive
|
bloomberg/bde
|
229de23237d9cc0937ec2d0b69ef7dfcb1fa2154
|
7cc8e30c7218eaffbc31f518bd40794cc79f7282
|
refs/heads/main
| 2023-09-01T08:52:24.600136
| 2023-08-31T17:43:40
| 2023-08-31T17:43:40
| 6,619,178
| 1,429
| 338
|
Apache-2.0
| 2023-05-20T13:33:26
| 2012-11-09T20:00:30
|
C++
|
UTF-8
|
C
| false
| false
| 35,636
|
c
|
blp_d2cpp.c
|
// Copyright 2018 Ulf Adams
//
// The contents of this file may be used under the terms of the Apache License,
// Version 2.0.
//
// (See accompanying file LICENSE-Apache or copy at
// http://www.apache.org/licenses/LICENSE-2.0)
//
// Alternatively, the contents of this file may be used under the terms of
// the Boost Software License, Version 1.0.
// (See accompanying file LICENSE-Boost or copy at
// https://www.boost.org/LICENSE_1_0.txt)
//
// Unless required by applicable law or agreed to in writing, this software
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.
// Runtime compiler options:
// -DRYU_DEBUG Generate verbose debugging output to stdout.
//
// -DRYU_ONLY_64_BIT_OPS Avoid using uint128_t or 64-bit intrinsics. Slower,
// depending on your compiler.
//
// -DRYU_OPTIMIZE_SIZE Use smaller lookup tables. Instead of storing every
// required power of 5, only store every 26th entry, and compute
// intermediate values with a multiplication. This reduces the lookup table
// size by about 10x (only one case, and only double) at the cost of some
// performance. Currently requires MSVC intrinsics.
//
// Bloomberg LP CHANGELOG
//
// 2021.07.16 Initial version built from d2s.c of Ulf's Ryu code
//
// 2021.08.24 Fixed printing of decimal integers to use full precisions, added
// decimal and scientific formats, changed non-numeric values'
// textual representation to XSD 1.1 mapping, refactored
// `write_digits`.
//
// 2021.08.26 Moved `is_integer`, and `mantissa_countr_zero` to the new
// `blp_common64.h` header, as well as renamed them to
// `is_integer64`, and `mantissa_counter64` respectively. Also
// move the `DOUBLE_MANTISSA_BITS`, `DOUBLE_EXPONENT_BITS`, and
// `DOUBLE_BIAS` macros to the same header as two of them are used
// in the functions move there.
//
// See README.BDE.md for further explanations.
#include "ryu/blp_ryu.h"
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#ifdef RYU_DEBUG
#include <inttypes.h>
#include <stdio.h>
#endif
#include "ryu/blp_common.h"
#include "ryu/blp_common64.h"
#include "ryu/common.h"
#include "ryu/digit_table.h"
#include "ryu/d2s_intrinsics.h"
// Include either the small or the full lookup tables depending on the mode.
#if defined(RYU_OPTIMIZE_SIZE)
#include "ryu/d2s_small_table.h"
#else
#include "ryu/d2s_full_table.h"
#endif
#include "ryu/ryu.h"
static inline uint32_t decimalLength17(const uint64_t v) {
// This is slightly faster than a loop.
// The average output length is 16.38 digits, so we check high-to-low.
// Function precondition: v is not an 18, 19, or 20-digit number.
// (17 digits are sufficient for round-tripping.)
assert(v < 100000000000000000L);
if (v >= 10000000000000000L) { return 17; }
if (v >= 1000000000000000L) { return 16; }
if (v >= 100000000000000L) { return 15; }
if (v >= 10000000000000L) { return 14; }
if (v >= 1000000000000L) { return 13; }
if (v >= 100000000000L) { return 12; }
if (v >= 10000000000L) { return 11; }
if (v >= 1000000000L) { return 10; }
if (v >= 100000000L) { return 9; }
if (v >= 10000000L) { return 8; }
if (v >= 1000000L) { return 7; }
if (v >= 100000L) { return 6; }
if (v >= 10000L) { return 5; }
if (v >= 1000L) { return 4; }
if (v >= 100L) { return 3; }
if (v >= 10L) { return 2; }
return 1;
}
// A floating decimal representing m * 10^e.
typedef struct floating_decimal_64 {
uint64_t mantissa;
// Decimal exponent's range is -324 to 308
// inclusive, and can fit in a short if needed.
int32_t exponent;
} floating_decimal_64;
static inline floating_decimal_64 d2d(const uint64_t ieeeMantissa, const uint32_t ieeeExponent) {
int32_t e2;
uint64_t m2;
if (ieeeExponent == 0) {
// We subtract 2 so that the bounds computation has 2 additional bits.
e2 = 1 - DOUBLE_BIAS - DOUBLE_MANTISSA_BITS - 2;
m2 = ieeeMantissa;
} else {
e2 = (int32_t) ieeeExponent - DOUBLE_BIAS - DOUBLE_MANTISSA_BITS - 2;
m2 = (1ull << DOUBLE_MANTISSA_BITS) | ieeeMantissa;
}
const bool even = (m2 & 1) == 0;
const bool acceptBounds = even;
#ifdef RYU_DEBUG
printf("-> %" PRIu64 " * 2^%d\n", m2, e2 + 2);
#endif
// Step 2: Determine the interval of valid decimal representations.
const uint64_t mv = 4 * m2;
// Implicit bool -> int conversion. True is 1, false is 0.
const uint32_t mmShift = ieeeMantissa != 0 || ieeeExponent <= 1;
// We would compute mp and mm like this:
// uint64_t mp = 4 * m2 + 2;
// uint64_t mm = mv - 1 - mmShift;
// Step 3: Convert to a decimal power base using 128-bit arithmetic.
uint64_t vr, vp, vm;
int32_t e10;
bool vmIsTrailingZeros = false;
bool vrIsTrailingZeros = false;
if (e2 >= 0) {
// I tried special-casing q == 0, but there was no effect on performance.
// This expression is slightly faster than max(0, log10Pow2(e2) - 1).
const uint32_t q = log10Pow2(e2) - (e2 > 3);
e10 = (int32_t) q;
const int32_t k = DOUBLE_POW5_INV_BITCOUNT + pow5bits((int32_t) q) - 1;
const int32_t i = -e2 + (int32_t) q + k;
#if defined(RYU_OPTIMIZE_SIZE)
uint64_t pow5[2];
double_computeInvPow5(q, pow5);
vr = mulShiftAll64(m2, pow5, i, &vp, &vm, mmShift);
#else
vr = mulShiftAll64(m2, DOUBLE_POW5_INV_SPLIT[q], i, &vp, &vm, mmShift);
#endif
#ifdef RYU_DEBUG
printf("%" PRIu64 " * 2^%d / 10^%u\n", mv, e2, q);
printf("V+=%" PRIu64 "\nV =%" PRIu64 "\nV-=%" PRIu64 "\n", vp, vr, vm);
#endif
if (q <= 21) {
// This should use q <= 22, but I think 21 is also safe. Smaller values
// may still be safe, but it's more difficult to reason about them.
// Only one of mp, mv, and mm can be a multiple of 5, if any.
const uint32_t mvMod5 = ((uint32_t) mv) - 5 * ((uint32_t) div5(mv));
if (mvMod5 == 0) {
vrIsTrailingZeros = multipleOfPowerOf5(mv, q);
} else if (acceptBounds) {
// Same as min(e2 + (~mm & 1), pow5Factor(mm)) >= q
// <=> e2 + (~mm & 1) >= q && pow5Factor(mm) >= q
// <=> true && pow5Factor(mm) >= q, since e2 >= q.
vmIsTrailingZeros = multipleOfPowerOf5(mv - 1 - mmShift, q);
} else {
// Same as min(e2 + 1, pow5Factor(mp)) >= q.
vp -= multipleOfPowerOf5(mv + 2, q);
}
}
} else {
// This expression is slightly faster than max(0, log10Pow5(-e2) - 1).
const uint32_t q = log10Pow5(-e2) - (-e2 > 1);
e10 = (int32_t) q + e2;
const int32_t i = -e2 - (int32_t) q;
const int32_t k = pow5bits(i) - DOUBLE_POW5_BITCOUNT;
const int32_t j = (int32_t) q - k;
#if defined(RYU_OPTIMIZE_SIZE)
uint64_t pow5[2];
double_computePow5(i, pow5);
vr = mulShiftAll64(m2, pow5, j, &vp, &vm, mmShift);
#else
vr = mulShiftAll64(m2, DOUBLE_POW5_SPLIT[i], j, &vp, &vm, mmShift);
#endif
#ifdef RYU_DEBUG
printf("%" PRIu64 " * 5^%d / 10^%u\n", mv, -e2, q);
printf("%u %d %d %d\n", q, i, k, j);
printf("V+=%" PRIu64 "\nV =%" PRIu64 "\nV-=%" PRIu64 "\n", vp, vr, vm);
#endif
if (q <= 1) {
// {vr,vp,vm} is trailing zeros if {mv,mp,mm} has at least q trailing 0 bits.
// mv = 4 * m2, so it always has at least two trailing 0 bits.
vrIsTrailingZeros = true;
if (acceptBounds) {
// mm = mv - 1 - mmShift, so it has 1 trailing 0 bit iff mmShift == 1.
vmIsTrailingZeros = mmShift == 1;
} else {
// mp = mv + 2, so it always has at least one trailing 0 bit.
--vp;
}
} else if (q < 63) { // TODO(ulfjack): Use a tighter bound here.
// We want to know if the full product has at least q trailing zeros.
// We need to compute min(p2(mv), p5(mv) - e2) >= q
// <=> p2(mv) >= q && p5(mv) - e2 >= q
// <=> p2(mv) >= q (because -e2 >= q)
vrIsTrailingZeros = multipleOfPowerOf2(mv, q);
#ifdef RYU_DEBUG
printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
#endif
}
}
#ifdef RYU_DEBUG
printf("e10=%d\n", e10);
printf("V+=%" PRIu64 "\nV =%" PRIu64 "\nV-=%" PRIu64 "\n", vp, vr, vm);
printf("vm is trailing zeros=%s\n", vmIsTrailingZeros ? "true" : "false");
printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
#endif
// Step 4: Find the shortest decimal representation in the interval of valid representations.
int32_t removed = 0;
uint8_t lastRemovedDigit = 0;
uint64_t output;
// On average, we remove ~2 digits.
if (vmIsTrailingZeros || vrIsTrailingZeros) {
// General case, which happens rarely (~0.7%).
for (;;) {
const uint64_t vpDiv10 = div10(vp);
const uint64_t vmDiv10 = div10(vm);
if (vpDiv10 <= vmDiv10) {
break;
}
const uint32_t vmMod10 = ((uint32_t) vm) - 10 * ((uint32_t) vmDiv10);
const uint64_t vrDiv10 = div10(vr);
const uint32_t vrMod10 = ((uint32_t) vr) - 10 * ((uint32_t) vrDiv10);
vmIsTrailingZeros &= vmMod10 == 0;
vrIsTrailingZeros &= lastRemovedDigit == 0;
lastRemovedDigit = (uint8_t) vrMod10;
vr = vrDiv10;
vp = vpDiv10;
vm = vmDiv10;
++removed;
}
#ifdef RYU_DEBUG
printf("V+=%" PRIu64 "\nV =%" PRIu64 "\nV-=%" PRIu64 "\n", vp, vr, vm);
printf("d-10=%s\n", vmIsTrailingZeros ? "true" : "false");
#endif
if (vmIsTrailingZeros) {
for (;;) {
const uint64_t vmDiv10 = div10(vm);
const uint32_t vmMod10 = ((uint32_t) vm) - 10 * ((uint32_t) vmDiv10);
if (vmMod10 != 0) {
break;
}
const uint64_t vpDiv10 = div10(vp);
const uint64_t vrDiv10 = div10(vr);
const uint32_t vrMod10 = ((uint32_t) vr) - 10 * ((uint32_t) vrDiv10);
vrIsTrailingZeros &= lastRemovedDigit == 0;
lastRemovedDigit = (uint8_t) vrMod10;
vr = vrDiv10;
vp = vpDiv10;
vm = vmDiv10;
++removed;
}
}
#ifdef RYU_DEBUG
printf("%" PRIu64 " %d\n", vr, lastRemovedDigit);
printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
#endif
if (vrIsTrailingZeros && lastRemovedDigit == 5 && vr % 2 == 0) {
// Round even if the exact number is .....50..0.
lastRemovedDigit = 4;
}
// We need to take vr + 1 if vr is outside bounds or we need to round up.
output = vr + ((vr == vm && (!acceptBounds || !vmIsTrailingZeros)) || lastRemovedDigit >= 5);
} else {
// Specialized for the common case (~99.3%). Percentages below are relative to this.
bool roundUp = false;
const uint64_t vpDiv100 = div100(vp);
const uint64_t vmDiv100 = div100(vm);
if (vpDiv100 > vmDiv100) { // Optimization: remove two digits at a time (~86.2%).
const uint64_t vrDiv100 = div100(vr);
const uint32_t vrMod100 = ((uint32_t) vr) - 100 * ((uint32_t) vrDiv100);
roundUp = vrMod100 >= 50;
vr = vrDiv100;
vp = vpDiv100;
vm = vmDiv100;
removed += 2;
}
// Loop iterations below (approximately), without optimization above:
// 0: 0.03%, 1: 13.8%, 2: 70.6%, 3: 14.0%, 4: 1.40%, 5: 0.14%, 6+: 0.02%
// Loop iterations below (approximately), with optimization above:
// 0: 70.6%, 1: 27.8%, 2: 1.40%, 3: 0.14%, 4+: 0.02%
for (;;) {
const uint64_t vpDiv10 = div10(vp);
const uint64_t vmDiv10 = div10(vm);
if (vpDiv10 <= vmDiv10) {
break;
}
const uint64_t vrDiv10 = div10(vr);
const uint32_t vrMod10 = ((uint32_t) vr) - 10 * ((uint32_t) vrDiv10);
roundUp = vrMod10 >= 5;
vr = vrDiv10;
vp = vpDiv10;
vm = vmDiv10;
++removed;
}
#ifdef RYU_DEBUG
printf("%" PRIu64 " roundUp=%s\n", vr, roundUp ? "true" : "false");
printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
#endif
// We need to take vr + 1 if vr is outside bounds or we need to round up.
output = vr + (vr == vm || roundUp);
}
const int32_t exp = e10 + removed;
#ifdef RYU_DEBUG
printf("V+=%" PRIu64 "\nV =%" PRIu64 "\nV-=%" PRIu64 "\n", vp, vr, vm);
printf("O=%" PRIu64 "\n", output);
printf("EXP=%d\n", exp);
#endif
floating_decimal_64 fd;
fd.exponent = exp;
fd.mantissa = output;
return fd;
}
static inline int write_mantissa(const uint32_t olength, uint64_t output, char *const result) {
// Write the decimal digits in the specified `output` to the specified
// `result` with specified `olength` containing the number of significant
// decimal digits of `output`. The behavior is undefined unless
// `olength == decimalLength17(output)`. Notice that this function will not
// write leading zeros, `olength` is just a precalculated value.
// The following code is equivalent to:
// for (uint32_t i = 0; i < olength - 1; ++i) {
// const uint32_t c = output % 10; output /= 10;
// result[olength - i + 1] = (char) ('0' + c);
// }
// if (olength > 1) result[1] = '.';
// result[0] = '0' + output % 10;
// Code up to the `if (output2 >= 10)` is not very interesting other than it
// uses the optimizers' ability to turn several `memcpy` calls into writing
// of a (potentially 64 bit long) register to memory. This is one of the
// things that makes Ryu faster.
char* ptr = result + olength + 1; // Writing backwards, with space for '.'
// We prefer 32-bit operations, even on 64-bit platforms.
// We have at most 17 digits, and uint32_t can store 9 digits.
// If output doesn't fit into uint32_t, we cut off 8 digits,
// so the rest will fit into uint32_t.
if ((output >> 32) != 0) {
// Expensive 64-bit division.
const uint64_t q = div1e8(output);
uint32_t output2 = ((uint32_t) output) - 100000000 * ((uint32_t) q);
output = q;
const uint32_t c = output2 % 10000;
output2 /= 10000;
const uint32_t d = output2 % 10000;
const uint32_t c0 = (c % 100) << 1;
const uint32_t c1 = (c / 100) << 1;
const uint32_t d0 = (d % 100) << 1;
const uint32_t d1 = (d / 100) << 1;
memcpy(ptr - 2, DIGIT_TABLE + c0, 2);
memcpy(ptr - 4, DIGIT_TABLE + c1, 2);
memcpy(ptr - 6, DIGIT_TABLE + d0, 2);
memcpy(ptr - 8, DIGIT_TABLE + d1, 2);
ptr -= 8;
}
uint32_t output2 = (uint32_t) output;
while (output2 >= 10000) {
#ifdef __clang__ // https://bugs.llvm.org/show_bug.cgi?id=38217
const uint32_t c = output2 - 10000 * (output2 / 10000);
#else
const uint32_t c = output2 % 10000;
#endif
output2 /= 10000;
const uint32_t c0 = (c % 100) << 1;
const uint32_t c1 = (c / 100) << 1;
memcpy(ptr - 2, DIGIT_TABLE + c0, 2);
memcpy(ptr - 4, DIGIT_TABLE + c1, 2);
ptr -= 4;
}
if (output2 >= 100) {
const uint32_t c = (output2 % 100) << 1;
output2 /= 100;
memcpy(ptr - 2, DIGIT_TABLE + c, 2);
ptr -= 2;
}
if (output2 >= 10) {
const uint32_t c = output2 << 1;
result[2] = DIGIT_TABLE[c + 1];
result[1] = '.';
result[0] = DIGIT_TABLE[c];
} else {
if (olength > 1) result[1] = '.';
result[0] = (char) ('0' + output2);
}
// Return the number of characters written
return olength + (olength > 1);
}
static inline void write_decimal_digits(const uint32_t olength, uint64_t output, char *const result) {
// Write the decimal digits in the specified `output` to the specified
// `result` with specified `olength` containing the number of significant
// decimal digits of `output`. The behavior is undefined unless
// `olength == decimalLength17(output)`. Notice that this function will not
// write leading zeros, `olength` is just a precalculated value.
// The following code is equivalent to:
// for (uint32_t i = 0; i < olength - 1; ++i) {
// const uint32_t c = output % 10; output /= 10;
// result[olength - i] = (char) ('0' + c);
// }
// result[0] = '0' + output % 10;
// Code up to the `if (output2 >= 10)` is not very interesting other than it
// uses the optimizers' ability to turn several `memcpy` calls into writing
// of a (potentially 64 bit long) register to memory. This is one of the
// things that makes Ryu faster.
char* wptr = result + olength; // Writing backwards
// We prefer 32-bit operations, even on 64-bit platforms.
// We have at most 17 digits, and uint32_t can store 9 digits.
// If output doesn't fit into uint32_t, we cut off 8 digits,
// so the rest will fit into uint32_t.
if ((output >> 32) != 0) {
// Expensive 64-bit division.
const uint64_t q = div1e8(output);
uint32_t output2 = ((uint32_t) output) - 100000000 * ((uint32_t) q);
output = q;
const uint32_t c = output2 % 10000;
output2 /= 10000;
const uint32_t d = output2 % 10000;
const uint32_t c0 = (c % 100) << 1;
const uint32_t c1 = (c / 100) << 1;
const uint32_t d0 = (d % 100) << 1;
const uint32_t d1 = (d / 100) << 1;
memcpy(wptr - 2, DIGIT_TABLE + c0, 2);
memcpy(wptr - 4, DIGIT_TABLE + c1, 2);
memcpy(wptr - 6, DIGIT_TABLE + d0, 2);
memcpy(wptr - 8, DIGIT_TABLE + d1, 2);
wptr -= 8;
}
uint32_t output2 = (uint32_t) output;
while (output2 >= 10000) {
#ifdef __clang__ // https://bugs.llvm.org/show_bug.cgi?id=38217
const uint32_t c = output2 - 10000 * (output2 / 10000);
#else
const uint32_t c = output2 % 10000;
#endif
output2 /= 10000;
const uint32_t c0 = (c % 100) << 1;
const uint32_t c1 = (c / 100) << 1;
memcpy(wptr - 2, DIGIT_TABLE + c0, 2);
memcpy(wptr - 4, DIGIT_TABLE + c1, 2);
wptr -= 4;
}
if (output2 >= 100) {
const uint32_t c = (output2 % 100) << 1;
output2 /= 100;
memcpy(wptr - 2, DIGIT_TABLE + c, 2);
wptr -= 2;
}
if (output2 >= 10) {
// We are writing the top two digits
const uint32_t c = output2 << 1;
memcpy(result, DIGIT_TABLE + c, 2);
} else {
result[0] = (char) ('0' + output2); // Write a single digit
}
}
static inline int write_scientific(uint32_t olength, const floating_decimal_64 v, char* const result) {
// Write the positive number represented by the specified `v` in scientific
// notation into the specified `result`. The specified `olength` is the
// precalculated number of decimal digits in `v.mantissa`. The behavior is
// undefined unless `decimalLength17(v.mantissa) == olength` and `result` has
// at least 23 characters.
// Write the mantissa.
int32_t index = write_mantissa(olength, v.mantissa, result);
// Write the exponent.
result[index++] = 'e';
int32_t exp = v.exponent + (int32_t)olength - 1;
if (exp < 0) {
result[index++] = '-';
exp = -exp; // Notice that we flip `exp` here to be positive
} else {
result[index++] = '+'; // ISO C++ requires sign for the exponent.
}
if (exp >= 100) {
const int32_t c = exp % 10;
memcpy(result + index, DIGIT_TABLE + 2 * (exp / 10), 2);
result[index + 2] = (char) ('0' + c);
index += 3;
} else {
// ISO C++ requires at least two exponent digits.
memcpy(result + index, DIGIT_TABLE + 2 * exp, 2);
index += 2;
}
// Return the number of characters written.
return index;
}
static inline int write_decimal(uint32_t olength, const floating_decimal_64 v, char* const result) {
// Write the positive number represented by the specified `v` in decimal
// notation into the specified `result`. The specified `olength` is the
// pre-calculated number of decimal digits in `v.mantissa`. The behavior is
// undefined unless `decimalLength17(v.mantissa) == olength` and `result` has
// at least 23 characters.
// We may change `output`, but `exponent` is constant
uint64_t output = v.mantissa;
const int32_t exponent = v.exponent;
// The number of characters written
int32_t index = 0;
// The condition `-exponent >= (int32_t)olength` really means the more
// involved `exponent < 0 && -exponent >= (int32_t)olength` because we know
// `1 <= olength <= 17`. Positive `exponent` will make `-exponent` negative,
// so it can never be larger than `olength` that is positive. If the
// `exponent` is `0`, it will still be smaller.
//
// It is safe to cast the unsigned `olength` to signed `int32_t` as its range
// representable even on a byte. However it would not be safe to compare a
// signed and unsigned value as negative `-exponent` values would get
// converted to large positive numbers.
if (-exponent >= (int32_t)olength) { // abs(value) < 1: no integer portion
// Write the zero integer portion and the decimal radix.
memcpy(result, "0.", 2);
index += 2;
// Calculate how much of the `exponent` is "used up" by moving all digits
// of `output` behind the radix point. `olength` has he number of digits
// in `output`. If any of the negative exponent is left we need to write
// that many zeros after the decimal dot. The cast is necessary to silence
// warnings.
const uint32_t rest = (uint32_t)(-exponent) - olength;
if (rest > 0) {
memset(result + index, '0', rest);
index += rest;
}
} else if (exponent < 0) { // Has integer and fractional portion
// When we get to this branch we don't just know that `exponent` is
// negative, but also know that its value is *less* than the number of
// digits in `output`, because this is an `else` branch as well.
// Obtain the 10^-exponent value so we can "split" the number to integer
// and fractional parts.
const uint64_t divider = ten_to_exp_for_decimal_notation(-exponent);
// Determine the integer part that we write first
const uint64_t outInt = output / divider;
// Notice that we put the fractional part back into `output` for later use
#ifdef __clang__ // https://bugs.llvm.org/show_bug.cgi?id=38217
output = output - outInt * divider;
#else
output = output % divider;
#endif
// Write the integer part
write_decimal_digits(olength + exponent, // `exponent` is negative
outInt, // these digits
result + index); // to this position
index += olength + exponent;
result[index++] = '.'; // Insert the radix point
// The decimal portion may start with zeros. `write_digits` does not write
// leading zeros, so we do it here. `exponent` is negative, and its
// absolute value is the number of decimal digits we need to write. So
// `-exponent` is minus the actual number of digits we have (in `output`)
// is the number of leading decimal zeros to write. For example `1.0025`
// will have `25 == output` and `-4 == exponent`:
olength = decimalLength17(output);
const uint32_t numLeadZeros = -exponent - olength;
if (numLeadZeros > 0) {
memset(result + index, '0', numLeadZeros);
index += numLeadZeros;
}
}
// Writes the digits of `output` to `result + index`. Notice that in
// `output` we may have fractional digits, or if `0 <= exponent` we will
// write the digits of the integer part here.
write_decimal_digits(olength, output, result + index);
index += olength;
// If the `exponent` is positive, it means we need zeros after our integer
// digits we just written.
if (exponent > 0) {
memset(result + index, '0', exponent);
index += exponent;
}
// Return the number of characters written
return index;
}
static inline int to_chars_minimal(const floating_decimal_64 v, const bool sign, const uint32_t olength, const bool needsDecimalNotaton, char* result) {
// Write the decimal representation of the floating point value represented
// by the specified `v`, having the specified `sign` into the specified
// `result`. Use the specified `olength` as the number of decimal digits in
// `v.mantissa`. Write either in decimal or scientific notation depending on
// the specified 'needsDecimalNotation. Return the number of characters
// written. The behavior is undefined unless `result` has at least 24
// characters space. Note that we do not null terminate `result`.
#ifdef RYU_DEBUG
printf("DIGITS=%" PRIu64 "\n", v.mantissa);
printf("OLEN=%u\n", olength);
printf("EXP=%u\n", v.exponent + olength);
#endif
// Negative values are handled here by writing the sign and adjusting the
// `result` pointer for the rest of the functions to write after the sign.
if (sign) {
*result++ = '-';
}
// The ternary operator chooses between the two notation functions, then we
// immediately call the chosen one. The parentheses around the ternary
// operator are necessary because it has much lower precedence the function
// call operator. The last line adjusts the number of characters written in
// case we wrote a negative sign earlier.
return (needsDecimalNotaton ? write_decimal : write_scientific)(olength,
v,
result)
+ (sign ? 1 : 0);
}
static inline int to_chars_scientific(const floating_decimal_64 v, const bool sign, char* result) {
// Write the scientific representation of the floating point value
// represented by the specified `v`, having the specified `sign` into the
// specified `result`. The behavior is undefined unless `result` has at
// least 24 characters space. Note that we do not null terminate `result`.
// Determine the number of significant digits of the output
const uint32_t olength = decimalLength17(v.mantissa);
#ifdef RYU_DEBUG
printf("DIGITS=%" PRIu64 "\n", v.mantissa);
printf("OLEN=%u\n", olength);
printf("EXP=%u\n", v.exponent + olength);
#endif
// Negative values are handled here by writing the sign and adjusting the
// `result` pointer for the rest of the functions to write after the sign.
if (sign) {
*result++ = '-';
}
return write_scientific(olength, v, result) + (sign ? 1 : 0);
}
static inline int to_chars_decimal(const floating_decimal_64 v, const bool sign, char* result) {
// Write the decimal representation of the floating point value represented
// by the specified `v`, having the specified `sign` into the specified
// `result`. Write using the shorter notation from decimal and scientific,
// preferring decimal notation over scientific in case of a tie. Return the
// number of characters written. The behavior is undefined unless `result`
// has at least 24 characters space. Note that we do not null terminate
// `result`.
// Determine the number of significant digits of the output
const uint32_t olength = decimalLength17(v.mantissa);
#ifdef RYU_DEBUG
printf("DIGITS=%" PRIu64 "\n", v.mantissa);
printf("OLEN=%u\n", olength);
printf("EXP=%u\n", v.exponent + olength);
#endif
// Negative values are handled here by writing the sign and adjusting the
// `result` pointer for the rest of the functions to write after the sign.
if (sign) {
*result++ = '-';
}
return write_decimal(olength, v, result) + (sign ? 1 : 0);
}
static inline bool d2d_small_int(const uint64_t ieeeMantissa, const uint32_t ieeeExponent,
floating_decimal_64* const v) {
const uint64_t m2 = (1ull << DOUBLE_MANTISSA_BITS) | ieeeMantissa;
const int32_t e2 = (int32_t) ieeeExponent - DOUBLE_BIAS - DOUBLE_MANTISSA_BITS;
if (e2 > 0) {
// f = m2 * 2^e2 >= 2^53 is an integer.
// Ignore this case for now.
return false;
}
if (e2 < -(DOUBLE_MANTISSA_BITS)) {
// f < 1.
return false;
}
// Since 2^52 <= m2 < 2^53 and 0 <= -e2 <= 52: 1 <= f = m2 / 2^-e2 < 2^53.
// Test if the lower -e2 bits of the significand are 0, i.e. whether the fraction is 0.
const uint64_t mask = (1ull << -e2) - 1;
const uint64_t fraction = m2 & mask;
if (fraction != 0) {
return false;
}
// f is an integer in the range [1, 2^53).
// Note: mantissa might contain trailing (decimal) 0's.
// Note: since 2^53 < 10^16, there is no need to adjust decimalLength17().
v->mantissa = m2 >> -e2;
v->exponent = 0;
return true;
}
int blp_d2m_buffered_n(double f, char* result) {
// Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
const uint64_t bits = double_to_bits(f);
#ifdef RYU_DEBUG
printf("IN=");
for (int32_t bit = 63; bit >= 0; --bit) {
printf("%d", (int) ((bits >> bit) & 1));
}
printf("\n");
#endif
// Shortcut for writing zero values. Original `d2s.c` code uses
// `copy_special_str`, but that writes in scientific format.
switch (bits) {
case 0:
*result = '0';
return 1;
case 0x8000000000000000:
memcpy(result, "-0", 2);
return 2;
}
// Decode bits into sign, mantissa, and exponent.
const bool ieeeSign = ((bits >> (DOUBLE_MANTISSA_BITS + DOUBLE_EXPONENT_BITS)) & 1) != 0;
const uint64_t ieeeMantissa = bits & ((1ull << DOUBLE_MANTISSA_BITS) - 1);
const uint32_t ieeeExponent = (uint32_t) ((bits >> DOUBLE_MANTISSA_BITS) & ((1u << DOUBLE_EXPONENT_BITS) - 1));
// Case distinction; exit early for NaN and Infinities. Original Ryu code
// also wrote zero values here. We write them even earlier.
if (ieeeExponent == ((1u << DOUBLE_EXPONENT_BITS) - 1u)) {
// Calling our own function here that uses the XSD 1.1 specification for
// the special values of INF, -INF, and NaN.
return xsd_non_numerical_mapping(result, ieeeSign, ieeeMantissa);
}
// Same as the original code, the magic that determines how many decimal
// digits we have to use happens here for small integers, and in `d2d` for
// all other values.
floating_decimal_64 v;
const bool isSmallInt = d2d_small_int(ieeeMantissa, ieeeExponent, &v);
if (isSmallInt) {
// For small integers in the range [1, 2^53), v.mantissa might contain trailing (decimal) zeros.
// For scientific notation we need to move these zeros into the exponent.
for (;;) {
const uint64_t q = div10(v.mantissa);
const uint32_t r = ((uint32_t) v.mantissa) - 10 * ((uint32_t) q);
if (r != 0) {
break;
}
v.mantissa = q;
++v.exponent;
}
} else {
v = d2d(ieeeMantissa, ieeeExponent);
}
// Determine the number of significant digits of the output
const uint32_t olength = decimalLength17(v.mantissa);
const bool needsDecimalNotaton = needs_decimal_notation_m(olength,
v.exponent);
// Integers are printed precisely in decimal notation.
if (needsDecimalNotaton && is_integer64(ieeeMantissa, ieeeExponent)) {
// The following call re-does some of the work we did here, but not enough
// of it to worry.
return ryu_d2fixed_buffered_n(f, 0, result);
}
// We write the non-integer values here, as well as large integer values that
// will require scientific notation due to length.
return to_chars_minimal(v, ieeeSign, olength, needsDecimalNotaton, result);
}
void blp_d2m_buffered(double f, char* result) {
const int index = blp_d2m_buffered_n(f, result);
// Terminate the string.
result[index] = '\0';
}
int blp_d2d_buffered_n(double f, char* result) {
// Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
const uint64_t bits = double_to_bits(f);
#ifdef RYU_DEBUG
printf("IN=");
for (int32_t bit = 63; bit >= 0; --bit) {
printf("%d", (int) ((bits >> bit) & 1));
}
printf("\n");
#endif
// Shortcut for writing zero values. Original `d2s.c` code uses
// `copy_special_str`, but that writes in scientific format.
switch (bits) {
case 0:
*result = '0';
return 1;
case 0x8000000000000000:
memcpy(result, "-0", 2);
return 2;
}
// Decode bits into sign, mantissa, and exponent.
const bool ieeeSign = ((bits >> (DOUBLE_MANTISSA_BITS + DOUBLE_EXPONENT_BITS)) & 1) != 0;
const uint64_t ieeeMantissa = bits & ((1ull << DOUBLE_MANTISSA_BITS) - 1);
const uint32_t ieeeExponent = (uint32_t) ((bits >> DOUBLE_MANTISSA_BITS) & ((1u << DOUBLE_EXPONENT_BITS) - 1));
// Case distinction; exit early for NaN and Infinities. Original Ryu code
// also wrote zero values here. We write them even earlier.
if (ieeeExponent == ((1u << DOUBLE_EXPONENT_BITS) - 1u)) {
// Calling our own function here that uses the XSD 1.1 specification for
// the special values of INF, -INF, and NaN.
return xsd_non_numerical_mapping(result, ieeeSign, ieeeMantissa);
}
// Integers are printed precisely in decimal notation
if (is_integer64(ieeeMantissa, ieeeExponent)) {
// The following call re-does some of the work we did here, but not enough
// of it to worry.
return ryu_d2fixed_buffered_n(f, 0, result);
}
// Same as the original code, the magic that determines how many decimal
// digits we have to use happens in `d2d` for non-integer values.
const floating_decimal_64 v = d2d(ieeeMantissa, ieeeExponent);
// Finally we write
return to_chars_decimal(v, ieeeSign, result);
}
void blp_d2d_buffered(double f, char* result) {
const int index = blp_d2d_buffered_n(f, result);
// Terminate the string.
result[index] = '\0';
}
int blp_d2s_buffered_n(double f, char* result) {
// Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
const uint64_t bits = double_to_bits(f);
#ifdef RYU_DEBUG
printf("IN=");
for (int32_t bit = 63; bit >= 0; --bit) {
printf("%d", (int) ((bits >> bit) & 1));
}
printf("\n");
#endif
// Shortcut for writing zero values. Original `d2s.c` code uses
// `copy_special_str`, but that writes in non-C++ scientific format.
switch (bits) {
case 0:
memcpy(result, "0e+00", 5);
return 5;
case 0x8000000000000000:
memcpy(result, "-0e+00", 6);
return 6;
}
// Decode bits into sign, mantissa, and exponent.
const bool ieeeSign = ((bits >> (DOUBLE_MANTISSA_BITS + DOUBLE_EXPONENT_BITS)) & 1) != 0;
const uint64_t ieeeMantissa = bits & ((1ull << DOUBLE_MANTISSA_BITS) - 1);
const uint32_t ieeeExponent = (uint32_t) ((bits >> DOUBLE_MANTISSA_BITS) & ((1u << DOUBLE_EXPONENT_BITS) - 1));
// Case distinction; exit early for NaN and Infinities. Original Ryu code
// also wrote zero values here. We write them even earlier.
if (ieeeExponent == ((1u << DOUBLE_EXPONENT_BITS) - 1u)) {
// Calling our own function here that uses the XSD 1.1 specification for
// the special values of INF, -INF, and NaN.
return xsd_non_numerical_mapping(result, ieeeSign, ieeeMantissa);
}
// Same as the original code, the magic that determines how many decimal
// digits we have to use happens here for small integers, and in `d2d` for
// all other values.
floating_decimal_64 v;
const bool isSmallInt = d2d_small_int(ieeeMantissa, ieeeExponent, &v);
if (isSmallInt) {
// For small integers in the range [1, 2^53), v.mantissa might contain trailing (decimal) zeros.
// For scientific notation we need to move these zeros into the exponent.
for (;;) {
const uint64_t q = div10(v.mantissa);
const uint32_t r = ((uint32_t) v.mantissa) - 10 * ((uint32_t) q);
if (r != 0) {
break;
}
v.mantissa = q;
++v.exponent;
}
} else {
v = d2d(ieeeMantissa, ieeeExponent);
}
// There is no checking here for integer values because in scientific
// notation integer values are not printed any differently than other values.
// We write the non-integer values here, as well as large integer values that
// will require scientific notation due to length.
return to_chars_scientific(v, ieeeSign, result);
}
void blp_d2s_buffered(double f, char* result) {
const int index = blp_d2s_buffered_n(f, result);
// Terminate the string.
result[index] = '\0';
}
|
bbdbbd1df914c044aff399a90f90b49c70a1f6ad
|
1efd2de8bf77ec00eb2fcaf5749278495946d920
|
/src/tests/suite/daos_dedup.c
|
b68a643d625a8eca00bebfcc7bb42e26c178e6bb
|
[
"BSD-2-Clause",
"BSD-2-Clause-Patent"
] |
permissive
|
daos-stack/daos
|
6f55bf3061fd830d5b8d28506e1295e2d3a27c38
|
ed5eed5df43a68571afe123132a743824c02637a
|
refs/heads/master
| 2023-08-31T21:43:37.606145
| 2023-08-31T16:38:00
| 2023-08-31T16:38:00
| 69,390,670
| 631
| 300
|
NOASSERTION
| 2023-09-14T18:55:15
| 2016-09-27T19:21:29
|
C
|
UTF-8
|
C
| false
| false
| 9,245
|
c
|
daos_dedup.c
|
/**
* (C) Copyright 2020-2022 Intel Corporation.
*
* SPDX-License-Identifier: BSD-2-Clause-Patent
*/
#define D_LOGFAC DD_FAC(tests)
#include "daos_test.h"
#include <daos/checksum.h>
#include <gurt/types.h>
#include <daos_prop.h>
struct dedup_test_ctx {
/** Pool */
daos_handle_t poh;
/** Container */
daos_handle_t coh;
daos_cont_info_t info;
uuid_t uuid;
/** Object */
daos_handle_t oh;
daos_obj_id_t oid;
daos_key_t dkey;
daos_iod_t update_iod;
d_sg_list_t update_sgl;
daos_iod_t fetch_iod;
d_sg_list_t fetch_sgl;
daos_recx_t recx[4];
};
enum THRESHOLD_SETTING {
THRESHOLD_GREATER_THAN_DATA = 1,
THRESHOLD_LESS_THAN_DATA,
};
static bool
dedup_is_nvme_enabled(test_arg_t *arg)
{
daos_pool_info_t pinfo = { 0 };
struct daos_pool_space *ps = &pinfo.pi_space;
int rc;
pinfo.pi_bits = DPI_ALL;
rc = test_pool_get_info(arg, &pinfo, NULL /* engine_ranks */);
assert_rc_equal(rc, 0);
return ps->ps_free_min[DAOS_MEDIA_NVME] != 0;
}
/** easily setup an iov and allocate */
static void
iov_alloc(d_iov_t *iov, size_t len)
{
D_ALLOC(iov->iov_buf, len);
iov->iov_buf_len = iov->iov_len = len;
}
static void
iov_alloc_str(d_iov_t *iov, const char *str)
{
iov_alloc(iov, strlen(str) + 1);
strcpy(iov->iov_buf, str);
}
static void
setup_from_test_args(struct dedup_test_ctx *ctx, test_arg_t *state)
{
ctx->poh = state->pool.poh;
}
static void
setup_sgl(struct dedup_test_ctx *ctx)
{
dts_sgl_init_with_strings_repeat(&ctx->update_sgl, 1000, 1,
"Lorem ipsum dolor sit "
"amet, consectetur adipiscing elit,"
" sed do eiusmod tempor incididunt ut"
" labore et dolore magna aliqua.");
d_sgl_init(&ctx->fetch_sgl, 1);
iov_alloc(&ctx->fetch_sgl.sg_iovs[0],
daos_sgl_buf_size(&ctx->update_sgl));
}
static void
setup_keys(struct dedup_test_ctx *ctx)
{
iov_alloc_str(&ctx->dkey, "dkey");
iov_alloc_str(&ctx->update_iod.iod_name, "akey");
}
static void
setup_as_array(struct dedup_test_ctx *ctx)
{
ctx->recx[0].rx_idx = 0;
ctx->recx[0].rx_nr = daos_sgl_buf_size(&ctx->update_sgl);
ctx->update_iod.iod_size = 1;
ctx->update_iod.iod_nr = 1;
ctx->update_iod.iod_recxs = &ctx->recx[0];
ctx->update_iod.iod_type = DAOS_IOD_ARRAY;
}
static void
setup_as_single_value(struct dedup_test_ctx *ctx)
{
ctx->update_iod.iod_nr = 1;
ctx->update_iod.iod_size = daos_sgl_buf_size(&ctx->update_sgl);
ctx->update_iod.iod_recxs = NULL;
ctx->update_iod.iod_type = DAOS_IOD_SINGLE;
}
static void
setup_fetch_iod(struct dedup_test_ctx *ctx)
{
ctx->fetch_iod.iod_name = ctx->update_iod.iod_name;
ctx->fetch_iod.iod_size = ctx->update_iod.iod_size;
ctx->fetch_iod.iod_recxs = ctx->update_iod.iod_recxs;
ctx->fetch_iod.iod_nr = ctx->update_iod.iod_nr;
ctx->fetch_iod.iod_type = ctx->update_iod.iod_type;
}
static void
setup_cont_obj(struct dedup_test_ctx *ctx,
uint32_t csum_prop_type,
daos_oclass_id_t oclass,
uint32_t dedup_type,
uint32_t dedup_threshold_setting)
{
daos_prop_t *props = NULL;
char str[37];
int rc;
daos_size_t data_len;
daos_size_t dedup_threshold;
/** calc threshold based on data size and setting */
data_len = daos_sgl_buf_size(&ctx->update_sgl);
dedup_threshold = dedup_threshold_setting == THRESHOLD_GREATER_THAN_DATA
? data_len + 10 : data_len - 10;
props = daos_prop_alloc(3);
assert_non_null(props);
props->dpp_entries[0].dpe_type = DAOS_PROP_CO_CSUM;
props->dpp_entries[0].dpe_val = csum_prop_type;
props->dpp_entries[1].dpe_type = DAOS_PROP_CO_DEDUP;
props->dpp_entries[1].dpe_val = dedup_type;
props->dpp_entries[2].dpe_type = DAOS_PROP_CO_DEDUP_THRESHOLD;
props->dpp_entries[2].dpe_val = dedup_threshold;
rc = daos_cont_create(ctx->poh, &ctx->uuid, props, NULL);
assert_rc_equal(0, rc);
daos_prop_free(props);
uuid_unparse(ctx->uuid, str);
rc = daos_cont_open(ctx->poh, str, DAOS_COO_RW,
&ctx->coh, &ctx->info, NULL);
assert_rc_equal(0, rc);
ctx->oid = daos_test_oid_gen(ctx->coh, oclass, 0, 0, 1);
rc = daos_obj_open(ctx->coh, ctx->oid, DAOS_OO_RW, &ctx->oh, NULL);
assert_rc_equal(0, rc);
}
static void
setup_context(struct dedup_test_ctx *ctx, test_arg_t *state,
uint32_t iod_type,
uint32_t csum_prop_type,
daos_oclass_id_t oclass,
uint32_t dedup_type,
enum THRESHOLD_SETTING dedup_threshold_setting)
{
setup_from_test_args(ctx, state);
setup_keys(ctx);
setup_sgl(ctx);
if (iod_type == DAOS_IOD_ARRAY)
setup_as_array(ctx);
else if (iod_type == DAOS_IOD_SINGLE)
setup_as_single_value(ctx);
else
fail_msg("Invalid iod_type: %d\n", iod_type);
setup_fetch_iod(ctx);
setup_cont_obj(ctx, csum_prop_type, oclass,
dedup_type, dedup_threshold_setting);
}
static daos_size_t
get_size(struct dedup_test_ctx *ctx)
{
daos_pool_info_t info;
int rc;
info.pi_bits = DPI_SPACE;
rc = daos_pool_query((*ctx).poh, NULL, &info, NULL, NULL);
assert_success(rc);
return info.pi_space.ps_space.s_free[0];
}
static int ctx_update(struct dedup_test_ctx *ctx)
{
return daos_obj_update(ctx->oh, DAOS_TX_NONE, 0,
&ctx->dkey,
1, &ctx->update_iod, &ctx->update_sgl,
NULL);
}
static void
with_identical_updates(void *const *state, uint32_t iod_type, int csum_type,
daos_oclass_id_t oc, int dedup_type,
enum THRESHOLD_SETTING dedup_threshold_setting)
{
struct dedup_test_ctx ctx;
/** acceptable size increase when dedup identifies identical data
* being inserted
*/
const daos_size_t dedup_size_increase = 256;
daos_size_t after_first_update;
daos_size_t after_second_update;
daos_size_t delta;
int rc;
if (dedup_is_nvme_enabled(*state)) {
print_message("Currently dedup doesn't support NVMe.\n");
skip();
}
setup_context(&ctx, *state, iod_type, csum_type, oc, dedup_type,
dedup_threshold_setting);
rc = ctx_update(&ctx);
assert_success(rc);
after_first_update = get_size(&ctx);
/** update again with same data */
rc = ctx_update(&ctx);
assert_success(rc);
/** if threshold is less than data size, dedup should prevent the extra
* update and therefore the data used from the pool is much less.
* Otherwise, the data used from the pool will be larger.
*/
after_second_update = get_size(&ctx);
delta = after_first_update - after_second_update;
if (dedup_threshold_setting == THRESHOLD_LESS_THAN_DATA &&
delta > dedup_size_increase)
fail_msg("Pool used size increased by %lu, which is larger "
"than expected size increase of less than or equal "
"to %lu", delta, dedup_size_increase);
else if (dedup_threshold_setting == THRESHOLD_GREATER_THAN_DATA &&
delta < dedup_size_increase)
fail_msg("Pool used size increased by %lu, which is less "
"than expected size increase of greater than or equal "
"to %lu", delta, dedup_size_increase);
}
static void
array_csumoff_deduphash(void **state)
{
with_identical_updates(state,
DAOS_IOD_ARRAY,
DAOS_PROP_CO_CSUM_OFF,
OC_SX,
DAOS_PROP_CO_DEDUP_HASH,
THRESHOLD_LESS_THAN_DATA);
}
static void
array_csumoff_dedupmemcmp(void **state)
{
with_identical_updates(state,
DAOS_IOD_ARRAY,
DAOS_PROP_CO_CSUM_OFF,
OC_SX,
DAOS_PROP_CO_DEDUP_MEMCMP,
THRESHOLD_LESS_THAN_DATA);
}
static void
array_csumcrc64_deduphash(void **state)
{
with_identical_updates(state,
DAOS_IOD_ARRAY,
DAOS_PROP_CO_CSUM_CRC64,
OC_SX,
DAOS_PROP_CO_DEDUP_HASH,
THRESHOLD_LESS_THAN_DATA);
}
static void
array_csumcrc64_dedupmemcmp(void **state)
{
with_identical_updates(state,
DAOS_IOD_ARRAY,
DAOS_PROP_CO_CSUM_CRC64,
OC_SX,
DAOS_PROP_CO_DEDUP_MEMCMP,
THRESHOLD_LESS_THAN_DATA);
}
static void
array_above_threshold(void **state)
{
with_identical_updates(state,
DAOS_IOD_ARRAY,
DAOS_PROP_CO_CSUM_CRC64,
OC_SX,
DAOS_PROP_CO_DEDUP_MEMCMP,
THRESHOLD_GREATER_THAN_DATA);
}
static int
setup(void **state)
{
return test_setup(state, SETUP_POOL_CONNECT, true, DEFAULT_POOL_SIZE,
0, NULL);
}
#define DEDUP_TEST(dsc, test) { dsc, test, NULL, test_case_teardown }
static const struct CMUnitTest dedup_tests[] = {
DEDUP_TEST("DAOS_DEDUP01: With array type, csums disabled, hash dedup",
array_csumoff_deduphash),
DEDUP_TEST("DAOS_DEDUP02: With array type, csums disabled, hash memcmp",
array_csumoff_dedupmemcmp),
DEDUP_TEST("DAOS_DEDUP03: With array type, csums crc64, hash dedup",
array_csumcrc64_deduphash),
DEDUP_TEST("DAOS_DEDUP04: With array type, csums crc64, hash memcmp",
array_csumcrc64_dedupmemcmp),
DEDUP_TEST("DAOS_DEDUP05: With array type, threshold greater than data "
"should still update",
array_above_threshold),
};
int
run_daos_dedup_test(int rank, int size, int *sub_tests, int sub_tests_size)
{
int rc = 0;
if (rank == 0) {
if (sub_tests_size == 0) {
rc = cmocka_run_group_tests_name("DAOS_Checksum",
dedup_tests, setup,
test_teardown);
} else {
rc = run_daos_sub_tests("DAOS_Checksum",
dedup_tests,
ARRAY_SIZE(dedup_tests),
sub_tests,
sub_tests_size, setup,
test_teardown);
}
}
par_barrier(PAR_COMM_WORLD);
return rc;
}
|
08f726211400ddab21b1c9d65e1c62a71a5240fe
|
9ca6d7ee24abbf3e2de2ec9499635a31ec863bb1
|
/QiniuSDK/include/QNServerUserConfig.h
|
2075826b62c8ca0e96e06055bfb5cc1e9e0a4836
|
[
"MIT"
] |
permissive
|
qiniu/objc-sdk
|
be895a012f654f704b0781e2c600e78d5d81e2c9
|
c1bdb198c5aa00ff4a4e7e8d580ed587977f455d
|
refs/heads/master
| 2023-08-18T10:55:39.592753
| 2023-08-07T10:44:46
| 2023-08-07T10:44:46
| 24,551,801
| 476
| 249
|
MIT
| 2023-09-12T09:35:07
| 2014-09-28T06:14:51
|
Objective-C
|
UTF-8
|
C
| false
| false
| 44
|
h
|
QNServerUserConfig.h
|
../Storage/ServerConfig/QNServerUserConfig.h
|
5a9eb349ce3aa4e1f99ce9ade8b7a0415b1e14dc
|
fbe68d84e97262d6d26dd65c704a7b50af2b3943
|
/third_party/virtualbox/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-Trap16Init.c
|
b1cb828ee046f8601f5590e27f42eff2383b83a0
|
[
"GPL-2.0-only",
"LicenseRef-scancode-unknown-license-reference",
"CDDL-1.0",
"LicenseRef-scancode-warranty-disclaimer",
"GPL-1.0-or-later",
"LGPL-2.1-or-later",
"GPL-2.0-or-later",
"MPL-1.0",
"LicenseRef-scancode-generic-exception",
"Apache-2.0",
"OpenSSL",
"MIT"
] |
permissive
|
thalium/icebox
|
c4e6573f2b4f0973b6c7bb0bf068fe9e795fdcfb
|
6f78952d58da52ea4f0e55b2ab297f28e80c1160
|
refs/heads/master
| 2022-08-14T00:19:36.984579
| 2022-02-22T13:10:31
| 2022-02-22T13:10:31
| 190,019,914
| 585
| 109
|
MIT
| 2022-01-13T20:58:15
| 2019-06-03T14:18:12
|
C++
|
UTF-8
|
C
| false
| false
| 4,876
|
c
|
bs3-cmn-Trap16Init.c
|
/* $Id: bs3-cmn-Trap16Init.c $ */
/** @file
* BS3Kit - Bs3Trap16Init
*/
/*
* Copyright (C) 2007-2017 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*********************************************************************************************************************************
* Header Files *
*********************************************************************************************************************************/
#include "bs3kit-template-header.h"
/*********************************************************************************************************************************
* Global Variables *
*********************************************************************************************************************************/
/* We ASSUME that BS3CLASS16CODE is 64KB aligned, so the low 16-bit of the
flat address matches. Also, these symbols are defined both with
and without underscore prefixes. */
extern BS3_DECL(void) BS3_FAR_CODE Bs3Trap16DoubleFaultHandler80386(void);
extern BS3_DECL(void) BS3_FAR_CODE Bs3Trap16DoubleFaultHandler80286(void);
extern BS3_DECL(void) BS3_FAR_CODE Bs3Trap16GenericEntries(void);
/* These two are ugly. Need data access for patching purposes. */
extern uint8_t BS3_FAR_DATA bs3Trap16GenericTrapOrInt[];
#undef Bs3Trap16InitEx
BS3_CMN_DEF(void, Bs3Trap16InitEx,(bool f386Plus))
{
X86TSS16 BS3_FAR *pTss;
unsigned iIdt;
/*
* If 386 or later, patch the trap handler code to not jump to the 80286
* code but continue with the next instruction (the 386+ code).
*/
if (f386Plus)
{
uint8_t BS3_FAR_DATA *pbFunction = &bs3Trap16GenericTrapOrInt[0];
#if ARCH_BITS == 16
if (g_bBs3CurrentMode != BS3_MODE_RM)
pbFunction = (uint8_t BS3_FAR_DATA *)BS3_FP_MAKE(BS3_SEL_TILED + 1, BS3_FP_OFF(pbFunction));
#endif
pbFunction[1] = 0;
pbFunction[2] = 0;
}
/*
* IDT entries, except the system call gate.
*/
for (iIdt = 0; iIdt < 256; iIdt++)
if (iIdt != BS3_TRAP_SYSCALL)
Bs3Trap16SetGate(iIdt, X86_SEL_TYPE_SYS_286_INT_GATE, 0 /*bDpl*/,
BS3_SEL_R0_CS16, (uint16_t)(uintptr_t)Bs3Trap16GenericEntries + iIdt * 8, 0 /*cParams*/);
/*
* Initialize the normal TSS so we can do ring transitions via the IDT.
*/
pTss = &Bs3Tss16;
Bs3MemZero(pTss, sizeof(*pTss));
pTss->sp0 = BS3_ADDR_STACK_R0;
pTss->ss0 = BS3_SEL_R0_SS16;
pTss->sp1 = BS3_ADDR_STACK_R1;
pTss->ss1 = BS3_SEL_R1_SS16 | 1;
pTss->sp2 = BS3_ADDR_STACK_R2;
pTss->ss2 = BS3_SEL_R2_SS16 | 2;
/*
* Initialize the double fault TSS.
* cr3 is filled in by switcher code, when needed.
*/
pTss = &Bs3Tss16DoubleFault;
Bs3MemZero(pTss, sizeof(*pTss));
pTss->sp0 = BS3_ADDR_STACK_R0;
pTss->ss0 = BS3_SEL_R0_SS16;
pTss->sp1 = BS3_ADDR_STACK_R1;
pTss->ss1 = BS3_SEL_R1_SS16 | 1;
pTss->sp2 = BS3_ADDR_STACK_R2;
pTss->ss2 = BS3_SEL_R2_SS16 | 2;
pTss->ip = (uint16_t)(uintptr_t)(f386Plus ? &Bs3Trap16DoubleFaultHandler80386 : &Bs3Trap16DoubleFaultHandler80286);
pTss->flags = X86_EFL_1;
pTss->sp = BS3_ADDR_STACK_R0_IST1;
pTss->es = BS3_SEL_R0_DS16;
pTss->ds = BS3_SEL_R0_DS16;
pTss->cs = BS3_SEL_R0_CS16;
pTss->ss = BS3_SEL_R0_SS16;
pTss->dx = f386Plus;
Bs3Trap16SetGate(X86_XCPT_DF, X86_SEL_TYPE_SYS_TASK_GATE, 0 /*bDpl*/, BS3_SEL_TSS16_DF, 0, 0 /*cParams*/);
}
#undef Bs3Trap16Init
BS3_CMN_DEF(void, Bs3Trap16Init,(void))
{
BS3_CMN_NM(Bs3Trap16InitEx)((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386);
}
|
06e41548e74c22bf58485e5d3a34c9139212b402
|
f9e7d65cb784c01a0200145ba8d289afe41d4a56
|
/chip/ish/system_state_subsys.c
|
36b79c747a0b8b5fcb8c30334fcfd0495ed4710a
|
[
"BSD-3-Clause"
] |
permissive
|
FrameworkComputer/EmbeddedController
|
ad7086769e87d0a4179eae96a7c9ff5e383ff54e
|
f6d6b927eed71550d3475411cfc3e59abe5cef2a
|
refs/heads/hx20-hx30
| 2023-08-08T20:45:10.621169
| 2023-05-26T07:03:59
| 2023-05-26T07:03:59
| 447,021,040
| 846
| 48
|
BSD-3-Clause
| 2023-05-26T07:04:59
| 2022-01-12T00:11:14
|
C
|
UTF-8
|
C
| false
| false
| 4,527
|
c
|
system_state_subsys.c
|
/* Copyright 2018 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "heci_client.h"
#include "registers.h"
#include "system_state.h"
#include "console.h"
#ifdef SS_SUBSYSTEM_DEBUG
#define CPUTS(outstr) cputs(CC_LPC, outstr)
#define CPRINTS(format, args...) cprints(CC_LPC, format, ## args)
#define CPRINTF(format, args...) cprintf(CC_LPC, format, ## args)
#else
#define CPUTS(outstr)
#define CPRINTS(format, args...)
#define CPRINTF(format, args...)
#endif
/* the following "define"s and structures are from host driver
* and they are slightly modified for look&feel purpose.
*/
#define SYSTEM_STATE_SUBSCRIBE 0x1
#define SYSTEM_STATE_STATUS 0x2
#define SYSTEM_STATE_QUERY_SUBSCRIBERS 0x3
#define SYSTEM_STATE_STATE_CHANGE_REQ 0x4
#define SUSPEND_STATE_BIT BIT(1) /* suspend/resume */
/* Cached state of ISH's requested power rails when AP suspends */
static uint32_t cached_vnn_request;
struct ss_header {
uint32_t cmd;
uint32_t cmd_status;
} __packed;
struct ss_query_subscribers {
struct ss_header hdr;
} __packed;
struct ss_subscribe {
struct ss_header hdr;
uint32_t states;
} __packed;
struct ss_status {
struct ss_header hdr;
uint32_t supported_states;
uint32_t states_status;
} __packed;
/* change request from device but host doesn't support it */
struct ss_state_change_req {
struct ss_header hdr;
uint32_t requested_states;
uint32_t states_status;
} __packed;
/*
* TODO: For now, every HECI client with valid .suspend or .resume callback is
* automatically registered as client of system state subsystem.
* so MAX_SS_CLIENTS should be HECI_MAX_NUM_OF_CLIENTS.
* if an object wants to get system state event then it can embeds
* "struct ss_subsys_device" in it and calls ss_subsys_register_client() like
* HECI client.
*/
#define MAX_SS_CLIENTS HECI_MAX_NUM_OF_CLIENTS
struct ss_subsystem_context {
uint32_t registered_state;
int num_of_ss_client;
struct ss_subsys_device *clients[MAX_SS_CLIENTS];
};
static struct ss_subsystem_context ss_subsys_ctx;
int ss_subsys_register_client(struct ss_subsys_device *ss_device)
{
int handle;
if (ss_subsys_ctx.num_of_ss_client == MAX_SS_CLIENTS)
return -1;
if (ss_device->cbs->resume || ss_device->cbs->suspend) {
handle = ss_subsys_ctx.num_of_ss_client++;
ss_subsys_ctx.registered_state |= SUSPEND_STATE_BIT;
ss_subsys_ctx.clients[handle] = ss_device;
} else {
return -1;
}
return handle;
}
static int ss_subsys_suspend(void)
{
int i;
for (i = ss_subsys_ctx.num_of_ss_client - 1; i >= 0; i--) {
if (ss_subsys_ctx.clients[i]->cbs->suspend)
ss_subsys_ctx.clients[i]->cbs->suspend(
ss_subsys_ctx.clients[i]);
}
/*
* PMU_VNN_REQ is used by ISH FW to assert power requirements of ISH to
* PMC. The system won't enter S0ix if ISH is requesting any power
* rails. Setting a bit to 1 both sets and clears a requested value.
* Cache the value of request power so we can restore it on resume.
*/
if (IS_ENABLED(CHIP_FAMILY_ISH5)) {
cached_vnn_request = PMU_VNN_REQ;
PMU_VNN_REQ = cached_vnn_request;
}
return EC_SUCCESS;
}
static int ss_subsys_resume(void)
{
int i;
/*
* Restore VNN power request from before suspend.
*/
if (IS_ENABLED(CHIP_FAMILY_ISH5) &&
cached_vnn_request) {
/* Request all cached power rails that are not already on. */
PMU_VNN_REQ = cached_vnn_request & ~PMU_VNN_REQ;
/* Wait for power request to get acknowledged */
while (!(PMU_VNN_REQ_ACK & PMU_VNN_REQ_ACK_STATUS))
continue;
}
for (i = 0; i < ss_subsys_ctx.num_of_ss_client; i++) {
if (ss_subsys_ctx.clients[i]->cbs->resume)
ss_subsys_ctx.clients[i]->cbs->resume(
ss_subsys_ctx.clients[i]);
}
return EC_SUCCESS;
}
void heci_handle_system_state_msg(uint8_t *msg, const size_t length)
{
struct ss_header *hdr = (struct ss_header *)msg;
struct ss_subscribe subscribe;
struct ss_status *status;
switch (hdr->cmd) {
case SYSTEM_STATE_QUERY_SUBSCRIBERS:
subscribe.hdr.cmd = SYSTEM_STATE_SUBSCRIBE;
subscribe.hdr.cmd_status = 0;
subscribe.states = ss_subsys_ctx.registered_state;
heci_send_fixed_client_msg(HECI_FIXED_SYSTEM_STATE_ADDR,
(uint8_t *)&subscribe,
sizeof(subscribe));
break;
case SYSTEM_STATE_STATUS:
status = (struct ss_status *)msg;
if (status->supported_states & SUSPEND_STATE_BIT) {
if (status->states_status & SUSPEND_STATE_BIT)
ss_subsys_suspend();
else
ss_subsys_resume();
}
break;
}
}
|
bd0dab1e7f3f870611197ddc46f5055e6a6433cc
|
a3d6556180e74af7b555f8d47d3fea55b94bcbda
|
/chrome/browser/support_tool/data_collector_utils.h
|
170cf71a96210fc7f8fe2a4e2c4b7781fdf3a938
|
[
"BSD-3-Clause"
] |
permissive
|
chromium/chromium
|
aaa9eda10115b50b0616d2f1aed5ef35d1d779d6
|
a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c
|
refs/heads/main
| 2023-08-24T00:35:12.585945
| 2023-08-23T22:01:11
| 2023-08-23T22:01:11
| 120,360,765
| 17,408
| 7,102
|
BSD-3-Clause
| 2023-09-10T23:44:27
| 2018-02-05T20:55:32
| null |
UTF-8
|
C
| false
| false
| 454
|
h
|
data_collector_utils.h
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_SUPPORT_TOOL_DATA_COLLECTOR_UTILS_H_
#define CHROME_BROWSER_SUPPORT_TOOL_DATA_COLLECTOR_UTILS_H_
#include "chrome/browser/support_tool/data_collector.h"
void MergePIIMaps(PIIMap& out_pii_map, const PIIMap& from_pii_map);
#endif // CHROME_BROWSER_SUPPORT_TOOL_DATA_COLLECTOR_UTILS_H_
|
a5f7693f727762062100f5b9282af905704125a0
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/u-boot_new/drivers/usb/gadget/ci_udc.h
|
346164a641329981b6c187dbdf44d609f36208cf
|
[
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"GPL-2.0-or-later"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 3,303
|
h
|
ci_udc.h
|
/*
* Copyright 2011, Marvell Semiconductor Inc.
*
* Licensed under the GPL-2 or later.
*/
#ifndef __GADGET__CI_UDC_H__
#define __GADGET__CI_UDC_H__
#define NUM_ENDPOINTS 6
#ifdef CONFIG_CI_UDC_HAS_HOSTPC
struct ci_udc {
u32 usbcmd; /* 0x130 */
u32 usbsts; /* 0x134 */
u32 pad1[3];
u32 devaddr; /* 0x144 */
u32 epinitaddr; /* 0x148 */
u32 pad2[10];
u32 portsc; /* 0x174 */
u32 pad178[(0x1b4 - (0x174 + 4)) / 4];
u32 hostpc1_devlc; /* 0x1b4 */
u32 pad1b8[(0x1f8 - (0x1b4 + 4)) / 4];
u32 usbmode; /* 0x1f8 */
u32 pad1fc[(0x208 - (0x1f8 + 4)) / 4];
u32 epsetupstat; /* 0x208 */
u32 epprime; /* 0x20c */
u32 epflush; /* 0x210 */
u32 epstat; /* 0x214 */
u32 epcomp; /* 0x218 */
u32 epctrl[16]; /* 0x21c */
};
#else
struct ci_udc {
u32 usbcmd; /* 0x140 */
u32 usbsts; /* 0x144 */
u32 pad1[3];
u32 devaddr; /* 0x154 */
u32 epinitaddr; /* 0x158 */
u32 pad2[10];
u32 portsc; /* 0x184 */
u32 pad3[8];
u32 usbmode; /* 0x1a8 */
u32 epstat; /* 0x1ac */
u32 epprime; /* 0x1b0 */
u32 epflush; /* 0x1b4 */
u32 pad4;
u32 epcomp; /* 0x1bc */
u32 epctrl[16]; /* 0x1c0 */
};
#define PTS_ENABLE 2
#define PTS(x) (((x) & 0x3) << 30)
#define PFSC (1 << 24)
#endif
#define MICRO_8FRAME 0x8
#define USBCMD_ITC(x) ((((x) > 0xff) ? 0xff : x) << 16)
#define USBCMD_FS2 (1 << 15)
#define USBCMD_RST (1 << 1)
#define USBCMD_RUN (1)
#define STS_SLI (1 << 8)
#define STS_URI (1 << 6)
#define STS_PCI (1 << 2)
#define STS_UEI (1 << 1)
#define STS_UI (1 << 0)
#define USBMODE_DEVICE 2
#define EPT_TX(x) (1 << (((x) & 0xffff) + 16))
#define EPT_RX(x) (1 << ((x) & 0xffff))
#define CTRL_TXE (1 << 23)
#define CTRL_TXR (1 << 22)
#define CTRL_RXE (1 << 7)
#define CTRL_RXR (1 << 6)
#define CTRL_TXT_BULK (2 << 18)
#define CTRL_RXT_BULK (2 << 2)
struct ci_req {
struct usb_request req;
struct list_head queue;
/* Bounce buffer allocated if needed to align the transfer */
uint8_t *b_buf;
uint32_t b_len;
/* Buffer for the current transfer. Either req.buf/len or b_buf/len */
uint8_t *hw_buf;
uint32_t hw_len;
};
struct ci_ep {
struct usb_ep ep;
struct list_head queue;
bool req_primed;
const struct usb_endpoint_descriptor *desc;
};
struct ci_drv {
struct usb_gadget gadget;
struct ci_req *ep0_req;
bool ep0_data_phase;
struct usb_gadget_driver *driver;
struct ehci_ctrl *ctrl;
struct ept_queue_head *epts;
uint8_t *items_mem;
struct ci_ep ep[NUM_ENDPOINTS];
};
struct ept_queue_head {
unsigned config;
unsigned current; /* read-only */
unsigned next;
unsigned info;
unsigned page0;
unsigned page1;
unsigned page2;
unsigned page3;
unsigned page4;
unsigned reserved_0;
unsigned char setup_data[8];
unsigned reserved_1;
unsigned reserved_2;
unsigned reserved_3;
unsigned reserved_4;
};
#define CONFIG_MAX_PKT(n) ((n) << 16)
#define CONFIG_ZLT (1 << 29) /* stop on zero-len xfer */
#define CONFIG_IOS (1 << 15) /* IRQ on setup */
struct ept_queue_item {
unsigned next;
unsigned info;
unsigned page0;
unsigned page1;
unsigned page2;
unsigned page3;
unsigned page4;
unsigned reserved;
};
#define TERMINATE 1
#define INFO_BYTES(n) ((n) << 16)
#define INFO_IOC (1 << 15)
#define INFO_ACTIVE (1 << 7)
#define INFO_HALTED (1 << 6)
#define INFO_BUFFER_ERROR (1 << 5)
#define INFO_TX_ERROR (1 << 3)
#endif
|
a1bc1460f2b9c14c5d57bbf833eb89d8b10dd09e
|
26d3db4534584624aa18cd2d297f4350682ea51f
|
/tests/scimark2/MonteCarlo.h
|
ea3f4adf2805af4b74cf0ad2824afeabef9bd531
|
[
"MIT"
] |
permissive
|
sysprog21/rv32emu
|
b4da9ae47eff5ecb9a044f75b0191ddd3b5fe69a
|
1275468f2bc1a37ea412f40629a32062bacbb156
|
refs/heads/master
| 2023-09-05T23:13:39.631150
| 2023-09-05T13:27:31
| 2023-09-05T13:27:31
| 304,615,451
| 193
| 49
|
MIT
| 2023-09-12T11:24:34
| 2020-10-16T12:05:06
|
C
|
UTF-8
|
C
| false
| false
| 106
|
h
|
MonteCarlo.h
|
#pragma once
double MonteCarlo_integrate(int Num_samples);
double MonteCarlo_num_flops(int Num_samples);
|
d7f61d831c6f97663a6832fe4e346fa8a37c2c39
|
b98323f2b23a23d674bbb75c6f5db0b5aafbe57a
|
/include/SDL_gpu_OpenGL_1_BASE.h
|
5c330354c56f9ae02f08885fe8e39cd2afef0a23
|
[
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
grimfang4/sdl-gpu
|
f03f24fd84a8e2f61d8c9c331044a592f6bbfd97
|
e8ee3522ba0dbe72ca387d978e5f49a9f31e7ba0
|
refs/heads/master
| 2023-07-10T10:56:21.827473
| 2022-06-24T14:59:46
| 2022-06-24T15:00:01
| 32,435,968
| 1,269
| 175
|
MIT
| 2022-09-03T11:53:58
| 2015-03-18T03:33:13
|
C
|
UTF-8
|
C
| false
| false
| 1,930
|
h
|
SDL_gpu_OpenGL_1_BASE.h
|
#ifndef _SDL_GPU_OPENGL_1_BASE_H__
#define _SDL_GPU_OPENGL_1_BASE_H__
#include "SDL_gpu.h"
#if !defined(SDL_GPU_DISABLE_OPENGL) && !defined(SDL_GPU_DISABLE_OPENGL_1_BASE)
// Hacks to fix compile errors due to polluted namespace
#ifdef _WIN32
#define _WINUSER_H
#define _WINGDI_H
#endif
#include "glew.h"
#if defined(GL_EXT_bgr) && !defined(GL_BGR)
#define GL_BGR GL_BGR_EXT
#endif
#if defined(GL_EXT_bgra) && !defined(GL_BGRA)
#define GL_BGRA GL_BGRA_EXT
#endif
#if defined(GL_EXT_abgr) && !defined(GL_ABGR)
#define GL_ABGR GL_ABGR_EXT
#endif
#undef GL_MIRRORED_REPEAT
#define GL_MIRRORED_REPEAT GL_MIRRORED_REPEAT_ARB
#endif
#define GPU_CONTEXT_DATA ContextData_OpenGL_1_BASE
#define GPU_IMAGE_DATA ImageData_OpenGL_1_BASE
#define GPU_TARGET_DATA TargetData_OpenGL_1_BASE
typedef struct ContextData_OpenGL_1_BASE
{
SDL_Color last_color;
GPU_bool last_use_texturing;
unsigned int last_shape;
GPU_bool last_use_blending;
GPU_BlendMode last_blend_mode;
GPU_Rect last_viewport;
GPU_Camera last_camera;
GPU_bool last_camera_inverted;
GPU_bool last_depth_test;
GPU_bool last_depth_write;
GPU_ComparisonEnum last_depth_function;
GPU_Image* last_image;
float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
unsigned short blit_buffer_num_vertices;
unsigned short blit_buffer_max_num_vertices;
unsigned short* index_buffer; // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
unsigned int index_buffer_num_vertices;
unsigned int index_buffer_max_num_vertices;
} ContextData_OpenGL_1_BASE;
typedef struct ImageData_OpenGL_1_BASE
{
int refcount;
GPU_bool owns_handle;
Uint32 handle;
Uint32 format;
} ImageData_OpenGL_1_BASE;
typedef struct TargetData_OpenGL_1_BASE
{
int refcount;
Uint32 handle;
Uint32 format;
} TargetData_OpenGL_1_BASE;
#endif
|
72b4951e24cdf9ba52dd5142eca983ecaf5e3e8a
|
5f86fc385c7dcfcb5b166cdea7c8b13057b8bb5f
|
/tests/eeid_plugin/test_helpers.h
|
224a1ddfbb63d045199b20ad8a10cbb0d1a06907
|
[
"MIT"
] |
permissive
|
openenclave/openenclave
|
54a38e12d9aa73357d9f438a07cd8c07ffe5e6df
|
cdeb95c1ec163117de409295333b6b2702013e08
|
refs/heads/master
| 2023-08-14T16:43:32.049533
| 2023-07-21T15:58:54
| 2023-07-21T15:58:54
| 101,804,230
| 800
| 372
|
MIT
| 2023-09-12T20:26:02
| 2017-08-29T20:31:38
|
C
|
UTF-8
|
C
| false
| false
| 339
|
h
|
test_helpers.h
|
// Copyright (c) Open Enclave SDK contributors.
// Licensed under the MIT License.
#ifndef _OE_EEID_PLUGIN_TEST_HELPERS_
#define _OE_EEID_PLUGIN_TEST_HELPERS_
#include <openenclave/bits/eeid.h>
#include <openenclave/bits/result.h>
oe_result_t make_test_eeid(oe_eeid_t** eeid, size_t data_size);
#endif // _OE_EEID_PLUGIN_TEST_HELPERS_S
|
5b1cd42ca289a3aca6e5eaae3689726b8a12bc65
|
bc0a8dd557e546379062bc31839b0baf29cebdf7
|
/tcmur_cmd_handler.h
|
9407d0a41aaac737b0cc6d01f605394faf062610
|
[
"Apache-2.0",
"LGPL-2.1-only"
] |
permissive
|
open-iscsi/tcmu-runner
|
d0dd5ec7a566fa7795912cc23ab92761b78b12dd
|
1bdb239fa183c84d2ace6b52aa33476968a0cef7
|
refs/heads/main
| 2023-08-26T05:58:34.068752
| 2023-01-18T17:26:03
| 2023-05-26T05:08:36
| 21,918,673
| 176
| 149
|
Apache-2.0
| 2023-09-05T15:47:01
| 2014-07-16T21:20:00
|
C
|
UTF-8
|
C
| false
| false
| 1,298
|
h
|
tcmur_cmd_handler.h
|
/*
* Copyright (c) 2017 Red Hat, Inc.
*
* This file is licensed to you under your choice of the GNU Lesser
* General Public License, version 2.1 or any later version (LGPLv2.1 or
* later), or the Apache License 2.0.
*/
#ifndef __TCMUR_CMD_HANDLER_H
#define __TCMUR_CMD_HANDLER_H
#include <stdint.h>
struct tcmu_device;
struct tcmulib_cmd;
struct tcmur_cmd;
struct timespec;
int tcmur_get_time(struct tcmu_device *dev, struct timespec *time);
int tcmur_dev_update_size(struct tcmu_device *dev, uint64_t new_size);
void tcmur_set_pending_ua(struct tcmu_device *dev, int ua);
int tcmur_generic_handle_cmd(struct tcmu_device *dev, struct tcmulib_cmd *cmd);
int tcmur_cmd_passthrough_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd);
bool tcmur_handler_is_passthrough_only(struct tcmur_handler *rhandler);
void tcmur_tcmulib_cmd_complete(struct tcmu_device *dev,
struct tcmulib_cmd *cmd, int ret);
typedef int (*tcmur_writesame_fn_t)(struct tcmu_device *dev,
struct tcmur_cmd *tcmur_cmd, uint64_t off,
uint64_t len, struct iovec *iov,
size_t iov_cnt);
typedef int (*tcmur_caw_fn_t)(struct tcmu_device *dev,
struct tcmur_cmd *tcmur_cmd, uint64_t off,
uint64_t len, struct iovec *iov, size_t iov_cnt);
#endif /* __TCMUR_CMD_HANDLER_H */
|
249804701f4b23107662d8c2ee4dd9a986b7397a
|
badb70a0b235c98ac034cfe5b4bfafda36647831
|
/Legacy/BootPlatform/BlockIoDxe/Edd.h
|
b9c457614226ba94ecb3553186253dd636d89c88
|
[
"BSD-3-Clause"
] |
permissive
|
acidanthera/OpenCorePkg
|
f34a7d67b22c74fb5ab559e48519e5f5855b6751
|
1d5b1736fe5a5ef7662b5c076c6d11aac96fd5d6
|
refs/heads/master
| 2023-08-30T21:03:02.993659
| 2023-08-28T23:30:43
| 2023-08-28T23:30:43
| 179,354,282
| 13,212
| 2,999
|
BSD-3-Clause
| 2023-09-10T18:29:53
| 2019-04-03T19:14:29
|
C
|
UTF-8
|
C
| false
| false
| 5,229
|
h
|
Edd.h
|
/** @file
Include file to suport EDD 3.0.
This file is coded to T13 D1386 Revision 3
Availible on http://www.t13.org/#Project drafts
Currently at ftp://fission.dt.wdc.com/pub/standards/x3t13/project/d1386r3.pdf
Copyright (c) 1999 - 2010, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef _EDD_H_
#define _EDD_H_
//
// packing with no compiler padding, so that the fields
// of the following architected structures can be
// properly accessed from C code.
//
#pragma pack(1)
typedef struct {
UINT8 Bus;
UINT8 Device;
UINT8 Function;
UINT8 Controller;
UINT32 Reserved;
} EDD_PCI;
typedef struct {
UINT16 Base;
UINT16 Reserved;
UINT32 Reserved2;
} EDD_LEGACY;
typedef union {
EDD_PCI Pci;
EDD_LEGACY Legacy;
} EDD_INTERFACE_PATH;
typedef struct {
UINT8 Master;
UINT8 Reserved[15];
} EDD_ATA;
typedef struct {
UINT8 Master;
UINT8 Lun;
UINT8 Reserved[14];
} EDD_ATAPI;
typedef struct {
UINT16 Pun;
UINT64 Lun;
UINT8 Reserved[6];
} EDD_SCSI;
typedef struct {
UINT64 SerialNumber;
UINT64 Reserved;
} EDD_USB;
typedef struct {
UINT64 Guid;
UINT64 Reserved;
} EDD_1394;
typedef struct {
UINT64 Wwn;
UINT64 Lun;
} EDD_FIBRE;
typedef union {
EDD_ATA Ata;
EDD_ATAPI Atapi;
EDD_SCSI Scsi;
EDD_USB Usb;
EDD_1394 FireWire;
EDD_FIBRE FibreChannel;
} EDD_DEVICE_PATH;
typedef struct {
UINT16 StructureSize;
UINT16 Flags;
UINT32 MaxCylinders;
UINT32 MaxHeads;
UINT32 SectorsPerTrack;
UINT64 PhysicalSectors;
UINT16 BytesPerSector;
UINT32 Fdpt;
UINT16 Key;
UINT8 DevicePathLength;
UINT8 Reserved1;
UINT16 Reserved2;
CHAR8 HostBusType[4];
CHAR8 InterfaceType[8];
EDD_INTERFACE_PATH InterfacePath;
EDD_DEVICE_PATH DevicePath;
UINT8 Reserved3;
UINT8 Checksum;
} EDD_DRIVE_PARAMETERS;
//
// EDD_DRIVE_PARAMETERS.Flags defines
//
#define EDD_GEOMETRY_VALID 0x02
#define EDD_DEVICE_REMOVABLE 0x04
#define EDD_WRITE_VERIFY_SUPPORTED 0x08
#define EDD_DEVICE_CHANGE 0x10
#define EDD_DEVICE_LOCKABLE 0x20
//
// BUGBUG: This bit does not follow the spec. It tends to be always set
// to work properly with Win98.
//
#define EDD_DEVICE_GEOMETRY_MAX 0x40
typedef struct {
UINT8 PacketSizeInBytes; // 0x18
UINT8 Zero;
UINT8 NumberOfBlocks; // Max 0x7f
UINT8 Zero2;
UINT32 SegOffset;
UINT64 Lba;
UINT64 TransferBuffer;
UINT32 ExtendedBlockCount; // Max 0xffffffff
UINT32 Zero3;
} EDD_DEVICE_ADDRESS_PACKET;
#define EDD_VERSION_30 0x30
//
// Int 13 BIOS Errors
//
#define BIOS_PASS 0x00
#define BIOS_WRITE_PROTECTED 0x03
#define BIOS_SECTOR_NOT_FOUND 0x04
#define BIOS_RESET_FAILED 0x05
#define BIOS_DISK_CHANGED 0x06
#define BIOS_DRIVE_DOES_NOT_EXIST 0x07
#define BIOS_DMA_ERROR 0x08
#define BIOS_DATA_BOUNDRY_ERROR 0x09
#define BIOS_BAD_SECTOR 0x0a
#define BIOS_BAD_TRACK 0x0b
#define BIOS_MEADIA_TYPE_NOT_FOUND 0x0c
#define BIOS_INVALED_FORMAT 0x0d
#define BIOS_ECC_ERROR 0x10
#define BIOS_ECC_CORRECTED_ERROR 0x11
#define BIOS_HARD_DRIVE_FAILURE 0x20
#define BIOS_SEEK_FAILED 0x40
#define BIOS_DRIVE_TIMEOUT 0x80
#define BIOS_DRIVE_NOT_READY 0xaa
#define BIOS_UNDEFINED_ERROR 0xbb
#define BIOS_WRITE_FAULT 0xcc
#define BIOS_SENSE_FAILED 0xff
#define MAX_EDD11_XFER 0xfe00
#pragma pack()
//
// Internal Data Structures
//
typedef struct {
CHAR8 Letter;
UINT8 Number;
UINT8 EddVersion;
BOOLEAN ExtendedInt13;
BOOLEAN DriveLockingAndEjecting;
BOOLEAN Edd;
BOOLEAN Extensions64Bit;
BOOLEAN ParametersValid;
UINT8 ErrorCode;
VOID *FdptPointer;
BOOLEAN Floppy;
BOOLEAN AtapiFloppy;
UINT8 MaxHead;
UINT8 MaxSector;
UINT16 MaxCylinder;
UINT16 Pad;
EDD_DRIVE_PARAMETERS Parameters;
} BIOS_LEGACY_DRIVE;
#define BIOS_CONSOLE_BLOCK_IO_DEV_SIGNATURE SIGNATURE_32 ('b', 'b', 'i', 'o')
typedef struct {
UINTN Signature;
EFI_HANDLE Handle;
EFI_HANDLE ControllerHandle;
EFI_BLOCK_IO_PROTOCOL BlockIo;
EFI_BLOCK_IO_MEDIA BlockMedia;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_PCI_IO_PROTOCOL *PciIo;
EFI_LEGACY_8259_PROTOCOL *Legacy8259;
THUNK_CONTEXT *ThunkContext;
BIOS_LEGACY_DRIVE Bios;
} BIOS_BLOCK_IO_DEV;
#define BIOS_BLOCK_IO_FROM_THIS(a) CR (a, BIOS_BLOCK_IO_DEV, BlockIo, BIOS_CONSOLE_BLOCK_IO_DEV_SIGNATURE)
#endif
|
99265a28f03c975f7bfdadf091a5678997ceecec
|
99bdb3251fecee538e0630f15f6574054dfc1468
|
/components/dfs/dfs_v1/filesystems/nfs/dfs_nfs.c
|
9adc5b6c4214a45a8a33a1d54f334689f818bbde
|
[
"Apache-2.0"
] |
permissive
|
RT-Thread/rt-thread
|
03a7c52c2aeb1b06a544143b0e803d72f47d1ece
|
3602f891211904a27dcbd51e5ba72fefce7326b2
|
refs/heads/master
| 2023-09-01T04:10:20.295801
| 2023-08-31T16:20:55
| 2023-08-31T16:20:55
| 7,408,108
| 9,599
| 5,805
|
Apache-2.0
| 2023-09-14T13:37:26
| 2013-01-02T14:49:21
|
C
|
UTF-8
|
C
| false
| false
| 28,586
|
c
|
dfs_nfs.c
|
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/
#include <stdio.h>
#include <rtthread.h>
#include <dfs_fs.h>
#include <dfs.h>
#include <dfs_file.h>
#include <rpc/rpc.h>
#include "mount.h"
#include "nfs.h"
#define NAME_MAX 64
#define DFS_NFS_MAX_MTU 1024
#ifdef _WIN32
#define strtok_r strtok_s
#endif
struct nfs_file
{
nfs_fh3 handle; /* handle */
size_t offset; /* current offset */
size_t size; /* total size */
bool_t eof; /* end of file */
};
struct nfs_dir
{
nfs_fh3 handle;
cookie3 cookie;
cookieverf3 cookieverf;
entry3 *entry;
bool_t eof;
READDIR3res res;
};
#define HOST_LENGTH 32
#define EXPORT_PATH_LENGTH 32
struct nfs_filesystem
{
nfs_fh3 root_handle;
nfs_fh3 current_handle;
CLIENT *nfs_client;
CLIENT *mount_client;
char host[HOST_LENGTH];
char export[EXPORT_PATH_LENGTH];
void *data; /* nfs_file or nfs_dir */
};
typedef struct nfs_filesystem nfs_filesystem;
typedef struct nfs_file nfs_file;
typedef struct nfs_dir nfs_dir;
nfs_dir *nfs_opendir(nfs_filesystem *nfs, const char *path);
static int nfs_parse_host_export(const char *host_export,
char *host,
size_t host_len,
char *export,
size_t export_len)
{
int index;
for (index = 0; index < host_len; index ++)
{
/* it's end of string, failed */
if (host_export[index] == 0)
return -1;
/* copy to host buffer */
if (host_export[index] != ':')
host[index] = host_export[index];
else
break;
}
/* host buffer is not enough, failed */
if (index == host_len)
return -1;
/* make NULL */
host_len = index;
host[host_len] = '\0';
host_len ++;
/* copy export path */
for (index = host_len; index < host_len + export_len; index ++)
{
if (host_export[index] == 0)
{
export[index - host_len] = '\0';
return 0;
}
export[index - host_len] = host_export[index];
}
return -1;
}
static void copy_handle(nfs_fh3 *dest, const nfs_fh3 *source)
{
dest->data.data_len = source->data.data_len;
dest->data.data_val = rt_malloc(dest->data.data_len);
if (dest->data.data_val == NULL)
{
dest->data.data_len = 0;
return;
}
memcpy(dest->data.data_val, source->data.data_val, dest->data.data_len);
}
static nfs_fh3 *get_handle(nfs_filesystem *nfs, const char *name)
{
nfs_fh3 *handle = NULL;
char *file;
char *path;
char *init;
init = path = rt_malloc(strlen(name) + 1);
if (init == NULL)
return NULL;
memcpy(init, name, strlen(name) + 1);
handle = rt_malloc(sizeof(nfs_fh3));
if (handle == NULL)
{
rt_free(init);
return NULL;
}
if (path[0] == '/')
{
path ++;
copy_handle(handle, &nfs->root_handle);
}
else
{
copy_handle(handle, &nfs->current_handle);
}
while ((file = strtok_r(NULL, "/", &path)) != NULL)
{
LOOKUP3args args;
LOOKUP3res res;
memset(&res, 0, sizeof(res));
copy_handle(&args.what.dir, handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
args.what.name = file;
if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Lookup failed\n");
rt_free(init);
rt_free(handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
return NULL;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Lookup failed: %d\n", res.status);
rt_free(init);
rt_free(handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
return NULL;
}
copy_handle(handle, &res.LOOKUP3res_u.resok.object);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
}
rt_free(init);
return handle;
}
static nfs_fh3 *get_dir_handle(nfs_filesystem *nfs, const char *name)
{
nfs_fh3 *handle = NULL;
char *file;
char *path;
char *init;
init = path = rt_malloc(strlen(name) + 1);
if (init == NULL)
return NULL;
memcpy(init, name, strlen(name) + 1);
handle = rt_malloc(sizeof(nfs_fh3));
if (handle == NULL)
{
rt_free(init);
return NULL;
}
if (path[0] == '/')
{
path ++;
copy_handle(handle, &nfs->root_handle);
}
else
{
copy_handle(handle, &nfs->current_handle);
}
while ((file = strtok_r(NULL, "/", &path)) != NULL && path && path[0] != 0)
{
LOOKUP3args args;
LOOKUP3res res;
memset(&res, 0, sizeof(res));
copy_handle(&args.what.dir, handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
args.what.name = file;
if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Lookup failed\n");
rt_free(init);
rt_free(handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
return NULL;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Lookup failed: %d\n", res.status);
rt_free(init);
rt_free(handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
return NULL;
}
copy_handle(handle, &res.LOOKUP3res_u.resok.object);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
}
rt_free(init);
return handle;
}
static size_t nfs_get_filesize(nfs_filesystem *nfs, nfs_fh3 *handle)
{
GETATTR3args args;
GETATTR3res res;
fattr3 *info;
size_t size;
args.object = *handle;
memset(&res, '\0', sizeof(res));
if ((nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) ||
res.status != NFS3_OK)
{
rt_kprintf("GetAttr failed: %d\n", res.status);
return 0;
}
info = &res.GETATTR3res_u.resok.obj_attributes;
size = info->size;
xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
return size;
}
rt_bool_t nfs_is_directory(nfs_filesystem *nfs, const char *name)
{
GETATTR3args args;
GETATTR3res res;
fattr3 *info;
nfs_fh3 *handle;
rt_bool_t result;
result = RT_FALSE;
handle = get_handle(nfs, name);
if (handle == NULL)
return RT_FALSE;
args.object = *handle;
memset(&res, '\0', sizeof(res));
if (nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("GetAttr failed\n");
return RT_FALSE;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Getattr failed: %d\n", res.status);
return RT_FALSE;
}
info = &res.GETATTR3res_u.resok.obj_attributes;
if (info->type == NFS3DIR)
result = RT_TRUE;
xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
return result;
}
int nfs_create(nfs_filesystem *nfs, const char *name, mode_t mode)
{
CREATE3args args;
CREATE3res res;
int ret = 0;
nfs_fh3 *handle;
if (nfs->nfs_client == NULL)
{
return -1;
}
handle = get_dir_handle(nfs, name);
if (handle == NULL)
{
return -1;
}
args.where.dir = *handle;
args.where.name = strrchr(name, '/') + 1;
if (args.where.name == NULL)
{
args.where.name = (char *)name;
}
args.how.mode = GUARDED;
args.how.createhow3_u.obj_attributes.mode.set_it = TRUE;
args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode = mode;
args.how.createhow3_u.obj_attributes.uid.set_it = FALSE;
args.how.createhow3_u.obj_attributes.gid.set_it = FALSE;
args.how.createhow3_u.obj_attributes.size.set_it = FALSE;
args.how.createhow3_u.obj_attributes.atime.set_it = DONT_CHANGE;
args.how.createhow3_u.obj_attributes.mtime.set_it = DONT_CHANGE;
memset(&res, 0, sizeof(res));
if (nfsproc3_create_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Create failed\n");
ret = -1;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Create failed: %d\n", res.status);
ret = -1;
}
xdr_free((xdrproc_t)xdr_CREATE3res, (char *)&res);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
return ret;
}
int nfs_mkdir(nfs_filesystem *nfs, const char *name, mode_t mode)
{
MKDIR3args args;
MKDIR3res res;
int ret = 0;
nfs_fh3 *handle;
if (nfs->nfs_client == NULL)
return -1;
handle = get_dir_handle(nfs, name);
if (handle == NULL)
return -1;
args.where.dir = *handle;
args.where.name = strrchr(name, '/') + 1;
if (args.where.name == NULL)
{
args.where.name = (char *)name;
}
args.attributes.mode.set_it = TRUE;
args.attributes.mode.set_mode3_u.mode = mode;
args.attributes.uid.set_it = FALSE;
args.attributes.gid.set_it = FALSE;
args.attributes.size.set_it = FALSE;
args.attributes.atime.set_it = DONT_CHANGE;
args.attributes.mtime.set_it = DONT_CHANGE;
memset(&res, 0, sizeof(res));
if (nfsproc3_mkdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Mkdir failed\n");
ret = -1;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Mkdir failed: %d\n", res.status);
ret = -1;
}
xdr_free((xdrproc_t)xdr_MKDIR3res, (char *)&res);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
return ret;
}
/* mount(NULL, "/mnt", "nfs", 0, "192.168.1.1:/export") */
int nfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
{
mountres3 res;
nfs_filesystem *nfs;
nfs = (nfs_filesystem *)rt_malloc(sizeof(nfs_filesystem));
memset(nfs, 0, sizeof(nfs_filesystem));
if (nfs_parse_host_export((const char *)data, nfs->host, HOST_LENGTH,
nfs->export, EXPORT_PATH_LENGTH) < 0)
{
rt_kprintf("host or export path error\n");
goto __return;
}
nfs->mount_client = clnt_create((char *)nfs->host, MOUNT_PROGRAM, MOUNT_V3, "udp");
if (nfs->mount_client == NULL)
{
rt_kprintf("create mount client failed\n");
goto __return;
}
memset(&res, '\0', sizeof(mountres3));
if (mountproc3_mnt_3((char *)nfs->export, &res, nfs->mount_client) != RPC_SUCCESS)
{
rt_kprintf("nfs mount failed\n");
goto __return;
}
else if (res.fhs_status != MNT3_OK)
{
rt_kprintf("nfs mount failed\n");
goto __return;
}
nfs->nfs_client = clnt_create((char *)nfs->host, NFS_PROGRAM, NFS_V3, "udp");
if (nfs->nfs_client == NULL)
{
rt_kprintf("creat nfs client failed\n");
goto __return;
}
copy_handle(&nfs->root_handle, (nfs_fh3 *)&res.mountres3_u.mountinfo.fhandle);
copy_handle(&nfs->current_handle, &nfs->root_handle);
nfs->nfs_client->cl_auth = authnone_create();
fs->data = nfs;
return 0;
__return:
if (nfs != NULL)
{
if (nfs->mount_client != NULL)
{
clnt_destroy(nfs->mount_client);
}
if (nfs->nfs_client != NULL)
{
if (nfs->nfs_client->cl_auth != NULL)
{
auth_destroy(nfs->nfs_client->cl_auth);
}
clnt_destroy(nfs->nfs_client);
}
rt_free(nfs);
}
return -1;
}
int nfs_unmount(struct dfs_filesystem *fs)
{
nfs_filesystem *nfs;
RT_ASSERT(fs != NULL);
RT_ASSERT(fs->data != NULL);
nfs = (nfs_filesystem *)fs->data;
if (nfs->mount_client != NULL &&
mountproc3_umnt_3((char *)nfs->export, NULL, nfs->mount_client) != RPC_SUCCESS)
{
rt_kprintf("unmount failed\n");
return -1;
}
/* destroy nfs client */
if (nfs->nfs_client != NULL)
{
if (nfs->nfs_client->cl_auth != NULL)
{
auth_destroy(nfs->nfs_client->cl_auth);
nfs->nfs_client->cl_auth = NULL;
}
clnt_destroy(nfs->nfs_client);
nfs->nfs_client = NULL;
}
/* destroy mount client */
if (nfs->mount_client != NULL)
{
if (nfs->mount_client->cl_auth != NULL)
{
auth_destroy(nfs->mount_client->cl_auth);
nfs->mount_client->cl_auth = NULL;
}
clnt_destroy(nfs->mount_client);
nfs->mount_client = NULL;
}
rt_free(nfs);
fs->data = NULL;
return 0;
}
int nfs_ioctl(struct dfs_file *file, int cmd, void *args)
{
return -ENOSYS;
}
int nfs_read(struct dfs_file *file, void *buf, size_t count)
{
READ3args args;
READ3res res;
ssize_t bytes, total = 0;
nfs_file *fd;
nfs_filesystem *nfs;
if (file->vnode->type == FT_DIRECTORY)
return -EISDIR;
RT_ASSERT(file->vnode->fs != NULL);
struct dfs_filesystem *dfs_nfs = ((struct dfs_filesystem *)(file->vnode->fs));
nfs = (struct nfs_filesystem *)(dfs_nfs->data);
fd = (nfs_file *)(nfs->data);
RT_ASSERT(fd != NULL);
if (nfs->nfs_client == NULL)
return -1;
/* end of file */
if (fd->eof == TRUE)
return 0;
args.file = fd->handle;
do
{
args.offset = fd->offset;
args.count = count > DFS_NFS_MAX_MTU ? DFS_NFS_MAX_MTU : count;
count -= args.count;
memset(&res, 0, sizeof(res));
if (nfsproc3_read_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Read failed\n");
total = 0;
break;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Read failed: %d\n", res.status);
total = 0;
break;
}
else
{
bytes = res.READ3res_u.resok.count;
total += bytes;
fd->offset += bytes;
/* update current position */
file->pos = fd->offset;
memcpy(buf, res.READ3res_u.resok.data.data_val, bytes);
buf = (void *)((char *)buf + args.count);
if (res.READ3res_u.resok.eof)
{
/* something should probably be here */
fd->eof = TRUE;
break;
}
}
xdr_free((xdrproc_t)xdr_READ3res, (char *)&res);
}
while (count > 0);
xdr_free((xdrproc_t)xdr_READ3res, (char *)&res);
return total;
}
int nfs_write(struct dfs_file *file, const void *buf, size_t count)
{
WRITE3args args;
WRITE3res res;
ssize_t bytes, total = 0;
nfs_file *fd;
nfs_filesystem *nfs;
if (file->vnode->type == FT_DIRECTORY)
return -EISDIR;
RT_ASSERT(file->vnode->fs != NULL);
struct dfs_filesystem *dfs_nfs = ((struct dfs_filesystem *)(file->vnode->fs));
nfs = (struct nfs_filesystem *)(dfs_nfs->data);
fd = (nfs_file *)(nfs->data);
RT_ASSERT(fd != NULL);
if (nfs->nfs_client == NULL)
return -1;
args.file = fd->handle;
args.stable = FILE_SYNC;
do
{
args.offset = fd->offset;
memset(&res, 0, sizeof(res));
args.data.data_val = (void *)buf;
args.count = count > DFS_NFS_MAX_MTU ? DFS_NFS_MAX_MTU : count;
args.data.data_len = args.count;
count -= args.count;
buf = (const void *)((char *)buf + args.count);
if (nfsproc3_write_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Write failed\n");
total = 0;
break;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Write failed: %d\n", res.status);
total = 0;
break;
}
else
{
bytes = res.WRITE3res_u.resok.count;
fd->offset += bytes;
total += bytes;
/* update current position */
file->pos = fd->offset;
/* update file size */
if (fd->size < fd->offset) fd->size = fd->offset;
file->vnode->size = fd->size;
}
xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res);
} while (count > 0);
xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res);
return total;
}
int nfs_lseek(struct dfs_file *file, off_t offset)
{
nfs_file *fd;
nfs_filesystem *nfs;
if (file->vnode->type == FT_DIRECTORY)
return -EISDIR;
RT_ASSERT(file->vnode->fs != NULL);
struct dfs_filesystem *dfs_nfs = ((struct dfs_filesystem *)(file->vnode->fs));
nfs = (struct nfs_filesystem *)(dfs_nfs->data);
fd = (nfs_file *)(nfs->data);
RT_ASSERT(fd != NULL);
if (offset <= fd->size)
{
fd->offset = offset;
return offset;
}
return -EIO;
}
int nfs_close(struct dfs_file *file)
{
nfs_filesystem *nfs;
RT_ASSERT(file->vnode->fs != NULL);
struct dfs_filesystem *dfs_nfs = ((struct dfs_filesystem *)(file->vnode->fs));
RT_ASSERT(file->vnode->ref_count > 0);
if (file->vnode->ref_count > 1)
{
return 0;
}
nfs = (struct nfs_filesystem *)(dfs_nfs->data);
if (file->vnode->type == FT_DIRECTORY)
{
struct nfs_dir *dir;
dir = (struct nfs_dir *)nfs->data;
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&dir->handle);
xdr_free((xdrproc_t)xdr_READDIR3res, (char *)&dir->res);
rt_free(dir);
}
else if (file->vnode->type == FT_REGULAR)
{
struct nfs_file *fd;
fd = (struct nfs_file *)nfs->data;
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&fd->handle);
rt_free(fd);
}
nfs->data = NULL;
return 0;
}
int nfs_open(struct dfs_file *file)
{
nfs_filesystem *nfs;
RT_ASSERT(file->vnode->fs != NULL);
struct dfs_filesystem *dfs_nfs = file->vnode->fs;
nfs = (struct nfs_filesystem *)(dfs_nfs->data);
RT_ASSERT(nfs != NULL);
RT_ASSERT(file->vnode->ref_count > 0);
if (file->vnode->ref_count > 1)
{
if (file->vnode->type == FT_DIRECTORY
&& !(file->flags & O_DIRECTORY))
{
return -ENOENT;
}
file->pos = 0;
return 0;
}
if (file->flags & O_DIRECTORY)
{
nfs_dir *dir;
if (file->flags & O_CREAT)
{
if (nfs_mkdir(nfs, file->vnode->path, 0755) < 0)
{
return -EAGAIN;
}
}
/* open directory */
dir = nfs_opendir(nfs, file->vnode->path);
if (dir == NULL)
{
return -ENOENT;
}
file->vnode->type = FT_DIRECTORY;
nfs->data = dir;
}
else
{
nfs_file *fp;
nfs_fh3 *handle;
/* create file */
if (file->flags & O_CREAT)
{
if (nfs_create(nfs, file->vnode->path, 0664) < 0)
{
return -EAGAIN;
}
}
/* open file (get file handle ) */
fp = rt_malloc(sizeof(nfs_file));
if (fp == NULL)
return -ENOMEM;
handle = get_handle(nfs, file->vnode->path);
if (handle == NULL)
{
rt_free(fp);
return -ENOENT;
}
/* get size of file */
fp->size = nfs_get_filesize(nfs, handle);
fp->offset = 0;
fp->eof = FALSE;
copy_handle(&fp->handle, handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
if (file->flags & O_APPEND)
{
fp->offset = fp->size;
}
/* set private file */
nfs->data = fp;
file->vnode->size = fp->size;
file->vnode->type = FT_REGULAR;
}
return 0;
}
int nfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
{
GETATTR3args args;
GETATTR3res res;
fattr3 *info;
nfs_fh3 *handle;
nfs_filesystem *nfs;
RT_ASSERT(fs != NULL);
RT_ASSERT(fs->data != NULL);
nfs = (nfs_filesystem *)fs->data;
handle = get_handle(nfs, path);
if (handle == NULL)
return -1;
args.object = *handle;
memset(&res, '\0', sizeof(res));
if (nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("GetAttr failed\n");
return -1;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Getattr failed: %d\n", res.status);
return -1;
}
info = &res.GETATTR3res_u.resok.obj_attributes;
st->st_dev = 0;
st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH;
if (info->type == NFS3DIR)
{
st->st_mode &= ~S_IFREG;
st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
}
st->st_size = info->size;
st->st_mtime = info->mtime.seconds;
xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
return 0;
}
nfs_dir *nfs_opendir(nfs_filesystem *nfs, const char *path)
{
nfs_dir *dir;
nfs_fh3 *handle;
dir = rt_malloc(sizeof(nfs_dir));
if (dir == NULL)
{
return NULL;
}
handle = get_handle(nfs, path);
if (handle == NULL)
{
rt_free(dir);
return NULL;
}
copy_handle(&dir->handle, handle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
dir->cookie = 0;
memset(&dir->cookieverf, '\0', sizeof(cookieverf3));
dir->entry = NULL;
dir->eof = FALSE;
memset(&dir->res, '\0', sizeof(dir->res));
return dir;
}
char *nfs_readdir(nfs_filesystem *nfs, nfs_dir *dir)
{
static char name[NAME_MAX];
if (nfs->nfs_client == NULL || dir == NULL)
return NULL;
if (dir->entry == NULL)
{
READDIR3args args;
xdr_free((xdrproc_t)xdr_READDIR3res, (char *)&dir->res);
memset(&dir->res, '\0', sizeof(dir->res));
args.dir = dir->handle;
args.cookie = dir->cookie;
memcpy(&args.cookieverf, &dir->cookieverf, sizeof(cookieverf3));
args.count = 1024;
if (nfsproc3_readdir_3(args, &dir->res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Readdir failed\n");
return NULL;
}
else if (dir->res.status != NFS3_OK)
{
rt_kprintf("Readdir failed: %d\n", dir->res.status);
return NULL;
}
memcpy(&dir->cookieverf, &dir->res.READDIR3res_u.resok.cookieverf, sizeof(cookieverf3));
dir->eof = dir->res.READDIR3res_u.resok.reply.eof;
dir->entry = dir->res.READDIR3res_u.resok.reply.entries;
}
if (dir->eof == TRUE && dir->entry == NULL)
return NULL;
dir->cookie = dir->entry->cookie;
strncpy(name, dir->entry->name, NAME_MAX - 1);
dir->entry = dir->entry->nextentry;
name[NAME_MAX - 1] = '\0';
return name;
}
int nfs_unlink(struct dfs_filesystem *fs, const char *path)
{
int ret = 0;
nfs_filesystem *nfs;
RT_ASSERT(fs != NULL);
RT_ASSERT(fs->data != NULL);
nfs = (nfs_filesystem *)fs->data;
if (nfs_is_directory(nfs, path) == RT_FALSE)
{
/* remove file */
REMOVE3args args;
REMOVE3res res;
nfs_fh3 *handle;
handle = get_dir_handle(nfs, path);
if (handle == NULL)
return -1;
args.object.dir = *handle;
args.object.name = strrchr(path, '/') + 1;
if (args.object.name == NULL)
{
args.object.name = (char *)path;
}
memset(&res, 0, sizeof(res));
if (nfsproc3_remove_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Remove failed\n");
ret = -1;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Remove failed: %d\n", res.status);
ret = -1;
}
xdr_free((xdrproc_t)xdr_REMOVE3res, (char *)&res);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
}
else
{
/* remove directory */
RMDIR3args args;
RMDIR3res res;
nfs_fh3 *handle;
handle = get_dir_handle(nfs, path);
if (handle == NULL)
return -1;
args.object.dir = *handle;
args.object.name = strrchr(path, '/') + 1;
if (args.object.name == NULL)
{
args.object.name = (char *)path;
}
memset(&res, 0, sizeof(res));
if (nfsproc3_rmdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Rmdir failed\n");
ret = -1;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Rmdir failed: %d\n", res.status);
ret = -1;
}
xdr_free((xdrproc_t)xdr_RMDIR3res, (char *)&res);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
rt_free(handle);
}
return ret;
}
int nfs_rename(struct dfs_filesystem *fs, const char *src, const char *dest)
{
RENAME3args args;
RENAME3res res;
nfs_fh3 *sHandle;
nfs_fh3 *dHandle;
int ret = 0;
nfs_filesystem *nfs;
RT_ASSERT(fs != NULL);
RT_ASSERT(fs->data != NULL);
nfs = (nfs_filesystem *)fs->data;
if (nfs->nfs_client == NULL)
return -1;
sHandle = get_dir_handle(nfs, src);
if (sHandle == NULL)
return -1;
dHandle = get_dir_handle(nfs, dest);
if (dHandle == NULL)
return -1;
args.from.dir = *sHandle;
args.from.name = strrchr(src, '/') + 1;
if (args.from.name == NULL)
args.from.name = (char *)src;
args.to.dir = *dHandle;
args.to.name = strrchr(src, '/') + 1;
if (args.to.name == NULL)
args.to.name = (char *)dest;
memset(&res, '\0', sizeof(res));
if (nfsproc3_rename_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
{
rt_kprintf("Rename failed\n");
ret = -1;
}
else if (res.status != NFS3_OK)
{
rt_kprintf("Rename failed: %d\n", res.status);
ret = -1;
}
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)sHandle);
xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)dHandle);
xdr_free((xdrproc_t)xdr_RENAME3res, (char *)&res);
return ret;
}
int nfs_getdents(struct dfs_file *file, struct dirent *dirp, uint32_t count)
{
nfs_dir *dir;
rt_uint32_t index;
struct dirent *d;
nfs_filesystem *nfs;
char *name;
RT_ASSERT(file->vnode->fs != NULL);
struct dfs_filesystem *dfs_nfs = ((struct dfs_filesystem *)(file->vnode->fs));
nfs = (struct nfs_filesystem *)(dfs_nfs->data);
dir = (nfs_dir *)(nfs->data);
RT_ASSERT(dir != NULL);
/* make integer count */
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
if (count == 0)
return -EINVAL;
index = 0;
while (1)
{
d = dirp + index;
name = nfs_readdir(nfs, dir);
if (name == NULL)
break;
if (rt_strcmp(name, ".") == 0)
{
continue;
}
else if (rt_strcmp(name, "..") == 0)
{
continue;
}
d->d_type = DT_REG;
d->d_namlen = rt_strlen(name);
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
rt_strncpy(d->d_name, name, DFS_PATH_MAX);
index ++;
if (index * sizeof(struct dirent) >= count)
break;
}
return index * sizeof(struct dirent);
}
static const struct dfs_file_ops nfs_fops =
{
nfs_open,
nfs_close,
nfs_ioctl,
nfs_read,
nfs_write,
NULL, /* flush */
nfs_lseek,
nfs_getdents,
NULL, /* poll */
};
static const struct dfs_filesystem_ops _nfs =
{
"nfs",
DFS_FS_FLAG_DEFAULT,
&nfs_fops,
nfs_mount,
nfs_unmount,
NULL, /* mkfs */
NULL, /* statfs */
nfs_unlink,
nfs_stat,
nfs_rename,
};
int nfs_init(void)
{
/* register nfs file system */
dfs_register(&_nfs);
return RT_EOK;
}
INIT_COMPONENT_EXPORT(nfs_init);
|
184d2bcac4ff467328e1ec21d7f4ac481248c9d3
|
88ae8695987ada722184307301e221e1ba3cc2fa
|
/third_party/wayland-protocols/gtk/gtk/gtkeventcontrollermotion.h
|
5fbcffe3b6a81c7b7fa922997b6871bc470238ee
|
[
"MIT",
"LGPL-2.0-or-later",
"LGPL-2.0-only",
"LGPL-2.1-only",
"BSD-3-Clause",
"Apache-2.0",
"GPL-1.0-or-later"
] |
permissive
|
iridium-browser/iridium-browser
|
71d9c5ff76e014e6900b825f67389ab0ccd01329
|
5ee297f53dc7f8e70183031cff62f37b0f19d25f
|
refs/heads/master
| 2023-08-03T16:44:16.844552
| 2023-07-20T15:17:00
| 2023-07-23T16:09:30
| 220,016,632
| 341
| 40
|
BSD-3-Clause
| 2021-08-13T13:54:45
| 2019-11-06T14:32:31
| null |
UTF-8
|
C
| false
| false
| 2,471
|
h
|
gtkeventcontrollermotion.h
|
/* GTK - The GIMP Toolkit
* Copyright (C) 2017, Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author(s): Matthias Clasen <mclasen@redhat.com>
*/
#ifndef __GTK_EVENT_CONTROLLER_MOTION_H__
#define __GTK_EVENT_CONTROLLER_MOTION_H__
#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
#error "Only <gtk/gtk.h> can be included directly."
#endif
#include <gdk/gdk.h>
#include <gtk/gtkeventcontroller.h>
G_BEGIN_DECLS
#define GTK_TYPE_EVENT_CONTROLLER_MOTION (gtk_event_controller_motion_get_type ())
#define GTK_EVENT_CONTROLLER_MOTION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_MOTION, GtkEventControllerMotion))
#define GTK_EVENT_CONTROLLER_MOTION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_MOTION, GtkEventControllerMotionClass))
#define GTK_IS_EVENT_CONTROLLER_MOTION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_MOTION))
#define GTK_IS_EVENT_CONTROLLER_MOTION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_MOTION))
#define GTK_EVENT_CONTROLLER_MOTION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_MOTION, GtkEventControllerMotionClass))
typedef struct _GtkEventControllerMotion GtkEventControllerMotion;
typedef struct _GtkEventControllerMotionClass GtkEventControllerMotionClass;
GDK_AVAILABLE_IN_ALL
GType gtk_event_controller_motion_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
GtkEventController *gtk_event_controller_motion_new (void);
GDK_AVAILABLE_IN_ALL
gboolean gtk_event_controller_motion_contains_pointer (GtkEventControllerMotion *self);
GDK_AVAILABLE_IN_ALL
gboolean gtk_event_controller_motion_is_pointer (GtkEventControllerMotion *self);
G_END_DECLS
#endif /* __GTK_EVENT_CONTROLLER_MOTION_H__ */
|
dafa9f62c386720216a47ab56e1c810f90601915
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/arch/arm/mach-at91/include/mach/at91rm9200_sdramc.h
|
aa047f458f1b15d0d60bf7e4611cf5cc7bd73bba
|
[
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 2,875
|
h
|
at91rm9200_sdramc.h
|
/*
* arch/arm/mach-at91/include/mach/at91rm9200_sdramc.h
*
* Copyright (C) 2005 Ivan Kokshaysky
* Copyright (C) SAN People
*
* Memory Controllers (SDRAMC only) - System peripherals registers.
* Based on AT91RM9200 datasheet revision E.
*
* 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.
*/
#ifndef AT91RM9200_SDRAMC_H
#define AT91RM9200_SDRAMC_H
/* SDRAM Controller registers */
#define AT91RM9200_SDRAMC_MR 0x90 /* Mode Register */
#define AT91RM9200_SDRAMC_MODE (0xf << 0) /* Command Mode */
#define AT91RM9200_SDRAMC_MODE_NORMAL (0 << 0)
#define AT91RM9200_SDRAMC_MODE_NOP (1 << 0)
#define AT91RM9200_SDRAMC_MODE_PRECHARGE (2 << 0)
#define AT91RM9200_SDRAMC_MODE_LMR (3 << 0)
#define AT91RM9200_SDRAMC_MODE_REFRESH (4 << 0)
#define AT91RM9200_SDRAMC_DBW (1 << 4) /* Data Bus Width */
#define AT91RM9200_SDRAMC_DBW_32 (0 << 4)
#define AT91RM9200_SDRAMC_DBW_16 (1 << 4)
#define AT91RM9200_SDRAMC_TR 0x94 /* Refresh Timer Register */
#define AT91RM9200_SDRAMC_COUNT (0xfff << 0) /* Refresh Timer Count */
#define AT91RM9200_SDRAMC_CR 0x98 /* Configuration Register */
#define AT91RM9200_SDRAMC_NC (3 << 0) /* Number of Column Bits */
#define AT91RM9200_SDRAMC_NC_8 (0 << 0)
#define AT91RM9200_SDRAMC_NC_9 (1 << 0)
#define AT91RM9200_SDRAMC_NC_10 (2 << 0)
#define AT91RM9200_SDRAMC_NC_11 (3 << 0)
#define AT91RM9200_SDRAMC_NR (3 << 2) /* Number of Row Bits */
#define AT91RM9200_SDRAMC_NR_11 (0 << 2)
#define AT91RM9200_SDRAMC_NR_12 (1 << 2)
#define AT91RM9200_SDRAMC_NR_13 (2 << 2)
#define AT91RM9200_SDRAMC_NB (1 << 4) /* Number of Banks */
#define AT91RM9200_SDRAMC_NB_2 (0 << 4)
#define AT91RM9200_SDRAMC_NB_4 (1 << 4)
#define AT91RM9200_SDRAMC_CAS (3 << 5) /* CAS Latency */
#define AT91RM9200_SDRAMC_CAS_2 (2 << 5)
#define AT91RM9200_SDRAMC_TWR (0xf << 7) /* Write Recovery Delay */
#define AT91RM9200_SDRAMC_TRC (0xf << 11) /* Row Cycle Delay */
#define AT91RM9200_SDRAMC_TRP (0xf << 15) /* Row Precharge Delay */
#define AT91RM9200_SDRAMC_TRCD (0xf << 19) /* Row to Column Delay */
#define AT91RM9200_SDRAMC_TRAS (0xf << 23) /* Active to Precharge Delay */
#define AT91RM9200_SDRAMC_TXSR (0xf << 27) /* Exit Self Refresh to Active Delay */
#define AT91RM9200_SDRAMC_SRR 0x9c /* Self Refresh Register */
#define AT91RM9200_SDRAMC_LPR 0xa0 /* Low Power Register */
#define AT91RM9200_SDRAMC_IER 0xa4 /* Interrupt Enable Register */
#define AT91RM9200_SDRAMC_IDR 0xa8 /* Interrupt Disable Register */
#define AT91RM9200_SDRAMC_IMR 0xac /* Interrupt Mask Register */
#define AT91RM9200_SDRAMC_ISR 0xb0 /* Interrupt Status Register */
#endif
|
e16b6c770170d8314104a66cc8987fff2492af36
|
9e8510cf31c58b8fff8cba7700abdfda472cb86e
|
/lib/lb.h
|
23d8fc9e9b14af16bb1ff823641b70c6988f1d57
|
[
"GPL-2.0-only",
"Apache-2.0",
"BSD-3-Clause",
"ISC"
] |
permissive
|
ovn-org/ovn
|
c78d9672fd0c381c33a8ad29eedecb3f45f0fbd4
|
4a77767e624fb735bbce3cb4e2dca9da92c418f4
|
refs/heads/main
| 2023-08-07T20:43:57.636339
| 2023-08-02T13:31:04
| 2023-08-04T19:27:19
| 182,148,991
| 401
| 230
|
Apache-2.0
| 2023-09-13T15:00:21
| 2019-04-18T19:54:33
|
C
|
UTF-8
|
C
| false
| false
| 8,240
|
h
|
lb.h
|
/* Copyright (c) 2020, Red Hat, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OVN_LIB_LB_H
#define OVN_LIB_LB_H 1
#include <sys/types.h>
#include <netinet/in.h>
#include "lib/smap.h"
#include "openvswitch/hmap.h"
#include "ovn-util.h"
#include "sset.h"
#include "uuid.h"
struct nbrec_load_balancer;
struct nbrec_load_balancer_group;
struct sbrec_load_balancer;
struct sbrec_datapath_binding;
struct ovn_datapath;
struct ovn_dp_group;
struct ovn_port;
struct uuid;
enum lb_neighbor_responder_mode {
LB_NEIGH_RESPOND_REACHABLE,
LB_NEIGH_RESPOND_ALL,
LB_NEIGH_RESPOND_NONE,
};
/* The "routable" ssets are subsets of the load balancer IPs for which IP
* routes and ARP resolution flows are automatically added. */
struct ovn_lb_ip_set {
struct sset ips_v4;
struct sset ips_v4_routable;
struct sset ips_v4_reachable;
struct sset ips_v6;
struct sset ips_v6_routable;
struct sset ips_v6_reachable;
};
struct ovn_lb_ip_set *ovn_lb_ip_set_create(void);
void ovn_lb_ip_set_destroy(struct ovn_lb_ip_set *);
struct ovn_lb_ip_set *ovn_lb_ip_set_clone(struct ovn_lb_ip_set *);
struct ovn_northd_lb {
struct hmap_node hmap_node;
const struct nbrec_load_balancer *nlb; /* May be NULL. */
const struct sbrec_load_balancer *slb; /* May be NULL. */
const char *proto;
char *selection_fields;
struct ovn_lb_vip *vips;
struct ovn_northd_lb_vip *vips_nb;
struct smap template_vips; /* Slightly changed template VIPs, populated
* if needed. Until now it's only required
* for IPv6 template load balancers. */
size_t n_vips;
enum lb_neighbor_responder_mode neigh_mode;
bool controller_event;
bool routable;
bool skip_snat;
bool template;
uint16_t affinity_timeout;
struct sset ips_v4;
struct sset ips_v6;
size_t n_nb_ls;
unsigned long *nb_ls_map;
size_t n_nb_lr;
unsigned long *nb_lr_map;
struct ovn_dp_group *dpg;
};
struct ovn_lb_vip {
struct in6_addr vip; /* Only used in ovn-controller. */
char *vip_str; /* Actual VIP string representation (without port).
* To be used in ovn-northd.
*/
uint16_t vip_port; /* Only used in ovn-controller. */
char *port_str; /* Actual port string representation. To be used
* in ovn-northd.
*/
struct ovn_lb_backend *backends;
size_t n_backends;
bool template_backends; /* True if the backends are templates. False if
* they're explicitly specified.
*/
bool empty_backend_rej;
int address_family;
};
struct ovn_lb_backend {
struct in6_addr ip; /* Only used in ovn-controller. */
char *ip_str; /* Actual IP string representation. To be used in
* ovn-northd.
*/
uint16_t port; /* Mostly used in ovn-controller but also for
* healthcheck in ovn-northd.
*/
char *port_str; /* Actual port string representation. To be used
* in ovn-northd.
*/
};
/* ovn-northd specific backend information. */
struct ovn_northd_lb_vip {
char *backend_ips;
struct ovn_northd_lb_backend *backends_nb;
size_t n_backends;
struct nbrec_load_balancer_health_check *lb_health_check;
};
struct ovn_northd_lb_backend {
struct ovn_port *op; /* Logical port to which the ip belong to. */
bool health_check;
char *svc_mon_src_ip; /* Source IP to use for monitoring. */
const struct sbrec_service_monitor *sbrec_monitor;
};
struct ovn_northd_lb *ovn_northd_lb_create(const struct nbrec_load_balancer *,
size_t n_ls_datapaths,
size_t n_lr_datapaths);
struct ovn_northd_lb *ovn_northd_lb_find(const struct hmap *,
const struct uuid *);
const struct smap *ovn_northd_lb_get_vips(const struct ovn_northd_lb *);
void ovn_northd_lb_destroy(struct ovn_northd_lb *);
void ovn_northd_lb_add_lr(struct ovn_northd_lb *lb, size_t n,
struct ovn_datapath **ods);
void ovn_northd_lb_add_ls(struct ovn_northd_lb *lb, size_t n,
struct ovn_datapath **ods);
struct ovn_lb_group {
struct hmap_node hmap_node;
struct uuid uuid;
size_t n_lbs;
struct ovn_northd_lb **lbs;
struct ovn_lb_ip_set *lb_ips;
/* Datapaths to which this LB group is applied. */
size_t n_ls;
struct ovn_datapath **ls;
size_t n_lr;
struct ovn_datapath **lr;
};
struct ovn_lb_group *ovn_lb_group_create(
const struct nbrec_load_balancer_group *,
const struct hmap *lbs,
size_t max_ls_datapaths,
size_t max_lr_datapaths);
void ovn_lb_group_destroy(struct ovn_lb_group *lb_group);
struct ovn_lb_group *ovn_lb_group_find(const struct hmap *lb_groups,
const struct uuid *);
static inline void
ovn_lb_group_add_ls(struct ovn_lb_group *lb_group, size_t n,
struct ovn_datapath **ods)
{
memcpy(&lb_group->ls[lb_group->n_ls], ods, n * sizeof *ods);
lb_group->n_ls += n;
}
static inline void
ovn_lb_group_add_lr(struct ovn_lb_group *lb_group, struct ovn_datapath *lr)
{
lb_group->lr[lb_group->n_lr++] = lr;
}
struct ovn_controller_lb {
struct hmap_node hmap_node;
const struct sbrec_load_balancer *slb; /* May be NULL. */
uint8_t proto;
struct ovn_lb_vip *vips;
size_t n_vips;
bool hairpin_orig_tuple; /* True if ovn-northd stores the original
* destination tuple in registers.
*/
bool ct_flush; /* True if we should flush CT after backend removal. */
struct lport_addresses hairpin_snat_ips; /* IP (v4 and/or v6) to be used
* as source for hairpinned
* traffic.
*/
};
struct ovn_controller_lb *ovn_controller_lb_create(
const struct sbrec_load_balancer *,
const struct smap *template_vars,
struct sset *template_vars_ref);
void ovn_controller_lb_destroy(struct ovn_controller_lb *);
void ovn_controller_lbs_destroy(struct hmap *ovn_controller_lbs);
struct ovn_controller_lb *ovn_controller_lb_find(
const struct hmap *ovn_controller_lbs,
const struct uuid *uuid);
char *ovn_lb_vip_init(struct ovn_lb_vip *lb_vip, const char *lb_key,
const char *lb_value, bool template, int address_family);
void ovn_lb_vip_destroy(struct ovn_lb_vip *vip);
void ovn_lb_vip_format(const struct ovn_lb_vip *vip, struct ds *s,
bool template);
void ovn_lb_vip_backends_format(const struct ovn_lb_vip *vip, struct ds *s);
struct ovn_lb_5tuple {
struct hmap_node hmap_node;
struct in6_addr vip_ip;
uint16_t vip_port;
struct in6_addr backend_ip;
uint16_t backend_port;
uint8_t proto;
};
void ovn_lb_5tuple_init(struct ovn_lb_5tuple *tuple,
const struct ovn_lb_vip *vip,
const struct ovn_lb_backend *backend, uint8_t proto);
void ovn_lb_5tuple_add(struct hmap *tuples, const struct ovn_lb_vip *vip,
const struct ovn_lb_backend *backend, uint8_t proto);
void ovn_lb_5tuple_find_and_delete(struct hmap *tuples,
const struct ovn_lb_5tuple *tuple);
void ovn_lb_5tuples_destroy(struct hmap *tuples);
#endif /* OVN_LIB_LB_H 1 */
|
3dc98d4eab5dfc96cebadd1d7c1de8ceb97cc37f
|
03666e5f961946fc1a0ac67781ac1425562ef0d7
|
/src/common/state/StatusAttributes.C
|
c54ce80a5455a01ecf3f602d4c890ab20e8f1024
|
[
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
visit-dav/visit
|
e9f81b4d4b9b9930a0db9d5282cd1bcabf465e2e
|
601ae46e0bef2e18425b482a755d03490ade0493
|
refs/heads/develop
| 2023-09-06T08:19:38.397058
| 2023-09-05T21:29:32
| 2023-09-05T21:29:32
| 165,565,988
| 335
| 120
|
BSD-3-Clause
| 2023-09-14T00:53:37
| 2019-01-13T23:27:26
|
C
|
UTF-8
|
C
| false
| false
| 24,265
|
c
|
StatusAttributes.C
|
// Copyright (c) Lawrence Livermore National Security, LLC and other VisIt
// Project developers. See the top-level LICENSE file for dates and other
// details. No copyright assignment is required to contribute to VisIt.
#include <StatusAttributes.h>
#include <DataNode.h>
const int StatusAttributes::DEFAULT_DURATION = 5000;
// ****************************************************************************
// Method: StatusAttributes::StatusAttributes
//
// Purpose:
// Init utility for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
void StatusAttributes::Init()
{
sender = "viewer";
clearStatus = false;
hasUnicode = false;
percent = 0;
currentStage = 1;
currentStageName = "stage1";
maxStage = 1;
messageType = 0;
duration = 5000;
StatusAttributes::SelectAll();
}
// ****************************************************************************
// Method: StatusAttributes::StatusAttributes
//
// Purpose:
// Copy utility for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
void StatusAttributes::Copy(const StatusAttributes &obj)
{
sender = obj.sender;
clearStatus = obj.clearStatus;
statusMessage = obj.statusMessage;
unicode = obj.unicode;
hasUnicode = obj.hasUnicode;
percent = obj.percent;
currentStage = obj.currentStage;
currentStageName = obj.currentStageName;
maxStage = obj.maxStage;
messageType = obj.messageType;
duration = obj.duration;
StatusAttributes::SelectAll();
}
// Type map format string
const char *StatusAttributes::TypeMapFormatString = STATUSATTRIBUTES_TMFS;
const AttributeGroup::private_tmfs_t StatusAttributes::TmfsStruct = {STATUSATTRIBUTES_TMFS};
// ****************************************************************************
// Method: StatusAttributes::StatusAttributes
//
// Purpose:
// Default constructor for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
StatusAttributes::StatusAttributes() :
AttributeSubject(StatusAttributes::TypeMapFormatString)
{
StatusAttributes::Init();
}
// ****************************************************************************
// Method: StatusAttributes::StatusAttributes
//
// Purpose:
// Constructor for the derived classes of StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
StatusAttributes::StatusAttributes(private_tmfs_t tmfs) :
AttributeSubject(tmfs.tmfs)
{
StatusAttributes::Init();
}
// ****************************************************************************
// Method: StatusAttributes::StatusAttributes
//
// Purpose:
// Copy constructor for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
StatusAttributes::StatusAttributes(const StatusAttributes &obj) :
AttributeSubject(StatusAttributes::TypeMapFormatString)
{
StatusAttributes::Copy(obj);
}
// ****************************************************************************
// Method: StatusAttributes::StatusAttributes
//
// Purpose:
// Copy constructor for derived classes of the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
StatusAttributes::StatusAttributes(const StatusAttributes &obj, private_tmfs_t tmfs) :
AttributeSubject(tmfs.tmfs)
{
StatusAttributes::Copy(obj);
}
// ****************************************************************************
// Method: StatusAttributes::~StatusAttributes
//
// Purpose:
// Destructor for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
StatusAttributes::~StatusAttributes()
{
// nothing here
}
// ****************************************************************************
// Method: StatusAttributes::operator =
//
// Purpose:
// Assignment operator for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
StatusAttributes&
StatusAttributes::operator = (const StatusAttributes &obj)
{
if (this == &obj) return *this;
StatusAttributes::Copy(obj);
return *this;
}
// ****************************************************************************
// Method: StatusAttributes::operator ==
//
// Purpose:
// Comparison operator == for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
bool
StatusAttributes::operator == (const StatusAttributes &obj) const
{
// Create the return value
return ((sender == obj.sender) &&
(clearStatus == obj.clearStatus) &&
(statusMessage == obj.statusMessage) &&
(unicode == obj.unicode) &&
(hasUnicode == obj.hasUnicode) &&
(percent == obj.percent) &&
(currentStage == obj.currentStage) &&
(currentStageName == obj.currentStageName) &&
(maxStage == obj.maxStage) &&
(messageType == obj.messageType) &&
(duration == obj.duration));
}
// ****************************************************************************
// Method: StatusAttributes::operator !=
//
// Purpose:
// Comparison operator != for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
bool
StatusAttributes::operator != (const StatusAttributes &obj) const
{
return !(this->operator == (obj));
}
// ****************************************************************************
// Method: StatusAttributes::TypeName
//
// Purpose:
// Type name method for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
const std::string
StatusAttributes::TypeName() const
{
return "StatusAttributes";
}
// ****************************************************************************
// Method: StatusAttributes::CopyAttributes
//
// Purpose:
// CopyAttributes method for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
bool
StatusAttributes::CopyAttributes(const AttributeGroup *atts)
{
if(TypeName() != atts->TypeName())
return false;
// Call assignment operator.
const StatusAttributes *tmp = (const StatusAttributes *)atts;
*this = *tmp;
return true;
}
// ****************************************************************************
// Method: StatusAttributes::CreateCompatible
//
// Purpose:
// CreateCompatible method for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
AttributeSubject *
StatusAttributes::CreateCompatible(const std::string &tname) const
{
AttributeSubject *retval = 0;
if(TypeName() == tname)
retval = new StatusAttributes(*this);
// Other cases could go here too.
return retval;
}
// ****************************************************************************
// Method: StatusAttributes::NewInstance
//
// Purpose:
// NewInstance method for the StatusAttributes class.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
AttributeSubject *
StatusAttributes::NewInstance(bool copy) const
{
AttributeSubject *retval = 0;
if(copy)
retval = new StatusAttributes(*this);
else
retval = new StatusAttributes;
return retval;
}
// ****************************************************************************
// Method: StatusAttributes::SelectAll
//
// Purpose:
// Selects all attributes.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
void
StatusAttributes::SelectAll()
{
Select(ID_sender, (void *)&sender);
Select(ID_clearStatus, (void *)&clearStatus);
Select(ID_statusMessage, (void *)&statusMessage);
Select(ID_unicode, (void *)&unicode);
Select(ID_hasUnicode, (void *)&hasUnicode);
Select(ID_percent, (void *)&percent);
Select(ID_currentStage, (void *)¤tStage);
Select(ID_currentStageName, (void *)¤tStageName);
Select(ID_maxStage, (void *)&maxStage);
Select(ID_messageType, (void *)&messageType);
Select(ID_duration, (void *)&duration);
}
///////////////////////////////////////////////////////////////////////////////
// Persistence methods
///////////////////////////////////////////////////////////////////////////////
// ****************************************************************************
// Method: StatusAttributes::CreateNode
//
// Purpose:
// This method creates a DataNode representation of the object so it can be saved to a config file.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
bool
StatusAttributes::CreateNode(DataNode *parentNode, bool completeSave, bool forceAdd)
{
if(parentNode == 0)
return false;
StatusAttributes defaultObject;
bool addToParent = false;
// Create a node for StatusAttributes.
DataNode *node = new DataNode("StatusAttributes");
if(completeSave || !FieldsEqual(ID_sender, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("sender", sender));
}
if(completeSave || !FieldsEqual(ID_clearStatus, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("clearStatus", clearStatus));
}
if(completeSave || !FieldsEqual(ID_statusMessage, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("statusMessage", statusMessage));
}
if(completeSave || !FieldsEqual(ID_unicode, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("unicode", unicode));
}
if(completeSave || !FieldsEqual(ID_hasUnicode, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("hasUnicode", hasUnicode));
}
if(completeSave || !FieldsEqual(ID_percent, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("percent", percent));
}
if(completeSave || !FieldsEqual(ID_currentStage, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("currentStage", currentStage));
}
if(completeSave || !FieldsEqual(ID_currentStageName, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("currentStageName", currentStageName));
}
if(completeSave || !FieldsEqual(ID_maxStage, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("maxStage", maxStage));
}
if(completeSave || !FieldsEqual(ID_messageType, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("messageType", messageType));
}
if(completeSave || !FieldsEqual(ID_duration, &defaultObject))
{
addToParent = true;
node->AddNode(new DataNode("duration", duration));
}
// Add the node to the parent node.
if(addToParent || forceAdd)
parentNode->AddNode(node);
else
delete node;
return (addToParent || forceAdd);
}
// ****************************************************************************
// Method: StatusAttributes::SetFromNode
//
// Purpose:
// This method sets attributes in this object from values in a DataNode representation of the object.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
void
StatusAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("StatusAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("sender")) != 0)
SetSender(node->AsString());
if((node = searchNode->GetNode("clearStatus")) != 0)
SetClearStatus(node->AsBool());
if((node = searchNode->GetNode("statusMessage")) != 0)
SetStatusMessage(node->AsString());
if((node = searchNode->GetNode("unicode")) != 0)
SetUnicode(node->AsUnsignedCharVector());
if((node = searchNode->GetNode("hasUnicode")) != 0)
SetHasUnicode(node->AsBool());
if((node = searchNode->GetNode("percent")) != 0)
SetPercent(node->AsInt());
if((node = searchNode->GetNode("currentStage")) != 0)
SetCurrentStage(node->AsInt());
if((node = searchNode->GetNode("currentStageName")) != 0)
SetCurrentStageName(node->AsString());
if((node = searchNode->GetNode("maxStage")) != 0)
SetMaxStage(node->AsInt());
if((node = searchNode->GetNode("messageType")) != 0)
SetMessageType(node->AsInt());
if((node = searchNode->GetNode("duration")) != 0)
SetDuration(node->AsInt());
}
///////////////////////////////////////////////////////////////////////////////
// Set property methods
///////////////////////////////////////////////////////////////////////////////
void
StatusAttributes::SetSender(const std::string &sender_)
{
sender = sender_;
Select(ID_sender, (void *)&sender);
}
void
StatusAttributes::SetClearStatus(bool clearStatus_)
{
clearStatus = clearStatus_;
Select(ID_clearStatus, (void *)&clearStatus);
}
void
StatusAttributes::SetStatusMessage(const std::string &statusMessage_)
{
statusMessage = statusMessage_;
Select(ID_statusMessage, (void *)&statusMessage);
}
void
StatusAttributes::SetUnicode(const unsignedCharVector &unicode_)
{
unicode = unicode_;
Select(ID_unicode, (void *)&unicode);
}
void
StatusAttributes::SetHasUnicode(bool hasUnicode_)
{
hasUnicode = hasUnicode_;
Select(ID_hasUnicode, (void *)&hasUnicode);
}
void
StatusAttributes::SetPercent(int percent_)
{
percent = percent_;
Select(ID_percent, (void *)&percent);
}
void
StatusAttributes::SetCurrentStage(int currentStage_)
{
currentStage = currentStage_;
Select(ID_currentStage, (void *)¤tStage);
}
void
StatusAttributes::SetCurrentStageName(const std::string ¤tStageName_)
{
currentStageName = currentStageName_;
Select(ID_currentStageName, (void *)¤tStageName);
}
void
StatusAttributes::SetMaxStage(int maxStage_)
{
maxStage = maxStage_;
Select(ID_maxStage, (void *)&maxStage);
}
void
StatusAttributes::SetMessageType(int messageType_)
{
messageType = messageType_;
Select(ID_messageType, (void *)&messageType);
}
void
StatusAttributes::SetDuration(int duration_)
{
duration = duration_;
Select(ID_duration, (void *)&duration);
}
///////////////////////////////////////////////////////////////////////////////
// Get property methods
///////////////////////////////////////////////////////////////////////////////
const std::string &
StatusAttributes::GetSender() const
{
return sender;
}
std::string &
StatusAttributes::GetSender()
{
return sender;
}
bool
StatusAttributes::GetClearStatus() const
{
return clearStatus;
}
const std::string &
StatusAttributes::GetStatusMessage() const
{
return statusMessage;
}
std::string &
StatusAttributes::GetStatusMessage()
{
return statusMessage;
}
const unsignedCharVector &
StatusAttributes::GetUnicode() const
{
return unicode;
}
unsignedCharVector &
StatusAttributes::GetUnicode()
{
return unicode;
}
bool
StatusAttributes::GetHasUnicode() const
{
return hasUnicode;
}
int
StatusAttributes::GetPercent() const
{
return percent;
}
int
StatusAttributes::GetCurrentStage() const
{
return currentStage;
}
const std::string &
StatusAttributes::GetCurrentStageName() const
{
return currentStageName;
}
std::string &
StatusAttributes::GetCurrentStageName()
{
return currentStageName;
}
int
StatusAttributes::GetMaxStage() const
{
return maxStage;
}
int
StatusAttributes::GetMessageType() const
{
return messageType;
}
int
StatusAttributes::GetDuration() const
{
return duration;
}
///////////////////////////////////////////////////////////////////////////////
// Select property methods
///////////////////////////////////////////////////////////////////////////////
void
StatusAttributes::SelectSender()
{
Select(ID_sender, (void *)&sender);
}
void
StatusAttributes::SelectStatusMessage()
{
Select(ID_statusMessage, (void *)&statusMessage);
}
void
StatusAttributes::SelectUnicode()
{
Select(ID_unicode, (void *)&unicode);
}
void
StatusAttributes::SelectCurrentStageName()
{
Select(ID_currentStageName, (void *)¤tStageName);
}
///////////////////////////////////////////////////////////////////////////////
// Keyframing methods
///////////////////////////////////////////////////////////////////////////////
// ****************************************************************************
// Method: StatusAttributes::GetFieldName
//
// Purpose:
// This method returns the name of a field given its index.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
std::string
StatusAttributes::GetFieldName(int index) const
{
switch (index)
{
case ID_sender: return "sender";
case ID_clearStatus: return "clearStatus";
case ID_statusMessage: return "statusMessage";
case ID_unicode: return "unicode";
case ID_hasUnicode: return "hasUnicode";
case ID_percent: return "percent";
case ID_currentStage: return "currentStage";
case ID_currentStageName: return "currentStageName";
case ID_maxStage: return "maxStage";
case ID_messageType: return "messageType";
case ID_duration: return "duration";
default: return "invalid index";
}
}
// ****************************************************************************
// Method: StatusAttributes::GetFieldType
//
// Purpose:
// This method returns the type of a field given its index.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
AttributeGroup::FieldType
StatusAttributes::GetFieldType(int index) const
{
switch (index)
{
case ID_sender: return FieldType_string;
case ID_clearStatus: return FieldType_bool;
case ID_statusMessage: return FieldType_string;
case ID_unicode: return FieldType_ucharVector;
case ID_hasUnicode: return FieldType_bool;
case ID_percent: return FieldType_int;
case ID_currentStage: return FieldType_int;
case ID_currentStageName: return FieldType_string;
case ID_maxStage: return FieldType_int;
case ID_messageType: return FieldType_int;
case ID_duration: return FieldType_int;
default: return FieldType_unknown;
}
}
// ****************************************************************************
// Method: StatusAttributes::GetFieldTypeName
//
// Purpose:
// This method returns the name of a field type given its index.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
std::string
StatusAttributes::GetFieldTypeName(int index) const
{
switch (index)
{
case ID_sender: return "string";
case ID_clearStatus: return "bool";
case ID_statusMessage: return "string";
case ID_unicode: return "ucharVector";
case ID_hasUnicode: return "bool";
case ID_percent: return "int";
case ID_currentStage: return "int";
case ID_currentStageName: return "string";
case ID_maxStage: return "int";
case ID_messageType: return "int";
case ID_duration: return "int";
default: return "invalid index";
}
}
// ****************************************************************************
// Method: StatusAttributes::FieldsEqual
//
// Purpose:
// This method compares two fields and return true if they are equal.
//
// Note: Autogenerated by xml2atts.
//
// Programmer: xml2atts
// Creation: omitted
//
// Modifications:
//
// ****************************************************************************
bool
StatusAttributes::FieldsEqual(int index_, const AttributeGroup *rhs) const
{
const StatusAttributes &obj = *((const StatusAttributes*)rhs);
bool retval = false;
switch (index_)
{
case ID_sender:
{ // new scope
retval = (sender == obj.sender);
}
break;
case ID_clearStatus:
{ // new scope
retval = (clearStatus == obj.clearStatus);
}
break;
case ID_statusMessage:
{ // new scope
retval = (statusMessage == obj.statusMessage);
}
break;
case ID_unicode:
{ // new scope
retval = (unicode == obj.unicode);
}
break;
case ID_hasUnicode:
{ // new scope
retval = (hasUnicode == obj.hasUnicode);
}
break;
case ID_percent:
{ // new scope
retval = (percent == obj.percent);
}
break;
case ID_currentStage:
{ // new scope
retval = (currentStage == obj.currentStage);
}
break;
case ID_currentStageName:
{ // new scope
retval = (currentStageName == obj.currentStageName);
}
break;
case ID_maxStage:
{ // new scope
retval = (maxStage == obj.maxStage);
}
break;
case ID_messageType:
{ // new scope
retval = (messageType == obj.messageType);
}
break;
case ID_duration:
{ // new scope
retval = (duration == obj.duration);
}
break;
default: retval = false;
}
return retval;
}
///////////////////////////////////////////////////////////////////////////////
// User-defined methods.
///////////////////////////////////////////////////////////////////////////////
|
e24d5b183fa020d9c4d587092d6cda075b181187
|
2d5743a0cc3b0ca82856d12e5576949868630031
|
/dynamodb-kv/capacity.h
|
c4907008c7a363d5477db20a2f865f80b45c2aae
|
[
"BSD-2-Clause"
] |
permissive
|
Tarsnap/kivaloo
|
20dfd70438375c7b8f8ea00a928b87c9299ae8be
|
1b4fffe65e8bdc789cb47a6191b4df33613a98e0
|
refs/heads/master
| 2023-09-03T01:26:01.625376
| 2023-08-26T18:52:14
| 2023-08-26T18:52:14
| 36,057,493
| 207
| 22
|
NOASSERTION
| 2023-08-29T18:49:29
| 2015-05-22T07:05:37
|
C
|
UTF-8
|
C
| false
| false
| 978
|
h
|
capacity.h
|
#ifndef CAPACITY_H_
#define CAPACITY_H_
/* Opaque types. */
struct serverpool;
struct dynamodb_request_queue;
/**
* capacity_init(key_id, key_secret, tname, rname, SP, QW, QR):
* Using the AWS key id ${key_id} and secret key ${key_secret}, issue
* DescribeTable requests to the DynamoDB table ${tname} in AWS region
* ${rname}, using endpoints returned by the server pool ${SP}. Update the
* capacity of the write queue ${QW} and read queue ${QR}.
*
* Issue one request immediately, and wait for it to complete before
* returning; issue subsequent requests every 15 seconds.
*
* This function may call events_run() internally.
*/
struct capacity_reader * capacity_init(const char *, const char *,
const char *, const char *, struct serverpool *,
struct dynamodb_request_queue *, struct dynamodb_request_queue *);
/**
* capacity_free(M):
* Stop issuing DescribeTable requests.
*/
void capacity_free(struct capacity_reader *);
#endif /* !CAPACITY_H_ */
|
0b9c3fab7e49c3826a2b09f3eeba6f1047ba271e
|
9e0c8c8d8bafa73d133e41f201badc756c92978a
|
/modules/acpi/acpica/dispatcher/dsmethod.c
|
43d6ee1a19fc634f8a95b17615fb288dca4ef474
|
[
"BSD-2-Clause",
"MIT",
"CC0-1.0",
"BSD-3-Clause",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause-Views"
] |
permissive
|
vvaltchev/tilck
|
ccf8d9933be1269b85388e5b21645b831ecf5412
|
e9c27da4dd15f5f8a927b11f31484aec3f1429f0
|
refs/heads/master
| 2023-08-16T00:07:42.593483
| 2023-07-04T21:00:31
| 2023-07-19T23:25:42
| 53,845,595
| 2,142
| 115
|
BSD-2-Clause
| 2023-09-03T05:36:46
| 2016-03-14T10:02:41
|
C
|
UTF-8
|
C
| false
| false
| 36,056
|
c
|
dsmethod.c
|
/******************************************************************************
*
* Module Name: dsmethod - Parser/Interpreter interface - control method parsing
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
* All rights reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************
*
* Alternatively, you may choose to be licensed under the terms of the
* following license:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, you may choose to be licensed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
*****************************************************************************/
#include "acpi.h"
#include "accommon.h"
#include "acdispat.h"
#include "acinterp.h"
#include "acnamesp.h"
#include "acparser.h"
#include "amlcode.h"
#include "acdebug.h"
#define _COMPONENT ACPI_DISPATCHER
ACPI_MODULE_NAME ("dsmethod")
/* Local prototypes */
static ACPI_STATUS
AcpiDsDetectNamedOpcodes (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT **OutOp);
static ACPI_STATUS
AcpiDsCreateMethodMutex (
ACPI_OPERAND_OBJECT *MethodDesc);
/*******************************************************************************
*
* FUNCTION: AcpiDsAutoSerializeMethod
*
* PARAMETERS: Node - Namespace Node of the method
* ObjDesc - Method object attached to node
*
* RETURN: Status
*
* DESCRIPTION: Parse a control method AML to scan for control methods that
* need serialization due to the creation of named objects.
*
* NOTE: It is a bit of overkill to mark all such methods serialized, since
* there is only a problem if the method actually blocks during execution.
* A blocking operation is, for example, a Sleep() operation, or any access
* to an operation region. However, it is probably not possible to easily
* detect whether a method will block or not, so we simply mark all suspicious
* methods as serialized.
*
* NOTE2: This code is essentially a generic routine for parsing a single
* control method.
*
******************************************************************************/
ACPI_STATUS
AcpiDsAutoSerializeMethod (
ACPI_NAMESPACE_NODE *Node,
ACPI_OPERAND_OBJECT *ObjDesc)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op = NULL;
ACPI_WALK_STATE *WalkState;
ACPI_FUNCTION_TRACE_PTR (DsAutoSerializeMethod, Node);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Method auto-serialization parse [%4.4s] %p\n",
AcpiUtGetNodeName (Node), Node));
/* Create/Init a root op for the method parse tree */
Op = AcpiPsAllocOp (AML_METHOD_OP, ObjDesc->Method.AmlStart);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
AcpiPsSetName (Op, Node->Name.Integer);
Op->Common.Node = Node;
/* Create and initialize a new walk state */
WalkState = AcpiDsCreateWalkState (Node->OwnerId, NULL, NULL, NULL);
if (!WalkState)
{
AcpiPsFreeOp (Op);
return_ACPI_STATUS (AE_NO_MEMORY);
}
Status = AcpiDsInitAmlWalk (WalkState, Op, Node,
ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength, NULL, 0);
if (ACPI_FAILURE (Status))
{
AcpiDsDeleteWalkState (WalkState);
AcpiPsFreeOp (Op);
return_ACPI_STATUS (Status);
}
WalkState->DescendingCallback = AcpiDsDetectNamedOpcodes;
/* Parse the method, scan for creation of named objects */
Status = AcpiPsParseAml (WalkState);
AcpiPsDeleteParseTree (Op);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsDetectNamedOpcodes
*
* PARAMETERS: WalkState - Current state of the parse tree walk
* OutOp - Unused, required for parser interface
*
* RETURN: Status
*
* DESCRIPTION: Descending callback used during the loading of ACPI tables.
* Currently used to detect methods that must be marked serialized
* in order to avoid problems with the creation of named objects.
*
******************************************************************************/
static ACPI_STATUS
AcpiDsDetectNamedOpcodes (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT **OutOp)
{
ACPI_FUNCTION_NAME (AcpiDsDetectNamedOpcodes);
/* We are only interested in opcodes that create a new name */
if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_CREATE | AML_FIELD)))
{
return (AE_OK);
}
/*
* At this point, we know we have a Named object opcode.
* Mark the method as serialized. Later code will create a mutex for
* this method to enforce serialization.
*
* Note, ACPI_METHOD_IGNORE_SYNC_LEVEL flag means that we will ignore the
* Sync Level mechanism for this method, even though it is now serialized.
* Otherwise, there can be conflicts with existing ASL code that actually
* uses sync levels.
*/
WalkState->MethodDesc->Method.SyncLevel = 0;
WalkState->MethodDesc->Method.InfoFlags |=
(ACPI_METHOD_SERIALIZED | ACPI_METHOD_IGNORE_SYNC_LEVEL);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Method serialized [%4.4s] %p - [%s] (%4.4X)\n",
WalkState->MethodNode->Name.Ascii, WalkState->MethodNode,
WalkState->OpInfo->Name, WalkState->Opcode));
/* Abort the parse, no need to examine this method any further */
return (AE_CTRL_TERMINATE);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodError
*
* PARAMETERS: Status - Execution status
* WalkState - Current state
*
* RETURN: Status
*
* DESCRIPTION: Called on method error. Invoke the global exception handler if
* present, dump the method data if the debugger is configured
*
* Note: Allows the exception handler to change the status code
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodError (
ACPI_STATUS Status,
ACPI_WALK_STATE *WalkState)
{
UINT32 AmlOffset;
ACPI_NAME Name = 0;
ACPI_FUNCTION_ENTRY ();
/* Ignore AE_OK and control exception codes */
if (ACPI_SUCCESS (Status) ||
(Status & AE_CODE_CONTROL))
{
return (Status);
}
/* Invoke the global exception handler */
if (AcpiGbl_ExceptionHandler)
{
/* Exit the interpreter, allow handler to execute methods */
AcpiExExitInterpreter ();
/*
* Handler can map the exception code to anything it wants, including
* AE_OK, in which case the executing method will not be aborted.
*/
AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->Aml,
WalkState->ParserState.AmlStart);
if (WalkState->MethodNode)
{
Name = WalkState->MethodNode->Name.Integer;
}
else if (WalkState->DeferredNode)
{
Name = WalkState->DeferredNode->Name.Integer;
}
Status = AcpiGbl_ExceptionHandler (Status, Name,
WalkState->Opcode, AmlOffset, NULL);
AcpiExEnterInterpreter ();
}
AcpiDsClearImplicitReturn (WalkState);
if (ACPI_FAILURE (Status))
{
AcpiDsDumpMethodStack (Status, WalkState, WalkState->Op);
/* Display method locals/args if debugger is present */
#ifdef ACPI_DEBUGGER
AcpiDbDumpMethodInfo (Status, WalkState);
#endif
}
return (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsCreateMethodMutex
*
* PARAMETERS: ObjDesc - The method object
*
* RETURN: Status
*
* DESCRIPTION: Create a mutex object for a serialized control method
*
******************************************************************************/
static ACPI_STATUS
AcpiDsCreateMethodMutex (
ACPI_OPERAND_OBJECT *MethodDesc)
{
ACPI_OPERAND_OBJECT *MutexDesc;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (DsCreateMethodMutex);
/* Create the new mutex object */
MutexDesc = AcpiUtCreateInternalObject (ACPI_TYPE_MUTEX);
if (!MutexDesc)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Create the actual OS Mutex */
Status = AcpiOsCreateMutex (&MutexDesc->Mutex.OsMutex);
if (ACPI_FAILURE (Status))
{
AcpiUtDeleteObjectDesc (MutexDesc);
return_ACPI_STATUS (Status);
}
MutexDesc->Mutex.SyncLevel = MethodDesc->Method.SyncLevel;
MethodDesc->Method.Mutex = MutexDesc;
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsBeginMethodExecution
*
* PARAMETERS: MethodNode - Node of the method
* ObjDesc - The method object
* WalkState - current state, NULL if not yet executing
* a method.
*
* RETURN: Status
*
* DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
* increments the thread count, and waits at the method semaphore
* for clearance to execute.
*
******************************************************************************/
ACPI_STATUS
AcpiDsBeginMethodExecution (
ACPI_NAMESPACE_NODE *MethodNode,
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE_PTR (DsBeginMethodExecution, MethodNode);
if (!MethodNode)
{
return_ACPI_STATUS (AE_NULL_ENTRY);
}
AcpiExStartTraceMethod (MethodNode, ObjDesc, WalkState);
/* Prevent wraparound of thread count */
if (ObjDesc->Method.ThreadCount == ACPI_UINT8_MAX)
{
ACPI_ERROR ((AE_INFO,
"Method reached maximum reentrancy limit (255)"));
return_ACPI_STATUS (AE_AML_METHOD_LIMIT);
}
/*
* If this method is serialized, we need to acquire the method mutex.
*/
if (ObjDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)
{
/*
* Create a mutex for the method if it is defined to be Serialized
* and a mutex has not already been created. We defer the mutex creation
* until a method is actually executed, to minimize the object count
*/
if (!ObjDesc->Method.Mutex)
{
Status = AcpiDsCreateMethodMutex (ObjDesc);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* The CurrentSyncLevel (per-thread) must be less than or equal to
* the sync level of the method. This mechanism provides some
* deadlock prevention.
*
* If the method was auto-serialized, we just ignore the sync level
* mechanism, because auto-serialization of methods can interfere
* with ASL code that actually uses sync levels.
*
* Top-level method invocation has no walk state at this point
*/
if (WalkState &&
(!(ObjDesc->Method.InfoFlags & ACPI_METHOD_IGNORE_SYNC_LEVEL)) &&
(WalkState->Thread->CurrentSyncLevel >
ObjDesc->Method.Mutex->Mutex.SyncLevel))
{
ACPI_ERROR ((AE_INFO,
"Cannot acquire Mutex for method [%4.4s]"
", current SyncLevel is too large (%u)",
AcpiUtGetNodeName (MethodNode),
WalkState->Thread->CurrentSyncLevel));
return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
}
/*
* Obtain the method mutex if necessary. Do not acquire mutex for a
* recursive call.
*/
if (!WalkState ||
!ObjDesc->Method.Mutex->Mutex.ThreadId ||
(WalkState->Thread->ThreadId !=
ObjDesc->Method.Mutex->Mutex.ThreadId))
{
/*
* Acquire the method mutex. This releases the interpreter if we
* block (and reacquires it before it returns)
*/
Status = AcpiExSystemWaitMutex (
ObjDesc->Method.Mutex->Mutex.OsMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Update the mutex and walk info and save the original SyncLevel */
if (WalkState)
{
ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =
WalkState->Thread->CurrentSyncLevel;
ObjDesc->Method.Mutex->Mutex.ThreadId =
WalkState->Thread->ThreadId;
/*
* Update the current SyncLevel only if this is not an auto-
* serialized method. In the auto case, we have to ignore
* the sync level for the method mutex (created for the
* auto-serialization) because we have no idea of what the
* sync level should be. Therefore, just ignore it.
*/
if (!(ObjDesc->Method.InfoFlags &
ACPI_METHOD_IGNORE_SYNC_LEVEL))
{
WalkState->Thread->CurrentSyncLevel =
ObjDesc->Method.SyncLevel;
}
}
else
{
ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =
ObjDesc->Method.Mutex->Mutex.SyncLevel;
ObjDesc->Method.Mutex->Mutex.ThreadId =
AcpiOsGetThreadId ();
}
}
/* Always increase acquisition depth */
ObjDesc->Method.Mutex->Mutex.AcquisitionDepth++;
}
/*
* Allocate an Owner ID for this method, only if this is the first thread
* to begin concurrent execution. We only need one OwnerId, even if the
* method is invoked recursively.
*/
if (!ObjDesc->Method.OwnerId)
{
Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
}
/*
* Increment the method parse tree thread count since it has been
* reentered one more time (even if it is the same thread)
*/
ObjDesc->Method.ThreadCount++;
AcpiMethodCount++;
return_ACPI_STATUS (Status);
Cleanup:
/* On error, must release the method mutex (if present) */
if (ObjDesc->Method.Mutex)
{
AcpiOsReleaseMutex (ObjDesc->Method.Mutex->Mutex.OsMutex);
}
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsCallControlMethod
*
* PARAMETERS: Thread - Info for this thread
* ThisWalkState - Current walk state
* Op - Current Op to be walked
*
* RETURN: Status
*
* DESCRIPTION: Transfer execution to a called control method
*
******************************************************************************/
ACPI_STATUS
AcpiDsCallControlMethod (
ACPI_THREAD_STATE *Thread,
ACPI_WALK_STATE *ThisWalkState,
ACPI_PARSE_OBJECT *Op)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *MethodNode;
ACPI_WALK_STATE *NextWalkState = NULL;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_EVALUATE_INFO *Info;
UINT32 i;
ACPI_FUNCTION_TRACE_PTR (DsCallControlMethod, ThisWalkState);
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Calling method %p, currentstate=%p\n",
ThisWalkState->PrevOp, ThisWalkState));
/*
* Get the namespace entry for the control method we are about to call
*/
MethodNode = ThisWalkState->MethodCallNode;
if (!MethodNode)
{
return_ACPI_STATUS (AE_NULL_ENTRY);
}
ObjDesc = AcpiNsGetAttachedObject (MethodNode);
if (!ObjDesc)
{
return_ACPI_STATUS (AE_NULL_OBJECT);
}
/* Init for new method, possibly wait on method mutex */
Status = AcpiDsBeginMethodExecution (
MethodNode, ObjDesc, ThisWalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Begin method parse/execution. Create a new walk state */
NextWalkState = AcpiDsCreateWalkState (
ObjDesc->Method.OwnerId, NULL, ObjDesc, Thread);
if (!NextWalkState)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/*
* The resolved arguments were put on the previous walk state's operand
* stack. Operands on the previous walk state stack always
* start at index 0. Also, null terminate the list of arguments
*/
ThisWalkState->Operands [ThisWalkState->NumOperands] = NULL;
/*
* Allocate and initialize the evaluation information block
* TBD: this is somewhat inefficient, should change interface to
* DsInitAmlWalk. For now, keeps this struct off the CPU stack
*/
Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
if (!Info)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
Info->Parameters = &ThisWalkState->Operands[0];
Status = AcpiDsInitAmlWalk (NextWalkState, NULL, MethodNode,
ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength,
Info, ACPI_IMODE_EXECUTE);
ACPI_FREE (Info);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
NextWalkState->MethodNestingDepth = ThisWalkState->MethodNestingDepth + 1;
/*
* Delete the operands on the previous walkstate operand stack
* (they were copied to new objects)
*/
for (i = 0; i < ObjDesc->Method.ParamCount; i++)
{
AcpiUtRemoveReference (ThisWalkState->Operands [i]);
ThisWalkState->Operands [i] = NULL;
}
/* Clear the operand stack */
ThisWalkState->NumOperands = 0;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"**** Begin nested execution of [%4.4s] **** WalkState=%p\n",
MethodNode->Name.Ascii, NextWalkState));
ThisWalkState->MethodPathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
ThisWalkState->MethodIsNested = TRUE;
/* Optional object evaluation log */
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EVALUATION,
"%-26s: %*s%s\n", " Nested method call",
NextWalkState->MethodNestingDepth * 3, " ",
&ThisWalkState->MethodPathname[1]));
/* Invoke an internal method if necessary */
if (ObjDesc->Method.InfoFlags & ACPI_METHOD_INTERNAL_ONLY)
{
Status = ObjDesc->Method.Dispatch.Implementation (NextWalkState);
if (Status == AE_OK)
{
Status = AE_CTRL_TERMINATE;
}
}
return_ACPI_STATUS (Status);
Cleanup:
/* On error, we must terminate the method properly */
AcpiDsTerminateControlMethod (ObjDesc, NextWalkState);
AcpiDsDeleteWalkState (NextWalkState);
return_ACPI_STATUS (Status);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsRestartControlMethod
*
* PARAMETERS: WalkState - State for preempted method (caller)
* ReturnDesc - Return value from the called method
*
* RETURN: Status
*
* DESCRIPTION: Restart a method that was preempted by another (nested) method
* invocation. Handle the return value (if any) from the callee.
*
******************************************************************************/
ACPI_STATUS
AcpiDsRestartControlMethod (
ACPI_WALK_STATE *WalkState,
ACPI_OPERAND_OBJECT *ReturnDesc)
{
ACPI_STATUS Status;
int SameAsImplicitReturn;
ACPI_FUNCTION_TRACE_PTR (DsRestartControlMethod, WalkState);
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
AcpiUtGetNodeName (WalkState->MethodNode),
WalkState->MethodCallOp, ReturnDesc));
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
" ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n",
WalkState->ReturnUsed,
WalkState->Results, WalkState));
/* Did the called method return a value? */
if (ReturnDesc)
{
/* Is the implicit return object the same as the return desc? */
SameAsImplicitReturn = (WalkState->ImplicitReturnObj == ReturnDesc);
/* Are we actually going to use the return value? */
if (WalkState->ReturnUsed)
{
/* Save the return value from the previous method */
Status = AcpiDsResultPush (ReturnDesc, WalkState);
if (ACPI_FAILURE (Status))
{
AcpiUtRemoveReference (ReturnDesc);
return_ACPI_STATUS (Status);
}
/*
* Save as THIS method's return value in case it is returned
* immediately to yet another method
*/
WalkState->ReturnDesc = ReturnDesc;
}
/*
* The following code is the optional support for the so-called
* "implicit return". Some AML code assumes that the last value of the
* method is "implicitly" returned to the caller, in the absence of an
* explicit return value.
*
* Just save the last result of the method as the return value.
*
* NOTE: this is optional because the ASL language does not actually
* support this behavior.
*/
else if (!AcpiDsDoImplicitReturn (ReturnDesc, WalkState, FALSE) ||
SameAsImplicitReturn)
{
/*
* Delete the return value if it will not be used by the
* calling method or remove one reference if the explicit return
* is the same as the implicit return value.
*/
AcpiUtRemoveReference (ReturnDesc);
}
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsTerminateControlMethod
*
* PARAMETERS: MethodDesc - Method object
* WalkState - State associated with the method
*
* RETURN: None
*
* DESCRIPTION: Terminate a control method. Delete everything that the method
* created, delete all locals and arguments, and delete the parse
* tree if requested.
*
* MUTEX: Interpreter is locked
*
******************************************************************************/
void
AcpiDsTerminateControlMethod (
ACPI_OPERAND_OBJECT *MethodDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_FUNCTION_TRACE_PTR (DsTerminateControlMethod, WalkState);
/* MethodDesc is required, WalkState is optional */
if (!MethodDesc)
{
return_VOID;
}
if (WalkState)
{
/* Delete all arguments and locals */
AcpiDsMethodDataDeleteAll (WalkState);
/*
* Delete any namespace objects created anywhere within the
* namespace by the execution of this method. Unless:
* 1) This method is a module-level executable code method, in which
* case we want make the objects permanent.
* 2) There are other threads executing the method, in which case we
* will wait until the last thread has completed.
*/
if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL) &&
(MethodDesc->Method.ThreadCount == 1))
{
/* Delete any direct children of (created by) this method */
(void) AcpiExExitInterpreter ();
AcpiNsDeleteNamespaceSubtree (WalkState->MethodNode);
(void) AcpiExEnterInterpreter ();
/*
* Delete any objects that were created by this method
* elsewhere in the namespace (if any were created).
* Use of the ACPI_METHOD_MODIFIED_NAMESPACE optimizes the
* deletion such that we don't have to perform an entire
* namespace walk for every control method execution.
*/
if (MethodDesc->Method.InfoFlags & ACPI_METHOD_MODIFIED_NAMESPACE)
{
(void) AcpiExExitInterpreter ();
AcpiNsDeleteNamespaceByOwner (MethodDesc->Method.OwnerId);
(void) AcpiExEnterInterpreter ();
MethodDesc->Method.InfoFlags &=
~ACPI_METHOD_MODIFIED_NAMESPACE;
}
}
/*
* If method is serialized, release the mutex and restore the
* current sync level for this thread
*/
if (MethodDesc->Method.Mutex)
{
/* Acquisition Depth handles recursive calls */
MethodDesc->Method.Mutex->Mutex.AcquisitionDepth--;
if (!MethodDesc->Method.Mutex->Mutex.AcquisitionDepth)
{
WalkState->Thread->CurrentSyncLevel =
MethodDesc->Method.Mutex->Mutex.OriginalSyncLevel;
AcpiOsReleaseMutex (
MethodDesc->Method.Mutex->Mutex.OsMutex);
MethodDesc->Method.Mutex->Mutex.ThreadId = 0;
}
}
}
/* Decrement the thread count on the method */
if (MethodDesc->Method.ThreadCount)
{
MethodDesc->Method.ThreadCount--;
}
else
{
ACPI_ERROR ((AE_INFO,
"Invalid zero thread count in method"));
}
/* Are there any other threads currently executing this method? */
if (MethodDesc->Method.ThreadCount)
{
/*
* Additional threads. Do not release the OwnerId in this case,
* we immediately reuse it for the next thread executing this method
*/
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"*** Completed execution of one thread, %u threads remaining\n",
MethodDesc->Method.ThreadCount));
}
else
{
/* This is the only executing thread for this method */
/*
* Support to dynamically change a method from NotSerialized to
* Serialized if it appears that the method is incorrectly written and
* does not support multiple thread execution. The best example of this
* is if such a method creates namespace objects and blocks. A second
* thread will fail with an AE_ALREADY_EXISTS exception.
*
* This code is here because we must wait until the last thread exits
* before marking the method as serialized.
*/
if (MethodDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED_PENDING)
{
if (WalkState)
{
ACPI_INFO ((
"Marking method %4.4s as Serialized "
"because of AE_ALREADY_EXISTS error",
WalkState->MethodNode->Name.Ascii));
}
/*
* Method tried to create an object twice and was marked as
* "pending serialized". The probable cause is that the method
* cannot handle reentrancy.
*
* The method was created as NotSerialized, but it tried to create
* a named object and then blocked, causing the second thread
* entrance to begin and then fail. Workaround this problem by
* marking the method permanently as Serialized when the last
* thread exits here.
*/
MethodDesc->Method.InfoFlags &=
~ACPI_METHOD_SERIALIZED_PENDING;
MethodDesc->Method.InfoFlags |=
(ACPI_METHOD_SERIALIZED | ACPI_METHOD_IGNORE_SYNC_LEVEL);
MethodDesc->Method.SyncLevel = 0;
}
/* No more threads, we can free the OwnerId */
if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL))
{
AcpiUtReleaseOwnerId (&MethodDesc->Method.OwnerId);
}
}
AcpiExStopTraceMethod ((ACPI_NAMESPACE_NODE *) MethodDesc->Method.Node,
MethodDesc, WalkState);
return_VOID;
}
|
6ca31d18484e89fe6c2ee087cb2389901bb9c492
|
d84c7df450292867f8c7bb58d1507735479d746d
|
/examples/petsc/qfunctions/bps/bp1sphere.h
|
511be387e7e7fc81df1b5ec749fca047e2881dd8
|
[
"BSD-2-Clause",
"BSD-3-Clause"
] |
permissive
|
CEED/libCEED
|
c17e8b2f8e9ccfafc0505bb6db451e2f7cfed690
|
c6c10e0994b55ea1726a79024cd4c333c40de38a
|
refs/heads/main
| 2023-09-01T20:13:21.268643
| 2023-09-01T20:08:36
| 2023-09-01T20:08:36
| 113,349,904
| 167
| 54
|
BSD-2-Clause
| 2023-09-14T20:37:58
| 2017-12-06T17:57:40
|
C
|
UTF-8
|
C
| false
| false
| 5,730
|
h
|
bp1sphere.h
|
// Copyright (c) 2017-2022, Lawrence Livermore National Security, LLC and other CEED contributors.
// All Rights Reserved. See the top-level LICENSE and NOTICE files for details.
//
// SPDX-License-Identifier: BSD-2-Clause
//
// This file is part of CEED: http://github.com/ceed
/// @file
/// libCEED QFunctions for mass operator example for a scalar field on the sphere using PETSc
#ifndef bp1sphere_h
#define bp1sphere_h
#include <ceed.h>
#include <math.h>
// -----------------------------------------------------------------------------
// This QFunction sets up the geometric factors required for integration and coordinate transformations when reference coordinates have a different
// dimension than the one of physical coordinates
//
// Reference (parent) 2D coordinates: X \in [-1, 1]^2
//
// Global 3D physical coordinates given by the mesh: xx \in [-R, R]^3 with R radius of the sphere
//
// Local 3D physical coordinates on the 2D manifold: x \in [-l, l]^3 with l half edge of the cube inscribed in the sphere
//
// Change of coordinates matrix computed by the library:
// (physical 3D coords relative to reference 2D coords)
// dxx_j/dX_i (indicial notation) [3 * 2]
//
// Change of coordinates x (on the 2D manifold) relative to xx (phyisical 3D):
// dx_i/dxx_j (indicial notation) [3 * 3]
//
// Change of coordinates x (on the 2D manifold) relative to X (reference 2D):
// (by chain rule)
// dx_i/dX_j [3 * 2] = dx_i/dxx_k [3 * 3] * dxx_k/dX_j [3 * 2]
//
// mod_J is given by the magnitude of the cross product of the columns of dx_i/dX_j
//
// The quadrature data is stored in the array q_data.
//
// We require the determinant of the Jacobian to properly compute integrals of the form: int( u v )
//
// Qdata: mod_J * w
// -----------------------------------------------------------------------------
CEED_QFUNCTION(SetupMassGeo)(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out) {
// Inputs
const CeedScalar *X = in[0], *J = in[1], *w = in[2];
// Outputs
CeedScalar *q_data = out[0];
// Quadrature Point Loop
CeedPragmaSIMD for (CeedInt i = 0; i < Q; i++) {
// Read global Cartesian coordinates
const CeedScalar xx[3] = {X[i + 0 * Q], X[i + 1 * Q], X[i + 2 * Q]};
// Read dxxdX Jacobian entries, stored as
// 0 3
// 1 4
// 2 5
const CeedScalar dxxdX[3][2] = {
{J[i + Q * 0], J[i + Q * 3]},
{J[i + Q * 1], J[i + Q * 4]},
{J[i + Q * 2], J[i + Q * 5]}
};
// Setup
// x = xx (xx^T xx)^{-1/2}
// dx/dxx = I (xx^T xx)^{-1/2} - xx xx^T (xx^T xx)^{-3/2}
const CeedScalar mod_xx_sq = xx[0] * xx[0] + xx[1] * xx[1] + xx[2] * xx[2];
CeedScalar xx_sq[3][3];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) xx_sq[j][k] = xx[j] * xx[k] / (sqrt(mod_xx_sq) * mod_xx_sq);
}
const CeedScalar dxdxx[3][3] = {
{1. / sqrt(mod_xx_sq) - xx_sq[0][0], -xx_sq[0][1], -xx_sq[0][2] },
{-xx_sq[1][0], 1. / sqrt(mod_xx_sq) - xx_sq[1][1], -xx_sq[1][2] },
{-xx_sq[2][0], -xx_sq[2][1], 1. / sqrt(mod_xx_sq) - xx_sq[2][2]}
};
CeedScalar dxdX[3][2];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 2; k++) {
dxdX[j][k] = 0;
for (int l = 0; l < 3; l++) dxdX[j][k] += dxdxx[j][l] * dxxdX[l][k];
}
}
// J is given by the cross product of the columns of dxdX
const CeedScalar J[3] = {dxdX[1][0] * dxdX[2][1] - dxdX[2][0] * dxdX[1][1], dxdX[2][0] * dxdX[0][1] - dxdX[0][0] * dxdX[2][1],
dxdX[0][0] * dxdX[1][1] - dxdX[1][0] * dxdX[0][1]};
// Use the magnitude of J as our detJ (volume scaling factor)
const CeedScalar mod_J = sqrt(J[0] * J[0] + J[1] * J[1] + J[2] * J[2]);
// Interp-to-Interp q_data
q_data[i + Q * 0] = mod_J * w[i];
} // End of Quadrature Point Loop
return 0;
}
// -----------------------------------------------------------------------------
// This QFunction sets up the rhs and true solution for the problem
// -----------------------------------------------------------------------------
CEED_QFUNCTION(SetupMassRhs)(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out) {
// Inputs
const CeedScalar *X = in[0], *q_data = in[1];
// Outputs
CeedScalar *true_soln = out[0], *rhs = out[1];
// Context
const CeedScalar *context = (const CeedScalar *)ctx;
const CeedScalar R = context[0];
// Quadrature Point Loop
CeedPragmaSIMD for (CeedInt i = 0; i < Q; i++) {
// Compute latitude
const CeedScalar theta = asin(X[i + 2 * Q] / R);
// Use absolute value of latitude for true solution
true_soln[i] = fabs(theta);
rhs[i] = q_data[i] * true_soln[i];
} // End of Quadrature Point Loop
return 0;
}
// -----------------------------------------------------------------------------
// This QFunction applies the mass operator for a scalar field.
//
// Inputs:
// u - Input vector at quadrature points
// q_data - Geometric factors
//
// Output:
// v - Output vector (test functions) at quadrature points
// -----------------------------------------------------------------------------
CEED_QFUNCTION(Mass)(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out) {
// Inputs
const CeedScalar *u = in[0], *q_data = in[1];
// Outputs
CeedScalar *v = out[0];
// Quadrature Point Loop
CeedPragmaSIMD for (CeedInt i = 0; i < Q; i++) v[i] = q_data[i] * u[i];
return 0;
}
// -----------------------------------------------------------------------------
#endif // bp1sphere_h
|
f5311b7694016aa7d43b306423f4832ba9dfcebf
|
fbdc48c28e54fb33ae4842ef95ff63893902c99a
|
/src/omv/imlib/haar.c
|
5817a98820fff6e5cd82ecb08bf28805c4f5392e
|
[
"MIT"
] |
permissive
|
openmv/openmv
|
44d4b79fc8693950a2e330e5e0fd95b5c36e230f
|
8a90e070a88b7fc14c87a00351b9c4a213278419
|
refs/heads/master
| 2023-08-30T20:59:57.227603
| 2023-08-23T16:50:55
| 2023-08-23T16:50:55
| 14,360,940
| 2,150
| 1,226
|
MIT
| 2023-09-14T07:18:15
| 2013-11-13T10:23:44
|
C
|
UTF-8
|
C
| false
| false
| 11,371
|
c
|
haar.c
|
/*
* This file is part of the OpenMV project.
*
* Copyright (c) 2013-2021 Ibrahim Abdelkader <iabdalkader@openmv.io>
* Copyright (c) 2013-2021 Kwabena W. Agyeman <kwagyeman@openmv.io>
*
* This work is licensed under the MIT license, see the file LICENSE for details.
*
* Viola-Jones object detector implementation.
* Based on the work of Francesco Comaschi (f.comaschi@tue.nl)
*/
#include <stdio.h>
#include "py/obj.h"
#include "py/nlr.h"
#include "ff.h"
#include "ff_wrapper.h"
#include "xalloc.h"
#include "imlib.h"
// built-in cascades
#include "cascade.h"
static int eval_weak_classifier(cascade_t *cascade, point_t pt, int t_idx, int w_idx, int r_idx) {
int32_t sumw = 0;
mw_image_t *sum = cascade->sum;
/* The node threshold is multiplied by the standard deviation of the sub window */
int32_t t = cascade->tree_thresh_array[t_idx] * cascade->std;
for (int i = 0; i < cascade->num_rectangles_array[t_idx]; i++) {
int x = cascade->rectangles_array[r_idx + (i << 2) + 0];
int y = cascade->rectangles_array[r_idx + (i << 2) + 1];
int w = cascade->rectangles_array[r_idx + (i << 2) + 2];
int h = cascade->rectangles_array[r_idx + (i << 2) + 3];
// Lookup the feature
sumw += imlib_integral_mw_lookup(sum, pt.x + x, y, w, h) * (cascade->weights_array[w_idx + i] << 12);
}
if (sumw >= t) {
return cascade->alpha2_array[t_idx];
}
return cascade->alpha1_array[t_idx];
}
static int run_cascade_classifier(cascade_t *cascade, point_t pt) {
int win_w = cascade->window.w;
int win_h = cascade->window.h;
uint32_t n = (win_w * win_h);
uint32_t i_s = imlib_integral_mw_lookup(cascade->sum, pt.x, 0, win_w, win_h);
uint32_t i_sq = imlib_integral_mw_lookup(cascade->ssq, pt.x, 0, win_w, win_h);
uint32_t m = i_s / n;
uint32_t v = i_sq / n - (m * m);
// Skip homogeneous regions.
if (v < (50 * 50)) {
return 0;
}
cascade->std = fast_sqrtf(i_sq * n - (i_s * i_s));
for (int i = 0, w_idx = 0, r_idx = 0, t_idx = 0; i < cascade->n_stages; i++) {
int stage_sum = 0;
for (int j = 0; j < cascade->stages_array[i]; j++, t_idx++) {
// Send the shifted window to a haar filter
stage_sum += eval_weak_classifier(cascade, pt, t_idx, w_idx, r_idx);
w_idx += cascade->num_rectangles_array[t_idx];
r_idx += cascade->num_rectangles_array[t_idx] * 4;
}
// If the sum is below the stage threshold, no objects were detected
if (stage_sum < (cascade->threshold * cascade->stages_thresh_array[i])) {
return 0;
}
}
return 1;
}
array_t *imlib_detect_objects(image_t *image, cascade_t *cascade, rectangle_t *roi) {
// Integral images
mw_image_t sum;
mw_image_t ssq;
// Detected objects array
array_t *objects;
// Allocate the objects array
array_alloc(&objects, xfree);
// Set cascade image pointers
cascade->img = image;
cascade->sum = ∑
cascade->ssq = &ssq;
// Set scanning step.
// Viola and Jones achieved best results using a scaling factor
// of 1.25 and a scanning factor proportional to the current scale.
// Start with a step of 5% of the image width and reduce at each scaling step
cascade->step = (roi->w * 50) / 1000;
// Make sure step is less than window height + 1
if (cascade->step > cascade->window.h) {
cascade->step = cascade->window.h;
}
// Allocate integral images
imlib_integral_mw_alloc(&sum, roi->w, cascade->window.h + 1);
imlib_integral_mw_alloc(&ssq, roi->w, cascade->window.h + 1);
// Iterate over the image pyramid
for (float factor = 1.0f; ; factor *= cascade->scale_factor) {
// Set the scaled width and height
int szw = roi->w / factor;
int szh = roi->h / factor;
// Break if scaled image is smaller than feature size
if (szw < cascade->window.w || szh < cascade->window.h) {
break;
}
// Set the integral images scale
imlib_integral_mw_scale(roi, &sum, szw, szh);
imlib_integral_mw_scale(roi, &ssq, szw, szh);
// Compute new scaled integral images
imlib_integral_mw_ss(image, &sum, &ssq, roi);
// Scale the scanning step
cascade->step = cascade->step / factor;
cascade->step = (cascade->step == 0) ? 1 : cascade->step;
// Process image at the current scale
// When filter window shifts to borders, some margin need to be kept
int y2 = szh - cascade->window.h;
int x2 = szw - cascade->window.w;
// Shift the filter window over the image.
for (int y = 0; y < y2; y += cascade->step) {
for (int x = 0; x < x2; x += cascade->step) {
point_t p = {x, y};
// If an object is detected, record the coordinates of the filter window
if (run_cascade_classifier(cascade, p) > 0) {
array_push_back(objects,
rectangle_alloc(fast_roundf(x * factor) + roi->x, fast_roundf(y * factor) + roi->y,
fast_roundf(cascade->window.w * factor),
fast_roundf(cascade->window.h * factor)));
}
}
// If not last line, shift integral images
if ((y + cascade->step) < y2) {
imlib_integral_mw_shift_ss(image, &sum, &ssq, roi, cascade->step);
}
}
}
imlib_integral_mw_free(&ssq);
imlib_integral_mw_free(&sum);
if (array_length(objects) > 1) {
// Merge objects detected at different scales
objects = rectangle_merge(objects);
}
return objects;
}
#if defined(IMLIB_ENABLE_IMAGE_FILE_IO)
int imlib_load_cascade_from_file(cascade_t *cascade, const char *path) {
int i;
FIL fp;
FRESULT res = FR_OK;
file_read_open(&fp, path);
file_buffer_on(&fp);
/* read detection window size */
read_data(&fp, &cascade->window, sizeof(cascade->window));
/* read num stages */
read_data(&fp, &cascade->n_stages, sizeof(cascade->n_stages));
cascade->stages_array = xalloc(sizeof(*cascade->stages_array) * cascade->n_stages);
cascade->stages_thresh_array = xalloc(sizeof(*cascade->stages_thresh_array) * cascade->n_stages);
if (cascade->stages_array == NULL ||
cascade->stages_thresh_array == NULL) {
res = 20;
goto error;
}
/* read num features in each stages */
read_data(&fp, cascade->stages_array, sizeof(uint8_t) * cascade->n_stages);
/* sum num of features in each stages*/
for (i = 0, cascade->n_features = 0; i < cascade->n_stages; i++) {
cascade->n_features += cascade->stages_array[i];
}
/* alloc features thresh array, alpha1, alpha 2,rects weights and rects*/
cascade->tree_thresh_array = xalloc(sizeof(*cascade->tree_thresh_array) * cascade->n_features);
cascade->alpha1_array = xalloc(sizeof(*cascade->alpha1_array) * cascade->n_features);
cascade->alpha2_array = xalloc(sizeof(*cascade->alpha2_array) * cascade->n_features);
cascade->num_rectangles_array = xalloc(sizeof(*cascade->num_rectangles_array) * cascade->n_features);
if (cascade->tree_thresh_array == NULL ||
cascade->alpha1_array == NULL ||
cascade->alpha2_array == NULL ||
cascade->num_rectangles_array == NULL) {
res = 20;
goto error;
}
/* read stages thresholds */
read_data(&fp, cascade->stages_thresh_array, sizeof(int16_t) * cascade->n_stages);
/* read features thresholds */
read_data(&fp, cascade->tree_thresh_array, sizeof(*cascade->tree_thresh_array) * cascade->n_features);
/* read alpha 1 */
read_data(&fp, cascade->alpha1_array, sizeof(*cascade->alpha1_array) * cascade->n_features);
/* read alpha 2 */
read_data(&fp, cascade->alpha2_array, sizeof(*cascade->alpha2_array) * cascade->n_features);
/* read num rectangles per feature*/
read_data(&fp, cascade->num_rectangles_array, sizeof(*cascade->num_rectangles_array) * cascade->n_features);
/* sum num of recatngles per feature*/
for (i = 0, cascade->n_rectangles = 0; i < cascade->n_features; i++) {
cascade->n_rectangles += cascade->num_rectangles_array[i];
}
cascade->weights_array = xalloc(sizeof(*cascade->weights_array) * cascade->n_rectangles);
cascade->rectangles_array = xalloc(sizeof(*cascade->rectangles_array) * cascade->n_rectangles * 4);
if (cascade->weights_array == NULL ||
cascade->rectangles_array == NULL) {
res = 20;
goto error;
}
/* read rectangles weights */
read_data(&fp, cascade->weights_array, sizeof(*cascade->weights_array) * cascade->n_rectangles);
/* read rectangles num rectangles * 4 points */
read_data(&fp, cascade->rectangles_array, sizeof(*cascade->rectangles_array) * cascade->n_rectangles * 4);
error:
file_buffer_off(&fp);
file_close(&fp);
return res;
}
#endif //(IMLIB_ENABLE_IMAGE_FILE_IO)
int imlib_load_cascade(cascade_t *cascade, const char *path) {
// built-in cascade
if (strcmp(path, "frontalface") == 0) {
cascade->window.w = frontalface_window_w;
cascade->window.h = frontalface_window_h;
cascade->n_stages = frontalface_n_stages;
cascade->stages_array = (uint8_t *) frontalface_stages_array;
cascade->stages_thresh_array = (int16_t *) frontalface_stages_thresh_array;
cascade->tree_thresh_array = (int16_t *) frontalface_tree_thresh_array;
cascade->alpha1_array = (int16_t *) frontalface_alpha1_array;
cascade->alpha2_array = (int16_t *) frontalface_alpha2_array;
cascade->num_rectangles_array = (int8_t *) frontalface_num_rectangles_array;
cascade->weights_array = (int8_t *) frontalface_weights_array;
cascade->rectangles_array = (int8_t *) frontalface_rectangles_array;
} else if (strcmp(path, "eye") == 0) {
cascade->window.w = eye_window_w;
cascade->window.h = eye_window_h;
cascade->n_stages = eye_n_stages;
cascade->stages_array = (uint8_t *) eye_stages_array;
cascade->stages_thresh_array = (int16_t *) eye_stages_thresh_array;
cascade->tree_thresh_array = (int16_t *) eye_tree_thresh_array;
cascade->alpha1_array = (int16_t *) eye_alpha1_array;
cascade->alpha2_array = (int16_t *) eye_alpha2_array;
cascade->num_rectangles_array = (int8_t *) eye_num_rectangles_array;
cascade->weights_array = (int8_t *) eye_weights_array;
cascade->rectangles_array = (int8_t *) eye_rectangles_array;
} else {
#if defined(IMLIB_ENABLE_IMAGE_FILE_IO)
// xml cascade
return imlib_load_cascade_from_file(cascade, path);
#else
return -1;
#endif
}
int i;
// sum the number of features in all stages
for (i = 0, cascade->n_features = 0; i < cascade->n_stages; i++) {
cascade->n_features += cascade->stages_array[i];
}
// sum the number of recatngles in all features
for (i = 0, cascade->n_rectangles = 0; i < cascade->n_features; i++) {
cascade->n_rectangles += cascade->num_rectangles_array[i];
}
return FR_OK;
}
|
683224567ec708a0806c9eaf1bbff80580e6b1ca
|
d579699e6728aa74084f8cc4dc435007b9f523a8
|
/tests/recompilation-tests/uns.c
|
fa14841b674967f5da1f3cba1ebdf433ae17abdc
|
[
"BSD-3-Clause"
] |
permissive
|
BoomerangDecompiler/boomerang
|
b3c6b4e88c152ac6d437f3dd3640fd9ffa157cb6
|
411041305f90d1d7c994f67255b5c03ea8666e60
|
refs/heads/develop
| 2023-08-31T03:50:56.112711
| 2020-12-28T12:11:55
| 2020-12-28T17:38:56
| 7,819,729
| 281
| 41
|
NOASSERTION
| 2020-12-27T17:59:52
| 2013-01-25T12:26:59
|
C++
|
UTF-8
|
C
| false
| false
| 658
|
c
|
uns.c
|
/*
* This file is part of the Boomerang Decompiler.
*
* See the file "LICENSE.TERMS" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
if (argc >= 4000000000U) {
printf("Population exceeds %u\n", 4000000000U);
}
if (argc < 0xF0000000) {
printf("The mask is %x\n", 0xF0000000);
}
unsigned int u = (unsigned int)argc;
if (u >= 2) {
printf("Arguments supplied\n");
}
if (-argc < -2) {
printf("Three or more arguments\n");
}
return EXIT_SUCCESS;
}
|
2ae4471e7866f6fbe5c7645c4b65e7632ede5ce5
|
549270020f6c8724e2ef1b12e38d11b025579f8d
|
/recipes/readosm/all/test_package/test_package.c
|
4671ccc588c2ccd654b80aa946a87b7e0e1d8d19
|
[
"MIT"
] |
permissive
|
conan-io/conan-center-index
|
1bcec065ccd65aa38b1fed93fbd94d9d5fe6bc43
|
3b17e69bb4e5601a850b6e006e44775e690bac33
|
refs/heads/master
| 2023-08-31T11:34:45.403978
| 2023-08-31T11:13:23
| 2023-08-31T11:13:23
| 204,671,232
| 844
| 1,820
|
MIT
| 2023-09-14T21:22:42
| 2019-08-27T09:43:58
|
Python
|
UTF-8
|
C
| false
| false
| 241
|
c
|
test_package.c
|
# include <readosm.h>
#include <stdio.h>
int main(void) {
printf("readosm %s built with:\n", readosm_version());
printf("-- expat %s\n", readosm_expat_version());
printf("-- zlib %s\n", readosm_zlib_version());
return 0;
}
|
fbbb396d930f9aab70ff1da7feb9b38a5b4c0cae
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/arch/arm/plat-omap/include/plat/mailbox.h
|
cc3921e9059c8995d55334dba80ee64cba8d9aff
|
[
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 2,663
|
h
|
mailbox.h
|
/* mailbox.h */
#ifndef MAILBOX_H
#define MAILBOX_H
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/kfifo.h>
typedef u32 mbox_msg_t;
struct omap_mbox;
typedef int __bitwise omap_mbox_irq_t;
#define IRQ_TX ((__force omap_mbox_irq_t) 1)
#define IRQ_RX ((__force omap_mbox_irq_t) 2)
typedef int __bitwise omap_mbox_type_t;
#define OMAP_MBOX_TYPE1 ((__force omap_mbox_type_t) 1)
#define OMAP_MBOX_TYPE2 ((__force omap_mbox_type_t) 2)
struct omap_mbox_ops {
omap_mbox_type_t type;
int (*startup)(struct omap_mbox *mbox);
void (*shutdown)(struct omap_mbox *mbox);
/* fifo */
mbox_msg_t (*fifo_read)(struct omap_mbox *mbox);
void (*fifo_write)(struct omap_mbox *mbox, mbox_msg_t msg);
int (*fifo_empty)(struct omap_mbox *mbox);
int (*fifo_full)(struct omap_mbox *mbox);
/* irq */
void (*enable_irq)(struct omap_mbox *mbox,
omap_mbox_irq_t irq);
void (*disable_irq)(struct omap_mbox *mbox,
omap_mbox_irq_t irq);
void (*ack_irq)(struct omap_mbox *mbox, omap_mbox_irq_t irq);
int (*is_irq)(struct omap_mbox *mbox, omap_mbox_irq_t irq);
/* ctx */
void (*save_ctx)(struct omap_mbox *mbox);
void (*restore_ctx)(struct omap_mbox *mbox);
};
struct omap_mbox_queue {
spinlock_t lock;
struct kfifo fifo;
struct work_struct work;
struct tasklet_struct tasklet;
struct omap_mbox *mbox;
bool full;
};
struct omap_mbox {
char *name;
unsigned int irq;
struct omap_mbox_queue *txq, *rxq;
struct omap_mbox_ops *ops;
struct device *dev;
void *priv;
int use_count;
struct blocking_notifier_head notifier;
};
int omap_mbox_msg_send(struct omap_mbox *, mbox_msg_t msg);
void omap_mbox_init_seq(struct omap_mbox *);
struct omap_mbox *omap_mbox_get(const char *, struct notifier_block *nb);
void omap_mbox_put(struct omap_mbox *mbox, struct notifier_block *nb);
int omap_mbox_register(struct device *parent, struct omap_mbox **);
int omap_mbox_unregister(void);
static inline void omap_mbox_save_ctx(struct omap_mbox *mbox)
{
if (!mbox->ops->save_ctx) {
dev_err(mbox->dev, "%s:\tno save\n", __func__);
return;
}
mbox->ops->save_ctx(mbox);
}
static inline void omap_mbox_restore_ctx(struct omap_mbox *mbox)
{
if (!mbox->ops->restore_ctx) {
dev_err(mbox->dev, "%s:\tno restore\n", __func__);
return;
}
mbox->ops->restore_ctx(mbox);
}
static inline void omap_mbox_enable_irq(struct omap_mbox *mbox,
omap_mbox_irq_t irq)
{
mbox->ops->enable_irq(mbox, irq);
}
static inline void omap_mbox_disable_irq(struct omap_mbox *mbox,
omap_mbox_irq_t irq)
{
mbox->ops->disable_irq(mbox, irq);
}
#endif /* MAILBOX_H */
|
ce12bee5c528b8168579ceefd1d3317fe48ab3dc
|
99bdb3251fecee538e0630f15f6574054dfc1468
|
/bsp/samd21/sam_d2x_asflib/common/services/spi/sam_usart_spi/usart_spi.c
|
7dcaf7668989d586dfb2db156c3379c228722743
|
[
"Zlib",
"LicenseRef-scancode-proprietary-license",
"MIT",
"BSD-3-Clause",
"X11",
"BSD-4-Clause-UC",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
RT-Thread/rt-thread
|
03a7c52c2aeb1b06a544143b0e803d72f47d1ece
|
3602f891211904a27dcbd51e5ba72fefce7326b2
|
refs/heads/master
| 2023-09-01T04:10:20.295801
| 2023-08-31T16:20:55
| 2023-08-31T16:20:55
| 7,408,108
| 9,599
| 5,805
|
Apache-2.0
| 2023-09-14T13:37:26
| 2013-01-02T14:49:21
|
C
|
UTF-8
|
C
| false
| false
| 9,099
|
c
|
usart_spi.c
|
/**
* \file
*
* \brief SAM USART in SPI mode driver functions.
*
* Copyright (c) 2011-2016 Atmel Corporation. All rights reserved.
*
* \asf_license_start
*
* \page License
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name of Atmel may not be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* 4. This software may only be redistributed and used in connection with an
* Atmel microcontroller product.
*
* THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
* EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* \asf_license_stop
*
*/
/*
* Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
*/
#include "usart_spi.h"
#include "sysclk.h"
#if SAMG55
#include "flexcom.h"
#include "conf_board.h"
#endif
/// @cond 0
/**INDENT-OFF**/
#ifdef __cplusplus
extern "C" {
#endif
/**INDENT-ON**/
/// @endcond
/*! \brief Enable the USART system clock in SPI master mode.
*
* \param p_usart Pointer to Base address of the USART instance.
*
*/
void usart_spi_init(Usart *p_usart)
{
#if (!SAMG55)
uint8_t uc_id;
#ifdef USART0
if (p_usart == USART0) {
uc_id = ID_USART0;
}
#endif
#ifdef USART1
else if(p_usart == USART1) {
uc_id = ID_USART1;
}
#endif
#ifdef USART2
else if(p_usart == USART2) {
uc_id = ID_USART2;
}
#endif
#ifdef USART3
else if(p_usart == USART3) {
uc_id = ID_USART3;
}
#endif
#endif
#if SAM4L
sysclk_enable_peripheral_clock(p_usart);
#elif SAMG55
flexcom_enable(BOARD_FLEXCOM_USART);
flexcom_set_opmode(BOARD_FLEXCOM_USART, FLEXCOM_USART);
#else
sysclk_enable_peripheral_clock(uc_id);
#endif
}
/**
* \brief Set up a USART in SPI master mode device.
*
* The returned device descriptor structure must be passed to the driver
* whenever that device should be used as current slave device.
*
* \param p_usart Base address of the USART instance.
* \param device Pointer to usart device struct that should be initialized.
* \param flags USART configuration flags. Common flags for all
* implementations are the usart modes, which should be SPI_MODE_0,
* SPI_MODE_1, SPI_MODE_2, SPI_MODE_3.
* \param baud_rate Baud rate for communication with slave device in Hz.
* \param sel_id Board specific select id.
*/
void usart_spi_setup_device(Usart *p_usart, struct usart_spi_device *device,
spi_flags_t flags, unsigned long baud_rate,
board_spi_select_id_t sel_id)
{
usart_spi_opt_t opt;
/* avoid Cppcheck Warning */
UNUSED(device);
UNUSED(sel_id);
/* Basic usart SPI configuration. */
opt.baudrate = baud_rate;
opt.char_length = US_MR_CHRL_8_BIT;
opt.spi_mode = flags;
opt.channel_mode = US_MR_CHMODE_NORMAL;
/* Initialize the USART module as SPI master. */
#if (SAM4L)
usart_init_spi_master(p_usart, &opt, sysclk_get_pba_hz());
#else
usart_init_spi_master(p_usart, &opt, sysclk_get_peripheral_hz());
#endif
usart_enable_rx(p_usart);
usart_enable_tx(p_usart);
}
/*! \brief Write one byte to an SPI device using USART in SPI mode.
*
* \param p_usart Base address of the USART instance.
* \param data The data to be sent out.
*
*/
void usart_spi_write_single(Usart *p_usart, uint8_t data)
{
usart_putchar(p_usart, data);
}
/**
* \brief Send a sequence of bytes to an SPI device using USART in SPI mode.
*
* Received bytes on the USART in SPI mode are discarded.
*
* \param p_usart Base address of the USART instance.
* \param data Data buffer to write.
* \param len Length of data.
*
* \return 0 if the USART in SPI master mode sends packet successfully.
*
* \pre USART device must be selected with usart_spi_select_device() first.
*/
uint32_t usart_spi_write_packet(Usart *p_usart, const uint8_t *data, size_t len)
{
uint32_t dummy_data;
size_t i=0;
while(len) {
usart_putchar(p_usart, *(data+i));
usart_getchar(p_usart, &dummy_data);
len--;
i++;
}
return 0;
}
/*! \brief Receive one byte from an SPI device using USART in SPI mode.
*
* \param p_usart Base address of the USART instance.
* \param data Pointer to the data byte where to store the received data.
*
* \pre USART device must be selected with usart_spi_select_device() first.
*/
void usart_spi_read_single(Usart *p_usart, uint8_t *data)
{
uint32_t temp_data = 0;
/* Dummy write one data to slave in order to read data. */
usart_putchar(p_usart, CONFIG_USART_SPI_DUMMY);
usart_getchar(p_usart, &temp_data);
*data = (uint8_t)temp_data;
}
/**
* \brief Receive a sequence of bytes from a USART in SPI mode device.
*
* All bytes sent out on usart bus are sent as value 0.
*
* \param p_usart Base address of the usart instance.
* \param data Data buffer to put read data.
* \param len Length of data.
*
* \return 0 if the USART in SPI master mode reads packet successfully.
*
* \pre USART device must be selected with usart_spi_select_device() first.
*/
uint32_t usart_spi_read_packet(Usart *p_usart, uint8_t *data, size_t len)
{
uint32_t val;
uint32_t i = 0;
while(len) {
/* Dummy write one data to slave in order to read data. */
usart_putchar(p_usart, CONFIG_USART_SPI_DUMMY);
usart_getchar(p_usart, &val);
data[i] = (uint8_t)(val & 0xFF);
i++;
len--;
}
return 0;
}
/**
* \brief Select the given device on the SPI bus.
*
* \param p_usart Base address of the USART instance.
* \param device SPI device.
*
*/
void usart_spi_select_device(Usart *p_usart, struct usart_spi_device *device)
{
/* avoid Cppcheck Warning */
UNUSED(device);
usart_spi_force_chip_select(p_usart);
}
/**
* \brief De-select the given device on the SPI bus.
*
* \param p_usart Base address of the USART instance.
* \param device SPI device.
*/
void usart_spi_deselect_device(Usart *p_usart, struct usart_spi_device *device)
{
/* avoid Cppcheck Warning */
UNUSED(device);
usart_spi_release_chip_select(p_usart);
}
/*! \brief Check whether there are data in Transmit Holding Register or
* Transmit Shift Register in SPI master mode.
*
* \param p_usart Base address of the USART instance.
*
* \retval 1 The two registers are empty.
* \retval 0 One of the two registers contains data.
*/
uint32_t usart_spi_is_tx_empty(Usart *p_usart)
{
return usart_is_tx_empty(p_usart);
}
/*! \brief Check whether the USART in SPI master mode contains a received character.
*
* \param p_usart Base address of the USART instance.
*
* \retval 1 Some data have been received.
* \retval 0 No data has been received.
*/
uint32_t usart_spi_is_rx_ready(Usart *p_usart)
{
return usart_is_rx_ready(p_usart);
}
/*! \brief Check if the USART Transmit Holding Register is empty or not in SPI mode.
*
* \param p_usart Base address of the USART instance.
*
* \retval 1 There is no data in the Transmit Holding Register.
* \retval 0 There are data in the Transmit Holding Register.
*/
uint32_t usart_spi_is_tx_ready(Usart *p_usart)
{
return usart_is_tx_ready(p_usart);
}
/*! \brief Check if both receive buffers are full.
*
* \param p_usart Base address of the USART instance.
*
* \retval 1 Receive buffers are full.
* \retval 0 Receive buffers are not full.
*/
uint32_t usart_spi_is_rx_full(Usart *p_usart)
{
#if (!SAMV71 && !SAMV70 && !SAME70 && !SAMS70)
return usart_is_rx_buf_full(p_usart);
#endif
}
/*! \brief Enable the USART for the specified USART in SPI mode.
*
* \param p_usart Base address of the USART instance.
*/
void usart_spi_enable(Usart *p_usart)
{
usart_enable_tx(p_usart);
usart_enable_rx(p_usart);
}
/*! \brief Disable the USART for the specified USART in SPI mode.
*
* Ensure that nothing is transferred while setting up buffers.
*
* \param p_usart Base address of the USART instance.
*
*/
void usart_spi_disable(Usart *p_usart)
{
usart_disable_tx(p_usart);
usart_disable_rx(p_usart);
}
/// @cond 0
/**INDENT-OFF**/
#ifdef __cplusplus
}
#endif
/**INDENT-ON**/
/// @endcond
|
04e7b2b7a3f95e42e10135f129208b7a95b5b438
|
79bd639c75da41ef50549141eb19ad1327026dd5
|
/thirdparty/mhook/disasm-lib/cpu.h
|
069fd75e03be1ff9fe4bce12c67c8a4d76692a55
|
[
"MIT"
] |
permissive
|
apitrace/apitrace
|
0ff067546af346aa623197491e54d4d0f80ca887
|
00706d1a395ab6570ab88136fffb3028a3ded3bd
|
refs/heads/master
| 2023-08-18T14:51:16.977789
| 2023-08-07T17:51:44
| 2023-08-11T08:18:20
| 1,611,530
| 2,097
| 452
|
MIT
| 2023-08-25T16:49:59
| 2011-04-13T21:37:46
|
C++
|
UTF-8
|
C
| false
| false
| 6,567
|
h
|
cpu.h
|
// Copyright (C) 2003, Matt Conover (mconover@gmail.com)
#ifndef CPU_H
#define CPU_H
#ifdef __cplusplus
extern "C" {
#endif
#include <windows.h>
#include "misc.h"
// Windows SDK assumes default alignment.
#pragma pack(push,1)
////////////////////////////////////////////////////////
// System descriptors
////////////////////////////////////////////////////////
#define GDT_NULL 0
#define GDT_R0_CODE 0x08
#define GDT_R0_DATA 0x10
#define GDT_R3_CODE 0x18
#define GDT_R3_DATA 0x20
#define GDT_TSS 0x28
#define GDT_PCR 0x30
#define GDT_R3_TEB 0x38
#define GDT_VDM 0x40
#define GDT_LDT 0x48
#define GDT_DOUBLEFAULT_TSS 0x50
#define GDT_NMI_TSS 0x58
// 16-bit GDT entries:
// TODO: #define GDT_ABIOS_UNKNOWN 0x60 (22F30-32F2F)
#define GDT_ABIOS_VIDEO 0x68
#define GDT_ABIOS_GDT 0x70 // descriptor describing ABIOS GDT itself
#define GDT_ABIOS_NTOS 0x78 // first 64K of NTOSKRNL
#define GDT_ABIOS_CDA 0xE8 // common data area
#define GDT_ABIOS_CODE 0xF0 // KiI386AbiosCall
#define GDT_ABIOS_STACK 0xF8
#define SELECTOR_RPL_MASK 0x03 // bits 0-1
#define SELECTOR_LDT 0x04 // bit 2
// for data selectors
#define DATA_ACCESS_MASK (1<<0)
#define DATA_WRITE_ENABLE_MASK (1<<1)
#define DATA_EXPAND_DOWN_MASK (1<<2)
// for code selectors
#define CODE_ACCESS_MASK (1<<0)
#define CODE_READ_MASK (1<<1)
#define CODE_CONFORMING_MASK (1<<2)
#define CODE_FLAG (1<<3)
#define TASK_GATE 5
#define INTERRUPT_GATE 6
#define TRAP_GATE 7
typedef struct _IDT_ENTRY
{
USHORT LowOffset;
USHORT Selector;
UCHAR Ignored : 5;
UCHAR Zero : 3;
UCHAR Type : 3;
UCHAR Is32Bit : 1;
UCHAR Ignored2 : 1;
UCHAR DPL : 2;
UCHAR Present : 1;
USHORT HighOffset;
#ifdef _WIN64
ULONG HighOffset64;
ULONG Reserved;
#endif
} IDT_ENTRY, TRAP_GATE_ENTRY;
typedef struct _CALL_GATE_ENTRY
{
USHORT LowOffset;
USHORT Selector;
UCHAR ParameterCount: 4;
UCHAR Ignored : 3;
UCHAR Type : 5;
UCHAR DPL : 2;
UCHAR Present : 1;
USHORT HighOffset;
#ifdef _WIN64
ULONG HighOffset64;
ULONG Reserved;
#endif
} CALL_GATE_ENTRY;
typedef struct _TASK_GATE_ENTRY
{
USHORT Ignored;
USHORT Selector;
UCHAR Ignored2 : 5;
UCHAR Zero : 3;
UCHAR Type : 5;
UCHAR DPL : 2;
UCHAR Present : 1;
USHORT Ignored3;
} TASK_GATE_ENTRY;
typedef struct _DESCRIPTOR_ENTRY
{
USHORT LimitLow;
USHORT BaseLow;
UCHAR BaseMid;
UCHAR Type : 4; // 10EWA (code), E=ExpandDown, W=Writable, A=Accessed
// 11CRA (data), C=Conforming, R=Readable, A=Accessed
UCHAR System : 1; // if 1 then it is a gate or LDT
UCHAR DPL : 2; // descriptor privilege level;
// for data selectors, MAX(CPL, RPL) must be <= DPL to access (or else GP# fault)
// for non-conforming code selectors (without callgate), MAX(CPL, RPL) must be <= DPL to access (or else GP# fault)
// for conforming code selectors, MAX(CPL, RPL) must be >= DPL (i.e., CPL 0-2 cannot access if DPL is 3)
// for non-conforming code selectors (with call gate), DPL indicates lowest privilege allowed to access gate
UCHAR Present : 1;
UCHAR LimitHigh : 4;
UCHAR Available: 1; // aka AVL
UCHAR Reserved : 1;
UCHAR Is32Bit : 1; // aka B flag
UCHAR Granularity : 1; // aka G flag
UCHAR BaseHi : 8;
#ifdef _WIN64
ULONG HighOffset64;
ULONG Reserved2;
#endif
} DESCRIPTOR_ENTRY;
typedef struct _GATE_ENTRY
{
USHORT LowOffset;
UCHAR Skip;
UCHAR Type : 5;
UCHAR DPL : 2;
UCHAR Present : 1;
USHORT HighOffset;
#ifdef _WIN64
ULONG HighOffset64;
ULONG Reserved;
#endif
} GATE_ENTRY;
// TODO: update for X64
typedef struct _PTE_ENTRY
{
ULONG Present : 1;
ULONG Write : 1;
ULONG Owner : 1; // E.g., user mode or supervisor mode
ULONG WriteThrough : 1;
ULONG CacheDisable : 1;
ULONG Accessed : 1;
ULONG Dirty : 1;
ULONG PAT : 1;
ULONG Global : 1;
ULONG CopyOnWrite : 1;
ULONG Prototype : 1;
ULONG Transition : 1;
ULONG Address : 20;
} PTE_ENTRY;
// TODO: update for X64
typedef struct _PDE_ENTRY
{
ULONG Present : 1;
ULONG Write : 1;
ULONG Owner : 1;
ULONG WriteThrough : 1;
ULONG CacheDisable : 1;
ULONG Accessed : 1;
ULONG Reserved1 : 1;
ULONG PageSize : 1;
ULONG Global : 1;
ULONG Reserved : 3;
ULONG Address : 20;
} PDE_ENTRY;
// TODO: update for X64
typedef struct _IO_ACCESS_MAP
{
UCHAR DirectionMap[32];
UCHAR IoMap[8196];
} IO_ACCESS_MAP;
#define MIN_TSS_SIZE FIELD_OFFSET(TSS_ENTRY, IoMaps)
// TODO: update for X64
typedef struct _TSS_ENTRY
{
USHORT Backlink;
USHORT Reserved0;
ULONG Esp0;
USHORT Ss0;
USHORT Reserved1;
ULONG NotUsed1[4];
ULONG CR3;
ULONG Eip;
ULONG NotUsed2[9];
USHORT Es;
USHORT Reserved2;
USHORT Cs;
USHORT Reserved3;
USHORT Ss;
USHORT Reserved4;
USHORT Ds;
USHORT Reserved5;
USHORT Fs;
USHORT Reserved6;
USHORT Gs;
USHORT Reserved7;
USHORT LDT;
USHORT Reserved8;
USHORT Flags;
USHORT IoMapBase;
IO_ACCESS_MAP IoMaps[1];
UCHAR IntDirectionMap[32];
} TSS_ENTRY;
// TODO: update for X64
typedef struct _TSS16_ENTRY
{
USHORT Backlink;
USHORT Sp0;
USHORT Ss0;
USHORT Sp1;
USHORT Ss1;
USHORT Sp2;
USHORT Ss3;
USHORT Ip;
USHORT Flags;
USHORT Ax;
USHORT Cx;
USHORT Dx;
USHORT Bx;
USHORT Sp;
USHORT Bp;
USHORT Si;
USHORT Di;
USHORT Es;
USHORT Cs;
USHORT Ss;
USHORT Ds;
USHORT LDT;
} TSS16_ENTRY;
// TODO: update for X64
typedef struct _GDT_ENTRY
{
USHORT LimitLow;
USHORT BaseLow;
union {
struct {
UCHAR BaseMid;
UCHAR Flags1;
UCHAR Flags2;
UCHAR BaseHi;
} Bytes;
struct {
ULONG BaseMid : 8;
ULONG Type : 5;
ULONG Dpl : 2;
ULONG Pres : 1;
ULONG LimitHi : 4;
ULONG Sys : 1;
ULONG Reserved_0 : 1;
ULONG Default_Big : 1;
ULONG Granularity : 1;
ULONG BaseHi : 8;
} Bits;
} HighWord;
} GDT_ENTRY;
BYTE *GetAbsoluteAddressFromSegment(BYTE Segment, DWORD Offset);
BYTE *GetAbsoluteAddressFromSelector(WORD Selector, DWORD Offset);
#pragma pack(pop)
#ifdef __cplusplus
}
#endif
#endif // CPU_H
|
d771b22ce573e87a16dbeb0932a1f53f2357f798
|
8e21b6d9727443e6e0995bd5cc66eacc8e9e5444
|
/examples/common/logs_foo_library/foo_library.h
|
daebb2603f523880277336b74cd435c6aac26ba3
|
[
"Apache-2.0"
] |
permissive
|
open-telemetry/opentelemetry-cpp
|
30a8b1710681f79ff32365882856d4b66049f914
|
f52ec6caded074437658643566bed0d83152a78a
|
refs/heads/main
| 2023-08-31T23:51:57.855002
| 2023-08-31T15:17:26
| 2023-08-31T15:17:26
| 193,156,399
| 500
| 325
|
Apache-2.0
| 2023-09-14T16:44:03
| 2019-06-21T20:27:18
|
C++
|
UTF-8
|
C
| false
| false
| 113
|
h
|
foo_library.h
|
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#pragma once
void foo_library();
|
42f4b6ce2ea7d717fb0bfcb9225ea2270d8c12f2
|
dfb9c45447721431326cc16bb7655cca7b20eeb9
|
/src/GUIslice_ex.h
|
bfa46ecb7f8b20b54276695da99d591095b6cbe5
|
[
"LicenseRef-scancode-proprietary-license",
"MIT"
] |
permissive
|
ImpulseAdventure/GUIslice
|
6257ec4b2a02205b7c1ba00b8795e573609fb1bf
|
e002baae1ac7cd6c504a26aea78dd81fdc21fcb7
|
refs/heads/master
| 2023-08-04T20:51:27.740337
| 2022-04-09T16:23:57
| 2022-04-09T16:23:57
| 69,373,650
| 993
| 216
|
MIT
| 2022-04-09T16:30:29
| 2016-09-27T15:55:00
|
C
|
UTF-8
|
C
| false
| false
| 2,067
|
h
|
GUIslice_ex.h
|
#ifndef _GUISLICE_EX_H_
#define _GUISLICE_EX_H_
#include "GUIslice.h"
// =======================================================================
// GUIslice library (extensions)
// - Calvin Hass
// - https://www.impulseadventure.com/elec/guislice-gui.html
// - https://github.com/ImpulseAdventure/GUIslice
// =======================================================================
//
// The MIT License
//
// Copyright 2016-2020 Calvin Hass
//
// 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.
//
// =======================================================================
/// \file GUIslice_ex.h
// Provide backwards compatibility until we have removed GUIslice_ex
#include "elem/XCheckbox.h"
#include "elem/XGauge.h"
#include "elem/XGraph.h"
#include "elem/XSelNum.h"
#include "elem/XSlider.h"
#include "elem/XTextbox.h"
// Warn users that they should update their includes
// #warning "NOTE: Please replace `GUIslice_ex` per https://github.com/ImpulseAdventure/GUIslice/wiki/Note-_-Include-Extended-Elements"
#endif // _GUISLICE_EX_H_
|
169d14e33ff75e9e31bbd434fc9f015680d2b0f1
|
9874716bc2f2dea03b9163a575ce383855508731
|
/thcrap/src/global.h
|
158c59b5a1452ae1e9b0216c5c7e4c8001e7cf33
|
[
"Unlicense",
"LicenseRef-scancode-public-domain"
] |
permissive
|
thpatch/thcrap
|
d135f6ddb8f5c4fc8b560e69e1f644fb096203e6
|
dec6e6e4d3e505feb55353f78dc1d5d9e770b6ee
|
refs/heads/master
| 2023-07-20T04:13:29.900439
| 2023-07-17T14:26:04
| 2023-07-17T14:26:15
| 11,221,712
| 510
| 57
|
Unlicense
| 2023-09-11T18:10:08
| 2013-07-06T17:29:28
|
C++
|
UTF-8
|
C
| false
| false
| 1,699
|
h
|
global.h
|
/**
* Touhou Community Reliant Automatic Patcher
* Main DLL
*
* ----
*
* Globals, compile-time constants and runconfig abstractions.
*/
#pragma once
// Project stats
THCRAP_API extern const char PROJECT_NAME[];
THCRAP_API extern const char PROJECT_NAME_SHORT[];
THCRAP_API extern const char PROJECT_URL[];
THCRAP_API extern const uint32_t PROJECT_VERSION;
THCRAP_API extern const char PROJECT_VERSION_STRING[];
THCRAP_API extern const char PROJECT_BRANCH[];
// Initializes global_cfg
void globalconfig_init(void);
// Returns the value matching key in config converted in bool
// If key isn't in config it returns default_value with errno ENOENT
BOOL globalconfig_get_boolean(const char* key, const BOOL default_value);
// Sets the value in config and then writes the result on disk
// It returns what json_dump_file returns
int globalconfig_set_boolean(const char* key, const BOOL value);
// Returns the value matching key in config converted in long long
// If key isn't in config it returns default_value with errno ENOENT
long long globalconfig_get_integer(const char* key, const long long default_value);
// Sets the value in config and then writes the result on disk
// It returns what json_dump_file returns
int globalconfig_set_integer(const char* key, const long long value);
// Releases global_cfg
void globalconfig_release(void);
// Memory management
void* TH_CDECL thcrap_alloc(size_t size);
void TH_CDECL thcrap_free(void *mem);
// Convenience macro for binary file names that differ between Debug and
// Release builds.
#ifdef _DEBUG
# define DEBUG_OR_RELEASE "_d"
# define DEBUG_OR_RELEASE_W L"_d"
#else
# define DEBUG_OR_RELEASE
# define DEBUG_OR_RELEASE_W
#endif
|
150fef888b03d8fc02ecf98acf5cf59dc3d86717
|
229a28fc18c13bfe1ba7fc81c38b03651ed8e93b
|
/sw/vendor/riscv-isa-sim/riscv/insns/addiw.h
|
4263eada244bb6f2f43f88df926600ece25a3dca
|
[
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-bsd-3-clause-jtag",
"GPL-3.0-or-later"
] |
permissive
|
pulp-platform/snitch
|
d3967742434fa21e8af71afa6be35ea5420166ca
|
d026f47843f0ea6c269244c4e6851e0e09141ec3
|
refs/heads/master
| 2023-08-24T08:42:36.230951
| 2023-06-19T09:34:05
| 2023-06-19T09:34:05
| 289,236,605
| 194
| 44
|
Apache-2.0
| 2023-07-11T12:46:26
| 2020-08-21T09:57:34
|
SystemVerilog
|
UTF-8
|
C
| false
| false
| 52
|
h
|
addiw.h
|
require_rv64;
WRITE_RD(sext32(insn.i_imm() + RS1));
|
4b44cfa8594fc2ed743454e85206934eeaab1899
|
a3cf3ed7895b6168fe0864770f944d0a25d5ad74
|
/src/print/tok.c
|
2a0b029d78ce4ebd744ed2eda4eec1573948e0ff
|
[
"BSD-2-Clause"
] |
permissive
|
katef/libfsm
|
32269415d8ab61778bef9bfdb3c14c61117216d4
|
479d103357f4e1a8596437895bbc6ddf237a1da0
|
refs/heads/main
| 2023-08-12T06:21:35.611111
| 2023-06-03T22:17:25
| 2023-06-15T20:40:54
| 80,573,145
| 918
| 66
|
BSD-2-Clause
| 2023-09-12T13:31:36
| 2017-01-31T23:31:36
|
C
|
UTF-8
|
C
| false
| false
| 398
|
c
|
tok.c
|
/*
* Copyright 2008-2017 Katherine Flavel
*
* See LICENCE for the full copyright terms.
*/
#include <ctype.h>
#include <assert.h>
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <print/esc.h>
void
esctok(FILE *f, const char *s)
{
const char *p;
assert(f != NULL);
assert(s != NULL);
for (p = s; *p != '\0'; p++) {
fputc(isalnum(*p) ? toupper(*p) : '_', f);
}
}
|
3f61fb2dc24594ac74e7173c22bd2bd494f2553b
|
533d5e1a40def1e1118895f6ba2b4d503c918d1a
|
/tools/BORLANDC/TVISION/DEMOS/TVCMDS.H
|
7510367e14c36e25fd6b35831fe9a6209b6273b9
|
[
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] |
permissive
|
gandrewstone/GameMaker
|
415cccdf0f9ecf5f339b7551469f07d53e43a6fd
|
1fe0070a9f8412b5b53923aae7e64769722685a3
|
refs/heads/master
| 2020-06-12T19:30:07.252432
| 2014-07-14T14:38:55
| 2014-07-14T14:38:55
| 21,754,773
| 103
| 23
| null | null | null | null |
UTF-8
|
C
| false
| false
| 799
|
h
|
TVCMDS.H
|
/*-----------------------------------------------------*/
/* */
/* Turbo Vision 1.0 */
/* Copyright (c) 1991 by Borland International */
/* */
/* Tvcmds.h : Constants for TVDemo events */
/*-----------------------------------------------------*/
const int cmAboutCmd = 100;
const int cmPuzzleCmd = 101;
const int cmCalendarCmd = 102;
const int cmAsciiCmd = 103;
const int cmCalcCmd = 104;
const int cmOpenCmd = 105;
const int cmChDirCmd = 106;
const int cmDOS_Cmd = 107;
const int cmMouseCmd = 108;
const int cmColorCmd = 109;
const int cmSaveCmd = 110;
const int cmRestoreCmd = 111;
|
af54b7e29fc8d439a2545a24ec192a6ef008753c
|
7c857119fe1505b1d80d6e62969661c06dc1a2f4
|
/FileSystems/GrubFS/grub/grub-core/kern/main.c
|
9cad0c4485cccfc7684f3ae5e8a6e9864a7912cf
|
[
"GPL-3.0-only",
"BSD-2-Clause"
] |
permissive
|
CloverHackyColor/CloverBootloader
|
7042ca7dd6b513d22be591a295e49071ae1482ee
|
2711170df4f60b2ae5aa20add3e00f35cf57b7e5
|
refs/heads/master
| 2023-08-30T22:14:34.590134
| 2023-08-27T19:14:02
| 2023-08-27T19:14:02
| 205,810,121
| 4,734
| 770
|
BSD-2-Clause
| 2023-09-03T12:41:33
| 2019-09-02T08:22:14
|
C
|
UTF-8
|
C
| false
| false
| 7,550
|
c
|
main.c
|
/* main.c - the kernel main routine */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2002,2003,2005,2006,2008,2009 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/kernel.h>
#include <grub/misc.h>
#include <grub/symbol.h>
#include <grub/dl.h>
#include <grub/term.h>
#include <grub/file.h>
#include <grub/device.h>
#include <grub/env.h>
#include <grub/mm.h>
#include <grub/command.h>
#include <grub/reader.h>
#include <grub/parser.h>
#ifdef GRUB_MACHINE_PCBIOS
#include <grub/machine/memory.h>
#endif
grub_addr_t
grub_modules_get_end (void)
{
struct grub_module_info *modinfo;
modinfo = (struct grub_module_info *) grub_modbase;
/* Check if there are any modules. */
if ((modinfo == 0) || modinfo->magic != GRUB_MODULE_MAGIC)
return grub_modbase;
return grub_modbase + modinfo->size;
}
/* Load all modules in core. */
static void
grub_load_modules (void)
{
struct grub_module_header *header;
FOR_MODULES (header)
{
/* Not an ELF module, skip. */
if (header->type != OBJ_TYPE_ELF)
continue;
if (! grub_dl_load_core ((char *) header + sizeof (struct grub_module_header),
(header->size - sizeof (struct grub_module_header))))
grub_fatal ("%s", grub_errmsg);
if (grub_errno)
grub_print_error ();
}
}
static char *load_config;
static void
grub_load_config (void)
{
struct grub_module_header *header;
FOR_MODULES (header)
{
/* Not an embedded config, skip. */
if (header->type != OBJ_TYPE_CONFIG)
continue;
load_config = grub_malloc (header->size - sizeof (struct grub_module_header) + 1);
if (!load_config)
{
grub_print_error ();
break;
}
grub_memcpy (load_config, (char *) header +
sizeof (struct grub_module_header),
header->size - sizeof (struct grub_module_header));
load_config[header->size - sizeof (struct grub_module_header)] = 0;
break;
}
}
/* Write hook for the environment variables of root. Remove surrounding
parentheses, if any. */
static char *
grub_env_write_root (struct grub_env_var *var __attribute__ ((unused)),
const char *val)
{
/* XXX Is it better to check the existence of the device? */
grub_size_t len = grub_strlen (val);
if (val[0] == '(' && val[len - 1] == ')')
return grub_strndup (val + 1, len - 2);
return grub_strdup (val);
}
static void
grub_set_prefix_and_root (void)
{
char *device = NULL;
char *path = NULL;
char *fwdevice = NULL;
char *fwpath = NULL;
char *prefix = NULL;
struct grub_module_header *header;
FOR_MODULES (header)
if (header->type == OBJ_TYPE_PREFIX)
prefix = (char *) header + sizeof (struct grub_module_header);
grub_register_variable_hook ("root", 0, grub_env_write_root);
grub_machine_get_bootlocation (&fwdevice, &fwpath);
if (fwdevice)
{
char *cmdpath;
cmdpath = grub_xasprintf ("(%s)%s", fwdevice, fwpath ? : "");
if (cmdpath)
{
grub_env_set ("cmdpath", cmdpath);
grub_env_export ("cmdpath");
grub_free (cmdpath);
}
}
if (prefix)
{
char *pptr = NULL;
if (prefix[0] == '(')
{
pptr = grub_strrchr (prefix, ')');
if (pptr)
{
device = grub_strndup (prefix + 1, pptr - prefix - 1);
pptr++;
}
}
if (!pptr)
pptr = prefix;
if (pptr[0])
path = grub_strdup (pptr);
}
if (!device && fwdevice)
device = fwdevice;
else if (fwdevice && (device[0] == ',' || !device[0]))
{
/* We have a partition, but still need to fill in the drive. */
char *comma, *new_device;
for (comma = fwdevice; *comma; )
{
if (comma[0] == '\\' && comma[1] == ',')
{
comma += 2;
continue;
}
if (*comma == ',')
break;
comma++;
}
if (*comma)
{
char *drive = grub_strndup (fwdevice, comma - fwdevice);
new_device = grub_xasprintf ("%s%s", drive, device);
grub_free (drive);
}
else
new_device = grub_xasprintf ("%s%s", fwdevice, device);
grub_free (fwdevice);
grub_free (device);
device = new_device;
}
else
grub_free (fwdevice);
if (fwpath && !path)
{
grub_size_t len = grub_strlen (fwpath);
while (len > 1 && fwpath[len - 1] == '/')
fwpath[--len] = 0;
if (len >= sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1
&& grub_memcmp (fwpath + len - (sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1), GRUB_TARGET_CPU "-" GRUB_PLATFORM,
sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1) == 0)
fwpath[len - (sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1)] = 0;
path = fwpath;
}
else
grub_free (fwpath);
if (device)
{
char *prefix_set;
prefix_set = grub_xasprintf ("(%s)%s", device, path ? : "");
if (prefix_set)
{
grub_env_set ("prefix", prefix_set);
grub_free (prefix_set);
}
grub_env_set ("root", device);
}
grub_free (device);
grub_free (path);
grub_print_error ();
}
/* Load the normal mode module and execute the normal mode if possible. */
static void
grub_load_normal_mode (void)
{
/* Load the module. */
grub_dl_load ("normal");
/* Print errors if any. */
grub_print_error ();
grub_errno = 0;
grub_command_execute ("normal", 0, 0);
}
static void
reclaim_module_space (void)
{
grub_addr_t modstart, modend;
if (!grub_modbase)
return;
#ifdef GRUB_MACHINE_PCBIOS
modstart = GRUB_MEMORY_MACHINE_DECOMPRESSION_ADDR;
#else
modstart = grub_modbase;
#endif
modend = grub_modules_get_end ();
grub_modbase = 0;
#if GRUB_KERNEL_PRELOAD_SPACE_REUSABLE
grub_mm_init_region ((void *) modstart, modend - modstart);
#else
(void) modstart;
(void) modend;
#endif
}
/* The main routine. */
void __attribute__ ((noreturn))
grub_main (void)
{
/* First of all, initialize the machine. */
grub_machine_init ();
grub_boot_time ("After machine init.");
/* Hello. */
grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
grub_printf ("Welcome to GRUB!\n\n");
grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
grub_load_config ();
grub_boot_time ("Before loading embedded modules.");
/* Load pre-loaded modules and free the space. */
grub_register_exported_symbols ();
#ifdef GRUB_LINKER_HAVE_INIT
grub_arch_dl_init_linker ();
#endif
grub_load_modules ();
grub_boot_time ("After loading embedded modules.");
/* It is better to set the root device as soon as possible,
for convenience. */
grub_set_prefix_and_root ();
grub_env_export ("root");
grub_env_export ("prefix");
/* Reclaim space used for modules. */
reclaim_module_space ();
grub_boot_time ("After reclaiming module space.");
grub_register_core_commands ();
grub_boot_time ("Before execution of embedded config.");
if (load_config)
grub_parser_execute (load_config);
grub_boot_time ("After execution of embedded config. Attempt to go to normal mode");
grub_load_normal_mode ();
grub_rescue_run ();
}
|
f3d06dc751576e9e10992c0e495866c50ca148f5
|
d169de4c5c6b281984df35536430dcc931a957a9
|
/source/hal/driver/WCH/CH32F10X/common/usb/usbhd_hcd/usbhd_hcd.c
|
5bdb6d206c35052651c373b772217d68484552cb
|
[
"LGPL-2.1-only",
"Apache-2.0"
] |
permissive
|
vsfteam/vsf
|
2ba968ba2ef53b036668019c6c6746149a63c38a
|
522a52ff2ee4ed149b52789a5bd366f80c08c458
|
refs/heads/master
| 2023-08-27T07:32:08.339123
| 2023-08-26T17:46:07
| 2023-08-26T17:46:07
| 181,911,464
| 273
| 83
|
Apache-2.0
| 2023-08-29T03:08:36
| 2019-04-17T14:43:42
|
C
|
UTF-8
|
C
| false
| false
| 26,620
|
c
|
usbhd_hcd.c
|
/*****************************************************************************
* Copyright(C)2009-2022 by VSF Team *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); *
* you may not use this file except in compliance with the License. *
* You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
* *
****************************************************************************/
/*============================ INCLUDES ======================================*/
#include "hal/vsf_hal_cfg.h"
#if VSF_USE_USB_HOST == ENABLED
#define __VSF_EDA_CLASS_INHERIT__
#define __VSF_USBH_CLASS_IMPLEMENT_HCD__
// ch32f10x_usbhd has no roothub, so need __VSF_USBH_CLASS_IMPLEMENT_HUB__ for
// vsf_usbh_new_device and vsf_usbh_disconnect_device
#define __VSF_USBH_CLASS_IMPLEMENT_HUB__
#define __VSF_USBH_CLASS_IMPLEMENT_CLASS__
#define CH32F10X_USBHD_HCD_CLASS_IMPLEMENT
#include "./usbhd_hcd.h"
/*============================ MACROS ========================================*/
/*============================ MACROFIED FUNCTIONS ===========================*/
#ifdef USB_HDC_REG_BASE
# define __hc32f10x_usbhd_get_reg(__usbhd) ((hc32f10x_usbhd_reg_t *)USB_HDC_REG_BASE)
#endif
#ifdef USB_HDC_IRQN
# define __hc32f10x_usbhd_get_irqn(__usbhd) ((IRQn_Type)USB_HDC_IRQN)
#endif
#ifndef __IO
# define __IO volatile
#endif
// R8_USB_CTRL
#define RB_UC_HOST_MODE 0x80 // enable USB host mode: 0=device mode, 1=host mode
#define RB_UC_LOW_SPEED 0x40 // enable USB low speed: 0=12Mbps, 1=1.5Mbps
#define RB_UC_INT_BUSY 0x08 // enable automatic responding busy for device mode or automatic pause for host mode during interrupt flag UIF_TRANSFER valid
#define RB_UC_RESET_SIE 0x04 // force reset USB SIE, need software clear
#define RB_UC_CLR_ALL 0x02 // force clear FIFO and count of USB
#define RB_UC_DMA_EN 0x01 // DMA enable and DMA interrupt enable for USB
// R8_UHOST_CTRL
#define RB_UH_LOW_SPEED 0x04 // enable USB port low speed: 0=full speed, 1=low speed
#define RB_UH_BUS_RESET 0x02 // control USB bus reset: 0=normal, 1=force bus reset
#define RB_UH_PORT_EN 0x01 // enable USB port: 0=disable, 1=enable port, automatic disabled if USB device detached
// R8_UH_EP_MOD
#define RB_UH_EP_TX_EN 0x40 // enable USB host OUT endpoint transmittal
#define RB_UH_EP_TBUF_MOD 0x10 // buffer mode of USB host OUT endpoint
// bUH_EP_TX_EN & bUH_EP_TBUF_MOD: USB host OUT endpoint buffer mode, buffer start address is UH_TX_DMA
// 0 x: disable endpoint and disable buffer
// 1 0: 64 bytes buffer for transmittal (OUT endpoint)
// 1 1: dual 64 bytes buffer by toggle bit bUH_T_TOG selection for transmittal (OUT endpoint), total=128bytes
#define RB_UH_EP_RX_EN 0x08 // enable USB host IN endpoint receiving
#define RB_UH_EP_RBUF_MOD 0x01 // buffer mode of USB host IN endpoint
// bUH_EP_RX_EN & bUH_EP_RBUF_MOD: USB host IN endpoint buffer mode, buffer start address is UH_RX_DMA
// 0 x: disable endpoint and disable buffer
// 1 0: 64 bytes buffer for receiving (IN endpoint)
// 1 1: dual 64 bytes buffer by toggle bit bUH_R_TOG selection for receiving (IN endpoint), total=128bytes
// R8_UH_SETUP
#define RB_UH_PRE_PID_EN 0x80 // USB host PRE PID enable for low speed device via hub
#define RB_UH_SOF_EN 0x40 // USB host automatic SOF enable
// R8_USB_INT_EN
#define RB_UIE_FIFO_OV 0x10 // enable interrupt for FIFO overflow
#define RB_UIE_HST_SOF 0x08 // enable interrupt for host SOF timer action for USB host mode
#define RB_UIE_SUSPEND 0x04 // enable interrupt for USB suspend or resume event
#define RB_UIE_TRANSFER 0x02 // enable interrupt for USB transfer completion
#define RB_UIE_DETECT 0x01 // enable interrupt for USB device detected event for USB host mode
// R8_USB_INT_FG
#define RB_U_IS_NAK 0x80 // RO, indicate current USB transfer is NAK received
#define RB_U_TOG_OK 0x40 // RO, indicate current USB transfer toggle is OK
#define RB_U_SIE_FREE 0x20 // RO, indicate USB SIE free status
#define RB_UIF_FIFO_OV 0x10 // FIFO overflow interrupt flag for USB, direct bit address clear or write 1 to clear
#define RB_UIF_HST_SOF 0x08 // host SOF timer interrupt flag for USB host, direct bit address clear or write 1 to clear
#define RB_UIF_SUSPEND 0x04 // USB suspend or resume event interrupt flag, direct bit address clear or write 1 to clear
#define RB_UIF_TRANSFER 0x02 // USB transfer completion interrupt flag, direct bit address clear or write 1 to clear
#define RB_UIF_DETECT 0x01 // device detected event interrupt flag for USB host mode, direct bit address clear or write 1 to clear
// R8_USB_INT_ST
#define RB_UIS_TOG_OK 0x40 // RO, indicate current USB transfer toggle is OK
#define MASK_UIS_H_RES 0x0F // RO, bit mask of current transfer handshake response for USB host mode: 0000=no response, time out from device, others=handshake response PID received
// R8_UH_RX_CTRL
#define RB_UH_R_TOG 0x80 // expected data toggle flag of host receiving (IN): 0=DATA0, 1=DATA1
#define RB_UH_R_AUTO_TOG 0x10 // enable automatic toggle after successful transfer completion: 0=manual toggle, 1=automatic toggle
// R8_UH_TX_CTRL
#define RB_UH_T_TOG 0x40 // prepared data toggle flag of host transmittal (SETUP/OUT): 0=DATA0, 1=DATA1
#define RB_UH_T_AUTO_TOG 0x10 // enable automatic toggle after successful transfer completion: 0=manual toggle, 1=automatic toggle
// R8_USB_MIS_ST
#define RB_UMS_DM_LEVEL 0x02 // RO, indicate UDM level saved at device attached to USB host
#define RB_UMS_DEV_ATTACH 0x01 // RO, indicate device attached status on USB host
/*============================ TYPES =========================================*/
typedef struct hc32f10x_usbhd_reg_t {
__IO uint8_t R8_USB_CTRL; /* offset 0x00 */
__IO uint8_t R8_UHOST_CTRL; /* offset 0x01 */
__IO uint8_t R8_USB_INT_EN; /* offset 0x02 */
__IO uint8_t R8_USB_DEV_AD; /* offset 0x03 */
__IO uint8_t __DUMMY0;
__IO uint8_t R8_USB_MIS_ST; /* offset 0x05 */
__IO uint8_t R8_USB_INT_FG; /* offset 0x06 */
__IO uint8_t R8_USB_INT_ST; /* offset 0x07 */
__IO uint8_t R8_USB_RX_LEN; /* offset 0x08 */
__IO uint8_t __DUMMY1[4];
__IO uint8_t R8_UH_EP_MOD; /* offset 0x0D */
__IO uint8_t __DUMMY2[10];
__IO uint16_t R16_UH_RX_DMA; /* offset 0x18 */
__IO uint8_t __DUMMY3[2];
__IO uint16_t R16_UH_TX_DMA; /* offset 0x1C */
__IO uint8_t __DUMMY4[8];
__IO uint8_t R8_UH_SETUP; /* offset 0x26 */
__IO uint8_t __DUMMY5[1];
__IO uint8_t R8_UH_EP_PID; /* offset 0x28 */
__IO uint8_t __DUMMY6[1];
__IO uint8_t R8_UH_RX_CTRL; /* offset 0x2A */
__IO uint8_t __DUMMY7[1];
__IO uint8_t R8_UH_TX_LEN; /* offset 0x2C */
__IO uint8_t __DUMMY8[1];
__IO uint8_t R8_UH_TX_CTRL; /* offset 0x2E */
__IO uint8_t __DUMMY9[9];
__IO uint8_t R8_USB_TYPE_C_CTRL; /* offset 0x38 */
} hc32f10x_usbhd_reg_t;
struct hc32f10x_usbhd_urb_t {
implement(vk_usbh_hcd_urb_t)
vsf_dlist_node_t urb_node;
enum {
HC32F10X_USBHD_URB_STATE_START_SUBMITTING,
HC32F10X_USBHD_URB_STATE_SETUP,
HC32F10X_USBHD_URB_STATE_SETUP_DATA,
HC32F10X_USBHD_URB_STATE_SETUP_STATUS,
HC32F10X_USBHD_URB_STATE_TO_FREE,
} state;
};
typedef struct hc32f10x_usbhd_urb_t hc32f10x_usbhd_urb_t;
enum {
VSF_HC32F10X_HCD_EVT_CONN_CHANGE= VSF_EVT_USER + 0,
VSF_HC32F10X_HCD_EVT_TRANSFER = VSF_EVT_USER + 1,
};
enum {
USB_ERR_HCD_NAK = VSF_ERR_NOT_READY + 1,
};
/*============================ PROTOTYPES ====================================*/
static vsf_err_t __hc32f10x_usbhd_hcd_init_evthandler(vsf_eda_t *eda, vsf_evt_t evt, vk_usbh_hcd_t *hcd);
static vsf_err_t __hc32f10x_usbhd_hcd_fini(vk_usbh_hcd_t *hcd);
static vsf_err_t __hc32f10x_usbhd_hcd_suspend(vk_usbh_hcd_t *hcd);
static vsf_err_t __hc32f10x_usbhd_hcd_resume(vk_usbh_hcd_t *hcd);
static vk_usbh_hcd_urb_t * __hc32f10x_usbhd_hcd_alloc_urb(vk_usbh_hcd_t *hcd);
static void __hc32f10x_usbhd_hcd_free_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb);
static vsf_err_t __hc32f10x_usbhd_hcd_submit_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb);
static vsf_err_t __hc32f10x_usbhd_hcd_relink_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb);
static vsf_err_t __hc32f10x_usbhd_hcd_reset_dev(vk_usbh_hcd_t *hcd, vk_usbh_hcd_dev_t *dev);
static bool __hc32f10x_usbhd_hcd_is_dev_reset(vk_usbh_hcd_t *hcd, vk_usbh_hcd_dev_t *dev);
/*============================ GLOBAL VARIABLES ==============================*/
const vk_usbh_hcd_drv_t hc32f10x_usbhd_hcd_drv = {
.init_evthandler = __hc32f10x_usbhd_hcd_init_evthandler,
.fini = __hc32f10x_usbhd_hcd_fini,
.suspend = __hc32f10x_usbhd_hcd_suspend,
.resume = __hc32f10x_usbhd_hcd_resume,
.alloc_urb = __hc32f10x_usbhd_hcd_alloc_urb,
.free_urb = __hc32f10x_usbhd_hcd_free_urb,
.submit_urb = __hc32f10x_usbhd_hcd_submit_urb,
.relink_urb = __hc32f10x_usbhd_hcd_relink_urb,
.reset_dev = __hc32f10x_usbhd_hcd_reset_dev,
.is_dev_reset = __hc32f10x_usbhd_hcd_is_dev_reset,
};
#ifdef USB_HDC_IRQHandler
static hc32f10x_usbhd_hcd_t *__hc32f10x_usbhd_hcd;
#endif
/*============================ LOCAL VARIABLES ===============================*/
/*============================ IMPLEMENTATION ================================*/
#ifndef USB_HDC_REG_BASE
static hc32f10x_usbhd_reg_t * __hc32f10x_usbhd_get_reg(hc32f10x_usbhd_const_t *param)
{
return (hc32f10x_usbhd_reg_t *)param->reg;
}
#endif
#ifndef USB_HDC_IRQN
static IRQn_Type __hc32f10x_usbhd_get_irqn(hc32f10x_usbhd_const_t *param)
{
return param->irq;
}
#endif
static vsf_err_t __hc32f10x_usbhd_hcd_urb_fsm(hc32f10x_usbhd_hcd_t *usbhd_hcd, hc32f10x_usbhd_urb_t *urb)
{
hc32f10x_usbhd_reg_t *reg = __hc32f10x_usbhd_get_reg(usbhd_hcd->param);
vk_usbh_pipe_t pipe = urb->pipe;
uint_fast8_t is_in = pipe.dir_in1out0;
uint_fast8_t pid = is_in ? USB_PID_IN : USB_PID_OUT;
uint8_t *buffer;
uint_fast8_t len, rxlen;
buffer = usbhd_hcd->cur_buffer;
len = urb->transfer_length;
switch (urb->state) {
case HC32F10X_USBHD_URB_STATE_START_SUBMITTING:
buffer = usbhd_hcd->cur_buffer = urb->buffer;
urb->actual_length = 0;
urb->status = VSF_ERR_NONE;
reg->R8_USB_DEV_AD = pipe.address;
if (0 == pipe.endpoint) {
is_in = false;
pid = USB_PID_SETUP;
len = sizeof(urb->setup_packet);
buffer = (uint8_t *)&urb->setup_packet;
reg->R8_UH_TX_CTRL = 0;
urb->state = HC32F10X_USBHD_URB_STATE_SETUP;
break;
}
// fall through
case HC32F10X_USBHD_URB_STATE_SETUP:
setup_data:
if ((0 == pipe.endpoint) && (0 == len)) {
goto setup_status;
}
if (urb->buffer == usbhd_hcd->cur_buffer) {
if (0 == pipe.endpoint) {
// EP0 start from DATA1 every time
reg->R8_UH_TX_CTRL = reg->R8_UH_RX_CTRL = RB_UH_R_TOG | RB_UH_R_AUTO_TOG | RB_UH_T_TOG | RB_UH_T_AUTO_TOG;
} else {
uint_fast8_t ep_mask = 1 << pipe.endpoint;
if (pipe.dir_in1out0) {
reg->R8_UH_RX_CTRL = RB_UH_R_AUTO_TOG | ((usbhd_hcd->dev->toggle[1] & ep_mask) ? RB_UH_R_TOG : 0);
} else {
reg->R8_UH_TX_CTRL = RB_UH_T_AUTO_TOG | ((usbhd_hcd->dev->toggle[0] & ep_mask) ? RB_UH_T_TOG : 0);
}
}
}
urb->state = HC32F10X_USBHD_URB_STATE_SETUP_DATA;
if (len > pipe.size) {
len = pipe.size;
}
usbhd_hcd->cur_size = len;
break;
case HC32F10X_USBHD_URB_STATE_SETUP_DATA:
if (!(reg->R8_USB_INT_ST & RB_UIS_TOG_OK)) {
switch (reg->R8_USB_INT_ST & MASK_UIS_H_RES) {
case 0x00:
case (USB_PID_STALL & 0x0F):
return VSF_ERR_FAIL;
case (USB_PID_NAK & 0x0F):
if (pipe.endpoint != 0) {
return USB_ERR_HCD_NAK;
}
goto setup_data;
break;
default:
VSF_USB_ASSERT(false);
}
}
if (is_in) {
rxlen = reg->R8_USB_RX_LEN;
if (rxlen > usbhd_hcd->cur_size) {
VSF_USB_ASSERT(false);
// TODO: process overflow
rxlen = urb->transfer_length;
}
memcpy(usbhd_hcd->cur_buffer, usbhd_hcd->ep_buffer, rxlen);
usbhd_hcd->cur_buffer = (uint8_t *)usbhd_hcd->cur_buffer + rxlen;
urb->transfer_length -= rxlen;
urb->actual_length += rxlen;
} else {
usbhd_hcd->cur_buffer = (uint8_t *)usbhd_hcd->cur_buffer + usbhd_hcd->cur_size;
urb->transfer_length -= usbhd_hcd->cur_size;
urb->actual_length += usbhd_hcd->cur_size;
}
len = urb->transfer_length;
setup_status:
if ((len > 0) && (!is_in || (rxlen >= pipe.size))) {
goto setup_data;
} else if (!is_in && (urb->transfer_flags & URB_ZERO_PACKET)) {
urb->transfer_flags &= ~URB_ZERO_PACKET;
break;
} else if (0 == pipe.endpoint) {
pid = is_in ? USB_PID_OUT : USB_PID_IN;
reg->R8_UH_TX_CTRL = reg->R8_UH_RX_CTRL = RB_UH_R_TOG | RB_UH_T_TOG;
len = 0;
is_in = false;
urb->state = HC32F10X_USBHD_URB_STATE_SETUP_STATUS;
break;
}
// fall through
case HC32F10X_USBHD_URB_STATE_SETUP_STATUS:
if (pipe.endpoint != 0) {
uint_fast8_t ep_mask = 1 << pipe.endpoint;
if (pipe.dir_in1out0) {
usbhd_hcd->dev->toggle[1] &= ~ep_mask;
usbhd_hcd->dev->toggle[1] |= (reg->R8_UH_RX_CTRL & 0x80) ? ep_mask : 0;
} else {
usbhd_hcd->dev->toggle[0] &= ~ep_mask;
usbhd_hcd->dev->toggle[0] |= (reg->R8_UH_TX_CTRL & 0x80) ? ep_mask : 0;
}
}
return VSF_ERR_NONE;
}
if (is_in) {
} else {
memcpy(usbhd_hcd->ep_buffer, buffer, len);
reg->R8_UH_TX_LEN = len;
}
reg->R8_UH_EP_PID = (pid << 4) | pipe.endpoint;
reg->R8_USB_INT_FG = RB_UIF_TRANSFER;
usbhd_hcd->is_transacting = true;
return VSF_ERR_NOT_READY;
}
static void __hc32f10x_usbhd_hcd_execute_urb(hc32f10x_usbhd_hcd_t *usbhd, hc32f10x_usbhd_urb_t *urb)
{
urb->state = HC32F10X_USBHD_URB_STATE_START_SUBMITTING;
__hc32f10x_usbhd_hcd_urb_fsm(usbhd, urb);
}
static void __hc32f10x_usbhd_hcd_evthandler(vsf_eda_t *eda, vsf_evt_t evt)
{
hc32f10x_usbhd_hcd_t *usbhd_hcd = container_of(eda, hc32f10x_usbhd_hcd_t, teda);
hc32f10x_usbhd_reg_t *reg = __hc32f10x_usbhd_get_reg(usbhd_hcd->param);
switch (evt) {
case VSF_EVT_INIT:
usbhd_hcd->state = HC32F10X_HCD_STATE_WAIT_CONNECT;
break;
case VSF_EVT_TIMER:
switch (usbhd_hcd->state) {
case HC32F10X_HCD_STATE_WAIT_RESET:
reg->R8_UHOST_CTRL &= ~RB_UH_BUS_RESET;
usbhd_hcd->state = HC32F10X_HCD_STATE_WAIT_RESET_CLEAR;
vsf_teda_set_timer_ms(20);
break;
case HC32F10X_HCD_STATE_WAIT_RESET_CLEAR:
reg->R8_UHOST_CTRL |= RB_UH_PORT_EN;
usbhd_hcd->state = HC32F10X_HCD_STATE_CONNECTED;
usbhd_hcd->dev = vk_usbh_new_device((vk_usbh_t *)usbhd_hcd->hcd,
reg->R8_USB_MIS_ST & RB_UMS_DM_LEVEL ? USB_SPEED_LOW : USB_SPEED_FULL,
NULL, 0);
reg->R8_USB_INT_EN = RB_UIE_DETECT;
break;
}
break;
case VSF_EVT_MESSAGE:
vsf_usbh_free(vsf_eda_get_cur_msg());
break;
case VSF_HC32F10X_HCD_EVT_CONN_CHANGE: {
bool is_connected = reg->R8_USB_MIS_ST & RB_UMS_DEV_ATTACH;
if ((HC32F10X_HCD_STATE_WAIT_CONNECT == usbhd_hcd->state) && is_connected) {
reg->R8_UHOST_CTRL &= ~RB_UH_PORT_EN;
if (reg->R8_USB_MIS_ST & RB_UMS_DM_LEVEL) {
// LowSpeed
reg->R8_USB_CTRL |= RB_UC_LOW_SPEED;
reg->R8_UHOST_CTRL |= RB_UH_LOW_SPEED;
} else {
// FullSpeed
reg->R8_USB_CTRL &= ~RB_UC_LOW_SPEED;
reg->R8_UHOST_CTRL &= ~RB_UH_LOW_SPEED;
}
reg->R8_UHOST_CTRL |= RB_UH_BUS_RESET;
usbhd_hcd->state = HC32F10X_HCD_STATE_WAIT_RESET;
vsf_teda_set_timer_ms(20);
} else if ((HC32F10X_HCD_STATE_CONNECTED == usbhd_hcd->state) && !is_connected) {
vk_usbh_disconnect_device((vk_usbh_t *)usbhd_hcd->hcd, usbhd_hcd->dev);
usbhd_hcd->dev = NULL;
usbhd_hcd->state = HC32F10X_HCD_STATE_WAIT_CONNECT;
reg->R8_USB_INT_EN = RB_UIE_DETECT;
} else {
// VSF_HC32F10X_HCD_EVT_CONN_CHANGE will not be triggered on startup
// but will be triggered later(when the first transaction done)
reg->R8_USB_INT_EN |= RB_UIE_DETECT;
}
}
break;
case VSF_HC32F10X_HCD_EVT_TRANSFER: {
hc32f10x_usbhd_urb_t *urb = usbhd_hcd->urb_cur;
if (HC32F10X_USBHD_URB_STATE_TO_FREE == urb->state) {
vsf_dlist_peek_next(hc32f10x_usbhd_urb_t, urb_node, urb, usbhd_hcd->urb_cur);
vsf_dlist_remove(hc32f10x_usbhd_urb_t, urb_node, &usbhd_hcd->urb_list, urb);
vsf_usbh_free(urb);
} else {
vsf_err_t err = __hc32f10x_usbhd_hcd_urb_fsm(usbhd_hcd, urb);
if (VSF_ERR_NOT_READY == err) {
break;
} else if (USB_ERR_HCD_NAK == err) {
vsf_dlist_peek_next(hc32f10x_usbhd_urb_t, urb_node, urb, usbhd_hcd->urb_cur);
} else {
urb->status = err;
vsf_dlist_peek_next(hc32f10x_usbhd_urb_t, urb_node, urb, usbhd_hcd->urb_cur);
vsf_dlist_remove(hc32f10x_usbhd_urb_t, urb_node, &usbhd_hcd->urb_list, urb);
vk_usbh_hcd_urb_complete(urb);
}
}
if (usbhd_hcd->urb_cur != NULL) {
__hc32f10x_usbhd_hcd_execute_urb(usbhd_hcd, (hc32f10x_usbhd_urb_t *)usbhd_hcd->urb_cur);
} else {
reg->R8_USB_INT_EN &= ~RB_UIE_TRANSFER;
}
}
break;
}
}
static vsf_err_t __hc32f10x_usbhd_hcd_init_evthandler(vsf_eda_t *eda, vsf_evt_t evt, vk_usbh_hcd_t *hcd)
{
hc32f10x_usbhd_hcd_t *usbhd_hcd = (hc32f10x_usbhd_hcd_t *)hcd->param;
hc32f10x_usbhd_reg_t *reg = __hc32f10x_usbhd_get_reg(usbhd_hcd);
switch (evt) {
case VSF_EVT_INIT:
__hc32f10x_usbhd_hcd= usbhd_hcd;
usbhd_hcd->hcd = hcd;
EXTEN->EXTEN_CTR |= EXTEN_USBHD_IO_EN;
switch (CH32F10X_SYS_FREQ_HZ) {
case 72UL * 1000 * 1000:
RCC->CFGR0 &= ~RCC_USBPRE;
break;
case 48UL * 1000 * 1000:
RCC->CFGR0 |= RCC_USBPRE;
break;
default:
VSF_HAL_ASSERT(false);
return VSF_ERR_INVALID_PARAMETER;
}
RCC->AHBPCENR |= RCC_USBHD;
reg->R8_USB_CTRL = RB_UC_HOST_MODE;
reg->R8_UHOST_CTRL = 0;
reg->R8_UH_EP_MOD = RB_UH_EP_TX_EN | RB_UH_EP_RX_EN;
reg->R16_UH_RX_DMA = (uint16_t)&usbhd_hcd->ep_buffer;
reg->R16_UH_TX_DMA = (uint16_t)&usbhd_hcd->ep_buffer;
reg->R8_UH_RX_CTRL = 0x00;
reg->R8_UH_TX_CTRL = 0x00;
reg->R8_USB_CTRL = RB_UC_HOST_MODE | RB_UC_INT_BUSY | RB_UC_DMA_EN;
reg->R8_UH_SETUP = RB_UH_SOF_EN;
reg->R8_USB_INT_FG = 0xFF;
reg->R8_USB_INT_EN = 0;
// TODO: enable nvic
// priotiry of hw interrupt MUST be >= priority of current task
NVIC_SetPriority(__hc32f10x_usbhd_get_irqn(usbd), usbhd_hcd->priority);
NVIC_EnableIRQ(__hc32f10x_usbhd_get_irqn(usbd));
usbhd_hcd->teda.fn.evthandler = __hc32f10x_usbhd_hcd_evthandler;
#if VSF_KERNEL_CFG_EDA_SUPPORT_ON_TERMINATE == ENABLED
usbhd_hcd->teda.on_terminate = NULL;
#endif
vsf_teda_init(&usbhd_hcd->teda);
// is device is already connected, send event
if (reg->R8_USB_MIS_ST & RB_UMS_DEV_ATTACH) {
vsf_eda_post_evt(&usbhd_hcd->teda.use_as__vsf_eda_t, VSF_HC32F10X_HCD_EVT_CONN_CHANGE);
} else {
reg->R8_USB_INT_EN = RB_UIE_DETECT;
}
return VSF_ERR_NONE;
// break;
}
return VSF_ERR_NOT_READY;
}
static vsf_err_t __hc32f10x_usbhd_hcd_fini(vk_usbh_hcd_t *hcd)
{
return VSF_ERR_NONE;
}
static vsf_err_t __hc32f10x_usbhd_hcd_suspend(vk_usbh_hcd_t *hcd)
{
return VSF_ERR_NONE;
}
static vsf_err_t __hc32f10x_usbhd_hcd_resume(vk_usbh_hcd_t *hcd)
{
return VSF_ERR_NONE;
}
static vk_usbh_hcd_urb_t * __hc32f10x_usbhd_hcd_alloc_urb(vk_usbh_hcd_t *hcd)
{
vk_usbh_hcd_urb_t *usbhd_urb = vsf_usbh_malloc(sizeof(hc32f10x_usbhd_urb_t));
if (usbhd_urb != NULL) {
memset(usbhd_urb, 0, sizeof(hc32f10x_usbhd_urb_t));
}
return usbhd_urb;
}
static void __hc32f10x_usbhd_hcd_free_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb)
{
hc32f10x_usbhd_hcd_t *usbhd_hcd = (hc32f10x_usbhd_hcd_t *)hcd->param;
hc32f10x_usbhd_reg_t *reg = __hc32f10x_usbhd_get_reg(usbhd_hcd);
uint_fast8_t orig = reg->R8_USB_INT_EN & RB_UIE_TRANSFER;
reg->R8_USB_INT_EN &= ~RB_UIE_TRANSFER;
hc32f10x_usbhd_urb_t *usbhd_urb = (hc32f10x_usbhd_urb_t *)usbhd_hcd->urb_cur;
if (&usbhd_urb->use_as__vk_usbh_hcd_urb_t == urb) {
usbhd_urb->state = HC32F10X_USBHD_URB_STATE_TO_FREE;
} else {
vsf_dlist_remove(hc32f10x_usbhd_urb_t, urb_node, &usbhd_hcd->urb_list, (hc32f10x_usbhd_urb_t *)urb);
vsf_eda_post_msg(&usbhd_hcd->teda.use_as__vsf_eda_t, urb);
}
reg->R8_USB_INT_EN |= orig;
}
static vsf_err_t __hc32f10x_usbhd_hcd_submit_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb)
{
hc32f10x_usbhd_hcd_t *usbhd_hcd = (hc32f10x_usbhd_hcd_t *)hcd->param;
hc32f10x_usbhd_reg_t *reg = __hc32f10x_usbhd_get_reg(usbhd_hcd);
uint_fast8_t orig = reg->R8_USB_INT_EN & RB_UIE_TRANSFER;
reg->R8_USB_INT_EN &= ~RB_UIE_TRANSFER;
vsf_dlist_add_to_tail(hc32f10x_usbhd_urb_t, urb_node, &usbhd_hcd->urb_list, (hc32f10x_usbhd_urb_t *)urb);
reg->R8_USB_INT_EN |= RB_UIE_TRANSFER;
if (!orig) {
vsf_dlist_peek_head(hc32f10x_usbhd_urb_t, urb_node, &usbhd_hcd->urb_list, usbhd_hcd->urb_cur);
__hc32f10x_usbhd_hcd_execute_urb(usbhd_hcd, (hc32f10x_usbhd_urb_t *)usbhd_hcd->urb_cur);
}
return VSF_ERR_NONE;
}
static vsf_err_t __hc32f10x_usbhd_hcd_relink_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb)
{
return __hc32f10x_usbhd_hcd_submit_urb(hcd, urb);
}
static vsf_err_t __hc32f10x_usbhd_hcd_reset_dev(vk_usbh_hcd_t *hcd, vk_usbh_hcd_dev_t *dev)
{
// TODO:
return VSF_ERR_NONE;
}
static bool __hc32f10x_usbhd_hcd_is_dev_reset(vk_usbh_hcd_t *hcd, vk_usbh_hcd_dev_t *dev)
{
// TODO:
return false;
}
static void __hc32f10x_usbhd_hcd_isr(void *param)
{
hc32f10x_usbhd_hcd_t *usbhd_hcd = param;
hc32f10x_usbhd_reg_t *reg = __hc32f10x_usbhd_get_reg(usbhd_hcd);
uint_fast8_t status = reg->R8_USB_INT_EN & reg->R8_USB_INT_FG;
if (status & RB_UIF_DETECT) {
reg->R8_USB_INT_FG = RB_UIF_DETECT;
reg->R8_USB_INT_EN &= ~RB_UIE_DETECT;
vsf_eda_post_evt(&usbhd_hcd->teda.use_as__vsf_eda_t, VSF_HC32F10X_HCD_EVT_CONN_CHANGE);
}
if (status & RB_UIF_TRANSFER) {
// seems RB_UIF_TRANSFER will be triggered twice in the first run
// is_transacting is used to skip unwanted interrupt
if (usbhd_hcd->is_transacting) {
usbhd_hcd->is_transacting = false;
vsf_eda_post_evt(&usbhd_hcd->teda.use_as__vsf_eda_t, VSF_HC32F10X_HCD_EVT_TRANSFER);
}
}
if (status & RB_UIF_HST_SOF) {
VSF_USB_ASSERT(NULL == usbhd_hcd->urb_cur);
reg->R8_USB_INT_EN |= RB_UIE_TRANSFER;
vsf_dlist_peek_head(hc32f10x_usbhd_urb_t, urb_node, &usbhd_hcd->urb_list, usbhd_hcd->urb_cur);
__hc32f10x_usbhd_hcd_execute_urb(usbhd_hcd, (hc32f10x_usbhd_urb_t *)usbhd_hcd->urb_cur);
}
}
#ifdef USB_HDC_IRQHandler
ROOT void USB_HDC_IRQHandler(void)
{
__hc32f10x_usbhd_hcd_isr(__hc32f10x_usbhd_hcd);
}
#endif
#endif // VSF_USE_USB_HOST
|
a4d8a68f041c2108f71289191766bd79c6ada610
|
fff6d13af91db925a94b3e3474108fafd519bba0
|
/src/Gui/jkGUIForce.c
|
a005b380347842f4f0353f8b9de11b4a90b1ad20
|
[
"LicenseRef-scancode-warranty-disclaimer"
] |
no_license
|
shinyquagsire23/OpenJKDF2
|
94f1364628924ac944466107606b91c6faeec3df
|
b79b8c210878b6f276ed3d1a5dad91d9219e6ce1
|
refs/heads/master
| 2023-07-08T16:41:38.986577
| 2023-06-28T08:47:39
| 2023-06-28T08:47:39
| 139,542,792
| 381
| 34
|
NOASSERTION
| 2023-06-28T08:47:40
| 2018-07-03T07:09:45
|
C
|
UTF-8
|
C
| false
| false
| 32,266
|
c
|
jkGUIForce.c
|
#include "jkGUIForce.h"
#include "General/Darray.h"
#include "General/stdBitmap.h"
#include "General/stdString.h"
#include "General/stdFont.h"
#include "Engine/rdMaterial.h" // TODO move stdVBuffer
#include "stdPlatform.h"
#include "jk.h"
#include "Gui/jkGUIRend.h"
#include "Gui/jkGUI.h"
#include "Gui/jkGUIDialog.h"
#include "World/jkPlayer.h"
#include "Gameplay/sithInventory.h"
#include "Gameplay/sithPlayer.h"
#include "Win95/stdDisplay.h"
#include "Win95/Windows.h"
#include "Main/jkStrings.h"
#include "World/jkPlayer.h"
static const char* jkGuiForce_bitmaps[17] = {
"foAbsorb.bm",
"foBlinding.bm",
"foDeadlySight.bm",
"foDestruction.bm",
"foGrip.bm",
"foHealth.bm",
"foJump.bm",
"foPersuasion.bm",
"foProtection.bm",
"foPull.bm",
"foSeeing.bm",
"foSpeed.bm",
"foThrow.bm",
"foThunderBolt.bm",
"foStars.bm",
"forceMeter.bm",
"forceMeterBack.bm"
};
static const char* jkGuiForce_bitmapsMots[19] = {
"foAbsorb.bm",
"foBlinding.bm",
"foChainLight.bm",
"foDeadlySight.bm",
"foDefense.bm",
"foDestruct.bm",
"foFarSight.bm",
"foGrip.bm",
"foHealth.bm",
"foJump.bm",
"foPersuasion.bm",
"foProjection.bm",
"foProtection.bm",
"foPull.bm",
"foPush.bm",
"foSaberThrow.bm",
"foSeeing.bm",
"foSpeed.bm",
"foStars.bm",
};
#define IDX_FOSTARS (Main_bMotsCompat ? 18 : 14)
#define EIDX_NAMETEXT (1)
#define EIDX_FLAVORTEXT (2)
#define EIDX_START_FP (3)
#define EIDX_END_FP_CLICKABLE (Main_bMotsCompat ? 20 : 15)
#define EIDX_END_FP (Main_bMotsCompat ? 20+1 : 16+1)
#define EIDX_MOTS_DEFENSE (20)
#define EIDX_RESET (Main_bMotsCompat ? 26 : 18)
#define EIDX_QUIT (Main_bMotsCompat ? 27 : 19)
#define EIDX_ALIGN_SLIDER (Main_bMotsCompat ? 30 : 23)
#define EIDX_OK_BUTTON (Main_bMotsCompat ? EIDX_END_FP + 4 : EIDX_END_FP)
#define EIDX_RESET_BUTTON (EIDX_OK_BUTTON + 1)
#define EIDX_QUIT_BUTTON (EIDX_RESET_BUTTON + 1)
static int jkGuiForce_alignment;
static float jkGuiForce_flt_556674;
static int jkGuiForce_numSpendStars;
static int jkGuiForce_bCanSpendStars;
static float jkGuiForce_isMulti;
static stdBitmap* jkGuiForce_aBitmaps[19];
static int jkGuiForce_sliderBitmapIndices[2] = {16, 15};
static wchar_t jkGuiForce_waTmp[400];
jkGuiElement jkGuiForce_buttonsMots[31] = {
/*0*/ { ELEMENT_TEXT, 0, 2, NULL,
3, { 160, 350, 320, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*1*/ { ELEMENT_TEXT, 0, 2, NULL,
3, { 10, 15, 620, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*2*/ { ELEMENT_TEXT, 0, 2, NULL,
3, { 10, 46, 620, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*3*/ { ELEMENT_PICBUTTON, SITHBIN_F_JUMP, 0, NULL,
9, { 146, 120, -1, -1 }, 1, 0, "GUI_HINT_JUMP", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*4*/ { ELEMENT_PICBUTTON, SITHBIN_F_PROJECT, 0, NULL,
11, { 146, 150, -1, -1 }, 1, 0, "GUI_HINT_PROJECTION", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*5*/ { ELEMENT_PICBUTTON, SITHBIN_F_SEEING, 0, NULL,
16, { 146, 180, -1, -1 }, 1, 0, "GUI_HINT_SEEING", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*6*/ { ELEMENT_PICBUTTON, SITHBIN_F_SPEED, 0, NULL,
17, { 146, 210, -1, -1 }, 1, 0, "GUI_HINT_SPEED", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*7*/ { ELEMENT_PICBUTTON, SITHBIN_F_PUSH, 0, NULL,
14, { 146, 240, -1, -1 }, 1, 0, "GUI_HINT_PUSH", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*8*/ { ELEMENT_PICBUTTON, SITHBIN_F_PULL, 0, NULL,
13, { 296, 120, -1, -1 }, 1, 0, "GUI_HINT_PULL", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*9*/ { ELEMENT_PICBUTTON, SITHBIN_F_SABERTHROW, 0, NULL,
15, { 296, 150, -1, -1 }, 1, 0, "GUI_HINT_SABERTHROW", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*10*/ { ELEMENT_PICBUTTON, SITHBIN_F_GRIP, 0, NULL,
7, { 296, 180, -1, -1 }, 1, 0, "GUI_HINT_GRIP", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*11*/ { ELEMENT_PICBUTTON, SITHBIN_F_FARSIGHT, 0, NULL,
6, { 296, 210, -1, -1 }, 1, 0, "GUI_HINT_FARSIGHT", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*12*/ { ELEMENT_PICBUTTON, SITHBIN_F_PERSUASION, 0, NULL,
10, { 446, 120, -1, -1 }, 1, 0, "GUI_HINT_PERSUASION", NULL, &jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*13*/ { ELEMENT_PICBUTTON, SITHBIN_F_HEALING, 0, NULL,
8, { 446, 150, -1, -1 }, 1, 0, "GUI_HINT_HEALING", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*14*/ { ELEMENT_PICBUTTON, SITHBIN_F_BLINDING, 0, NULL,
1, { 446, 180, -1, -1 }, 1, 0, "GUI_HINT_BLINDING", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*15*/ { ELEMENT_PICBUTTON, SITHBIN_F_CHAINLIGHT, 0, NULL,
2, { 446, 210, -1, -1 }, 1, 0, "GUI_HINT_CHAINLIGHT", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*16*/ { ELEMENT_PICBUTTON, SITHBIN_F_ABSORB, 0, NULL,
0, { 596, 120, -1, -1 }, 1, 0, "GUI_HINT_ABSORB", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*17*/ { ELEMENT_PICBUTTON, SITHBIN_F_DESTRUCTION, 0, NULL,
5, { 596, 150, -1, -1 }, 1, 0, "GUI_HINT_DESTRUCTION", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*18*/ { ELEMENT_PICBUTTON, SITHBIN_F_PROTECTION, 0, NULL,
12, { 596, 180, -1, -1 }, 1, 0, "GUI_HINT_PROTECTION", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*19*/ { ELEMENT_PICBUTTON, SITHBIN_F_DEADLYSIGHT, 0, NULL,
3, { 596, 210, -1, -1 }, 1, 0, "GUI_HINT_DEADLYSIGHT", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
/*20*/ { ELEMENT_PICBUTTON, SITHBIN_F_DEFENSE, 0, NULL,
4, { 308, 300, -1, -1 }, 1, 0, "GUI_HINT_DEFENSE", NULL, jkGuiForce_ButtonClick, NULL, {0}, 0 },
// `Choose <num>:` text
/*21*/ { ELEMENT_TEXT, 0, 2, &jkGuiForce_waTmp[0],
3, { 20, 90, 150, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*22*/ { ELEMENT_TEXT, 0, 2, &jkGuiForce_waTmp[100],
3, { 170, 90, 150, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*23*/ { ELEMENT_TEXT, 0, 2, &jkGuiForce_waTmp[200],
3, { 320, 90, 150, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*24*/ { ELEMENT_TEXT, 0, 2, &jkGuiForce_waTmp[300],
3, { 470, 90, 150, 30 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*25*/ { ELEMENT_TEXTBUTTON, 1, 2, "GUI_OK",
3, { 550, 440, 80, 40 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*26*/ { ELEMENT_TEXTBUTTON, 0, 2, "GUI_RESET",
3, { 270, 440, 100, 30 }, 1, 0, NULL, NULL, &jkGuiForce_ResetClick, NULL, {0}, 0 },
/*27*/ { ELEMENT_TEXTBUTTON, /*12345*/-1, 2, "GUI_QUIT",
3, { 0, 440, 100, 40 }, 1, 0, NULL, NULL, NULL, NULL, {0}, 0 },
/*28*/ { ELEMENT_CUSTOM, 0, 0, NULL,
0, { 0, 390, 640, 30 }, 1, 0, NULL, &jkGuiForce_ForceStarsDraw, NULL, NULL, {0}, 0 },
/*29*/ { ELEMENT_END, 0, 0, NULL,
0, { 0, 0, 0, 0 }, 0, 0, NULL, NULL, NULL, NULL, {0}, 0 },
// HACK: Just make an unused slider
/*30*/ { ELEMENT_SLIDER, 0, 0, .origExtraInt = 200,
100, {150, 418, 340, 40}, 1, 0, NULL, 0, 0, &jkGuiForce_sliderBitmapIndices, {0}, 0},
};
static jkGuiElement jkGuiForce_buttons[25] = {
/*0*/ { ELEMENT_TEXT, 0, 2, NULL,
3, {160, 320, 320, 30}, 1, 0, NULL, 0, 0, 0, {0}, 0},
/*1*/ { ELEMENT_TEXT, 0, 2, NULL,
3, {10, 15, 620, 30}, 1, 0, NULL, 0, 0, 0, {0}, 0},
/*2*/ { ELEMENT_TEXT, 0, 2, NULL,
3, {10, 46, 620, 30}, 1, 0, NULL, 0, 0, 0, {0}, 0},
/*3*/ { ELEMENT_PICBUTTON, SITHBIN_F_ABSORB, 0, NULL,
0, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_ABSORB", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*4*/ { ELEMENT_PICBUTTON, SITHBIN_F_BLINDING, 0, NULL,
1, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_BLINDING", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*5*/ { ELEMENT_PICBUTTON, SITHBIN_F_DESTRUCTION, 0, NULL,
3, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_DESTRUCTION", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*6*/ { ELEMENT_PICBUTTON, SITHBIN_F_GRIP, 0, NULL,
4, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_GRIP", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*7*/ { ELEMENT_PICBUTTON, SITHBIN_F_HEALING, 0, NULL,
5, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_HEALING", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*8*/ { ELEMENT_PICBUTTON, SITHBIN_F_JUMP, 0, NULL,
6, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_JUMP", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*9*/ { ELEMENT_PICBUTTON, SITHBIN_F_PERSUASION, 0, NULL,
7, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_PERSUASION", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*10*/ { ELEMENT_PICBUTTON, SITHBIN_F_PULL, 0, NULL,
9, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_PULL", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*11*/ { ELEMENT_PICBUTTON, SITHBIN_F_SEEING, 0, NULL,
10, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_SEEING", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*12*/ { ELEMENT_PICBUTTON, SITHBIN_F_SPEED, 0, NULL,
11, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_SPEED", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*13*/ { ELEMENT_PICBUTTON, SITHBIN_F_THROW, 0, NULL,
12, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_THROW", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*14*/ { ELEMENT_PICBUTTON, SITHBIN_F_LIGHTNING, 0, NULL,
13, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_LIGHTNING", 0, jkGuiForce_ButtonClick, 0, {0}, 0},
/*15*/ { ELEMENT_PICBUTTON, SITHBIN_F_PROTECTION, 0, NULL,
8, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_PROTECTION", 0, jkGuiForce_ExtraClick, 0, {0}, 0},
/*16*/ { ELEMENT_PICBUTTON, SITHBIN_F_DEADLYSIGHT, 0, NULL,
2, {-1, -1, -1, -1}, 1, 0, "GUI_HINT_DEADLYSIGHT", 0, jkGuiForce_ExtraClick, 0, {0}, 0},
/*17*/ { ELEMENT_TEXTBUTTON, 1, 2, "GUI_OK",
3, {550, 420, 80, 40}, 1, 0, NULL, 0, 0, 0, {0}, 0},
/*18*/ { ELEMENT_TEXTBUTTON, 0, 2, "GUI_RESET",
3, {270, 350, 100, 30}, 1, 0, NULL, 0, jkGuiForce_ResetClick, 0, {0}, 0},
/*19*/ { ELEMENT_TEXTBUTTON, -1, 2, "GUI_QUIT",
3, { 0, 420, 100, 40}, 1, 0, NULL, 0, 0, 0, {0}, 0},
/*20*/ { ELEMENT_CUSTOM, 0, 0, NULL,
0, { 0, 390, 640, 30}, 1, 0, NULL, jkGuiForce_ForceStarsDraw, 0, 0, {0}, 0},
/*21*/ { ELEMENT_CUSTOM, 0, 0, NULL,
0, {320, 418, 170, 40}, 1, 0, "GUI_DARKSIDE", jkGuiForce_DarkLightHoverDraw, 0, 0, {0}, 0},
/*22*/ { ELEMENT_CUSTOM, 0, 0, NULL,
0, {150, 418, 170, 40}, 1, 0, "GUI_LIGHTSIDE", jkGuiForce_DarkLightHoverDraw, 0, 0, {0}, 0},
/*23*/ { ELEMENT_SLIDER, 0, 0, .origExtraInt = 200,
100, {150, 418, 340, 40}, 1, 0, NULL, 0, 0, &jkGuiForce_sliderBitmapIndices, {0}, 0},
/*24*/ { ELEMENT_END, 0, 0, NULL,
0, {0}, 0, 0, NULL, 0, 0, 0, {0}, 0}
};
static jkGuiMenu jkGuiForce_menu =
{ jkGuiForce_buttons, 0, 0xe1, 0xff, 0x0f, 0, 0, jkGuiForce_aBitmaps, jkGui_stdFonts, 0, jkGuiForce_ChoiceRemoveStars, "thermloop01.wav", "thrmlpu2.wav", 0, 0, 0, 0, 0, 0};
static jkGuiMenu jkGuiForce_menuMots =
{ jkGuiForce_buttonsMots, 0, 0xe1, 0xff, 0x0f, 0, 0, jkGuiForce_aBitmaps, jkGui_stdFonts, 0, 0, "thermloop01.wav", "thrmlpu2.wav", 0, 0, 0, 0, 0, 0};
static jkGuiElement* jkGuiForce_pElements = jkGuiForce_buttons;
static jkGuiMenu* jkGuiForce_pMenu = &jkGuiForce_menu;
void jkGuiForce_ChoiceRemoveStar(jkGuiMenu *menu, int fpIdx, int amount)
{
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS, (float)((int)sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS) + 1));
sithPlayer_SetBinAmt(fpIdx, (float)(amount - 1));
if ( fpIdx >= SITHBIN_F_THROW && fpIdx <= SITHBIN_F_DESTRUCTION )
{
jkGuiRend_PlayWav("ForcePersuas01.wav");
}
else if ( fpIdx >= SITHBIN_F_HEALING && fpIdx <= SITHBIN_F_ABSORB )
{
jkGuiRend_PlayWav("ForceBlind01.wav");
}
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].selectedTextEntry = 100 - (int)jkPlayer_CalcAlignment(jkGuiForce_isMulti);
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
jkGuiForce_pElements[i].bIsVisible = !!(jkPlayer_playerInfos[playerThingIdx].iteminfo[id].state & ITEMSTATE_CARRIES);
}
jkGuiRend_Paint(menu);
}
void jkGuiForce_ChoiceRemoveStars(jkGuiMenu *menu)
{
if ( jkGuiForce_alignment && (double)(unsigned int)stdPlatform_GetTimeMsec() > jkGuiForce_flt_556674 )
{
jkGuiForce_flt_556674 = (double)(unsigned int)stdPlatform_GetTimeMsec() - -1000.0;
int beginIdx = SITHBIN_F_THROW;
int endIdx = SITHBIN_F_DEADLYSIGHT;
if ( jkGuiForce_alignment == 2 )
{
beginIdx = SITHBIN_F_HEALING;
endIdx = SITHBIN_F_PROTECTION;
}
for (int i = beginIdx; i < endIdx; i++)
{
sithPlayer_SetBinCarries(i, 0);
int curAmt = (int)sithPlayer_GetBinAmt(i);
if (curAmt > 0)
{
jkGuiForce_ChoiceRemoveStar(menu, i, curAmt);
return;
}
}
if ( jkGuiForce_alignment == 2 )
{
jkPlayer_SetChoice(jkGuiForce_alignment);
}
else if ( jkGuiForce_alignment == 1 )
{
jkPlayer_SetChoice(jkGuiForce_alignment);
}
jkGuiForce_alignment = 0;
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].selectedTextEntry = 100 - (int)jkPlayer_CalcAlignment(0.0);
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
jkGuiForce_pElements[i].bIsVisible = !!(jkPlayer_playerInfos[playerThingIdx].iteminfo[id].state & ITEMSTATE_CARRIES);
}
jkGuiRend_Paint(menu);
}
}
void jkGuiForce_ForceStarsDraw(jkGuiElement *element, jkGuiMenu *menu, stdVBuffer *vbuf, int redraw)
{
int spendStars = (int)sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS);
if ( spendStars <= 0 )
{
stdFont_Draw4(vbuf, jkGui_stdFonts[2], element->rect.x, element->rect.y, element->rect.width, element->rect.height, 3, jkStrings_GetUniStringWithFallback("GUI_NO_STARS"), 1);
}
else
{
stdVBuffer* bitmap = jkGuiForce_aBitmaps[IDX_FOSTARS]->mipSurfaces[Main_bMotsCompat ? 10 : 0];
// MOTS added
int spendStarsVisualMax = element->rect.width / bitmap->format.width;
if (spendStarsVisualMax <= spendStars) {
spendStars = spendStarsVisualMax;
}
for (int i = 0; i < spendStars; i++)
{
stdDisplay_VBufferCopy(vbuf, bitmap, element->rect.x + bitmap->format.width * i + ((element->rect.width - bitmap->format.width * spendStars) >> 1), element->rect.y, 0, 1);
}
}
for (int i = EIDX_START_FP; i < (Main_bMotsCompat ? EIDX_END_FP : EIDX_END_FP_CLICKABLE); i++)
{
// MOTS added: different rendering
if (Main_bMotsCompat) {
jkGuiElement* pFpElement = &jkGuiForce_pElements[i];
int id = pFpElement->hoverId;
int numStars = (int)sithPlayer_GetBinAmt(id);
if (!jkGuiForce_isMulti && i == EIDX_MOTS_DEFENSE)
continue;
stdBitmap* psVar1 = !pFpElement->bIsVisible ? menu->ui_structs[pFpElement->selectedTextEntry] : NULL;
if (psVar1)
{
rdRect local_10;
local_10.x = 0;
local_10.y = 0;
local_10.width = pFpElement->rect.width;
if (psVar1->mipSurfaces[3]->format.width <= local_10.width) {
local_10.width = (psVar1->mipSurfaces[3]->format).width;
}
local_10.height = pFpElement->rect.height;
if (psVar1->mipSurfaces[3]->format.height <= local_10.height) {
local_10.height = psVar1->mipSurfaces[3]->format.height;
}
stdDisplay_VBufferCopy(vbuf, psVar1->mipSurfaces[3], pFpElement->rect.x, pFpElement->rect.y, &local_10, 1);
}
int x_left = pFpElement->rect.x - jkGuiForce_aBitmaps[IDX_FOSTARS]->mipSurfaces[numStars]->format.width - 19;
int x_right = pFpElement->rect.x + pFpElement->rect.width + 19;
int y = pFpElement->rect.y + 3;
stdDisplay_VBufferCopy(vbuf, jkGuiForce_aBitmaps[IDX_FOSTARS]->mipSurfaces[numStars + 5], x_left, y, NULL,1);
if (i == EIDX_MOTS_DEFENSE)
{
stdDisplay_VBufferCopy(vbuf, jkGuiForce_aBitmaps[IDX_FOSTARS]->mipSurfaces[numStars], x_right, y, NULL, 1);
}
}
else {
int id = jkGuiForce_pElements[i].hoverId;
int numStars = (int)sithPlayer_GetBinAmt(id) - 1;
if ( numStars >= 0 )
{
if (id >= SITHBIN_F_HEALING && id <= SITHBIN_F_ABSORB)
{
numStars += 4; // Light side
}
else if (id >= SITHBIN_F_THROW && id <= SITHBIN_F_DESTRUCTION)
{
numStars += 8; // Dark side
}
// Show the number of force stars next to each button
int x;
if (jkGuiForce_pElements[i].rect.x >= 320 )
x = jkGuiForce_pElements[i].rect.width + jkGuiForce_pElements[i].rect.x + 19;
else
x = jkGuiForce_pElements[i].rect.x - jkGuiForce_aBitmaps[IDX_FOSTARS]->mipSurfaces[numStars]->format.width - 19;
stdDisplay_VBufferCopy(vbuf, jkGuiForce_aBitmaps[IDX_FOSTARS]->mipSurfaces[numStars], x, jkGuiForce_pElements[i].rect.y + 3, NULL, 1);
}
}
}
}
int jkGuiForce_ExtraClick(jkGuiElement *element, jkGuiMenu *menu, int a, int b, int c)
{
return 0;
}
int jkGuiForce_ButtonClick(jkGuiElement *element, jkGuiMenu *menu, int a, int b, int c)
{
if ( !jkGuiForce_bCanSpendStars )
return 0;
int binIdx = element->hoverId;
int spendStars = (int)sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS);
int curLevel = (int)sithPlayer_GetBinAmt(binIdx);
int bIsDefense = Main_bMotsCompat ? (!!(element == &jkGuiForce_pElements[EIDX_MOTS_DEFENSE]) + 1) : 0;
if (Main_bMotsCompat) {
int pvVar1;
if ((element == &jkGuiForce_pElements[EIDX_MOTS_DEFENSE]) && (-1 < jkPlayer_aMotsFpBins[curLevel + 0x44])) {
int iVar3 = 0;
float fVar5;
int* piVar2 = jkPlayer_aMotsFpBins + jkPlayer_aMotsFpBins[curLevel + 0x44] * 8;
do {
if ((*piVar2 != 0) &&
(fVar5 = sithPlayer_GetBinAmt(*piVar2), 0.0 < fVar5)) break;
iVar3 = iVar3 + 1;
piVar2 = piVar2 + 1;
} while (iVar3 < 8);
if (iVar3 != 8) {
return 0;
}
}
if ((curLevel < 4) && (bIsDefense <= spendStars)) {
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS,(float)(spendStars - bIsDefense));
sithPlayer_SetBinAmt(binIdx,(float)(curLevel + 1));
}
if (jkGuiForce_isMulti == 0) {
if ((curLevel == element->oldForcePoints) ||
((curLevel != 4 && (bIsDefense <= spendStars)))) goto LAB_00418eb2;
sithPlayer_SetBinAmt
(SITHBIN_SPEND_STARS,
(float)((curLevel - element->oldForcePoints) * bIsDefense + spendStars));
pvVar1 = element->oldForcePoints;
}
else {
if ((curLevel != 4) && (bIsDefense <= spendStars)) goto LAB_00418eb2;
if (element == &jkGuiForce_pElements[EIDX_MOTS_DEFENSE]) {
pvVar1 = (int)jkPlayer_aMultiParams[119];
}
else {
pvVar1 = 0;
}
sithPlayer_SetBinAmt
(SITHBIN_SPEND_STARS,(float)((curLevel - pvVar1) * bIsDefense + spendStars));
}
sithPlayer_SetBinAmt(binIdx,(float)pvVar1);
LAB_00418eb2:
jkGuiForce_UpdateViewForRank();
jkGuiRend_Paint(menu);
return 0;
}
else {
if ( curLevel < 4 && spendStars > 0 )
{
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS, (float)(spendStars - 1));
sithPlayer_SetBinAmt(binIdx, (float)(curLevel + 1));
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].selectedTextEntry = 100 - (int)jkPlayer_CalcAlignment(jkGuiForce_isMulti);
jkGuiRend_Paint(menu);
}
if (jkGuiForce_isMulti)
{
if ( curLevel == 4 || !spendStars )
{
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS, (float)(spendStars + curLevel));
sithPlayer_SetBinAmt(binIdx, 0.0);
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].selectedTextEntry = 100 - (int)jkPlayer_CalcAlignment(jkGuiForce_isMulti);
}
jkGuiForce_UpdateViewForRank();
jkGuiRend_Paint(menu);
}
}
return 0;
}
// MOTS altered
int jkGuiForce_ResetClick(jkGuiElement *element, jkGuiMenu *menu, int mouseX, int mouseY, int bRedraw)
{
if ( !jkGuiForce_bCanSpendStars )
return 0;
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS, (double)jkGuiForce_numSpendStars);
for (int i = EIDX_START_FP; i < (Main_bMotsCompat ? EIDX_END_FP : EIDX_END_FP_CLICKABLE); i++)
{
float initialForcePoints = (float)jkGuiForce_pElements[i].oldForcePoints;
sithPlayer_SetBinAmt(jkGuiForce_pElements[i].hoverId, initialForcePoints);
}
// MOTS added: no condition
if (Main_bMotsCompat || jkGuiForce_isMulti)
{
jkGuiForce_UpdateViewForRank();
}
if (!Main_bMotsCompat)
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].selectedTextEntry = 100 - (uint64_t)(int)jkPlayer_CalcAlignment(jkGuiForce_isMulti);
jkGuiRend_Paint(menu);
return 0;
}
// MOTS altered
int jkGuiForce_Show(int bCanSpendStars, int isMulti, int a4, wchar_t* a5, int *pbIsLight, int bEnableIdk)
{
int newStars;
int spendStars;
int isLight = 1;
jkGuiForce_bCanSpendStars = bCanSpendStars;
jkGuiForce_isMulti = isMulti;
jkGui_SetModeMenu(jkGui_stdBitmaps[JKGUI_BM_BK_FORCE]->palette);
jkGuiForce_pElements[EIDX_NAMETEXT].wstr = jkPlayer_playerShortName;
jkGuiForce_pElements[EIDX_RESET].bIsVisible = bCanSpendStars;
jkGuiForce_pElements[EIDX_QUIT].bIsVisible = bEnableIdk != 0;
float darklight_float = jkPlayer_CalcAlignment(jkGuiForce_isMulti);
if (Main_bMotsCompat) {
if (!isMulti || jkPlayer_personality == 1) {
stdString_snprintf(std_genBuffer, 1024, "RANK_%d_%c",jkPlayer_GetJediRank(),'L');
}
else {
stdString_snprintf(std_genBuffer, 1024, "GUI_PERSONALITY%d",jkPlayer_personality);
}
}
else {
stdString_snprintf(std_genBuffer, 1024, "RANK_%d_%c", jkPlayer_GetJediRank(), (darklight_float >= 0.0) ? 'L' : 'D');
}
jkGuiForce_pElements[EIDX_FLAVORTEXT].wstr = jkStrings_GetUniStringWithFallback(std_genBuffer);
if ( Main_bMotsCompat || (!Main_bMotsCompat && a4 == 0) )
{
newStars = (int)sithPlayer_GetBinAmt(SITHBIN_NEW_STARS);
spendStars = (int)sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS);
sithPlayer_SetBinAmt(SITHBIN_NEW_STARS, 0.0);
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS, (float)(newStars + spendStars));
}
if (!Main_bMotsCompat)
{
jkGuiForce_numSpendStars = (int)sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS);
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].bIsVisible = 1;
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].enableHover = 1;
jkGuiForce_pElements[EIDX_ALIGN_SLIDER].selectedTextEntry = 100 - (uint32_t)darklight_float;
if (isMulti)
{
jkPlayer_SetAccessiblePowers(jkPlayer_GetJediRank());
jkGuiForce_UpdateViewForRank();
jkGuiForce_pElements[EIDX_NAMETEXT].wstr = (wchar_t *)a5;
}
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
jkGuiForce_pElements[i].oldForcePoints = (int)sithPlayer_GetBinAmt(id);
jkGuiForce_pElements[i].bIsVisible = !!(jkPlayer_playerInfos[playerThingIdx].iteminfo[id].state & ITEMSTATE_CARRIES);
}
if ( a4 != 0 )
{
if ( darklight_float >= 0.0 )
{
jkGuiForce_pElements[EIDX_FLAVORTEXT].wstr = jkStrings_GetUniStringWithFallback("GUI_PATH_LIGHT");
if ( jkPlayer_GetAlignment() == 1 )
{
sithPlayer_SetBinCarries(SITHBIN_F_PROTECTION, 1);
sithPlayer_SetBinAmt(SITHBIN_F_PROTECTION, 4.0);
}
jkGuiForce_alignment = 1;
isLight = 1;
}
else
{
jkGuiForce_pElements[EIDX_FLAVORTEXT].wstr = jkStrings_GetUniStringWithFallback("GUI_PATH_DARK");
if ( jkPlayer_GetAlignment() == 2 )
{
sithPlayer_SetBinCarries(SITHBIN_F_DEADLYSIGHT, 1);
sithPlayer_SetBinAmt(SITHBIN_F_DEADLYSIGHT, 4.0);
}
jkGuiForce_alignment = 2;
isLight = 0;
}
}
}
else
{
// MOTS added: no slider
if (isMulti)
{
jkGuiForce_pElements[EIDX_NAMETEXT].wstr = a5;
}
jkGuiForce_UpdateViewForRank();
jkGuiForce_numSpendStars = (int)sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS);
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
// Added?
if (i == EIDX_MOTS_DEFENSE) {
jkGuiForce_pElements[i].bIsVisible = !!jkGuiForce_isMulti;
}
jkGuiForce_pElements[i].oldForcePoints = (int)sithPlayer_GetBinAmt(id);
}
}
jkGuiRend_MenuSetReturnKeyShortcutElement(jkGuiForce_pMenu, &jkGuiForce_pElements[EIDX_OK_BUTTON]);
int clicked;
while (1)
{
clicked = jkGuiRend_DisplayAndReturnClicked(jkGuiForce_pMenu);
if ( clicked == -1 )
{
if ( !jkGuiDialog_YesNoDialog(jkStrings_GetUniStringWithFallback("GUI_ABORT_GAME"), jkStrings_GetUniStringWithFallback("GUI_CONFIRM_ABORTCD")) )
continue;
}
else if ( clicked != 1 )
{
continue;
}
break;
}
if (isMulti)
{
sithPlayer_SetBinAmt(SITHBIN_NEW_STARS, 0.0);
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS, 0.0);
}
jkGui_SetModeGame();
if ( pbIsLight )
*pbIsLight = isLight;
return clicked;
}
void jkGuiForce_Startup()
{
char tmp[128];
if (Main_bMotsCompat) {
jkGuiForce_pMenu = &jkGuiForce_menuMots;
jkGuiForce_pElements = jkGuiForce_buttonsMots;
}
else {
jkGuiForce_pMenu = &jkGuiForce_menu;
jkGuiForce_pElements = jkGuiForce_buttons;
}
jkGui_InitMenu(jkGuiForce_pMenu, jkGui_stdBitmaps[JKGUI_BM_BK_FORCE]);
if (Main_bMotsCompat) {
for (int i = 0; i < 19; i++)
{
stdString_snprintf(tmp, sizeof(tmp), "ui\\bm\\%s", jkGuiForce_bitmapsMots[i]);
jkGuiForce_aBitmaps[i] = stdBitmap_Load(tmp, 1, 0);
if (jkGuiForce_aBitmaps[i] == NULL)
Windows_GameErrorMsgbox("ERR_CANNOT_LOAD_FILE %s", tmp);
}
}
else {
for (int i = 0; i < 17; i++)
{
stdString_snprintf(tmp, sizeof(tmp), "ui\\bm\\%s", jkGuiForce_bitmaps[i]);
jkGuiForce_aBitmaps[i] = stdBitmap_Load(tmp, 1, 0);
if (jkGuiForce_aBitmaps[i] == NULL)
Windows_GameErrorMsgbox("ERR_CANNOT_LOAD_FILE %s", tmp);
}
}
}
void jkGuiForce_Shutdown()
{
for (int i = 0; i < (Main_bMotsCompat ? 19 : 17); i++)
{
if ( jkGuiForce_aBitmaps[i] )
{
stdBitmap_Free(jkGuiForce_aBitmaps[i]);
jkGuiForce_aBitmaps[i] = NULL;
}
}
// Added: Clean restart
jkGuiForce_alignment = 0;
jkGuiForce_flt_556674 = 0;
jkGuiForce_numSpendStars = 0;
jkGuiForce_bCanSpendStars = 0;
jkGuiForce_isMulti = 0;
memset(jkGuiForce_aBitmaps, 0, sizeof(jkGuiForce_aBitmaps));
memset(jkGuiForce_waTmp, 0, sizeof(jkGuiForce_waTmp));
}
void jkGuiForce_UpdateViewForRankMots(void)
{
int jediRank;
int jediRank_;
int *piVar2;
wchar_t *pwVar5;
int bIsMulti;
jediRank = jkPlayer_GetJediRank();
bIsMulti = jkGuiForce_isMulti;
jediRank_ = jkPlayer_GetJediRank(); // ?
bIsMulti = jkPlayer_SyncForcePowers(jediRank_,bIsMulti);
if (bIsMulti)
{
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS,sithPlayer_GetBinAmt(SITHBIN_SPEND_STARS) + (float)bIsMulti);
}
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
jkGuiForce_pElements[i].bIsVisible = !!(jkPlayer_playerInfos[playerThingIdx].iteminfo[id].state & ITEMSTATE_CARRIES);
}
pwVar5 = jkGuiForce_waTmp;
for (int categoryIdx = 0; categoryIdx < 4; categoryIdx++)
{
jediRank_ = 0;
for(int fpIdx = 0; fpIdx < 8; fpIdx++)
{
int amt = jkPlayer_aMotsFpBins[(categoryIdx*8) + fpIdx];
if (amt && !!(jkPlayer_playerInfos[playerThingIdx].iteminfo[amt].state & ITEMSTATE_CARRIES)) {
jediRank_ = jediRank_ + 1;
}
}
*pwVar5 = 0;
if (jkPlayer_aMotsFpBins[0x20 + (jediRank * 4) + categoryIdx] <= jediRank_) {
jediRank_ = jkPlayer_aMotsFpBins[0x20 + (jediRank * 4) + categoryIdx];
}
if (jediRank_ != 0) {
jk_snwprintf(pwVar5,100,jkStrings_GetUniStringWithFallback("GUI_CHOOSE_N"),jediRank_);
}
pwVar5 = pwVar5 + 100;
}
if (jkGuiForce_isMulti)
{
if (jkPlayer_personality != 1)
{
sithPlayer_SetBinAmt(SITHBIN_SPEND_STARS,0.0);
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
jkGuiForce_pElements[i].bIsVisible = (sithPlayer_GetBinAmt(id) > 0.0);
// Added?
if (i == EIDX_MOTS_DEFENSE) {
jkGuiForce_pElements[i].bIsVisible = !!jkGuiForce_isMulti;
}
}
for (int i = 0; i < 4; i++) {
jkGuiForce_waTmp[100 * i] = 0;
}
}
if (jkGuiForce_isMulti) {
return;
}
}
jkGuiForce_pElements[EIDX_MOTS_DEFENSE].bIsVisible = 0;
}
void jkGuiForce_UpdateViewForRank()
{
if (Main_bMotsCompat) {
jkGuiForce_UpdateViewForRankMots();
return;
}
jkPlayer_SetProtectionDeadlysight();
if ( jkPlayer_GetJediRank() >= 7 )
jkPlayer_DisallowOtherSide(jkPlayer_GetJediRank());
for (int i = EIDX_START_FP; i < EIDX_END_FP; i++)
{
int id = jkGuiForce_pElements[i].hoverId;
jkGuiForce_pElements[i].bIsVisible = !!(jkPlayer_playerInfos[playerThingIdx].iteminfo[id].state & ITEMSTATE_CARRIES);
}
}
void jkGuiForce_DarkLightHoverDraw(jkGuiElement *element, jkGuiMenu *menu, stdVBuffer *vbuf, int redraw)
{
}
|
a11754f2aab208133dcd23eb2e4fb131ea82ec5a
|
9a5257de7e51a879042fb63e16d3fba652e0aff7
|
/src/util/nlpt-select.h
|
016ea9d6dfb30490ba2c1c78136a8c27176cdfde
|
[
"Apache-2.0"
] |
permissive
|
openthread/wpantund
|
146c0eb45ab56e85b15b4bbd9830192ad1d4fa9a
|
e2fd726982d626817b1db56c4361c1c5cb7d6201
|
refs/heads/master
| 2023-01-12T02:17:39.422466
| 2023-01-05T17:07:18
| 2023-01-05T20:46:41
| 60,717,054
| 176
| 130
|
Apache-2.0
| 2023-01-05T20:46:42
| 2016-06-08T17:32:11
|
C++
|
UTF-8
|
C
| false
| false
| 2,223
|
h
|
nlpt-select.h
|
/*
*
* Copyright (c) 2016 Nest Labs, Inc.
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Description:
* Flavor of protothreads for handling asynchronous I/O, via select()
*
*/
#ifndef wpantund_nlpt_select_h
#define wpantund_nlpt_select_h
#include <stdbool.h>
#include <poll.h>
#include <sys/select.h>
#if defined(__cplusplus)
extern "C" {
#endif
struct nlpt {
struct pt pt;
struct pt sub_pt;
size_t byte_count;
int last_errno;
fd_set read_fds;
fd_set write_fds;
fd_set error_fds;
int max_fd;
};
/* ========================================================================= */
/* Private, Back-end-specific functions */
extern void _nlpt_init(struct nlpt* nlpt);
extern void _nlpt_cleanup_all(struct nlpt* nlpt);
extern void _nlpt_cleanup_read_fd_source(struct nlpt* nlpt, int fd);
extern void _nlpt_cleanup_write_fd_source(struct nlpt* nlpt, int fd);
extern void _nlpt_setup_read_fd_source(struct nlpt* nlpt, int fd);
extern void _nlpt_setup_write_fd_source(struct nlpt* nlpt, int fd);
/* ========================================================================= */
/* Protected, Back-end-specific hooks (for async I/O) */
extern bool nlpt_hook_check_read_fd_source(struct nlpt* nlpt, int fd);
extern bool nlpt_hook_check_write_fd_source(struct nlpt* nlpt, int fd);
/* ========================================================================= */
/* Public, Back-end-specific functions (for async I/O) */
extern void nlpt_select_update_fd_set(
const struct nlpt* nlpt,
fd_set *read_fd_set,
fd_set *write_fd_set,
fd_set *error_fd_set,
int *max_fd
);
extern bool _nlpt_checkpoll(int fd, short poll_flags);
#if defined(__cplusplus)
}
#endif
#endif
|
d3333259517d3c853aa003284b3fe0f5b0048b85
|
9de0cec678bc4a3bec2b4adabef9f39ff5b4afac
|
/ML/MLLinkDef.h
|
488aa0981c7a97dc65fd64f152814d9ce1493efa
|
[] |
permissive
|
alisw/AliPhysics
|
91bf1bd01ab2af656a25ff10b25e618a63667d3e
|
5df28b2b415e78e81273b0d9bf5c1b99feda3348
|
refs/heads/master
| 2023-08-31T20:41:44.927176
| 2023-08-31T14:51:12
| 2023-08-31T14:51:12
| 61,661,378
| 129
| 1,150
|
BSD-3-Clause
| 2023-09-14T18:48:45
| 2016-06-21T19:31:29
|
C++
|
UTF-8
|
C
| false
| false
| 300
|
h
|
MLLinkDef.h
|
#ifdef __CINT__
#pragma link off all globals;
#pragma link off all classes;
#pragma link off all functions;
#pragma link C++ class AliExternalBDT+;
/// classes working in ROOT6 only
#ifdef __CLING__
#pragma link C++ class AliMLResponse+;
#pragma link C++ class AliMLModelHandler+;
#endif
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.