hexsha stringlengths 40 40 | size int64 5 2.72M | ext stringclasses 5
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 3 976 | max_stars_repo_name stringlengths 5 113 | max_stars_repo_head_hexsha stringlengths 40 78 | max_stars_repo_licenses listlengths 1 10 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringdate 2015-01-01 00:01:43 2022-03-31 23:59:48 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 00:06:24 2022-03-31 23:59:53 ⌀ | max_issues_repo_path stringlengths 3 976 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 78 | max_issues_repo_licenses listlengths 1 10 | max_issues_count float64 1 134k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 976 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 78 | max_forks_repo_licenses listlengths 1 10 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringdate 2015-01-01 00:01:19 2022-03-31 23:59:49 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 12:00:57 2022-03-31 23:59:49 ⌀ | content stringlengths 5 2.72M | avg_line_length float64 1.38 573k | max_line_length int64 2 1.01M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d1ef50f60087e449887f72dbab91e0ebfe197474 | 928 | h | C | source/parser_data.h | PixelRifts/Rift | 3870548d1660081c99f2b5ab8f8313706aec6f23 | [
"MIT"
] | 19 | 2021-10-19T14:46:13.000Z | 2022-03-28T04:23:31.000Z | source/parser_data.h | PixelRifts/Rift | 3870548d1660081c99f2b5ab8f8313706aec6f23 | [
"MIT"
] | 4 | 2022-01-10T05:48:53.000Z | 2022-01-22T03:23:27.000Z | source/parser_data.h | PixelRifts/Rift | 3870548d1660081c99f2b5ab8f8313706aec6f23 | [
"MIT"
] | 5 | 2022-01-08T21:36:48.000Z | 2022-01-25T13:42:33.000Z | /* date = February 13th 2022 8:35 pm */
#ifndef PARSER_DATA_H
#define PARSER_DATA_H
typedef u32 Prec;
enum Prec {
Prec_Invalid,
Prec_LogOr,
Prec_LogAnd,
Prec_Equality,
Prec_Compare,
Prec_Term,
Prec_Factor,
Prec_Call,
Prec_None,
};
u32 infix_expr_precs[] = {
[TokenType_OpenParenthesis] = Prec_Call,
[TokenType_Star] = Prec_Factor,
[TokenType_Slash] = Prec_Factor,
[TokenType_Plus] = Prec_Term,
[TokenType_Minus] = Prec_Term,
[TokenType_EqualEqual] = Prec_Equality,
[TokenType_BangEqual] = Prec_Equality,
[TokenType_Less] = Prec_Compare,
[TokenType_LessEqual] = Prec_Compare,
[TokenType_Greater] = Prec_Compare,
[TokenType_GreaterEqual] = Prec_Compare,
[TokenType_AmpersandAmpersand] = Prec_LogAnd,
[TokenType_PipePipe] = Prec_LogOr,
[TokenType_TokenTypeCount] = Prec_Invalid,
};
#endif //PARSER_DATA_H
| 21.581395 | 49 | 0.6875 |
d1f281232cf13fed59a86afb712ab984b3b629eb | 10,749 | c | C | src/mods/io.c | fy0/python_lite | f59850b6093ec8260d96302af25c2bc3bdababc9 | [
"Zlib"
] | 91 | 2016-05-12T21:10:13.000Z | 2022-03-29T14:20:36.000Z | src/mods/io.c | fy0/python_lite | f59850b6093ec8260d96302af25c2bc3bdababc9 | [
"Zlib"
] | 1 | 2017-01-11T23:17:43.000Z | 2021-11-17T05:30:23.000Z | src/mods/io.c | fy0/python_lite | f59850b6093ec8260d96302af25c2bc3bdababc9 | [
"Zlib"
] | 5 | 2017-01-02T12:23:34.000Z | 2022-03-29T14:20:41.000Z |
#include <errno.h>
#include "io.h"
#include "../intp.h"
#include "../api.h"
#include "../bind.h"
#include "../types/all.h"
#include "../types/objectE.h"
#include "../utils/misc.h"
#include "../utils/io/_io.h"
/**
class BaseIO:
def read(self, size=None):
pass
def write(self, buf):
pass
class TextIO:
def read(self, size=None):
pass
class BytesIO(BaseIO):
def readline(self, size=-1):
pass
*/
#define IO_VALUE_CHK(io_ret) \
if (io_ret == -1) { \
pl_error(I, _S(OSError), "[Errno %d] IO Error", pylt_obj_int_new(I, errno)); \
return NULL; \
}
PyLiteFile* getPF(PyLiteInterpreter *I, PyLiteObject *a) {
PyLiteCPtrObject *obj = castcptr(pylt_obj_Egetattr(I, a, castobj(_S(__cobj__)), NULL));
if (!obj) {
pl_error(I, pl_static.str.RuntimeError, "lost attribute: %r", _S(__cobj__));
return NULL;
}
return (PyLiteFile*)obj->ob_ptr;
}
PyLiteObject* pylt_mods_io_BaseIO_read(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
pl_error(I, pl_static.str.NotImplementedError, NULL);
return NULL;
}
PyLiteObject* pylt_mods_io_BaseIO_write(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
pl_error(I, pl_static.str.NotImplementedError, NULL);
return NULL;
}
#if 0
PyLiteObject* pylt_mods_io_BaseIO_fileno(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteFile *pf = getPF(I, args[0]);
if (!pf) return NULL;
return castobj(pylt_obj_int_new(I, pf->fno));
}
PyLiteObject* pylt_mods_io_BaseIO_isatty(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteFile *pf = getPF(I, args[0]);
if (!pf) return NULL;
return castobj(pylt_obj_bool_new(I, pylt_io_file_isatty(I, pf)));
}
#endif
PyLiteObject* pylt_mods_io_BaseIO_prop_encoding_get(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteFile *pf = getPF(I, args[0]);
if (!pf) return NULL;
return castobj(pylt_io_getencoding(I, pf));
}
PyLiteObject* pylt_mods_io_TextIO_readuntil(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteFile *pf = getPF(I, args[0]);
if (!pf) return NULL;
if (!(pl_isnone(args[2]) || pl_isint(args[2]))) {
pl_error(I, pl_static.str.TypeError, "'size' must be integer or None, got %r", pl_type(I, args[2]));
return NULL;
}
if (!pylt_io_readable(I, pf)) {
PyLiteModuleObject *mod = pl_getmod(I, _S(io));
pl_error_by_type(I, casttype(pylt_obj_mod_getattr(I, mod, _S(UnsupportedOperation))), "not readable");
return NULL;
}
if (!pl_isstr(args[1])) {
pl_error(I, pl_static.str.TypeError, "text must be str, got %r", pl_type(I, args[1]));
return NULL;
}
pl_int_t bsize = 64;
pl_int_t read_count = 0;
pl_int_t maxval = pl_isnone(args[2]) ? -1 : castint(args[2])->ob_val;
pl_int_t pindex = 0;
uint32_t *ptext = caststr(args[1])->ob_val;
pl_int_t index = 0;
uint32_t *buf = (uint32_t*)pylt_malloc(I, sizeof(uint32_t) * bsize);
while (maxval == -1 || read_count < maxval) {
pl_int_t ret = pylt_io_readstr(I, pf, buf + index, 1);
IO_VALUE_CHK(ret);
read_count += ret;
if (buf[index] == ptext[pindex]) {
if (++pindex == caststr(args[1])->ob_size) break;
} else {
if (pindex) pindex = 0;
}
index++;
if (index >= bsize) {
buf = pylt_realloc(I, buf, sizeof(uint32_t) * bsize, sizeof(uint32_t) * (bsize + 64));
bsize += 64;
}
}
PyLiteObject *ret = castobj(pylt_obj_str_new(I, buf, read_count, true));
pylt_free(I, buf, sizeof(uint32_t) * bsize);
return ret;
}
PyLiteObject* pylt_mods_io_TextIO_readline(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteTupleObject *t = pylt_obj_tuple_new(I, 3);
t->ob_val[0] = args[0];
t->ob_val[1] = castobj(pl_strnew_w(I, L"\n", true));
t->ob_val[2] = args[1];
PyLiteObject *ret = pylt_mods_io_TextIO_readuntil(I, 3, t->ob_val);
pylt_obj_tuple_free(I, t);
return ret;
}
PyLiteObject* pylt_mods_io_TextIO_read(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteFile *pf = getPF(I, args[0]);
if (!pf) return NULL;
if (!(pl_isnone(args[1]) || pl_isint(args[1]))) {
pl_error(I, pl_static.str.TypeError, "'size' must be integer or None, got %r", pl_type(I, args[1]));
return NULL;
}
pl_int_t finalcount = 0;
uint32_t tmpbuf[8192];
uint32_t *buf = (uint32_t*)tmpbuf;
if (!pylt_io_readable(I, pf)) {
PyLiteModuleObject *mod = pl_getmod(I, _S(io));
pl_error_by_type(I, casttype(pylt_obj_mod_getattr(I, mod, _S(UnsupportedOperation))), "not readable");
return NULL;
}
if (pl_isint(args[1])) {
pl_int_t count = castint(args[1])->ob_val;
if (count < 8192) {
finalcount = pylt_io_readstr(I, pf, buf, count);
IO_VALUE_CHK(finalcount);
} else {
buf = NULL;
pl_int_t current = 8192;
while (true) {
pl_int_t tmp = pylt_io_readstr(I, pf, tmpbuf, current);
if (tmp == -1) pylt_free(I, buf, sizeof(uint32_t) * finalcount);
IO_VALUE_CHK(tmp);
buf = pylt_realloc(I, buf, sizeof(uint32_t) * finalcount, sizeof(uint32_t) * (finalcount + tmp));
memcpy(buf + finalcount, tmpbuf, sizeof(uint32_t) * tmp);
finalcount += tmp;
if (tmp < 8192) break;
count -= 8192;
if (count == 0) break;
current = min(count, 8192);
}
}
} else {
buf = NULL;
while (true) {
pl_int_t tmp = pylt_io_readstr(I, pf, tmpbuf, 8192);
buf = pylt_realloc(I, buf, sizeof(uint32_t) * finalcount, sizeof(uint32_t) * (finalcount + tmp));
memcpy(buf + finalcount, tmpbuf, sizeof(uint32_t) * tmp);
finalcount += tmp;
if (tmp < 8192) break;
}
}
PyLiteObject *ret = castobj(pylt_obj_str_new(I, buf, finalcount, true));
if (buf != tmpbuf) {
pylt_free(I, buf, sizeof(uint32_t) * finalcount);
}
return ret;
}
PyLiteObject* pylt_mods_io_TextIO_write(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
PyLiteFile *pf = getPF(I, args[0]);
if (!pf) return NULL;
if (!pl_isstr(args[1])) {
pl_error(I, pl_static.str.TypeError, "write() argument must be str, not %s", pl_type(I, args[1])->name);
return NULL;
}
PyLiteStrObject *str = caststr(args[1]);
if (!pylt_io_writeable(I, pf)) {
PyLiteModuleObject *mod = pl_getmod(I, _S(io));
pl_error_by_type(I, casttype(pylt_obj_mod_getattr(I, mod, _S(UnsupportedOperation))), "not writeable");
return NULL;
}
return castobj(pylt_obj_int_new(I, pylt_io_writestr(I, pf, str->ob_val, str->ob_size)));
}
PyLiteObject* pylt_mods_io_open(PyLiteInterpreter *I, int argc, PyLiteObject **args) {
int err, mode;
pl_bool_t is_binary;
PyLiteCFunctionObject *func = castcfunc(I->recent_called);
mode = pylt_io_mode_parse(caststr(args[1]), &err);
is_binary = mode & PYLT_IOMODE_BINARY;
if (err != 0) {
pl_error(I, pl_static.str.ValueError, "invalid mode: %r", caststr(args[1]));
return NULL;
}
PyLiteFile *pf = pylt_io_open(I, caststr(args[0]), mode, PYLT_IOTE_UTF8);
if (!pf) return NULL;
PyLiteModuleObject *mod = castmod(func->ob_owner);
pl_assert(I, pl_ismod(mod), NULL);
PyLiteTypeObject *iotype = casttype(pylt_obj_mod_getattr(I, mod, (is_binary) ? _S(BytesIO) : _S(TextIO)));
PyLiteObject *ret = pylt_obj_cutstom_create(I, iotype->ob_reftype, NULL);
pylt_obj_setattr(I, ret, castobj(_S(__cobj__)), castobj(pylt_obj_cptr_new(I, pf, false)));
return ret;
}
PyLiteModuleObject* pylt_mods_io_loader(PyLiteInterpreter *I) {
PyLiteModuleObject *mod = pylt_obj_module_new(I, _S(io));
pylt_obj_mod_setattr(I, mod, _NS(I, "SEEK_CUR"), castobj(pylt_obj_int_new(I, SEEK_CUR)));
pylt_obj_mod_setattr(I, mod, _NS(I, "SEEK_END"), castobj(pylt_obj_int_new(I, SEEK_END)));
pylt_obj_mod_setattr(I, mod, _NS(I, "SEEK_SET"), castobj(pylt_obj_int_new(I, SEEK_SET)));
pylt_cfunc_register(I, mod, _NS(I, "open"), _NST(I, 2, "fn", "mode"), NULL, NULL, &pylt_mods_io_open);
PyLiteTypeObject *type;
type = pylt_obj_type_new(I, pl_static.str.BaseIO, PYLT_OBJ_TYPE_OBJ, NULL);
pylt_cmethod_register(I, type, _NS(I, "read"), _NST(I, 2, "self", "size"), _NT(I, 2, &PyLiteParamUndefined, &PyLiteNone), NULL, &pylt_mods_io_BaseIO_read);
pylt_cmethod_register(I, type, _NS(I, "write"), _NST(I, 2, "self", "data"), NULL, NULL, &pylt_mods_io_BaseIO_write);
//pylt_cmethod_register_0_args(I, type, _NS(I, "fileno"), &pylt_mods_io_BaseIO_fileno);
//pylt_cmethod_register_0_args(I, type, _NS(I, "isatty"), &pylt_mods_io_BaseIO_isatty);
pylt_cprop_register(I, type, _S(encoding), &pylt_mods_io_BaseIO_prop_encoding_get, NULL);
pylt_type_register(I, mod, type);
PyLiteTypeObject *tTextIO = pylt_obj_type_new(I, pl_static.str.TextIO, type->ob_reftype, NULL);
pylt_cmethod_register(I, tTextIO, _NS(I, "read"), _NST(I, 2, "self", "size"), _NT(I, 2, &PyLiteParamUndefined, &PyLiteNone), NULL, &pylt_mods_io_TextIO_read);
pylt_cmethod_register(I, tTextIO, _NS(I, "readuntil"), _NST(I, 3, "self", "text", "size"), _NT(I, 3, &PyLiteParamUndefined, &PyLiteParamUndefined, &PyLiteNone), NULL, &pylt_mods_io_TextIO_readuntil);
pylt_cmethod_register(I, tTextIO, _NS(I, "readline"), _NST(I, 2, "self", "size"), _NT(I, 2, &PyLiteParamUndefined, &PyLiteNone), NULL, &pylt_mods_io_TextIO_readline);
pylt_cmethod_register(I, tTextIO, _NS(I, "write"), _NST(I, 2, "self", "str"), NULL, NULL, &pylt_mods_io_TextIO_write);
pylt_type_register(I, mod, tTextIO);
PyLiteTypeObject *tBytesIO = pylt_obj_type_new(I, pl_static.str.BytesIO, type->ob_reftype, NULL);
pylt_cmethod_register(I, tBytesIO, _NS(I, "read"), _NST(I, 2, "self", "size"), _NT(I, 2, &PyLiteParamUndefined, &PyLiteNone), NULL, &pylt_mods_io_TextIO_read);
pylt_cmethod_register(I, tBytesIO, _NS(I, "write"), _NST(I, 2, "self", "str"), NULL, NULL, &pylt_mods_io_TextIO_write);
pylt_type_register(I, mod, tBytesIO);
PyLiteTypeObject *tOSError = casttype(pylt_obj_mod_getattr(I, pl_getmod(I, _S(pltypes)), _S(OSError)));
PyLiteTypeObject *EUnsupportedOperation = pylt_obj_type_new(I, _S(UnsupportedOperation), tOSError->ob_reftype, NULL);
pylt_type_register(I, mod, EUnsupportedOperation);
return mod;
}
pl_bool_t pylt_mods_io_register(PyLiteInterpreter *I) {
return pylt_mod_register(I, _S(io), &pylt_mods_io_loader, true);
}
| 38.252669 | 203 | 0.646572 |
d1f3f38293e833b4bd96c8593bc3b68943e8a861 | 1,151 | h | C | effects/internal/effect_panner.h | ngeiswei/zytrax | 31a6962a61af32d7a9ee2e6950b2a54467193918 | [
"MIT"
] | 197 | 2019-05-17T17:09:06.000Z | 2022-03-29T06:45:42.000Z | effects/internal/effect_panner.h | ngeiswei/zytrax | 31a6962a61af32d7a9ee2e6950b2a54467193918 | [
"MIT"
] | 12 | 2019-06-08T04:56:00.000Z | 2021-02-20T16:29:04.000Z | effects/internal/effect_panner.h | ngeiswei/zytrax | 31a6962a61af32d7a9ee2e6950b2a54467193918 | [
"MIT"
] | 9 | 2019-06-05T08:33:12.000Z | 2021-02-21T19:04:25.000Z | #ifndef EFFECT_PANNER_H
#define EFFECT_PANNER_H
#include "engine/audio_effect.h"
class AudioEffectPanner : public AudioEffect {
enum ControlPorts {
CONTROL_PORT_PAN,
CONTROL_PORT_MAX
};
ControlPortDefault control_ports[CONTROL_PORT_MAX];
int block_size;
public:
//process
virtual bool has_secondary_input() const;
virtual void process(const Event *p_events, int p_event_count, const AudioFrame *p_in, AudioFrame *p_out, bool p_prev_active);
virtual void process_with_secondary(const Event *p_events, int p_event_count, const AudioFrame *p_in, const AudioFrame *p_secondary, AudioFrame *p_out, bool p_prev_active);
virtual void set_process_block_size(int p_size);
virtual void set_sampling_rate(int p_hz);
//info
virtual String get_name() const;
virtual String get_unique_id() const;
virtual String get_provider_id() const;
virtual int get_control_port_count() const;
virtual ControlPort *get_control_port(int p_port);
virtual void reset();
/* Load/Save */
virtual JSON::Node to_json() const;
virtual Error from_json(const JSON::Node &node);
AudioEffectPanner();
~AudioEffectPanner();
};
#endif // EFFECT_PANNER_H
| 26.159091 | 173 | 0.785404 |
d1f53fa3eff152afbc2806c1ccb45a76cd322bec | 208 | h | C | Source/Common/Navigation/NavigationStateCoordinator.h | reddit/AlienBlue | cc37f574c244ec2b49ad780a7edb100f0df0e400 | [
"BSD-3-Clause"
] | 23 | 2021-10-04T19:39:05.000Z | 2022-03-30T15:00:15.000Z | Source/Common/Navigation/NavigationStateCoordinator.h | reddit/AlienBlue | cc37f574c244ec2b49ad780a7edb100f0df0e400 | [
"BSD-3-Clause"
] | null | null | null | Source/Common/Navigation/NavigationStateCoordinator.h | reddit/AlienBlue | cc37f574c244ec2b49ad780a7edb100f0df0e400 | [
"BSD-3-Clause"
] | 1 | 2021-10-05T18:21:49.000Z | 2021-10-05T18:21:49.000Z | @class NavigationManager;
@interface NavigationStateCoordinator : NSObject
- (id)initWithParentNavigationManager:(NavigationManager *)parentNavigationManager;
- (void)saveState;
- (void)restoreState;
@end
| 20.8 | 83 | 0.817308 |
d1f55d49b8f74fd1a20baaf74bb2c18c8c747223 | 1,232 | h | C | System/Library/PrivateFrameworks/Silex.framework/SXFontIndexCacheKey.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 2 | 2021-11-02T09:23:27.000Z | 2022-03-28T08:21:57.000Z | System/Library/PrivateFrameworks/Silex.framework/SXFontIndexCacheKey.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/Silex.framework/SXFontIndexCacheKey.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 1 | 2022-03-28T08:21:59.000Z | 2022-03-28T08:21:59.000Z | /*
* This header is generated by classdump-dyld 1.5
* on Wednesday, October 27, 2021 at 3:16:44 PM Mountain Standard Time
* Operating System: Version 13.5.1 (Build 17F80)
* Image Source: /System/Library/PrivateFrameworks/Silex.framework/Silex
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
#import <Silex/Silex-Structs.h>
#import <libobjc.A.dylib/NSCopying.h>
@protocol SXFontAttributes;
@interface SXFontIndexCacheKey : NSObject <NSCopying> {
id<SXFontAttributes> _fontAttributes;
long long _fontSize;
}
@property (nonatomic,readonly) id<SXFontAttributes> fontAttributes; //@synthesize fontAttributes=_fontAttributes - In the implementation block
@property (nonatomic,readonly) long long fontSize; //@synthesize fontSize=_fontSize - In the implementation block
-(BOOL)isEqual:(id)arg1 ;
-(unsigned long long)hash;
-(id)copyWithZone:(NSZone*)arg1 ;
-(id<SXFontAttributes>)fontAttributes;
-(long long)fontSize;
-(id)initWithFontAttributes:(id)arg1 fontSize:(long long)arg2 ;
@end
| 41.066667 | 155 | 0.663961 |
d1f570feca2bb96ff9d9ee72e18237183ac64c5c | 3,786 | h | C | include/il2cpp/UnityEngine/UIElements/MouseEventBase_WheelEvent_.h | martmists-gh/BDSP | d6326c5d3ad9697ea65269ed47aa0b63abac2a0a | [
"MIT"
] | 1 | 2022-01-15T20:20:27.000Z | 2022-01-15T20:20:27.000Z | include/il2cpp/UnityEngine/UIElements/MouseEventBase_WheelEvent_.h | martmists-gh/BDSP | d6326c5d3ad9697ea65269ed47aa0b63abac2a0a | [
"MIT"
] | null | null | null | include/il2cpp/UnityEngine/UIElements/MouseEventBase_WheelEvent_.h | martmists-gh/BDSP | d6326c5d3ad9697ea65269ed47aa0b63abac2a0a | [
"MIT"
] | null | null | null | #pragma once
#include "il2cpp.h"
int32_t UnityEngine_UIElements_MouseEventBase_WheelEvent___get_modifiers (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
UnityEngine_Vector2_o UnityEngine_UIElements_MouseEventBase_WheelEvent___get_mousePosition (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
UnityEngine_Vector2_o UnityEngine_UIElements_MouseEventBase_WheelEvent___get_mouseDelta (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
int32_t UnityEngine_UIElements_MouseEventBase_WheelEvent___get_clickCount (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
int32_t UnityEngine_UIElements_MouseEventBase_WheelEvent___get_button (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
int32_t UnityEngine_UIElements_MouseEventBase_WheelEvent___get_pressedButtons (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
bool UnityEngine_UIElements_MouseEventBase_WheelEvent___UnityEngine_UIElements_IMouseEventInternal_get_triggeredByOS (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___UnityEngine_UIElements_IMouseEventInternal_set_triggeredByOS (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, bool value, const MethodInfo* method_info);
bool UnityEngine_UIElements_MouseEventBase_WheelEvent___UnityEngine_UIElements_IMouseEventInternal_get_recomputeTopElementUnderMouse (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___UnityEngine_UIElements_IMouseEventInternal_set_recomputeTopElementUnderMouse (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, bool value, const MethodInfo* method_info);
UnityEngine_UIElements_IPointerEvent_o* UnityEngine_UIElements_MouseEventBase_WheelEvent___UnityEngine_UIElements_IMouseEventInternal_get_sourcePointerEvent (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___UnityEngine_UIElements_IMouseEventInternal_set_sourcePointerEvent (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, UnityEngine_UIElements_IPointerEvent_o* value, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___Init (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
UnityEngine_UIElements_IEventHandler_o* UnityEngine_UIElements_MouseEventBase_WheelEvent___get_currentTarget (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___set_currentTarget (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, UnityEngine_UIElements_IEventHandler_o* value, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___PreDispatch (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, UnityEngine_UIElements_IPanel_o* panel, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent___PostDispatch (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, UnityEngine_UIElements_IPanel_o* panel, const MethodInfo* method_info);
UnityEngine_UIElements_WheelEvent_o* UnityEngine_UIElements_MouseEventBase_WheelEvent___GetPooled (UnityEngine_Event_o* systemEvent, const MethodInfo* method_info);
void UnityEngine_UIElements_MouseEventBase_WheelEvent____ctor (UnityEngine_UIElements_MouseEventBase_WheelEvent__o* __this, const MethodInfo* method_info);
| 157.75 | 262 | 0.925251 |
d1f5d430716e4dbd80fbe9a11767762c6dec8d28 | 473 | h | C | include/DataAccess/CalDAVGetResourceOperation.h | iMokhles/MyTheosHeaders | 2c263362a8a6f947b1a868e03983ed188ead6539 | [
"MIT"
] | 7 | 2016-07-22T14:29:58.000Z | 2021-03-19T05:31:48.000Z | iphone-private-frameworks-master/DataAccess/CalDAVGetResourceOperation.h | tt295362026/demo | 7d6e9e75f29c992ea9c5693d38f76e0012bbbf15 | [
"BSD-4-Clause"
] | null | null | null | iphone-private-frameworks-master/DataAccess/CalDAVGetResourceOperation.h | tt295362026/demo | 7d6e9e75f29c992ea9c5693d38f76e0012bbbf15 | [
"BSD-4-Clause"
] | 3 | 2017-02-06T23:58:01.000Z | 2017-10-31T03:47:52.000Z | /**
* This header is generated by class-dump-z 0.2-1.
* class-dump-z is Copyright (C) 2009 by KennyTM~, licensed under GPLv3.
*
* Source: /System/Library/PrivateFrameworks/DataAccess.framework/DataAccess
*/
#import <DAVKit/AYOperation.h>
@class DAVSession, NSString;
@interface CalDAVGetResourceOperation : AYOperation {
NSString* _uri;
DAVSession* _session;
}
-(id)initWithSession:(id)session URI:(id)uri;
// inherited: -(void)dealloc;
-(void)getResource;
@end
| 22.52381 | 76 | 0.737844 |
d1f69a4bd49c08da16d65c3d4e90612b24c56515 | 2,482 | c | C | srcs/log2_meta.c | AugustinLopez/Fancy_Ft_Malloc | 279d6a5090883a3060bc352159488eb41808b911 | [
"MIT"
] | 2 | 2020-10-18T22:30:17.000Z | 2020-11-25T14:39:33.000Z | srcs/log2_meta.c | AugustinLopez/Fancy_Ft_Malloc | 279d6a5090883a3060bc352159488eb41808b911 | [
"MIT"
] | null | null | null | srcs/log2_meta.c | AugustinLopez/Fancy_Ft_Malloc | 279d6a5090883a3060bc352159488eb41808b911 | [
"MIT"
] | null | null | null | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* log2_meta.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: aulopez <aulopez@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/10/11 01:29:30 by aulopez #+# #+# */
/* Updated: 2020/10/14 19:34:09 by aulopez ### ########.fr */
/* */
/* ************************************************************************** */
#include "minilibft.h"
#include "malloc.h"
int log_metadata_set(t_metadata *data, void *l, void *r)
{
int fd;
fd = get_fd();
if (fd == -1)
return (1);
if (l != NULL && r != NULL)
ft_dprintf(fd, "\n>>> New metadata: (%p| [%p] |%p)\n\n",
l, (void *)data, r);
else if (l != NULL)
ft_dprintf(fd, "\n>>> New metadata: (%p| [%p]\n\n", l, (void *)data);
else if (r != NULL)
ft_dprintf(fd, "\n>>> New metadata: [%p] |%p)\n\n", (void *)data, r);
else
ft_dprintf(fd, "\n>>> New metadata: [%p]\n\n", (void *)data);
return (0);
}
int log_metabody_set(t_metabody *body, t_metahead *head)
{
int fd;
fd = get_fd();
if (fd == -1)
return (1);
ft_dprintf(fd, "[%p] New metabody: %p -> %p (%zu left)\n", head->container,
(void *)body, (void *)body->address, head->available_heap);
return (0);
}
int log_metabody_free(t_metabody *body, void *ptr, t_metahead *head)
{
int fd;
fd = get_fd();
if (fd == -1)
return (1);
ft_dprintf(fd, "[%p] Freed metabody: %p -> %p (%zu left)\n",
head->container, (void *)body, ptr, head->available_heap);
return (0);
}
int log_metadata_free(t_metadata *data, void *l, void *r)
{
int fd;
fd = get_fd();
if (fd == -1)
return (1);
if (l != NULL && r != NULL)
ft_dprintf(fd, "\n>>> Freed metadata: (%p| [%p] |%p)\n\n",
l, (void *)data, r);
else if (l != NULL)
ft_dprintf(fd, "\n>>> Freed metadata: (%p| [%p]\n\n", l, (void *)data);
else if (r != NULL)
ft_dprintf(fd, "\n>>> Freed metadata: [%p] |%p)\n\n", (void *)data, r);
else
ft_dprintf(fd, "\n>>> Freed metadata: [%p]\n\n", (void *)data);
return (0);
}
| 32.233766 | 80 | 0.399275 |
d1f6e11191c0eb4d7cebc28380aa92e9119997b6 | 2,434 | c | C | C/math/Sieve_of_Eratosthenes.c | zhcet19/NeoAlgo-1 | c534a23307109280bda0e4867d6e8e490002a4ee | [
"MIT"
] | 897 | 2020-06-25T00:12:52.000Z | 2022-03-24T00:49:31.000Z | C/math/Sieve_of_Eratosthenes.c | zhcet19/NeoAlgo-1 | c534a23307109280bda0e4867d6e8e490002a4ee | [
"MIT"
] | 5,707 | 2020-06-24T17:53:28.000Z | 2022-01-22T05:03:15.000Z | C/math/Sieve_of_Eratosthenes.c | zhcet19/NeoAlgo-1 | c534a23307109280bda0e4867d6e8e490002a4ee | [
"MIT"
] | 1,817 | 2020-06-25T03:51:05.000Z | 2022-03-29T05:14:07.000Z | /*Sieve_of_eratosthenes
Sieve of Eratosthenes is an ancient algorithm for finding all prime numbers up to any given limit.
It does so by iteratively marking as composite (i.e., not prime) the multiples of each prime, starting with
the first prime number, 2. The multiples of a given prime are generated as a sequence of numbers starting from that prime,
with constant difference between them that is equal to that prime.*/
//Header files
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
void Sieve_of_eratosthenes(int n)
{
// Creating an array for storing prime factors.
// and if the i is not prime, mark it as 0 else 1
int prime[n + 1];
// Initialising all elements as 1
for (int i = 2; i <= n; i++)
prime[i] = 1;
for (int i = 2; i * i <= n; i++)
{
// If prime[i] is marked 1, then it is a prime.
if (prime[i] == 1)
{
// Marking all multiples of i as 0
for (int j = i * i; j <= n; j += i)
prime[j] = 0;
}
}
// Printing all the prime numbers
for (int i = 2; i <= n; i++)
if (prime[i])
{
printf("%d ", i);
}
}
/**
* Optimized version of Sieve of Eratosthenes using Dynamic Memory Allocation and using Boolean.
*/
void sieve(int N, bool * isprime)
{
isprime[0] = true;
isprime[1] = true;
// eliminating multiples of i
for (int i = 2; i * i <= N; ++i)
{
if (!isprime[i])
{
for (int j = i * i; j <= N; j = j + i)
{
isprime[j] = true;
}
}
}
// Printing all the prime numbers
for (int i = 1; i <= N; i++)
{
if (!isprime[i])
{
printf("%d ", i);
}
}
printf("\n ");
}
// Driver Function
int main() {
int num;
printf("Enter the number: \n");
scanf("%d", & num);
printf("The prime numbers smaller than or equal to %d are: \n", num);
Sieve_of_eratosthenes(num);
//Implementation of Optimized version of Sieve of Eratosthenes
printf("\n Using optimized version of code: \n");
bool * isprime = (bool * ) malloc(num * sizeof(bool));
sieve(num, isprime);
free(isprime);
return 0;
}
/*Sample Input:
Enter the number: 10
Sample Outut:
The prime numbers smaller than or equal to 10 are:
2 3 5 7
Using optimized version of code:
2 3 5 7
*/
| 25.621053 | 124 | 0.556286 |
d1f8ccfc87496e5c0e7c5dbd7bcebe7e3626cd1f | 9,246 | h | C | client/resources/framework/cmc/ext/cmc/intervalheap.h | 6l17ch-3xpl017/uchat | 15a206010a8a9df5ad8e6ab9a97c22ffff404720 | [
"Unlicense"
] | null | null | null | client/resources/framework/cmc/ext/cmc/intervalheap.h | 6l17ch-3xpl017/uchat | 15a206010a8a9df5ad8e6ab9a97c22ffff404720 | [
"Unlicense"
] | null | null | null | client/resources/framework/cmc/ext/cmc/intervalheap.h | 6l17ch-3xpl017/uchat | 15a206010a8a9df5ad8e6ab9a97c22ffff404720 | [
"Unlicense"
] | null | null | null | /**
* ext/cmc/intervalheap.h
*
* Creation Date: 02/06/2020
*
* Authors:
* Leonardo Vencovsky (https://github.com/LeoVen)
*
*/
#ifndef CMC_EXT_CMC_INTERVALHEAP_H
#define CMC_EXT_CMC_INTERVALHEAP_H
#include "../../cor/core.h"
/**
* All the EXT parts of CMC IntervalHeap.
*/
#define CMC_EXT_CMC_INTERVALHEAP_PARTS ITER, STR
/**
* ITER
*/
#define CMC_EXT_CMC_INTERVALHEAP_ITER(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_ITER_HEADER(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_ITER_SOURCE(PARAMS)
#define CMC_EXT_CMC_INTERVALHEAP_ITER_HEADER(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_ITER_HEADER_(CMC_PARAM_PFX(PARAMS), CMC_PARAM_SNAME(PARAMS), CMC_PARAM_V(PARAMS))
#define CMC_EXT_CMC_INTERVALHEAP_ITER_SOURCE(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_ITER_SOURCE_(CMC_PARAM_PFX(PARAMS), CMC_PARAM_SNAME(PARAMS), CMC_PARAM_V(PARAMS))
#define CMC_EXT_CMC_INTERVALHEAP_ITER_HEADER_(PFX, SNAME, V) \
\
/* IntervalHeap Iterator */ \
struct CMC_DEF_ITER(SNAME) \
{ \
/* Target IntervalHeap */ \
struct SNAME *target; \
\
/* Cursor's position (index) */ \
size_t cursor; \
\
/* If the iterator has reached the start of the iteration */ \
bool start; \
\
/* If the iterator has reached the end of the iteration */ \
bool end; \
}; \
\
/* Iterator Initialization */ \
struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \
struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \
/* Iterator State */ \
bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \
bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \
/* Iterator Movement */ \
bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \
bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \
bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \
bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \
bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps); \
bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps); \
bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, size_t index); \
/* Iterator Access */ \
V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \
size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter);
#define CMC_EXT_CMC_INTERVALHEAP_ITER_SOURCE_(PFX, SNAME, V) \
\
struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \
{ \
struct CMC_DEF_ITER(SNAME) iter; \
\
iter.target = target; \
iter.cursor = 0; \
iter.start = true; \
iter.end = CMC_(PFX, _empty)(target); \
\
return iter; \
} \
\
struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \
{ \
struct CMC_DEF_ITER(SNAME) iter; \
\
iter.target = target; \
iter.cursor = 0; \
iter.start = CMC_(PFX, _empty)(target); \
iter.end = true; \
\
if (!CMC_(PFX, _empty)(target)) \
iter.cursor = target->count - 1; \
\
return iter; \
} \
\
bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
return CMC_(PFX, _empty)(iter->target) || iter->start; \
} \
\
bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
return CMC_(PFX, _empty)(iter->target) || iter->end; \
} \
\
bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
if (!CMC_(PFX, _empty)(iter->target)) \
{ \
iter->cursor = 0; \
iter->start = true; \
iter->end = CMC_(PFX, _empty)(iter->target); \
\
return true; \
} \
\
return false; \
} \
\
bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
if (!CMC_(PFX, _empty)(iter->target)) \
{ \
iter->cursor = iter->target->count - 1; \
iter->start = CMC_(PFX, _empty)(iter->target); \
iter->end = true; \
\
return true; \
} \
\
return false; \
} \
\
bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
if (iter->end) \
return false; \
\
if (iter->cursor + 1 == iter->target->count) \
{ \
iter->end = true; \
return false; \
} \
\
iter->start = CMC_(PFX, _empty)(iter->target); \
\
iter->cursor++; \
\
return true; \
} \
\
bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
if (iter->start) \
return false; \
\
if (iter->cursor == 0) \
{ \
iter->start = true; \
return false; \
} \
\
iter->end = CMC_(PFX, _empty)(iter->target); \
\
iter->cursor--; \
\
return true; \
} \
\
/* Returns true only if the iterator moved */ \
bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps) \
{ \
if (iter->end) \
return false; \
\
if (iter->cursor + 1 == iter->target->count) \
{ \
iter->end = true; \
return false; \
} \
\
if (steps == 0 || iter->cursor + steps >= iter->target->count) \
return false; \
\
if (iter->end) \
return false; \
\
iter->start = CMC_(PFX, _empty)(iter->target); \
\
iter->cursor += steps; \
\
return true; \
} \
\
/* Returns true only if the iterator moved */ \
bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps) \
{ \
if (iter->start) \
return false; \
\
if (iter->cursor == 0) \
{ \
iter->start = true; \
return false; \
} \
\
if (steps == 0 || iter->cursor < steps) \
return false; \
\
iter->end = CMC_(PFX, _empty)(iter->target); \
\
iter->cursor -= steps; \
\
return true; \
} \
\
/* Returns true only if the iterator was able to be positioned at the */ \
/* given index */ \
bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, size_t index) \
{ \
if (index >= iter->target->count) \
return false; \
\
if (iter->cursor > index) \
return CMC_(PFX, _iter_rewind)(iter, iter->cursor - index); \
else if (iter->cursor < index) \
return CMC_(PFX, _iter_advance)(iter, index - iter->cursor); \
\
return true; \
} \
\
V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
if (CMC_(PFX, _empty)(iter->target)) \
return (V){ 0 }; \
\
return iter->target->buffer[iter->cursor / 2][iter->cursor % 2]; \
} \
\
size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \
{ \
return iter->cursor; \
}
/**
* STR
*/
#define CMC_EXT_CMC_INTERVALHEAP_STR(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_STR_HEADER(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_STR_SOURCE(PARAMS)
#define CMC_EXT_CMC_INTERVALHEAP_STR_HEADER(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_STR_HEADER_(CMC_PARAM_PFX(PARAMS), CMC_PARAM_SNAME(PARAMS), CMC_PARAM_V(PARAMS))
#define CMC_EXT_CMC_INTERVALHEAP_STR_SOURCE(PARAMS) \
CMC_EXT_CMC_INTERVALHEAP_STR_SOURCE_(CMC_PARAM_PFX(PARAMS), CMC_PARAM_SNAME(PARAMS), CMC_PARAM_V(PARAMS))
#define CMC_EXT_CMC_INTERVALHEAP_STR_HEADER_(PFX, SNAME, V) \
\
bool CMC_(PFX, _to_string)(struct SNAME * _heap_, FILE * fptr); \
bool CMC_(PFX, _print)(struct SNAME * _heap_, FILE * fptr, const char *start, const char *separator, \
const char *end);
#define CMC_EXT_CMC_INTERVALHEAP_STR_SOURCE_(PFX, SNAME, V) \
\
bool CMC_(PFX, _to_string)(struct SNAME * _heap_, FILE * fptr) \
{ \
struct SNAME *h_ = _heap_; \
\
return 0 <= fprintf(fptr, \
"struct %s<%s> " \
"at %p { " \
"buffer:%p, " \
"capacity:%" PRIuMAX ", " \
"size:%" PRIuMAX ", " \
"count:%" PRIuMAX ", " \
"flag:%d, " \
"f_val:%p, " \
"alloc:%p, " \
"callbacks:%p }", \
CMC_TO_STRING(SNAME), CMC_TO_STRING(V), h_, h_->buffer, h_->capacity, h_->size, h_->count, \
h_->flag, h_->f_val, h_->alloc, CMC_CALLBACKS_GET(h_)); \
} \
\
bool CMC_(PFX, _print)(struct SNAME * _heap_, FILE * fptr, const char *start, const char *separator, \
const char *end) \
{ \
fprintf(fptr, "%s", start); \
\
for (size_t i = 0; i < _heap_->count; i++) \
{ \
if (!_heap_->f_val->str(fptr, _heap_->buffer[i / 2][i % 2])) \
return false; \
\
if (i + 1 < _heap_->count) \
fprintf(fptr, "%s", separator); \
} \
\
fprintf(fptr, "%s", end); \
\
return true; \
}
#endif /* CMC_EXT_CMC_INTERVALHEAP_H */
| 30.019481 | 120 | 0.551698 |
d1fa01ff17906201015d77e7703d2898af81f14a | 16,021 | h | C | WDYBaseProject/Classes/UIComponent/ModalPresentationViewController.h | wangdongyang/WDYBaseProject | 863982cc88d4ca9a999f4653b89d1ce8a0a16687 | [
"MIT"
] | null | null | null | WDYBaseProject/Classes/UIComponent/ModalPresentationViewController.h | wangdongyang/WDYBaseProject | 863982cc88d4ca9a999f4653b89d1ce8a0a16687 | [
"MIT"
] | null | null | null | WDYBaseProject/Classes/UIComponent/ModalPresentationViewController.h | wangdongyang/WDYBaseProject | 863982cc88d4ca9a999f4653b89d1ce8a0a16687 | [
"MIT"
] | null | null | null | //
// ModalPresentationViewController.h
// MultiCustomUIComponent
//
// Created by fang wang on 17/1/13.
// Copyright © 2017年 wdy. All rights reserved.
//
#import <UIKit/UIKit.h>
@class ModalPresentationViewController;
typedef enum : NSUInteger {
ModalPresentationAnimationStyleFade, // 渐现渐隐，默认
ModalPresentationAnimationStylePopup, // 从中心点弹出
ModalPresentationAnimationStyleSlide // 从下往上升起
} ModalPresentationAnimationStyle;
@protocol ModalPresentationContentViewProtocol <NSObject>
@optional
/**
* 当浮层使用modalController提供的默认布局时，则可通过这个方法告诉modalController当前浮层期望的大小
* @param controller 当前的modalController
* @param limitSize 浮层最大的宽高，由当前modalController的大小及`contentViewMargins`、`maximumContentViewWidth`决定
* @return 返回浮层在`limitSize`限定内的大小，如果业务自身不需要限制宽度/高度，则为width/height返回CGFLOAT_MAX即可
*/
- (CGSize)preferredContentSizeInModalPresentationVC:(ModalPresentationViewController *)controller
limitSize:(CGSize)limitSize;
@end
@protocol ModalPresentationViewControllerDelegate <NSObject>
@optional
/**
* 是否应该隐藏浮层，会在调用`hideWithAnimated:completion:`时，以及点击背景遮罩时被调用。默认为YES。
* @param controller 当前的modalController
* @return 是否允许隐藏，YES表示允许隐藏，NO表示不允许隐藏
*/
- (BOOL)shouldHideModalPresentationViewController:(ModalPresentationViewController *)controller;
/**
* modalController隐藏后的回调函数，不管是直接调用`hideWithAnimated:completion:`，还是通过点击遮罩触发的隐藏，都会调用这个方法。
* 如果你想区分这两种方式的隐藏回调，请直接使用hideWithAnimated方法的completion参数，以及`didHideByDimmingViewTappedBlock`属性。
* @param controller 当前的modalController
*/
- (void)didHideModalPresentationViewController:(ModalPresentationViewController *)controller;
- (void)requestHideAllModalPresentationViewController;
@end
/**
* 一个提供通用的弹出浮层功能的控件，可以将任意`UIView`或`UIViewController`以浮层的形式显示出来并自动布局。
*
* 支持 3 种方式显示浮层：
*
* 1. **推荐** 新起一个 `UIWindow` 盖在当前界面上，将 `QMUIModalPresentationViewController` 以 `rootViewController` 的形式显示出来，可通过 `supportedOrientationMask` 支持横竖屏，不支持在浮层不消失的情况下做界面切换（因为 window 会把背后的 controller 盖住，看不到界面切换）
* @code
* [modalPresentationViewController showWithAnimated:YES completion:nil];
* @endcode
*
* 2. 使用系统接口来显示，支持界面切换，**注意** 使用这种方法必定只能以动画的形式来显示浮层，无法以无动画的形式来显示，并且 `animated` 参数必须为 `NO`。可通过 `supportedOrientationMask` 支持横竖屏。
* @code
* [self presentViewController:modalPresentationViewController animated:NO completion:nil];
* @endcode
*
* 3. 将浮层作为一个 subview 添加到 `superview` 上，从而能够实现在浮层不消失的情况下进行界面切换，但需要 `superview` 自行管理浮层的大小和横竖屏旋转，而且 `QMUIModalPresentationViewController` 不能用局部变量来保存，会在显示后被释放，需要自行 retain。横竖屏跟随当前界面的设置。
* @code
* self.modalPresentationViewController.view.frame = CGRectMake(50, 50, 100, 100);
* [self.view addSubview:self.modalPresentationViewController.view];
* @endcode
*
* 默认的布局会将浮层居中显示，浮层的大小可通过接口控制：
* 1. 如果是用 `contentViewController`，则可通过 `preferredContentSizeInModalPresentationViewController:limitSize:` 来设置
* 2. 如果使用 `contentView`，或者使用 `contentViewController` 但没实现 `preferredContentSizeInModalPresentationViewController:limitSize:`，则调用`contentView`的`sizeThatFits:`方法获取大小。
*
* 通过`layoutBlock`、`showingAnimation`、`hidingAnimation`可设置自定义的布局、打开及隐藏的动画，并允许你适配键盘升起时的场景。
*
* 默认提供背景遮罩`dimmingView`，你也可以使用自己的遮罩 view。
*
* 默认提供多种显示动画，可通过 `animationStyle` 来设置。
*
* @warning 如果使用者retain了modalPresentationViewController，注意应该在`hideWithAnimated:completion:`里release
*
* @see QMUIAlertController
* @see QMUIDialogViewController
* @see QMUIMoreOperationController
*/
@interface ModalPresentationViewController : UIViewController
@property(nonatomic, weak) id <ModalPresentationViewControllerDelegate> delegate;
/**
* 要被弹出的浮层
* @warning 当设置了`contentView`时，不要再设置`contentViewController`
*/
@property(nonatomic, strong) UIView *contentView;
/**
* 背景遮罩，默认为一个普通的`UIView`，背景色为`UIColorMask`，可设置为自己的view，注意`dimmingView`的大小将会盖满整个控件。
*
* `QMUIModalPresentationViewController`会自动给自定义的`dimmingView`添加手势以实现点击遮罩隐藏浮层。
*/
@property(nonatomic, strong) UIView *dimmingView;
/**
* 要被弹出的浮层，适用于浮层以UIViewController的形式来管理的情况。
* @warning 当设置了`contentViewController`时，`contentViewController.view`会被当成`contentView`使用，因此不要再自行设置`contentView`
* @warning 注意`contentViewController`是强引用，容易导致循环引用，使用时请注意
*/
@property(nonatomic, strong) UIViewController<ModalPresentationContentViewProtocol> *contentViewController;
/**
* 设置`contentView`布局时与外容器的间距，默认为(20, 20, 20, 20)
* @warning 当设置了`layoutBlock`属性时，此属性不生效
*/
@property(nonatomic, assign) UIEdgeInsets contentViewMargins UI_APPEARANCE_SELECTOR;
/**
* 限制`contentView`布局时的最大宽度，默认为iPhone 6竖屏下的屏幕宽度减去`contentViewMargins`在水平方向的值，
也即浮层在iPhone 6 Plus或iPad上的宽度以iPhone 6上的宽度为准。
* @warning 当设置了`layoutBlock`属性时，此属性不生效
*/
@property(nonatomic, assign) CGFloat maximumContentViewWidth UI_APPEARANCE_SELECTOR;
/**
* 由于点击遮罩导致浮层被隐藏时的回调（区分于`hideWithAnimated:completion:`里的completion，这里是特地用于点击遮罩的情况）
*/
@property(nonatomic, copy) void (^didHideByDimmingViewTappedBlock)();
/**
* 控制当前是否以模态的形式存在。如果以模态的形式存在，则点击空白区域不会隐藏浮层。
*
* 默认为NO，也即点击空白区域将会自动隐藏浮层。
*/
@property(nonatomic, assign, getter=isModal) BOOL modal;
/**
* 标志当前浮层的显示/隐藏状态，默认为NO。
*/
@property(nonatomic, assign, readonly, getter=isVisible) BOOL visible;
/**
* 修改当前界面要支持的横竖屏方向，默认为 SupportedOrientationMask。
*/
@property(nonatomic, assign) UIInterfaceOrientationMask supportedOrientationMask;
/**
* 设置要使用的显示/隐藏动画的类型，默认为`ModalPresentationAnimationStyleFade`。
* @warning 当使用了`showingAnimation`和`hidingAnimation`时，该属性无效
*/
@property(nonatomic, assign) ModalPresentationAnimationStyle animationStyle UI_APPEARANCE_SELECTOR;
/**
* 管理自定义的浮层布局，将会在浮层显示前、控件的容器大小发生变化时（例如横竖屏、来电状态栏）被调用
* @arg containerBounds 浮层所在的父容器的大小，也即`self.view.bounds`
* @arg keyboardHeight 键盘在当前界面里的高度，若无键盘，则为0
* @arg contentViewDefaultFrame 不使用自定义布局的情况下的默认布局，会受`contentViewMargins`、`maximumContentViewWidth`、`contentView sizeThatFits:`的影响
*
* @see contentViewMargins
* @see maximumContentViewWidth
*/
@property(nonatomic, copy) void (^layoutBlock)(CGRect containerBounds, CGFloat keyboardHeight, CGRect contentViewDefaultFrame);
/**
* 管理自定义的显示动画，需要管理的对象包括`contentView`和`dimmingView`，在`showingAnimation`被调用前，`contentView`已被添加到界面上。若使用了`layoutBlock`，则会先调用`layoutBlock`，再调用`showingAnimation`。在动画结束后，必须调用参数里的`completion` block。
* @arg dimmingView 背景遮罩的View，请自行设置显示遮罩的动画
* @arg containerBounds 浮层所在的父容器的大小，也即`self.view.bounds`
* @arg keyboardHeight 键盘在当前界面里的高度，若无键盘，则为0
* @arg contentViewFrame 动画执行完后`contentView`的最终frame，若使用了`layoutBlock`，则也即`layoutBlock`计算完后的frame
* @arg completion 动画结束后给到modalController的回调，modalController会在这个回调里做一些状态设置，务必调用。
*/
@property(nonatomic, copy) void (^showingAnimation)(UIView *dimmingView, CGRect containerBounds, CGFloat keyboardHeight, CGRect contentViewFrame, void(^completion)(BOOL finished));
/**
* 管理自定义的隐藏动画，需要管理的对象包括`contentView`和`dimmingView`，在动画结束后，必须调用参数里的`completion` block。
* @arg dimmingView 背景遮罩的View，请自行设置隐藏遮罩的动画
* @arg containerBounds 浮层所在的父容器的大小，也即`self.view.bounds`
* @arg keyboardHeight 键盘在当前界面里的高度，若无键盘，则为0
* @arg completion 动画结束后给到modalController的回调，modalController会在这个回调里做一些清理工作，务必调用
*/
@property(nonatomic, copy) void (^hidingAnimation)(UIView *dimmingView, CGRect containerBounds, CGFloat keyboardHeight, void(^completion)(BOOL finished));
/**
* 将浮层以 UIWindow 的方式显示出来
* @param animated 是否以动画的形式显示
* @param completion 显示动画结束后的回调
*/
- (void)showWithAnimated:(BOOL)animated completion:(void (^)(BOOL finished))completion;
/**
* 将浮层隐藏掉
* @param animated 是否以动画的形式隐藏
* @param completion 隐藏动画结束后的回调
* @warning 这里的`completion`只会在你显式调用`hideWithAnimated:completion:`方法来隐藏浮层时会被调用，如果你通过点击`dimmingView`来触发`hideWithAnimated:completion:`，则completion是不会被调用的，那种情况下如果你要在浮层隐藏后做一些事情，请使用`delegate`提供的`didHideModalPresentationViewController:`方法。
*/
- (void)hideWithAnimated:(BOOL)animated completion:(void (^)(BOOL finished))completion;
/**
* 将浮层以 addSubview 的方式显示出来
*
* @param view 要显示到哪个 view 上
* @param animated 是否以动画的形式显示
* @param completion 显示动画结束后的回调
*/
- (void)showInView:(UIView *)view animated:(BOOL)animated completion:(void (^)(BOOL finished))completion;
/**
* 将某个 view 上显示的浮层隐藏掉
* @param view 要隐藏哪个 view 上的浮层
* @param animated 是否以动画的形式隐藏
* @param completion 隐藏动画结束后的回调
* @warning 这里的`completion`只会在你显式调用`hideInView:animated:completion:`方法来隐藏浮层时会被调用，如果你通过点击`dimmingView`来触发`hideInView:animated:completion:`，则completion是不会被调用的，那种情况下如果你要在浮层隐藏后做一些事情，请使用`delegate`提供的`didHideModalPresentationViewController:`方法。
*/
- (void)hideInView:(UIView *)view animated:(BOOL)animated completion:(void (^)(BOOL finished))completion;
@end
@interface ModalPresentationViewController (Manager)
/**
* 判断当前App里是否有modalViewController正在显示（存在modalViewController但不可见的时候，也视为不存在）
* @return 只要存在正在显示的浮层，则返回YES，否则返回NO
*/
+ (BOOL)isAnyModalPresentationViewControllerVisible;
/**
* 把所有正在显示的并且允许被隐藏的modalViewController都隐藏掉
* @return 只要遇到一个正在显示的并且不能被隐藏的浮层，就会返回NO，否则都返回YES，表示成功隐藏掉所有可视浮层
* @see shouldHideModalPresentationViewController:
*/
+ (BOOL)hideAllVisibleModalPresentationViewControllerIfCan;
@end
@interface ModalPresentationViewController (UIAppearance)
+ (instancetype)appearance;
@end
@interface UIViewController (ModalPresentationViewController)
/**
* 获取弹出当前vieController的QMUIModalPresentationViewController
*/
@property(nonatomic, weak, readonly) ModalPresentationViewController *modalPresentedViewController;
@end
@interface UIViewController (Helper)
/**
* 获取当前controller里的最高层可见viewController（可见的意思是还会判断self.view.window是否存在）
*
* @see 如果要获取当前App里的可见viewController，请使用<i>[Helper visibleViewController]</i>
*
* @return 当前controller里的最高层可见viewController
*/
- (UIViewController *)visibleViewControllerIfExist;
@end
@interface ModalPresentationWindow : UIWindow
@end
/**********************************************************************************************************/
// 使用介绍
/*
// 自定义显示 和 隐藏动画
- (void)handleLayoutBlockAndAnimation {
UIView *contentView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 300, 400)];
contentView.backgroundColor = [UIColor blackColor];
contentView.layer.cornerRadius = 6;
UILabel *label = [[UILabel alloc] init];
label.numberOfLines = 0;
label.text = @"hello world!";
label.textAlignment = NSTextAlignmentCenter;
label.frame = CGRectMake(0, 0, contentView.frame.size.width, 50);
label.center = CGPointMake(contentView.center.x, contentView.center.y - 20);
[contentView addSubview:label];
UITextField* textField = [[UITextField alloc] init];
textField.frame = CGRectMake(0, 0, contentView.frame.size.width, 30);
textField.center = CGPointMake(contentView.center.x, contentView.center.y + 40);
[contentView addSubview:textField];
ModalPresentationViewController *modalViewController = [[ModalPresentationViewController alloc] init];
modalViewController.contentView = contentView;
// modalViewController.layoutBlock = ^(CGRect containerBounds, CGFloat keyboardHeight, CGRect contentViewDefaultFrame) {
// CGFloat contentViewX = (containerBounds.origin.x - contentView.frame.origin.x)*0.5;
// CGFloat contentViewY = (containerBounds.origin.y - contentView.frame.origin.y)*0.5;
// contentView.frame = CGRectMake(100,
// 100,
// (CGRectGetWidth(containerBounds)-CGRectGetWidth(contentView.frame))*0.5,
// CGRectGetHeight(containerBounds) - 20 - CGRectGetHeight(contentView.frame));
// };
modalViewController.showingAnimation = ^(UIView *dimmingView, CGRect containerBounds, CGFloat keyboardHeight, CGRect contentViewFrame, void(^completion)(BOOL finished)) {
// CGFloat contentViewX = (containerBounds.origin.x - contentView.frame.origin.x)*0.5;
// CGFloat contentViewY = (containerBounds.origin.y - contentView.frame.origin.y)*0.5;
// CGFloat contentViewW = contentView.frame.size.width;
// CGFloat contentViewH = contentView.frame.size.height;
// contentView.frame = CGRectMake(100, 100, contentViewW, contentViewH);
dimmingView.alpha = 0;
[UIView animateWithDuration:.3 delay:0.0 options:QMUIViewAnimationOptionsCurveOut animations:^{
dimmingView.alpha = 1;
contentView.frame = contentViewFrame;
} completion:^(BOOL finished) {
// 记住一定要在适当的时机调用completion()
if (completion) {
completion(finished);
}
}];
};
modalViewController.hidingAnimation = ^(UIView *dimmingView, CGRect containerBounds, CGFloat keyboardHeight, void(^completion)(BOOL finished)) {
[UIView animateWithDuration:.3 delay:0.0 options:QMUIViewAnimationOptionsCurveOut animations:^{
dimmingView.alpha = 0.0;
} completion:^(BOOL finished) {
// 记住一定要在适当的时机调用completion()
if (completion) {
completion(finished);
}
}];
};
[modalViewController showWithAnimated:YES completion:nil];
}
- (void)customDimmingView{
UIView *contentView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 300, 400)];
contentView.backgroundColor = [UIColor whiteColor];
contentView.layer.cornerRadius = 6;
UIImageView* imageV = [[UIImageView alloc] init];
imageV.image = [UIImage imageNamed:@"name01.jpeg"];
ModalPresentationViewController *modalViewController = [[ModalPresentationViewController alloc] init];
modalViewController.dimmingView = imageV;
modalViewController.contentView = contentView;
[modalViewController showWithAnimated:YES completion:nil];
}
// 内容是控制器的时候
- (void)testContentViewController{
ModalContentViewController* vc = [[ModalContentViewController alloc] init];
ModalPresentationViewController *modalViewController = [[ModalPresentationViewController alloc] init];
modalViewController.contentViewController = vc;
modalViewController.maximumContentViewWidth = CGFLOAT_MAX;
[modalViewController showWithAnimated:YES completion:nil];
}
// 弹出动画，文本框键盘处理
- (void)testModalViewController{
UIView *contentView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 300, 400)];
contentView.backgroundColor = [UIColor whiteColor];
contentView.layer.cornerRadius = 6;
UILabel *label = [[UILabel alloc] init];
label.numberOfLines = 0;
label.text = @"hello world!";
label.textAlignment = NSTextAlignmentCenter;
label.frame = CGRectMake(0, 0, contentView.frame.size.width, 50);
label.center = CGPointMake(contentView.center.x, contentView.center.y - 20);
[contentView addSubview:label];
UITextField* textField = [[UITextField alloc] init];
textField.frame = CGRectMake(0, 0, contentView.frame.size.width, 30);
textField.center = CGPointMake(contentView.center.x, contentView.center.y + 40);
[contentView addSubview:textField];
// 以Window方式弹出
ModalPresentationViewController *modalViewController = [[ModalPresentationViewController alloc] init];
modalViewController.contentView = contentView;
// modalViewController.maximumContentViewWidth = CGFLOAT_MAX;
[modalViewController showWithAnimated:YES completion:nil];
// [self presentViewController:modalViewController animated:NO completion:nil];
// if (self.myModalViewController) {
// [self.myModalViewController hideInView:self.view animated:YES completion:nil];
// }
//
// self.myModalViewController = [[ModalPresentationViewController alloc] init];
// self.myModalViewController.contentView = contentView;
// self.myModalViewController.animationStyle = ModalPresentationAnimationStylePopup;
// self.myModalViewController.view.frame = self.view.bounds;
// [self.myModalViewController showInView:self.view animated:YES completion:nil];
}
*/
| 37.171694 | 239 | 0.740715 |
d1fa721b72dc16038a8fbd471392d2f592be8555 | 2,104 | c | C | test_projects/nif/c_src/example/example.c | vanillahsu/unifex | a501479b611a94c8a1477d969e170a7280673b7c | [
"Apache-2.0"
] | 42 | 2018-09-11T02:27:00.000Z | 2022-03-23T18:30:56.000Z | test_projects/nif/c_src/example/example.c | vanillahsu/unifex | a501479b611a94c8a1477d969e170a7280673b7c | [
"Apache-2.0"
] | 30 | 2018-10-18T10:56:22.000Z | 2022-03-09T13:04:51.000Z | test_projects/nif/c_src/example/example.c | vanillahsu/unifex | a501479b611a94c8a1477d969e170a7280673b7c | [
"Apache-2.0"
] | 7 | 2018-10-24T09:21:40.000Z | 2022-03-29T12:39:08.000Z | #include "example.h"
int example_was_handle_load_called = 0;
int handle_load(UnifexEnv *env, void **priv_data) {
UNIFEX_UNUSED(env);
UNIFEX_UNUSED(priv_data);
example_was_handle_load_called = 1;
return 0;
}
UNIFEX_TERM init(UnifexEnv *env) {
MyState *state = unifex_alloc_state(env);
state->a = 42;
UNIFEX_TERM res = init_result_ok(env, example_was_handle_load_called, state);
unifex_release_state(env, state);
return res;
}
UNIFEX_TERM test_atom(UnifexEnv *env, char *in_atom) {
return test_atom_result_ok(env, in_atom);
}
UNIFEX_TERM test_float(UnifexEnv *env, double in_float) {
return test_float_result_ok(env, in_float);
}
UNIFEX_TERM test_int(UnifexEnv *env, int in_int) {
return test_int_result_ok(env, in_int);
}
UNIFEX_TERM test_string(UnifexEnv *env, char *str) {
return test_string_result_ok(env, str);
}
UNIFEX_TERM test_list(UnifexEnv *env, int *in_list, unsigned int list_length) {
return test_list_result_ok(env, in_list, list_length);
}
UNIFEX_TERM test_list_of_strings(UnifexEnv *env, char **in_strings,
unsigned int list_length) {
return test_list_of_strings_result_ok(env, in_strings, list_length);
}
UNIFEX_TERM test_pid(UnifexEnv *env, UnifexPid in_pid) {
return test_pid_result_ok(env, in_pid);
}
UNIFEX_TERM test_state(UnifexEnv *env, MyState *state) {
return test_state_result_ok(env, state);
}
UNIFEX_TERM test_example_message(UnifexEnv *env, UnifexPid pid) {
int res = send_example_msg(env, pid, 0, 10);
if (!res) {
return test_example_message_result_error(env, "send_failed");
}
return test_example_message_result_ok(env);
}
UNIFEX_TERM test_my_struct(UnifexEnv *env, my_struct in_struct) {
return test_my_struct_result_ok(env, in_struct);
}
UNIFEX_TERM test_my_enum(UnifexEnv *env, MyEnum in_enum) {
return test_my_enum_result_ok(env, in_enum);
}
UNIFEX_TERM test_nested_struct(UnifexEnv *env, nested_struct in_struct) {
return test_nested_struct_result_ok(env, in_struct);
}
void handle_destroy_state(UnifexEnv *env, MyState *state) {
UNIFEX_UNUSED(env);
state->a = 0;
} | 27.684211 | 79 | 0.75903 |
d1fb39152a3ca6ffb11c970ac2772b903ed81e49 | 1,304 | h | C | components/sync/model/local_change_observer.h | google-ar/chromium | 2441c86a5fd975f09a6c30cddb57dfb7fc239699 | [
"Apache-2.0",
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | components/sync/model/local_change_observer.h | harrymarkovskiy/WebARonARCore | 2441c86a5fd975f09a6c30cddb57dfb7fc239699 | [
"Apache-2.0",
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | components/sync/model/local_change_observer.h | harrymarkovskiy/WebARonARCore | 2441c86a5fd975f09a6c30cddb57dfb7fc239699 | [
"Apache-2.0",
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_SYNC_MODEL_LOCAL_CHANGE_OBSERVER_H_
#define COMPONENTS_SYNC_MODEL_LOCAL_CHANGE_OBSERVER_H_
namespace syncer {
class SyncChange;
namespace syncable {
class Entry;
} // namespace syncable
// Interface for observers that want to be notified of local sync changes.
// The OnLocalChange function will be called when a local change made through
// ProcessSyncChanges is about to be applied to the directory. This is useful
// for inspecting the specifics of sync data being written locally and comparing
// it against the current state of the directory. Registering a local change
// observer is done by calling the AddLocalChangeObserver function on an
// instance of SyncChangeProcessor.
class LocalChangeObserver {
public:
virtual ~LocalChangeObserver() {}
// Function called to notify observer of the local change. current_entry
// should reflect the state of the entry *before* change is applied.
virtual void OnLocalChange(const syncable::Entry* current_entry,
const SyncChange& change) = 0;
};
} // namespace syncer
#endif // COMPONENTS_SYNC_MODEL_LOCAL_CHANGE_OBSERVER_H_
| 39.515152 | 80 | 0.77684 |
06013bccaacdc2a365f05dbdc529e17809bbdcfc | 916 | h | C | qWebTest/qskinobject/config/configurator.h | privet56/qWebTest | d85166445d04d9fe918b7225986cf62b7e757797 | [
"Apache-2.0"
] | null | null | null | qWebTest/qskinobject/config/configurator.h | privet56/qWebTest | d85166445d04d9fe918b7225986cf62b7e757797 | [
"Apache-2.0"
] | null | null | null | qWebTest/qskinobject/config/configurator.h | privet56/qWebTest | d85166445d04d9fe918b7225986cf62b7e757797 | [
"Apache-2.0"
] | null | null | null | #ifndef CONFIGURATOR_H_
#define CONFIGURATOR_H_
#include <QtGui>
#include "ui_configurator.h"
#include "../qskinobject/qskinobject.h"
class Configurator : public QWidget, public Ui::configurator
{
Q_OBJECT
public:
Configurator(QWidget *parent = 0);
void initData();
public slots:
void skinOnToggled(int skio);
void initSkinList();
void Erstellen();
void changeBCS()
{
BCS = QColorDialog::getColor(Qt::white, this);
QPixmap pxm(32,32);
pxm.fill(BCS);
bcs->setIcon(QIcon(pxm));
}
void changeTCS()
{
TCS = QColorDialog::getColor(Qt::black, this);
QPixmap pxm(32,32);
pxm.fill(TCS);
tcs->setIcon(QIcon(pxm));
}
void changeFS()
{
bool ok;
FS = QFontDialog::getFont(
&ok, QFont("Comic Sans MS", 8), this);
if (ok)
fs->setFont(FS);
}
private:
QSkinObject *qskinobject;
QColor BCS,TCS;
QFont FS;
};
#endif
| 19.489362 | 60 | 0.633188 |
0601b7018ce8f54c982910490256789295a92c7f | 1,284 | h | C | src/arpmonitorworker.h | ktemelkov/arp-monitor | 2e7914768d841a3665d8e25135e4a5449aa3298a | [
"MIT"
] | null | null | null | src/arpmonitorworker.h | ktemelkov/arp-monitor | 2e7914768d841a3665d8e25135e4a5449aa3298a | [
"MIT"
] | null | null | null | src/arpmonitorworker.h | ktemelkov/arp-monitor | 2e7914768d841a3665d8e25135e4a5449aa3298a | [
"MIT"
] | null | null | null | #include <napi.h>
#include <pcap/pcap.h>
/**
*
*/
class ArpMonitorWorker : public Napi::AsyncProgressQueueWorker<u_char> {
public:
/**
*
*/
ArpMonitorWorker(const Napi::Env& env, Napi::String intfName, Napi::Array hwAddr, Napi::Function& progressCallback, ArpMonitorWorker** parentPointer);
/**
*
*/
virtual ~ArpMonitorWorker();
/**
*
*/
void Execute(const ExecutionProgress& progress);
/**
*
*/
void OnProgress(const u_char* frame, size_t len);
/**
* Executed when the async work is complete
* this function will be run inside the main event loop
* so it is safe to use JS engine data again
*/
void OnOK();
/**
*
*/
void OnError(Napi::Error const &error);
/**
*
*/
Napi::Promise Start() {
return deferredStart.Promise();
}
/**
*
*/
Napi::Promise Stop() {
this->stopArpMonitorThread = true;
return deferredStop.Promise();
}
protected:
/**
*
*/
pcap_t* InitCapture();
private:
std::string interfaceName;
uint8_t hardwareAddress[6];
uint32_t Xid;
Napi::ObjectReference hosts;
Napi::Promise::Deferred deferredStart;
Napi::Promise::Deferred deferredStop;
volatile bool stopArpMonitorThread;
ArpMonitorWorker** parentPointerToThisWorker;
};
| 16.253165 | 152 | 0.642523 |
06020c358c6a021f31c34d52ae3cd1d60a68dfec | 1,031 | h | C | plot_2D_opengl.h | RomanFesenko/SurfaceViewer | e8f27946ae3bce125b4c6639d9315e4652f401e5 | [
"MIT"
] | null | null | null | plot_2D_opengl.h | RomanFesenko/SurfaceViewer | e8f27946ae3bce125b4c6639d9315e4652f401e5 | [
"MIT"
] | null | null | null | plot_2D_opengl.h | RomanFesenko/SurfaceViewer | e8f27946ae3bce125b4c6639d9315e4652f401e5 | [
"MIT"
] | null | null | null |
#ifndef _plot_2D_opengl_
#define _plot_2D_opengl_
#include <utility>
#include <functional>
#include "plot_2D_base.h"
class COpenGLDrawer2D:public CDrawer2D
{
using point_t=Eigen::Vector2f;
using box_t=Eigen::AlignedBox<float,2>;
bool m_domain_init=false;
bool m_draw=false;
const float m_back_disp=+0.5;
public:
std::function<std::pair<int,int>()> fn_sizes;
COpenGLDrawer2D() {}
virtual viewport_t AvailableViewport()const;
virtual void SetMatrix(const Eigen::Matrix3f&)override;
virtual void DrawLineBegin()override;
virtual void DrawEnd()override;
virtual void DrawLine(const point_t&,const point_t&)override;
virtual void SetColor(const Eigen::Vector3f&)override;
virtual void SetWidth(int)override;
virtual void FillBackground(const box_t&)override;
//dummy
virtual int StringHeight(const std::string&)const{return 1;}
virtual int StringWidth(const std::string&)const{return 1;}
virtual void StringOut(const std::string&,int x,int y){}
};
#endif
| 28.638889 | 64 | 0.735209 |
060744f96b9f853315274212f927ac3d9236bf6a | 602 | h | C | resources/Wireshark/WiresharkDissectorFoo/epan/dissectors/packet-bssap.h | joshis1/C_Programming | 4a8003321251448a167bfca0b595c5eeab88608d | [
"MIT"
] | 2 | 2020-09-11T05:51:42.000Z | 2020-12-31T11:42:02.000Z | resources/Wireshark/WiresharkDissectorFoo/epan/dissectors/packet-bssap.h | joshis1/C_Programming | 4a8003321251448a167bfca0b595c5eeab88608d | [
"MIT"
] | null | null | null | resources/Wireshark/WiresharkDissectorFoo/epan/dissectors/packet-bssap.h | joshis1/C_Programming | 4a8003321251448a167bfca0b595c5eeab88608d | [
"MIT"
] | null | null | null | /* packet-bssap.h
* Routines for Base Station Subsystem Application Part (BSSAP/BSAP) dissection
* Specifications from 3GPP2 (www.3gpp2.org) and 3GPP (www.3gpp.org)
* IOS 4.0.1 (BSAP)
* GSM 08.06 (BSSAP)
*
* Copyright 2003, Michael Lum <mlum [AT] telostech.com>
* In association with Telos Technology Inc.
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#define BSSAP_PDU_TYPE_BSSMAP 0x00
#define BSSAP_PDU_TYPE_DTAP 0x01
#define BSSAP_PDU_TYPE_BSMAP BSSAP_PDU_TYPE_BSSMAP
| 28.666667 | 79 | 0.750831 |
0607edd1d90c51b5b39812f18c6a3cdb127c9f3d | 4,266 | c | C | Clothing Adviser/ColorPaletteRatingMATLAB/getPlaneFeatures.c | pallik/OutfitAdvisor | 37611cb5601e240cd58d5c49d82fe1ae4ac1196f | [
"MIT"
] | null | null | null | Clothing Adviser/ColorPaletteRatingMATLAB/getPlaneFeatures.c | pallik/OutfitAdvisor | 37611cb5601e240cd58d5c49d82fe1ae4ac1196f | [
"MIT"
] | null | null | null | Clothing Adviser/ColorPaletteRatingMATLAB/getPlaneFeatures.c | pallik/OutfitAdvisor | 37611cb5601e240cd58d5c49d82fe1ae4ac1196f | [
"MIT"
] | null | null | null | /*
* getPlaneFeatures.c
*
* Code generation for function 'getPlaneFeatures'
*
* C source code generated on: Sat Jan 10 16:52:51 2015
*
*/
/* Include files */
#include "rateColorPalette.h"
#include "getPlaneFeatures.h"
#include "sum.h"
#include "pca2.h"
/* Function Definitions */
void getPlaneFeatures(const real_T X_data[15], const int32_T X_size[2], real_T
normal[3], real_T pctExplained_data[3], int32_T
pctExplained_size[2], real_T meanX[3], real_T *sse)
{
real_T b_X_data[15];
int32_T b_X_size[2];
int32_T br;
int32_T ia;
int32_T k;
int32_T roots_size[2];
real_T roots_data[7];
real_T coeff[9];
int32_T signals_size[2];
real_T signals_data[15];
int8_T sz[2];
real_T sumRoots_data[1];
int32_T ib;
int32_T ix;
real_T s;
boolean_T x_data[1];
boolean_T y;
boolean_T exitg1;
int8_T mv[2];
real_T y_data[5];
real_T error_data[5];
b_X_size[0] = 3;
b_X_size[1] = X_size[0];
br = X_size[0];
for (ia = 0; ia < br; ia++) {
for (k = 0; k < 3; k++) {
b_X_data[k + 3 * ia] = X_data[ia + X_size[0] * k];
}
}
pca2(b_X_data, b_X_size, signals_data, signals_size, coeff, roots_data,
roots_size);
for (ia = 0; ia < 3; ia++) {
normal[ia] = coeff[6 + ia];
}
if (coeff[6] < 0.0) {
for (ia = 0; ia < 3; ia++) {
normal[ia] = -coeff[6 + ia];
}
}
for (ia = 0; ia < 2; ia++) {
sz[ia] = (int8_T)roots_size[ia];
}
ib = sz[1];
if ((roots_size[0] == 0) || (roots_size[1] == 0)) {
ib = sz[1];
br = sz[1];
for (ia = 0; ia < br; ia++) {
sumRoots_data[ia] = 0.0;
}
} else {
ix = -1;
s = roots_data[0];
for (k = 2; k <= roots_size[0]; k++) {
ix++;
s += roots_data[ix + 1];
}
sumRoots_data[0] = s;
}
br = ib;
for (ia = 0; ia < br; ia++) {
x_data[ia] = (sumRoots_data[ia] == 0.0);
}
y = TRUE;
ix = 1;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (ix <= ib)) {
if (x_data[0] == 0) {
y = FALSE;
exitg1 = TRUE;
} else {
ix = 2;
}
}
if (y) {
pctExplained_size[0] = 1;
pctExplained_size[1] = 3;
for (ia = 0; ia < 3; ia++) {
pctExplained_data[ia] = 0.0;
}
} else {
pctExplained_size[0] = roots_size[1];
pctExplained_size[1] = roots_size[0];
br = roots_size[0];
for (ia = 0; ia < br; ia++) {
ix = roots_size[1];
for (k = 0; k < ix; k++) {
pctExplained_data[k + roots_size[1] * ia] = roots_data[ia + roots_size[0]
* k] / sumRoots_data[k + ia];
}
}
}
sum(X_data, X_size, meanX);
for (ia = 0; ia < 3; ia++) {
meanX[ia] /= (real_T)X_size[0];
}
mv[0] = (int8_T)X_size[0];
mv[1] = 1;
for (ia = 0; ia < 2; ia++) {
sz[ia] = (int8_T)((1 + (ia << 1)) * mv[ia]);
}
if (sz[0] == 0) {
} else {
ia = 1;
ib = 0;
ix = 1;
for (k = 0; k < 3; k++) {
for (br = 1; br <= (int8_T)X_size[0]; br++) {
b_X_data[ib] = meanX[ix - 1];
ia = ix + 1;
ib++;
}
ix = ia;
}
}
br = X_size[0] * X_size[1];
for (ia = 0; ia < br; ia++) {
b_X_data[ia] = X_data[ia] - b_X_data[ia];
}
br = (int8_T)X_size[0];
for (ia = 0; ia < br; ia++) {
y_data[ia] = 0.0;
}
if (X_size[0] == 0) {
} else {
ix = 0;
while ((X_size[0] > 0) && (ix <= 0)) {
for (k = 1; k <= X_size[0]; k++) {
y_data[k - 1] = 0.0;
}
ix = X_size[0];
}
br = 0;
ix = 0;
while ((X_size[0] > 0) && (ix <= 0)) {
ix = 0;
for (ib = br; ib + 1 <= br + 3; ib++) {
if (normal[ib] != 0.0) {
ia = ix;
for (k = 0; k + 1 <= X_size[0]; k++) {
ia++;
y_data[k] += normal[ib] * b_X_data[ia - 1];
}
}
ix += X_size[0];
}
br += 3;
ix = X_size[0];
}
}
for (k = 0; k < (int8_T)X_size[0]; k++) {
error_data[k] = fabs(y_data[k]);
}
for (k = 0; k < (int8_T)X_size[0]; k++) {
y_data[k] = error_data[k] * error_data[k];
}
if ((int8_T)X_size[0] == 0) {
*sse = 0.0;
} else {
*sse = y_data[0];
for (k = 2; k <= (int8_T)X_size[0]; k++) {
*sse += y_data[k - 1];
}
}
}
/* End of code generation (getPlaneFeatures.c) */
| 20.411483 | 81 | 0.474449 |
0608bf1165304473b1f21dbe99f2e62e438e888c | 85 | h | C | tools/Ubertooth/firmware/btbr/include/ubtbr/master_state.h | Charmve/BLE-Security-Att-Def | 3652d84bf4ac0c694bb3c4c0f611098da9122af0 | [
"BSD-2-Clause"
] | 149 | 2020-10-23T23:31:51.000Z | 2022-03-15T00:25:35.000Z | tools/Ubertooth/firmware/btbr/include/ubtbr/master_state.h | Charmve/BLE-Security-Att-Def | 3652d84bf4ac0c694bb3c4c0f611098da9122af0 | [
"BSD-2-Clause"
] | 1 | 2021-04-12T19:24:00.000Z | 2021-04-27T03:11:07.000Z | tools/Ubertooth/firmware/btbr/include/ubtbr/master_state.h | Charmve/BLE-Security-Att-Def | 3652d84bf4ac0c694bb3c4c0f611098da9122af0 | [
"BSD-2-Clause"
] | 22 | 2020-11-17T02:52:40.000Z | 2022-03-15T00:26:38.000Z | #ifndef __MASTER_TASK_H
#define __MASTER_TASK_H
void master_state_init(void);
#endif
| 17 | 29 | 0.847059 |
4d4252d1a0894f5c7036bd678771e4a6cdeb6a96 | 714 | h | C | src/lllengine.h | gligneul/Lua-LLVM | 1579b46e28d9ca16b70b9e9f3c11b389734eca00 | [
"MIT"
] | 12 | 2016-02-26T02:50:59.000Z | 2021-05-27T00:56:16.000Z | src/lllengine.h | gligneul/Lua-LLVM | 1579b46e28d9ca16b70b9e9f3c11b389734eca00 | [
"MIT"
] | null | null | null | src/lllengine.h | gligneul/Lua-LLVM | 1579b46e28d9ca16b70b9e9f3c11b389734eca00 | [
"MIT"
] | 1 | 2021-03-25T18:56:50.000Z | 2021-03-25T18:56:50.000Z | /*
** LLL - Lua Low Level
** September, 2015
** Author: Gabriel de Quadros Ligneul
** Copyright Notice for LLL: see lllcore.h
**
** lllengine.h
*/
#ifndef LLLENGINE_H
#define LLLENGINE_H
#include <memory>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
namespace lll {
class Engine {
public:
Engine(llvm::ExecutionEngine* ee, llvm::Module* module,
llvm::Function* function);
// Gets the compiled function
void* GetFunction();
// Dumps the compiled modules
void Dump();
// Writes the bytecode and asm files
void Write(const std::string& path);
private:
std::unique_ptr<llvm::ExecutionEngine> ee_;
llvm::Module* module_;
void* function_;
};
}
#endif
| 16.604651 | 59 | 0.672269 |
4d427687cd6ecd52cb367481eb37a0980a682b0f | 229 | h | C | test/unit-test/src/test-mbus-001.h | solosTec/node | e35e127867a4f66129477b780cbd09c5231fc7da | [
"MIT"
] | 2 | 2020-03-03T12:40:29.000Z | 2021-05-06T06:20:19.000Z | test/unit-test/src/test-mbus-001.h | solosTec/node | e35e127867a4f66129477b780cbd09c5231fc7da | [
"MIT"
] | 7 | 2020-01-14T20:38:04.000Z | 2021-05-17T09:52:07.000Z | test/unit-test/src/test-mbus-001.h | solosTec/node | e35e127867a4f66129477b780cbd09c5231fc7da | [
"MIT"
] | 2 | 2019-11-09T09:14:48.000Z | 2020-03-03T12:40:30.000Z | /*
* The MIT License (MIT)
*
* Copyright (c) 2018 Sylko Olzscher
*
*/
#ifndef TEST_MBUS_001_H
#define TEST_MBUS_001_H
#include <NODE_project_info.h>
namespace node
{
bool test_mbus_001();
}
#endif // TEST_MBUS_001_H
| 13.470588 | 37 | 0.69869 |
4d447ce36fbb5c1c263b3cb3ade2098734cfdc93 | 1,001 | h | C | include/QMarkdown/extensions/admonition.h | mugwort-rc/QMarkdown | cd865b41ef6038d32d109bdb0eae830ed1eb14a3 | [
"BSD-3-Clause"
] | null | null | null | include/QMarkdown/extensions/admonition.h | mugwort-rc/QMarkdown | cd865b41ef6038d32d109bdb0eae830ed1eb14a3 | [
"BSD-3-Clause"
] | null | null | null | include/QMarkdown/extensions/admonition.h | mugwort-rc/QMarkdown | cd865b41ef6038d32d109bdb0eae830ed1eb14a3 | [
"BSD-3-Clause"
] | null | null | null | #ifndef ADMONITION_H
#define ADMONITION_H
/*!
* Admonition extension for Python-Markdown
* ========================================
*
* Adds rST-style admonitions. Inspired by [rST][] feature with the same name.
*
* [rST]: http://docutils.sourceforge.net/docs/ref/rst/directives.html#specific-admonitions # noqa
*
* See <https://pythonhosted.org/Markdown/extensions/admonition.html>
* for documentation.
*
* Original code Copyright [Tiago Serafim](http://www.tiagoserafim.com/).
*
* All changes Copyright The Python Markdown Project
*
* License: [BSD](http://www.opensource.org/licenses/bsd-license.php)
*/
#include "Extension.h"
namespace markdown{
class AdmonitionExtension : public Extension, public std::enable_shared_from_this<AdmonitionExtension>
{
public:
AdmonitionExtension();
void extendMarkdown(const std::shared_ptr<Markdown> &md/*, md_globals*/);
public:
static Extension::Ptr generate(void);
};
} // end of namespace markdown
#endif // ADMONITION_H
| 24.414634 | 102 | 0.705295 |
4d45c75be923d17342b3fecab42e857c91dc85bc | 2,775 | h | C | include/monkey/mk_http2_dynamic_table.h | leonardo-albertovich/monkey | 2df5dd2d2f844d2d022e68d8e8a15862e733a5fd | [
"Apache-2.0"
] | null | null | null | include/monkey/mk_http2_dynamic_table.h | leonardo-albertovich/monkey | 2df5dd2d2f844d2d022e68d8e8a15862e733a5fd | [
"Apache-2.0"
] | null | null | null | include/monkey/mk_http2_dynamic_table.h | leonardo-albertovich/monkey | 2df5dd2d2f844d2d022e68d8e8a15862e733a5fd | [
"Apache-2.0"
] | null | null | null | /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* Monkey HTTP Server
* ==================
* Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
*
* 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 MK_HTTP2_DYNAMIC_TABLE_H
#define MK_HTTP2_DYNAMIC_TABLE_H
#include <monkey/mk_core.h>
struct mk_http2_dynamic_table_entry {
struct mk_list _head;
uint32_t id;
char *name;
char *value;
size_t size;
};
struct mk_http2_dynamic_table {
struct mk_list entries; /* list of dynamic table entries */
size_t size; /* pre-computed size of the entire table */
size_t size_limit; /* maximum size (used for eviction) */
uint32_t next_id; /* this needs to resist table wipes */
};
int mk_http2_dynamic_table_entry_create(struct mk_http2_dynamic_table *ctx,
char *name,
size_t name_length,
char *value,
size_t value_length);
int mk_http2_dynamic_table_entry_destroy(struct mk_http2_dynamic_table *ctx,
struct mk_http2_dynamic_table_entry *entry);
int mk_http2_dynamic_table_entry_destroy_all(struct mk_http2_dynamic_table *ctx);
struct mk_http2_dynamic_table_entry *mk_http2_dynamic_table_entry_get_by_id(
struct mk_http2_dynamic_table *ctx,
uint32_t id);
struct mk_http2_dynamic_table_entry *mk_http2_dynamic_table_entry_get_by_name(
struct mk_http2_dynamic_table *ctx,
char *name);
int mk_http2_dynamic_table_enforce_size_limit(struct mk_http2_dynamic_table *ctx,
size_t size_limit);
void mk_http2_dynamic_table_set_size_limit(struct mk_http2_dynamic_table *ctx,
uint32_t size_limit);
struct mk_http2_dynamic_table *mk_http2_dynamic_table_create(uint32_t size_limit);
int mk_http2_dynamic_table_destroy(struct mk_http2_dynamic_table *ctx);
#endif
| 39.642857 | 85 | 0.628108 |
4d462649d872f92621120683eeda12b27f54d34a | 3,469 | h | C | protobuf_demo/item_write.h | deguangchow/protobuf_demo | 73d983868d93e3005f27cf098e04e3adad40f6a0 | [
"MIT"
] | null | null | null | protobuf_demo/item_write.h | deguangchow/protobuf_demo | 73d983868d93e3005f27cf098e04e3adad40f6a0 | [
"MIT"
] | null | null | null | protobuf_demo/item_write.h | deguangchow/protobuf_demo | 73d983868d93e3005f27cf098e04e3adad40f6a0 | [
"MIT"
] | null | null | null | /// Copyright (C) 2019 DG.C, DGCHOW, deguangchow
/// deguangchow@qq.com
///
/// \brief item_write : item 写
///
/// \author deguangchow
/// \version 1.0
/// \2019/10/28
#pragma once
#pragma once
#ifndef ITEM_WRITE_H
#define ITEM_WRITE_H
#include "item.pb.h"
void PromptForItemProperty(::core::Item *it) {
cout << "Edit Property to item ?(Y/n)";
char c = getchar();
if (c != 'Y' && c != 'y') {
return;
}
auto *prop = it->mutable__props();
cout << "Enter code: ";
getline(cin, *prop->mutable_code());
cin.ignore(256, '\n');
cout << "Enter catagory: ";
int catagory;
cin >> catagory;
prop->set_catagory(catagory);
cin.ignore(256, '\n');
cout << "Enter name: ";
string name;
getline(cin, name);
if (!name.empty()) {
prop->set_name(name);
}
cout << "Enter unit: ";
string unit;
getline(cin, unit);
if (!unit.empty()) {
prop->set_unit(unit);
}
cout << "Enter amount: ";
double amount;
cin >> amount;
prop->set_amount(amount);
cout << "Enter price: ";
double price;
cin >> price;
prop->set_price(amount);
prop->set_summary(prop->amount() * prop->price());
}
void PromptForItemRelation(::core::Item *it) {
while (true) {
cin.ignore(256, '\n');
cout << "Enter a relation type (or leave blank to finish): ";
string rel_type;
getline(cin, rel_type);
if (rel_type.empty()) {
break;
}
auto *rel = it->add__relations();
if (rel_type == "child") {
rel->set__type(core::child);
} else if (rel_type == "secondary") {
rel->set__type(core::secondary);
} else if (rel_type == "inherit") {
rel->set__type(core::inherit);
} else if (rel_type == "feetable") {
rel->set__type(core::feetable);
} else if (rel_type == "vartable") {
rel->set__type(core::vartable);
} else {
break;
}
while (true) {
cout << "Add an item to relation " << rel_type << " ?(Y/n)";
char c = getchar();
if (c != 'Y' && c != 'y') {
break;
}
cin.ignore(256, '\n');
auto *it = rel->add__relatives();
PromptForItemProperty(it);
}
}
}
int test_item_write(int argc, char* argv[]) {
GOOGLE_PROTOBUF_VERIFY_VERSION;
if (argc != 2) {
cout << "Usage: " << argv[0] << " ITEM_FILE" << endl;
return -1;
}
core::Item item;
{
// Read the exsiting item.
fstream input(argv[1], ios::in | ios::binary);
if (!input) {
cout <<argv[1] <<": File not found. Creating a new file." << endl;
} else if (!item.ParseFromIstream(&input)) {
cerr << "Failed to parse item" << endl;
return -1;
}
}
// Add an item.
PromptForItemProperty(&item);
PromptForItemRelation(&item);
{
// Write the new item back to disk.
fstream output(argv[1], ios::out | ios::trunc | ios::binary);
if (!item.SerializePartialToOstream(&output)) {
cerr << "Failed to write item." << endl;
return -1;
}
}
// Optional : Delete all global objects allocated by libprotobuf.
google::protobuf::ShutdownProtobufLibrary();
return 0;
}
#endif //ITEM_WRITE_H
| 24.090278 | 78 | 0.515999 |
4d46ccf0ac4bb259b48ec6a00473643926280b97 | 484 | h | C | LibWaveSynther/A_MOTHOD.h | Angelic47/LibWaveSynther | bd0b71a59a46dab562f13f67424242d722b26779 | [
"MIT"
] | 20 | 2021-02-12T19:27:17.000Z | 2022-02-10T14:29:44.000Z | LibWaveSynther/A_MOTHOD.h | Angelic47/LibWaveSynther | bd0b71a59a46dab562f13f67424242d722b26779 | [
"MIT"
] | 1 | 2021-09-13T01:44:56.000Z | 2021-09-18T12:56:31.000Z | LibWaveSynther/A_MOTHOD.h | Angelic47/LibWaveSynther | bd0b71a59a46dab562f13f67424242d722b26779 | [
"MIT"
] | 3 | 2021-02-13T10:06:19.000Z | 2021-09-13T01:36:39.000Z | #ifndef A_MOTHOD_H
#define A_MOTHOD_H
#define _0 255
#define _1 38
#define _2 40
#define _3 42
#define _4 43
#define _5 45
#define _6 47
#define _7 49
#define _1U 50
#define _2U 52
#define _3U 54
#define _4U 55
#define _5U 57
#define _6U 59
#define _7U 61
#define _1B 26
#define _2B 28
#define _3B 30
#define _4B 31
#define _5B 33
#define _6B 35
#define _7B 37
#define _1BB 14
#define _2BB 16
#define _3BB 18
#define _4BB 19
#define _5BB 21
#define _6BB 23
#define _7BB 25
#endif | 13.081081 | 18 | 0.735537 |
4d49475a56846b2611be11d8d206e84e3326fdad | 14,809 | c | C | src/graphic.c | MrrRaph/Encode-Decode-Morse-Code | f628d52d272056db3fc4db3b79981b50fd58d5a3 | [
"Apache-2.0"
] | 2 | 2021-01-30T07:26:01.000Z | 2022-01-12T06:15:53.000Z | src/graphic.c | MrrRaph/Encode-Decode-Morse-Code | f628d52d272056db3fc4db3b79981b50fd58d5a3 | [
"Apache-2.0"
] | null | null | null | src/graphic.c | MrrRaph/Encode-Decode-Morse-Code | f628d52d272056db3fc4db3b79981b50fd58d5a3 | [
"Apache-2.0"
] | null | null | null | #include "../headers/graphic.h"
int graphicInterface(Arbre tree)
{
if(SDLnIMGnTTF_Initialize() == EXIT_FAILURE)
return EXIT_FAILURE;
SDL_Window * window = SDL_CreateWindow("Encode&Decode Morse Code", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if(!window)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to create window: %s\n", SDL_GetError());
TTF_Quit();
IMG_Quit();
SDL_Quit();
return EXIT_FAILURE;
}
SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if(!renderer)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to create renderer: %s\n", SDL_GetError());
TTF_Quit();
IMG_Quit();
SDL_Quit();
return EXIT_FAILURE;
}
SDL_Texture * background = loadTexture("../images/Background.png", renderer);
if(!background)
{
cleanUp(window, renderer);
return EXIT_FAILURE;
}
SDL_Texture * encode_btn = loadTexture("../images/Encode_btnSprites.png", renderer);
if(!encode_btn)
{
SDL_DestroyTexture(background);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
int iWencode = 259, iHencode = 67, xEncode = 0, yEncode = 0;
SDL_Rect encodeClips[3];
for(int i = 0; i < 3; i++)
{
encodeClips[i].x = i * iWencode;
encodeClips[i].y = 0;
encodeClips[i].w = iWencode;
encodeClips[i].h = iHencode;
}
SDL_Texture * decode_btn = loadTexture("../images/Decode_btnSprites.png", renderer);
if(!decode_btn)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
int iWdecode = 259, iHdecode = 67, xDecode = 435, yDecode = 0;
SDL_Rect decodeClips[3];
for(int i = 0; i < 3; i++)
{
decodeClips[i].x = i * iWdecode;
decodeClips[i].y = 0;
decodeClips[i].w = iWdecode;
decodeClips[i].h = iHdecode;
}
SDL_Texture * submit_btn = loadTexture("../images/Submit_btn.png", renderer);
if(!submit_btn)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
int iWsubmit = 259, iHsubmit = 67, xSubmit = 825, ySubmit = 508;
SDL_Texture * inputText = loadTexture("../images/InputText.png", renderer);
if(!inputText)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
int xInput = 660, xOutput = 660, yInput = 450, yOutput = 600, iWinputText = 610, iHinputText = 51;
char * textInput = malloc(sizeof(char) * 61);
strcpy(textInput, "Put your text here !");
SDL_Color black = {0, 0, 0, 0xFF};
SDL_Texture * texte = renderText(textInput, "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!texte)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
int xTexte = xInput + 20, yTexte = yInput + 20;
char * outputText = malloc(sizeof(char) * 80);
memset(outputText, 0, strlen(outputText));
SDL_Texture * output = renderText(" \0", "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!output)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
int xTexteOutput = xOutput + 20, yTexteOutput = yOutput + 20;
int hoverEncode = 0, OnClickEncode = 0, encodeSelect = 1;
int hoverDecode = 0, OnClickDecode = 0, decodeSelect = 0;
int hoverSubmit = 0, OnClickSubmit = 0;
int clickForText = 0;
Uint32 frameStart, frameTime;
SDL_StartTextInput();
while(!SDL_QuitRequested())
{
frameStart = SDL_GetTicks();
SDL_Event event;
int reRenderText = 0;
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_MOUSEBUTTONDOWN:
if(event.button.button == SDL_BUTTON_LEFT)
{
if(isInRegion(event.button.x, event.button.y, xEncode, xEncode + iWencode, yEncode, yEncode + iHencode))
{
hoverEncode = 0;
OnClickEncode = 1;
encodeSelect = 1;
decodeSelect = 0;
}
else if(isInRegion(event.button.x, event.button.y, xDecode, xDecode + iWdecode, yDecode, yDecode + iHdecode))
{
hoverDecode = 0;
OnClickDecode = 1;
encodeSelect = 0;
decodeSelect = 1;
}
else if(isInRegion(event.button.x, event.button.y, xSubmit, xSubmit + iWsubmit, ySubmit, ySubmit + iHsubmit))
{
hoverSubmit = 0;
OnClickSubmit = 1;
}
else if(isInRegion(event.button.x, event.button.y, xInput, xInput + iWinputText, yInput, yInput + iHinputText))
clickForText = 1;
else if(clickForText)
clickForText = 0;
}
break;
case SDL_MOUSEBUTTONUP:
if(event.button.button == SDL_BUTTON_LEFT)
{
if(isInRegion(event.button.x, event.button.y, xEncode, xEncode + iWencode, yEncode, yEncode + iHencode))
{
hoverEncode = 1;
OnClickEncode = 0;
}
else if(isInRegion(event.button.x, event.button.y, xDecode, xDecode + iWdecode, yDecode, yDecode + iHdecode))
{
hoverDecode = 1;
OnClickDecode = 0;
}
else
{
hoverEncode = 0;
OnClickEncode = 0;
hoverDecode = 0;
OnClickDecode = 0;
hoverSubmit = 0;
OnClickSubmit = 0;
}
}
break;
case SDL_MOUSEMOTION:
if(isInRegion(event.motion.x, event.motion.y, xEncode, xEncode + iWencode, yEncode, yEncode + iHencode))
{
if(!OnClickEncode)
hoverEncode = 1;
}
else if(isInRegion(event.motion.x, event.motion.y, xDecode, xDecode + iWdecode, yDecode, yDecode + iHdecode))
{
if(!OnClickDecode)
hoverDecode = 1;
}
else
{
hoverEncode = 0;
OnClickEncode = 0;
hoverDecode = 0;
OnClickDecode = 0;
}
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_BACKSPACE:
if(clickForText && strlen(textInput) > 0)
{
textInput[strlen(textInput) - 1] = 0;
reRenderText = 1;
}
break;
case SDLK_c:
if((SDL_GetModState() & KMOD_CTRL) && clickForText)
SDL_SetClipboardText(textInput);
break;
case SDLK_v:
if((SDL_GetModState() & KMOD_CTRL) && clickForText)
{
strcat(textInput, SDL_GetClipboardText());
reRenderText = 1;
}
break;
}
break;
case SDL_TEXTINPUT:
if(!((event.text.text[0] == 'c' || event.text.text[0] == 'C') && (event.text.text[0] == 'v' || event.text.text[0] == 'V') && SDL_GetModState() & KMOD_CTRL) && clickForText && strlen(textInput) < 60)
{
strcat(textInput, event.text.text);
reRenderText = 1;
}
break;
}
}
if(reRenderText)
{
SDL_DestroyTexture(texte);
if(strcmp(textInput, "") != 0)
{
texte = renderText(textInput, "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!texte)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
SDL_DestroyTexture(output);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
}
else
{
texte = renderText(" \0", "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!texte)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
SDL_DestroyTexture(output);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
}
}
if(OnClickSubmit)
{
OnClickSubmit = 0;
SDL_DestroyTexture(output);
if(decodeSelect)
{
if(strcmp(textInput, "\0") != 0)
{
memset(outputText, 0, strlen(outputText));
char ** splitted = str_split(textInput, " \0");
if(!splitted)
{
fprintf(stderr, "Unable to split the string\n");
return EXIT_FAILURE;
}
for(int i = 0; splitted[i] != NULL; i++)
{
strcat(outputText, morseDecypher(tree, splitted[i]));
if(splitted[i+1] != NULL)
strcat(outputText, " \0");
}
free(splitted); splitted = NULL;
output = renderText(outputText, "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!output)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
}
else
{
SDL_Texture * output = renderText(" \0", "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!output)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
}
}
else if(encodeSelect)
{
if(strcmp(textInput, "\0") != 0)
{
memset(outputText, 0, strlen(outputText));
strcpy(outputText, morseCypher(tree, textInput));
int pass = 0;
int i = 0;
while(outputText[i] != '.' && outputText[i] != '-')
{
pass++;
i++;
}
char * outputTextPass = outputText + pass;
output = renderText(outputTextPass, "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!output)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
}
else
{
SDL_Texture * output = renderText(" \0", "../fonts/arial_narrow_7/arial_narrow_7.ttf", black, 24, renderer);
if(!output)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
cleanUp(window, renderer);
return EXIT_FAILURE;
}
}
}
}
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00);
SDL_RenderClear(renderer);
renderTexture(background, renderer, 0, 0, NULL);
if(hoverEncode)
renderTexture(encode_btn, renderer, xEncode, yEncode, &encodeClips[1]);
else if(OnClickEncode)
renderTexture(encode_btn, renderer, xEncode, yEncode, &encodeClips[2]);
else
renderTexture(encode_btn, renderer, xEncode, yEncode, &encodeClips[0]);
if(hoverDecode)
renderTexture(decode_btn, renderer, xDecode, yDecode, &decodeClips[1]);
else if(OnClickDecode)
renderTexture(decode_btn, renderer, xDecode, yDecode, &decodeClips[2]);
else
renderTexture(decode_btn, renderer, xDecode, yDecode, &decodeClips[0]);
renderTexture(submit_btn, renderer, xSubmit, ySubmit, NULL);
renderTexture(inputText, renderer, xInput, yInput, NULL);
renderTexture(inputText, renderer, xOutput, yOutput, NULL);
renderTexture(texte, renderer, xTexte, yTexte, NULL);
renderTexture(output, renderer, xTexteOutput, yTexteOutput, NULL);
SDL_RenderPresent(renderer);
frameTime = SDL_GetTicks() - frameStart;
if(frameTime < DELAY_TIME)
SDL_Delay((int)(DELAY_TIME - frameTime));
}
SDL_StopTextInput();
SDL_DestroyTexture(background);
SDL_DestroyTexture(encode_btn);
SDL_DestroyTexture(decode_btn);
SDL_DestroyTexture(submit_btn);
SDL_DestroyTexture(inputText);
SDL_DestroyTexture(texte);
SDL_DestroyTexture(output);
cleanUp(window, renderer);
free(textInput);
free(outputText);
return EXIT_SUCCESS;
}
int SDLnIMGnTTF_Initialize()
{
int flags = IMG_INIT_PNG;
int initted = IMG_Init(flags);
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) != 0)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to initialize SDL: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
if((initted & flags) != flags)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to initialize png images: %s\n", IMG_GetError());
SDL_Quit();
return EXIT_FAILURE;
}
if(TTF_Init() == -1)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to initialize font feature: %s\n", TTF_GetError());
IMG_Quit();
SDL_Quit();
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
SDL_Texture * loadTexture(const char * filename, SDL_Renderer * renderer)
{
SDL_Texture * texture = IMG_LoadTexture(renderer, filename);
if(!texture)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to create texture: %s\n", SDL_GetError());
return NULL;
}
return texture;
}
void renderTextureClip(SDL_Texture * texture, SDL_Renderer * renderer, SDL_Rect dest, SDL_Rect * clip)
{
SDL_RenderCopy(renderer, texture, clip, &dest);
}
void renderTexture(SDL_Texture * texture, SDL_Renderer * renderer, int x, int y, SDL_Rect * clip)
{
SDL_Rect dest;
dest.x = x;
dest.y = y;
if(!clip)
SDL_QueryTexture(texture, NULL, NULL, &dest.w, &dest.h);
else
{
dest.w = clip->w;
dest.h = clip->h;
}
renderTextureClip(texture, renderer, dest, clip);
}
SDL_Texture * renderText(const char * text, const char * fontName, SDL_Color color, int fontSize, SDL_Renderer * renderer)
{
TTF_Font * font = TTF_OpenFont(fontName, fontSize);
if(!font)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to open font: %s\n", TTF_GetError());
return NULL;
}
SDL_Surface * surface = TTF_RenderText_Blended(font, text, color);
if(!surface)
{
TTF_CloseFont(font);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to apply text on surface: %s\n", TTF_GetError());
return NULL;
}
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
if(!texture)
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to create texture: %s\n", SDL_GetError());
SDL_FreeSurface(surface);
TTF_CloseFont(font);
return texture;
}
bool isInRegion(int x, int y, int xInf, int xSup, int yInf, int ySup)
{
if((x >= xInf && x <= xSup) && (y >= yInf && y <= ySup))
return true;
return false;
}
void cleanUp(SDL_Window * window, SDL_Renderer * renderer)
{
SDL_DestroyWindow(window);
SDL_DestroyRenderer(renderer);
TTF_Quit();
IMG_Quit();
SDL_Quit();
} | 27.322878 | 203 | 0.670673 |
4d4b4a09c1a07b9da2af6e659d10f890eb4e1de9 | 123 | h | C | src/include/font_mine.h | MarkRoss470/pepperOS | 669e3b24840cc9ba1d25db2d2180a0406026b500 | [
"MIT"
] | null | null | null | src/include/font_mine.h | MarkRoss470/pepperOS | 669e3b24840cc9ba1d25db2d2180a0406026b500 | [
"MIT"
] | null | null | null | src/include/font_mine.h | MarkRoss470/pepperOS | 669e3b24840cc9ba1d25db2d2180a0406026b500 | [
"MIT"
] | null | null | null | #ifndef FONT_H
#define FONT_H
#include <stdint.h>
#include <util/types.h>
const uint8_t *font_char_mine(char c);
#endif
| 12.3 | 38 | 0.739837 |
4d4bbda5de6801ded470d343f62861fcb29a01f7 | 4,862 | h | C | platform/gucefCORE/include/CROIOAccess.h | amvb/GUCEF | 08fd423bbb5cdebbe4b70df24c0ae51716b65825 | [
"Apache-2.0"
] | 5 | 2016-04-18T23:12:51.000Z | 2022-03-06T05:12:07.000Z | platform/gucefCORE/include/CROIOAccess.h | amvb/GUCEF | 08fd423bbb5cdebbe4b70df24c0ae51716b65825 | [
"Apache-2.0"
] | 2 | 2015-10-09T19:13:25.000Z | 2018-12-25T17:16:54.000Z | platform/gucefCORE/include/CROIOAccess.h | amvb/GUCEF | 08fd423bbb5cdebbe4b70df24c0ae51716b65825 | [
"Apache-2.0"
] | 15 | 2015-02-23T16:35:28.000Z | 2022-03-25T13:40:33.000Z | /*
* gucefCORE: GUCEF module providing O/S abstraction and generic solutions
* Copyright (C) 2002 - 2007. Dinand Vanvelzen
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef GUCEF_CORE_CROIOACCESS_H
#define GUCEF_CORE_CROIOACCESS_H
/*-------------------------------------------------------------------------//
// //
// INCLUDES //
// //
//-------------------------------------------------------------------------*/
#ifndef GUCEF_CORE_CIOACCESS_H
#include "CIOAccess.h" /* abstract base for IO Access */
#define GUCEF_CORE_CIOACCESS_H
#endif /* GUCEF_CORE_CIOACCESS_H ? */
/*-------------------------------------------------------------------------//
// //
// NAMESPACE //
// //
//-------------------------------------------------------------------------*/
namespace GUCEF {
namespace CORE {
/*-------------------------------------------------------------------------//
// //
// CLASSES //
// //
//-------------------------------------------------------------------------*/
/**
* Abstract base class for read-only media independant recource access
* Read-only media access implementations can inherit from this class
* to avoid having to implement the write interface for each decending
* implementation.
*/
class GUCEF_CORE_PUBLIC_CPP CROIOAccess : public CIOAccess
{
public:
CROIOAccess( void );
virtual ~CROIOAccess();
/**
* Is the only allowed access method reading ?
* If true the recource cannot be written to
* Always returns true
*/
virtual bool IsReadable( void ) const;
/**
* Is the only allowed access method writing ?
* if true the recource cannot be read.
* Always returns false
*/
virtual bool IsWriteable( void ) const;
/**
* Attempts to write the specified number of bytes to the recourse
* using srcdata as the data source.
* Always returns 0, no actual write operation will be performed.
*/
virtual UInt32 Write( const void* srcdata ,
UInt32 esize ,
UInt32 elements );
virtual void Flush( void );
protected:
TIOAccess _access;
};
/*-------------------------------------------------------------------------//
// //
// NAMESPACE //
// //
//-------------------------------------------------------------------------*/
}; /* namespace CORE */
}; /* namespace GUCEF */
/*-------------------------------------------------------------------------*/
#endif /* GUCEF_CORE_CROIOACCESS_H ? */
/*-------------------------------------------------------------------------//
// //
// Info & Changes //
// //
//-------------------------------------------------------------------------//
- 28-05-2005 :
- Designed and implemented this class.
-----------------------------------------------------------------------------*/
| 41.913793 | 80 | 0.358083 |
4d501eb776c3668e9870f958525b2d7a8b994232 | 892 | h | C | MiaoSha/Pods/TTCounterLabel/Source/TTCounterLabel.h | daqiangge/ZhengFengDuoMiao | 155533193f68a5f93233679cd135bd38621f7109 | [
"Apache-2.0"
] | 1 | 2017-10-27T06:38:41.000Z | 2017-10-27T06:38:41.000Z | Sport/ThirdKit/CustomUi/TimerLabel/TTCounterLabel.h | zltqzj/Sport | 28c9b443ba683a548ba72fb01d575a40eaf3b0fe | [
"Apache-2.0"
] | null | null | null | Sport/ThirdKit/CustomUi/TimerLabel/TTCounterLabel.h | zltqzj/Sport | 28c9b443ba683a548ba72fb01d575a40eaf3b0fe | [
"Apache-2.0"
] | null | null | null | //
// TTCounterLabel.h
// TTCounterLabel
//
// Created by Ross Gibson on 10/10/2013.
// Copyright (c) 2013 Triggertrap. All rights reserved.
//
#import "TTTAttributedLabel.h"
typedef NS_ENUM(NSInteger, kCountDirection){
kCountDirectionUp = 0,
kCountDirectionDown
};
@protocol TTCounterLabelDelegate <NSObject>
@optional
- (void)countdownDidEnd;
@end
@interface TTCounterLabel : TTTAttributedLabel
@property (weak) id <TTCounterLabelDelegate> countdownDelegate;
@property (nonatomic, assign) unsigned long currentValue;
@property (nonatomic, assign) unsigned long startValue;
@property (nonatomic, assign) NSInteger countDirection;
@property (strong, nonatomic) UIFont *boldFont;
@property (strong, nonatomic) UIFont *regularFont;
@property (nonatomic, assign) BOOL isRunning;
#pragma mark - Public
- (void)start;
- (void)stop;
- (void)reset;
- (void)updateApperance;
@end
| 22.871795 | 63 | 0.758969 |
4d519ff03dcd08179a98d4c69004d9517e171f6e | 580 | h | C | CoreUI.framework/CUINamedRecognitionImage.h | reels-research/iOS-Private-Frameworks | 9a4f4534939310a51fdbf5a439dd22487efb0f01 | [
"MIT"
] | 4 | 2021-10-06T12:15:26.000Z | 2022-02-21T02:26:00.000Z | CoreUI.framework/CUINamedRecognitionImage.h | reels-research/iOS-Private-Frameworks | 9a4f4534939310a51fdbf5a439dd22487efb0f01 | [
"MIT"
] | null | null | null | CoreUI.framework/CUINamedRecognitionImage.h | reels-research/iOS-Private-Frameworks | 9a4f4534939310a51fdbf5a439dd22487efb0f01 | [
"MIT"
] | 1 | 2021-10-08T07:40:53.000Z | 2021-10-08T07:40:53.000Z | /* Generated by RuntimeBrowser
Image: /System/Library/PrivateFrameworks/CoreUI.framework/CoreUI
*/
@interface CUINamedRecognitionImage : CUINamedLookup
@property (nonatomic, readonly) int exifOrientation;
@property (nonatomic, readonly) struct CGImage { }*image;
@property (nonatomic, readonly) struct CGSize { double x1; double x2; } physicalSizeInMeters;
- (int)exifOrientation;
- (struct CGImage { }*)image;
- (id)initWithName:(id)arg1 usingRenditionKey:(id)arg2 fromTheme:(unsigned long long)arg3;
- (struct CGSize { double x1; double x2; })physicalSizeInMeters;
@end
| 34.117647 | 93 | 0.768966 |
4d52831e2229f5245d0145dc8b4a4ef66ba84f35 | 2,074 | h | C | System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PPContact.h | lechium/iPhoneOS_12.1.1_Headers | aac688b174273dfcbade13bab104461f463db772 | [
"MIT"
] | 12 | 2019-06-02T02:42:41.000Z | 2021-04-13T07:22:20.000Z | System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PPContact.h | lechium/iPhoneOS_12.1.1_Headers | aac688b174273dfcbade13bab104461f463db772 | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PPContact.h | lechium/iPhoneOS_12.1.1_Headers | aac688b174273dfcbade13bab104461f463db772 | [
"MIT"
] | 3 | 2019-06-11T02:46:10.000Z | 2019-12-21T14:58:16.000Z | /*
* This header is generated by classdump-dyld 1.0
* on Saturday, June 1, 2019 at 6:52:49 PM Mountain Standard Time
* Operating System: Version 12.1.1 (Build 16C5050a)
* Image Source: /System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PersonalizationPortraitInternals
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
@class NSString, CNContact, SGContact;
@interface PPContact : NSObject {
NSString* _cachedFullName;
BOOL _isFavorite;
NSString* _identifier;
CNContact* _contact;
SGContact* _sgContact;
unsigned long long _source;
double _score;
}
@property (nonatomic,copy) NSString * identifier; //@synthesize identifier=_identifier - In the implementation block
@property (nonatomic,copy) CNContact * contact; //@synthesize contact=_contact - In the implementation block
@property (nonatomic,copy) SGContact * sgContact; //@synthesize sgContact=_sgContact - In the implementation block
@property (assign,nonatomic) unsigned long long source; //@synthesize source=_source - In the implementation block
@property (assign,nonatomic) double score; //@synthesize score=_score - In the implementation block
@property (assign,nonatomic) BOOL isFavorite; //@synthesize isFavorite=_isFavorite - In the implementation block
-(void)setScore:(double)arg1 ;
-(void)setIsFavorite:(BOOL)arg1 ;
-(id)socialProfiles;
-(id)nonGregorianBirthday;
-(id)postalAddresses;
-(id)birthday;
-(BOOL)isEqualToContact:(id)arg1 ;
-(void)setContact:(CNContact *)arg1 ;
-(id)givenName;
-(id)nickname;
-(BOOL)isFavorite;
-(double)score;
-(CNContact *)contact;
-(id)emailAddresses;
-(id)phoneNumbers;
-(id)organizationName;
-(id)fullName;
-(SGContact *)sgContact;
-(void)setSgContact:(SGContact *)arg1 ;
-(NSString *)identifier;
-(unsigned long long)hash;
-(id)description;
-(void)setIdentifier:(NSString *)arg1 ;
-(void)setSource:(unsigned long long)arg1 ;
-(unsigned long long)source;
-(id)familyName;
@end
| 35.758621 | 135 | 0.725651 |
4d54c4440c55f21b1722d55f6b62f017647d5b69 | 345 | h | C | include/ee2/CombineAO.h | xzrunner/easyeditor2 | 7b399e7b6571c93d3193d9ed6e47b5d4a946c036 | [
"MIT"
] | null | null | null | include/ee2/CombineAO.h | xzrunner/easyeditor2 | 7b399e7b6571c93d3193d9ed6e47b5d4a946c036 | [
"MIT"
] | null | null | null | include/ee2/CombineAO.h | xzrunner/easyeditor2 | 7b399e7b6571c93d3193d9ed6e47b5d4a946c036 | [
"MIT"
] | null | null | null | #pragma once
#include <ee0/AtomicOP.h>
#include <memory>
#include <vector>
namespace ee2
{
class CombineAO : public ee0::AtomicOP
{
public:
virtual void Undo() override;
virtual void Redo() override;
void Add(const std::shared_ptr<ee0::AtomicOP>& ao);
private:
std::vector<std::shared_ptr<ee0::AtomicOP>> m_atomics;
}; // CombineAO
} | 14.375 | 55 | 0.713043 |
4d557aec9b4834628ae7dc7882436df45ed67f88 | 334 | h | C | YFCategory/Foundation/YFCategory+Foundation.h | ghostfeng/YFCategory | 2d932651a38ff8023d33108f44feae8ce445f5bc | [
"MIT"
] | null | null | null | YFCategory/Foundation/YFCategory+Foundation.h | ghostfeng/YFCategory | 2d932651a38ff8023d33108f44feae8ce445f5bc | [
"MIT"
] | null | null | null | YFCategory/Foundation/YFCategory+Foundation.h | ghostfeng/YFCategory | 2d932651a38ff8023d33108f44feae8ce445f5bc | [
"MIT"
] | null | null | null | //
// YFCategory+Foundation.h
// YFCategoryDemo
//
// Created by 刘永峰 on 2019/3/19.
// Copyright © 2019 刘永峰. All rights reserved.
//
#ifndef YFCategory_Foundation_h
#define YFCategory_Foundation_h
#import "NSObject+YFCategory.h"
#import "NSDate+YFCategory.h"
#import "NSString+YFCategory.h"
#endif /* YFCategory_Foundation_h */
| 19.647059 | 46 | 0.742515 |
4d5611e5f1ffa0a0e07289b5ce2fa3112e7230f1 | 1,893 | h | C | DYLTool/DYLTool/HttpService/NetWork/MacrosNetWork.h | a619668402/DYLTool | 3cce16df7c7c7bf1cbc68ac2e4f6089eeb4b0923 | [
"Apache-2.0"
] | null | null | null | DYLTool/DYLTool/HttpService/NetWork/MacrosNetWork.h | a619668402/DYLTool | 3cce16df7c7c7bf1cbc68ac2e4f6089eeb4b0923 | [
"Apache-2.0"
] | null | null | null | DYLTool/DYLTool/HttpService/NetWork/MacrosNetWork.h | a619668402/DYLTool | 3cce16df7c7c7bf1cbc68ac2e4f6089eeb4b0923 | [
"Apache-2.0"
] | null | null | null | //
// MacrosNetWork.h
// DYLTool
//
// Created by sky on 2018/6/13.
// Copyright © 2018年 DYL. All rights reserved.
//
/*********************************************
网络请求相关
*********************************************/
#ifndef MacrosNetWork_h
#define MacrosNetWork_h
// 网络请求用到的头文件
#import "BaseRequest.h"
#import "BaseResponse.h"
/*
// 网络错误
#define NetworkErrorDomain @"NerworkErrorDomain"
#define NetWorkErrorCode 7001
#define NetWorkError @"NetWorkError"
#define NetWorkErrorInfo @"网络错误,请检查网络"
// 请求失败
#define NetWorkFailureDomain @"NetWorkFailureDomain"
#define NetWorkFailureCode 7002
#define NetWorkFailure @"NetWorkFialure"
#define NetWorkFailureInfo @"网络请求失败,请稍后重试"
// 请求错误
#define NetWorkRequestErrorDomain @"NetWorkRequestErrorDomain"
#define NetWorkRequestErrorCode 7003
#define NetWorkRequestError @"NetWorkRequestError"
*/
// 接口返回的CODE值
#define CODE_SUCCESS @"1" // 请求正常
#define CODE_LACKPARAMETERERROR @"-1" // 缺少参数
#define CODE_PASSWORDERROR @"-2" // 密码错误
#define CODE_VERIFYERROR @"-3" // 验证码错误
#define CODE_ACCOUNTERROR @"-4" // 账号重复/错误
#define CODE_NOAUTHORITYERROR @"-5" // 没有权限访问接口
#define CODE_SYSTEMERROR @"-6" // 系统内部错误
#define CODE_LOGICERROR @"-7" // 正常业务错误
#define CODE_TOKENERROR @"-10" // token 错误
#endif /* MacrosNetWork_h */
| 38.632653 | 91 | 0.467512 |
4d56171e710d9d70cf84f29f4f3c90e00c264b9c | 10,704 | h | C | Engine/Core/Containers/StringPointerHash.h | vitei/Usa | c44f893d5b3d8080529ecf0e227f983fddb829d4 | [
"MIT"
] | 47 | 2018-04-27T02:16:26.000Z | 2022-02-28T05:21:24.000Z | Engine/Core/Containers/StringPointerHash.h | vitei/Usa | c44f893d5b3d8080529ecf0e227f983fddb829d4 | [
"MIT"
] | 2 | 2018-11-13T18:46:41.000Z | 2022-03-12T00:04:44.000Z | Engine/Core/Containers/StringPointerHash.h | vitei/Usa | c44f893d5b3d8080529ecf0e227f983fddb829d4 | [
"MIT"
] | 6 | 2019-08-10T21:56:23.000Z | 2020-10-21T11:18:29.000Z | /****************************************************************************
// Usagi Engine, Copyright © Vitei, Inc. 2013
****************************************************************************/
#pragma once
#ifndef STRING_POINTER_HASH_H
#define STRING_POINTER_HASH_H
#include "Engine/Memory/MemHeap.h"
#include "Engine/Core/String/StringCRC.h"
#define HASH_AMORTIZED_INSERT_RATE (3)
#define HASH_MAX_LOAD (.7f)
#define HASH_MAX_LOAD_AMORTIZING (.9f)
#define HASH_GROWTH_RATE (1.62f) // Golden ratio works best
namespace usg
{
// Hash table that maps pointers to hashes
template <class T>
class StringPointerHash
{
struct StringPointerHashNode
{
string_crc hash;
T data;
StringPointerHashNode* next;
};
StringPointerHashNode* Find(string_crc crc) const
{
if (Count() == 0)
return 0;
int idx = 0;
StringPointerHashNode* node = nullptr;
// If old table exists
if (m_oldData != 0)
{
idx = crc.Get() % m_oldMax;
node = &m_oldData[idx];
while (node && node->hash.Get() != 0)
{
if (node->hash == crc)
return node;
node = node->next;
}
}
// Check current table
idx = crc.Get() % m_maxElements;
node = &m_data[idx];
while (node && node->hash.Get() != 0)
{
if (node->hash == crc)
return node;
node = node->next;
}
return 0;
}
void FreeOldTable()
{
if (m_oldData != nullptr)
{
for (int i = 0; i < m_oldMax; i++)
{
StringPointerHashNode* node = m_oldData[i].next;
while (node)
{
StringPointerHashNode* del = node;
node = node->next;
m_allocator->Deallocate(del);
}
}
m_allocator->Deallocate(m_oldData);
}
m_oldMax = 0;
m_oldRemainingIndex = 0;
m_oldData = 0;
}
void Allocate()
{
ASSERT(m_allocator != nullptr);
const memsize allocSize = sizeof(StringPointerHashNode) * m_uHashStartingSize;
// Allocate the table
m_data = (StringPointerHashNode*)m_allocator->Allocate(allocSize, 4, 0, ALLOC_STRING_POINTER_HASH);
MemSet(m_data, 0, allocSize);
m_currentElements = 0;
m_maxElements = m_uHashStartingSize;
m_oldData = 0;
m_oldMax = 0;
m_oldActiveElements = 0;
m_currentAmortizing = false;
}
void AllocateNewTable()
{
ASSERT(m_oldData == nullptr);
// Save old data first
m_oldData = m_data;
m_oldMax = m_maxElements;
m_oldActiveElements = m_currentElements;
// Increase max elements
m_maxElements = (sint32)(m_maxElements * HASH_GROWTH_RATE);
const memsize allocSize = sizeof(StringPointerHashNode) * m_maxElements;
// Allocate the new table
m_data = (StringPointerHashNode*)m_allocator->Allocate(allocSize, 4, 0, ALLOC_STRING_POINTER_HASH);
// memset it
MemSet(m_data, 0, allocSize);
// Save old data
m_oldRemainingIndex = 0;
m_currentElements = 0;
}
// Pull elements from the old table into the new table
void Amortize()
{
if (m_oldData != 0 && m_currentAmortizing == false)
{
m_currentAmortizing = true;
bool tableDone = false;
// dpw 20160426 -- HASH_AMORTIZED_INSERT_RATE here causes a crash when not tuned
// correctly. For now I'm just ignoring it; if insertions become
// a problem consider re-introducing it, but you will have to fix
// the crash (to do with m_oldData not being cleared) if you do!
for (int i = 0; !tableDone /*&& i < HASH_AMORTIZED_INSERT_RATE*/; i++)
{
StringPointerHashNode* node = &m_oldData[m_oldRemainingIndex];
if (node->hash.Get() != 0 && m_oldActiveElements > 0)
{
// Add the old node value into the new table
Insert(node->hash, node->data);
if (node->next != 0)
{
StringPointerHashNode* next = node->next;
node->hash = next->hash;
node->data = next->data;
node->next = next->next;
// Free the node
m_allocator->Deallocate(next);
}
else
{
m_oldData[m_oldRemainingIndex].hash.Clear();
m_oldData[m_oldRemainingIndex].data = 0;
m_oldRemainingIndex++;
}
m_oldActiveElements--;
}
else if (m_oldActiveElements > 0)
{
m_oldRemainingIndex++;
}
tableDone = (m_oldRemainingIndex >= m_oldMax || m_oldActiveElements <= 0);
}
m_currentAmortizing = false;
}
if (m_oldActiveElements == 0)
{
FreeOldTable();
}
}
public:
StringPointerHash<T>(uint32 uHashStartingSize = 32)
: m_uHashStartingSize(uHashStartingSize)
, m_data(nullptr)
, m_oldData(nullptr)
, m_allocator(nullptr)
, m_currentAmortizing(false)
, m_oldRemainingIndex(0)
, m_oldActiveElements(0)
, m_oldMax(0)
, m_currentElements(0)
, m_maxElements(0)
{
}
~StringPointerHash<T>()
{
Clear();
}
class Iterator
{
public:
Iterator(StringPointerHash<T>* hash)
: m_hash(hash), m_slotIdx(0), m_node(&hash->m_data[0])
{
if(m_node && m_node->data == nullptr) { ++(*this); }
}
Iterator& operator++()
{
m_node = m_node->next;
while((m_node == nullptr || m_node->data == nullptr) && m_slotIdx < m_hash->m_maxElements)
{
if(m_node != nullptr)
{
m_node = m_node->next;
}
else
{
m_slotIdx++;
if(m_slotIdx < m_hash->m_maxElements)
{
m_node = &m_hash->m_data[m_slotIdx];
}
else
{
m_node = nullptr;
}
}
}
return *this;
}
const T* operator*() const { return &m_node->data; }
T* operator*() { return &m_node->data; }
bool IsEnd() const { return m_node == nullptr; }
string_crc GetKey() const {
return m_node->hash.Get();
}
private:
StringPointerHash<T>* m_hash;
sint32 m_slotIdx;
StringPointerHashNode* m_node;
};
friend class Iterator;
Iterator Begin() { ASSERT(m_oldData == nullptr); return Iterator(this); }
void SetAllocator(MemHeap* heap)
{
ASSERT(heap != 0);
m_allocator = heap;
}
void Clear()
{
Shutdown();
}
bool IsEmpty() const
{
return (m_currentElements == 0);
}
int Count() const
{
return m_currentElements + m_oldActiveElements;
}
void Shutdown()
{
FreeOldTable();
m_currentElements = 0;
m_oldActiveElements = 0;
if (m_data != nullptr)
{
for (int i = 0; i < m_maxElements; i++)
{
StringPointerHashNode* node = m_data[i].next;
while (node)
{
StringPointerHashNode* del = node;
node = node->next;
// Free the node
m_allocator->Deallocate(del);
}
}
// Free the table
m_allocator->Deallocate(m_data);
}
m_data = nullptr;
m_maxElements = 0;
}
bool Insert(char* key, T data)
{
return Insert(string_crc(key), data);
}
bool Insert(string_crc key, T data)
{
// Can't insert elements with no key
if (key.Get() == 0)
return false;
// Can't insert elements with no data
if (data == 0)
return false;
// If it's already added we have a problem
if (Exists(key) && !m_currentAmortizing)
return false;
// First insertion? create the table
if (m_data == nullptr)
{
Allocate();
}
// Acquire a slot
sint32 slotIdx = key.Get() % m_maxElements;
StringPointerHashNode* node = &m_data[slotIdx];
if (node->hash.Get() != 0)
{
while (node->next != nullptr)
{
node = node->next;
}
// Allocate the node
StringPointerHashNode* next = (StringPointerHashNode*)m_allocator->Allocate(sizeof(StringPointerHashNode), 4, 0, ALLOC_STRING_POINTER_HASH);
node->next = next;
// advance the pointer
node = node->next;
node->next = nullptr;
}
node->hash = key;
node->data = data;
m_currentElements++;
// Allocate new table if we are over the max load
// If we are currently amortizing, give a little extra space as buffer
const float maxLoad = m_currentAmortizing ? HASH_MAX_LOAD_AMORTIZING : HASH_MAX_LOAD;
const float currentLoad = (float)m_currentElements / (float)m_maxElements;
if (currentLoad >= maxLoad)
AllocateNewTable();
// Amortize
Amortize();
return true;
}
bool Exists(const char* key) const
{
return Exists(string_crc(key));
}
bool Exists(string_crc key) const
{
return Find(key) != nullptr;
}
T Delete(const char* key)
{
return Delete(string_crc(key));
}
T Delete(string_crc key)
{
int idx = 0;
StringPointerHashNode* node = nullptr;
// If old table exists
if (m_oldData != nullptr)
{
idx = key.Get() % m_oldMax;
node = &m_oldData[idx];
if (node && node->hash == key)
{
m_oldActiveElements--;
T data = node->data;
if (node->next)
{
StringPointerHashNode* del = node->next;
node->next = del->next;
node->hash = del->hash;
node->data = del->data;
// Delete this pointer
m_allocator->Deallocate(del);
}
else {
node->hash.Clear();
node->data = nullptr;
}
return data;
}
while (node && node->next != nullptr)
{
if (node->next->hash == key)
{
T data = node->next->data;
StringPointerHashNode* del = node->next;
node->next = del->next;
// Delete the pointer
m_allocator->Deallocate(del);
m_oldActiveElements--;
return data;
}
node = node->next;
}
}
// Check current table
idx = key.Get() % m_maxElements;
node = &m_data[idx];
if (node && node->hash == key)
{
m_currentElements--;
T data = node->data;
if (node->next)
{
StringPointerHashNode* del = node->next;
node->next = del->next;
node->hash = del->hash;
node->data = del->data;
// Delete the pointer
m_allocator->Deallocate(del);
}
else {
node->hash.Clear();
node->data = nullptr;
}
return data;
}
while (node && node->next != nullptr)
{
if (node->next->hash == key)
{
T data = node->next->data;
StringPointerHashNode* del = node->next;
node->next = del->next;
// Delete the pointer
m_allocator->Deallocate(del);
m_currentElements--;
return data;
}
node = node->next;
}
return nullptr;
}
T Get(const char* key) const
{
return Get(string_crc(key));
}
T Get(string_crc key) const
{
StringPointerHashNode* node = Find(key);
if (node == nullptr)
{
return nullptr;
}
return node->data;
}
T* GetPtr(string_crc key) const
{
StringPointerHashNode* node = Find(key);
if (node == 0)
return nullptr;
return &node->data;
}
void Set(string_crc crc, T data)
{
StringPointerHashNode* node = Find(crc);
if (node != nullptr)
{
node->data = data;
return;
}
}
private:
const uint32 m_uHashStartingSize;
StringPointerHashNode* m_data;
StringPointerHashNode* m_oldData;
MemHeap* m_allocator;
bool m_currentAmortizing;
sint32 m_oldRemainingIndex;
sint32 m_oldActiveElements;
sint32 m_oldMax;
sint32 m_currentElements;
sint32 m_maxElements;
};
} // namespace usg
#endif // STRING_POINTER_HASH_H
| 20.427481 | 143 | 0.626588 |
4d569da24fab4ef9d2df49473e41c5d4e28afab5 | 7,505 | h | C | src/java.desktop/share/native/libmlib_image/mlib_image_types.h | siweilxy/openjdkstudy | 8597674ec1d6809faf55cbee1f45f4e9149d670d | [
"Apache-2.0"
] | 2 | 2018-06-19T05:43:32.000Z | 2018-06-23T10:04:56.000Z | src/java.desktop/share/native/libmlib_image/mlib_image_types.h | siweilxy/openjdkstudy | 8597674ec1d6809faf55cbee1f45f4e9149d670d | [
"Apache-2.0"
] | 1 | 2020-12-26T04:57:19.000Z | 2020-12-26T04:57:19.000Z | src/java.desktop/share/native/libmlib_image/mlib_image_types.h | siweilxy/openjdkstudy | 8597674ec1d6809faf55cbee1f45f4e9149d670d | [
"Apache-2.0"
] | 1 | 2021-12-06T01:13:18.000Z | 2021-12-06T01:13:18.000Z | /*
* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#ifndef MLIB_IMAGE_TYPES_H
#define MLIB_IMAGE_TYPES_H
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
MLIB_BIT = 0, /* 1-bit data */
MLIB_BYTE = 1, /* 8-bit unsigned integer data */
MLIB_SHORT = 2, /* 16-bit signed integer data */
MLIB_INT = 3, /* 32-bit signed integer data */
MLIB_FLOAT = 4, /* 32-bit floating-point data */
MLIB_DOUBLE = 5, /* 64-bit floating-point data */
MLIB_USHORT = 6 /* 16-bit unsigned integer data */
} mlib_type;
typedef enum {
MLIB_NEAREST = 0, /* nearest neighbor filter */
MLIB_BILINEAR = 1, /* bilinear filter */
MLIB_BICUBIC = 2, /* bicubic filter */
MLIB_BICUBIC2 = 3 /* bicubic2 filter */
} mlib_filter;
typedef enum {
MLIB_EDGE_DST_NO_WRITE = 0, /* no write to dst edge */
MLIB_EDGE_DST_FILL_ZERO = 1, /* set dst edge to zero */
MLIB_EDGE_DST_COPY_SRC = 2, /* copy src edge to dst edge */
MLIB_EDGE_OP_NEAREST = 3, /* use nearest neighbor interpolation
for edge pixels */
MLIB_EDGE_OP_DEGRADED = 4, /* use degraded interpolation for
edge pixels, i.e., bicubic ->
bilinear -> nearest neighbor */
MLIB_EDGE_SRC_EXTEND = 5, /* extend src edge by replication */
MLIB_EDGE_SRC_EXTEND_ZERO = 6, /* extend src edge with zeros */
MLIB_EDGE_SRC_EXTEND_MIRROR = 7, /* extend src edge with mirrored data */
MLIB_EDGE_SRC_PADDED = 8 /* use borders specified in mlib_image structure */
} mlib_edge;
typedef enum {
MLIB_BLEND_ZERO = 0,
MLIB_BLEND_ONE = 1,
MLIB_BLEND_DST_COLOR = 2,
MLIB_BLEND_SRC_COLOR = 3,
MLIB_BLEND_ONE_MINUS_DST_COLOR = 4,
MLIB_BLEND_ONE_MINUS_SRC_COLOR = 5,
MLIB_BLEND_DST_ALPHA = 6,
MLIB_BLEND_SRC_ALPHA = 7,
MLIB_BLEND_ONE_MINUS_DST_ALPHA = 8,
MLIB_BLEND_ONE_MINUS_SRC_ALPHA = 9,
MLIB_BLEND_SRC_ALPHA_SATURATE = 10
} mlib_blend;
typedef enum {
MLIB_DFT_SCALE_NONE = 0, /* forward transform without scaling */
MLIB_DFT_SCALE_MXN = 1, /* forward transform with scaling of
1/(M*N) */
MLIB_DFT_SCALE_SQRT = 2, /* forward transform with scaling of
1/sqrt(M*N) */
MLIB_IDFT_SCALE_NONE = 3, /* inverse transform without scaling */
MLIB_IDFT_SCALE_MXN = 4, /* inverse transform with scaling of
1/(M*N) */
MLIB_IDFT_SCALE_SQRT = 5 /* inverse transform with scaling of
1/sqrt(M*N) */
} mlib_fourier_mode;
typedef enum {
MLIB_MEDIAN_MASK_RECT = 0, /* Rectangle shaped mask */
MLIB_MEDIAN_MASK_PLUS = 1, /* Plus shaped mask */
MLIB_MEDIAN_MASK_X = 2, /* X shaped mask */
MLIB_MEDIAN_MASK_RECT_SEPARABLE = 3 /* Separable rectangle mask */
} mlib_median_mask;
typedef enum { /* constants used for pixel format */
MLIB_FORMAT_UNKNOWN = 0,
MLIB_FORMAT_INDEXED = 1,
MLIB_FORMAT_GRAYSCALE = 2,
MLIB_FORMAT_RGB = 3,
MLIB_FORMAT_BGR = 4,
MLIB_FORMAT_ARGB = 5,
MLIB_FORMAT_ABGR = 6,
MLIB_FORMAT_PACKED_ARGB = 7,
MLIB_FORMAT_PACKED_ABGR = 8,
MLIB_FORMAT_GRAYSCALE_ALPHA = 9,
MLIB_FORMAT_RGBA = 10
} mlib_format;
typedef struct {
mlib_type type; /* data type of image */
mlib_s32 channels; /* number of channels */
mlib_s32 width; /* width of image in pixels, x dimension */
mlib_s32 height; /* height of image in pixels, y dimension */
mlib_s32 stride; /* linestride = bytes to next row */
mlib_s32 flags; /* collection of helpful hints */
void *data; /* pointer to first data pixel */
void *state; /* internal state structure */
mlib_u8 paddings[4]; /* left, top, right, bottom */
mlib_s32 bitoffset; /* the offset in bits from the beginning */
/* of the data buffer to the first pixel */
mlib_format format; /* pixels format */
mlib_s32 reserved[7 - 2*sizeof(void*)/4];
/* Reserved for future use. Also makes */
/* size of this structure = 64 bytes, which */
/* is the size of the cache line. */
} mlib_image;
/*
* Flags or hints are contained in a 32-bit integer. The bit structure is
* shown below:
*
* 3 2 1
* 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* |S| |U|V| shint | hhint | whint | dhint |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* S = 0 - attributes have been set (attribute field >= 0)
* 1 - attributes have not been set (attribute field < 0)
*
* U = 0 - mediaLib allocated data space
* 1 - user allocated data space
*
* V = 0 - stride == width => 1-D vector
* 1 - stride != width
*
* shint - last 4 bits of stride
*
* hhint - last 4 bits of height
*
* whint - last 4 bits of width
*
* dhint - last 8 bits of data address
*/
enum {
MLIB_IMAGE_ALIGNED64 = 0x3f,
MLIB_IMAGE_ALIGNED8 = 0x7,
MLIB_IMAGE_ALIGNED4 = 0x3,
MLIB_IMAGE_ALIGNED2 = 0x1,
MLIB_IMAGE_WIDTH8X = 0x700,
MLIB_IMAGE_WIDTH4X = 0x300,
MLIB_IMAGE_WIDTH2X = 0x100,
MLIB_IMAGE_HEIGHT8X = 0x7000,
MLIB_IMAGE_HEIGHT4X = 0x3000,
MLIB_IMAGE_HEIGHT2X = 0x1000,
MLIB_IMAGE_STRIDE8X = 0x70000,
MLIB_IMAGE_ONEDVECTOR = 0x100000,
MLIB_IMAGE_USERALLOCATED = 0x200000,
MLIB_IMAGE_ATTRIBUTESET = 0x7fffffff
};
#ifdef __cplusplus
}
#endif
#endif /* MLIB_IMAGE_TYPES_H */
| 41.010929 | 91 | 0.57455 |
4d56fc38f0c47be5604a6688754528d43c803240 | 1,377 | h | C | linux-socfpga/arch/mips/include/asm/mach-loongson32/regs-clk.h | AlbandeCrevoisier/ldd-athens | 93112a15ceac601c93e577ec16369ba7d3b6949e | [
"BSD-3-Clause"
] | null | null | null | linux-socfpga/arch/mips/include/asm/mach-loongson32/regs-clk.h | AlbandeCrevoisier/ldd-athens | 93112a15ceac601c93e577ec16369ba7d3b6949e | [
"BSD-3-Clause"
] | null | null | null | linux-socfpga/arch/mips/include/asm/mach-loongson32/regs-clk.h | AlbandeCrevoisier/ldd-athens | 93112a15ceac601c93e577ec16369ba7d3b6949e | [
"BSD-3-Clause"
] | null | null | null | /*
* Copyright (c) 2011 Zhang, Keguang <keguang.zhang@gmail.com>
*
* Loongson 1 Clock Register Definitions.
*
* 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 __ASM_MACH_LOONGSON32_REGS_CLK_H
#define __ASM_MACH_LOONGSON32_REGS_CLK_H
#define LS1X_CLK_REG(x) \
((void __iomem *)KSEG1ADDR(LS1X_CLK_BASE + (x)))
#define LS1X_CLK_PLL_FREQ LS1X_CLK_REG(0x0)
#define LS1X_CLK_PLL_DIV LS1X_CLK_REG(0x4)
/* Clock PLL Divisor Register Bits */
#define DIV_DC_EN BIT(31)
#define DIV_DC_RST BIT(30)
#define DIV_CPU_EN BIT(25)
#define DIV_CPU_RST BIT(24)
#define DIV_DDR_EN BIT(19)
#define DIV_DDR_RST BIT(18)
#define RST_DC_EN BIT(5)
#define RST_DC BIT(4)
#define RST_DDR_EN BIT(3)
#define RST_DDR BIT(2)
#define RST_CPU_EN BIT(1)
#define RST_CPU BIT(0)
#define DIV_DC_SHIFT 26
#define DIV_CPU_SHIFT 20
#define DIV_DDR_SHIFT 14
#define DIV_DC_WIDTH 4
#define DIV_CPU_WIDTH 4
#define DIV_DDR_WIDTH 4
#define BYPASS_DC_SHIFT 12
#define BYPASS_DDR_SHIFT 10
#define BYPASS_CPU_SHIFT 8
#define BYPASS_DC_WIDTH 1
#define BYPASS_DDR_WIDTH 1
#define BYPASS_CPU_WIDTH 1
#endif /* __ASM_MACH_LOONGSON32_REGS_CLK_H */
| 26.480769 | 75 | 0.750908 |
4d5834aaca10028051a53c70e15f77e4db1cd4db | 274 | h | C | kernels.h | voxel-tracer/cuda-raytracing-optimized | 3e20bc1194a498a69d527f1c0786803e25060c61 | [
"MIT"
] | null | null | null | kernels.h | voxel-tracer/cuda-raytracing-optimized | 3e20bc1194a498a69d527f1c0786803e25060c61 | [
"MIT"
] | null | null | null | kernels.h | voxel-tracer/cuda-raytracing-optimized | 3e20bc1194a498a69d527f1c0786803e25060c61 | [
"MIT"
] | null | null | null | #pragma once
// Required to include vec3.h
#include "helper_structs.h"
extern "C" void initRenderer(const kernel_scene sc, const camera cam, vec3 * *fb, int nx, int ny, int maxDepth);
extern "C" void runRenderer(int ns, int tx, int ty);
extern "C" void cleanupRenderer();
| 30.444444 | 112 | 0.729927 |
4d585f6c1e04879a1881cfbcf7ae0345cb89601f | 8,077 | h | C | Slicer/Slicing/FunctionStaticSlicer.h | twang15/BarrierFinder | c20ff99ffeeeabc1508682bc99ffb4c7659e7e9f | [
"MIT"
] | null | null | null | Slicer/Slicing/FunctionStaticSlicer.h | twang15/BarrierFinder | c20ff99ffeeeabc1508682bc99ffb4c7659e7e9f | [
"MIT"
] | null | null | null | Slicer/Slicing/FunctionStaticSlicer.h | twang15/BarrierFinder | c20ff99ffeeeabc1508682bc99ffb4c7659e7e9f | [
"MIT"
] | null | null | null | // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
#ifndef SLICING_FUNCTIONSTATICSLICER_H
#define SLICING_FUNCTIONSTATICSLICER_H
#include <map>
#include <utility> /* pair */
#include "llvm/IR/Value.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/IR/InstIterator.h"
#include "../PointsTo/PointsTo.h"
#include "../Modifies/Modifies.h"
#include "PostDominanceFrontier.h"
namespace llvm { namespace slicing {
typedef llvm::SmallSetVector<llvm::ptr::PointsToSets::Pointee, 10> ValSet;
typedef std::vector<std::pair<llvm::ptr::PointsToSets::Pointee, llvm::ptr::PointsToSets::Pointee> > DefRcChainSet;
#define __SLICING_FUN__ "Criteria"
#define __WRAPPING_FUN__ "codeWrapping"
#define __ATOMIC_FUN__ "atomic_cmpxchg"
#define __ATOMIC_FUN_1__ "atomic_cmpxchg1"
#define __WAIT_FOR_ALL_FUN__ "waitForAll"
#define __PTHREAD_CREATE__ "pthread_create"
#define __READ_ENV_FILE__ "ReadEnvFile"
#define __FOPEN__ "fopen"
#define __FSCANF__ "fscanf"
#define __SSCANF__ "sscanf"
#define __STRCMP__ "strcmp"
#define __GETC__ "_IO_getc"
class FunctionStaticSlicer;
class InsInfo {
private:
typedef llvm::ptr::PointsToSets::Pointee Pointee;
public:
InsInfo(const llvm::Instruction *i, const llvm::ptr::PointsToSets &PS,
const llvm::mods::Modifies &MOD, FunctionStaticSlicer& fss);
const Instruction *getIns() const { return ins; }
bool addRC(const Pointee &var) { return RC.insert(var); }
bool addDEF(const Pointee &var) { return DEF.insert(var); }
bool addREF(const Pointee &var) { return REF.insert(var); }
void addDefRcChain(std::pair<Pointee, Pointee> chain) { return DefRcChain.push_back(chain); }
void deslice() { sliced = false; }
ValSet::const_iterator RC_begin() const { return RC.begin(); }
ValSet::const_iterator RC_end() const { return RC.end(); }
ValSet::const_iterator DEF_begin() const { return DEF.begin(); }
ValSet::const_iterator DEF_end() const { return DEF.end(); }
ValSet::const_iterator REF_begin() const { return REF.begin(); }
ValSet::const_iterator REF_end() const { return REF.end(); }
DefRcChainSet::const_iterator DefRcChain_begin() const { return DefRcChain.begin(); }
DefRcChainSet::const_iterator DefRcChain_end() const { return DefRcChain.end(); }
bool isSliced() const { return sliced; }
void dumpRC();
void dumpDEF();
void dumpREF();
void dump();
bool isWriteSide(CallInst const* const C);
const Instruction* findSlicingInst(CallInst const* const C, bool isWriteSide);
bool addParameterToREF(Value *parameter);
private:
void addDEFArray(const ptr::PointsToSets &PS, const Value *V,
uint64_t lenConst);
void addREFArray(const ptr::PointsToSets &PS, const Value *V,
uint64_t lenConst);
void handleVariousFuns(const ptr::PointsToSets &PS, const CallInst *C,
const Function *F);
const llvm::Instruction *ins;
ValSet RC, DEF, REF;
//i's Def is j's Rc. Only valid when sliced is false.
//Push into
DefRcChainSet DefRcChain;
bool sliced;
//Fix Radix over-slicing bugs:
//key[0] = malloc(n);
//key[1] = malloc(n);
//if(key[0] == NULL || key[1] == NULL)
//{
// exit(-1);
//}
//
//key[0] is always sliced because the slicer is field insensitive.
//the code above is considered as:
//key = malloc(n)
//key = malloc(n)
//...
//Add members to record all operands for GetElementPtrConstantExpr.
//If all the fields are ConstantInt, it is easy to check their equality.
//But, if any of them is not ConstantInt, we have to conservatively assume their
//equality.
//
//In fact, a very easy fix is to treat all conservatively. The slice currently
//treat all are different and thus is field-insensitve.
};
class FunctionStaticSlicer {
typedef llvm::ptr::PointsToSets::Pointee Pointee;
public:
typedef std::map<const llvm::Instruction *, InsInfo *> InsInfoMap;
FunctionStaticSlicer(llvm::Function &F, llvm::ModulePass *MP,
const llvm::ptr::PointsToSets &PT,
const llvm::mods::Modifies &mods) :
fun(F), MP(MP), modSet(mods) {
for (llvm::inst_iterator I = llvm::inst_begin(F), E = llvm::inst_end(F);
I != E; ++I)
insInfoMap.insert(InsInfoMap::value_type(&*I, new InsInfo(&*I, PT, mods, *this)));
}
~FunctionStaticSlicer();
ValSet::const_iterator relevant_begin(const llvm::Instruction *I) const {
return getInsInfo(I)->RC_begin();
}
ValSet::const_iterator relevant_end(const llvm::Instruction *I) const {
return getInsInfo(I)->RC_end();
}
ValSet::const_iterator REF_begin(const llvm::Instruction *I) const {
return getInsInfo(I)->REF_begin();
}
ValSet::const_iterator REF_end(const llvm::Instruction *I) const {
return getInsInfo(I)->REF_end();
}
ValSet::const_iterator RC_begin(const llvm::Instruction *I) const {
return getInsInfo(I)->RC_begin();
}
ValSet::const_iterator RC_end(const llvm::Instruction *I) const {
return getInsInfo(I)->RC_end();
}
bool isRCEmpty(const llvm::Instruction *I) const { return RC_begin(I) == RC_end(I); }
void deslice(const llvm::Instruction *I) { getInsInfo(I)->deslice(); }
template<typename FwdValueIterator>
bool addCriterion(const llvm::Instruction *ins, FwdValueIterator b,
FwdValueIterator const e, bool desliceIfChanged = false) {
InsInfo *ii = getInsInfo(ins);
bool change = false;
for (; b != e; ++b)
if (ii->addRC(*b))
change = true;
if (change && desliceIfChanged)
ii->deslice();
return change;
}
void addInitialCriterion(const llvm::Instruction *ins,
const Pointee &cond = Pointee(0, 0),
bool deslice = true) {
InsInfo *ii = getInsInfo(ins);
if (cond.first)
ii->addRC(cond);
#if 0
//add REF into RC for slicing criteria.
for (ValSet::const_iterator I = ii->REF_begin(), E = ii->REF_end(); I != E ; I++)
{
const Pointee &REFi = *I;
ii->addRC(REFi);
}
ii->deslice();
#endif
}
void calculateStaticSlice();
bool slice();
static void removeUndefs(ModulePass *MP, Function &F);
void addSkipAssert(const llvm::CallInst *CI) {
skipAssert.insert(CI);
}
bool shouldSkipAssert(const llvm::CallInst *CI) {
return skipAssert.count(CI);
}
void dumpContext(const llvm::Value * val);
void dump();
void dumpRC();
void dumpBC();
void dumpSC();
void dumpDEF();
void dumpREF();
void dumpCriteria();
InsInfo *getInsInfo(const llvm::Instruction *i) const
{
InsInfoMap::const_iterator I = insInfoMap.find(i);
assert(I != insInfoMap.end());
return I->second;
}
private:
llvm::Function &fun;
const mods::Modifies &modSet;
llvm::ModulePass *MP;
InsInfoMap insInfoMap;
llvm::SmallSetVector<const llvm::CallInst *, 10> skipAssert;
static bool sameValues(const Pointee &val1, const Pointee &val2);
void crawlBasicBlock(const llvm::BasicBlock *bb);
bool computeRCi(InsInfo *insInfoi, InsInfo *insInfoj);
bool computeRCi(InsInfo *insInfoi);
void computeRC();
void computeSCi(const llvm::Instruction *i, const llvm::Instruction *j);
void computeSC();
bool computeBC();
bool updateRCSC(llvm::PostDominanceFrontier::DomSetType::const_iterator start,
llvm::PostDominanceFrontier::DomSetType::const_iterator end);
public:
static bool isAllParametersUndefs(CallInst *callInst);
static void removeUndefBranches(ModulePass *MP, Function &F);
static void removeUndefCalls(ModulePass *MP, Function &F);
};
bool findInitialCriterion(llvm::Function &F, FunctionStaticSlicer &ss,
bool startingFunction = false);
}}
#endif
| 33.376033 | 116 | 0.657794 |
4d5a524384327b19756dcf5491628424569ff370 | 534 | h | C | Books/SFML Game Development by Example/Chapter 3/Snake/Snake/include/Textbox.h | mequint/Cpp-Samples | a5e8e08381121c10c100632ae190cc509be3293e | [
"MIT"
] | null | null | null | Books/SFML Game Development by Example/Chapter 3/Snake/Snake/include/Textbox.h | mequint/Cpp-Samples | a5e8e08381121c10c100632ae190cc509be3293e | [
"MIT"
] | null | null | null | Books/SFML Game Development by Example/Chapter 3/Snake/Snake/include/Textbox.h | mequint/Cpp-Samples | a5e8e08381121c10c100632ae190cc509be3293e | [
"MIT"
] | null | null | null | #pragma once
#include <SFML/Graphics.hpp>
using MessageContainer = std::vector<std::string>;
class Textbox {
public:
Textbox();
Textbox(int visible, int charSize, int width, const sf::Vector2f& screenPos);
~Textbox();
void Setup(int visible, int charSize, int width, const sf::Vector2f& screenPos);
void Add(const std::string& message);
void Clear();
void Render(sf::RenderWindow& window);
private:
MessageContainer m_messages;
int m_numVisible;
sf::RectangleShape m_backdrop;
sf::Font m_font;
sf::Text m_content;
}; | 21.36 | 81 | 0.735955 |
4d5cca1d5f6e66d41947b59b4f688eae99650c78 | 619 | h | C | phase_1/eval/livingston/variants/unpatched/common/include/Wave.h | cromulencellc/chess-aces | 7780e29de1991758078816ca501ff79a2586b8c2 | [
"MIT"
] | null | null | null | phase_1/eval/livingston/variants/unpatched/common/include/Wave.h | cromulencellc/chess-aces | 7780e29de1991758078816ca501ff79a2586b8c2 | [
"MIT"
] | null | null | null | phase_1/eval/livingston/variants/unpatched/common/include/Wave.h | cromulencellc/chess-aces | 7780e29de1991758078816ca501ff79a2586b8c2 | [
"MIT"
] | null | null | null | #ifndef WAVE_H
#define WAVE_H
#include "Serializable.h"
#include "Utils.h"
class LFO;
class Wave : public Serializable {
public:
Wave();
Wave(uint32_t sampleRate);
virtual ~Wave();
void addLFO(double detune, double modDepth, double rate);
virtual double getCarrierSignal(double freq) = 0;
virtual audio_sample getSample(double freq) = 0;
protected:
virtual std::ostream &serialize(std::ostream &out) const;
virtual std::istream &dserialize(std::istream &in);
protected:
double getOscilatedFrequency(double frequencyIn);
uint16_t getSampleRate();
private:
uint32_t sampleRate;
LFO *lfo;
};
#endif | 25.791667 | 59 | 0.746365 |
4d6163f5d3d470fb6e7293c3afaa62f3b2bf5366 | 9,035 | c | C | src/ace/acecli.c | zvezdochiot/iminterp | f3ca130e2b7d849f236d1a46d23b4f35ab6596f0 | [
"BSD-2-Clause"
] | 1 | 2019-06-14T20:13:33.000Z | 2019-06-14T20:13:33.000Z | src/ace/acecli.c | IPOL-Fork/iminterp | f3ca130e2b7d849f236d1a46d23b4f35ab6596f0 | [
"BSD-2-Clause"
] | null | null | null | src/ace/acecli.c | IPOL-Fork/iminterp | f3ca130e2b7d849f236d1a46d23b4f35ab6596f0 | [
"BSD-2-Clause"
] | null | null | null | /**
* @file acecli.c
* @brief ACE automatic color enhancement command line program
* @author Pascal Getreuer <getreuer@gmail.com>
*
* Copyright (c) 2012, Pascal Getreuer
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify it
* under, at your option, 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, or the terms of the
* simplified BSD license.
*
* You should have received a copy of these licenses along with this program.
* If not, see <http://www.gnu.org/licenses/> and
* <http://www.opensource.org/licenses/bsd-license.html>.
*/
/**
* @mainpage
* @verbinclude readme.txt
*/
#include <math.h>
#include <string.h>
#include <ctype.h>
#ifdef _OPENMP
#include "omp.h"
#endif
#include "ace.h"
#include <ipol/imageio.h>
#define VERBOSE 0
/** @brief struct of program parameters */
typedef struct
{
/** @brief Input file name */
char *input_file;
/** @brief Output file name */
char *output_file;
/** @brief Quality for saving JPEG images (0 to 100) */
int jpeg_quality;
/** @brief Slope parameter, larger implies stronger in enhancement */
float alpha;
/** @brief Spatial weighting \f$ \omega(x,y) \f$ */
char *omega_string;
/** @brief method: polynomial or interpolation */
char *method;
/** @brief method param */
int method_param;
} program_params;
int parse_params(program_params *param, int argc, char *argv[]);
/** @brief Print program usage help message */
void print_usage()
{
puts("ACE automatic color enhancement, P. Getreuer 2012");
#ifdef _OPENMP
printf("Using OpenMP with %d threads\n", omp_get_max_threads());
#endif
puts("\nSyntax: imintace [options] <input file> <output file>\n\n"
"Only " READIMAGE_FORMATS_SUPPORTED " images are supported.\n");
puts("Options:");
puts(" -a <number> alpha, stronger implies stronger enhancement");
puts(" -w <omega> omega, spatial weighting function, choices are");
puts(" 1/r default ACE, omega(x,y) = 1/sqrt(x^2+y^2)");
puts(" 1 constant, omega(x,y) = 1");
puts(" G:# Gaussian, where # specifies sigma,");
puts(" omega(x,y) = exp(-(x^2+y^2)/(2 sigma^2))");
puts(" -m <method> method to use for fast computation, choices are");
puts(" interp:# interpolate s_a(L - I(x)) with # levels\n");
puts(" poly:# polynomial s_a with degree #");
#ifdef USE_LIBJPEG
puts(" -q <number> quality for saving JPEG images (0 to 100)\n");
#endif
puts("Example: ");
puts(" imintace -a 5 -w 1/r -m interp:12 input.bmp output.bmp\n");
}
#include "omp.h"
int main(int argc, char *argv[])
{
program_params param;
float *f = NULL, *u = NULL;
unsigned long time_start;
int width, height;
int status = 1, success;
if(!parse_params(¶m, argc, argv))
return 0;
/* Read the input image */
if(!(f = (float *)ReadImage(&width, &height, param.input_file,
IMAGEIO_FLOAT | IMAGEIO_PLANAR | IMAGEIO_RGB)))
goto fail;
/* Allocate the output image */
if(!(u = (float *)Malloc(sizeof(float)*3*
((long int)width)*((long int)height))))
goto fail;
printf("Enhancing %dx%d image, alpha = %.4f, omega = %s\n",
width, height, param.alpha, param.omega_string);
#ifdef _OPENMP
printf("Using OpenMP with %d threads\n", omp_get_max_threads());
#endif
time_start = Clock();
/* ACE enhancement */
if(!param.method || !strcmp(param.method, "interp"))
{
printf("Interpolation with %d levels\n", param.method_param);
success = ace_enhance_image_interp(u, f, width, height,
param.alpha, param.omega_string, param.method_param);
}
else
{
printf("Degree %d polynomial approximation\n", param.method_param);
success = ace_enhance_image_poly(u, f, width, height,
param.alpha, param.omega_string, param.method_param);
}
if(!success)
{
ErrorMessage("Error in computation.\n");
goto fail;
}
printf("CPU Time: %.3f s\n", 0.001f*(Clock() - time_start));
/* Write the output image */
if(!WriteImage(u, width, height, param.output_file,
IMAGEIO_FLOAT | IMAGEIO_PLANAR | IMAGEIO_RGB, param.jpeg_quality))
goto fail;
#if VERBOSE > 0
else
printf("Output written to \"%s\".\n", param.output_file);
#endif
status = 0; /* Finished successfully, set exit status to zero. */
fail:
Free(u);
Free(f);
return status;
}
int parse_params(program_params *param, int argc, char *argv[])
{
static char *default_output_file = (char *)"out.bmp";
static char *default_omega = (char *)"1/r";
char *option_string;
char option_char;
int i;
if(argc < 2)
{
print_usage();
return 0;
}
/* Set parameter defaults */
param->input_file = NULL;
param->output_file = default_output_file;
param->jpeg_quality = 85;
param->alpha = 5;
param->omega_string = default_omega;
param->method = NULL;
param->method_param = 8;
for(i = 1; i < argc;)
{
if(argv[i] && argv[i][0] == '-')
{
if((option_char = argv[i][1]) == 0)
{
ErrorMessage("Invalid parameter format.\n");
return 0;
}
if(argv[i][2])
option_string = &argv[i][2];
else if(++i < argc)
option_string = argv[i];
else
{
ErrorMessage("Invalid parameter format.\n");
return 0;
}
switch(option_char)
{
case 'a': /* Read slope parameter alpha */
param->alpha = atof(option_string);
break;
case 'w': /* Read spatial weighting omega */
param->omega_string = option_string;
break;
case 'm': /* Read method string */
{
char *method_param;
param->method = option_string;
if((method_param = strchr(param->method, ':')))
{
*(method_param++) = '\0';
param->method_param = atoi(method_param);
}
else
param->method_param = -1;
if(!strcmp(param->method, "interp"))
{
if(param->method_param == -1)
param->method_param = 8;
else if(param->method_param < 2)
{
ErrorMessage("Interpolation levels must be"
" at least 2.\n");
return 0;
}
}
else if(!strcmp(param->method, "poly"))
{
if(param->method_param == -1)
param->method_param = 9;
else if(param->method_param % 2 == 0
|| param->method_param < 3
|| param->method_param > 11)
{
ErrorMessage("Polynomial degree must be"
" 3, 5, 7, 9, or 11.\n");
return 0;
}
}
else
{
ErrorMessage("Unknown method \"%s\".\n",
param->method);
return 0;
}
}
break;
#ifdef USE_LIBJPEG
case 'q':
param->jpeg_quality = atoi(option_string);
if(param->jpeg_quality <= 0 || param->jpeg_quality > 100)
{
ErrorMessage("JPEG quality must be between 0 and 100.\n");
return 0;
}
break;
#endif
case '-':
print_usage();
return 0;
default:
if(isprint(option_char))
ErrorMessage("Unknown option \"-%c\".\n", option_char);
else
ErrorMessage("Unknown option.\n");
return 0;
}
i++;
}
else
{
if(!param->input_file)
param->input_file = argv[i];
else
param->output_file = argv[i];
i++;
}
}
if(!param->input_file)
{
print_usage();
return 0;
}
return 1;
}
| 30.523649 | 78 | 0.50249 |
4d62884ec27e5bf1bbfdaba300aafb12ad6837f3 | 5,800 | c | C | src/bcon.c | mochimo-in-a-container/mochimo | 7ae45d7dd6157cc0fe7997a0c2fc39e86dab668c | [
"BSD-3-Clause-No-Nuclear-Warranty",
"Unlicense"
] | null | null | null | src/bcon.c | mochimo-in-a-container/mochimo | 7ae45d7dd6157cc0fe7997a0c2fc39e86dab668c | [
"BSD-3-Clause-No-Nuclear-Warranty",
"Unlicense"
] | null | null | null | src/bcon.c | mochimo-in-a-container/mochimo | 7ae45d7dd6157cc0fe7997a0c2fc39e86dab668c | [
"BSD-3-Clause-No-Nuclear-Warranty",
"Unlicense"
] | null | null | null | /* bcon.c Block Constructor
*
* Copyright (c) 2018 by Adequate Systems, LLC. All Rights Reserved.
* See LICENSE.PDF **** NO WARRANTY ****
*
* The Mochimo Project System Software
*
* Date: 10 January 2018
*
* NOTE: Invoked by server.c by fork() and execl()
*
* Inputs: argv[1], txclean.dat
*
* Outputs: argv[2] candidate block cblock.dat
* exit status 0=block make, or non-zero=no block.
*/
#include "config.h"
#include "mochimo.h"
#include "errno.h"
#define closesocket(_sd) close(_sd)
#define EXCLUDE_NODES /* exclude Nodes[], ip, and socket data */
#include "data.c"
#include "error.c"
#include "crypto/crc16.c"
#include "rand.c"
#include "add64.c"
#include "util.c"
#include "daemon.c"
#include "sorttx.c"
word32 Tnum = -1; /* transaction sequence number */
void bail(char *message)
{
if(message) error("bcon: bailing out: %s (%d)", message, Tnum);
exit(1);
}
/*
* Clean-up on SIGTERM
*/
void sigterm2(int sig)
{
unlink("cblock.tmp");
unlink("cblock.dat");
unlink("bctx.dat");
exit(1);
}
/* Invocation: bcon txclean.dat cblock.dat */
int main(int argc, char **argv)
{
static TXQENTRY tx; /* Holds one transaction in the array */
FILE *fp; /* to read txclean.dat file */
FILE *fpout; /* for cblock.dat */
word32 bnum[2]; /* new block num */
int count;
SHA256_CTX mctx; /* to hash transaction array */
SHA256_CTX bctx; /* to hash entire block */
static BHEADER bh; /* the minimal length block header */
static BTRAILER bt; /* block trailers are fixed length */
word32 *idx;
byte prev_tx_id[HASHLEN]; /* to check for duplicate transactions */
int cond;
word32 ntx;
static word32 mreward[2];
fix_signals();
signal(SIGTERM, sigterm2); /* server() may kill us. */
if(argc != 3) {
printf("\nusage: bcon txclean.dat cblock.dat\n"
"This program is spawned from server.c\n\n");
exit(1);
}
unlink("bctx.dat");
/* get global block number, peer ip, etc. */
if(read_global() != VEOK)
bail("no global.dat");
/* read mining address */
if(read_data(Maddr, TXADDRLEN, "maddr.dat") != TXADDRLEN)
bail("no maddr.dat");
if(Trace) {
Logfp = fopen(LOGFNAME, "a");
plog("Entering bcon...");
}
/* build sorted index Txidx[] from txclean.dat */
if(sorttx(argv[1]) != VEOK) bail("bad sorttx()");
/* re-open the clean TX queue (txclean.dat) to read */
fp = fopen(argv[1], "rb");
if(!fp) {
badread:
bail("Cannot open [txclean.dat]");
}
/* create cblock.dat */
fpout = fopen("cblock.tmp", "wb");
if(!fpout) {
badwrite:
bail("Cannot write [cblock.tmp]");
}
sha256_init(&mctx); /* for Merkel array */
sha256_init(&bctx); /* for entire block */
/* trailer */
memcpy(bt.phash, Cblockhash, HASHLEN); /* hash of previous to new block */
add64(Cblocknum, One, bnum); /* Compute the new block num */
put64(bt.bnum, bnum); /* and put in trailer. */
if(Trace) plog("bcon: put 0x%s in trailer", bnum2hex(bt.bnum));
put64(bt.mfee, Mfee);
put32(bt.difficulty, Difficulty);
put32(bt.time0, Time0);
/* Prepare new block header and trailer */
put32(bh.hdrlen, sizeof(bh));
memcpy(bh.maddr, Maddr, TXADDRLEN);
get_mreward(mreward, bnum);
put64(bh.mreward, mreward);
/* begin hash of entire block */
sha256_update(&bctx, (byte *) &bh, sizeof(BHEADER));
/* write header to disk */
count = fwrite(&bh, 1, sizeof(BHEADER), fpout);
if(count != sizeof(BHEADER)) goto badwrite;
/* Read transactions from txclean.dat in sort order
* using Txidx[].
*/
ntx = 0;
for(idx = Txidx, Tnum = 0; Tnum < Ntx && ntx < MAXBLTX; Tnum++, idx++) {
if(Tnum != 0) {
cond = memcmp(&Tx_ids[*idx * HASHLEN], prev_tx_id, HASHLEN);
if(cond < 0)
bail("internal txclean.dat sort error");
if(cond == 0) continue; /* ignore duplicate transaction */
}
memcpy(prev_tx_id, &Tx_ids[*idx * HASHLEN], HASHLEN);
if(fseek(fp, *idx * sizeof(TXQENTRY), SEEK_SET) != 0)
bail("bad seek on txclean.dat");
count = fread(&tx, 1, sizeof(TXQENTRY), fp);
if(count != sizeof(TXQENTRY)) goto badread;
ntx++; /* actual transactions for block */
sha256_update(&bctx, (byte *) &tx, sizeof(TXQENTRY)); /* entire block */
sha256_update(&mctx, (byte *) &tx, sizeof(TXQENTRY)); /* Merkel Array */
count = fwrite(&tx, 1, sizeof(TXQENTRY), fpout);
if(count != sizeof(TXQENTRY)) goto badwrite;
} /* end for Tnum */
sha256_final(&mctx, bt.mroot); /* put the Merkel root in trailer */
/* Put tran count in trailer */
if(ntx == 0) {
if(Trace) plog("bcon: no good transactions");
bail(NULL);
}
put32(bt.tcount, ntx);
/* Hash in the trailer leaving out:
* nonce[32], stime[4], and bhash[32].
*/
sha256_update(&bctx, (byte *) &bt, (sizeof(BTRAILER) - (2*HASHLEN) - 4));
/* Let the miner put final hash[] and stime[] at end of BTRAILER struct
* with the calls to sha256_final() and put32().
* Gift bctx to miner using write_data().
*/
/* write trailer to disk */
count = fwrite(&bt, 1, sizeof(BTRAILER), fpout);
if(count != sizeof(BTRAILER)) goto badwrite;
if(Tx_ids) free(Tx_ids); /* sorttx() allocated these two */
if(Txidx) free(Txidx);
fclose(fp); /* txclean.dat */
fclose(fpout); /* cblock.dat */
/* save bctx to disk for miner */
if(write_data(&bctx, sizeof(bctx), "bctx.dat") != VEOK)
bail("bctx.dat");
unlink(argv[2]);
if(rename("cblock.tmp", argv[2])) {
error("bcon: rename cblock.tmp (%d)", errno);
bail(NULL);
}
return 0;
} /* end main() */
| 28.15534 | 79 | 0.596724 |
4d63000c93ec9a7851a1f67524322124a6e17676 | 2,484 | c | C | src/test/test_endianess.c | sseering/pycryptodome | ebe633f30ae5b1a6f171fc75a33a6dfca9a7a0b3 | [
"Unlicense"
] | 1 | 2021-05-12T04:02:03.000Z | 2021-05-12T04:02:03.000Z | src/test/test_endianess.c | sseering/pycryptodome | ebe633f30ae5b1a6f171fc75a33a6dfca9a7a0b3 | [
"Unlicense"
] | null | null | null | src/test/test_endianess.c | sseering/pycryptodome | ebe633f30ae5b1a6f171fc75a33a6dfca9a7a0b3 | [
"Unlicense"
] | null | null | null | #include "common.h"
#include <assert.h>
void test_little_32(void)
{
uint32_t t;
uint8_t res[4];
t = 0x04030201U;
memset(res, 0xFF, 4);
u32to8_little(res, &t);
assert(0 == memcmp(res, "\x01\x02\x03\x04", 4));
t = ~0U;
u8to32_little(&t, res);
assert(t == 0x04030201U);
t = ~0U;
t = load_u8to32_little(res);
assert(t == 0x04030201U);
t = ~0U;
t = LOAD_U32_LITTLE(res);
assert(t == 0x04030201U);
t = 0x04030201U;
memset(res, 0xFF, 4);
STORE_U32_LITTLE(res, t);
assert(0 == memcmp(res, "\x01\x02\x03\x04", 4));
}
void test_big_32(void)
{
uint32_t t;
uint8_t res[4];
t = 0x04030201U;
memset(res, 0xFF, 4);
u32to8_big(res, &t);
assert(0 == memcmp(res, "\x04\x03\x02\x01", 4));
t = ~0U;
u8to32_big(&t, res);
assert(t == 0x04030201U);
t = ~0U;
t = load_u8to32_big(res);
assert(t == 0x04030201U);
t = ~0U;
t = LOAD_U32_BIG(res);
assert(t == 0x04030201U);
t = 0x04030201U;
memset(res, 0xFF, 4);
STORE_U32_BIG(res, t);
assert(0 == memcmp(res, "\x04\x03\x02\x01", 4));
}
void test_little_64(void)
{
uint64_t t;
uint8_t res[8];
t = 0x0807060504030201UL;
memset(res, 0xFF, 8);
u64to8_little(res, &t);
assert(0 == memcmp(res, "\x01\x02\x03\x04\x05\x06\x07\x08", 8));
t = ~0UL;
u8to64_little(&t, res);
assert(t == 0x0807060504030201UL);
t = ~0UL;
t = load_u8to64_little(res);
assert(t == 0x0807060504030201UL);
t = ~0UL;
t = LOAD_U64_LITTLE(res);
assert(t == 0x0807060504030201UL);
t = 0x0807060504030201UL;
memset(res, 0xFF, 8);
STORE_U64_LITTLE(res, t);
assert(0 == memcmp(res, "\x01\x02\x03\x04\x05\x06\x07\x08", 8));
}
void test_big_64(void)
{
uint64_t t;
uint8_t res[8];
t = 0x0807060504030201UL;
memset(res, 0xFF, 8);
u64to8_big(res, &t);
assert(0 == memcmp(res, "\x08\x07\x06\x05\x04\x03\x02\x01", 8));
t = ~0UL;
u8to64_big(&t, res);
assert(t == 0x0807060504030201UL);
t = ~0UL;
t = load_u8to64_big(res);
assert(t == 0x0807060504030201UL);
t = ~0UL;
t = LOAD_U64_BIG(res);
assert(t == 0x0807060504030201UL);
t = 0x0807060504030201UL;
memset(res, 0xFF, 8);
STORE_U64_BIG(res, t);
assert(0 == memcmp(res, "\x08\x07\x06\x05\x04\x03\x02\x01", 8));
}
int main(void)
{
test_little_32();
test_big_32();
test_little_64();
test_big_64();
return 0;
}
| 19.40625 | 68 | 0.58132 |
4d66de0ba837bfdcbdbdb20e98607a236dd42588 | 583 | h | C | src/BLASxON/gnd/util/inc/m__swaprow.h | meinkea/RottenCore | 310a1cad96558e6e6accc1f67baf141fb921048c | [
"Unlicense"
] | null | null | null | src/BLASxON/gnd/util/inc/m__swaprow.h | meinkea/RottenCore | 310a1cad96558e6e6accc1f67baf141fb921048c | [
"Unlicense"
] | null | null | null | src/BLASxON/gnd/util/inc/m__swaprow.h | meinkea/RottenCore | 310a1cad96558e6e6accc1f67baf141fb921048c | [
"Unlicense"
] | null | null | null | /*! /file m__swaprow.h
*
*/
#ifndef BLASxON__M__SWAPROW_H
#define BLASxON__M__SWAPROW_H
// -- CPU Architecture
#include "../../cpu_architecture/cpu_architecture.h"
// -- BLAS Datatypes
// #include "../../datatypes/inc/vector.h"
#include "../../datatypes/inc/matrix.h"
#ifdef __cplusplus
extern "C" {
#endif
void BLASxON__FuncHEAD m__swaprow(
struct matrix * mDst,
const unsigned int row1,
const unsigned int row2
)
__attribute__((nonull))
;
#ifdef __cplusplus
}
#endif
#endif // BLASxON__M__SWAPROW_H
| 14.219512 | 54 | 0.634648 |
4d66e564b3108d5db596a3e27e6b82ff13802dc3 | 1,325 | c | C | Cadeira Algoritmos em C/Nro Primos Acima DiagP.c | rhuanlinke/banco-algoritmo | b026cedaf3415d7f51f079cf32e8976cb97f0516 | [
"MIT"
] | 1 | 2020-06-16T04:31:06.000Z | 2020-06-16T04:31:06.000Z | Cadeira Algoritmos em C/Nro Primos Acima DiagP.c | rhuanlinke/Banco-Algoritmo | b026cedaf3415d7f51f079cf32e8976cb97f0516 | [
"MIT"
] | null | null | null | Cadeira Algoritmos em C/Nro Primos Acima DiagP.c | rhuanlinke/Banco-Algoritmo | b026cedaf3415d7f51f079cf32e8976cb97f0516 | [
"MIT"
] | null | null | null | /******************************************************************************
Faça um algoritmo que armazena em uma matriz quadrada a quantidade de numeros do tipo int definidos pelo usuário
e que verifica e imprime na tela todos os números que são primos e que estão presentes acima diagonal principal.
Ex.: Em Amarelo a diagonal principal e em Verde os elementos acima da diagonal principal
*******************************************************************************/
#include <stdio.h>
int main()
{
int i = 0, j = 0, id = 1, ir = 0, m;
printf("Matriz:\n");
scanf("%d", &m);
int nro[m][m];
while (i < m)
{
j = 0;
while (j < m)
{
printf("Digite um nro\n");
scanf("%d", &nro[i][j]);
j++;
}
i++;
}
j = 0;
i = 0;
while (i < m)
{
j = 0;
while (j < m)
{
id = 1;
ir = 0;
while (id <= nro[i][j])
{
if (nro[i][j] % id == 0)
{
ir++;
}
id++;
}
if (ir == 2 && j > i)
{
printf("Primos acima da diagonal principal: %d\n", nro[i][j]);
}
j++;
}
i++;
}
} | 23.245614 | 112 | 0.355472 |
4d688643c7dc9595eb3ee7a87587585098a3a777 | 5,514 | h | C | usr/src/cmd/rpcbind/rpcbind.h | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | null | null | null | usr/src/cmd/rpcbind/rpcbind.h | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | null | null | null | usr/src/cmd/rpcbind/rpcbind.h | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | 1 | 2020-12-30T00:04:16.000Z | 2020-12-30T00:04:16.000Z | /*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright 2014 Nexenta Systems, Inc. All rights reserved.
*/
/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
/*
* rpcbind.h
* The common header declarations
*/
#ifndef _RPCBIND_H
#define _RPCBIND_H
#ifdef PORTMAP
#include <rpc/pmap_prot.h>
#endif
#include <rpc/rpcb_prot.h>
#include <synch.h>
#ifdef __cplusplus
extern "C" {
#endif
extern int debugging;
extern int doabort;
extern rwlock_t list_rbl_lock; /* Protects list_rbl */
extern rpcblist_ptr list_rbl; /* A list of version 3 & 4 rpcbind services */
extern char *loopback_dg; /* CLTS loopback transport, for set/unset */
extern char *loopback_vc; /* COTS loopback transport, for set/unset */
extern char *loopback_vc_ord; /* COTS_ORD loopback transport, for set/unset */
#ifdef PORTMAP
extern rwlock_t list_pml_lock; /* Protects list_pml */
extern pmaplist *list_pml; /* A list of version 2 rpcbind services */
extern char *udptrans; /* Name of UDP transport */
extern char *tcptrans; /* Name of TCP transport */
extern char *udp_uaddr; /* Universal UDP address */
extern char *tcp_uaddr; /* Universal TCP address */
#endif
char *mergeaddr(SVCXPRT *, char *, char *, char *);
int add_bndlist(struct netconfig *, struct t_bind *, struct t_bind *);
int create_rmtcall_fd(struct netconfig *);
bool_t is_bound(char *, char *);
void set_rpcb_rmtcalls_max(int);
/* TCP wrapper functions and variables. */
boolean_t localxprt(SVCXPRT *, boolean_t);
void qsyslog(int pri, const char *fmt, ...);
boolean_t rpcb_check(SVCXPRT *, rpcproc_t, boolean_t);
void rpcb_log(boolean_t, SVCXPRT *, rpcproc_t, rpcprog_t, boolean_t);
extern volatile boolean_t allow_indirect;
extern volatile boolean_t wrap_enabled;
extern volatile boolean_t verboselog;
extern volatile boolean_t local_only;
#define svc_getgencaller(transp) \
((struct sockaddr_gen *)svc_getrpccaller((transp))->buf)
#define RPCB_CHECK(xprt, proc) \
if ((wrap_enabled || local_only) && \
!rpcb_check((xprt), (proc), B_FALSE)) \
return
#define PMAP_CHECK(xprt, proc) \
if ((wrap_enabled || local_only) && \
!rpcb_check((xprt), (proc), B_TRUE)) \
return
#define PMAP_CHECK_RET(xprt, proc, ret) \
if ((wrap_enabled || local_only) && \
!rpcb_check((xprt), (proc), B_TRUE)) \
return (ret)
#define RPCB_LOG(xprt, proc, prog) \
if (wrap_enabled) \
rpcb_log(B_TRUE, (xprt), (proc), (prog), B_FALSE)
#define PMAP_LOG(ans, xprt, proc, prog) \
if (wrap_enabled) \
rpcb_log(ans, (xprt), (proc), (prog), B_TRUE)
bool_t map_set(RPCB *, char *);
bool_t map_unset(RPCB *, char *);
/* Statistics gathering functions */
void rpcbs_procinfo(int, rpcproc_t);
void rpcbs_set(int, bool_t);
void rpcbs_unset(int, bool_t);
void rpcbs_getaddr(int, rpcprog_t, rpcvers_t, char *, char *);
void rpcbs_rmtcall(int, rpcproc_t, rpcprog_t, rpcvers_t, rpcproc_t, char *,
rpcblist_ptr);
bool_t rpcbproc_getstat(void *, rpcb_stat_byvers **);
bool_t xdr_rpcb_stat_byvers_ptr(XDR *, rpcb_stat_byvers **);
struct netconfig *rpcbind_get_conf();
void rpcbind_abort() __NORETURN;
#ifdef PORTMAP
void pmap_service(struct svc_req *, SVCXPRT *xprt);
#endif
void rpcb_service_3(struct svc_req *, SVCXPRT *xprt);
void rpcb_service_4(struct svc_req *, SVCXPRT *xprt);
void read_warmstart(void);
void write_warmstart(void);
int Is_ipv6present(void);
extern zoneid_t myzone;
/* Common functions shared between versions */
void rpcbproc_callit_com(struct svc_req *, SVCXPRT *, ulong_t, int);
bool_t rpcbproc_set_com(RPCB *, bool_t *, struct svc_req *, int);
bool_t rpcbproc_unset_com(RPCB *, bool_t *, struct svc_req *, int);
bool_t rpcbproc_gettime_com(void *, ulong_t *);
bool_t rpcbproc_uaddr2taddr_com(char **, struct netbuf *, struct svc_req *);
bool_t rpcbproc_taddr2uaddr_com(struct netbuf *, char **, struct svc_req *);
bool_t rpcbproc_getaddr_com(RPCB *, char **, struct svc_req *, ulong_t);
void delete_prog(rpcprog_t);
bool_t rpcbproc_dump_com(void *, rpcblist_ptr **);
char *getowner(SVCXPRT *, char *);
int del_pmaplist(RPCB *);
void delete_rbl(rpcblist_ptr);
uid_t rpcb_caller_uid(SVCXPRT *);
/* XDR functions */
bool_t xdr_rpcblist_ptr_ptr(XDR *, rpcblist_ptr **);
/* For different getaddr semantics */
#define RPCB_ALLVERS 0
#define RPCB_ONEVERS 1
#ifdef __cplusplus
}
#endif
#endif /* _RPCBIND_H */
| 32.05814 | 78 | 0.735945 |
4d694b6ace0bbd4e82c4b4d7d8234c63d7b1f602 | 5,201 | h | C | Examples_3/Unit_Tests/src/06_MaterialPlayground/Shaders/FSL/Quest/hair.comp.h | divecoder/The-Forge | e882fbc000b2915b52c98fe3a8c791930490dd3c | [
"Apache-2.0"
] | 3,058 | 2017-10-03T01:33:22.000Z | 2022-03-30T22:04:23.000Z | Examples_3/Unit_Tests/src/06_MaterialPlayground/Shaders/FSL/Quest/hair.comp.h | juteman/The-Forge | e882fbc000b2915b52c98fe3a8c791930490dd3c | [
"Apache-2.0"
] | 157 | 2018-01-26T10:18:33.000Z | 2022-03-06T10:59:23.000Z | Examples_3/Unit_Tests/src/06_MaterialPlayground/Shaders/FSL/Quest/hair.comp.h | juteman/The-Forge | e882fbc000b2915b52c98fe3a8c791930490dd3c | [
"Apache-2.0"
] | 388 | 2017-12-21T10:52:32.000Z | 2022-03-31T18:25:49.000Z |
#define THREAD_GROUP_SIZE 64
struct VertexIndices
{
uint globalStrandIndex;
uint localStrandIndex;
uint globalVertexIndex;
uint localVertexIndex;
uint indexSharedMem;
};
struct StrandIndices
{
uint globalStrandIndex;
uint globalRootVertexIndex;
};
struct Capsule
{
float4 center0AndRadius0;
float4 center1AndRadius1;
};
// cbuffer cbSimulation : register(b0, UPDATE_FREQ_PER_DRAW)
CBUFFER(cbSimulation, UPDATE_FREQ_PER_DRAW, b0, binding = 0)
{
DATA(float4x4, Transform, None);
DATA(float4, QuatRotation, None);
#if HAIR_MAX_CAPSULE_COUNT > 0
DATA(Capsule, Capsules[HAIR_MAX_CAPSULE_COUNT], None);
DATA(uint, mCapsuleCount, None);
#endif
DATA(float, Scale, None);
DATA(uint, NumStrandsPerThreadGroup, None);
DATA(uint, NumFollowHairsPerGuideHair, None);
DATA(uint, NumVerticesPerStrand, None);
DATA(float, Damping, None);
DATA(float, GlobalConstraintStiffness, None);
DATA(float, GlobalConstraintRange, None);
DATA(float, VSPStrength, None);
DATA(float, VSPAccelerationThreshold, None);
DATA(float, LocalStiffness, None);
DATA(uint, LocalConstraintIterations, None);
DATA(uint, LengthConstraintIterations, None);
DATA(float, TipSeperationFactor, None);
};
// cbuffer cbHairGlobal : register(b4, UPDATE_FREQ_PER_DRAW)
CBUFFER(cbHairGlobal, UPDATE_FREQ_PER_DRAW, b4, binding = 1)
{
DATA(float4, Viewport, None);
DATA(float4, Gravity, None);
DATA(float4, Wind, None);
DATA(float, TimeStep, None);
};
RES(RWBuffer(float4),HairVertexPositions, UPDATE_FREQ_PER_DRAW, u0, binding = 2);
RES(RWBuffer(float4),HairVertexPositionsPrev, UPDATE_FREQ_PER_DRAW, u1, binding = 3);
RES(RWBuffer(float4),HairVertexPositionsPrevPrev, UPDATE_FREQ_PER_DRAW, u2, binding = 4);
RES(RWBuffer(float4),HairVertexTangents, UPDATE_FREQ_PER_DRAW, u3, binding = 5);
RES(Buffer(float4), HairRestPositions, UPDATE_FREQ_PER_DRAW, t0, binding = 6);
RES(Buffer(float), HairRestLengths, UPDATE_FREQ_PER_DRAW, t1, binding = 7);
RES(Buffer(float4), HairGlobalRotations, UPDATE_FREQ_PER_DRAW, t2, binding = 8);
RES(Buffer(float4), HairRefsInLocalFrame, UPDATE_FREQ_PER_DRAW, t3, binding = 9);
RES(Buffer(float4), FollowHairRootOffsets, UPDATE_FREQ_PER_DRAW, t4, binding = 10);
DECLARE_RESOURCES()
float3 RotateVec(float4 q, float3 v)
{
float3 uv, uuv;
float3 qvec = float3(q.x, q.y, q.z);
uv = cross(qvec, v);
uuv = cross(qvec, uv);
uv *= (2.0f * q.w);
uuv *= 2.0f;
return v + uv + uuv;
}
float4 InverseQuaternion(float4 q)
{
float lengthSqr = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
if (lengthSqr < 0.001)
return float4(0, 0, 0, 1.0f);
q.x = -q.x / lengthSqr;
q.y = -q.y / lengthSqr;
q.z = -q.z / lengthSqr;
q.w = q.w / lengthSqr;
return q;
}
float4 NormalizeQuaternion(float4 q)
{
float4 qq = q;
float n = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
if (n < 1e-10f)
{
qq.w = 1;
return qq;
}
qq *= 1.0f / sqrt(n);
return qq;
}
float4 MultQuaternionAndQuaternion(float4 qA, float4 qB)
{
float4 q;
q.w = qA.w * qB.w - qA.x * qB.x - qA.y * qB.y - qA.z * qB.z;
q.x = qA.w * qB.x + qA.x * qB.w + qA.y * qB.z - qA.z * qB.y;
q.y = qA.w * qB.y + qA.y * qB.w + qA.z * qB.x - qA.x * qB.z;
q.z = qA.w * qB.z + qA.z * qB.w + qA.x * qB.y - qA.y * qB.x;
return q;
}
float4 MakeQuaternion(float angle_radian, float3 axis)
{
// create quaternion using angle and rotation axis
float4 quaternion;
float halfAngle = 0.5f * angle_radian;
float sinHalf = sin(halfAngle);
quaternion.w = cos(halfAngle);
quaternion.xyz = sinHalf * axis.xyz;
return quaternion;
}
float4 QuatFromUnitVectors(float3 u, float3 v)
{
float r = 1.f + dot(u, v);
float3 n;
// if u and v are parallel
if (r < 1e-7)
{
r = 0.0f;
n = abs(u.x) > abs(u.z) ? float3(-u.y, u.x, 0.f) : float3(0.f, -u.z, u.y);
}
else
{
n = cross(u, v);
}
float4 q = float4(n.x, n.y, n.z, r);
return NormalizeQuaternion(q);
}
VertexIndices CalculateVertexIndices(uint localID, uint groupID)
{
VertexIndices result;
result.indexSharedMem = localID;
result.localStrandIndex = localID % Get(NumStrandsPerThreadGroup);
result.globalStrandIndex = groupID * Get(NumStrandsPerThreadGroup) + result.localStrandIndex;
result.globalStrandIndex *= Get(NumFollowHairsPerGuideHair) + 1;
result.localVertexIndex = (localID - result.localStrandIndex) / Get(NumStrandsPerThreadGroup);
result.globalVertexIndex = result.globalStrandIndex * Get(NumVerticesPerStrand) + result.localVertexIndex;
return result;
}
StrandIndices CalculateStrandIndices(uint localID, uint groupID)
{
StrandIndices result;
result.globalStrandIndex = THREAD_GROUP_SIZE * groupID + localID;
result.globalStrandIndex *= Get(NumFollowHairsPerGuideHair) + 1;
result.globalRootVertexIndex = result.globalStrandIndex * Get(NumVerticesPerStrand);
return result;
}
float4 Integrate(float4 currentPosition, float4 prevPosition, float4 force, VertexIndices indices)
{
float4 result = currentPosition;
force.xyz += Get(Gravity).xyz;
result.xyz += (1.0f - Get(Damping)) * (currentPosition.xyz - prevPosition.xyz) + force.xyz * Get(TimeStep) * Get(TimeStep);
return result;
}
GroupShared(float4, sharedPos[THREAD_GROUP_SIZE]);
GroupShared(float4, sharedTangent[THREAD_GROUP_SIZE]);
GroupShared(float, sharedLength[THREAD_GROUP_SIZE]); | 26.535714 | 124 | 0.722553 |
4d6bd495975dd3d18c14d8ecc0cbc35cf7f1426d | 5,773 | h | C | libimage/source/Image.h | PRImA-Research-Lab/prima-image-lib | 9072672cf1f42caf35e8c69d6b09ee6217fb24a6 | [
"Apache-2.0"
] | 4 | 2017-10-04T06:23:11.000Z | 2019-05-09T14:39:12.000Z | libimage/source/Image.h | PRImA-Research-Lab/prima-image-lib | 9072672cf1f42caf35e8c69d6b09ee6217fb24a6 | [
"Apache-2.0"
] | null | null | null | libimage/source/Image.h | PRImA-Research-Lab/prima-image-lib | 9072672cf1f42caf35e8c69d6b09ee6217fb24a6 | [
"Apache-2.0"
] | 2 | 2018-10-11T02:01:42.000Z | 2019-02-09T21:30:59.000Z | #ifndef IMAGE_H
#define IMAGE_H
#ifdef _MSC_VER
#include "afxwin.h"
#include "extrastring.h"
//#include <pstdint.h>
#include <cstdint>
#else
#include <stdint.h>
#endif
#ifndef DllExport
#ifndef PRIMA_DLL_IMPORT
#define DllExport __declspec( dllexport )
#else
#define DllExport __declspec( dllimport )
#endif
#endif
typedef struct tagImageInfo
{
short int Type;
double RangeLeft;
double RangeRight;
} ImageInfo;
struct RGBCOLOUR
{
unsigned char R;
unsigned char G;
unsigned char B;
unsigned char A;
bool operator==(RGBCOLOUR & cmp)
{
return (R == cmp.R && G == cmp.G && B == cmp.B && A == cmp.A);
};
};
const RGBCOLOUR RGBBLACK = { 0, 0, 0, 255};
const RGBCOLOUR RGBWHITE = {255, 255, 255, 255};
const RGBCOLOUR RGBRED = {255, 0, 0, 255};
const RGBCOLOUR RGBGREEN = { 0, 255, 0, 255};
const RGBCOLOUR RGBBLUE = { 0, 0, 255, 255};
const RGBCOLOUR RGBYELLOW = {255, 255, 0, 255};
const RGBCOLOUR RGBORANGE = {255, 128, 0, 255};
const RGBCOLOUR RGBPINK = {255, 128, 255, 255};
const RGBCOLOUR RGBGREY = {128, 128, 128, 255};
const RGBCOLOUR RGBGREY32 = { 32, 32, 32, 255};
const RGBCOLOUR RGBGREY64 = { 64, 64, 64, 255};
const RGBCOLOUR RGBGREY96 = { 96, 96, 96, 255};
const RGBCOLOUR RGBGREY128 = {128, 128, 128, 255};
const RGBCOLOUR RGBGREY160 = {160, 160, 160, 255};
const RGBCOLOUR RGBGREY192 = {192, 192, 192, 255};
const RGBCOLOUR RGBGREY224 = {224, 224, 224, 255};
const RGBCOLOUR RGBTURQUOISE = { 0, 255, 192, 255};
const RGBCOLOUR RGBINDIGO = { 75, 0, 130, 255};
const RGBCOLOUR RGBVIOLET = {238, 130, 238, 255};
const RGBCOLOUR RGBCYAN = { 0, 255, 255, 255};
const RGBCOLOUR RGBMAGENTA = {255, 0, 255, 255};
namespace PRImA
{
/*
* Class CImage
*
* Base class for PRImA image classes.
*
* Deprecated: Use OpenCV image classes.
*/
class DllExport CImage
{
public:
static const int ERR_NONE = 0;
static const int ERR_UNKNOWN = 1;
static const int ERR_OUT_OF_MEMORY = 2;
// CONSTRUCTION
public:
CImage();
virtual ~CImage();
// METHODS
public:
void Init();
virtual bool Create(int Width, int Height, RGBCOLOUR BackColour, const char * Name, bool reverse = false);
CImage* CreateSubImage(int left, int top, int width, int height); //Creates an image of the same type copying the specified frame.
virtual CImage * CreateNewImage() = 0; //Factory method to create an empty image
//virtual bool DetectBaselineDist(int NoStrips = 1);
virtual void Frame(int FrameWidth, bool White);
virtual int GetBaselineDist();
virtual CImage * Clone(bool reverse = false) = 0; //Creates a deep copy of this image
#ifdef _MSC_VER
HBITMAP CreateBitmap();
//inline CBitmap * GetBitmap() { if (m_ImageBitmap == NULL) return CreateBitmap(); else return m_ImageBitmap; };
#endif
inline RGBCOLOUR GetBackColour() { return m_BackColour; };
inline unsigned GetBitsPerPixel() { return m_BitsPerPixel; };
static double GetColourDistance(RGBCOLOUR a, RGBCOLOUR b);
inline int GetHeight() { return m_Height; };
void GetICCProfile(uint32_t * ICCLength, uint8_t ** ICCProfile);
virtual RGBCOLOUR GetRGBColor(int x, int y)
{
return (x ==y ? RGBWHITE : RGBWHITE);
};
virtual void FillBitmapInfo()
{
return;
};
virtual void SetRGBColor(int, int, RGBCOLOUR){return;};
inline char * GetName() { return m_sName; };
void SetName(const char * name);
inline int GetWidth() { return m_Width;};
inline void SetSize(unsigned width, unsigned height)
{
m_Width = width;
m_Height = height;
}
inline double GetXRes() { return m_ResX; };
inline double GetYRes() { return m_ResY; };
void inline SetBitsPerPixel(unsigned bpp) { m_BitsPerPixel = bpp; };
void SetICCProfile(uint32_t ICCLength, uint8_t * ICCProfile);
inline void SetResolution(const double XRes, const double YRes)
{
m_ResX = XRes;
m_ResY = YRes;
};
inline void SetResolutionUnit(int resUnit) { m_ResUnit = resUnit; };
inline void SetBytesBerLine(long bytes) { m_BytesPerLine = bytes; };
void InitArrays();
inline long GetBytesPerLine() { return m_BytesPerLine; };
inline uint8_t** GetLineArray() { return m_pLineArray; };
inline void SetLineArray(uint8_t** lineArray) { m_pLineArray = lineArray; };
inline uint8_t* GetArray() { return m_pArray; };
inline void SetArray(uint8_t* pArray) { m_pArray = pArray;};
inline uint32_t GetIccLength() { return m_nICCLength; };
inline void SetIccLength(uint32_t iccLength) { m_nICCLength = iccLength; };
//TODO CC: There already is a method called GetICCProfile! What does it do and where is it used? Maybe it should be renamed.
inline uint8_t* GetIccProfile() { return m_sICCProfile; };
inline void SetIccProfile(uint8_t* iccProfile) { m_sICCProfile = iccProfile; };
inline HBITMAP GetHBitmap() { if (m_ImageHBitmap==NULL) return CreateBitmap(); else return m_ImageHBitmap; };
inline void ResetHBitmap() { DeleteObject(m_ImageHBitmap); m_ImageHBitmap = 0; };
inline CUniString GetFilePath() { return m_FilePath; };
inline void SetFilePath(CUniString path) { m_FilePath = path; };
virtual void Clear(RGBCOLOUR colour) = 0;
// DATA
private:
ImageInfo m_Info;
long m_NumberOfPixels;
int m_ResUnit;
protected:
uint8_t * m_pArray;
RGBCOLOUR m_BackColour;
int m_BaselineDist;
uint16_t m_BitsPerPixel;
long m_BytesPerLine;
RGBCOLOUR m_nForeColour;
int m_Height;
uint32_t m_nICCLength;
uint8_t * m_sICCProfile;
uint8_t ** m_pLineArray; //Helper for faster access of lines
char * m_sName;
double m_ResX;
double m_ResY;
int m_Width;
CUniString m_FilePath;
#ifdef _MSC_VER
//CBitmap * m_ImageBitmap;
BITMAPINFO * m_pBitmapInfo;
HBITMAP m_ImageHBitmap;
#endif
};
} //end namespace PRImA
#endif
| 31.546448 | 133 | 0.69877 |
4d6e51162ab6375cb3034413d88f41df5ca52b15 | 342 | h | C | Websocket/ftp/ftp_command.h | JacobBorden/Websocket | b21fc17f1363b898a0c1ff94c093bd083d0b6a8c | [
"MIT"
] | null | null | null | Websocket/ftp/ftp_command.h | JacobBorden/Websocket | b21fc17f1363b898a0c1ff94c093bd083d0b6a8c | [
"MIT"
] | 27 | 2021-04-05T03:39:51.000Z | 2021-04-11T19:52:20.000Z | Websocket/ftp/ftp_command.h | JacobBorden/Websocket | b21fc17f1363b898a0c1ff94c093bd083d0b6a8c | [
"MIT"
] | null | null | null | #pragma once
#ifndef FTP_COMMAND_H
#define FTP_COMMAND_H
#include <iostream>
#include "../socket/socket.h"
#include "ftp_command.h"
namespace ftp {
class Cmd
{
public:
std::string code = "\0";
std::string args = "\0";
int Send(Socket websocket);
static int ReceiveResponse(Socket websocket);
};
}
#endif // !FTP_COMMAND_H
| 14.25 | 47 | 0.687135 |
4d6e863219bdf83bcd64042a1e11be2b3715e7ec | 369 | h | C | include/nsessentials/util/GLDebug.h | NSchertler/NSEssentials | e5bceb01708368756528fdc95054bd3d05b7b745 | [
"BSD-3-Clause"
] | 2 | 2020-11-20T13:21:36.000Z | 2022-03-25T17:41:58.000Z | include/nsessentials/util/GLDebug.h | NSchertler/NSEssentials | e5bceb01708368756528fdc95054bd3d05b7b745 | [
"BSD-3-Clause"
] | null | null | null | include/nsessentials/util/GLDebug.h | NSchertler/NSEssentials | e5bceb01708368756528fdc95054bd3d05b7b745 | [
"BSD-3-Clause"
] | 2 | 2019-02-21T03:10:25.000Z | 2022-03-25T17:42:04.000Z | #pragma once
#ifdef HAVE_NANOGUI
#include <nanogui/opengl.h>
#include <unordered_set>
#include "nsessentials/NSELibrary.h"
namespace nse
{
namespace util
{
class NSE_EXPORT GLDebug
{
public:
static void IgnoreGLError(GLuint errorId);
static void SetupDebugCallback();
private:
static std::unordered_set<GLuint> ignoredIds;
};
}
}
#endif | 14.192308 | 48 | 0.718157 |
4d716afb1644fdcbf4f9847c4242bc0dd2c02817 | 5,108 | c | C | app/src/main/cpp/tcpick/lookup_tree.c | alessandrodd/AndroidintheMiddle | dfc12ae5108d7ad03de5b896d7808a6c55916f14 | [
"MIT"
] | null | null | null | app/src/main/cpp/tcpick/lookup_tree.c | alessandrodd/AndroidintheMiddle | dfc12ae5108d7ad03de5b896d7808a6c55916f14 | [
"MIT"
] | 1 | 2021-07-01T03:15:27.000Z | 2021-07-01T03:15:27.000Z | app/src/main/cpp/tcpick/src/lookup_tree.c | alessandrodd/AndroidintheMiddle | dfc12ae5108d7ad03de5b896d7808a6c55916f14 | [
"MIT"
] | null | null | null | /*
* lookup_tree.c -- the tree of host lookup engine
* Part of the tcpick project
*
* Author: Francesco Stablum <duskdruid @ despammed.com>
*
* Copyright (C) 2003, 2004 Francesco Stablum
* Licensed under the GPL
*
*/
/*
* 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 you option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111,
* USA.
*/
/* lookup_tree.c
* this file contains the functions called by lookup.c
* all name/ip couples are cached in a balanced tree (in a similar way
* to the avl tree)
*/
#include "tcpick.h"
#include "extern.h"
#define PARENT_POSITION_IS_LEFT(p) (p->parent->right == p)
struct _l_node * _l_root; /* the first node */
/* prototypes */
struct _l_node *
_l_alloc(struct in_addr, char *);
char *
_l_get(struct in_addr);
int
_l_insert(struct _l_node *);
int
_l_walkup(struct _l_node *);
int
_l_checkweight(struct _l_node *);
int
_l_balance_right(struct _l_node *);
int
_l_balance_left(struct _l_node *);
int
_l_adjust_h(struct _l_node *);
struct _l_node *
_l_alloc(struct in_addr ip, char * name)
{
register struct _l_node * new;
new = (struct _l_node *) S_malloc(sizeof(struct _l_node));
memset(new, 0, sizeof(struct _l_node));
new->name = (char *)strdup(name);
/* FIXME: not sure strdup is a good thing*/
memcpy(&(new->ip), &ip, sizeof(struct in_addr));
return new;
}
char *
_l_get(struct in_addr ia)
{
register struct _l_node * p;
p = _l_root;
while(p) {
if ( p->ip.s_addr == ia.s_addr )
return p->name; /* found */
p = ( ia.s_addr > p->ip.s_addr )
? p->right : p->left;
}
return NULL; /* not found */
}
int
_l_insert(struct _l_node * new)
{
/* FIXME: could be better */
register struct _l_node ** p;
register struct _l_node * pre = NULL;
p = & _l_root;
while(*p) {
pre = *p;
p = ( new->ip.s_addr > (*p)->ip.s_addr ) ?
&((*p)->right) : &((*p)->left);
}
*p = new;
new->parent = pre;
_l_walkup(new);
return 1;
}
int
_l_walkup(struct _l_node * node)
/* FIXME: could be improved maybe */
{
register struct _l_node * par;
par = node->parent;
while( par != NULL ) {
if( par->right == node )
par->right_h = MAX(par->right->right_h,
par->right->left_h) + 1;
else
par->left_h = MAX(par->left->right_h,
par->left->left_h) + 1;
if( _l_checkweight(par) != 0 )
/* something was done */
return 1;
node = par;
par = par->parent;
}
return 0;
}
int
_l_checkweight(struct _l_node * node)
{
if( (node->right_h - node->left_h) > 1) {
/* need balance because of right too weight */
_l_balance_right(node->right);
return 1;
}
if( (node->left_h - node->right_h) > 1) {
/* need balance because of left too weight */
_l_balance_left(node->left);
return 2;
}
return 0;
}
int
_l_balance_right(struct _l_node * D)
{
/* before:
B
/ \
A D
/ \
C E
after:
D
/ \
B E
/ \
A C
*/
register struct _l_node *
B = D->parent;
/* 1. step: put up the node */
if( B->parent != NULL ) {
if( PARENT_POSITION_IS_LEFT(B) )
B->parent->right = D;
else
B->parent->left = D;
D->parent = B->parent;
} else { /* this is the root */
_l_root = D;
_l_root->parent = NULL;
}
/* 2. step: the left side C of the node D becames the
* right of the node B */
B->right = D->left;
if( B->right )
B->right->parent = B;
/* 3. step: left side of D is B */
D->left = B;
B->parent = D;
/* 4. step: adjust height values */
_l_adjust_h(B);
_l_adjust_h(D);
return 1;
}
int
_l_balance_left(struct _l_node * D)
{
/* before:
B
/ \
D A
/ \
E C
after:
D
/ \
E B
/ \
C A
*/
register struct _l_node *
B = D->parent;
/* 1. step: put up the node */
if( B->parent != NULL ) {
if( PARENT_POSITION_IS_LEFT(B) )
B->parent->right = D;
else
B->parent->left = D;
}
D->parent = B->parent;
/* 2. step: the right side C of the node D becames the
* left of the node B */
B->left = D->right;
if( B->left )
B->left->parent = B;
/* 3. step: right side of D is B */
D->right = B;
B->parent = D;
/* 4. step: adjust height values */
_l_adjust_h(B);
_l_adjust_h(D);
return 1;
}
int
_l_adjust_h(struct _l_node * node)
{
node->right_h = ( node->right != NULL )
? MAX(node->right->left_h,
node->right->right_h) + 1
: 0;
node->left_h = ( node->left != NULL )
? MAX(node->left->left_h,
node->left->right_h) + 1
: 0;
return 1;
}
| 17.198653 | 70 | 0.606891 |
4d733ed39501b921007549696d3c1506463b4932 | 627 | h | C | src/rx/core/traits/remove_extent.h | DethRaid/rex | 21ba92d38398240faa45a402583c11f8c72e6e41 | [
"MIT"
] | 2 | 2020-06-13T11:39:46.000Z | 2021-03-10T01:03:03.000Z | src/rx/core/traits/remove_extent.h | DethRaid/rex | 21ba92d38398240faa45a402583c11f8c72e6e41 | [
"MIT"
] | null | null | null | src/rx/core/traits/remove_extent.h | DethRaid/rex | 21ba92d38398240faa45a402583c11f8c72e6e41 | [
"MIT"
] | 1 | 2021-01-06T03:47:08.000Z | 2021-01-06T03:47:08.000Z | #ifndef RX_CORE_TRAITS_REMOVE_EXTENT_H
#define RX_CORE_TRAITS_REMOVE_EXTENT_H
#include "rx/core/types.h" // Size
#include "rx/core/traits/type_identity.h"
namespace rx::traits {
namespace detail {
template<typename T>
struct remove_extent : traits::type_identity<T> {};
template<typename T>
struct remove_extent<T[]> : traits::type_identity<T> {};
template<typename T, Size E>
struct remove_extent<T[E]> : traits::type_identity<T> {};
} // namespace detail
template<typename T>
using remove_extent = typename detail::remove_extent<T>::type;
} // namespace rx::traits
#endif // RX_CORE_TRAITS_REMOVE_EXTENT_H
| 25.08 | 62 | 0.749601 |
4d75e514301ddcd1ea2429137df32c4750b7fd28 | 53,254 | c | C | NAMD_2.12_Source/charm-6.7.1/src/conv-core/memory-charmdebug.c | scottkwarren/config-db | fb5c3da2465e5cff0ad30950493b11d452bd686b | [
"MIT"
] | 1 | 2019-01-17T20:07:23.000Z | 2019-01-17T20:07:23.000Z | NAMD_2.12_Source/charm-6.7.1/src/conv-core/memory-charmdebug.c | scottkwarren/config-db | fb5c3da2465e5cff0ad30950493b11d452bd686b | [
"MIT"
] | null | null | null | NAMD_2.12_Source/charm-6.7.1/src/conv-core/memory-charmdebug.c | scottkwarren/config-db | fb5c3da2465e5cff0ad30950493b11d452bd686b | [
"MIT"
] | null | null | null | /*
* Filippo's charm debug memory module, gioachin@uiuc.edu, 2005/10
* based on Orion's memory-leak.c
*
* This special version of malloc() and company is meant to be used in
* conjunction with the parallel debugger CharmDebug.
*
* Functionalities provided:
* - detect multiple delete on a pointer
* - stacktrace for all memory allocated
* - division of allocated memory among different types of allocations
* - sweep of the memory searching for leaks
*/
#if ! CMK_MEMORY_BUILD_OS
/* Use Gnumalloc as meta-meta malloc fallbacks (mm_*) */
#include "memory-gnu.c"
#endif
#include "tracec.h"
#include <sys/mman.h>
/* Utilities needed by the code */
#include "ckhashtable.h"
/*#include "pup_c.h" */
#include "crc32.h"
#if ! CMK_CHARMDEBUG
#error "charmdebug is not enabled (e.g. when building with-production)"
static void *meta_malloc(size_t size);
static void *meta_calloc(size_t nelem, size_t size);
static void *meta_realloc(void *oldBuffer, size_t newSize);
static void *meta_memalign(size_t align, size_t size);
static void *meta_valloc(size_t size);
#else
typedef struct _Slot Slot;
typedef struct _SlotStack SlotStack;
int nextChareID;
extern int memory_chare_id;
int memory_charmdebug_internal = 0;
/**
* Struct Slot contains all of the information about a malloc buffer except
* for the contents of its memory.
*/
struct _Slot {
#ifdef CMK_SEPARATE_SLOT
char *userData;
#else
/*Doubly-linked allocated block list*/
Slot *next;
Slot *prev;
#endif
/*The number of bytes of user data*/
int userSize;
#define FLAGS_MASK 0xFF
#define BLOCK_PROTECTED 0x80
#define MODIFIED 0x40
#define NEW_BLOCK 0x20
#define LEAK_CLEAN 0x10
#define LEAK_FLAG 0x8
#define UNKNOWN_TYPE 0x0
#define SYSTEM_TYPE 0x1
#define USER_TYPE 0x2
#define CHARE_TYPE 0x3
#define MESSAGE_TYPE 0x4
/* A magic number field, to verify this is an actual malloc'd buffer, and what
type of allocation it is. The last 4 bits of the magic number are used to
define a classification of mallocs. */
#define SLOTMAGIC 0x8402a500
#define SLOTMAGIC_VALLOC 0x7402a500
#define SLOTMAGIC_FREED 0xDEADBEEF
int magic;
int chareID;
/* Controls the number of stack frames to print out. */
int stackLen;
void **from;
/* Pointer to extra stacktrace, when the user requested more trace */
SlotStack *extraStack;
/* CRC32 checksums */
CmiUInt8 slotCRC;
CmiUInt8 userCRC;
};
struct _SlotStack {
char *protectedMemory;
int protectedMemoryLength;
/* empty for the moment, to be filled when needed */
};
/********* List of allocated memory *********/
/* First memory slot */
#ifdef CMK_SEPARATE_SLOT
CkHashtable_c block_slots = NULL;
#else
Slot slot_first_storage = {&slot_first_storage, &slot_first_storage};
Slot *slot_first = &slot_first_storage;
#endif
int memory_allocated_user_total;
int get_memory_allocated_user_total() {return memory_allocated_user_total;}
void *lastMemoryAllocated = NULL;
Slot **allocatedSince = NULL;
int allocatedSinceSize = 0;
int allocatedSinceMaxSize = 0;
int saveAllocationHistory = 0;
/* Convert a slot to a user address */
static char *SlotToUser(Slot *s) {
#ifdef CMK_SEPARATE_SLOT
return s->userData;
#else
return ((char *)s)+sizeof(Slot);
#endif
}
/* Convert a user address to a slot. The parameter "user" must be at the
* beginning of the allocated block */
static Slot *UserToSlot(void *user) {
#ifdef CMK_SEPARATE_SLOT
return (Slot *)CkHashtableGet(block_slots, &user);
#else
char *cu=(char *)user;
Slot *s=(Slot *)(cu-sizeof(Slot));
return s;
#endif
}
static int isLeakSlot(Slot *s) {
return s->magic & LEAK_FLAG;
}
static int isProtected(Slot *s) {
return s->magic & BLOCK_PROTECTED;
}
int Slot_ChareOwner(void *s) {
return ((Slot*)s)->chareID;
}
int Slot_AllocatedSize(void *s) {
return ((Slot*)s)->userSize;
}
int Slot_StackTrace(void *s, void ***stack) {
*stack = ((Slot*)s)->from;
return ((Slot*)s)->stackLen;
}
static void printSlot(Slot *s) {
CmiPrintf("[%d] Leaked block of %d bytes at %p:\n",
CmiMyPe(), s->userSize, SlotToUser(s));
CmiBacktracePrint(s->from,s->stackLen);
}
/********* Cpd routines for pupping data to the debugger *********/
/** Returns the number of total blocks of memory allocated */
size_t cpd_memory_length(void *lenParam) {
size_t n=0;
#ifdef CMK_SEPARATE_SLOT
n = CkHashtableSize(block_slots) - 1;
#else
Slot *cur = slot_first->next;
while (cur != slot_first) {
n++;
cur = cur->next;
}
#endif
return n;
}
/** PUP a single slot of memory for the debugger. This includes the information
* about the slot (like size and location), but not the allocated data itself. */
#ifdef CMK_SEPARATE_SLOT
void cpd_memory_single_pup(CkHashtable_c h, pup_er p) {
CkHashtableIterator_c hashiter;
void *key;
Slot *cur;
//int counter=0;
memory_charmdebug_internal = 1;
hashiter = CkHashtableGetIterator(h);
while ((cur = (Slot *)CkHashtableIteratorNext(hashiter, &key)) != NULL) {
if (pup_isPacking(p) && cur->userData == lastMemoryAllocated) continue;
//counter++;
#else
void cpd_memory_single_pup(Slot* list, pup_er p) {
Slot *cur = list->next;
/* Stupid hack to avoid sending the memory we just allocated for this packing,
otherwise the lengths will mismatch */
if (pup_isPacking(p)) cur = cur->next;
for ( ; cur != list; cur = cur->next) {
#endif
{
int i;
int flags;
void *loc = SlotToUser(cur);
CpdListBeginItem(p, 0);
pup_comment(p, "loc");
pup_pointer(p, &loc);
pup_comment(p, "size");
pup_int(p, &cur->userSize);
pup_comment(p, "flags");
flags = cur->magic & FLAGS_MASK;
pup_int(p, &flags);
pup_comment(p, "chare");
pup_int(p, &cur->chareID);
pup_comment(p, "stack");
//for (i=0; i<STACK_LEN; ++i) {
// if (cur->from[i] <= 0) break;
// if (cur->from[i] > 0) pup_uint(p, (unsigned int*)&cur->from[i]);
// else break;
//}
if (cur->from != NULL)
pup_pointers(p, cur->from, cur->stackLen);
else {
void *myNULL = NULL;
printf("Block %p has no stack!\n",cur);
pup_pointer(p, &myNULL);
}
}
}
/*CmiPrintf("counter=%d\n",counter);*/
memory_charmdebug_internal = 0;
}
/** PUP the entire information about the allocated memory to the debugger */
void cpd_memory_pup(void *itemParam, pup_er p, CpdListItemsRequest *req) {
CpdListBeginItem(p, 0);
pup_comment(p, "name");
pup_chars(p, "memory", strlen("memory"));
pup_comment(p, "slots");
pup_syncComment(p, pup_sync_begin_array, 0);
#ifdef CMK_SEPARATE_SLOT
cpd_memory_single_pup(block_slots, p);
#else
cpd_memory_single_pup(slot_first, p);
#endif
pup_syncComment(p, pup_sync_end_array, 0);
}
/*
void check_memory_leaks(CpdListItemsRequest *);
void cpd_memory_leak(void *iterParam, pup_er p, CpdListItemsRequest *req) {
if (pup_isSizing(p)) {
// let's perform the memory leak checking. This is the first step in the
// packing, where we size, in the second step we pack and we avoid doing
// this check again.
check_memory_leaks(req);
}
cpd_memory_pup(iterParam, p, req);
}
*/
size_t cpd_memory_getLength(void *lenParam) { return 1; }
/** Returns the content of a block of memory (i.e the user data).
This request must always be at the beginning of an allocated block
(not for example an object part of an array) */
void cpd_memory_get(void *iterParam, pup_er p, CpdListItemsRequest *req) {
void *userData = (void*)(((unsigned int)req->lo) + (((unsigned long)req->hi)<<32));
Slot *sl = UserToSlot(userData);
CpdListBeginItem(p, 0);
pup_comment(p, "size");
//printf("value: %x %x %x %d\n",sl->magic, sl->magic&~FLAGS_MASK, SLOTMAGIC, ((sl->magic&~FLAGS_MASK) != SLOTMAGIC));
if ((sl->magic&~FLAGS_MASK) != SLOTMAGIC) {
int zero = 0;
pup_int(p, &zero);
} else {
pup_int(p, &sl->userSize);
pup_comment(p, "value");
pup_bytes(p, userData, sl->userSize);
}
}
/********* Heap Checking ***********/
int charmEnvelopeSize = 0;
#include "pcqueue.h"
#ifdef CMK_SEPARATE_SLOT
#define SLOTSPACE 0
#define SLOT_ITERATE_START(scanner) \
{ \
CkHashtableIterator_c hashiter = CkHashtableGetIterator(block_slots); \
void *key; \
while ((scanner = (Slot *)CkHashtableIteratorNext(hashiter, &key)) != NULL) {
#define SLOT_ITERATE_END \
} \
CkHashtableDestroyIterator(hashiter); \
}
#else
#define SLOTSPACE sizeof(Slot)
#define SLOT_ITERATE_START(scanner) \
for (scanner=slot_first->next; scanner!=slot_first; scanner=scanner->next) {
#define SLOT_ITERATE_END }
#endif
/** Perform a scan of all the memory to find all the memory that is reacheable
* from either the stack or the global variables. */
// FIXME: this function assumes that all memory is allocated in slot_unknown!
void check_memory_leaks(LeakSearchInfo *info) {
//FILE* fd=fopen("check_memory_leaks", "w");
// Step 1)
// index all memory into a CkHashtable, with a scan of 4 bytes.
CkHashtable_c table;
PCQueue inProgress;
Slot *sl, **fnd, *found;
char *scanner;
char *begin_stack, *end_stack;
//char *begin_data, *end_data;
//char *begin_bss, *end_bss;
int growing_dimension = 0;
// copy all the memory from "slot_first" to "leaking"
Slot *slold1=0, *slold2=0, *slold3=0;
memory_charmdebug_internal = 1;
inProgress = PCQueueCreate();
table = CkCreateHashtable_pointer(sizeof(char *), 10000);
SLOT_ITERATE_START(sl)
// index the i-th memory slot
//printf("hashing slot %p\n",sl);
char *ptr;
sl->magic |= LEAK_FLAG;
if (info->quick > 0) {
char **object;
//CmiPrintf("checking memory fast\n");
// means index only specific offsets of the memory region
ptr = SlotToUser(sl);
object = (char**)CkHashtablePut(table, &ptr);
*object = (char*)sl;
ptr += 4;
object = (char**)CkHashtablePut(table, &ptr);
*object = (char*)sl;
// beginning of converse header
ptr += sizeof(CmiChunkHeader) - 4;
if (ptr < SlotToUser(sl)+sizeof(Slot)+sl->userSize) {
object = (char**)CkHashtablePut(table, &ptr);
*object = (char*)sl;
}
// beginning of charm header
ptr += CmiReservedHeaderSize;
if (ptr < SlotToUser(sl)+sizeof(Slot)+sl->userSize) {
object = (char**)CkHashtablePut(table, &ptr);
*object = (char*)sl;
}
// beginning of ampi header
ptr += charmEnvelopeSize - CmiReservedHeaderSize;
if (ptr < SlotToUser(sl)+sizeof(Slot)+sl->userSize) {
object = (char**)CkHashtablePut(table, &ptr);
*object = (char*)sl;
}
} else {
//CmiPrintf("checking memory extensively\n");
// means index every fourth byte of the memory region
for (ptr = SlotToUser(sl); ptr <= SlotToUser(sl)+sl->userSize; ptr+=sizeof(char*)) {
//printf("memory %p\n",ptr);
//growing_dimension++;
//if ((growing_dimension&0xFF) == 0) printf("inserted %d objects\n",growing_dimension);
char **object = (char**)CkHashtablePut(table, &ptr);
*object = (char*)sl;
}
}
slold3 = slold2;
slold2 = slold1;
slold1 = sl;
SLOT_ITERATE_END
// Step 2)
// start the check with the stack and the global data. The stack is found
// through the current pointer, going up until 16 bits filling (considering
// the stack grows toward decreasing addresses). The pointers to the global
// data (segments .data and .bss) are passed in with "req" as the "extra"
// field, with the structure "begin .data", "end .data", "begin .bss", "end .bss".
begin_stack = (char*)&table;
end_stack = (char*)memory_stack_top;
/*if (req->extraLen != 4*4 / *sizeof(char*) FIXME: assumes 64 bit addresses of .data and .bss are small enough * /) {
CmiPrintf("requested for a memory leak check with wrong information! %d bytes\n",req->extraLen);
}*/
/*if (sizeof(char*) == 4) {
/ * 32 bit addresses; for 64 bit machines it assumes the following addresses were small enough * /
begin_data = (char*)ntohl(((int*)(req->extra))[0]);
end_data = (char*)ntohl(((int*)(req->extra))[1]) - sizeof(char*) + 1;
begin_bss = (char*)ntohl(((int*)(req->extra))[2]);
end_bss = (char*)ntohl(((int*)(req->extra))[3]) - sizeof(char*) + 1;
/ *} else {
CmiAbort("not ready yet");
begin_data = ntohl(((char**)(req->extra))[0]);
end_data = ntohl(((char**)(req->extra))[1]) - sizeof(char*) + 1;
begin_bss = ntohl(((char**)(req->extra))[2]);
end_bss = ntohl(((char**)(req->extra))[3]) - sizeof(char*) + 1;
}*/
printf("scanning stack from %p to %p\n", begin_stack, end_stack);
for (scanner = begin_stack; scanner < end_stack; scanner+=sizeof(char*)) {
fnd = (Slot**)CkHashtableGet(table, scanner);
//if (fnd != NULL) printf("scanning stack %p, %d\n",*fnd,isLeakSlot(*fnd));
if (fnd != NULL && isLeakSlot(*fnd)) {
found = *fnd;
/* mark slot as not leak */
//printf("stack pointing to %p\n",found+1);
found->magic &= ~LEAK_FLAG;
/* move the slot into inProgress */
PCQueuePush(inProgress, (char*)found);
}
}
printf("scanning data from %p to %p\n", info->begin_data, info->end_data);
for (scanner = info->begin_data; scanner < info->end_data; scanner+=sizeof(char*)) {
//fprintf(fd, "scanner = %p\n",scanner);
//fflush(fd);
fnd = (Slot**)CkHashtableGet(table, scanner);
//if (fnd != NULL) printf("scanning data %p, %d\n",*fnd,isLeakSlot(*fnd));
if (fnd != NULL && isLeakSlot(*fnd)) {
found = *fnd;
/* mark slot as not leak */
//printf("data pointing to %p\n",found+1);
found->magic &= ~LEAK_FLAG;
/* move the slot into inProgress */
PCQueuePush(inProgress, (char*)found);
}
}
printf("scanning bss from %p to %p\n", info->begin_bss, info->end_bss);
for (scanner = info->begin_bss; scanner < info->end_bss; scanner+=sizeof(char*)) {
//printf("bss: %p %p\n",scanner,*(char**)scanner);
fnd = (Slot**)CkHashtableGet(table, scanner);
//if (fnd != NULL) printf("scanning bss %p, %d\n",*fnd,isLeakSlot(*fnd));
if (fnd != NULL && isLeakSlot(*fnd)) {
found = *fnd;
/* mark slot as not leak */
//printf("bss pointing to %p\n",found+1);
found->magic &= ~LEAK_FLAG;
/* move the slot into inProgress */
PCQueuePush(inProgress, (char*)found);
}
}
// Step 3)
// continue iteratively to check the memory by sweeping it with the
// "inProcess" list
while ((sl = (Slot *)PCQueuePop(inProgress)) != NULL) {
//printf("scanning memory %p of size %d\n",sl,sl->userSize);
/* scan through this memory and pick all the slots which are still leaking
and add them to the inProgress list */
if (sl->extraStack != NULL && sl->extraStack->protectedMemory != NULL) mprotect(sl->extraStack->protectedMemory, sl->extraStack->protectedMemoryLength, PROT_READ);
for (scanner = SlotToUser(sl); scanner < SlotToUser(sl)+sl->userSize-sizeof(char*)+1; scanner+=sizeof(char*)) {
fnd = (Slot**)CkHashtableGet(table, scanner);
//if (fnd != NULL) printf("scanning heap %p, %d\n",*fnd,isLeakSlot(*fnd));
if (fnd != NULL && isLeakSlot(*fnd)) {
found = *fnd;
/* mark slot as not leak */
//printf("heap pointing to %p\n",found+1);
found->magic &= ~LEAK_FLAG;
/* move the slot into inProgress */
PCQueuePush(inProgress, (char*)found);
}
}
if (sl->extraStack != NULL && sl->extraStack->protectedMemory != NULL) mprotect(sl->extraStack->protectedMemory, sl->extraStack->protectedMemoryLength, PROT_NONE);
}
// Step 4)
// move back all the entries in leaking to slot_first
/*if (leaking.next != &leaking) {
leaking.next->prev = slot_first;
leaking.prev->next = slot_first->next;
slot_first->next->prev = leaking.prev;
slot_first->next = leaking.next;
}*/
// mark all the entries in the leaking list as leak, and put them back
// into the main list
/*sl = leaking.next;
while (sl != &leaking) {
sl->magic | LEAK_FLAG;
}
if (leaking.next != &leaking) {
slot_first->next->prev = leaking.prev;
leaking.prev->next = slot_first->next;
leaking.next->prev = slot_first;
slot_first->next = leaking.next;
}
*/
PCQueueDestroy(inProgress);
CkDeleteHashtable(table);
memory_charmdebug_internal = 0;
}
void CpdMemoryMarkClean(char *msg) {
Slot *sl;
/* The first byte of the data packet indicates if we want o mark or unmark */
if ((msg+CmiMsgHeaderSizeBytes)[0]) {
SLOT_ITERATE_START(sl)
sl->magic |= LEAK_CLEAN;
SLOT_ITERATE_END
} else {
SLOT_ITERATE_START(sl)
sl->magic &= ~LEAK_CLEAN;
SLOT_ITERATE_END
}
CmiFree(msg);
}
/****************** memory allocation tree ******************/
/* This allows the representation and creation of a tree where each node
* represents a line in the code part of a stack trace of a malloc. The node
* contains how much data has been allocated starting from that line of code,
* down the stack.
*/
typedef struct _AllocationPoint AllocationPoint;
struct _AllocationPoint {
/* The stack pointer this allocation refers to */
void * key;
/* Pointer to the parent AllocationPoint of this AllocationPoint in the tree */
AllocationPoint * parent;
/* Pointer to the first child AllocationPoint in the tree */
AllocationPoint * firstChild;
/* Pointer to the sibling of this AllocationPoint (i.e the next child of the parent) */
AllocationPoint * sibling;
/* Pointer to the next AllocationPoint with the same key.
* There can be more than one AllocationPoint with the same key because the
* parent can be different. Used only in the hashtable. */
AllocationPoint * next;
/* Size of the memory allocate */
int size;
/* How many blocks have been allocated from this point */
int count;
/* Flags pertaining to the allocation point, currently only LEAK_FLAG */
char flags;
};
// pup a single AllocationPoint. The data structure must be already allocated
void pupAllocationPointSingle(pup_er p, AllocationPoint *node, int *numChildren) {
AllocationPoint *child;
pup_pointer(p, &node->key);
pup_int(p, &node->size);
pup_int(p, &node->count);
pup_char(p, &node->flags);
if (pup_isUnpacking(p)) {
node->parent = NULL;
node->firstChild = NULL;
node->sibling = NULL;
node->next = NULL;
}
*numChildren = 0;
for (child = node->firstChild; child != NULL; child = child->sibling) (*numChildren) ++;
pup_int(p, numChildren);
}
// TODO: the following pup does not work for unpacking!
void pupAllocationPoint(pup_er p, void *data) {
AllocationPoint *node = (AllocationPoint*)data;
int numChildren;
AllocationPoint *child;
pupAllocationPointSingle(p, node, &numChildren);
for (child = node->firstChild; child != NULL; child = child->sibling) {
pupAllocationPoint(p, child);
}
}
void deleteAllocationPoint(void *ptr) {
AllocationPoint *node = (AllocationPoint*)ptr;
AllocationPoint *child;
for (child = node->firstChild; child != NULL; child = child->sibling) deleteAllocationPoint(child);
BEFORE_MALLOC_CALL;
mm_free(node);
AFTER_MALLOC_CALL;
}
void printAllocationTree(AllocationPoint *node, FILE *fd, int depth) {
int i;
int numChildren = 0;
AllocationPoint *child;
if (node==NULL) return;
for (child = node->firstChild; child != NULL; child = child->sibling) numChildren ++;
for (i=0; i<depth; ++i) fprintf(fd, " ");
fprintf(fd, "node %p: bytes=%d, count=%d, child=%d\n",node->key,node->size,node->count,numChildren);
printAllocationTree(node->sibling, fd, depth);
printAllocationTree(node->firstChild, fd, depth+2);
}
AllocationPoint * CreateAllocationTree(int *nodesCount) {
Slot *scanner;
CkHashtable_c table;
int i, isnew;
AllocationPoint *parent, **start, *cur;
AllocationPoint *root = NULL;
int numNodes = 0;
char filename[100];
FILE *fd;
CkHashtableIterator_c it;
AllocationPoint **startscan, *scan;
table = CkCreateHashtable_pointer(sizeof(char *), 10000);
BEFORE_MALLOC_CALL;
root = (AllocationPoint*) mm_malloc(sizeof(AllocationPoint));
AFTER_MALLOC_CALL;
*(AllocationPoint**)CkHashtablePut(table, &numNodes) = root;
numNodes ++;
root->key = 0;
root->parent = NULL;
root->size = 0;
root->count = 0;
root->flags = 0;
root->firstChild = NULL;
root->sibling = NULL;
root->next = root;
SLOT_ITERATE_START(scanner)
parent = root;
for (i=scanner->stackLen-1; i>=0; --i) {
isnew = 0;
start = (AllocationPoint**)CkHashtableGet(table, &scanner->from[i]);
if (start == NULL) {
BEFORE_MALLOC_CALL;
cur = (AllocationPoint*) mm_malloc(sizeof(AllocationPoint));
AFTER_MALLOC_CALL;
numNodes ++;
isnew = 1;
cur->next = cur;
*(AllocationPoint**)CkHashtablePut(table, &scanner->from[i]) = cur;
} else {
for (cur = (*start)->next; cur != *start && cur->parent != parent; cur = cur->next);
if (cur->parent != parent) {
BEFORE_MALLOC_CALL;
cur = (AllocationPoint*) mm_malloc(sizeof(AllocationPoint));
AFTER_MALLOC_CALL;
numNodes ++;
isnew = 1;
cur->next = (*start)->next;
(*start)->next = cur;
}
}
// here "cur" points to the correct AllocationPoint for this stack frame
if (isnew) {
cur->key = scanner->from[i];
cur->parent = parent;
cur->size = 0;
cur->count = 0;
cur->flags = 0;
cur->firstChild = NULL;
//if (parent == NULL) {
// cur->sibling = NULL;
// CmiAssert(root == NULL);
// root = cur;
//} else {
cur->sibling = parent->firstChild;
parent->firstChild = cur;
//}
}
cur->size += scanner->userSize;
cur->count ++;
cur->flags |= isLeakSlot(scanner);
parent = cur;
}
SLOT_ITERATE_END
sprintf(filename, "allocationTree_%d", CmiMyPe());
fd = fopen(filename, "w");
fprintf(fd, "digraph %s {\n", filename);
it = CkHashtableGetIterator(table);
while ((startscan=(AllocationPoint**)CkHashtableIteratorNext(it,NULL))!=NULL) {
fprintf(fd, "\t\"n%p\" [label=\"%p\\nsize=%d\\ncount=%d\"];\n",*startscan,(*startscan)->key,
(*startscan)->size,(*startscan)->count);
for (scan = (*startscan)->next; scan != *startscan; scan = scan->next) {
fprintf(fd, "\t\"n%p\" [label=\"%p\\nsize=%d\\ncount=%d\"];\n",scan,scan->key,scan->size,scan->count);
}
}
CkHashtableIteratorSeekStart(it);
while ((startscan=(AllocationPoint**)CkHashtableIteratorNext(it,NULL))!=NULL) {
fprintf(fd, "\t\"n%p\" -> \"n%p\";\n",(*startscan)->parent,(*startscan));
for (scan = (*startscan)->next; scan != *startscan; scan = scan->next) {
fprintf(fd, "\t\"n%p\" -> \"n%p\";\n",scan->parent,scan);
}
}
fprintf(fd, "}\n");
fclose(fd);
sprintf(filename, "allocationTree_%d.tree", CmiMyPe());
fd = fopen(filename, "w");
printAllocationTree(root, fd, 0);
fclose(fd);
CkDeleteHashtable(table);
if (nodesCount != NULL) *nodesCount = numNodes;
return root;
}
void MergeAllocationTreeSingle(AllocationPoint *node, AllocationPoint *remote, int numChildren, pup_er p) {
AllocationPoint child;
int numChildChildren;
int i;
//pupAllocationPointSingle(p, &remote, &numChildren);
/* Update the node with the information coming from remote */
node->size += remote->size;
node->count += remote->count;
node->flags |= remote->flags;
/* Recursively merge the children */
for (i=0; i<numChildren; ++i) {
AllocationPoint *localChild;
pupAllocationPointSingle(p, &child, &numChildChildren);
/* Find the child in the local tree */
for (localChild = node->firstChild; localChild != NULL; localChild = localChild->sibling) {
if (localChild->key == child.key) {
break;
}
}
if (localChild == NULL) {
/* This child did not exist locally, allocate it */
BEFORE_MALLOC_CALL;
localChild = (AllocationPoint*) mm_malloc(sizeof(AllocationPoint));
AFTER_MALLOC_CALL;
localChild->key = child.key;
localChild->flags = 0;
localChild->count = 0;
localChild->size = 0;
localChild->firstChild = NULL;
localChild->next = NULL;
localChild->parent = node;
localChild->sibling = node->firstChild;
node->firstChild = localChild;
}
MergeAllocationTreeSingle(localChild, &child, numChildChildren, p);
}
}
void * MergeAllocationTree(int *size, void *data, void **remoteData, int numRemote) {
int i;
for (i=0; i<numRemote; ++i) {
pup_er p = pup_new_fromMem(remoteData[i]);
AllocationPoint root;
int numChildren;
pupAllocationPointSingle(p, &root, &numChildren);
MergeAllocationTreeSingle((AllocationPoint*)data, &root, numChildren, p);
pup_destroy(p);
}
return data;
}
/********************** Memory statistics ***********************/
/* Collect the statistics relative to the amount of memory allocated.
* Starts from the statistics of a single processor and combines them to contain
* all the processors in the application.
*/
typedef struct MemStatSingle {
// [0] is total, [1] is the leaking part
int pe;
int sizes[2][5];
int counts[2][5];
} MemStatSingle;
typedef struct MemStat {
int count;
MemStatSingle array[1];
} MemStat;
void pupMemStat(pup_er p, void *st) {
int i;
MemStat *comb = (MemStat*)st;
pup_fmt_sync_begin_object(p);
pup_comment(p, "count");
pup_int(p, &comb->count);
pup_comment(p, "list");
pup_fmt_sync_begin_array(p);
for (i=0; i<comb->count; ++i) {
MemStatSingle *stat = &comb->array[i];
pup_fmt_sync_item(p);
pup_comment(p, "pe");
pup_int(p, &stat->pe);
pup_comment(p, "totalsize");
pup_ints(p, stat->sizes[0], 5);
pup_comment(p, "totalcount");
pup_ints(p, stat->counts[0], 5);
pup_comment(p, "leaksize");
pup_ints(p, stat->sizes[1], 5);
pup_comment(p, "leakcount");
pup_ints(p, stat->counts[1], 5);
}
pup_fmt_sync_end_array(p);
pup_fmt_sync_end_object(p);
}
void deleteMemStat(void *ptr) {
BEFORE_MALLOC_CALL;
mm_free(ptr);
AFTER_MALLOC_CALL;
}
static int memStatReturnOnlyOne = 1;
void * mergeMemStat(int *size, void *data, void **remoteData, int numRemote) {
int i,j,k;
if (memStatReturnOnlyOne) {
MemStatSingle *l = &((MemStat*) data)->array[0];
MemStat r;
MemStatSingle *m = &r.array[0];
l->pe = -1;
for (i=0; i<numRemote; ++i) {
pup_er p = pup_new_fromMem(remoteData[i]);
pupMemStat(p, &r);
for (j=0; j<2; ++j) {
for (k=0; k<5; ++k) {
l->sizes[j][k] += m->sizes[j][k];
l->counts[j][k] += m->counts[j][k];
}
}
pup_destroy(p);
}
return data;
} else {
MemStat *l = (MemStat*)data, *res;
MemStat r;
int count = l->count;
for (i=0; i<numRemote; ++i) count += ((MemStat*)remoteData[i])->count;
BEFORE_MALLOC_CALL;
res = (MemStat*)mm_malloc(sizeof(MemStat) + (count-1)*sizeof(MemStatSingle));
AFTER_MALLOC_CALL;
memset(res, 0, sizeof(MemStat)+(count-1)*sizeof(MemStatSingle));
res->count = count;
memcpy(res->array, l->array, l->count*sizeof(MemStatSingle));
count = l->count;
for (i=0; i<numRemote; ++i) {
pup_er p = pup_new_fromMem(remoteData[i]);
pupMemStat(p, &r);
memcpy(&res->array[count], r.array, r.count*sizeof(MemStatSingle));
count += r.count;
pup_destroy(p);
}
deleteMemStat(data);
return res;
}
}
MemStat * CreateMemStat() {
Slot *cur;
MemStat *st;
MemStatSingle *stat;
BEFORE_MALLOC_CALL;
st = (MemStat*)mm_calloc(1, sizeof(MemStat));
AFTER_MALLOC_CALL;
st->count = 1;
stat = &st->array[0];
SLOT_ITERATE_START(cur)
stat->sizes[0][(cur->magic&0x7)] += cur->userSize;
stat->counts[0][(cur->magic&0x7)] ++;
if (cur->magic & 0x8) {
stat->sizes[1][(cur->magic&0x7)] += cur->userSize;
stat->counts[1][(cur->magic&0x7)] ++;
}
SLOT_ITERATE_END
stat->pe=CmiMyPe();
return st;
}
/*********************** Cross-chare corruption detection *******************/
static int reportMEM = 0;
/* This first method uses two fields (userCRC and slotCRC) of the Slot structure
* to store the CRC32 checksum of the user data and the slot itself. It compares
* the stored values against a new value recomputed after the entry method
* returned to detect cross-chare corruption.
*/
static int CpdCRC32 = 0;
#define SLOT_CRC_LENGTH (sizeof(Slot) - 2*sizeof(CmiUInt8))
static int checkSlotCRC(void *userPtr) {
Slot *sl = UserToSlot(userPtr);
if (sl!=NULL) {
unsigned int crc = crc32_initial((unsigned char*)sl, SLOT_CRC_LENGTH);
crc = crc32_update((unsigned char*)sl->from, sl->stackLen*sizeof(void*), crc);
return sl->slotCRC == crc;
} else return 0;
}
static int checkUserCRC(void *userPtr) {
Slot *sl = UserToSlot(userPtr);
if (sl!=NULL) return sl->userCRC == crc32_initial((unsigned char*)userPtr, sl->userSize);
else return 0;
}
static void resetUserCRC(void *userPtr) {
Slot *sl = UserToSlot(userPtr);
if (sl!=NULL) sl->userCRC = crc32_initial((unsigned char*)userPtr, sl->userSize);
}
static void resetSlotCRC(void *userPtr) {
Slot *sl = UserToSlot(userPtr);
if (sl!=NULL) {
unsigned int crc = crc32_initial((unsigned char*)sl, SLOT_CRC_LENGTH);
crc = crc32_update((unsigned char*)sl->from, sl->stackLen*sizeof(void*), crc);
sl->slotCRC = crc;
}
}
static void ResetAllCRC() {
Slot *cur;
unsigned int crc1, crc2;
SLOT_ITERATE_START(cur)
crc1 = crc32_initial((unsigned char*)cur, SLOT_CRC_LENGTH);
crc1 = crc32_update((unsigned char*)cur->from, cur->stackLen*sizeof(void*), crc1);
crc2 = crc32_initial((unsigned char*)SlotToUser(cur), cur->userSize);
cur->slotCRC = crc1;
cur->userCRC = crc2;
SLOT_ITERATE_END
}
static void CheckAllCRC() {
Slot *cur;
unsigned int crc1, crc2;
SLOT_ITERATE_START(cur)
crc1 = crc32_initial((unsigned char*)cur, SLOT_CRC_LENGTH);
crc1 = crc32_update((unsigned char*)cur->from, cur->stackLen*sizeof(void*), crc1);
crc2 = crc32_initial((unsigned char*)SlotToUser(cur), cur->userSize);
/* Here we can check if a modification has occured */
if (reportMEM && cur->slotCRC != crc1) CmiPrintf("CRC: Object %d modified slot for %p\n",memory_chare_id,SlotToUser(cur));
cur->slotCRC = crc1;
if (reportMEM && cur->userCRC != crc2 && memory_chare_id != cur->chareID)
CmiPrintf("CRC: Object %d modified memory of object %d for %p\n",memory_chare_id,cur->chareID,SlotToUser(cur));
cur->userCRC = crc2;
SLOT_ITERATE_END
}
/* This second method requires all the memory in the processor to be copied
* into a safe region, and then compare it with the working copy after the
* entry method returned.
*/
static int CpdMemBackup = 0;
static void backupMemory() {
Slot *cur;
char * ptr;
int totalMemory = SLOTSPACE;
if (*memoryBackup != NULL)
CmiAbort("memoryBackup != NULL\n");
{
SLOT_ITERATE_START(cur)
totalMemory += sizeof(Slot) + cur->userSize + cur->stackLen*sizeof(void*);
SLOT_ITERATE_END
}
if (reportMEM) CmiPrintf("CPD: total memory in use (%d): %d\n",CmiMyPe(),totalMemory);
BEFORE_MALLOC_CALL;
*memoryBackup = mm_malloc(totalMemory);
AFTER_MALLOC_CALL;
ptr = *memoryBackup;
#ifndef CMK_SEPARATE_SLOT
memcpy(*memoryBackup, slot_first, sizeof(Slot));
ptr += sizeof(Slot);
#endif
SLOT_ITERATE_START(cur)
int tocopy = SLOTSPACE + cur->userSize + cur->stackLen*sizeof(void*);
char *data = (char *)cur;
#ifdef CMK_SEPARATE_SLOT
memcpy(ptr, cur, sizeof(Slot));
ptr += sizeof(Slot);
data = SlotToUser(cur);
#endif
memcpy(ptr, data, tocopy);
cur->magic &= ~ (NEW_BLOCK | MODIFIED);
ptr += tocopy;
SLOT_ITERATE_END
allocatedSinceSize = 0;
}
static void checkBackup() {
#ifndef CMK_SEPARATE_SLOT
Slot *cur = slot_first->next;
char *ptr = *memoryBackup + sizeof(Slot);
// skip over the new allocated blocks
//while (cur != ((Slot*)*memoryBackup)->next) cur = cur->next;
int idx = allocatedSinceSize-1;
while (idx >= 0) {
while (idx >= 0 && allocatedSince[idx] != cur) idx--;
if (idx >= 0) {
cur = cur->next;
idx --;
}
}
while (cur != slot_first) {
char *last;
// ptr is the old copy of cur
if (memory_chare_id != cur->chareID) {
int res = memcmp(ptr+sizeof(Slot), ((char*)cur)+sizeof(Slot), cur->userSize + cur->stackLen*sizeof(void*));
if (res != 0) {
cur->magic |= MODIFIED;
if (reportMEM) CmiPrintf("CPD: Object %d modified memory of object %d for %p on pe %d\n",memory_chare_id,cur->chareID,cur+1,CmiMyPe());
}
}
// advance to next, skipping deleted memory blocks
cur = cur->next;
do {
last = ptr;
ptr += sizeof(Slot) + ((Slot*)ptr)->userSize + ((Slot*)ptr)->stackLen*sizeof(void*);
} while (((Slot*)last)->next != cur);
}
#endif
BEFORE_MALLOC_CALL;
mm_free(*memoryBackup);
AFTER_MALLOC_CALL;
*memoryBackup = NULL;
}
/* Third method to detect cross-chare corruption. Use mprotect to change the
* protection bits of each page, and a following segmentation fault to detect
* the corruption. It is more accurate as it can provide the stack trace of the
* first instruction that modified the memory.
*/
#include <signal.h>
static int meta_getpagesize(void);
static int CpdMprotect = 0;
static void** unProtectedPages = NULL;
static int unProtectedPagesSize = 0;
static int unProtectedPagesMaxSize = 0;
static void* lastAddressSegv;
static void CpdMMAPhandler(int sig, siginfo_t *si, void *unused){
void *pageToUnprotect;
if (lastAddressSegv == si->si_addr) {
CmiPrintf("Second SIGSEGV at address 0x%lx\n", (long) si->si_addr);
CpdFreeze();
}
lastAddressSegv = si->si_addr;
pageToUnprotect = (void*)((CmiUInt8)si->si_addr & ~(meta_getpagesize()-1));
mprotect(pageToUnprotect, 4, PROT_READ|PROT_WRITE);
if (unProtectedPagesSize >= unProtectedPagesMaxSize) {
void **newUnProtectedPages;
unProtectedPagesMaxSize += 10;
BEFORE_MALLOC_CALL;
newUnProtectedPages = (void**)mm_malloc((unProtectedPagesMaxSize)*sizeof(void*));
memcpy(newUnProtectedPages, unProtectedPages, unProtectedPagesSize*sizeof(void*));
mm_free(unProtectedPages);
AFTER_MALLOC_CALL;
unProtectedPages = newUnProtectedPages;
}
unProtectedPages[unProtectedPagesSize++] = pageToUnprotect;
if (reportMEM) CpdNotify(CPD_CROSSCORRUPTION, si->si_addr, memory_chare_id);
//CmiPrintf("Got SIGSEGV at address: 0x%lx\n", (long) si->si_addr);
//CmiPrintStackTrace(0);
}
static void protectMemory() {
#ifdef CPD_USE_MMAP
Slot *cur;
/*printf("protecting memory (chareid=%d)",memory_chare_id);*/
SLOT_ITERATE_START(cur)
if (cur->chareID != memory_chare_id && cur->chareID > 0) {
/*printf(" %p",cur->userData);*/
#ifdef CMK_SEPARATE_SLOT
char * data = cur->userData;
#else
char * data = (char *)cur;
#endif
cur->magic |= BLOCK_PROTECTED;
mprotect(data, cur->userSize+SLOTSPACE+cur->stackLen*sizeof(void*), PROT_READ);
} /*else printf(" (%p)",cur->userData);*/
SLOT_ITERATE_END
/*printf("\n");*/
#endif
}
static void unProtectMemory() {
#ifdef CPD_USE_MMAP
Slot *cur;
SLOT_ITERATE_START(cur)
#ifdef CMK_SEPARATE_SLOT
char * data = cur->userData;
#else
char * data = (char *)cur;
#endif
mprotect(data, cur->userSize+SLOTSPACE+cur->stackLen*sizeof(void*), PROT_READ|PROT_WRITE);
cur->magic &= ~BLOCK_PROTECTED;
SLOT_ITERATE_END
/*printf("unprotecting memory\n");*/
#endif
}
/** Called before the entry method: resets all current memory for the chare
* receiving the message.
*/
void CpdResetMemory() {
if (CpdMemBackup) backupMemory();
if (CpdCRC32) ResetAllCRC();
if (CpdMprotect) protectMemory();
}
/** Called after the entry method to check if the chare that just received the
* message has corrupted the memory of some other chare, or some system memory.
*/
void CpdCheckMemory() {
Slot *cur;
if (CpdMprotect) unProtectMemory();
if (CpdCRC32) CheckAllCRC();
if (CpdMemBackup) checkBackup();
SLOT_ITERATE_START(cur)
if (cur->magic == SLOTMAGIC_FREED) CmiAbort("SLOT deallocate in list");
if (cur->from == NULL) printf("SLOT %p has no stack\n",cur);
#ifndef CMK_SEPARATE_SLOT
if (cur->next == NULL) printf("SLOT %p has null next!\n",cur);
#endif
SLOT_ITERATE_END
}
void CpdSystemEnter() {
#ifdef CPD_USE_MMAP
Slot *cur;
if (++cpdInSystem == 1) {
if (CpdMprotect) {
int count=0;
SLOT_ITERATE_START(cur)
if (cur->chareID == 0) {
#ifdef CMK_SEPARATE_SLOT
char * data = cur->userData;
#else
char * data = (char *)cur;
#endif
mprotect(data, cur->userSize+SLOTSPACE+cur->stackLen*sizeof(void*), PROT_READ|PROT_WRITE);
cur->magic &= ~BLOCK_PROTECTED;
count++;
}
SLOT_ITERATE_END
//printf("CpdSystemEnter: unprotected %d elements\n",count);
}
}
#endif
}
void CpdSystemExit() {
#ifdef CPD_USE_MMAP
Slot *cur;
int i;
if (--cpdInSystem == 0) {
if (CpdMprotect) {
int count=0;
SLOT_ITERATE_START(cur)
if (cur->chareID == 0) {
#ifdef CMK_SEPARATE_SLOT
char * data = cur->userData;
#else
char * data = (char *)cur;
#endif
cur->magic |= BLOCK_PROTECTED;
mprotect(data, cur->userSize+SLOTSPACE+cur->stackLen*sizeof(void*), PROT_READ);
count++;
}
SLOT_ITERATE_END
//printf("CpdSystemExit: protected %d elements\n",count);
/* unprotect the pages that have been unprotected by a signal SEGV */
for (i=0; i<unProtectedPagesSize; ++i) {
mprotect(unProtectedPages[i], 4, PROT_READ|PROT_WRITE);
}
}
}
#endif
}
/*
/ *Head of the current circular allocated block list* /
Slot slot_first_storage={&slot_first_storage,&slot_first_storage};
Slot *slot_first=&slot_first_storage;
#define CMI_MEMORY_ROUTINES 1
/ * Mark all allocated memory as being OK * /
void CmiMemoryMark(void) {
CmiMemLock();
/ * Just make a new linked list of slots * /
slot_first=(Slot *)mm_malloc(sizeof(Slot));
slot_first->next=slot_first->prev=slot_first;
CmiMemUnlock();
}
/ * Mark this allocated block as being OK * /
void CmiMemoryMarkBlock(void *blk) {
Slot *s=Slot_fmUser(blk);
CmiMemLock();
if (s->magic!=SLOTMAGIC) CmiAbort("CmiMemoryMarkBlock called on non-malloc'd block!\n");
/ * Splice us out of the current linked list * /
s->next->prev=s->prev;
s->prev->next=s->next;
s->prev=s->next=s; / * put us in our own list * /
CmiMemUnlock();
}
/ * Print out all allocated memory * /
void CmiMemorySweep(const char *where) {
Slot *cur;
int nBlocks=0,nBytes=0;
CmiMemLock();
cur=slot_first->next;
CmiPrintf("[%d] ------- LEAK CHECK: %s -----\n",CmiMyPe(), where);
while (cur!=slot_first) {
printSlot(cur);
nBlocks++; nBytes+=cur->userSize;
cur=cur->next;
}
if (nBlocks) {
CmiPrintf("[%d] Total leaked memory: %d blocks, %d bytes\n",
CmiMyPe(),nBlocks,nBytes);
/ * CmiAbort("Memory leaks detected!\n"); * /
}
CmiMemUnlock();
CmiMemoryMark();
}
void CmiMemoryCheck(void) {}
*/
/********** Allocation/Free ***********/
static int stackTraceDisabled = 0;
#define MAX_STACK_FRAMES 2048
static int numStackFrames; // the number of frames presetn in stackFrames - 4 (this number is trimmed at 0
static void *stackFrames[MAX_STACK_FRAMES];
static void dumpStackFrames() {
numStackFrames=MAX_STACK_FRAMES;
if (stackTraceDisabled==0) {
stackTraceDisabled = 1;
CmiBacktraceRecordHuge(stackFrames,&numStackFrames);
stackTraceDisabled = 0;
numStackFrames-=4;
if (numStackFrames < 0) numStackFrames = 0;
} else {
numStackFrames=0;
stackFrames[0] = (void*)0;
}
}
/* Write a valid slot to this field */
static void *setSlot(Slot **sl,int userSize) {
#ifdef CMK_SEPARATE_SLOT
Slot *s;
char *user;
static int mallocFirstTime = 1;
if (mallocFirstTime) {
mallocFirstTime = 0;
memory_charmdebug_internal = 1;
block_slots = CkCreateHashtable_pointer(sizeof(Slot), 10000);
memory_charmdebug_internal = 0;
}
user = (char *)*sl;
memory_charmdebug_internal = 1;
s = (Slot *)CkHashtablePut(block_slots, sl);
memory_charmdebug_internal = 0;
*sl = s;
s->userData = user;
#else
Slot *s = *sl;
char *user=(char*)(s+1);
/* Splice into the slot list just past the head (part 1) */
s->next=slot_first->next;
s->prev=slot_first;
/* Handle correctly memory protection while changing neighbor blocks */
if (CpdMprotect) {
mprotect(s->next, 4, PROT_READ | PROT_WRITE);
mprotect(s->prev, 4, PROT_READ | PROT_WRITE);
}
/* Splice into the slot list just past the head (part 2) */
s->next->prev=s;
s->prev->next=s;
if (CpdCRC32) {
/* fix crc for previous and next block */
resetSlotCRC(s->next + 1);
resetSlotCRC(s->prev + 1);
}
if (CpdMprotect) {
if (isProtected(s->next)) mprotect(s->next, 4, PROT_READ);
if (isProtected(s->prev)) mprotect(s->prev, 4, PROT_READ);
}
#endif
/* Set the last 4 bits of magic to classify the memory together with the magic */
s->magic=SLOTMAGIC + NEW_BLOCK + (memory_status_info>0? USER_TYPE : SYSTEM_TYPE);
//if (memory_status_info>0) printf("user allocation\n");
s->chareID = memory_chare_id;
s->userSize=userSize;
s->extraStack=(SlotStack *)0;
/* Set the stack frames */
s->stackLen=numStackFrames;
s->from=(void**)(user+userSize);
memcpy(s->from, &stackFrames[4], numStackFrames*sizeof(void*));
if (CpdCRC32) {
unsigned int crc = crc32_initial((unsigned char*)s, SLOT_CRC_LENGTH);
s->slotCRC = crc32_update((unsigned char*)s->from, numStackFrames*sizeof(void*), crc);
s->userCRC = crc32_initial((unsigned char*)user, userSize);
}
if (saveAllocationHistory) {
if (allocatedSinceSize >= allocatedSinceMaxSize) {
Slot **newAllocatedSince;
allocatedSinceMaxSize += 10;
BEFORE_MALLOC_CALL;
newAllocatedSince = (Slot**)mm_malloc((allocatedSinceMaxSize)*sizeof(Slot*));
memcpy(newAllocatedSince, allocatedSince, allocatedSinceSize*sizeof(Slot*));
mm_free(allocatedSince);
AFTER_MALLOC_CALL;
allocatedSince = newAllocatedSince;
}
allocatedSince[allocatedSinceSize++] = s;
}
lastMemoryAllocated = user;
return (void *)user;
}
/* Delete this slot structure */
static void freeSlot(Slot *s) {
#ifdef CMK_SEPARATE_SLOT
/* Don't delete it from the hash table, simply mark it as freed */
int removed = CkHashtableRemove(block_slots, &s->userData);
CmiAssert(removed);
/* WARNING! After the slot has been removed from the hashtable,
* the pointer "s" becomes invalid.
*/
#else
/* Handle correctly memory protection while changing neighbor blocks */
if (CpdMprotect) {
mprotect(s->next, 4, PROT_READ | PROT_WRITE);
mprotect(s->prev, 4, PROT_READ | PROT_WRITE);
}
/* Splice out of the slot list */
s->next->prev=s->prev;
s->prev->next=s->next;
if (CpdCRC32) {
/* fix crc for previous and next block */
resetSlotCRC(s->next + 1);
resetSlotCRC(s->prev + 1);
}
if (CpdMprotect) {
if (isProtected(s->next)) mprotect(s->next, 4, PROT_READ);
if (isProtected(s->prev)) mprotect(s->prev, 4, PROT_READ);
}
s->prev=s->next=(Slot *)0;//0x0F00; why was it not 0?
s->magic=SLOTMAGIC_FREED;
s->userSize=-1;
#endif
}
/********** meta_ routines ***********/
/* Return the system page size */
static int meta_getpagesize(void) {
static int cache=0;
#if defined(CMK_GETPAGESIZE_AVAILABLE)
if (cache==0) cache=getpagesize();
#else
if (cache==0) cache=8192;
#endif
return cache;
}
/* Only display startup status messages from processor 0 */
static void status(char *msg) {
if (CmiMyPe()==0 && !CmiArgGivingUsage()) {
CmiPrintf("%s",msg);
}
}
extern int getCharmEnvelopeSize();
static int disableVerbosity = 1;
int cpdInitializeMemory;
void CpdSetInitializeMemory(int v) { cpdInitializeMemory = v; }
static void meta_init(char **argv) {
char buf[100];
status("Converse -memory mode: charmdebug\n");
sprintf(buf, "slot size %d\n", (int)sizeof(Slot));
status(buf);
CmiMemoryIs_flag|=CMI_MEMORY_IS_CHARMDEBUG;
cpdInitializeMemory = 0;
charmEnvelopeSize = getCharmEnvelopeSize();
CpdDebugGetAllocationTree = (void* (*)(int*))CreateAllocationTree;
CpdDebug_pupAllocationPoint = pupAllocationPoint;
CpdDebug_deleteAllocationPoint = deleteAllocationPoint;
CpdDebug_MergeAllocationTree = MergeAllocationTree;
CpdDebugGetMemStat = (void* (*)(void))CreateMemStat;
CpdDebug_pupMemStat = pupMemStat;
CpdDebug_deleteMemStat = deleteMemStat;
CpdDebug_mergeMemStat = mergeMemStat;
memory_allocated_user_total = 0;
nextChareID = 1;
#ifndef CMK_SEPARATE_SLOT
slot_first->userSize = 0;
slot_first->stackLen = 0;
#endif
if (CmiGetArgFlagDesc(argv,"+memory_report", "Print all cross-object violations")) {
reportMEM = 1;
}
if (CmiGetArgFlagDesc(argv,"+memory_backup", "Backup all memory at every entry method")) {
CpdMemBackup = 1;
saveAllocationHistory = 1;
}
if (CmiGetArgFlagDesc(argv,"+memory_crc", "Use CRC32 to detect memory changes")) {
CpdCRC32 = 1;
}
#ifdef CPD_USE_MMAP
if (CmiGetArgFlagDesc(argv,"+memory_mprotect", "Use mprotect to protect memory of other chares")) {
struct sigaction sa;
CpdMprotect = 1;
sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART;
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = CpdMMAPhandler;
if (sigaction(SIGSEGV, &sa, NULL) == -1) CmiPrintf("failed to install signal handler\n");
}
#endif
if (CmiGetArgFlagDesc(argv,"+memory_verbose", "Print all memory-related operations")) {
disableVerbosity = 0;
}
if (CmiGetArgFlagDesc(argv,"+memory_nostack", "Do not collect stack traces for memory allocations")) {
stackTraceDisabled = 1;
}
}
static void *meta_malloc(size_t size) {
void *user;
if (memory_charmdebug_internal==0) {
Slot *s;
dumpStackFrames();
BEFORE_MALLOC_CALL;
#if CPD_USE_MMAP
s=(Slot *)mmap(NULL, SLOTSPACE+size+numStackFrames*sizeof(void*), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
#else
s=(Slot *)mm_malloc(SLOTSPACE+size+numStackFrames*sizeof(void*));
#endif
AFTER_MALLOC_CALL;
if (s!=NULL) {
user = (char*)setSlot(&s,size);
memory_allocated_user_total += size;
#if ! CMK_BIGSIM_CHARM
traceMalloc_c(user, size, s->from, s->stackLen);
#endif
}
if (disableVerbosity == 0) {
disableVerbosity = 1;
CmiPrintf("allocating %p: %d bytes\n",s,size);
disableVerbosity = 0;
}
} else {
BEFORE_MALLOC_CALL;
user = mm_malloc(size);
AFTER_MALLOC_CALL;
}
if (cpdInitializeMemory) {
memset(user, 0, size); // for Record-Replay must initialize all memory otherwise paddings may differ (screwing up the CRC)
}
return user;
}
static void meta_free(void *mem) {
if (memory_charmdebug_internal==0) {
int memSize;
Slot *s;
if (mem==NULL) return; /*Legal, but misleading*/
s=UserToSlot(mem);
#if CMK_MEMORY_BUILD_OS
/* In this situation, we can have frees that were not allocated by our malloc...
* for now simply skip over them. */
if (s == NULL || ((s->magic&~FLAGS_MASK) != SLOTMAGIC_VALLOC &&
(s->magic&~FLAGS_MASK) != SLOTMAGIC)) {
BEFORE_MALLOC_CALL;
mm_free(mem);
AFTER_MALLOC_CALL;
return;
}
#endif
/* Check that the memory is really allocated, and we can use its slot */
/* TODO */
if (s == NULL ||
((s->magic&~FLAGS_MASK) != SLOTMAGIC &&
(s->magic&~FLAGS_MASK) != SLOTMAGIC_FREED &&
(s->magic&~FLAGS_MASK) != SLOTMAGIC_VALLOC)) {
CmiAbort("Free'd non-malloc'd block");
}
#ifdef CMK_SEPARATE_SLOT
CmiAssert(s->userData == mem);
#endif
memSize = 0;
if (mem!=NULL) memSize = s->userSize;
memory_allocated_user_total -= memSize;
#if ! CMK_BIGSIM_CHARM
traceFree_c(mem, memSize);
#endif
if (disableVerbosity == 0) {
disableVerbosity = 1;
CmiPrintf("freeing %p\n",mem);
disableVerbosity = 0;
}
/*Overwrite stack trace with the one of the free*/
dumpStackFrames();
if (s->stackLen > numStackFrames) s->stackLen=numStackFrames;
memcpy(s->from, &stackFrames[4], s->stackLen*sizeof(void*));
if ((s->magic&~FLAGS_MASK)==SLOTMAGIC_VALLOC)
{ /*Allocated with special alignment*/
void *ptr = s->extraStack;
freeSlot(s);
BEFORE_MALLOC_CALL;
mm_free(ptr);
/*mm_free(((char *)mem)-meta_getpagesize());*/
AFTER_MALLOC_CALL;
}
else if ((s->magic&~FLAGS_MASK)==SLOTMAGIC)
{ /*Ordinary allocated block */
int freeSize=SLOTSPACE+s->userSize+s->stackLen*sizeof(void*);
void *ptr;
freeSlot(s);
#ifdef CMK_SEPARATE_SLOT
ptr = mem;
#else
ptr = s;
#endif
BEFORE_MALLOC_CALL;
#if CPD_USE_MMAP
munmap(ptr, freeSize);
#else
mm_free(ptr);
#endif
AFTER_MALLOC_CALL;
}
else if (s->magic==SLOTMAGIC_FREED)
CmiAbort("Free'd block twice");
else /*Unknown magic number*/
CmiAbort("Free'd non-malloc'd block");
} else {
BEFORE_MALLOC_CALL;
mm_free(mem);
AFTER_MALLOC_CALL;
}
}
static void *meta_calloc(size_t nelem, size_t size) {
void *area=meta_malloc(nelem*size);
if (area != NULL) memset(area,0,nelem*size);
return area;
}
static void meta_cfree(void *mem) {
meta_free(mem);
}
static void *meta_realloc(void *oldBuffer, size_t newSize) {
void *newBuffer = meta_malloc(newSize);
if ( newBuffer && oldBuffer ) {
/*Preserve old buffer contents*/
Slot *o=UserToSlot(oldBuffer);
size_t size=o->userSize;
if (size>newSize) size=newSize;
if (size > 0)
memcpy(newBuffer, oldBuffer, size);
meta_free(oldBuffer);
}
return newBuffer;
}
static void *meta_memalign(size_t align, size_t size) {
int overhead = align;
char *alloc;
Slot *s;
void *user;
while (overhead < SLOTSPACE+sizeof(SlotStack)) overhead += align;
/* Allocate the required size + the overhead needed to keep the user alignment */
dumpStackFrames();
BEFORE_MALLOC_CALL;
alloc=(char *)mm_memalign(align,overhead+size+numStackFrames*sizeof(void*));
AFTER_MALLOC_CALL;
s=(Slot*)(alloc+overhead-SLOTSPACE);
user=setSlot(&s,size);
s->magic = SLOTMAGIC_VALLOC + (s->magic&0xF);
s->extraStack = (SlotStack *)alloc; /* use the extra space as stack */
s->extraStack->protectedMemory = NULL;
s->extraStack->protectedMemoryLength = 0;
memory_allocated_user_total += size;
#if ! CMK_BIGSIM_CHARM
traceMalloc_c(user, size, s->from, s->stackLen);
#endif
return user;
}
static void *meta_valloc(size_t size) {
return meta_memalign(meta_getpagesize(),size);
}
void setProtection(char* mem, char *ptr, int len, int flag) {
Slot *sl = UserToSlot(mem);
if (sl->extraStack == NULL) CmiAbort("Tried to protect memory not memaligned\n");
if (flag != 0) {
sl->extraStack->protectedMemory = ptr;
sl->extraStack->protectedMemoryLength = len;
} else {
sl->extraStack->protectedMemory = NULL;
sl->extraStack->protectedMemoryLength = 0;
}
}
void **chareObjectMemory = NULL;
int chareObjectMemorySize = 0;
void setMemoryTypeChare(void *ptr) {
Slot *sl = UserToSlot(ptr);
sl->magic = (sl->magic & ~FLAGS_MASK) | CHARE_TYPE;
sl->chareID = nextChareID;
if (nextChareID >= chareObjectMemorySize) {
void **newChare;
BEFORE_MALLOC_CALL;
newChare = (void**)mm_malloc((nextChareID+100) * sizeof(void*));
AFTER_MALLOC_CALL;
memcpy(newChare, chareObjectMemory, chareObjectMemorySize*sizeof(void*));
chareObjectMemorySize = nextChareID+100;
BEFORE_MALLOC_CALL;
mm_free(chareObjectMemory);
AFTER_MALLOC_CALL;
chareObjectMemory = newChare;
}
chareObjectMemory[nextChareID] = ptr;
nextChareID ++;
}
/* The input parameter is the pointer to the envelope, after the CmiChunkHeader */
void setMemoryTypeMessage(void *ptr) {
void *realptr = (char*)ptr - sizeof(CmiChunkHeader);
Slot *sl = UserToSlot(realptr);
if ((sl->magic&~FLAGS_MASK) == SLOTMAGIC || (sl->magic&~FLAGS_MASK) == SLOTMAGIC_VALLOC) {
sl->magic = (sl->magic & ~FLAGS_MASK) | MESSAGE_TYPE;
}
}
int setMemoryChareIDFromPtr(void *ptr) {
int tmp = memory_chare_id;
if (ptr == NULL || ptr == 0) memory_chare_id = 0;
else memory_chare_id = UserToSlot(ptr)->chareID;
return tmp;
}
void setMemoryChareID(int chareID) {
memory_chare_id = chareID;
}
void setMemoryOwnedBy(void *ptr, int chareID) {
Slot *sl = UserToSlot(ptr);
sl->chareID = chareID;
}
void * MemoryToSlot(void *ptr) {
Slot *sl;
int i;
#if defined(CPD_USE_MMAP) && defined(CMK_SEPARATE_SLOT)
for (i=0; i<1000; ++i) {
sl = UserToSlot((void*)(((CmiUInt8)ptr)-i*meta_getpagesize() & ~(meta_getpagesize()-1)));
if (sl != NULL) return sl;
}
#endif
return NULL;
}
/*void PrintDebugStackTrace(void *ptr) {
int i;
Slot *sl = UserToSlot((void*)(((CmiUInt8)ptr) & ~(meta_getpagesize()-1)));
if (sl != NULL) {
CmiPrintf("%d %d ",sl->chareID,sl->stackLen);
for (i=0; i<sl->stackLen; ++i) CmiPrintf("%p ",sl->from[i]);
} else {
CmiPrintf("%d 0 ",sl->chareID);
}
}*/
#endif
| 30.889791 | 167 | 0.660007 |
4d7729af937db335ca144ee252a9e6964cced95e | 188 | c | C | Tests/Programs/Exp.c | ALMikhai/CCompiler | a5df9a834685ffb673d5d545ebb9e7ab28c02b93 | [
"MIT"
] | null | null | null | Tests/Programs/Exp.c | ALMikhai/CCompiler | a5df9a834685ffb673d5d545ebb9e7ab28c02b93 | [
"MIT"
] | null | null | null | Tests/Programs/Exp.c | ALMikhai/CCompiler | a5df9a834685ffb673d5d545ebb9e7ab28c02b93 | [
"MIT"
] | null | null | null | #include <stdio.h>
void print_int(int a) {
printf("%d\n", a);
}
int main() {
int a = 3;
int b = 0;
a = (1, print_int(a), b = 1, 4);
print_int(a);
print_int(b);
}
| 13.428571 | 36 | 0.484043 |
4d77d9314228ceb45274b37ca13786db87684ed1 | 3,359 | h | C | src/normalized_conjunction.h | denis631/llvm-lab | 113bf8be19b74db7320779137a1082b4ad6de238 | [
"Unlicense"
] | null | null | null | src/normalized_conjunction.h | denis631/llvm-lab | 113bf8be19b74db7320779137a1082b4ad6de238 | [
"Unlicense"
] | null | null | null | src/normalized_conjunction.h | denis631/llvm-lab | 113bf8be19b74db7320779137a1082b4ad6de238 | [
"Unlicense"
] | null | null | null | //
// conjunction.h
// PAIN
//
// Created by Tim Gymnich on 17.1.20.
//
#pragma once
#include <unordered_map>
#include <vector>
#include <set>
#include <llvm/IR/Instructions.h>
#include "global.h"
#include "linear_equality.h"
namespace pcpo {
class NormalizedConjunction {
public:
std::unordered_map<llvm::Value const*, LinearEquality> values;
std::set<llvm::Value const*> validVariables;
bool isBottom = true;
NormalizedConjunction() = default;
NormalizedConjunction(NormalizedConjunction const& state) = default;
NormalizedConjunction(std::unordered_map<llvm::Value const*, LinearEquality> const& equalaties);
explicit NormalizedConjunction(llvm::Function const& f);
/// This constructor is used to initialize the state of a function call, to which parameters are passed.
/// This is the "enter" function as described in "Compiler Design: Analysis and Transformation"
explicit NormalizedConjunction(llvm::Function const* callee_func, NormalizedConjunction const& state, llvm::CallInst const* call);
/// Handles the evaluation of merging points
void applyPHINode(llvm::BasicBlock const& bb, std::vector<NormalizedConjunction> pred_values, llvm::Instruction const& phi);
/// Handles the evaluation of function calls
/// This is the "combine" function as described in "Compiler Design: Analysis and Transformation"
void applyCallInst(llvm::Instruction const& inst, llvm::BasicBlock const* end_block, NormalizedConjunction const& callee_state);
/// Handles the evaluation of return instructions
void applyReturnInst(llvm::Instruction const& inst);
/// Handles the evaluation of all other instructions
void applyDefault(llvm::Instruction const& inst);
bool merge(Merge_op::Type op, NormalizedConjunction const& other);
void branch(llvm::BasicBlock const& from, llvm::BasicBlock const& towards) { return; };
bool leastUpperBound(NormalizedConjunction rhs);
bool checkOperandsForBottom(llvm::Instruction const& inst) { return false; }
void printIncoming(llvm::BasicBlock const& bb, llvm::raw_ostream& out, int indentation) const;
void printOutgoing(llvm::BasicBlock const& bb, llvm::raw_ostream& out, int indentation) const;
// Abstract Assignments
void linearAssignment(llvm::Value const* xi, int64_t a, llvm::Value const* xj, int64_t b);
void nonDeterminsticAssignment(llvm::Value const* xi);
// Operators
LinearEquality& operator[](llvm::Value const*);
LinearEquality& get(llvm::Value const*);
protected:
// Abstract Operators
void Add(llvm::Instruction const& inst);
void Sub(llvm::Instruction const& inst);
void Mul(llvm::Instruction const& inst);
/// Used for debug output
void debug_output(llvm::Instruction const& inst, std::vector<LinearEquality> operands);
// Helpers
static std::set<LinearEquality> computeX0(std::set<LinearEquality> const& E1, std::set<LinearEquality> const& E2);
static std::set<LinearEquality> computeX1(std::set<LinearEquality> const& E1, std::set<LinearEquality> const& E2);
static std::set<LinearEquality> computeX2(std::set<LinearEquality> const& E1, std::set<LinearEquality> const& E2);
static std::set<LinearEquality> computeX4(std::set<LinearEquality> const& E1, std::set<LinearEquality> const& E2);
};
}
| 41.9875 | 134 | 0.730277 |
4d7af0584e1f567bc4285afcb39eec5d3b95957b | 1,375 | c | C | deps/nanoresource/allocator.c | jwerle/sleepfile.c | 34f8f1d1b9fbc5357555928feb6c80fc1083e503 | [
"MIT"
] | 5 | 2019-07-25T23:11:14.000Z | 2022-02-25T15:58:20.000Z | deps/nanoresource/allocator.c | jwerle/libsleepfile | 34f8f1d1b9fbc5357555928feb6c80fc1083e503 | [
"MIT"
] | null | null | null | deps/nanoresource/allocator.c | jwerle/libsleepfile | 34f8f1d1b9fbc5357555928feb6c80fc1083e503 | [
"MIT"
] | null | null | null | #include "nanoresource/allocator.h"
#include <stdlib.h>
#ifndef NANORESOURCE_ALLOCATOR_ALLOC
#define NANORESOURCE_ALLOCATOR_ALLOC 0
#endif
#ifndef NANORESOURCE_ALLOCATOR_FREE
#define NANORESOURCE_ALLOCATOR_FREE 0
#endif
static void *(*alloc)(unsigned long int) = NANORESOURCE_ALLOCATOR_ALLOC;
static void (*dealloc)(void *) = NANORESOURCE_ALLOCATOR_FREE;
static struct nanoresource_allocator_stats_s stats = { 0 };
const struct nanoresource_allocator_stats_s
nanoresource_allocator_stats() {
return (struct nanoresource_allocator_stats_s) {
.alloc = stats.alloc,
.free = stats.free
};
}
int
nanoresource_allocator_alloc_count() {
return stats.alloc;
}
int
nanoresource_allocator_free_count() {
return stats.free;
}
void
nanoresource_allocator_set(void *(*allocator)(unsigned long int)) {
alloc = allocator;
}
void
nanoresource_deallocator_set(void (*deallocator)(void *)) {
dealloc = deallocator;
}
void *
nanoresource_allocator_alloc(unsigned long int size) {
if (0 == size) {
return 0;
} else if (0 != alloc) {
(void) stats.alloc++;
return alloc(size);
} else {
(void) stats.alloc++;
return malloc(size);
}
}
void
nanoresource_allocator_free(void *ptr) {
if (0 == ptr) {
return;
} else if (0 != dealloc) {
(void) stats.free++;
dealloc(ptr);
} else {
(void) stats.free++;
free(ptr);
}
}
| 19.642857 | 72 | 0.711273 |
4d7b616977ddeac3d1828a137776c5512fa13ccb | 1,387 | c | C | main/kernel.c | kammce/KinXOS | 637ecc7a345e19df7ebffd95b476591ce1134829 | [
"MIT"
] | null | null | null | main/kernel.c | kammce/KinXOS | 637ecc7a345e19df7ebffd95b476591ce1134829 | [
"MIT"
] | null | null | null | main/kernel.c | kammce/KinXOS | 637ecc7a345e19df7ebffd95b476591ce1134829 | [
"MIT"
] | null | null | null | /* Desc: Kernel C Code and Main file */
/* Check if the bit BIT in FLAGS is set. */
#include <multiboot.h>
#include <cpu.h>
#include <core.h>
#include <memory.h>
#include <shell.h>
#include <stdio.h>
#include <varg.h>
#include <video.h>
kmain(unsigned long magic, unsigned long info) //like normal main in C programs
{
/*if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
puts ("Invalid magic number: 0x%x\n", (unsigned) magic);
return;
}*/
/* Set MBI to the address of the Multiboot information structure. */
//mbi = (multiboot_info_t *) info;
init_video();
ClearScreen();
putch('\n');
puts("Initiating video [DONE]\n");
puts("Installing Global Descriptor Table");
gdt_install();
puts(" [DONE]\n");
puts("Installing Interrupt Descriptor Table");
idt_install();
puts(" [DONE]\n");
puts("Installing Interrupt Service Routines");
isrs_install();
puts(" [DONE]\n");
puts("Installing Interrupt Vector Table");
irq_install();
puts(" [DONE]\n");
puts("Installing Physical Memory Manager");
physical_memory_manager_install(info);
puts(" [DONE]\n");
puts("Installing Timer Driver");
timer_install();
puts(" [DONE]\n");
puts("Installing Keyboard Driver");
keyboard_install();
puts(" [DONE]\n");
puts("Enabling Interrupts");
enableInts();
puts(" [DONE]\n");
puts("Starting KinDOS\n");
kinDOSInstall();
while (1) { hlt(); }
};
| 25.218182 | 79 | 0.658255 |
4d7e91a644bf5c69f0fe55f1da730a021fe53227 | 3,723 | c | C | kamailio/modules/src/mod_dsiprouter.c | ednt/dsiprouter | 7f24186c907e4bdf8f63a90a8cfc311139db3189 | [
"Apache-2.0"
] | 130 | 2017-07-18T11:50:56.000Z | 2022-02-26T09:21:53.000Z | kamailio/modules/src/mod_dsiprouter.c | ednt/dsiprouter | 7f24186c907e4bdf8f63a90a8cfc311139db3189 | [
"Apache-2.0"
] | 319 | 2017-07-21T15:46:30.000Z | 2022-03-27T05:25:24.000Z | kamailio/modules/src/mod_dsiprouter.c | ednt/dsiprouter | 7f24186c907e4bdf8f63a90a8cfc311139db3189 | [
"Apache-2.0"
] | 87 | 2017-07-21T13:27:05.000Z | 2022-02-22T20:06:41.000Z | /*
* mod_dsiprouter.c
*/
/*!
* \file
* \brief dSipRouter Module Interface
* \ingroup dsiprouter
* Module: \ref dsiprouter
*/
/**
* @defgroup dsiprouter dsiprouter :: Kamailio dsiprouter module
* @brief Kamailio dsiprouter module
*/
#include <string.h>
#include <stdio.h>
#include "../../core/ver_defs.h"
#include "../../core/sr_module.h"
#include "../../core/mod_fix.h"
#include "../../core/rpc.h"
#include "../../core/rpc_lookup.h"
#include "mod_funcs.h"
MODULE_VERSION
/* module params */
static char *license_file = "/etc/dsiprouter/license.txt";
static char *signature_file = "/etc/dsiprouter/license-sig.b64";
static char *uuid_file = "/etc/dsiprouter/uuid.txt";
/* Module management function prototypes */
static int mod_init(void);
static int mod_child_init(int rank);
static void mod_destroy(void);
static int fixup_get_params(void **param, int param_no);
static int fixup_get_params_free(void **param, int param_no);
static int mod_health_check();
static void rpc_health_check(rpc_t *rpc, void *ctx);
/* Exported functions */
static cmd_export_t cmds[] = {
{"health_check", (cmd_function) mod_health_check, 1,
fixup_get_params, fixup_get_params_free, ANY_ROUTE},
{0,0, 0,0,0}
};
/* Exported rpc functions */
static const char *rpc_health_check_doc[2] = {"Check health of dsiprouter system.", 0};
static rpc_export_t rpc_cmds[] = {
{"dsiprouter.health_check", rpc_health_check, rpc_health_check_doc,0},
{0,0,0,0}
};
/* Exported parameters */
static param_export_t params[] = {
{"license_file", PARAM_STRING, &license_file},
{"signature_file", PARAM_STRING, &signature_file},
{"uuid_file", PARAM_STRING, &uuid_file},
{0,0,0}
};
/* Module interface */
module_exports_t exports = {
"dsiprouter", /* module name */
DEFAULT_DLFLAGS, /* dlopen flags */
cmds, /* exported functions */
params, /* exported parameters */
0, /* exported rpc functions */
0, /* exported pseudo-variables */
0, /* exported response function */
mod_init, /* exported initialization function */
mod_child_init, /* exported child initialization function */
mod_destroy, /* exported destroy function */
};
/* Module initialization function - The main initialization function will be called
before any other function exported by the module. The function will be called only once,
before the main process forks. This function is good for initialization that is common
for all the children (processes). The function should return 0 if everything went OK
and a negative error code otherwise. Server will abort if the function returns a negative value.
*/
static int mod_init(void) {
LM_DBG("mod_dsiprouter initializing\n");
if (rpc_register_array(rpc_cmds) != 0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
return 0;
}
static int mod_child_init(int rank) {
return 0;
}
static void mod_destroy(void) {
LM_DBG("mod_dsiprouter unloading\n");
}
static int fixup_get_params(void **param, int param_no) {
if (param_no == 1) {
return fixup_pvar_null(param, 1);
}
LM_ERR("invalid parameter number <%d>\n", param_no);
return -1;
}
static int fixup_get_params_free(void **param, int param_no) {
if (param_no == 1) {
return fixup_free_pvar_null(param, 1);
}
LM_ERR("invalid parameter number <%d>\n", param_no);
return -1;
}
static int mod_health_check() {
return validate_license(license_file, signature_file, uuid_file);
}
static void rpc_health_check(rpc_t *rpc, void *ctx) {
if (!validate_license(license_file, signature_file, uuid_file)) {
rpc->fault(ctx, 500, "Health Check Failed");
}
else {
rpc->rpl_printf(ctx, "Health Check Succeeded");
}
}
| 28.638462 | 99 | 0.701853 |
4d7f46c85e1d0d8559341e2ce4ab87108658e49f | 1,531 | c | C | problem_production_of_water/queue.c | Paulo-http/pthreads | da7e45b7cb87da9a72f09a25c4d8dadf4f78b07f | [
"MIT"
] | null | null | null | problem_production_of_water/queue.c | Paulo-http/pthreads | da7e45b7cb87da9a72f09a25c4d8dadf4f78b07f | [
"MIT"
] | null | null | null | problem_production_of_water/queue.c | Paulo-http/pthreads | da7e45b7cb87da9a72f09a25c4d8dadf4f78b07f | [
"MIT"
] | null | null | null | //
// queue.c
// pthreads
//
// Created by Paulo Henrique Leite on 10/04/2018.
// Copyright © 2018 com.hfleite. All rights reserved.
//
#include "queue.h"
bool is_empty(node *atoms) {
return (atoms->next == NULL) ? true : false;
}
void _free(node *atoms) {
if (is_empty(atoms)) {
return;
}
node *atom = atoms->next;
node *next_atom;
while (atom != NULL) {
next_atom = atom->next;
free(atom);
atom = next_atom;
}
}
void start(node *atoms) {
atoms->next = NULL;
}
node *alloc(enum element type) {
node *atom = (node *) malloc(sizeof(node));
atom->type = type;
return atom;
}
void append(node *atoms, enum element type) {
node *atom = alloc(type);
atom->next = NULL;
if (is_empty(atoms)) {
atoms->next = atom;
} else {
node *next_atom = atoms->next;
while (next_atom->next != NULL) {
next_atom = next_atom->next;
}
next_atom->next = atom;
}
}
void _remove(node *atoms) {
if (is_empty(atoms)) {
return;
} else {
node *next_atom = atoms->next;
atoms->next = next_atom->next;
if(next_atom != NULL) {
free(next_atom);
}
}
}
int count(node *atoms) {
int count = 0;
if (is_empty(atoms)) {
return count;
}
node *next_atom = atoms->next;
while (next_atom != NULL) {
next_atom = next_atom->next;
++count;
}
return count;
}
| 18.22619 | 54 | 0.524494 |
4d81906ba84de7a0fb54f361ae255e6562a2667b | 237 | h | C | helper/PrivateInterfaces/NSTouchbarItem.h | cyco/karma-touchbar-reporter | 39657ca0ca6fc6d9a3aaef71d08a90237cce4631 | [
"MIT"
] | 10 | 2018-04-27T10:41:33.000Z | 2020-09-15T14:18:25.000Z | helper/PrivateInterfaces/NSTouchbarItem.h | cyco/karma-touchbar-reporter | 39657ca0ca6fc6d9a3aaef71d08a90237cce4631 | [
"MIT"
] | 1 | 2018-06-17T18:41:57.000Z | 2018-06-20T19:21:45.000Z | helper/PrivateInterfaces/NSTouchbarItem.h | cyco/karma-touchbar-reporter | 39657ca0ca6fc6d9a3aaef71d08a90237cce4631 | [
"MIT"
] | null | null | null | #ifndef NSTouchbarItem_h
#define NSTouchbarItem_h
@interface NSTouchBarItem ()
+ (void)removeSystemTrayItem:(id)arg1;
+ (void)addSystemTrayItem:(id)arg1;
+ (void)removeTouchIDItem:(id)arg1;
+ (void)addTouchIDItem:(id)arg1;
@end
#endif
| 19.75 | 38 | 0.772152 |
4d8a2b03562eea73ca277931c19702f12608c191 | 1,136 | h | C | System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PPDiscoverySuggester.h | lechium/iPhoneOS_12.1.1_Headers | aac688b174273dfcbade13bab104461f463db772 | [
"MIT"
] | 12 | 2019-06-02T02:42:41.000Z | 2021-04-13T07:22:20.000Z | System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PPDiscoverySuggester.h | lechium/iPhoneOS_12.1.1_Headers | aac688b174273dfcbade13bab104461f463db772 | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PPDiscoverySuggester.h | lechium/iPhoneOS_12.1.1_Headers | aac688b174273dfcbade13bab104461f463db772 | [
"MIT"
] | 3 | 2019-06-11T02:46:10.000Z | 2019-12-21T14:58:16.000Z | /*
* This header is generated by classdump-dyld 1.0
* on Saturday, June 1, 2019 at 6:52:49 PM Mountain Standard Time
* Operating System: Version 12.1.1 (Build 16C5050a)
* Image Source: /System/Library/PrivateFrameworks/PersonalizationPortraitInternals.framework/PersonalizationPortraitInternals
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <PersonalizationPortraitInternals/PPContactSuggester.h>
@protocol OS_dispatch_queue;
@class NSObject, _PASLock;
@interface PPDiscoverySuggester : PPContactSuggester {
NSObject*<OS_dispatch_queue> _queue;
_PASLock* _data;
BOOL _enabled;
}
-(void)clearCaches;
-(void)_addContacts:(id)arg1 ;
-(void)_removeContacts:(id)arg1 ;
-(void)undiscoverEvent:(id)arg1 store:(id)arg2 ;
-(void)_undiscoverEvent:(id)arg1 identifier:(id)arg2 store:(id)arg3 ;
-(void)discoverEvent:(id)arg1 store:(id)arg2 ;
-(void)_discoveredEvent:(id)arg1 identifier:(id)arg2 store:(id)arg3 ;
-(void)discoveredRecipients:(id)arg1 ;
-(void)_discoveredRecipient:(id)arg1 ;
-(void)waitForDiscoveriesToProcess;
-(void)stopDiscovering;
-(void)resumeDiscovering;
-(id)init;
@end
| 31.555556 | 125 | 0.78081 |
4d8beedcf8c668464a3b2b63f73abc3476b0c0dc | 506 | h | C | PrivateFrameworks/PassKitUI.framework/PKStoreProductViewController.h | shaojiankui/iOS10-Runtime-Headers | 6b0d842bed0c52c2a7c1464087b3081af7e10c43 | [
"MIT"
] | 36 | 2016-04-20T04:19:04.000Z | 2018-10-08T04:12:25.000Z | PrivateFrameworks/PassKitUI.framework/PKStoreProductViewController.h | shaojiankui/iOS10-Runtime-Headers | 6b0d842bed0c52c2a7c1464087b3081af7e10c43 | [
"MIT"
] | null | null | null | PrivateFrameworks/PassKitUI.framework/PKStoreProductViewController.h | shaojiankui/iOS10-Runtime-Headers | 6b0d842bed0c52c2a7c1464087b3081af7e10c43 | [
"MIT"
] | 10 | 2016-06-16T02:40:44.000Z | 2019-01-15T03:31:45.000Z | /* Generated by RuntimeBrowser
Image: /System/Library/PrivateFrameworks/PassKitUI.framework/PassKitUI
*/
@interface PKStoreProductViewController : SKStoreProductViewController <SKStoreProductViewControllerDelegate>
@property (readonly, copy) NSString *debugDescription;
@property (readonly, copy) NSString *description;
@property (readonly) unsigned long long hash;
@property (readonly) Class superclass;
- (id)initWithItemIdentifier:(id)arg1;
- (void)productViewControllerDidFinish:(id)arg1;
@end
| 31.625 | 109 | 0.812253 |
4d8bfe9c29835c910eed92a8c706b8d834d584dc | 1,514 | h | C | SJVideoPlayer/ControlView/SJVideoPlayerFilmEditingControlView.h | MiaoShichang/SJVideoPlayer | 831fc57d74419c5a1914a6e3f83165fe0615e0bf | [
"MIT"
] | 1 | 2018-05-30T07:05:59.000Z | 2018-05-30T07:05:59.000Z | SJVideoPlayer/ControlView/SJVideoPlayerFilmEditingControlView.h | hgl753951/SJVideoPlayer | f73b60feea7efa06e0e3da2b73b33940fadb3eb7 | [
"MIT"
] | null | null | null | SJVideoPlayer/ControlView/SJVideoPlayerFilmEditingControlView.h | hgl753951/SJVideoPlayer | f73b60feea7efa06e0e3da2b73b33940fadb3eb7 | [
"MIT"
] | 1 | 2020-04-22T03:04:26.000Z | 2020-04-22T03:04:26.000Z | //
// SJVideoPlayerFilmEditingControlView.h
// SJVideoPlayerProject
//
// Created by BlueDancer on 2018/3/9.
// Copyright © 2018年 SanJiang. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "SJVideoPlayerFilmEditingStatus.h"
#import "SJVideoPlayerFilmEditingCommonHeader.h"
NS_ASSUME_NONNULL_BEGIN
@interface SJVideoPlayerFilmEditingControlView : UIView
@property (nonatomic, weak, nullable) id <SJVideoPlayerFilmEditingControlViewDataSource> dataSource;
@property (nonatomic, weak, nullable) id <SJVideoPlayerFilmEditingControlViewDelegate> delegate;
@property (nonatomic, weak, nullable) id <SJVideoPlayerFilmEditingPromptResource> resource;
@property (nonatomic, weak, nullable) id <SJVideoPlayerFilmEditingResultUpload> uploader;
#pragma mark - operation
@property (nonatomic, readonly) SJVideoPlayerFilmEditingOperation currentOperation; // user selected operation.
@property (nonatomic) BOOL disableScreenshot; // default is NO
@property (nonatomic) BOOL disableRecord; // default is NO
@property (nonatomic) BOOL disableGIF; // default is NO
#pragma mark -
@property (nonatomic, readonly) SJVideoPlayerFilmEditingStatus status;
- (void)pause; // `filmEditingControlView:statusChanged:` will be called.
- (void)resume; // `filmEditingControlView:statusChanged:` will be called.
- (void)cancel; // `filmEditingControlView:statusChanged:` will be called.
- (void)finalize; // `filmEditingControlView:statusChanged:` will be called.
@end
NS_ASSUME_NONNULL_END
| 38.820513 | 111 | 0.783355 |
4d901670519f58c1441c8e72063650acc05b8560 | 2,247 | c | C | Validation/pyFrame3DD-master/gcc-master/gcc/testsuite/c-c++-common/Wrestrict-2.c | djamal2727/Main-Bearing-Analytical-Model | 2f00c2219c71be0175c6f4f8f1d4cca231d97096 | [
"Apache-2.0"
] | null | null | null | Validation/pyFrame3DD-master/gcc-master/gcc/testsuite/c-c++-common/Wrestrict-2.c | djamal2727/Main-Bearing-Analytical-Model | 2f00c2219c71be0175c6f4f8f1d4cca231d97096 | [
"Apache-2.0"
] | null | null | null | Validation/pyFrame3DD-master/gcc-master/gcc/testsuite/c-c++-common/Wrestrict-2.c | djamal2727/Main-Bearing-Analytical-Model | 2f00c2219c71be0175c6f4f8f1d4cca231d97096 | [
"Apache-2.0"
] | null | null | null | /* PR 35503 - Warn about restricted pointers
Test to exercise that -Wrestrict warnings are issued for memory and
sring functions when they are declared in system headers (i.e., not
just when they are explicitly declared in the source file.)
Also verify that the warnings are issued even for calls where the
source of the aliasing violation is in a different function than
the restricted call.
{ dg-do compile }
{ dg-options "-O2 -Wrestrict" } */
#if __has_include (<stddef.h>)
# include <stddef.h>
#else
/* For cross-compilers. */
typedef __PTRDIFF_TYPE__ ptrdiff_t;
typedef __SIZE_TYPE__ size_t;
#endif
#if __has_include (<string.h>)
# include <string.h>
# undef memcpy
# undef strcat
# undef strcpy
# undef strncat
# undef strncpy
#else
extern void* memcpy (void*, const void*, size_t);
extern char* strcat (char*, const char*);
extern char* strcpy (char*, const char*);
extern char* strncat (char*, const char*, size_t);
extern char* strncpy (char*, const char*, size_t);
#endif
static void wrap_memcpy (void *d, const void *s, size_t n)
{
memcpy (d, s, n); /* { dg-warning "accessing 2 bytes at offsets 0 and 1 overlaps 1 byte at offset 1" "memcpy" } */
}
void call_memcpy (char *d)
{
const void *s = d + 1;
wrap_memcpy (d, s, 2);
}
static void wrap_strcat (char *d, const char *s)
{
strcat (d, s); /* { dg-warning "source argument is the same as destination" "strcat" } */
}
void call_strcat (char *d)
{
const char *s = d;
wrap_strcat (d, s);
}
static void wrap_strcpy (char *d, const char *s)
{
strcpy (d, s); /* { dg-warning "source argument is the same as destination" "strcpy" } */
}
void call_strcpy (char *d)
{
const char *s = d;
wrap_strcpy (d, s);
}
static void wrap_strncat (char *d, const char *s, size_t n)
{
strncat (d, s, n); /* { dg-warning "source argument is the same as destination" "strncat" } */
}
void call_strncat (char *d, size_t n)
{
const char *s = d;
wrap_strncat (d, s, n);
}
static void wrap_strncpy (char *d, const char *s, size_t n)
{
strncpy (d, s, n); /* { dg-warning "source argument is the same as destination" "strncpy" } */
}
void call_strncpy (char *d, size_t n)
{
const char *s = d;
wrap_strncpy (d, s, n);
}
| 24.16129 | 118 | 0.665777 |
4d90b11dd20b7eb25da6863974d5bd4125ff493d | 701 | h | C | srv/espaciocomplementario.h | stsewd/polideportivo | 420da8135b4529115fb5f5acae901c0b6cbca3f7 | [
"MIT"
] | null | null | null | srv/espaciocomplementario.h | stsewd/polideportivo | 420da8135b4529115fb5f5acae901c0b6cbca3f7 | [
"MIT"
] | null | null | null | srv/espaciocomplementario.h | stsewd/polideportivo | 420da8135b4529115fb5f5acae901c0b6cbca3f7 | [
"MIT"
] | null | null | null | #ifndef ESPACIOCOIMPLEMENTARIO_H
#define ESPACIOCOIMPLEMENTARIO_H
#include <string>
#include "espacio.h"
class TipoEspacioComplementario {
public:
std::string nombre;
TipoEspacioComplementario(){}
TipoEspacioComplementario(std::string nombre){
this->nombre = nombre;
}
};
class EspacioComplementario : public Espacio {
public:
TipoEspacioComplementario tipo;
EspacioComplementario();
EspacioComplementario(std::string nombre, std::string descripcion, double precioPorhora,
int capacidad, Estado estado, Horario horario, TipoEspacioComplementario TipoEspacio
);
~EspacioComplementario();
};
#endif // ESPACIOCOIMPLEMENTARIO_H
| 24.172414 | 110 | 0.733238 |
4d91f43231e49960d2e3ee355531f7084a06e54f | 1,227 | h | C | M5Bridge.h | biblepaywallet/M5Widgets | 1c8a5577c967d81212550e778313c09f02f6776c | [
"MIT"
] | 3 | 2019-05-27T05:31:35.000Z | 2020-07-23T15:54:16.000Z | M5Bridge.h | biblepaywallet/M5Widgets | 1c8a5577c967d81212550e778313c09f02f6776c | [
"MIT"
] | null | null | null | M5Bridge.h | biblepaywallet/M5Widgets | 1c8a5577c967d81212550e778313c09f02f6776c | [
"MIT"
] | 1 | 2021-05-13T08:51:38.000Z | 2021-05-13T08:51:38.000Z | #ifndef _M5BRIDGE_H_
#define _M5BRIDGE_H_
#include <Arduino.h>
#include <M5LoRa.h>
#include <SPI.h>
#define PIPE0 0
#define PIPE1 1
#define INPUTPIPE 0
#define OUTPUTPIPE 1
#define tSERIAL0 0
#define tSERIAL2 1
#define tLoRa 2
class M5Bridge {
public:
M5Bridge();
void setIOFunction(uint8_t, uint8_t);
void start(void);
void stop(void);
void run(void);
void setLoRaBand(uint32_t);
void setLoRaUUID(char *);
bool isActive(void);
bool serial0Inited(void);
bool serial2Inited(void);
bool loraInited(void);
void setSerial0Inited(bool);
void setSerial2Inited(bool);
void setLoRaInited(bool);
uint32_t getSerial0Speed(void);
uint32_t getSerial2Speed(void);
uint32_t getLoRaBand(void);
private:
bool _isActive, _serial0Inited, _serial2Inited, _loraInited;
void (*_streamInput0Function)(void);
void (*_streamInput1Function)(void);
void (*_streamOutput0Function)(void);
void (*_streamOutput1Function)(void);
void (*_streamInit0Function)(M5Bridge*);
void (*_streamInit1Function)(M5Bridge*);
uint32_t _BAND, _serialSourceCount, _serialDestinationCount;
uint32_t _Serial0Speed, _Serial2Speed;
char *_myLoRaUUID;
};
#endif
| 24.54 | 64 | 0.718826 |
4d93053737fadbb8a0a322a1c7fb5996e8b77b24 | 468,171 | h | C | SOFTWARE/c/TOMBSTONE_BMP.h | rob-ng15/PAWS | 12a0f6bbce641898fc0e3c6bb2a26ce9637dcf97 | [
"MIT"
] | 20 | 2021-11-17T08:24:44.000Z | 2022-02-23T11:15:55.000Z | SOFTWARE/c/TOMBSTONE_BMP.h | rob-ng15/PAWS | 12a0f6bbce641898fc0e3c6bb2a26ce9637dcf97 | [
"MIT"
] | null | null | null | SOFTWARE/c/TOMBSTONE_BMP.h | rob-ng15/PAWS | 12a0f6bbce641898fc0e3c6bb2a26ce9637dcf97 | [
"MIT"
] | 3 | 2021-12-02T15:20:53.000Z | 2022-01-07T22:01:46.000Z | unsigned char tombstonebitmap[] = {
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x2a,0x15,0x15,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x15,0x15,0x2a,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,
0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,
0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,
0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x2a,0x2a,
0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x2a,0x2a,0x15,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,
0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x2a,0x15,0x2a,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x15,0x2a,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x15,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x2a,0x2a,
0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x15,0x2a,0x2a,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x15,0x2a,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,
0x2a,0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,
0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x2a,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,
0x2a,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x2a,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x2a,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,
0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x15,
0x2a,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x2a,
0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x15,0x15,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,
0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,
0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x2a,0x2a,0x2a,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x14,0x29,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x29,0x28,0x29,0x19,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x19,0x28,0x28,0x28,0x29,0x19,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x14,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x14,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x19,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x14,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x19,
0x29,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x29,0x14,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x19,0x28,0x28,
0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x2a,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x29,0x28,0x28,0x28,
0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x14,0x29,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x29,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x2a,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,
0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x4,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x29,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x18,0x28,0x28,0x28,0x28,
0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x4,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x18,0x28,
0x28,0x18,0x29,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x18,0x28,0x18,0x18,0x28,
0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x4,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x29,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,
0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x18,0x18,0x28,0x28,
0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x4,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x18,0x18,0x18,0x28,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x2a,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,
0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x18,0x18,0x28,0x28,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x14,0x29,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x2a,0x2a,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x4,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x2a,0x2a,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x14,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,
0x0,0x0,0x0,0x14,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x18,0x18,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x14,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x4,0x29,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x4,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x29,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x19,0x28,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x19,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x18,0x28,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x19,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x4,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x18,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x14,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x18,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x4,0x4,0x4,0x4,0x4,0x4,0x4,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,
0x29,0x28,0x28,0x28,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x29,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x18,0x18,0x28,
0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x14,0x14,0x18,
0x19,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,
0x29,0x19,0x14,0x14,0x14,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x29,0x29,0x29,0x29,0x19,0x14,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x4,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,
0x28,0x28,0x28,0x28,0x28,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x14,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x14,0x19,0x29,0x29,0x29,0x28,0x28,0x28,
0x28,0x28,0x28,0x18,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x29,0x19,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x28,0x29,0x29,0x19,0x18,
0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x28,
0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x29,0x29,0x29,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x18,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x28,0x18,0x28,0x28,
0x29,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,
0x19,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x19,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x4,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x29,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x29,0x19,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x14,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x14,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x18,0x28,
0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x14,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x18,
0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x19,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x29,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x19,0x0,0x0,0x4,0x19,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x29,0x28,0x18,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x14,0x29,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x29,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x29,0x29,0x29,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x18,0x28,0x18,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x29,0x28,
0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,
0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x18,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x18,0x28,0x18,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x29,
0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x19,0x14,0x0,0x0,0x4,0x19,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
0x2a,0x2a,0x2a,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x29,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x18,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,
0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x29,0x29,0x29,0x29,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x14,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x29,0x28,0x28,0x18,
0x18,0x18,0x18,0x18,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x29,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x2a,0x2a,0x2a,0x2a,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x14,0x18,0x18,
0x19,0x19,0x29,0x29,0x29,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x18,0x18,
0x18,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x18,0x28,0x28,0x18,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x14,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,
0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x4,0x4,0x14,0x14,0x14,0x14,0x19,0x19,0x29,0x29,0x29,0x29,
0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x18,0x28,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x19,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,
0x18,0x18,0x18,0x28,0x28,0x28,0x29,0x29,0x29,0x29,0x19,0x19,0x18,0x14,0x14,0x14,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,
0x14,0x14,0x14,0x18,0x18,0x19,0x29,0x29,0x29,0x29,0x28,0x28,0x28,0x18,0x18,0x18,
0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x29,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x4,0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,
0x29,0x29,0x19,0x19,0x19,0x14,0x14,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x14,0x14,0x18,0x19,0x19,0x29,0x29,
0x29,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x28,0x28,0x28,0x28,0x28,
0x28,0x28,0x28,0x18,0x18,0x18,0x28,0x28,0x29,0x29,0x29,0x19,0x18,0x14,0x14,0x14,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,
0x14,0x14,0x14,0x18,0x19,0x29,0x29,0x29,0x28,0x28,0x18,0x18,0x18,0x28,0x28,0x28,
0x28,0x28,0x28,0x28,0x28,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x29,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x18,0x18,0x28,
0x28,0x28,0x29,0x29,0x29,0x19,0x18,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x14,0x18,0x19,0x29,0x29,0x29,0x28,0x28,
0x28,0x18,0x18,0x28,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x18,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x28,0x29,0x29,0x19,
0x18,0x14,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x10,0x10,0x14,0x10,0x10,0x10,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x14,0x14,0x18,
0x19,0x29,0x29,0x29,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x4,0x29,0x18,0x28,0x29,0x29,0x29,0x19,0x18,0x14,0x14,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x4,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x19,0x19,0x19,0x14,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x10,0x10,0x10,0x10,0x14,0x14,0x15,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x15,0x14,0x14,0x10,0x10,0x10,0x10,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,
0x10,0x10,0x10,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x10,0x10,0x10,
0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x15,0x2a,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x10,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x10,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x2a,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x15,
0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x2a,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x10,0x10,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x10,0x10,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x10,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x10,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x10,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,0x3f,
0x3f,0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,0x3f,
0x3f,0x3f,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,0x3f,0x3f,
0x3f,0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0x3f,
0x3f,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,
0x14,0x14,0x14,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,0x3f,
0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,
0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2a,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x15,
0x3f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,
0x3f,0x3f,0x2a,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x2a,0x3f,0x3f
};
| 78.512661 | 80 | 0.78356 |
4d95ef910adf1e21121c1b29df2088fc0cf9a8aa | 10,654 | h | C | private/shell/shlwapi/thunk.h | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | 11 | 2017-09-02T11:27:08.000Z | 2022-01-02T15:25:24.000Z | private/shell/shlwapi/thunk.h | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | null | null | null | private/shell/shlwapi/thunk.h | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | 14 | 2019-01-16T01:01:23.000Z | 2022-02-20T15:54:27.000Z |
BOOL
AnsiFromUnicode(
LPSTR * ppszAnsi,
LPCWSTR pwszWide, // NULL to clean up
LPSTR pszBuf,
int cchBuf);
#define RegSetValueExW RegSetValueExWrapW
#define CompareStringW CompareStringWrapW
#define GetFileAttributesW GetFileAttributesWrapW
#define GetFullPathNameW GetFullPathNameWrapW
#define SearchPathW SearchPathWrapW
#define GetWindowsDirectoryW GetWindowsDirectoryWrapW
#define GetSystemDirectoryW GetSystemDirectoryWrapW
#define GetEnvironmentVariableW GetEnvironmentVariableWrapW
//+---------------------------------------------------------------------------
//
// NEEDs
//
// All functions in unicwrap must be bracketed in NEED_<DLLNAME>_WRAPPER
// to ensure that wrappers are generated only on platforms that require them.
//
//----------------------------------------------------------------------------
// UNIX Quirk - The UNIX people tell me that they don't have
// kernel32 or any of that stuff. They recommend continuing
// to use all the wrappers on UNIX even though they might not
// be necessary. They're willing to live with the perf hit.
//
#if defined(_X86_) || defined(UNIX) // X86 platform - use full wrappers
// also use full wrappers on UNIX for safety
#define NEED_KERNEL32_WRAPPER
#define NEED_USER32_WRAPPER
#define NEED_GDI32_WRAPPER
#define NEED_ADVAPI32_WRAPPER
#define NEED_WINMM_WRAPPER
#define NEED_MPR_WRAPPER
#define NEED_VERSION_WRAPPER
#define NEED_SHELL32_WRAPPER
#define NEED_COMDLG32_WRAPPER
#else // other platform - don't need wrappers
#undef NEED_KERNEL32_WRAPPER
#undef NEED_USER32_WRAPPER
#undef NEED_GDI32_WRAPPER
#undef NEED_ADVAPI32_WRAPPER
#undef NEED_WINMM_WRAPPER
#undef NEED_MPR_WRAPPER
#undef NEED_VERSION_WRAPPER
#undef NEED_SHELL32_WRAPPER
#undef NEED_COMDLG32_WRAPPER
#endif
#define NEED_OLE32_WRAPPER
//
// UNIX is funky. If ANSI_SHELL32_ON_UNIX is defined, then shell32
// and comdlg32 need wrappers even though we thought we didn't need them.
//
#ifdef ANSI_SHELL32_ON_UNIX
#define NEED_SHELL32_WRAPPER
#define NEED_COMDLG32_WRAPPER
#endif
//+---------------------------------------------------------------------------
//
// Unwrapping
//
// Based on what we NEED, we disable selected wrappers so we can still
// build other parts of shlwapi in the unwrapped case.
//
//----------------------------------------------------------------------------
// These wrappers are to be always unwrapped.
//#define GetLongPathNameWrapW GetLongPathNameW
//#define GetLongPathNameWrapA GetLongPathNameA
#ifndef NEED_KERNEL32_WRAPPER
#define CreateDirectoryWrapW CreateDirectoryW
#define CreateEventWrapW CreateEventW
#define CreateFileWrapW CreateFileW
#define DeleteFileWrapW DeleteFileW
#define EnumResourceNamesWrapW EnumResourceNamesW
#define FindFirstFileWrapW FindFirstFileW
#define FindResourceWrapW FindResourceW
#define FormatMessageWrapW FormatMessageW
#define GetCurrentDirectoryWrapW GetCurrentDirectoryW
#undef GetFileAttributesW
#define GetFileAttributesWrapW GetFileAttributesW
#define GetLocaleInfoWrapW GetLocaleInfoW
#define GetModuleFileNameWrapW GetModuleFileNameW
#undef SearchPathW
#define SearchPathWrapW SearchPathW
#define GetModuleHandleWrapW GetModuleHandleW
#define SetFileAttributesWrapW SetFileAttributesW
#define GetNumberFormatWrapW GetNumberFormatW
#define FindNextFileWrapW FindNextFileW
#undef GetFullPathNameW
#define GetFullPathNameWrapW GetFullPathNameW
#define GetShortPathNameWrapW GetShortPathNameW
#define GetStringTypeExWrapW GetStringTypeExW
#define GetPrivateProfileIntWrapW GetPrivateProfileIntW
#define GetProfileStringWrapW GetProfileStringW
#define GetTempFileNameWrapW GetTempFileNameW
#define GetTempPathWrapW GetTempPathW
#undef GetWindowsDirectoryW
#define GetWindowsDirectoryWrapW GetWindowsDirectoryW
#undef GetSystemDirectoryW
#define GetSystemDirectoryWrapW GetSystemDirectoryW
#undef GetEnvironmentVariableW
#define GetEnvironmentVariableWrapW GetEnvironmentVariableW
#define LoadLibraryExWrapW LoadLibraryExW
#undef CompareStringW
#define CompareStringWrapW CompareStringW
#define CopyFileWrapW CopyFileW
#define MoveFileWrapW MoveFileW
#define OpenEventWrapW OpenEventW
#define OutputDebugStringWrapW OutputDebugStringW
#define RemoveDirectoryWrapW RemoveDirectoryW
#define SetCurrentDirectoryWrapW SetCurrentDirectoryW
#define CreateMutexWrapW CreateMutexW
#define ExpandEnvironmentStringsWrapW ExpandEnvironmentStringsW
#define CreateSemaphoreWrapW CreateSemaphoreW
#define IsBadStringPtrWrapW IsBadStringPtrW
#define LoadLibraryWrapW LoadLibraryW
#define GetTimeFormatWrapW GetTimeFormatW
#define GetDateFormatWrapW GetDateFormatW
#define WritePrivateProfileStringWrapW WritePrivateProfileStringW
#define GetPrivateProfileStringWrapW GetPrivateProfileStringW
#define WritePrivateProfileStructWrapW WritePrivateProfileStructW
#define GetPrivateProfileStructWrapW GetPrivateProfileStructW
#define CreateProcessWrapW CreateProcessW
#endif
#ifndef NEED_USER32_WRAPPER
#define CallWindowProcWrapW CallWindowProcW
#define CallMsgFilterWrapW CallMsgFilterW
#define CharLowerWrapW CharLowerW
#define CharLowerBuffWrapW CharLowerBuffW
#define CharNextWrapW CharNextW
#define CharPrevWrapW CharPrevW
#define CharToOemWrapW CharToOemW
#define CharUpperWrapW CharUpperW
#define CharUpperBuffWrapW CharUpperBuffW
#define CopyAcceleratorTableWrapW CopyAcceleratorTableW
#define CreateAcceleratorTableWrapW CreateAcceleratorTableW
#define CreateWindowExWrapW CreateWindowExW
#define DefWindowProcWrapW DefWindowProcW
#define DispatchMessageWrapW DispatchMessageW
#define DrawTextWrapW DrawTextW
#define FindWindowWrapW FindWindowW
#define FindWindowExWrapW FindWindowExW
#define GetClassInfoWrapW GetClassInfoW
#define GetClassLongWrapW GetClassLongW
#define GetClassNameWrapW GetClassNameW
#define GetClipboardFormatNameWrapW GetClipboardFormatNameW
#define GetDlgItemTextWrapW GetDlgItemTextW
#define GetMessageWrapW GetMessageW
#define MessageBoxWrapW MessageBoxW
#define GetPropWrapW GetPropW
#define GetWindowLongWrapW GetWindowLongW
#define GetWindowTextWrapW GetWindowTextW
#define GetWindowTextLengthWrapW GetWindowTextLengthW
#define IsDialogMessageWrapW IsDialogMessageW
#define LoadAcceleratorsWrapW LoadAcceleratorsW
#define LoadBitmapWrapW LoadBitmapW
#define LoadCursorWrapW LoadCursorW
#define LoadIconWrapW LoadIconW
#define LoadImageWrapW LoadImageW
#define LoadStringWrapW LoadStringW
#define MessageBoxIndirectWrapW MessageBoxIndirectW
#define MessageBoxIndirectWrapW MessageBoxIndirectW
#define ModifyMenuWrapW ModifyMenuW
#define OemToCharWrapW OemToCharW
#define PeekMessageWrapW PeekMessageW
#define PostMessageWrapW PostMessageW
#define PostThreadMessageWrapW PostThreadMessageW
#define RegisterClassWrapW RegisterClassW
#define RegisterClipboardFormatWrapW RegisterClipboardFormatW
#define RegisterWindowMessageWrapW RegisterWindowMessageW
#define RemovePropWrapW RemovePropW
#define SendMessageWrapW SendMessageW
#define SendDlgItemMessageWrapW SendDlgItemMessageW
#define SendMessageWrapW SendMessageW
#define SendMessageTimeoutWrapW SendMessageTimeoutW
#define SetDlgItemTextWrapW SetDlgItemTextW
#define SetPropWrapW SetPropW
#define SetWindowLongWrapW SetWindowLongW
#define SetWindowsHookExWrapW SetWindowsHookExW
#define SetWindowTextWrapW SetWindowTextW
#define SystemParametersInfoWrapW SystemParametersInfoW
#define TranslateAcceleratorWrapW TranslateAcceleratorW
#define UnregisterClassWrapW UnregisterClassW
#define VkKeyScanWrapW VkKeyScanW
#define WinHelpWrapW WinHelpW
#define wvsprintfWrapW wvsprintfW
#define DrawTextExWrapW DrawTextExW
#define RegisterClassExWrapW RegisterClassExW
#define GetClassInfoExWrapW GetClassInfoExW
#define DdeInitializeWrapW DdeInitializeW
#define DdeCreateStringHandleWrapW DdeCreateStringHandleW
#define DdeQueryStringWrapW DdeQueryStringW
#endif
#ifndef NEED_GDI32_WRAPPER
#define CreateDCWrapW CreateDCW
#define CreateICWrapW CreateICW
#define CreateFontIndirectWrapW CreateFontIndirectW
#define EnumFontFamiliesWrapW EnumFontFamiliesW
#define EnumFontFamiliesExWrapW EnumFontFamiliesExW
#define GetObjectWrapW GetObjectW
#define GetTextExtentPoint32WrapW GetTextExtentPoint32W
#define GetTextFaceWrapW GetTextFaceW
#define GetTextMetricsWrapW GetTextMetricsW
#define GetCharacterPlacementWrapW GetCharacterPlacementW
#define GetCharWidth32WrapW GetCharWidth32W
#define ExtTextOutWrapW ExtTextOutW
#define CreateFontWrapW CreateFontW
#define CreateMetaFileWrapW CreateMetaFileW
#define StartDocWrapW StartDocW
#endif
#ifndef NEED_ADVAPI32_WRAPPER
#define GetUserNameWrapW GetUserNameW
#define RegCreateKeyWrapW RegCreateKeyW
#define RegCreateKeyExWrapW RegCreateKeyExW
#define RegDeleteKeyWrapW RegDeleteKeyW
#define RegDeleteValueWrapW RegDeleteValueW
#define RegEnumKeyWrapW RegEnumKeyW
#define RegEnumKeyExWrapW RegEnumKeyExW
#define RegOpenKeyWrapW RegOpenKeyW
#define RegOpenKeyExWrapW RegOpenKeyExW
#define RegQueryInfoKeyWrapW RegQueryInfoKeyW
#define RegQueryValueWrapW RegQueryValueW
#define RegQueryValueExWrapW RegQueryValueExW
#define RegSetValueWrapW RegSetValueW
#undef RegSetValueExW
#define RegSetValueExWrapW RegSetValueExW
#define RegEnumValueWrapW RegEnumValueW
#endif
#ifndef NEED_WINMM_WRAPPER
#define PlaySoundWrapW PlaySoundW
#endif
#ifndef NEED_MPR_WRAPPER
#define WNetRestoreConnectionWrapW WNetRestoreConnectionW
#define WNetGetLastErrorWrapW WNetGetLastErrorW
#endif
#ifndef NEED_VERSION_WRAPPER
#define GetFileVersionInfoSizeWrapW GetFileVersionInfoSizeW
#define GetFileVersionInfoWrapW GetFileVersionInfoW
#define VerQueryValueWrapW VerQueryValueW
#endif
#ifndef NEED_SHELL32_WRAPPER
#define SHBrowseForFolderWrapW _SHBrowseForFolderW
#define SHGetPathFromIDListWrapW _SHGetPathFromIDListW
#define ShellExecuteExWrapW _ShellExecuteExW
#define SHFileOperationWrapW _SHFileOperationW
#define ExtractIconExWrapW _ExtractIconExW
#define SHGetFileInfoWrapW _SHGetFileInfoW
#define DragQueryFileWrapW _DragQueryFileW
#define SHDefExtractIconWrapW _SHDefExtractIconW
#define ExtractIconWrapW _ExtractIconW
#define SHChangeNotifyWrap _SHChangeNotify
#endif
#ifndef NEED_COMDLG32_WRAPPER
#define GetSaveFileNameWrapW GetSaveFileNameW
#endif
#ifndef NEED_OLE32_WRAPPER
#define CLSIDFromStringWrap CLSIDFromString
#define CLSIDFromProgIDWrap CLSIDFromProgID
#endif
| 37.514085 | 85 | 0.819129 |
4d975a2442039678ac049a60ed12ff37a600b61c | 224 | c | C | test/tricky3.c | nn4ip/pluto | 92ace2441b6b8d6b66d1bb7ef3e893df4ff23a4d | [
"MIT"
] | 183 | 2017-01-28T17:23:29.000Z | 2022-03-25T08:58:56.000Z | test/tricky3.c | nn4ip/pluto | 92ace2441b6b8d6b66d1bb7ef3e893df4ff23a4d | [
"MIT"
] | 70 | 2017-03-29T09:51:04.000Z | 2021-12-28T07:00:44.000Z | test/tricky3.c | nn4ip/pluto | 92ace2441b6b8d6b66d1bb7ef3e893df4ff23a4d | [
"MIT"
] | 57 | 2017-03-29T07:27:58.000Z | 2022-01-14T03:13:39.000Z | // CHECK: Output written
#pragma scop
for (p = 0; p < pointc; ++p) {
dist_min = 0;
for (k = 0; k < clusterc; ++k) {
dist = 0;
kmin = 0;
}
for (d = 0; d < dims; ++d) {
clusterv = 0;
}
}
#pragma endscop
| 14.933333 | 34 | 0.482143 |
4d98d34071e46d5358b59f0b435378a48f40e070 | 421 | c | C | src/kernel/global.c | JasonChuanTian/onix | f19b39e15059f45352781bd58bc1da83a6f966ac | [
"MIT"
] | 1 | 2022-03-23T10:27:50.000Z | 2022-03-23T10:27:50.000Z | src/kernel/global.c | JasonChuanTian/onix | f19b39e15059f45352781bd58bc1da83a6f966ac | [
"MIT"
] | null | null | null | src/kernel/global.c | JasonChuanTian/onix | f19b39e15059f45352781bd58bc1da83a6f966ac | [
"MIT"
] | null | null | null | #include <onix/global.h>
#include <onix/string.h>
#include <onix/debug.h>
descriptor_t gdt[GDT_SIZE]; // 内核全局描述符表
pointer_t gdt_ptr; // 内核全局描述符表指针
// 初始化内核全局描述符表
void gdt_init()
{
DEBUGK("init gdt!!!\n");
asm volatile("sgdt gdt_ptr");
memcpy(&gdt, (void *)gdt_ptr.base, gdt_ptr.limit + 1);
gdt_ptr.base = (u32)&gdt;
gdt_ptr.limit = sizeof(gdt) - 1;
asm volatile("lgdt gdt_ptr\n");
}
| 20.047619 | 58 | 0.63658 |
4d9e5c1e912f7599fc0e842599e33dc7f86be87f | 2,844 | h | C | stromx/runtime/Visualization.h | roteroktober/stromx | e081a35114f68a77e99a4761946b8b8c64eb591a | [
"Apache-2.0"
] | 11 | 2015-08-16T09:59:07.000Z | 2021-06-15T14:39:20.000Z | stromx/runtime/Visualization.h | roteroktober/stromx | e081a35114f68a77e99a4761946b8b8c64eb591a | [
"Apache-2.0"
] | null | null | null | stromx/runtime/Visualization.h | roteroktober/stromx | e081a35114f68a77e99a4761946b8b8c64eb591a | [
"Apache-2.0"
] | 8 | 2015-05-10T02:25:37.000Z | 2020-10-28T13:06:01.000Z | /*
* Copyright 2016 Matthias Fuchs
*
* 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 STROMX_RUNTIME_VISUALIZATION_H
#define STROMX_RUNTIME_VISUALIZATION_H
#include "stromx/runtime/Variant.h"
namespace stromx
{
namespace runtime
{
/** \brief Visualization variants. */
class STROMX_RUNTIME_API Visualization : public Variant
{
public:
/** Matrix data which represents points. */
const static VariantHandle POINT;
/** Matrix data which represents lines. */
const static VariantHandle LINE;
/** Matrix data which represents line segments. */
const static VariantHandle LINE_SEGMENT;
/** Matrix data which represents polygons. */
const static VariantHandle POLYGON;
/** Matrix data which represents polylines. */
const static VariantHandle POLYLINE;
/** Matrix data which represents axis aligned rectangles. */
const static VariantHandle RECTANGLE;
/** Matrix data which represents rotated rectangles. */
const static VariantHandle ROTATED_RECTANGLE;
/** Matrix data which represents circles. */
const static VariantHandle CIRCLE;
/** Matrix data which represents rotated ellipses. */
const static VariantHandle ELLIPSE;
/** Matrix data which represents histograms. */
const static VariantHandle HISTOGRAM;
virtual const std::string title() const;
virtual bool isVariant(const VariantInterface& variant) const;
private:
enum Types
{
POINT_ID = Variant::NUM_VARIANTS,
LINE_ID,
LINE_SEGMENT_ID,
POLYGON_ID,
POLYLINE_ID,
RECTANGLE_ID,
ROTATED_RECTANGLE_ID,
ELLIPSIS_ID,
CIRCLE_ID,
HISTOGRAM_ID
};
Visualization(const unsigned int id) : Variant(id)
{}
};
}
}
#endif // STROMX_RUNTIME_VISUALIZATION_H
| 33.458824 | 76 | 0.579114 |
4da6665533f8c317f45fb4e60f6353db493fc121 | 662 | c | C | benchmarks/Angha_small/extr_citrus_iso2022__ISO2022_sputwchar/extr_citrus_iso2022__ISO2022_sputwchar.c | ComputerSystemsLab/OptimizationCache | 9c30ae120673e57b772ea42e29e087f775aa9de9 | [
"Apache-2.0"
] | 2 | 2021-03-11T00:46:25.000Z | 2021-07-08T16:44:58.000Z | benchmarks/Angha_small/extr_citrus_iso2022__ISO2022_sputwchar/extr_citrus_iso2022__ISO2022_sputwchar.c | ComputerSystemsLab/OptimizationCache | 9c30ae120673e57b772ea42e29e087f775aa9de9 | [
"Apache-2.0"
] | null | null | null | benchmarks/Angha_small/extr_citrus_iso2022__ISO2022_sputwchar/extr_citrus_iso2022__ISO2022_sputwchar.c | ComputerSystemsLab/OptimizationCache | 9c30ae120673e57b772ea42e29e087f775aa9de9 | [
"Apache-2.0"
] | null | null | null | struct {
int b
} * q;
c, d, e, f, a, g, h, j, l, m, n, o;
char k;
r(s) {
char *p;
char b[f];
int i = 0;
if (t())
m = a;
else if (c & 128)
n = 8;
else
n = 0;
p = b;
if (h)
*p++ = h;
k = h;
if (o == 1 && c)
*p++ = 'n';
if (o == 3 && q->b) {
p++;
p++;
} else if (o == 1) {
++p;
p++;
} else if (o == 3 && d) {
p++;
p++;
} else if (o == 2 && e) {
p++;
*p++ = 'N';
} else if (o == 3) {
p++;
*p++ = 'O';
} else {
p++;
*p++ = 'N';
}
l = 8;
if (j)
l = 0;
switch (g)
case 8:
i = !0 ? u() ? 3 : 2 : 1;
while (i-- > 0)
*p = s >> i << 3 & 15 | l;
}
| 13.24 | 35 | 0.276435 |
4da9977ace804ced85f80ab501fcfabe3c561010 | 2,221 | h | C | RKBaseLibs/RKBaseLibs/Classes/Network/HPRequest+UploadFile.h | juzi888999/RKBaseLibs | decff22bcf07a86166059da384b29ff5616d7495 | [
"MIT"
] | 1 | 2019-11-09T11:06:50.000Z | 2019-11-09T11:06:50.000Z | RKBaseLibs/RKBaseLibs/Classes/Network/HPRequest+UploadFile.h | juzi888999/RKBaseLibs | decff22bcf07a86166059da384b29ff5616d7495 | [
"MIT"
] | null | null | null | RKBaseLibs/RKBaseLibs/Classes/Network/HPRequest+UploadFile.h | juzi888999/RKBaseLibs | decff22bcf07a86166059da384b29ff5616d7495 | [
"MIT"
] | null | null | null | //
// HPRequest+UploadFile.h
// RKBaseLibs
//
// Created by rk on 16/6/7.
// Copyright © 2016年 haixiaedu. All rights reserved.
//
#import "HPRequest.h"
/**
* 上传状态
*/
typedef NS_ENUM(NSInteger, HPUploadState) {
HPUploadStateProgress,
HPUploadStateFinished,
HPUploadStateFailed,
};
/**
* 上传文件类型
*/
typedef NS_ENUM(NSUInteger, HPUploadFileType) {
/**
* 图片 mimeType: image/jpeg
*/
HPUploadFileTypeImage = 1,
/**
* 语音 mimeType: audio/mpeg3
*/
HPUploadFileTypeSound,
/**
* 附件 mimeType: application/octet-stream
*/
HPUploadFileTypeAttach,
};
/**
* 上传模块类型（用户区分上传路径）
*/
typedef NS_ENUM(NSInteger, HPUpLoadType) {
HPUpLoadTypeNone = -1,
//...
};
@interface HPUploadFileRequest : HPBodyRequest
@property (assign,nonatomic) HPUpLoadType uploadType;
@property (assign,nonatomic) HPUploadFileType fileType;
@property (strong,nonatomic) NSURL * localUrl;
@property (strong,nonatomic) NSString * paramName;
@end
@interface HPUploadFileEntity : HPEntity
@property (strong,nonatomic)NSString *size;// 573.11K,
@property (strong,nonatomic)NSString *id;// f1f425e7b43645e29f0b2696a120b463,
@property (strong,nonatomic)NSString *ext;// jpg,
@property (strong,nonatomic)NSString *name;// C35E8D45-05EF-4C04-A44B-E924072F749E-1489-00000F547F68CCD1.jpg,
@property (strong,nonatomic)NSString *url;// upload/homework/image/20160612/20160612144549-2506939.jpg
@property (assign,nonatomic,readonly)BOOL uploaded;
+ (NSString *)jsonArrayWithObjectArray:(NSArray <HPUploadFileEntity *>*)jsonArray;
@end
@interface NetworkClient (UploadFile)
- (AFHTTPRequestOperation *)uploadFileWithFileType:(HPUploadFileType)fileType uploadType:(HPUpLoadType)uploadType filePath:(NSString *)filePath;
- (AFHTTPRequestOperation *)uploadFileWithRequest:(HPUploadFileRequest *)request
path:(NSString *)path
progress:(void (^)(NSUInteger bytesWritten, long long totalBytesWritten, long long totalBytesExpectedToWrite))uploadProgress
success:(HPSuccess)success
failure:(HPFailure)failure;
@end
| 29.223684 | 165 | 0.686628 |
4daa35e15139d94185db48ebe950b549f07ce856 | 71,754 | c | C | src/bcmfp/handler/util/bcmfp_lt_group.c | lguohan/SDKLT | 37acbc80e162bdfc7f7d5fb0833178f4f7a8afd4 | [
"Apache-2.0"
] | 2 | 2018-01-31T07:21:32.000Z | 2018-01-31T07:21:49.000Z | src/bcmfp/handler/util/bcmfp_lt_group.c | lguohan/SDKLT | 37acbc80e162bdfc7f7d5fb0833178f4f7a8afd4 | [
"Apache-2.0"
] | null | null | null | src/bcmfp/handler/util/bcmfp_lt_group.c | lguohan/SDKLT | 37acbc80e162bdfc7f7d5fb0833178f4f7a8afd4 | [
"Apache-2.0"
] | 3 | 2021-07-13T08:29:18.000Z | 2022-01-14T06:14:56.000Z | /*! \file bcmfp_lt_group.c
*
* APIs for LT group interface
*
* This file contains function definitions for group LT template.
*/
/*
* Copyright: (c) 2018 Broadcom. All Rights Reserved. "Broadcom" refers to
* Broadcom Limited and/or its subsidiaries.
*
* Broadcom Switch Software License
*
* This license governs the use of the accompanying Broadcom software. Your
* use of the software indicates your acceptance of the terms and conditions
* of this license. If you do not agree to the terms and conditions of this
* license, do not use the software.
* 1. Definitions
* "Licensor" means any person or entity that distributes its Work.
* "Software" means the original work of authorship made available under
* this license.
* "Work" means the Software and any additions to or derivative works of
* the Software that are made available under this license.
* The terms "reproduce," "reproduction," "derivative works," and
* "distribution" have the meaning as provided under U.S. copyright law.
* Works, including the Software, are "made available" under this license
* by including in or with the Work either (a) a copyright notice
* referencing the applicability of this license to the Work, or (b) a copy
* of this license.
* 2. Grant of Copyright License
* Subject to the terms and conditions of this license, each Licensor
* grants to you a perpetual, worldwide, non-exclusive, and royalty-free
* copyright license to reproduce, prepare derivative works of, publicly
* display, publicly perform, sublicense and distribute its Work and any
* resulting derivative works in any form.
* 3. Grant of Patent License
* Subject to the terms and conditions of this license, each Licensor
* grants to you a perpetual, worldwide, non-exclusive, and royalty-free
* patent license to make, have made, use, offer to sell, sell, import, and
* otherwise transfer its Work, in whole or in part. This patent license
* applies only to the patent claims licensable by Licensor that would be
* infringed by Licensor's Work (or portion thereof) individually and
* excluding any combinations with any other materials or technology.
* If you institute patent litigation against any Licensor (including a
* cross-claim or counterclaim in a lawsuit) to enforce any patents that
* you allege are infringed by any Work, then your patent license from such
* Licensor to the Work shall terminate as of the date such litigation is
* filed.
* 4. Redistribution
* You may reproduce or distribute the Work only if (a) you do so under
* this License, (b) you include a complete copy of this License with your
* distribution, and (c) you retain without modification any copyright,
* patent, trademark, or attribution notices that are present in the Work.
* 5. Derivative Works
* You may specify that additional or different terms apply to the use,
* reproduction, and distribution of your derivative works of the Work
* ("Your Terms") only if (a) Your Terms provide that the limitations of
* Section 7 apply to your derivative works, and (b) you identify the
* specific derivative works that are subject to Your Terms.
* Notwithstanding Your Terms, this license (including the redistribution
* requirements in Section 4) will continue to apply to the Work itself.
* 6. Trademarks
* This license does not grant any rights to use any Licensor's or its
* affiliates' names, logos, or trademarks, except as necessary to
* reproduce the notices described in this license.
* 7. Limitations
* Platform. The Work and any derivative works thereof may only be used, or
* intended for use, with a Broadcom switch integrated circuit.
* No Reverse Engineering. You will not use the Work to disassemble,
* reverse engineer, decompile, or attempt to ascertain the underlying
* technology of a Broadcom switch integrated circuit.
* 8. Termination
* If you violate any term of this license, then your rights under this
* license (including the license grants of Sections 2 and 3) will
* terminate immediately.
* 9. Disclaimer of Warranty
* THE WORK IS PROVIDED "AS IS" WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR
* NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER
* THIS LICENSE. SOME STATES' CONSUMER LAWS DO NOT ALLOW EXCLUSION OF AN
* IMPLIED WARRANTY, SO THIS DISCLAIMER MAY NOT APPLY TO YOU.
* 10. Limitation of Liability
* EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL
* THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE
* SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
* INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
* OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK
* (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION,
* LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER
* COMMERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGES.
*/
/*******************************************************************************
Includes
*/
#include <shr/shr_debug.h>
#include <bcmfp/bcmfp_lt_util.h>
#include <bcmfp/bcmfp_lt_group.h>
#include <bcmfp/bcmfp_lt_policy.h>
#include <bcmfp/map/bcmfp_lt_group_map.h>
#include <bcmfp/map/bcmfp_lt_src_class_mode_map.h>
#include <bcmfp/map/bcmfp_lt_presel_entry_map.h>
#include <bcmfp/bcmfp_lt_inmem.h>
#include <bcmimm/bcmimm_basic.h>
#define BSL_LOG_MODULE BSL_LS_BCMFP_COMMON
/*******************************************************************************
Static functions
*/
static int
bcmfp_lt_group_qual_bitmap_add(int unit,
bcmfp_qual_t qual,
uint32_t *field_val,
bcmfp_lt_group_config_t *group_config)
{
bcmfp_qual_bitmap_t *node = NULL;
SHR_FUNC_ENTER(unit);
BCMFP_ALLOC(node, sizeof(bcmfp_qual_bitmap_t), "qual bitmap");
node->qual = qual;
sal_memcpy(node->bitmap, field_val, sizeof(uint32_t) * BCMFP_MAX_WSIZE);
node->next = NULL;
/* Add to qual bitmap list */
if (group_config->qual_bitmap == NULL) {
group_config->qual_bitmap = node;
} else {
node->next = group_config->qual_bitmap;
group_config->qual_bitmap = node;
}
exit:
if (SHR_FUNC_ERR()) {
SHR_FREE(node);
}
SHR_FUNC_EXIT();
}
static int
bcmfp_lt_group_qual_add(int unit,
bcmfp_lt_field_info_t *field_info,
bcmfp_lt_group_qual_map_t *group_qual_map,
uint32_t *field_val,
bcmfp_lt_group_config_t *group_config)
{
bool is_partial = FALSE;
uint32_t i = 0;
uint32_t idx = 0;
uint32_t width = 0;
uint32_t mask = 0;
uint32_t all_ones = 0xFFFFFFFF;
SHR_FUNC_ENTER(unit);
/* Add to Qset */
if (group_qual_map->qual == BCMFP_QUAL_SRC_IP6) {
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_SRC_IP6_UPPER);
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_SRC_IP6_LOWER);
} else if (group_qual_map->qual == BCMFP_QUAL_DST_IP6) {
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_DST_IP6_UPPER);
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_DST_IP6_LOWER);
} else if (group_qual_map->qual == BCMFP_QUAL_DST_IP6) {
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_DST_IP6_UPPER);
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_DST_IP6_LOWER);
} else if (group_qual_map->qual == BCMFP_QUAL_INNER_SRC_IP6) {
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_INNER_SRC_IP6_UPPER);
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_INNER_SRC_IP6_LOWER);
} else if (group_qual_map->qual == BCMFP_QUAL_INNER_DST_IP6) {
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_INNER_DST_IP6_UPPER);
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_INNER_DST_IP6_LOWER);
} else if (group_qual_map->qual == BCMFP_QUAL_INNER_DST_IP6) {
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_INNER_DST_IP6_UPPER);
BCMFP_QSET_ADD(group_config->qset, BCMFP_QUAL_INNER_DST_IP6_LOWER);
} else {
BCMFP_QSET_ADD(group_config->qset, group_qual_map->qual);
}
if (field_info->is_symbol) {
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
}
/* Check for partial bitmap */
width = field_info->width;
idx = (width - 1) >> 5;
width = width % 32;
/* Checking first to second last words. */
for (i = 0; i < idx; i++) {
if ((field_val[i] & all_ones) != all_ones) {
is_partial = TRUE;
break;
}
}
/* Checking last word. */
if (is_partial == FALSE) {
if (width == 0) {
mask = all_ones;
} else {
mask = ((1 << width) - 1);
}
/* Last remaining parts is at index=idx. */
if ((field_val[idx] & mask) != mask) {
is_partial = TRUE;
}
}
/* Making Partial bitmap */
if (is_partial) {
BCMFP_QSET_ADD(group_config->partial_qset, group_qual_map->qual);
SHR_IF_ERR_EXIT(bcmfp_lt_group_qual_bitmap_add(unit,
group_qual_map->qual, field_val, group_config));
}
exit:
SHR_FUNC_EXIT();
}
static int
bcmfp_lt_group_action_add(int unit,
bcmfp_lt_group_qual_map_t *group_qual_map,
bcmfp_lt_group_config_t *group_config)
{
SHR_FUNC_ENTER(unit);
/* Add to Aset */
BCMFP_ASET_ADD(group_config->aset, group_qual_map->action);
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
SHR_FUNC_EXIT();
}
int
bcmfp_lt_group_validate(int unit,
bcmltd_sid_t sid,
bcmimm_entry_event_t action,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
bool has_mode_auto = FALSE;
bool mode_auto = FALSE;
bool has_mode = FALSE;
uint32_t presel_id = 0;
uint32_t mode = 0;
uint32_t i = 0;
uint32_t group_id = 0;
uint64_t key_val = 0;
uint64_t data_val = 0;
uint32_t fid = 0;
bcmfp_lt_info_t *lt_info = NULL;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_lt_presel_entry_sp_fids_t *presel_fid_list = NULL;
bcmltd_fields_t grp_imm_fields = {0};
bcmltd_fields_t presel_imm_fields = {0};
bcmltd_fields_t input = {0};
uint32_t grp_out_fields = 0;
uint32_t presel_out_fields = 0;
bcmltd_fields_t *in = NULL;
bcmltd_sid_t group_ltid = 0;
bcmltd_field_t presel_set[BCMFP_GROUP_MAX_PRESEL];
bcmltd_field_t *presel_fields[BCMFP_GROUP_MAX_PRESEL];
bcmltd_fields_t multi_fields;
bcmltd_field_t inmem_presel_set[BCMFP_GROUP_MAX_PRESEL];
bcmltd_field_t *inmem_presel_fields[BCMFP_GROUP_MAX_PRESEL];
bcmltd_fields_t inmem_multi_fields = {0};
SHR_FUNC_ENTER(unit);
if (action == BCMIMM_ENTRY_LOOKUP) {
/* Ignore other fields */
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
}
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit, sid, &grp_imm_fields));
input.count = 0;
input.field = NULL;
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit,
sid,
&input));
grp_out_fields = input.count;
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID) {
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit,
fid_list->presel_lt_sid,
&presel_imm_fields));
presel_out_fields = presel_imm_fields.count;
}
/*Get the key value from the key array */
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
in = &input;
/* Automode not valid for EFP */
if (lt_info->flags & BCMFP_LT_FLAGS_FIXED_KEY_GRP) {
BCMFP_RET_VAL_ASSIGN(bcmfp_fixed_key_group_validate(unit,
action,
lt_info,
key,
data));
if (SHR_FUNC_VAL_IS(SHR_E_CONFIG)) {
SHR_RETURN_VAL_EXIT(SHR_E_CONFIG);
}
} else {
fid = fid_list->mode_auto_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
has_mode_auto = TRUE;
BCMFP_UINT64_TO_BOOL(data_val, mode_auto);
}
fid = fid_list->mode_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, mode);
has_mode = TRUE;
}
}
if (action == BCMIMM_ENTRY_INSERT) {
/* if auto_mode is not present or FALSE, Mode Must be present */
if (!(lt_info->flags & BCMFP_LT_FLAGS_FIXED_KEY_GRP)) {
if ((!(has_mode_auto && mode_auto)) &&
((has_mode == FALSE) || (mode == 0))) {
SHR_RETURN_VAL_EXIT(SHR_E_PARAM);
}
}
} else { /* action == BCMIMM_ENTRY_UPDATE */
/* Validate Group Mode */
if (!(lt_info->flags & BCMFP_LT_FLAGS_FIXED_KEY_GRP)) {
if ((has_mode_auto) || (has_mode)) {
if ((!(has_mode_auto && mode_auto)) &&
((has_mode == FALSE) || (mode == 0))) {
SHR_RETURN_VAL_EXIT(SHR_E_PARAM);
}
}
}
}
/*To restrict two VFP groups having same priority*/
if (lt_info->flags & BCMFP_LT_FLAGS_UNIQUE_GRP_PRI) {
BCMFP_RET_VAL_ASSIGN(bcmfp_group_priority_validate(unit,
action,
lt_info,
key,
data));
if (SHR_FUNC_VAL_IS(SHR_E_CONFIG)) {
SHR_RETURN_VAL_EXIT(SHR_E_CONFIG);
}
}
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID) {
/* Verifying Presels. */
fid = fid_list->presel_ids_set_fid;
/* Get group info from in memory to check for duplicates */
if (action == BCMIMM_ENTRY_UPDATE) {
group_ltid = sid;
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = group_id;
input.count = 1;
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
group_ltid,
in,
&grp_imm_fields));
for (i = 0; i < BCMFP_GROUP_MAX_PRESEL; i++) {
inmem_presel_fields[i] = &inmem_presel_set[i];
}
inmem_multi_fields.count = BCMFP_GROUP_MAX_PRESEL;
inmem_multi_fields.field = inmem_presel_fields;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_multi_data_get(unit,
sid, fid, &grp_imm_fields, &inmem_multi_fields));
/* In case Presel was not set earlier */
if (!SHR_FUNC_VAL_IS(SHR_E_NONE)) {
inmem_multi_fields.count = 0;
}
}
for (i = 0; i < BCMFP_GROUP_MAX_PRESEL; i++) {
presel_fields[i] = &presel_set[i];
}
multi_fields.count = BCMFP_GROUP_MAX_PRESEL;
multi_fields.field = presel_fields;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_multi_data_get_from_data_array(unit,
fid, data, &multi_fields));
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, fid_list->presel_lt_sid, <_info));
presel_fid_list = (bcmfp_lt_presel_entry_sp_fids_t*) lt_info->sp_fids;
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
/* Fail if duplicate Presel Entry in List is present */
SHR_IF_ERR_EXIT
(bcmfp_lt_field_duplicate_check(unit, &multi_fields,
&inmem_multi_fields));
for (i = 0; i < multi_fields.count; i++) {
if (presel_set[i].data != 0) {
BCMFP_UINT64_TO_UINT32(presel_set[i].data, presel_id);
input.field[0]->id = presel_fid_list->presel_id_fid;
input.field[0]->data = presel_id;
input.count = 1;
/* Reset the out fields count */
presel_imm_fields.count = presel_out_fields;
BCMFP_RET_VAL_ASSIGN(bcmimm_entry_lookup(unit,
fid_list->presel_lt_sid,
in,
&presel_imm_fields));
if (!SHR_FUNC_VAL_IS(SHR_E_NONE)) {
SHR_RETURN_VAL_EXIT(SHR_E_PARAM);
}
}
}
}
}
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, grp_out_fields,
&grp_imm_fields);
if (lt_info) {
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID) {
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, presel_out_fields,
&presel_imm_fields);
}
}
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, grp_out_fields, &input);
SHR_FUNC_EXIT();
}
int
bcmfp_lt_group_config_free(int unit,
bcmfp_lt_group_config_t *group_config)
{
bcmfp_qual_bitmap_t *temp_ptr = NULL;
SHR_FUNC_ENTER(unit);
if (group_config->qual_bitmap != NULL) {
temp_ptr = group_config->qual_bitmap;
while(temp_ptr != NULL) {
temp_ptr = temp_ptr->next;
SHR_FREE(group_config->qual_bitmap);
group_config->qual_bitmap = temp_ptr;
}
}
group_config->qual_bitmap = NULL;
SHR_FUNC_EXIT();
}
int
bcmfp_lt_ingress_grp_config_insert(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t i = 0;
uint64_t data_val = 0;
uint32_t src_class_mask = 0;
uint32_t fid = 0;
uint32_t presel_id = 0;
uint32_t in_pipe_id = 0;
bool increment_flag = FALSE;
bcmltd_fields_t imm_fields = {0};
bcmltd_fields_t input = {0};
uint32_t out_fields = 0;
bcmltd_fields_t *in = NULL;
bcmfp_stage_id_t stage_id;
bcmfp_stage_oper_mode_t oper_mode;
bcmltd_field_t presel_set[BCMFP_GROUP_MAX_PRESEL];
bcmltd_field_t *presel_fields[BCMFP_GROUP_MAX_PRESEL];
bcmltd_fields_t multi_fields;
bcmfp_lt_info_t *lt_info = NULL;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_lt_presel_entry_sp_fids_t *presel_fid_list = NULL;
bcmfp_lt_src_class_mode_sp_fids_t *src_class_mode_fid_list = NULL;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
stage_id = lt_info->stage_id;
input.count = 0;
input.field = NULL;
in = &input;
BCMFP_ALLOC(input.field, sizeof(bcmltd_field_t *),
"bcmltd field array");
BCMFP_ALLOC(input.field[0], sizeof (bcmltd_field_t), "field");
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID) {
SHR_IF_ERR_EXIT(bcmfp_lt_info_get_by_type(unit,
stage_id,
BCMFP_LT_TYPE_PRESEL_ENTRY,
<_info));
imm_fields.count = 0;
imm_fields.field = NULL;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, lt_info->ltid, &imm_fields));
out_fields = imm_fields.count;
fid = fid_list->presel_ids_set_fid;
for (i = 0; i < BCMFP_GROUP_MAX_PRESEL; i++) {
presel_fields[i] = &presel_set[i];
}
multi_fields.count = BCMFP_GROUP_MAX_PRESEL;
multi_fields.field = presel_fields;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_multi_data_get_from_data_array(unit,
fid,
data,
&multi_fields));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
for (i = 0; i < multi_fields.count; i++) {
if (presel_set[i].data == 0) {
continue;
}
BCMFP_UINT64_TO_UINT32(presel_set[i].data, presel_id);
/* Lock the presel template*/
presel_fid_list = (bcmfp_lt_presel_entry_sp_fids_t*) lt_info->sp_fids;
input.field[0]->id = presel_fid_list->presel_id_fid;
input.field[0]->data = presel_id;
input.count = 1;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
/* Check if the Mixed Src Class Mask field is present in the
* presel entry and is non zero*/
input.field[0]->id = presel_fid_list->presel_id_fid;
input.field[0]->data = presel_id;
input.count = 1;
imm_fields.count = out_fields;
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
lt_info->ltid,
in,
&imm_fields));
fid = fid_list->presel_lt_mixed_src_class_mask_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, src_class_mask);
}
if((src_class_mask != 0) &&
(increment_flag == FALSE)) {
SHR_IF_ERR_EXIT
(bcmfp_stage_oper_mode_get(unit, stage_id, &oper_mode));
SHR_IF_ERR_EXIT(bcmfp_lt_info_get_by_type(unit,
stage_id,
BCMFP_LT_SRC_CLASS_MODE,
<_info));
src_class_mode_fid_list = (bcmfp_lt_src_class_mode_sp_fids_t*) lt_info->sp_fids;
input.field[0]->id = src_class_mode_fid_list->pipe_id_fid;
if (oper_mode == BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
fid = fid_list->pipe_fid;
SHR_IF_ERR_EXIT
(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
BCMFP_UINT64_TO_UINT32(data_val, in_pipe_id);
/*Lock the src_class LT entry with index pipe id*/
input.field[0]->data = in_pipe_id;
input.count = 1;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
} else {
/*Lock the src_class LT entry with index 0 in global mode*/
input.field[0]->data = 0;
input.count = 1;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
}
increment_flag = TRUE;
}
}
}
}
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
if (in) {
SHR_FREE(in->field[0]);
SHR_FREE(in->field);
}
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &imm_fields);
SHR_FUNC_EXIT();
}
int
bcmfp_lt_ingress_grp_config_update(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t key_fid = 0;
uint32_t offset = 0;
uint32_t i = 0;
uint32_t j = 0;
uint32_t fid = 0;
uint32_t gid = 0;
uint32_t idx = 0;
uint32_t src_class_mask = 0;
uint32_t last_index = 0;
uint64_t data_val = 0;
uint64_t key_val = 0;
uint32_t presel_id = 0;
uint32_t in_pipe_id = 0;
bool increment_flag = FALSE;
bcmltd_sid_t group_ltid;
bcmfp_lt_info_t *lt_info = NULL;
bcmfp_lt_field_info_t *field_info = NULL;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_lt_presel_entry_sp_fids_t *presel_fid_list = NULL;
bcmfp_lt_src_class_mode_sp_fids_t *src_class_mode_fid_list = NULL;
bcmltd_fields_t imm_fields = {0};
bcmltd_fields_t input = {0};
uint32_t out_fields = 0;
uint16_t add_count = 0;
bcmltd_fields_t *in = NULL;
bcmfp_stage_id_t stage_id;
bcmfp_stage_oper_mode_t oper_mode;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
stage_id = lt_info->stage_id;
key_fid = fid_list->group_id_fid;
group_ltid = sid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
key_fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, gid);
imm_fields.count = 0;
imm_fields.field = NULL;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &imm_fields));
out_fields = imm_fields.count;
input.count = 0;
input.field = NULL;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &input));
in = &input;
input.field[0]->id = key_fid;
input.field[0]->data = gid;
input.count = 1;
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
sid,
in,
&imm_fields));
SHR_IF_ERR_EXIT(bcmfp_lt_info_get_by_type(unit,
stage_id,
BCMFP_LT_TYPE_PRESEL_ENTRY,
<_info));
presel_fid_list = (bcmfp_lt_presel_entry_sp_fids_t*) lt_info->sp_fids;
input.field[0]->id = presel_fid_list->presel_id_fid;
input.count = 1;
do {
fid = data->id;
idx = data->idx;
for (j = 0; j < imm_fields.count; j++) {
if ((imm_fields.field[j]->id == fid) &&
(imm_fields.field[j]->idx == idx)) {
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID &&
fid == fid_list->presel_ids_set_fid) {
/* Decrement ref count for old id */
if (imm_fields.field[j]->data) {
BCMFP_UINT64_TO_UINT32(imm_fields.field[j]->data,
presel_id);
input.field[0]->data = presel_id;
SHR_IF_ERR_EXIT
(bcmimm_entry_unlock(unit, lt_info->ltid, in));
}
/* Increment ref count for new id */
if (in->field[i]->data) {
BCMFP_UINT64_TO_UINT32(in->field[i]->data, presel_id);
input.field[0]->data = presel_id;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
}
}
imm_fields.field[j]->data = in->field[i]->data;
break;
}
}
if (j == imm_fields.count) {
/* Field not found in imm_fields. Add it */
last_index = imm_fields.count;
SHR_IF_ERR_EXIT
(bcmfp_lt_field_add(unit, group_ltid, fid, out_fields, &imm_fields));
SHR_IF_ERR_EXIT
(bcmfp_lt_field_info_get(unit, fid, lt_info, &field_info));
/* Set Data to newly added field */
if (field_info->is_array) {
imm_fields.field[last_index]->idx = in->field[i]->idx;
imm_fields.field[last_index]->data = in->field[i]->data;
} else {
imm_fields.field[last_index + idx]->data = in->field[i]->data;
}
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID &&
fid == fid_list->presel_ids_set_fid) {
if (in->field[i]->data == 0) {
continue;
}
/* Increment ref count for new id */
BCMFP_UINT64_TO_UINT32(in->field[i]->data, presel_id);
input.field[0]->data = presel_id;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
/* Check if the presel entry has Mixed Src Class Qualifier. */
fid = fid_list->presel_lt_mixed_src_class_mask_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, src_class_mask);
}
if((src_class_mask != 0) &&
(increment_flag == FALSE)) {
/* Increment the SRC_CLASS_MODE REF_COUNT by one*/
SHR_IF_ERR_EXIT
(bcmfp_stage_oper_mode_get(unit, stage_id, &oper_mode));
SHR_IF_ERR_EXIT(bcmfp_lt_info_get_by_type(unit,
stage_id,
BCMFP_LT_SRC_CLASS_MODE,
<_info));
src_class_mode_fid_list = (bcmfp_lt_src_class_mode_sp_fids_t*) lt_info->sp_fids;
input.field[0]->id = src_class_mode_fid_list->pipe_id_fid;
if (oper_mode == BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
fid = fid_list->pipe_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_data_get(unit,
fid,
in,
&data_val));
BCMFP_UINT64_TO_UINT32(data_val, in_pipe_id);
input.field[0]->data = in_pipe_id;
input.count = 1;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
} else {
/* Update REF_COUNT for pipe=0 in global mode */
input.field[0]->data = 0;
input.count = 1;
SHR_IF_ERR_EXIT
(bcmimm_entry_lock(unit, lt_info->ltid, in));
}
increment_flag = TRUE;
}
}
}
data = data->next;
} while (data != NULL);
/* Reset the Group mode_oper to NONE on update*/
in = &input;
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = gid;
input.count = 1;
imm_fields.count = out_fields;
SHR_IF_ERR_EXIT(
bcmimm_entry_lookup(unit,
group_ltid,
in,
&imm_fields));
fid = fid_list->mode_oper_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
add_count = 1;
}
else {
add_count = 2;
}
/*Update the in with KEY*/
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = gid;
input.field[1]->id = fid;
/* Reset the mode_oper to 0*/
input.field[1]->data = 0;
input.count = imm_fields.count + add_count;
if (in != NULL) {
for (offset = 2; offset < input.count; offset++) {
input.field[offset]->id = imm_fields.field[offset - add_count]->id;
input.field[offset]->idx = imm_fields.field[offset - add_count]->idx;
input.field[offset]->data = imm_fields.field[offset - add_count]->data;
}
}
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &imm_fields);
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &input);
SHR_FUNC_EXIT();
}
int
bcmfp_lt_ingress_grp_config_delete(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t fid = 0;
uint32_t i = 0;
uint32_t presel_id = 0;
uint32_t group_id = 0;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_lt_presel_entry_sp_fids_t *presel_fid_list = NULL;
bcmfp_lt_info_t *lt_info = NULL;
bcmltd_fields_t input = {0};
bcmltd_fields_t *in = NULL;
uint32_t out_fields = 0;
uint64_t key_val = 0;
bcmfp_stage_id_t stage_id = 0;
bcmltd_fields_t imm_fields = {0};
bcmltd_fields_t multi_fields;
bcmltd_field_t presel_set[BCMFP_GROUP_MAX_PRESEL];
bcmltd_field_t *presel_fields[BCMFP_GROUP_MAX_PRESEL];
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
stage_id = lt_info->stage_id;
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit, sid, &imm_fields));
out_fields = imm_fields.count;
input.count = 0;
input.field = NULL;
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit, sid, &input));
/*Get the key value from the key array */
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
in = &input;
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = group_id;
input.count = 1;
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
sid,
in,
&imm_fields));
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID) {
fid = fid_list->presel_ids_set_fid;
/* Increment for Presel Entry */
for (i = 0; i < BCMFP_GROUP_MAX_PRESEL; i++) {
presel_fields[i] = &presel_set[i];
}
multi_fields.count = BCMFP_GROUP_MAX_PRESEL;
multi_fields.field = presel_fields;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_multi_data_get(unit,
sid,
fid,
&imm_fields,
&multi_fields));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
for (i = 0; i < multi_fields.count; i++) {
BCMFP_UINT64_TO_UINT32(presel_set[i].data, presel_id);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get_by_type(unit,
stage_id,
BCMFP_LT_TYPE_PRESEL_ENTRY,
<_info));
presel_fid_list = (bcmfp_lt_presel_entry_sp_fids_t*) lt_info->sp_fids;
input.field[0]->id = presel_fid_list->presel_id_fid;
input.count = 1;
input.field[0]->data = presel_id;
SHR_IF_ERR_EXIT
(bcmimm_entry_unlock(unit, lt_info->ltid, in));
}
}
}
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &input);
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &imm_fields);
SHR_FUNC_EXIT();
}
int
bcmfp_fixed_key_group_validate(int unit,
bcmimm_entry_event_t action,
bcmfp_lt_info_t *lt_info,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t grp_idx = 1;
uint32_t fid = 0;
uint64_t key_val = 0;
uint32_t grp_id = 0;
uint32_t group_id = 0;
uint64_t data_val = 0;
uint32_t out_fields = 0;
uint32_t oper_mode = 0;
bcmltd_fields_t input = {0};
bcmltd_fields_t *in = NULL;
bcmltd_fields_t imm_fields = {0};
bcmltd_sid_t group_ltid = 0;
uint32_t grp_pri = 0, in_grp_pri = 0;
uint32_t pipe_id = 0, in_pipe_id = 0;
uint32_t mode = 0, in_mode = 0;
uint32_t port_pkt_type = 0, in_port_pkt_type = 0;
bool same = TRUE;
bcmfp_stage_id_t stage_id;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_group_oper_info_t *group_oper_info = NULL;
SHR_FUNC_ENTER(unit);
stage_id = lt_info->stage_id;
group_ltid = lt_info->ltid;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &imm_fields));
out_fields = imm_fields.count;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
/* Update with the inmemory value if the values in the user-input is default
* and this is needed in case of UPDATE operation. */
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
input.count = 0;
input.field = NULL;
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &input));
in = &input;
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = group_id;
input.count = 1;
if (action == BCMIMM_ENTRY_UPDATE) {
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
group_ltid,
in,
&imm_fields));
}
SHR_IF_ERR_EXIT(bcmfp_stage_oper_mode_get(unit,
stage_id,
&oper_mode));
if(oper_mode == BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
/* Update the pipe_id */
fid = fid_list->pipe_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_pipe_id);
} else if (action == BCMIMM_ENTRY_UPDATE) {
/*Update with the in-mem value if the input does not have the field value */
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit,
fid,
&imm_fields,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_pipe_id);
}
}
}
/* Update the group mode */
fid = fid_list->mode_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_mode);
} else if (action == BCMIMM_ENTRY_UPDATE) {
/*Update with the in-mem value if the input does not have the field value */
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_mode);
}
}
/* Update the group priority */
fid = fid_list->priority_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_grp_pri);
} else if (action == BCMIMM_ENTRY_UPDATE) {
/*Update with the in-mem value if the input does not have the field value */
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_grp_pri);
}
}
/* Update the group port_pkt_type */
fid = fid_list->port_pkt_type_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_port_pkt_type);
} else if (action == BCMIMM_ENTRY_UPDATE) {
/*Update with the in-mem value if the input does not have the field value */
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_port_pkt_type);
}
}
while(grp_idx <= BCMFP_GROUP_MAX_EGRESS) {
/* Skip validation if the group_id in imm is same as in user input */
group_oper_info = NULL;
SHR_IF_ERR_EXIT_EXCEPT_IF(
bcmfp_group_oper_info_get(unit, stage_id, grp_idx,
&group_oper_info),
SHR_E_NOT_FOUND);
if ((group_oper_info != NULL) && (group_oper_info->group_id)) {
grp_id = group_oper_info->group_id;
if (grp_id != group_id) {
/* Check if pipe_id is same */
if(oper_mode == BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
pipe_id = group_oper_info->tbl_inst;
if (in_pipe_id == pipe_id) {
same = TRUE;
} else {
same = FALSE;
}
}
if (same == TRUE) {
/* Check if group priority is same */
grp_pri = group_oper_info->group_prio;
if (in_grp_pri == grp_pri) {
same = TRUE;
} else {
same = FALSE;
}
}
if (same == TRUE) {
/* Check if group mode is same */
mode = group_oper_info->group_slice_mode;
if (in_mode == mode) {
same = TRUE;
} else {
same = FALSE;
}
}
if (same == TRUE) {
/* Check if port_pkt_type is same */
port_pkt_type = group_oper_info->port_pkt_type;
if (in_port_pkt_type == port_pkt_type) {
SHR_RETURN_VAL_EXIT(SHR_E_CONFIG);
} else {
same = FALSE;
}
}
}
}
grp_idx++;
}
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &imm_fields);
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &input);
SHR_FUNC_EXIT();
}
int
bcmfp_group_priority_validate (int unit,
bcmimm_entry_event_t action,
bcmfp_lt_info_t *lt_info,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t grp_idx = 1;
uint32_t fid = 0;
uint64_t key_val = 0;
uint32_t grp_id = 0;
uint32_t group_id = 0;
uint32_t oper_mode = 0;
uint64_t data_val = 0;
uint32_t out_fields = 0;
bcmfp_stage_id_t stage_id = 0;
bcmltd_fields_t input = {0};
bcmltd_fields_t *in = NULL;
bcmltd_fields_t imm_fields = {0};
bcmltd_sid_t group_ltid = 0;
uint32_t grp_pri = 0, in_grp_pri = 0;
uint32_t pipe_id = 0, in_pipe_id = 0;
bool same = TRUE;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_group_oper_info_t *group_oper_info = NULL;
SHR_FUNC_ENTER(unit);
stage_id = lt_info->stage_id;
group_ltid = lt_info->ltid;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &imm_fields));
out_fields = imm_fields.count;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
/* Update with the inmemory value if the values in the user-input is default
* and this is needed in case of UPDATE operation. */
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
input.count = 0;
input.field = NULL;
SHR_IF_ERR_EXIT(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &input));
out_fields = input.count;
in = &input;
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = group_id;
input.count = 1;
if (action == BCMIMM_ENTRY_UPDATE) {
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
group_ltid,
in,
&imm_fields));
}
SHR_IF_ERR_EXIT(bcmfp_stage_oper_mode_get(unit,
stage_id,
&oper_mode));
if(oper_mode == BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
/* Update the pipe_id */
fid = fid_list->pipe_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_pipe_id);
} else if (action == BCMIMM_ENTRY_UPDATE) {
/*Update with the in-mem value if the input does not have the field value */
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit,
fid,
&imm_fields,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_pipe_id);
}
}
}
/* Update the group priority */
fid = fid_list->priority_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_grp_pri);
} else if (action == BCMIMM_ENTRY_UPDATE) {
/*Update with the in-mem value if the input does not have the field value */
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, in_grp_pri);
}
}
while(grp_idx <= BCMFP_GROUP_MAX_VFP) {
/* Skip validation if the group_id in imm is same as in user input */
group_oper_info = NULL;
SHR_IF_ERR_EXIT_EXCEPT_IF(
bcmfp_group_oper_info_get(unit, stage_id, grp_idx,
&group_oper_info),
SHR_E_NOT_FOUND);
if (group_oper_info != NULL) {
grp_id = group_oper_info->group_id;
if (grp_id != group_id) {
/* Check if pipe_id is same */
if(oper_mode == BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
pipe_id = group_oper_info->tbl_inst;
if (in_pipe_id == pipe_id) {
same = TRUE;
} else {
same = FALSE;
}
}
if (same == TRUE) {
/* Check if group priority is same */
grp_pri = group_oper_info->group_prio;
if (in_grp_pri == grp_pri) {
SHR_RETURN_VAL_EXIT(SHR_E_CONFIG);
} else {
same = FALSE;
}
}
}
}
grp_idx++;
}
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &imm_fields);
(void) bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &input);
SHR_FUNC_EXIT();
}
int
bcmfp_lt_group_config_get(int unit,
uint32_t trans_id,
bcmfp_stage_id_t stage_id,
uint32_t group_id,
bcmfp_lt_group_config_t *group_config)
{
bool auto_mode = FALSE;
uint8_t active_presel_count = 0;
uint32_t i = 0;
uint16_t group_ref_count = 0;
uint32_t fid = 0;
uint32_t idx = 0;
uint32_t incr = 0;
uint32_t out_fields = 0;
/* Default value of GRP_MODE is SINGLE=1 */
uint32_t mode = 1;
uint32_t mode_oper = 0;
uint32_t group_em_ltid = 0;
uint32_t group_em_auto_ltid= 0;
uint32_t group_em_oper_ltid = 0;
uint32_t field_val[BCMFP_MAX_WSIZE];
uint64_t data = 0;
uint64_t data_def = 0;
bcmltd_sid_t group_ltid = 0;
bcmfp_lt_group_qual_map_t group_qual_map;
bcmltd_fields_t imm_fields;
bcmltd_fields_t input;
bcmltd_fields_t *in = NULL;
bcmltd_field_t presel_set[BCMFP_GROUP_MAX_PRESEL];
bcmltd_field_t *presel_fields[BCMFP_GROUP_MAX_PRESEL];
bcmltd_fields_t multi_fields;
bcmfp_lt_info_t *lt_info = NULL;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_lt_field_info_t *field_info = NULL;
bcmfp_stage_oper_mode_t stage_oper_mode = BCMFP_STAGE_OPER_MODE_GLOBAL;
bcmfp_group_oper_info_t *group_oper_info = NULL;
bcmfp_stage_t *stage = NULL;
bcmfp_lt_policy_config_t *policy_config = NULL;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_stage_get(unit, stage_id, &stage));
/* LT for stage */
SHR_IF_ERR_EXIT(bcmfp_lt_info_get_by_type(unit,
stage_id,
BCMFP_LT_TYPE_GROUP,
<_info));
SHR_IF_ERR_EXIT_EXCEPT_IF(
bcmfp_group_oper_info_get(unit, stage_id,
group_id, &group_oper_info), SHR_E_NOT_FOUND);
if (group_oper_info != NULL) {
group_ref_count = group_oper_info->ref_count;
}
group_ltid = lt_info->ltid;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
imm_fields.count = 0;
imm_fields.field = NULL;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &imm_fields));
input.count = 0;
input.field = NULL;
SHR_IF_ERR_EXIT
(bcmfp_lt_bcmltd_fields_buff_alloc(unit, group_ltid, &input));
out_fields = input.count;
in = &input;
input.field[0]->id = fid_list->group_id_fid;
input.field[0]->data = group_id;
input.count = 1;
SHR_IF_ERR_EXIT(bcmimm_entry_lookup(unit,
group_ltid,
in,
&imm_fields));
i = 0;
while (i < imm_fields.count) {
fid = imm_fields.field[i]->id;
idx = imm_fields.field[i]->idx;
SHR_IF_ERR_EXIT
(bcmfp_lt_field_info_get(unit, fid, lt_info, &field_info));
if (field_info->dtag != BCMLT_FIELD_DATA_TAG_RAW) {
data_def = field_info->def.u64;
} else {
data_def = 0;
}
if (imm_fields.field[i]->data == data_def)
{
i++;
continue;
}
BCMFP_RET_VAL_ASSIGN
(lt_info->map_get(unit, fid, idx, (void *) &group_qual_map));
if (SHR_FUNC_ERR()) {
i++;
continue;
}
sal_memset(&field_val[0], 0, sizeof(field_val));
if (field_info->is_array == TRUE) {
/* Each array Index has different qualifier. */
incr = 1;
} else {
incr = field_info->elements;
}
for (idx = 0; idx < incr; idx++) {
SHR_IF_ERR_EXIT
(bcmfp_lt_field_data_to_uint32_array(unit,
imm_fields.field[i + idx],
field_info,
field_val));
}
if ((stage->flags & BCMFP_STAGE_POLICY_TYPE_PDD) &&
(group_qual_map.field_type == BCMFP_LT_EM_GROUP_FIELD_TYPE_ACTION)) {
SHR_IF_ERR_EXIT(bcmfp_lt_group_action_add(unit,
&group_qual_map,
group_config));
} else {
SHR_IF_ERR_EXIT(bcmfp_lt_group_qual_add(unit,
field_info,
&group_qual_map,
field_val,
group_config));
}
/* Increment i. */
i += incr;
}
group_config->group_id = group_id;
SHR_IF_ERR_EXIT(
bcmfp_stage_oper_mode_get(unit, stage_id, &stage_oper_mode));
if (stage_oper_mode != BCMFP_STAGE_OPER_MODE_PIPE_UNIQUE) {
group_config->flag |= 0x1;
group_config->pipe_id = -1;
} else {
/* fill Pipe info */
fid = fid_list->pipe_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
group_config->flag |= 0x1;
BCMFP_UINT64_TO_UINT32(data, group_config->pipe_id);
}
}
/* fill Priority info */
group_config->priority = 0;
fid = fid_list->priority_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, group_config->priority);
}
group_config->lookup_id = 0;
fid = fid_list->group_lookup_id_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, group_config->lookup_id);
}
if (lt_info->flags & BCMFP_LT_FLAGS_FIXED_KEY_GRP) {
fid = fid_list->mode_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (!SHR_FUNC_ERR()) {
BCMFP_UINT64_TO_UINT32(data, group_config->slice_mode);
}
fid = fid_list->port_pkt_type_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (!SHR_FUNC_ERR()) {
BCMFP_UINT64_TO_UINT32(data, group_config->port_pkt_type);
}
}
else {
/* fill auto mode */
fid = fid_list->mode_auto_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_BOOL(data, auto_mode);
}
fid = fid_list->mode_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, mode);
}
fid = fid_list->mode_oper_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, mode_oper);
}
if (group_ref_count != 0) {
/* Group is already configured in H/W, Use Mode Oper */
group_config->mode = mode_oper;
} else if (auto_mode == FALSE) {
switch (mode) {
case 1:
group_config->mode = BCMFP_GROUP_MODE_SINGLE;
break;
case 2:
group_config->mode = BCMFP_GROUP_MODE_DBLINTRA;
break;
case 3:
group_config->mode = BCMFP_GROUP_MODE_DBLINTER;
break;
case 4:
group_config->mode = BCMFP_GROUP_MODE_TRIPLE;
break;
case 5:
group_config->mode = BCMFP_GROUP_MODE_QUAD;
break;
default:
SHR_RETURN_VAL_EXIT(SHR_E_UNAVAIL);
}
} else {
group_config->mode = BCMFP_GROUP_MODE_AUTO;
}
}
if (lt_info->flags & BCMFP_LT_FLAGS_VIRTUAL_SLICE_GRP) {
fid = fid_list->virtual_slice_grp_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (!SHR_FUNC_ERR()) {
BCMFP_UINT64_TO_UINT8(data, group_config->virtual_slice_grp);
}
}
if (lt_info->flags & BCMFP_LT_FLAGS_HASH_KEY_GRP) {
fid = fid_list->policy_id_fid;
policy_config = &(group_config->policy_config);
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
if (data) {
group_config->policy_valid = TRUE;
group_config->flag |= BCMFP_GROUP_WITH_DEFAULT_POLICY;
policy_config->valid = TRUE;
} else {
/* Dettach the policy template if the ID == 0 */
group_config->policy_valid = FALSE;
policy_config->valid = FALSE;
}
}
if (group_config->policy_valid) {
SHR_IF_ERR_EXIT(bcmfp_lt_policy_config_get(unit,
trans_id,
stage_id,
data,
0,
NULL,
policy_config));
}
fid = fid_list->group_ltid_auto_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_BOOL(data, group_em_auto_ltid);
}
fid = fid_list->group_ltid_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, group_em_ltid);
}
fid = fid_list->group_ltid_oper_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, group_em_oper_ltid);
}
if (group_ref_count != 0) {
/* Group is already configured in H/W, Use Mode Oper */
group_config->group_ltid = group_em_oper_ltid;
} else if (group_em_auto_ltid == FALSE) {
group_config->group_ltid = group_em_ltid;
} else {
group_config->group_ltid = BCMFP_GROUP_AUTO_LTID;
}
}
if (lt_info->flags & BCMFP_LT_FLAGS_PRESEL_VALID) {
for (i = 0; i < BCMFP_GROUP_MAX_PRESEL; i++) {
presel_fields[i] = &presel_set[i];
}
fid = fid_list->presel_ids_set_count_fid;
BCMFP_RET_VAL_ASSIGN
(bcmfp_lt_field_data_get(unit, fid, &imm_fields, &data));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data, active_presel_count);
}
multi_fields.count = BCMFP_GROUP_MAX_PRESEL;
multi_fields.field = presel_fields;
fid = fid_list->presel_ids_set_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_multi_data_get(unit,
group_ltid,
fid,
&imm_fields,
&multi_fields));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
group_config->num_presel_ids = (active_presel_count < multi_fields.count)?
active_presel_count : multi_fields.count;
for (i = 0; i < group_config->num_presel_ids; i++) {
BCMFP_UINT64_TO_UINT32(presel_set[i].data, group_config->presel_ids[i]);
}
}
}
group_config->valid = TRUE;
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
if (!SHR_FUNC_VAL_IS(SHR_E_NONE)) {
bcmfp_lt_group_config_free(unit, group_config);
}
(void)bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &imm_fields);
(void)bcmfp_lt_bcmltd_fields_buff_free(unit, out_fields, &input);
SHR_FUNC_EXIT();
}
int
bcmfp_lt_egress_grp_config_update(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t fid = 0;
bcmfp_group_slice_mode_t mode = BCMFP_GROUP_SLICE_MODE_L2_SINGLE_WIDE;
uint64_t key_val = 0;
uint64_t data_val = 0;
uint32_t group_id = 0;
uint32_t pipe_id = 0;
uint32_t port_pkt_type = 0;
uint32_t priority = 0;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_stage_id_t stage_id = 0;
bcmfp_lt_info_t *lt_info = NULL;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
stage_id = lt_info->stage_id;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
fid = fid_list->pipe_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, pipe_id);
}
fid = fid_list->mode_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, mode);
}
fid = fid_list->port_pkt_type_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, port_pkt_type);
}
fid = fid_list->priority_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, priority);
}
SHR_IF_ERR_EXIT(bcmfp_group_params_set(unit,
stage_id,
pipe_id,
group_id,
priority,
mode,
port_pkt_type));
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
SHR_FUNC_EXIT();
}
int
bcmfp_lt_egress_grp_config_delete(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t fid = 0;
uint32_t group_id = 0;
uint64_t key_val = 0;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_stage_id_t stage_id = 0;
bcmfp_lt_info_t *lt_info = NULL;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
stage_id = lt_info->stage_id;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
SHR_IF_ERR_EXIT(bcmfp_group_params_reset(unit,
stage_id,
group_id));
exit:
SHR_FUNC_EXIT();
}
int
bcmfp_lt_vlan_grp_config_update(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t fid = 0;
uint64_t key_val = 0;
uint64_t data_val = 0;
uint32_t group_id = 0;
uint32_t pipe_id = 0;
uint32_t priority = 0;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_stage_id_t stage_id = 0;
bcmfp_lt_info_t *lt_info = NULL;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
stage_id = lt_info->stage_id;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
fid = fid_list->pipe_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, pipe_id);
}
fid = fid_list->priority_fid;
BCMFP_RET_VAL_ASSIGN(bcmfp_lt_field_data_get_from_data_array(unit,
fid,
data,
&data_val));
if (SHR_FUNC_VAL_IS(SHR_E_NONE)) {
BCMFP_UINT64_TO_UINT32(data_val, priority);
}
SHR_IF_ERR_EXIT(bcmfp_group_params_set(unit,
stage_id,
pipe_id,
group_id,
priority,
0,
0));
SHR_RETURN_VAL_EXIT(SHR_E_NONE);
exit:
SHR_FUNC_EXIT();
}
int
bcmfp_lt_vlan_grp_config_delete(int unit,
uint32_t trans_id,
bcmltd_sid_t sid,
const bcmltd_field_t *key,
const bcmltd_field_t *data)
{
uint32_t fid = 0;
uint32_t group_id = 0;
uint64_t key_val = 0;
bcmfp_lt_group_sp_fids_t *fid_list = NULL;
bcmfp_stage_id_t stage_id = 0;
bcmfp_lt_info_t *lt_info = NULL;
SHR_FUNC_ENTER(unit);
SHR_IF_ERR_EXIT(bcmfp_lt_info_get(unit, sid, <_info));
stage_id = lt_info->stage_id;
fid_list = (bcmfp_lt_group_sp_fids_t *) lt_info->sp_fids;
fid = fid_list->group_id_fid;
SHR_IF_ERR_EXIT(bcmfp_lt_field_key_get_from_key_array(unit,
fid,
key,
&key_val));
BCMFP_UINT64_TO_UINT32(key_val, group_id);
SHR_IF_ERR_EXIT(bcmfp_group_params_reset(unit,
stage_id,
group_id));
exit:
SHR_FUNC_EXIT();
}
| 38.453376 | 100 | 0.534688 |
4daa5797dac0304b5de962139664356b9a34d64b | 6,447 | c | C | src/kernel/sdhost.c | LJP-TW/test | 1e2898e784a888799c97bb22a3a9eaf59b356e66 | [
"MIT"
] | 1 | 2022-03-14T10:16:35.000Z | 2022-03-14T10:16:35.000Z | src/kernel/sdhost.c | LJP-TW/test | 1e2898e784a888799c97bb22a3a9eaf59b356e66 | [
"MIT"
] | null | null | null | src/kernel/sdhost.c | LJP-TW/test | 1e2898e784a888799c97bb22a3a9eaf59b356e66 | [
"MIT"
] | null | null | null | #include <sdhost.h>
#include <BCM2837.h>
#include <utils.h>
// SD card command
#define GO_IDLE_STATE 0
#define SEND_OP_CMD 1
#define ALL_SEND_CID 2
#define SEND_RELATIVE_ADDR 3
#define SELECT_CARD 7
#define SEND_IF_COND 8
#define VOLTAGE_CHECK_PATTERN 0x1aa
#define STOP_TRANSMISSION 12
#define SET_BLOCKLEN 16
#define READ_SINGLE_BLOCK 17
#define WRITE_SINGLE_BLOCK 24
#define SD_APP_OP_COND 41
#define SDCARD_3_3V (1 << 21)
#define SDCARD_ISHCS (1 << 30)
#define SDCARD_READY (1 << 31)
#define APP_CMD 55
// sdhost
#define SDHOST_BASE PA2VA(PERIPHERALS_BASE + 0x202000)
#define SDHOST_CMD (SDHOST_BASE + 0)
#define SDHOST_READ 0x40
#define SDHOST_WRITE 0x80
#define SDHOST_LONG_RESPONSE 0x200
#define SDHOST_NO_REPONSE 0x400
#define SDHOST_BUSY 0x800
#define SDHOST_NEW_CMD 0x8000
#define SDHOST_ARG (SDHOST_BASE + 0x4)
#define SDHOST_TOUT (SDHOST_BASE + 0x8)
#define SDHOST_TOUT_DEFAULT 0xf00000
#define SDHOST_CDIV (SDHOST_BASE + 0xc)
#define SDHOST_CDIV_MAXDIV 0x7ff
#define SDHOST_CDIV_DEFAULT 0x148
#define SDHOST_RESP0 (SDHOST_BASE + 0x10)
#define SDHOST_RESP1 (SDHOST_BASE + 0x14)
#define SDHOST_RESP2 (SDHOST_BASE + 0x18)
#define SDHOST_RESP3 (SDHOST_BASE + 0x1c)
#define SDHOST_HSTS (SDHOST_BASE + 0x20)
#define SDHOST_HSTS_MASK (0x7f8)
#define SDHOST_HSTS_ERR_MASK (0xf8)
#define SDHOST_HSTS_DATA (1 << 0)
#define SDHOST_PWR (SDHOST_BASE + 0x30)
#define SDHOST_DBG (SDHOST_BASE + 0x34)
#define SDHOST_DBG_FSM_DATA 1
#define SDHOST_DBG_FSM_MASK 0xf
#define SDHOST_DBG_MASK (0x1f << 14 | 0x1f << 9)
#define SDHOST_DBG_FIFO (0x4 << 14 | 0x4 << 9)
#define SDHOST_CFG (SDHOST_BASE + 0x38)
#define SDHOST_CFG_DATA_EN (1 << 4)
#define SDHOST_CFG_SLOW (1 << 3)
#define SDHOST_CFG_INTBUS (1 << 1)
#define SDHOST_SIZE (SDHOST_BASE + 0x3c)
#define SDHOST_DATA (SDHOST_BASE + 0x40)
#define SDHOST_CNT (SDHOST_BASE + 0x50)
static int is_hcs; // high capcacity(SDHC)
static void pin_setup(void)
{
put32(PA2VA(GPFSEL4), 0x24000000);
put32(PA2VA(GPFSEL5), 0x924);
put32(PA2VA(GPPUD), 0);
delay(15000);
put32(PA2VA(GPPUDCLK1), 0xffffffff);
delay(15000);
put32(PA2VA(GPPUDCLK1), 0);
}
static void sdhost_setup(void)
{
unsigned int tmp;
put32(SDHOST_PWR, 0);
put32(SDHOST_CMD, 0);
put32(SDHOST_ARG, 0);
put32(SDHOST_TOUT, SDHOST_TOUT_DEFAULT);
put32(SDHOST_CDIV, 0);
put32(SDHOST_HSTS, SDHOST_HSTS_MASK);
put32(SDHOST_CFG, 0);
put32(SDHOST_CNT, 0);
put32(SDHOST_SIZE, 0);
tmp = get32(SDHOST_DBG);
tmp &= ~SDHOST_DBG_MASK;
tmp |= SDHOST_DBG_FIFO;
put32(SDHOST_DBG, tmp);
delay(250000);
put32(SDHOST_PWR, 1);
delay(250000);
put32(SDHOST_CFG, SDHOST_CFG_SLOW | SDHOST_CFG_INTBUS | SDHOST_CFG_DATA_EN);
put32(SDHOST_CDIV, SDHOST_CDIV_DEFAULT);
}
static int wait_sd(void)
{
int cnt = 1000000;
unsigned int cmd;
do {
if (cnt == 0) {
return -1;
}
cmd = get32(SDHOST_CMD);
--cnt;
} while (cmd & SDHOST_NEW_CMD);
return 0;
}
static int sd_cmd(unsigned cmd, unsigned int arg)
{
put32(SDHOST_ARG, arg);
put32(SDHOST_CMD, cmd | SDHOST_NEW_CMD);
return wait_sd();
}
static int sdcard_setup(void)
{
unsigned int tmp;
sd_cmd(GO_IDLE_STATE | SDHOST_NO_REPONSE, 0);
sd_cmd(SEND_IF_COND, VOLTAGE_CHECK_PATTERN);
tmp = get32(SDHOST_RESP0);
if (tmp != VOLTAGE_CHECK_PATTERN) {
return -1;
}
while (1) {
if (sd_cmd(APP_CMD, 0) == -1) {
// MMC card or invalid card status
// currently not support
continue;
}
sd_cmd(SD_APP_OP_COND, SDCARD_3_3V | SDCARD_ISHCS);
tmp = get32(SDHOST_RESP0);
if (tmp & SDCARD_READY) {
break;
}
delay(1000000);
}
is_hcs = tmp & SDCARD_ISHCS;
sd_cmd(ALL_SEND_CID | SDHOST_LONG_RESPONSE, 0);
sd_cmd(SEND_RELATIVE_ADDR, 0);
tmp = get32(SDHOST_RESP0);
sd_cmd(SELECT_CARD, tmp);
sd_cmd(SET_BLOCKLEN, BLOCK_SIZE);
return 0;
}
static int wait_fifo(void)
{
int cnt = 1000000;
unsigned int hsts;
do {
if (cnt == 0) {
return -1;
}
hsts = get32(SDHOST_HSTS);
--cnt;
} while ((hsts & SDHOST_HSTS_DATA) == 0);
return 0;
}
static void set_block(int size, int cnt)
{
put32(SDHOST_SIZE, size);
put32(SDHOST_CNT, cnt);
}
static void wait_finish(void)
{
unsigned int dbg;
do {
dbg = get32(SDHOST_DBG);
} while ((dbg & SDHOST_DBG_FSM_MASK) != SDHOST_HSTS_DATA);
}
void sd_readblock(int block_idx, void *buf)
{
unsigned int *buf_u = (unsigned int *)buf;
int succ = 0;
if (!is_hcs) {
block_idx <<= 9;
}
do {
unsigned int hsts;
set_block(BLOCK_SIZE, 1);
sd_cmd(READ_SINGLE_BLOCK | SDHOST_READ, block_idx);
for (int i = 0; i < 128; ++i) {
wait_fifo();
buf_u[i] = get32(SDHOST_DATA);
}
hsts = get32(SDHOST_HSTS);
if (hsts & SDHOST_HSTS_ERR_MASK) {
put32(SDHOST_HSTS, SDHOST_HSTS_ERR_MASK);
sd_cmd(STOP_TRANSMISSION | SDHOST_BUSY, 0);
} else {
succ = 1;
}
} while(!succ);
wait_finish();
}
void sd_writeblock(int block_idx, const void *buf)
{
const unsigned int *buf_u = (const unsigned int *)buf;
int succ = 0;
if (!is_hcs) {
block_idx <<= 9;
}
do {
unsigned int hsts;
set_block(BLOCK_SIZE, 1);
sd_cmd(WRITE_SINGLE_BLOCK | SDHOST_WRITE, block_idx);
for (int i = 0; i < 128; ++i) {
wait_fifo();
put32(SDHOST_DATA, buf_u[i]);
}
hsts = get32(SDHOST_HSTS);
if (hsts & SDHOST_HSTS_ERR_MASK) {
put32(SDHOST_HSTS, SDHOST_HSTS_ERR_MASK);
sd_cmd(STOP_TRANSMISSION | SDHOST_BUSY, 0);
} else {
succ = 1;
}
} while(!succ);
wait_finish();
}
void sd_init(void)
{
pin_setup();
sdhost_setup();
sdcard_setup();
} | 27.551282 | 80 | 0.597953 |
4dab5780f30eccd04485d9f58bf8e528f1eac9c6 | 3,058 | h | C | Other/Headers/UploadVideoReportData.h | XWJACK/WeChatPlugin-MacOS | 4241ddb10ccce9484fcf6d5bd51a6afa3b446632 | [
"MIT"
] | 2 | 2019-01-11T02:02:55.000Z | 2020-04-23T02:42:01.000Z | Other/Headers/UploadVideoReportData.h | XWJACK/WeChatPlugin-MacOS | 4241ddb10ccce9484fcf6d5bd51a6afa3b446632 | [
"MIT"
] | null | null | null | Other/Headers/UploadVideoReportData.h | XWJACK/WeChatPlugin-MacOS | 4241ddb10ccce9484fcf6d5bd51a6afa3b446632 | [
"MIT"
] | 1 | 2021-01-09T14:54:27.000Z | 2021-01-09T14:54:27.000Z | //
// Generated by class-dump 3.5 (64 bit) (Debug version compiled Sep 17 2017 16:24:48).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2015 by Steve Nygard.
//
#import <objc/NSObject.h>
@class NSString;
@interface UploadVideoReportData : NSObject
{
unsigned int _m_touin;
unsigned int _m_nettype;
unsigned int _m_size;
unsigned int _m_length;
unsigned int _m_videobitrate;
unsigned int _m_audiobitrate;
unsigned int _m_framerate;
unsigned int _m_cpvideobitrate;
unsigned int _m_cpaudiobitrate;
unsigned int _m_cpframerate;
unsigned int _m_cplength;
unsigned int _m_cpsize;
unsigned int _m_scene;
unsigned int _m_status;
NSString *_m_msgsource;
NSString *_m_fileid;
NSString *_m_cdnip;
NSString *_m_newmd5;
unsigned long long _m_begintime;
unsigned long long _m_endtime;
NSString *_m_resolution;
NSString *_m_cpresolution;
NSString *_m_newtouin;
}
@property(retain, nonatomic) NSString *m_newtouin; // @synthesize m_newtouin=_m_newtouin;
@property(nonatomic) unsigned int m_status; // @synthesize m_status=_m_status;
@property(nonatomic) unsigned int m_scene; // @synthesize m_scene=_m_scene;
@property(nonatomic) unsigned int m_cpsize; // @synthesize m_cpsize=_m_cpsize;
@property(nonatomic) unsigned int m_cplength; // @synthesize m_cplength=_m_cplength;
@property(nonatomic) unsigned int m_cpframerate; // @synthesize m_cpframerate=_m_cpframerate;
@property(retain, nonatomic) NSString *m_cpresolution; // @synthesize m_cpresolution=_m_cpresolution;
@property(nonatomic) unsigned int m_cpaudiobitrate; // @synthesize m_cpaudiobitrate=_m_cpaudiobitrate;
@property(nonatomic) unsigned int m_cpvideobitrate; // @synthesize m_cpvideobitrate=_m_cpvideobitrate;
@property(retain, nonatomic) NSString *m_resolution; // @synthesize m_resolution=_m_resolution;
@property(nonatomic) unsigned int m_framerate; // @synthesize m_framerate=_m_framerate;
@property(nonatomic) unsigned int m_audiobitrate; // @synthesize m_audiobitrate=_m_audiobitrate;
@property(nonatomic) unsigned int m_videobitrate; // @synthesize m_videobitrate=_m_videobitrate;
@property(nonatomic) unsigned int m_length; // @synthesize m_length=_m_length;
@property(nonatomic) unsigned int m_size; // @synthesize m_size=_m_size;
@property(nonatomic) unsigned long long m_endtime; // @synthesize m_endtime=_m_endtime;
@property(nonatomic) unsigned long long m_begintime; // @synthesize m_begintime=_m_begintime;
@property(retain, nonatomic) NSString *m_newmd5; // @synthesize m_newmd5=_m_newmd5;
@property(retain, nonatomic) NSString *m_cdnip; // @synthesize m_cdnip=_m_cdnip;
@property(retain, nonatomic) NSString *m_fileid; // @synthesize m_fileid=_m_fileid;
@property(nonatomic) unsigned int m_nettype; // @synthesize m_nettype=_m_nettype;
@property(retain, nonatomic) NSString *m_msgsource; // @synthesize m_msgsource=_m_msgsource;
@property(nonatomic) unsigned int m_touin; // @synthesize m_touin=_m_touin;
- (void).cxx_destruct;
- (id)copy;
- (id)logStr;
- (id)init;
@end
| 44.970588 | 102 | 0.775016 |
4dae6d8ae97caeffa23009f585df83d91603b941 | 640 | h | C | OGPeerObjC/OGStreamView.h | satansly/PeerObjC | 854229f65df08424c67e853719815daf1ae6db90 | [
"MIT"
] | 2 | 2016-05-30T04:22:11.000Z | 2017-06-03T12:56:47.000Z | OGPeerObjC/OGStreamView.h | satansly/PeerObjC | 854229f65df08424c67e853719815daf1ae6db90 | [
"MIT"
] | 2 | 2016-05-31T06:26:31.000Z | 2016-06-01T02:43:03.000Z | OGPeerObjC/OGStreamView.h | satansly/PeerObjC | 854229f65df08424c67e853719815daf1ae6db90 | [
"MIT"
] | null | null | null | //
// OGStreamView.h
// Pods
//
// Created by Omar Hussain on 2/13/16.
//
//
#import <UIKit/UIKit.h>
@class RTCMediaStream;
@interface OGStreamView : UIView
/**
* @brief RTCMediaStream object used to render the the video
*/
@property(nonatomic, strong) RTCMediaStream* stream;
/**
* @brief Initializes and returns a ready to be displayed stream view
*
* @param stream RTCMediaStream object to populate the view
*
* @return Instance of OGStreamView ready to be displayed in view hierarchy
*/
-(instancetype)initWithStream:(RTCMediaStream *)stream;
/**
* @brief Resets renderers and views
*/
-(void)resetSession;
@end
| 18.823529 | 76 | 0.710938 |
4db2ca9395a6b0d0971463a0d51241c59cea7507 | 14,253 | c | C | src/benchmark.c | ibireme/yyjson_benchmark | 79cb96635354b1a4e2b50e173ba457337e627082 | [
"MIT"
] | 36 | 2020-10-08T12:11:07.000Z | 2022-01-08T08:39:31.000Z | src/benchmark.c | ibireme/yyjson_benchmark | 79cb96635354b1a4e2b50e173ba457337e627082 | [
"MIT"
] | 1 | 2021-01-01T15:05:43.000Z | 2021-01-25T02:17:50.000Z | src/benchmark.c | ibireme/yyjson_benchmark | 79cb96635354b1a4e2b50e173ba457337e627082 | [
"MIT"
] | 6 | 2020-10-09T02:57:57.000Z | 2022-02-23T04:05:01.000Z | #include "benchmark.h"
static int reader_num = 0;
static const char *reader_names[64];
static int reader_name_max = 0;
static reader_measure_func reader_funcs[64];
static int writer_num = 0;
static const char *writer_names[64];
static int writer_name_max = 0;
static writer_measure_func writer_funcs[64];
static int stats_num = 0;
static const char *stats_names[64];
static int stats_name_max = 0;
static stats_measure_func stats_funcs[64];
static void func_register_all(void) {
#define register_reader(name) \
extern u64 reader_measure_##name(const char *json, size_t size, int repeat); \
reader_funcs[reader_num] = reader_measure_##name; \
reader_names[reader_num] = #name; \
reader_num++; \
if ((int)strlen(#name) > reader_name_max) reader_name_max = (int)strlen(#name);
#define register_writer(name) \
extern u64 writer_measure_##name(const char *json, size_t size, size_t *out_size, \
bool *roundtrip, bool pretty, int repeat); \
writer_funcs[writer_num] = writer_measure_##name; \
writer_names[writer_num] = #name; \
writer_num++; \
if ((int)strlen(#name) > writer_name_max) writer_name_max = (int)strlen(#name);
#define register_stats(name) \
extern u64 stats_measure_##name(const char *json, size_t size, stats_data *data, int repeat); \
stats_funcs[stats_num] = stats_measure_##name; \
stats_names[stats_num] = #name; \
stats_num++; \
if ((int)strlen(#name) > stats_name_max) stats_name_max = (int)strlen(#name);
// fast
register_reader(yyjson_fast); // validate_encoding, insitu, fast_fp
register_reader(yyjson); // validate_encoding, full_precision_fp
register_writer(yyjson); // immutable writer
register_stats(yyjson); // stats recursive
#if BENCHMARK_HAS_SIMDJSON
register_reader(simdjson);
register_writer(simdjson); // immutable writer, minify only
register_stats(simdjson);
#endif
register_reader(rapidjson); // validate_encoding, full_precision_fp
register_writer(rapidjson);
register_stats(rapidjson); // stats recursive
// full
/*
register_reader(yyjson_fast); // validate_encoding, insitu, fast_fp
register_reader(yyjson); // validate_encoding, full_precision_fp
register_writer(yyjson); // immutable writer
register_writer(yyjson_mut); // mutable writer
register_stats(yyjson_fast); // stats iterator
register_stats(yyjson); // stats recursive
#if BENCHMARK_HAS_SIMDJSON
register_reader(simdjson);
register_writer(simdjson); // immutable writer, minify only
register_stats(simdjson);
#endif
register_reader(sajson);
register_reader(sajson_dynamic);
register_stats(sajson);
register_reader(rapidjson); // validate_encoding, full_precision_fp
register_reader(rapidjson_fast); // no_validate_encoding, insitu, fast_fp
register_writer(rapidjson);
register_stats(rapidjson_fast); // stats with handler
register_stats(rapidjson); // stats recursive
register_reader(cjson);
register_writer(cjson);
register_stats(cjson);
register_reader(jansson);
register_writer(jansson);
register_stats(jansson);
*/
}
static void func_cleanup(void) {
reader_num = 0;
reader_name_max = 0;
writer_num = 0;
writer_name_max = 0;
stats_num = 0;
stats_name_max = 0;
}
static int get_repeat_count(usize len) {
return (len > 16 * 1024 * 1024) ? 4 : 16;
}
static void setup_chart_column_option(yy_chart_options *op) {
op->type = YY_CHART_COLUMN;
op->h_axis.categories = reader_names;
op->h_axis.allow_decimals = true;
op->plot.value_labels_enabled = false;
op->plot.value_labels_decimals = 2;
op->plot.color_by_point = false;
op->plot.group_padding = 0.1f;
op->plot.point_padding = 0.0f;
op->plot.border_width = 0.0f;
op->legend.enabled = true;
op->tooltip.value_decimals = 2;
op->width = 800;
op->height = 350;
}
static void run_reader_benchmark(yy_report *report, char **file_paths, int file_count) {
yy_chart_options op;
yy_chart_options_init(&op);
setup_chart_column_option(&op);
op.h_axis.categories = reader_names;
// bytes per second
op.title = "JSON reader";
op.subtitle = "gigabytes per second (larger is better)";
op.v_axis.title = "GB/s";
op.tooltip.value_suffix = " GB/s";
yy_chart *chart_bps = yy_chart_new();
yy_chart_set_options(chart_bps, &op);
yy_report_add_chart(report, chart_bps);
// cycles per byte
op.title = "JSON reader (cpb)";
op.subtitle = "cycles per byte (smaller is better)";
op.v_axis.title = "cycles";
op.tooltip.value_suffix = " cycles/byte";
yy_chart *chart_cpb = yy_chart_new();
yy_chart_set_options(chart_cpb, &op);
yy_report_add_chart(report, chart_cpb);
printf("benchmark reader...\n");
for (int f = 0; f < file_count; f++) {
char file_name[YY_MAX_PATH];
char *file_path = file_paths[f];
yy_path_get_last(file_name, file_path);
if (!yy_str_has_suffix(file_name, ".json")) continue;
printf(" %s\n", file_name);
yy_path_remove_ext(file_name, file_name);
char *dat;
usize len;
if (!yy_file_read(file_path, (u8 **)&dat, &len)) {
printf("cannot read file: %s\n", file_path);
continue;
}
yy_chart_item_begin(chart_bps, file_name);
yy_chart_item_begin(chart_cpb, file_name);
for (int i = 0; i < reader_num; i++) {
reader_measure_func func = reader_funcs[i];
int repeat = get_repeat_count(len);
u64 ticks = func(dat, len, repeat);
f64 cycles = (f64)ticks * yy_cpu_get_cycle_per_tick();
f64 cycles_per_byte = cycles / (f64)len;
yy_chart_item_add_float(chart_cpb, (f32)cycles_per_byte);
f64 gb_per_sec = (f64)len / ((f64)ticks / yy_cpu_get_tick_per_sec()) / 1024.0 / 1024.0 / 1024.0;
yy_chart_item_add_float(chart_bps, (f32)gb_per_sec);
}
yy_chart_item_end(chart_bps);
yy_chart_item_end(chart_cpb);
free(dat);
}
yy_chart_free(chart_bps);
yy_chart_free(chart_cpb);
}
static void run_writer_benchmark(yy_report *report, char **file_paths, int file_count) {
yy_chart_options op;
yy_chart_options_init(&op);
setup_chart_column_option(&op);
op.h_axis.categories = writer_names;
// pretty
op.title = "JSON writer pretty";
op.subtitle = "gigabytes per second (larger is better)";
op.v_axis.title = "GB/s";
op.tooltip.value_suffix = " GB/s";
yy_chart *chart_pretty = yy_chart_new();
yy_chart_set_options(chart_pretty, &op);
yy_report_add_chart(report, chart_pretty);
// minify
op.title = "JSON writer minify";
op.subtitle = "gigabytes per second (larger is better)";
op.v_axis.title = "GB/s";
op.tooltip.value_suffix = " GB/s";
yy_chart *chart_minify = yy_chart_new();
yy_chart_set_options(chart_minify, &op);
yy_report_add_chart(report, chart_minify);
printf("benchmark writer...\n");
for (int f = 0; f < file_count; f++) {
char file_name[YY_MAX_PATH];
char *file_path = file_paths[f];
yy_path_get_last(file_name, file_path);
if (!yy_str_has_suffix(file_name, ".json")) continue;
printf(" %s\n", file_name);
yy_path_remove_ext(file_name, file_name);
char *dat;
usize len;
if (!yy_file_read(file_path, (u8 **)&dat, &len)) {
printf("cannot read file: %s\n", file_path);
continue;
}
yy_chart_item_begin(chart_pretty, file_name);
yy_chart_item_begin(chart_minify, file_name);
for (int i = 0; i < writer_num; i++) {
writer_measure_func func = writer_funcs[i];
int repeat = get_repeat_count(len);
usize out_size;
bool roundtrip;
u64 ticks = func(dat, len, &out_size, &roundtrip, true, repeat);
f64 gb_per_sec = (f64)out_size / ((f64)ticks / yy_cpu_get_tick_per_sec()) / 1024.0 / 1024.0 / 1024.0;
yy_chart_item_add_float(chart_pretty, (f32)gb_per_sec);
ticks = func(dat, len, &out_size, &roundtrip, false, repeat);
gb_per_sec = (f64)out_size / ((f64)ticks / yy_cpu_get_tick_per_sec()) / 1024.0 / 1024.0 / 1024.0;
yy_chart_item_add_float(chart_minify, (f32)gb_per_sec);
}
yy_chart_item_end(chart_pretty);
yy_chart_item_end(chart_minify);
free(dat);
}
yy_chart_free(chart_pretty);
yy_chart_free(chart_minify);
}
static void run_stats_benchmark(yy_report *report, char **file_paths, int file_count) {
yy_chart_options op;
yy_chart_options_init(&op);
setup_chart_column_option(&op);
op.h_axis.categories = stats_names;
op.title = "JSON stats";
op.subtitle = "value count per seconds (larger is better)";
op.v_axis.title = "value count";
yy_chart *chart = yy_chart_new();
yy_chart_set_options(chart, &op);
yy_report_add_chart(report, chart);
printf("benchmark stats...\n");
for (int f = 0; f < file_count; f++) {
char file_name[YY_MAX_PATH];
char *file_path = file_paths[f];
yy_path_get_last(file_name, file_path);
if (!yy_str_has_suffix(file_name, ".json")) continue;
printf(" %s\n", file_name);
yy_path_remove_ext(file_name, file_name);
char *dat;
usize len;
if (!yy_file_read(file_path, (u8 **)&dat, &len)) {
printf("cannot read file: %s\n", file_path);
continue;
}
yy_chart_item_begin(chart, file_name);
int total_num_cmp = 0;
for (int i = 0; i < stats_num; i++) {
stats_measure_func func = stats_funcs[i];
int repeat = get_repeat_count(len);
stats_data data;
u64 ticks = func(dat, len, &data, repeat);
int total_num = data.num_null + data.num_true + data.num_false + data.num_number +
data.num_string + data.num_array + data.num_object;
if (!total_num_cmp) total_num_cmp = total_num;
else if (total_num_cmp != total_num) printf("stats not match: %s\n", stats_names[i]);
f64 seconds = (f64)ticks / yy_cpu_get_tick_per_sec();
yy_chart_item_add_float(chart, (f32)(total_num / seconds));
}
yy_chart_item_end(chart);
free(dat);
}
yy_chart_free(chart);
}
// RFC 8259 JSON Test Suite
// https://github.com/nst/JSONTestSuite
static void run_conformance_benchmark(void) {
printf("\n");
printf("RFC 8259 JSON Test Suite: https://github.com/nst/JSONTestSuite\n");
char path[YY_MAX_PATH];
yy_path_combine(path, BENCHMARK_DATA_PATH, "data", "parsing", NULL);
int file_count = 0;
char **files = yy_dir_read(path, &file_count);
for (int f = 0; f < reader_num; f++) {
reader_measure_func func = reader_funcs[f];
const char *func_name = reader_names[f];
int used_count = 0;
int valid_count = 0;
for (int i = 0; i < file_count; i++) {
char *json_name = files[i];
if (!yy_str_has_suffix(json_name, ".json")) continue;
char json_path[YY_MAX_PATH];
yy_path_combine(json_path, path, json_name, NULL);
char *dat;
usize dat_len;
if (!yy_file_read(json_path, (u8 **)&dat, &dat_len)) continue;
used_count++;
if (strncmp(func_name, "rapidjson", strlen("rapidjson")) == 0 &&
(strcmp(json_name, "n_structure_100000_opening_arrays.json") == 0 ||
strcmp(json_name, "n_structure_open_array_object.json") == 0 ||
strcmp(json_name, "n_structure_100000_opening_arrays.json") == 0)) {
// may crash
} else {
u64 suc = func(dat, dat_len, 1);
if (yy_str_has_prefix(json_name, "y_")) { // must be accepted
if (suc) valid_count++;
} else if (yy_str_has_prefix(json_name, "n_")) { // must be rejected
if (!suc) valid_count++;
} else { // free to accept or reject
valid_count++;
}
}
free(dat);
}
printf("%*s (%d/%d)%s\n",reader_name_max, func_name, valid_count, used_count, valid_count == used_count ? " [OK]" : "");
}
printf("\n");
yy_dir_free(files);
}
static void run_all_benchmark(const char *output_path) {
char path[YY_MAX_PATH];
yy_path_combine(path, BENCHMARK_DATA_PATH, "data", "json", NULL);
int file_count = 0;
char **files = yy_dir_read_full(path, &file_count);
#if TWITTER_ONLY
file_count = 1;
yy_path_combine(path, BENCHMARK_DATA_PATH, "data", "json", "twitter.json", NULL);
files[0] = path;
#endif
yy_report *report = yy_report_new();
yy_report_add_env_info(report);
run_conformance_benchmark();
run_reader_benchmark(report, files, file_count);
run_writer_benchmark(report, files, file_count);
run_stats_benchmark(report, files, file_count);
bool suc = yy_report_write_html_file(report, output_path);
if (!suc) {
printf("write report file failed: %s\n", output_path);
}
yy_report_free(report);
#if !TWITTER_ONLY
yy_dir_free(files);
#endif
}
void benchmark(const char *output_path) {
printf("------[prepare]---------\n");
printf("warmup...\n");
yy_cpu_setup_priority();
yy_cpu_spin(0.5);
yy_cpu_measure_freq();
func_register_all();
printf("------[benchmark]------\n");
run_all_benchmark(output_path);
printf("------[finish]---------\n");
func_cleanup();
}
| 33.457746 | 129 | 0.618817 |
4db31e0ca3189737a37f2eb579b63d37bce16c89 | 444 | h | C | External Sources/PDF/LZWHandle.h | Waitsnake/xee | b0e52760420d517399a87ab19e1afb567efe3d11 | [
"CC0-1.0"
] | null | null | null | External Sources/PDF/LZWHandle.h | Waitsnake/xee | b0e52760420d517399a87ab19e1afb567efe3d11 | [
"CC0-1.0"
] | null | null | null | External Sources/PDF/LZWHandle.h | Waitsnake/xee | b0e52760420d517399a87ab19e1afb567efe3d11 | [
"CC0-1.0"
] | null | null | null | #import <XADMaster/CSByteStreamHandle.h>
#import <XADMaster/LZW.h>
#import "PDFNameCollisionPreventer.h"
extern NSString *LZWInvalidCodeException;
@interface LZWHandle : CSByteStreamHandle {
BOOL early;
LZW *lzw;
int symbolsize;
int currbyte;
uint8_t buffer[4096];
}
- (id)initWithHandle:(CSHandle *)handle earlyChange:(BOOL)earlychange;
- (void)clearTable;
- (void)resetByteStream;
- (uint8_t)produceByteAtOffset:(off_t)pos;
@end
| 17.76 | 70 | 0.765766 |
4db4c280d70ef9945f2e3691c7473f487c67d422 | 1,821 | h | C | ov/src/OVreturns.h | dualword/pymol-open-source | abc307745d7d231af4f77f984ebd64f1b428cef8 | [
"CNRI-Python"
] | 636 | 2018-06-21T20:46:36.000Z | 2022-03-30T13:07:47.000Z | ov/src/OVreturns.h | dualword/pymol-open-source | abc307745d7d231af4f77f984ebd64f1b428cef8 | [
"CNRI-Python"
] | 218 | 2018-06-25T00:10:59.000Z | 2022-03-23T14:15:48.000Z | ov/src/OVreturns.h | dualword/pymol-open-source | abc307745d7d231af4f77f984ebd64f1b428cef8 | [
"CNRI-Python"
] | 192 | 2018-06-21T17:33:10.000Z | 2022-03-31T17:53:03.000Z | #ifndef _H_OVreturns
#define _H_OVreturns
typedef struct {
ov_word status;
} OVstatus;
/* a few very common result codes */
#define OVstatus_NO_EFFECT 2
#define OVstatus_YES 1
#define OVstatus_NO 0
#define OVstatus_SUCCESS 0
#define OVstatus_FAILURE -1
#define OVstatus_NULL_PTR -2
#define OVstatus_OUT_OF_MEMORY -3
#define OVstatus_NOT_FOUND -4
#define OVstatus_DUPLICATE -5
#define OVstatus_MISMATCH -6
#define OVstatus_INVALID_REF_CNT -7
#define return_OVstatus_NO_EFFECT { OVstatus _result = { OVstatus_FAILURE }; return _result; }
#define return_OVstatus_YES { OVstatus _result = { OVstatus_YES }; return _result; }
#define return_OVstatus_NO { OVstatus _result = { OVstatus_NO }; return _result; }
#define return_OVstatus_SUCCESS { OVstatus _result = { OVstatus_SUCCESS }; return _result; }
#define return_OVstatus_FAILURE { OVstatus _result = { OVstatus_FAILURE }; return _result; }
#define return_OVstatus_NULL_PTR { OVstatus _result = { OVstatus_NULL_PTR }; return _result; }
#define return_OVstatus_OUT_OF_MEMORY { OVstatus _result = { OVstatus_OUT_OF_MEMORY }; return _result; }
#define return_OVstatus_NOT_FOUND { OVstatus _result = { OVstatus_NOT_FOUND }; return _result; }
#define return_OVstatus_DUPLICATE { OVstatus _result = { OVstatus_DUPLICATE }; return _result; }
#define return_OVstatus_MISMATCH { OVstatus _result = { OVstatus_MISMATCH }; return _result; }
#define return_OVstatus_INVALID_REF_CNT { OVstatus _result = { OVstatus_MISMATCH }; return _result; }
#define OVreturn_IS_ERROR(r) ((r).status<0)
#define OVreturn_IS_OK(r) ((r).status>=0)
typedef struct {
ov_word status;
ov_word word;
} OVreturn_word;
typedef struct {
ov_word status;
ov_size size;
} OVreturn_size;
#endif
| 35.705882 | 105 | 0.739703 |
4db51d15d47bb46539cb6910a2d81605e6737a01 | 1,194 | c | C | src/tests_ppm.c | Smoltbob/JPEG-decoder.c | 4a8c03f26481e29741c4fcad0a8235534d893023 | [
"MIT"
] | null | null | null | src/tests_ppm.c | Smoltbob/JPEG-decoder.c | 4a8c03f26481e29741c4fcad0a8235534d893023 | [
"MIT"
] | null | null | null | src/tests_ppm.c | Smoltbob/JPEG-decoder.c | 4a8c03f26481e29741c4fcad0a8235534d893023 | [
"MIT"
] | null | null | null | /* Module de tests de la génération d'images ppm */
#include <stdio.h>
#include "ppm.h"
int main(void)
{
/* Générer une petite image 8x8 : invader noir et blanc avec yeux rouge */
uint32_t invader[64] = { 0x000000, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000,
0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000,
0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000,
0xFFFFFF, 0xFFFFFF, 0xFF0000, 0xFFFFFF, 0xFFFFFF, 0xFF0000, 0xFFFFFF, 0xFFFFFF,
0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF,
0x000000, 0x000000, 0xFFFFFF, 0x000000, 0x000000, 0xFFFFFF, 0x000000, 0x000000,
0x000000, 0xFFFFFF, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0xFFFFFF, 0x000000,
0xFFFFFF, 0x000000, 0xFFFFFF, 0x000000, 0x000000, 0xFFFFFF, 0x000000, 0xFFFFFF
};
FILE *testppm = fopen("testppm.ppm", "w");
cree_ppm(testppm, invader, 8, 8);
fclose(testppm);
}
| 56.857143 | 108 | 0.603015 |
4db7ed96918568942ff91d12e9640a169a3835a5 | 3,403 | h | C | package/standalone_kr_usn/sdk/apps/atcmd/lwip_ping.h | teledatics/nrc7292_sdk | d0ba3f17e1bef3d6fec7370e7f0ffa77db56e3a4 | [
"MIT"
] | null | null | null | package/standalone_kr_usn/sdk/apps/atcmd/lwip_ping.h | teledatics/nrc7292_sdk | d0ba3f17e1bef3d6fec7370e7f0ffa77db56e3a4 | [
"MIT"
] | null | null | null | package/standalone_kr_usn/sdk/apps/atcmd/lwip_ping.h | teledatics/nrc7292_sdk | d0ba3f17e1bef3d6fec7370e7f0ffa77db56e3a4 | [
"MIT"
] | null | null | null | /*
* MIT License
*
* Copyright (c) 2020 Newracom, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#ifndef __LWIP_PING_H__
#define __LWIP_PING_H__
/**********************************************************************************************/
#include "lwip/sockets.h"
#include "lwip/ip.h"
#include "lwip/icmp.h"
#include "lwip/inet_chksum.h"
#include "lwip/sys.h"
#define _lwip_ping_malloc pvPortMalloc
#define _lwip_ping_free vPortFree
#define _lwip_ping_delay _delay_ms
#define _lwip_ping_printf(fmt, ...) hal_uart_printf("[PING] " fmt, ##__VA_ARGS__)
#define _lwip_ping_error(fmt, ...) _lwip_ping_printf(fmt, ##__VA_ARGS__)
#define _lwip_ping_debug(fmt, ...) /*_lwip_ping_printf(fmt, ##__VA_ARGS__) */
#define _lwip_ping_log(fmt, ...) /*_lwip_ping_printf(fmt, ##__VA_ARGS__) */
/**********************************************************************************************/
/* #define IP_HLEN_MAX (IP_HLEN + 16) */
#define ICMP_ECHO_HLEN 8
typedef enum
{
_LWIP_PING_SUCCESS = 0,
_LWIP_PING_SEND_FAIL,
_LWIP_PING_RECV_TIMEOUT
} _lwip_ping_status_t;
typedef struct
{
_lwip_ping_status_t status;
ip4_addr_t remote_ip;
uint16_t data_size;
uint32_t icmp_seq;
uint8_t ttl;
uint32_t resp_time; /* msec */
} _lwip_ping_report_t;
typedef void (*_lwip_ping_report_cb_t)(_lwip_ping_report_t *report);
typedef struct _lwip_ping_params
{
ip4_addr_t remote_ip;
uint16_t interval; /* msec */
uint16_t count;
uint16_t data_size;
_lwip_ping_report_cb_t report_cb;
} _lwip_ping_params_t;
typedef struct
{
char *buf;
uint16_t buf_size;
ip4_addr_t remote_ip;
uint16_t id;
uint16_t icmp_seq;
uint16_t icmp_seq_end;
uint32_t time; /* msec */
} _lwip_ping_request_t;
typedef struct
{
char *buf;
uint16_t buf_size;
ip4_addr_t remote_ip;
uint16_t data_size;
uint32_t icmp_seq;
uint8_t ttl;
uint32_t time; /* msec */
} _lwip_ping_reply_t;
typedef struct
{
TaskHandle_t task;
int socket;
uint32_t send_time;
_lwip_ping_status_t status;
_lwip_ping_params_t params;
_lwip_ping_request_t request;
_lwip_ping_reply_t reply;
} _lwip_ping_info_t;
extern int _lwip_ping_start (_lwip_ping_params_t *params);
/* extern void _lwip_ping_stop (_lwip_ping_info_t *info); */
/**********************************************************************************************/
#endif /* #ifndef __LWIP_PING_H__ */
| 26.379845 | 96 | 0.693506 |
4db863f1a8871cc62f8851f2c1957a6c9d87b1cd | 8,220 | h | C | wrapper/nim_cpp_wrapper/api/nim_cpp_sysmsg.h | Mao-Lin-Cooperation/NIM_PC_Demo | f7a6b79bd6945bdf6bdaf46b7190de12ca581119 | [
"BSD-2-Clause",
"OpenSSL"
] | 1 | 2022-01-17T09:42:37.000Z | 2022-01-17T09:42:37.000Z | wrapper/nim_cpp_wrapper/api/nim_cpp_sysmsg.h | Mao-Lin-Cooperation/NIM_PC_Demo | f7a6b79bd6945bdf6bdaf46b7190de12ca581119 | [
"BSD-2-Clause",
"OpenSSL"
] | null | null | null | wrapper/nim_cpp_wrapper/api/nim_cpp_sysmsg.h | Mao-Lin-Cooperation/NIM_PC_Demo | f7a6b79bd6945bdf6bdaf46b7190de12ca581119 | [
"BSD-2-Clause",
"OpenSSL"
] | null | null | null | /** @file nim_cpp_sysmsg.h
* @brief 系统（自定义）消息
* @copyright (c) 2015-2017, NetEase Inc. All rights reserved
* @date 2015/2/1
*/
#ifndef _NIM_SDK_CPP_SYSMSG_H_
#define _NIM_SDK_CPP_SYSMSG_H_
#include <functional>
#include <list>
#include <string>
#include "nim_cpp_wrapper/helper/nim_msg_helper.h"
#include "nim_cpp_wrapper/helper/nim_sysmsg_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
/**
* @namespace nim
* @brief namespace nim
*/
namespace nim {
/** @class SystemMsg
* @brief 系统消息接口；主要包括查询系统消息、删除系统消息等功能
*/
class NIM_SDK_CPPWRAPPER_DLL_API SystemMsg {
public:
typedef std::function<void(const SysMessage&)> ReceiveSysmsgCallback; /**< 收到自定义通知回执回调模板 */
typedef std::function<void(const SendMessageArc&)> SendCustomSysmsgCallback; /**< 发送自定义通知回调模板 */
typedef std::function<void(int, int, const std::list<SysMessage>&)> QueryMsgCallback; /**< 查询系统消息自定义通知回调模板 */
typedef std::function<void(NIMResCode res_code, int unread_count)> NotifySysmsgResCallback; /**< 修改系统消息自定义通知回调模板 */
typedef NotifySysmsgResCallback QuerySysmsgUnreadCallback; /**< 查询系统消息自定义通知未读数回调模板 */
typedef NotifySysmsgResCallback ReadAllCallback; /**< 设置系统消息自定义通知已读状态回调模板 */
typedef NotifySysmsgResCallback DeleteAllCallback; /**< 删除全部系统消息自定义通知回调模板 */
typedef NotifySysmsgResCallback BatchSetCallback; /**< 批量调整系统消息自定义通知回调模板 */
typedef std::function<void(NIMResCode, int64_t, int)> NotifySingleSysmsgCallback; /**< 修改（单条）系统消息自定义通知回调模板 */
typedef NotifySingleSysmsgCallback SetStatusCallback; /**< 设置系统消息自定义通知状态回调模板 */
typedef NotifySingleSysmsgCallback DeleteCallback; /**< 删除系统消息自定义通知回调模板 */
/** @fn static void RegSysmsgCb(const ReceiveSysmsgCallback& cb, const std::string& json_extension = "")
* (全局回调)注册接收系统通知回调接口
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 操作结果的回调函数
* @return void 无返回值
* @note 错误码 200:成功
*/
static void RegSysmsgCb(const ReceiveSysmsgCallback& cb, const std::string& json_extension = "");
/** @fn static void RegSendCustomSysmsgCb(const SendCustomSysmsgCallback& cb, const std::string& json_extension = "")
* (全局回调)注册发送透传消息回调函数 （必须全局注册，统一接受回调后分发消息到具体的会话。注意：客户端发包之后，服务器不一定会返回！！！）
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 发送透传消息的回调函数
* @return void 无返回值
* @note 错误码 200:成功
*/
static void RegSendCustomSysmsgCb(const SendCustomSysmsgCallback& cb, const std::string& json_extension = "");
/** @fn static void SendCustomNotificationMsg(const std::string& json_msg)
* 发送自定义通知消息
* @param[in] json_msg 消息体Json, 可以通过CreateCustomNotificationMsg方法自动创建
* @return void 无返回值
*/
static void SendCustomNotificationMsg(const std::string& json_msg);
/** @fn static std::string CreateCustomNotificationMsg(const std::string& receiver_id,
const NIMSysMsgType type,
const std::string& client_msg_id,
const std::string& content,
const SysMessageSetting& msg_setting,
int64_t timetag = 0)
* 生成自定义通知消息
* @param[in] receiver_id 接收者id
* @param[in] type 通知类型
* @param[in] client_msg_id 本地消息id
* @param[in] content 通知内容
* @param[in] msg_setting 通知属性
* @param[in] timetag 消息时间
* @return std::string 生成自定义通知消息Json字符串
*/
static std::string CreateCustomNotificationMsg(const std::string& receiver_id,
const NIMSysMsgType type,
const std::string& client_msg_id,
const std::string& content,
const SysMessageSetting& msg_setting,
int64_t timetag = 0);
/** @fn static bool QueryMsgAsync(int limit_count, int64_t last_time, const QueryMsgCallback& cb, const std::string& json_extension = "")
* 查询本地系统消息
* @param[in] limit_count 一次查询数量，建议20
* @param[in] last_time 上次查询最后一条消息的时间戳
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 查询本地系统消息的回调函数
* @return bool 检查参数如果不符合要求则返回失败
*/
static bool QueryMsgAsync(int limit_count, int64_t last_time, const QueryMsgCallback& cb, const std::string& json_extension = "");
/** @fn static void QueryUnreadCount(const QuerySysmsgUnreadCallback& cb, const std::string& json_extension = "")
* 查询未读消息数
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 查询未读消息数的回调函数
* @return void 无返回值
* @note 错误码 200:成功
*/
static void QueryUnreadCount(const QuerySysmsgUnreadCallback& cb, const std::string& json_extension = "");
/** @fn static bool SetStatusAsync(int64_t msg_id,
nim::NIMSysMsgStatus status,
const SetStatusCallback& cb,
const std::string& json_extension = "")
* 设置消息状态
* @param[in] msg_id 消息id
* @param[in] status 消息状态
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 设置消息状态的回调函数
* @return void 无返回值
* @note 错误码 200:成功
* 0:失败
*/
static bool SetStatusAsync(int64_t msg_id, nim::NIMSysMsgStatus status, const SetStatusCallback& cb, const std::string& json_extension = "");
/** @fn static void ReadAllAsync(const ReadAllCallback& cb, const std::string& json_extension = "")
* 设置全部消息为已读
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 设置全部消息为已读的回调函数
* @return void 无返回值
* @note 错误码 200:成功
* 0:失败
*/
static void ReadAllAsync(const ReadAllCallback& cb, const std::string& json_extension = "");
/** @fn static bool DeleteAsync(int64_t msg_id, const DeleteCallback& cb, const std::string& json_extension = "")
* 删除消息
* @param[in] msg_id 消息id
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 删除消息的回调函数
* @return bool 检查参数如果不符合要求则返回失败
* @note 错误码 200:成功
* 0:失败
*/
static bool DeleteAsync(int64_t msg_id, const DeleteCallback& cb, const std::string& json_extension = "");
/** @fn static void DeleteAllAsync(const DeleteAllCallback& cb, const std::string& json_extension = "")
* 全部删除
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 删除消息的回调函数
* @return void 无返回值
* @note 错误码 200:成功
* 0:失败
*/
static void DeleteAllAsync(const DeleteAllCallback& cb, const std::string& json_extension = "");
/** @fn static void SetStatusByTypeAsync(NIMSysMsgType type,
NIMSysMsgStatus status,
const BatchSetCallback& cb,
const std::string& json_extension = "")
* 按类型设置系统通知状态
* @param[in] type 类型
* @param[in] status 状态
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 回调函数
* @return void 无返回值
* @note 错误码 200:成功
* 0:失败
*/
static void SetStatusByTypeAsync(NIMSysMsgType type, NIMSysMsgStatus status, const BatchSetCallback& cb, const std::string& json_extension = "");
/** @fn static void DeleteByTypeAsync(NIMSysMsgType type, const BatchSetCallback& cb, const std::string& json_extension = "")
* 按类型删除系统通知
* @param[in] type 类型
* @param[in] json_extension json扩展参数（备用，目前不需要）
* @param[in] cb 回调函数
* @return void 无返回值
* @note 错误码 200:成功
* 0:失败
*/
static void DeleteByTypeAsync(NIMSysMsgType type, const BatchSetCallback& cb, const std::string& json_extension = "");
/** @fn void UnregSysmsgCb()
* 反注册SysMsg提供的所有回调
* @return void 无返回值
*/
static void UnregSysmsgCb();
};
} // namespace nim
#endif //_NIM_SDK_CPP_SYSMSG_H_ | 43.957219 | 149 | 0.614842 |
4db8a84551c148c7557173abc30d2b7292da88b8 | 6,659 | c | C | src/core/core.c | JirJIN/core | 0199fddc6092d78e4c0613dfdc7a176cd5037255 | [
"Zlib"
] | null | null | null | src/core/core.c | JirJIN/core | 0199fddc6092d78e4c0613dfdc7a176cd5037255 | [
"Zlib"
] | null | null | null | src/core/core.c | JirJIN/core | 0199fddc6092d78e4c0613dfdc7a176cd5037255 | [
"Zlib"
] | null | null | null | #include "core.h"
#include "gll/gll.h"
#include "time.h"
#include "thread/thread.h"
#include "window/window.h"
#include "env/env.h"
struct JIN_Window *root; /* Root window */
struct JIN_Env env; /* Environment variables */
struct JIN_Input JIN_inputv = {0};
struct JIN_Input JIN_input = {0};
/* CORE FUNCTIONS */
/*
* JIN_init
*
* @desc
* Initialize JIN
* @return
* 0 on success
* !0 on failure
*/
int JIN_init(void)
{
if (JIN_logger_init(JIN_LOGGER_CONSOLE, JIN_LOGGER_ERR)) return -1;
if (JIN_env_init(&JIN_env)) ERR_EXIT(-1, "Could not initialize the environment");
if (!(root = JIN_window_create())) ERR_EXIT(-1, "Could not create the root window");
return 0;
}
/*
* JIN_quit
*
* @desc
* Quit JIN
* @return
* 0 on success
*/
int JIN_quit(void)
{
JIN_window_destroy(root);
JIN_env_quit(&JIN_env);
JIN_logger_quit();
return 0;
}
#define FPS 30
#define FRAME_DELAY (1000 / FPS)
void JIN_tick(void)
{
clock_t frame_start, frame_end;
double frame_time;
frame_start = clock();
JIN_input = JIN_inputv;
JIN_update();
JIN_draw();
frame_end = clock();
frame_time = (frame_end - frame_start) / CLOCKS_PER_SEC / 1000;
if (FRAME_DELAY > frame_time) {
JIN_sleep(FRAME_DELAY - frame_time);
}
}
float r, g, b;
/*
* JIN_update
*
* @desc
* Update stuff
* @return
* 0 on success
*/
int JIN_update(void)
{
if (JIN_input.keys.f1) {
r = 0.2f, g = 0.3f, b = 0.3f;
}
if (JIN_input.keys.f2) {
r = 0.2f, g = 0.6f, b = 0.8f;
}
if (JIN_input.keys.f3) {
JIN_window_size_set(root, 480, 320);
}
if (JIN_input.keys.f4) {
JIN_window_size_set(root, 960, 640);
}
return 0;
}
/*
* JIN_draw
*
* @desc
* Draw stuff
* @return
* 0 on success
*/
unsigned int VAO;
unsigned int shaderProgram;
int JIN_draw(void)
{
glClearColor(r, g, b, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
int w, h;
JIN_window_size_get(root, &w, &h);
glViewport(0, 0, w, h);
// draw our first triangle
glUseProgram(shaderProgram);
glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
glDrawArrays(GL_TRIANGLES, 0, 3);
JIN_window_buffer_swap(root);
JIN_window_buffer_swap(root);
return 0;
}
#include <stdio.h>
const char *vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
const char *fragmentShaderSource = "#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
"}\n\0";
/* This shouldn't be needed but is for some reason, GLAPIENTRY is not defined */
#ifdef _WIN32
#define GLAPIENTRY __stdcall
#endif
void GLAPIENTRY gl_err_callback(GLenum src, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *msg, const void *usr_param)
{
if (severity != GL_DEBUG_SEVERITY_NOTIFICATION)
LOG(ERR, "GL CALLBACK: type = 0x%x, severity = 0x%x, message = %s\n", type, severity, msg);
}
JIN_THREAD_FN JIN_game_thread(void *data)
{
JIN_window_gl_set(root);
JIN_gll();
/* This is only in openGL 4...
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(gl_err_callback, 0);
*/
/* Learn OpenGL #1 triangle, THIS IS NOT MY CODE, JUST FOR TEMPORARY TESTING (checkout src, good stuff in there) */
// build and compile our shader program
// ------------------------------------
// vertex shader
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);
// check for shader compile errors
int success;
char infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
printf("Shader compilation failed: %s\n", infoLog);
}
// fragment shader
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
// check for shader compile errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
printf("Shader compilation failed: %s\n", infoLog);
}
// link shaders
shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
// check for linking errors
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
printf("Shader linking failed: %s\n", infoLog);
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// set up vertex data (and buffer(s)) and configure vertex attributes
// ------------------------------------------------------------------
float vertices[] = {
0.0f, 0.5f, 0.0f, // top
0.5f, -0.5f, 0.0f, // bottom right
-0.5f, -0.5f, 0.0f, // bottom left
};
unsigned int VBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
// note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
glBindBuffer(GL_ARRAY_BUFFER, 0);
// You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
// VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
glBindVertexArray(0);
r = 0.2f, g = 0.3f, b = 0.3f;
JIN_tick();
JIN_dialog("Starting game loop");
JIN_tick();
JIN_dialog("Really long string. Let's try to get some overflow and see what happens...");
while (1) {
if (JIN_input.quit) break;
JIN_tick();
}
JIN_window_gl_unset(root);
return 0;
}
int JIN_dialog(const char* msg)
{
JIN_window_dialog(root, msg);
return 0;
}
| 26.320158 | 170 | 0.659558 |
4db9fa10b48571b14339d60e12adc046b0c35a49 | 442 | h | C | CallTraceForWeChat/CallTraceForWeChat/WeChat_Headers/WNSelectionViewDelegate-Protocol.h | ceekay1991/CallTraceForWeChat | 5767cb6f781821b6bf9facc8c87e58e15fa88541 | [
"MIT"
] | 30 | 2020-03-22T12:30:21.000Z | 2022-02-09T08:49:13.000Z | CallTraceForWeChat/CallTraceForWeChat/WeChat_Headers/WNSelectionViewDelegate-Protocol.h | ceekay1991/CallTraceForWeChat | 5767cb6f781821b6bf9facc8c87e58e15fa88541 | [
"MIT"
] | null | null | null | CallTraceForWeChat/CallTraceForWeChat/WeChat_Headers/WNSelectionViewDelegate-Protocol.h | ceekay1991/CallTraceForWeChat | 5767cb6f781821b6bf9facc8c87e58e15fa88541 | [
"MIT"
] | 8 | 2020-03-22T12:30:23.000Z | 2020-09-22T04:01:47.000Z | //
// Generated by class-dump 3.5 (64 bit) (Debug version compiled Sep 17 2017 16:24:48).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2015 by Steve Nygard.
//
#import "MMUIViewControllerDelegate-Protocol.h"
@class MMUIViewController;
@protocol WNSelectionViewDelegate <MMUIViewControllerDelegate>
- (MMUIViewController *)getCurrentViewController;
- (void)setPopGestureEnable:(_Bool)arg1;
- (_Bool)bEditable;
@end
| 26 | 90 | 0.751131 |
4dbb7f1ed7b38f9c5ec82226c900f7f4ad654c94 | 2,299 | h | C | Networking/Bomb.h | devilmhzx/UE4-Cpp-Tutorials | 2cbf9d44dd4fa1c4eb68530f692065fc2c36b55d | [
"MIT"
] | 531 | 2016-10-19T14:04:55.000Z | 2022-03-28T06:34:25.000Z | Networking/Bomb.h | devilmhzx/UE4-Cpp-Tutorials | 2cbf9d44dd4fa1c4eb68530f692065fc2c36b55d | [
"MIT"
] | null | null | null | Networking/Bomb.h | devilmhzx/UE4-Cpp-Tutorials | 2cbf9d44dd4fa1c4eb68530f692065fc2c36b55d | [
"MIT"
] | 172 | 2016-10-18T14:53:11.000Z | 2022-03-22T10:39:44.000Z | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "GameFramework/Actor.h"
#include "GameFramework/ProjectileMovementComponent.h"
#include "Bomb.generated.h"
UCLASS()
class NETWORKINGTUT_API ABomb : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
ABomb();
// Called when the game starts or when spawned
virtual void BeginPlay() override;
protected:
/** The static mesh of the comp */
UPROPERTY(VisibleAnywhere)
UStaticMeshComponent* SM;
/** The projectile movement comp */
UPROPERTY(VisibleAnywhere)
UProjectileMovementComponent* ProjectileMovementComp;
/** Sphere comp used for collision. Movement component need a collision component as root to function properly */
UPROPERTY(VisibleAnywhere)
USphereComponent* SphereComp;
/** The delay until explosion */
UPROPERTY(EditAnywhere, Category = BombProps)
float FuseTime = 2.5f;
UPROPERTY(EditAnywhere, Category = BombProps)
float ExplosionRadius = 200.f;
UPROPERTY(EditAnywhere, Category = BombProps)
float ExplosionDamage = 25.f;
/** The particle system of the explosion */
UPROPERTY(EditAnywhere)
UParticleSystem* ExplosionFX;
private:
/** Marks the properties we wish to replicate */
virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
UPROPERTY(ReplicatedUsing = OnRep_IsArmed)
bool bIsArmed = false;
/** Called when bIsArmed gets updated */
UFUNCTION()
void OnRep_IsArmed();
/** Arms the bomb for explosion */
void ArmBomb();
/** Called when our bomb bounces */
UFUNCTION()
void OnProjectileBounce(const FHitResult& ImpactResult, const FVector& ImpactVelocity);
/** Performs an explosion after a certain amount of time */
void PerformDelayedExplosion(float ExplosionDelay);
/** Performs an explosion when called */
UFUNCTION()
void Explode();
//Simulate explosion functions
/**
* The multicast specifier, indicates that every client will call the SimulateExplosionFX_Implementation.
* You don't have to generate an implementation for this function.
*/
UFUNCTION(Reliable, NetMulticast)
void SimulateExplosionFX();
/** The actual implementation of the SimulateExplosionFX */
void SimulateExplosionFX_Implementation();
};
| 26.425287 | 114 | 0.765985 |
4dbc0c2ab834746824b145fee4d7a019c782c4c4 | 549 | h | C | include/tewi/EventSystem/Event.h | andry-dev/tewi | eb75eb8a00ee61f36f1df5040e25928089745d77 | [
"MIT"
] | null | null | null | include/tewi/EventSystem/Event.h | andry-dev/tewi | eb75eb8a00ee61f36f1df5040e25928089745d77 | [
"MIT"
] | null | null | null | include/tewi/EventSystem/Event.h | andry-dev/tewi | eb75eb8a00ee61f36f1df5040e25928089745d77 | [
"MIT"
] | null | null | null | #ifndef EVENT_SYSTEM_EVENT_H
#define EVENT_SYSTEM_EVENT_H
#include <cstdint>
#include "EventType.h"
namespace tewi
{
namespace EventSystem
{
class Event
{
public:
auto getType() { return m_eventType; }
protected:
Event(std::uint32_t eventType)
: m_eventType(eventType)
{
}
private:
std::uint32_t m_eventType = EventType::Null_event;
};
}
}
#endif /* EVENT_SYSTEM_EVENT_H */
| 15.685714 | 62 | 0.522769 |
4dc1de91c16fa3fb6c23d1a0f1f3b6f956eee025 | 1,004 | h | C | LibFoundation/Mathematics/Wm4Sphere3.h | wjezxujian/WildMagic4 | 249a17f8c447cf57c6283408e01009039810206a | [
"BSL-1.0"
] | 3 | 2021-08-02T04:03:03.000Z | 2022-01-04T07:31:20.000Z | LibFoundation/Mathematics/Wm4Sphere3.h | wjezxujian/WildMagic4 | 249a17f8c447cf57c6283408e01009039810206a | [
"BSL-1.0"
] | null | null | null | LibFoundation/Mathematics/Wm4Sphere3.h | wjezxujian/WildMagic4 | 249a17f8c447cf57c6283408e01009039810206a | [
"BSL-1.0"
] | 5 | 2019-10-13T02:44:19.000Z | 2021-08-02T04:03:10.000Z | // Geometric Tools, Inc.
// http://www.geometrictools.com
// Copyright (c) 1998-2006. All Rights Reserved
//
// The Wild Magic Version 4 Foundation Library source code is supplied
// under the terms of the license agreement
// http://www.geometrictools.com/License/Wm4FoundationLicense.pdf
// and may not be copied or disclosed except in accordance with the terms
// of that agreement.
#ifndef WM4SPHERE3_H
#define WM4SPHERE3_H
#include "Wm4FoundationLIB.h"
#include "Wm4Vector3.h"
namespace Wm4
{
template <class Real>
class Sphere3
{
public:
// The sphere is represented as |X-C| = R where C is the center and R is
// the radius.
Sphere3 (); // uninitialized
Sphere3 (const Vector3<Real>& rkCenter, Real fRadius);
Sphere3 (const Sphere3& rkSphere);
// assignment
Sphere3& operator= (const Sphere3& rkSphere);
Vector3<Real> Center;
Real Radius;
};
#include "Wm4Sphere3.inl"
typedef Sphere3<float> Sphere3f;
typedef Sphere3<double> Sphere3d;
}
#endif
| 21.826087 | 76 | 0.716135 |
4dc2133e8b564516ffbde64868ce68e06ce7f54e | 386 | h | C | PrivateFrameworks/XQuery/XQueryFilterStep.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 17 | 2018-11-13T04:02:58.000Z | 2022-01-20T09:27:13.000Z | PrivateFrameworks/XQuery/XQueryFilterStep.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 3 | 2018-04-06T02:02:27.000Z | 2018-10-02T01:12:10.000Z | PrivateFrameworks/XQuery/XQueryFilterStep.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 1 | 2018-09-28T13:54:23.000Z | 2018-09-28T13:54:23.000Z | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import <XQuery/XQueryStep.h>
__attribute__((visibility("hidden")))
@interface XQueryFilterStep : XQueryStep
{
}
+ (id)filterStepWithExpr:(id)arg1;
- (void)processItems:(id)arg1 toResults:(id)arg2 forContext:(id)arg3 validate:(BOOL)arg4;
@end
| 20.315789 | 89 | 0.699482 |
4dc253d5a4deb534278a32bcfad5b91fc6099257 | 298 | h | C | include_pybind11.h | after5cst/pybind11_gil_demo | 2fb9e457c1b0646b013ed4de16b15f20028c8b34 | [
"MIT"
] | 2 | 2019-10-08T02:38:10.000Z | 2020-01-28T16:33:33.000Z | include_pybind11.h | after5cst/pybind11_gil_demo | 2fb9e457c1b0646b013ed4de16b15f20028c8b34 | [
"MIT"
] | 1 | 2019-10-08T02:30:58.000Z | 2019-10-21T00:11:00.000Z | include_pybind11.h | after5cst/pybind11_gil_demo | 2fb9e457c1b0646b013ed4de16b15f20028c8b34 | [
"MIT"
] | null | null | null | #pragma once
// Include the pybind11 headers, suppressing warnings
// that we don't allow in our own code.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#include "pybind11/include/pybind11/pybind11.h"
#include "pybind11/include/pybind11/chrono.h"
#pragma GCC diagnostic pop
| 33.111111 | 53 | 0.781879 |
4dc25f506b4624f5436488d3df846a0ef306717b | 1,014 | h | C | src/vglTiffIo.h | HDANILO/visiongl | 7cff4404a1ac9ff6db6b44742d72bdb9004aba84 | [
"Apache-2.0"
] | 12 | 2015-09-04T08:09:43.000Z | 2018-11-03T15:49:30.000Z | src/vglTiffIo.h | HDANILO/visiongl | 7cff4404a1ac9ff6db6b44742d72bdb9004aba84 | [
"Apache-2.0"
] | 14 | 2015-01-09T19:43:50.000Z | 2019-04-18T17:09:26.000Z | src/vglTiffIo.h | HDANILO/visiongl | 7cff4404a1ac9ff6db6b44742d72bdb9004aba84 | [
"Apache-2.0"
] | 9 | 2015-10-06T00:31:27.000Z | 2022-03-14T17:49:18.000Z | /*********************************************************************
*** ***
*** Header file vglTiffIo.h ***
*** ***
*********************************************************************/
#ifndef __VGLTIFFIO_H__
#define __VGLTIFFIO_H__
#ifdef __TIFF__
#include <vglImage.h>
//IplImage
#ifdef __OPENCV__
#include <opencv2/core/types_c.h>
#else
#include <vglOpencv.h>
#endif
VglImage* vglLoadTiff(char* inFilename);
IplImage* iplLoadTiff(char* inFilename);
VglImage* vglLoadTiffAlt(char* inFilename);
VglImage* vglLoad4dTiff(char* filename, int lStart, int lEnd, bool has_mipmap = 0);
int vglSaveTiff(char* outFilename, VglImage* image);
int iplSaveTiff(char* outFilename, IplImage* image);
int vglSave4dTiff(char* filename, VglImage* image, int lStart, int lEnd);
int vglPrintTiffInfo(char* inFilename, char* msg = NULL);
#endif
#endif
| 29.823529 | 83 | 0.519724 |
4dc3dcb56cfc4b7a977743bf7ef60f068003427e | 1,041 | h | C | PrivateFrameworks/PreferencePanesSupport/IOServiceObserver.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 17 | 2018-11-13T04:02:58.000Z | 2022-01-20T09:27:13.000Z | PrivateFrameworks/PreferencePanesSupport/IOServiceObserver.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 3 | 2018-04-06T02:02:27.000Z | 2018-10-02T01:12:10.000Z | PrivateFrameworks/PreferencePanesSupport/IOServiceObserver.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 1 | 2018-09-28T13:54:23.000Z | 2018-09-28T13:54:23.000Z | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import "NSObject.h"
@interface IOServiceObserver : NSObject
{
id mTarget;
SEL mSelector;
unsigned int mIOConnectIterator;
unsigned int mIOTerminateIterator;
}
+ (id)observerForConnectService:(struct __CFDictionary *)arg1 target:(id)arg2 selector:(SEL)arg3;
+ (id)observerForService:(struct __CFDictionary *)arg1 target:(id)arg2 selector:(SEL)arg3;
+ (void)_closeNotificationPort;
+ (struct IONotificationPort *)_openNotificationPort;
@property(readonly) SEL selector; // @synthesize selector=mSelector;
@property(readonly) id target; // @synthesize target=mTarget;
- (void).cxx_destruct;
- (void)armIterators;
- (unsigned int)terminateIterator;
- (unsigned int)connectIterator;
- (void)dealloc;
- (id)initForConnectService:(struct __CFDictionary *)arg1 target:(id)arg2 selector:(SEL)arg3;
- (id)initForService:(struct __CFDictionary *)arg1 target:(id)arg2 selector:(SEL)arg3;
@end
| 31.545455 | 97 | 0.746398 |
4dc6ddc3404bb49d2562b44d5f68fdeaef80de0e | 14,139 | h | C | code/include/playfab/PFAnalytics.h | PlayFab/XPlatCSdk | 101896fff5c5ce822dd188e4670a9ba8c1705619 | [
"MIT"
] | null | null | null | code/include/playfab/PFAnalytics.h | PlayFab/XPlatCSdk | 101896fff5c5ce822dd188e4670a9ba8c1705619 | [
"MIT"
] | 1 | 2022-03-04T20:50:28.000Z | 2022-03-04T21:02:12.000Z | code/include/playfab/PFAnalytics.h | PlayFab/XPlatCSdk | 101896fff5c5ce822dd188e4670a9ba8c1705619 | [
"MIT"
] | 3 | 2021-12-04T20:43:04.000Z | 2022-01-03T21:16:32.000Z | // Copyright (c) Microsoft Corporation
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#if !defined(__cplusplus)
#error C++11 required
#endif
#pragma once
#include <playfab/PFAnalyticsDataModels.h>
#include <playfab/PFGlobal.h>
#include <playfab/PFTitlePlayer.h>
extern "C"
{
/// <summary>
/// Write a PlayStream event to describe the provided player device information. This API method is not
/// designed to be called directly by developers. Each PlayFab client SDK will eventually report this
/// information automatically.
/// </summary>
/// <param name="entityHandle">PFTitlePlayerHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// Any arbitrary information collected by the device.
///
/// Call <see cref="XAsyncGetStatus"/> to get the status of the operation.
/// </remarks>
HRESULT PFAnalyticsClientReportDeviceInfoAsync(
_In_ PFTitlePlayerHandle titlePlayerHandle,
_In_ const PFAnalyticsDeviceInfoRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
#if HC_PLATFORM != HC_PLATFORM_GDK
/// <summary>
/// Gets the current values for the Insights performance and data storage retention, list of pending
/// operations, and the performance and data storage retention limits.
/// </summary>
/// <param name="entityHandle">PFEntityHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// If successful, call <see cref="PFAnalyticsGetDetailsGetResult"/> to get the result.
/// </remarks>
HRESULT PFAnalyticsGetDetailsAsync(
_In_ PFEntityHandle entityHandle,
_In_ const PFAnalyticsInsightsEmptyRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
/// <summary>
/// Get the size in bytes needed to store the result of a GetDetails call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The buffer size in bytes required for the result.</param>
/// <returns>Result code for this API operation.</returns>
HRESULT PFAnalyticsGetDetailsGetResultSize(
_Inout_ XAsyncBlock* async,
_Out_ size_t* bufferSize
) noexcept;
/// <summary>
/// Gets the result of a successful PFAnalyticsGetDetailsAsync call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The size of the buffer for the result object.</param>
/// <param name="buffer">Byte buffer used for the result value and its fields.</param>
/// <param name="result">Pointer to the result object.</param>
/// <param name="bufferUsed">The number of bytes in the provided buffer that were used.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// result is a pointer within buffer and does not need to be freed separately.
/// </remarks>
HRESULT PFAnalyticsGetDetailsGetResult(
_Inout_ XAsyncBlock* async,
_In_ size_t bufferSize,
_Out_writes_bytes_to_(bufferSize, *bufferUsed) void* buffer,
_Outptr_ PFAnalyticsInsightsGetDetailsResponse** result,
_Out_opt_ size_t* bufferUsed
) noexcept;
#endif
#if HC_PLATFORM != HC_PLATFORM_GDK
/// <summary>
/// Retrieves the range of allowed values for performance and data storage retention values as well as
/// the submeter details for each performance level.
/// </summary>
/// <param name="entityHandle">PFEntityHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// If successful, call <see cref="PFAnalyticsGetLimitsGetResult"/> to get the result.
/// </remarks>
HRESULT PFAnalyticsGetLimitsAsync(
_In_ PFEntityHandle entityHandle,
_In_ const PFAnalyticsInsightsEmptyRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
/// <summary>
/// Get the size in bytes needed to store the result of a GetLimits call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The buffer size in bytes required for the result.</param>
/// <returns>Result code for this API operation.</returns>
HRESULT PFAnalyticsGetLimitsGetResultSize(
_Inout_ XAsyncBlock* async,
_Out_ size_t* bufferSize
) noexcept;
/// <summary>
/// Gets the result of a successful PFAnalyticsGetLimitsAsync call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The size of the buffer for the result object.</param>
/// <param name="buffer">Byte buffer used for the result value and its fields.</param>
/// <param name="result">Pointer to the result object.</param>
/// <param name="bufferUsed">The number of bytes in the provided buffer that were used.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// result is a pointer within buffer and does not need to be freed separately.
/// </remarks>
HRESULT PFAnalyticsGetLimitsGetResult(
_Inout_ XAsyncBlock* async,
_In_ size_t bufferSize,
_Out_writes_bytes_to_(bufferSize, *bufferUsed) void* buffer,
_Outptr_ PFAnalyticsInsightsGetLimitsResponse** result,
_Out_opt_ size_t* bufferUsed
) noexcept;
#endif
#if HC_PLATFORM != HC_PLATFORM_GDK
/// <summary>
/// Gets the status of a SetPerformance or SetStorageRetention operation.
/// </summary>
/// <param name="entityHandle">PFEntityHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// If successful, call <see cref="PFAnalyticsGetOperationStatusGetResult"/> to get the result.
/// </remarks>
HRESULT PFAnalyticsGetOperationStatusAsync(
_In_ PFEntityHandle entityHandle,
_In_ const PFAnalyticsInsightsGetOperationStatusRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
/// <summary>
/// Get the size in bytes needed to store the result of a GetOperationStatus call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The buffer size in bytes required for the result.</param>
/// <returns>Result code for this API operation.</returns>
HRESULT PFAnalyticsGetOperationStatusGetResultSize(
_Inout_ XAsyncBlock* async,
_Out_ size_t* bufferSize
) noexcept;
/// <summary>
/// Gets the result of a successful PFAnalyticsGetOperationStatusAsync call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The size of the buffer for the result object.</param>
/// <param name="buffer">Byte buffer used for the result value and its fields.</param>
/// <param name="result">Pointer to the result object.</param>
/// <param name="bufferUsed">The number of bytes in the provided buffer that were used.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// result is a pointer within buffer and does not need to be freed separately.
/// </remarks>
HRESULT PFAnalyticsGetOperationStatusGetResult(
_Inout_ XAsyncBlock* async,
_In_ size_t bufferSize,
_Out_writes_bytes_to_(bufferSize, *bufferUsed) void* buffer,
_Outptr_ PFAnalyticsInsightsGetOperationStatusResponse** result,
_Out_opt_ size_t* bufferUsed
) noexcept;
#endif
#if HC_PLATFORM != HC_PLATFORM_GDK
/// <summary>
/// Gets a list of pending SetPerformance and/or SetStorageRetention operations for the title.
/// </summary>
/// <param name="entityHandle">PFEntityHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// If successful, call <see cref="PFAnalyticsGetPendingOperationsGetResult"/> to get the result.
/// </remarks>
HRESULT PFAnalyticsGetPendingOperationsAsync(
_In_ PFEntityHandle entityHandle,
_In_ const PFAnalyticsInsightsGetPendingOperationsRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
/// <summary>
/// Get the size in bytes needed to store the result of a GetPendingOperations call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The buffer size in bytes required for the result.</param>
/// <returns>Result code for this API operation.</returns>
HRESULT PFAnalyticsGetPendingOperationsGetResultSize(
_Inout_ XAsyncBlock* async,
_Out_ size_t* bufferSize
) noexcept;
/// <summary>
/// Gets the result of a successful PFAnalyticsGetPendingOperationsAsync call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The size of the buffer for the result object.</param>
/// <param name="buffer">Byte buffer used for the result value and its fields.</param>
/// <param name="result">Pointer to the result object.</param>
/// <param name="bufferUsed">The number of bytes in the provided buffer that were used.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// result is a pointer within buffer and does not need to be freed separately.
/// </remarks>
HRESULT PFAnalyticsGetPendingOperationsGetResult(
_Inout_ XAsyncBlock* async,
_In_ size_t bufferSize,
_Out_writes_bytes_to_(bufferSize, *bufferUsed) void* buffer,
_Outptr_ PFAnalyticsInsightsGetPendingOperationsResponse** result,
_Out_opt_ size_t* bufferUsed
) noexcept;
#endif
#if HC_PLATFORM != HC_PLATFORM_GDK
/// <summary>
/// Sets the Insights performance level value for the title.
/// </summary>
/// <param name="entityHandle">PFEntityHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// If successful, call <see cref="PFAnalyticsSetPerformanceGetResult"/> to get the result.
/// </remarks>
HRESULT PFAnalyticsSetPerformanceAsync(
_In_ PFEntityHandle entityHandle,
_In_ const PFAnalyticsInsightsSetPerformanceRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
/// <summary>
/// Get the size in bytes needed to store the result of a SetPerformance call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The buffer size in bytes required for the result.</param>
/// <returns>Result code for this API operation.</returns>
HRESULT PFAnalyticsSetPerformanceGetResultSize(
_Inout_ XAsyncBlock* async,
_Out_ size_t* bufferSize
) noexcept;
/// <summary>
/// Gets the result of a successful PFAnalyticsSetPerformanceAsync call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The size of the buffer for the result object.</param>
/// <param name="buffer">Byte buffer used for the result value and its fields.</param>
/// <param name="result">Pointer to the result object.</param>
/// <param name="bufferUsed">The number of bytes in the provided buffer that were used.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// result is a pointer within buffer and does not need to be freed separately.
/// </remarks>
HRESULT PFAnalyticsSetPerformanceGetResult(
_Inout_ XAsyncBlock* async,
_In_ size_t bufferSize,
_Out_writes_bytes_to_(bufferSize, *bufferUsed) void* buffer,
_Outptr_ PFAnalyticsInsightsOperationResponse** result,
_Out_opt_ size_t* bufferUsed
) noexcept;
#endif
#if HC_PLATFORM != HC_PLATFORM_GDK
/// <summary>
/// Sets the Insights data storage retention days value for the title.
/// </summary>
/// <param name="entityHandle">PFEntityHandle to use for authentication.</param>
/// <param name="request">Populated request object.</param>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// If successful, call <see cref="PFAnalyticsSetStorageRetentionGetResult"/> to get the result.
/// </remarks>
HRESULT PFAnalyticsSetStorageRetentionAsync(
_In_ PFEntityHandle entityHandle,
_In_ const PFAnalyticsInsightsSetStorageRetentionRequest* request,
_Inout_ XAsyncBlock* async
) noexcept;
/// <summary>
/// Get the size in bytes needed to store the result of a SetStorageRetention call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The buffer size in bytes required for the result.</param>
/// <returns>Result code for this API operation.</returns>
HRESULT PFAnalyticsSetStorageRetentionGetResultSize(
_Inout_ XAsyncBlock* async,
_Out_ size_t* bufferSize
) noexcept;
/// <summary>
/// Gets the result of a successful PFAnalyticsSetStorageRetentionAsync call.
/// </summary>
/// <param name="async">XAsyncBlock for the async operation.</param>
/// <param name="bufferSize">The size of the buffer for the result object.</param>
/// <param name="buffer">Byte buffer used for the result value and its fields.</param>
/// <param name="result">Pointer to the result object.</param>
/// <param name="bufferUsed">The number of bytes in the provided buffer that were used.</param>
/// <returns>Result code for this API operation.</returns>
/// <remarks>
/// result is a pointer within buffer and does not need to be freed separately.
/// </remarks>
HRESULT PFAnalyticsSetStorageRetentionGetResult(
_Inout_ XAsyncBlock* async,
_In_ size_t bufferSize,
_Out_writes_bytes_to_(bufferSize, *bufferUsed) void* buffer,
_Outptr_ PFAnalyticsInsightsOperationResponse** result,
_Out_opt_ size_t* bufferUsed
) noexcept;
#endif
} | 42.332335 | 103 | 0.745951 |
4dca878b90bd0507e05afe5c6273a0b79053eb0b | 1,020 | c | C | test/asynctest-drystream.c | rauhma/async | 699864d96e28eb2a5a7b0a8b01f73db175306270 | [
"Apache-2.0"
] | null | null | null | test/asynctest-drystream.c | rauhma/async | 699864d96e28eb2a5a7b0a8b01f73db175306270 | [
"Apache-2.0"
] | 3 | 2020-06-05T16:55:15.000Z | 2021-12-29T08:55:11.000Z | test/asynctest-drystream.c | rauhma/async | 699864d96e28eb2a5a7b0a8b01f73db175306270 | [
"Apache-2.0"
] | 14 | 2020-02-10T09:30:50.000Z | 2021-08-18T11:05:17.000Z | #include "asynctest-drystream.h"
#include <errno.h>
#include <async/async.h>
#include <async/drystream.h>
static void dry_probe(tester_base_t *context)
{
uint8_t buffer[100];
ssize_t count = bytestream_1_read(drystream, buffer, sizeof buffer);
if (count >= 0 || errno != EAGAIN) {
context->verdict = FAIL;
quit_test(context);
}
}
VERDICT test_drystream(void)
{
async_t *async = make_async();
tester_base_t context;
init_test(&context, async, 2);
context.verdict = PASS;
action_1 probe = { &context, (act_1) dry_probe };
bytestream_1_register_callback(drystream, probe);
async_execute(async, probe);
if (async_loop(async) < 0)
tlog("Unexpected error from async_loop: %d", errno);
bytestream_1_close(drystream);
destroy_async(async);
uint8_t buffer[100];
ssize_t count = bytestream_1_read(drystream, buffer, sizeof buffer);
if (count >= 0 || errno != EAGAIN)
return FAIL;
return posttest_check(context.verdict);
}
| 27.567568 | 72 | 0.67451 |
4dcb339197c6c7cc315030e95cb8f3cec0a38413 | 6,351 | c | C | nfc/mnfc.c | blarz/heiko | c99da90709a7a21498257a2922f7663a8d5547a9 | [
"MIT"
] | 3 | 2018-05-19T13:10:07.000Z | 2019-01-08T17:50:53.000Z | nfc/mnfc.c | blarz/heiko | c99da90709a7a21498257a2922f7663a8d5547a9 | [
"MIT"
] | 44 | 2019-01-07T09:06:41.000Z | 2019-11-07T22:04:30.000Z | nfc/mnfc.c | blarz/heiko | c99da90709a7a21498257a2922f7663a8d5547a9 | [
"MIT"
] | 3 | 2019-06-13T19:23:06.000Z | 2019-08-08T18:55:13.000Z | /*
Mifare NFC Python Module for Heiko
Copyright (C) 2019 Christian Carlowitz <chca@cmesh.de>
This program 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 3 of the License, or (at your
option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <nfc/nfc.h>
#include <freefare.h>
#include <Python.h>
nfc_device* device = 0;
nfc_context* context = 0;
static PyObject* mnfc_init(PyObject* self, PyObject* args)
{
const int devicesLen = 8;
nfc_connstring devices[devicesLen];
size_t ndev;
nfc_init(&context);
if(!context)
{
printf("NFC: unable to init libnfc\n");
return Py_BuildValue("i",0);
}
ndev = nfc_list_devices(context, devices, devicesLen);
if(ndev <= 0)
{
printf("NFC: no device found\n");
return Py_BuildValue("i",0);
}
int devFound = 0;
for (size_t d = 0; d < ndev; d++)
{
device = nfc_open(context, devices[d]);
if(!device)
{
printf("NFC: nfc_open() failed\n");
continue;
}
devFound = 1;
break;
}
return Py_BuildValue("i", devFound);
}
static PyObject* mnfc_deinit(PyObject* self, PyObject* args)
{
if(device)
nfc_close(device);
if(context)
nfc_exit(context);
return Py_BuildValue("i", 1);
}
static PyObject* mnfc_read(PyObject* self, PyObject* args)
{
if(!device)
return Py_BuildValue("issy", 10, "", "", 0);
int ret = 0;
#define MAX_SECS 16
#define MAX_BLOCKS MAX_SECS*4
MifareClassicBlock* block = malloc(sizeof(MifareClassicBlock)*MAX_BLOCKS);
int secStart;
int secNum;
MifareClassicKey key = {0xff,0xff,0xff,0xff,0xff,0xff};
const char* keyInput;
int keyLen;
int readKeys;
PyArg_ParseTuple(args, "iiy#i", &secStart, &secNum, &keyInput, &keyLen, &readKeys);
if(secNum > MAX_SECS)
secNum = MAX_SECS;
if(keyLen >= 6)
memcpy(key, keyInput, 6);
int nb = readKeys ? 4 : 3;
#define MAX_UID_LEN 16
char firstTagUid[MAX_UID_LEN+1] = {0};
#define MAX_TTYPE_LEN 32
char firstTagType[MAX_TTYPE_LEN+1] = {0};
Py_BEGIN_ALLOW_THREADS
MifareTag* tags = freefare_get_tags(device);
if(!tags)
{
printf("NFC: device error while listing tags\n");
ret = 1;
goto error;
}
for (int i = 0; tags[i]; i++)
{
char* tag_uid = freefare_get_tag_uid(tags[i]);
const char* ttype = freefare_get_tag_friendly_name(tags[i]);
if(i == 0)
{
strncpy(firstTagUid, tag_uid, MAX_UID_LEN);
strncpy(firstTagType, ttype, MAX_TTYPE_LEN);
}
else
{
printf("NFC: warning: found additional tag %s with UID %s\n", ttype, tag_uid);
}
free(tag_uid);
}
if(tags[0])
{
if(mifare_classic_connect(tags[0]))
{
printf("NFC: mifare_classic_connect failed\n");
ret = 2;
goto error;
}
int bcount = 0;
for(int n = 0; n < secNum; n++)
{
MifareClassicBlockNumber b = (secStart+n)*4;
if(mifare_classic_authenticate(tags[0], b, key, MFC_KEY_A))
{
printf("NFC: auth failed\n");
ret = 3;
goto error;
}
for(int k = 0; k < nb; k++)
{
int n = mifare_classic_read(tags[0], b + k, &block[bcount]);
bcount++;
if(n < 0)
{
printf("NFC: read error\n");
ret = 4;
goto error;
}
}
}
}
else
{
ret = 5;
}
error:
freefare_free_tags(tags);
Py_END_ALLOW_THREADS
if(!ret)
{
PyObject* o = Py_BuildValue("issy#",
ret, firstTagUid, firstTagType,
(const char*)block, sizeof(MifareClassicBlock)*nb*secNum);
free(block);
return o;
}
free(block);
return Py_BuildValue("issy", ret, "", "", 0);
}
static PyObject* mnfc_write(PyObject* self, PyObject* args)
{
if(!device)
return Py_BuildValue("i", 10);
int ret = 0;
int secStart;
int secNum;
const char* uid;
const char* data;
Py_ssize_t data_len;
MifareClassicKey key = {0xff};
const char* keyInput;
int keyLen;
int writeKeys;
PyArg_ParseTuple(args, "iisy#y#i", &secStart, &secNum, &uid, &data, &data_len, &keyInput, &keyLen, &writeKeys);
if(keyLen >= 6)
memcpy(key, keyInput, 6);
int nb = writeKeys ? 4 : 3;
if(data_len < sizeof(MifareClassicBlock)*nb*secNum)
{
printf("NFC: invalid write block len\n");
return Py_BuildValue("i", -1);
}
const MifareClassicBlock* block = (MifareClassicBlock*)data;
Py_BEGIN_ALLOW_THREADS
MifareTag* tags = freefare_get_tags(device);
if(!tags)
{
printf("NFC: device error while listing tags\n");
ret = 1;
goto error;
}
if(tags[0])
{
char* tag_uid = freefare_get_tag_uid(tags[0]);
if(strncmp(tag_uid, uid, MAX_UID_LEN) != 0)
{
printf("NFC: tag %s not found for write operation\n", uid);
ret = 2;
}
free(tag_uid);
if(!ret)
{
if(mifare_classic_connect(tags[0]))
{
printf("NFC: mifare_classic_connect failed\n");
ret = 3;
goto error;
}
for(int n = 0; n < secNum; n++)
{
MifareClassicBlockNumber b = (secStart+n)*4;
if(mifare_classic_authenticate(tags[0], b, key, MFC_KEY_B))
{
printf("NFC: auth failed\n");
ret = 4;
goto error;
}
for(int k = 0; k < nb; k++)
{
int r = mifare_classic_write(tags[0], b+k, block[n*nb+k]);
if(r < 0)
{
printf("NFC: write error\n");
ret = 5;
goto error;
}
}
}
}
}
else
{
ret = 6;
}
error:
freefare_free_tags(tags);
Py_END_ALLOW_THREADS
return Py_BuildValue("i", ret);
}
static PyMethodDef module_methods[] = {
{"init", &mnfc_init, METH_VARARGS, "initialize nfc backend"},
{"deinit", &mnfc_deinit, METH_VARARGS, "deinitialize nfc backend"},
{"read", &mnfc_read, METH_VARARGS, "read data from tag"},
{"write", &mnfc_write, METH_VARARGS, "write data to tag"},
{NULL, NULL, 0, NULL}
};
PyMODINIT_FUNC PyInit_mnfc(void)
{
PyObject* module;
static struct PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT,
"mnfc",
"basic NFC communication",
-1,
module_methods,
NULL,
NULL,
NULL,
NULL
};
module = PyModule_Create(&moduledef);
if(!module)
return NULL;
return module;
}
| 20.487097 | 112 | 0.658322 |
4dcb8786aef5e9c3a62d68061689d48cab1c5b68 | 3,542 | h | C | src/event/subscription.h | simula/flexran | 372a6e3398d839f4f87961217dbf6c5610464fbc | [
"Apache-2.0"
] | 2 | 2020-12-01T02:02:24.000Z | 2021-01-13T03:05:02.000Z | src/event/subscription.h | simula/flexran | 372a6e3398d839f4f87961217dbf6c5610464fbc | [
"Apache-2.0"
] | null | null | null | src/event/subscription.h | simula/flexran | 372a6e3398d839f4f87961217dbf6c5610464fbc | [
"Apache-2.0"
] | 2 | 2020-12-03T12:31:26.000Z | 2021-09-29T02:56:43.000Z | /*
* Copyright 2016-2018 FlexRAN Authors, Eurecom and The University of Edinburgh
* 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.
*
* For more information about Mosaic5G: contact@mosaic-5g.io
*/
/*! \file subscription.h
* \brief Event subscription: callback subscription for certain events
* \authors Robert Schmidt
* \company Eurecom
* \email robert.schmidt@eurecom.fr
*/
#ifndef SUBSCRIPTION_H_RRRR
#define SUBSCRIPTION_H_RRRR
#include <atomic>
#include <boost/signals2.hpp>
namespace bs2 = boost::signals2;
#include "callbacks.h"
namespace flexran {
namespace rib {
class rib_updater;
}
namespace core {
class task_manager;
}
}
namespace flexran {
namespace event {
class subscription {
public:
// friend classes can access private fields
friend class flexran::rib::rib_updater;
friend class flexran::core::task_manager;
subscription() : last_tick_(0) {}
uint64_t last_tick() const { return last_tick_; }
// in the following, functions without _extended subscribe to "simple"
// callback (as in callbacks.h), while the _extended versions subscribe
// to a callback passing the connection which can be used to disconnect.
// In both cases, they return the actual connection which can also be
// used to disconnect.
bs2::connection subscribe_bs_add(const bs_cb::slot_type& cb);
bs2::connection subscribe_bs_add_extended(const bs_cb::extended_slot_type& cb);
bs2::connection subscribe_bs_remove(const bs_cb::slot_type& cb);
bs2::connection subscribe_bs_remove_extended(const bs_cb::extended_slot_type& cb);
bs2::connection subscribe_ue_connect(const ue_cb::slot_type& cb);
bs2::connection subscribe_ue_connect_extended(const ue_cb::extended_slot_type& cb);
bs2::connection subscribe_ue_update(const ue_cb::slot_type& cb);
bs2::connection subscribe_ue_update_extended(const ue_cb::extended_slot_type& cb);
bs2::connection subscribe_ue_disconnect(const ue_cb::slot_type& cb);
bs2::connection subscribe_ue_disconnect_extended(const ue_cb::extended_slot_type& cb);
bs2::connection subscribe_task_tick(const task_cb::slot_type& cb,
uint64_t period, uint64_t start = 0);
bs2::connection subscribe_task_tick_extended(const task_cb::extended_slot_type& cb,
uint64_t period, uint64_t start = 0);
bs2::connection subscribe_control_del_req(
const msg_cb<protocol::flex_control_delegation_request>::slot_type& cb);
bs2::connection subscribe_control_del_req_extended(
const msg_cb<protocol::flex_control_delegation_request>::extended_slot_type& cb);
private:
bs_cb bs_add_;
bs_cb bs_remove_;
ue_cb ue_connect_;
ue_cb ue_update_;
ue_cb ue_disconnect_;
task_cb task_tick_;
std::atomic<uint64_t> last_tick_; // used to calculate offsets
msg_cb<protocol::flex_control_delegation_request> control_del_req_;
};
}
}
#endif /* SUBSCRIPTION_H_ */
| 36.142857 | 92 | 0.727273 |
4dcfd356daf15dda385d05c5a468230af0309bad | 690 | c | C | coding_interviews/q_8/nvidia2.c | darbinreyes/subparprogrammer | e3588adc494a69a564fe0a9859ff296fc710eab0 | [
"MIT"
] | null | null | null | coding_interviews/q_8/nvidia2.c | darbinreyes/subparprogrammer | e3588adc494a69a564fe0a9859ff296fc710eab0 | [
"MIT"
] | 1 | 2021-05-11T22:20:01.000Z | 2021-05-11T22:20:01.000Z | coding_interviews/q_8/nvidia2.c | darbinreyes/subparprogrammer | e3588adc494a69a564fe0a9859ff296fc710eab0 | [
"MIT"
] | null | null | null | // test
// input - unsigned int, output input with
// 1010 -> 0101
// 1
unsigned int swap_adj_bits (unsigned int v) {
int num_bits = sizeof(v) * 8;
unsigned int t0, t1;
int i;
// 1010
// 3210
// 0101
// 0x55555555
t0 = v & 0xAAAAAAAA;
t1 = v & 0x55555555;
v = (t0 >> 1) | (t1 << 1);
// for (i = 0; i < num_bits/2; i++) {
// t0 = v & (1 << i);
// t1 = v & (1 << (i + 1));
// v &= ~(1 << i);
// v &= ~(1 << (i + 1));
// //if (t0)
// // v |= (1 << (i + 1));
// v |= t0 << 1;
// //if (t1)
// // v |= (1 << i);
// v |= t1 >> 1;
// }
return v;
} | 18.157895 | 45 | 0.343478 |
4dd1c67454645b7b124343fa6c17054af5c3abcf | 1,398 | h | C | Item.h | keithbarker/3503_group_project | a13ad81d0c8565f92154cd12ace5f4da9e013639 | [
"MIT"
] | 1 | 2016-03-21T21:41:08.000Z | 2016-03-21T21:41:08.000Z | Item.h | keithbarker/3503_group_project | a13ad81d0c8565f92154cd12ace5f4da9e013639 | [
"MIT"
] | 2 | 2016-03-31T14:32:52.000Z | 2016-04-10T03:19:51.000Z | Item.h | keithbarker/3503_group_project | a13ad81d0c8565f92154cd12ace5f4da9e013639 | [
"MIT"
] | null | null | null | #pragma once
#include <string>
#include <QObject>
using namespace std;
class Item : public QObject //stores information for individual food and drink items
{
private:
Q_OBJECT
int itemsLeft;
double price;
string name;
string description;
string size;
string flavor;
int quantity;
vector<string> requested_extras; // Used to store selected "toppings".
vector<string> allowed_extras; // Used to store list of allowed "toppings".
public:
Item(); //default constructor declaration
//constructor called when instance of Food or Drink is created
Item(int itemsLeft, double price, string name, string description, string size, string flavor, int quantity);
/*getters and setter
methods declaration*/
void setItemsLeft(int itemsLeft);
int getItemsLeft();
void setPrice(double price);
double getPrice();
void setDescription(string description);
string getDescription();
void setName(string name);
string getName();
void setSize(string size);
string getSize();
void setFlavor(string flavor);
string getFlavor();
void increaseQuantity();
void decreaseQuantity();
int getQuantity();
void addExtra(string extra);
string getExtras();
void removeExtra(string extra);
void addAllowedExtras(vector<string> extras); //initializes vector with allowed toppings for each type of food item
};
| 23.3 | 121 | 0.716023 |
4dd3418e08c7e6fb88fe55828f83c7efbb89d86e | 258 | c | C | src/main.c | jsaka1259/sh | 6963d473f01987dd404031c2c1a82fb007a2d2ed | [
"MIT"
] | 1 | 2020-02-24T06:55:45.000Z | 2020-02-24T06:55:45.000Z | src/main.c | jsaka1259/sh | 6963d473f01987dd404031c2c1a82fb007a2d2ed | [
"MIT"
] | null | null | null | src/main.c | jsaka1259/sh | 6963d473f01987dd404031c2c1a82fb007a2d2ed | [
"MIT"
] | null | null | null | #include "common.h"
#define PROMPT "$ "
int main(int argc, char **argv) {
cmd_t *cmd = NULL;
while (1) {
fputs(PROMPT, stdout);
cmd = get_cmd();
while (!cmd->argv)
free(cmd->argv);
free(cmd);
cmd = NULL;
}
return 0;
}
| 12.285714 | 33 | 0.531008 |