blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
721
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
57
| license_type
stringclasses 2
values | repo_name
stringlengths 5
91
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 321
values | visit_date
timestamp[ns]date 2016-08-12 09:31:09
2023-09-06 10:45:07
| revision_date
timestamp[ns]date 2010-09-28 14:01:40
2023-09-06 06:22:19
| committer_date
timestamp[ns]date 2010-09-28 14:01:40
2023-09-06 06:22:19
| github_id
int64 426
681M
| star_events_count
int64 101
243k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[ns]date 2012-06-28 18:51:49
2023-09-14 21:59:16
⌀ | gha_created_at
timestamp[ns]date 2008-02-11 22:55:26
2023-08-10 11:14:58
⌀ | gha_language
stringclasses 147
values | src_encoding
stringclasses 26
values | language
stringclasses 2
values | is_vendor
bool 2
classes | is_generated
bool 2
classes | length_bytes
int64 6
10.2M
| extension
stringclasses 115
values | filename
stringlengths 3
113
| content
stringlengths 6
10.2M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8f5cc908f87e1bac1ce293580e0037f18c6fb454
|
736e760612f2b431c4b2524fe1a4a8e4083c72a1
|
/librtsp/test/rtsp-client-test.c
|
38089282685f05885fcd5fbf6e4f2d6cdc5a3bbb
|
[
"MIT"
] |
permissive
|
ireader/media-server
|
7f86da8ff0c8694876a2043d50a1260f315dad8a
|
3d8647f50fe832856f42b03d1e5b0fe2eafe5796
|
refs/heads/master
| 2023-09-03T17:53:13.722595
| 2023-09-02T03:38:19
| 2023-09-02T03:38:19
| 15,598,496
| 2,785
| 1,015
|
MIT
| 2023-08-30T03:45:24
| 2014-01-03T01:43:35
|
C
|
UTF-8
|
C
| false
| false
| 6,288
|
c
|
rtsp-client-test.c
|
#if defined(_DEBUG) || defined(DEBUG)
#include "sockutil.h"
#include "rtsp-client.h"
#include <assert.h>
#include <stdlib.h>
#include "sockpair.h"
#include "cstringext.h"
#include "sys/system.h"
#include "cpm/unuse.h"
#include "sdp.h"
//#define UDP_MULTICAST_ADDR "239.0.0.2"
void rtp_receiver_tcp_input(uint8_t channel, const void* data, uint16_t bytes);
void rtp_receiver_test(socket_t rtp[2], const char* peer, int peerport[2], int payload, const char* encoding);
void* rtp_receiver_tcp_test(uint8_t interleave1, uint8_t interleave2, int payload, const char* encoding);
int rtsp_addr_is_multicast(const char* ip);
struct rtsp_client_test_t
{
void* rtsp;
socket_t socket;
int transport;
socket_t rtp[5][2];
unsigned short port[5][2];
};
static int rtsp_client_send(void* param, const char* uri, const void* req, size_t bytes)
{
//TODO: check uri and make socket
//1. uri != rtsp describe uri(user input)
//2. multi-uri if media_count > 1
struct rtsp_client_test_t *ctx = (struct rtsp_client_test_t *)param;
return socket_send_all_by_time(ctx->socket, req, bytes, 0, 2000);
}
static int rtpport(void* param, int media, const char* source, unsigned short rtp[2], char* ip, int len)
{
struct rtsp_client_test_t *ctx = (struct rtsp_client_test_t *)param;
int m = rtsp_client_get_media_type(ctx->rtsp, media);
if (SDP_M_MEDIA_AUDIO != m && SDP_M_MEDIA_VIDEO != m)
return 0; // ignore
switch (ctx->transport)
{
case RTSP_TRANSPORT_RTP_UDP:
// TODO: ipv6
assert(0 == sockpair_create("0.0.0.0", ctx->rtp[media], ctx->port[media]));
rtp[0] = ctx->port[media][0];
rtp[1] = ctx->port[media][1];
if(rtsp_addr_is_multicast(ip))
{
if(0 != socket_udp_multicast(ctx->rtp[media][0], ip, source, 16) || 0 != socket_udp_multicast(ctx->rtp[media][1], ip, source, 16))
return -1;
}
#if defined(UDP_MULTICAST_ADDR)
else
{
if(0 != socket_udp_multicast(ctx->rtp[media][0], UDP_MULTICAST_ADDR, source, 16) || 0 != socket_udp_multicast(ctx->rtp[media][1], UDP_MULTICAST_ADDR, source, 16))
return -1;
snprintf(ip, len, "%s", UDP_MULTICAST_ADDR);
}
#endif
break;
case RTSP_TRANSPORT_RTP_TCP:
rtp[0] = 2 * media;
rtp[1] = 2 * media + 1;
break;
default:
assert(0);
return -1;
}
return ctx->transport;
}
int rtsp_client_options(rtsp_client_t *rtsp, const char* commands);
static void onrtp(void* param, uint8_t channel, const void* data, uint16_t bytes)
{
static int keepalive = 0;
struct rtsp_client_test_t *ctx = (struct rtsp_client_test_t *)param;
rtp_receiver_tcp_input(channel, data, bytes);
if (++keepalive % 1000 == 0)
{
rtsp_client_play(ctx->rtsp, NULL, NULL);
}
}
static int ondescribe(void* param, const char* sdp, int len)
{
struct rtsp_client_test_t *ctx = (struct rtsp_client_test_t *)param;
return rtsp_client_setup(ctx->rtsp, sdp, len);
}
static int onsetup(void* param, int timeout, int64_t duration)
{
int i;
uint64_t npt = 0;
char ip[65];
u_short rtspport;
struct rtsp_client_test_t *ctx = (struct rtsp_client_test_t *)param;
assert(0 == rtsp_client_play(ctx->rtsp, &npt, NULL));
for (i = 0; i < rtsp_client_media_count(ctx->rtsp); i++)
{
int payload, port[2];
const char* encoding;
const struct rtsp_header_transport_t* transport;
transport = rtsp_client_get_media_transport(ctx->rtsp, i);
encoding = rtsp_client_get_media_encoding(ctx->rtsp, i);
payload = rtsp_client_get_media_payload(ctx->rtsp, i);
if (RTSP_TRANSPORT_RTP_UDP == transport->transport)
{
//assert(RTSP_TRANSPORT_RTP_UDP == transport->transport); // udp only
assert(0 == transport->multicast); // unicast only
assert(transport->rtp.u.client_port1 == ctx->port[i][0]);
assert(transport->rtp.u.client_port2 == ctx->port[i][1]);
port[0] = transport->rtp.u.server_port1;
port[1] = transport->rtp.u.server_port2;
if (*transport->source)
{
rtp_receiver_test(ctx->rtp[i], transport->source, port, payload, encoding);
}
else
{
socket_getpeername(ctx->socket, ip, &rtspport);
rtp_receiver_test(ctx->rtp[i], ip, port, payload, encoding);
}
}
else if (RTSP_TRANSPORT_RTP_TCP == transport->transport)
{
//assert(transport->rtp.u.client_port1 == transport->interleaved1);
//assert(transport->rtp.u.client_port2 == transport->interleaved2);
rtp_receiver_tcp_test(transport->interleaved1, transport->interleaved2, payload, encoding);
}
else
{
assert(0); // TODO
}
}
return 0;
}
static int onteardown(void* param)
{
return 0;
}
static int onplay(void* param, int media, const uint64_t *nptbegin, const uint64_t *nptend, const double *scale, const struct rtsp_rtp_info_t* rtpinfo, int count)
{
return 0;
}
static int onpause(void* param)
{
return 0;
}
void rtsp_client_test(const char* host, const char* file)
{
int r;
struct rtsp_client_test_t ctx;
struct rtsp_client_handler_t handler;
static char packet[2 * 1024 * 1024];
memset(&ctx, 0, sizeof(ctx));
handler.send = rtsp_client_send;
handler.rtpport = rtpport;
handler.ondescribe = ondescribe;
handler.onsetup = onsetup;
handler.onplay = onplay;
handler.onpause = onpause;
handler.onteardown = onteardown;
handler.onrtp = onrtp;
ctx.transport = RTSP_TRANSPORT_RTP_UDP; // RTSP_TRANSPORT_RTP_TCP
snprintf(packet, sizeof(packet), "rtsp://%s/%s", host, file); // url
socket_init();
ctx.socket = socket_connect_host(host, 8554, 2000);
assert(socket_invalid != ctx.socket);
//ctx.rtsp = rtsp_client_create(NULL, NULL, &handler, &ctx);
ctx.rtsp = rtsp_client_create(packet, "username1", "password1", &handler, &ctx);
assert(ctx.rtsp);
assert(0 == rtsp_client_describe(ctx.rtsp));
socket_setnonblock(ctx.socket, 0);
r = socket_recv(ctx.socket, packet, sizeof(packet), 0);
while(r > 0)
{
assert(0 == rtsp_client_input(ctx.rtsp, packet, r));
r = socket_recv(ctx.socket, packet, sizeof(packet), 0);
}
assert(0 == rtsp_client_teardown(ctx.rtsp));
rtsp_client_destroy(ctx.rtsp);
socket_close(ctx.socket);
socket_cleanup();
}
#endif
|
63e660fac4f70c81045ec7655d23fdf822da5150
|
62f756687af4f522b78e4963a6d2262136a9b65d
|
/extmod/vfs.h
|
f2efdbe795ab25cecda3895f21892719d028ab92
|
[
"MIT"
] |
permissive
|
micropython/micropython-esp32
|
48ce07832c8d44fcdc530962bd9ae087949b957b
|
2f4dac5f121a59fc187c1d9c1f9eade365b3aba1
|
refs/heads/esp32
| 2023-08-28T12:00:44.867727
| 2018-02-27T04:06:10
| 2018-02-27T04:06:10
| 76,828,539
| 737
| 238
|
MIT
| 2023-09-06T02:31:38
| 2016-12-19T04:38:26
|
C
|
UTF-8
|
C
| false
| false
| 3,529
|
h
|
vfs.h
|
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 Damien P. George
*
* 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 MICROPY_INCLUDED_EXTMOD_VFS_H
#define MICROPY_INCLUDED_EXTMOD_VFS_H
#include "py/lexer.h"
#include "py/obj.h"
// return values of mp_vfs_lookup_path
// ROOT is 0 so that the default current directory is the root directory
#define MP_VFS_NONE ((mp_vfs_mount_t*)1)
#define MP_VFS_ROOT ((mp_vfs_mount_t*)0)
// MicroPython's port-standardized versions of stat constants
#define MP_S_IFDIR (0x4000)
#define MP_S_IFREG (0x8000)
// constants for block protocol ioctl
#define BP_IOCTL_INIT (1)
#define BP_IOCTL_DEINIT (2)
#define BP_IOCTL_SYNC (3)
#define BP_IOCTL_SEC_COUNT (4)
#define BP_IOCTL_SEC_SIZE (5)
typedef struct _mp_vfs_mount_t {
const char *str; // mount point with leading /
size_t len;
mp_obj_t obj;
struct _mp_vfs_mount_t *next;
} mp_vfs_mount_t;
mp_vfs_mount_t *mp_vfs_lookup_path(const char *path, const char **path_out);
mp_import_stat_t mp_vfs_import_stat(const char *path);
mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
mp_obj_t mp_vfs_umount(mp_obj_t mnt_in);
mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
mp_obj_t mp_vfs_chdir(mp_obj_t path_in);
mp_obj_t mp_vfs_getcwd(void);
mp_obj_t mp_vfs_ilistdir(size_t n_args, const mp_obj_t *args);
mp_obj_t mp_vfs_listdir(size_t n_args, const mp_obj_t *args);
mp_obj_t mp_vfs_mkdir(mp_obj_t path_in);
mp_obj_t mp_vfs_remove(mp_obj_t path_in);
mp_obj_t mp_vfs_rename(mp_obj_t old_path_in, mp_obj_t new_path_in);
mp_obj_t mp_vfs_rmdir(mp_obj_t path_in);
mp_obj_t mp_vfs_stat(mp_obj_t path_in);
mp_obj_t mp_vfs_statvfs(mp_obj_t path_in);
MP_DECLARE_CONST_FUN_OBJ_KW(mp_vfs_mount_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_umount_obj);
MP_DECLARE_CONST_FUN_OBJ_KW(mp_vfs_open_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_chdir_obj);
MP_DECLARE_CONST_FUN_OBJ_0(mp_vfs_getcwd_obj);
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vfs_ilistdir_obj);
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vfs_listdir_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_mkdir_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_remove_obj);
MP_DECLARE_CONST_FUN_OBJ_2(mp_vfs_rename_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_rmdir_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_stat_obj);
MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_statvfs_obj);
#endif // MICROPY_INCLUDED_EXTMOD_VFS_H
|
6dbaec6252889a31b1430f9b9d61022b1cb2fe66
|
91aee99745750204ddba60d07f323316c7cde91b
|
/src/libsodium/crypto_aead/aes256gcm/armcrypto/aead_aes256gcm_armcrypto.c
|
f730ee790704288bb5c3a89291808cac283d4f77
|
[
"ISC"
] |
permissive
|
jedisct1/libsodium
|
7dfb8c418b1bd8f7d0539be3386e07e3599fc48f
|
0ea62015f2c397168566c7f8c6df65e59a0d1049
|
refs/heads/master
| 2023-09-01T10:53:16.647374
| 2023-08-31T21:23:30
| 2023-08-31T21:23:30
| 7,710,647
| 10,795
| 1,968
|
NOASSERTION
| 2023-09-14T16:00:28
| 2013-01-20T00:03:40
|
C
|
UTF-8
|
C
| false
| false
| 34,984
|
c
|
aead_aes256gcm_armcrypto.c
|
#include <errno.h>
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "core.h"
#include "crypto_aead_aes256gcm.h"
#include "crypto_verify_16.h"
#include "export.h"
#include "private/common.h"
#include "randombytes.h"
#include "runtime.h"
#include "utils.h"
#if defined(HAVE_ARMCRYPTO) && defined(__clang__) && defined(NATIVE_LITTLE_ENDIAN)
#if !defined(MSC_VER) || _MSC_VER < 1800
#define __vectorcall
#endif
#ifndef __ARM_FEATURE_AES
#define __ARM_FEATURE_AES 1
#endif
#include <arm_neon.h>
#define ABYTES crypto_aead_aes256gcm_ABYTES
#define NPUBBYTES crypto_aead_aes256gcm_NPUBBYTES
#define KEYBYTES crypto_aead_aes256gcm_KEYBYTES
#define PARALLEL_BLOCKS 6
#undef USE_KARATSUBA_MULTIPLICATION
typedef uint64x2_t BlockVec;
#define LOAD128(a) vld1q_u64((const void *) a)
#define STORE128(a, b) vst1q_u64(((void *) a), (b))
#define AES_XENCRYPT(block_vec, rkey) \
vreinterpretq_u64_u8( \
vaesmcq_u8(vaeseq_u8(vreinterpretq_u8_u64(block_vec), rkey)))
#define AES_XENCRYPTLAST(block_vec, rkey) \
vreinterpretq_u64_u8(vaeseq_u8(vreinterpretq_u8_u64(block_vec), rkey))
#define XOR128(a, b) veorq_u64((a), (b))
#define AND128(a, b) vandq_u64((a), (b))
#define OR128(a, b) vorrq_u64((a), (b))
#define SET64x2(a, b) vsetq_lane_u64((uint64_t) (a), vmovq_n_u64((uint64_t) (b)), 1)
#define ZERO128 vmovq_n_u8(0)
#define ONE128 SET64x2(0, 1)
#define ADD64x2(a, b) vaddq_u64((a), (b))
#define SUB64x2(a, b) vsubq_u64((a), (b))
#define SHL64x2(a, b) vshlq_n_u64((a), (b))
#define SHR64x2(a, b) vshrq_n_u64((a), (b))
#define REV128(x) \
vreinterpretq_u64_u8(__builtin_shufflevector(vreinterpretq_u8_u64(x), vreinterpretq_u8_u64(x), \
15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, \
1, 0))
#define SHUFFLE32x4(x, a, b, c, d) \
vreinterpretq_u64_u32(__builtin_shufflevector(vreinterpretq_u32_u64(x), \
vreinterpretq_u32_u64(x), (a), (b), (c), (d)))
#define BYTESHL128(a, b) vreinterpretq_u64_u8(vextq_s8(vdupq_n_s8(0), (int8x16_t) a, 16 - (b)))
#define BYTESHR128(a, b) vreinterpretq_u64_u8(vextq_s8((int8x16_t) a, vdupq_n_s8(0), (b)))
#define SHL128(a, b) OR128(SHL64x2((a), (b)), SHR64x2(BYTESHL128((a), 8), 64 - (b)))
#define CLMULLO128(a, b) \
vreinterpretq_u64_p128(vmull_p64((poly64_t) vget_low_u64(a), (poly64_t) vget_low_u64(b)))
#define CLMULHI128(a, b) \
vreinterpretq_u64_p128(vmull_high_p64(vreinterpretq_p64_s64(a), vreinterpretq_p64_s64(b)))
#define CLMULLOHI128(a, b) \
vreinterpretq_u64_p128(vmull_p64((poly64_t) vget_low_u64(a), (poly64_t) vget_high_u64(b)))
#define CLMULHILO128(a, b) \
vreinterpretq_u64_p128(vmull_p64((poly64_t) vget_high_u64(a), (poly64_t) vget_low_u64(b)))
#define PREFETCH_READ(x) __builtin_prefetch((x), 0, 2)
#define PREFETCH_WRITE(x) __builtin_prefetch((x), 1, 2);
static inline BlockVec
AES_KEYGEN(BlockVec block_vec, const int rc)
{
uint8x16_t a = vaeseq_u8(vreinterpretq_u8_u64(block_vec), vmovq_n_u8(0));
const uint8x16_t b =
__builtin_shufflevector(a, a, 4, 1, 14, 11, 1, 14, 11, 4, 12, 9, 6, 3, 9, 6, 3, 12);
const uint64x2_t c = SET64x2((uint64_t) rc << 32, (uint64_t) rc << 32);
return XOR128(b, c);
}
#define ROUNDS 14
#define PC_COUNT (2 * PARALLEL_BLOCKS)
typedef struct I256 {
BlockVec hi;
BlockVec lo;
BlockVec mid;
} I256;
typedef BlockVec Precomp;
typedef struct GHash {
BlockVec acc;
} GHash;
typedef struct State {
BlockVec rkeys[ROUNDS + 1];
Precomp hx[PC_COUNT];
} State;
static void __vectorcall expand256(const unsigned char key[KEYBYTES], BlockVec rkeys[1 + ROUNDS])
{
BlockVec t1, t2, s;
size_t i = 0;
#define EXPAND_KEY_1(RC) \
rkeys[i++] = t2; \
s = AES_KEYGEN(t2, RC); \
t1 = XOR128(t1, BYTESHL128(t1, 4)); \
t1 = XOR128(t1, BYTESHL128(t1, 8)); \
t1 = XOR128(t1, SHUFFLE32x4(s, 3, 3, 3, 3));
#define EXPAND_KEY_2(RC) \
rkeys[i++] = t1; \
s = AES_KEYGEN(t1, RC); \
t2 = XOR128(t2, BYTESHL128(t2, 4)); \
t2 = XOR128(t2, BYTESHL128(t2, 8)); \
t2 = XOR128(t2, SHUFFLE32x4(s, 2, 2, 2, 2));
t1 = LOAD128(&key[0]);
t2 = LOAD128(&key[16]);
rkeys[i++] = t1;
EXPAND_KEY_1(0x01);
EXPAND_KEY_2(0x01);
EXPAND_KEY_1(0x02);
EXPAND_KEY_2(0x02);
EXPAND_KEY_1(0x04);
EXPAND_KEY_2(0x04);
EXPAND_KEY_1(0x08);
EXPAND_KEY_2(0x08);
EXPAND_KEY_1(0x10);
EXPAND_KEY_2(0x10);
EXPAND_KEY_1(0x20);
EXPAND_KEY_2(0x20);
EXPAND_KEY_1(0x40);
rkeys[i++] = t1;
}
/* Encrypt a single AES block */
static inline void
encrypt(const State *st, unsigned char dst[16], const unsigned char src[16])
{
BlockVec t;
size_t i;
t = AES_XENCRYPT(LOAD128(src), st->rkeys[0]);
for (i = 1; i < ROUNDS - 1; i++) {
t = AES_XENCRYPT(t, st->rkeys[i]);
}
t = AES_XENCRYPTLAST(t, st->rkeys[i]);
t = XOR128(t, st->rkeys[ROUNDS]);
STORE128(dst, t);
}
/* Encrypt and add a single AES block */
static inline void __vectorcall encrypt_xor_block(const State *st, unsigned char dst[16],
const unsigned char src[16],
const BlockVec counter)
{
BlockVec ts;
size_t i;
ts = AES_XENCRYPT(counter, st->rkeys[0]);
for (i = 1; i < ROUNDS - 1; i++) {
ts = AES_XENCRYPT(ts, st->rkeys[i]);
}
ts = AES_XENCRYPTLAST(ts, st->rkeys[i]);
ts = XOR128(ts, XOR128(st->rkeys[ROUNDS], LOAD128(src)));
STORE128(dst, ts);
}
/* Encrypt and add PARALLEL_BLOCKS AES blocks */
static inline void __vectorcall encrypt_xor_wide(const State *st,
unsigned char dst[16 * PARALLEL_BLOCKS],
const unsigned char src[16 * PARALLEL_BLOCKS],
const BlockVec counters[PARALLEL_BLOCKS])
{
BlockVec ts[PARALLEL_BLOCKS];
size_t i, j;
for (j = 0; j < PARALLEL_BLOCKS; j++) {
ts[j] = AES_XENCRYPT(counters[j], st->rkeys[0]);
}
for (i = 1; i < ROUNDS - 1; i++) {
for (j = 0; j < PARALLEL_BLOCKS; j++) {
ts[j] = AES_XENCRYPT(ts[j], st->rkeys[i]);
}
}
for (j = 0; j < PARALLEL_BLOCKS; j++) {
ts[j] = AES_XENCRYPTLAST(ts[j], st->rkeys[i]);
ts[j] = XOR128(ts[j], XOR128(st->rkeys[ROUNDS], LOAD128(&src[16 * j])));
}
for (j = 0; j < PARALLEL_BLOCKS; j++) {
STORE128(&dst[16 * j], ts[j]);
}
}
/* Square a field element */
static inline I256 __vectorcall clsq128(const BlockVec x)
{
const BlockVec r_lo = CLMULLO128(x, x);
const BlockVec r_hi = CLMULHI128(x, x);
return (I256) {
SODIUM_C99(.hi =) r_hi,
SODIUM_C99(.lo =) r_lo,
SODIUM_C99(.mid =) ZERO128,
};
}
/* Multiply two field elements -- Textbook multiplication is faster than Karatsuba on some recent
* CPUs */
static inline I256 __vectorcall clmul128(const BlockVec x, const BlockVec y)
{
#ifdef USE_KARATSUBA_MULTIPLICATION
const BlockVec x_hi = BYTESHR128(x, 8);
const BlockVec y_hi = BYTESHR128(y, 8);
const BlockVec r_lo = CLMULLO128(x, y);
const BlockVec r_hi = CLMULHI128(x, y);
const BlockVec r_mid = XOR128(CLMULLO128(XOR128(x, x_hi), XOR128(y, y_hi)), XOR128(r_lo, r_hi));
return (I256) {
SODIUM_C99(.hi =) r_hi,
SODIUM_C99(.lo =) r_lo,
SODIUM_C99(.mid =) r_mid,
};
#else
const BlockVec r_hi = CLMULHI128(x, y);
const BlockVec r_lo = CLMULLO128(x, y);
const BlockVec r_mid = XOR128(CLMULHILO128(x, y), CLMULLOHI128(x, y));
return (I256) {
SODIUM_C99(.hi =) r_hi,
SODIUM_C99(.lo =) r_lo,
SODIUM_C99(.mid =) r_mid,
};
#endif
}
/* Merge the middle word and reduce a field element */
static inline BlockVec __vectorcall gcm_reduce(const I256 x)
{
const BlockVec hi = XOR128(x.hi, BYTESHR128(x.mid, 8));
const BlockVec lo = XOR128(x.lo, BYTESHL128(x.mid, 8));
const BlockVec p64 = SET64x2(0, 0xc200000000000000);
const BlockVec a = CLMULLO128(lo, p64);
const BlockVec b = XOR128(SHUFFLE32x4(lo, 2, 3, 0, 1), a);
const BlockVec c = CLMULLO128(b, p64);
const BlockVec d = XOR128(SHUFFLE32x4(b, 2, 3, 0, 1), c);
return XOR128(d, hi);
}
/* Precompute powers of H from `from` to `to` */
static inline void __vectorcall precomp(Precomp hx[PC_COUNT], const size_t from, const size_t to)
{
const Precomp h = hx[0];
size_t i;
for (i = from & ~1U; i < to; i += 2) {
hx[i] = gcm_reduce(clmul128(hx[i - 1], h));
hx[i + 1] = gcm_reduce(clsq128(hx[i / 2]));
}
}
/* Precompute powers of H given a key and a block count */
static void __vectorcall precomp_for_block_count(Precomp hx[PC_COUNT],
const unsigned char gh_key[16],
const size_t block_count)
{
const BlockVec h0 = REV128(LOAD128(gh_key));
BlockVec carry = SET64x2(0xc200000000000000, 1);
BlockVec mask = SUB64x2(ZERO128, SHR64x2(h0, 63));
BlockVec h0_shifted;
BlockVec h;
mask = SHUFFLE32x4(mask, 3, 3, 3, 3);
carry = AND128(carry, mask);
h0_shifted = SHL128(h0, 1);
h = XOR128(h0_shifted, carry);
hx[0] = h;
hx[1] = gcm_reduce(clsq128(hx[0]));
if (block_count >= PC_COUNT) {
precomp(hx, 2, PC_COUNT);
} else {
precomp(hx, 2, block_count);
}
}
/* Initialize a GHash */
static inline void
gh_init(GHash *sth)
{
sth->acc = ZERO128;
}
static inline I256 __vectorcall gh_update0(const GHash *const sth, const unsigned char *const p,
const Precomp hn)
{
const BlockVec m = REV128(LOAD128(p));
return clmul128(XOR128(sth->acc, m), hn);
}
static inline void __vectorcall gh_update(I256 *const u, const unsigned char *p, const Precomp hn)
{
const BlockVec m = REV128(LOAD128(p));
const I256 t = clmul128(m, hn);
*u = (I256) { SODIUM_C99(.hi =) XOR128(u->hi, t.hi), SODIUM_C99(.lo =) XOR128(u->lo, t.lo),
SODIUM_C99(.mid =) XOR128(u->mid, t.mid) };
}
/* Absorb ad_len bytes of associated data. There has to be no partial block. */
static inline void
gh_ad_blocks(const State *st, GHash *sth, const unsigned char *ad, size_t ad_len)
{
size_t i;
i = (size_t) 0U;
for (; i + PC_COUNT * 16 <= ad_len; i += PC_COUNT * 16) {
I256 u = gh_update0(sth, ad + i, st->hx[PC_COUNT - 1 - 0]);
size_t j;
for (j = 1; j < PC_COUNT; j += 1) {
gh_update(&u, ad + i + j * 16, st->hx[PC_COUNT - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
for (; i + PC_COUNT * 16 / 2 <= ad_len; i += PC_COUNT * 16 / 2) {
I256 u = gh_update0(sth, ad + i, st->hx[PC_COUNT / 2 - 1 - 0]);
size_t j;
for (j = 1; j < PC_COUNT / 2; j += 1) {
gh_update(&u, ad + i + j * 16, st->hx[PC_COUNT / 2 - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
for (; i + 4 * 16 <= ad_len; i += 4 * 16) {
size_t j;
I256 u = gh_update0(sth, ad + i, st->hx[4 - 1 - 0]);
for (j = 1; j < 4; j += 1) {
gh_update(&u, ad + i + j * 16, st->hx[4 - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
for (; i + 2 * 16 <= ad_len; i += 2 * 16) {
size_t j;
I256 u = gh_update0(sth, ad + i, st->hx[2 - 1 - 0]);
for (j = 1; j < 2; j += 1) {
gh_update(&u, ad + i + j * 16, st->hx[2 - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
if (i < ad_len) {
I256 u = gh_update0(sth, ad + i, st->hx[0]);
sth->acc = gcm_reduce(u);
}
}
/* Increment counters */
static inline BlockVec __vectorcall incr_counters(BlockVec rev_counters[], BlockVec counter,
const size_t n)
{
size_t i;
const BlockVec one = ONE128;
for (i = 0; i < n; i++) {
rev_counters[i] = REV128(counter);
counter = ADD64x2(counter, one);
}
return counter;
}
/* Compute the number of required blocks to encrypt and authenticate `ad_len` of associated data,
* and `m_len` of encrypted bytes. Return `0` if limits would be exceeded.*/
static inline size_t
required_blocks(const size_t ad_len, const size_t m_len)
{
const size_t ad_blocks = (ad_len + 15) / 16;
const size_t m_blocks = (m_len + 15) / 16;
if (ad_len > SIZE_MAX - 2 * PARALLEL_BLOCKS * 16 ||
m_len > SIZE_MAX - 2 * PARALLEL_BLOCKS * 16 || ad_len < ad_blocks || m_len < m_blocks ||
m_blocks >= (1ULL << 32) - 2) {
return 0;
}
return ad_blocks + m_blocks + 1;
}
/* Generic AES-GCM encryption. "Generic" as it can handle arbitrary input sizes,
unlike a length-limited version that would precompute all the required powers of H */
static void
aes_gcm_encrypt_generic(const State *st, GHash *sth, unsigned char mac[ABYTES], unsigned char *dst,
const unsigned char *src, size_t src_len, const unsigned char *ad,
size_t ad_len, unsigned char counter_[16])
{
CRYPTO_ALIGN(32) I256 u;
CRYPTO_ALIGN(16) unsigned char last_blocks[2 * 16];
const BlockVec one = ONE128;
BlockVec final_block;
BlockVec rev_counters[PARALLEL_BLOCKS];
BlockVec counter;
size_t i;
size_t j;
size_t left;
size_t pi;
COMPILER_ASSERT(PC_COUNT % PARALLEL_BLOCKS == 0);
/* Associated data */
if (ad != NULL && ad_len != 0) {
gh_ad_blocks(st, sth, ad, ad_len & ~15);
left = ad_len & 15;
if (left != 0) {
unsigned char pad[16];
memset(pad, 0, sizeof pad);
memcpy(pad, ad + ad_len - left, left);
gh_ad_blocks(st, sth, pad, sizeof pad);
}
}
/* Encrypted data */
counter = REV128(LOAD128(counter_));
i = 0;
/* 2*PARALLEL_BLOCKS aggregation */
if (src_len - i >= 2 * PARALLEL_BLOCKS * 16) {
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
i += PARALLEL_BLOCKS * 16;
for (; i + 2 * PARALLEL_BLOCKS * 16 <= src_len; i += 2 * PARALLEL_BLOCKS * 16) {
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
pi = i - PARALLEL_BLOCKS * 16;
u = gh_update0(sth, dst + pi, st->hx[2 * PARALLEL_BLOCKS - 1 - 0]);
for (j = 1; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, dst + pi + j * 16, st->hx[2 * PARALLEL_BLOCKS - 1 - j]);
}
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
encrypt_xor_wide(st, dst + i + PARALLEL_BLOCKS * 16, src + i + PARALLEL_BLOCKS * 16,
rev_counters);
pi = i;
for (j = 0; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, dst + pi + j * 16, st->hx[PARALLEL_BLOCKS - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
pi = i - PARALLEL_BLOCKS * 16;
u = gh_update0(sth, dst + pi, st->hx[PARALLEL_BLOCKS - 1 - 0]);
for (j = 1; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, dst + pi + j * 16, st->hx[PARALLEL_BLOCKS - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
/* PARALLEL_BLOCKS aggregation */
if (src_len - i >= PARALLEL_BLOCKS * 16) {
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
i += PARALLEL_BLOCKS * 16;
for (; i + PARALLEL_BLOCKS * 16 <= src_len; i += PARALLEL_BLOCKS * 16) {
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
pi = i - PARALLEL_BLOCKS * 16;
u = gh_update0(sth, dst + pi, st->hx[PARALLEL_BLOCKS - 1 - 0]);
for (j = 1; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, dst + pi + j * 16, st->hx[PARALLEL_BLOCKS - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
pi = i - PARALLEL_BLOCKS * 16;
u = gh_update0(sth, dst + pi, st->hx[PARALLEL_BLOCKS - 1 - 0]);
for (j = 1; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, dst + pi + j * 16, st->hx[PARALLEL_BLOCKS - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
/* 4-blocks aggregation */
for (; i + 4 * 16 <= src_len; i += 4 * 16) {
counter = incr_counters(rev_counters, counter, 4);
for (j = 0; j < 4; j++) {
encrypt_xor_block(st, dst + i + j * 16, src + i + j * 16, rev_counters[j]);
}
u = gh_update0(sth, dst + i, st->hx[4 - 1 - 0]);
for (j = 1; j < 4; j += 1) {
gh_update(&u, dst + i + j * 16, st->hx[4 - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
/* 2-blocks aggregation */
for (; i + 2 * 16 <= src_len; i += 2 * 16) {
counter = incr_counters(rev_counters, counter, 2);
for (j = 0; j < 2; j++) {
encrypt_xor_block(st, dst + i + j * 16, src + i + j * 16, rev_counters[j]);
}
u = gh_update0(sth, dst + i, st->hx[2 - 1 - 0]);
for (j = 1; j < 2; j += 1) {
gh_update(&u, dst + i + j * 16, st->hx[2 - 1 - j]);
}
sth->acc = gcm_reduce(u);
}
/* Remaining *partial* blocks; if we have 16 bytes left, we want to keep the
full block authenticated along with the final block, hence < and not <= */
for (; i + 16 < src_len; i += 16) {
encrypt_xor_block(st, dst + i, src + i, REV128(counter));
u = gh_update0(sth, dst + i, st->hx[1 - 1 - 0]);
sth->acc = gcm_reduce(u);
counter = ADD64x2(counter, one);
}
/* Authenticate both the last block of the message and the final block */
final_block = REV128(SET64x2(ad_len * 8, src_len * 8));
STORE32_BE(counter_ + NPUBBYTES, 1);
encrypt(st, mac, counter_);
left = src_len - i;
if (left != 0) {
for (j = 0; j < left; j++) {
last_blocks[j] = src[i + j];
}
STORE128(last_blocks + 16, final_block);
encrypt_xor_block(st, last_blocks, last_blocks, REV128(counter));
for (; j < 16; j++) {
last_blocks[j] = 0;
}
for (j = 0; j < left; j++) {
dst[i + j] = last_blocks[j];
}
gh_ad_blocks(st, sth, last_blocks, 32);
} else {
STORE128(last_blocks, final_block);
gh_ad_blocks(st, sth, last_blocks, 16);
}
STORE128(mac, XOR128(LOAD128(mac), REV128(sth->acc)));
}
/* Generic AES-GCM decryption. "Generic" as it can handle arbitrary input sizes,
unlike a length-limited version that would precompute all the required powers of H */
static void
aes_gcm_decrypt_generic(const State *st, GHash *sth, unsigned char mac[ABYTES], unsigned char *dst,
const unsigned char *src, size_t src_len, const unsigned char *ad,
size_t ad_len, unsigned char counter_[16])
{
CRYPTO_ALIGN(32) I256 u;
CRYPTO_ALIGN(16) unsigned char last_blocks[2 * 16];
const BlockVec one = ONE128;
BlockVec final_block;
BlockVec rev_counters[PARALLEL_BLOCKS];
BlockVec counter;
size_t i;
size_t j;
size_t left;
COMPILER_ASSERT(PC_COUNT % PARALLEL_BLOCKS == 0);
/* Associated data */
if (ad != NULL && ad_len != 0) {
gh_ad_blocks(st, sth, ad, ad_len & ~15);
left = ad_len & 15;
if (left != 0) {
unsigned char pad[16];
memset(pad, 0, sizeof pad);
memcpy(pad, ad + ad_len - left, left);
gh_ad_blocks(st, sth, pad, sizeof pad);
}
}
/* Encrypted data */
counter = REV128(LOAD128(counter_));
i = 0;
/* 2*PARALLEL_BLOCKS aggregation */
while (i + 2 * PARALLEL_BLOCKS * 16 <= src_len) {
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
u = gh_update0(sth, src + i, st->hx[2 * PARALLEL_BLOCKS - 1 - 0]);
for (j = 1; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, src + i + j * 16, st->hx[2 * PARALLEL_BLOCKS - 1 - j]);
}
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
i += PARALLEL_BLOCKS * 16;
for (j = 0; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, src + i + j * 16, st->hx[PARALLEL_BLOCKS - 1 - j]);
}
sth->acc = gcm_reduce(u);
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
i += PARALLEL_BLOCKS * 16;
}
/* PARALLEL_BLOCKS aggregation */
for (; i + PARALLEL_BLOCKS * 16 <= src_len; i += PARALLEL_BLOCKS * 16) {
counter = incr_counters(rev_counters, counter, PARALLEL_BLOCKS);
u = gh_update0(sth, src + i, st->hx[PARALLEL_BLOCKS - 1 - 0]);
for (j = 1; j < PARALLEL_BLOCKS; j += 1) {
gh_update(&u, src + i + j * 16, st->hx[PARALLEL_BLOCKS - 1 - j]);
}
sth->acc = gcm_reduce(u);
encrypt_xor_wide(st, dst + i, src + i, rev_counters);
}
/* 4-blocks aggregation */
for (; i + 4 * 16 <= src_len; i += 4 * 16) {
counter = incr_counters(rev_counters, counter, 4);
u = gh_update0(sth, src + i, st->hx[4 - 1 - 0]);
for (j = 1; j < 4; j += 1) {
gh_update(&u, src + i + j * 16, st->hx[4 - 1 - j]);
}
sth->acc = gcm_reduce(u);
for (j = 0; j < 4; j++) {
encrypt_xor_block(st, dst + i + j * 16, src + i + j * 16, rev_counters[j]);
}
}
/* 2-blocks aggregation */
for (; i + 2 * 16 <= src_len; i += 2 * 16) {
counter = incr_counters(rev_counters, counter, 2);
u = gh_update0(sth, src + i, st->hx[2 - 1 - 0]);
for (j = 1; j < 2; j += 1) {
gh_update(&u, src + i + j * 16, st->hx[2 - 1 - j]);
}
sth->acc = gcm_reduce(u);
for (j = 0; j < 2; j++) {
encrypt_xor_block(st, dst + i + j * 16, src + i + j * 16, rev_counters[j]);
}
}
/* Remaining *partial* blocks; if we have 16 bytes left, we want to keep the
full block authenticated along with the final block, hence < and not <= */
for (; i + 16 < src_len; i += 16) {
u = gh_update0(sth, src + i, st->hx[1 - 1 - 0]);
sth->acc = gcm_reduce(u);
encrypt_xor_block(st, dst + i, src + i, REV128(counter));
counter = ADD64x2(counter, one);
}
/* Authenticate both the last block of the message and the final block */
final_block = REV128(SET64x2(ad_len * 8, src_len * 8));
STORE32_BE(counter_ + NPUBBYTES, 1);
encrypt(st, mac, counter_);
left = src_len - i;
if (left != 0) {
for (j = 0; j < left; j++) {
last_blocks[j] = src[i + j];
}
for (; j < 16; j++) {
last_blocks[j] = 0;
}
STORE128(last_blocks + 16, final_block);
gh_ad_blocks(st, sth, last_blocks, 32);
encrypt_xor_block(st, last_blocks, last_blocks, REV128(counter));
for (j = 0; j < left; j++) {
dst[i + j] = last_blocks[j];
}
} else {
STORE128(last_blocks, final_block);
gh_ad_blocks(st, sth, last_blocks, 16);
}
STORE128(mac, XOR128(LOAD128(mac), REV128(sth->acc)));
}
int
crypto_aead_aes256gcm_beforenm(crypto_aead_aes256gcm_state *st_, const unsigned char *k)
{
State *st = (State *) (void *) st_;
CRYPTO_ALIGN(16) unsigned char h[16];
COMPILER_ASSERT(sizeof *st_ >= sizeof *st);
expand256(k, st->rkeys);
memset(h, 0, sizeof h);
encrypt(st, h, h);
precomp_for_block_count(st->hx, h, PC_COUNT);
return 0;
}
int
crypto_aead_aes256gcm_encrypt_detached_afternm(unsigned char *c, unsigned char *mac,
unsigned long long *maclen_p, const unsigned char *m,
unsigned long long m_len_, const unsigned char *ad,
unsigned long long ad_len_,
const unsigned char *nsec, const unsigned char *npub,
const crypto_aead_aes256gcm_state *st_)
{
const State *st = (const State *) (const void *) st_;
GHash sth;
CRYPTO_ALIGN(16) unsigned char j[16];
size_t gh_required_blocks;
const size_t ad_len = (size_t) ad_len_;
const size_t m_len = (size_t) m_len_;
(void) nsec;
if (maclen_p != NULL) {
*maclen_p = 0;
}
if (ad_len_ > SODIUM_SIZE_MAX || m_len_ > SODIUM_SIZE_MAX) {
sodium_misuse();
}
gh_required_blocks = required_blocks(ad_len, m_len);
if (gh_required_blocks == 0) {
memset(mac, 0xd0, ABYTES);
memset(c, 0, m_len);
return -1;
}
gh_init(&sth);
memcpy(j, npub, NPUBBYTES);
STORE32_BE(j + NPUBBYTES, 2);
aes_gcm_encrypt_generic(st, &sth, mac, c, m, m_len, ad, ad_len, j);
if (maclen_p != NULL) {
*maclen_p = ABYTES;
}
return 0;
}
int
crypto_aead_aes256gcm_encrypt(unsigned char *c, unsigned long long *clen_p, const unsigned char *m,
unsigned long long m_len, const unsigned char *ad,
unsigned long long ad_len, const unsigned char *nsec,
const unsigned char *npub, const unsigned char *k)
{
const int ret = crypto_aead_aes256gcm_encrypt_detached(c, c + m_len, NULL, m, m_len, ad, ad_len,
nsec, npub, k);
if (clen_p != NULL) {
if (ret == 0) {
*clen_p = m_len + crypto_aead_aes256gcm_ABYTES;
} else {
*clen_p = 0;
}
}
return ret;
}
int
crypto_aead_aes256gcm_encrypt_detached(unsigned char *c, unsigned char *mac,
unsigned long long *maclen_p, const unsigned char *m,
unsigned long long m_len, const unsigned char *ad,
unsigned long long ad_len, const unsigned char *nsec,
const unsigned char *npub, const unsigned char *k)
{
CRYPTO_ALIGN(16) crypto_aead_aes256gcm_state st;
int ret;
PREFETCH_WRITE(c);
PREFETCH_READ(m);
PREFETCH_READ(ad);
crypto_aead_aes256gcm_beforenm(&st, k);
ret = crypto_aead_aes256gcm_encrypt_detached_afternm(c, mac, maclen_p, m, m_len, ad, ad_len,
nsec, npub, &st);
sodium_memzero(&st, sizeof st);
return ret;
}
int
crypto_aead_aes256gcm_encrypt_afternm(unsigned char *c, unsigned long long *clen_p,
const unsigned char *m, unsigned long long mlen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *nsec, const unsigned char *npub,
const crypto_aead_aes256gcm_state *st_)
{
int ret = crypto_aead_aes256gcm_encrypt_detached_afternm(c, c + mlen, NULL, m, mlen, ad, adlen,
nsec, npub, st_);
if (clen_p != NULL) {
*clen_p = mlen + crypto_aead_aes256gcm_ABYTES;
}
return ret;
}
static int
crypto_aead_aes256gcm_verify_mac(unsigned char *nsec, const unsigned char *c,
unsigned long long c_len_, const unsigned char *mac,
const unsigned char *ad, unsigned long long ad_len_,
const unsigned char *npub, const crypto_aead_aes256gcm_state *st_)
{
const State *st = (const State *) (const void *) st_;
GHash sth;
BlockVec final_block;
CRYPTO_ALIGN(16) unsigned char j[16];
CRYPTO_ALIGN(16) unsigned char computed_mac[16];
CRYPTO_ALIGN(16) unsigned char last_block[16];
size_t gh_required_blocks;
size_t left;
const size_t ad_len = (size_t) ad_len_;
const size_t c_len = (size_t) c_len_;
int ret;
(void) nsec;
if (ad_len_ > SODIUM_SIZE_MAX || c_len_ > SODIUM_SIZE_MAX) {
sodium_misuse();
}
gh_required_blocks = required_blocks(ad_len, c_len);
if (gh_required_blocks == 0) {
return -1;
}
gh_init(&sth);
memcpy(j, npub, NPUBBYTES);
STORE32_BE(j + NPUBBYTES, 2);
gh_ad_blocks(st, &sth, ad, ad_len & ~15);
left = ad_len & 15;
if (left != 0) {
unsigned char pad[16];
memset(pad, 0, sizeof pad);
memcpy(pad, ad + ad_len - left, left);
gh_ad_blocks(st, &sth, pad, sizeof pad);
}
gh_ad_blocks(st, &sth, c, c_len & ~15);
left = c_len & 15;
if (left != 0) {
unsigned char pad[16];
memset(pad, 0, sizeof pad);
memcpy(pad, c + c_len - left, left);
gh_ad_blocks(st, &sth, pad, sizeof pad);
}
final_block = REV128(SET64x2(ad_len * 8, c_len * 8));
STORE32_BE(j + NPUBBYTES, 1);
encrypt(st, computed_mac, j);
STORE128(last_block, final_block);
gh_ad_blocks(st, &sth, last_block, 16);
STORE128(computed_mac, XOR128(LOAD128(computed_mac), REV128(sth.acc)));
ret = crypto_verify_16(mac, computed_mac);
sodium_memzero(computed_mac, sizeof computed_mac);
return ret;
}
int
crypto_aead_aes256gcm_decrypt_detached_afternm(unsigned char *m, unsigned char *nsec,
const unsigned char *c, unsigned long long c_len_,
const unsigned char *mac, const unsigned char *ad,
unsigned long long ad_len_,
const unsigned char *npub,
const crypto_aead_aes256gcm_state *st_)
{
const State *st = (const State *) (const void *) st_;
GHash sth;
CRYPTO_ALIGN(16) unsigned char j[16];
unsigned char computed_mac[16];
size_t gh_required_blocks;
const size_t ad_len = (size_t) ad_len_;
const size_t c_len = (size_t) c_len_;
const size_t m_len = c_len;
(void) nsec;
if (ad_len_ > SODIUM_SIZE_MAX || c_len_ > SODIUM_SIZE_MAX) {
sodium_misuse();
}
if (m == NULL) {
return crypto_aead_aes256gcm_verify_mac(nsec, c, c_len, mac, ad, ad_len, npub, st_);
}
gh_required_blocks = required_blocks(ad_len, m_len);
if (gh_required_blocks == 0) {
return -1;
}
gh_init(&sth);
memcpy(j, npub, NPUBBYTES);
STORE32_BE(j + NPUBBYTES, 2);
aes_gcm_decrypt_generic(st, &sth, computed_mac, m, c, m_len, ad, ad_len, j);
if (crypto_verify_16(mac, computed_mac) != 0) {
sodium_memzero(computed_mac, sizeof computed_mac);
memset(m, 0xd0, m_len);
return -1;
}
return 0;
}
int
crypto_aead_aes256gcm_decrypt_afternm(unsigned char *m, unsigned long long *mlen_p,
unsigned char *nsec, const unsigned char *c,
unsigned long long clen, const unsigned char *ad,
unsigned long long adlen, const unsigned char *npub,
const crypto_aead_aes256gcm_state *st_)
{
unsigned long long mlen = 0ULL;
int ret = -1;
if (clen >= ABYTES) {
ret = crypto_aead_aes256gcm_decrypt_detached_afternm(
m, nsec, c, clen - ABYTES, c + clen - ABYTES, ad, adlen, npub, st_);
}
if (mlen_p != NULL) {
if (ret == 0) {
mlen = clen - ABYTES;
}
*mlen_p = mlen;
}
return ret;
}
int
crypto_aead_aes256gcm_decrypt_detached(unsigned char *m, unsigned char *nsec,
const unsigned char *c, unsigned long long clen,
const unsigned char *mac, const unsigned char *ad,
unsigned long long adlen, const unsigned char *npub,
const unsigned char *k)
{
CRYPTO_ALIGN(16) crypto_aead_aes256gcm_state st;
PREFETCH_WRITE(m);
PREFETCH_READ(c);
PREFETCH_READ(ad);
crypto_aead_aes256gcm_beforenm(&st, k);
return crypto_aead_aes256gcm_decrypt_detached_afternm(
m, nsec, c, clen, mac, ad, adlen, npub, (const crypto_aead_aes256gcm_state *) &st);
}
int
crypto_aead_aes256gcm_decrypt(unsigned char *m, unsigned long long *mlen_p, unsigned char *nsec,
const unsigned char *c, unsigned long long clen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *npub, const unsigned char *k)
{
CRYPTO_ALIGN(16) crypto_aead_aes256gcm_state st;
int ret;
PREFETCH_WRITE(m);
PREFETCH_READ(c);
PREFETCH_READ(ad);
crypto_aead_aes256gcm_beforenm(&st, k);
ret = crypto_aead_aes256gcm_decrypt_afternm(m, mlen_p, nsec, c, clen, ad, adlen, npub,
(const crypto_aead_aes256gcm_state *) &st);
sodium_memzero(&st, sizeof st);
return ret;
}
int
crypto_aead_aes256gcm_is_available(void)
{
return sodium_runtime_has_armcrypto();
}
#endif
|
5091c9e14c49f9799bc9985442295e882a14d3b0
|
0744dcc5394cebf57ebcba343747af6871b67017
|
/os/board/rtl8730e/src/component/soc/amebad2/atf/include/export/lib/utils_def_exp.h
|
d4a4a85dd421ad188ded5389f3d74ebf7645121a
|
[
"GPL-1.0-or-later",
"BSD-3-Clause",
"ISC",
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-other-permissive",
"Apache-2.0"
] |
permissive
|
Samsung/TizenRT
|
96abf62f1853f61fcf91ff14671a5e0c6ca48fdb
|
1a5c2e00a4b1bbf4c505bbf5cc6a8259e926f686
|
refs/heads/master
| 2023-08-31T08:59:33.327998
| 2023-08-08T06:09:20
| 2023-08-31T04:38:20
| 82,517,252
| 590
| 719
|
Apache-2.0
| 2023-09-14T06:54:49
| 2017-02-20T04:38:30
|
C
|
UTF-8
|
C
| false
| false
| 1,073
|
h
|
utils_def_exp.h
|
/*
* Copyright (c) 2016-2019, ARM Limited and Contributors. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef ARM_TRUSTED_FIRMWARE_EXPORT_LIB_UTILS_DEF_EXP_H
#define ARM_TRUSTED_FIRMWARE_EXPORT_LIB_UTILS_DEF_EXP_H
/* EXPORT HEADER -- See include/export/README for details! -- EXPORT HEADER */
/*
* For those constants to be shared between C and other sources, apply a 'U',
* 'UL', 'ULL', 'L' or 'LL' suffix to the argument only in C, to avoid
* undefined or unintended behaviour.
*
* The GNU assembler and linker do not support these suffixes (it causes the
* build process to fail) therefore the suffix is omitted when used in linker
* scripts and assembler files.
*/
#if defined(__ASSEMBLER__)
# define U(_x) (_x)
# define UL(_x) (_x)
# define ULL(_x) (_x)
# define L(_x) (_x)
# define LL(_x) (_x)
#else
# define U_(_x) (_x##U)
# define U(_x) U_(_x)
# define UL(_x) (_x##UL)
# define ULL(_x) (_x##ULL)
# define L(_x) (_x##L)
# define LL(_x) (_x##LL)
#endif
#endif /* ARM_TRUSTED_FIRMWARE_EXPORT_LIB_UTILS_DEF_EXP_H */
|
adc14b7ae008faf3d0070444874a6d63cce39a91
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/drivers/cpufreq/spear-cpufreq.c
|
156829f4576de63497147d6e72f5e1d05e2e5cae
|
[
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 7,129
|
c
|
spear-cpufreq.c
|
/*
* drivers/cpufreq/spear-cpufreq.c
*
* CPU Frequency Scaling for SPEAr platform
*
* Copyright (C) 2012 ST Microelectronics
* Deepak Sikri <deepak.sikri@st.com>
*
* This file is licensed under the terms of the GNU General Public
* License version 2. This program is licensed "as is" without any
* warranty of any kind, whether express or implied.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/clk.h>
#include <linux/cpufreq.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/types.h>
/* SPEAr CPUFreq driver data structure */
static struct {
struct clk *clk;
unsigned int transition_latency;
struct cpufreq_frequency_table *freq_tbl;
u32 cnt;
} spear_cpufreq;
static int spear_cpufreq_verify(struct cpufreq_policy *policy)
{
return cpufreq_frequency_table_verify(policy, spear_cpufreq.freq_tbl);
}
static unsigned int spear_cpufreq_get(unsigned int cpu)
{
return clk_get_rate(spear_cpufreq.clk) / 1000;
}
static struct clk *spear1340_cpu_get_possible_parent(unsigned long newfreq)
{
struct clk *sys_pclk;
int pclk;
/*
* In SPEAr1340, cpu clk's parent sys clk can take input from
* following sources
*/
const char *sys_clk_src[] = {
"sys_syn_clk",
"pll1_clk",
"pll2_clk",
"pll3_clk",
};
/*
* As sys clk can have multiple source with their own range
* limitation so we choose possible sources accordingly
*/
if (newfreq <= 300000000)
pclk = 0; /* src is sys_syn_clk */
else if (newfreq > 300000000 && newfreq <= 500000000)
pclk = 3; /* src is pll3_clk */
else if (newfreq == 600000000)
pclk = 1; /* src is pll1_clk */
else
return ERR_PTR(-EINVAL);
/* Get parent to sys clock */
sys_pclk = clk_get(NULL, sys_clk_src[pclk]);
if (IS_ERR(sys_pclk))
pr_err("Failed to get %s clock\n", sys_clk_src[pclk]);
return sys_pclk;
}
/*
* In SPEAr1340, we cannot use newfreq directly because we need to actually
* access a source clock (clk) which might not be ancestor of cpu at present.
* Hence in SPEAr1340 we would operate on source clock directly before switching
* cpu clock to it.
*/
static int spear1340_set_cpu_rate(struct clk *sys_pclk, unsigned long newfreq)
{
struct clk *sys_clk;
int ret = 0;
sys_clk = clk_get_parent(spear_cpufreq.clk);
if (IS_ERR(sys_clk)) {
pr_err("failed to get cpu's parent (sys) clock\n");
return PTR_ERR(sys_clk);
}
/* Set the rate of the source clock before changing the parent */
ret = clk_set_rate(sys_pclk, newfreq);
if (ret) {
pr_err("Failed to set sys clk rate to %lu\n", newfreq);
return ret;
}
ret = clk_set_parent(sys_clk, sys_pclk);
if (ret) {
pr_err("Failed to set sys clk parent\n");
return ret;
}
return 0;
}
static int spear_cpufreq_target(struct cpufreq_policy *policy,
unsigned int target_freq, unsigned int relation)
{
struct cpufreq_freqs freqs;
unsigned long newfreq;
struct clk *srcclk;
int index, ret, mult = 1;
if (cpufreq_frequency_table_target(policy, spear_cpufreq.freq_tbl,
target_freq, relation, &index))
return -EINVAL;
freqs.old = spear_cpufreq_get(0);
newfreq = spear_cpufreq.freq_tbl[index].frequency * 1000;
if (of_machine_is_compatible("st,spear1340")) {
/*
* SPEAr1340 is special in the sense that due to the possibility
* of multiple clock sources for cpu clk's parent we can have
* different clock source for different frequency of cpu clk.
* Hence we need to choose one from amongst these possible clock
* sources.
*/
srcclk = spear1340_cpu_get_possible_parent(newfreq);
if (IS_ERR(srcclk)) {
pr_err("Failed to get src clk\n");
return PTR_ERR(srcclk);
}
/* SPEAr1340: src clk is always 2 * intended cpu clk */
mult = 2;
} else {
/*
* src clock to be altered is ancestor of cpu clock. Hence we
* can directly work on cpu clk
*/
srcclk = spear_cpufreq.clk;
}
newfreq = clk_round_rate(srcclk, newfreq * mult);
if (newfreq < 0) {
pr_err("clk_round_rate failed for cpu src clock\n");
return newfreq;
}
freqs.new = newfreq / 1000;
freqs.new /= mult;
cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
if (mult == 2)
ret = spear1340_set_cpu_rate(srcclk, newfreq);
else
ret = clk_set_rate(spear_cpufreq.clk, newfreq);
/* Get current rate after clk_set_rate, in case of failure */
if (ret) {
pr_err("CPU Freq: cpu clk_set_rate failed: %d\n", ret);
freqs.new = clk_get_rate(spear_cpufreq.clk) / 1000;
}
cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
return ret;
}
static int spear_cpufreq_init(struct cpufreq_policy *policy)
{
int ret;
ret = cpufreq_frequency_table_cpuinfo(policy, spear_cpufreq.freq_tbl);
if (ret) {
pr_err("cpufreq_frequency_table_cpuinfo() failed");
return ret;
}
cpufreq_frequency_table_get_attr(spear_cpufreq.freq_tbl, policy->cpu);
policy->cpuinfo.transition_latency = spear_cpufreq.transition_latency;
policy->cur = spear_cpufreq_get(0);
cpumask_setall(policy->cpus);
return 0;
}
static int spear_cpufreq_exit(struct cpufreq_policy *policy)
{
cpufreq_frequency_table_put_attr(policy->cpu);
return 0;
}
static struct freq_attr *spear_cpufreq_attr[] = {
&cpufreq_freq_attr_scaling_available_freqs,
NULL,
};
static struct cpufreq_driver spear_cpufreq_driver = {
.name = "cpufreq-spear",
.flags = CPUFREQ_STICKY,
.verify = spear_cpufreq_verify,
.target = spear_cpufreq_target,
.get = spear_cpufreq_get,
.init = spear_cpufreq_init,
.exit = spear_cpufreq_exit,
.attr = spear_cpufreq_attr,
};
static int spear_cpufreq_driver_init(void)
{
struct device_node *np;
const struct property *prop;
struct cpufreq_frequency_table *freq_tbl;
const __be32 *val;
int cnt, i, ret;
np = of_find_node_by_path("/cpus/cpu@0");
if (!np) {
pr_err("No cpu node found");
return -ENODEV;
}
if (of_property_read_u32(np, "clock-latency",
&spear_cpufreq.transition_latency))
spear_cpufreq.transition_latency = CPUFREQ_ETERNAL;
prop = of_find_property(np, "cpufreq_tbl", NULL);
if (!prop || !prop->value) {
pr_err("Invalid cpufreq_tbl");
ret = -ENODEV;
goto out_put_node;
}
cnt = prop->length / sizeof(u32);
val = prop->value;
freq_tbl = kmalloc(sizeof(*freq_tbl) * (cnt + 1), GFP_KERNEL);
if (!freq_tbl) {
ret = -ENOMEM;
goto out_put_node;
}
for (i = 0; i < cnt; i++) {
freq_tbl[i].index = i;
freq_tbl[i].frequency = be32_to_cpup(val++);
}
freq_tbl[i].index = i;
freq_tbl[i].frequency = CPUFREQ_TABLE_END;
spear_cpufreq.freq_tbl = freq_tbl;
of_node_put(np);
spear_cpufreq.clk = clk_get(NULL, "cpu_clk");
if (IS_ERR(spear_cpufreq.clk)) {
pr_err("Unable to get CPU clock\n");
ret = PTR_ERR(spear_cpufreq.clk);
goto out_put_mem;
}
ret = cpufreq_register_driver(&spear_cpufreq_driver);
if (!ret)
return 0;
pr_err("failed register driver: %d\n", ret);
clk_put(spear_cpufreq.clk);
out_put_mem:
kfree(freq_tbl);
return ret;
out_put_node:
of_node_put(np);
return ret;
}
late_initcall(spear_cpufreq_driver_init);
MODULE_AUTHOR("Deepak Sikri <deepak.sikri@st.com>");
MODULE_DESCRIPTION("SPEAr CPUFreq driver");
MODULE_LICENSE("GPL");
|
08bb756c364b1e116c4295ba01eda990bb5fec37
|
4674b8088ffdf55905d44995f08a0792a3e4cd5c
|
/src/common/hw_features_common.h
|
9cddbd50e56a9a4b1ca7b49fb0b880e83ecc08b6
|
[
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
vanhoefm/krackattacks-scripts
|
41daca791638a92aa4cfa68a582e46119037560e
|
4b78669686f74efe664c6543b1b5b1616b22f902
|
refs/heads/research
| 2022-10-29T20:21:11.512335
| 2022-10-16T18:44:41
| 2022-10-16T18:44:41
| 107,408,514
| 2,184
| 577
|
NOASSERTION
| 2021-07-06T12:43:49
| 2017-10-18T12:58:08
|
C
|
UTF-8
|
C
| false
| false
| 1,565
|
h
|
hw_features_common.h
|
/*
* Common hostapd/wpa_supplicant HW features
* Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi>
* Copyright (c) 2015, Qualcomm Atheros, Inc.
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef HW_FEATURES_COMMON_H
#define HW_FEATURES_COMMON_H
#include "drivers/driver.h"
struct hostapd_channel_data * hw_get_channel_chan(struct hostapd_hw_modes *mode,
int chan, int *freq);
struct hostapd_channel_data * hw_get_channel_freq(struct hostapd_hw_modes *mode,
int freq, int *chan);
int hw_get_freq(struct hostapd_hw_modes *mode, int chan);
int hw_get_chan(struct hostapd_hw_modes *mode, int freq);
int allowed_ht40_channel_pair(struct hostapd_hw_modes *mode, int pri_chan,
int sec_chan);
void get_pri_sec_chan(struct wpa_scan_res *bss, int *pri_chan, int *sec_chan);
int check_40mhz_5g(struct hostapd_hw_modes *mode,
struct wpa_scan_results *scan_res, int pri_chan,
int sec_chan);
int check_40mhz_2g4(struct hostapd_hw_modes *mode,
struct wpa_scan_results *scan_res, int pri_chan,
int sec_chan);
int hostapd_set_freq_params(struct hostapd_freq_params *data,
enum hostapd_hw_mode mode,
int freq, int channel, int ht_enabled,
int vht_enabled, int sec_channel_offset,
int vht_oper_chwidth, int center_segment0,
int center_segment1, u32 vht_caps);
void set_disable_ht40(struct ieee80211_ht_capabilities *htcaps,
int disabled);
int ieee80211ac_cap_check(u32 hw, u32 conf);
#endif /* HW_FEATURES_COMMON_H */
|
84c639e192375fee22129b88910d7c87628b738e
|
4de159aea4b1eb5a527a3011275be57c4bb8d28f
|
/src/deps/kazmath/ray3.h
|
738752c0701fc696c8a5403f035e531cc2a3a13a
|
[
"MIT",
"LicenseRef-scancode-free-unknown"
] |
permissive
|
tanis2000/binocle-c
|
27691ec089a4b75acc451ef6abc4767cb06a6fdd
|
cd3dbacdd5cb94bfce489b9ee2f07e218c645e29
|
refs/heads/master
| 2023-09-04T20:39:34.331172
| 2023-08-29T13:22:12
| 2023-08-29T13:22:12
| 192,515,187
| 132
| 8
|
MIT
| 2023-05-09T14:39:31
| 2019-06-18T10:07:33
|
C
|
UTF-8
|
C
| false
| false
| 842
|
h
|
ray3.h
|
#ifndef RAY3_H
#define RAY3_H
#include "utility.h"
#include "vec3.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct kmRay3 {
kmVec3 start;
kmVec3 dir;
} kmRay3;
struct kmPlane;
struct kmAABB3;
kmRay3* kmRay3Fill(kmRay3* ray, kmScalar px, kmScalar py, kmScalar pz, kmScalar vx, kmScalar vy, kmScalar vz);
kmRay3* kmRay3FromPointAndDirection(kmRay3* ray, const kmVec3* point, const kmVec3* direction);
kmBool kmRay3IntersectPlane(kmVec3* pOut, const kmRay3* ray, const struct kmPlane* plane);
kmBool kmRay3IntersectTriangle(const kmRay3* ray, const kmVec3* v0, const kmVec3* v1, const kmVec3* v2, kmVec3* intersection, kmVec3* normal, kmScalar* distance);
kmBool kmRay3IntersectAABB3(const kmRay3* ray, const struct kmAABB3* aabb, kmVec3* intersection, kmScalar* distance);
#ifdef __cplusplus
}
#endif
#endif /* RAY3_H */
|
56176dd1f31b2fb5b0b889bba0f3589a838c1232
|
79d343002bb63a44f8ab0dbac0c9f4ec54078c3a
|
/lib/libc/mingw/secapi/_access_s.c
|
9be582e8787ba0fc601f55404222078483d9498d
|
[
"MIT",
"LGPL-2.0-or-later",
"ZPL-2.1",
"LicenseRef-scancode-public-domain"
] |
permissive
|
ziglang/zig
|
4aa75d8d3bcc9e39bf61d265fd84b7f005623fc5
|
f4c9e19bc3213c2bc7e03d7b06d7129882f39f6c
|
refs/heads/master
| 2023-08-31T13:16:45.980913
| 2023-08-31T05:50:29
| 2023-08-31T05:50:29
| 40,276,274
| 25,560
| 2,399
|
MIT
| 2023-09-14T21:09:50
| 2015-08-06T00:51:28
|
Zig
|
UTF-8
|
C
| false
| false
| 927
|
c
|
_access_s.c
|
#include <windows.h>
#include <malloc.h>
#include <errno.h>
#include <msvcrt.h>
#include <io.h>
static errno_t __cdecl _int_access_s (const char *, int);
static errno_t __cdecl _stub (const char *, int);
errno_t __cdecl (*__MINGW_IMP_SYMBOL(_access_s))(const char *, int) =
_stub;
static errno_t __cdecl
_stub (const char *s, int m)
{
errno_t __cdecl (*f)(const char *, int) = __MINGW_IMP_SYMBOL(_access_s);
if (f == _stub)
{
f = (errno_t __cdecl (*)(const char *, int))
GetProcAddress (__mingw_get_msvcrt_handle (), "_access_s");
if (!f)
f = _int_access_s;
__MINGW_IMP_SYMBOL(_access_s) = f;
}
return (*f)(s, m);
}
errno_t __cdecl
_access_s (const char *s, int m)
{
return _stub (s, m);
}
static errno_t __cdecl
_int_access_s (const char *s, int m)
{
if (!s || (m & ~6) != 0)
{
_access (NULL, m);
return EINVAL;
}
if (!_access (s, m))
return 0;
return errno;
}
|
0c42ebfd5124b34527e3bc2c0950712753e96a03
|
79d343002bb63a44f8ab0dbac0c9f4ec54078c3a
|
/lib/libc/include/powerpc-linux-any/asm/posix_types.h
|
aaeda20fed924e09ea3de9f2766a452ee4d6fa65
|
[
"MIT"
] |
permissive
|
ziglang/zig
|
4aa75d8d3bcc9e39bf61d265fd84b7f005623fc5
|
f4c9e19bc3213c2bc7e03d7b06d7129882f39f6c
|
refs/heads/master
| 2023-08-31T13:16:45.980913
| 2023-08-31T05:50:29
| 2023-08-31T05:50:29
| 40,276,274
| 25,560
| 2,399
|
MIT
| 2023-09-14T21:09:50
| 2015-08-06T00:51:28
|
Zig
|
UTF-8
|
C
| false
| false
| 593
|
h
|
posix_types.h
|
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _ASM_POWERPC_POSIX_TYPES_H
#define _ASM_POWERPC_POSIX_TYPES_H
/*
* This file is generally used by user-level software, so you need to
* be a little careful about namespace pollution etc. Also, we cannot
* assume GCC is being used.
*/
#ifdef __powerpc64__
typedef unsigned long __kernel_old_dev_t;
#define __kernel_old_dev_t __kernel_old_dev_t
#else
typedef short __kernel_ipc_pid_t;
#define __kernel_ipc_pid_t __kernel_ipc_pid_t
#endif
#include <asm-generic/posix_types.h>
#endif /* _ASM_POWERPC_POSIX_TYPES_H */
|
8d75cada69a3885eb345811244e1617727cdcace
|
c244e99bb9d753c6c1e4449301aa9687a64cd9e2
|
/misc/src/popcnttest.c
|
1413184e9f24161ec4f6bdd86bf5c4508c4dcc30
|
[
"BSD-2-Clause"
] |
permissive
|
cbsd/cbsd
|
61338c64dcf41ca96c8afcb1a5fac45af3c0bbc8
|
9b1a872fdc216168310df89fb1a35adbaa0457b9
|
refs/heads/develop
| 2023-09-05T15:13:49.482412
| 2023-09-02T10:12:23
| 2023-09-02T10:12:23
| 2,840,189
| 501
| 80
|
BSD-2-Clause
| 2023-07-26T20:10:14
| 2011-11-24T00:46:39
|
C
|
UTF-8
|
C
| false
| false
| 168
|
c
|
popcnttest.c
|
#include <stdio.h>
//#include <smmintrin.h>
#include <nmmintrin.h>
int
main(void)
{
int pop = _mm_popcnt_u32(0xf0f0f0f0ULL);
printf("pop = %d\n", pop);
return 0;
}
|
dd5f31349c496c6c002d01a6c7c606469be01622
|
fbdc48c28e54fb33ae4842ef95ff63893902c99a
|
/src/drivers/winc1500/include/driver/include/nmdrv.h
|
f702ee545412376d354c0b8e442615df69fb987e
|
[
"MIT"
] |
permissive
|
openmv/openmv
|
44d4b79fc8693950a2e330e5e0fd95b5c36e230f
|
8a90e070a88b7fc14c87a00351b9c4a213278419
|
refs/heads/master
| 2023-08-30T20:59:57.227603
| 2023-08-23T16:50:55
| 2023-08-23T16:50:55
| 14,360,940
| 2,150
| 1,226
|
MIT
| 2023-09-14T07:18:15
| 2013-11-13T10:23:44
|
C
|
UTF-8
|
C
| false
| false
| 5,052
|
h
|
nmdrv.h
|
/**
*
* \file
*
* \brief This module contains NMC1500 M2M driver APIs declarations.
*
* Copyright (c) 2016-2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*
*/
#ifndef _NMDRV_H_
#define _NMDRV_H_
#include "common/include/nm_common.h"
/**
* @struct tstrM2mRev
* @brief Structure holding firmware version parameters and build date/time
*/
typedef struct {
uint32 u32Chipid; /* HW revision which will be basically the chip ID */
uint8 u8FirmwareMajor; /* Version Major Number which represents the official release base */
uint8 u8FirmwareMinor; /* Version Minor Number which represents the engineering release base */
uint8 u8FirmwarePatch; /* Version patch Number which represents the patches release base */
uint8 u8DriverMajor; /* Version Major Number which represents the official release base */
uint8 u8DriverMinor; /* Version Minor Number which represents the engineering release base */
uint8 u8DriverPatch; /* Version Patch Number which represents the patches release base */
uint8 BuildDate[sizeof(__DATE__)];
uint8 BuildTime[sizeof(__TIME__)];
uint8 _PAD8_;
uint16 u16FirmwareSvnNum;
uint16 _PAD16_[2];
} tstrM2mRev;
/**
* @struct tstrM2mBinaryHeader
* @brief Structure holding compatibility version info for firmware binaries
*/
typedef struct {
tstrM2mRev binVerInfo;
uint32 flashOffset;
uint32 payloadSize;
} tstrM2mBinaryHeader;
#ifdef __cplusplus
extern "C" {
#endif
/**
* @fn nm_get_firmware_info(tstrM2mRev* M2mRev)
* @brief Get Firmware version info
* @param [out] M2mRev
* pointer holds address of structure "tstrM2mRev" that contains the firmware version parameters
* @version 1.0
*/
sint8 nm_get_firmware_info(tstrM2mRev* M2mRev);
/**
* @fn nm_get_firmware_full_info(tstrM2mRev* pstrRev)
* @brief Get Firmware version info
* @param [out] M2mRev
* pointer holds address of structure "tstrM2mRev" that contains the firmware version parameters
* @version 1.0
*/
sint8 nm_get_firmware_full_info(tstrM2mRev* pstrRev);
/**
* @fn nm_get_ota_firmware_info(tstrM2mRev* pstrRev)
* @brief Get Firmware version info
* @param [out] M2mRev
* pointer holds address of structure "tstrM2mRev" that contains the firmware version parameters
* @version 1.0
*/
sint8 nm_get_ota_firmware_info(tstrM2mRev* pstrRev);
/*
* @fn nm_drv_init
* @brief Initialize NMC1000 driver
* @return ZERO in case of success and Negative error code in case of failure
*/
sint8 nm_drv_init_download_mode(void);
/*
* @fn nm_drv_init
* @brief Initialize NMC1000 driver
* @return M2M_SUCCESS in case of success and Negative error code in case of failure
* @param [in] arg
* Generic argument TBD
* @return ZERO in case of success and Negative error code in case of failure
*/
sint8 nm_drv_init(void * arg);
/*
* @fn nm_drv_init_hold
* @brief First part of nm_drv_init, up to the point of initializing spi for flash access.
* @see nm_drv_init
* @return M2M_SUCCESS in case of success and Negative error code in case of failure
* @param [in] req_serial_number
* Parameter inherited from nm_drv_init
* @return ZERO in case of success and Negative error code in case of failure
*/
sint8 nm_drv_init_hold(void);
/*
* @fn nm_drv_init_start
* @brief Second part of nm_drv_init, continuing from where nm_drv_init_hold left off.
* @see nm_drv_init
* @return M2M_SUCCESS in case of success and Negative error code in case of failure
* @param [in] arg
* Parameter inherited from nm_drv_init
* @return ZERO in case of success and Negative error code in case of failure
*/
sint8 nm_drv_init_start(void * arg);
/**
* @fn nm_drv_deinit
* @brief Deinitialize NMC1000 driver
* @author M. Abdelmawla
* @param [in] arg
* Generic argument TBD
* @return ZERO in case of success and Negative error code in case of failure
*/
sint8 nm_drv_deinit(void * arg);
#ifdef __cplusplus
}
#endif
#endif /*_NMDRV_H_*/
|
5c362b36ca2e6c9434ae38d889704be92fb119e8
|
9de0cec678bc4a3bec2b4adabef9f39ff5b4afac
|
/PWGGA/PHOSTasks/PHOS_Run2embedding/macros/sim.C
|
9dd960660295e3d2e123076f7978fe4224059947
|
[] |
permissive
|
alisw/AliPhysics
|
91bf1bd01ab2af656a25ff10b25e618a63667d3e
|
5df28b2b415e78e81273b0d9bf5c1b99feda3348
|
refs/heads/master
| 2023-08-31T20:41:44.927176
| 2023-08-31T14:51:12
| 2023-08-31T14:51:12
| 61,661,378
| 129
| 1,150
|
BSD-3-Clause
| 2023-09-14T18:48:45
| 2016-06-21T19:31:29
|
C++
|
UTF-8
|
C
| false
| false
| 848
|
c
|
sim.C
|
void sim(Int_t nev=50) {
if (gSystem->Getenv("SIM_EVENTS"))
nev = atoi(gSystem->Getenv("SIM_EVENTS"));
printf("GENERATE << %d >> events \n",nev);
AliSimulation simulator;
simulator.SetMakeSDigits("PHOS");
simulator.SetMakeDigits("PHOS");
simulator.SetDefaultStorage("alien://Folder=/alice/data/2018/OCDB");
simulator.SetRunHLT("");
AliPHOSSimParam *simParam = AliPHOSSimParam::GetInstance() ;
simParam->SetAPDNoise(0.000001) ;
simParam->SetCellNonLineairyA(0.001) ;
simParam->SetCellNonLineairyB(0.2) ;
simParam->SetCellNonLineairyC(1.031) ; //no NL
simulator.UseMagFieldFromGRP();
simulator.SetRunQA(":") ;
gSystem->Load("liblhapdf"); // Parton density functions
gSystem->Load("libEGPythia6"); // TGenerator interface
gSystem->Load("libpythia6"); // Pythia 6.2
simulator.Run(nev);
}
|
0b6ff573f0e41baa05a6b06395f140af009d61e7
|
baa9fffc817a2a993d4ecc774d3f277783308c20
|
/src/ucp/stream/stream_recv.c
|
56ef4c4b760c9ba649f982801369749c5baf4b58
|
[
"BSD-3-Clause"
] |
permissive
|
openucx/ucx
|
9a0f2205295afbdf3cff14b5d24af781b123f5ea
|
73a48700badb7cbace64d94b82f408e2a26fca32
|
refs/heads/master
| 2023-09-01T16:51:26.913950
| 2023-09-01T13:02:25
| 2023-09-01T13:02:25
| 25,379,390
| 966
| 420
|
NOASSERTION
| 2023-09-14T12:29:35
| 2014-10-17T22:17:24
|
C
|
UTF-8
|
C
| false
| false
| 21,571
|
c
|
stream_recv.c
|
/**
* Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2017. ALL RIGHTS RESERVED.
*
* See file LICENSE for terms.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <ucp/core/ucp_ep.h>
#include <ucp/core/ucp_worker.h>
#include <ucp/core/ucp_context.h>
#include <ucp/core/ucp_request.h>
#include <ucp/core/ucp_request.inl>
#include <ucp/stream/stream.h>
#include <ucs/datastruct/mpool.inl>
#include <ucs/profile/profile.h>
/* @verbatim
* Data layout within Stream AM
* |---------------------------------------------------------------------------------------------------------------------------|
* | ucp_recv_desc_t | \ / | ucp_stream_am_data_t | payload |
* |-----------------------------------------------------------------| \ / |----------------------|-------------------------|
* | stream_queue | length | payload_offset | flags | \/ | am_header | |
* | tag_list (not used) | | | | /\ | rdesc | |
* |---------------------|----------------|----------------|---------| / \ |----------------------|-------------------------|
* | 4 * sizeof(ptr) | 32 bits | 32 bits | 16 bits | / \ | 64 bits | up to TL AM buffer size |
* |---------------------------------------------------------------------------------------------------------------------------|
* @endverbatim
*
* stream_queue is an entry link in the "unexpected" queue per endpoint
* length is an actual size of 'payload'
* payload_offset is a distance between 'ucp_recv_desc_t *' and 'payload *'
* X is an optional empty space which is a result of partial
* handled payload in case when 'length' greater than user's
* buffer size passed to @ref ucp_stream_recv_nb
* am_header is an active message header, not actual after ucp_recv_desc_t
* initialization and setup of offsets
* rdesc pointer to 'ucp_recv_desc_t *', it's needed to get access to
* 'ucp_recv_desc_t *' inside @ref ucp_stream_release_data after
* the buffer was returned to user by
* @ref ucp_stream_recv_data_nb as a pointer to 'payload'
*/
#define ucp_stream_rdesc_payload(_rdesc) \
(UCS_PTR_BYTE_OFFSET((_rdesc), (_rdesc)->payload_offset))
#define ucp_stream_rdesc_am_data(_rdesc) \
((ucp_stream_am_data_t *) \
UCS_PTR_BYTE_OFFSET(ucp_stream_rdesc_payload(_rdesc), \
-sizeof(ucp_stream_am_data_t)))
#define ucp_stream_rdesc_from_data(_data) \
((ucp_stream_am_data_t *)_data - 1)->rdesc
static UCS_F_ALWAYS_INLINE ucp_recv_desc_t *
ucp_stream_rdesc_dequeue(ucp_ep_ext_t *ep_ext)
{
ucp_recv_desc_t *rdesc = ucs_queue_pull_elem_non_empty(&ep_ext->stream.match_q,
ucp_recv_desc_t,
stream_queue);
ucs_assert(ucp_stream_ep_has_data(ep_ext));
if (ucs_unlikely(ucs_queue_is_empty(&ep_ext->stream.match_q))) {
ep_ext->ep->flags &= ~UCP_EP_FLAG_STREAM_HAS_DATA;
if (ucp_stream_ep_is_queued(ep_ext)) {
ucp_stream_ep_dequeue(ep_ext);
}
}
return rdesc;
}
static UCS_F_ALWAYS_INLINE ucp_recv_desc_t *
ucp_stream_rdesc_get(ucp_ep_ext_t *ep_ext)
{
ucp_recv_desc_t *rdesc = ucs_queue_head_elem_non_empty(&ep_ext->stream.match_q,
ucp_recv_desc_t,
stream_queue);
ucs_assert(ucp_stream_ep_has_data(ep_ext));
ucs_trace_data("ep %p, rdesc %p with %u stream bytes", ep_ext->ep, rdesc,
rdesc->length);
return rdesc;
}
static UCS_F_ALWAYS_INLINE ucs_status_ptr_t
ucp_stream_recv_data_nb_nolock(ucp_ep_h ep, size_t *length)
{
ucp_ep_ext_t *ep_ext = ep->ext;
ucp_recv_desc_t *rdesc;
ucp_stream_am_data_t *am_data;
if (ucs_unlikely(!ucp_stream_ep_has_data(ep_ext))) {
return UCS_STATUS_PTR(UCS_OK);
}
rdesc = ucp_stream_rdesc_dequeue(ep_ext);
*length = rdesc->length;
am_data = ucp_stream_rdesc_am_data(rdesc);
am_data->rdesc = rdesc;
return am_data + 1;
}
UCS_PROFILE_FUNC(ucs_status_ptr_t, ucp_stream_recv_data_nb, (ep, length),
ucp_ep_h ep, size_t *length)
{
ucs_status_ptr_t status_ptr;
UCP_CONTEXT_CHECK_FEATURE_FLAGS(ep->worker->context, UCP_FEATURE_STREAM,
return UCS_STATUS_PTR(UCS_ERR_INVALID_PARAM));
UCP_WORKER_THREAD_CS_ENTER_CONDITIONAL(ep->worker);
status_ptr = ucp_stream_recv_data_nb_nolock(ep, length);
UCP_WORKER_THREAD_CS_EXIT_CONDITIONAL(ep->worker);
return status_ptr;
}
static UCS_F_ALWAYS_INLINE void
ucp_stream_rdesc_dequeue_and_release(ucp_recv_desc_t *rdesc,
ucp_ep_ext_t *ep_ext)
{
ucs_assert(ucp_stream_ep_has_data(ep_ext));
ucs_assert(rdesc == ucs_queue_head_elem_non_empty(&ep_ext->stream.match_q,
ucp_recv_desc_t,
stream_queue));
ucp_stream_rdesc_dequeue(ep_ext);
ucp_recv_desc_release(rdesc);
}
UCS_PROFILE_FUNC_VOID(ucp_stream_data_release, (ep, data),
ucp_ep_h ep, void *data)
{
ucp_recv_desc_t *rdesc = ucp_stream_rdesc_from_data(data);
UCP_WORKER_THREAD_CS_ENTER_CONDITIONAL(ep->worker);
ucp_recv_desc_release(rdesc);
UCP_WORKER_THREAD_CS_EXIT_CONDITIONAL(ep->worker);
}
static UCS_F_ALWAYS_INLINE ssize_t
ucp_stream_rdata_unpack(const void *rdata, size_t length, ucp_request_t *dst_req)
{
size_t valid_len;
int last;
ucs_status_t status;
/* Truncated error is not actual for stream, need to adjust */
valid_len = dst_req->recv.length - dst_req->recv.stream.offset;
if (valid_len <= length) {
last = (valid_len == length);
} else {
valid_len = length;
last = !(dst_req->flags & UCP_REQUEST_FLAG_STREAM_RECV_WAITALL);
}
status = ucp_request_recv_data_unpack(dst_req, rdata, valid_len,
dst_req->recv.stream.offset, last);
if (ucs_likely(status == UCS_OK)) {
dst_req->recv.stream.offset += valid_len;
ucs_trace_data("unpacked %zd bytes of stream data %p",
valid_len, rdata);
return valid_len;
}
ucs_assert(status != UCS_ERR_MESSAGE_TRUNCATED);
return status;
}
static UCS_F_ALWAYS_INLINE ucs_status_t
ucp_stream_rdesc_advance(ucp_recv_desc_t *rdesc, ssize_t offset,
ucp_ep_ext_t *ep_ext)
{
ucs_assert(offset <= rdesc->length);
if (ucs_unlikely(offset < 0)) {
return (ucs_status_t)offset;
} else if (ucs_likely(offset == rdesc->length)) {
ucp_stream_rdesc_dequeue_and_release(rdesc, ep_ext);
} else {
rdesc->length -= offset;
rdesc->payload_offset += offset;
}
return UCS_OK;
}
static UCS_F_ALWAYS_INLINE ucs_status_t ucp_stream_process_rdesc_inplace(
ucp_recv_desc_t *rdesc, void *buffer, size_t count, size_t length,
const ucp_request_param_t *param, ucp_ep_ext_t *ep_ext)
{
ucp_worker_h worker = ep_ext->ep->worker;
ucs_status_t status;
ssize_t unpacked;
status = ucp_datatype_iter_unpack_single(worker, buffer, count,
ucp_stream_rdesc_payload(rdesc),
length, 0, param);
unpacked = ucs_likely(status == UCS_OK) ? length : status;
return ucp_stream_rdesc_advance(rdesc, unpacked, ep_ext);
}
static UCS_F_ALWAYS_INLINE ucs_status_t
ucp_stream_process_rdesc(ucp_recv_desc_t *rdesc, ucp_ep_ext_t *ep_ext,
ucp_request_t *req)
{
ssize_t unpacked;
unpacked = ucp_stream_rdata_unpack(ucp_stream_rdesc_payload(rdesc),
rdesc->length, req);
ucs_assert(req->recv.stream.offset <= req->recv.length);
return ucp_stream_rdesc_advance(rdesc, unpacked, ep_ext);
}
static UCS_F_ALWAYS_INLINE void
ucp_stream_recv_request_init(ucp_request_t *req, ucp_ep_h ep, void *buffer,
size_t count, size_t length,
ucp_datatype_t datatype,
const ucp_request_param_t *param)
{
uint32_t flags = ucp_request_param_flags(param);
req->flags = UCP_REQUEST_FLAG_STREAM_RECV |
((flags & UCP_STREAM_RECV_FLAG_WAITALL) ?
UCP_REQUEST_FLAG_STREAM_RECV_WAITALL : 0);
#if UCS_ENABLE_ASSERT
req->status = UCS_OK; /* for ucp_request_recv_data_unpack() */
#endif
req->recv.stream.length = 0;
req->recv.stream.offset = 0;
ucp_dt_recv_state_init(&req->recv.state, buffer, datatype, count);
req->recv.worker = ep->worker;
req->recv.buffer = buffer;
req->recv.datatype = datatype;
req->recv.length = ucs_likely(!UCP_DT_IS_GENERIC(datatype)) ? length :
ucp_dt_length(datatype, count, NULL, &req->recv.state);
req->recv.mem_type = ucp_request_get_memory_type(ep->worker->context,
(void*)buffer, count,
datatype, req->recv.length,
param);
if (param->op_attr_mask & UCP_OP_ATTR_FIELD_CALLBACK) {
req->flags |= UCP_REQUEST_FLAG_CALLBACK;
req->recv.stream.cb = param->cb.recv_stream;
req->user_data = ucp_request_param_user_data(param);
}
}
static UCS_F_ALWAYS_INLINE int
ucp_stream_recv_nb_is_inplace(ucp_ep_ext_t *ep_ext, size_t dt_length)
{
return ucp_stream_ep_has_data(ep_ext) &&
(ucp_stream_rdesc_get(ep_ext)->length >= dt_length);
}
UCS_PROFILE_FUNC(ucs_status_ptr_t, ucp_stream_recv_nb,
(ep, buffer, count, datatype, cb, length, flags),
ucp_ep_h ep, void *buffer, size_t count,
ucp_datatype_t datatype, ucp_stream_recv_callback_t cb,
size_t *length, unsigned flags)
{
ucp_request_param_t param = {
.op_attr_mask = UCP_OP_ATTR_FIELD_DATATYPE |
UCP_OP_ATTR_FIELD_CALLBACK |
UCP_OP_ATTR_FIELD_FLAGS,
.cb.recv_stream = (ucp_stream_recv_nbx_callback_t)cb,
.flags = flags,
.datatype = datatype
};
return ucp_stream_recv_nbx(ep, buffer, count, length, ¶m);
}
UCS_PROFILE_FUNC(ucs_status_ptr_t, ucp_stream_recv_nbx,
(ep, buffer, count, length, param),
ucp_ep_h ep, void *buffer, size_t count, size_t *length,
const ucp_request_param_t *param)
{
ucs_status_t status = UCS_OK;
ucp_ep_ext_t *ep_ext = ep->ext;
ucp_datatype_t datatype;
size_t dt_length;
ucp_request_t *req;
ucp_recv_desc_t *rdesc;
uint32_t attr_mask;
UCP_CONTEXT_CHECK_FEATURE_FLAGS(ep->worker->context, UCP_FEATURE_STREAM,
return UCS_STATUS_PTR(UCS_ERR_INVALID_PARAM));
UCP_REQUEST_CHECK_PARAM(param);
UCP_WORKER_THREAD_CS_ENTER_CONDITIONAL(ep->worker);
attr_mask = param->op_attr_mask &
(UCP_OP_ATTR_FIELD_DATATYPE | UCP_OP_ATTR_FLAG_NO_IMM_CMPL);
if (ucs_likely(attr_mask == 0)) {
datatype = ucp_dt_make_contig(1);
dt_length = count; /* use dt_length to suppress coverity false positive */
if (ucs_likely(ucp_stream_recv_nb_is_inplace(ep_ext, count))) {
rdesc = ucp_stream_rdesc_get(ep_ext);
status = ucp_stream_process_rdesc_inplace(rdesc, buffer, count,
dt_length, param, ep_ext);
*length = count;
goto out_status;
}
} else if (attr_mask == UCP_OP_ATTR_FIELD_DATATYPE) {
datatype = param->datatype;
if (!UCP_DT_IS_GENERIC(datatype)) {
dt_length = ucp_dt_length(datatype, count, buffer, NULL);
if (ucp_stream_recv_nb_is_inplace(ep_ext, dt_length)) {
rdesc = ucp_stream_rdesc_get(ep_ext);
status = ucp_stream_process_rdesc_inplace(rdesc, buffer, count,
dt_length, param,
ep_ext);
*length = dt_length;
goto out_status;
}
} else {
dt_length = 0;
}
} else {
datatype = ucp_dt_make_contig(1);
dt_length = count;
}
if (ucs_unlikely(param->op_attr_mask & UCP_OP_ATTR_FLAG_FORCE_IMM_CMPL)) {
status = UCS_ERR_NO_RESOURCE;
goto out_status;
}
req = ucp_request_get_param(ep->worker, param,
{
status = UCS_ERR_NO_MEMORY;
goto out_status;
});
ucp_stream_recv_request_init(req, ep, buffer, count, dt_length, datatype,
param);
/* OK, lets obtain all arrived data which matches the recv size */
while ((req->recv.stream.offset < req->recv.length) &&
ucp_stream_ep_has_data(ep_ext)) {
rdesc = ucp_stream_rdesc_get(ep_ext);
status = ucp_stream_process_rdesc(rdesc, ep_ext, req);
if (ucs_unlikely(status != UCS_OK)) {
goto out_put_request;
}
/*
* NOTE: generic datatype can be completed with any amount of data to
* avoid extra logic in ucp_stream_process_rdesc, exception is
* WAITALL flag
*/
if (ucs_unlikely(UCP_DT_IS_GENERIC(req->recv.datatype)) &&
!(req->flags & UCP_REQUEST_FLAG_STREAM_RECV_WAITALL)) {
break;
}
}
ucs_assert(req->recv.stream.offset <= req->recv.length);
if (ucp_request_can_complete_stream_recv(req)) {
*length = req->recv.stream.offset;
} else {
ucs_assert(!ucp_stream_ep_has_data(ep_ext));
ucs_queue_push(&ep_ext->stream.match_q, &req->recv.queue);
req += 1;
goto out;
}
out_put_request:
ucp_request_put_param(param, req);
out_status:
req = UCS_STATUS_PTR(status);
out:
UCP_WORKER_THREAD_CS_EXIT_CONDITIONAL(ep->worker);
return req;
}
static UCS_F_ALWAYS_INLINE ucs_status_t
ucp_stream_am_data_process(ucp_worker_t *worker, ucp_ep_ext_t *ep_ext,
ucp_stream_am_data_t *am_data, size_t length,
unsigned am_flags)
{
ucp_recv_desc_t rdesc_tmp;
void *payload;
ucp_recv_desc_t *rdesc;
ucp_request_t *req;
ssize_t unpacked;
rdesc_tmp.length = length;
rdesc_tmp.payload_offset = sizeof(*am_data); /* add sizeof(*rdesc) only if
am_data wont be handled in
place */
/* First, process expected requests */
if (!ucp_stream_ep_has_data(ep_ext)) {
while (!ucs_queue_is_empty(&ep_ext->stream.match_q)) {
req = ucs_queue_head_elem_non_empty(&ep_ext->stream.match_q,
ucp_request_t, recv.queue);
payload = UCS_PTR_BYTE_OFFSET(am_data, rdesc_tmp.payload_offset);
unpacked = ucp_stream_rdata_unpack(payload, rdesc_tmp.length, req);
if (ucs_unlikely(unpacked < 0)) {
ucs_fatal("failed to unpack from am_data %p with offset %u to request %p",
am_data, rdesc_tmp.payload_offset, req);
} else if (unpacked == rdesc_tmp.length) {
if (ucp_request_can_complete_stream_recv(req)) {
ucp_request_complete_stream_recv(req, ep_ext, UCS_OK);
}
return UCS_OK;
}
ucp_stream_rdesc_advance(&rdesc_tmp, unpacked, ep_ext);
/* This request is full, try next one */
ucs_assert(ucp_request_can_complete_stream_recv(req));
ucp_request_complete_stream_recv(req, ep_ext, UCS_OK);
}
}
ucs_assert(rdesc_tmp.length > 0);
/* Now, enqueue the rest of data */
if (ucs_likely(!(am_flags & UCT_CB_PARAM_FLAG_DESC))) {
rdesc = (ucp_recv_desc_t*)ucs_mpool_set_get_inline(&worker->am_mps,
length);
ucs_assertv_always(rdesc != NULL,
"ucp recv descriptor is not allocated");
rdesc->length = rdesc_tmp.length;
/* reset offset to improve locality */
rdesc->payload_offset = sizeof(*rdesc) + sizeof(*am_data);
rdesc->flags = 0;
rdesc->release_desc_offset = 0;
ucp_recv_desc_set_name(rdesc, "stream_am_data_process");
memcpy(ucp_stream_rdesc_payload(rdesc),
UCS_PTR_BYTE_OFFSET(am_data, rdesc_tmp.payload_offset),
rdesc_tmp.length);
} else {
/* slowpath */
rdesc = (ucp_recv_desc_t *)am_data - 1;
rdesc->length = rdesc_tmp.length;
rdesc->payload_offset = rdesc_tmp.payload_offset + sizeof(*rdesc);
rdesc->release_desc_offset = UCP_WORKER_HEADROOM_PRIV_SIZE;
rdesc->flags = UCP_RECV_DESC_FLAG_UCT_DESC;
}
ep_ext->ep->flags |= UCP_EP_FLAG_STREAM_HAS_DATA;
ucs_queue_push(&ep_ext->stream.match_q, &rdesc->stream_queue);
return UCS_INPROGRESS;
}
void ucp_stream_ep_init(ucp_ep_h ep)
{
ucp_ep_ext_t *ep_ext = ep->ext;
if (ep->worker->context->config.features & UCP_FEATURE_STREAM) {
ep_ext->stream.ready_list.prev = NULL;
ep_ext->stream.ready_list.next = NULL;
ucs_queue_head_init(&ep_ext->stream.match_q);
}
}
void ucp_stream_ep_cleanup(ucp_ep_h ep, ucs_status_t status)
{
ucp_ep_ext_t *ep_ext = ep->ext;
ucp_request_t *req;
size_t length;
void *data;
if (!(ep->worker->context->config.features & UCP_FEATURE_STREAM)) {
return;
}
/* drop unmatched data */
while ((data = ucp_stream_recv_data_nb_nolock(ep, &length)) != NULL) {
ucs_assert_always(!UCS_PTR_IS_ERR(data));
ucp_stream_data_release(ep, data);
}
if (ucp_stream_ep_is_queued(ep_ext)) {
ucp_stream_ep_dequeue(ep_ext);
}
/* cancel not completed requests */
ucs_assert(!ucp_stream_ep_has_data(ep_ext));
while (!ucs_queue_is_empty(&ep_ext->stream.match_q)) {
req = ucs_queue_head_elem_non_empty(&ep_ext->stream.match_q,
ucp_request_t, recv.queue);
ucp_request_complete_stream_recv(req, ep_ext, status);
}
}
void ucp_stream_ep_activate(ucp_ep_h ep)
{
ucp_ep_ext_t *ep_ext = ep->ext;
if ((ep->worker->context->config.features & UCP_FEATURE_STREAM) &&
ucp_stream_ep_has_data(ep_ext) && !ucp_stream_ep_is_queued(ep_ext)) {
ucp_stream_ep_enqueue(ep_ext, ep->worker);
}
}
static UCS_F_ALWAYS_INLINE ucs_status_t
ucp_stream_am_handler(void *am_arg, void *am_data, size_t am_length,
unsigned am_flags)
{
ucp_worker_h worker = am_arg;
ucp_stream_am_data_t *data = am_data;
ucp_ep_h ep;
ucp_ep_ext_t *ep_ext;
ucs_status_t status;
ucs_assert(am_length >= sizeof(ucp_stream_am_hdr_t));
/* Drop the date if the endpoint is invalid */
UCP_WORKER_GET_VALID_EP_BY_ID(&ep, worker, data->hdr.ep_id, return UCS_OK,
"stream data");
ep_ext = ep->ext;
status = ucp_stream_am_data_process(worker, ep_ext, data,
am_length - sizeof(data->hdr),
am_flags);
if (status == UCS_OK) {
/* rdesc was processed in place */
return UCS_OK;
}
ucs_assert(status == UCS_INPROGRESS);
if (!ucp_stream_ep_is_queued(ep_ext) && (ep->flags & UCP_EP_FLAG_USED)) {
ucp_stream_ep_enqueue(ep_ext, worker);
}
return (am_flags & UCT_CB_PARAM_FLAG_DESC) ? UCS_INPROGRESS : UCS_OK;
}
static void ucp_stream_am_dump(ucp_worker_h worker, uct_am_trace_type_t type,
uint8_t id, const void *data, size_t length,
char *buffer, size_t max)
{
const ucp_stream_am_hdr_t *hdr = data;
size_t hdr_len = sizeof(*hdr);
char *p;
snprintf(buffer, max, "STREAM ep_id 0x%"PRIx64, hdr->ep_id);
p = buffer + strlen(buffer);
ucs_assert(hdr->ep_id != UCS_PTR_MAP_KEY_INVALID);
ucp_dump_payload(worker->context, p, buffer + max - p,
UCS_PTR_BYTE_OFFSET(data, hdr_len), length - hdr_len);
}
UCP_DEFINE_AM_WITH_PROXY(UCP_FEATURE_STREAM, UCP_AM_ID_STREAM_DATA,
ucp_stream_am_handler, ucp_stream_am_dump, 0);
|
5f2644d6ec2400898dccbd46faa94b0ca76c6751
|
e9911598c43e8526da22b2773a73d9b5966f602a
|
/lib/cyr_qsort_r.h
|
44fef777ce7efea7dece10cc714a0f280158362d
|
[
"LicenseRef-scancode-warranty-disclaimer",
"BSD-2-Clause"
] |
permissive
|
cyrusimap/cyrus-imapd
|
07236dfd887ed92c147938cf1ed2591449d7e8fd
|
315441d067ba85814768f840f20bc3bb7f20ea6b
|
refs/heads/master
| 2023-09-05T09:57:10.683822
| 2023-09-05T06:09:43
| 2023-09-05T06:09:43
| 59,071,965
| 508
| 164
|
NOASSERTION
| 2023-09-13T04:34:31
| 2016-05-18T01:33:49
|
C
|
UTF-8
|
C
| false
| false
| 1,604
|
h
|
cyr_qsort_r.h
|
/* cyr_qsort_r.h -- Cyrus compatibility header for qsort_r
*
* Always use the QSORT_R_COMPAR_ARGS macro to declare the
* comparison function, e.g.
*
* int mysort QSORT_R_COMPAR_ARGS(const void *pa,
* const void *pb,
* void *arg)
* {
* ... your code here ...
* }
*
*/
#ifndef INCLUDED_CYR_QSORT_R_H
#define INCLUDED_CYR_QSORT_R_H
#include "config.h"
#include <stdlib.h>
#if defined(_GNU_SOURCE) && defined (__GLIBC__) && \
((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >=0)))
#define HAVE_GLIBC_QSORT_R
#endif
#if defined(__NEWLIB__) && \
((__NEWLIB__ > 2) || ((__NEWLIB__ == 2) && (__NEWLIB_MINOR__ >= 2)))
#if defined(_GNU_SOURCE)
#define HAVE_GLIBC_QSORT_R
#else
#define HAVE_BSD_QSORT_R
#endif
#endif
#if !defined(HAVE_GLIBC_QSORT_R) && \
(defined(__FreeBSD__) || defined(__DragonFly__) || defined(__APPLE__))
#define HAVE_BSD_QSORT_R
#endif
#ifdef HAVE_BSD_QSORT_R
#define QSORT_R_COMPAR_ARGS(a,b,c) (c,a,b)
#define cyr_qsort_r(base, nmemb, size, compar, thunk) qsort_r(base, nmemb, size, thunk, compar)
#else
#define QSORT_R_COMPAR_ARGS(a,b,c) (a,b,c)
# if defined(HAVE_GLIBC_QSORT_R)
#define cyr_qsort_r(base, nmemb, size, compar, thunk) qsort_r(base, nmemb, size, compar, thunk)
# elif defined(__GNUC__)
extern void cyr_qsort_r(void *base, size_t nmemb, size_t size,
int (*compar)(const void *, const void *, void *),
void *thunk);
# else
# error No qsort_r support
# endif
#endif
#endif /* INCLUDED_CYR_QSORT_R_H */
|
3393e07e1664841869605493e8c5168702f3cf07
|
7664f318ed04bd0680f3d82321c18896e3ef6ad5
|
/src/overlays/actors/ovl_En_Ru1/z_en_ru1.h
|
29570c980ebc8a374b48e198ba549dca4d7f3ef2
|
[] |
no_license
|
zeldaret/oot
|
9c80ce17f2d8fd61514b375f92ee4739b5ce9d4e
|
2875ab4fcf5c5f81d76353d1ee0024c9ea8d0b23
|
refs/heads/master
| 2023-08-29T05:29:31.356427
| 2023-08-28T22:48:52
| 2023-08-28T22:48:52
| 247,875,738
| 4,401
| 802
| null | 2023-09-14T13:34:38
| 2020-03-17T04:02:19
|
C
|
UTF-8
|
C
| false
| false
| 2,434
|
h
|
z_en_ru1.h
|
#ifndef Z_EN_RU1_H
#define Z_EN_RU1_H
#include "ultra64.h"
#include "global.h"
#include "overlays/actors/ovl_Bg_Bdan_Objects/z_bg_bdan_objects.h"
#include "overlays/actors/ovl_Door_Warp1/z_door_warp1.h"
struct EnRu1;
typedef void (*EnRu1ActionFunc)(struct EnRu1*, PlayState*);
typedef void (*EnRu1DrawFunc)(struct EnRu1*, PlayState*);
typedef void (*EnRu1PreLimbDrawFunc)(struct EnRu1*, PlayState*, s32, Vec3s*);
typedef struct EnRu1 {
/* 0x0000 */ Actor actor;
/* 0x014C */ SkelAnime skelAnime;
/* 0x0190 */ Vec3s jointTable[17];
/* 0x01F6 */ Vec3s morphTable[17];
/* 0x025C */ s16 eyeIndex;
/* 0x025E */ s16 blinkTimer;
/* 0x0260 */ s16 mouthIndex;
/* 0x0264 */ s32 action;
/* 0x0268 */ s32 drawConfig;
/* 0x026C */ f32 unk_26C;
/* 0x0270 */ f32 unk_270;
/* 0x0274 */ char unk_274[0x4];
/* 0x0278 */ DoorWarp1* blueWarp;
/* 0x027C */ f32 unk_27C;
/* 0x0280 */ s32 unk_280;
/* 0x0284 */ s8 roomNum1;
/* 0x0285 */ s8 roomNum2;
/* 0x0286 */ s8 roomNum3;
/* 0x0288 */ f32 unk_288;
/* 0x028C */ BgBdanObjects* unk_28C;
/* 0x0290 */ s32 unk_290;
/* 0x0294 */ char unk_294[0x4];
/* 0x0298 */ s32 unk_298;
/* 0x029C */ char unk_29C[0x2];
/* 0x029E */ s16 unk_29E;
/* 0x02A0 */ char unk_2A0[0x4];
/* 0x02A4 */ f32 unk_2A4;
/* 0x02A8 */ s32 alpha;
/* 0x02AC */ s16 unk_2AC;
/* 0x02B0 */ s32 unk_2B0;
/* 0x02B4 */ ColliderCylinder collider;
/* 0x0300 */ ColliderCylinder collider2;
/* 0x034C */ s32 unk_34C;
/* 0x0350 */ s32 unk_350;
/* 0x0354 */ f32 unk_354;
/* 0x0358 */ f32 unk_358;
/* 0x035C */ s16 unk_35C;
/* 0x0360 */ f32 unk_360;
/* 0x0364 */ Vec3f unk_364;
/* 0x0370 */ f32 unk_370;
/* 0x0374 */ NpcInteractInfo interactInfo;
} EnRu1; // size = 0x039C
typedef enum {
/* 0 */ RUTO_CHILD_NONE,
/* 1 */ RUTO_CHILD_ROOT,
/* 2 */ RUTO_CHILD_LEFT_THIGH,
/* 3 */ RUTO_CHILD_LEFT_SHIN,
/* 4 */ RUTO_CHILD_LEFT_FOOT,
/* 5 */ RUTO_CHILD_RIGHT_THIGH,
/* 6 */ RUTO_CHILD_RIGHT_SHIN,
/* 7 */ RUTO_CHILD_RIGHT_FOOT,
/* 8 */ RUTO_CHILD_CHEST,
/* 9 */ RUTO_CHILD_LEFT_UPPER_ARM,
/* 10 */ RUTO_CHILD_LEFT_FIN,
/* 11 */ RUTO_CHILD_LEFT_HAND,
/* 12 */ RUTO_CHILD_RIGHT_UPPER_ARM,
/* 13 */ RUTO_CHILD_RIGHT_FIN,
/* 14 */ RUTO_CHILD_RIGHT_HAND,
/* 15 */ RUTO_CHILD_HEAD,
/* 16 */ RUTO_CHILD_TORSO
} RutoLimb;
#endif
|
ab68ee35fcd733671679eeec505011b4ed730bfe
|
7f6c235b0598353549959c18f69eefd20b766907
|
/include/debug.h
|
a5c820d80eeaabec20751481b2302b0a9c93df80
|
[
"ClArtistic"
] |
permissive
|
z88dk/z88dk
|
46dfd4905f36d99333173cadd0a660839befc9f0
|
8b07f37cc43c5d9ffe69b563c80763491d8faff7
|
refs/heads/master
| 2023-09-04T19:29:49.254958
| 2023-09-03T20:51:24
| 2023-09-03T20:51:24
| 54,035,569
| 820
| 263
|
NOASSERTION
| 2023-09-05T11:09:04
| 2016-03-16T13:48:16
|
Assembly
|
UTF-8
|
C
| false
| false
| 1,264
|
h
|
debug.h
|
/*
* Debugging Routines
*
* $Id: debug.h,v 1.4 2016-06-11 19:53:08 dom Exp $
*/
#ifndef __DEBUG_H__
#define __DEBUG_H__
#include <sys/compiler.h>
#define MYSELF = 0xFFFF
/* Disassembles a line; returns the address for the next line
if MYSELF, disassembles the current program location */
__ZPROTO2(unsigned int,,disz80,unsigned int,address, unsigned int,lines)
/* Dump on screen: if MYSELF address is given, displays #count stack words
and returns the current SP value (dump excluded), otherwise dumps memory
bytes and returns the address reached */
__ZPROTO2(unsigned int,,dump,unsigned int,address,unsigned int,count)
/* TRUE if Z80 supports undocumented instructions.
Otherwise, FALSE (or, in worst cases.. crash !) */
extern int __LIB__ z80undoc(void);
/* TRUE if Z80 supports strange undocumented flag behaviours
Otherwise, FALSE */
extern int __LIB__ z80genuine(void);
/* TRUE if Z80 supports strange undocumented flag behaviours
Otherwise, FALSE */
extern int __LIB__ z80rabbit(void);
/* Z80 type detection (cross fingers!)
0 - Z80
1 - Z180 / HD6140 / Other
2 - Z280
3 - Z380
4 - R800
5 - Rabbit Control Module
*/
extern int __LIB__ z80type(void);
#endif
|
3a64a163cfa6d3594213b30e7ccc9e21eb10d3be
|
635a81339db4dc4ce21e72f2d77faa92461404d9
|
/include/perfetto/base/export.h
|
14044b37c1c061e94c7e3abeaf0484a0dd943ed2
|
[
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
google/perfetto
|
b3fee34767174ca8c9e8e501eeec6f73fb3e0cda
|
4201d29ef8ce94a064dfbba6d9c9518b297dbc3f
|
refs/heads/master
| 2023-09-04T07:16:27.954459
| 2023-09-03T01:33:19
| 2023-09-03T01:33:19
| 227,091,502
| 1,920
| 274
|
Apache-2.0
| 2023-09-13T18:18:23
| 2019-12-10T10:32:44
|
C++
|
UTF-8
|
C
| false
| false
| 1,432
|
h
|
export.h
|
/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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 INCLUDE_PERFETTO_BASE_EXPORT_H_
#define INCLUDE_PERFETTO_BASE_EXPORT_H_
#include "perfetto/base/build_config.h"
#include "perfetto/public/abi/export.h"
// PERFETTO_EXPORT_COMPONENT: Exports a symbol among C++ components when
// building with is_component = true (mostly used by chromium build).
#if PERFETTO_BUILDFLAG(PERFETTO_COMPONENT_BUILD)
#if defined(PERFETTO_IMPLEMENTATION)
#define PERFETTO_EXPORT_COMPONENT PERFETTO_INTERNAL_DLL_EXPORT
#else
#define PERFETTO_EXPORT_COMPONENT PERFETTO_INTERNAL_DLL_IMPORT
#endif
#else // !PERFETTO_BUILDFLAG(PERFETTO_COMPONENT_BUILD)
#if !defined(PERFETTO_EXPORT_COMPONENT)
#define PERFETTO_EXPORT_COMPONENT
#endif // !defined(PERFETTO_EXPORT_COMPONENT)
#endif // PERFETTO_BUILDFLAG(PERFETTO_COMPONENT_BUILD)
#endif // INCLUDE_PERFETTO_BASE_EXPORT_H_
|
0acb5c9a0a3e305a3e2214fedc46b366ef656aa0
|
54b1be394eaa23a14cfbcc686b00ed287b001a17
|
/src/gba/GBA.h
|
ab96af352297bb07a882567db84d7aee365cb1cd
|
[] |
no_license
|
visualboyadvance-m/visualboyadvance-m
|
d39353624814dcaddf45b23ca888e4588adb1289
|
803ab35269a9c5c66f3c910be7f6f3cdb6d5290d
|
refs/heads/master
| 2023-09-04T09:44:20.726135
| 2023-08-27T22:46:12
| 2023-08-28T00:08:09
| 37,228,563
| 3,306
| 477
| null | 2023-09-11T04:14:47
| 2015-06-10T23:43:02
|
C++
|
UTF-8
|
C
| false
| false
| 4,694
|
h
|
GBA.h
|
#ifndef GBA_H
#define GBA_H
#include "../common/Types.h"
#include "../System.h"
#include "../Util.h"
const uint64_t TICKS_PER_SECOND = 16777216;
#define SAVE_GAME_VERSION_1 1
#define SAVE_GAME_VERSION_2 2
#define SAVE_GAME_VERSION_3 3
#define SAVE_GAME_VERSION_4 4
#define SAVE_GAME_VERSION_5 5
#define SAVE_GAME_VERSION_6 6
#define SAVE_GAME_VERSION_7 7
#define SAVE_GAME_VERSION_8 8
#define SAVE_GAME_VERSION_9 9
#define SAVE_GAME_VERSION_10 10
#define SAVE_GAME_VERSION SAVE_GAME_VERSION_10
#define gbaWidth 240
#define gbaHeight 160
enum {
GBA_SAVE_AUTO = 0,
GBA_SAVE_EEPROM,
GBA_SAVE_SRAM,
GBA_SAVE_FLASH,
GBA_SAVE_EEPROM_SENSOR,
GBA_SAVE_NONE
};
enum {
SIZE_SRAM = 32768,
SIZE_FLASH512 = 65536,
SIZE_FLASH1M = 131072,
SIZE_EEPROM_512 = 512,
SIZE_EEPROM_8K = 8192
};
enum {
SIZE_ROM = 0x2000000,
SIZE_BIOS = 0x0004000,
SIZE_IRAM = 0x0008000,
SIZE_WRAM = 0x0040000,
SIZE_PRAM = 0x0000400,
SIZE_VRAM = 0x0020000,
SIZE_OAM = 0x0000400,
SIZE_IOMEM = 0x0000400,
#ifndef __LIBRETRO__
SIZE_PIX = (4 * 241 * 162)
#else
SIZE_PIX = (4 * 240 * 160)
#endif
};
typedef struct {
uint8_t* address;
uint32_t mask;
#ifdef BKPT_SUPPORT
uint8_t* breakPoints;
uint8_t* searchMatch;
uint8_t* trace;
uint32_t size;
#endif
} memoryMap;
typedef union {
struct {
#ifdef WORDS_BIGENDIAN
uint8_t B3;
uint8_t B2;
uint8_t B1;
uint8_t B0;
#else
uint8_t B0;
uint8_t B1;
uint8_t B2;
uint8_t B3;
#endif
} B;
struct {
#ifdef WORDS_BIGENDIAN
uint16_t W1;
uint16_t W0;
#else
uint16_t W0;
uint16_t W1;
#endif
} W;
#ifdef WORDS_BIGENDIAN
volatile uint32_t I;
#else
uint32_t I;
#endif
} reg_pair;
#ifndef NO_GBA_MAP
extern memoryMap map[256];
#endif
extern uint8_t biosProtected[4];
extern void (*cpuSaveGameFunc)(uint32_t, uint8_t);
extern bool cpuSramEnabled;
extern bool cpuFlashEnabled;
extern bool cpuEEPROMEnabled;
extern bool cpuEEPROMSensorEnabled;
#ifdef BKPT_SUPPORT
extern uint8_t freezeWorkRAM[0x40000];
extern uint8_t freezeInternalRAM[0x8000];
extern uint8_t freezeVRAM[0x18000];
extern uint8_t freezeOAM[0x400];
extern uint8_t freezePRAM[0x400];
extern bool debugger_last;
extern int oldreg[18];
extern char oldbuffer[10];
extern bool debugger;
#endif
extern bool CPUReadGSASnapshot(const char*);
extern bool CPUReadGSASPSnapshot(const char*);
extern bool CPUWriteGSASnapshot(const char*, const char*, const char*, const char*);
extern bool CPUWriteBatteryFile(const char*);
extern bool CPUReadBatteryFile(const char*);
extern bool CPUExportEepromFile(const char*);
extern bool CPUImportEepromFile(const char*);
extern bool CPUWritePNGFile(const char*);
extern bool CPUWriteBMPFile(const char*);
extern void CPUCleanUp();
extern void CPUUpdateRender();
extern void CPUUpdateRenderBuffers(bool);
extern bool CPUReadMemState(char*, int);
extern bool CPUWriteMemState(char*, int);
#ifdef __LIBRETRO__
extern bool CPUReadState(const uint8_t*);
extern unsigned int CPUWriteState(uint8_t* data, unsigned int size);
#else
extern bool CPUReadState(const char*);
extern bool CPUWriteState(const char*);
#endif
extern int CPULoadRom(const char*);
extern int CPULoadRomData(const char* data, int size);
extern void doMirroring(bool);
extern void CPUUpdateRegister(uint32_t, uint16_t);
extern void applyTimer();
extern void CPUInit(const char*, bool);
void SetSaveType(int st);
extern void CPUReset();
extern void CPULoop(int);
extern void CPUCheckDMA(int, int);
extern bool CPUIsGBAImage(const char*);
extern bool CPUIsZipFile(const char*);
#ifdef PROFILING
#include "prof/prof.h"
extern void cpuProfil(profile_segment* seg);
extern void cpuEnableProfiling(int hz);
#endif
const char* GetLoadDotCodeFile();
const char* GetSaveDotCodeFile();
void ResetLoadDotCodeFile();
void SetLoadDotCodeFile(const char* szFile);
void ResetSaveDotCodeFile();
void SetSaveDotCodeFile(const char* szFile);
// Updates romSize and realloc rom pointer if needed after soft-patching
void gbaUpdateRomSize(int size);
extern struct EmulatedSystem GBASystem;
#define R13_IRQ 18
#define R14_IRQ 19
#define SPSR_IRQ 20
#define R13_USR 26
#define R14_USR 27
#define R13_SVC 28
#define R14_SVC 29
#define SPSR_SVC 30
#define R13_ABT 31
#define R14_ABT 32
#define SPSR_ABT 33
#define R13_UND 34
#define R14_UND 35
#define SPSR_UND 36
#define R8_FIQ 37
#define R9_FIQ 38
#define R10_FIQ 39
#define R11_FIQ 40
#define R12_FIQ 41
#define R13_FIQ 42
#define R14_FIQ 43
#define SPSR_FIQ 44
#include "Cheats.h"
#include "EEprom.h"
#include "Flash.h"
#include "Globals.h"
#endif // GBA_H
|
bc2b7e40bd84eb4b9bdb06087453a8a0e2b5997c
|
f7dc806f341ef5dbb0e11252a4693003a66853d5
|
/thirdparty/zstd/compress/zstd_compress_superblock.c
|
638c4acbe708aa48437a1092616fe9fb6b4b59ba
|
[
"MIT",
"OFL-1.1",
"JSON",
"LicenseRef-scancode-nvidia-2002",
"BSD-3-Clause",
"Zlib",
"MPL-2.0",
"CC0-1.0",
"BSL-1.0",
"Libpng",
"Apache-2.0",
"LicenseRef-scancode-public-domain",
"Unlicense",
"LicenseRef-scancode-free-unknown",
"CC-BY-4.0",
"Bison-exception-2.2",
"LicenseRef-scancode-other-permissive",
"GPL-3.0-only",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-unicode",
"BSD-2-Clause",
"FTL",
"GPL-3.0-or-later",
"Bitstream-Vera",
"MIT-Modern-Variant"
] |
permissive
|
godotengine/godot
|
8a2419750f4851d1426a8f3bcb52cac5c86f23c2
|
970be7afdc111ccc7459d7ef3560de70e6d08c80
|
refs/heads/master
| 2023-08-21T14:37:00.262883
| 2023-08-21T06:26:15
| 2023-08-21T06:26:15
| 15,634,981
| 68,852
| 18,388
|
MIT
| 2023-09-14T21:42:16
| 2014-01-04T16:05:36
|
C++
|
UTF-8
|
C
| false
| false
| 28,499
|
c
|
zstd_compress_superblock.c
|
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
* in the COPYING file in the root directory of this source tree).
* You may select, at your option, one of the above-listed licenses.
*/
/*-*************************************
* Dependencies
***************************************/
#include "zstd_compress_superblock.h"
#include "../common/zstd_internal.h" /* ZSTD_getSequenceLength */
#include "hist.h" /* HIST_countFast_wksp */
#include "zstd_compress_internal.h" /* ZSTD_[huf|fse|entropy]CTablesMetadata_t */
#include "zstd_compress_sequences.h"
#include "zstd_compress_literals.h"
/** ZSTD_compressSubBlock_literal() :
* Compresses literals section for a sub-block.
* When we have to write the Huffman table we will sometimes choose a header
* size larger than necessary. This is because we have to pick the header size
* before we know the table size + compressed size, so we have a bound on the
* table size. If we guessed incorrectly, we fall back to uncompressed literals.
*
* We write the header when writeEntropy=1 and set entropyWritten=1 when we succeeded
* in writing the header, otherwise it is set to 0.
*
* hufMetadata->hType has literals block type info.
* If it is set_basic, all sub-blocks literals section will be Raw_Literals_Block.
* If it is set_rle, all sub-blocks literals section will be RLE_Literals_Block.
* If it is set_compressed, first sub-block's literals section will be Compressed_Literals_Block
* If it is set_compressed, first sub-block's literals section will be Treeless_Literals_Block
* and the following sub-blocks' literals sections will be Treeless_Literals_Block.
* @return : compressed size of literals section of a sub-block
* Or 0 if unable to compress.
* Or error code */
static size_t
ZSTD_compressSubBlock_literal(const HUF_CElt* hufTable,
const ZSTD_hufCTablesMetadata_t* hufMetadata,
const BYTE* literals, size_t litSize,
void* dst, size_t dstSize,
const int bmi2, int writeEntropy, int* entropyWritten)
{
size_t const header = writeEntropy ? 200 : 0;
size_t const lhSize = 3 + (litSize >= (1 KB - header)) + (litSize >= (16 KB - header));
BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstSize;
BYTE* op = ostart + lhSize;
U32 const singleStream = lhSize == 3;
symbolEncodingType_e hType = writeEntropy ? hufMetadata->hType : set_repeat;
size_t cLitSize = 0;
DEBUGLOG(5, "ZSTD_compressSubBlock_literal (litSize=%zu, lhSize=%zu, writeEntropy=%d)", litSize, lhSize, writeEntropy);
*entropyWritten = 0;
if (litSize == 0 || hufMetadata->hType == set_basic) {
DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal");
return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
} else if (hufMetadata->hType == set_rle) {
DEBUGLOG(5, "ZSTD_compressSubBlock_literal using rle literal");
return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize);
}
assert(litSize > 0);
assert(hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat);
if (writeEntropy && hufMetadata->hType == set_compressed) {
ZSTD_memcpy(op, hufMetadata->hufDesBuffer, hufMetadata->hufDesSize);
op += hufMetadata->hufDesSize;
cLitSize += hufMetadata->hufDesSize;
DEBUGLOG(5, "ZSTD_compressSubBlock_literal (hSize=%zu)", hufMetadata->hufDesSize);
}
{ int const flags = bmi2 ? HUF_flags_bmi2 : 0;
const size_t cSize = singleStream ? HUF_compress1X_usingCTable(op, oend-op, literals, litSize, hufTable, flags)
: HUF_compress4X_usingCTable(op, oend-op, literals, litSize, hufTable, flags);
op += cSize;
cLitSize += cSize;
if (cSize == 0 || ERR_isError(cSize)) {
DEBUGLOG(5, "Failed to write entropy tables %s", ZSTD_getErrorName(cSize));
return 0;
}
/* If we expand and we aren't writing a header then emit uncompressed */
if (!writeEntropy && cLitSize >= litSize) {
DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal because uncompressible");
return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
}
/* If we are writing headers then allow expansion that doesn't change our header size. */
if (lhSize < (size_t)(3 + (cLitSize >= 1 KB) + (cLitSize >= 16 KB))) {
assert(cLitSize > litSize);
DEBUGLOG(5, "Literals expanded beyond allowed header size");
return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
}
DEBUGLOG(5, "ZSTD_compressSubBlock_literal (cSize=%zu)", cSize);
}
/* Build header */
switch(lhSize)
{
case 3: /* 2 - 2 - 10 - 10 */
{ U32 const lhc = hType + ((!singleStream) << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<14);
MEM_writeLE24(ostart, lhc);
break;
}
case 4: /* 2 - 2 - 14 - 14 */
{ U32 const lhc = hType + (2 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<18);
MEM_writeLE32(ostart, lhc);
break;
}
case 5: /* 2 - 2 - 18 - 18 */
{ U32 const lhc = hType + (3 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<22);
MEM_writeLE32(ostart, lhc);
ostart[4] = (BYTE)(cLitSize >> 10);
break;
}
default: /* not possible : lhSize is {3,4,5} */
assert(0);
}
*entropyWritten = 1;
DEBUGLOG(5, "Compressed literals: %u -> %u", (U32)litSize, (U32)(op-ostart));
return op-ostart;
}
static size_t
ZSTD_seqDecompressedSize(seqStore_t const* seqStore,
const seqDef* sequences, size_t nbSeq,
size_t litSize, int lastSequence)
{
const seqDef* const sstart = sequences;
const seqDef* const send = sequences + nbSeq;
const seqDef* sp = sstart;
size_t matchLengthSum = 0;
size_t litLengthSum = 0;
(void)(litLengthSum); /* suppress unused variable warning on some environments */
while (send-sp > 0) {
ZSTD_sequenceLength const seqLen = ZSTD_getSequenceLength(seqStore, sp);
litLengthSum += seqLen.litLength;
matchLengthSum += seqLen.matchLength;
sp++;
}
assert(litLengthSum <= litSize);
if (!lastSequence) {
assert(litLengthSum == litSize);
}
return matchLengthSum + litSize;
}
/** ZSTD_compressSubBlock_sequences() :
* Compresses sequences section for a sub-block.
* fseMetadata->llType, fseMetadata->ofType, and fseMetadata->mlType have
* symbol compression modes for the super-block.
* The first successfully compressed block will have these in its header.
* We set entropyWritten=1 when we succeed in compressing the sequences.
* The following sub-blocks will always have repeat mode.
* @return : compressed size of sequences section of a sub-block
* Or 0 if it is unable to compress
* Or error code. */
static size_t
ZSTD_compressSubBlock_sequences(const ZSTD_fseCTables_t* fseTables,
const ZSTD_fseCTablesMetadata_t* fseMetadata,
const seqDef* sequences, size_t nbSeq,
const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
const ZSTD_CCtx_params* cctxParams,
void* dst, size_t dstCapacity,
const int bmi2, int writeEntropy, int* entropyWritten)
{
const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstCapacity;
BYTE* op = ostart;
BYTE* seqHead;
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (nbSeq=%zu, writeEntropy=%d, longOffsets=%d)", nbSeq, writeEntropy, longOffsets);
*entropyWritten = 0;
/* Sequences Header */
RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
dstSize_tooSmall, "");
if (nbSeq < 0x7F)
*op++ = (BYTE)nbSeq;
else if (nbSeq < LONGNBSEQ)
op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
else
op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
if (nbSeq==0) {
return op - ostart;
}
/* seqHead : flags for FSE encoding type */
seqHead = op++;
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (seqHeadSize=%u)", (unsigned)(op-ostart));
if (writeEntropy) {
const U32 LLtype = fseMetadata->llType;
const U32 Offtype = fseMetadata->ofType;
const U32 MLtype = fseMetadata->mlType;
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (fseTablesSize=%zu)", fseMetadata->fseTablesSize);
*seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
ZSTD_memcpy(op, fseMetadata->fseTablesBuffer, fseMetadata->fseTablesSize);
op += fseMetadata->fseTablesSize;
} else {
const U32 repeat = set_repeat;
*seqHead = (BYTE)((repeat<<6) + (repeat<<4) + (repeat<<2));
}
{ size_t const bitstreamSize = ZSTD_encodeSequences(
op, oend - op,
fseTables->matchlengthCTable, mlCode,
fseTables->offcodeCTable, ofCode,
fseTables->litlengthCTable, llCode,
sequences, nbSeq,
longOffsets, bmi2);
FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
op += bitstreamSize;
/* zstd versions <= 1.3.4 mistakenly report corruption when
* FSE_readNCount() receives a buffer < 4 bytes.
* Fixed by https://github.com/facebook/zstd/pull/1146.
* This can happen when the last set_compressed table present is 2
* bytes and the bitstream is only one byte.
* In this exceedingly rare case, we will simply emit an uncompressed
* block, since it isn't worth optimizing.
*/
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (writeEntropy && fseMetadata->lastCountSize && fseMetadata->lastCountSize + bitstreamSize < 4) {
/* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
assert(fseMetadata->lastCountSize + bitstreamSize == 3);
DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
"emitting an uncompressed block.");
return 0;
}
#endif
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (bitstreamSize=%zu)", bitstreamSize);
}
/* zstd versions <= 1.4.0 mistakenly report error when
* sequences section body size is less than 3 bytes.
* Fixed by https://github.com/facebook/zstd/pull/1664.
* This can happen when the previous sequences section block is compressed
* with rle mode and the current block's sequences section is compressed
* with repeat mode where sequences section body size can be 1 byte.
*/
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (op-seqHead < 4) {
DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.4.0 by emitting "
"an uncompressed block when sequences are < 4 bytes");
return 0;
}
#endif
*entropyWritten = 1;
return op - ostart;
}
/** ZSTD_compressSubBlock() :
* Compresses a single sub-block.
* @return : compressed size of the sub-block
* Or 0 if it failed to compress. */
static size_t ZSTD_compressSubBlock(const ZSTD_entropyCTables_t* entropy,
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
const seqDef* sequences, size_t nbSeq,
const BYTE* literals, size_t litSize,
const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
const ZSTD_CCtx_params* cctxParams,
void* dst, size_t dstCapacity,
const int bmi2,
int writeLitEntropy, int writeSeqEntropy,
int* litEntropyWritten, int* seqEntropyWritten,
U32 lastBlock)
{
BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstCapacity;
BYTE* op = ostart + ZSTD_blockHeaderSize;
DEBUGLOG(5, "ZSTD_compressSubBlock (litSize=%zu, nbSeq=%zu, writeLitEntropy=%d, writeSeqEntropy=%d, lastBlock=%d)",
litSize, nbSeq, writeLitEntropy, writeSeqEntropy, lastBlock);
{ size_t cLitSize = ZSTD_compressSubBlock_literal((const HUF_CElt*)entropy->huf.CTable,
&entropyMetadata->hufMetadata, literals, litSize,
op, oend-op, bmi2, writeLitEntropy, litEntropyWritten);
FORWARD_IF_ERROR(cLitSize, "ZSTD_compressSubBlock_literal failed");
if (cLitSize == 0) return 0;
op += cLitSize;
}
{ size_t cSeqSize = ZSTD_compressSubBlock_sequences(&entropy->fse,
&entropyMetadata->fseMetadata,
sequences, nbSeq,
llCode, mlCode, ofCode,
cctxParams,
op, oend-op,
bmi2, writeSeqEntropy, seqEntropyWritten);
FORWARD_IF_ERROR(cSeqSize, "ZSTD_compressSubBlock_sequences failed");
if (cSeqSize == 0) return 0;
op += cSeqSize;
}
/* Write block header */
{ size_t cSize = (op-ostart)-ZSTD_blockHeaderSize;
U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
MEM_writeLE24(ostart, cBlockHeader24);
}
return op-ostart;
}
static size_t ZSTD_estimateSubBlockSize_literal(const BYTE* literals, size_t litSize,
const ZSTD_hufCTables_t* huf,
const ZSTD_hufCTablesMetadata_t* hufMetadata,
void* workspace, size_t wkspSize,
int writeEntropy)
{
unsigned* const countWksp = (unsigned*)workspace;
unsigned maxSymbolValue = 255;
size_t literalSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
if (hufMetadata->hType == set_basic) return litSize;
else if (hufMetadata->hType == set_rle) return 1;
else if (hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat) {
size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);
if (ZSTD_isError(largest)) return litSize;
{ size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);
if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;
return cLitSizeEstimate + literalSectionHeaderSize;
} }
assert(0); /* impossible */
return 0;
}
static size_t ZSTD_estimateSubBlockSize_symbolType(symbolEncodingType_e type,
const BYTE* codeTable, unsigned maxCode,
size_t nbSeq, const FSE_CTable* fseCTable,
const U8* additionalBits,
short const* defaultNorm, U32 defaultNormLog, U32 defaultMax,
void* workspace, size_t wkspSize)
{
unsigned* const countWksp = (unsigned*)workspace;
const BYTE* ctp = codeTable;
const BYTE* const ctStart = ctp;
const BYTE* const ctEnd = ctStart + nbSeq;
size_t cSymbolTypeSizeEstimateInBits = 0;
unsigned max = maxCode;
HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize); /* can't fail */
if (type == set_basic) {
/* We selected this encoding type, so it must be valid. */
assert(max <= defaultMax);
cSymbolTypeSizeEstimateInBits = max <= defaultMax
? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max)
: ERROR(GENERIC);
} else if (type == set_rle) {
cSymbolTypeSizeEstimateInBits = 0;
} else if (type == set_compressed || type == set_repeat) {
cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);
}
if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) return nbSeq * 10;
while (ctp < ctEnd) {
if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];
else cSymbolTypeSizeEstimateInBits += *ctp; /* for offset, offset code is also the number of additional bits */
ctp++;
}
return cSymbolTypeSizeEstimateInBits / 8;
}
static size_t ZSTD_estimateSubBlockSize_sequences(const BYTE* ofCodeTable,
const BYTE* llCodeTable,
const BYTE* mlCodeTable,
size_t nbSeq,
const ZSTD_fseCTables_t* fseTables,
const ZSTD_fseCTablesMetadata_t* fseMetadata,
void* workspace, size_t wkspSize,
int writeEntropy)
{
size_t const sequencesSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
size_t cSeqSizeEstimate = 0;
if (nbSeq == 0) return sequencesSectionHeaderSize;
cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, MaxOff,
nbSeq, fseTables->offcodeCTable, NULL,
OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
workspace, wkspSize);
cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->llType, llCodeTable, MaxLL,
nbSeq, fseTables->litlengthCTable, LL_bits,
LL_defaultNorm, LL_defaultNormLog, MaxLL,
workspace, wkspSize);
cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, MaxML,
nbSeq, fseTables->matchlengthCTable, ML_bits,
ML_defaultNorm, ML_defaultNormLog, MaxML,
workspace, wkspSize);
if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;
return cSeqSizeEstimate + sequencesSectionHeaderSize;
}
static size_t ZSTD_estimateSubBlockSize(const BYTE* literals, size_t litSize,
const BYTE* ofCodeTable,
const BYTE* llCodeTable,
const BYTE* mlCodeTable,
size_t nbSeq,
const ZSTD_entropyCTables_t* entropy,
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
void* workspace, size_t wkspSize,
int writeLitEntropy, int writeSeqEntropy) {
size_t cSizeEstimate = 0;
cSizeEstimate += ZSTD_estimateSubBlockSize_literal(literals, litSize,
&entropy->huf, &entropyMetadata->hufMetadata,
workspace, wkspSize, writeLitEntropy);
cSizeEstimate += ZSTD_estimateSubBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,
nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,
workspace, wkspSize, writeSeqEntropy);
return cSizeEstimate + ZSTD_blockHeaderSize;
}
static int ZSTD_needSequenceEntropyTables(ZSTD_fseCTablesMetadata_t const* fseMetadata)
{
if (fseMetadata->llType == set_compressed || fseMetadata->llType == set_rle)
return 1;
if (fseMetadata->mlType == set_compressed || fseMetadata->mlType == set_rle)
return 1;
if (fseMetadata->ofType == set_compressed || fseMetadata->ofType == set_rle)
return 1;
return 0;
}
/** ZSTD_compressSubBlock_multi() :
* Breaks super-block into multiple sub-blocks and compresses them.
* Entropy will be written to the first block.
* The following blocks will use repeat mode to compress.
* All sub-blocks are compressed blocks (no raw or rle blocks).
* @return : compressed size of the super block (which is multiple ZSTD blocks)
* Or 0 if it failed to compress. */
static size_t ZSTD_compressSubBlock_multi(const seqStore_t* seqStorePtr,
const ZSTD_compressedBlockState_t* prevCBlock,
ZSTD_compressedBlockState_t* nextCBlock,
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
const ZSTD_CCtx_params* cctxParams,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
const int bmi2, U32 lastBlock,
void* workspace, size_t wkspSize)
{
const seqDef* const sstart = seqStorePtr->sequencesStart;
const seqDef* const send = seqStorePtr->sequences;
const seqDef* sp = sstart;
const BYTE* const lstart = seqStorePtr->litStart;
const BYTE* const lend = seqStorePtr->lit;
const BYTE* lp = lstart;
BYTE const* ip = (BYTE const*)src;
BYTE const* const iend = ip + srcSize;
BYTE* const ostart = (BYTE*)dst;
BYTE* const oend = ostart + dstCapacity;
BYTE* op = ostart;
const BYTE* llCodePtr = seqStorePtr->llCode;
const BYTE* mlCodePtr = seqStorePtr->mlCode;
const BYTE* ofCodePtr = seqStorePtr->ofCode;
size_t targetCBlockSize = cctxParams->targetCBlockSize;
size_t litSize, seqCount;
int writeLitEntropy = entropyMetadata->hufMetadata.hType == set_compressed;
int writeSeqEntropy = 1;
int lastSequence = 0;
DEBUGLOG(5, "ZSTD_compressSubBlock_multi (litSize=%u, nbSeq=%u)",
(unsigned)(lend-lp), (unsigned)(send-sstart));
litSize = 0;
seqCount = 0;
do {
size_t cBlockSizeEstimate = 0;
if (sstart == send) {
lastSequence = 1;
} else {
const seqDef* const sequence = sp + seqCount;
lastSequence = sequence == send - 1;
litSize += ZSTD_getSequenceLength(seqStorePtr, sequence).litLength;
seqCount++;
}
if (lastSequence) {
assert(lp <= lend);
assert(litSize <= (size_t)(lend - lp));
litSize = (size_t)(lend - lp);
}
/* I think there is an optimization opportunity here.
* Calling ZSTD_estimateSubBlockSize for every sequence can be wasteful
* since it recalculates estimate from scratch.
* For example, it would recount literal distribution and symbol codes every time.
*/
cBlockSizeEstimate = ZSTD_estimateSubBlockSize(lp, litSize, ofCodePtr, llCodePtr, mlCodePtr, seqCount,
&nextCBlock->entropy, entropyMetadata,
workspace, wkspSize, writeLitEntropy, writeSeqEntropy);
if (cBlockSizeEstimate > targetCBlockSize || lastSequence) {
int litEntropyWritten = 0;
int seqEntropyWritten = 0;
const size_t decompressedSize = ZSTD_seqDecompressedSize(seqStorePtr, sp, seqCount, litSize, lastSequence);
const size_t cSize = ZSTD_compressSubBlock(&nextCBlock->entropy, entropyMetadata,
sp, seqCount,
lp, litSize,
llCodePtr, mlCodePtr, ofCodePtr,
cctxParams,
op, oend-op,
bmi2, writeLitEntropy, writeSeqEntropy,
&litEntropyWritten, &seqEntropyWritten,
lastBlock && lastSequence);
FORWARD_IF_ERROR(cSize, "ZSTD_compressSubBlock failed");
if (cSize > 0 && cSize < decompressedSize) {
DEBUGLOG(5, "Committed the sub-block");
assert(ip + decompressedSize <= iend);
ip += decompressedSize;
sp += seqCount;
lp += litSize;
op += cSize;
llCodePtr += seqCount;
mlCodePtr += seqCount;
ofCodePtr += seqCount;
litSize = 0;
seqCount = 0;
/* Entropy only needs to be written once */
if (litEntropyWritten) {
writeLitEntropy = 0;
}
if (seqEntropyWritten) {
writeSeqEntropy = 0;
}
}
}
} while (!lastSequence);
if (writeLitEntropy) {
DEBUGLOG(5, "ZSTD_compressSubBlock_multi has literal entropy tables unwritten");
ZSTD_memcpy(&nextCBlock->entropy.huf, &prevCBlock->entropy.huf, sizeof(prevCBlock->entropy.huf));
}
if (writeSeqEntropy && ZSTD_needSequenceEntropyTables(&entropyMetadata->fseMetadata)) {
/* If we haven't written our entropy tables, then we've violated our contract and
* must emit an uncompressed block.
*/
DEBUGLOG(5, "ZSTD_compressSubBlock_multi has sequence entropy tables unwritten");
return 0;
}
if (ip < iend) {
size_t const cSize = ZSTD_noCompressBlock(op, oend - op, ip, iend - ip, lastBlock);
DEBUGLOG(5, "ZSTD_compressSubBlock_multi last sub-block uncompressed, %zu bytes", (size_t)(iend - ip));
FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
assert(cSize != 0);
op += cSize;
/* We have to regenerate the repcodes because we've skipped some sequences */
if (sp < send) {
seqDef const* seq;
repcodes_t rep;
ZSTD_memcpy(&rep, prevCBlock->rep, sizeof(rep));
for (seq = sstart; seq < sp; ++seq) {
ZSTD_updateRep(rep.rep, seq->offBase, ZSTD_getSequenceLength(seqStorePtr, seq).litLength == 0);
}
ZSTD_memcpy(nextCBlock->rep, &rep, sizeof(rep));
}
}
DEBUGLOG(5, "ZSTD_compressSubBlock_multi compressed");
return op-ostart;
}
size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
void* dst, size_t dstCapacity,
void const* src, size_t srcSize,
unsigned lastBlock) {
ZSTD_entropyCTablesMetadata_t entropyMetadata;
FORWARD_IF_ERROR(ZSTD_buildBlockEntropyStats(&zc->seqStore,
&zc->blockState.prevCBlock->entropy,
&zc->blockState.nextCBlock->entropy,
&zc->appliedParams,
&entropyMetadata,
zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */), "");
return ZSTD_compressSubBlock_multi(&zc->seqStore,
zc->blockState.prevCBlock,
zc->blockState.nextCBlock,
&entropyMetadata,
&zc->appliedParams,
dst, dstCapacity,
src, srcSize,
zc->bmi2, lastBlock,
zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */);
}
|
1144d3c583a4142b4725a5c757ee019e53dcc5fa
|
07327b5e8b2831b12352bf7c6426bfda60129da7
|
/Include/10.0.10240.0/km/ucx/1.1/ucxclass.h
|
9e071ef59d30006446a07805b023084e87065db6
|
[] |
no_license
|
tpn/winsdk-10
|
ca279df0fce03f92036e90fb04196d6282a264b7
|
9b69fd26ac0c7d0b83d378dba01080e93349c2ed
|
refs/heads/master
| 2021-01-10T01:56:18.586459
| 2018-02-19T21:26:31
| 2018-02-19T21:29:50
| 44,352,845
| 218
| 432
| null | null | null | null |
UTF-8
|
C
| false
| false
| 61,435
|
h
|
ucxclass.h
|
/*++
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
UcxClass.h
Abstract:
This module contains the USB Host Controller (UCX) WDF class extension's
datatypes and exported methods.
Environment:
kernel-mode only
Revision History:
--*/
#ifndef __UCX_CLASS_H__
#define __UCX_CLASS_H__
#ifndef WDFAPI
#error Include WDF.H first
#endif
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#include <usbspec.h>
#include <usb.h>
#include <usbioctl.h>
#include <usbdlib.h>
//
// This is a private capability exposed by the host controller to be
// queried by UCX. If supported by the host controller this capability
// indicates that a Clear TT Buffer request should be issued to a TT hub
// if a transfer is canceled on a control or bulk endpoint on a low
// speed or full speed device downstream of the TT hub.
//
DEFINE_GUID(GUID_USB_CAPABILITY_CLEAR_TT_BUFFER_ON_ASYNC_TRANSFER_CANCEL,
0x09b76d52, 0x0a6d, 0x4e4f, 0xa9, 0x11, 0xd0, 0x36, 0xd1, 0x92, 0x94, 0x97);
DECLARE_HANDLE(UCXUSBDEVICE);
DECLARE_HANDLE(UCXENDPOINT);
typedef struct _USBDEVICE_MGMT_HEADER {
ULONG Size;
UCXUSBDEVICE Hub;
UCXUSBDEVICE UsbDevice;
} USBDEVICE_MGMT_HEADER, *PUSBDEVICE_MGMT_HEADER;
typedef struct _USBDEVICE_ENABLE_FAILURE_FLAGS {
ULONG InsufficientHardwareResourcesForDefaultEndpoint:1;
ULONG InsufficientHardwareResourcesForDevice:1;
ULONG Reserved:30;
} USBDEVICE_ENABLE_FAILURE_FLAGS;
typedef struct _USBDEVICE_ENABLE {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
UCXENDPOINT DefaultEndpoint;
USBDEVICE_ENABLE_FAILURE_FLAGS FailureFlags;
} USBDEVICE_ENABLE, *PUSBDEVICE_ENABLE;
typedef struct _USBDEVICE_RESET {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
UCXENDPOINT DefaultEndpoint;
ULONG EndpointsToDisableCount;
UCXENDPOINT* EndpointsToDisable;
} USBDEVICE_RESET, *PUSBDEVICE_RESET;
typedef struct _USBDEVICE_PURGEIO {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
} USBDEVICE_PURGEIO, *PUSBDEVICE_PURGEIO;
typedef struct _USBDEVICE_ABORTIO {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
} USBDEVICE_ABORTIO, *PUSBDEVICE_ABORTIO;
typedef struct _USBDEVICE_STARTIO {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
} USBDEVICE_STARTIO, *PUSBDEVICE_STARTIO;
typedef struct _USBDEVICE_TREE_PURGEIO {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
} USBDEVICE_TREE_PURGEIO, *PUSBDEVICE_TREE_PURGEIO;
typedef struct _USBDEVICE_ADDRESS {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
ULONG Reserved;
ULONG Address;
} USBDEVICE_ADDRESS, *PUSBDEVICE_ADDRESS;
typedef struct _ENDPOINTS_CONFIGURE_FAILURE_FLAGS {
ULONG InsufficientBandwidth:1;
ULONG InsufficientHardwareResourcesForEndpoints:1;
ULONG MaxExitLatencyTooLarge:1;
ULONG Reserved:29;
} ENDPOINTS_CONFIGURE_FAILURE_FLAGS;
typedef struct _ENDPOINTS_CONFIGURE {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
ULONG EndpointsToEnableCount;
_Field_size_(EndpointsToEnableCount)
UCXENDPOINT* EndpointsToEnable;
ULONG EndpointsToDisableCount;
_Field_size_(EndpointsToDisableCount)
UCXENDPOINT* EndpointsToDisable;
ULONG EndpointsEnabledAndUnchangedCount;
_Field_size_(EndpointsEnabledAndUnchangedCount)
UCXENDPOINT* EndpointsEnabledAndUnchanged;
ENDPOINTS_CONFIGURE_FAILURE_FLAGS FailureFlags;
ULONG ExitLatencyDelta;
UCHAR ConfigurationValue;
UCHAR InterfaceNumber;
UCHAR AlternateSetting;
} ENDPOINTS_CONFIGURE, *PENDPOINTS_CONFIGURE;
typedef enum {
FlagEndpointResetPreserveTransferState = 0x1
} ENDPOINT_RESET_FLAGS;
typedef struct _ENDPOINT_RESET {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
UCXENDPOINT Endpoint;
ENDPOINT_RESET_FLAGS Flags;
} ENDPOINT_RESET, *PENDPOINT_RESET;
typedef struct _USBDEVICE_UPDATE_FLAGS {
ULONG UpdateDeviceDescriptor:1;
ULONG UpdateBosDescriptor:1;
ULONG UpdateMaxExitLatency:1;
ULONG UpdateIsHub:1;
ULONG UpdateAllowIoOnInvalidPipeHandles:1;
ULONG Update20HardwareLpmParameters:1;
ULONG UpdateRootPortResumeTime:1;
ULONG Reserved:26;
} USBDEVICE_UPDATE_FLAGS;
typedef struct _USBDEVICE_UPDATE_FAILURE_FLAGS {
ULONG MaxExitLatencyTooLarge:1;
ULONG Reserved:31;
} USBDEVICE_UPDATE_FAILURE_FLAGS;
typedef struct _USBDEVICE_UPDATE_20_HARDWARE_LPM_PARAMETERS {
ULONG HardwareLpmEnable:1;
ULONG RemoteWakeEnable:1;
ULONG HostInitiatedResumeDurationMode:1;
ULONG BestEffortServiceLatency:4;
ULONG BestEffortServiceLatencyDeep:4;
ULONG L1Timeout:8;
ULONG Reserved:13;
} USBDEVICE_UPDATE_20_HARDWARE_LPM_PARAMETERS;
typedef struct _USBDEVICE_UPDATE {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
USBDEVICE_UPDATE_FLAGS Flags;
PUSB_DEVICE_DESCRIPTOR DeviceDescriptor;
PUSB_BOS_DESCRIPTOR BosDescriptor;
ULONG MaxExitLatency;
BOOLEAN IsHub;
USBDEVICE_UPDATE_FAILURE_FLAGS FailureFlags;
USBDEVICE_UPDATE_20_HARDWARE_LPM_PARAMETERS Usb20HardwareLpmParameters;
USHORT RootPortResumeTime;
} USBDEVICE_UPDATE, *PUSBDEVICE_UPDATE;
typedef struct _USBDEVICE_HUB_INFO {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
ULONG NumberOfPorts;
ULONG NumberOfTTs;
ULONG TTThinkTime;
} USBDEVICE_HUB_INFO, *PUSBDEVICE_HUB_INFO;
typedef struct _DEFAULT_ENDPOINT_UPDATE {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
UCXENDPOINT DefaultEndpoint;
ULONG MaxPacketSize;
} DEFAULT_ENDPOINT_UPDATE, *PDEFAULT_ENDPOINT_UPDATE;
typedef struct _USBDEVICE_DISABLE {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
UCXENDPOINT DefaultEndpoint;
} USBDEVICE_DISABLE, *PUSBDEVICE_DISABLE;
typedef struct _ADDRESS0_OWNERSHIP_ACQUIRE {
#ifdef __cplusplus
USBDEVICE_MGMT_HEADER Header;
#else
USBDEVICE_MGMT_HEADER;
#endif
} ADDRESS0_OWNERSHIP_ACQUIRE, *PADDRESS0_OWNERSHIP_ACQUIRE;
typedef enum _CONTROLLER_TYPE {
ControllerTypeXhci,
ControllerTypeSoftXhci,
} CONTROLLER_TYPE;
typedef union _CONTROLLER_USB_20_HARDWARE_LPM_FLAGS {
UCHAR AsUchar;
struct {
UCHAR L1CapabilitySupported:1;
UCHAR BeslLpmCapabilitySupported:1;
#ifdef __cplusplus
} Flags;
#else
};
#endif
} CONTROLLER_USB_20_HARDWARE_LPM_FLAGS, *PCONTROLLER_USB_20_HARDWARE_LPM_FLAGS;
#define MAX_VENDOR_ID_STRING_LENGTH 5
#define MAX_DEVICE_ID_STRING_LENGTH 5
#define MAX_REVISION_ID_STRING_LENGTH 5
typedef struct _ROOTHUB_INFO {
ULONG Size;
CONTROLLER_TYPE ControllerType;
USHORT NumberOf20Ports;
USHORT NumberOf30Ports;
USHORT MaxU1ExitLatency;
USHORT MaxU2ExitLatency;
} ROOTHUB_INFO, *PROOTHUB_INFO;
typedef enum TRISTATE {
TriStateUnknown = 'u',
TriStateFalse = 'f',
TriStateTrue = 't'
} TRISTATE;
typedef struct _ROOTHUB_20PORT_INFO {
USHORT PortNumber;
UCHAR MinorRevision;
UCHAR HubDepth;
TRISTATE Removable;
TRISTATE IntegratedHubImplemented;
TRISTATE DebugCapable;
CONTROLLER_USB_20_HARDWARE_LPM_FLAGS ControllerUsb20HardwareLpmFlags;
} ROOTHUB_20PORT_INFO, *PROOTHUB_20PORT_INFO;
typedef struct _ROOTHUB_20PORTS_INFO {
ULONG Size;
USHORT NumberOfPorts;
USHORT PortInfoSize;
PROOTHUB_20PORT_INFO* PortInfoArray;
} ROOTHUB_20PORTS_INFO, *PROOTHUB_20PORTS_INFO;
typedef struct _ROOTHUB_30PORT_INFO {
USHORT PortNumber;
UCHAR MinorRevision;
UCHAR HubDepth;
TRISTATE Removable;
TRISTATE DebugCapable;
} ROOTHUB_30PORT_INFO, *PROOTHUB_30PORT_INFO;
//
// Extended 3.0 port info additionally contains speed information.
//
typedef struct _ROOTHUB_30PORT_INFO_EX {
#ifdef __cplusplus
ROOTHUB_30PORT_INFO Info;
#else
ROOTHUB_30PORT_INFO;
#endif
USHORT MaxSpeedsCount;
USHORT SpeedsCount;
PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED Speeds;
} ROOTHUB_30PORT_INFO_EX, *PROOTHUB_30PORT_INFO_EX;
//
// Maximum number of speeds in the table is 32; also allocate 16 IDs for default speeds.
//
#define MAX_SPEEDS_COUNT (32 + 16)
typedef struct _ROOTHUB_30PORTS_INFO {
ULONG Size;
USHORT NumberOfPorts;
USHORT PortInfoSize;
PROOTHUB_30PORT_INFO* PortInfoArray;
} ROOTHUB_30PORTS_INFO, *PROOTHUB_30PORTS_INFO;
typedef union _PARENT_HUB_FLAGS {
ULONG AsUlong32;
struct {
ULONG DisableLpmForAllDownstreamDevices:1;
ULONG HubIsHighSpeedCapable:1;
#ifdef __cplusplus
} Flags;
#else
};
#endif
} PARENT_HUB_FLAGS, *PPARENT_HUB_FLAGS;
C_ASSERT(sizeof(PARENT_HUB_FLAGS) == sizeof(ULONG));
typedef struct _HUB_INFO_FROM_PARENT {
PDEVICE_OBJECT IoTarget;
USB_DEVICE_DESCRIPTOR DeviceDescriptor;
USHORT U1ExitLatency;
USHORT U2ExitLatency;
USHORT ExitLatencyOfSlowestLinkForU1;
UCHAR DepthOfSlowestLinkForU1;
USHORT ExitLatencyOfSlowestLinkForU2;
UCHAR DepthOfSlowestLinkForU2;
USHORT HostInitiatedU1ExitLatency;
USHORT HostInitiatedU2ExitLatency;
UCHAR TotalHubDepth;
USHORT TotalTPPropogationDelay;
PARENT_HUB_FLAGS HubFlags;
PUSB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED SublinkSpeedAttr;
ULONG SublinkSpeedAttrCount;
//PCONNECTOR_OBJECT ConnectorId;
//USB30_LTM_INFO 30LtmInfo;
} HUB_INFO_FROM_PARENT, *PHUB_INFO_FROM_PARENT;
DECLARE_HANDLE(UCXCONTROLLER);
DECLARE_HANDLE(UCXROOTHUB);
DECLARE_HANDLE(UCXSSTREAMS);
typedef struct _UCXUSBDEVICE_INIT *PUCXUSBDEVICE_INIT;
typedef struct _UCXENDPOINT_INIT *PUCXENDPOINT_INIT;
typedef struct _UCXSSTREAMS_INIT *PUCXSSTREAMS_INIT;
typedef void (*PFN_UCX_CLASS)(void);
extern PFN_UCX_CLASS UcxClassFunctions[];
typedef enum _UCX_CLASS_FUNCTIONS {
UcxIoDeviceControlIndex = 0,
UcxControllerCreateIndex,
UcxControllerNeedsResetIndex,
UcxControllerResetCompleteIndex,
UcxControllerSetFailedIndex,
UcxRootHubCreateIndex,
UcxRootHubPortChangedIndex,
UcxUsbDeviceCreateIndex,
UcxUsbDeviceInitSetEventCallbacksIndex,
UcxUsbDeviceRemoteWakeNotificationIndex,
UcxEndpointCreateIndex,
UcxEndpointGetStaticStreamsReferencedIndex,
UcxEndpointNeedToCancelTransfersIndex,
UcxEndpointInitSetEventCallbacksIndex,
UcxDefaultEndpointInitSetEventCallbacksIndex,
UcxEndpointSetWdfIoQueueIndex,
UcxEndpointPurgeCompleteIndex,
UcxEndpointAbortCompleteIndex,
UcxEndpointNoPingResponseErrorIndex,
UcxStaticStreamsSetStreamInfoIndex,
UcxStaticStreamsCreateIndex,
UcxInitializeDeviceInitIndex,
UcxFunctionsMax
} UCX_CLASS_FUNCTIONS;
typedef struct _UCX_GLOBALS {
//
// Size in bytes of this structure
//
ULONG Size;
//
// Client's WdfDriverGlobals
//
PWDF_DRIVER_GLOBALS WdfDriverGlobals;
} UCX_GLOBALS, *PUCX_GLOBALS;
extern PUCX_GLOBALS UcxGlobals;
//
// UcxInitializeDeviceInit
//
typedef
__drv_requiresIRQL(PASSIVE_LEVEL)
_Must_inspect_result_
NTSTATUS
(*PFN_UCX_INITIALIZE_DEVICE_INIT)(
__in
PUCX_GLOBALS Globals,
__inout
PWDFDEVICE_INIT DeviceInit
);
__drv_requiresIRQL(PASSIVE_LEVEL)
_Must_inspect_result_
NTSTATUS
FORCEINLINE
UcxInitializeDeviceInit(
__inout
PWDFDEVICE_INIT DeviceInit
)
{
return(((PFN_UCX_INITIALIZE_DEVICE_INIT)
UcxClassFunctions[UcxInitializeDeviceInitIndex])(UcxGlobals,
DeviceInit));
}
//
// UcxIoDeviceControl
//
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
_Must_inspect_result_
BOOLEAN
(*PFN_UCX_IO_DEVICE_CONTROL)(
__in
PUCX_GLOBALS Globals,
__in
WDFDEVICE Device,
__in
WDFREQUEST Request,
__in
size_t OutputBufferLength,
__in
size_t InputBufferLength,
__in
ULONG IoControlCode
);
_Must_inspect_result_
__drv_maxIRQL(DISPATCH_LEVEL)
BOOLEAN
FORCEINLINE
UcxIoDeviceControl(
__in
WDFDEVICE Device,
__in
WDFREQUEST Request,
__in
size_t OutputBufferLength,
__in
size_t InputBufferLength,
__in
ULONG IoControlCode
)
{
return(((PFN_UCX_IO_DEVICE_CONTROL)
UcxClassFunctions[UcxIoDeviceControlIndex])(UcxGlobals,
Device,
Request,
OutputBufferLength,
InputBufferLength,
IoControlCode));
}
#define MAX_USB_DEVICE_DEPTH 6
typedef struct _USB_DEVICE_PORT_PATH {
ULONG Size;
ULONG PortPathDepth;
ULONG TTHubDepth;
ULONG PortPath[ MAX_USB_DEVICE_DEPTH ];
} USB_DEVICE_PORT_PATH, *PUSB_DEVICE_PORT_PATH;
typedef struct _UCXUSBDEVICE_INFO {
ULONG Size;
USB_DEVICE_SPEED DeviceSpeed;
UCXUSBDEVICE TtHub;
USB_DEVICE_PORT_PATH PortPath;
} UCXUSBDEVICE_INFO, *PUCXUSBDEVICE_INFO;
typedef
__drv_functionClass(EVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY)
_Must_inspect_result_
NTSTATUS
EVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY (
__in
UCXCONTROLLER UcxController,
__in
PGUID CapabilityType,
__in
ULONG OutputBufferLength,
__out_bcount_opt(OutputBufferLength)
PVOID OutputBuffer,
__out
PULONG ResultLength
);
typedef EVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY *PEVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY;
typedef
__drv_functionClass(EVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER)
_Must_inspect_result_
NTSTATUS
EVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER (
__in
UCXCONTROLLER UcxController,
__out
PULONG FrameNumber
);
typedef EVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER *PEVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER;
typedef
__drv_functionClass(EVT_UCX_CONTROLLER_USBDEVICE_ADD)
__drv_requiresIRQL(PASSIVE_LEVEL)
_Must_inspect_result_
NTSTATUS
EVT_UCX_CONTROLLER_USBDEVICE_ADD (
__in
UCXCONTROLLER UcxController,
__in
PUCXUSBDEVICE_INFO UcxUsbDeviceInfo,
__in
PUCXUSBDEVICE_INIT UsbDeviceInit
);
typedef EVT_UCX_CONTROLLER_USBDEVICE_ADD *PEVT_UCX_CONTROLLER_USBDEVICE_ADD;
typedef
__drv_functionClass(EVT_UCX_CONTROLLER_RESET)
__drv_requiresIRQL(PASSIVE_LEVEL)
VOID
EVT_UCX_CONTROLLER_RESET (
__in
UCXCONTROLLER UcxController
);
typedef EVT_UCX_CONTROLLER_RESET *PEVT_UCX_CONTROLLER_RESET;
typedef enum {
UcxControllerParentBusTypeCustom,
UcxControllerParentBusTypePci,
UcxControllerParentBusTypeAcpi
} UCX_CONTROLLER_PARENT_BUS_TYPE;
typedef struct _UCX_CONTROLLER_PCI_INFORMATION {
ULONG VendorId;
ULONG DeviceId;
USHORT RevisionId;
ULONG BusNumber;
ULONG DeviceNumber;
ULONG FunctionNumber;
} UCX_CONTROLLER_PCI_INFORMATION, *PUCX_CONTROLLER_PCI_INFORMATION;
typedef struct _UCX_CONTROLLER_ACPI_INFORMATION {
CHAR VendorId[MAX_VENDOR_ID_STRING_LENGTH];
CHAR DeviceId[MAX_DEVICE_ID_STRING_LENGTH];
CHAR RevisionId[MAX_REVISION_ID_STRING_LENGTH];
} UCX_CONTROLLER_ACPI_INFORMATION, *PUCX_CONTROLLER_ACPI_INFORMATION;
#define MAX_GENERIC_USB_CONTROLLER_NAME_SIZE 40
typedef struct _UCX_CONTROLLER_CONFIG {
//
// Size in bytes of this structure
//
ULONG Size;
ULONG NumberOfPresentedDeviceMgmtEvtCallbacks;
PEVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY EvtControllerQueryUsbCapability;
HANDLE Reserved1;
PEVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER EvtControllerGetCurrentFrameNumber;
PEVT_UCX_CONTROLLER_USBDEVICE_ADD EvtControllerUsbDeviceAdd;
PEVT_UCX_CONTROLLER_RESET EvtControllerReset;
HANDLE Reserved2;
HANDLE Reserved3;
HANDLE Reserved4;
UCX_CONTROLLER_PARENT_BUS_TYPE ParentBusType;
UCX_CONTROLLER_PCI_INFORMATION PciDeviceInfo;
UCX_CONTROLLER_ACPI_INFORMATION AcpiDeviceInfo;
//
// Due to compat with GUID_USB_WMI_NODE_INFO we cannot use WCHAR.
//
UCHAR DeviceDescription[MAX_GENERIC_USB_CONTROLLER_NAME_SIZE];
} UCX_CONTROLLER_CONFIG, *PUCX_CONTROLLER_CONFIG;
//
// UcxControllerCreate
//
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
_Must_inspect_result_
NTSTATUS
(*PFN_UCX_CONTROLLER_CREATE)(
__in
PUCX_GLOBALS Globals,
__in
WDFDEVICE Device,
__in
PUCX_CONTROLLER_CONFIG Config,
__in_opt
PWDF_OBJECT_ATTRIBUTES Attributes,
__out
UCXCONTROLLER *Controller
);
__drv_at(Config->Size, __drv_out (__range(!=,0)))
__drv_at(Config->EvtControllerQueryUsbCapability, __drv_out (__null))
__drv_at(Config->EvtControllerGetCurrentFrameNumber, __drv_out (__null))
__drv_at(Config->EvtControllerUsbDeviceAdd, __drv_out (__null))
__drv_at(Config->EvtControllerReset, __drv_out (__null))
__drv_at(Config->Reserved1, __drv_out (__null))
__drv_at(Config->Reserved2, __drv_out (__null))
__drv_at(Config->Reserved3, __drv_out (__null))
__drv_at(Config->Reserved4, __drv_out (__null))
VOID
FORCEINLINE
UCX_CONTROLLER_CONFIG_INIT(
__out
PUCX_CONTROLLER_CONFIG Config,
__in
LPCSTR DeviceDescription
)
{
RtlZeroMemory(Config, sizeof(UCX_CONTROLLER_CONFIG));
Config->Size = sizeof(UCX_CONTROLLER_CONFIG);
Config->NumberOfPresentedDeviceMgmtEvtCallbacks = (ULONG)-1;
Config->ParentBusType = UcxControllerParentBusTypeCustom;
Config->AcpiDeviceInfo.VendorId[0] = ANSI_NULL;
Config->AcpiDeviceInfo.DeviceId[0] = ANSI_NULL;
Config->AcpiDeviceInfo.RevisionId[0] = ANSI_NULL;
Config->PciDeviceInfo.VendorId = LONG_MAX;
Config->PciDeviceInfo.DeviceId = LONG_MAX;
Config->PciDeviceInfo.RevisionId = 0;
Config->PciDeviceInfo.BusNumber = 0;
Config->PciDeviceInfo.DeviceNumber = 0;
Config->PciDeviceInfo.FunctionNumber = 0;
(VOID) RtlStringCbCopyA((LPSTR)Config->DeviceDescription,
sizeof(Config->DeviceDescription),
DeviceDescription);
__assume(Config->EvtControllerQueryUsbCapability == NULL);
__assume(Config->EvtControllerGetCurrentFrameNumber == NULL);
__assume(Config->EvtControllerUsbDeviceAdd == NULL);
__assume(Config->EvtControllerReset == NULL);
__assume(Config->Reserved1 == NULL);
__assume(Config->Reserved2 == NULL);
__assume(Config->Reserved3 == NULL);
__assume(Config->Reserved4 == NULL);
}
VOID
FORCEINLINE
UCX_CONTROLLER_CONFIG_SET_PCI_INFO(
__in
PUCX_CONTROLLER_CONFIG Config,
__in
ULONG VendorId,
__in
ULONG DeviceId,
__in
USHORT RevisionId,
__in
ULONG BusNumber,
__in
ULONG DeviceNumber,
__in
ULONG FunctionNumber
)
{
Config->ParentBusType = UcxControllerParentBusTypePci;
Config->PciDeviceInfo.VendorId = VendorId;
Config->PciDeviceInfo.DeviceId = DeviceId;
Config->PciDeviceInfo.RevisionId = RevisionId;
Config->PciDeviceInfo.BusNumber = BusNumber;
Config->PciDeviceInfo.DeviceNumber = DeviceNumber;
Config->PciDeviceInfo.FunctionNumber = FunctionNumber;
}
VOID
FORCEINLINE
UCX_CONTROLLER_CONFIG_SET_ACPI_INFO(
__in
PUCX_CONTROLLER_CONFIG Config,
__in_ecount(MAX_VENDOR_ID_STRING_LENGTH)
PSTR VendorId,
__in_ecount(MAX_DEVICE_ID_STRING_LENGTH)
PSTR DeviceId,
__in_ecount(MAX_REVISION_ID_STRING_LENGTH)
PSTR RevisionId
)
{
Config->ParentBusType = UcxControllerParentBusTypeAcpi;
RtlStringCchCopyA(Config->AcpiDeviceInfo.VendorId, MAX_VENDOR_ID_STRING_LENGTH, VendorId);
RtlStringCchCopyA(Config->AcpiDeviceInfo.DeviceId, MAX_DEVICE_ID_STRING_LENGTH, DeviceId);
RtlStringCchCopyA(Config->AcpiDeviceInfo.RevisionId, MAX_REVISION_ID_STRING_LENGTH, RevisionId);
}
_Must_inspect_result_
__drv_maxIRQL(DISPATCH_LEVEL)
__drv_at(Config->Size, __range(!=,0))
__drv_at(Config->EvtControllerUsbDeviceAdd, __notnull)
NTSTATUS
FORCEINLINE
UcxControllerCreate(
__in
WDFDEVICE Device,
__in
PUCX_CONTROLLER_CONFIG Config,
__in_opt
PWDF_OBJECT_ATTRIBUTES Attributes,
__out
UCXCONTROLLER *Controller
)
{
return(((PFN_UCX_CONTROLLER_CREATE) UcxClassFunctions[UcxControllerCreateIndex])(UcxGlobals,
Device,
Config,
Attributes,
Controller));
}
//
// UcxControllerNeedsReset
//
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_CONTROLLER_NEEDS_RESET)(
__in
PUCX_GLOBALS Globals,
__in
UCXCONTROLLER Controller
);
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxControllerNeedsReset(
__in
UCXCONTROLLER Controller
)
{
(((PFN_UCX_CONTROLLER_NEEDS_RESET) UcxClassFunctions[UcxControllerNeedsResetIndex])(
UcxGlobals,
Controller));
}
//
// UcxControllerResetComplete
//
typedef enum {
UcxControllerStateLost,
UcxControllerStatePreserved
} UCX_CONTROLLER_STATE;
typedef struct _UCX_CONTROLLER_RESET_COMPLETE_INFO {
ULONG Size;
UCX_CONTROLLER_STATE UcxControllerState;
BOOLEAN UcxCoordinated;
} UCX_CONTROLLER_RESET_COMPLETE_INFO, *PUCX_CONTROLLER_RESET_COMPLETE_INFO;
FORCEINLINE
VOID
UCX_CONTROLLER_RESET_COMPLETE_INFO_INIT(
__out
PUCX_CONTROLLER_RESET_COMPLETE_INFO UcxControllerResetCompleteInfo,
__in
UCX_CONTROLLER_STATE UcxControllerState,
__in
BOOLEAN UcxCoordinated
)
{
RtlZeroMemory(UcxControllerResetCompleteInfo, sizeof(UCX_CONTROLLER_RESET_COMPLETE_INFO));
UcxControllerResetCompleteInfo->Size = sizeof(UCX_CONTROLLER_RESET_COMPLETE_INFO);
UcxControllerResetCompleteInfo->UcxControllerState = UcxControllerState;
UcxControllerResetCompleteInfo->UcxCoordinated = UcxCoordinated;
}
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_CONTROLLER_RESET_COMPLETE)(
__in
PUCX_GLOBALS Globals,
__in
UCXCONTROLLER Controller,
__in
PUCX_CONTROLLER_RESET_COMPLETE_INFO UcxControllerResetCompleteInfo
);
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxControllerResetComplete(
__in
UCXCONTROLLER Controller,
__in
PUCX_CONTROLLER_RESET_COMPLETE_INFO UcxControllerResetCompleteInfo
)
{
(((PFN_UCX_CONTROLLER_RESET_COMPLETE) UcxClassFunctions[UcxControllerResetCompleteIndex])(
UcxGlobals,
Controller,
UcxControllerResetCompleteInfo));
}
//
// UcxControllerSetFailed
//
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_CONTROLLER_SET_FAILED)(
__in
PUCX_GLOBALS Globals,
__in
UCXCONTROLLER Controller
);
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxControllerSetFailed(
__in
UCXCONTROLLER Controller
)
{
(((PFN_UCX_CONTROLLER_SET_FAILED) UcxClassFunctions[UcxControllerSetFailedIndex])(
UcxGlobals,
Controller));
}
/*-------------------Structures for UCXROOTHUB creation ----------------------*/
typedef
__drv_functionClass(EVT_UCX_ROOTHUB_INTERRUPT_TX)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ROOTHUB_INTERRUPT_TX (
__in
UCXROOTHUB UcxRootHub,
__in
WDFREQUEST Request
);
typedef EVT_UCX_ROOTHUB_INTERRUPT_TX *PEVT_UCX_ROOTHUB_INTERRUPT_TX;
typedef
__drv_functionClass(EVT_UCX_ROOTHUB_CONTROL_URB)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ROOTHUB_CONTROL_URB (
__in
UCXROOTHUB,
__in
WDFREQUEST
);
typedef EVT_UCX_ROOTHUB_CONTROL_URB *PEVT_UCX_ROOTHUB_CONTROL_URB;
typedef
__drv_functionClass(EVT_UCX_ROOTHUB_GET_INFO)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ROOTHUB_GET_INFO (
__in
UCXROOTHUB,
__in
WDFREQUEST
);
typedef EVT_UCX_ROOTHUB_GET_INFO *PEVT_UCX_ROOTHUB_GET_INFO;
typedef
__drv_functionClass(EVT_UCX_ROOTHUB_GET_20PORT_INFO)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ROOTHUB_GET_20PORT_INFO (
__in
UCXROOTHUB,
__in
WDFREQUEST
);
typedef EVT_UCX_ROOTHUB_GET_20PORT_INFO *PEVT_UCX_ROOTHUB_GET_20PORT_INFO;
typedef
__drv_functionClass(EVT_UCX_ROOTHUB_GET_30PORT_INFO)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ROOTHUB_GET_30PORT_INFO (
__in
UCXROOTHUB,
__in
WDFREQUEST
);
typedef EVT_UCX_ROOTHUB_GET_30PORT_INFO *PEVT_UCX_ROOTHUB_GET_30PORT_INFO;
typedef struct _UCX_ROOTHUB_CONFIG {
//
// Size in bytes of this structure
//
ULONG Size;
ULONG NumberOfPresentedControlUrbCallbacks;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubClearHubFeature;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubClearPortFeature;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubGetHubStatus;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubGetPortStatus;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubSetHubFeature;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubSetPortFeature;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubGetPortErrorCount;
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubControlUrb;
PEVT_UCX_ROOTHUB_INTERRUPT_TX EvtRootHubInterruptTx;
PEVT_UCX_ROOTHUB_GET_INFO EvtRootHubGetInfo;
PEVT_UCX_ROOTHUB_GET_20PORT_INFO EvtRootHubGet20PortInfo;
PEVT_UCX_ROOTHUB_GET_30PORT_INFO EvtRootHubGet30PortInfo;
WDF_OBJECT_ATTRIBUTES WdfRequestAttributes;
} UCX_ROOTHUB_CONFIG, *PUCX_ROOTHUB_CONFIG;
//
// UcxRootHubCreate
//
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
_Must_inspect_result_
NTSTATUS
(*PFN_UCX_ROOTHUB_CREATE)(
__in
PUCX_GLOBALS,
__in
UCXCONTROLLER,
__in
PUCX_ROOTHUB_CONFIG,
__in_opt
PWDF_OBJECT_ATTRIBUTES,
__out
UCXROOTHUB*
);
__drv_at(Config->Size, __drv_out (__range(!=,0)))
__drv_at(Config->EvtRootHubControlUrb, __drv_out (__notnull))
__drv_at(Config->EvtRootHubClearHubFeature, __drv_out (__null))
__drv_at(Config->EvtRootHubClearPortFeature, __drv_out (__null))
__drv_at(Config->EvtRootHubGetHubStatus, __drv_out (__null))
__drv_at(Config->EvtRootHubGetPortStatus, __drv_out (__null))
__drv_at(Config->EvtRootHubSetHubFeature, __drv_out (__null))
__drv_at(Config->EvtRootHubSetPortFeature, __drv_out (__null))
__drv_at(Config->EvtRootHubGetPortErrorCount, __drv_out (__null))
__drv_at(Config->EvtRootHubInterruptTx, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGetInfo, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGet20PortInfo, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGet30PortInfo, __drv_out (__notnull))
VOID
FORCEINLINE
UCX_ROOTHUB_CONFIG_INIT_WITH_CONTROL_URB_HANDLER(
__out
PUCX_ROOTHUB_CONFIG Config,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubControlUrb,
__in
PEVT_UCX_ROOTHUB_INTERRUPT_TX EvtRootHubInterruptTx,
__in
PEVT_UCX_ROOTHUB_GET_INFO EvtRootHubGetInfo,
__in
PEVT_UCX_ROOTHUB_GET_20PORT_INFO EvtRootHubGet20PortInfo,
__in
PEVT_UCX_ROOTHUB_GET_30PORT_INFO EvtRootHubGet30PortInfo
)
{
RtlZeroMemory(Config, sizeof(UCX_ROOTHUB_CONFIG));
Config->Size = sizeof(UCX_ROOTHUB_CONFIG);
Config->NumberOfPresentedControlUrbCallbacks = 1;
Config->EvtRootHubControlUrb = EvtRootHubControlUrb;
Config->EvtRootHubInterruptTx = EvtRootHubInterruptTx;
Config->EvtRootHubGetInfo = EvtRootHubGetInfo;
Config->EvtRootHubGet20PortInfo = EvtRootHubGet20PortInfo;
Config->EvtRootHubGet30PortInfo = EvtRootHubGet30PortInfo;
WDF_OBJECT_ATTRIBUTES_INIT(&Config->WdfRequestAttributes);
__assume(Config->EvtRootHubClearHubFeature == NULL);
__assume(Config->EvtRootHubClearPortFeature == NULL);
__assume(Config->EvtRootHubGetHubStatus == NULL);
__assume(Config->EvtRootHubGetPortStatus == NULL);
__assume(Config->EvtRootHubSetHubFeature == NULL);
__assume(Config->EvtRootHubSetPortFeature == NULL);
__assume(Config->EvtRootHubGetPortErrorCount == NULL);
}
__drv_at(Config->Size, __drv_out (__range(!=,0)))
__drv_at(Config->EvtRootHubControlUrb, __drv_out (__null))
__drv_at(Config->EvtRootHubClearHubFeature, __drv_out (__notnull))
__drv_at(Config->EvtRootHubClearPortFeature, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGetHubStatus, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGetPortStatus, __drv_out (__notnull))
__drv_at(Config->EvtRootHubSetHubFeature, __drv_out (__notnull))
__drv_at(Config->EvtRootHubSetPortFeature, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGetPortErrorCount, __drv_out (__notnull))
__drv_at(Config->EvtRootHubInterruptTx, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGetInfo, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGet20PortInfo, __drv_out (__notnull))
__drv_at(Config->EvtRootHubGet30PortInfo, __drv_out (__notnull))
VOID
FORCEINLINE
UCX_ROOTHUB_CONFIG_INIT(
__out
PUCX_ROOTHUB_CONFIG Config,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubClearHubFeature,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubClearPortFeature,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubGetHubStatus,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubGetPortStatus,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubSetHubFeature,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubSetPortFeature,
__in
PEVT_UCX_ROOTHUB_CONTROL_URB EvtRootHubGetPortErrorCount,
__in
PEVT_UCX_ROOTHUB_INTERRUPT_TX EvtRootHubInterruptTx,
__in
PEVT_UCX_ROOTHUB_GET_INFO EvtRootHubGetInfo,
__in
PEVT_UCX_ROOTHUB_GET_20PORT_INFO EvtRootHubGet20PortInfo,
__in
PEVT_UCX_ROOTHUB_GET_30PORT_INFO EvtRootHubGet30PortInfo
)
{
RtlZeroMemory(Config, sizeof(UCX_ROOTHUB_CONFIG));
Config->Size = sizeof(UCX_ROOTHUB_CONFIG);
Config->NumberOfPresentedControlUrbCallbacks = 1;
Config->EvtRootHubClearHubFeature = EvtRootHubClearHubFeature;
Config->EvtRootHubClearPortFeature = EvtRootHubClearPortFeature;
Config->EvtRootHubGetHubStatus = EvtRootHubGetHubStatus;
Config->EvtRootHubGetPortStatus = EvtRootHubGetPortStatus;
Config->EvtRootHubSetHubFeature = EvtRootHubSetHubFeature;
Config->EvtRootHubSetPortFeature = EvtRootHubSetPortFeature;
Config->EvtRootHubGetPortErrorCount = EvtRootHubGetPortErrorCount;
Config->EvtRootHubInterruptTx = EvtRootHubInterruptTx;
Config->EvtRootHubGetInfo = EvtRootHubGetInfo;
Config->EvtRootHubGet20PortInfo = EvtRootHubGet20PortInfo;
Config->EvtRootHubGet30PortInfo = EvtRootHubGet30PortInfo;
WDF_OBJECT_ATTRIBUTES_INIT(&Config->WdfRequestAttributes);
__assume(Config->EvtRootHubControlUrb == NULL);
}
_Must_inspect_result_
__drv_maxIRQL(DISPATCH_LEVEL)
__drv_at(Config->Size, __range(!=,0))
__drv_when(NULL == Config->EvtRootHubControlUrb,
__drv_at(Config->EvtRootHubClearHubFeature, __notnull)
__drv_at(Config->EvtRootHubClearPortFeature, __notnull)
__drv_at(Config->EvtRootHubGetHubStatus, __notnull)
__drv_at(Config->EvtRootHubGetPortStatus, __notnull)
__drv_at(Config->EvtRootHubSetHubFeature, __notnull)
__drv_at(Config->EvtRootHubSetPortFeature, __notnull)
__drv_at(Config->EvtRootHubGetPortErrorCount, __notnull)
)
__drv_at(Config->EvtRootHubInterruptTx, __notnull)
__drv_at(Config->EvtRootHubGetInfo, __notnull)
__drv_at(Config->EvtRootHubGet20PortInfo, __notnull)
__drv_at(Config->EvtRootHubGet30PortInfo, __notnull)
NTSTATUS
FORCEINLINE
UcxRootHubCreate(
__in
UCXCONTROLLER Controller,
__in
PUCX_ROOTHUB_CONFIG Config,
__in_opt
PWDF_OBJECT_ATTRIBUTES Attributes,
__out
UCXROOTHUB *RootHub
)
{
return(((PFN_UCX_ROOTHUB_CREATE)UcxClassFunctions[UcxRootHubCreateIndex])(UcxGlobals,
Controller,
Config,
Attributes,
RootHub));
}
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_ROOTHUB_PORT_CHANGED)(
__in_opt
PUCX_GLOBALS,
__in
UCXROOTHUB
);
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxRootHubPortChanged(
__in
UCXROOTHUB UcxRootHub
)
{
(((PFN_UCX_ROOTHUB_PORT_CHANGED)UcxClassFunctions[UcxRootHubPortChangedIndex])(UcxGlobals,
UcxRootHub));
}
/*-------------------Structures for UCXUSBDEVICE creation---------------------*/
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_ENDPOINTS_CONFIGURE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_ENDPOINTS_CONFIGURE (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_ENDPOINTS_CONFIGURE *PEVT_UCX_USBDEVICE_ENDPOINTS_CONFIGURE;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_ENABLE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_ENABLE (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_ENABLE *PEVT_UCX_USBDEVICE_ENABLE;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_DISABLE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_DISABLE (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_DISABLE *PEVT_UCX_USBDEVICE_DISABLE;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_RESET)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_RESET (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_RESET *PEVT_UCX_USBDEVICE_RESET;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_ADDRESS)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_ADDRESS (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_ADDRESS *PEVT_UCX_USBDEVICE_ADDRESS;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_UPDATE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_UPDATE (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_UPDATE *PEVT_UCX_USBDEVICE_UPDATE;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_HUB_INFO)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_USBDEVICE_HUB_INFO (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_USBDEVICE_HUB_INFO *PEVT_UCX_USBDEVICE_HUB_INFO;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_DEFAULT_ENDPOINT_ADD)
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
EVT_UCX_USBDEVICE_DEFAULT_ENDPOINT_ADD (
__in
UCXCONTROLLER,
__in
UCXUSBDEVICE,
__in
ULONG,
__in
PUCXENDPOINT_INIT
);
typedef EVT_UCX_USBDEVICE_DEFAULT_ENDPOINT_ADD *PEVT_UCX_USBDEVICE_DEFAULT_ENDPOINT_ADD;
typedef
__drv_functionClass(EVT_UCX_USBDEVICE_ENDPOINT_ADD)
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
EVT_UCX_USBDEVICE_ENDPOINT_ADD (
__in
UCXCONTROLLER UcxController,
__in
UCXUSBDEVICE UcxUsbDevice,
__in_bcount(UsbEndpointDescriptorBufferLength)
PUSB_ENDPOINT_DESCRIPTOR UsbEndpointDescriptor,
__in
ULONG UsbEndpointDescriptorBufferLength,
__in_opt
PUSB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR SuperSpeedEndpointCompanionDescriptor,
__in
PUCXENDPOINT_INIT UcxEndpointInit
);
typedef EVT_UCX_USBDEVICE_ENDPOINT_ADD *PEVT_UCX_USBDEVICE_ENDPOINT_ADD;
typedef struct _UCX_USBDEVICE_EVENT_CALLBACKS {
ULONG Size;
PEVT_UCX_USBDEVICE_ENDPOINTS_CONFIGURE EvtUsbDeviceEndpointsConfigure;
PEVT_UCX_USBDEVICE_ENABLE EvtUsbDeviceEnable;
PEVT_UCX_USBDEVICE_DISABLE EvtUsbDeviceDisable;
PEVT_UCX_USBDEVICE_RESET EvtUsbDeviceReset;
PEVT_UCX_USBDEVICE_ADDRESS EvtUsbDeviceAddress;
PEVT_UCX_USBDEVICE_UPDATE EvtUsbDeviceUpdate;
PEVT_UCX_USBDEVICE_HUB_INFO EvtUsbDeviceHubInfo;
PEVT_UCX_USBDEVICE_DEFAULT_ENDPOINT_ADD EvtUsbDeviceDefaultEndpointAdd;
PEVT_UCX_USBDEVICE_ENDPOINT_ADD EvtUsbDeviceEndpointAdd;
} UCX_USBDEVICE_EVENT_CALLBACKS, *PUCX_USBDEVICE_EVENT_CALLBACKS;
VOID
FORCEINLINE
UCX_USBDEVICE_EVENT_CALLBACKS_INIT
(
__out
PUCX_USBDEVICE_EVENT_CALLBACKS Callbacks,
__in
PEVT_UCX_USBDEVICE_ENDPOINTS_CONFIGURE EvtUsbDeviceEndpointsConfigure,
__in
PEVT_UCX_USBDEVICE_ENABLE EvtUsbDeviceEnable,
__in
PEVT_UCX_USBDEVICE_DISABLE EvtUsbDeviceDisable,
__in
PEVT_UCX_USBDEVICE_RESET EvtUsbDeviceReset,
__in
PEVT_UCX_USBDEVICE_ADDRESS EvtUsbDeviceAddress,
__in
PEVT_UCX_USBDEVICE_UPDATE EvtUsbDeviceUpdate,
__in
PEVT_UCX_USBDEVICE_HUB_INFO EvtUsbDeviceHubInfo,
__in
PEVT_UCX_USBDEVICE_DEFAULT_ENDPOINT_ADD EvtUsbDeviceDefaultEndpointAdd,
__in
PEVT_UCX_USBDEVICE_ENDPOINT_ADD EvtUsbDeviceEndpointAdd
)
{
RtlZeroMemory(Callbacks, sizeof(UCX_USBDEVICE_EVENT_CALLBACKS));
Callbacks->Size = sizeof(UCX_USBDEVICE_EVENT_CALLBACKS);
Callbacks->EvtUsbDeviceEndpointsConfigure = EvtUsbDeviceEndpointsConfigure;
Callbacks->EvtUsbDeviceEnable = EvtUsbDeviceEnable;
Callbacks->EvtUsbDeviceDisable = EvtUsbDeviceDisable;
Callbacks->EvtUsbDeviceReset = EvtUsbDeviceReset;
Callbacks->EvtUsbDeviceAddress = EvtUsbDeviceAddress;
Callbacks->EvtUsbDeviceUpdate = EvtUsbDeviceUpdate;
Callbacks->EvtUsbDeviceHubInfo = EvtUsbDeviceHubInfo;
Callbacks->EvtUsbDeviceDefaultEndpointAdd = EvtUsbDeviceDefaultEndpointAdd;
Callbacks->EvtUsbDeviceEndpointAdd = EvtUsbDeviceEndpointAdd;
}
typedef
_Must_inspect_result_
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
(*PFN_UCX_USBDEVICE_CREATE)(
__in
PUCX_GLOBALS,
__in
UCXCONTROLLER,
__deref_inout
PUCXUSBDEVICE_INIT*,
__in_opt
PWDF_OBJECT_ATTRIBUTES,
__out
UCXUSBDEVICE*
);
typedef
VOID
(*PFN_UCX_USBDEVICE_INIT_SET_EVENT_CALLBACKS)(
__in
PUCX_GLOBALS,
__in
PUCXUSBDEVICE_INIT,
__in
PUCX_USBDEVICE_EVENT_CALLBACKS
);
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_USBDEVICE_REMOTE_WAKE_NOTIFICATION)(
__in
PUCX_GLOBALS,
__in
UCXUSBDEVICE,
__in
ULONG
);
VOID
FORCEINLINE
UcxUsbDeviceInitSetEventCallbacks(
__inout
PUCXUSBDEVICE_INIT UsbDeviceInit,
__in
PUCX_USBDEVICE_EVENT_CALLBACKS EventCallbacks
)
{
(((PFN_UCX_USBDEVICE_INIT_SET_EVENT_CALLBACKS)
UcxClassFunctions[UcxUsbDeviceInitSetEventCallbacksIndex])(UcxGlobals,
UsbDeviceInit,
EventCallbacks));
}
_Must_inspect_result_
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
FORCEINLINE
UcxUsbDeviceCreate(
__in
UCXCONTROLLER Controller,
__deref_inout
PUCXUSBDEVICE_INIT *UsbDeviceInit,
__in_opt
PWDF_OBJECT_ATTRIBUTES Attributes,
__out
UCXUSBDEVICE *UsbDevice
)
{
return(((PFN_UCX_USBDEVICE_CREATE)UcxClassFunctions[UcxUsbDeviceCreateIndex])(UcxGlobals,
Controller,
UsbDeviceInit,
Attributes,
UsbDevice));
}
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxUsbDeviceRemoteWakeNotification(
__in
UCXUSBDEVICE UsbDevice,
__in
ULONG Interface
)
{
(((PFN_UCX_USBDEVICE_REMOTE_WAKE_NOTIFICATION)
UcxClassFunctions[UcxUsbDeviceRemoteWakeNotificationIndex])(UcxGlobals,
UsbDevice,
Interface));
}
/*-------------------Structures for UCXENDPOINT creation----------------------*/
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_RESET)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_RESET (
__in
UCXCONTROLLER,
__in
UCXENDPOINT,
__in
WDFREQUEST
);
typedef EVT_UCX_ENDPOINT_RESET *PEVT_UCX_ENDPOINT_RESET;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_PURGE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_PURGE (
__in
UCXCONTROLLER,
__in
UCXENDPOINT
);
typedef EVT_UCX_ENDPOINT_PURGE *PEVT_UCX_ENDPOINT_PURGE;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_START)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_START (
__in
UCXCONTROLLER,
__in
UCXENDPOINT
);
typedef EVT_UCX_ENDPOINT_START *PEVT_UCX_ENDPOINT_START;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_ABORT)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_ABORT (
__in
UCXCONTROLLER,
__in
UCXENDPOINT
);
typedef EVT_UCX_ENDPOINT_ABORT *PEVT_UCX_ENDPOINT_ABORT;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS (
__in
UCXENDPOINT
);
typedef EVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS *PEVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_STATIC_STREAMS_ADD)
__drv_maxIRQL(DISPATCH_LEVEL)
_Must_inspect_result_
NTSTATUS
EVT_UCX_ENDPOINT_STATIC_STREAMS_ADD (
__in
UCXENDPOINT,
__in
ULONG,
__in
PUCXSSTREAMS_INIT
);
typedef EVT_UCX_ENDPOINT_STATIC_STREAMS_ADD *PEVT_UCX_ENDPOINT_STATIC_STREAMS_ADD;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE (
__in
UCXENDPOINT,
__in
UCXSSTREAMS,
__in
WDFREQUEST
);
typedef EVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE *PEVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE (
__in
UCXENDPOINT,
__in
UCXSSTREAMS,
__in
WDFREQUEST
);
typedef EVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE *PEVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE;
typedef
__drv_functionClass(EVT_UCX_ENDPOINT_ENABLE_FORWARD_PROGRESS)
__drv_requiresIRQL(PASSIVE_LEVEL)
_Must_inspect_result_
NTSTATUS
EVT_UCX_ENDPOINT_ENABLE_FORWARD_PROGRESS (
__in
UCXENDPOINT,
__in
ULONG
);
typedef EVT_UCX_ENDPOINT_ENABLE_FORWARD_PROGRESS *PEVT_UCX_ENDPOINT_ENABLE_FORWARD_PROGRESS;
typedef
__drv_functionClass(EVT_UCX_DEFAULT_ENDPOINT_UPDATE)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
EVT_UCX_DEFAULT_ENDPOINT_UPDATE (
__in
UCXCONTROLLER,
__in
WDFREQUEST
);
typedef EVT_UCX_DEFAULT_ENDPOINT_UPDATE *PEVT_UCX_DEFAULT_ENDPOINT_UPDATE;
typedef struct _UCX_ENDPOINT_EVENT_CALLBACKS {
ULONG Size;
PEVT_UCX_ENDPOINT_PURGE EvtEndpointPurge;
PEVT_UCX_ENDPOINT_START EvtEndpointStart;
PEVT_UCX_ENDPOINT_ABORT EvtEndpointAbort;
PEVT_UCX_ENDPOINT_RESET EvtEndpointReset;
PEVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS EvtEndpointOkToCancelTransfers;
PEVT_UCX_ENDPOINT_STATIC_STREAMS_ADD EvtEndpointStaticStreamsAdd;
PEVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE EvtEndpointStaticStreamsEnable;
PEVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE EvtEndpointStaticStreamsDisable;
HANDLE Reserved1;
} UCX_ENDPOINT_EVENT_CALLBACKS, *PUCX_ENDPOINT_EVENT_CALLBACKS;
VOID
FORCEINLINE
UCX_ENDPOINT_EVENT_CALLBACKS_INIT
(
__out
PUCX_ENDPOINT_EVENT_CALLBACKS Callbacks,
__in
PEVT_UCX_ENDPOINT_PURGE EvtEndpointPurge,
__in
PEVT_UCX_ENDPOINT_START EvtEndpointStart,
__in
PEVT_UCX_ENDPOINT_ABORT EvtEndpointAbort,
__in
PEVT_UCX_ENDPOINT_RESET EvtEndpointReset,
__in
PEVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS EvtEndpointOkToCancelTransfers,
__in
PEVT_UCX_ENDPOINT_STATIC_STREAMS_ADD EvtEndpointStaticStreamsAdd,
__in
PEVT_UCX_ENDPOINT_STATIC_STREAMS_ENABLE EvtEndpointStaticStreamsEnable,
__in
PEVT_UCX_ENDPOINT_STATIC_STREAMS_DISABLE EvtEndpointStaticStreamsDisable
)
{
RtlZeroMemory(Callbacks, sizeof(UCX_ENDPOINT_EVENT_CALLBACKS));
Callbacks->Size = sizeof(UCX_ENDPOINT_EVENT_CALLBACKS);
Callbacks->EvtEndpointPurge = EvtEndpointPurge;
Callbacks->EvtEndpointStart = EvtEndpointStart;
Callbacks->EvtEndpointAbort = EvtEndpointAbort;
Callbacks->EvtEndpointReset = EvtEndpointReset;
Callbacks->EvtEndpointOkToCancelTransfers = EvtEndpointOkToCancelTransfers;
Callbacks->EvtEndpointStaticStreamsAdd = EvtEndpointStaticStreamsAdd;
Callbacks->EvtEndpointStaticStreamsEnable = EvtEndpointStaticStreamsEnable;
Callbacks->EvtEndpointStaticStreamsDisable = EvtEndpointStaticStreamsDisable;
}
typedef struct _UCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS {
ULONG Size;
PEVT_UCX_ENDPOINT_PURGE EvtEndpointPurge;
PEVT_UCX_ENDPOINT_START EvtEndpointStart;
PEVT_UCX_ENDPOINT_ABORT EvtEndpointAbort;
PEVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS EvtEndpointOkToCancelTransfers;
PEVT_UCX_DEFAULT_ENDPOINT_UPDATE EvtDefaultEndpointUpdate;
HANDLE Reserved1;
} UCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS, *PUCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS;
VOID
FORCEINLINE
UCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS_INIT
(
__out
PUCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS Callbacks,
__in
PEVT_UCX_ENDPOINT_PURGE EvtEndpointPurge,
__in
PEVT_UCX_ENDPOINT_START EvtEndpointStart,
__in
PEVT_UCX_ENDPOINT_ABORT EvtEndpointAbort,
__in
PEVT_UCX_ENDPOINT_OK_TO_CANCEL_TRANSFERS EvtEndpointOkToCancelTransfers,
__in
PEVT_UCX_DEFAULT_ENDPOINT_UPDATE EvtDefaultEndpointUpdate
)
{
RtlZeroMemory(Callbacks, sizeof(UCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS));
Callbacks->Size = sizeof(UCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS);
Callbacks->EvtEndpointPurge = EvtEndpointPurge;
Callbacks->EvtEndpointStart = EvtEndpointStart;
Callbacks->EvtEndpointAbort = EvtEndpointAbort;
Callbacks->EvtEndpointOkToCancelTransfers = EvtEndpointOkToCancelTransfers;
Callbacks->EvtDefaultEndpointUpdate = EvtDefaultEndpointUpdate;
}
typedef
_Must_inspect_result_
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
(*PFN_UCX_ENDPOINT_CREATE)(
__in
PUCX_GLOBALS,
__in
UCXUSBDEVICE,
__deref_inout_opt
PUCXENDPOINT_INIT*,
__in_opt
PWDF_OBJECT_ATTRIBUTES,
__out
UCXENDPOINT*
);
typedef
_Must_inspect_result_
__drv_maxIRQL(DISPATCH_LEVEL)
UCXSSTREAMS
(*PFN_UCX_ENDPOINT_GET_STATIC_STREAMS_REFERENCED)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT,
__in
PVOID
);
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_ENDPOINT_PURGE_COMPLETE)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT
);
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_ENDPOINT_ABORT_COMPLETE)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT
);
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_ENDPOINT_NO_PING_RESPONSE_ERROR)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT
);
typedef
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
(*PFN_UCX_ENDPOINT_NEED_TO_CANCEL_TRANSFERS)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT
);
typedef
VOID
(*PFN_UCX_ENDPOINT_INIT_SET_EVENT_CALLBACKS)(
__in
PUCX_GLOBALS,
__inout
PUCXENDPOINT_INIT,
__in
PUCX_ENDPOINT_EVENT_CALLBACKS
);
typedef
VOID
(*PFN_UCX_DEFAULT_ENDPOINT_INIT_SET_EVENT_CALLBACKS)(
__in
PUCX_GLOBALS,
__inout
PUCXENDPOINT_INIT,
__in
PUCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS
);
typedef
VOID
(*PFN_UCX_ENDPOINT_SET_WDFQUEUE)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT,
__in
WDFQUEUE
);
VOID
FORCEINLINE
UcxEndpointInitSetEventCallbacks(
__inout
PUCXENDPOINT_INIT EndpointInit,
__in
PUCX_ENDPOINT_EVENT_CALLBACKS EventCallbacks
)
{
(((PFN_UCX_ENDPOINT_INIT_SET_EVENT_CALLBACKS)
UcxClassFunctions[UcxEndpointInitSetEventCallbacksIndex])(UcxGlobals,
EndpointInit,
EventCallbacks));
}
VOID
FORCEINLINE
UcxDefaultEndpointInitSetEventCallbacks(
__inout
PUCXENDPOINT_INIT EndpointInit,
__in
PUCX_DEFAULT_ENDPOINT_EVENT_CALLBACKS EventCallbacks
)
{
(((PFN_UCX_DEFAULT_ENDPOINT_INIT_SET_EVENT_CALLBACKS)
UcxClassFunctions[UcxDefaultEndpointInitSetEventCallbacksIndex])(UcxGlobals,
EndpointInit,
EventCallbacks));
}
VOID
FORCEINLINE
UcxEndpointSetWdfIoQueue(
__in
UCXENDPOINT Endpoint,
__in
WDFQUEUE WdfQueue
)
{
(((PFN_UCX_ENDPOINT_SET_WDFQUEUE)
UcxClassFunctions[UcxEndpointSetWdfIoQueueIndex])(UcxGlobals,
Endpoint,
WdfQueue));
}
_Must_inspect_result_
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
FORCEINLINE
UcxEndpointCreate(
__in
UCXUSBDEVICE UsbDevice,
__deref_inout_opt
PUCXENDPOINT_INIT *EndpointInit,
__in_opt
PWDF_OBJECT_ATTRIBUTES Attributes,
__out
UCXENDPOINT *Endpoint
)
{
return(((PFN_UCX_ENDPOINT_CREATE)UcxClassFunctions[UcxEndpointCreateIndex])(UcxGlobals,
UsbDevice,
EndpointInit,
Attributes,
Endpoint));
}
_Must_inspect_result_
__drv_maxIRQL(DISPATCH_LEVEL)
UCXSSTREAMS
FORCEINLINE
UcxEndpointGetStaticStreamsReferenced(
__in
UCXENDPOINT Endpoint,
__in
PVOID Tag
)
{
return(((PFN_UCX_ENDPOINT_GET_STATIC_STREAMS_REFERENCED)
UcxClassFunctions[UcxEndpointGetStaticStreamsReferencedIndex])(UcxGlobals,
Endpoint,
Tag));
}
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxEndpointPurgeComplete(
__in
UCXENDPOINT Endpoint
)
{
((PFN_UCX_ENDPOINT_PURGE_COMPLETE)UcxClassFunctions[UcxEndpointPurgeCompleteIndex])(UcxGlobals,
Endpoint);
}
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxEndpointAbortComplete(
__in
UCXENDPOINT Endpoint
)
{
((PFN_UCX_ENDPOINT_ABORT_COMPLETE)UcxClassFunctions[UcxEndpointAbortCompleteIndex])(UcxGlobals,
Endpoint);
}
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxEndpointNoPingResponseError(
__in
UCXENDPOINT Endpoint
)
{
((PFN_UCX_ENDPOINT_NO_PING_RESPONSE_ERROR)
UcxClassFunctions[UcxEndpointNoPingResponseErrorIndex])(UcxGlobals,
Endpoint);
}
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FORCEINLINE
UcxEndpointNeedToCancelTransfers(
__in
UCXENDPOINT Endpoint
)
{
(((PFN_UCX_ENDPOINT_NEED_TO_CANCEL_TRANSFERS)
UcxClassFunctions[UcxEndpointNeedToCancelTransfersIndex])(UcxGlobals,
Endpoint));
}
/*-------------------Structures for UCXSSTREAMS creation----------------------*/
typedef struct _STREAM_INFO {
ULONG Size;
WDFQUEUE WdfQueue;
ULONG StreamId;
} STREAM_INFO, *PSTREAM_INFO;
VOID
FORCEINLINE
STREAM_INFO_INIT(
__out
PSTREAM_INFO StreamInfo,
__in
WDFQUEUE WdfQueue,
__in
ULONG StreamId
)
{
RtlZeroMemory(StreamInfo, sizeof(STREAM_INFO));
StreamInfo->Size = sizeof(STREAM_INFO);
StreamInfo->WdfQueue = WdfQueue;
StreamInfo->StreamId = StreamId;
}
typedef
VOID
(*PFN_UCX_STATIC_STREAMS_SET_STREAM_INFO)(
__in
PUCX_GLOBALS,
__in
UCXSSTREAMS,
__in
PSTREAM_INFO
);
typedef
_Must_inspect_result_
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
(*PFN_UCX_STATIC_STREAMS_CREATE)(
__in
PUCX_GLOBALS,
__in
UCXENDPOINT,
__deref_inout_opt
PUCXSSTREAMS_INIT*,
__in_opt
PWDF_OBJECT_ATTRIBUTES,
__out
UCXSSTREAMS*
);
VOID
FORCEINLINE
UcxStaticStreamsSetStreamInfo(
__in
UCXSSTREAMS StaticStreams,
__in
PSTREAM_INFO StreamInfo
)
{
((PFN_UCX_STATIC_STREAMS_SET_STREAM_INFO)
UcxClassFunctions[UcxStaticStreamsSetStreamInfoIndex])(UcxGlobals,
StaticStreams,
StreamInfo);
}
_Must_inspect_result_
__drv_requiresIRQL(PASSIVE_LEVEL)
NTSTATUS
FORCEINLINE
UcxStaticStreamsCreate(
__in
UCXENDPOINT Endpoint,
__deref_inout_opt
PUCXSSTREAMS_INIT *StaticStreamsInit,
__in_opt
PWDF_OBJECT_ATTRIBUTES Attributes,
__out
UCXSSTREAMS *StaticStreams
)
{
return(((PFN_UCX_STATIC_STREAMS_CREATE)UcxClassFunctions[UcxStaticStreamsCreateIndex])
(UcxGlobals,
Endpoint,
StaticStreamsInit,
Attributes,
StaticStreams));
}
#endif // if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#endif // __UCX_CLASS_H__
|
13be81e8364a9dd8c885cbd916b0e55f5a8a24c3
|
0a3363c1d3d5867f1340de49b84eab84defa3fb8
|
/libs/ne10/modules/dsp/hidden/NE10_fft_int16.neonintrinsic.c
|
8971faff31f95078a91c55de5dadc939c8ad4ce3
|
[
"MIT"
] |
permissive
|
odevices/er-301
|
b09bc53f1b11ff1bba2be8a51220ebfe932dd935
|
3a7b592fe5d223d5a96b2d8e90b578b23bbdabe5
|
refs/heads/develop
| 2023-02-17T16:31:01.764589
| 2023-02-14T06:55:32
| 2023-02-14T06:55:32
| 343,000,824
| 124
| 26
|
MIT
| 2023-02-14T06:55:34
| 2021-02-28T02:06:10
|
C
|
UTF-8
|
C
| false
| false
| 60,347
|
c
|
NE10_fft_int16.neonintrinsic.c
|
/*
* Copyright 2013-15 ARM Limited and Contributors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of ARM Limited nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY ARM LIMITED AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ARM LIMITED AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* NE10 Library : dsp/NE10_fft_int16.neon.c
*/
#include <hal/neon.h>
#include "NE10_types.h"
#include "NE10_macros.h"
#include "NE10_fft.h"
#define FFT4_FS_START \
ne10_int16_t s0_r, s0_i, s1_r, s1_i, s2_r, s2_i; \
ne10_int16_t tmp_r, tmp_i;
#define FFT4_FS \
s2_r = Fin[0].r - Fin[2].r; \
s2_i = Fin[0].i - Fin[2].i; \
tmp_r = Fin[0].r + Fin[2].r; \
tmp_i = Fin[0].i + Fin[2].i; \
s0_r = Fin[1].r + Fin[3].r; \
s0_i = Fin[1].i + Fin[3].i; \
s1_r = Fin[1].r - Fin[3].r; \
s1_i = Fin[1].i - Fin[3].i;
#define FFT4_FS_SCALED \
s2_r = (Fin[0].r - Fin[2].r) >> 2; \
s2_i = (Fin[0].i - Fin[2].i) >> 2; \
tmp_r = (Fin[0].r + Fin[2].r) >> 2; \
tmp_i = (Fin[0].i + Fin[2].i) >> 2; \
s0_r = (Fin[1].r + Fin[3].r) >> 2; \
s0_i = (Fin[1].i + Fin[3].i) >> 2; \
s1_r = (Fin[1].r - Fin[3].r) >> 2; \
s1_i = (Fin[1].i - Fin[3].i) >> 2;
#define FFT4_FWD_LS \
Fout[2].r = tmp_r - s0_r; \
Fout[2].i = tmp_i - s0_i; \
Fout[0].r = tmp_r + s0_r; \
Fout[0].i = tmp_i + s0_i; \
Fout[1].r = s2_r + s1_i; \
Fout[1].i = s2_i - s1_r; \
Fout[3].r = s2_r - s1_i; \
Fout[3].i = s2_i + s1_r;
#define FFT4_INV_LS \
Fout[2].r = tmp_r - s0_r; \
Fout[2].i = tmp_i - s0_i; \
Fout[0].r = tmp_r + s0_r; \
Fout[0].i = tmp_i + s0_i; \
Fout[1].r = s2_r - s1_i; \
Fout[1].i = s2_i + s1_r; \
Fout[3].r = s2_r + s1_i; \
Fout[3].i = s2_i - s1_r;
static inline void ne10_fft4_forward_int16_unscaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT4_FS_START
FFT4_FS
FFT4_FWD_LS
}
static inline void ne10_fft4_backward_int16_unscaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT4_FS_START
FFT4_FS
FFT4_INV_LS
}
static inline void ne10_fft4_forward_int16_scaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT4_FS_START
FFT4_FS_SCALED
FFT4_FWD_LS
}
static inline void ne10_fft4_backward_int16_scaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT4_FS_START
FFT4_FS_SCALED
FFT4_INV_LS
}
#define FFT8_FS_START \
ne10_int16_t s0_r, s0_i, s1_r, s1_i, s2_r, s2_i, s3_r, s3_i, s4_r, s4_i, s5_r, s5_i, s6_r, s6_i, s7_r, s7_i; \
ne10_int16_t t0_r, t0_i, t1_r, t1_i, t2_r, t2_i, t3_r, t3_i, t4_r, t4_i, t5_r, t5_i; \
const ne10_int16_t TW_81 = 23169;
#define FFT8_FS \
s0_r = Fin[0].r + Fin[4].r; \
s0_i = Fin[0].i + Fin[4].i; \
s1_r = Fin[0].r - Fin[4].r; \
s1_i = Fin[0].i - Fin[4].i; \
s2_r = Fin[1].r + Fin[5].r; \
s2_i = Fin[1].i + Fin[5].i; \
s3_r = Fin[1].r - Fin[5].r; \
s3_i = Fin[1].i - Fin[5].i; \
s4_r = Fin[2].r + Fin[6].r; \
s4_i = Fin[2].i + Fin[6].i; \
s5_r = Fin[2].r - Fin[6].r; \
s5_i = Fin[2].i - Fin[6].i; \
s6_r = Fin[3].r + Fin[7].r; \
s6_i = Fin[3].i + Fin[7].i; \
s7_r = Fin[3].r - Fin[7].r; \
s7_i = Fin[3].i - Fin[7].i;
#define FFT8_FS_SCALED \
s0_r = (Fin[0].r + Fin[4].r) >> 3; \
s0_i = (Fin[0].i + Fin[4].i) >> 3; \
s1_r = (Fin[0].r - Fin[4].r) >> 3; \
s1_i = (Fin[0].i - Fin[4].i) >> 3; \
s2_r = (Fin[1].r + Fin[5].r) >> 3; \
s2_i = (Fin[1].i + Fin[5].i) >> 3; \
s3_r = (Fin[1].r - Fin[5].r) >> 3; \
s3_i = (Fin[1].i - Fin[5].i) >> 3; \
s4_r = (Fin[2].r + Fin[6].r) >> 3; \
s4_i = (Fin[2].i + Fin[6].i) >> 3; \
s5_r = (Fin[2].r - Fin[6].r) >> 3; \
s5_i = (Fin[2].i - Fin[6].i) >> 3; \
s6_r = (Fin[3].r + Fin[7].r) >> 3; \
s6_i = (Fin[3].i + Fin[7].i) >> 3; \
s7_r = (Fin[3].r - Fin[7].r) >> 3; \
s7_i = (Fin[3].i - Fin[7].i) >> 3;
#define FFT8_FWD_LS \
t0_r = s0_r - s4_r; \
t0_i = s0_i - s4_i; \
t1_r = s0_r + s4_r; \
t1_i = s0_i + s4_i; \
t2_r = s2_r + s6_r; \
t2_i = s2_i + s6_i; \
t3_r = s2_r - s6_r; \
t3_i = s2_i - s6_i; \
Fout[0].r = t1_r + t2_r; \
Fout[0].i = t1_i + t2_i; \
Fout[4].r = t1_r - t2_r; \
Fout[4].i = t1_i - t2_i; \
Fout[2].r = t0_r + t3_i; \
Fout[2].i = t0_i - t3_r; \
Fout[6].r = t0_r - t3_i; \
Fout[6].i = t0_i + t3_r; \
t4_r = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s3_r + s3_i) * TW_81) >> NE10_F2I16_SHIFT); \
t4_i = - (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s3_r - s3_i) * TW_81) >> NE10_F2I16_SHIFT); \
t5_r = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s7_r - s7_i) * TW_81) >> NE10_F2I16_SHIFT); \
t5_i = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s7_r + s7_i) * TW_81) >> NE10_F2I16_SHIFT); \
t0_r = s1_r - s5_i; \
t0_i = s1_i + s5_r; \
t1_r = s1_r + s5_i; \
t1_i = s1_i - s5_r; \
t2_r = t4_r - t5_r; \
t2_i = t4_i - t5_i; \
t3_r = t4_r + t5_r; \
t3_i = t4_i + t5_i; \
Fout[1].r = t1_r + t2_r; \
Fout[1].i = t1_i + t2_i; \
Fout[5].r = t1_r - t2_r; \
Fout[5].i = t1_i - t2_i; \
Fout[3].r = t0_r + t3_i; \
Fout[3].i = t0_i - t3_r; \
Fout[7].r = t0_r - t3_i; \
Fout[7].i = t0_i + t3_r;
#define FFT8_INV_LS \
t0_r = s0_r - s4_r; \
t0_i = s0_i - s4_i; \
t1_r = s0_r + s4_r; \
t1_i = s0_i + s4_i; \
t2_r = s2_r + s6_r; \
t2_i = s2_i + s6_i; \
t3_r = s2_r - s6_r; \
t3_i = s2_i - s6_i; \
Fout[0].r = t1_r + t2_r; \
Fout[0].i = t1_i + t2_i; \
Fout[4].r = t1_r - t2_r; \
Fout[4].i = t1_i - t2_i; \
Fout[2].r = t0_r - t3_i; \
Fout[2].i = t0_i + t3_r; \
Fout[6].r = t0_r + t3_i; \
Fout[6].i = t0_i - t3_r; \
t4_r = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s3_r - s3_i) * TW_81) >> NE10_F2I16_SHIFT); \
t4_i = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s3_r + s3_i) * TW_81) >> NE10_F2I16_SHIFT); \
t5_r = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s7_r + s7_i) * TW_81) >> NE10_F2I16_SHIFT); \
t5_i = - (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) (s7_r - s7_i) * TW_81) >> NE10_F2I16_SHIFT); \
t0_r = s1_r + s5_i; \
t0_i = s1_i - s5_r; \
t1_r = s1_r - s5_i; \
t1_i = s1_i + s5_r; \
t2_r = t4_r - t5_r; \
t2_i = t4_i - t5_i; \
t3_r = t4_r + t5_r; \
t3_i = t4_i + t5_i; \
Fout[1].r = t1_r + t2_r; \
Fout[1].i = t1_i + t2_i; \
Fout[5].r = t1_r - t2_r; \
Fout[5].i = t1_i - t2_i; \
Fout[3].r = t0_r - t3_i; \
Fout[3].i = t0_i + t3_r; \
Fout[7].r = t0_r + t3_i; \
Fout[7].i = t0_i - t3_r;
static inline void ne10_fft8_forward_int16_unscaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT8_FS_START
FFT8_FS
FFT8_FWD_LS
}
static inline void ne10_fft8_backward_int16_unscaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT8_FS_START
FFT8_FS
FFT8_INV_LS
}
static inline void ne10_fft8_forward_int16_scaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT8_FS_START
FFT8_FS_SCALED
FFT8_FWD_LS
}
static inline void ne10_fft8_backward_int16_scaled (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin)
{
FFT8_FS_START
FFT8_FS_SCALED
FFT8_INV_LS
}
#define RADIX8x4_START \
ne10_int32_t f_count; \
ne10_int32_t src_step = stride << 1; \
const ne10_int16_t TW_81 = 23169; \
const ne10_int16_t TW_81N = -23169; \
int16_t *p_src, *p_dst; \
int16x4x2_t d2_in0, d2_in1, d2_in2, d2_in3, d2_in4, d2_in5, d2_in6, d2_in7; \
int16x4_t d_sin0_r, d_sin0_i, d_sin1_r, d_sin1_i, d_sin2_r, d_sin2_i, d_sin3_r, d_sin3_i; \
int16x4_t d_sin4_r, d_sin4_i, d_sin5_r, d_sin5_i, d_sin6_r, d_sin6_i, d_sin7_r, d_sin7_i; \
int16x4_t d_s3_r, d_s3_i, d_s5_r, d_s5_i, d_s7_r, d_s7_i; \
int16x4_t d_s8_r, d_s8_i, d_s9_r, d_s9_i, d_s10_r, d_s10_i, d_s11_r, d_s11_i; \
int16x4_t d_s12_r, d_s12_i, d_s13_r, d_s13_i, d_s14_r, d_s14_i, d_s15_r, d_s15_i; \
int16x4_t d_out0_r, d_out0_i, d_out1_r, d_out1_i, d_out2_r, d_out2_i, d_out3_r, d_out3_i; \
int16x4_t d_out4_r, d_out4_i, d_out5_r, d_out5_i, d_out6_r, d_out6_i, d_out7_r, d_out7_i; \
int16x4x2_t d2_out0, d2_out1, d2_out2, d2_out3, d2_out4, d2_out5, d2_out6, d2_out7; \
int16x8x2_t q2_tmp0, q2_tmp1, q2_tmp2, q2_tmp3; \
int32x4x2_t q2_tmp4, q2_tmp5, q2_tmp6, q2_tmp7; \
int16x4_t d_tw_81, d_tw_81n; \
p_src = (int16_t *) Fin; \
p_dst = (int16_t *) Fout;
#define RADIX8x4_LOAD \
d2_in0 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in2 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in4 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in6 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in1 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in3 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in5 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in7 = vld2_s16 (p_src); \
p_src += src_step;
#define RADIX8x4_STORE \
q2_tmp0 = vtrnq_s16 (vcombine_s16(d_out0_r, d_out0_i), vcombine_s16(d_out1_r, d_out1_i)); \
q2_tmp1 = vtrnq_s16 (vcombine_s16(d_out2_r, d_out2_i), vcombine_s16(d_out3_r, d_out3_i)); \
q2_tmp2 = vtrnq_s16 (vcombine_s16(d_out4_r, d_out4_i), vcombine_s16(d_out5_r, d_out5_i)); \
q2_tmp3 = vtrnq_s16 (vcombine_s16(d_out6_r, d_out6_i), vcombine_s16(d_out7_r, d_out7_i)); \
q2_tmp4 = vtrnq_s32 (vreinterpretq_s32_s16(q2_tmp0.val[0]), vreinterpretq_s32_s16(q2_tmp1.val[0])); \
q2_tmp5 = vtrnq_s32 (vreinterpretq_s32_s16(q2_tmp0.val[1]), vreinterpretq_s32_s16(q2_tmp1.val[1])); \
q2_tmp6 = vtrnq_s32 (vreinterpretq_s32_s16(q2_tmp2.val[0]), vreinterpretq_s32_s16(q2_tmp3.val[0])); \
q2_tmp7 = vtrnq_s32 (vreinterpretq_s32_s16(q2_tmp2.val[1]), vreinterpretq_s32_s16(q2_tmp3.val[1])); \
d2_out0.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp4.val[0])); \
d2_out0.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp4.val[0])); \
d2_out1.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp6.val[0])); \
d2_out1.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp6.val[0])); \
d2_out2.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp5.val[0])); \
d2_out2.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp5.val[0])); \
d2_out3.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp7.val[0])); \
d2_out3.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp7.val[0])); \
d2_out4.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp4.val[1])); \
d2_out4.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp4.val[1])); \
d2_out5.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp6.val[1])); \
d2_out5.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp6.val[1])); \
d2_out6.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp5.val[1])); \
d2_out6.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp5.val[1])); \
d2_out7.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp7.val[1])); \
d2_out7.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp7.val[1])); \
vst2_s16 (p_dst, d2_out0); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out1); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out2); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out3); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out4); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out5); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out6); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out7); \
p_dst += 8; \
p_src = p_src - src_step * 8 + 8;
#define RADIX8x4_FS_S0 \
d_sin0_r = vadd_s16 (d2_in0.val[0], d2_in1.val[0]); \
d_sin0_i = vadd_s16 (d2_in0.val[1], d2_in1.val[1]); \
d_sin1_r = vsub_s16 (d2_in0.val[0], d2_in1.val[0]); \
d_sin1_i = vsub_s16 (d2_in0.val[1], d2_in1.val[1]); \
d_sin2_r = vadd_s16 (d2_in2.val[0], d2_in3.val[0]); \
d_sin2_i = vadd_s16 (d2_in2.val[1], d2_in3.val[1]); \
d_sin3_r = vsub_s16 (d2_in2.val[0], d2_in3.val[0]); \
d_sin3_i = vsub_s16 (d2_in2.val[1], d2_in3.val[1]); \
d_sin4_r = vadd_s16 (d2_in4.val[0], d2_in5.val[0]); \
d_sin4_i = vadd_s16 (d2_in4.val[1], d2_in5.val[1]); \
d_sin5_r = vsub_s16 (d2_in4.val[0], d2_in5.val[0]); \
d_sin5_i = vsub_s16 (d2_in4.val[1], d2_in5.val[1]); \
d_sin6_r = vadd_s16 (d2_in6.val[0], d2_in7.val[0]); \
d_sin6_i = vadd_s16 (d2_in6.val[1], d2_in7.val[1]); \
d_sin7_r = vsub_s16 (d2_in6.val[0], d2_in7.val[0]); \
d_sin7_i = vsub_s16 (d2_in6.val[1], d2_in7.val[1]);
#define RADIX8x4_FWD_S357 \
d_tw_81 = vdup_n_s16 (TW_81); \
d_tw_81n = vdup_n_s16 (TW_81N); \
d_s5_r = d_sin5_i; \
d_s5_i = vneg_s16 (d_sin5_r); \
d_s3_r = vadd_s16 (d_sin3_r, d_sin3_i); \
d_s3_i = vsub_s16 (d_sin3_i, d_sin3_r); \
d_s7_r = vsub_s16 (d_sin7_r, d_sin7_i); \
d_s7_i = vadd_s16 (d_sin7_i, d_sin7_r); \
d_s3_r = vqdmulh_s16 (d_s3_r, d_tw_81); \
d_s3_i = vqdmulh_s16 (d_s3_i, d_tw_81); \
d_s7_r = vqdmulh_s16 (d_s7_r, d_tw_81n); \
d_s7_i = vqdmulh_s16 (d_s7_i, d_tw_81n);
#define RADIX8x4_INV_S357 \
d_tw_81 = vdup_n_s16 (TW_81); \
d_tw_81n = vdup_n_s16 (TW_81N); \
d_s5_r = vneg_s16 (d_sin5_i); \
d_s5_i = d_sin5_r; \
d_s3_r = vsub_s16 (d_sin3_r, d_sin3_i); \
d_s3_i = vadd_s16 (d_sin3_i, d_sin3_r); \
d_s7_r = vadd_s16 (d_sin7_r, d_sin7_i); \
d_s7_i = vsub_s16 (d_sin7_i, d_sin7_r); \
d_s3_r = vqdmulh_s16 (d_s3_r, d_tw_81); \
d_s3_i = vqdmulh_s16 (d_s3_i, d_tw_81); \
d_s7_r = vqdmulh_s16 (d_s7_r, d_tw_81n); \
d_s7_i = vqdmulh_s16 (d_s7_i, d_tw_81n);
#define RADIX8x4_LS_02 \
d_s8_r = vadd_s16 (d_sin0_r, d_sin4_r); \
d_s8_i = vadd_s16 (d_sin0_i, d_sin4_i); \
d_s9_r = vadd_s16 (d_sin1_r, d_s5_r); \
d_s9_i = vadd_s16 (d_sin1_i, d_s5_i); \
d_s10_r = vsub_s16 (d_sin0_r, d_sin4_r); \
d_s10_i = vsub_s16 (d_sin0_i, d_sin4_i); \
d_s11_r = vsub_s16 (d_sin1_r, d_s5_r); \
d_s11_i = vsub_s16 (d_sin1_i, d_s5_i); \
d_s12_r = vadd_s16 (d_sin2_r, d_sin6_r); \
d_s12_i = vadd_s16 (d_sin2_i, d_sin6_i); \
d_s13_r = vadd_s16 (d_s3_r, d_s7_r); \
d_s13_i = vadd_s16 (d_s3_i, d_s7_i); \
d_s14_r = vsub_s16 (d_sin2_r, d_sin6_r); \
d_s14_i = vsub_s16 (d_sin2_i, d_sin6_i); \
d_s15_r = vsub_s16 (d_s3_r, d_s7_r); \
d_s15_i = vsub_s16 (d_s3_i, d_s7_i); \
d_out4_r = vsub_s16 (d_s8_r, d_s12_r); \
d_out4_i = vsub_s16 (d_s8_i, d_s12_i); \
d_out5_r = vsub_s16 (d_s9_r, d_s13_r); \
d_out5_i = vsub_s16 (d_s9_i, d_s13_i); \
d_out0_r = vadd_s16 (d_s8_r, d_s12_r); \
d_out0_i = vadd_s16 (d_s8_i, d_s12_i); \
d_out1_r = vadd_s16 (d_s9_r, d_s13_r); \
d_out1_i = vadd_s16 (d_s9_i, d_s13_i);
#define RADIX8x4_FS_S0_SCALED \
d_sin0_r = vhadd_s16 (d2_in0.val[0], d2_in1.val[0]); \
d_sin0_i = vhadd_s16 (d2_in0.val[1], d2_in1.val[1]); \
d_sin1_r = vhsub_s16 (d2_in0.val[0], d2_in1.val[0]); \
d_sin1_i = vhsub_s16 (d2_in0.val[1], d2_in1.val[1]); \
d_sin2_r = vhadd_s16 (d2_in2.val[0], d2_in3.val[0]); \
d_sin2_i = vhadd_s16 (d2_in2.val[1], d2_in3.val[1]); \
d_sin3_r = vhsub_s16 (d2_in2.val[0], d2_in3.val[0]); \
d_sin3_i = vhsub_s16 (d2_in2.val[1], d2_in3.val[1]); \
d_sin4_r = vhadd_s16 (d2_in4.val[0], d2_in5.val[0]); \
d_sin4_i = vhadd_s16 (d2_in4.val[1], d2_in5.val[1]); \
d_sin5_r = vhsub_s16 (d2_in4.val[0], d2_in5.val[0]); \
d_sin5_i = vhsub_s16 (d2_in4.val[1], d2_in5.val[1]); \
d_sin6_r = vhadd_s16 (d2_in6.val[0], d2_in7.val[0]); \
d_sin6_i = vhadd_s16 (d2_in6.val[1], d2_in7.val[1]); \
d_sin7_r = vhsub_s16 (d2_in6.val[0], d2_in7.val[0]); \
d_sin7_i = vhsub_s16 (d2_in6.val[1], d2_in7.val[1]);
#define RADIX8x4_LS_02_SCALED \
d_s8_r = vhadd_s16 (d_sin0_r, d_sin4_r); \
d_s8_i = vhadd_s16 (d_sin0_i, d_sin4_i); \
d_s9_r = vhadd_s16 (d_sin1_r, d_s5_r); \
d_s9_i = vhadd_s16 (d_sin1_i, d_s5_i); \
d_s10_r = vhsub_s16 (d_sin0_r, d_sin4_r); \
d_s10_i = vhsub_s16 (d_sin0_i, d_sin4_i); \
d_s11_r = vhsub_s16 (d_sin1_r, d_s5_r); \
d_s11_i = vhsub_s16 (d_sin1_i, d_s5_i); \
d_s12_r = vhadd_s16 (d_sin2_r, d_sin6_r); \
d_s12_i = vhadd_s16 (d_sin2_i, d_sin6_i); \
d_s13_r = vhadd_s16 (d_s3_r, d_s7_r); \
d_s13_i = vhadd_s16 (d_s3_i, d_s7_i); \
d_s14_r = vhsub_s16 (d_sin2_r, d_sin6_r); \
d_s14_i = vhsub_s16 (d_sin2_i, d_sin6_i); \
d_s15_r = vhsub_s16 (d_s3_r, d_s7_r); \
d_s15_i = vhsub_s16 (d_s3_i, d_s7_i); \
d_out4_r = vhsub_s16 (d_s8_r, d_s12_r); \
d_out4_i = vhsub_s16 (d_s8_i, d_s12_i); \
d_out5_r = vhsub_s16 (d_s9_r, d_s13_r); \
d_out5_i = vhsub_s16 (d_s9_i, d_s13_i); \
d_out0_r = vhadd_s16 (d_s8_r, d_s12_r); \
d_out0_i = vhadd_s16 (d_s8_i, d_s12_i); \
d_out1_r = vhadd_s16 (d_s9_r, d_s13_r); \
d_out1_i = vhadd_s16 (d_s9_i, d_s13_i);
static inline void ne10_radix8x4_forward_unscaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX8x4_START
for (f_count = 0; f_count < stride; f_count += 4)
{
RADIX8x4_LOAD
RADIX8x4_FS_S0
// radix 4 butterfly without twiddles
RADIX8x4_FWD_S357
RADIX8x4_LS_02
d_out2_r = vadd_s16 (d_s10_r, d_s14_i);
d_out2_i = vsub_s16 (d_s10_i, d_s14_r);
d_out3_r = vadd_s16 (d_s11_r, d_s15_i);
d_out3_i = vsub_s16 (d_s11_i, d_s15_r);
d_out6_r = vsub_s16 (d_s10_r, d_s14_i);
d_out6_i = vadd_s16 (d_s10_i, d_s14_r);
d_out7_r = vsub_s16 (d_s11_r, d_s15_i);
d_out7_i = vadd_s16 (d_s11_i, d_s15_r);
RADIX8x4_STORE
} // f_count
}
static inline void ne10_radix8x4_backward_unscaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX8x4_START
for (f_count = 0; f_count < stride; f_count += 4)
{
RADIX8x4_LOAD
RADIX8x4_FS_S0
// radix 4 butterfly without twiddles
RADIX8x4_INV_S357
RADIX8x4_LS_02
d_out2_r = vsub_s16 (d_s10_r, d_s14_i);
d_out2_i = vadd_s16 (d_s10_i, d_s14_r);
d_out3_r = vsub_s16 (d_s11_r, d_s15_i);
d_out3_i = vadd_s16 (d_s11_i, d_s15_r);
d_out6_r = vadd_s16 (d_s10_r, d_s14_i);
d_out6_i = vsub_s16 (d_s10_i, d_s14_r);
d_out7_r = vadd_s16 (d_s11_r, d_s15_i);
d_out7_i = vsub_s16 (d_s11_i, d_s15_r);
RADIX8x4_STORE
} // f_count
}
static inline void ne10_radix8x4_forward_scaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX8x4_START
for (f_count = 0; f_count < stride; f_count += 4)
{
RADIX8x4_LOAD
RADIX8x4_FS_S0_SCALED
// radix 4 butterfly without twiddles
RADIX8x4_FWD_S357
RADIX8x4_LS_02_SCALED
d_out2_r = vhadd_s16 (d_s10_r, d_s14_i);
d_out2_i = vhsub_s16 (d_s10_i, d_s14_r);
d_out3_r = vhadd_s16 (d_s11_r, d_s15_i);
d_out3_i = vhsub_s16 (d_s11_i, d_s15_r);
d_out6_r = vhsub_s16 (d_s10_r, d_s14_i);
d_out6_i = vhadd_s16 (d_s10_i, d_s14_r);
d_out7_r = vhsub_s16 (d_s11_r, d_s15_i);
d_out7_i = vhadd_s16 (d_s11_i, d_s15_r);
RADIX8x4_STORE
} // f_count
}
static inline void ne10_radix8x4_backward_scaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX8x4_START
for (f_count = 0; f_count < stride; f_count += 4)
{
RADIX8x4_LOAD
RADIX8x4_FS_S0_SCALED
// radix 4 butterfly without twiddles
RADIX8x4_INV_S357
RADIX8x4_LS_02_SCALED
d_out2_r = vhsub_s16 (d_s10_r, d_s14_i);
d_out2_i = vhadd_s16 (d_s10_i, d_s14_r);
d_out3_r = vhsub_s16 (d_s11_r, d_s15_i);
d_out3_i = vhadd_s16 (d_s11_i, d_s15_r);
d_out6_r = vhadd_s16 (d_s10_r, d_s14_i);
d_out6_i = vhsub_s16 (d_s10_i, d_s14_r);
d_out7_r = vhadd_s16 (d_s11_r, d_s15_i);
d_out7_i = vhsub_s16 (d_s11_i, d_s15_r);
RADIX8x4_STORE
} // f_count
}
#define RADIX4x4_WITHOUT_TW_START \
ne10_int32_t f_count; \
ne10_int32_t src_step = stride << 1; \
int16_t *p_src, *p_dst; \
int16x4x2_t d2_in0, d2_in1, d2_in2, d2_in3; \
int16x4_t d_s0_r, d_s0_i, d_s1_r, d_s1_i, d_s2_r, d_s2_i, d_s3_r, d_s3_i; \
int16x4_t d_out0_r, d_out0_i, d_out1_r, d_out1_i, d_out2_r, d_out2_i, d_out3_r, d_out3_i; \
int16x4x2_t d2_out0, d2_out1, d2_out2, d2_out3; \
int16x8x2_t q2_tmp0, q2_tmp1; \
int32x4x2_t q2_tmp2, q2_tmp3; \
p_src = (int16_t *) Fin; \
p_dst = (int16_t *) Fout;
#define RADIX4x4_WITHOUT_TW_LOAD \
d2_in0 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in1 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in2 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in3 = vld2_s16 (p_src); \
p_src += src_step;
#define RADIX4x4_WITHOUT_TW_STORE \
q2_tmp0 = vtrnq_s16 (vcombine_s16(d_out0_r, d_out0_i), vcombine_s16(d_out1_r, d_out1_i)); \
q2_tmp1 = vtrnq_s16 (vcombine_s16(d_out2_r, d_out2_i), vcombine_s16(d_out3_r, d_out3_i)); \
q2_tmp2 = vtrnq_s32 (vreinterpretq_s32_s16(q2_tmp0.val[0]), vreinterpretq_s32_s16(q2_tmp1.val[0])); \
q2_tmp3 = vtrnq_s32 (vreinterpretq_s32_s16(q2_tmp0.val[1]), vreinterpretq_s32_s16(q2_tmp1.val[1])); \
d2_out0.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp2.val[0])); \
d2_out0.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp2.val[0])); \
d2_out1.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp3.val[0])); \
d2_out1.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp3.val[0])); \
d2_out2.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp2.val[1])); \
d2_out2.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp2.val[1])); \
d2_out3.val[0] = vget_low_s16 (vreinterpretq_s16_s32(q2_tmp3.val[1])); \
d2_out3.val[1] = vget_high_s16 (vreinterpretq_s16_s32(q2_tmp3.val[1])); \
vst2_s16 (p_dst, d2_out0); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out1); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out2); \
p_dst += 8; \
vst2_s16 (p_dst, d2_out3); \
p_dst += 8; \
p_src = p_src - src_step * 4 + 8;
#define RADIX4x4_WITHOUT_TW_S0 \
d_s0_r = vadd_s16 (d2_in0.val[0], d2_in2.val[0]); \
d_s0_i = vadd_s16 (d2_in0.val[1], d2_in2.val[1]); \
d_s1_r = vsub_s16 (d2_in0.val[0], d2_in2.val[0]); \
d_s1_i = vsub_s16 (d2_in0.val[1], d2_in2.val[1]); \
d_s2_r = vadd_s16 (d2_in1.val[0], d2_in3.val[0]); \
d_s2_i = vadd_s16 (d2_in1.val[1], d2_in3.val[1]); \
d_s3_r = vsub_s16 (d2_in1.val[0], d2_in3.val[0]); \
d_s3_i = vsub_s16 (d2_in1.val[1], d2_in3.val[1]); \
d_out2_r = vsub_s16 (d_s0_r, d_s2_r); \
d_out2_i = vsub_s16 (d_s0_i, d_s2_i); \
d_out0_r = vadd_s16 (d_s0_r, d_s2_r); \
d_out0_i = vadd_s16 (d_s0_i, d_s2_i);
#define RADIX4x4_WITHOUT_TW_S0_SCALED \
d_s0_r = vhadd_s16 (d2_in0.val[0], d2_in2.val[0]); \
d_s0_i = vhadd_s16 (d2_in0.val[1], d2_in2.val[1]); \
d_s1_r = vhsub_s16 (d2_in0.val[0], d2_in2.val[0]); \
d_s1_i = vhsub_s16 (d2_in0.val[1], d2_in2.val[1]); \
d_s2_r = vhadd_s16 (d2_in1.val[0], d2_in3.val[0]); \
d_s2_i = vhadd_s16 (d2_in1.val[1], d2_in3.val[1]); \
d_s3_r = vhsub_s16 (d2_in1.val[0], d2_in3.val[0]); \
d_s3_i = vhsub_s16 (d2_in1.val[1], d2_in3.val[1]); \
d_out2_r = vhsub_s16 (d_s0_r, d_s2_r); \
d_out2_i = vhsub_s16 (d_s0_i, d_s2_i); \
d_out0_r = vhadd_s16 (d_s0_r, d_s2_r); \
d_out0_i = vhadd_s16 (d_s0_i, d_s2_i);
static inline void ne10_radix4x4_without_twiddles_forward_unscaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX4x4_WITHOUT_TW_START
for (f_count = 0; f_count < stride; f_count += 4)
{
// load
RADIX4x4_WITHOUT_TW_LOAD
// radix 4 butterfly without twiddles
RADIX4x4_WITHOUT_TW_S0
d_out1_r = vadd_s16 (d_s1_r, d_s3_i);
d_out1_i = vsub_s16 (d_s1_i, d_s3_r);
d_out3_r = vsub_s16 (d_s1_r, d_s3_i);
d_out3_i = vadd_s16 (d_s1_i, d_s3_r);
RADIX4x4_WITHOUT_TW_STORE
}
}
static inline void ne10_radix4x4_without_twiddles_backward_unscaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX4x4_WITHOUT_TW_START
for (f_count = 0; f_count < stride; f_count += 4)
{
// load
RADIX4x4_WITHOUT_TW_LOAD
// radix 4 butterfly without twiddles
RADIX4x4_WITHOUT_TW_S0
d_out1_r = vsub_s16 (d_s1_r, d_s3_i);
d_out1_i = vadd_s16 (d_s1_i, d_s3_r);
d_out3_r = vadd_s16 (d_s1_r, d_s3_i);
d_out3_i = vsub_s16 (d_s1_i, d_s3_r);
RADIX4x4_WITHOUT_TW_STORE
}
}
static inline void ne10_radix4x4_without_twiddles_forward_scaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX4x4_WITHOUT_TW_START
for (f_count = 0; f_count < stride; f_count += 4)
{
// load
RADIX4x4_WITHOUT_TW_LOAD
// radix 4 butterfly without twiddles
RADIX4x4_WITHOUT_TW_S0_SCALED
d_out1_r = vhadd_s16 (d_s1_r, d_s3_i);
d_out1_i = vhsub_s16 (d_s1_i, d_s3_r);
d_out3_r = vhsub_s16 (d_s1_r, d_s3_i);
d_out3_i = vhadd_s16 (d_s1_i, d_s3_r);
RADIX4x4_WITHOUT_TW_STORE
}
}
static inline void ne10_radix4x4_without_twiddles_backward_scaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_int32_t stride)
{
RADIX4x4_WITHOUT_TW_START
for (f_count = 0; f_count < stride; f_count += 4)
{
// load
RADIX4x4_WITHOUT_TW_LOAD
// radix 4 butterfly without twiddles
RADIX4x4_WITHOUT_TW_S0_SCALED
d_out1_r = vhsub_s16 (d_s1_r, d_s3_i);
d_out1_i = vhadd_s16 (d_s1_i, d_s3_r);
d_out3_r = vhadd_s16 (d_s1_r, d_s3_i);
d_out3_i = vhsub_s16 (d_s1_i, d_s3_r);
RADIX4x4_WITHOUT_TW_STORE
}
}
#define RADIX4x4_WITH_TW_START \
ne10_int32_t m_count; \
ne10_int32_t src_step = src_stride << 1; \
ne10_int32_t dst_step = dst_stride << 1; \
ne10_int32_t tw_step = mstride << 1; \
int16_t *p_src, *p_dst, *p_tw; \
int16x4x2_t d2_in0, d2_in1, d2_in2, d2_in3; \
int16x4x2_t d2_tw0, d2_tw1, d2_tw2; \
int16x4_t d_s1_r, d_s1_i, d_s2_r, d_s2_i, d_s3_r, d_s3_i; \
int16x4_t d_tmp0, d_tmp1, d_tmp2, d_tmp3, d_tmp4, d_tmp5; \
int16x4_t d_s4_r, d_s4_i, d_s5_r, d_s5_i, d_s6_r, d_s6_i, d_s7_r, d_s7_i; \
int16x4x2_t d2_out0, d2_out1, d2_out2, d2_out3; \
p_src = (int16_t *) Fin; \
p_dst = (int16_t *) Fout; \
p_tw = (int16_t *) tw;
#define RADIX4x4_WITH_TW_LOAD \
d2_in0 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in1 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in2 = vld2_s16 (p_src); \
p_src += src_step; \
d2_in3 = vld2_s16 (p_src); \
p_src += src_step; \
d2_tw0 = vld2_s16 (p_tw); \
p_tw += tw_step; \
d2_tw1 = vld2_s16 (p_tw); \
p_tw += tw_step; \
d2_tw2 = vld2_s16 (p_tw); \
d_s1_r = vqdmulh_s16 (d2_in1.val[0], d2_tw0.val[0]); \
d_s1_i = vqdmulh_s16 (d2_in1.val[1], d2_tw0.val[0]); \
d_s2_r = vqdmulh_s16 (d2_in2.val[0], d2_tw1.val[0]); \
d_s2_i = vqdmulh_s16 (d2_in2.val[1], d2_tw1.val[0]); \
d_s3_r = vqdmulh_s16 (d2_in3.val[0], d2_tw2.val[0]); \
d_s3_i = vqdmulh_s16 (d2_in3.val[1], d2_tw2.val[0]); \
d_tmp0 = vqdmulh_s16 (d2_in1.val[1], d2_tw0.val[1]); \
d_tmp1 = vqdmulh_s16 (d2_in1.val[0], d2_tw0.val[1]); \
d_tmp2 = vqdmulh_s16 (d2_in2.val[1], d2_tw1.val[1]); \
d_tmp3 = vqdmulh_s16 (d2_in2.val[0], d2_tw1.val[1]); \
d_tmp4 = vqdmulh_s16 (d2_in3.val[1], d2_tw2.val[1]); \
d_tmp5 = vqdmulh_s16 (d2_in3.val[0], d2_tw2.val[1]);
#define RADIX4x4_WITH_TW_STORE \
vst2_s16 (p_dst, d2_out0); \
p_dst += dst_step; \
vst2_s16 (p_dst, d2_out1); \
p_dst += dst_step; \
vst2_s16 (p_dst, d2_out2); \
p_dst += dst_step; \
vst2_s16 (p_dst, d2_out3); \
p_dst += dst_step; \
p_src = p_src - src_step * 4 + 8; \
p_dst = p_dst - dst_step * 4 + 8; \
p_tw = p_tw - tw_step * 2 + 8;
#define RADIX4x4_WITH_TW_S1_FWD \
d_s1_r = vsub_s16 (d_s1_r, d_tmp0); \
d_s1_i = vadd_s16 (d_s1_i, d_tmp1); \
d_s2_r = vsub_s16 (d_s2_r, d_tmp2); \
d_s2_i = vadd_s16 (d_s2_i, d_tmp3); \
d_s3_r = vsub_s16 (d_s3_r, d_tmp4); \
d_s3_i = vadd_s16 (d_s3_i, d_tmp5);
#define RADIX4x4_WITH_TW_S1_INV \
d_s1_r = vadd_s16 (d_s1_r, d_tmp0); \
d_s1_i = vsub_s16 (d_s1_i, d_tmp1); \
d_s2_r = vadd_s16 (d_s2_r, d_tmp2); \
d_s2_i = vsub_s16 (d_s2_i, d_tmp3); \
d_s3_r = vadd_s16 (d_s3_r, d_tmp4); \
d_s3_i = vsub_s16 (d_s3_i, d_tmp5);
#define RADIX4x4_WITH_TW_LS_02 \
d_s4_r = vadd_s16 (d2_in0.val[0], d_s2_r); \
d_s4_i = vadd_s16 (d2_in0.val[1], d_s2_i); \
d_s5_r = vsub_s16 (d2_in0.val[0], d_s2_r); \
d_s5_i = vsub_s16 (d2_in0.val[1], d_s2_i); \
d_s6_r = vadd_s16 (d_s1_r, d_s3_r); \
d_s6_i = vadd_s16 (d_s1_i, d_s3_i); \
d_s7_r = vsub_s16 (d_s1_r, d_s3_r); \
d_s7_i = vsub_s16 (d_s1_i, d_s3_i); \
d2_out2.val[0] = vsub_s16 (d_s4_r, d_s6_r); \
d2_out2.val[1] = vsub_s16 (d_s4_i, d_s6_i); \
d2_out0.val[0] = vadd_s16 (d_s4_r, d_s6_r); \
d2_out0.val[1] = vadd_s16 (d_s4_i, d_s6_i);
#define RADIX4x4_WITH_TW_LS_02_SCALED \
d_s4_r = vhadd_s16 (d2_in0.val[0], d_s2_r); \
d_s4_i = vhadd_s16 (d2_in0.val[1], d_s2_i); \
d_s5_r = vhsub_s16 (d2_in0.val[0], d_s2_r); \
d_s5_i = vhsub_s16 (d2_in0.val[1], d_s2_i); \
d_s6_r = vhadd_s16 (d_s1_r, d_s3_r); \
d_s6_i = vhadd_s16 (d_s1_i, d_s3_i); \
d_s7_r = vhsub_s16 (d_s1_r, d_s3_r); \
d_s7_i = vhsub_s16 (d_s1_i, d_s3_i); \
d2_out2.val[0] = vhsub_s16 (d_s4_r, d_s6_r); \
d2_out2.val[1] = vhsub_s16 (d_s4_i, d_s6_i); \
d2_out0.val[0] = vhadd_s16 (d_s4_r, d_s6_r); \
d2_out0.val[1] = vhadd_s16 (d_s4_i, d_s6_i);
static inline void ne10_radix4x4_with_twiddles_forward_unscaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_fft_cpx_int16_t * tw,
ne10_int32_t src_stride,
ne10_int32_t dst_stride,
ne10_int32_t mstride)
{
RADIX4x4_WITH_TW_START
for (m_count = 0; m_count < mstride; m_count += 4)
{
// load
RADIX4x4_WITH_TW_LOAD
RADIX4x4_WITH_TW_S1_FWD
RADIX4x4_WITH_TW_LS_02
d2_out1.val[0] = vadd_s16 (d_s5_r, d_s7_i);
d2_out1.val[1] = vsub_s16 (d_s5_i, d_s7_r);
d2_out3.val[0] = vsub_s16 (d_s5_r, d_s7_i);
d2_out3.val[1] = vadd_s16 (d_s5_i, d_s7_r);
// store
RADIX4x4_WITH_TW_STORE
}
}
static inline void ne10_radix4x4_with_twiddles_backward_unscaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_fft_cpx_int16_t * tw,
ne10_int32_t src_stride,
ne10_int32_t dst_stride,
ne10_int32_t mstride)
{
RADIX4x4_WITH_TW_START
for (m_count = 0; m_count < mstride; m_count += 4)
{
// load
RADIX4x4_WITH_TW_LOAD
RADIX4x4_WITH_TW_S1_INV
RADIX4x4_WITH_TW_LS_02
d2_out1.val[0] = vsub_s16 (d_s5_r, d_s7_i);
d2_out1.val[1] = vadd_s16 (d_s5_i, d_s7_r);
d2_out3.val[0] = vadd_s16 (d_s5_r, d_s7_i);
d2_out3.val[1] = vsub_s16 (d_s5_i, d_s7_r);
// store
RADIX4x4_WITH_TW_STORE
}
}
static inline void ne10_radix4x4_with_twiddles_forward_scaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_fft_cpx_int16_t * tw,
ne10_int32_t src_stride,
ne10_int32_t dst_stride,
ne10_int32_t mstride)
{
RADIX4x4_WITH_TW_START
for (m_count = 0; m_count < mstride; m_count += 4)
{
// load
RADIX4x4_WITH_TW_LOAD
RADIX4x4_WITH_TW_S1_FWD
RADIX4x4_WITH_TW_LS_02_SCALED
d2_out1.val[0] = vhadd_s16 (d_s5_r, d_s7_i);
d2_out1.val[1] = vhsub_s16 (d_s5_i, d_s7_r);
d2_out3.val[0] = vhsub_s16 (d_s5_r, d_s7_i);
d2_out3.val[1] = vhadd_s16 (d_s5_i, d_s7_r);
// store
RADIX4x4_WITH_TW_STORE
}
}
static inline void ne10_radix4x4_with_twiddles_backward_scaled_neon (ne10_fft_cpx_int16_t * Fout,
ne10_fft_cpx_int16_t * Fin,
ne10_fft_cpx_int16_t * tw,
ne10_int32_t src_stride,
ne10_int32_t dst_stride,
ne10_int32_t mstride)
{
RADIX4x4_WITH_TW_START
for (m_count = 0; m_count < mstride; m_count += 4)
{
// load
RADIX4x4_WITH_TW_LOAD
RADIX4x4_WITH_TW_S1_INV
RADIX4x4_WITH_TW_LS_02_SCALED
d2_out1.val[0] = vhsub_s16 (d_s5_r, d_s7_i);
d2_out1.val[1] = vhadd_s16 (d_s5_i, d_s7_r);
d2_out3.val[0] = vhadd_s16 (d_s5_r, d_s7_i);
d2_out3.val[1] = vhsub_s16 (d_s5_i, d_s7_r);
// store
RADIX4x4_WITH_TW_STORE
}
}
#define ne10_mixed_radix_fft_forward_int16_neon(scaled) \
void ne10_mixed_radix_fft_forward_int16_##scaled##_neon (ne10_fft_cpx_int16_t * Fout, \
ne10_fft_cpx_int16_t * Fin, \
ne10_int32_t * factors, \
ne10_fft_cpx_int16_t * twiddles, \
ne10_fft_cpx_int16_t * buffer) \
{ \
ne10_int32_t fstride, mstride, N; \
ne10_int32_t fstride1; \
ne10_int32_t f_count; \
ne10_int32_t stage_count; \
\
ne10_fft_cpx_int16_t *Fin1, *Fout1; \
ne10_fft_cpx_int16_t *Fout_ls = Fout; \
ne10_fft_cpx_int16_t *Ftmp; \
ne10_fft_cpx_int16_t *tw, *tw1; \
\
/* init fstride, mstride, N */ \
stage_count = factors[0]; \
fstride = factors[1]; \
mstride = factors[ (stage_count << 1) - 1 ]; \
N = factors[ stage_count << 1 ]; \
\
/* the first stage */ \
Fin1 = Fin; \
Fout1 = Fout; \
if (N == 2) \
{ \
N = fstride >> 1;\
tw = twiddles; \
fstride1 = fstride >> 2; \
ne10_radix8x4_forward_##scaled##_neon (Fout, Fin, fstride1);\
\
tw += 6; \
mstride <<= 2; \
fstride >>= 4; \
stage_count -= 2; \
\
Ftmp = Fin; \
Fin = Fout; \
Fout = Ftmp; \
} \
else if (N == 4) \
{ \
ne10_radix4x4_without_twiddles_forward_##scaled##_neon (Fout, Fin, fstride); \
N = fstride; \
Ftmp = Fin; \
Fin = Fout; \
Fout = Ftmp; \
/* update address for other stages*/ \
stage_count--; \
tw = twiddles; \
fstride >>= 2; \
} \
/* others but the last one*/ \
for (; stage_count > 1 ; stage_count--) \
{ \
Fin1 = Fin; \
for (f_count = 0; f_count < fstride; f_count ++) \
{ \
Fout1 = & Fout[ f_count * mstride << 2 ]; \
tw1 = tw; \
ne10_radix4x4_with_twiddles_forward_##scaled##_neon (Fout1, Fin1, tw1, N, mstride, mstride); \
Fin1 += mstride; \
} \
tw += mstride * 3; \
mstride <<= 2; \
Ftmp = Fin; \
Fin = Fout; \
Fout = Ftmp; \
fstride >>= 2; \
}\
/* the last one*/ \
if (stage_count) \
{ \
Fin1 = Fin; \
Fout1 = Fout_ls; \
for (f_count = 0; f_count < fstride; f_count ++) \
{ \
tw1 = tw; \
ne10_radix4x4_with_twiddles_forward_##scaled##_neon (Fout1, Fin1, tw1, N, N, mstride); \
Fin1 += mstride; \
Fout1 += mstride; \
} \
} \
}
#define ne10_mixed_radix_fft_backward_int16_neon(scaled) \
void ne10_mixed_radix_fft_backward_int16_##scaled##_neon (ne10_fft_cpx_int16_t * Fout, \
ne10_fft_cpx_int16_t * Fin, \
ne10_int32_t * factors, \
ne10_fft_cpx_int16_t * twiddles, \
ne10_fft_cpx_int16_t * buffer) \
{ \
ne10_int32_t fstride, mstride, N; \
ne10_int32_t fstride1; \
ne10_int32_t f_count; \
ne10_int32_t stage_count; \
\
ne10_fft_cpx_int16_t *Fin1, *Fout1; \
ne10_fft_cpx_int16_t *Fout_ls = Fout; \
ne10_fft_cpx_int16_t *Ftmp; \
ne10_fft_cpx_int16_t *tw, *tw1; \
\
/* init fstride, mstride, N */ \
stage_count = factors[0]; \
fstride = factors[1]; \
mstride = factors[ (stage_count << 1) - 1 ]; \
N = factors[ stage_count << 1 ]; \
\
/* the first stage */ \
Fin1 = Fin; \
Fout1 = Fout; \
if (N == 2) \
{ \
N = fstride >> 1;\
tw = twiddles; \
fstride1 = fstride >> 2; \
ne10_radix8x4_backward_##scaled##_neon (Fout, Fin, fstride1);\
\
tw += 6; \
mstride <<= 2; \
fstride >>= 4; \
stage_count -= 2; \
\
Ftmp = Fin; \
Fin = Fout; \
Fout = Ftmp; \
} \
else if (N == 4) \
{ \
ne10_radix4x4_without_twiddles_backward_##scaled##_neon (Fout, Fin, fstride); \
N = fstride; \
Ftmp = Fin; \
Fin = Fout; \
Fout = Ftmp; \
/* update address for other stages*/ \
stage_count--; \
tw = twiddles; \
fstride >>= 2; \
} \
/* others but the last one*/ \
for (; stage_count > 1 ; stage_count--) \
{ \
Fin1 = Fin; \
for (f_count = 0; f_count < fstride; f_count ++) \
{ \
Fout1 = & Fout[ f_count * mstride << 2 ]; \
tw1 = tw; \
ne10_radix4x4_with_twiddles_backward_##scaled##_neon (Fout1, Fin1, tw1, N, mstride, mstride); \
Fin1 += mstride; \
} \
tw += mstride * 3; \
mstride <<= 2; \
Ftmp = Fin; \
Fin = Fout; \
Fout = Ftmp; \
fstride >>= 2; \
}\
/* the last one*/ \
if (stage_count) \
{ \
Fin1 = Fin; \
Fout1 = Fout_ls; \
for (f_count = 0; f_count < fstride; f_count ++) \
{ \
tw1 = tw; \
ne10_radix4x4_with_twiddles_backward_##scaled##_neon (Fout1, Fin1, tw1, N, N, mstride); \
Fin1 += mstride; \
Fout1 += mstride; \
} \
} \
}
ne10_mixed_radix_fft_forward_int16_neon (unscaled)
ne10_mixed_radix_fft_forward_int16_neon (scaled)
ne10_mixed_radix_fft_backward_int16_neon (unscaled)
ne10_mixed_radix_fft_backward_int16_neon (scaled)
static void ne10_fft_split_r2c_1d_int16_neon (ne10_fft_cpx_int16_t *dst,
const ne10_fft_cpx_int16_t *src,
ne10_fft_cpx_int16_t *twiddles,
ne10_int32_t ncfft,
ne10_int32_t scaled_flag)
{
ne10_int32_t k;
ne10_int32_t count = ncfft / 2;
ne10_fft_cpx_int16_t fpnk, fpk, f1k, f2k, tw, tdc;
int16x8x2_t q2_fpk, q2_fpnk, q2_tw, q2_dst, q2_dst2;
int16x8_t q_fpnk_r, q_fpnk_i;
int16x8_t q_f1k_r, q_f1k_i, q_f2k_r, q_f2k_i;
int16x8_t q_tw_r, q_tw_i;
int16x8_t q_tmp0, q_tmp1, q_tmp2, q_tmp3;
int16x8_t q_dst2_r, q_dst2_i;
int16_t *p_src, *p_src2, *p_dst, *p_dst2, *p_twiddles;
tdc.r = src[0].r;
tdc.i = src[0].i;
if (scaled_flag)
NE10_F2I16_FIXDIV (tdc, 2);
dst[0].r = tdc.r + tdc.i;
dst[ncfft].r = tdc.r - tdc.i;
dst[ncfft].i = dst[0].i = 0;
if (count >= 8)
{
if (scaled_flag)
{
for (k = 1; k <= count ; k += 8)
{
p_src = (int16_t*) (& (src[k]));
p_src2 = (int16_t*) (& (src[ncfft - k - 7]));
p_twiddles = (int16_t*) (& (twiddles[k - 1]));
p_dst = (int16_t*) (& (dst[k]));
p_dst2 = (int16_t*) (& (dst[ncfft - k - 7]));
q2_fpk = vld2q_s16 (p_src);
q2_fpnk = vld2q_s16 (p_src2);
q2_tw = vld2q_s16 (p_twiddles);
q2_fpnk.val[0] = vrev32q_s16 (q2_fpnk.val[0]);
q2_fpnk.val[1] = vrev32q_s16 (q2_fpnk.val[1]);
q2_fpnk.val[0] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fpnk.val[0])));
q2_fpnk.val[1] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fpnk.val[1])));
q_fpnk_r = vcombine_s16 (vget_high_s16 (q2_fpnk.val[0]), vget_low_s16 (q2_fpnk.val[0]));
q_fpnk_i = vcombine_s16 (vget_high_s16 (q2_fpnk.val[1]), vget_low_s16 (q2_fpnk.val[1]));
q_fpnk_i = vnegq_s16 (q_fpnk_i);
q_f1k_r = vhaddq_s16 (q2_fpk.val[0], q_fpnk_r);
q_f1k_i = vhaddq_s16 (q2_fpk.val[1], q_fpnk_i);
q_f2k_r = vhsubq_s16 (q2_fpk.val[0], q_fpnk_r);
q_f2k_i = vhsubq_s16 (q2_fpk.val[1], q_fpnk_i);
q_tmp0 = vqdmulhq_s16 (q_f2k_r, q2_tw.val[0]);
q_tmp1 = vqdmulhq_s16 (q_f2k_i, q2_tw.val[1]);
q_tmp2 = vqdmulhq_s16 (q_f2k_r, q2_tw.val[1]);
q_tmp3 = vqdmulhq_s16 (q_f2k_i, q2_tw.val[0]);
q_tw_r = vsubq_s16 (q_tmp0, q_tmp1);
q_tw_i = vaddq_s16 (q_tmp2, q_tmp3);
q_dst2_r = vhsubq_s16 (q_f1k_r, q_tw_r);
q_dst2_i = vhsubq_s16 (q_tw_i, q_f1k_i);
q2_dst.val[0] = vhaddq_s16 (q_f1k_r, q_tw_r);
q2_dst.val[1] = vhaddq_s16 (q_f1k_i, q_tw_i);
q_dst2_r = vrev32q_s16 (q_dst2_r);
q_dst2_i = vrev32q_s16 (q_dst2_i);
q_dst2_r = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_r))) ;
q_dst2_i = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_i)));
q2_dst2.val[0] = vcombine_s16 (vget_high_s16 (q_dst2_r), vget_low_s16 (q_dst2_r));
q2_dst2.val[1] = vcombine_s16 (vget_high_s16 (q_dst2_i), vget_low_s16 (q_dst2_i));
vst2q_s16 (p_dst, q2_dst);
vst2q_s16 (p_dst2, q2_dst2);
}
}
else
{
for (k = 1; k <= count ; k += 8)
{
p_src = (int16_t*) (& (src[k]));
p_src2 = (int16_t*) (& (src[ncfft - k - 7]));
p_twiddles = (int16_t*) (& (twiddles[k - 1]));
p_dst = (int16_t*) (& (dst[k]));
p_dst2 = (int16_t*) (& (dst[ncfft - k - 7]));
q2_fpk = vld2q_s16 (p_src);
q2_fpnk = vld2q_s16 (p_src2);
q2_tw = vld2q_s16 (p_twiddles);
q2_fpnk.val[0] = vrev32q_s16 (q2_fpnk.val[0]);
q2_fpnk.val[1] = vrev32q_s16 (q2_fpnk.val[1]);
q2_fpnk.val[0] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fpnk.val[0])));
q2_fpnk.val[1] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fpnk.val[1])));
q_fpnk_r = vcombine_s16 (vget_high_s16 (q2_fpnk.val[0]), vget_low_s16 (q2_fpnk.val[0]));
q_fpnk_i = vcombine_s16 (vget_high_s16 (q2_fpnk.val[1]), vget_low_s16 (q2_fpnk.val[1]));
q_fpnk_i = vnegq_s16 (q_fpnk_i);
q_f1k_r = vaddq_s16 (q2_fpk.val[0], q_fpnk_r);
q_f1k_i = vaddq_s16 (q2_fpk.val[1], q_fpnk_i);
q_f2k_r = vsubq_s16 (q2_fpk.val[0], q_fpnk_r);
q_f2k_i = vsubq_s16 (q2_fpk.val[1], q_fpnk_i);
q_tmp0 = vqdmulhq_s16 (q_f2k_r, q2_tw.val[0]);
q_tmp1 = vqdmulhq_s16 (q_f2k_i, q2_tw.val[1]);
q_tmp2 = vqdmulhq_s16 (q_f2k_r, q2_tw.val[1]);
q_tmp3 = vqdmulhq_s16 (q_f2k_i, q2_tw.val[0]);
q_tw_r = vsubq_s16 (q_tmp0, q_tmp1);
q_tw_i = vaddq_s16 (q_tmp2, q_tmp3);
q_dst2_r = vhsubq_s16 (q_f1k_r, q_tw_r);
q_dst2_i = vhsubq_s16 (q_tw_i, q_f1k_i);
q2_dst.val[0] = vhaddq_s16 (q_f1k_r, q_tw_r);
q2_dst.val[1] = vhaddq_s16 (q_f1k_i, q_tw_i);
q_dst2_r = vrev32q_s16 (q_dst2_r);
q_dst2_i = vrev32q_s16 (q_dst2_i);
q_dst2_r = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_r))) ;
q_dst2_i = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_i)));
q2_dst2.val[0] = vcombine_s16 (vget_high_s16 (q_dst2_r), vget_low_s16 (q_dst2_r));
q2_dst2.val[1] = vcombine_s16 (vget_high_s16 (q_dst2_i), vget_low_s16 (q_dst2_i));
vst2q_s16 (p_dst, q2_dst);
vst2q_s16 (p_dst2, q2_dst2);
}
}
}
else
{
for (k = 1; k <= ncfft / 2 ; ++k)
{
fpk = src[k];
fpnk.r = src[ncfft - k].r;
fpnk.i = - src[ncfft - k].i;
if (scaled_flag)
{
NE10_F2I16_FIXDIV (fpk, 2);
NE10_F2I16_FIXDIV (fpnk, 2);
}
f1k.r = fpk.r + fpnk.r;
f1k.i = fpk.i + fpnk.i;
f2k.r = fpk.r - fpnk.r;
f2k.i = fpk.i - fpnk.i;
tw.r = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) f2k.r * (twiddles[k - 1]).r
- (NE10_F2I16_SAMPPROD) f2k.i * (twiddles[k - 1]).i) >> NE10_F2I16_SHIFT);
tw.i = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) f2k.r * (twiddles[k - 1]).i
+ (NE10_F2I16_SAMPPROD) f2k.i * (twiddles[k - 1]).r) >> NE10_F2I16_SHIFT);
dst[k].r = (f1k.r + tw.r) >> 1;
dst[k].i = (f1k.i + tw.i) >> 1;
dst[ncfft - k].r = (f1k.r - tw.r) >> 1;
dst[ncfft - k].i = (tw.i - f1k.i) >> 1;
}
}
}
static void ne10_fft_split_c2r_1d_int16_neon (ne10_fft_cpx_int16_t *dst,
const ne10_fft_cpx_int16_t *src,
ne10_fft_cpx_int16_t *twiddles,
ne10_int32_t ncfft,
ne10_int32_t scaled_flag)
{
ne10_int32_t k;
ne10_int32_t count = ncfft / 2;
ne10_fft_cpx_int16_t fk, fnkc, fek, fok, tmp;
int16x8x2_t q2_fk, q2_fnkc, q2_tw, q2_dst, q2_dst2;
int16x8_t q_fnkc_r, q_fnkc_i;
int16x8_t q_fek_r, q_fek_i, q_fok_r, q_fok_i;
int16x8_t q_tmp0, q_tmp1, q_tmp2, q_tmp3;
int16x8_t q_dst2_r, q_dst2_i;
int16_t *p_src, *p_src2, *p_dst, *p_dst2, *p_twiddles;
dst[0].r = src[0].r + src[ncfft].r;
dst[0].i = src[0].r - src[ncfft].r;
if (scaled_flag)
NE10_F2I16_FIXDIV (dst[0], 2);
if (count >= 8)
{
if (scaled_flag)
{
for (k = 1; k <= count ; k += 8)
{
p_src = (int16_t*) (& (src[k]));
p_src2 = (int16_t*) (& (src[ncfft - k - 7]));
p_twiddles = (int16_t*) (& (twiddles[k - 1]));
p_dst = (int16_t*) (& (dst[k]));
p_dst2 = (int16_t*) (& (dst[ncfft - k - 7]));
q2_fk = vld2q_s16 (p_src);
q2_fnkc = vld2q_s16 (p_src2);
q2_tw = vld2q_s16 (p_twiddles);
q2_fnkc.val[0] = vrev32q_s16 (q2_fnkc.val[0]);
q2_fnkc.val[1] = vrev32q_s16 (q2_fnkc.val[1]);
q2_fnkc.val[0] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fnkc.val[0])));
q2_fnkc.val[1] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fnkc.val[1])));
q_fnkc_r = vcombine_s16 (vget_high_s16 (q2_fnkc.val[0]), vget_low_s16 (q2_fnkc.val[0]));
q_fnkc_i = vcombine_s16 (vget_high_s16 (q2_fnkc.val[1]), vget_low_s16 (q2_fnkc.val[1]));
q_fnkc_i = vnegq_s16 (q_fnkc_i);
q_fek_r = vhaddq_s16 (q2_fk.val[0], q_fnkc_r);
q_fek_i = vhaddq_s16 (q2_fk.val[1], q_fnkc_i);
q_tmp0 = vhsubq_s16 (q2_fk.val[0], q_fnkc_r);
q_tmp1 = vhsubq_s16 (q2_fk.val[1], q_fnkc_i);
q_fok_r = vqdmulhq_s16 (q_tmp0, q2_tw.val[0]);
q_fok_i = vqdmulhq_s16 (q_tmp1, q2_tw.val[0]);
q_tmp2 = vqdmulhq_s16 (q_tmp1, q2_tw.val[1]);
q_tmp3 = vqdmulhq_s16 (q_tmp0, q2_tw.val[1]);
q_fok_r = vaddq_s16 (q_fok_r, q_tmp2);
q_fok_i = vsubq_s16 (q_fok_i, q_tmp3);
q_dst2_r = vsubq_s16 (q_fek_r, q_fok_r);
q_dst2_i = vsubq_s16 (q_fok_i, q_fek_i);
q2_dst.val[0] = vaddq_s16 (q_fek_r, q_fok_r);
q2_dst.val[1] = vaddq_s16 (q_fek_i, q_fok_i);
q_dst2_r = vrev32q_s16 (q_dst2_r);
q_dst2_i = vrev32q_s16 (q_dst2_i);
q_dst2_r = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_r))) ;
q_dst2_i = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_i)));
q2_dst2.val[0] = vcombine_s16 (vget_high_s16 (q_dst2_r), vget_low_s16 (q_dst2_r));
q2_dst2.val[1] = vcombine_s16 (vget_high_s16 (q_dst2_i), vget_low_s16 (q_dst2_i));
vst2q_s16 (p_dst, q2_dst);
vst2q_s16 (p_dst2, q2_dst2);
}
}
else
{
for (k = 1; k <= count ; k += 8)
{
p_src = (int16_t*) (& (src[k]));
p_src2 = (int16_t*) (& (src[ncfft - k - 7]));
p_twiddles = (int16_t*) (& (twiddles[k - 1]));
p_dst = (int16_t*) (& (dst[k]));
p_dst2 = (int16_t*) (& (dst[ncfft - k - 7]));
q2_fk = vld2q_s16 (p_src);
q2_fnkc = vld2q_s16 (p_src2);
q2_tw = vld2q_s16 (p_twiddles);
q2_fnkc.val[0] = vrev32q_s16 (q2_fnkc.val[0]);
q2_fnkc.val[1] = vrev32q_s16 (q2_fnkc.val[1]);
q2_fnkc.val[0] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fnkc.val[0])));
q2_fnkc.val[1] = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q2_fnkc.val[1])));
q_fnkc_r = vcombine_s16 (vget_high_s16 (q2_fnkc.val[0]), vget_low_s16 (q2_fnkc.val[0]));
q_fnkc_i = vcombine_s16 (vget_high_s16 (q2_fnkc.val[1]), vget_low_s16 (q2_fnkc.val[1]));
q_fnkc_i = vnegq_s16 (q_fnkc_i);
q_fek_r = vaddq_s16 (q2_fk.val[0], q_fnkc_r);
q_fek_i = vaddq_s16 (q2_fk.val[1], q_fnkc_i);
q_tmp0 = vsubq_s16 (q2_fk.val[0], q_fnkc_r);
q_tmp1 = vsubq_s16 (q2_fk.val[1], q_fnkc_i);
q_fok_r = vqdmulhq_s16 (q_tmp0, q2_tw.val[0]);
q_fok_i = vqdmulhq_s16 (q_tmp1, q2_tw.val[0]);
q_tmp2 = vqdmulhq_s16 (q_tmp1, q2_tw.val[1]);
q_tmp3 = vqdmulhq_s16 (q_tmp0, q2_tw.val[1]);
q_fok_r = vaddq_s16 (q_fok_r, q_tmp2);
q_fok_i = vsubq_s16 (q_fok_i, q_tmp3);
q_dst2_r = vsubq_s16 (q_fek_r, q_fok_r);
q_dst2_i = vsubq_s16 (q_fok_i, q_fek_i);
q2_dst.val[0] = vaddq_s16 (q_fek_r, q_fok_r);
q2_dst.val[1] = vaddq_s16 (q_fek_i, q_fok_i);
q_dst2_r = vrev32q_s16 (q_dst2_r);
q_dst2_i = vrev32q_s16 (q_dst2_i);
q_dst2_r = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_r))) ;
q_dst2_i = vreinterpretq_s16_s32 (vrev64q_s32 (vreinterpretq_s32_s16 (q_dst2_i)));
q2_dst2.val[0] = vcombine_s16 (vget_high_s16 (q_dst2_r), vget_low_s16 (q_dst2_r));
q2_dst2.val[1] = vcombine_s16 (vget_high_s16 (q_dst2_i), vget_low_s16 (q_dst2_i));
vst2q_s16 (p_dst, q2_dst);
vst2q_s16 (p_dst2, q2_dst2);
}
}
}
else
{
for (k = 1; k <= ncfft / 2; k++)
{
fk = src[k];
fnkc.r = src[ncfft - k].r;
fnkc.i = -src[ncfft - k].i;
if (scaled_flag)
{
NE10_F2I16_FIXDIV (fk, 2);
NE10_F2I16_FIXDIV (fnkc, 2);
}
fek.r = fk.r + fnkc.r;
fek.i = fk.i + fnkc.i;
tmp.r = fk.r - fnkc.r;
tmp.i = fk.i - fnkc.i;
fok.r = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) tmp.r * (twiddles[k - 1]).r
+ (NE10_F2I16_SAMPPROD) tmp.i * (twiddles[k - 1]).i) >> NE10_F2I16_SHIFT);
fok.i = (ne10_int16_t) ( ( (NE10_F2I16_SAMPPROD) tmp.i * (twiddles[k - 1]).r
- (NE10_F2I16_SAMPPROD) tmp.r * (twiddles[k - 1]).i) >> NE10_F2I16_SHIFT);
dst[k].r = fek.r + fok.r;
dst[k].i = fek.i + fok.i;
dst[ncfft - k].r = fek.r - fok.r;
dst[ncfft - k].i = fok.i - fek.i;
}
}
}
/**
* @addtogroup C2C_FFT_IFFT
* @{
*/
/**
* @brief Mixed radix-2/4 complex FFT/IFFT of 32-bit fixed point data.
* @param[out] *fout point to the output buffer (out-of-place)
* @param[in] *fin point to the input buffer (out-of-place)
* @param[in] *twiddles point to the twiddle buffer
* @param[in] *factors point to factors buffer. 0: stage number, 1: stride for the first stage, others: radix and stage's fft length/radix
* @param[in] nfft length of FFT
* @param[in] inverse_fft the flag of IFFT, 0: FFT, 1: IFFT
* @param[in] scaled_flag scale flag, 0 unscaled, 1 scaled
* @return none.
* The function implements a mixed radix-2/4 complex FFT/IFFT. The length of 2^N(N is 3, 4, 5, 6 ....etc) is supported.
* Otherwise, this FFT is an out-of-place algorithm. When you want to get an in-place FFT, it creates a temp buffer as
* output buffer and then copies the temp buffer back to input buffer. For the usage of this function, please check test/test_suite_fft_int32.c
*/
void ne10_fft_c2c_1d_int16_neon (ne10_fft_cpx_int16_t *fout,
ne10_fft_cpx_int16_t *fin,
ne10_fft_cfg_int16_t cfg,
ne10_int32_t inverse_fft,
ne10_int32_t scaled_flag)
{
if (scaled_flag)
{
if (inverse_fft)
{
switch (cfg->nfft)
{
case 4:
ne10_fft4_backward_int16_scaled (fout, fin);
break;
case 8:
ne10_fft8_backward_int16_scaled (fout, fin);
break;
default:
ne10_mixed_radix_fft_backward_int16_scaled_neon (fout, fin, cfg->factors, cfg->twiddles, cfg->buffer);
break;
}
}
else
{
switch (cfg->nfft)
{
case 4:
ne10_fft4_forward_int16_scaled (fout, fin);
break;
case 8:
ne10_fft8_forward_int16_scaled (fout, fin);
break;
default:
ne10_mixed_radix_fft_forward_int16_scaled_neon (fout, fin, cfg->factors, cfg->twiddles, cfg->buffer);
break;
}
}
}
else
{
if (inverse_fft)
{
switch (cfg->nfft)
{
case 4:
ne10_fft4_backward_int16_unscaled (fout, fin);
break;
case 8:
ne10_fft8_backward_int16_unscaled (fout, fin);
break;
default:
ne10_mixed_radix_fft_backward_int16_unscaled_neon (fout, fin, cfg->factors, cfg->twiddles, cfg->buffer);
break;
}
}
else
{
switch (cfg->nfft)
{
case 4:
ne10_fft4_forward_int16_unscaled (fout, fin);
break;
case 8:
ne10_fft8_forward_int16_unscaled (fout, fin);
break;
default:
ne10_mixed_radix_fft_forward_int16_unscaled_neon (fout, fin, cfg->factors, cfg->twiddles, cfg->buffer);
break;
}
}
}
}
/**
* @}
*/ //end of C2C_FFT_IFFT group
/**
* @addtogroup R2C_FFT_IFFT
* @{
*/
/**
* @brief Mixed radix-2/4 FFT (real to complex) of int16 data.
* @param[out] *fout point to the output buffer
* @param[in] *fin point to the input buffer
* @param[in] *twiddles point to the twiddle buffer
* @param[in] *super_twiddles point to the twiddle buffer for data split
* @param[in] *factors point to factors buffer. 0: stage number, 1: stride for the first stage, others: radix and stage's fft length/radix
* @param[in] nfft length of FFT
* @param[in] scaled_flag scale flag, 0 unscaled, 1 scaled
* @return none.
* The function implements a mixed radix-2/4 FFT (real to complex). The length of 2^N(N is 2, 3, 4, 5, 6 ....etc) is supported.
* Otherwise, we alloc a temp buffer(the size is same as input buffer) for storing intermedia.
* For the usage of this function, please check test/test_suite_fft_int16.c
*/
void ne10_fft_r2c_1d_int16_neon (ne10_fft_cpx_int16_t *fout,
ne10_int16_t *fin,
ne10_fft_r2c_cfg_int16_t cfg,
ne10_int32_t scaled_flag)
{
ne10_fft_cpx_int16_t * tmpbuf1 = cfg->buffer;
ne10_fft_cpx_int16_t * tmpbuf2 = cfg->buffer + cfg->ncfft;
ne10_fft_state_int16_t c2c_state;
c2c_state.nfft = cfg->ncfft;
c2c_state.factors = cfg->factors;
c2c_state.twiddles = cfg->twiddles;
c2c_state.buffer = tmpbuf2;
ne10_fft_c2c_1d_int16_neon (tmpbuf1, (ne10_fft_cpx_int16_t*) fin, &c2c_state, 0, scaled_flag);
ne10_fft_split_r2c_1d_int16_neon (fout, tmpbuf1, cfg->super_twiddles, cfg->ncfft, scaled_flag);
}
/**
* @brief Mixed radix-2/4 IFFT (complex to real) of int16 data.
* @param[out] *fout point to the output buffer
* @param[in] *fin point to the input buffer
* @param[in] *twiddles point to the twiddle buffer
* @param[in] *super_twiddles point to the twiddle buffer for data split
* @param[in] *factors point to factors buffer. 0: stage number, 1: stride for the first stage, others: radix and stage's fft length/radix
* @param[in] nfft length of FFT
* @param[in] scaled_flag scale flag, 0 unscaled, 1 scaled
* @return none.
* The function implements a mixed radix-2/4 FFT (complex to real). The length of 2^N(N is 2, 3, 4, 5, 6 ....etc) is supported.
* Otherwise, we alloc a temp buffer(the size is same as input buffer) for storing intermedia.
* For the usage of this function, please check test/test_suite_fft_int16.c
*/
void ne10_fft_c2r_1d_int16_neon (ne10_int16_t *fout,
ne10_fft_cpx_int16_t *fin,
ne10_fft_r2c_cfg_int16_t cfg,
ne10_int32_t scaled_flag)
{
ne10_fft_cpx_int16_t * tmpbuf1 = cfg->buffer;
ne10_fft_cpx_int16_t * tmpbuf2 = cfg->buffer + cfg->ncfft;
ne10_fft_state_int16_t c2c_state;
c2c_state.nfft = cfg->ncfft;
c2c_state.factors = cfg->factors;
c2c_state.twiddles = cfg->twiddles;
c2c_state.buffer = tmpbuf2;
ne10_fft_split_c2r_1d_int16_neon (tmpbuf1, fin, cfg->super_twiddles, cfg->ncfft, scaled_flag);
ne10_fft_c2c_1d_int16_neon ( (ne10_fft_cpx_int16_t*) fout, tmpbuf1, &c2c_state, 1, scaled_flag);
}
/**
* @} end of R2C_FFT_IFFT group
*/
|
4d40241896c7b02caa2cc0bcaa77f2f56013fbbc
|
1535a8209a17670603cba472d2663fe82a3a1adf
|
/common.h
|
66cc4295e0c4baf4e18d30c2878f70de5f1bc389
|
[
"ISC"
] |
permissive
|
maandree/sha3sum
|
69662425cec66241c02c36f5678cdad8fdadb10f
|
07d982d650a3ca3758ae69a78efcfe92249855d2
|
refs/heads/master
| 2022-07-24T13:54:38.311002
| 2022-07-18T21:38:34
| 2022-07-18T21:38:34
| 7,999,424
| 159
| 45
|
ISC
| 2018-05-12T14:34:58
| 2013-02-04T01:46:58
|
C
|
UTF-8
|
C
| false
| false
| 1,626
|
h
|
common.h
|
/* See LICENSE file for copyright and license details. */
#include <libkeccak.h>
#define COMMON_MAIN(CONFIGURATION, SUFFIX)\
int main(int argc, char *argv[]) {\
struct libkeccak_generalised_spec spec;\
libkeccak_generalised_spec_initialise(&spec);\
CONFIGURATION;\
return run(argc, argv, &spec, SUFFIX, 0);\
}
#define KECCAK_MAIN(N)\
COMMON_MAIN(libkeccak_spec_sha3((struct libkeccak_spec *)&spec, N), "")
#define SHA3_MAIN(N)\
COMMON_MAIN(libkeccak_spec_sha3((struct libkeccak_spec *)&spec, N), LIBKECCAK_SHA3_SUFFIX)
#define RAWSHAKE_MAIN(N)\
COMMON_MAIN(libkeccak_spec_rawshake((struct libkeccak_spec *)&spec, N, N), LIBKECCAK_RAWSHAKE_SUFFIX)
#define SHAKE_MAIN(N)\
COMMON_MAIN(libkeccak_spec_shake((struct libkeccak_spec *)&spec, N, N), LIBKECCAK_SHAKE_SUFFIX)
/**
* Message digest representation formats
*/
enum representation {
/**
* Print the checksum in binary
*/
REPRESENTATION_BINARY,
/**
* Print the checksum in upper case hexadecimal
*/
REPRESENTATION_UPPER_CASE,
/**
* Print the checksum in lower case hexadecimal
*/
REPRESENTATION_LOWER_CASE
};
/**
* Parse the command line and calculate the hashes of the selected files
*
* @param argc The first argument from `main`
* @param argv The second argument from `main`
* @param gspec The default algorithm parameters
* @param suffix Message suffix
* @param with_a Whether the -a option should be recognised (but ignored)
* @return An appropriate exit value
*/
int run(int argc, char *argv[], struct libkeccak_generalised_spec *restrict gspec, const char *restrict suffix, int with_a);
|
095dc7a865c77eb39121e2c572ef498a991c9c4e
|
fb47ab6337a71029dee71933e449cf7f6805fc0f
|
/external/platform/stm32f4xx/STM32F4xx_StdPeriph_Driver/src/stm32f4xx_cryp_aes.c
|
c83d5847c25e17b17dfae0f1c366c08c02c297dd
|
[
"MIT"
] |
permissive
|
littlekernel/lk
|
7e7ba50b87b1f2e0b6e2f052c59249825c91975b
|
30dc320054f70910e1c1ee40a6948ee99672acec
|
refs/heads/master
| 2023-09-02T00:47:52.203963
| 2023-06-21T22:42:35
| 2023-06-21T22:42:35
| 3,058,456
| 3,077
| 618
|
MIT
| 2023-08-30T09:41:31
| 2011-12-27T19:19:36
|
C
|
UTF-8
|
C
| false
| false
| 55,831
|
c
|
stm32f4xx_cryp_aes.c
|
/**
******************************************************************************
* @file stm32f4xx_cryp_aes.c
* @author MCD Application Team
* @version V1.8.1
* @date 27-January-2022
* @brief This file provides high level functions to encrypt and decrypt an
* input message using AES in ECB/CBC/CTR/GCM/CCM modes.
* It uses the stm32f4xx_cryp.c/.h drivers to access the STM32F4xx CRYP
* peripheral.
* AES-ECB/CBC/CTR/GCM/CCM modes are available on STM32F437x Devices.
* For STM32F41xx Devices, only AES-ECB/CBC/CTR modes are available.
*
@verbatim
===================================================================
##### How to use this driver #####
===================================================================
[..]
(#) Enable The CRYP controller clock using
RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_CRYP, ENABLE); function.
(#) Encrypt and decrypt using AES in ECB Mode using CRYP_AES_ECB() function.
(#) Encrypt and decrypt using AES in CBC Mode using CRYP_AES_CBC() function.
(#) Encrypt and decrypt using AES in CTR Mode using CRYP_AES_CTR() function.
(#) Encrypt and decrypt using AES in GCM Mode using CRYP_AES_GCM() function.
(#) Encrypt and decrypt using AES in CCM Mode using CRYP_AES_CCM() function.
@endverbatim
*
******************************************************************************
* @attention
*
* Copyright (c) 2016 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_cryp.h"
/** @addtogroup STM32F4xx_StdPeriph_Driver
* @{
*/
/** @defgroup CRYP
* @brief CRYP driver modules
* @{
*/
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define AESBUSY_TIMEOUT ((uint32_t) 0x00010000)
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/** @defgroup CRYP_Private_Functions
* @{
*/
/** @defgroup CRYP_Group6 High Level AES functions
* @brief High Level AES functions
*
@verbatim
===============================================================================
##### High Level AES functions #####
===============================================================================
@endverbatim
* @{
*/
/**
* @brief Encrypt and decrypt using AES in ECB Mode
* @param Mode: encryption or decryption Mode.
* This parameter can be one of the following values:
* @arg MODE_ENCRYPT: Encryption
* @arg MODE_DECRYPT: Decryption
* @param Key: Key used for AES algorithm.
* @param Keysize: length of the Key, must be a 128, 192 or 256.
* @param Input: pointer to the Input buffer.
* @param Ilength: length of the Input buffer, must be a multiple of 16.
* @param Output: pointer to the returned buffer.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: Operation done
* - ERROR: Operation failed
*/
ErrorStatus CRYP_AES_ECB(uint8_t Mode, uint8_t* Key, uint16_t Keysize,
uint8_t* Input, uint32_t Ilength, uint8_t* Output)
{
CRYP_InitTypeDef AES_CRYP_InitStructure;
CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
__IO uint32_t counter = 0;
uint32_t busystatus = 0;
ErrorStatus status = SUCCESS;
uint32_t keyaddr = (uint32_t)Key;
uint32_t inputaddr = (uint32_t)Input;
uint32_t outputaddr = (uint32_t)Output;
uint32_t i = 0;
/* Crypto structures initialisation*/
CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
switch(Keysize)
{
case 128:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 192:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_192b;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 256:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_256b;
AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
default:
break;
}
/*------------------ AES Decryption ------------------*/
if(Mode == MODE_DECRYPT) /* AES decryption */
{
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Crypto Init for Key preparation for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_Key;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_32b;
CRYP_Init(&AES_CRYP_InitStructure);
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
/* wait until the Busy flag is RESET */
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Crypto Init for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
}
}
/*------------------ AES Encryption ------------------*/
else /* AES encryption */
{
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* Crypto Init for Encryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
}
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_ECB;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(i=0; ((i<Ilength) && (status != ERROR)); i+=16)
{
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
/* Disable Crypto */
CRYP_Cmd(DISABLE);
return status;
}
/**
* @brief Encrypt and decrypt using AES in CBC Mode
* @param Mode: encryption or decryption Mode.
* This parameter can be one of the following values:
* @arg MODE_ENCRYPT: Encryption
* @arg MODE_DECRYPT: Decryption
* @param InitVectors: Initialisation Vectors used for AES algorithm.
* @param Key: Key used for AES algorithm.
* @param Keysize: length of the Key, must be a 128, 192 or 256.
* @param Input: pointer to the Input buffer.
* @param Ilength: length of the Input buffer, must be a multiple of 16.
* @param Output: pointer to the returned buffer.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: Operation done
* - ERROR: Operation failed
*/
ErrorStatus CRYP_AES_CBC(uint8_t Mode, uint8_t InitVectors[16], uint8_t *Key,
uint16_t Keysize, uint8_t *Input, uint32_t Ilength,
uint8_t *Output)
{
CRYP_InitTypeDef AES_CRYP_InitStructure;
CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
__IO uint32_t counter = 0;
uint32_t busystatus = 0;
ErrorStatus status = SUCCESS;
uint32_t keyaddr = (uint32_t)Key;
uint32_t inputaddr = (uint32_t)Input;
uint32_t outputaddr = (uint32_t)Output;
uint32_t ivaddr = (uint32_t)InitVectors;
uint32_t i = 0;
/* Crypto structures initialisation*/
CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
switch(Keysize)
{
case 128:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 192:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_192b;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 256:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_256b;
AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
default:
break;
}
/* CRYP Initialization Vectors */
AES_CRYP_IVInitStructure.CRYP_IV0Left = __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV0Right= __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Left = __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Right= __REV(*(uint32_t*)(ivaddr));
/*------------------ AES Decryption ------------------*/
if(Mode == MODE_DECRYPT) /* AES decryption */
{
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Crypto Init for Key preparation for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_Key;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_32b;
CRYP_Init(&AES_CRYP_InitStructure);
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
/* wait until the Busy flag is RESET */
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Crypto Init for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
}
}
/*------------------ AES Encryption ------------------*/
else /* AES encryption */
{
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* Crypto Init for Encryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
}
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CBC;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/* CRYP Initialization Vectors */
CRYP_IVInit(&AES_CRYP_IVInitStructure);
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(i=0; ((i<Ilength) && (status != ERROR)); i+=16)
{
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
/* Disable Crypto */
CRYP_Cmd(DISABLE);
return status;
}
/**
* @brief Encrypt and decrypt using AES in CTR Mode
* @param Mode: encryption or decryption Mode.
* This parameter can be one of the following values:
* @arg MODE_ENCRYPT: Encryption
* @arg MODE_DECRYPT: Decryption
* @param InitVectors: Initialisation Vectors used for AES algorithm.
* @param Key: Key used for AES algorithm.
* @param Keysize: length of the Key, must be a 128, 192 or 256.
* @param Input: pointer to the Input buffer.
* @param Ilength: length of the Input buffer, must be a multiple of 16.
* @param Output: pointer to the returned buffer.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: Operation done
* - ERROR: Operation failed
*/
ErrorStatus CRYP_AES_CTR(uint8_t Mode, uint8_t InitVectors[16], uint8_t *Key,
uint16_t Keysize, uint8_t *Input, uint32_t Ilength,
uint8_t *Output)
{
CRYP_InitTypeDef AES_CRYP_InitStructure;
CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
__IO uint32_t counter = 0;
uint32_t busystatus = 0;
ErrorStatus status = SUCCESS;
uint32_t keyaddr = (uint32_t)Key;
uint32_t inputaddr = (uint32_t)Input;
uint32_t outputaddr = (uint32_t)Output;
uint32_t ivaddr = (uint32_t)InitVectors;
uint32_t i = 0;
/* Crypto structures initialisation*/
CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
switch(Keysize)
{
case 128:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 192:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_192b;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 256:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_256b;
AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
default:
break;
}
/* CRYP Initialization Vectors */
AES_CRYP_IVInitStructure.CRYP_IV0Left = __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV0Right= __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Left = __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Right= __REV(*(uint32_t*)(ivaddr));
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/*------------------ AES Decryption ------------------*/
if(Mode == MODE_DECRYPT) /* AES decryption */
{
/* Crypto Init for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
}
/*------------------ AES Encryption ------------------*/
else /* AES encryption */
{
/* Crypto Init for Encryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
}
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CTR;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/* CRYP Initialization Vectors */
CRYP_IVInit(&AES_CRYP_IVInitStructure);
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(i=0; ((i<Ilength) && (status != ERROR)); i+=16)
{
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
/* Disable Crypto */
CRYP_Cmd(DISABLE);
return status;
}
/**
* @brief Encrypt and decrypt using AES in GCM Mode. The GCM and CCM modes
* are available only on STM32F437x Devices.
* @param Mode: encryption or decryption Mode.
* This parameter can be one of the following values:
* @arg MODE_ENCRYPT: Encryption
* @arg MODE_DECRYPT: Decryption
* @param InitVectors: Initialisation Vectors used for AES algorithm.
* @param Key: Key used for AES algorithm.
* @param Keysize: length of the Key, must be a 128, 192 or 256.
* @param Input: pointer to the Input buffer.
* @param Ilength: length of the Input buffer in bytes, must be a multiple of 16.
* @param Header: pointer to the header buffer.
* @param Hlength: length of the header buffer in bytes, must be a multiple of 16.
* @param Output: pointer to the returned buffer.
* @param AuthTAG: pointer to the authentication TAG buffer.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: Operation done
* - ERROR: Operation failed
*/
ErrorStatus CRYP_AES_GCM(uint8_t Mode, uint8_t InitVectors[16],
uint8_t *Key, uint16_t Keysize,
uint8_t *Input, uint32_t ILength,
uint8_t *Header, uint32_t HLength,
uint8_t *Output, uint8_t *AuthTAG)
{
CRYP_InitTypeDef AES_CRYP_InitStructure;
CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
__IO uint32_t counter = 0;
uint32_t busystatus = 0;
ErrorStatus status = SUCCESS;
uint32_t keyaddr = (uint32_t)Key;
uint32_t inputaddr = (uint32_t)Input;
uint32_t outputaddr = (uint32_t)Output;
uint32_t ivaddr = (uint32_t)InitVectors;
uint32_t headeraddr = (uint32_t)Header;
uint32_t tagaddr = (uint32_t)AuthTAG;
uint64_t headerlength = HLength * 8;/* header length in bits */
uint64_t inputlength = ILength * 8;/* input length in bits */
uint32_t loopcounter = 0;
/* Crypto structures initialisation*/
CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
switch(Keysize)
{
case 128:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 192:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_192b;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 256:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_256b;
AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
default:
break;
}
/* CRYP Initialization Vectors */
AES_CRYP_IVInitStructure.CRYP_IV0Left = __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV0Right= __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Left = __REV(*(uint32_t*)(ivaddr));
ivaddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Right= __REV(*(uint32_t*)(ivaddr));
/*------------------ AES Encryption ------------------*/
if(Mode == MODE_ENCRYPT) /* AES encryption */
{
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* CRYP Initialization Vectors */
CRYP_IVInit(&AES_CRYP_IVInitStructure);
/* Crypto Init for Key preparation for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_GCM;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/***************************** Init phase *********************************/
/* Select init phase */
CRYP_PhaseConfig(CRYP_Phase_Init);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
/* Wait for CRYPEN bit to be 0 */
while(CRYP_GetCmdStatus() == ENABLE)
{
}
/***************************** header phase *******************************/
if(HLength != 0)
{
/* Select header phase */
CRYP_PhaseConfig(CRYP_Phase_Header);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; (loopcounter < HLength); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
}
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
}
/**************************** payload phase *******************************/
if(ILength != 0)
{
/* Select payload phase */
CRYP_PhaseConfig(CRYP_Phase_Payload);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
}
/***************************** final phase ********************************/
/* Select final phase */
CRYP_PhaseConfig(CRYP_Phase_Final);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
/* Write number of bits concatenated with header in the IN FIFO */
CRYP_DataIn(__REV(headerlength>>32));
CRYP_DataIn(__REV(headerlength));
CRYP_DataIn(__REV(inputlength>>32));
CRYP_DataIn(__REV(inputlength));
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
tagaddr = (uint32_t)AuthTAG;
/* Read the Auth TAG in the IN FIFO */
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
}
/*------------------ AES Decryption ------------------*/
else /* AES decryption */
{
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* CRYP Initialization Vectors */
CRYP_IVInit(&AES_CRYP_IVInitStructure);
/* Crypto Init for Key preparation for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_GCM;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/***************************** Init phase *********************************/
/* Select init phase */
CRYP_PhaseConfig(CRYP_Phase_Init);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
/* Wait for CRYPEN bit to be 0 */
while(CRYP_GetCmdStatus() == ENABLE)
{
}
/***************************** header phase *******************************/
if(HLength != 0)
{
/* Select header phase */
CRYP_PhaseConfig(CRYP_Phase_Header);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; (loopcounter < HLength); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
}
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
}
/**************************** payload phase *******************************/
if(ILength != 0)
{
/* Select payload phase */
CRYP_PhaseConfig(CRYP_Phase_Payload);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
}
/***************************** final phase ********************************/
/* Select final phase */
CRYP_PhaseConfig(CRYP_Phase_Final);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
/* Write number of bits concatenated with header in the IN FIFO */
CRYP_DataIn(__REV(headerlength>>32));
CRYP_DataIn(__REV(headerlength));
CRYP_DataIn(__REV(inputlength>>32));
CRYP_DataIn(__REV(inputlength));
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
tagaddr = (uint32_t)AuthTAG;
/* Read the Auth TAG in the IN FIFO */
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
*(uint32_t*)(tagaddr) = CRYP_DataOut();
tagaddr+=4;
}
/* Disable Crypto */
CRYP_Cmd(DISABLE);
return status;
}
/**
* @brief Encrypt and decrypt using AES in CCM Mode. The GCM and CCM modes
* are available only on STM32F437x Devices.
* @param Mode: encryption or decryption Mode.
* This parameter can be one of the following values:
* @arg MODE_ENCRYPT: Encryption
* @arg MODE_DECRYPT: Decryption
* @param Nonce: the nonce used for AES algorithm. It shall be unique for each processing.
* @param Key: Key used for AES algorithm.
* @param Keysize: length of the Key, must be a 128, 192 or 256.
* @param Input: pointer to the Input buffer.
* @param Ilength: length of the Input buffer in bytes, must be a multiple of 16.
* @param Header: pointer to the header buffer.
* @param Hlength: length of the header buffer in bytes.
* @param HBuffer: pointer to temporary buffer used to append the header
* HBuffer size must be equal to Hlength + 21
* @param Output: pointer to the returned buffer.
* @param AuthTAG: pointer to the authentication TAG buffer.
* @param TAGSize: the size of the TAG (called also MAC).
* @retval An ErrorStatus enumeration value:
* - SUCCESS: Operation done
* - ERROR: Operation failed
*/
ErrorStatus CRYP_AES_CCM(uint8_t Mode,
uint8_t* Nonce, uint32_t NonceSize,
uint8_t *Key, uint16_t Keysize,
uint8_t *Input, uint32_t ILength,
uint8_t *Header, uint32_t HLength, uint8_t *HBuffer,
uint8_t *Output,
uint8_t *AuthTAG, uint32_t TAGSize)
{
CRYP_InitTypeDef AES_CRYP_InitStructure;
CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
__IO uint32_t counter = 0;
uint32_t busystatus = 0;
ErrorStatus status = SUCCESS;
uint32_t keyaddr = (uint32_t)Key;
uint32_t inputaddr = (uint32_t)Input;
uint32_t outputaddr = (uint32_t)Output;
uint32_t headeraddr = (uint32_t)Header;
uint32_t tagaddr = (uint32_t)AuthTAG;
uint32_t headersize = HLength;
uint32_t loopcounter = 0;
uint32_t bufferidx = 0;
uint8_t blockb0[16] = {0};/* Block B0 */
uint8_t ctr[16] = {0}; /* Counter */
uint32_t temptag[4] = {0}; /* temporary TAG (MAC) */
uint32_t ctraddr = (uint32_t)ctr;
uint32_t b0addr = (uint32_t)blockb0;
/************************ Formatting the header block ***********************/
if(headersize != 0)
{
/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
if(headersize < 65280)
{
HBuffer[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
HBuffer[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
headersize += 2;
}
else
{
/* header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
HBuffer[bufferidx++] = 0xFF;
HBuffer[bufferidx++] = 0xFE;
HBuffer[bufferidx++] = headersize & 0xff000000;
HBuffer[bufferidx++] = headersize & 0x00ff0000;
HBuffer[bufferidx++] = headersize & 0x0000ff00;
HBuffer[bufferidx++] = headersize & 0x000000ff;
headersize += 6;
}
/* Copy the header buffer in internal buffer "HBuffer" */
for(loopcounter = 0; loopcounter < headersize; loopcounter++)
{
HBuffer[bufferidx++] = Header[loopcounter];
}
/* Check if the header size is modulo 16 */
if ((headersize % 16) != 0)
{
/* Padd the header buffer with 0s till the HBuffer length is modulo 16 */
for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
{
HBuffer[loopcounter] = 0;
}
/* Set the header size to modulo 16 */
headersize = ((headersize/16) + 1) * 16;
}
/* set the pointer headeraddr to HBuffer */
headeraddr = (uint32_t)HBuffer;
}
/************************* Formatting the block B0 **************************/
if(headersize != 0)
{
blockb0[0] = 0x40;
}
/* Flags byte */
blockb0[0] |= 0u | (((( (uint8_t) TAGSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - NonceSize) - 1) & 0x07);
for (loopcounter = 0; loopcounter < NonceSize; loopcounter++)
{
blockb0[loopcounter+1] = Nonce[loopcounter];
}
for ( ; loopcounter < 13; loopcounter++)
{
blockb0[loopcounter+1] = 0;
}
blockb0[14] = ((ILength >> 8) & 0xFF);
blockb0[15] = (ILength & 0xFF);
/************************* Formatting the initial counter *******************/
/* Byte 0:
Bits 7 and 6 are reserved and shall be set to 0
Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter blocks
are distinct from B0
Bits 0, 1, and 2 contain the same encoding of q as in B0
*/
ctr[0] = blockb0[0] & 0x07;
/* byte 1 to NonceSize is the IV (Nonce) */
for(loopcounter = 1; loopcounter < NonceSize + 1; loopcounter++)
{
ctr[loopcounter] = blockb0[loopcounter];
}
/* Set the LSB to 1 */
ctr[15] |= 0x01;
/* Crypto structures initialisation*/
CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
switch(Keysize)
{
case 128:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 192:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_192b;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
case 256:
AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_256b;
AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
keyaddr+=4;
AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
break;
default:
break;
}
/* CRYP Initialization Vectors */
AES_CRYP_IVInitStructure.CRYP_IV0Left = (__REV(*(uint32_t*)(ctraddr)));
ctraddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV0Right= (__REV(*(uint32_t*)(ctraddr)));
ctraddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Left = (__REV(*(uint32_t*)(ctraddr)));
ctraddr+=4;
AES_CRYP_IVInitStructure.CRYP_IV1Right= (__REV(*(uint32_t*)(ctraddr)));
/*------------------ AES Encryption ------------------*/
if(Mode == MODE_ENCRYPT) /* AES encryption */
{
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* CRYP Initialization Vectors */
CRYP_IVInit(&AES_CRYP_IVInitStructure);
/* Crypto Init for Key preparation for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CCM;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/***************************** Init phase *********************************/
/* Select init phase */
CRYP_PhaseConfig(CRYP_Phase_Init);
b0addr = (uint32_t)blockb0;
/* Write the blockb0 block in the IN FIFO */
CRYP_DataIn((*(uint32_t*)(b0addr)));
b0addr+=4;
CRYP_DataIn((*(uint32_t*)(b0addr)));
b0addr+=4;
CRYP_DataIn((*(uint32_t*)(b0addr)));
b0addr+=4;
CRYP_DataIn((*(uint32_t*)(b0addr)));
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
/* Wait for CRYPEN bit to be 0 */
while(CRYP_GetCmdStatus() == ENABLE)
{
}
/***************************** header phase *******************************/
if(headersize != 0)
{
/* Select header phase */
CRYP_PhaseConfig(CRYP_Phase_Header);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
}
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
}
/**************************** payload phase *******************************/
if(ILength != 0)
{
/* Select payload phase */
CRYP_PhaseConfig(CRYP_Phase_Payload);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
}
/***************************** final phase ********************************/
/* Select final phase */
CRYP_PhaseConfig(CRYP_Phase_Final);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
ctraddr = (uint32_t)ctr;
/* Write the counter block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(ctraddr));
ctraddr+=4;
CRYP_DataIn(*(uint32_t*)(ctraddr));
ctraddr+=4;
CRYP_DataIn(*(uint32_t*)(ctraddr));
ctraddr+=4;
/* Reset bit 0 (after 8-bit swap) is equivalent to reset bit 24 (before 8-bit swap) */
CRYP_DataIn(*(uint32_t*)(ctraddr) & 0xfeffffff);
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
/* Read the Auth TAG in the IN FIFO */
temptag[0] = CRYP_DataOut();
temptag[1] = CRYP_DataOut();
temptag[2] = CRYP_DataOut();
temptag[3] = CRYP_DataOut();
}
/*------------------ AES Decryption ------------------*/
else /* AES decryption */
{
/* Flush IN/OUT FIFOs */
CRYP_FIFOFlush();
/* Key Initialisation */
CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
/* CRYP Initialization Vectors */
CRYP_IVInit(&AES_CRYP_IVInitStructure);
/* Crypto Init for Key preparation for decryption process */
AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CCM;
AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
CRYP_Init(&AES_CRYP_InitStructure);
/***************************** Init phase *********************************/
/* Select init phase */
CRYP_PhaseConfig(CRYP_Phase_Init);
b0addr = (uint32_t)blockb0;
/* Write the blockb0 block in the IN FIFO */
CRYP_DataIn((*(uint32_t*)(b0addr)));
b0addr+=4;
CRYP_DataIn((*(uint32_t*)(b0addr)));
b0addr+=4;
CRYP_DataIn((*(uint32_t*)(b0addr)));
b0addr+=4;
CRYP_DataIn((*(uint32_t*)(b0addr)));
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
/* Wait for CRYPEN bit to be 0 */
while(CRYP_GetCmdStatus() == ENABLE)
{
}
/***************************** header phase *******************************/
if(headersize != 0)
{
/* Select header phase */
CRYP_PhaseConfig(CRYP_Phase_Header);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
CRYP_DataIn(*(uint32_t*)(headeraddr));
headeraddr+=4;
}
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
}
/**************************** payload phase *******************************/
if(ILength != 0)
{
/* Select payload phase */
CRYP_PhaseConfig(CRYP_Phase_Payload);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
{
/* Wait until the IFEM flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
{
}
/* Write the Input block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
CRYP_DataIn(*(uint32_t*)(inputaddr));
inputaddr+=4;
/* Wait until the complete message has been processed */
counter = 0;
do
{
busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
counter++;
}while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
if (busystatus != RESET)
{
status = ERROR;
}
else
{
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
/* Read the Output block from the Output FIFO */
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
*(uint32_t*)(outputaddr) = CRYP_DataOut();
outputaddr+=4;
}
}
}
/***************************** final phase ********************************/
/* Select final phase */
CRYP_PhaseConfig(CRYP_Phase_Final);
/* Enable Crypto processor */
CRYP_Cmd(ENABLE);
if(CRYP_GetCmdStatus() == DISABLE)
{
/* The CRYP peripheral clock is not enabled or the device doesn't embed
the CRYP peripheral (please check the device sales type. */
return(ERROR);
}
ctraddr = (uint32_t)ctr;
/* Write the counter block in the IN FIFO */
CRYP_DataIn(*(uint32_t*)(ctraddr));
ctraddr+=4;
CRYP_DataIn(*(uint32_t*)(ctraddr));
ctraddr+=4;
CRYP_DataIn(*(uint32_t*)(ctraddr));
ctraddr+=4;
/* Reset bit 0 (after 8-bit swap) is equivalent to reset bit 24 (before 8-bit swap) */
CRYP_DataIn(*(uint32_t*)(ctraddr) & 0xfeffffff);
/* Wait until the OFNE flag is reset */
while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
{
}
/* Read the Authentification TAG (MAC) in the IN FIFO */
temptag[0] = CRYP_DataOut();
temptag[1] = CRYP_DataOut();
temptag[2] = CRYP_DataOut();
temptag[3] = CRYP_DataOut();
}
/* Copy temporary authentication TAG in user TAG buffer */
for(loopcounter = 0; (loopcounter < TAGSize); loopcounter++)
{
/* Set the authentication TAG buffer */
*((uint8_t*)tagaddr+loopcounter) = *((uint8_t*)temptag+loopcounter);
}
/* Disable Crypto */
CRYP_Cmd(DISABLE);
return status;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
|
7117fa854a7944e71f8eb04071772f8e5378f03c
|
1efb2283837c9b70bc6449cec877799e4efa3268
|
/src/mpid/ch3/channels/nemesis/src/ch3_istartmsgv.c
|
68843dc9c4f8118a0a0378a0e4e612b2e31dbd6a
|
[
"mpich2"
] |
permissive
|
pmodels/mpich
|
d2392e8e30536cad3e500c16aa1e71211101d83f
|
2d265f9f5f93ebdd07ad547423bc6212868262a4
|
refs/heads/main
| 2023-09-04T05:50:15.041823
| 2023-09-01T23:07:33
| 2023-09-01T23:07:33
| 70,918,679
| 506
| 313
|
NOASSERTION
| 2023-09-14T14:38:36
| 2016-10-14T14:39:42
|
C
|
UTF-8
|
C
| false
| false
| 6,102
|
c
|
ch3_istartmsgv.c
|
/*
* Copyright (C) by Argonne National Laboratory
* See COPYRIGHT in top-level directory
*/
#include "mpidi_ch3_impl.h"
/*#include "mpidpre.h"*/
#include "mpid_nem_impl.h"
#if defined (MPID_NEM_INLINE) && MPID_NEM_INLINE
#include "mpid_nem_inline.h"
#endif
/*
* MPIDI_CH3_iStartMsgv() attempts to send the message immediately.
* If the entire message is successfully sent, then NULL is returned.
* Otherwise a request is allocated, the iovec and the first buffer
* pointed to by the iovec (which is assumed to be a MPIDI_CH3_Pkt_t)
* are copied into the request, and a pointer to the request is
* returned. An error condition also results in a request be
* allocated and the error being returned in the status field of the
* request.
*/
/* NOTE - The completion action associated with a request created by CH3_iStartMsgv() is always null (onDataAvail = 0). This
implies that CH3_iStartMsgv() can only be used when the entire message can be described by a single iovec of size
MPL_IOV_LIMIT. */
int MPIDI_CH3_iStartMsgv (MPIDI_VC_t *vc, struct iovec *iov, int n_iov, MPIR_Request **sreq_ptr)
{
MPIR_Request * sreq = *sreq_ptr = NULL;
int mpi_errno = MPI_SUCCESS;
int again = 0;
int j;
MPIR_FUNC_ENTER;
MPIR_ERR_CHKANDJUMP1(vc->state == MPIDI_VC_STATE_MORIBUND, mpi_errno, MPIX_ERR_PROC_FAILED, "**comm_fail", "**comm_fail %d", vc->pg_rank);
if (vc->ch.iStartContigMsg)
{
MPIR_Assert (n_iov > 0);
switch (n_iov)
{
case 1:
mpi_errno = vc->ch.iStartContigMsg(vc, iov[0].iov_base, iov[0].iov_len, NULL, 0, sreq_ptr);
break;
case 2:
mpi_errno = vc->ch.iStartContigMsg(vc, iov[0].iov_base, iov[0].iov_len,
iov[1].iov_base, iov[1].iov_len, sreq_ptr);
break;
default:
mpi_errno = MPID_nem_send_iov(vc, &sreq, iov, n_iov);
*sreq_ptr = sreq;
break;
}
goto fn_exit;
}
MPIR_Assert (n_iov <= MPL_IOV_LIMIT);
MPIR_Assert (iov[0].iov_len <= sizeof(MPIDI_CH3_Pkt_t));
/* The channel uses a fixed length header, the size of which is
* the maximum of all possible packet headers */
iov[0].iov_len = sizeof(MPIDI_CH3_Pkt_t);
MPIDI_DBG_Print_packet((MPIDI_CH3_Pkt_t*)iov[0].iov_base);
if (MPIDI_CH3I_Sendq_empty(MPIDI_CH3I_shm_sendq))
/* MT */
{
struct iovec *remaining_iov = iov;
int remaining_n_iov = n_iov;
MPL_DBG_MSG (MPIDI_CH3_DBG_CHANNEL, VERBOSE, "iStartMsgv");
MPL_DBG_STMT (MPIDI_CH3_DBG_CHANNEL, VERBOSE, {
int total = 0;
int i;
for (i = 0; i < n_iov; ++i)
total += iov[i].iov_len;
MPL_DBG_MSG_D (MPIDI_CH3_DBG_CHANNEL, VERBOSE, " + len=%d ", total);
});
mpi_errno = MPID_nem_mpich_sendv_header (&remaining_iov, &remaining_n_iov, vc, &again);
if (mpi_errno) MPIR_ERR_POP (mpi_errno);
while (!again && (remaining_n_iov > 0))
{
MPL_DBG_STMT (MPIDI_CH3_DBG_CHANNEL, VERBOSE, {
int total = 0;
int i;
for (i = 0; i < remaining_n_iov; ++i)
total += remaining_iov[i].iov_len;
MPL_DBG_MSG_D (MPIDI_CH3_DBG_CHANNEL, VERBOSE, " + len=%d ", total);
});
mpi_errno = MPID_nem_mpich_sendv (&remaining_iov, &remaining_n_iov, vc, &again);
if (mpi_errno) MPIR_ERR_POP (mpi_errno);
}
MPL_DBG_STMT (MPIDI_CH3_DBG_CHANNEL, VERBOSE, {
int total = 0;
int i;
for (i = 0; i < remaining_n_iov; ++i)
total += remaining_iov[i].iov_len;
MPL_DBG_MSG_D (MPIDI_CH3_DBG_CHANNEL, VERBOSE, " - len=%d ", total);
});
if (again)
{
/* Create a new request and save remaining portions of the
* iov in it. */
sreq = MPIR_Request_create(MPIR_REQUEST_KIND__UNDEFINED);
MPIR_Assert(sreq != NULL);
MPIR_Object_set_ref(sreq, 2);
sreq->kind = MPIR_REQUEST_KIND__SEND;
for (j = 0; j < remaining_n_iov; ++j)
{
sreq->dev.iov[j] = remaining_iov[j];
}
sreq->dev.iov_offset = 0;
sreq->dev.iov_count = remaining_n_iov;
sreq->dev.OnDataAvail = 0;
sreq->ch.noncontig = FALSE;
sreq->ch.vc = vc;
if ( iov == remaining_iov )
{
/* header was not sent, so iov[0] might point to something on the stack */
sreq->dev.pending_pkt = *(MPIDI_CH3_Pkt_t *) iov[0].iov_base;
sreq->dev.iov[0].iov_base = (char *) &sreq->dev.pending_pkt;
sreq->dev.iov[0].iov_len = iov[0].iov_len;
}
MPIDI_CH3I_Sendq_enqueue(&MPIDI_CH3I_shm_sendq, sreq);
MPIR_Assert (MPIDI_CH3I_shm_active_send == NULL);
MPIDI_CH3I_shm_active_send = sreq;
}
}
else
{
int i;
MPL_DBG_MSG(MPIDI_CH3_DBG_OTHER, TERSE, "request enqueued");
/* create a request */
sreq = MPIR_Request_create(MPIR_REQUEST_KIND__UNDEFINED);
MPIR_Assert(sreq != NULL);
MPIR_Object_set_ref(sreq, 2);
sreq->kind = MPIR_REQUEST_KIND__SEND;
sreq->dev.pending_pkt = *(MPIDI_CH3_Pkt_t *) iov[0].iov_base;
sreq->dev.iov[0].iov_base = (char *) &sreq->dev.pending_pkt;
sreq->dev.iov[0].iov_len = iov[0].iov_len;
/* copy iov */
for (i = 1; i < n_iov; ++i)
{
sreq->dev.iov[i] = iov[i];
}
sreq->dev.iov_offset = 0;
sreq->dev.iov_count = n_iov;
sreq->dev.OnDataAvail = 0;
sreq->ch.noncontig = FALSE;
sreq->ch.vc = vc;
if (MPIDI_CH3I_Sendq_empty(MPIDI_CH3I_shm_sendq)) {
MPIDI_CH3I_Sendq_enqueue(&MPIDI_CH3I_shm_sendq, sreq);
} else {
/* this is not the first send on the queue, enqueue it then
check to see if we can send any now */
MPIDI_CH3I_Sendq_enqueue(&MPIDI_CH3I_shm_sendq, sreq);
mpi_errno = MPIDI_CH3I_Shm_send_progress();
MPIR_ERR_CHECK(mpi_errno);
}
}
*sreq_ptr = sreq;
fn_exit:
MPIR_FUNC_EXIT;
return mpi_errno;
fn_fail:
goto fn_exit;
}
|
a2cbbf40c511218332bb7637040df68c1b83f520
|
9c4ec01e04f7b0a1d213e1060c6b0a008dde7cbd
|
/series2/iadc/iadc_scan_iadc_timer/src/main_scan_iadc_timer.c
|
1c2a42720e1cc53678f01cbeac62bca322144d8b
|
[
"Zlib"
] |
permissive
|
SiliconLabs/peripheral_examples
|
edf5ee87cd0bcb2e7ad5066e278fa1ad3b92bd35
|
87b252e5a1bf5b36a548c121e8ffda085d3bcbc4
|
refs/heads/master
| 2023-07-26T22:20:57.916375
| 2023-07-07T18:18:01
| 2023-07-07T18:20:16
| 116,865,771
| 326
| 212
|
NOASSERTION
| 2021-06-17T20:12:04
| 2018-01-09T20:13:39
|
C
|
UTF-8
|
C
| false
| false
| 11,326
|
c
|
main_scan_iadc_timer.c
|
/***************************************************************************//**
* @file main_scan_iadc_timer.c
* @brief Use the IADC to take repeated, non-blocking measurements on
* multiple inputs using IADC local timer to trigger conversions.
*******************************************************************************
* # License
* <b>Copyright 2021 Silicon Laboratories Inc. www.silabs.com</b>
*******************************************************************************
*
* SPDX-License-Identifier: Zlib
*
* The licensor of this software is Silicon Laboratories Inc.
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
*******************************************************************************
* # Evaluation Quality
* This code has been minimally tested to ensure that it builds and is suitable
* as a demonstration for evaluation purposes only. This code will be maintained
* at the sole discretion of Silicon Labs.
******************************************************************************/
#include "em_device.h"
#include "em_chip.h"
#include "em_cmu.h"
#include "em_gpio.h"
#include "em_iadc.h"
#include "bsp.h"
/*******************************************************************************
******************************* DEFINES ***********************************
******************************************************************************/
// Set CLK_ADC to 40 MHz - this will be adjusted to HFXO frequency in the
// initialization process
#define CLK_SRC_ADC_FREQ 40000000 // CLK_SRC_ADC - 40 MHz max
#define CLK_ADC_FREQ 10000000 // CLK_ADC - 10 MHz max in normal mode
// Number of scan channels
#define NUM_INPUTS 2
/*
* Specify the IADC input using the IADC_PosInput_t typedef. This
* must be paired with a corresponding macro definition that allocates
* the corresponding ABUS to the IADC. These are...
*
* GPIO->ABUSALLOC |= GPIO_ABUSALLOC_AEVEN0_ADC0
* GPIO->ABUSALLOC |= GPIO_ABUSALLOC_AODD0_ADC0
* GPIO->BBUSALLOC |= GPIO_BBUSALLOC_BEVEN0_ADC0
* GPIO->BBUSALLOC |= GPIO_BBUSALLOC_BODD0_ADC0
* GPIO->CDBUSALLOC |= GPIO_CDBUSALLOC_CDEVEN0_ADC0
* GPIO->CDBUSALLOC |= GPIO_CDBUSALLOC_CDODD0_ADC0
*
* ...for port A, port B, and port C/D pins, even and odd, respectively.
*/
#define IADC_INPUT_0_PORT_PIN iadcPosInputPortBPin0;
#define IADC_INPUT_1_PORT_PIN iadcPosInputPortBPin1;
#define IADC_INPUT_0_BUS BBUSALLOC
#define IADC_INPUT_0_BUSALLOC GPIO_BBUSALLOC_BEVEN0_ADC0
#define IADC_INPUT_1_BUS BBUSALLOC
#define IADC_INPUT_1_BUSALLOC GPIO_BBUSALLOC_BODD0_ADC0
// GPIO output toggle to notify IADC conversion complete
#define GPIO_OUTPUT_0_PORT gpioPortC
#define GPIO_OUTPUT_0_PIN 5
#if defined(BSP_WSTK_BRD4181A) || defined(BSP_WSTK_BRD4182A)
// HFXO frequency set for BRD4181A and BRD4182A
#define HFXO_FREQ 38400000
#else
// HFXO frequency for rest of radio boards
#define HFXO_FREQ 39000000
#endif
/*******************************************************************************
*************************** GLOBAL VARIABLES *******************************
******************************************************************************/
static volatile double scanResult[NUM_INPUTS];
/**************************************************************************//**
* @brief CMU initialization
*****************************************************************************/
void initCMU(void)
{
// Initialization structure for HFXO configuration
CMU_HFXOInit_TypeDef hfxoInit = CMU_HFXOINIT_DEFAULT;
// Check if device has HFXO configuration information in DEVINFO page
if (DEVINFO->MODULEINFO & DEVINFO_MODULEINFO_HFXOCALVAL) {
// Use the DEVINFO page's CTUNE values
hfxoInit.ctuneXoAna = (DEVINFO->MODXOCAL & DEVINFO_MODXOCAL_HFXOCTUNEXOANA_DEFAULT)
>> _DEVINFO_MODXOCAL_HFXOCTUNEXOANA_SHIFT;
hfxoInit.ctuneXiAna = (DEVINFO->MODXOCAL & DEVINFO_MODXOCAL_HFXOCTUNEXIANA_DEFAULT)
>> _DEVINFO_MODXOCAL_HFXOCTUNEXIANA_SHIFT;
}
// Configure HFXO settings
CMU_HFXOInit(&hfxoInit);
// Set system HFXO frequency
SystemHFXOClockSet(HFXO_FREQ);
// Enable HFXO oscillator, and wait for it to be stable
CMU_OscillatorEnable(cmuOsc_HFXO, true, true);
// Select HFXO as the EM01GRPA clock
CMU_ClockSelectSet(cmuClock_EM01GRPACLK, cmuSelect_HFXO);
}
/**************************************************************************//**
* @brief GPIO initialization
*****************************************************************************/
void initGPIO(void)
{
/*
* On EFR32xG21 devices, CMU_ClockEnable() calls have no effect as
* clocks are enabled/disabled on-demand in response to peripheral
* requests. Deleting such lines is safe on xG21 devices and will
* provide a small reduction in code size.
*/
CMU_ClockEnable(cmuClock_GPIO, true);
// Output toggled upon completing each IADC scan sequence
GPIO_PinModeSet(GPIO_OUTPUT_0_PORT, GPIO_OUTPUT_0_PIN, gpioModePushPull, 0);
}
/**************************************************************************//**
* @brief IADC initialization
*****************************************************************************/
void initIADC(void)
{
// Declare initialization structures
IADC_Init_t init = IADC_INIT_DEFAULT;
IADC_AllConfigs_t initAllConfigs = IADC_ALLCONFIGS_DEFAULT;
IADC_InitScan_t initScan = IADC_INITSCAN_DEFAULT;
// Scan table structure
IADC_ScanTable_t scanTable = IADC_SCANTABLE_DEFAULT;
CMU_ClockEnable(cmuClock_IADC0, true);
// Use the EM01GRPACLK as the IADC clock
CMU_ClockSelectSet(cmuClock_IADCCLK, cmuSelect_EM01GRPACLK);
// Shutdown between conversions to reduce current
init.warmup = iadcWarmupNormal;
// Set the HFSCLK prescale value here
init.srcClkPrescale = IADC_calcSrcClkPrescale(IADC0, CLK_SRC_ADC_FREQ, 0);
/*
* The IADC local timer runs at CLK_SRC_ADC_FREQ, which is at least
* 2x CLK_ADC_FREQ. CLK_SRC_ADC_FREQ in this example is equal to the
* HFXO frequency. Dividing the frequency of the HFXO by 1000 will give
* the tick count for 1 ms trigger rate.
* For example - if HFXO freq = 38.4 MHz,
*
* ticks for 1 ms trigger = 38400000 / 1000
* ticks = 38400
*/
init.timerCycles = CMU_ClockFreqGet(cmuClock_IADCCLK)/1000;
/*
* Configuration 0 is used by both scan and single conversions by
* default. Use internal bandgap as the reference and specify the
* reference voltage in mV.
*
* Resolution is not configurable directly but is based on the
* selected oversampling ratio (osrHighSpeed), which defaults to
* 2x and generates 12-bit results.
*/
initAllConfigs.configs[0].reference = iadcCfgReferenceInt1V2;
initAllConfigs.configs[0].vRef = 1210;
initAllConfigs.configs[0].osrHighSpeed = iadcCfgOsrHighSpeed2x;
initAllConfigs.configs[0].analogGain = iadcCfgAnalogGain0P5x;
/*
* CLK_SRC_ADC must be prescaled by some value greater than 1 to
* derive the intended CLK_ADC frequency.
*
* Based on the default 2x oversampling rate (OSRHS)...
*
* conversion time = ((4 * OSRHS) + 2) / fCLK_ADC
*
* ...which results in a maximum sampling rate of 833 ksps with the
* 2-clock input multiplexer switching time is included.
*/
initAllConfigs.configs[0].adcClkPrescale = IADC_calcAdcClkPrescale(IADC0,
CLK_ADC_FREQ,
0,
iadcCfgModeNormal,
init.srcClkPrescale);
/*
* The IADC local timer triggers conversions.
*
* Set the SCANFIFODVL flag when scan FIFO holds 2 entries. In this
* example, the interrupt associated with the SCANFIFODVL flag in
* the IADC_IF register is not used.
*
* Tag each FIFO entry with scan table entry ID.
*/
initScan.triggerSelect = iadcTriggerSelTimer;
initScan.dataValidLevel = iadcFifoCfgDvl2;
initScan.showId = true;
/*
* Configure entries in the scan table. CH0 is single-ended from
* input 0; CH1 is single-ended from input 1.
*/
scanTable.entries[0].posInput = IADC_INPUT_0_PORT_PIN;
scanTable.entries[0].negInput = iadcNegInputGnd;
scanTable.entries[0].includeInScan = true;
scanTable.entries[1].posInput = IADC_INPUT_1_PORT_PIN;
scanTable.entries[1].negInput = iadcNegInputGnd;
scanTable.entries[1].includeInScan = true;
// Initialize IADC
IADC_init(IADC0, &init, &initAllConfigs);
// Initialize scan
IADC_initScan(IADC0, &initScan, &scanTable);
// Enable the IADC timer (must be after the IADC is initialized)
IADC_command(IADC0, iadcCmdEnableTimer);
// Allocate the analog bus for ADC0 inputs
GPIO->IADC_INPUT_0_BUS |= IADC_INPUT_0_BUSALLOC;
GPIO->IADC_INPUT_1_BUS |= IADC_INPUT_1_BUSALLOC;
// Enable scan interrupts
IADC_enableInt(IADC0, IADC_IEN_SCANFIFODVL);
// Enable ADC interrupts
NVIC_ClearPendingIRQ(IADC_IRQn);
NVIC_EnableIRQ(IADC_IRQn);
}
/**************************************************************************//**
* @brief IADC interrupt handler
*****************************************************************************/
void IADC_IRQHandler(void)
{
IADC_Result_t sample;
// Toggle GPIO to signal scan completion
GPIO_PinOutToggle(GPIO_OUTPUT_0_PORT, GPIO_OUTPUT_0_PIN);
// While the FIFO count is non-zero...
while (IADC_getScanFifoCnt(IADC0))
{
// Pull a scan result from the FIFO
sample = IADC_pullScanFifoResult(IADC0);
/*
* Calculate the voltage converted as follows:
*
* For single-ended conversions, the result can range from 0 to
* +Vref, i.e., for Vref = VBGR = 1.21V, and with analog gain = 0.5,
* 0xFFF represents the full scale value of 2.42V.
*/
scanResult[sample.id] = sample.data * 2.42 / 0xFFF;
}
/*
* Clear the scan table complete interrupt. Reading from the FIFO
* does not do this automatically.
*/
IADC_clearInt(IADC0, IADC_IF_SCANFIFODVL);
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
CHIP_Init();
initCMU();
initGPIO();
initIADC();
// Start scan
IADC_command(IADC0, iadcCmdStartScan);
// Infinite loop
while (1);
}
|
976fc444ca255752509c85693cf944e3ccf18d73
|
e65a4dbfbfb0e54e59787ba7741efee12f7687f3
|
/audio/fluidsynth/files/patch-src_drivers_fluid__mdriver.h
|
ebba65ff907a429ac2dc8c9a7f0737726f6f5820
|
[
"BSD-2-Clause"
] |
permissive
|
freebsd/freebsd-ports
|
86f2e89d43913412c4f6b2be3e255bc0945eac12
|
605a2983f245ac63f5420e023e7dce56898ad801
|
refs/heads/main
| 2023-08-30T21:46:28.720924
| 2023-08-30T19:33:44
| 2023-08-30T19:33:44
| 1,803,961
| 916
| 918
|
NOASSERTION
| 2023-09-08T04:06:26
| 2011-05-26T11:15:35
| null |
UTF-8
|
C
| false
| false
| 655
|
h
|
patch-src_drivers_fluid__mdriver.h
|
--- src/drivers/fluid_mdriver.h.orig 2019-02-03 07:13:59 UTC
+++ src/drivers/fluid_mdriver.h
@@ -53,6 +53,15 @@ void delete_fluid_alsa_seq_driver(fluid_midi_driver_t
void fluid_alsa_seq_driver_settings(fluid_settings_t *settings);
#endif
+/* SNDIO */
+#if SNDIO_SUPPORT
+void fluid_sndio_midi_driver_settings(fluid_settings_t *settings);
+fluid_midi_driver_t *new_fluid_sndio_midi_driver(fluid_settings_t *settings,
+ handle_midi_event_func_t handler,
+ void *data);
+void delete_fluid_sndio_midi_driver(fluid_midi_driver_t *p);
+#endif
+
/* JACK */
#if JACK_SUPPORT
void fluid_jack_midi_driver_settings(fluid_settings_t *settings);
|
e45eaadde958933654fd4ca11a6634a0f263862a
|
a474d7e6c0dd5f8f3a0919db050ebf773780865f
|
/lib/drivers/include/i2s.h
|
946fa82ba0a5cf2d96619723e9b340e9bb050ef0
|
[
"Apache-2.0"
] |
permissive
|
kendryte/kendryte-standalone-sdk
|
7b8b1887eab040da76b4ad9063d11b8ca5e5e5b9
|
02576ba67e8797444f3ee3f34c625b5ed048e707
|
refs/heads/develop
| 2023-09-03T11:18:18.009662
| 2021-09-24T02:56:10
| 2021-09-24T02:56:10
| 147,705,154
| 416
| 158
|
Apache-2.0
| 2021-07-18T10:25:52
| 2018-09-06T16:53:21
|
C
|
UTF-8
|
C
| false
| false
| 23,357
|
h
|
i2s.h
|
/* Copyright 2018 Canaan Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _DRIVER_I2S_H
#define _DRIVER_I2S_H
#include <stddef.h>
#include <stdint.h>
#include "bsp.h"
#include "dmac.h"
#include "io.h"
#include "platform.h"
#ifdef __cplusplus
extern "C" {
#endif
#define I2S0_IN_D0 90
#define I2S0_SCLK 88
#define I2S0_WS 89
typedef enum _i2s_device_number
{
I2S_DEVICE_0 = 0,
I2S_DEVICE_1 = 1,
I2S_DEVICE_2 = 2,
I2S_DEVICE_MAX
} i2s_device_number_t;
typedef enum _i2s_channel_num
{
I2S_CHANNEL_0 = 0,
I2S_CHANNEL_1 = 1,
I2S_CHANNEL_2 = 2,
I2S_CHANNEL_3 = 3
} i2s_channel_num_t;
typedef enum _i2s_transmit
{
I2S_TRANSMITTER = 0,
I2S_RECEIVER = 1
} i2s_transmit_t;
typedef enum _i2s_work_mode
{
STANDARD_MODE = 1,
RIGHT_JUSTIFYING_MODE = 2,
LEFT_JUSTIFYING_MODE = 4
} i2s_work_mode_t;
typedef enum _sclk_gating_cycles
{
/* Clock gating is diable */
NO_CLOCK_GATING = 0x0,
/* Gating after 12 sclk cycles */
CLOCK_CYCLES_12 = 0x1,
/* Gating after 16 sclk cycles */
CLOCK_CYCLES_16 = 0x2,
/* Gating after 20 sclk cycles */
CLOCK_CYCLES_20 = 0x3,
/* Gating after 24 sclk cycles */
CLOCK_CYCLES_24 = 0x4
} i2s_sclk_gating_cycles_t;
typedef enum _word_select_cycles
{
/* 16 sclk cycles */
SCLK_CYCLES_16 = 0x0,
/* 24 sclk cycles */
SCLK_CYCLES_24 = 0x1,
/* 32 sclk cycles */
SCLK_CYCLES_32 = 0x2
} i2s_word_select_cycles_t;
typedef enum _word_length
{
/* Ignore the word length */
IGNORE_WORD_LENGTH = 0x0,
/* 12-bit data resolution of the receiver */
RESOLUTION_12_BIT = 0x1,
/* 16-bit data resolution of the receiver */
RESOLUTION_16_BIT = 0x2,
/* 20-bit data resolution of the receiver */
RESOLUTION_20_BIT = 0x3,
/* 24-bit data resolution of the receiver */
RESOLUTION_24_BIT = 0x4,
/* 32-bit data resolution of the receiver */
RESOLUTION_32_BIT = 0x5
} i2s_word_length_t;
typedef enum _fifo_threshold
{
/* Interrupt trigger when FIFO level is 1 */
TRIGGER_LEVEL_1 = 0x0,
/* Interrupt trigger when FIFO level is 2 */
TRIGGER_LEVEL_2 = 0x1,
/* Interrupt trigger when FIFO level is 3 */
TRIGGER_LEVEL_3 = 0x2,
/* Interrupt trigger when FIFO level is 4 */
TRIGGER_LEVEL_4 = 0x3,
/* Interrupt trigger when FIFO level is 5 */
TRIGGER_LEVEL_5 = 0x4,
/* Interrupt trigger when FIFO level is 6 */
TRIGGER_LEVEL_6 = 0x5,
/* Interrupt trigger when FIFO level is 7 */
TRIGGER_LEVEL_7 = 0x6,
/* Interrupt trigger when FIFO level is 8 */
TRIGGER_LEVEL_8 = 0x7,
/* Interrupt trigger when FIFO level is 9 */
TRIGGER_LEVEL_9 = 0x8,
/* Interrupt trigger when FIFO level is 10 */
TRIGGER_LEVEL_10 = 0x9,
/* Interrupt trigger when FIFO level is 11 */
TRIGGER_LEVEL_11 = 0xa,
/* Interrupt trigger when FIFO level is 12 */
TRIGGER_LEVEL_12 = 0xb,
/* Interrupt trigger when FIFO level is 13 */
TRIGGER_LEVEL_13 = 0xc,
/* Interrupt trigger when FIFO level is 14 */
TRIGGER_LEVEL_14 = 0xd,
/* Interrupt trigger when FIFO level is 15 */
TRIGGER_LEVEL_15 = 0xe,
/* Interrupt trigger when FIFO level is 16 */
TRIGGER_LEVEL_16 = 0xf
} i2s_fifo_threshold_t;
typedef struct _i2s_ier
{
/* Bit 0 is ien, 0 for disable i2s and 1 for enable i2s */
uint32_t ien : 1;
/* Bits [31:1] is reserved */
uint32_t resv : 31;
} __attribute__((packed, aligned(4))) i2s_ier_t;
typedef union _ier_u
{
i2s_ier_t ier;
uint32_t reg_data;
} ier_t;
typedef struct _i2s_irer
{
/* Bit 0 is receiver block enable,
* 0 for receiver disable
* 1 for receiver enable
*/
uint32_t rxen : 1;
/* Bits [31:1] is reserved */
uint32_t resv : 31;
} __attribute__((packed, aligned(4))) i2s_irer_t;
typedef union _irer_u
{
i2s_irer_t irer;
uint32_t reg_data;
} irer_t;
typedef struct _i2s_iter
{
uint32_t txen : 1;
/* Bit 0 is transmitter block enable,
* 0 for transmitter disable
* 1 for transmitter enable
*/
uint32_t resv : 31;
/* Bits [31:1] is reserved */
} __attribute__((packed, aligned(4))) i2s_iter_t;
typedef union _iter_u
{
i2s_iter_t iter;
uint32_t reg_data;
} iter_t;
typedef struct _i2s_cer
{
uint32_t clken : 1;
/* Bit 0 is clock generation enable/disable,
* 0 for clock generation disable,
* 1 for clock generation enable
*/
uint32_t resv : 31;
/* Bits [31:1] is reserved */
} __attribute__((packed, aligned(4))) i2s_cer_t;
typedef union _cer_u
{
i2s_cer_t cer;
uint32_t reg_data;
} cer_t;
typedef struct _i2s_ccr
{
/* Bits [2:0] is used to program the gating of sclk,
* 0x0 for clock gating is diable,
* 0x1 for gating after 12 sclk cycles
* 0x2 for gating after 16 sclk cycles
* 0x3 for gating after 20 sclk cycles
* 0x4 for gating after 24 sclk cycles
*/
uint32_t clk_gate : 3;
/* Bits [4:3] used program the number of sclk cycles for which the
* word select line stayd in the left aligned or right aligned mode.
* 0x0 for 16sclk cycles, 0x1 for 24 sclk cycles 0x2 for 32 sclk
* cycles
*/
uint32_t clk_word_size : 2;
/* Bit[5:7] is alignment mode setting.
* 0x1 for standard i2s format
* 0x2 for right aligned format
* 0x4 for left aligned format
*/
uint32_t align_mode : 3;
/* Bit[8] is DMA transmit enable control */
uint32_t dma_tx_en : 1;
/* Bit[9] is DMA receive enable control */
uint32_t dma_rx_en : 1;
uint32_t dma_divide_16 : 1;
/* Bit[10] split 32bit data to two 16 bit data and filled in left
* and right channel. Used with dma_tx_en or dma_rx_en
*/
uint32_t sign_expand_en : 1;
uint32_t resv : 20;
/* Bits [31:11] is reseved */
} __attribute__((packed, aligned(4))) i2s_ccr_t;
typedef union _ccr_u
{
i2s_ccr_t ccr;
uint32_t reg_data;
} ccr_t;
typedef struct _i2s_rxffr
{
uint32_t rxffr : 1;
/* Bit 0 is receiver FIFO reset,
* 0 for does not flush RX FIFO, 1 for flush RX FIFO
*/
uint32_t resv : 31;
/* Bits [31:1] is reserved */
} __attribute__((packed, aligned(4))) i2s_rxffr_t;
typedef union _rxffr_u
{
i2s_rxffr_t rxffr;
uint32_t reg_data;
} rxffr_t;
typedef struct _i2s_lrbrthr
{
uint32_t fifo : 16;
/* Bits [15:0] if used data receive or transmit */
uint32_t resv : 16;
} i2s_lrbrthr_t;
typedef union _lrbthr_u
{
i2s_lrbrthr_t buffer;
uint32_t reg_data;
} lrbthr_t;
typedef struct _i2s_rthr
{
/* Bits [15:0] is right stereo data transmitted serially
* from transmit channel input
*/
uint32_t rthrx : 16;
/* Bits [31:16] is reserved */
uint32_t resv : 16;
} __attribute__((packed, aligned(4))) i2s_rthr_t;
typedef union _rthr_u
{
i2s_rthr_t rthr;
uint32_t reg_data;
} rthr_t;
typedef struct _i2s_rer
{
/* Bit 0 is receive channel enable/disable, 0 for receive channel disable,
*1 for receive channel enable
*/
uint32_t rxchenx : 1;
/* Bits [31:1] is reseved */
uint32_t resv : 31;
} __attribute__((packed, aligned(4))) i2s_rer_t;
typedef union _rer_u
{
i2s_rer_t rer;
uint32_t reg_data;
} rer_t;
typedef struct _i2s_ter
{
/* Bit 0 is transmit channel enable/disable, 0 for transmit channel disable,
* 1 for transmit channel enable
*/
uint32_t txchenx : 1;
/* Bits [31:1] is reseved */
uint32_t resv : 31;
} __attribute__((packed, aligned(4))) i2s_ter_t;
typedef union _ter_u
{
i2s_ter_t ter;
uint32_t reg_data;
} ter_t;
typedef struct _i2s_rcr_tcr
{
/* Bits [2:0] is used to program desired data resolution of
* receiver/transmitter,
* 0x0 for ignore the word length
* 0x1 for 12-bit data resolution of the receiver/transmitter,
* 0x2 for 16-bit data resolution of the receiver/transmitter,
* 0x3 for 20-bit data resolution of the receiver/transmitter,
* 0x4 for 24-bit data resolution of the receiver/transmitter,
* 0x5 for 32-bit data resolution of the receiver/transmitter
*/
uint32_t wlen : 3;
/* Bits [31:3] is reseved */
uint32_t resv : 29;
} __attribute__((packed, aligned(4))) i2s_rcr_tcr_t;
typedef union _rcr_tcr_u
{
i2s_rcr_tcr_t rcr_tcr;
uint32_t reg_data;
} rcr_tcr_t;
typedef struct _i2s_isr
{
/* Bit 0 is status of receiver data avaliable interrupt
* 0x0 for RX FIFO trigger level not reached
* 0x1 for RX FIFO trigger level is reached
*/
uint32_t rxda : 1;
/* Bit 1 is status of data overrun interrupt for rx channel
* 0x0 for RX FIFO write valid
* 0x1 for RX FIFO write overrun
*/
uint32_t rxfo : 1;
/* Bits [3:2] is reserved */
uint32_t resv1 : 2;
/* Bit 4 is status of transmit empty triger interrupt
* 0x0 for TX FIFO triiger level is reach
* 0x1 for TX FIFO trigger level is not reached
*/
uint32_t txfe : 1;
/* BIt 5 is status of data overrun interrupt for the TX channel
* 0x0 for TX FIFO write valid
* 0x1 for TX FIFO write overrun
*/
uint32_t txfo : 1;
/* BIts [31:6] is reserved */
uint32_t resv2 : 26;
} __attribute__((packed, aligned(4))) i2s_isr_t;
typedef union _isr_u
{
i2s_isr_t isr;
uint32_t reg_data;
} isr_t;
typedef struct _i2s_imr
{
/* Bit 0 is mask RX FIFO data available interrupt
* 0x0 for unmask RX FIFO data available interrupt
* 0x1 for mask RX FIFO data available interrupt
*/
uint32_t rxdam : 1;
/* Bit 1 is mask RX FIFO overrun interrupt
* 0x0 for unmask RX FIFO overrun interrupt
* 0x1 for mask RX FIFO overrun interrupt
*/
uint32_t rxfom : 1;
/* Bits [3:2] is reserved */
uint32_t resv1 : 2;
/* Bit 4 is mask TX FIFO empty interrupt,
* 0x0 for unmask TX FIFO empty interrupt,
* 0x1 for mask TX FIFO empty interrupt
*/
uint32_t txfem : 1;
/* BIt 5 is mask TX FIFO overrun interrupt
* 0x0 for mask TX FIFO overrun interrupt
* 0x1 for unmash TX FIFO overrun interrupt
*/
uint32_t txfom : 1;
/* Bits [31:6] is reserved */
uint32_t resv2 : 26;
} __attribute__((packed, aligned(4))) i2s_imr_t;
typedef union _imr_u
{
i2s_imr_t imr;
uint32_t reg_data;
} imr_t;
typedef struct _i2s_ror
{
/* Bit 0 is read this bit to clear RX FIFO data overrun interrupt
* 0x0 for RX FIFO write valid,
*0x1 for RX FIFO write overrun
*/
uint32_t rxcho : 1;
/* Bits [31:1] is reserved */
uint32_t resv : 31;
} __attribute__((packed, aligned(4))) i2s_ror_t;
typedef union _ror_u
{
i2s_ror_t ror;
uint32_t reg_data;
} ror_t;
typedef struct _i2s_tor
{
/* Bit 0 is read this bit to clear TX FIFO data overrun interrupt
* 0x0 for TX FIFO write valid,
*0x1 for TX FIFO write overrun
*/
uint32_t txcho : 1;
/* Bits [31:1] is reserved */
uint32_t resv : 31;
} __attribute__((packed, aligned(4))) i2s_tor_t;
typedef union _tor_u
{
i2s_tor_t tor;
uint32_t reg_data;
} tor_t;
typedef struct _i2s_rfcr
{
/* Bits [3:0] is used program the trigger level in the RX FIFO at
* which the receiver data available interrupt generate,
* 0x0 for interrupt trigger when FIFO level is 1,
* 0x2 for interrupt trigger when FIFO level is 2,
* 0x3 for interrupt trigger when FIFO level is 4,
* 0x4 for interrupt trigger when FIFO level is 5,
* 0x5 for interrupt trigger when FIFO level is 6,
* 0x6 for interrupt trigger when FIFO level is 7,
* 0x7 for interrupt trigger when FIFO level is 8,
* 0x8 for interrupt trigger when FIFO level is 9,
* 0x9 for interrupt trigger when FIFO level is 10,
* 0xa for interrupt trigger when FIFO level is 11,
* 0xb for interrupt trigger when FIFO level is 12,
* 0xc for interrupt trigger when FIFO level is 13,
* 0xd for interrupt trigger when FIFO level is 14,
* 0xe for interrupt trigger when FIFO level is 15,
* 0xf for interrupt trigger when FIFO level is 16
*/
uint32_t rxchdt : 4;
/* Bits [31:4] is reserved */
uint32_t rsvd_rfcrx : 28;
} __attribute__((packed, aligned(4))) i2s_rfcr_t;
typedef union _rfcr_u
{
i2s_rfcr_t rfcr;
uint32_t reg_data;
} rfcr_t;
typedef struct _i2s_tfcr
{
/* Bits [3:0] is used program the trigger level in the TX FIFO at
* which the receiver data available interrupt generate,
* 0x0 for interrupt trigger when FIFO level is 1,
* 0x2 for interrupt trigger when FIFO level is 2,
* 0x3 for interrupt trigger when FIFO level is 4,
* 0x4 for interrupt trigger when FIFO level is 5,
* 0x5 for interrupt trigger when FIFO level is 6,
* 0x6 for interrupt trigger when FIFO level is 7,
* 0x7 for interrupt trigger when FIFO level is 8,
* 0x8 for interrupt trigger when FIFO level is 9,
* 0x9 for interrupt trigger when FIFO level is 10,
* 0xa for interrupt trigger when FIFO level is 11,
* 0xb for interrupt trigger when FIFO level is 12,
* 0xc for interrupt trigger when FIFO level is 13,
* 0xd for interrupt trigger when FIFO level is 14,
* 0xe for interrupt trigger when FIFO level is 15,
* 0xf for interrupt trigger when FIFO level is 16
*/
uint32_t txchet : 4;
/* Bits [31:4] is reserved */
uint32_t rsvd_tfcrx : 28;
} __attribute__((packed, aligned(4))) i2s_tfcr_t;
typedef union _tfcr_u
{
i2s_tfcr_t tfcr;
uint32_t reg_data;
} tfcr_t;
typedef struct _i2s_rff
{
/* Bit 0 is receiver channel FIFO reset,
* 0x0 for does not flush an individual RX FIFO,
* 0x1 for flush an indiviadual RX FIFO
*/
uint32_t rxchfr : 1;
/*< Bits [31:1] is reserved ,write only */
uint32_t rsvd_rffx : 31;
} __attribute__((packed, aligned(4))) i2s_rff_t;
typedef union _rff_u
{
i2s_rff_t rff;
uint32_t reg_data;
} rff_t;
typedef struct _i2s_tff
{
/* Bit 0 is transmit channel FIFO reset,
* 0x0 for does not flush an individual TX FIFO,
* 0x1 for flush an indiviadual TX FIFO
*/
uint32_t rtxchfr : 1;
/*< Bits [31:1] is reserved ,write only */
uint32_t rsvd_rffx : 31;
} __attribute__((packed, aligned(4))) i2s_tff_t;
typedef union tff_u
{
i2s_tff_t tff;
uint32_t reg_data;
} tff_t;
typedef struct _i2s_channel
{
/* Left Receive or Left Transmit Register (0x20) */
volatile uint32_t left_rxtx;
/* Right Receive or Right Transmit Register (0x24) */
volatile uint32_t right_rxtx;
/* Receive Enable Register (0x28) */
volatile uint32_t rer;
/* Transmit Enable Register (0x2c) */
volatile uint32_t ter;
/* Receive Configuration Register (0x30) */
volatile uint32_t rcr;
/* Transmit Configuration Register (0x34) */
volatile uint32_t tcr;
/* Interrupt Status Register (0x38) */
volatile uint32_t isr;
/* Interrupt Mask Register (0x3c) */
volatile uint32_t imr;
/* Receive Overrun Register (0x40) */
volatile uint32_t ror;
/* Transmit Overrun Register (0x44) */
volatile uint32_t tor;
/* Receive FIFO Configuration Register (0x48) */
volatile uint32_t rfcr;
/* Transmit FIFO Configuration Register (0x4c) */
volatile uint32_t tfcr;
/* Receive FIFO Flush Register (0x50) */
volatile uint32_t rff;
/* Transmit FIFO Flush Register (0x54) */
volatile uint32_t tff;
/* reserved (0x58-0x5c) */
volatile uint32_t reserved1[2];
} __attribute__((packed, aligned(4))) i2s_channel_t;
/****is* i2s.api/dw_i2s_portmap
* NAME
* i2s_t
* DESCRIPTION
* This is the structure used for accessing the i2s register
* portmap.
* EXAMPLE
* struct i2s_t *portmap;
* portmap = (struct dw_i2s_portmap *) DW_APB_I2S_BASE;
* SOURCE
*/
typedef struct _i2s
{
/* I2S Enable Register (0x00) */
volatile uint32_t ier;
/* I2S Receiver Block Enable Register (0x04) */
volatile uint32_t irer;
/* I2S Transmitter Block Enable Register (0x08) */
volatile uint32_t iter;
/* Clock Enable Register (0x0c) */
volatile uint32_t cer;
/* Clock Configuration Register (0x10) */
volatile uint32_t ccr;
/* Receiver Block FIFO Reset Register (0x04) */
volatile uint32_t rxffr;
/* Transmitter Block FIFO Reset Register (0x18) */
volatile uint32_t txffr;
/* reserved (0x1c) */
volatile uint32_t reserved1;
volatile i2s_channel_t channel[4];
/* reserved (0x118-0x1bc) */
volatile uint32_t reserved2[40];
/* Receiver Block DMA Register (0x1c0) */
volatile uint32_t rxdma;
/* Reset Receiver Block DMA Register (0x1c4) */
volatile uint32_t rrxdma;
/* Transmitter Block DMA Register (0x1c8) */
volatile uint32_t txdma;
/* Reset Transmitter Block DMA Register (0x1cc) */
volatile uint32_t rtxdma;
/* reserved (0x1d0-0x1ec) */
volatile uint32_t reserved3[8];
/* Component Parameter Register 2 (0x1f0) */
volatile uint32_t i2s_comp_param_2;
/* Component Parameter Register 1 (0x1f4) */
volatile uint32_t i2s_comp_param_1;
/* I2S Component Version Register (0x1f8) */
volatile uint32_t i2s_comp_version_1;
/* I2S Component Type Register (0x1fc) */
volatile uint32_t i2s_comp_type;
} __attribute__((packed, aligned(4))) i2s_t;
typedef enum _i2s_transfer_mode
{
I2S_SEND,
I2S_RECEIVE,
} i2s_transfer_mode_t;
typedef struct _i2s_data_t
{
dmac_channel_number_t tx_channel;
dmac_channel_number_t rx_channel;
uint32_t *tx_buf;
size_t tx_len;
uint32_t *rx_buf;
size_t rx_len;
i2s_transfer_mode_t transfer_mode;
bool nowait_dma_idle;
bool wait_dma_done;
} i2s_data_t;
/**
* @brief I2S object instance
*/
extern volatile i2s_t *const i2s[3];
/**
* @brief I2s init
*
* @param[in] device_num The device number
* @param[in] rxtx_mode I2s work mode
* @param[in] channel_mask Channel mask to which channel work
*
*/
void i2s_init(i2s_device_number_t device_num, i2s_transmit_t rxtx_mode, uint32_t channel_mask);
/**
* @brief Read pcm data from dma
*
* @param[in] device_num which of device
* @param[in] buf save read data
* @param[in] buf_len the length to read form i2s
* @param[in] channel_num The dma channel number
*
* @return result
* - 0 Success
* - Other Fail
*/
void i2s_receive_data_dma(i2s_device_number_t device_num, uint32_t *buf, size_t buf_len,
dmac_channel_number_t channel_num);
/**
* @brief Write pcm data to channel_num channel by dma, first wait dmac done
*
* @param[in] device_num which of device
* @param[in] pcm Send data
* @param[in] buf_len Send data length
* @param[in] channel_num dmac channel
*
*/
void i2s_send_data_dma(i2s_device_number_t device_num, const void *buf, size_t buf_len, dmac_channel_number_t channel_num);
/**
* @brief I2S receive channel configure
*
* @param[in] device_num The device number
* @param[in] channel_num The channel number
* @param[in] word_length The word length
* @param[in] word_select_size The word select size
* @param[in] trigger_level The trigger level
*/
void i2s_rx_channel_config(i2s_device_number_t device_num,
i2s_channel_num_t channel_num,
i2s_word_length_t word_length,
i2s_word_select_cycles_t word_select_size,
i2s_fifo_threshold_t trigger_level,
i2s_work_mode_t word_mode);
/**
* @brief I2S transmit channel enable
*
* @param[in] device_num The device number
* @param[in] channel_num The channel number
* @param[in] word_length The word length
* @param[in] word_select_size The word select size
* @param[in] trigger_level The trigger level
*/
void i2s_tx_channel_config(i2s_device_number_t device_num,
i2s_channel_num_t channel_num,
i2s_word_length_t word_length,
i2s_word_select_cycles_t word_select_size,
i2s_fifo_threshold_t trigger_level,
i2s_work_mode_t word_mode);
/**
* @brief Play PCM format audio
*
* @param[in] device_num The device number
* @param[in] channel_num The channel number
* @param[in] buf PCM data
* @param[in] buf_len PCM data length
* @param[in] frame Transmit amount once
* @param[in] bits_per_sample Sample bit length
* @param[in] track_num Track amount
*/
void i2s_play(i2s_device_number_t device_num, dmac_channel_number_t channel_num,
const uint8_t *buf, size_t buf_len, size_t frame, size_t bits_per_sample, uint8_t track_num);
/**
* @brief Play PCM format audio
*
* @param[in] device_num The device number
* @param[in] sample_rate The Sample rate
*
*
* @return The real sample rate
*/
uint32_t i2s_set_sample_rate(i2s_device_number_t device_num, uint32_t sample_rate);
/**
* @brief Set dma_divide_16 split 32bit data to two 16 bit data and filled in left
* and right channel. Used with dma_tx_en or dma_rx_en
*
* @param[in] device_num The device number
* @param[in] enable The value of dma_divide_16 0:disable 1:enable
*
* @return result
* - 0 Success
* - Other Fail
*/
int i2s_set_dma_divide_16(i2s_device_number_t device_num, uint32_t enable);
/**
* @brief Get dma_divide_16.
*
* @param[in] device_num The device number
*
* @return result
* - <0 Fail
* - other value of dma_divide_16
*/
int i2s_get_dma_divide_16(i2s_device_number_t device_num);
/**
* @brief I2s handle transfer data operations
*
* @param[in] device_num I2s device number
* @param[in] data I2s data information
* @param[in] cb I2s dma callback
*
*/
void i2s_handle_data_dma(i2s_device_number_t device_num, i2s_data_t data, plic_interrupt_t *cb);
#ifdef __cplusplus
}
#endif
#endif
|
a45b067742cd20f414a81fe5a12e7c40792026e1
|
9ceacf33fd96913cac7ef15492c126d96cae6911
|
/sys/net/if_pppx.c
|
66826738bf3b9940b02fb1f82b2e7ff18deecffb
|
[
"BSD-3-Clause"
] |
permissive
|
openbsd/src
|
ab97ef834fd2d5a7f6729814665e9782b586c130
|
9e79f3a0ebd11a25b4bff61e900cb6de9e7795e9
|
refs/heads/master
| 2023-09-02T18:54:56.624627
| 2023-09-02T15:16:12
| 2023-09-02T15:16:12
| 66,966,208
| 3,394
| 1,235
| null | 2023-08-08T02:42:25
| 2016-08-30T18:18:25
|
C
|
UTF-8
|
C
| false
| false
| 32,290
|
c
|
if_pppx.c
|
/* $OpenBSD: if_pppx.c,v 1.126 2023/02/10 14:34:17 visa Exp $ */
/*
* Copyright (c) 2010 Claudio Jeker <claudio@openbsd.org>
* Copyright (c) 2010 David Gwynne <dlg@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*-
* Copyright (c) 2009 Internet Initiative Japan Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/queue.h>
#include <sys/pool.h>
#include <sys/mbuf.h>
#include <sys/errno.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/vnode.h>
#include <sys/event.h>
#include <sys/mutex.h>
#include <sys/refcnt.h>
#include <net/if.h>
#include <net/if_types.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <net/if_dl.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#ifdef INET6
#include <netinet6/in6_var.h>
#include <netinet/ip6.h>
#include <netinet6/nd6.h>
#endif /* INET6 */
#include "bpfilter.h"
#if NBPFILTER > 0
#include <net/bpf.h>
#endif
#include "pf.h"
#if NPF > 0
#include <net/pfvar.h>
#endif
#include <net/ppp_defs.h>
#include <net/ppp-comp.h>
#include <crypto/arc4.h>
#ifdef PIPEX
#include <net/radix.h>
#include <net/pipex.h>
#include <net/pipex_local.h>
#else
#error PIPEX option not enabled
#endif
#ifdef PPPX_DEBUG
#define PPPX_D_INIT (1<<0)
int pppxdebug = 0;
#define DPRINTF(_m, _p...) do { \
if (ISSET(pppxdebug, (_m))) \
printf(_p); \
} while (0)
#else
#define DPRINTF(_m, _p...) /* _m, _p */
#endif
struct pppx_if;
/*
* Locks used to protect struct members and global data
* I immutable after creation
* K kernel lock
* N net lock
* m pxd_mtx
*/
struct pppx_dev {
LIST_ENTRY(pppx_dev) pxd_entry; /* [K] */
int pxd_unit; /* [I] */
/* kq shizz */
struct mutex pxd_mtx;
struct klist pxd_rklist; /* [m] */
struct klist pxd_wklist; /* [m] */
/* queue of packets for userland to service - protected by splnet */
struct mbuf_queue pxd_svcq;
int pxd_waiting; /* [N] */
LIST_HEAD(,pppx_if) pxd_pxis; /* [K] */
};
LIST_HEAD(, pppx_dev) pppx_devs =
LIST_HEAD_INITIALIZER(pppx_devs); /* [K] */
struct pool pppx_if_pl;
struct pppx_dev *pppx_dev_lookup(dev_t);
struct pppx_dev *pppx_dev2pxd(dev_t);
struct pppx_if_key {
int pxik_session_id; /* [I] */
int pxik_protocol; /* [I] */
};
struct pppx_if {
struct pppx_if_key pxi_key; /* [I] must be first
in the struct */
struct refcnt pxi_refcnt;
RBT_ENTRY(pppx_if) pxi_entry; /* [K] */
LIST_ENTRY(pppx_if) pxi_list; /* [K] */
int pxi_ready; /* [K] */
int pxi_unit; /* [I] */
struct ifnet pxi_if;
struct pppx_dev *pxi_dev; /* [I] */
struct pipex_session *pxi_session; /* [I] */
};
static inline int
pppx_if_cmp(const struct pppx_if *a, const struct pppx_if *b)
{
return memcmp(&a->pxi_key, &b->pxi_key, sizeof(a->pxi_key));
}
RBT_HEAD(pppx_ifs, pppx_if) pppx_ifs = RBT_INITIALIZER(&pppx_ifs); /* [N] */
RBT_PROTOTYPE(pppx_ifs, pppx_if, pxi_entry, pppx_if_cmp);
int pppx_if_next_unit(void);
struct pppx_if *pppx_if_find_locked(struct pppx_dev *, int, int);
static inline struct pppx_if *pppx_if_find(struct pppx_dev *, int, int);
static inline void pppx_if_rele(struct pppx_if *);
int pppx_add_session(struct pppx_dev *,
struct pipex_session_req *);
int pppx_del_session(struct pppx_dev *,
struct pipex_session_close_req *);
int pppx_set_session_descr(struct pppx_dev *,
struct pipex_session_descr_req *);
void pppx_if_destroy(struct pppx_dev *, struct pppx_if *);
void pppx_if_qstart(struct ifqueue *);
int pppx_if_output(struct ifnet *, struct mbuf *,
struct sockaddr *, struct rtentry *);
int pppx_if_ioctl(struct ifnet *, u_long, caddr_t);
void pppxattach(int);
void filt_pppx_rdetach(struct knote *);
int filt_pppx_read(struct knote *, long);
int filt_pppx_modify(struct kevent *, struct knote *);
int filt_pppx_process(struct knote *, struct kevent *);
const struct filterops pppx_rd_filtops = {
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
.f_attach = NULL,
.f_detach = filt_pppx_rdetach,
.f_event = filt_pppx_read,
.f_modify = filt_pppx_modify,
.f_process = filt_pppx_process,
};
void filt_pppx_wdetach(struct knote *);
int filt_pppx_write(struct knote *, long);
const struct filterops pppx_wr_filtops = {
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
.f_attach = NULL,
.f_detach = filt_pppx_wdetach,
.f_event = filt_pppx_write,
.f_modify = filt_pppx_modify,
.f_process = filt_pppx_process,
};
struct pppx_dev *
pppx_dev_lookup(dev_t dev)
{
struct pppx_dev *pxd;
int unit = minor(dev);
LIST_FOREACH(pxd, &pppx_devs, pxd_entry) {
if (pxd->pxd_unit == unit)
return (pxd);
}
return (NULL);
}
struct pppx_dev *
pppx_dev2pxd(dev_t dev)
{
struct pppx_dev *pxd;
pxd = pppx_dev_lookup(dev);
return (pxd);
}
void
pppxattach(int n)
{
pool_init(&pppx_if_pl, sizeof(struct pppx_if), 0, IPL_NONE,
PR_WAITOK, "pppxif", NULL);
pipex_init();
}
int
pppxopen(dev_t dev, int flags, int mode, struct proc *p)
{
struct pppx_dev *pxd;
pxd = malloc(sizeof(*pxd), M_DEVBUF, M_WAITOK | M_ZERO);
if (pppx_dev_lookup(dev) != NULL) {
free(pxd, M_DEVBUF, sizeof(*pxd));
return (EBUSY);
}
pxd->pxd_unit = minor(dev);
mtx_init(&pxd->pxd_mtx, IPL_NET);
klist_init_mutex(&pxd->pxd_rklist, &pxd->pxd_mtx);
klist_init_mutex(&pxd->pxd_wklist, &pxd->pxd_mtx);
LIST_INIT(&pxd->pxd_pxis);
mq_init(&pxd->pxd_svcq, 128, IPL_NET);
LIST_INSERT_HEAD(&pppx_devs, pxd, pxd_entry);
return 0;
}
int
pppxread(dev_t dev, struct uio *uio, int ioflag)
{
struct pppx_dev *pxd = pppx_dev2pxd(dev);
struct mbuf *m, *m0;
int error = 0;
size_t len;
if (!pxd)
return (ENXIO);
while ((m0 = mq_dequeue(&pxd->pxd_svcq)) == NULL) {
if (ISSET(ioflag, IO_NDELAY))
return (EWOULDBLOCK);
NET_LOCK();
pxd->pxd_waiting = 1;
error = rwsleep_nsec(pxd, &netlock,
(PZERO + 1)|PCATCH, "pppxread", INFSLP);
NET_UNLOCK();
if (error != 0) {
return (error);
}
}
while (m0 != NULL && uio->uio_resid > 0 && error == 0) {
len = ulmin(uio->uio_resid, m0->m_len);
if (len != 0)
error = uiomove(mtod(m0, caddr_t), len, uio);
m = m_free(m0);
m0 = m;
}
m_freem(m0);
return (error);
}
int
pppxwrite(dev_t dev, struct uio *uio, int ioflag)
{
struct pppx_dev *pxd = pppx_dev2pxd(dev);
struct pppx_hdr *th;
struct pppx_if *pxi;
uint32_t proto;
struct mbuf *top, **mp, *m;
int tlen;
int error = 0;
size_t mlen;
if (uio->uio_resid < sizeof(*th) + sizeof(uint32_t) ||
uio->uio_resid > MCLBYTES)
return (EMSGSIZE);
tlen = uio->uio_resid;
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
return (ENOBUFS);
mlen = MHLEN;
if (uio->uio_resid > MHLEN) {
MCLGET(m, M_DONTWAIT);
if (!(m->m_flags & M_EXT)) {
m_free(m);
return (ENOBUFS);
}
mlen = MCLBYTES;
}
top = NULL;
mp = ⊤
while (error == 0 && uio->uio_resid > 0) {
m->m_len = ulmin(mlen, uio->uio_resid);
error = uiomove(mtod (m, caddr_t), m->m_len, uio);
*mp = m;
mp = &m->m_next;
if (error == 0 && uio->uio_resid > 0) {
MGET(m, M_DONTWAIT, MT_DATA);
if (m == NULL) {
error = ENOBUFS;
break;
}
mlen = MLEN;
if (uio->uio_resid >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
if (!(m->m_flags & M_EXT)) {
error = ENOBUFS;
m_free(m);
break;
}
mlen = MCLBYTES;
}
}
}
if (error) {
m_freem(top);
return (error);
}
top->m_pkthdr.len = tlen;
/* Find the interface */
th = mtod(top, struct pppx_hdr *);
m_adj(top, sizeof(struct pppx_hdr));
pxi = pppx_if_find(pxd, th->pppx_id, th->pppx_proto);
if (pxi == NULL) {
m_freem(top);
return (EINVAL);
}
top->m_pkthdr.ph_ifidx = pxi->pxi_if.if_index;
#if NBPFILTER > 0
if (pxi->pxi_if.if_bpf)
bpf_mtap(pxi->pxi_if.if_bpf, top, BPF_DIRECTION_IN);
#endif
/* strip the tunnel header */
proto = ntohl(*(uint32_t *)(th + 1));
m_adj(top, sizeof(uint32_t));
NET_LOCK();
switch (proto) {
case AF_INET:
ipv4_input(&pxi->pxi_if, top);
break;
#ifdef INET6
case AF_INET6:
ipv6_input(&pxi->pxi_if, top);
break;
#endif
default:
m_freem(top);
error = EAFNOSUPPORT;
break;
}
NET_UNLOCK();
pppx_if_rele(pxi);
return (error);
}
int
pppxioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p)
{
struct pppx_dev *pxd = pppx_dev2pxd(dev);
int error = 0;
switch (cmd) {
case PIPEXASESSION:
error = pppx_add_session(pxd,
(struct pipex_session_req *)addr);
break;
case PIPEXDSESSION:
error = pppx_del_session(pxd,
(struct pipex_session_close_req *)addr);
break;
case PIPEXSIFDESCR:
error = pppx_set_session_descr(pxd,
(struct pipex_session_descr_req *)addr);
break;
case FIONBIO:
break;
case FIONREAD:
*(int *)addr = mq_hdatalen(&pxd->pxd_svcq);
break;
default:
error = pipex_ioctl(pxd, cmd, addr);
break;
}
return (error);
}
int
pppxkqfilter(dev_t dev, struct knote *kn)
{
struct pppx_dev *pxd = pppx_dev2pxd(dev);
struct klist *klist;
switch (kn->kn_filter) {
case EVFILT_READ:
klist = &pxd->pxd_rklist;
kn->kn_fop = &pppx_rd_filtops;
break;
case EVFILT_WRITE:
klist = &pxd->pxd_wklist;
kn->kn_fop = &pppx_wr_filtops;
break;
default:
return (EINVAL);
}
kn->kn_hook = pxd;
klist_insert(klist, kn);
return (0);
}
void
filt_pppx_rdetach(struct knote *kn)
{
struct pppx_dev *pxd = kn->kn_hook;
klist_remove(&pxd->pxd_rklist, kn);
}
int
filt_pppx_read(struct knote *kn, long hint)
{
struct pppx_dev *pxd = kn->kn_hook;
MUTEX_ASSERT_LOCKED(&pxd->pxd_mtx);
kn->kn_data = mq_hdatalen(&pxd->pxd_svcq);
return (kn->kn_data > 0);
}
void
filt_pppx_wdetach(struct knote *kn)
{
struct pppx_dev *pxd = kn->kn_hook;
klist_remove(&pxd->pxd_wklist, kn);
}
int
filt_pppx_write(struct knote *kn, long hint)
{
/* We're always ready to accept a write. */
return (1);
}
int
filt_pppx_modify(struct kevent *kev, struct knote *kn)
{
struct pppx_dev *pxd = kn->kn_hook;
int active;
mtx_enter(&pxd->pxd_mtx);
active = knote_modify(kev, kn);
mtx_leave(&pxd->pxd_mtx);
return (active);
}
int
filt_pppx_process(struct knote *kn, struct kevent *kev)
{
struct pppx_dev *pxd = kn->kn_hook;
int active;
mtx_enter(&pxd->pxd_mtx);
active = knote_process(kn, kev);
mtx_leave(&pxd->pxd_mtx);
return (active);
}
int
pppxclose(dev_t dev, int flags, int mode, struct proc *p)
{
struct pppx_dev *pxd;
struct pppx_if *pxi;
pxd = pppx_dev_lookup(dev);
while ((pxi = LIST_FIRST(&pxd->pxd_pxis))) {
pxi->pxi_ready = 0;
pppx_if_destroy(pxd, pxi);
}
LIST_REMOVE(pxd, pxd_entry);
mq_purge(&pxd->pxd_svcq);
klist_free(&pxd->pxd_rklist);
klist_free(&pxd->pxd_rklist);
free(pxd, M_DEVBUF, sizeof(*pxd));
return (0);
}
int
pppx_if_next_unit(void)
{
struct pppx_if *pxi;
int unit = 0;
/* this is safe without splnet since we're not modifying it */
do {
int found = 0;
RBT_FOREACH(pxi, pppx_ifs, &pppx_ifs) {
if (pxi->pxi_unit == unit) {
found = 1;
break;
}
}
if (found == 0)
break;
unit++;
} while (unit > 0);
return (unit);
}
struct pppx_if *
pppx_if_find_locked(struct pppx_dev *pxd, int session_id, int protocol)
{
struct pppx_if_key key;
struct pppx_if *pxi;
memset(&key, 0, sizeof(key));
key.pxik_session_id = session_id;
key.pxik_protocol = protocol;
pxi = RBT_FIND(pppx_ifs, &pppx_ifs, (struct pppx_if *)&key);
if (pxi && pxi->pxi_ready == 0)
pxi = NULL;
return pxi;
}
static inline struct pppx_if *
pppx_if_find(struct pppx_dev *pxd, int session_id, int protocol)
{
struct pppx_if *pxi;
if ((pxi = pppx_if_find_locked(pxd, session_id, protocol)))
refcnt_take(&pxi->pxi_refcnt);
return pxi;
}
static inline void
pppx_if_rele(struct pppx_if *pxi)
{
refcnt_rele_wake(&pxi->pxi_refcnt);
}
int
pppx_add_session(struct pppx_dev *pxd, struct pipex_session_req *req)
{
struct pppx_if *pxi;
struct pipex_session *session;
struct ifnet *ifp;
int unit, error = 0;
struct in_ifaddr *ia;
struct sockaddr_in ifaddr;
/*
* XXX: As long as `session' is allocated as part of a `pxi'
* it isn't possible to free it separately. So disallow
* the timeout feature until this is fixed.
*/
if (req->pr_timeout_sec != 0)
return (EINVAL);
error = pipex_init_session(&session, req);
if (error)
return (error);
pxi = pool_get(&pppx_if_pl, PR_WAITOK | PR_ZERO);
ifp = &pxi->pxi_if;
pxi->pxi_session = session;
/* try to set the interface up */
unit = pppx_if_next_unit();
if (unit < 0) {
error = ENOMEM;
goto out;
}
refcnt_init(&pxi->pxi_refcnt);
pxi->pxi_unit = unit;
pxi->pxi_key.pxik_session_id = req->pr_session_id;
pxi->pxi_key.pxik_protocol = req->pr_protocol;
pxi->pxi_dev = pxd;
if (RBT_INSERT(pppx_ifs, &pppx_ifs, pxi) != NULL) {
error = EADDRINUSE;
goto out;
}
LIST_INSERT_HEAD(&pxd->pxd_pxis, pxi, pxi_list);
snprintf(ifp->if_xname, sizeof(ifp->if_xname), "%s%d", "pppx", unit);
ifp->if_mtu = req->pr_peer_mru; /* XXX */
ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST | IFF_UP;
ifp->if_xflags = IFXF_CLONED | IFXF_MPSAFE;
ifp->if_qstart = pppx_if_qstart;
ifp->if_output = pppx_if_output;
ifp->if_ioctl = pppx_if_ioctl;
ifp->if_rtrequest = p2p_rtrequest;
ifp->if_type = IFT_PPP;
ifp->if_softc = pxi;
/* ifp->if_rdomain = req->pr_rdomain; */
if_counters_alloc(ifp);
if_attach(ifp);
NET_LOCK();
if_addgroup(ifp, "pppx");
if_alloc_sadl(ifp);
NET_UNLOCK();
#if NBPFILTER > 0
bpfattach(&ifp->if_bpf, ifp, DLT_LOOP, sizeof(u_int32_t));
#endif
/* XXX ipv6 support? how does the caller indicate it wants ipv6
* instead of ipv4?
*/
memset(&ifaddr, 0, sizeof(ifaddr));
ifaddr.sin_family = AF_INET;
ifaddr.sin_len = sizeof(ifaddr);
ifaddr.sin_addr = req->pr_ip_srcaddr;
ia = malloc(sizeof (*ia), M_IFADDR, M_WAITOK | M_ZERO);
refcnt_init_trace(&ia->ia_ifa.ifa_refcnt, DT_REFCNT_IDX_IFADDR);
ia->ia_addr.sin_family = AF_INET;
ia->ia_addr.sin_len = sizeof(struct sockaddr_in);
ia->ia_addr.sin_addr = req->pr_ip_srcaddr;
ia->ia_dstaddr.sin_family = AF_INET;
ia->ia_dstaddr.sin_len = sizeof(struct sockaddr_in);
ia->ia_dstaddr.sin_addr = req->pr_ip_address;
ia->ia_sockmask.sin_family = AF_INET;
ia->ia_sockmask.sin_len = sizeof(struct sockaddr_in);
ia->ia_sockmask.sin_addr = req->pr_ip_netmask;
ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr);
ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr);
ia->ia_ifa.ifa_netmask = sintosa(&ia->ia_sockmask);
ia->ia_ifa.ifa_ifp = ifp;
ia->ia_netmask = ia->ia_sockmask.sin_addr.s_addr;
NET_LOCK();
error = in_ifinit(ifp, ia, &ifaddr, 1);
if (error) {
printf("pppx: unable to set addresses for %s, error=%d\n",
ifp->if_xname, error);
} else {
if_addrhooks_run(ifp);
}
NET_UNLOCK();
error = pipex_link_session(session, ifp, pxd);
if (error)
goto detach;
NET_LOCK();
SET(ifp->if_flags, IFF_RUNNING);
NET_UNLOCK();
pxi->pxi_ready = 1;
return (error);
detach:
if_detach(ifp);
if (RBT_REMOVE(pppx_ifs, &pppx_ifs, pxi) == NULL)
panic("%s: inconsistent RB tree", __func__);
LIST_REMOVE(pxi, pxi_list);
out:
pool_put(&pppx_if_pl, pxi);
pipex_rele_session(session);
return (error);
}
int
pppx_del_session(struct pppx_dev *pxd, struct pipex_session_close_req *req)
{
struct pppx_if *pxi;
pxi = pppx_if_find_locked(pxd, req->pcr_session_id, req->pcr_protocol);
if (pxi == NULL)
return (EINVAL);
pxi->pxi_ready = 0;
pipex_export_session_stats(pxi->pxi_session, &req->pcr_stat);
pppx_if_destroy(pxd, pxi);
return (0);
}
int
pppx_set_session_descr(struct pppx_dev *pxd,
struct pipex_session_descr_req *req)
{
struct pppx_if *pxi;
pxi = pppx_if_find(pxd, req->pdr_session_id, req->pdr_protocol);
if (pxi == NULL)
return (EINVAL);
NET_LOCK();
(void)memset(pxi->pxi_if.if_description, 0, IFDESCRSIZE);
strlcpy(pxi->pxi_if.if_description, req->pdr_descr, IFDESCRSIZE);
NET_UNLOCK();
pppx_if_rele(pxi);
return (0);
}
void
pppx_if_destroy(struct pppx_dev *pxd, struct pppx_if *pxi)
{
struct ifnet *ifp;
struct pipex_session *session;
session = pxi->pxi_session;
ifp = &pxi->pxi_if;
refcnt_finalize(&pxi->pxi_refcnt, "pxifinal");
NET_LOCK();
CLR(ifp->if_flags, IFF_RUNNING);
NET_UNLOCK();
pipex_unlink_session(session);
if_detach(ifp);
pipex_rele_session(session);
if (RBT_REMOVE(pppx_ifs, &pppx_ifs, pxi) == NULL)
panic("%s: inconsistent RB tree", __func__);
LIST_REMOVE(pxi, pxi_list);
pool_put(&pppx_if_pl, pxi);
}
void
pppx_if_qstart(struct ifqueue *ifq)
{
struct ifnet *ifp = ifq->ifq_if;
struct pppx_if *pxi = (struct pppx_if *)ifp->if_softc;
struct mbuf *m;
int proto;
while ((m = ifq_dequeue(ifq)) != NULL) {
proto = *mtod(m, int *);
m_adj(m, sizeof(proto));
pipex_ppp_output(m, pxi->pxi_session, proto);
}
}
int
pppx_if_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
struct rtentry *rt)
{
struct pppx_if *pxi = (struct pppx_if *)ifp->if_softc;
struct pppx_hdr *th;
int error = 0;
int pipex_enable_local, proto;
pipex_enable_local = atomic_load_int(&pipex_enable);
NET_ASSERT_LOCKED();
if (!ISSET(ifp->if_flags, IFF_RUNNING)) {
m_freem(m);
error = ENETDOWN;
goto out;
}
#if NBPFILTER > 0
if (ifp->if_bpf)
bpf_mtap_af(ifp->if_bpf, dst->sa_family, m, BPF_DIRECTION_OUT);
#endif
if (pipex_enable_local) {
switch (dst->sa_family) {
#ifdef INET6
case AF_INET6:
proto = PPP_IPV6;
break;
#endif
case AF_INET:
proto = PPP_IP;
break;
default:
m_freem(m);
error = EPFNOSUPPORT;
goto out;
}
} else
proto = htonl(dst->sa_family);
M_PREPEND(m, sizeof(int), M_DONTWAIT);
if (m == NULL) {
error = ENOBUFS;
goto out;
}
*mtod(m, int *) = proto;
if (pipex_enable_local)
error = if_enqueue(ifp, m);
else {
M_PREPEND(m, sizeof(struct pppx_hdr), M_DONTWAIT);
if (m == NULL) {
error = ENOBUFS;
goto out;
}
th = mtod(m, struct pppx_hdr *);
th->pppx_proto = 0; /* not used */
th->pppx_id = pxi->pxi_session->ppp_id;
error = mq_enqueue(&pxi->pxi_dev->pxd_svcq, m);
if (error == 0) {
if (pxi->pxi_dev->pxd_waiting) {
wakeup((caddr_t)pxi->pxi_dev);
pxi->pxi_dev->pxd_waiting = 0;
}
knote(&pxi->pxi_dev->pxd_rklist, 0);
}
}
out:
if (error)
counters_inc(ifp->if_counters, ifc_oerrors);
return (error);
}
int
pppx_if_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr)
{
struct pppx_if *pxi = (struct pppx_if *)ifp->if_softc;
struct ifreq *ifr = (struct ifreq *)addr;
int error = 0;
switch (cmd) {
case SIOCSIFADDR:
break;
case SIOCSIFFLAGS:
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
break;
case SIOCSIFMTU:
if (ifr->ifr_mtu < 512 ||
ifr->ifr_mtu > pxi->pxi_session->peer_mru)
error = EINVAL;
else
ifp->if_mtu = ifr->ifr_mtu;
break;
default:
error = ENOTTY;
break;
}
return (error);
}
RBT_GENERATE(pppx_ifs, pppx_if, pxi_entry, pppx_if_cmp);
/*
* Locks used to protect struct members and global data
* I immutable after creation
* K kernel lock
* N net lock
* m sc_mtx
*/
struct pppac_softc {
struct ifnet sc_if;
dev_t sc_dev; /* [I] */
int sc_ready; /* [K] */
LIST_ENTRY(pppac_softc)
sc_entry; /* [K] */
struct mutex sc_mtx;
struct klist sc_rklist; /* [m] */
struct klist sc_wklist; /* [m] */
struct pipex_session
*sc_multicast_session;
struct mbuf_queue
sc_mq;
};
LIST_HEAD(pppac_list, pppac_softc); /* [K] */
static void filt_pppac_rdetach(struct knote *);
static int filt_pppac_read(struct knote *, long);
static int filt_pppac_modify(struct kevent *, struct knote *);
static int filt_pppac_process(struct knote *, struct kevent *);
static const struct filterops pppac_rd_filtops = {
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
.f_attach = NULL,
.f_detach = filt_pppac_rdetach,
.f_event = filt_pppac_read,
.f_modify = filt_pppac_modify,
.f_process = filt_pppac_process,
};
static void filt_pppac_wdetach(struct knote *);
static int filt_pppac_write(struct knote *, long);
static const struct filterops pppac_wr_filtops = {
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
.f_attach = NULL,
.f_detach = filt_pppac_wdetach,
.f_event = filt_pppac_write,
.f_modify = filt_pppac_modify,
.f_process = filt_pppac_process,
};
static struct pppac_list pppac_devs = LIST_HEAD_INITIALIZER(pppac_devs);
static int pppac_ioctl(struct ifnet *, u_long, caddr_t);
static int pppac_add_session(struct pppac_softc *,
struct pipex_session_req *);
static int pppac_del_session(struct pppac_softc *,
struct pipex_session_close_req *);
static int pppac_output(struct ifnet *, struct mbuf *, struct sockaddr *,
struct rtentry *);
static void pppac_qstart(struct ifqueue *);
static inline struct pppac_softc *
pppac_lookup(dev_t dev)
{
struct pppac_softc *sc;
LIST_FOREACH(sc, &pppac_devs, sc_entry) {
if (sc->sc_dev == dev) {
if (sc->sc_ready == 0)
break;
return (sc);
}
}
return (NULL);
}
void
pppacattach(int n)
{
pipex_init(); /* to be sure, to be sure */
}
int
pppacopen(dev_t dev, int flags, int mode, struct proc *p)
{
struct pppac_softc *sc, *tmp;
struct ifnet *ifp;
struct pipex_session *session;
sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK|M_ZERO);
sc->sc_dev = dev;
LIST_FOREACH(tmp, &pppac_devs, sc_entry) {
if (tmp->sc_dev == dev) {
free(sc, M_DEVBUF, sizeof(*sc));
return (EBUSY);
}
}
LIST_INSERT_HEAD(&pppac_devs, sc, sc_entry);
/* virtual pipex_session entry for multicast */
session = pool_get(&pipex_session_pool, PR_WAITOK | PR_ZERO);
session->flags |= PIPEX_SFLAGS_MULTICAST;
session->ownersc = sc;
sc->sc_multicast_session = session;
mtx_init(&sc->sc_mtx, IPL_SOFTNET);
klist_init_mutex(&sc->sc_rklist, &sc->sc_mtx);
klist_init_mutex(&sc->sc_wklist, &sc->sc_mtx);
mq_init(&sc->sc_mq, IFQ_MAXLEN, IPL_SOFTNET);
ifp = &sc->sc_if;
snprintf(ifp->if_xname, sizeof(ifp->if_xname), "pppac%u", minor(dev));
ifp->if_softc = sc;
ifp->if_type = IFT_L3IPVLAN;
ifp->if_hdrlen = sizeof(uint32_t); /* for BPF */;
ifp->if_mtu = MAXMCLBYTES - sizeof(uint32_t);
ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST;
ifp->if_xflags = IFXF_CLONED | IFXF_MPSAFE;
ifp->if_rtrequest = p2p_rtrequest; /* XXX */
ifp->if_output = pppac_output;
ifp->if_qstart = pppac_qstart;
ifp->if_ioctl = pppac_ioctl;
if_counters_alloc(ifp);
if_attach(ifp);
if_alloc_sadl(ifp);
#if NBPFILTER > 0
bpfattach(&ifp->if_bpf, ifp, DLT_LOOP, sizeof(uint32_t));
#endif
sc->sc_ready = 1;
return (0);
}
int
pppacread(dev_t dev, struct uio *uio, int ioflag)
{
struct pppac_softc *sc = pppac_lookup(dev);
struct ifnet *ifp = &sc->sc_if;
struct mbuf *m0, *m;
int error = 0;
size_t len;
if (!ISSET(ifp->if_flags, IFF_RUNNING))
return (EHOSTDOWN);
m0 = mq_dequeue(&sc->sc_mq);
if (m0 == NULL) {
if (ISSET(ioflag, IO_NDELAY))
return (EWOULDBLOCK);
do {
error = tsleep_nsec(sc, (PZERO + 1)|PCATCH,
"pppacrd", INFSLP);
if (error != 0)
return (error);
m0 = mq_dequeue(&sc->sc_mq);
} while (m0 == NULL);
}
m = m0;
while (uio->uio_resid > 0) {
len = ulmin(uio->uio_resid, m->m_len);
if (len != 0) {
error = uiomove(mtod(m, caddr_t), len, uio);
if (error != 0)
break;
}
m = m->m_next;
if (m == NULL)
break;
}
m_freem(m0);
return (error);
}
int
pppacwrite(dev_t dev, struct uio *uio, int ioflag)
{
struct pppac_softc *sc = pppac_lookup(dev);
struct ifnet *ifp = &sc->sc_if;
uint32_t proto;
int error;
struct mbuf *m;
if (!ISSET(ifp->if_flags, IFF_RUNNING))
return (EHOSTDOWN);
if (uio->uio_resid < ifp->if_hdrlen || uio->uio_resid > MAXMCLBYTES)
return (EMSGSIZE);
m = m_gethdr(M_DONTWAIT, MT_DATA);
if (m == NULL)
return (ENOMEM);
if (uio->uio_resid > MHLEN) {
m_clget(m, M_WAITOK, uio->uio_resid);
if (!ISSET(m->m_flags, M_EXT)) {
m_free(m);
return (ENOMEM);
}
}
m->m_pkthdr.len = m->m_len = uio->uio_resid;
error = uiomove(mtod(m, void *), m->m_len, uio);
if (error != 0) {
m_freem(m);
return (error);
}
#if NBPFILTER > 0
if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
#endif
/* strip the tunnel header */
proto = ntohl(*mtod(m, uint32_t *));
m_adj(m, sizeof(uint32_t));
m->m_flags &= ~(M_MCAST|M_BCAST);
m->m_pkthdr.ph_ifidx = ifp->if_index;
m->m_pkthdr.ph_rtableid = ifp->if_rdomain;
#if NPF > 0
pf_pkt_addr_changed(m);
#endif
counters_pkt(ifp->if_counters,
ifc_ipackets, ifc_ibytes, m->m_pkthdr.len);
NET_LOCK();
switch (proto) {
case AF_INET:
ipv4_input(ifp, m);
break;
#ifdef INET6
case AF_INET6:
ipv6_input(ifp, m);
break;
#endif
default:
m_freem(m);
error = EAFNOSUPPORT;
break;
}
NET_UNLOCK();
return (error);
}
int
pppacioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p)
{
struct pppac_softc *sc = pppac_lookup(dev);
int error = 0;
switch (cmd) {
case FIONBIO:
break;
case FIONREAD:
*(int *)data = mq_hdatalen(&sc->sc_mq);
break;
case PIPEXASESSION:
error = pppac_add_session(sc, (struct pipex_session_req *)data);
break;
case PIPEXDSESSION:
error = pppac_del_session(sc,
(struct pipex_session_close_req *)data);
break;
default:
error = pipex_ioctl(sc, cmd, data);
break;
}
return (error);
}
int
pppackqfilter(dev_t dev, struct knote *kn)
{
struct pppac_softc *sc = pppac_lookup(dev);
struct klist *klist;
switch (kn->kn_filter) {
case EVFILT_READ:
klist = &sc->sc_rklist;
kn->kn_fop = &pppac_rd_filtops;
break;
case EVFILT_WRITE:
klist = &sc->sc_wklist;
kn->kn_fop = &pppac_wr_filtops;
break;
default:
return (EINVAL);
}
kn->kn_hook = sc;
klist_insert(klist, kn);
return (0);
}
static void
filt_pppac_rdetach(struct knote *kn)
{
struct pppac_softc *sc = kn->kn_hook;
klist_remove(&sc->sc_rklist, kn);
}
static int
filt_pppac_read(struct knote *kn, long hint)
{
struct pppac_softc *sc = kn->kn_hook;
MUTEX_ASSERT_LOCKED(&sc->sc_mtx);
kn->kn_data = mq_hdatalen(&sc->sc_mq);
return (kn->kn_data > 0);
}
static void
filt_pppac_wdetach(struct knote *kn)
{
struct pppac_softc *sc = kn->kn_hook;
klist_remove(&sc->sc_wklist, kn);
}
static int
filt_pppac_write(struct knote *kn, long hint)
{
/* We're always ready to accept a write. */
return (1);
}
static int
filt_pppac_modify(struct kevent *kev, struct knote *kn)
{
struct pppac_softc *sc = kn->kn_hook;
int active;
mtx_enter(&sc->sc_mtx);
active = knote_modify(kev, kn);
mtx_leave(&sc->sc_mtx);
return (active);
}
static int
filt_pppac_process(struct knote *kn, struct kevent *kev)
{
struct pppac_softc *sc = kn->kn_hook;
int active;
mtx_enter(&sc->sc_mtx);
active = knote_process(kn, kev);
mtx_leave(&sc->sc_mtx);
return (active);
}
int
pppacclose(dev_t dev, int flags, int mode, struct proc *p)
{
struct pppac_softc *sc = pppac_lookup(dev);
struct ifnet *ifp = &sc->sc_if;
sc->sc_ready = 0;
NET_LOCK();
CLR(ifp->if_flags, IFF_RUNNING);
NET_UNLOCK();
if_detach(ifp);
klist_free(&sc->sc_rklist);
klist_free(&sc->sc_wklist);
pool_put(&pipex_session_pool, sc->sc_multicast_session);
pipex_destroy_all_sessions(sc);
LIST_REMOVE(sc, sc_entry);
free(sc, M_DEVBUF, sizeof(*sc));
return (0);
}
static int
pppac_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
/* struct ifreq *ifr = (struct ifreq *)data; */
int error = 0;
switch (cmd) {
case SIOCSIFADDR:
SET(ifp->if_flags, IFF_UP); /* XXX cry cry */
/* FALLTHROUGH */
case SIOCSIFFLAGS:
if (ISSET(ifp->if_flags, IFF_UP))
SET(ifp->if_flags, IFF_RUNNING);
else
CLR(ifp->if_flags, IFF_RUNNING);
break;
case SIOCSIFMTU:
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
/* XXX */
break;
default:
error = ENOTTY;
break;
}
return (error);
}
static int
pppac_add_session(struct pppac_softc *sc, struct pipex_session_req *req)
{
int error;
struct pipex_session *session;
error = pipex_init_session(&session, req);
if (error != 0)
return (error);
error = pipex_link_session(session, &sc->sc_if, sc);
if (error != 0)
pipex_rele_session(session);
return (error);
}
static int
pppac_del_session(struct pppac_softc *sc, struct pipex_session_close_req *req)
{
struct pipex_session *session;
mtx_enter(&pipex_list_mtx);
session = pipex_lookup_by_session_id_locked(req->pcr_protocol,
req->pcr_session_id);
if (session == NULL || session->ownersc != sc) {
mtx_leave(&pipex_list_mtx);
return (EINVAL);
}
pipex_unlink_session_locked(session);
pipex_rele_session(session);
mtx_leave(&pipex_list_mtx);
return (0);
}
static int
pppac_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
struct rtentry *rt)
{
int error;
if (!ISSET(ifp->if_flags, IFF_RUNNING)) {
error = EHOSTDOWN;
goto drop;
}
switch (dst->sa_family) {
case AF_INET:
#ifdef INET6
case AF_INET6:
#endif
break;
default:
error = EAFNOSUPPORT;
goto drop;
}
m->m_pkthdr.ph_family = dst->sa_family;
return (if_enqueue(ifp, m));
drop:
m_freem(m);
return (error);
}
static void
pppac_qstart(struct ifqueue *ifq)
{
struct ifnet *ifp = ifq->ifq_if;
struct pppac_softc *sc = ifp->if_softc;
struct mbuf *m, *m0;
struct pipex_session *session;
struct ip ip;
int rv;
while ((m = ifq_dequeue(ifq)) != NULL) {
#if NBPFILTER > 0
if (ifp->if_bpf) {
bpf_mtap_af(ifp->if_bpf, m->m_pkthdr.ph_family, m,
BPF_DIRECTION_OUT);
}
#endif
switch (m->m_pkthdr.ph_family) {
case AF_INET:
if (m->m_pkthdr.len < sizeof(struct ip))
goto bad;
m_copydata(m, 0, sizeof(struct ip), &ip);
if (IN_MULTICAST(ip.ip_dst.s_addr)) {
/* pass a copy to pipex */
m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
if (m0 != NULL)
pipex_ip_output(m0,
sc->sc_multicast_session);
else
goto bad;
} else {
session = pipex_lookup_by_ip_address(ip.ip_dst);
if (session != NULL) {
pipex_ip_output(m, session);
pipex_rele_session(session);
m = NULL;
}
}
break;
}
if (m == NULL) /* handled by pipex */
continue;
m = m_prepend(m, sizeof(uint32_t), M_DONTWAIT);
if (m == NULL)
goto bad;
*mtod(m, uint32_t *) = htonl(m->m_pkthdr.ph_family);
rv = mq_enqueue(&sc->sc_mq, m);
if (rv == 1)
counters_inc(ifp->if_counters, ifc_collisions);
continue;
bad:
counters_inc(ifp->if_counters, ifc_oerrors);
if (m != NULL)
m_freem(m);
continue;
}
if (!mq_empty(&sc->sc_mq)) {
wakeup(sc);
knote(&sc->sc_rklist, 0);
}
}
|
21e5083aa05d7df61011166350ee7e46fac88368
|
9874716bc2f2dea03b9163a575ce383855508731
|
/thcrap_tasofro/src/png.h
|
9d1bf9b4f539d51a5c110996fa0d9c0cdc5c73e1
|
[
"Unlicense",
"LicenseRef-scancode-public-domain"
] |
permissive
|
thpatch/thcrap
|
d135f6ddb8f5c4fc8b560e69e1f644fb096203e6
|
dec6e6e4d3e505feb55353f78dc1d5d9e770b6ee
|
refs/heads/master
| 2023-07-20T04:13:29.900439
| 2023-07-17T14:26:04
| 2023-07-17T14:26:15
| 11,221,712
| 510
| 57
|
Unlicense
| 2023-09-11T18:10:08
| 2013-07-06T17:29:28
|
C++
|
UTF-8
|
C
| false
| false
| 765
|
h
|
png.h
|
/**
* Touhou Community Reliant Automatic Patcher
* Tasogare Frontier support plugin
*
* ----
*
* PNG files reading.
*/
#pragma once
#include <thcrap.h>
#ifdef __cplusplus
extern "C" {
#endif
// Reads the PNG file [fn]. The returned value is an array of lines. It has to be freed by the caller.
// If this function is successful, bpp will be either 24 or 32.
TH_CALLER_FREE BYTE **png_image_read(const char *fn, uint32_t *width, uint32_t *height, uint8_t *bpp, bool gray_to_rgb = true);
// Reads the IHDR chunk in the PNG file [fn], and extract some informations.
// If this function is successful, bpp will be either 24 or 32.
bool png_image_get_IHDR(const char *fn, uint32_t *width, uint32_t *height, uint8_t *bpp);
#ifdef __cplusplus
}
#endif
|
261811f38e596b80b49314c7a78ac567b42d9860
|
aa3befea459382dc5c01c925653d54f435b3fb0f
|
/arch/arm/include/lpc17xx_40xx/lpc176x_irq.h
|
6da827df2c2b74f44dc20b2108247358a44ef1b7
|
[
"MIT-open-group",
"BSD-3-Clause",
"HPND-sell-variant",
"BSD-4-Clause-UC",
"LicenseRef-scancode-warranty-disclaimer",
"MIT-0",
"LicenseRef-scancode-bsd-atmel",
"LicenseRef-scancode-gary-s-brown",
"LicenseRef-scancode-proprietary-license",
"SunPro",
"MIT",
"LicenseRef-scancode-public-domain-disclaimer",
"LicenseRef-scancode-other-permissive",
"HPND",
"ISC",
"Apache-2.0",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"GPL-1.0-or-later",
"CC-BY-2.0",
"CC-BY-4.0"
] |
permissive
|
apache/nuttx
|
14519a7bff4a87935d94fb8fb2b19edb501c7cec
|
606b6d9310fb25c7d92c6f95bf61737e3c79fa0f
|
refs/heads/master
| 2023-08-25T06:55:45.822534
| 2023-08-23T16:03:31
| 2023-08-24T21:25:47
| 228,103,273
| 407
| 241
|
Apache-2.0
| 2023-09-14T18:26:05
| 2019-12-14T23:27:55
|
C
|
UTF-8
|
C
| false
| false
| 14,434
|
h
|
lpc176x_irq.h
|
/****************************************************************************
* arch/arm/include/lpc17xx_40xx/lpc176x_irq.h
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/* This file should never be included directly but, rather,
* only indirectly through nuttx/irq.h
*/
#ifndef __ARCH_ARM_INCLUDE_LPC17XX_40XX_LPC176X_IRQ_H
#define __ARCH_ARM_INCLUDE_LPC17XX_40XX_LPC176X_IRQ_H
/****************************************************************************
* Included Files
****************************************************************************/
/****************************************************************************
* Pre-processor Prototypes
****************************************************************************/
/* IRQ numbers. The IRQ number corresponds vector number and hence map
* directly to bits in the NVIC. This does, however, waste several words of
* memory in the IRQ to handle mapping tables.
*/
/* External interrupts (vectors >= 16) */
#define LPC17_40_IRQ_WDT (LPC17_40_IRQ_EXTINT+0) /* WDT Watchdog Interrupt (WDINT) */
#define LPC17_40_IRQ_TMR0 (LPC17_40_IRQ_EXTINT+1) /* Timer 0 Match 0 - 1 (MR0, MR1)
* Capture 0 - 1 (CR0, CR1) */
#define LPC17_40_IRQ_TMR1 (LPC17_40_IRQ_EXTINT+2) /* Timer 1 Match 0 - 2 (MR0, MR1, MR2)
* Capture 0 - 1 (CR0, CR1) */
#define LPC17_40_IRQ_TMR2 (LPC17_40_IRQ_EXTINT+3) /* Timer 2 Match 0-3
* Capture 0-1 */
#define LPC17_40_IRQ_TMR3 (LPC17_40_IRQ_EXTINT+4) /* Timer 3 Match 0-3
* Capture 0-1 */
#define LPC17_40_IRQ_UART0 (LPC17_40_IRQ_EXTINT+5) /* UART 0 Rx Line Status (RLS)
* Transmit Holding Register Empty (THRE)
* Rx Data Available (RDA)
* Character Time-out Indicator (CTI)
* End of Auto-Baud (ABEO)
* Auto-Baud Time-Out (ABTO) */
#define LPC17_40_IRQ_UART1 (LPC17_40_IRQ_EXTINT+6) /* UART 1 Rx Line Status (RLS)
* Transmit Holding Register Empty (THRE)
* Rx Data Available (RDA)
* Character Time-out Indicator (CTI)
* Modem Control Change
* End of Auto-Baud (ABEO)
* Auto-Baud Time-Out (ABTO) */
#define LPC17_40_IRQ_UART2 (LPC17_40_IRQ_EXTINT+7) /* UART 2 Rx Line Status (RLS)
* Transmit Holding Register Empty (THRE)
* Rx Data Available (RDA)
* Character Time-out Indicator (CTI)
* End of Auto-Baud (ABEO)
* Auto-Baud Time-Out (ABTO) */
#define LPC17_40_IRQ_UART3 (LPC17_40_IRQ_EXTINT+8) /* UART 3 Rx Line Status (RLS)
* Transmit Holding Register Empty (THRE)
* Rx Data Available (RDA)
* Character Time-out Indicator (CTI)
* End of Auto-Baud (ABEO)
* Auto-Baud Time-Out (ABTO) */
#define LPC17_40_IRQ_PWM1 (LPC17_40_IRQ_EXTINT+9) /* PWM1 Match 0 - 6 of PWM1
* Capture 0-1 of PWM1 */
#define LPC17_40_IRQ_I2C0 (LPC17_40_IRQ_EXTINT+10) /* I2C0 SI (state change) */
#define LPC17_40_IRQ_I2C1 (LPC17_40_IRQ_EXTINT+11) /* I2C1 SI (state change) */
#define LPC17_40_IRQ_I2C2 (LPC17_40_IRQ_EXTINT+12) /* I2C2 SI (state change) */
#define LPC17_40_IRQ_SPIF (LPC17_40_IRQ_EXTINT+13) /* SPI SPI Interrupt Flag (SPIF)
* Mode Fault (MODF) */
#define LPC17_40_IRQ_SSP0 (LPC17_40_IRQ_EXTINT+14) /* SSP0 Tx FIFO half empty of SSP0
* Rx FIFO half full of SSP0
* Rx Timeout of SSP0
* Rx Overrun of SSP0 */
#define LPC17_40_IRQ_SSP1 (LPC17_40_IRQ_EXTINT+15) /* SSP 1 Tx FIFO half empty
* Rx FIFO half full
* Rx Timeout
* Rx Overrun */
#define LPC17_40_IRQ_PLL0 (LPC17_40_IRQ_EXTINT+16) /* PLL0 (Main PLL) PLL0 Lock (PLOCK0) */
#define LPC17_40_IRQ_RTC (LPC17_40_IRQ_EXTINT+17) /* RTC Counter Increment (RTCCIF)
* Alarm (RTCALF) */
#define LPC17_40_IRQ_EINT0 (LPC17_40_IRQ_EXTINT+18) /* External Interrupt 0 (EINT0) */
#define LPC17_40_IRQ_EINT1 (LPC17_40_IRQ_EXTINT+19) /* External Interrupt 1 (EINT1) */
#define LPC17_40_IRQ_EINT2 (LPC17_40_IRQ_EXTINT+20) /* External Interrupt 2 (EINT2) */
#define LPC17_40_IRQ_EINT3 (LPC17_40_IRQ_EXTINT+21) /* External Interrupt 3 (EINT3)
* Note: EINT3 channel is shared with GPIO interrupts */
#define LPC17_40_IRQ_ADC (LPC17_40_IRQ_EXTINT+22) /* ADC A/D Converter end of conversion */
#define LPC17_40_IRQ_BOD (LPC17_40_IRQ_EXTINT+23) /* BOD Brown Out detect */
#define LPC17_40_IRQ_USB (LPC17_40_IRQ_EXTINT+24) /* USB USB_INT_REQ_LP, USB_INT_REQ_HP,
* USB_INT_REQ_DMA */
#define LPC17_40_IRQ_CAN (LPC17_40_IRQ_EXTINT+25) /* CAN CAN Common, CAN 0 Tx, CAN 0 Rx,
* CAN 1 Tx, CAN 1 Rx */
#define LPC17_40_IRQ_GPDMA (LPC17_40_IRQ_EXTINT+26) /* GPDMA IntStatus of DMA channel 0,
* IntStatus of DMA channel 1 */
#define LPC17_40_IRQ_I2S (LPC17_40_IRQ_EXTINT+27) /* I2S irq, dmareq1, dmareq2 */
#define LPC17_40_IRQ_ETH (LPC17_40_IRQ_EXTINT+28) /* Ethernet WakeupInt, SoftInt, TxDoneInt,
* TxFinishedInt, TxErrorInt,* TxUnderrunInt,
* RxDoneInt, RxFinishedInt, RxErrorInt,
* RxOverrunInt */
#define LPC17_40_IRQ_RITINT (LPC17_40_IRQ_EXTINT+29) /* Repetitive Interrupt Timer (RITINT) */
#define LPC17_40_IRQ_MCPWM (LPC17_40_IRQ_EXTINT+30) /* Motor Control PWM IPER[2:0], IPW[2:0],
* ICAP[2:0], FES */
#define LPC17_40_IRQ_QEI (LPC17_40_IRQ_EXTINT+31) /* Quadrature Encoder INX_Int, TIM_Int, VELC_Int,
* DIR_Int, ERR_Int, ENCLK_Int, POS0_Int, POS1_Int
* POS2_Int, REV_Int, POS0REV_Int, OS1REV_Int,
* POS2REV_Int */
#define LPC17_40_IRQ_PLL1 (LPC17_40_IRQ_EXTINT+32) /* PLL1 (USB PLL) PLL1 Lock (PLOCK1) */
#define LPC17_40_IRQ_USBACT (LPC17_40_IRQ_EXTINT+33) /* USB Activity Interrupt USB_NEED_CLK */
#define LPC17_40_IRQ_CANACT (LPC17_40_IRQ_EXTINT+34) /* CAN Activity Interrupt CAN1WAKE, CAN2WAKE */
#define LPC17_40_IRQ_NEXTINT (35)
#define LPC17_40_IRQ_NIRQS (LPC17_40_IRQ_EXTINT+LPC17_40_IRQ_NEXTINT)
/* GPIO interrupts. The LPC17xx/LPC40xx supports several interrupts on ports
* 0 and 2 (only). We go through some special efforts to keep the number of
* IRQs to a minimum in this sparse interrupt case.
*
* 28 interrupts on Port 0: p0.0 - p0.11, p0.15-p0.30
* 14 interrupts on Port 2: p2.0 - p2.13
* --
* 42
*/
#ifdef CONFIG_LPC17_40_GPIOIRQ
# define LPC17_40_VALID_GPIOINT0 (0x7fff8ffful) /* GPIO port 0 interrupt set */
# define LPC17_40_VALID_GPIOINT2 (0x00003ffful) /* GPIO port 2 interrupt set */
/* Set 1: 12 interrupts p0.0-p0.11 */
# define LPC17_40_VALID_GPIOINT0L (0x00000ffful)
# define LPC17_40_VALID_SHIFT0L (0)
# define LPC17_40_VALID_FIRST0L (LPC17_40_IRQ_EXTINT+LPC17_40_IRQ_NEXTINT)
# define LPC17_40_IRQ_P0p0 (LPC17_40_VALID_FIRST0L+0)
# define LPC17_40_IRQ_P0p1 (LPC17_40_VALID_FIRST0L+1)
# define LPC17_40_IRQ_P0p2 (LPC17_40_VALID_FIRST0L+2)
# define LPC17_40_IRQ_P0p3 (LPC17_40_VALID_FIRST0L+3)
# define LPC17_40_IRQ_P0p4 (LPC17_40_VALID_FIRST0L+4)
# define LPC17_40_IRQ_P0p5 (LPC17_40_VALID_FIRST0L+5)
# define LPC17_40_IRQ_P0p6 (LPC17_40_VALID_FIRST0L+6)
# define LPC17_40_IRQ_P0p7 (LPC17_40_VALID_FIRST0L+7)
# define LPC17_40_IRQ_P0p8 (LPC17_40_VALID_FIRST0L+8)
# define LPC17_40_IRQ_P0p9 (LPC17_40_VALID_FIRST0L+9)
# define LPC17_40_IRQ_P0p10 (LPC17_40_VALID_FIRST0L+10)
# define LPC17_40_IRQ_P0p11 (LPC17_40_VALID_FIRST0L+11)
# define LPC17_40_VALID_NIRQS0L (12)
/* Set 2: 16 interrupts p0.15-p0.30 */
# define LPC17_40_VALID_GPIOINT0H (0x7fff8000ull)
# define LPC17_40_VALID_SHIFT0H (15)
# define LPC17_40_VALID_FIRST0H (LPC17_40_VALID_FIRST0L+LPC17_40_VALID_NIRQS0L)
# define LPC17_40_IRQ_P0p15 (LPC17_40_VALID_FIRST0H+0)
# define LPC17_40_IRQ_P0p16 (LPC17_40_VALID_FIRST0H+1)
# define LPC17_40_IRQ_P0p17 (LPC17_40_VALID_FIRST0H+2)
# define LPC17_40_IRQ_P0p18 (LPC17_40_VALID_FIRST0H+3)
# define LPC17_40_IRQ_P0p19 (LPC17_40_VALID_FIRST0H+4)
# define LPC17_40_IRQ_P0p20 (LPC17_40_VALID_FIRST0H+5)
# define LPC17_40_IRQ_P0p21 (LPC17_40_VALID_FIRST0H+6)
# define LPC17_40_IRQ_P0p22 (LPC17_40_VALID_FIRST0H+7)
# define LPC17_40_IRQ_P0p23 (LPC17_40_VALID_FIRST0H+8)
# define LPC17_40_IRQ_P0p24 (LPC17_40_VALID_FIRST0H+9)
# define LPC17_40_IRQ_P0p25 (LPC17_40_VALID_FIRST0H+10)
# define LPC17_40_IRQ_P0p26 (LPC17_40_VALID_FIRST0H+11)
# define LPC17_40_IRQ_P0p27 (LPC17_40_VALID_FIRST0H+12)
# define LPC17_40_IRQ_P0p28 (LPC17_40_VALID_FIRST0H+13)
# define LPC17_40_IRQ_P0p29 (LPC17_40_VALID_FIRST0H+14)
# define LPC17_40_IRQ_P0p30 (LPC17_40_VALID_FIRST0H+15)
# define LPC17_40_VALID_NIRQS0H (16)
/* Set 3: 14 interrupts p2.0-p2.13 */
# define LPC17_40_VALID_GPIOINT2 (0x00003ffful)
# define LPC17_40_VALID_SHIFT2 (0)
# define LPC17_40_VALID_FIRST2 (LPC17_40_VALID_FIRST0H+LPC17_40_VALID_NIRQS0H)
# define LPC17_40_IRQ_P2p0 (LPC17_40_VALID_FIRST2+0)
# define LPC17_40_IRQ_P2p1 (LPC17_40_VALID_FIRST2+1)
# define LPC17_40_IRQ_P2p2 (LPC17_40_VALID_FIRST2+2)
# define LPC17_40_IRQ_P2p3 (LPC17_40_VALID_FIRST2+3)
# define LPC17_40_IRQ_P2p4 (LPC17_40_VALID_FIRST2+4)
# define LPC17_40_IRQ_P2p5 (LPC17_40_VALID_FIRST2+5)
# define LPC17_40_IRQ_P2p6 (LPC17_40_VALID_FIRST2+6)
# define LPC17_40_IRQ_P2p7 (LPC17_40_VALID_FIRST2+7)
# define LPC17_40_IRQ_P2p8 (LPC17_40_VALID_FIRST2+8)
# define LPC17_40_IRQ_P2p9 (LPC17_40_VALID_FIRST2+9)
# define LPC17_40_IRQ_P2p10 (LPC17_40_VALID_FIRST2+10)
# define LPC17_40_IRQ_P2p11 (LPC17_40_VALID_FIRST2+11)
# define LPC17_40_IRQ_P2p12 (LPC17_40_VALID_FIRST2+12)
# define LPC17_40_IRQ_P2p13 (LPC17_40_VALID_FIRST2+13)
# define LPC17_40_VALID_NIRQS2 (14)
# define LPC17_40_NGPIOAIRQS (LPC17_40_VALID_NIRQS0L+LPC17_40_VALID_NIRQS0H+LPC17_40_VALID_NIRQS2)
#else
# define LPC17_40_NGPIOAIRQS (0)
#endif
/* Total number of IRQ numbers */
#define NR_IRQS (LPC17_40_IRQ_EXTINT+LPC17_40_IRQ_NEXTINT+LPC17_40_NGPIOAIRQS)
/****************************************************************************
* Public Types
****************************************************************************/
/****************************************************************************
* Inline functions
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
#endif /* __ARCH_ARM_INCLUDE_LPC17XX_40XX_LPC176X_IRQ_H */
|
b9ae6820cb9563a8ca284cc809791347d29362fb
|
b8906afecca06f48f2cd289a9997f670b26c4721
|
/spec/api_generator_spec/extensions/barcode1/ext/shared/generated/barcode1_ruby_api.c
|
986ec14419e74efc13778db33e1acaabd0f8f907
|
[
"MIT"
] |
permissive
|
rhomobile/rhodes
|
51bd88921c51bd618948f9a557de17fc297e7cc2
|
fc8409c9c281684a49d7ff6805ddc565de09a6d5
|
refs/heads/master
| 2023-09-01T17:45:36.149868
| 2023-08-31T20:56:06
| 2023-08-31T20:56:06
| 54,084
| 504
| 155
|
MIT
| 2023-09-12T00:14:29
| 2008-09-18T21:55:16
|
C
|
UTF-8
|
C
| false
| false
| 3,994
|
c
|
barcode1_ruby_api.c
|
#include "ruby.h"
static VALUE rb_mParent;
static VALUE rb_cBarcode1;
VALUE rb_Barcode1_enable(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_enable(int argc, VALUE *argv);
VALUE rb_Barcode1_start(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_start(int argc, VALUE *argv);
VALUE rb_Barcode1_stop(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_stop(int argc, VALUE *argv);
VALUE rb_Barcode1_disable(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_disable(int argc, VALUE *argv);
VALUE rb_Barcode1_take(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_take(int argc, VALUE *argv);
VALUE rb_Barcode1_getProperty(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_getProperty(int argc, VALUE *argv);
VALUE rb_Barcode1_getProperties(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_getProperties(int argc, VALUE *argv);
VALUE rb_Barcode1_getAllProperties(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_getAllProperties(int argc, VALUE *argv);
VALUE rb_Barcode1_setProperty(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_setProperty(int argc, VALUE *argv);
VALUE rb_Barcode1_setProperties(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_setProperties(int argc, VALUE *argv);
VALUE rb_Barcode1_clearProps(int argc, VALUE *argv, VALUE obj);
VALUE rb_s_Barcode1_def_clearProps(int argc, VALUE *argv);
VALUE rb_s_Barcode1_enumerate(int argc, VALUE *argv);
VALUE rb_Barcode1_s_default(VALUE klass);
VALUE rb_Barcode1_s_setDefault(VALUE klass, VALUE obj);
VALUE getRuby_Barcode1_Module(){ return rb_cBarcode1; }
void Init_RubyAPI_Barcode1(void)
{
rb_mParent = rb_define_module("Rho");
rb_cBarcode1 = rb_define_class_under(rb_mParent, "Barcode1", rb_cObject);
//Constructor should be not available
//rb_define_alloc_func(rb_cBarcode1, rb_barcode1_allocate);
rb_undef_alloc_func(rb_cBarcode1);
//rb_define_method(rb_cBarcode1, "enable", rb_Barcode1_enable, -1);
//rb_define_singleton_method(rb_cBarcode1, "enable", rb_s_Barcode1_def_enable, -1);
//rb_define_method(rb_cBarcode1, "start", rb_Barcode1_start, -1);
//rb_define_singleton_method(rb_cBarcode1, "start", rb_s_Barcode1_def_start, -1);
//rb_define_method(rb_cBarcode1, "stop", rb_Barcode1_stop, -1);
//rb_define_singleton_method(rb_cBarcode1, "stop", rb_s_Barcode1_def_stop, -1);
//rb_define_method(rb_cBarcode1, "disable", rb_Barcode1_disable, -1);
//rb_define_singleton_method(rb_cBarcode1, "disable", rb_s_Barcode1_def_disable, -1);
//rb_define_method(rb_cBarcode1, "take", rb_Barcode1_take, -1);
//rb_define_singleton_method(rb_cBarcode1, "take", rb_s_Barcode1_def_take, -1);
//rb_define_method(rb_cBarcode1, "getProperty", rb_Barcode1_getProperty, -1);
//rb_define_singleton_method(rb_cBarcode1, "getProperty", rb_s_Barcode1_def_getProperty, -1);
//rb_define_method(rb_cBarcode1, "getProperties", rb_Barcode1_getProperties, -1);
//rb_define_singleton_method(rb_cBarcode1, "getProperties", rb_s_Barcode1_def_getProperties, -1);
//rb_define_method(rb_cBarcode1, "getAllProperties", rb_Barcode1_getAllProperties, -1);
//rb_define_singleton_method(rb_cBarcode1, "getAllProperties", rb_s_Barcode1_def_getAllProperties, -1);
//rb_define_method(rb_cBarcode1, "setProperty", rb_Barcode1_setProperty, -1);
//rb_define_singleton_method(rb_cBarcode1, "setProperty", rb_s_Barcode1_def_setProperty, -1);
//rb_define_method(rb_cBarcode1, "setProperties", rb_Barcode1_setProperties, -1);
//rb_define_singleton_method(rb_cBarcode1, "setProperties", rb_s_Barcode1_def_setProperties, -1);
//rb_define_method(rb_cBarcode1, "clearProps", rb_Barcode1_clearProps, -1);
//rb_define_singleton_method(rb_cBarcode1, "clearProps", rb_s_Barcode1_def_clearProps, -1);
//rb_define_singleton_method(rb_cBarcode1, "enumerate", rb_s_Barcode1_enumerate, -1);
rb_define_singleton_method(rb_cBarcode1, "default", rb_Barcode1_s_default, 0);
rb_define_singleton_method(rb_cBarcode1, "setDefault", rb_Barcode1_s_setDefault, 1);
}
|
5f37a8ed21b169b95bd0199b4c9f22803466c833
|
f6f6d13ecabee843ad4b41aae301e1bad1a07bdb
|
/include/PI/int/pi_int.h
|
700991c4e34d3022c3896ec97a6ce887ba48329e
|
[
"Apache-2.0"
] |
permissive
|
p4lang/PI
|
ec6a912f77f3ed73516a844ea5ca9fdb74c0e774
|
6d0f3d6c08d595f65c7d96fd852d9e0c308a6f30
|
refs/heads/main
| 2023-08-30T02:44:12.127320
| 2023-08-21T16:45:07
| 2023-08-21T16:45:07
| 51,870,280
| 170
| 128
|
Apache-2.0
| 2023-09-11T09:52:09
| 2016-02-16T21:07:15
|
C++
|
UTF-8
|
C
| false
| false
| 4,137
|
h
|
pi_int.h
|
/* Copyright 2013-present Barefoot Networks, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Antonin Bas (antonin@barefootnetworks.com)
*
*/
#ifndef PI_INT_PI_INT_H_
#define PI_INT_PI_INT_H_
#include "PI/pi.h"
#ifdef __cplusplus
extern "C" {
#endif
// Increment any time a change is made to the PI internal ABI
// Revision history:
// * 1 -> 2: support for optional match type
// * 2 -> 3: add PI_STATUS_INIT_ALREADY_CALLED error
#define PI_ABI_VERSION 3
static inline pi_p4_id_t pi_make_action_id(uint16_t index) {
return (PI_ACTION_ID << 24) | index;
}
static inline pi_p4_id_t pi_make_table_id(uint16_t index) {
return (PI_TABLE_ID << 24) | index;
}
static inline pi_p4_id_t pi_make_act_prof_id(uint16_t index) {
return (PI_ACT_PROF_ID << 24) | index;
}
static inline pi_p4_id_t pi_make_counter_id(uint16_t index) {
return (PI_COUNTER_ID << 24) | index;
}
static inline pi_p4_id_t pi_make_direct_counter_id(uint16_t index) {
return (PI_DIRECT_COUNTER_ID << 24) | index;
}
static inline pi_p4_id_t pi_make_meter_id(uint16_t index) {
return (PI_METER_ID << 24) | index;
}
static inline pi_p4_id_t pi_make_direct_meter_id(uint16_t index) {
return (PI_DIRECT_METER_ID << 24) | index;
}
#define PI_GET_TYPE_ID(id) ((id) >> 24)
// TODO(antonin): find a better location
static inline size_t get_match_key_size_one_field(
pi_p4info_match_type_t match_type, size_t bitwidth) {
size_t nbytes = (bitwidth + 7) / 8;
switch (match_type) {
case PI_P4INFO_MATCH_TYPE_VALID:
assert(nbytes == 1);
case PI_P4INFO_MATCH_TYPE_EXACT:
return nbytes;
case PI_P4INFO_MATCH_TYPE_LPM:
return nbytes + sizeof(uint32_t);
case PI_P4INFO_MATCH_TYPE_TERNARY:
case PI_P4INFO_MATCH_TYPE_RANGE:
case PI_P4INFO_MATCH_TYPE_OPTIONAL: // treat it as ternary for now
return 2 * nbytes;
default:
assert(0);
}
return 0;
}
struct pi_match_key_s {
const pi_p4info_t *p4info;
pi_p4_id_t table_id;
pi_priority_t priority;
size_t data_size;
char *data;
};
struct pi_action_data_s {
const pi_p4info_t *p4info;
pi_p4_id_t action_id;
size_t data_size;
char *data;
};
struct pi_table_fetch_res_s {
const pi_p4info_t *p4info;
pi_p4_id_t table_id; // TODO(antonin): remove?
size_t num_entries;
size_t mkey_nbytes;
size_t idx;
size_t curr;
size_t entries_size;
char *entries;
// byte buffer to store structs used to represent entries in contiguous memory
// includes pointers to entries byte buffer
char *data;
// size reserved for each entry in data byte buffer
size_t data_size_per_entry;
size_t num_direct_resources;
size_t max_size_of_direct_resources;
};
struct pi_act_prof_fetch_res_s {
const pi_p4info_t *p4info;
pi_p4_id_t act_prof_id; // TODO(antonin): remove?
size_t num_members;
size_t num_groups;
size_t idx_members;
size_t idx_groups;
size_t curr_members;
size_t curr_groups;
size_t entries_members_size;
size_t entries_groups_size;
char *entries_members;
char *entries_groups;
size_t num_cumulated_mbr_handles;
pi_indirect_handle_t *mbr_handles;
struct pi_action_data_s *action_datas;
};
typedef struct {
pi_dev_id_t dev_id;
int backend_id;
size_t version;
const pi_p4info_t *p4info;
} pi_device_info_t;
void pi_device_lock();
void pi_device_unlock();
pi_device_info_t *pi_get_device_info(pi_dev_id_t dev_id);
pi_device_info_t *pi_get_devices(size_t *num_devices);
void pi_update_device_config(pi_dev_id_t dev_id, const pi_p4info_t *p4info);
void pi_create_device_config(pi_dev_id_t dev_id);
#ifdef __cplusplus
}
#endif
#endif // PI_INT_PI_INT_H_
|
741de2daf5a28cc668cf77f28bc82e06f4c4e4c4
|
75196819c910f3fd523f1a4d28e5d0fe12570ab1
|
/src/bdb53/src/common/util_log.c
|
505ac6f1ae3f03cba7ba99a4a04f21370e664892
|
[
"MIT",
"BSD-3-Clause",
"Sleepycat"
] |
permissive
|
gridcoin-community/Gridcoin-Research
|
889967579b5b05bcc3ae836697a0f173b5ae91ea
|
21414dd0f63c9a34060f7f762f08d1a52aeb9e87
|
refs/heads/development
| 2023-09-04T09:21:55.006935
| 2023-09-03T17:45:20
| 2023-09-03T17:45:20
| 23,332,350
| 292
| 117
|
MIT
| 2023-09-11T10:22:10
| 2014-08-25T23:41:04
|
HTML
|
UTF-8
|
C
| false
| false
| 792
|
c
|
util_log.c
|
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 2000, 2013 Oracle and/or its affiliates. All rights reserved.
*
* $Id$
*/
#include "db_config.h"
#include "db_int.h"
/*
* __db_util_logset --
* Log that we're running.
*
* PUBLIC: int __db_util_logset __P((const char *, char *));
*/
int
__db_util_logset(progname, fname)
const char *progname;
char *fname;
{
pid_t pid;
FILE *fp;
time_t now;
char time_buf[CTIME_BUFLEN];
if ((fp = fopen(fname, "w")) == NULL)
goto err;
(void)time(&now);
__os_id(NULL, &pid, NULL);
fprintf(fp,
"%s: %lu %s", progname, (u_long)pid, __os_ctime(&now, time_buf));
if (fclose(fp) == EOF)
goto err;
return (0);
err: fprintf(stderr, "%s: %s: %s\n", progname, fname, strerror(errno));
return (1);
}
|
21578fd39d367b93579951254c8d0e3011acdc85
|
105be9a75408fe7944b60885061d281e7fd9192b
|
/include/unk_structs/D_800D6A08.h
|
db3f53fc7c0a661563243cc4d669e362096b6021
|
[] |
no_license
|
farisawan-2000/kirby64
|
73146684368b0cbe5e2a41a42625f07817cc91c3
|
9f95c182132771cfb5f439ab1a60b589c6f7d665
|
refs/heads/master
| 2023-08-08T18:19:35.226495
| 2023-07-23T20:37:14
| 2023-07-23T20:37:14
| 265,695,457
| 148
| 18
| null | 2022-12-27T15:23:50
| 2020-05-20T22:03:14
|
Assembly
|
UTF-8
|
C
| false
| false
| 494
|
h
|
D_800D6A08.h
|
#ifndef _D_800D6A08_H
#define _D_800D6A08_H
struct UnkStruct800D6A08 {
struct UnkStruct800D6A08 *next;
u16 unk4;
u16 unk6;
u32 unk8;
u32 unkC;
u32 unk10;
u32 unk14;
u32 unk18;
u32 unk1C;
u32 unk20;
u32 unk24;
u32 unk28;
u32 unk2C;
u32 unk30;
u32 unk34;
u32 unk38;
u32 unk3C;
u32 unk40;
u32 unk44;
u32 unk48;
u32 unk4C;
};
extern struct UnkStruct800D6A08 *D_800D6A08;
extern struct UnkStruct800D6A08 *D_800D6A0C;
extern struct UnkStruct800D6A08 *D_800D6AF0;
#endif
|
647f378832c619a23f83709b37d3fe3f4b142226
|
3cd3872acbc8b1a79a70b89b2fd58a171e7adc82
|
/vpx_dsp/quantize.c
|
d44ced20dca6e82e717b8fa97bdda26b7d79e840
|
[] |
permissive
|
webmproject/libvpx
|
58ab97861063cb521ec0d00ef9cb222ca97873b1
|
6fd360c684736e351160b131827dfbb207841164
|
refs/heads/main
| 2023-04-09T15:32:34.688724
| 2023-04-07T22:19:18
| 2023-04-07T22:19:18
| 22,927,608
| 889
| 376
|
BSD-3-Clause
| 2023-03-24T13:37:34
| 2014-08-13T19:03:21
|
C
|
UTF-8
|
C
| false
| false
| 12,142
|
c
|
quantize.c
|
/*
* Copyright (c) 2015 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <assert.h>
#include "./vpx_dsp_rtcd.h"
#include "vpx_dsp/quantize.h"
#include "vpx_dsp/vpx_dsp_common.h"
#include "vpx_mem/vpx_mem.h"
#include "vp9/common/vp9_scan.h"
#include "vp9/encoder/vp9_block.h"
void vpx_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant, uint16_t *eob_ptr) {
const int rc = 0;
const int coeff = coeff_ptr[rc];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
int tmp, eob = -1;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
tmp = clamp(abs_coeff + round_ptr[rc != 0], INT16_MIN, INT16_MAX);
tmp = (tmp * quant) >> 16;
qcoeff_ptr[rc] = (tmp ^ coeff_sign) - coeff_sign;
dqcoeff_ptr[rc] = qcoeff_ptr[rc] * dequant;
if (tmp) eob = 0;
*eob_ptr = eob + 1;
}
#if CONFIG_VP9_HIGHBITDEPTH
void vpx_highbd_quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant, uint16_t *eob_ptr) {
int eob = -1;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
{
const int coeff = coeff_ptr[0];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
const int64_t tmp = abs_coeff + round_ptr[0];
const int abs_qcoeff = (int)((tmp * quant) >> 16);
qcoeff_ptr[0] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign);
dqcoeff_ptr[0] = qcoeff_ptr[0] * dequant;
if (abs_qcoeff) eob = 0;
}
*eob_ptr = eob + 1;
}
#endif
void vpx_quantize_dc_32x32(const tran_low_t *coeff_ptr,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant, uint16_t *eob_ptr) {
const int n_coeffs = 1024;
const int rc = 0;
const int coeff = coeff_ptr[rc];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
int tmp, eob = -1;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
tmp = clamp(abs_coeff + ROUND_POWER_OF_TWO(round_ptr[rc != 0], 1), INT16_MIN,
INT16_MAX);
tmp = (tmp * quant) >> 15;
qcoeff_ptr[rc] = (tmp ^ coeff_sign) - coeff_sign;
dqcoeff_ptr[rc] = qcoeff_ptr[rc] * dequant / 2;
if (tmp) eob = 0;
*eob_ptr = eob + 1;
}
#if CONFIG_VP9_HIGHBITDEPTH
void vpx_highbd_quantize_dc_32x32(const tran_low_t *coeff_ptr,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t dequant, uint16_t *eob_ptr) {
const int n_coeffs = 1024;
int eob = -1;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
{
const int coeff = coeff_ptr[0];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
const int64_t tmp = abs_coeff + ROUND_POWER_OF_TWO(round_ptr[0], 1);
const int abs_qcoeff = (int)((tmp * quant) >> 15);
qcoeff_ptr[0] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign);
dqcoeff_ptr[0] = qcoeff_ptr[0] * dequant / 2;
if (abs_qcoeff) eob = 0;
}
*eob_ptr = eob + 1;
}
#endif
void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
const int16_t *zbin_ptr, const int16_t *round_ptr,
const int16_t *quant_ptr, const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
int i, non_zero_count = (int)n_coeffs, eob = -1;
const int zbins[2] = { zbin_ptr[0], zbin_ptr[1] };
const int nzbins[2] = { zbins[0] * -1, zbins[1] * -1 };
(void)iscan;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
// Pre-scan pass
for (i = (int)n_coeffs - 1; i >= 0; i--) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
if (coeff < zbins[rc != 0] && coeff > nzbins[rc != 0])
non_zero_count--;
else
break;
}
// Quantization pass: All coefficients with index >= zero_flag are
// skippable. Note: zero_flag can be zero.
for (i = 0; i < non_zero_count; i++) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
if (abs_coeff >= zbins[rc != 0]) {
int tmp = clamp(abs_coeff + round_ptr[rc != 0], INT16_MIN, INT16_MAX);
tmp = ((((tmp * quant_ptr[rc != 0]) >> 16) + tmp) *
quant_shift_ptr[rc != 0]) >>
16; // quantization
qcoeff_ptr[rc] = (tmp ^ coeff_sign) - coeff_sign;
dqcoeff_ptr[rc] = (tran_low_t)(qcoeff_ptr[rc] * dequant_ptr[rc != 0]);
if (tmp) eob = i;
}
}
*eob_ptr = eob + 1;
}
#if CONFIG_VP9_HIGHBITDEPTH
void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
const int16_t *zbin_ptr, const int16_t *round_ptr,
const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
int i, non_zero_count = (int)n_coeffs, eob = -1;
const int zbins[2] = { zbin_ptr[0], zbin_ptr[1] };
const int nzbins[2] = { zbins[0] * -1, zbins[1] * -1 };
(void)iscan;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
// Pre-scan pass
for (i = (int)n_coeffs - 1; i >= 0; i--) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
if (coeff < zbins[rc != 0] && coeff > nzbins[rc != 0])
non_zero_count--;
else
break;
}
// Quantization pass: All coefficients with index >= zero_flag are
// skippable. Note: zero_flag can be zero.
for (i = 0; i < non_zero_count; i++) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
if (abs_coeff >= zbins[rc != 0]) {
const int64_t tmp1 = abs_coeff + round_ptr[rc != 0];
const int64_t tmp2 = ((tmp1 * quant_ptr[rc != 0]) >> 16) + tmp1;
const int abs_qcoeff = (int)((tmp2 * quant_shift_ptr[rc != 0]) >> 16);
qcoeff_ptr[rc] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign);
dqcoeff_ptr[rc] = qcoeff_ptr[rc] * dequant_ptr[rc != 0];
if (abs_qcoeff) eob = i;
}
}
*eob_ptr = eob + 1;
}
#endif
void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr,
const struct macroblock_plane *const mb_plane,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr, uint16_t *eob_ptr,
const struct ScanOrder *const scan_order) {
const int n_coeffs = 32 * 32;
const int zbins[2] = { ROUND_POWER_OF_TWO(mb_plane->zbin[0], 1),
ROUND_POWER_OF_TWO(mb_plane->zbin[1], 1) };
const int nzbins[2] = { zbins[0] * -1, zbins[1] * -1 };
const int16_t *round_ptr = mb_plane->round;
const int16_t *quant_ptr = mb_plane->quant;
const int16_t *quant_shift_ptr = mb_plane->quant_shift;
const int16_t *scan = scan_order->scan;
int idx = 0;
int idx_arr[32 * 32 /* n_coeffs */];
int i, eob = -1;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
// Pre-scan pass
for (i = 0; i < n_coeffs; i++) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
// If the coefficient is out of the base ZBIN range, keep it for
// quantization.
if (coeff >= zbins[rc != 0] || coeff <= nzbins[rc != 0]) idx_arr[idx++] = i;
}
// Quantization pass: only process the coefficients selected in
// pre-scan pass. Note: idx can be zero.
for (i = 0; i < idx; i++) {
const int rc = scan[idx_arr[i]];
const int coeff = coeff_ptr[rc];
const int coeff_sign = (coeff >> 31);
int tmp;
int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
abs_coeff += ROUND_POWER_OF_TWO(round_ptr[rc != 0], 1);
abs_coeff = clamp(abs_coeff, INT16_MIN, INT16_MAX);
tmp = ((((abs_coeff * quant_ptr[rc != 0]) >> 16) + abs_coeff) *
quant_shift_ptr[rc != 0]) >>
15;
qcoeff_ptr[rc] = (tmp ^ coeff_sign) - coeff_sign;
#if (VPX_ARCH_X86 || VPX_ARCH_X86_64) && !CONFIG_VP9_HIGHBITDEPTH
// When tran_low_t is only 16 bits dqcoeff can outrange it. Rather than
// truncating with a cast, saturate the value. This is easier to implement
// on x86 and preserves the sign of the value.
dqcoeff_ptr[rc] =
clamp(qcoeff_ptr[rc] * dequant_ptr[rc != 0] / 2, INT16_MIN, INT16_MAX);
#else
dqcoeff_ptr[rc] = qcoeff_ptr[rc] * dequant_ptr[rc != 0] / 2;
#endif // VPX_ARCH_X86 && CONFIG_VP9_HIGHBITDEPTH
if (tmp) eob = idx_arr[i];
}
*eob_ptr = eob + 1;
}
#if CONFIG_VP9_HIGHBITDEPTH
void vpx_highbd_quantize_b_32x32_c(
const tran_low_t *coeff_ptr, const struct macroblock_plane *const mb_plane,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr,
uint16_t *eob_ptr, const struct ScanOrder *const scan_order) {
const intptr_t n_coeffs = 32 * 32;
const int zbins[2] = { ROUND_POWER_OF_TWO(mb_plane->zbin[0], 1),
ROUND_POWER_OF_TWO(mb_plane->zbin[1], 1) };
const int nzbins[2] = { zbins[0] * -1, zbins[1] * -1 };
const int16_t *round_ptr = mb_plane->round;
const int16_t *quant_ptr = mb_plane->quant;
const int16_t *quant_shift_ptr = mb_plane->quant_shift;
const int16_t *scan = scan_order->scan;
int idx = 0;
int idx_arr[1024];
int i, eob = -1;
memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
// Pre-scan pass
for (i = 0; i < n_coeffs; i++) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
// If the coefficient is out of the base ZBIN range, keep it for
// quantization.
if (coeff >= zbins[rc != 0] || coeff <= nzbins[rc != 0]) idx_arr[idx++] = i;
}
// Quantization pass: only process the coefficients selected in
// pre-scan pass. Note: idx can be zero.
for (i = 0; i < idx; i++) {
const int rc = scan[idx_arr[i]];
const int coeff = coeff_ptr[rc];
const int coeff_sign = (coeff >> 31);
const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign;
const int64_t tmp1 = abs_coeff + ROUND_POWER_OF_TWO(round_ptr[rc != 0], 1);
const int64_t tmp2 = ((tmp1 * quant_ptr[rc != 0]) >> 16) + tmp1;
const int abs_qcoeff = (int)((tmp2 * quant_shift_ptr[rc != 0]) >> 15);
qcoeff_ptr[rc] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign);
dqcoeff_ptr[rc] = qcoeff_ptr[rc] * dequant_ptr[rc != 0] / 2;
if (abs_qcoeff) eob = idx_arr[i];
}
*eob_ptr = eob + 1;
}
#endif
|
51b27e17c6852a5da7b5a933a5c09066ff2f9cbb
|
431a5c28b8dfcc7d6ca6f4f97bf370cd770547a7
|
/src/tmx/Asn_J2735/include/asn_j2735_r63/ITIScodes.h
|
6402c46d9c26c816a3d017998ae561807d33ccab
|
[
"Apache-2.0"
] |
permissive
|
usdot-fhwa-OPS/V2X-Hub
|
134061cfb55d8c83e871f7fd4bbfa5d8d3092eb0
|
aae33e6a16b8a30e1faee31a7ee863d191be06b8
|
refs/heads/develop
| 2023-08-26T10:10:59.989176
| 2023-08-24T14:58:21
| 2023-08-24T14:58:21
| 168,020,929
| 106
| 63
| null | 2023-09-11T20:24:45
| 2019-01-28T19:16:45
|
C
|
UTF-8
|
C
| false
| false
| 1,169
|
h
|
ITIScodes.h
|
/*
* Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
* From ASN.1 module "ITIS"
* found in "J2735_201603_ASN_CC.asn"
* `asn1c -gen-PER -fcompound-names -fincludes-quoted -fskeletons-copy`
*/
#ifndef _ITIScodes_H_
#define _ITIScodes_H_
#include "asn_application.h"
/* Including external dependencies */
#include "NativeInteger.h"
#ifdef __cplusplus
extern "C" {
#endif
/* ITIScodes */
typedef long ITIScodes_t;
/* Implementation */
extern asn_per_constraints_t asn_PER_type_ITIScodes_constr_1;
extern asn_TYPE_descriptor_t asn_DEF_ITIScodes;
asn_struct_free_f ITIScodes_free;
asn_struct_print_f ITIScodes_print;
asn_constr_check_f ITIScodes_constraint;
ber_type_decoder_f ITIScodes_decode_ber;
der_type_encoder_f ITIScodes_encode_der;
xer_type_decoder_f ITIScodes_decode_xer;
xer_type_encoder_f ITIScodes_encode_xer;
oer_type_decoder_f ITIScodes_decode_oer;
oer_type_encoder_f ITIScodes_encode_oer;
per_type_decoder_f ITIScodes_decode_uper;
per_type_encoder_f ITIScodes_encode_uper;
per_type_decoder_f ITIScodes_decode_aper;
per_type_encoder_f ITIScodes_encode_aper;
#ifdef __cplusplus
}
#endif
#endif /* _ITIScodes_H_ */
#include "asn_internal.h"
|
98b21fb28b9c9e5a14e19b895d0e7d33ea04591c
|
88ae8695987ada722184307301e221e1ba3cc2fa
|
/third_party/grpc/src/third_party/upb/upb/upb.h
|
7398d09fff5874f591e54028286a1b5912913714
|
[
"Apache-2.0",
"LGPL-2.0-or-later",
"MIT",
"GPL-1.0-or-later",
"BSD-3-Clause",
"MPL-2.0"
] |
permissive
|
iridium-browser/iridium-browser
|
71d9c5ff76e014e6900b825f67389ab0ccd01329
|
5ee297f53dc7f8e70183031cff62f37b0f19d25f
|
refs/heads/master
| 2023-08-03T16:44:16.844552
| 2023-07-20T15:17:00
| 2023-07-23T16:09:30
| 220,016,632
| 341
| 40
|
BSD-3-Clause
| 2021-08-13T13:54:45
| 2019-11-06T14:32:31
| null |
UTF-8
|
C
| false
| false
| 5,511
|
h
|
upb.h
|
/*
* Copyright (c) 2009-2021, Google LLC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Google LLC nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This file contains shared definitions that are widely used across upb.
*/
#ifndef UPB_H_
#define UPB_H_
#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
// TODO(b/232091617): Remove these and fix everything that breaks as a result.
#include "upb/arena.h"
#include "upb/status.h"
// Must be last.
#include "upb/port_def.inc"
#ifdef __cplusplus
extern "C" {
#endif
/** upb_StringView ************************************************************/
typedef struct {
const char* data;
size_t size;
} upb_StringView;
UPB_INLINE upb_StringView upb_StringView_FromDataAndSize(const char* data,
size_t size) {
upb_StringView ret;
ret.data = data;
ret.size = size;
return ret;
}
UPB_INLINE upb_StringView upb_StringView_FromString(const char* data) {
return upb_StringView_FromDataAndSize(data, strlen(data));
}
UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b) {
return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
}
#define UPB_STRINGVIEW_INIT(ptr, len) \
{ ptr, len }
#define UPB_STRINGVIEW_FORMAT "%.*s"
#define UPB_STRINGVIEW_ARGS(view) (int)(view).size, (view).data
/* Constants ******************************************************************/
/* A list of types as they are encoded on-the-wire. */
typedef enum {
kUpb_WireType_Varint = 0,
kUpb_WireType_64Bit = 1,
kUpb_WireType_Delimited = 2,
kUpb_WireType_StartGroup = 3,
kUpb_WireType_EndGroup = 4,
kUpb_WireType_32Bit = 5
} upb_WireType;
/* The types a field can have. Note that this list is not identical to the
* types defined in descriptor.proto, which gives INT32 and SINT32 separate
* types (we distinguish the two with the "integer encoding" enum below). */
typedef enum {
kUpb_CType_Bool = 1,
kUpb_CType_Float = 2,
kUpb_CType_Int32 = 3,
kUpb_CType_UInt32 = 4,
kUpb_CType_Enum = 5, /* Enum values are int32. */
kUpb_CType_Message = 6,
kUpb_CType_Double = 7,
kUpb_CType_Int64 = 8,
kUpb_CType_UInt64 = 9,
kUpb_CType_String = 10,
kUpb_CType_Bytes = 11
} upb_CType;
/* The repeated-ness of each field; this matches descriptor.proto. */
typedef enum {
kUpb_Label_Optional = 1,
kUpb_Label_Required = 2,
kUpb_Label_Repeated = 3
} upb_Label;
/* Descriptor types, as defined in descriptor.proto. */
typedef enum {
kUpb_FieldType_Double = 1,
kUpb_FieldType_Float = 2,
kUpb_FieldType_Int64 = 3,
kUpb_FieldType_UInt64 = 4,
kUpb_FieldType_Int32 = 5,
kUpb_FieldType_Fixed64 = 6,
kUpb_FieldType_Fixed32 = 7,
kUpb_FieldType_Bool = 8,
kUpb_FieldType_String = 9,
kUpb_FieldType_Group = 10,
kUpb_FieldType_Message = 11,
kUpb_FieldType_Bytes = 12,
kUpb_FieldType_UInt32 = 13,
kUpb_FieldType_Enum = 14,
kUpb_FieldType_SFixed32 = 15,
kUpb_FieldType_SFixed64 = 16,
kUpb_FieldType_SInt32 = 17,
kUpb_FieldType_SInt64 = 18
} upb_FieldType;
#define kUpb_Map_Begin ((size_t)-1)
UPB_INLINE bool _upb_IsLittleEndian(void) {
int x = 1;
return *(char*)&x == 1;
}
UPB_INLINE uint32_t _upb_BigEndian_Swap32(uint32_t val) {
if (_upb_IsLittleEndian()) {
return val;
} else {
return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
}
}
UPB_INLINE uint64_t _upb_BigEndian_Swap64(uint64_t val) {
if (_upb_IsLittleEndian()) {
return val;
} else {
return ((uint64_t)_upb_BigEndian_Swap32((uint32_t)val) << 32) |
_upb_BigEndian_Swap32((uint32_t)(val >> 32));
}
}
UPB_INLINE int _upb_Log2Ceiling(int x) {
if (x <= 1) return 0;
#ifdef __GNUC__
return 32 - __builtin_clz(x - 1);
#else
int lg2 = 0;
while (1 << lg2 < x) lg2++;
return lg2;
#endif
}
UPB_INLINE int _upb_Log2CeilingSize(int x) { return 1 << _upb_Log2Ceiling(x); }
#include "upb/port_undef.inc"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* UPB_H_ */
|
4f5d6f9cc038d6e0bdf92c7c628d2a44edd82594
|
5ff4b6986e6799bc0e143e060bafc14369030d8b
|
/toolchain/riscv-isa-sim/riscv/insns/fsqrt_h.h
|
138d5727448e332038219ff1a59e8540c03d306b
|
[
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"GPL-1.0-or-later",
"LLVM-exception",
"Apache-2.0",
"BSD-3-Clause",
"LicenseRef-scancode-bsd-3-clause-jtag",
"GPL-3.0-or-later"
] |
permissive
|
pulp-platform/mempool
|
7583204b2436cfc12ed95599463e51ad4df51557
|
c98fb3ada4f255623eaf9b09861f397a60c3d96b
|
refs/heads/main
| 2023-08-08T09:07:56.696580
| 2023-07-27T17:24:38
| 2023-07-27T17:24:38
| 223,218,149
| 178
| 28
|
Apache-2.0
| 2023-07-27T17:24:39
| 2019-11-21T16:34:37
|
C
|
UTF-8
|
C
| false
| false
| 120
|
h
|
fsqrt_h.h
|
require_extension(EXT_ZFH);
require_fp;
softfloat_roundingMode = RM;
WRITE_FRD(f16_sqrt(f16(FRS1)));
set_fp_exceptions;
|
77009fc67d2cb0c5ef587c4cdb124456c94d8063
|
17d7357e5c5130ace022b3c9d9f98e7b13dda0ca
|
/src/util/samples_ops.c
|
b4e09cad2693083547c40406dee14a108872ea01
|
[
"ISC",
"LicenseRef-scancode-public-domain"
] |
permissive
|
vgmstream/vgmstream
|
4a7747bb75ff513f8fc8cc26f31d6e3a4150bc43
|
883d796d4b63c42810586e9f1ffbdcdd28c73ef5
|
refs/heads/master
| 2023-09-04T16:14:38.136915
| 2023-09-02T18:06:38
| 2023-09-02T18:06:38
| 5,591,410
| 762
| 137
|
NOASSERTION
| 2023-09-10T22:58:26
| 2012-08-28T20:08:24
|
C
|
UTF-8
|
C
| false
| false
| 1,632
|
c
|
samples_ops.c
|
#include "samples_ops.h"
void swap_samples_le(sample_t *buf, int count) {
/* Windows can't be BE... I think */
#if !defined(_WIN32)
#if !defined(__BYTE_ORDER__) || __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
int i;
for (i = 0; i < count; i++) {
/* 16b sample in memory: aabb where aa=MSB, bb=LSB */
uint8_t b0 = buf[i] & 0xff;
uint8_t b1 = buf[i] >> 8;
uint8_t *p = (uint8_t*)&(buf[i]);
/* 16b sample in buffer: bbaa where bb=LSB, aa=MSB */
p[0] = b0;
p[1] = b1;
/* when endianness is LE, buffer has bbaa already so this function can be skipped */
}
#endif
#endif
}
/* unused */
/*
void interleave_channel(sample_t * outbuffer, sample_t * inbuffer, int32_t sample_count, int channel_count, int channel_number) {
int32_t insample,outsample;
if (channel_count==1) {
memcpy(outbuffer,inbuffer,sizeof(sample)*sample_count);
return;
}
for (insample=0,outsample=channel_number;insample<sample_count;insample++,outsample+=channel_count) {
outbuffer[outsample]=inbuffer[insample];
}
}
*/
/* failed attempt at interleave in place */
/*
void interleave_stereo(sample_t * buffer, int32_t sample_count) {
int32_t tomove, belongs;
sample_t moving,temp;
tomove = sample_count;
moving = buffer[tomove];
do {
if (tomove<sample_count)
belongs = tomove*2;
else
belongs = (tomove-sample_count)*2+1;
temp = buffer[belongs];
buffer[belongs] = moving;
moving = temp;
tomove = belongs;
} while (tomove != sample_count);
}
*/
|
4089da88f319617a8a0025ef7e335b1753b43a32
|
376e1818d427b5e4d32fa6dd6c7b71e9fd88afdb
|
/chat/prosody/patches/patch-util-src_pposix.c
|
73981bc4144c714c758160beed45b6ef2b87672a
|
[] |
no_license
|
NetBSD/pkgsrc
|
a0732c023519650ef821ab89c23ab6ab59e25bdb
|
d042034ec4896cc5b47ed6f2e5b8802d9bc5c556
|
refs/heads/trunk
| 2023-09-01T07:40:12.138283
| 2023-09-01T05:25:19
| 2023-09-01T05:25:19
| 88,439,572
| 321
| 138
| null | 2023-07-12T22:34:14
| 2017-04-16T20:04:15
| null |
UTF-8
|
C
| false
| false
| 277
|
c
|
patch-util-src_pposix.c
|
$NetBSD: patch-util-src_pposix.c,v 1.1 2022/05/08 21:24:12 khorben Exp $
--- util-src/pposix.c.orig 2022-03-08 12:34:39.594708341 +0000
+++ util-src/pposix.c
@@ -38,6 +38,7 @@
#endif
#endif
+#include <unistd.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
|
09bfbfbc851a02f6a47f12277ed9a7e66324fa0e
|
d2253070a3a64b14dee5ca0b3d311919178e590c
|
/include/metatile_behavior.h
|
c2d0d23ee3b42c8dfb5b10f68549e5dd7fc30dc8
|
[] |
no_license
|
pret/pokeemerald
|
ce232eccdde78502f3c251d672b26af3e1d7e508
|
d67914e114c937c4c80ce128ddc5523d4dc2cd40
|
refs/heads/master
| 2023-08-31T11:23:13.877932
| 2023-08-27T23:40:59
| 2023-08-27T23:40:59
| 43,677,244
| 1,944
| 1,903
| null | 2023-09-12T22:48:06
| 2015-10-05T10:09:22
|
C
|
UTF-8
|
C
| false
| false
| 6,631
|
h
|
metatile_behavior.h
|
#ifndef GUARD_METATILE_BEHAVIOR_H
#define GUARD_METATILE_BEHAVIOR_H
// Return values for MetatileBehavior_GetBridgeType
enum {
BRIDGE_TYPE_OCEAN, // For log bridges over 'ocean' style water (Routes 110/119 use this).
BRIDGE_TYPE_POND_LOW,
BRIDGE_TYPE_POND_MED,
BRIDGE_TYPE_POND_HIGH,
};
bool8 MetatileBehavior_IsATile(u8);
bool8 MetatileBehavior_IsEncounterTile(u8);
bool8 MetatileBehavior_IsJumpEast(u8);
bool8 MetatileBehavior_IsJumpWest(u8);
bool8 MetatileBehavior_IsJumpNorth(u8);
bool8 MetatileBehavior_IsJumpSouth(u8);
bool8 MetatileBehavior_IsPokeGrass(u8);
bool8 MetatileBehavior_IsSandOrDeepSand(u8);
bool8 MetatileBehavior_IsDeepSand(u8);
bool8 MetatileBehavior_IsReflective(u8);
bool8 MetatileBehavior_IsIce(u8);
bool8 MetatileBehavior_IsWarpDoor(u8);
bool8 MetatileBehavior_IsDoor(u8);
bool8 MetatileBehavior_IsEscalator(u8);
bool8 MetatileBehavior_IsLadder(u8);
bool8 MetatileBehavior_IsNonAnimDoor(u8);
bool8 MetatileBehavior_IsDeepSouthWarp(u8);
bool8 MetatileBehavior_IsSurfableWaterOrUnderwater(u8);
bool8 MetatileBehavior_IsEastArrowWarp(u8);
bool8 MetatileBehavior_IsWestArrowWarp(u8);
bool8 MetatileBehavior_IsNorthArrowWarp(u8);
bool8 MetatileBehavior_IsSouthArrowWarp(u8);
bool8 MetatileBehavior_IsArrowWarp(u8);
bool8 MetatileBehavior_IsForcedMovementTile(u8);
bool8 MetatileBehavior_IsIce_2(u8);
bool8 MetatileBehavior_IsTrickHouseSlipperyFloor(u8);
bool8 MetatileBehavior_IsWalkNorth(u8);
bool8 MetatileBehavior_IsWalkSouth(u8);
bool8 MetatileBehavior_IsWalkWest(u8);
bool8 MetatileBehavior_IsWalkEast(u8);
bool8 MetatileBehavior_IsNorthwardCurrent(u8);
bool8 MetatileBehavior_IsSouthwardCurrent(u8);
bool8 MetatileBehavior_IsWestwardCurrent(u8);
bool8 MetatileBehavior_IsEastwardCurrent(u8);
bool8 MetatileBehavior_IsSlideNorth(u8);
bool8 MetatileBehavior_IsSlideSouth(u8);
bool8 MetatileBehavior_IsSlideWest(u8);
bool8 MetatileBehavior_IsSlideEast(u8);
bool8 MetatileBehavior_IsCounter(u8);
bool8 MetatileBehavior_IsPlayerFacingTVScreen(u8 tile, u8 playerDir);
bool8 MetatileBehavior_IsPC(u8);
bool8 MetatileBehavior_IsCableBoxResults1(u8);
bool8 MetatileBehavior_IsOpenSecretBaseDoor(u8);
bool8 MetatileBehavior_IsSecretBaseCave(u8);
bool8 MetatileBehavior_IsSecretBaseTree(u8);
bool8 MetatileBehavior_IsSecretBaseShrub(u8);
bool8 MetatileBehavior_IsSecretBasePC(u8);
bool8 MetatileBehavior_IsRecordMixingSecretBasePC(u8);
bool8 MetatileBehavior_IsSecretBaseTrainerSpot(u8);
bool8 MetatileBehavior_IsSecretBaseImpassable(u8);
bool8 MetatileBehavior_IsSecretBaseDecorationBase(u8);
bool8 MetatileBehavior_IsSecretBasePoster(u8);
bool8 MetatileBehavior_IsNormal(u8);
bool8 MetatileBehavior_IsSecretBaseNorthWall(u8);
bool8 MetatileBehavior_HoldsSmallDecoration(u8);
bool8 MetatileBehavior_HoldsLargeDecoration(u8);
bool8 MetatileBehavior_IsSecretBaseHole(u8);
bool8 MetatileBehavior_IsSecretBaseBalloon(u8);
bool8 MetatileBehavior_IsSecretBaseBreakableDoor(u8);
bool8 MetatileBehavior_IsSecretBaseSoundMat(u8);
bool8 MetatileBehavior_IsSecretBaseGlitterMat(u8);
bool8 MetatileBehavior_IsSecretBaseSandOrnament(u8);
bool8 MetatileBehavior_IsSecretBaseShieldOrToyTV(u8);
bool8 MetatileBehavior_IsPlayerRoomPCOn(u8);
bool8 MetatileBehavior_HasRipples(u8);
bool8 MetatileBehavior_IsPuddle(u8);
bool8 MetatileBehavior_IsTallGrass(u8);
bool8 MetatileBehavior_IsLongGrass(u8);
bool8 MetatileBehavior_IsBerryTreeSoil(u8);
bool8 MetatileBehavior_IsAshGrass(u8);
bool8 MetatileBehavior_IsFootprints(u8);
bool8 MetatileBehavior_IsBridgeOverWater(u8);
u8 MetatileBehavior_GetBridgeType(u8);
bool8 MetatileBehavior_IsBridgeOverWaterNoEdge(u8);
bool8 MetatileBehavior_IsLandWildEncounter(u8);
bool8 MetatileBehavior_IsWaterWildEncounter(u8);
bool8 MetatileBehavior_IsIndoorEncounter(u8);
bool8 MetatileBehavior_IsMountain(u8);
bool8 MetatileBehavior_IsDiveable(u8);
bool8 MetatileBehavior_IsUnableToEmerge(u8);
bool8 MetatileBehavior_IsShallowFlowingWater(u8);
bool8 MetatileBehavior_IsThinIce(u8);
bool8 MetatileBehavior_IsCrackedIce(u8);
bool8 MetatileBehavior_IsDeepOrOceanWater(u8);
bool8 MetatileBehavior_IsSurfableAndNotWaterfall(u8);
bool8 MetatileBehavior_IsEastBlocked(u8);
bool8 MetatileBehavior_IsWestBlocked(u8);
bool8 MetatileBehavior_IsNorthBlocked(u8);
bool8 MetatileBehavior_IsSouthBlocked(u8);
bool8 MetatileBehavior_IsShortGrass(u8);
bool8 MetatileBehavior_IsHotSprings(u8);
bool8 MetatileBehavior_IsWaterfall(u8);
bool8 MetatileBehavior_IsFortreeBridge(u8);
bool8 MetatileBehavior_IsPacifidlogVerticalLogTop(u8);
bool8 MetatileBehavior_IsPacifidlogVerticalLogBottom(u8);
bool8 MetatileBehavior_IsPacifidlogHorizontalLogLeft(u8);
bool8 MetatileBehavior_IsPacifidlogHorizontalLogRight(u8);
bool8 MetatileBehavior_IsPacifidlogLog(u8);
bool8 MetatileBehavior_IsTrickHousePuzzleDoor(u8);
bool8 MetatileBehavior_IsRegionMap(u8);
bool8 MetatileBehavior_IsClosedSootopolisDoor(u8);
bool8 MetatileBehavior_IsSkyPillarClosedDoor(u8);
bool8 MetatileBehavior_IsRoulette(u8);
bool8 MetatileBehavior_IsPokeblockFeeder(u8);
bool8 MetatileBehavior_IsSecretBaseJumpMat(u8);
bool8 MetatileBehavior_IsSecretBaseSpinMat(u8);
bool8 MetatileBehavior_IsLavaridgeB1FWarp(u8);
bool8 MetatileBehavior_IsLavaridge1FWarp(u8);
bool8 MetatileBehavior_IsAquaHideoutWarp(u8);
bool8 MetatileBehavior_IsUnionRoomWarp(u8);
bool8 MetatileBehavior_IsMossdeepGymWarp(u8);
bool8 MetatileBehavior_IsSurfableFishableWater(u8);
bool8 MetatileBehavior_IsMtPyreHole(u8);
bool8 MetatileBehavior_IsCrackedFloorHole(u8);
bool8 MetatileBehavior_IsCrackedFloor(u8);
bool8 MetatileBehavior_IsMuddySlope(u8);
bool8 MetatileBehavior_IsBumpySlope(u8);
bool8 MetatileBehavior_IsIsolatedVerticalRail(u8);
bool8 MetatileBehavior_IsIsolatedHorizontalRail(u8);
bool8 MetatileBehavior_IsVerticalRail(u8);
bool8 MetatileBehavior_IsHorizontalRail(u8);
bool8 MetatileBehavior_IsSeaweed(u8);
bool8 MetatileBehavior_IsRunningDisallowed(u8);
bool8 MetatileBehavior_IsCuttableGrass(u8);
bool8 MetatileBehavior_IsRunningShoesManual(u8);
bool8 MetatileBehavior_IsPictureBookShelf(u8);
bool8 MetatileBehavior_IsBookShelf(u8);
bool8 MetatileBehavior_IsPokeCenterBookShelf(u8);
bool8 MetatileBehavior_IsVase(u8);
bool8 MetatileBehavior_IsTrashCan(u8);
bool8 MetatileBehavior_IsShopShelf(u8);
bool8 MetatileBehavior_IsBlueprint(u8);
bool8 MetatileBehavior_IsBattlePyramidWarp(u8);
bool8 MetatileBehavior_IsPlayerFacingWirelessBoxResults(u8 tile, u8 playerDir);
bool8 MetatileBehavior_IsCableBoxResults2(u8 tile, u8 playerDir);
bool8 MetatileBehavior_IsQuestionnaire(u8);
bool8 MetatileBehavior_IsLongGrass_Duplicate(u8);
bool8 MetatileBehavior_IsLongGrassSouthEdge(u8);
bool8 MetatileBehavior_IsTrainerHillTimer(u8);
#endif // GUARD_METATILE_BEHAVIOR_H
|
c78886bae7766ea9dcd491bc631f5ccf1344262b
|
badb70a0b235c98ac034cfe5b4bfafda36647831
|
/Library/OcFirmwarePasswordLib/AppleFwPasswordInternal.h
|
70051a7b6711d3bff2d1cd4c879c25da3acfacfe
|
[
"BSD-3-Clause"
] |
permissive
|
acidanthera/OpenCorePkg
|
f34a7d67b22c74fb5ab559e48519e5f5855b6751
|
1d5b1736fe5a5ef7662b5c076c6d11aac96fd5d6
|
refs/heads/master
| 2023-08-30T21:03:02.993659
| 2023-08-28T23:30:43
| 2023-08-28T23:30:43
| 179,354,282
| 13,212
| 2,999
|
BSD-3-Clause
| 2023-09-10T18:29:53
| 2019-04-03T19:14:29
|
C
|
UTF-8
|
C
| false
| false
| 1,208
|
h
|
AppleFwPasswordInternal.h
|
/** @file
Copyright (C) 2016, The HermitCrabs Lab. All rights reserved.
All rights reserved.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __APPLE_FIRMWARE_PASSWORD_INTERNAL_H
#define __APPLE_FIRMWARE_PASSWORD_INTERNAL_H
#define APPLE_FIRMWARE_PASSWORD_PROTOCOL_REVISION 0x10000
typedef struct APPLE_FIRMWARE_PASSWORD_PRIVATE_DATA {
UINTN Signature;
APPLE_FIRMWARE_PASSWORD_PROTOCOL AppleFirmwarePassword;
} APPLE_FIRMWARE_PASSWORD_PRIVATE_DATA;
#define APPLE_FIRMWARE_PASSWORD_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('A', 'F', 'W', 'P')
#define APPLE_FIRMWARE_PASSWORD_PRIVATE_DATA_FROM_APPLE_SMC_THIS(a) \
CR(a, APPLE_FIRMWARE_PASSWORD_PRIVATE_DATA, AppleFirmwarePassword, APPLE_FIRMWARE_PASSWORD_PRIVATE_DATA_SIGNATURE)
#endif /* __APPLE_FIRMWARE_PASSWORD_INTERNAL_H */
|
f8310e84637bd8f1cb7065f35679e682c55f3a82
|
d169de4c5c6b281984df35536430dcc931a957a9
|
/source/component/usb/host/vsf_usbh.c
|
4aef97560bdb049f839066743dfee5ca85e1e183
|
[
"LGPL-2.1-only",
"Apache-2.0"
] |
permissive
|
vsfteam/vsf
|
2ba968ba2ef53b036668019c6c6746149a63c38a
|
522a52ff2ee4ed149b52789a5bd366f80c08c458
|
refs/heads/master
| 2023-08-27T07:32:08.339123
| 2023-08-26T17:46:07
| 2023-08-26T17:46:07
| 181,911,464
| 273
| 83
|
Apache-2.0
| 2023-08-29T03:08:36
| 2019-04-17T14:43:42
|
C
|
UTF-8
|
C
| false
| false
| 48,603
|
c
|
vsf_usbh.c
|
/*****************************************************************************
* Copyright(C)2009-2022 by VSF Team *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); *
* you may not use this file except in compliance with the License. *
* You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
* *
****************************************************************************/
/*============================ INCLUDES ======================================*/
#include "component/usb/vsf_usb_cfg.h"
#if VSF_USE_USB_HOST == ENABLED
#define __VSF_EDA_CLASS_INHERIT__
#define __VSF_USBH_CLASS_IMPLEMENT
#include "./vsf_usbh.h"
#include "hal/vsf_hal.h"
/*============================ MACROS ========================================*/
#ifndef VSF_USBH_CFG_CONTROL_TIMEOUT
# define VSF_USBH_CFG_CONTROL_TIMEOUT 2000
#endif
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
# define VSF_USBH_REL 0
# define VSF_USBH_VER 0
#endif
/*============================ MACROFIED FUNCTIONS ===========================*/
/*============================ TYPES =========================================*/
/*============================ GLOBAL VARIABLES ==============================*/
/*============================ LOCAL VARIABLES ===============================*/
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
/* usb 2.0 root hub device descriptor */
static const uint8_t __vk_usb_rh_dev_descriptor[18] = {
0x12, /* __u8 bLength; */
0x01, /* __u8 bDescriptorType; Device */
0x00, 0x00, /* __le16 bcdUSB: to be patched */
0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
0x00, /* __u8 bDeviceSubClass; */
0x00, /* __u8 bDeviceProtocol; [ usb 2.0 no TT ] */
0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
0x6b, 0x1d, /* __le16 idVendor; Linux Foundation 0x1d6b */
0x02, 0x00, /* __le16 idProduct; device 0x0002 */
VSF_USBH_VER, VSF_USBH_REL, /* __le16 bcdDevice */
0x00, /* __u8 iManufacturer; */
0x00, /* __u8 iProduct; */
0x00, /* __u8 iSerialNumber; */
0x01 /* __u8 bNumConfigurations; */
};
/* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
static const uint8_t __vk_usbh_rh_config_descriptor[] = {
/* one configuration */
0x09, /* __u8 bLength; */
0x02, /* __u8 bDescriptorType; Configuration */
0x19, 0x00, /* __le16 wTotalLength; */
0x01, /* __u8 bNumInterfaces; (1) */
0x01, /* __u8 bConfigurationValue; */
0x00, /* __u8 iConfiguration; */
0xc0, /* __u8 bmAttributes;
Bit 7: must be set,
6: Self-powered,
5: Remote wakeup,
4..0: resvd */
0x00, /* __u8 MaxPower; */
/* USB 1.1:
* USB 2.0, single TT organization (mandatory):
* one interface, protocol 0
*
* USB 2.0, multiple TT organization (optional):
* two interfaces, protocols 1 (like single TT)
* and 2 (multiple TT mode) ... config is
* sometimes settable
* NOT IMPLEMENTED
*/
/* one interface */
0x09, /* __u8 if_bLength; */
0x04, /* __u8 if_bDescriptorType; Interface */
0x00, /* __u8 if_bInterfaceNumber; */
0x00, /* __u8 if_bAlternateSetting; */
0x01, /* __u8 if_bNumEndpoints; */
0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
0x00, /* __u8 if_bInterfaceSubClass; */
0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
0x00, /* __u8 if_iInterface; */
/* one endpoint (status change endpoint) */
0x07, /* __u8 ep_bLength; */
0x05, /* __u8 ep_bDescriptorType; Endpoint */
0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
0x03, /* __u8 ep_bmAttributes; Interrupt */
(15 + 1 + 7) / 8, 0x00, /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
0xff /* __u8 ep_bInterval; (255ms -- usb 2.0 spec) */
};
#endif
/*============================ PROTOTYPES ====================================*/
extern void vsf_usbh_on_dev_parsed(vk_usbh_dev_t *dev, vk_usbh_dev_parser_t *parser);
extern vsf_err_t vsf_usbh_on_match_interface(
vk_usbh_dev_parser_t *parser, vk_usbh_ifs_parser_t *parser_ifs);
extern void vsf_usbh_on_remove_interface(vk_usbh_ifs_t *ifs);
/*============================ IMPLEMENTATION ================================*/
WEAK(vsf_usbh_on_dev_parsed)
void vsf_usbh_on_dev_parsed(vk_usbh_dev_t *dev, vk_usbh_dev_parser_t *parser)
{
}
WEAK(vsf_usbh_on_match_interface)
vsf_err_t vsf_usbh_on_match_interface(
vk_usbh_dev_parser_t *parser, vk_usbh_ifs_parser_t *parser_ifs)
{
vsf_trace_info("%s: vid%04X pid%04X interface%d" VSF_TRACE_CFG_LINEEND,
parser_ifs->ifs->drv->name,
parser->desc_device->idVendor, parser->desc_device->idProduct,
parser_ifs->parser_alt[parser_ifs->ifs->cur_alt].desc_ifs->bInterfaceNumber);
return VSF_ERR_NONE;
}
WEAK(vsf_usbh_on_remove_interface)
void vsf_usbh_on_remove_interface(vk_usbh_ifs_t *ifs)
{
vsf_trace_info("%s: remove interface" VSF_TRACE_CFG_LINEEND, ifs->drv->name);
}
uint32_t __vk_usbh_get_pipe_value(vk_usbh_dev_t *dev,
uint8_t endpoint, uint8_t type, uint16_t size)
{
return 1| (size << 1) /* 11-bit size */
| ((endpoint & 0xF) << 12) /* 4-bit endpoint */
| (type << 16) /* 2-bit type */
| (dev->speed << 18) /* 2-bit speed */
| (dev->devnum << 20) /* 7-bit address */
| ((endpoint & USB_DIR_MASK) << 20); /* 1-bit direction */
}
vk_usbh_pipe_t __vk_usbh_get_pipe(vk_usbh_dev_t *dev,
uint8_t endpoint, uint8_t type, uint16_t size, uint8_t interval)
{
vk_usbh_pipe_t pipe = {
.value = __vk_usbh_get_pipe_value(dev, endpoint, type, size),
};
if ( (USB_ENDPOINT_XFER_ISOC == type)
|| ((USB_ENDPOINT_XFER_INT == type) && (dev->speed >= USB_SPEED_HIGH))) {
// interval is 2 exp (interval - 1), interval at [1, 16]
VSF_USB_ASSERT((interval >= 1) && (interval <= 16));
pipe.interval = 1 << (interval - 1);
} else if (USB_ENDPOINT_XFER_INT == type) {
VSF_USB_ASSERT(interval >= 1);
pipe.interval = interval;
}
return pipe;
}
vk_usbh_pipe_t vk_usbh_get_pipe_from_ep_desc(vk_usbh_dev_t *dev,
struct usb_endpoint_desc_t *desc_ep)
{
return vk_usbh_get_pipe(dev, desc_ep->bEndpointAddress,
desc_ep->bmAttributes & 3, le16_to_cpu(desc_ep->wMaxPacketSize), desc_ep->bInterval);
}
void vk_usbh_urb_prepare_by_pipe(vk_usbh_urb_t *urb, vk_usbh_dev_t *dev, vk_usbh_pipe_t pipe)
{
VSF_USB_ASSERT((urb != NULL) && (dev != NULL));
urb->pipe = pipe;
}
void vk_usbh_urb_prepare(vk_usbh_urb_t *urb, vk_usbh_dev_t *dev,
struct usb_endpoint_desc_t *desc_ep)
{
VSF_USB_ASSERT((urb != NULL) && (dev != NULL) && (desc_ep != NULL));
urb->pipe = vk_usbh_get_pipe_from_ep_desc(dev, desc_ep);
}
bool vk_usbh_urb_is_valid(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT(urb != NULL);
return urb->pipe.value != 0;
}
bool vk_usbh_urb_is_alloced(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT(urb != NULL);
return !urb->pipe.is_pipe && (urb->urb_hcd != NULL);
}
vk_usbh_pipe_t vk_usbh_urb_get_pipe(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT(urb != NULL);
if (urb->pipe.is_pipe) {
return urb->pipe;
} else {
return urb->urb_hcd->pipe;
}
}
void vk_usbh_urb_set_pipe(vk_usbh_urb_t *urb, vk_usbh_pipe_t pipe)
{
VSF_USB_ASSERT(urb != NULL && pipe.is_pipe);
if (urb->pipe.is_pipe) {
urb->pipe = pipe;
} else {
urb->urb_hcd->pipe = pipe;
}
}
static void __vk_usbh_urb_reset_buffer(vk_usbh_hcd_urb_t *urb_hcd)
{
urb_hcd->buffer = NULL;
urb_hcd->transfer_length = 0;
urb_hcd->free_buffer = NULL;
}
void vk_usbh_hcd_urb_free_buffer(vk_usbh_hcd_urb_t *urb_hcd)
{
VSF_USB_ASSERT(urb_hcd != NULL);
if (urb_hcd->buffer && (urb_hcd->free_buffer != NULL)) {
urb_hcd->free_buffer(urb_hcd->free_buffer_param);
}
__vk_usbh_urb_reset_buffer(urb_hcd);
}
void vk_usbh_hcd_urb_complete(vk_usbh_hcd_urb_t *hcd_urb)
{
// check complete first because eda_caller uses same ram space as param for complete
vsf_usbh_urb_complete_t complete = hcd_urb->complete;
if (complete != NULL) {
complete(hcd_urb->param, hcd_urb);
return;
}
vsf_eda_t *eda_caller = hcd_urb->eda_caller;
if (eda_caller != NULL) {
vsf_eda_post_msg(eda_caller, hcd_urb);
}
}
static void __vk_usbh_free_buffer(void *buffer)
{
vsf_usbh_free(buffer);
}
void * vk_usbh_hcd_urb_alloc_buffer(vk_usbh_hcd_urb_t *urb_hcd, uint_fast16_t size)
{
VSF_USB_ASSERT((urb_hcd != NULL) && (size > 0));
vk_usbh_hcd_urb_free_buffer(urb_hcd);
urb_hcd->buffer = vsf_usbh_malloc(size);
urb_hcd->transfer_length = size;
urb_hcd->free_buffer = __vk_usbh_free_buffer;
urb_hcd->free_buffer_param = urb_hcd->buffer;
return urb_hcd->buffer;
}
uint_fast16_t vk_usbh_get_frame(vk_usbh_t *usbh)
{
return usbh->drv->get_frame_number(&usbh->use_as__vk_usbh_hcd_t);
}
static vk_usbh_dev_t * __vk_usbh_alloc_device(vk_usbh_t *usbh)
{
vk_usbh_dev_t *dev;
VSF_USB_ASSERT(usbh != NULL);
dev = vsf_usbh_malloc(sizeof(vk_usbh_dev_t));
if (NULL == dev) { return NULL; }
memset(dev, 0, sizeof(vk_usbh_dev_t));
if ( (usbh->drv->alloc_device != NULL)
&& (usbh->drv->alloc_device(&usbh->use_as__vk_usbh_hcd_t, &dev->use_as__vk_usbh_hcd_dev_t) != VSF_ERR_NONE)) {
free_dev:
vsf_usbh_free(dev);
return NULL;
}
dev->devnum = vsf_bitmap_ffz(&usbh->device_bitmap, VSF_USBH_CFG_MAX_DEVICE);
if (dev->devnum == 0) { goto free_dev; }
vsf_bitmap_set(&usbh->device_bitmap, dev->devnum);
return dev;
}
vk_usbh_dev_t * vk_usbh_new_device(vk_usbh_t *usbh, enum usb_device_speed_t speed,
vk_usbh_dev_t *dev_parent, uint_fast8_t idx)
{
vk_usbh_dev_t *dev_new = __vk_usbh_alloc_device(usbh);
if (dev_new != NULL) {
dev_new->speed = speed;
vsf_trace_info("usbh: new %s speed device connected" VSF_TRACE_CFG_LINEEND,
USB_SPEED_HIGH == speed ? "high" :
USB_SPEED_FULL == speed ? "full" :
USB_SPEED_LOW == speed ? "low" : "unknown");
if (dev_parent != NULL) {
#if VSF_USBH_USE_HUB == ENABLED
dev_new->index = idx;
dev_new->dev_parent = dev_parent;
vsf_slist_add_to_head(vk_usbh_dev_t, child_node, &dev_parent->children_list, dev_new);
#else
VSF_USB_ASSERT(false);
#endif
}
// notify to emulate new device
usbh->dev_new = dev_new;
vsf_eda_post_evt(&usbh->teda.use_as__vsf_eda_t, VSF_EVT_INIT);
}
return dev_new;
}
static void __vk_usbh_clean_device(vk_usbh_t *usbh, vk_usbh_dev_t *dev)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
vk_usbh_free_urb(usbh, &dev->ep0.urb);
if (usbh->drv->free_device != NULL) {
usbh->drv->free_device(&usbh->use_as__vk_usbh_hcd_t, &dev->use_as__vk_usbh_hcd_dev_t);
}
if (dev->ifs != NULL) {
vsf_usbh_free(dev->ifs);
dev->ifs = NULL;
}
}
enum usb_device_speed_t vk_usbh_get_dev_speed(vk_usbh_dev_t *dev)
{
return (enum usb_device_speed_t)dev->speed;
}
void vk_usbh_reset_dev(vk_usbh_t *usbh, vk_usbh_dev_t *dev)
{
vk_usbh_update_address(dev, 0);
#if VSF_USBH_USE_HUB == ENABLED
if (dev->dev_parent != NULL) {
vk_usbh_hub_reset_dev(dev);
} else
#endif
if ( (usbh->drv->reset_dev != NULL)
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
&& (usbh->dev_rh != dev)
#endif
) {
usbh->drv->reset_dev(&usbh->use_as__vk_usbh_hcd_t, &dev->use_as__vk_usbh_hcd_dev_t);
}
}
bool vk_usbh_is_dev_resetting(vk_usbh_t *usbh, vk_usbh_dev_t *dev)
{
#if VSF_USBH_USE_HUB == ENABLED
if (dev->dev_parent != NULL) {
return vk_usbh_hub_is_dev_resetting(dev);
} else
#endif
if ( (usbh->drv->is_dev_reset != NULL)
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
&& (usbh->dev_rh != dev)
#endif
) {
return usbh->drv->is_dev_reset(&usbh->use_as__vk_usbh_hcd_t, &dev->use_as__vk_usbh_hcd_dev_t);
}
return false;
}
void vk_usbh_update_address(vk_usbh_dev_t *dev, uint_fast8_t address)
{
vk_usbh_urb_t *urb = &dev->ep0.urb;
if (vk_usbh_urb_is_alloced(urb)) {
urb->urb_hcd->pipe.address = address;
} else {
urb->pipe.address = address;
}
}
#if __IS_COMPILER_IAR__
//! statement is unreachable
# pragma diag_suppress=pe111
#endif
vsf_err_t vk_usbh_alloc_urb(vk_usbh_t *usbh, vk_usbh_dev_t *dev, vk_usbh_urb_t *urb)
{
vk_usbh_pipe_t pipe;
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL) && (urb != NULL) && urb->pipe.is_pipe);
pipe = urb->pipe;
urb->urb_hcd = usbh->drv->alloc_urb(&usbh->use_as__vk_usbh_hcd_t);
if (urb->urb_hcd != NULL) {
urb->urb_hcd->pipe = pipe;
VSF_USB_ASSERT(!urb->urb_hcd->pipe.is_submitted);
urb->urb_hcd->dev_hcd = &dev->use_as__vk_usbh_hcd_dev_t;
return VSF_ERR_NONE;
} else {
urb->pipe = pipe;
VSF_USB_ASSERT(false);
return VSF_ERR_NOT_ENOUGH_RESOURCES;
}
}
void vk_usbh_unlink_urb(vk_usbh_t *usbh, vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT((usbh != NULL) && (urb != NULL));
if (vk_usbh_urb_is_alloced(urb)) {
urb->urb_hcd->transfer_flags &= ~__URB_NEED_FREE;
usbh->drv->free_urb(&usbh->use_as__vk_usbh_hcd_t, urb->urb_hcd);
}
}
void vk_usbh_free_urb(vk_usbh_t *usbh, vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT((usbh != NULL) && (urb != NULL));
if (vk_usbh_urb_is_alloced(urb)) {
vk_usbh_pipe_t pipe = urb->urb_hcd->pipe;
urb->urb_hcd->transfer_flags |= __URB_NEED_FREE;
usbh->drv->free_urb(&usbh->use_as__vk_usbh_hcd_t, urb->urb_hcd);
pipe.is_submitted = false;
urb->pipe = pipe;
}
}
void vk_usbh_urb_free_buffer(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT(urb != NULL);
if (!urb->pipe.is_pipe) {
vk_usbh_hcd_urb_free_buffer(urb->urb_hcd);
}
}
void * vk_usbh_urb_alloc_buffer(vk_usbh_urb_t *urb, uint_fast16_t size)
{
VSF_USB_ASSERT((urb != NULL) && (size > 0) && !urb->pipe.is_pipe);
return vk_usbh_hcd_urb_alloc_buffer(urb->urb_hcd, size);
}
void * vk_usbh_urb_peek_buffer(vk_usbh_urb_t *urb)
{
return urb->urb_hcd->buffer;
}
void * vk_usbh_urb_take_buffer(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT((urb != NULL) && !urb->pipe.is_pipe);
void *buffer = vk_usbh_urb_peek_buffer(urb);
__vk_usbh_urb_reset_buffer(urb->urb_hcd);
return buffer;
}
void vk_usbh_urb_set_buffer(vk_usbh_urb_t *urb, void *buffer,
uint_fast32_t size)
{
VSF_USB_ASSERT((urb != NULL) && !urb->pipe.is_pipe);
vk_usbh_hcd_urb_t *urb_hcd = urb->urb_hcd;
vk_usbh_urb_free_buffer(urb);
urb_hcd->buffer = buffer;
urb_hcd->transfer_length = size;
}
int_fast16_t vk_usbh_urb_get_status(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT((urb != NULL) && (urb->urb_hcd != NULL) && !urb->pipe.is_pipe);
return urb->urb_hcd->status;
}
uint_fast32_t vk_usbh_urb_get_actual_length(vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT((urb != NULL) && !urb->pipe.is_pipe);
return urb->urb_hcd->actual_length;
}
void vk_usbh_urb_set_complete(vk_usbh_urb_t *urb, vsf_usbh_urb_complete_t complete, void *param)
{
VSF_USB_ASSERT((urb != NULL) && !urb->pipe.is_pipe);
urb->urb_hcd->param = param;
urb->urb_hcd->complete = complete;
}
void vk_usbh_remove_interface(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
vk_usbh_ifs_t *ifs)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL) && (ifs != NULL));
const vk_usbh_class_drv_t *drv = ifs->drv;
if (drv) {
vsf_usbh_on_remove_interface(ifs);
drv->disconnect(usbh, dev, ifs->param);
ifs->drv = NULL;
ifs->param = NULL;
ifs->cur_alt = 0;
}
}
static void __vk_usbh_reset_parser(vk_usbh_dev_parser_t *parser)
{
if (parser->desc_config != NULL) {
vsf_usbh_free(parser->desc_config);
parser->desc_config = NULL;
}
if (parser->parser_ifs != NULL) {
vk_usbh_ifs_parser_t *parser_ifs = parser->parser_ifs;
for (uint_fast8_t ifs_idx = 0; ifs_idx < parser->num_of_ifs; ifs_idx++, parser_ifs++) {
vsf_usbh_free(parser_ifs->parser_alt);
}
vsf_usbh_free(parser->parser_ifs);
parser->parser_ifs = NULL;
}
}
static void __vk_usbh_free_parser(vk_usbh_t *usbh)
{
vk_usbh_dev_parser_t *parser = usbh->parser;
if (parser != NULL) {
__vk_usbh_reset_parser(parser);
if (parser->desc_device != NULL) {
vsf_usbh_free(parser->desc_device);
}
vsf_usbh_free(parser);
usbh->parser = NULL;
}
}
void vk_usbh_disconnect_device(vk_usbh_t *usbh, vk_usbh_dev_t *dev)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
#if VSF_USBH_USE_HUB == ENABLED
if (dev->dev_parent != NULL) {
vsf_slist_remove(vk_usbh_dev_t, child_node, &dev->dev_parent->children_list, dev);
}
#endif
vsf_trace_info("usbh: device disconnected" VSF_TRACE_CFG_LINEEND);
if (dev->num_of_ifs && (dev->ifs != NULL)) {
vk_usbh_ifs_t *ifs = dev->ifs;
for (uint_fast8_t i = 0; i < dev->num_of_ifs; i++, ifs++) {
vk_usbh_remove_interface(usbh, dev, ifs);
}
}
#if VSF_USBH_USE_HUB == ENABLED
vk_usbh_dev_t *dev_child;
while (!vsf_slist_is_empty(&dev->children_list)) {
vsf_slist_remove_from_head_unsafe(vk_usbh_dev_t, child_node, &dev->children_list, dev_child);
vk_usbh_disconnect_device(usbh, dev_child);
}
#endif
__vk_usbh_clean_device(usbh, dev);
if (dev->devnum != 0) {
vsf_bitmap_clear(&usbh->device_bitmap, dev->devnum);
}
if (usbh->dev_new == dev) {
usbh->dev_new = NULL;
vsf_eda_post_evt(&usbh->teda.use_as__vsf_eda_t, VSF_EVT_USER);
}
vsf_usbh_free(dev);
}
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
static vsf_err_t __vk_usbh_rh_submit_urb(vk_usbh_hcd_t *hcd, vk_usbh_hcd_urb_t *urb_hcd)
{
uint_fast16_t typeReq, wValue, wLength;
struct usb_ctrlrequest_t *req = &urb_hcd->setup_packet;
uint8_t data[32];
int_fast16_t len = 0;
if (urb_hcd->pipe.type == USB_ENDPOINT_XFER_INT) {
// WARNING: not support int transfer for HUB
return VSF_ERR_NOT_SUPPORT;
}
typeReq = (req->bRequestType << 8) | req->bRequest;
wValue = req->wValue;
wLength = req->wLength;
if (wLength > urb_hcd->transfer_length) {
goto error;
}
switch (typeReq) {
case DeviceRequest | USB_REQ_GET_STATUS:
data[0] = 1;
data[1] = 0;
len = 2;
break;
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
case DeviceOutRequest | USB_REQ_SET_FEATURE:
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
data[0] = 1;
len = 1;
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
break;
case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
switch ((wValue & 0xff00) >> 8) {
case USB_DT_DEVICE:
memcpy(data, __vk_usb_rh_dev_descriptor, sizeof(__vk_usb_rh_dev_descriptor));
switch (urb_hcd->pipe.speed) {
case USB_SPEED_LOW:
case USB_SPEED_FULL:
((struct usb_device_desc_t *)data)->bcdUSB = cpu_to_le16(0x0110);
break;
case USB_SPEED_HIGH:
((struct usb_device_desc_t *)data)->bcdUSB = cpu_to_le16(0x0200);
break;
//case USB_SPEED_VARIABLE:
// break;
//case USB_SPEED_SUPER:
// break;
default:
goto error;
}
len = sizeof(__vk_usb_rh_dev_descriptor);
break;
case USB_DT_CONFIG:
len = sizeof(__vk_usbh_rh_config_descriptor);
memcpy(data, __vk_usbh_rh_config_descriptor, len);
break;
default:
goto error;
}
break;
case DeviceRequest | USB_REQ_GET_INTERFACE:
data[0] = 0;
len = 1;
break;
case DeviceOutRequest | USB_REQ_SET_INTERFACE:
break;
case DeviceOutRequest | USB_REQ_SET_ADDRESS:
break;
case EndpointRequest | USB_REQ_GET_STATUS:
data[0] = 0;
data[1] = 0;
len = 2;
break;
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
case EndpointOutRequest | USB_REQ_SET_FEATURE:
break;
default:
len = hcd->drv->rh_control(hcd, urb_hcd);
if (len < 0) {
goto error;
}
goto complete;
}
if (len > 0) {
if (urb_hcd->transfer_length < len) {
len = urb_hcd->transfer_length;
}
urb_hcd->actual_length = len;
memcpy(urb_hcd->buffer, data, len);
}
complete:
urb_hcd->status = URB_OK;
vk_usbh_hcd_urb_complete(urb_hcd);
return VSF_ERR_NONE;
error:
urb_hcd->status = URB_FAIL;
return VSF_ERR_FAIL;
}
#endif
static vsf_err_t __vk_usbh_submit_urb_imp(vk_usbh_t *usbh, vk_usbh_urb_t *urb, vsf_eda_t *eda)
{
vk_usbh_hcd_urb_t *urb_hcd;
VSF_USB_ASSERT( (usbh != NULL) && (urb != NULL) && (urb->urb_hcd != NULL)
&& !urb->pipe.is_pipe);
urb_hcd = urb->urb_hcd;
if (NULL == urb_hcd->complete) {
if (NULL == eda) {
urb_hcd->eda_caller = vsf_eda_get_cur();
VSF_USB_ASSERT(urb_hcd->eda_caller != NULL);
} else {
urb_hcd->eda_caller = eda;
}
}
urb_hcd->actual_length = 0;
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
if (urb_hcd->dev_hcd == &usbh->dev_rh->use_as__vk_usbh_hcd_dev_t) {
return __vk_usbh_rh_submit_urb(&usbh->use_as__vk_usbh_hcd_t, urb_hcd);
}
#endif
if ( ( (urb_hcd->pipe.type != USB_ENDPOINT_XFER_INT)
&& (urb_hcd->pipe.type != USB_ENDPOINT_XFER_ISOC))
|| !urb_hcd->pipe.is_submitted) {
vsf_err_t err = usbh->drv->submit_urb(&usbh->use_as__vk_usbh_hcd_t, urb_hcd);
if (VSF_ERR_NONE == err) {
urb_hcd->pipe.is_submitted = true;
}
return err;
} else {
return usbh->drv->relink_urb(&usbh->use_as__vk_usbh_hcd_t, urb_hcd);
}
}
vsf_err_t vk_usbh_submit_urb(vk_usbh_t *usbh, vk_usbh_urb_t *urb)
{
VSF_USB_ASSERT(vk_usbh_urb_is_alloced(urb));
return __vk_usbh_submit_urb_imp(usbh, urb, NULL);
}
vsf_err_t vk_usbh_submit_urb_flags(vk_usbh_t *usbh, vk_usbh_urb_t *urb, uint_fast16_t flags)
{
VSF_USB_ASSERT(vk_usbh_urb_is_alloced(urb));
urb->urb_hcd->transfer_flags = flags;
return vk_usbh_submit_urb(usbh, urb);
}
vsf_err_t vk_usbh_submit_urb_ex(vk_usbh_t *usbh, vk_usbh_urb_t *urb, uint_fast16_t flags, vsf_eda_t *eda)
{
VSF_USB_ASSERT(vk_usbh_urb_is_alloced(urb));
urb->urb_hcd->transfer_flags = flags;
return __vk_usbh_submit_urb_imp(usbh, urb, eda);
}
#if VSF_USBH_CFG_ISO_EN == ENABLED
vsf_err_t vk_usbh_submit_urb_iso(vk_usbh_t *usbh, vk_usbh_urb_t *urb, uint_fast16_t start_frame)
{
VSF_USB_ASSERT(vk_usbh_urb_is_alloced(urb));
vk_usbh_hcd_iso_packet_t *iso_packet = &urb->urb_hcd->iso_packet;
vk_usbh_hcd_iso_packet_descriptor_t *frame_desc = iso_packet->frame_desc;
int_fast32_t size = urb->urb_hcd->transfer_length, cur_offset = 0;
uint_fast16_t ep_size = urb->urb_hcd->pipe.size, cur_size;
VSF_USB_ASSERT(size <= ep_size * dimof(iso_packet->frame_desc));
iso_packet->start_frame = start_frame;
iso_packet->number_of_packets = 0;
while (size > 0) {
iso_packet->number_of_packets++;
cur_size = vsf_min(ep_size, size);
frame_desc->length = cur_size;
frame_desc->offset = cur_offset;
size -= cur_size;
cur_offset += cur_size;
}
return vk_usbh_submit_urb(usbh, urb);
}
#endif
static vk_usbh_urb_t * __vk_usbh_control_msg_common(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
struct usb_ctrlrequest_t *req)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL) && (req != NULL));
vk_usbh_urb_t *urb = &dev->ep0.urb;
vk_usbh_hcd_urb_t *urb_hcd = urb->urb_hcd;
if (!dev->is_ep0_rdy) {
urb->pipe = vk_usbh_get_pipe(dev, 0, USB_ENDPOINT_XFER_CONTROL, 64);
vsf_err_t err = vk_usbh_alloc_urb(usbh, dev, urb);
if (err != VSF_ERR_NONE) { return NULL; }
urb_hcd = dev->ep0.urb.urb_hcd;
urb_hcd->dev_hcd = &dev->use_as__vk_usbh_hcd_dev_t;
dev->is_ep0_rdy = true;
}
urb_hcd->transfer_length = req->wLength;
if ( !urb_hcd->buffer && (req->wLength > 0)
&& !vk_usbh_urb_alloc_buffer(urb, req->wLength)) {
return NULL;
}
urb_hcd->pipe.dir_in1out0 = (req->bRequestType & USB_DIR_IN) > 0;
urb_hcd->timeout = VSF_USBH_CFG_CONTROL_TIMEOUT;
urb_hcd->setup_packet = *req;
return urb;
}
vsf_err_t vk_usbh_control_msg(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
struct usb_ctrlrequest_t *req)
{
vk_usbh_urb_t * urb = __vk_usbh_control_msg_common(usbh, dev, req);
if (urb != NULL) {
return vk_usbh_submit_urb(usbh, urb);
}
return VSF_ERR_FAIL;
}
vsf_err_t vk_usbh_control_msg_ex(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
struct usb_ctrlrequest_t *req, uint_fast16_t flags, vsf_eda_t *eda)
{
vk_usbh_urb_t * urb = __vk_usbh_control_msg_common(usbh, dev, req);
if (urb != NULL) {
return vk_usbh_submit_urb_ex(usbh, urb, flags, eda);
}
return VSF_ERR_FAIL;
}
vsf_err_t vk_usbh_set_address(vk_usbh_t *usbh, vk_usbh_dev_t *dev)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_DEVICE | USB_DIR_OUT,
.bRequest = USB_REQ_SET_ADDRESS,
.wValue = dev->devnum,
.wIndex = 0,
.wLength = 0,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_get_descriptor(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast8_t type, uint_fast8_t index, uint_fast16_t size)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_DEVICE | USB_DIR_IN,
.bRequest = USB_REQ_GET_DESCRIPTOR,
.wValue = (type << 8) + index,
.wIndex = index,
.wLength = size,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_get_class_descriptor(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast16_t ifs_no, uint_fast8_t type, uint_fast8_t id,
uint_fast16_t size)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_INTERFACE | USB_DIR_IN,
.bRequest = USB_REQ_GET_DESCRIPTOR,
.wValue = (type << 8) + id,
.wIndex = ifs_no,
.wLength = size,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_set_configuration(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast8_t configuration)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_DEVICE | USB_DIR_OUT,
.bRequest = USB_REQ_SET_CONFIGURATION,
.wValue = configuration,
.wIndex = 0,
.wLength = 0,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_set_interface(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast8_t ifs, uint_fast8_t alternate)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_INTERFACE | USB_DIR_OUT,
.bRequest = USB_REQ_SET_INTERFACE,
.wValue = alternate,
.wIndex = ifs,
.wLength = 0,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_clear_interface_feature(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast8_t ifs, uint_fast8_t feature)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_INTERFACE | USB_DIR_OUT,
.bRequest = USB_REQ_CLEAR_FEATURE,
.wValue = feature,
.wIndex = ifs,
.wLength = 0,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_clear_endpoint_feature(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast8_t endpoint, uint_fast8_t feature)
{
VSF_USB_ASSERT((usbh != NULL) && (dev != NULL));
struct usb_ctrlrequest_t req = {
.bRequestType = USB_RECIP_ENDPOINT | USB_DIR_OUT,
.bRequest = USB_REQ_CLEAR_FEATURE,
.wValue = feature,
.wIndex = endpoint,
.wLength = 0,
};
return vk_usbh_control_msg(usbh, dev, &req);
}
vsf_err_t vk_usbh_clear_endpoint_halt(vk_usbh_t *usbh, vk_usbh_dev_t *dev,
uint_fast8_t endpoint)
{
return vk_usbh_clear_endpoint_feature(usbh, dev, endpoint, USB_ENDPOINT_HALT);
}
static bool __vk_usbh_match_id(vk_usbh_dev_parser_t *parser,
vk_usbh_ifs_parser_t *parser_ifs, const vk_usbh_dev_id_t *dev_id)
{
vk_usbh_ifs_t *ifs = parser_ifs->ifs;
struct usb_interface_desc_t *desc_ifs =
parser_ifs->parser_alt[ifs->cur_alt].desc_ifs;
if ( (dev_id->match_vendor && (dev_id->idVendor != parser->desc_device->idVendor))
|| (dev_id->match_product && (dev_id->idProduct != parser->desc_device->idProduct))
|| (dev_id->match_dev_lo && (dev_id->bcdDevice_lo > parser->desc_device->bcdDevice))
|| (dev_id->match_dev_hi && (dev_id->bcdDevice_hi < parser->desc_device->bcdDevice))
|| (dev_id->match_dev_class && (dev_id->bDeviceClass != parser->desc_device->bDeviceClass))
|| (dev_id->match_dev_subclass && (dev_id->bDeviceSubClass!= parser->desc_device->bDeviceSubClass))
|| (dev_id->match_dev_protocol && (dev_id->bDeviceProtocol != parser->desc_device->bDeviceProtocol))
|| (dev_id->match_ifs_class && (dev_id->bInterfaceClass != desc_ifs->bInterfaceClass))
|| (dev_id->match_ifs_subclass && (dev_id->bInterfaceSubClass != desc_ifs->bInterfaceSubClass))
|| (dev_id->match_ifs_protocol && (dev_id->bInterfaceProtocol != desc_ifs->bInterfaceProtocol))
|| (dev_id->match_ifs_num && (dev_id->bInterfaceNumber != desc_ifs->bInterfaceNumber))
) {
return false;
}
return true;
}
static const vk_usbh_class_t *
__vk_usbh_match_interface_driver(vk_usbh_t *usbh, vk_usbh_dev_parser_t *parser,
vk_usbh_ifs_parser_t *parser_ifs, const vk_usbh_class_t *c)
{
vk_usbh_ifs_t *ifs = parser_ifs->ifs;
const vk_usbh_class_drv_t *drv;
const vk_usbh_dev_id_t *dev_id;
if (NULL == c) {
vsf_slist_peek_next(vk_usbh_class_t, node, &usbh->class_list, c);
} else {
vsf_slist_peek_next(vk_usbh_class_t, node, &c->node, c);
}
while (c != NULL) {
drv = c->drv;
dev_id = drv->dev_ids;
for (uint_fast8_t id_idx = 0; id_idx < drv->dev_id_num; id_idx++, dev_id++) {
for (uint_fast8_t i = 0; i < ifs->num_of_alt; i++) {
ifs->cur_alt = i;
if (__vk_usbh_match_id(parser, parser_ifs, dev_id)) {
parser_ifs->id = dev_id;
goto end;
}
}
}
vsf_slist_peek_next(vk_usbh_class_t, node, &c->node, c);
}
end:
return c;
}
static vsf_err_t __vk_usbh_find_intrface_driver(vk_usbh_t *usbh,
vk_usbh_dev_parser_t *parser, vk_usbh_ifs_parser_t *parser_ifs)
{
vk_usbh_ifs_t *ifs = parser_ifs->ifs;
const vk_usbh_class_t *c = NULL;
void *param;
do {
c = __vk_usbh_match_interface_driver(usbh, parser, parser_ifs, c);
if (c != NULL) {
const vk_usbh_class_drv_t *drv = c->drv;
ifs->drv = drv;
param = drv->probe(usbh, usbh->dev_new, parser_ifs);
if (param != NULL) {
ifs->param = param;
if (VSF_ERR_NONE != vsf_usbh_on_match_interface(parser, parser_ifs)) {
drv->disconnect(usbh, usbh->dev_new, param);
ifs->drv = NULL;
continue;
}
return VSF_ERR_NONE;
} else {
ifs->drv = NULL;
}
}
} while (c != NULL);
return VSF_ERR_FAIL;
}
static vsf_err_t __vk_usbh_parse_config(vk_usbh_t *usbh, vk_usbh_dev_parser_t *parser)
{
vk_usbh_dev_t *dev = usbh->dev_new;
struct usb_config_desc_t *desc_config = parser->desc_config;
struct usb_interface_desc_t *desc_ifs;
struct usb_descriptor_header_t *desc_header =
(struct usb_descriptor_header_t *)desc_config, *header_tmp;
uint_fast16_t size = desc_config->wTotalLength, len, tmpsize;
vk_usbh_ifs_parser_t *parser_ifs;
vk_usbh_ifs_alt_parser_t *parser_alt;
uint_fast8_t ifs_no;
enum {
STAGE_NONE = 0,
STAGE_ALLOC_ALT,
STAGE_PROBE_ALT,
} stage;
if (desc_header->bDescriptorType != USB_DT_CONFIG) {
return VSF_ERR_NONE;
}
parser->num_of_ifs = dev->num_of_ifs = desc_config->bNumInterfaces;
len = dev->num_of_ifs * sizeof(vk_usbh_ifs_t);
dev->ifs = vsf_usbh_malloc(len);
if (!dev->ifs) {
VSF_USB_ASSERT(false);
return VSF_ERR_NOT_ENOUGH_RESOURCES;
}
memset(dev->ifs, 0, len);
len = dev->num_of_ifs * sizeof(vk_usbh_ifs_parser_t);
parser->parser_ifs = vsf_usbh_malloc(len);
if (!parser->parser_ifs) {
VSF_USB_ASSERT(false);
return VSF_ERR_NOT_ENOUGH_RESOURCES;
}
memset(parser->parser_ifs, 0, len);
parser_ifs = parser->parser_ifs;
parser_ifs->ifs = dev->ifs;
size -= desc_header->bLength;
desc_header = (struct usb_descriptor_header_t *)((uint8_t *)desc_header + desc_header->bLength);
parser_alt = NULL;
stage = STAGE_ALLOC_ALT;
ifs_no = 0;
tmpsize = size;
header_tmp = desc_header;
while ((size > 0) && (size >= desc_header->bLength)) {
switch (desc_header->bDescriptorType) {
case USB_DT_INTERFACE:
desc_ifs = (struct usb_interface_desc_t *)desc_header;
if (!parser_ifs->parser_alt) {
if (desc_ifs->bInterfaceNumber == ifs_no) {
parser_ifs->ifs->num_of_alt++;
} else {
alloc_alt:
parser_ifs->ifs->no = ifs_no;
len = parser_ifs->ifs->num_of_alt * sizeof(*parser_ifs->parser_alt);
parser_ifs->parser_alt = vsf_usbh_malloc(len);
if (!parser_ifs->parser_alt) {
VSF_USB_ASSERT(false);
return VSF_ERR_NOT_ENOUGH_RESOURCES;
}
memset(parser_ifs->parser_alt, 0, len);
stage = STAGE_PROBE_ALT;
parser_alt = parser_ifs->parser_alt - 1;
size = tmpsize;
desc_header = header_tmp;
continue;
}
} else {
if (desc_ifs->bInterfaceNumber == ifs_no) {
if (parser_alt > parser_ifs->parser_alt) {
parser_alt[-1].desc_size = (uint8_t *)desc_ifs - (uint8_t *)parser_alt[-1].desc_ifs;
}
(++parser_alt)->desc_ifs = desc_ifs;
} else {
probe_alt:
parser_alt->desc_size = (uint8_t *)desc_ifs - (uint8_t *)parser_alt->desc_ifs;
parser_alt = NULL;
stage = size > 0 ? STAGE_ALLOC_ALT : STAGE_NONE;
ifs_no++;
if (ifs_no < dev->num_of_ifs) {
parser_ifs[1].ifs = &parser_ifs[0].ifs[1];
parser_ifs++;
}
tmpsize = size;
header_tmp = desc_header;
continue;
}
}
break;
case USB_DT_ENDPOINT:
if (parser_alt) {
if (!parser_alt->desc_ep) {
parser_alt->desc_ep = (struct usb_endpoint_desc_t *)desc_header;
parser_alt->num_of_ep = 0;
}
parser_alt->num_of_ep++;
}
break;
}
size -= desc_header->bLength;
desc_header = (struct usb_descriptor_header_t *)((uint8_t *)desc_header + desc_header->bLength);
if (!size && stage) {
if (stage == STAGE_ALLOC_ALT) {
goto alloc_alt;
} else /*if (stage == STAGE_PROBE_ALT)*/ {
desc_ifs = (struct usb_interface_desc_t *)desc_header;
goto probe_alt;
}
}
}
vsf_usbh_on_dev_parsed(usbh->dev_new, parser);
// probe
size = 0;
parser_ifs = parser->parser_ifs;
for (ifs_no = 0; ifs_no < dev->num_of_ifs; ifs_no++, parser_ifs++) {
if (!__vk_usbh_find_intrface_driver(usbh, parser, parser_ifs)) {
size++;
}
}
return size > 0 ? VSF_ERR_NONE : VSF_ERR_FAIL;
}
#if __IS_COMPILER_IAR__
//! statement is unreachable
# pragma diag_warning=pe111
#endif
static void __vk_usbh_probe_evthandler(vsf_eda_t *eda, vsf_evt_t evt)
{
vk_usbh_t *usbh = container_of(eda, vk_usbh_t, teda);
vk_usbh_dev_parser_t *parser = NULL;
vk_usbh_dev_t *dev;
vk_usbh_urb_t *urb;
uint8_t *buffer;
vsf_err_t err = VSF_ERR_NONE;
if (evt != VSF_EVT_INIT) {
parser = usbh->parser;
}
dev = usbh->dev_new;
if (NULL == dev) {
urb = NULL;
goto probe_cleanup;
}
urb = &dev->ep0.urb;
switch (evt) {
case VSF_EVT_USER:
probe_cleanup:
vsf_teda_cancel_timer();
goto parse_failed;
break;
case VSF_EVT_INIT:
parser = vsf_usbh_malloc(sizeof(*parser));
if (NULL == parser) { goto parse_failed; }
memset(parser, 0, sizeof(*parser));
usbh->parser = parser;
__vsf_eda_crit_npb_init(&dev->ep0.crit);
__vsf_eda_crit_npb_enter(&dev->ep0.crit);
parser->devnum_temp = dev->devnum;
device_probe_retry:
parser->probe_state = VSF_USBH_PROBE_START;
dev->devnum = 0;
// get 64 bytes device descriptor
err = vk_usbh_get_descriptor(usbh, dev, USB_DT_DEVICE, 0, 64);
break;
case VSF_EVT_MESSAGE:
if (vk_usbh_urb_get_status(urb) != URB_OK) {
// TODO: add retry cnt?
parser->is_to_retry = true;
parser->probe_state = VSF_USBH_PROBE_WAIT_DEVICE_RESET;
vk_usbh_reset_dev(usbh, dev);
goto device_reset_wait;
}
switch (parser->probe_state) {
case VSF_USBH_PROBE_WAIT_DEVICE_DESC:
buffer = vk_usbh_urb_take_buffer(urb);
urb->urb_hcd->pipe.size = buffer[7];
__vk_usbh_free_buffer(buffer);
if (dev->speed < USB_SPEED_HIGH) {
vk_usbh_reset_dev(usbh, dev);
goto device_reset_wait;
} else {
set_address:
dev->devnum = parser->devnum_temp;
err = vk_usbh_set_address(usbh, dev);
}
break;
case VSF_USBH_PROBE_WAIT_SET_ADDRESS:
vsf_teda_set_timer_ms(10);
break;
case VSF_USBH_PROBE_WAIT_FULL_DEVICE_DESC:
parser->desc_device = vk_usbh_urb_take_buffer(urb);
if (parser->desc_device->bNumConfigurations < 1) {
goto parse_failed;
}
dev->cur_config = 0;
parse_next_config:
parser->probe_state = VSF_USBH_PROBE_WAIT_FULL_DEVICE_DESC;
if (dev->cur_config >= parser->desc_device->bNumConfigurations) {
goto parse_failed;
}
// get 9 bytes configuration
err = vk_usbh_get_descriptor(usbh, dev, USB_DT_CONFIG, dev->cur_config, 9);
break;
case VSF_USBH_PROBE_WAIT_CONFIG_DESC_SIZE:
parser->desc_config = vk_usbh_urb_take_buffer(urb);
// get full configuration
err = vk_usbh_get_descriptor(usbh, dev, USB_DT_CONFIG,
dev->cur_config, parser->desc_config->wTotalLength);
break;
case VSF_USBH_PROBE_WAIT_FULL_CONFIG_DESC:
// check wTotalLength
if (vk_usbh_urb_get_actual_length(urb) != parser->desc_config->wTotalLength) {
goto parse_failed;
}
__vk_usbh_free_buffer(parser->desc_config);
parser->desc_config = vk_usbh_urb_take_buffer(urb);
if (__vk_usbh_parse_config(usbh, parser) < 0) {
__vk_usbh_reset_parser(parser);
dev->cur_config++;
goto parse_next_config;
}
if (!parser->no_set_configuration) {
err = vk_usbh_set_configuration(usbh, dev, parser->desc_config->bConfigurationValue);
break;
}
// fall through
case VSF_USBH_PROBE_WAIT_SET_CONFIG:
__vsf_eda_crit_npb_leave(&dev->ep0.crit);
goto parse_ok;
}
break;
case VSF_EVT_TIMER:
switch (parser->probe_state) {
case VSF_USBH_PROBE_WAIT_DEVICE_RESET:
if (vk_usbh_is_dev_resetting(usbh, dev)) {
device_reset_wait:
vsf_teda_set_timer_ms(20);
return;
} else {
if (parser->is_to_retry) {
parser->is_to_retry = false;
goto device_probe_retry;
} else {
goto set_address;
}
}
break;
case VSF_USBH_PROBE_WAIT_ADDRESS_STABLE:
// update address
vk_usbh_update_address(dev, dev->devnum);
// get full device descriptor
err = vk_usbh_get_descriptor(usbh, dev, USB_DT_DEVICE, 0,
sizeof(*parser->desc_device));
break;
}
}
if (err < 0) {
goto parse_failed;
}
parser->probe_state++;
return;
parse_failed:
if (dev != NULL) {
__vk_usbh_clean_device(usbh, dev);
}
parse_ok:
if (urb != NULL) {
vk_usbh_urb_free_buffer(urb);
}
__vk_usbh_free_parser(usbh);
usbh->dev_new = NULL;
}
static void __vk_usbh_init_evthandler(vsf_eda_t *eda, vsf_evt_t evt)
{
vk_usbh_t *usbh = container_of(eda, vk_usbh_t, teda);
vsf_err_t err = usbh->drv->init_evthandler(eda, evt, &usbh->use_as__vk_usbh_hcd_t);
VSF_USB_ASSERT(err >= 0);
if (VSF_ERR_NONE == err) {
#if VSF_KERNEL_CFG_EDA_SUPPORT_SUB_CALL == ENABLED
// init_evthandler should not use frame
VSF_USB_ASSERT(!eda->flag.feature.is_use_frame);
#endif
eda->fn.evthandler = __vk_usbh_probe_evthandler;
#if VSF_USBH_CFG_ENABLE_ROOT_HUB == ENABLED
if (usbh->drv->rh_control != NULL) {
usbh->dev_rh = vk_usbh_new_device(usbh, usbh->rh_speed, NULL, 0);
VSF_USB_ASSERT(usbh->dev_rh != NULL);
}
#endif
}
}
vsf_err_t vk_usbh_init(vk_usbh_t *usbh)
{
VSF_USB_ASSERT((usbh != NULL) && (usbh->drv != NULL));
vsf_slist_init(&usbh->class_list);
vsf_bitmap_reset(&usbh->device_bitmap, VSF_USBH_CFG_MAX_DEVICE);
vsf_bitmap_set(&usbh->device_bitmap, 0);
#if VSF_KERNEL_CFG_EDA_SUPPORT_ON_TERMINATE == ENABLED
usbh->teda.on_terminate = NULL;
#endif
usbh->teda.fn.evthandler = __vk_usbh_init_evthandler;
vsf_err_t err = vsf_teda_init(&usbh->teda, VSF_USBH_CFG_EDA_PRIORITY);
#if VSF_KERNEL_CFG_TRACE == ENABLED
vsf_kernel_trace_eda_info(&usbh->teda.use_as__vsf_eda_t, "usbh_task", NULL, 0);
#endif
return err;
}
vsf_err_t vk_usbh_fini(vk_usbh_t *usbh)
{
// TODO
return VSF_ERR_NONE;
}
void vk_usbh_unregister_class(vk_usbh_t *usbh, vk_usbh_class_t *c)
{
__vsf_slist_foreach_next_unsafe(vk_usbh_class_t, node, &usbh->class_list) {
if (_ == c) {
vsf_slist_set_next(vk_usbh_class_t, node, __, (vk_usbh_class_t *)_->node.next);
break;
}
}
}
void vk_usbh_register_class(vk_usbh_t *usbh, vk_usbh_class_t *c)
{
VSF_USB_ASSERT((usbh != NULL) && (c != NULL));
vsf_slist_add_to_head(vk_usbh_class_t, node, &usbh->class_list, c);
}
vsf_err_t vk_usbh_get_extra_descriptor(uint8_t *buf, uint_fast16_t size,
uint_fast8_t type, void **ptr)
{
struct usb_descriptor_header_t *header;
VSF_USB_ASSERT((buf != NULL) && (ptr != NULL));
while (size >= sizeof(struct usb_descriptor_header_t)) {
header = (struct usb_descriptor_header_t *)buf;
if (header->bLength < 2) {
break;
}
if (header->bDescriptorType == type) {
*ptr = header;
return VSF_ERR_NONE;
}
if (size < header->bLength) {
break;
}
buf += header->bLength;
size -= header->bLength;
}
return VSF_ERR_FAIL;
}
usb_endpoint_desc_t * vk_usbh_get_next_ep_descriptor(usb_endpoint_desc_t *desc_ep, uint_fast16_t size)
{
if (size > desc_ep->bLength) {
desc_ep = (struct usb_endpoint_desc_t *)((uintptr_t)desc_ep + desc_ep->bLength);
size -= desc_ep->bLength;
if (USB_DT_SS_ENDPOINT_COMP == desc_ep->bDescriptorType) {
if (size > desc_ep->bLength) {
desc_ep = (struct usb_endpoint_desc_t *)((uintptr_t)desc_ep + desc_ep->bLength);
} else {
desc_ep = NULL;
}
}
} else {
desc_ep = NULL;
}
return desc_ep;
}
#endif
|
91af267ddc300760f80e821afd35de273681592d
|
58fe7cb3949dd1930e709696659a0296500b64a6
|
/crypto/s2n_cipher.c
|
fdf0e648dc473337837a65a35fc69305df52e3be
|
[
"Apache-2.0",
"MIT"
] |
permissive
|
aws/s2n-tls
|
3344638a6a69c6f20665cf6847e1bc4b85f2e558
|
62dc7a6d4876e5eee0dea3690d528a4c7080a1d5
|
refs/heads/main
| 2023-08-31T23:26:33.780048
| 2023-08-31T05:17:33
| 2023-08-31T05:17:33
| 21,287,076
| 513
| 213
|
Apache-2.0
| 2023-09-13T23:52:29
| 2014-06-27T19:37:59
|
C
|
UTF-8
|
C
| false
| false
| 1,658
|
c
|
s2n_cipher.c
|
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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.
*/
#include <openssl/evp.h>
#if defined(OPENSSL_IS_BORINGSSL) || defined(OPENSSL_IS_AWSLC)
#include <openssl/mem.h>
#endif
#include "crypto/s2n_cipher.h"
#include "utils/s2n_safety.h"
int s2n_session_key_alloc(struct s2n_session_key *key)
{
POSIX_ENSURE_EQ(key->evp_cipher_ctx, NULL);
POSIX_ENSURE_REF(key->evp_cipher_ctx = EVP_CIPHER_CTX_new());
#if defined(S2N_CIPHER_AEAD_API_AVAILABLE)
POSIX_ENSURE_EQ(key->evp_aead_ctx, NULL);
key->evp_aead_ctx = OPENSSL_malloc(sizeof(EVP_AEAD_CTX));
if (key->evp_aead_ctx == NULL) {
EVP_CIPHER_CTX_free(key->evp_cipher_ctx);
S2N_ERROR_PRESERVE_ERRNO();
}
EVP_AEAD_CTX_zero(key->evp_aead_ctx);
#endif
return 0;
}
int s2n_session_key_free(struct s2n_session_key *key)
{
if (key->evp_cipher_ctx != NULL) {
EVP_CIPHER_CTX_free(key->evp_cipher_ctx);
key->evp_cipher_ctx = NULL;
}
#if defined(S2N_CIPHER_AEAD_API_AVAILABLE)
if (key->evp_aead_ctx != NULL) {
EVP_AEAD_CTX_free(key->evp_aead_ctx);
key->evp_aead_ctx = NULL;
}
#endif
return 0;
}
|
b60251f8880ba3b2259e43c52bc899d7c8d1e0a2
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/drivers/media/usb/tm6000/tm6000.h
|
08bd0740dd2368ddaaa23dcaea687f8de57e086c
|
[
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 11,103
|
h
|
tm6000.h
|
/*
* tm6000.h - driver for TM5600/TM6000/TM6010 USB video capture devices
*
* Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
*
* Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
* - DVB-T support
*
* 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 version 2
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <linux/videodev2.h>
#include <media/v4l2-common.h>
#include <media/videobuf-vmalloc.h>
#include "tm6000-usb-isoc.h"
#include <linux/i2c.h>
#include <linux/mutex.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-fh.h>
#include <linux/dvb/frontend.h>
#include "dvb_demux.h"
#include "dvb_frontend.h"
#include "dmxdev.h"
/* Inputs */
enum tm6000_itype {
TM6000_INPUT_TV = 1,
TM6000_INPUT_COMPOSITE1,
TM6000_INPUT_COMPOSITE2,
TM6000_INPUT_SVIDEO,
TM6000_INPUT_DVB,
TM6000_INPUT_RADIO,
};
enum tm6000_mux {
TM6000_VMUX_VIDEO_A = 1,
TM6000_VMUX_VIDEO_B,
TM6000_VMUX_VIDEO_AB,
TM6000_AMUX_ADC1,
TM6000_AMUX_ADC2,
TM6000_AMUX_SIF1,
TM6000_AMUX_SIF2,
TM6000_AMUX_I2S,
};
enum tm6000_devtype {
TM6000 = 0,
TM5600,
TM6010,
};
struct tm6000_input {
enum tm6000_itype type;
enum tm6000_mux vmux;
enum tm6000_mux amux;
unsigned int v_gpio;
unsigned int a_gpio;
};
/* ------------------------------------------------------------------
* Basic structures
* ------------------------------------------------------------------
*/
struct tm6000_fmt {
char *name;
u32 fourcc; /* v4l2 format id */
int depth;
};
/* buffer for one video frame */
struct tm6000_buffer {
/* common v4l buffer stuff -- must be first */
struct videobuf_buffer vb;
struct tm6000_fmt *fmt;
};
struct tm6000_dmaqueue {
struct list_head active;
struct list_head queued;
/* thread for generating video stream*/
struct task_struct *kthread;
wait_queue_head_t wq;
/* Counters to control fps rate */
int frame;
int ini_jiffies;
};
/* device states */
enum tm6000_core_state {
DEV_INITIALIZED = 0x01,
DEV_DISCONNECTED = 0x02,
DEV_MISCONFIGURED = 0x04,
};
/* io methods */
enum tm6000_io_method {
IO_NONE,
IO_READ,
IO_MMAP,
};
enum tm6000_mode {
TM6000_MODE_UNKNOWN = 0,
TM6000_MODE_ANALOG,
TM6000_MODE_DIGITAL,
};
struct tm6000_gpio {
int tuner_reset;
int tuner_on;
int demod_reset;
int demod_on;
int power_led;
int dvb_led;
int ir;
};
struct tm6000_capabilities {
unsigned int has_tuner:1;
unsigned int has_tda9874:1;
unsigned int has_dvb:1;
unsigned int has_zl10353:1;
unsigned int has_eeprom:1;
unsigned int has_remote:1;
unsigned int has_radio:1;
};
struct tm6000_dvb {
struct dvb_adapter adapter;
struct dvb_demux demux;
struct dvb_frontend *frontend;
struct dmxdev dmxdev;
unsigned int streams;
struct urb *bulk_urb;
struct mutex mutex;
};
struct snd_tm6000_card {
struct snd_card *card;
spinlock_t reg_lock;
struct tm6000_core *core;
struct snd_pcm_substream *substream;
/* temporary data for buffer fill processing */
unsigned buf_pos;
unsigned period_pos;
};
struct tm6000_endpoint {
struct usb_host_endpoint *endp;
__u8 bInterfaceNumber;
__u8 bAlternateSetting;
unsigned maxsize;
};
#define TM6000_QUIRK_NO_USB_DELAY (1 << 0)
struct tm6000_core {
/* generic device properties */
char name[30]; /* name (including minor) of the device */
int model; /* index in the device_data struct */
int devno; /* marks the number of this device */
enum tm6000_devtype dev_type; /* type of device */
unsigned char eedata[256]; /* Eeprom data */
unsigned eedata_size; /* Size of the eeprom info */
v4l2_std_id norm; /* Current norm */
int width, height; /* Selected resolution */
enum tm6000_core_state state;
/* Device Capabilities*/
struct tm6000_capabilities caps;
/* Used to load alsa/dvb */
struct work_struct request_module_wk;
/* Tuner configuration */
int tuner_type; /* type of the tuner */
int tuner_addr; /* tuner address */
struct tm6000_gpio gpio;
char *ir_codes;
__u8 radio;
/* Demodulator configuration */
int demod_addr; /* demodulator address */
int audio_bitrate;
/* i2c i/o */
struct i2c_adapter i2c_adap;
struct i2c_client i2c_client;
/* extension */
struct list_head devlist;
/* video for linux */
int users;
/* various device info */
struct tm6000_fh *resources; /* Points to fh that is streaming */
bool is_res_read;
struct video_device *vfd;
struct video_device *radio_dev;
struct tm6000_dmaqueue vidq;
struct v4l2_device v4l2_dev;
struct v4l2_ctrl_handler ctrl_handler;
struct v4l2_ctrl_handler radio_ctrl_handler;
int input;
struct tm6000_input vinput[3]; /* video input */
struct tm6000_input rinput; /* radio input */
int freq;
unsigned int fourcc;
enum tm6000_mode mode;
int ctl_mute; /* audio */
int ctl_volume;
int amode;
/* DVB-T support */
struct tm6000_dvb *dvb;
/* audio support */
struct snd_tm6000_card *adev;
struct work_struct wq_trigger; /* Trigger to start/stop audio for alsa module */
atomic_t stream_started; /* stream should be running if true */
struct tm6000_IR *ir;
/* locks */
struct mutex lock;
struct mutex usb_lock;
/* usb transfer */
struct usb_device *udev; /* the usb device */
struct tm6000_endpoint bulk_in, bulk_out, isoc_in, isoc_out;
struct tm6000_endpoint int_in, int_out;
/* scaler!=0 if scaler is active*/
int scaler;
/* Isoc control struct */
struct usb_isoc_ctl isoc_ctl;
spinlock_t slock;
/* urb dma buffers */
char **urb_buffer;
dma_addr_t *urb_dma;
unsigned int urb_size;
unsigned long quirks;
};
enum tm6000_ops_type {
TM6000_AUDIO = 0x10,
TM6000_DVB = 0x20,
};
struct tm6000_ops {
struct list_head next;
char *name;
enum tm6000_ops_type type;
int (*init)(struct tm6000_core *);
int (*fini)(struct tm6000_core *);
int (*fillbuf)(struct tm6000_core *, char *buf, int size);
};
struct tm6000_fh {
struct v4l2_fh fh;
struct tm6000_core *dev;
unsigned int radio;
/* video capture */
struct tm6000_fmt *fmt;
unsigned int width, height;
struct videobuf_queue vb_vidq;
enum v4l2_buf_type type;
};
#define TM6000_STD (V4L2_STD_PAL|V4L2_STD_PAL_N|V4L2_STD_PAL_Nc| \
V4L2_STD_PAL_M|V4L2_STD_PAL_60|V4L2_STD_NTSC_M| \
V4L2_STD_NTSC_M_JP|V4L2_STD_SECAM)
/* In tm6000-cards.c */
int tm6000_tuner_callback(void *ptr, int component, int command, int arg);
int tm6000_xc5000_callback(void *ptr, int component, int command, int arg);
int tm6000_cards_setup(struct tm6000_core *dev);
void tm6000_flash_led(struct tm6000_core *dev, u8 state);
/* In tm6000-core.c */
int tm6000_read_write_usb(struct tm6000_core *dev, u8 reqtype, u8 req,
u16 value, u16 index, u8 *buf, u16 len);
int tm6000_get_reg(struct tm6000_core *dev, u8 req, u16 value, u16 index);
int tm6000_get_reg16(struct tm6000_core *dev, u8 req, u16 value, u16 index);
int tm6000_get_reg32(struct tm6000_core *dev, u8 req, u16 value, u16 index);
int tm6000_set_reg(struct tm6000_core *dev, u8 req, u16 value, u16 index);
int tm6000_set_reg_mask(struct tm6000_core *dev, u8 req, u16 value,
u16 index, u16 mask);
int tm6000_i2c_reset(struct tm6000_core *dev, u16 tsleep);
int tm6000_init(struct tm6000_core *dev);
int tm6000_reset(struct tm6000_core *dev);
int tm6000_init_analog_mode(struct tm6000_core *dev);
int tm6000_init_digital_mode(struct tm6000_core *dev);
int tm6000_set_audio_bitrate(struct tm6000_core *dev, int bitrate);
int tm6000_set_audio_rinput(struct tm6000_core *dev);
int tm6000_tvaudio_set_mute(struct tm6000_core *dev, u8 mute);
void tm6000_set_volume(struct tm6000_core *dev, int vol);
int tm6000_v4l2_register(struct tm6000_core *dev);
int tm6000_v4l2_unregister(struct tm6000_core *dev);
int tm6000_v4l2_exit(void);
void tm6000_set_fourcc_format(struct tm6000_core *dev);
void tm6000_remove_from_devlist(struct tm6000_core *dev);
void tm6000_add_into_devlist(struct tm6000_core *dev);
int tm6000_register_extension(struct tm6000_ops *ops);
void tm6000_unregister_extension(struct tm6000_ops *ops);
void tm6000_init_extension(struct tm6000_core *dev);
void tm6000_close_extension(struct tm6000_core *dev);
int tm6000_call_fillbuf(struct tm6000_core *dev, enum tm6000_ops_type type,
char *buf, int size);
/* In tm6000-stds.c */
void tm6000_get_std_res(struct tm6000_core *dev);
int tm6000_set_standard(struct tm6000_core *dev);
/* In tm6000-i2c.c */
int tm6000_i2c_register(struct tm6000_core *dev);
int tm6000_i2c_unregister(struct tm6000_core *dev);
/* In tm6000-queue.c */
int tm6000_v4l2_mmap(struct file *filp, struct vm_area_struct *vma);
int tm6000_vidioc_streamon(struct file *file, void *priv,
enum v4l2_buf_type i);
int tm6000_vidioc_streamoff(struct file *file, void *priv,
enum v4l2_buf_type i);
int tm6000_vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *rb);
int tm6000_vidioc_querybuf(struct file *file, void *priv,
struct v4l2_buffer *b);
int tm6000_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b);
int tm6000_vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b);
ssize_t tm6000_v4l2_read(struct file *filp, char __user * buf, size_t count,
loff_t *f_pos);
unsigned int tm6000_v4l2_poll(struct file *file,
struct poll_table_struct *wait);
int tm6000_queue_init(struct tm6000_core *dev);
/* In tm6000-alsa.c */
/*int tm6000_audio_init(struct tm6000_core *dev, int idx);*/
/* In tm6000-input.c */
int tm6000_ir_init(struct tm6000_core *dev);
int tm6000_ir_fini(struct tm6000_core *dev);
void tm6000_ir_wait(struct tm6000_core *dev, u8 state);
int tm6000_ir_int_start(struct tm6000_core *dev);
void tm6000_ir_int_stop(struct tm6000_core *dev);
/* Debug stuff */
extern int tm6000_debug;
#define dprintk(dev, level, fmt, arg...) do {\
if (tm6000_debug & level) \
printk(KERN_INFO "(%lu) %s %s :"fmt, jiffies, \
dev->name, __func__ , ##arg); } while (0)
#define V4L2_DEBUG_REG 0x0004
#define V4L2_DEBUG_I2C 0x0008
#define V4L2_DEBUG_QUEUE 0x0010
#define V4L2_DEBUG_ISOC 0x0020
#define V4L2_DEBUG_RES_LOCK 0x0040 /* Resource locking */
#define V4L2_DEBUG_OPEN 0x0080 /* video open/close debug */
#define tm6000_err(fmt, arg...) do {\
printk(KERN_ERR "tm6000 %s :"fmt, \
__func__ , ##arg); } while (0)
|
5cfbea1d827b2082eac5f5ab1e82ba1bac77aa50
|
4c4deee160ee4a3056b2973f6202e5cbaafb5925
|
/tools/event-benchmark/event_worker.c
|
89b665c624c51b63c6084c9dc53120865b241f88
|
[
"AGPL-3.0-or-later",
"AGPL-3.0-only",
"LGPL-3.0-only"
] |
permissive
|
open-io/oio-sds
|
b9bc7cec283838a59b83b5279cb181cded69034f
|
08abd65aac86e47cf324826487ab9b475e014938
|
refs/heads/master
| 2023-09-05T05:09:29.653325
| 2023-08-01T16:37:37
| 2023-08-31T16:05:19
| 32,169,193
| 663
| 121
|
MIT
| 2022-03-04T13:08:03
| 2015-03-13T17:06:25
|
Python
|
UTF-8
|
C
| false
| false
| 1,904
|
c
|
event_worker.c
|
/*
OpenIO SDS oio-event-benchmark
Copyright (C) 2017-2019 OpenIO SAS, as part of OpenIO SDS
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <glib.h>
#include <metautils/lib/metautils.h>
#include <events/oio_events_queue.h>
#include <core/internals.h>
#include "event_worker.h"
struct oio_events_queue_s *q = NULL;
GError *
event_worker_init(const char *addr)
{
if (!addr) {
q = NULL;
return NULL;
}
GError *err = oio_events_queue_factory__create(addr, "oio", &q);
if (err) {
g_prefix_error(&err, "Event queue creation failed: ");
return err;
}
err = oio_events_queue__start(q);
if (err) {
g_prefix_error(&err, "Thread creation failed: ");
return err;
}
return NULL;
}
void
event_worker_destroy(void)
{
if (q) {
oio_events_queue__destroy(q);
q = NULL;
}
}
GError *
event_worker_send(const char *event_type, struct oio_url_s *url,
GString *data_json)
{
if (q != NULL) {
GString *json = oio_event__create(event_type, url);
if (data_json) {
g_string_append_printf(json, ",\"data\":%.*s}",
(int) data_json->len, data_json->str);
} else {
g_string_append(json, ",\"data\":null}");
}
oio_events_queue__send(q, g_string_free(json, FALSE));
}
if (url) {
oio_url_clean(url);
}
if (data_json) {
g_string_free(data_json, TRUE);
}
return NULL;
}
|
fe91eaa5708f90a9b9f2962d8770ce433cd8771f
|
e1d9c54e9925e30e388a255b53a93cccad0b94cb
|
/kubernetes/model/v1_namespace_condition.h
|
a5d5cdd237b1c7c68446f3b00c95599601bef7c9
|
[
"Apache-2.0",
"curl"
] |
permissive
|
kubernetes-client/c
|
dd4fd8095485c083e0f40f2b48159b1609a6141b
|
5ac5ff25e9809a92a48111b1f77574b6d040b711
|
refs/heads/master
| 2023-08-13T10:51:03.702497
| 2023-08-07T19:18:32
| 2023-08-07T19:18:32
| 247,958,425
| 127
| 47
|
Apache-2.0
| 2023-09-07T20:07:00
| 2020-03-17T11:59:05
|
C
|
UTF-8
|
C
| false
| false
| 1,106
|
h
|
v1_namespace_condition.h
|
/*
* v1_namespace_condition.h
*
* NamespaceCondition contains details about state of namespace.
*/
#ifndef _v1_namespace_condition_H_
#define _v1_namespace_condition_H_
#include <string.h>
#include "../external/cJSON.h"
#include "../include/list.h"
#include "../include/keyValuePair.h"
#include "../include/binary.h"
typedef struct v1_namespace_condition_t v1_namespace_condition_t;
typedef struct v1_namespace_condition_t {
char *last_transition_time; //date time
char *message; // string
char *reason; // string
char *status; // string
char *type; // string
} v1_namespace_condition_t;
v1_namespace_condition_t *v1_namespace_condition_create(
char *last_transition_time,
char *message,
char *reason,
char *status,
char *type
);
void v1_namespace_condition_free(v1_namespace_condition_t *v1_namespace_condition);
v1_namespace_condition_t *v1_namespace_condition_parseFromJSON(cJSON *v1_namespace_conditionJSON);
cJSON *v1_namespace_condition_convertToJSON(v1_namespace_condition_t *v1_namespace_condition);
#endif /* _v1_namespace_condition_H_ */
|
c59a63d988ba55e8f95a12f48a6cb15b61dbc88f
|
2247493654c160426c1655281aa7f1dca2bc98dd
|
/src/ComputeWallModelTurbDissipationWallAlgorithm.C
|
c12bae83da57d01f745169129759817743fccf42
|
[
"BSD-2-Clause"
] |
permissive
|
NaluCFD/Nalu
|
12999b0e3b76dbeab8fc184f38b65a13b1180bce
|
3286651e494894ac5948c41bf985f987d20c2370
|
refs/heads/master
| 2023-08-10T02:48:04.179859
| 2023-08-02T19:02:46
| 2023-08-02T19:02:46
| 69,712,764
| 138
| 185
|
NOASSERTION
| 2023-09-14T16:42:19
| 2016-10-01T01:25:20
|
C
|
UTF-8
|
C
| false
| false
| 6,578
|
c
|
ComputeWallModelTurbDissipationWallAlgorithm.C
|
/*------------------------------------------------------------------------*/
/* Copyright 2014 Sandia Corporation. */
/* This software is released under the license detailed */
/* in the file, LICENSE, which is located in the top-level Nalu */
/* directory structure */
/*------------------------------------------------------------------------*/
// nalu
#include <ComputeWallModelTurbDissipationWallAlgorithm.h>
#include <Algorithm.h>
#include <FieldTypeDef.h>
#include <Realm.h>
#include <master_element/MasterElement.h>
// stk_mesh/base/fem
#include <stk_mesh/base/BulkData.hpp>
#include <stk_mesh/base/Field.hpp>
#include <stk_mesh/base/FieldParallel.hpp>
#include <stk_mesh/base/GetBuckets.hpp>
#include <stk_mesh/base/GetEntities.hpp>
#include <stk_mesh/base/MetaData.hpp>
#include <stk_mesh/base/Part.hpp>
// basic c++
#include <cmath>
namespace sierra{
namespace nalu{
//==========================================================================
// Class Definition
//==========================================================================
// ComputeWallModelTurbDissipationWallAlgorithm - eps at wall bc;
// eps = (cmu^3/4*k^3/2)/kappa/yp,
// k = utau^2/Cmu^1/2
// gather yp and utau
//==========================================================================
//--------------------------------------------------------------------------
//-------- constructor -----------------------------------------------------
//--------------------------------------------------------------------------
ComputeWallModelTurbDissipationWallAlgorithm::ComputeWallModelTurbDissipationWallAlgorithm(
Realm &realm,
stk::mesh::Part *part)
: Algorithm(realm, part),
kappa_(realm.get_turb_model_constant(TM_kappa))
{
// save off fields
stk::mesh::MetaData & meta_data = realm_.meta_data();
exposedAreaVec_ = meta_data.get_field<double>(meta_data.side_rank(), "exposed_area_vector");
wallFrictionVelocityBip_ = meta_data.get_field<double>(meta_data.side_rank(), "wall_friction_velocity_bip");
wallNormalDistanceBip_ = meta_data.get_field<double>(meta_data.side_rank(), "wall_normal_distance_bip");
epsBc_ = meta_data.get_field<double>(stk::topology::NODE_RANK, "wall_model_eps_bc");
assembledWallArea_ = meta_data.get_field<double>(stk::topology::NODE_RANK, "assembled_wall_area_eps");
}
//--------------------------------------------------------------------------
//-------- destructor ------------------------------------------------------
//--------------------------------------------------------------------------
ComputeWallModelTurbDissipationWallAlgorithm::~ComputeWallModelTurbDissipationWallAlgorithm()
{
// does nothing
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
ComputeWallModelTurbDissipationWallAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// define vector of parent topos; should always be UNITY in size
std::vector<stk::topology> parentTopo;
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& face_buckets =
realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin();
ib != face_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
// extract connected element topology
b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo);
STK_ThrowAssert ( parentTopo.size() == 1 );
stk::topology theElemTopo = parentTopo[0];
// extract master element
MasterElement *meSCS = sierra::nalu::MasterElementRepo::get_surface_master_element(theElemTopo);
const stk::mesh::Bucket::size_type length = b.size();
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// get face
stk::mesh::Entity face = b[k];
//======================================
// gather nodal data off of face; n/a
//======================================
int num_face_nodes = bulk_data.num_nodes(face);
// pointer to face data
const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, face);
double *wallFrictionVelocityBip = stk::mesh::field_data(*wallFrictionVelocityBip_, face);
double *wallNormalDistanceBip = stk::mesh::field_data(*wallNormalDistanceBip_, face);
// extract the connected element to this exposed face; should be single in size!
const stk::mesh::Entity* face_elem_rels = bulk_data.begin_elements(face);
STK_ThrowAssert( bulk_data.num_elements(face) == 1 );
// get element; its face ordinal number and populate face_node_ordinals
stk::mesh::Entity element = face_elem_rels[0];
const int face_ordinal = bulk_data.begin_element_ordinals(face)[0];
const int *face_node_ordinals = meSCS->side_node_ordinals(face_ordinal);
// get the relations off of element
stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element);
// loop over face nodes
for ( int ip = 0; ip < num_face_nodes; ++ip ) {
const int ipNdim = ip*nDim;
// nearest node to bip
const int nearestNode = face_node_ordinals[ip];
stk::mesh::Entity nNode = elem_node_rels[nearestNode];
// aMag
double aMag = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = areaVec[ipNdim+j];
aMag += axj*axj;
}
aMag = std::sqrt(aMag);
// extract bip values
const double yp = wallNormalDistanceBip[ip];
const double utau = wallFrictionVelocityBip[ip];
// compute wall function wall eps
const double wallFuncEps = utau*utau*utau/kappa_/yp;
// assemble to nodal quantities; will normalize and assemble in driver
double * assembledWallArea = stk::mesh::field_data(*assembledWallArea_, nNode );
double * epsBc = stk::mesh::field_data(*epsBc_, nNode );
*assembledWallArea += aMag;
*epsBc += wallFuncEps*aMag;
}
}
}
}
} // namespace nalu
} // namespace Sierra
|
4609f20a5b2bd946cc5cd5318927cf8318dc73e0
|
010279e2ba272d09e9d2c4e903722e5faba2cf7a
|
/contrib/libs/lcms2/src/cmslut.c
|
77977fc6c91b141ae7c837c3c858fe9f69646d33
|
[
"LicenseRef-scancode-free-unknown",
"MIT",
"Apache-2.0"
] |
permissive
|
catboost/catboost
|
854c1a1f439a96f1ae6b48e16644be20aa04dba2
|
f5042e35b945aded77b23470ead62d7eacefde92
|
refs/heads/master
| 2023-09-01T12:14:14.174108
| 2023-09-01T10:01:01
| 2023-09-01T10:22:12
| 97,556,265
| 8,012
| 1,425
|
Apache-2.0
| 2023-09-11T03:32:32
| 2017-07-18T05:29:04
|
Python
|
UTF-8
|
C
| false
| false
| 52,442
|
c
|
cmslut.c
|
//---------------------------------------------------------------------------------
//
// Little Color Management System
// Copyright (c) 1998-2023 Marti Maria Saguer
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software
// is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//---------------------------------------------------------------------------------
//
#include "lcms2_internal.h"
// Allocates an empty multi profile element
cmsStage* CMSEXPORT _cmsStageAllocPlaceholder(cmsContext ContextID,
cmsStageSignature Type,
cmsUInt32Number InputChannels,
cmsUInt32Number OutputChannels,
_cmsStageEvalFn EvalPtr,
_cmsStageDupElemFn DupElemPtr,
_cmsStageFreeElemFn FreePtr,
void* Data)
{
cmsStage* ph = (cmsStage*) _cmsMallocZero(ContextID, sizeof(cmsStage));
if (ph == NULL) return NULL;
ph ->ContextID = ContextID;
ph ->Type = Type;
ph ->Implements = Type; // By default, no clue on what is implementing
ph ->InputChannels = InputChannels;
ph ->OutputChannels = OutputChannels;
ph ->EvalPtr = EvalPtr;
ph ->DupElemPtr = DupElemPtr;
ph ->FreePtr = FreePtr;
ph ->Data = Data;
return ph;
}
static
void EvaluateIdentity(const cmsFloat32Number In[],
cmsFloat32Number Out[],
const cmsStage *mpe)
{
memmove(Out, In, mpe ->InputChannels * sizeof(cmsFloat32Number));
}
cmsStage* CMSEXPORT cmsStageAllocIdentity(cmsContext ContextID, cmsUInt32Number nChannels)
{
return _cmsStageAllocPlaceholder(ContextID,
cmsSigIdentityElemType,
nChannels, nChannels,
EvaluateIdentity,
NULL,
NULL,
NULL);
}
// Conversion functions. From floating point to 16 bits
static
void FromFloatTo16(const cmsFloat32Number In[], cmsUInt16Number Out[], cmsUInt32Number n)
{
cmsUInt32Number i;
for (i=0; i < n; i++) {
Out[i] = _cmsQuickSaturateWord(In[i] * 65535.0);
}
}
// From 16 bits to floating point
static
void From16ToFloat(const cmsUInt16Number In[], cmsFloat32Number Out[], cmsUInt32Number n)
{
cmsUInt32Number i;
for (i=0; i < n; i++) {
Out[i] = (cmsFloat32Number) In[i] / 65535.0F;
}
}
// This function is quite useful to analyze the structure of a LUT and retrieve the MPE elements
// that conform the LUT. It should be called with the LUT, the number of expected elements and
// then a list of expected types followed with a list of cmsFloat64Number pointers to MPE elements. If
// the function founds a match with current pipeline, it fills the pointers and returns TRUE
// if not, returns FALSE without touching anything. Setting pointers to NULL does bypass
// the storage process.
cmsBool CMSEXPORT cmsPipelineCheckAndRetreiveStages(const cmsPipeline* Lut, cmsUInt32Number n, ...)
{
va_list args;
cmsUInt32Number i;
cmsStage* mpe;
cmsStageSignature Type;
void** ElemPtr;
// Make sure same number of elements
if (cmsPipelineStageCount(Lut) != n) return FALSE;
va_start(args, n);
// Iterate across asked types
mpe = Lut ->Elements;
for (i=0; i < n; i++) {
// Get asked type. cmsStageSignature is promoted to int by compiler
Type = (cmsStageSignature)va_arg(args, int);
if (mpe ->Type != Type) {
va_end(args); // Mismatch. We are done.
return FALSE;
}
mpe = mpe ->Next;
}
// Found a combination, fill pointers if not NULL
mpe = Lut ->Elements;
for (i=0; i < n; i++) {
ElemPtr = va_arg(args, void**);
if (ElemPtr != NULL)
*ElemPtr = mpe;
mpe = mpe ->Next;
}
va_end(args);
return TRUE;
}
// Below there are implementations for several types of elements. Each type may be implemented by a
// evaluation function, a duplication function, a function to free resources and a constructor.
// *************************************************************************************************
// Type cmsSigCurveSetElemType (curves)
// *************************************************************************************************
cmsToneCurve** _cmsStageGetPtrToCurveSet(const cmsStage* mpe)
{
_cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) mpe ->Data;
return Data ->TheCurves;
}
static
void EvaluateCurves(const cmsFloat32Number In[],
cmsFloat32Number Out[],
const cmsStage *mpe)
{
_cmsStageToneCurvesData* Data;
cmsUInt32Number i;
_cmsAssert(mpe != NULL);
Data = (_cmsStageToneCurvesData*) mpe ->Data;
if (Data == NULL) return;
if (Data ->TheCurves == NULL) return;
for (i=0; i < Data ->nCurves; i++) {
Out[i] = cmsEvalToneCurveFloat(Data ->TheCurves[i], In[i]);
}
}
static
void CurveSetElemTypeFree(cmsStage* mpe)
{
_cmsStageToneCurvesData* Data;
cmsUInt32Number i;
_cmsAssert(mpe != NULL);
Data = (_cmsStageToneCurvesData*) mpe ->Data;
if (Data == NULL) return;
if (Data ->TheCurves != NULL) {
for (i=0; i < Data ->nCurves; i++) {
if (Data ->TheCurves[i] != NULL)
cmsFreeToneCurve(Data ->TheCurves[i]);
}
}
_cmsFree(mpe ->ContextID, Data ->TheCurves);
_cmsFree(mpe ->ContextID, Data);
}
static
void* CurveSetDup(cmsStage* mpe)
{
_cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) mpe ->Data;
_cmsStageToneCurvesData* NewElem;
cmsUInt32Number i;
NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageToneCurvesData));
if (NewElem == NULL) return NULL;
NewElem ->nCurves = Data ->nCurves;
NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(mpe ->ContextID, NewElem ->nCurves, sizeof(cmsToneCurve*));
if (NewElem ->TheCurves == NULL) goto Error;
for (i=0; i < NewElem ->nCurves; i++) {
// Duplicate each curve. It may fail.
NewElem ->TheCurves[i] = cmsDupToneCurve(Data ->TheCurves[i]);
if (NewElem ->TheCurves[i] == NULL) goto Error;
}
return (void*) NewElem;
Error:
if (NewElem ->TheCurves != NULL) {
for (i=0; i < NewElem ->nCurves; i++) {
if (NewElem ->TheCurves[i])
cmsFreeToneCurve(NewElem ->TheCurves[i]);
}
}
_cmsFree(mpe ->ContextID, NewElem ->TheCurves);
_cmsFree(mpe ->ContextID, NewElem);
return NULL;
}
// Curves == NULL forces identity curves
cmsStage* CMSEXPORT cmsStageAllocToneCurves(cmsContext ContextID, cmsUInt32Number nChannels, cmsToneCurve* const Curves[])
{
cmsUInt32Number i;
_cmsStageToneCurvesData* NewElem;
cmsStage* NewMPE;
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCurveSetElemType, nChannels, nChannels,
EvaluateCurves, CurveSetDup, CurveSetElemTypeFree, NULL );
if (NewMPE == NULL) return NULL;
NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(ContextID, sizeof(_cmsStageToneCurvesData));
if (NewElem == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
NewMPE ->Data = (void*) NewElem;
NewElem ->nCurves = nChannels;
NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(ContextID, nChannels, sizeof(cmsToneCurve*));
if (NewElem ->TheCurves == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
for (i=0; i < nChannels; i++) {
if (Curves == NULL) {
NewElem ->TheCurves[i] = cmsBuildGamma(ContextID, 1.0);
}
else {
NewElem ->TheCurves[i] = cmsDupToneCurve(Curves[i]);
}
if (NewElem ->TheCurves[i] == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
}
return NewMPE;
}
// Create a bunch of identity curves
cmsStage* CMSEXPORT _cmsStageAllocIdentityCurves(cmsContext ContextID, cmsUInt32Number nChannels)
{
cmsStage* mpe = cmsStageAllocToneCurves(ContextID, nChannels, NULL);
if (mpe == NULL) return NULL;
mpe ->Implements = cmsSigIdentityElemType;
return mpe;
}
// *************************************************************************************************
// Type cmsSigMatrixElemType (Matrices)
// *************************************************************************************************
// Special care should be taken here because precision loss. A temporary cmsFloat64Number buffer is being used
static
void EvaluateMatrix(const cmsFloat32Number In[],
cmsFloat32Number Out[],
const cmsStage *mpe)
{
cmsUInt32Number i, j;
_cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
cmsFloat64Number Tmp;
// Input is already in 0..1.0 notation
for (i=0; i < mpe ->OutputChannels; i++) {
Tmp = 0;
for (j=0; j < mpe->InputChannels; j++) {
Tmp += In[j] * Data->Double[i*mpe->InputChannels + j];
}
if (Data ->Offset != NULL)
Tmp += Data->Offset[i];
Out[i] = (cmsFloat32Number) Tmp;
}
// Output in 0..1.0 domain
}
// Duplicate a yet-existing matrix element
static
void* MatrixElemDup(cmsStage* mpe)
{
_cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
_cmsStageMatrixData* NewElem;
cmsUInt32Number sz;
NewElem = (_cmsStageMatrixData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageMatrixData));
if (NewElem == NULL) return NULL;
sz = mpe ->InputChannels * mpe ->OutputChannels;
NewElem ->Double = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID, Data ->Double, sz * sizeof(cmsFloat64Number)) ;
if (Data ->Offset)
NewElem ->Offset = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID,
Data ->Offset, mpe -> OutputChannels * sizeof(cmsFloat64Number)) ;
return (void*) NewElem;
}
static
void MatrixElemTypeFree(cmsStage* mpe)
{
_cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
if (Data == NULL)
return;
if (Data ->Double)
_cmsFree(mpe ->ContextID, Data ->Double);
if (Data ->Offset)
_cmsFree(mpe ->ContextID, Data ->Offset);
_cmsFree(mpe ->ContextID, mpe ->Data);
}
cmsStage* CMSEXPORT cmsStageAllocMatrix(cmsContext ContextID, cmsUInt32Number Rows, cmsUInt32Number Cols,
const cmsFloat64Number* Matrix, const cmsFloat64Number* Offset)
{
cmsUInt32Number i, n;
_cmsStageMatrixData* NewElem;
cmsStage* NewMPE;
n = Rows * Cols;
// Check for overflow
if (n == 0) return NULL;
if (n >= UINT_MAX / Cols) return NULL;
if (n >= UINT_MAX / Rows) return NULL;
if (n < Rows || n < Cols) return NULL;
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigMatrixElemType, Cols, Rows,
EvaluateMatrix, MatrixElemDup, MatrixElemTypeFree, NULL );
if (NewMPE == NULL) return NULL;
NewElem = (_cmsStageMatrixData*) _cmsMallocZero(ContextID, sizeof(_cmsStageMatrixData));
if (NewElem == NULL) goto Error;
NewMPE->Data = (void*)NewElem;
NewElem ->Double = (cmsFloat64Number*) _cmsCalloc(ContextID, n, sizeof(cmsFloat64Number));
if (NewElem->Double == NULL) goto Error;
for (i=0; i < n; i++) {
NewElem ->Double[i] = Matrix[i];
}
if (Offset != NULL) {
NewElem ->Offset = (cmsFloat64Number*) _cmsCalloc(ContextID, Rows, sizeof(cmsFloat64Number));
if (NewElem->Offset == NULL) goto Error;
for (i=0; i < Rows; i++) {
NewElem ->Offset[i] = Offset[i];
}
}
return NewMPE;
Error:
cmsStageFree(NewMPE);
return NULL;
}
// *************************************************************************************************
// Type cmsSigCLutElemType
// *************************************************************************************************
// Evaluate in true floating point
static
void EvaluateCLUTfloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
Data -> Params ->Interpolation.LerpFloat(In, Out, Data->Params);
}
// Convert to 16 bits, evaluate, and back to floating point
static
void EvaluateCLUTfloatIn16(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
cmsUInt16Number In16[MAX_STAGE_CHANNELS], Out16[MAX_STAGE_CHANNELS];
_cmsAssert(mpe ->InputChannels <= MAX_STAGE_CHANNELS);
_cmsAssert(mpe ->OutputChannels <= MAX_STAGE_CHANNELS);
FromFloatTo16(In, In16, mpe ->InputChannels);
Data -> Params ->Interpolation.Lerp16(In16, Out16, Data->Params);
From16ToFloat(Out16, Out, mpe ->OutputChannels);
}
// Given an hypercube of b dimensions, with Dims[] number of nodes by dimension, calculate the total amount of nodes
static
cmsUInt32Number CubeSize(const cmsUInt32Number Dims[], cmsUInt32Number b)
{
cmsUInt32Number rv, dim;
_cmsAssert(Dims != NULL);
for (rv = 1; b > 0; b--) {
dim = Dims[b-1];
if (dim <= 1) return 0; // Error
rv *= dim;
// Check for overflow
if (rv > UINT_MAX / dim) return 0;
}
return rv;
}
static
void* CLUTElemDup(cmsStage* mpe)
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
_cmsStageCLutData* NewElem;
NewElem = (_cmsStageCLutData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageCLutData));
if (NewElem == NULL) return NULL;
NewElem ->nEntries = Data ->nEntries;
NewElem ->HasFloatValues = Data ->HasFloatValues;
if (Data ->Tab.T) {
if (Data ->HasFloatValues) {
NewElem ->Tab.TFloat = (cmsFloat32Number*) _cmsDupMem(mpe ->ContextID, Data ->Tab.TFloat, Data ->nEntries * sizeof (cmsFloat32Number));
if (NewElem ->Tab.TFloat == NULL)
goto Error;
} else {
NewElem ->Tab.T = (cmsUInt16Number*) _cmsDupMem(mpe ->ContextID, Data ->Tab.T, Data ->nEntries * sizeof (cmsUInt16Number));
if (NewElem ->Tab.T == NULL)
goto Error;
}
}
NewElem ->Params = _cmsComputeInterpParamsEx(mpe ->ContextID,
Data ->Params ->nSamples,
Data ->Params ->nInputs,
Data ->Params ->nOutputs,
NewElem ->Tab.T,
Data ->Params ->dwFlags);
if (NewElem->Params != NULL)
return (void*) NewElem;
Error:
if (NewElem->Tab.T)
// This works for both types
_cmsFree(mpe ->ContextID, NewElem -> Tab.T);
_cmsFree(mpe ->ContextID, NewElem);
return NULL;
}
static
void CLutElemTypeFree(cmsStage* mpe)
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
// Already empty
if (Data == NULL) return;
// This works for both types
if (Data -> Tab.T)
_cmsFree(mpe ->ContextID, Data -> Tab.T);
_cmsFreeInterpParams(Data ->Params);
_cmsFree(mpe ->ContextID, mpe ->Data);
}
// Allocates a 16-bit multidimensional CLUT. This is evaluated at 16-bit precision. Table may have different
// granularity on each dimension.
cmsStage* CMSEXPORT cmsStageAllocCLut16bitGranular(cmsContext ContextID,
const cmsUInt32Number clutPoints[],
cmsUInt32Number inputChan,
cmsUInt32Number outputChan,
const cmsUInt16Number* Table)
{
cmsUInt32Number i, n;
_cmsStageCLutData* NewElem;
cmsStage* NewMPE;
_cmsAssert(clutPoints != NULL);
if (inputChan > MAX_INPUT_DIMENSIONS) {
cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", inputChan, MAX_INPUT_DIMENSIONS);
return NULL;
}
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCLutElemType, inputChan, outputChan,
EvaluateCLUTfloatIn16, CLUTElemDup, CLutElemTypeFree, NULL );
if (NewMPE == NULL) return NULL;
NewElem = (_cmsStageCLutData*) _cmsMallocZero(ContextID, sizeof(_cmsStageCLutData));
if (NewElem == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
NewMPE ->Data = (void*) NewElem;
NewElem -> nEntries = n = outputChan * CubeSize(clutPoints, inputChan);
NewElem -> HasFloatValues = FALSE;
if (n == 0) {
cmsStageFree(NewMPE);
return NULL;
}
NewElem ->Tab.T = (cmsUInt16Number*) _cmsCalloc(ContextID, n, sizeof(cmsUInt16Number));
if (NewElem ->Tab.T == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
if (Table != NULL) {
for (i=0; i < n; i++) {
NewElem ->Tab.T[i] = Table[i];
}
}
NewElem ->Params = _cmsComputeInterpParamsEx(ContextID, clutPoints, inputChan, outputChan, NewElem ->Tab.T, CMS_LERP_FLAGS_16BITS);
if (NewElem ->Params == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
return NewMPE;
}
cmsStage* CMSEXPORT cmsStageAllocCLut16bit(cmsContext ContextID,
cmsUInt32Number nGridPoints,
cmsUInt32Number inputChan,
cmsUInt32Number outputChan,
const cmsUInt16Number* Table)
{
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
int i;
// Our resulting LUT would be same gridpoints on all dimensions
for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
Dimensions[i] = nGridPoints;
return cmsStageAllocCLut16bitGranular(ContextID, Dimensions, inputChan, outputChan, Table);
}
cmsStage* CMSEXPORT cmsStageAllocCLutFloat(cmsContext ContextID,
cmsUInt32Number nGridPoints,
cmsUInt32Number inputChan,
cmsUInt32Number outputChan,
const cmsFloat32Number* Table)
{
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
int i;
// Our resulting LUT would be same gridpoints on all dimensions
for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
Dimensions[i] = nGridPoints;
return cmsStageAllocCLutFloatGranular(ContextID, Dimensions, inputChan, outputChan, Table);
}
cmsStage* CMSEXPORT cmsStageAllocCLutFloatGranular(cmsContext ContextID, const cmsUInt32Number clutPoints[], cmsUInt32Number inputChan, cmsUInt32Number outputChan, const cmsFloat32Number* Table)
{
cmsUInt32Number i, n;
_cmsStageCLutData* NewElem;
cmsStage* NewMPE;
_cmsAssert(clutPoints != NULL);
if (inputChan > MAX_INPUT_DIMENSIONS) {
cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", inputChan, MAX_INPUT_DIMENSIONS);
return NULL;
}
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCLutElemType, inputChan, outputChan,
EvaluateCLUTfloat, CLUTElemDup, CLutElemTypeFree, NULL);
if (NewMPE == NULL) return NULL;
NewElem = (_cmsStageCLutData*) _cmsMallocZero(ContextID, sizeof(_cmsStageCLutData));
if (NewElem == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
NewMPE ->Data = (void*) NewElem;
// There is a potential integer overflow on conputing n and nEntries.
NewElem -> nEntries = n = outputChan * CubeSize(clutPoints, inputChan);
NewElem -> HasFloatValues = TRUE;
if (n == 0) {
cmsStageFree(NewMPE);
return NULL;
}
NewElem ->Tab.TFloat = (cmsFloat32Number*) _cmsCalloc(ContextID, n, sizeof(cmsFloat32Number));
if (NewElem ->Tab.TFloat == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
if (Table != NULL) {
for (i=0; i < n; i++) {
NewElem ->Tab.TFloat[i] = Table[i];
}
}
NewElem ->Params = _cmsComputeInterpParamsEx(ContextID, clutPoints, inputChan, outputChan, NewElem ->Tab.TFloat, CMS_LERP_FLAGS_FLOAT);
if (NewElem ->Params == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
return NewMPE;
}
static
int IdentitySampler(CMSREGISTER const cmsUInt16Number In[], CMSREGISTER cmsUInt16Number Out[], CMSREGISTER void * Cargo)
{
int nChan = *(int*) Cargo;
int i;
for (i=0; i < nChan; i++)
Out[i] = In[i];
return 1;
}
// Creates an MPE that just copies input to output
cmsStage* CMSEXPORT _cmsStageAllocIdentityCLut(cmsContext ContextID, cmsUInt32Number nChan)
{
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
cmsStage* mpe ;
int i;
for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
Dimensions[i] = 2;
mpe = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, nChan, nChan, NULL);
if (mpe == NULL) return NULL;
if (!cmsStageSampleCLut16bit(mpe, IdentitySampler, &nChan, 0)) {
cmsStageFree(mpe);
return NULL;
}
mpe ->Implements = cmsSigIdentityElemType;
return mpe;
}
// Quantize a value 0 <= i < MaxSamples to 0..0xffff
cmsUInt16Number CMSEXPORT _cmsQuantizeVal(cmsFloat64Number i, cmsUInt32Number MaxSamples)
{
cmsFloat64Number x;
x = ((cmsFloat64Number) i * 65535.) / (cmsFloat64Number) (MaxSamples - 1);
return _cmsQuickSaturateWord(x);
}
// This routine does a sweep on whole input space, and calls its callback
// function on knots. returns TRUE if all ok, FALSE otherwise.
cmsBool CMSEXPORT cmsStageSampleCLut16bit(cmsStage* mpe, cmsSAMPLER16 Sampler, void * Cargo, cmsUInt32Number dwFlags)
{
int i, t, index, rest;
cmsUInt32Number nTotalPoints;
cmsUInt32Number nInputs, nOutputs;
cmsUInt32Number* nSamples;
cmsUInt16Number In[MAX_INPUT_DIMENSIONS+1], Out[MAX_STAGE_CHANNELS];
_cmsStageCLutData* clut;
if (mpe == NULL) return FALSE;
clut = (_cmsStageCLutData*) mpe->Data;
if (clut == NULL) return FALSE;
nSamples = clut->Params ->nSamples;
nInputs = clut->Params ->nInputs;
nOutputs = clut->Params ->nOutputs;
if (nInputs <= 0) return FALSE;
if (nOutputs <= 0) return FALSE;
if (nInputs > MAX_INPUT_DIMENSIONS) return FALSE;
if (nOutputs >= MAX_STAGE_CHANNELS) return FALSE;
memset(In, 0, sizeof(In));
memset(Out, 0, sizeof(Out));
nTotalPoints = CubeSize(nSamples, nInputs);
if (nTotalPoints == 0) return FALSE;
index = 0;
for (i = 0; i < (int) nTotalPoints; i++) {
rest = i;
for (t = (int)nInputs - 1; t >= 0; --t) {
cmsUInt32Number Colorant = rest % nSamples[t];
rest /= nSamples[t];
In[t] = _cmsQuantizeVal(Colorant, nSamples[t]);
}
if (clut ->Tab.T != NULL) {
for (t = 0; t < (int)nOutputs; t++)
Out[t] = clut->Tab.T[index + t];
}
if (!Sampler(In, Out, Cargo))
return FALSE;
if (!(dwFlags & SAMPLER_INSPECT)) {
if (clut ->Tab.T != NULL) {
for (t=0; t < (int) nOutputs; t++)
clut->Tab.T[index + t] = Out[t];
}
}
index += nOutputs;
}
return TRUE;
}
// Same as anterior, but for floating point
cmsBool CMSEXPORT cmsStageSampleCLutFloat(cmsStage* mpe, cmsSAMPLERFLOAT Sampler, void * Cargo, cmsUInt32Number dwFlags)
{
int i, t, index, rest;
cmsUInt32Number nTotalPoints;
cmsUInt32Number nInputs, nOutputs;
cmsUInt32Number* nSamples;
cmsFloat32Number In[MAX_INPUT_DIMENSIONS+1], Out[MAX_STAGE_CHANNELS];
_cmsStageCLutData* clut = (_cmsStageCLutData*) mpe->Data;
nSamples = clut->Params ->nSamples;
nInputs = clut->Params ->nInputs;
nOutputs = clut->Params ->nOutputs;
if (nInputs <= 0) return FALSE;
if (nOutputs <= 0) return FALSE;
if (nInputs > MAX_INPUT_DIMENSIONS) return FALSE;
if (nOutputs >= MAX_STAGE_CHANNELS) return FALSE;
nTotalPoints = CubeSize(nSamples, nInputs);
if (nTotalPoints == 0) return FALSE;
index = 0;
for (i = 0; i < (int)nTotalPoints; i++) {
rest = i;
for (t = (int) nInputs-1; t >=0; --t) {
cmsUInt32Number Colorant = rest % nSamples[t];
rest /= nSamples[t];
In[t] = (cmsFloat32Number) (_cmsQuantizeVal(Colorant, nSamples[t]) / 65535.0);
}
if (clut ->Tab.TFloat != NULL) {
for (t=0; t < (int) nOutputs; t++)
Out[t] = clut->Tab.TFloat[index + t];
}
if (!Sampler(In, Out, Cargo))
return FALSE;
if (!(dwFlags & SAMPLER_INSPECT)) {
if (clut ->Tab.TFloat != NULL) {
for (t=0; t < (int) nOutputs; t++)
clut->Tab.TFloat[index + t] = Out[t];
}
}
index += nOutputs;
}
return TRUE;
}
// This routine does a sweep on whole input space, and calls its callback
// function on knots. returns TRUE if all ok, FALSE otherwise.
cmsBool CMSEXPORT cmsSliceSpace16(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[],
cmsSAMPLER16 Sampler, void * Cargo)
{
int i, t, rest;
cmsUInt32Number nTotalPoints;
cmsUInt16Number In[cmsMAXCHANNELS];
if (nInputs >= cmsMAXCHANNELS) return FALSE;
nTotalPoints = CubeSize(clutPoints, nInputs);
if (nTotalPoints == 0) return FALSE;
for (i = 0; i < (int) nTotalPoints; i++) {
rest = i;
for (t = (int) nInputs-1; t >=0; --t) {
cmsUInt32Number Colorant = rest % clutPoints[t];
rest /= clutPoints[t];
In[t] = _cmsQuantizeVal(Colorant, clutPoints[t]);
}
if (!Sampler(In, NULL, Cargo))
return FALSE;
}
return TRUE;
}
cmsInt32Number CMSEXPORT cmsSliceSpaceFloat(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[],
cmsSAMPLERFLOAT Sampler, void * Cargo)
{
int i, t, rest;
cmsUInt32Number nTotalPoints;
cmsFloat32Number In[cmsMAXCHANNELS];
if (nInputs >= cmsMAXCHANNELS) return FALSE;
nTotalPoints = CubeSize(clutPoints, nInputs);
if (nTotalPoints == 0) return FALSE;
for (i = 0; i < (int) nTotalPoints; i++) {
rest = i;
for (t = (int) nInputs-1; t >=0; --t) {
cmsUInt32Number Colorant = rest % clutPoints[t];
rest /= clutPoints[t];
In[t] = (cmsFloat32Number) (_cmsQuantizeVal(Colorant, clutPoints[t]) / 65535.0);
}
if (!Sampler(In, NULL, Cargo))
return FALSE;
}
return TRUE;
}
// ********************************************************************************
// Type cmsSigLab2XYZElemType
// ********************************************************************************
static
void EvaluateLab2XYZ(const cmsFloat32Number In[],
cmsFloat32Number Out[],
const cmsStage *mpe)
{
cmsCIELab Lab;
cmsCIEXYZ XYZ;
const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
// V4 rules
Lab.L = In[0] * 100.0;
Lab.a = In[1] * 255.0 - 128.0;
Lab.b = In[2] * 255.0 - 128.0;
cmsLab2XYZ(NULL, &XYZ, &Lab);
// From XYZ, range 0..19997 to 0..1.0, note that 1.99997 comes from 0xffff
// encoded as 1.15 fixed point, so 1 + (32767.0 / 32768.0)
Out[0] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.X / XYZadj);
Out[1] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Y / XYZadj);
Out[2] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Z / XYZadj);
return;
cmsUNUSED_PARAMETER(mpe);
}
// No dup or free routines needed, as the structure has no pointers in it.
cmsStage* CMSEXPORT _cmsStageAllocLab2XYZ(cmsContext ContextID)
{
return _cmsStageAllocPlaceholder(ContextID, cmsSigLab2XYZElemType, 3, 3, EvaluateLab2XYZ, NULL, NULL, NULL);
}
// ********************************************************************************
// v2 L=100 is supposed to be placed on 0xFF00. There is no reasonable
// number of gridpoints that would make exact match. However, a prelinearization
// of 258 entries, would map 0xFF00 exactly on entry 257, and this is good to avoid scum dot.
// Almost all what we need but unfortunately, the rest of entries should be scaled by
// (255*257/256) and this is not exact.
cmsStage* _cmsStageAllocLabV2ToV4curves(cmsContext ContextID)
{
cmsStage* mpe;
cmsToneCurve* LabTable[3];
int i, j;
LabTable[0] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
LabTable[1] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
LabTable[2] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
for (j=0; j < 3; j++) {
if (LabTable[j] == NULL) {
cmsFreeToneCurveTriple(LabTable);
return NULL;
}
// We need to map * (0xffff / 0xff00), that's same as (257 / 256)
// So we can use 258-entry tables to do the trick (i / 257) * (255 * 257) * (257 / 256);
for (i=0; i < 257; i++) {
LabTable[j]->Table16[i] = (cmsUInt16Number) ((i * 0xffff + 0x80) >> 8);
}
LabTable[j] ->Table16[257] = 0xffff;
}
mpe = cmsStageAllocToneCurves(ContextID, 3, LabTable);
cmsFreeToneCurveTriple(LabTable);
if (mpe == NULL) return NULL;
mpe ->Implements = cmsSigLabV2toV4;
return mpe;
}
// ********************************************************************************
// Matrix-based conversion, which is more accurate, but slower and cannot properly be saved in devicelink profiles
cmsStage* CMSEXPORT _cmsStageAllocLabV2ToV4(cmsContext ContextID)
{
static const cmsFloat64Number V2ToV4[] = { 65535.0/65280.0, 0, 0,
0, 65535.0/65280.0, 0,
0, 0, 65535.0/65280.0
};
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, V2ToV4, NULL);
if (mpe == NULL) return mpe;
mpe ->Implements = cmsSigLabV2toV4;
return mpe;
}
// Reverse direction
cmsStage* CMSEXPORT _cmsStageAllocLabV4ToV2(cmsContext ContextID)
{
static const cmsFloat64Number V4ToV2[] = { 65280.0/65535.0, 0, 0,
0, 65280.0/65535.0, 0,
0, 0, 65280.0/65535.0
};
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, V4ToV2, NULL);
if (mpe == NULL) return mpe;
mpe ->Implements = cmsSigLabV4toV2;
return mpe;
}
// To Lab to float. Note that the MPE gives numbers in normal Lab range
// and we need 0..1.0 range for the formatters
// L* : 0...100 => 0...1.0 (L* / 100)
// ab* : -128..+127 to 0..1 ((ab* + 128) / 255)
cmsStage* _cmsStageNormalizeFromLabFloat(cmsContext ContextID)
{
static const cmsFloat64Number a1[] = {
1.0/100.0, 0, 0,
0, 1.0/255.0, 0,
0, 0, 1.0/255.0
};
static const cmsFloat64Number o1[] = {
0,
128.0/255.0,
128.0/255.0
};
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, o1);
if (mpe == NULL) return mpe;
mpe ->Implements = cmsSigLab2FloatPCS;
return mpe;
}
// Fom XYZ to floating point PCS
cmsStage* _cmsStageNormalizeFromXyzFloat(cmsContext ContextID)
{
#define n (32768.0/65535.0)
static const cmsFloat64Number a1[] = {
n, 0, 0,
0, n, 0,
0, 0, n
};
#undef n
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, NULL);
if (mpe == NULL) return mpe;
mpe ->Implements = cmsSigXYZ2FloatPCS;
return mpe;
}
cmsStage* _cmsStageNormalizeToLabFloat(cmsContext ContextID)
{
static const cmsFloat64Number a1[] = {
100.0, 0, 0,
0, 255.0, 0,
0, 0, 255.0
};
static const cmsFloat64Number o1[] = {
0,
-128.0,
-128.0
};
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, o1);
if (mpe == NULL) return mpe;
mpe ->Implements = cmsSigFloatPCS2Lab;
return mpe;
}
cmsStage* _cmsStageNormalizeToXyzFloat(cmsContext ContextID)
{
#define n (65535.0/32768.0)
static const cmsFloat64Number a1[] = {
n, 0, 0,
0, n, 0,
0, 0, n
};
#undef n
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, NULL);
if (mpe == NULL) return mpe;
mpe ->Implements = cmsSigFloatPCS2XYZ;
return mpe;
}
// Clips values smaller than zero
static
void Clipper(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{
cmsUInt32Number i;
for (i = 0; i < mpe->InputChannels; i++) {
cmsFloat32Number n = In[i];
Out[i] = n < 0 ? 0 : n;
}
}
cmsStage* _cmsStageClipNegatives(cmsContext ContextID, cmsUInt32Number nChannels)
{
return _cmsStageAllocPlaceholder(ContextID, cmsSigClipNegativesElemType,
nChannels, nChannels, Clipper, NULL, NULL, NULL);
}
// ********************************************************************************
// Type cmsSigXYZ2LabElemType
// ********************************************************************************
static
void EvaluateXYZ2Lab(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{
cmsCIELab Lab;
cmsCIEXYZ XYZ;
const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
// From 0..1.0 to XYZ
XYZ.X = In[0] * XYZadj;
XYZ.Y = In[1] * XYZadj;
XYZ.Z = In[2] * XYZadj;
cmsXYZ2Lab(NULL, &Lab, &XYZ);
// From V4 Lab to 0..1.0
Out[0] = (cmsFloat32Number) (Lab.L / 100.0);
Out[1] = (cmsFloat32Number) ((Lab.a + 128.0) / 255.0);
Out[2] = (cmsFloat32Number) ((Lab.b + 128.0) / 255.0);
return;
cmsUNUSED_PARAMETER(mpe);
}
cmsStage* CMSEXPORT _cmsStageAllocXYZ2Lab(cmsContext ContextID)
{
return _cmsStageAllocPlaceholder(ContextID, cmsSigXYZ2LabElemType, 3, 3, EvaluateXYZ2Lab, NULL, NULL, NULL);
}
// ********************************************************************************
// For v4, S-Shaped curves are placed in a/b axis to increase resolution near gray
cmsStage* _cmsStageAllocLabPrelin(cmsContext ContextID)
{
cmsToneCurve* LabTable[3];
cmsFloat64Number Params[1] = {2.4} ;
LabTable[0] = cmsBuildGamma(ContextID, 1.0);
LabTable[1] = cmsBuildParametricToneCurve(ContextID, 108, Params);
LabTable[2] = cmsBuildParametricToneCurve(ContextID, 108, Params);
return cmsStageAllocToneCurves(ContextID, 3, LabTable);
}
// Free a single MPE
void CMSEXPORT cmsStageFree(cmsStage* mpe)
{
if (mpe ->FreePtr)
mpe ->FreePtr(mpe);
_cmsFree(mpe ->ContextID, mpe);
}
cmsUInt32Number CMSEXPORT cmsStageInputChannels(const cmsStage* mpe)
{
return mpe ->InputChannels;
}
cmsUInt32Number CMSEXPORT cmsStageOutputChannels(const cmsStage* mpe)
{
return mpe ->OutputChannels;
}
cmsStageSignature CMSEXPORT cmsStageType(const cmsStage* mpe)
{
return mpe -> Type;
}
void* CMSEXPORT cmsStageData(const cmsStage* mpe)
{
return mpe -> Data;
}
cmsContext CMSEXPORT cmsGetStageContextID(const cmsStage* mpe)
{
return mpe -> ContextID;
}
cmsStage* CMSEXPORT cmsStageNext(const cmsStage* mpe)
{
return mpe -> Next;
}
// Duplicates an MPE
cmsStage* CMSEXPORT cmsStageDup(cmsStage* mpe)
{
cmsStage* NewMPE;
if (mpe == NULL) return NULL;
NewMPE = _cmsStageAllocPlaceholder(mpe ->ContextID,
mpe ->Type,
mpe ->InputChannels,
mpe ->OutputChannels,
mpe ->EvalPtr,
mpe ->DupElemPtr,
mpe ->FreePtr,
NULL);
if (NewMPE == NULL) return NULL;
NewMPE ->Implements = mpe ->Implements;
if (mpe ->DupElemPtr) {
NewMPE ->Data = mpe ->DupElemPtr(mpe);
if (NewMPE->Data == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
} else {
NewMPE ->Data = NULL;
}
return NewMPE;
}
// ***********************************************************************************************************
// This function sets up the channel count
static
cmsBool BlessLUT(cmsPipeline* lut)
{
// We can set the input/output channels only if we have elements.
if (lut ->Elements != NULL) {
cmsStage* prev;
cmsStage* next;
cmsStage* First;
cmsStage* Last;
First = cmsPipelineGetPtrToFirstStage(lut);
Last = cmsPipelineGetPtrToLastStage(lut);
if (First == NULL || Last == NULL) return FALSE;
lut->InputChannels = First->InputChannels;
lut->OutputChannels = Last->OutputChannels;
// Check chain consistency
prev = First;
next = prev->Next;
while (next != NULL)
{
if (next->InputChannels != prev->OutputChannels)
return FALSE;
next = next->Next;
prev = prev->Next;
}
}
return TRUE;
}
// Default to evaluate the LUT on 16 bit-basis. Precision is retained.
static
void _LUTeval16(CMSREGISTER const cmsUInt16Number In[], CMSREGISTER cmsUInt16Number Out[], CMSREGISTER const void* D)
{
cmsPipeline* lut = (cmsPipeline*) D;
cmsStage *mpe;
cmsFloat32Number Storage[2][MAX_STAGE_CHANNELS];
int Phase = 0, NextPhase;
From16ToFloat(In, &Storage[Phase][0], lut ->InputChannels);
for (mpe = lut ->Elements;
mpe != NULL;
mpe = mpe ->Next) {
NextPhase = Phase ^ 1;
mpe ->EvalPtr(&Storage[Phase][0], &Storage[NextPhase][0], mpe);
Phase = NextPhase;
}
FromFloatTo16(&Storage[Phase][0], Out, lut ->OutputChannels);
}
// Does evaluate the LUT on cmsFloat32Number-basis.
static
void _LUTevalFloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const void* D)
{
cmsPipeline* lut = (cmsPipeline*) D;
cmsStage *mpe;
cmsFloat32Number Storage[2][MAX_STAGE_CHANNELS];
int Phase = 0, NextPhase;
memmove(&Storage[Phase][0], In, lut ->InputChannels * sizeof(cmsFloat32Number));
for (mpe = lut ->Elements;
mpe != NULL;
mpe = mpe ->Next) {
NextPhase = Phase ^ 1;
mpe ->EvalPtr(&Storage[Phase][0], &Storage[NextPhase][0], mpe);
Phase = NextPhase;
}
memmove(Out, &Storage[Phase][0], lut ->OutputChannels * sizeof(cmsFloat32Number));
}
// LUT Creation & Destruction
cmsPipeline* CMSEXPORT cmsPipelineAlloc(cmsContext ContextID, cmsUInt32Number InputChannels, cmsUInt32Number OutputChannels)
{
cmsPipeline* NewLUT;
// A value of zero in channels is allowed as placeholder
if (InputChannels >= cmsMAXCHANNELS ||
OutputChannels >= cmsMAXCHANNELS) return NULL;
NewLUT = (cmsPipeline*) _cmsMallocZero(ContextID, sizeof(cmsPipeline));
if (NewLUT == NULL) return NULL;
NewLUT -> InputChannels = InputChannels;
NewLUT -> OutputChannels = OutputChannels;
NewLUT ->Eval16Fn = _LUTeval16;
NewLUT ->EvalFloatFn = _LUTevalFloat;
NewLUT ->DupDataFn = NULL;
NewLUT ->FreeDataFn = NULL;
NewLUT ->Data = NewLUT;
NewLUT ->ContextID = ContextID;
if (!BlessLUT(NewLUT))
{
_cmsFree(ContextID, NewLUT);
return NULL;
}
return NewLUT;
}
cmsContext CMSEXPORT cmsGetPipelineContextID(const cmsPipeline* lut)
{
_cmsAssert(lut != NULL);
return lut ->ContextID;
}
cmsUInt32Number CMSEXPORT cmsPipelineInputChannels(const cmsPipeline* lut)
{
_cmsAssert(lut != NULL);
return lut ->InputChannels;
}
cmsUInt32Number CMSEXPORT cmsPipelineOutputChannels(const cmsPipeline* lut)
{
_cmsAssert(lut != NULL);
return lut ->OutputChannels;
}
// Free a profile elements LUT
void CMSEXPORT cmsPipelineFree(cmsPipeline* lut)
{
cmsStage *mpe, *Next;
if (lut == NULL) return;
for (mpe = lut ->Elements;
mpe != NULL;
mpe = Next) {
Next = mpe ->Next;
cmsStageFree(mpe);
}
if (lut ->FreeDataFn) lut ->FreeDataFn(lut ->ContextID, lut ->Data);
_cmsFree(lut ->ContextID, lut);
}
// Default to evaluate the LUT on 16 bit-basis.
void CMSEXPORT cmsPipelineEval16(const cmsUInt16Number In[], cmsUInt16Number Out[], const cmsPipeline* lut)
{
_cmsAssert(lut != NULL);
lut ->Eval16Fn(In, Out, lut->Data);
}
// Does evaluate the LUT on cmsFloat32Number-basis.
void CMSEXPORT cmsPipelineEvalFloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsPipeline* lut)
{
_cmsAssert(lut != NULL);
lut ->EvalFloatFn(In, Out, lut);
}
// Duplicates a LUT
cmsPipeline* CMSEXPORT cmsPipelineDup(const cmsPipeline* lut)
{
cmsPipeline* NewLUT;
cmsStage *NewMPE, *Anterior = NULL, *mpe;
cmsBool First = TRUE;
if (lut == NULL) return NULL;
NewLUT = cmsPipelineAlloc(lut ->ContextID, lut ->InputChannels, lut ->OutputChannels);
if (NewLUT == NULL) return NULL;
for (mpe = lut ->Elements;
mpe != NULL;
mpe = mpe ->Next) {
NewMPE = cmsStageDup(mpe);
if (NewMPE == NULL) {
cmsPipelineFree(NewLUT);
return NULL;
}
if (First) {
NewLUT ->Elements = NewMPE;
First = FALSE;
}
else {
if (Anterior != NULL)
Anterior ->Next = NewMPE;
}
Anterior = NewMPE;
}
NewLUT ->Eval16Fn = lut ->Eval16Fn;
NewLUT ->EvalFloatFn = lut ->EvalFloatFn;
NewLUT ->DupDataFn = lut ->DupDataFn;
NewLUT ->FreeDataFn = lut ->FreeDataFn;
if (NewLUT ->DupDataFn != NULL)
NewLUT ->Data = NewLUT ->DupDataFn(lut ->ContextID, lut->Data);
NewLUT ->SaveAs8Bits = lut ->SaveAs8Bits;
if (!BlessLUT(NewLUT))
{
_cmsFree(lut->ContextID, NewLUT);
return NULL;
}
return NewLUT;
}
int CMSEXPORT cmsPipelineInsertStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage* mpe)
{
cmsStage* Anterior = NULL, *pt;
if (lut == NULL || mpe == NULL)
return FALSE;
switch (loc) {
case cmsAT_BEGIN:
mpe ->Next = lut ->Elements;
lut ->Elements = mpe;
break;
case cmsAT_END:
if (lut ->Elements == NULL)
lut ->Elements = mpe;
else {
for (pt = lut ->Elements;
pt != NULL;
pt = pt -> Next) Anterior = pt;
Anterior ->Next = mpe;
mpe ->Next = NULL;
}
break;
default:;
return FALSE;
}
return BlessLUT(lut);
}
// Unlink an element and return the pointer to it
void CMSEXPORT cmsPipelineUnlinkStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage** mpe)
{
cmsStage *Anterior, *pt, *Last;
cmsStage *Unlinked = NULL;
// If empty LUT, there is nothing to remove
if (lut ->Elements == NULL) {
if (mpe) *mpe = NULL;
return;
}
// On depending on the strategy...
switch (loc) {
case cmsAT_BEGIN:
{
cmsStage* elem = lut ->Elements;
lut ->Elements = elem -> Next;
elem ->Next = NULL;
Unlinked = elem;
}
break;
case cmsAT_END:
Anterior = Last = NULL;
for (pt = lut ->Elements;
pt != NULL;
pt = pt -> Next) {
Anterior = Last;
Last = pt;
}
Unlinked = Last; // Next already points to NULL
// Truncate the chain
if (Anterior)
Anterior ->Next = NULL;
else
lut ->Elements = NULL;
break;
default:;
}
if (mpe)
*mpe = Unlinked;
else
cmsStageFree(Unlinked);
// May fail, but we ignore it
BlessLUT(lut);
}
// Concatenate two LUT into a new single one
cmsBool CMSEXPORT cmsPipelineCat(cmsPipeline* l1, const cmsPipeline* l2)
{
cmsStage* mpe;
// If both LUTS does not have elements, we need to inherit
// the number of channels
if (l1 ->Elements == NULL && l2 ->Elements == NULL) {
l1 ->InputChannels = l2 ->InputChannels;
l1 ->OutputChannels = l2 ->OutputChannels;
}
// Cat second
for (mpe = l2 ->Elements;
mpe != NULL;
mpe = mpe ->Next) {
// We have to dup each element
if (!cmsPipelineInsertStage(l1, cmsAT_END, cmsStageDup(mpe)))
return FALSE;
}
return BlessLUT(l1);
}
cmsBool CMSEXPORT cmsPipelineSetSaveAs8bitsFlag(cmsPipeline* lut, cmsBool On)
{
cmsBool Anterior = lut ->SaveAs8Bits;
lut ->SaveAs8Bits = On;
return Anterior;
}
cmsStage* CMSEXPORT cmsPipelineGetPtrToFirstStage(const cmsPipeline* lut)
{
return lut ->Elements;
}
cmsStage* CMSEXPORT cmsPipelineGetPtrToLastStage(const cmsPipeline* lut)
{
cmsStage *mpe, *Anterior = NULL;
for (mpe = lut ->Elements; mpe != NULL; mpe = mpe ->Next)
Anterior = mpe;
return Anterior;
}
cmsUInt32Number CMSEXPORT cmsPipelineStageCount(const cmsPipeline* lut)
{
cmsStage *mpe;
cmsUInt32Number n;
for (n=0, mpe = lut ->Elements; mpe != NULL; mpe = mpe ->Next)
n++;
return n;
}
// This function may be used to set the optional evaluator and a block of private data. If private data is being used, an optional
// duplicator and free functions should also be specified in order to duplicate the LUT construct. Use NULL to inhibit such functionality.
void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut,
_cmsPipelineEval16Fn Eval16,
void* PrivateData,
_cmsFreeUserDataFn FreePrivateDataFn,
_cmsDupUserDataFn DupPrivateDataFn)
{
Lut ->Eval16Fn = Eval16;
Lut ->DupDataFn = DupPrivateDataFn;
Lut ->FreeDataFn = FreePrivateDataFn;
Lut ->Data = PrivateData;
}
// ----------------------------------------------------------- Reverse interpolation
// Here's how it goes. The derivative Df(x) of the function f is the linear
// transformation that best approximates f near the point x. It can be represented
// by a matrix A whose entries are the partial derivatives of the components of f
// with respect to all the coordinates. This is know as the Jacobian
//
// The best linear approximation to f is given by the matrix equation:
//
// y-y0 = A (x-x0)
//
// So, if x0 is a good "guess" for the zero of f, then solving for the zero of this
// linear approximation will give a "better guess" for the zero of f. Thus let y=0,
// and since y0=f(x0) one can solve the above equation for x. This leads to the
// Newton's method formula:
//
// xn+1 = xn - A-1 f(xn)
//
// where xn+1 denotes the (n+1)-st guess, obtained from the n-th guess xn in the
// fashion described above. Iterating this will give better and better approximations
// if you have a "good enough" initial guess.
#define JACOBIAN_EPSILON 0.001f
#define INVERSION_MAX_ITERATIONS 30
// Increment with reflexion on boundary
static
void IncDelta(cmsFloat32Number *Val)
{
if (*Val < (1.0 - JACOBIAN_EPSILON))
*Val += JACOBIAN_EPSILON;
else
*Val -= JACOBIAN_EPSILON;
}
// Euclidean distance between two vectors of n elements each one
static
cmsFloat32Number EuclideanDistance(cmsFloat32Number a[], cmsFloat32Number b[], int n)
{
cmsFloat32Number sum = 0;
int i;
for (i=0; i < n; i++) {
cmsFloat32Number dif = b[i] - a[i];
sum += dif * dif;
}
return sqrtf(sum);
}
// Evaluate a LUT in reverse direction. It only searches on 3->3 LUT. Uses Newton method
//
// x1 <- x - [J(x)]^-1 * f(x)
//
// lut: The LUT on where to do the search
// Target: LabK, 3 values of Lab plus destination K which is fixed
// Result: The obtained CMYK
// Hint: Location where begin the search
cmsBool CMSEXPORT cmsPipelineEvalReverseFloat(cmsFloat32Number Target[],
cmsFloat32Number Result[],
cmsFloat32Number Hint[],
const cmsPipeline* lut)
{
cmsUInt32Number i, j;
cmsFloat64Number error, LastError = 1E20;
cmsFloat32Number fx[4], x[4], xd[4], fxd[4];
cmsVEC3 tmp, tmp2;
cmsMAT3 Jacobian;
// Only 3->3 and 4->3 are supported
if (lut ->InputChannels != 3 && lut ->InputChannels != 4) return FALSE;
if (lut ->OutputChannels != 3) return FALSE;
// Take the hint as starting point if specified
if (Hint == NULL) {
// Begin at any point, we choose 1/3 of CMY axis
x[0] = x[1] = x[2] = 0.3f;
}
else {
// Only copy 3 channels from hint...
for (j=0; j < 3; j++)
x[j] = Hint[j];
}
// If Lut is 4-dimensions, then grab target[3], which is fixed
if (lut ->InputChannels == 4) {
x[3] = Target[3];
}
else x[3] = 0; // To keep lint happy
// Iterate
for (i = 0; i < INVERSION_MAX_ITERATIONS; i++) {
// Get beginning fx
cmsPipelineEvalFloat(x, fx, lut);
// Compute error
error = EuclideanDistance(fx, Target, 3);
// If not convergent, return last safe value
if (error >= LastError)
break;
// Keep latest values
LastError = error;
for (j=0; j < lut ->InputChannels; j++)
Result[j] = x[j];
// Found an exact match?
if (error <= 0)
break;
// Obtain slope (the Jacobian)
for (j = 0; j < 3; j++) {
xd[0] = x[0];
xd[1] = x[1];
xd[2] = x[2];
xd[3] = x[3]; // Keep fixed channel
IncDelta(&xd[j]);
cmsPipelineEvalFloat(xd, fxd, lut);
Jacobian.v[0].n[j] = ((fxd[0] - fx[0]) / JACOBIAN_EPSILON);
Jacobian.v[1].n[j] = ((fxd[1] - fx[1]) / JACOBIAN_EPSILON);
Jacobian.v[2].n[j] = ((fxd[2] - fx[2]) / JACOBIAN_EPSILON);
}
// Solve system
tmp2.n[0] = fx[0] - Target[0];
tmp2.n[1] = fx[1] - Target[1];
tmp2.n[2] = fx[2] - Target[2];
if (!_cmsMAT3solve(&tmp, &Jacobian, &tmp2))
return FALSE;
// Move our guess
x[0] -= (cmsFloat32Number) tmp.n[0];
x[1] -= (cmsFloat32Number) tmp.n[1];
x[2] -= (cmsFloat32Number) tmp.n[2];
// Some clipping....
for (j=0; j < 3; j++) {
if (x[j] < 0) x[j] = 0;
else
if (x[j] > 1.0) x[j] = 1.0;
}
}
return TRUE;
}
|
38a646cab91b5217bd5c511b4f02bf4233074eef
|
0dd85c72c457ac317ecdde7dc40518f7be1a2602
|
/vendor/platform/Fibocom-MA510/src/rpc/http_client.h
|
719892b6a14ec66b33d54beadc5916858830d9dc
|
[
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
aitos-io/BoAT-X-Framework
|
00072acd6e570b8dda5c3e211103717110303915
|
92c09bd1ed269903b542b7b39a02137bb0b4f9be
|
refs/heads/master
| 2023-07-08T11:20:52.441231
| 2023-03-08T01:43:57
| 2023-03-08T01:43:57
| 249,309,472
| 2,165
| 141
|
Apache-2.0
| 2023-06-27T03:22:02
| 2020-03-23T01:39:16
|
C
|
UTF-8
|
C
| false
| false
| 3,695
|
h
|
http_client.h
|
/* Copyright (C) 2012 mbed.org, MIT License
*
* 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 __HTTPCLIENT_H__
#define __HTTPCLIENT_H__
#include <stdint.h>
#include <stdbool.h>
#include <sys/time.h>
#include "qapi_types.h"
#include "com_dtypes.h"
#define lower(c) (('A' <= c && c <= 'Z') ? c + ('a' - 'A') : c)
#define LEFT_SHIFT_OP(N) (1 << (N))
typedef enum
{
HTTP_SESSION_IDLE,
HTTP_SESSION_INIT,
HTTP_SESSION_CONN,
HTTP_SESSION_DOWNLOADING,
HTTP_SESSION_DL_FAIL,
HTTP_SESSION_DL_FIN,
HTTP_SESSION_DISCONN
} http_session_status_e;
typedef struct
{
http_session_status_e session_state;
uint8 data_retry;
int32 reason_code;
uint32 start_pos;
uint32 last_pos;
uint32 range_size;
} http_session_policy_t;
typedef enum DSS_SIG_EVENTS
{
DSS_SIG_EVT_INV_E = LEFT_SHIFT_OP(0),
DSS_SIG_EVT_NO_CONN_E = LEFT_SHIFT_OP(1),
DSS_SIG_EVT_CONN_E = LEFT_SHIFT_OP(2),
DSS_SIG_EVT_DIS_E = LEFT_SHIFT_OP(3),
DSS_SIG_EVT_EXIT_E = LEFT_SHIFT_OP(4),
DSS_SIG_EVT_MAX_E = LEFT_SHIFT_OP(5)
} DSS_Signal_Evt_e;
typedef enum DSS_Lib_Status
{
DSS_LIB_STAT_INVALID_E = -1,
DSS_LIB_STAT_FAIL_E,
DSS_LIB_STAT_SUCCESS_E,
DSS_LIB_STAT_MAX_E
} DSS_Lib_Status_e;
typedef enum DSS_Net_Evt_TYPE
{
DSS_EVT_INVALID_E = 0x00, /**< Invalid event. */
DSS_EVT_NET_IS_CONN_E, /**< Call connected. */
DSS_EVT_NET_NO_NET_E, /**< Call disconnected. */
DSS_EVT_NET_RECONFIGURED_E, /**< Call reconfigured. */
DSS_EVT_NET_NEWADDR_E, /**< New address generated. */
DSS_EVT_NET_DELADDR_E, /**< Delete generated. */
DSS_EVT_NIPD_DL_DATA_E,
DSS_EVT_MAX_E
} DSS_Net_Evt_Type_e;
#define HTTP_DEFAULT_PORT 80
#define HTTPS_DEFAULT_PORT 443
#define HTTP_DOMAIN_NAME_LENGTH 150
#define HTTP_URL_LENGTH 700
#define HTTP_MAX_PATH_LENGTH 100
#define HTTP_READ_BYTES 1024
#define HTPP_MAX_CONNECT_RETRY (6)
#define FIBOCOMHTTPPORT_RECV_BUF_SIZE (4096)
boolean http_decode_url(uint8 *url,uint32 *url_length,char *host,uint16 *port,uint8 *file_name);
int http_request_send(char* host, uint16 port, uint8* file_name,const char *request_data,uint32 request_data_len, StringWithLen *http_resp);
void http_release(void);
int http_netctrl_start(void);
void http_netctrl_stop(void);
/**
* @}
*/
/* The following content is used in the HttpClient module. */
#ifndef MTK_DEBUG_LEVEL_NONE
#define HTTPCLIENT_DEBUG 1
#else
#define HTTPCLIENT_DEBUG 0
#endif
#ifdef BOAT_HTTPCLIENT_SSL_ENABLE
#endif
#ifdef __cplusplus
}
#endif
#endif /* __HTTPCLIENT_H__ */
|
41cd8c41f1238e2c1088ec23f3b848f5ff8bce75
|
e73547787354afd9b717ea57fe8dd0695d161821
|
/src/world/area_flo/flo_03/flo_03_3_npc.c
|
a244e283bc240c21bb1a71975f472eac7c42f8d3
|
[] |
no_license
|
pmret/papermario
|
8b514b19653cef8d6145e47499b3636b8c474a37
|
9774b26d93f1045dd2a67e502b6efc9599fb6c31
|
refs/heads/main
| 2023-08-31T07:09:48.951514
| 2023-08-21T18:07:08
| 2023-08-21T18:07:08
| 287,151,133
| 904
| 139
| null | 2023-09-14T02:44:23
| 2020-08-13T01:22:57
|
C
|
UTF-8
|
C
| false
| false
| 44,152
|
c
|
flo_03_3_npc.c
|
#include "flo_03.h"
#include "sprite/player.h"
NpcSettings N(NpcSettings_Dayzee) = {
.height = 24,
.radius = 24,
.level = ACTOR_LEVEL_NONE,
};
NpcSettings N(NpcSettings_Petunia) = {
.height = 56,
.radius = 40,
.level = ACTOR_LEVEL_NONE,
};
#include "world/common/complete/GiveReward.inc.c"
Vec3i N(BurrowLocations_Mole_01)[] = {
{ -100, 0, 210 },
{ -160, 0, 285 },
{ -35, 0, 305 },
};
Vec3i N(BurrowLocations_Mole_02)[] = {
{ -190, 0, 80 },
{ -130, 0, 0 },
{ -70, 0, -60 },
};
Vec3i N(BurrowLocations_Mole_03)[] = {
{ 75, 0, -15 },
{ 35, 0, -100 },
{ 130, 0, 0 },
};
Vec3i N(BurrowLocations_Mole_04)[] = {
{ 115, 0, 180 },
{ 85, 0, 290 },
{ 145, 0, 140 },
};
EvtScript N(EVS_Scene_SunReturns) = {
EVT_CALL(DisablePlayerInput, TRUE)
EVT_CALL(DisablePlayerPhysics, TRUE)
EVT_CALL(SetNpcYaw, NPC_Petunia, 90)
EVT_CALL(GetNpcPos, NPC_Petunia, LVar0, LVar1, LVar2)
EVT_CALL(UseSettingsFrom, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetPanTarget, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetCamDistance, CAM_DEFAULT, 300)
EVT_CALL(SetCamPitch, CAM_DEFAULT, EVT_FLOAT(17.0), EVT_FLOAT(-9.5))
EVT_CALL(SetCamPosA, CAM_DEFAULT, -27, 0)
EVT_CALL(SetCamPosB, CAM_DEFAULT, 0, -50)
EVT_CALL(SetCamSpeed, CAM_DEFAULT, EVT_FLOAT(90.0))
EVT_CALL(PanToTarget, CAM_DEFAULT, 0, 1)
EVT_CALL(WaitForCam, CAM_DEFAULT, EVT_FLOAT(1.0))
EVT_WAIT(20)
EVT_CALL(SpeakToPlayer, NPC_Petunia, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0, MSG_CH6_00C8)
EVT_CALL(SetNpcAnimation, NPC_Petunia, ANIM_Petunia_Dance)
EVT_WAIT(10)
EVT_CALL(GotoMap, EVT_PTR("flo_18"), flo_18_ENTRY_1)
EVT_WAIT(100)
EVT_RETURN
EVT_END
};
API_CALLABLE(N(HideBehindTree)) {
Enemy* enemy = script->owner1.enemy;
Npc* npc = get_npc_unsafe(enemy->npcID);
f32 posX, posZ, yaw, angle;
f64 dist;
// get a point 46 units away from the tree on the side opposite the player
yaw = clamp_angle(atan2(-210.0f, -183.0f, gPlayerStatus.pos.x, gPlayerStatus.pos.z) + 180.0f);
posX = -210.0f;
posZ = -183.0f;
add_vec2D_polar(&posX, &posZ, 46.0f, yaw);
// run or walk to target position, based on the distance from current position
dist = dist2D(npc->pos.x, npc->pos.z, posX, posZ);
if (dist > 2.0) {
f32 curAngle = clamp_angle(atan2(-210.0f, -183.0f, npc->pos.x, npc->pos.z));
f32 targetAngle = clamp_angle(atan2(-210.0f, -183.0f, posX, posZ));
f32 deltaAngle = curAngle - targetAngle;
if (abs(deltaAngle) > 20) {
angle = deltaAngle;
if (angle >= 180.0f) {
angle -= 360.0f;
}
if (angle <= -180.0f) {
angle += 360.0f;
}
if (deltaAngle == angle) {
posX = -210.0f;
posZ = -183.0f;
if (deltaAngle >= 0.0f) {
yaw = clamp_angle(curAngle - 20.0f);
} else {
yaw = clamp_angle(curAngle + 20.0f);
}
add_vec2D_polar(&posX, &posZ, 46.0f, yaw);
}
}
npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_RUN];
npc->yaw = atan2(npc->pos.x, npc->pos.z, posX, posZ);
npc_move_heading(npc, 2.0f, npc->yaw);
} else if (dist > 0.2) {
npc->yaw = atan2(npc->pos.x, npc->pos.z, posX, posZ);
npc->pos.x = posX;
npc->pos.z = posZ;
npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_WALK];
} else {
npc->pos.x = posX;
npc->pos.z = posZ;
npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_IDLE];
}
return ApiStatus_BLOCK;
}
EvtScript N(EVS_NpcAI_Dayzee) = {
EVT_CALL(N(HideBehindTree))
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcDefeat_Dayzee) = {
EVT_CALL(GetBattleOutcome, LVar0)
EVT_SWITCH(LVar0)
EVT_CASE_EQ(OUTCOME_PLAYER_WON)
EVT_SET(GF_FLO03_Defeated_Dayzee, TRUE)
EVT_CALL(DoNpcDefeat)
EVT_CASE_EQ(OUTCOME_PLAYER_LOST)
EVT_CASE_EQ(OUTCOME_PLAYER_FLED)
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
EvtScript N(EVS_FocusCamBetween) = {
EVT_CALL(GetPlayerPos, LVar3, LVar1, LVar2)
EVT_CALL(GetNpcPos, NPC_SELF, LVar0, LVar1, LVar2)
EVT_ADD(LVar0, LVar3)
EVT_DIV(LVar0, 2)
EVT_CALL(SetCamProperties, CAM_DEFAULT, LVar4, LVar0, LVar1, LVar2, 300, EVT_FLOAT(20.0), EVT_FLOAT(-9.5))
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInteract_Petunia) = {
EVT_EXEC_WAIT(N(EVS_PushFlowerSong))
EVT_SWITCH(GB_StoryProgress)
EVT_CASE_LT(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_SET(MV_PauseBurrowing, TRUE)
EVT_SET(LVar4, EVT_FLOAT(3.5 / DT))
EVT_EXEC_WAIT(N(EVS_FocusCamBetween))
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0050)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_Petunia_Angry)
EVT_CALL(SetPlayerAnimation, ANIM_Mario1_NodYes)
EVT_WAIT(20 * DT)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0051)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_01, ANIM_MontyMole_Dark_Anim12)
EVT_CALL(SetNpcYaw, NPC_MontyMole_01, 270)
EVT_CALL(GetNpcPos, NPC_MontyMole_01, LVar0, LVar1, LVar2)
EVT_CALL(UseSettingsFrom, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetPanTarget, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetCamSpeed, CAM_DEFAULT, EVT_FLOAT(90.0))
EVT_CALL(SetCamPitch, CAM_DEFAULT, EVT_FLOAT(17.0), EVT_FLOAT(-8.0))
EVT_CALL(SetCamDistance, CAM_DEFAULT, 200)
EVT_CALL(PanToTarget, CAM_DEFAULT, 0, 1)
EVT_CALL(WaitForCam, CAM_DEFAULT, EVT_FLOAT(1.0))
EVT_WAIT(20 * DT)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_01, SOUND_BURROW_SURFACE, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_01, ANIM_MontyMole_Dark_Anim16)
EVT_WAIT(10 * DT)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_01, SOUND_0263, SOUND_SPACE_DEFAULT)
EVT_CALL(ShowEmote, NPC_MontyMole_01, EMOTE_QUESTION, -45, 30, EMOTER_NPC, 0, 0, 0, 0)
EVT_CALL(GetNpcPos, NPC_MontyMole_02, LVar0, LVar1, LVar2)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0052)
EVT_CALL(SetNpcYaw, NPC_MontyMole_02, 90)
EVT_CALL(SetNpcPos, NPC_MontyMole_02, NPC_DISPOSE_LOCATION)
EVT_CALL(UseSettingsFrom, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetPanTarget, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetCamDistance, CAM_DEFAULT, 200)
EVT_CALL(SetCamPitch, CAM_DEFAULT, EVT_FLOAT(17.0), EVT_FLOAT(-8.0))
EVT_CALL(PanToTarget, CAM_DEFAULT, 0, 1)
EVT_CALL(WaitForCam, CAM_DEFAULT, EVT_FLOAT(1.0))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_02, ANIM_MontyMole_Dark_Anim00)
EVT_WAIT(20 * DT)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_02, SOUND_BURROW_SURFACE, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcPos, NPC_MontyMole_02, LVar0, LVar1, LVar2)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_02, ANIM_MontyMole_Dark_Anim10)
EVT_WAIT(20 * DT)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0053)
EVT_CALL(SetNpcYaw, NPC_MontyMole_03, 270)
EVT_CALL(GetNpcPos, NPC_MontyMole_03, LVar0, LVar1, LVar2)
EVT_CALL(UseSettingsFrom, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetPanTarget, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetCamDistance, CAM_DEFAULT, 200)
EVT_CALL(SetCamPitch, CAM_DEFAULT, EVT_FLOAT(17.0), EVT_FLOAT(-8.0))
EVT_CALL(PanToTarget, CAM_DEFAULT, 0, 1)
EVT_CALL(WaitForCam, CAM_DEFAULT, EVT_FLOAT(1.0))
EVT_WAIT(20 * DT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_03, ANIM_MontyMole_Dark_Anim14)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0054)
EVT_CALL(SetNpcYaw, NPC_MontyMole_04, 270)
EVT_CALL(GetNpcPos, NPC_MontyMole_04, LVar0, LVar1, LVar2)
EVT_CALL(UseSettingsFrom, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetPanTarget, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetCamDistance, CAM_DEFAULT, 200)
EVT_CALL(SetCamPitch, CAM_DEFAULT, EVT_FLOAT(17.0), EVT_FLOAT(-9.0))
EVT_CALL(PanToTarget, CAM_DEFAULT, 0, 1)
EVT_CALL(WaitForCam, CAM_DEFAULT, EVT_FLOAT(1.0))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim06)
EVT_WAIT(20 * DT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim07)
EVT_WAIT(20 * DT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim08)
EVT_WAIT(20 * DT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim16)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0055)
EVT_CALL(SetNpcPos, NPC_Dayzee, -233, 0, -217)
EVT_CALL(GetNpcPos, NPC_Dayzee, LVar0, LVar1, LVar2)
EVT_CALL(UseSettingsFrom, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetPanTarget, CAM_DEFAULT, LVar0, LVar1, LVar2)
EVT_CALL(SetCamDistance, CAM_DEFAULT, 300)
EVT_CALL(SetCamPitch, CAM_DEFAULT, EVT_FLOAT(17.0), EVT_FLOAT(-9.0))
EVT_CALL(PanToTarget, CAM_DEFAULT, 0, 1)
EVT_CALL(WaitForCam, CAM_DEFAULT, EVT_FLOAT(1.0))
EVT_CALL(SetNpcAnimation, NPC_Dayzee, ANIM_Dayzee_Anim0D)
EVT_CALL(PlaySoundAtNpc, NPC_Dayzee, SOUND_0262, SOUND_SPACE_DEFAULT)
EVT_CALL(ShowEmote, NPC_Dayzee, EMOTE_EXCLAMATION, 45, 30, EMOTER_NPC, 0, 0, 0, 0)
EVT_WAIT(15 * DT)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0056)
EVT_SET(LVar4, EVT_FLOAT(90.0))
EVT_EXEC_WAIT(N(EVS_FocusCamBetween))
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0057)
EVT_CALL(SetEnemyFlagBits, NPC_Dayzee, ENEMY_FLAG_PASSIVE, 0)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_01, ENEMY_FLAG_PASSIVE, 0)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_02, ENEMY_FLAG_PASSIVE, 0)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_03, ENEMY_FLAG_PASSIVE, 0)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_04, ENEMY_FLAG_PASSIVE, 0)
EVT_CALL(BindNpcAI, NPC_Dayzee, EVT_PTR(N(EVS_NpcAI_Dayzee)))
EVT_SET(MV_PauseBurrowing, FALSE)
EVT_SET(MV_NextBurrowTriggerRadius, 60)
EVT_SET(GB_StoryProgress, STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CASE_EQ(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_IF_EQ(GF_FLO03_DefeatedAll_MontyMoles, FALSE)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0, MSG_CH6_0058)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_Petunia_Angry)
EVT_ELSE
EVT_SET(LVar4, EVT_FLOAT(3.5 / DT))
EVT_EXEC_WAIT(N(EVS_FocusCamBetween))
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_HappyTalk, ANIM_Petunia_Dance, 0, MSG_CH6_0059)
EVT_CALL(EndSpeech, NPC_SELF, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_Petunia_GiveItem)
EVT_WAIT(20 * DT)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_Petunia_Idle)
EVT_GIVE_KEY_REWARD(ITEM_MAGICAL_BEAN)
EVT_WAIT(20 * DT)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0, MSG_CH6_005A)
EVT_CALL(EndSpeech, NPC_SELF, ANIM_Petunia_AngryTalk, ANIM_Petunia_Angry, 0)
EVT_SET(GB_StoryProgress, STORY_CH6_GOT_MAGICAL_BEAN)
EVT_END_IF
EVT_CASE_LT(STORY_CH6_DESTROYED_PUFF_PUFF_MACHINE)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0, MSG_CH6_005B)
EVT_CASE_LT(STORY_CH6_RETURNED_TO_TOAD_TOWN)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0, MSG_CH6_005C)
EVT_CASE_DEFAULT
EVT_IF_EQ(AB_FLO_PetuniaDialogue, 0)
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0, MSG_CH6_005D)
EVT_SET(AB_FLO_PetuniaDialogue, 1)
EVT_ELSE
EVT_CALL(SpeakToPlayer, NPC_SELF, ANIM_Petunia_Talk, ANIM_Petunia_Idle, 0, MSG_CH6_005E)
EVT_END_IF
EVT_END_SWITCH
EVT_CALL(ResetCam, CAM_DEFAULT, EVT_FLOAT(8.0 / DT))
EVT_EXEC_WAIT(N(EVS_PopSong))
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInit_Petunia) = {
EVT_CALL(BindNpcInteract, NPC_SELF, EVT_PTR(N(EVS_NpcInteract_Petunia)))
EVT_IF_EQ(GF_FLO03_DefeatedAll_MontyMoles, FALSE)
EVT_CALL(SetNpcAnimation, NPC_Petunia, ANIM_Petunia_Angry)
EVT_ELSE
EVT_CALL(SetNpcAnimation, NPC_Petunia, ANIM_Petunia_Idle)
EVT_END_IF
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInit_Dayzee) = {
EVT_CALL(BindNpcDefeat, NPC_SELF, EVT_PTR(N(EVS_NpcDefeat_Dayzee)))
EVT_CALL(EnableNpcShadow, NPC_Dayzee, FALSE)
EVT_SWITCH(GB_StoryProgress)
EVT_CASE_LT(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CALL(SetNpcPos, NPC_Dayzee, NPC_DISPOSE_LOCATION)
EVT_CASE_DEFAULT
EVT_IF_EQ(GF_FLO03_Defeated_Dayzee, FALSE)
EVT_CALL(SetEnemyFlagBits, NPC_Dayzee, ENEMY_FLAG_PASSIVE, 0)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcAI_Dayzee)))
EVT_ELSE
EVT_CALL(SetNpcPos, NPC_Dayzee, NPC_DISPOSE_LOCATION)
EVT_END_IF
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
EvtScript N(EVS_SetupMoles) = {
EVT_SET(MV_PauseBurrowing, FALSE)
EVT_SET(MV_NextBurrowTime_Mole_01, 0)
EVT_SET(MV_NextBurrowTime_Mole_02, 0)
EVT_SET(MV_NextBurrowTime_Mole_03, 0)
EVT_SET(MV_NextBurrowTime_Mole_04, 0)
EVT_SET(MV_NextBurrowTriggerRadius, 100)
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcDefeat_MontyMole) = {
EVT_CALL(GetBattleOutcome, LVar0)
EVT_SWITCH(LVar0)
EVT_CASE_EQ(OUTCOME_PLAYER_WON)
// record defeat
EVT_CALL(GetSelfNpcID, LVar0)
EVT_SWITCH(LVar0)
EVT_CASE_EQ(NPC_MontyMole_01)
EVT_SET(GF_FLO03_Defeated_MontyMoleA, TRUE)
EVT_CASE_EQ(NPC_MontyMole_02)
EVT_SET(GF_FLO03_Defeated_MontyMoleB, TRUE)
EVT_CASE_EQ(NPC_MontyMole_03)
EVT_SET(GF_FLO03_Defeated_MontyMoleC, TRUE)
EVT_CASE_EQ(NPC_MontyMole_04)
EVT_SET(GF_FLO03_Defeated_MontyMoleD, TRUE)
EVT_END_SWITCH
// count number of defeated moles
EVT_SET(LVar0, 0)
EVT_ADD(LVar0, GF_FLO03_Defeated_MontyMoleA)
EVT_ADD(LVar0, GF_FLO03_Defeated_MontyMoleB)
EVT_ADD(LVar0, GF_FLO03_Defeated_MontyMoleC)
EVT_ADD(LVar0, GF_FLO03_Defeated_MontyMoleD)
// end the mole-hunting minigame if all 4 are defeated
EVT_IF_NE(LVar0, 4)
EVT_CALL(SetNpcAnimation, NPC_Petunia, ANIM_Petunia_Angry)
EVT_ELSE
EVT_CALL(SetNpcAnimation, NPC_Petunia, ANIM_Petunia_Idle)
EVT_SET(GF_FLO03_DefeatedAll_MontyMoles, TRUE)
EVT_EXEC_WAIT(N(EVS_SetupMusic))
EVT_END_IF
EVT_CALL(DoNpcDefeat)
EVT_CASE_EQ(OUTCOME_PLAYER_LOST)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_MontyMole_Dark_Anim01)
EVT_CASE_EQ(OUTCOME_PLAYER_FLED)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_MontyMole_Dark_Anim01)
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcHit_MontyMole) = {
EVT_IF_EQ(GB_StoryProgress, STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CALL(GetOwnerEncounterTrigger, LVar0)
EVT_IF_NE(LVar0, ENCOUNTER_TRIGGER_NONE)
EVT_CALL(SetNpcAnimation, NPC_SELF, ANIM_MontyMole_Dark_Anim05)
EVT_END_IF
EVT_END_IF
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcIdle_MontyMole_01) = {
#define LV_ShouldBurrow LVar3
EVT_LOOP(0)
EVT_IF_EQ(MV_NextBurrowTime_Mole_01, 0)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_01, TRUE)
EVT_GOTO(0)
EVT_END_IF
EVT_SET(LV_ShouldBurrow, TRUE)
EVT_ELSE
EVT_LABEL(0)
EVT_CALL(GetNpcPos, NPC_MontyMole_01, LVar0, LVar1, LVar2)
EVT_CALL(IsPlayerWithin, LVar0, LVar2, MV_NextBurrowTriggerRadius, LV_ShouldBurrow)
EVT_END_IF
EVT_CALL(GetPartnerInUse, LVar9)
EVT_IF_EQ(LVar9, PARTNER_BOW)
EVT_SET(LVar3, FALSE)
EVT_END_IF
EVT_IF_EQ(MV_PauseBurrowing, TRUE)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(LV_ShouldBurrow, TRUE)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_01, FALSE)
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_01, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_01, 1)
EVT_WAIT(1)
EVT_SET(AF_FLO_IsUnderground_Mole_01, TRUE)
EVT_IF_NE(MV_NextBurrowTime_Mole_01, 0)
EVT_IF_LT(GB_StoryProgress, STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_SET(LVar1, 4)
EVT_ELSE
EVT_SET(LVar1, 10)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_01, SOUND_0262, SOUND_SPACE_DEFAULT)
EVT_CALL(ShowEmote, NPC_MontyMole_01, EMOTE_EXCLAMATION, 0, LVar1, EMOTER_NPC, 0, 0, 0, 0)
EVT_WAIT(LVar1)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 1)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_01, SOUND_BURROW_DIG, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_01, ANIM_MontyMole_Dark_Anim11)
EVT_WAIT(20)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleA, FALSE)
EVT_CALL(SetNpcPos, NPC_MontyMole_01, 0, -50, 0)
EVT_END_IF
EVT_WAIT(45)
EVT_END_IF
EVT_ELSE
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_01, TRUE)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleA, FALSE)
EVT_CALL(RandInt, ARRAY_COUNT(N(BurrowLocations_Mole_01)) - 1, LVar0)
EVT_ADD(LVar0, 1)
EVT_USE_BUF(EVT_PTR(N(BurrowLocations_Mole_01)))
EVT_LOOP(LVar0)
EVT_BUF_READ3(LVar1, LVar2, LVar3)
EVT_END_LOOP
EVT_CALL(SetNpcPos, NPC_MontyMole_01, LVar1, LVar2, LVar3)
EVT_END_IF
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_01, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_SET(AF_FLO_IsUnderground_Mole_01, FALSE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_01, 1)
EVT_WAIT(1)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_01, SOUND_BURROW_SURFACE, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_01, ANIM_MontyMole_Dark_Anim10)
EVT_WAIT(10)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 0)
EVT_CALL(RandInt, 30, LVar0)
EVT_ADD(LVar0, 60)
EVT_SET(MV_NextBurrowTime_Mole_01, LVar0)
EVT_ELSE
EVT_IF_GT(MV_NextBurrowTime_Mole_01, 0)
EVT_SUB(MV_NextBurrowTime_Mole_01, 1)
EVT_END_IF
EVT_END_IF
EVT_END_IF
EVT_WAIT(1)
EVT_END_LOOP
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcIdle_MontyMole_02) = {
#define LV_ShouldBurrow LVar3
EVT_LOOP(0)
EVT_IF_EQ(MV_NextBurrowTime_Mole_02, 0)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_02, TRUE)
EVT_GOTO(0)
EVT_END_IF
EVT_SET(LV_ShouldBurrow, TRUE)
EVT_ELSE
EVT_LABEL(0)
EVT_CALL(GetNpcPos, NPC_MontyMole_02, LVar0, LVar1, LVar2)
EVT_CALL(IsPlayerWithin, LVar0, LVar2, MV_NextBurrowTriggerRadius, LV_ShouldBurrow)
EVT_END_IF
EVT_CALL(GetPartnerInUse, LVar9)
EVT_IF_EQ(LVar9, PARTNER_BOW)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(MV_PauseBurrowing, TRUE)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(LV_ShouldBurrow, TRUE)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_02, FALSE)
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_02, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_02, 1)
EVT_WAIT(1)
EVT_SET(AF_FLO_IsUnderground_Mole_02, TRUE)
EVT_IF_NE(MV_NextBurrowTime_Mole_02, 0)
EVT_IF_LT(GB_StoryProgress, STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_SET(LVar1, 4)
EVT_ELSE
EVT_SET(LVar1, 10)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_02, SOUND_0262, SOUND_SPACE_DEFAULT)
EVT_CALL(ShowEmote, NPC_MontyMole_02, EMOTE_EXCLAMATION, 0, LVar1, EMOTER_NPC, 0, 0, 0, 0)
EVT_WAIT(LVar1)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 1)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_02, SOUND_BURROW_DIG, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_02, ANIM_MontyMole_Dark_Anim11)
EVT_WAIT(20)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleB, FALSE)
EVT_CALL(SetNpcPos, NPC_MontyMole_02, 0, -50, 0)
EVT_END_IF
EVT_WAIT(45)
EVT_END_IF
EVT_ELSE
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_02, TRUE)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleB, FALSE)
EVT_CALL(RandInt, ARRAY_COUNT(N(BurrowLocations_Mole_02)) - 1, LVar0)
EVT_ADD(LVar0, 1)
EVT_USE_BUF(EVT_PTR(N(BurrowLocations_Mole_02)))
EVT_LOOP(LVar0)
EVT_BUF_READ3(LVar1, LVar2, LVar3)
EVT_END_LOOP
EVT_CALL(SetNpcPos, NPC_MontyMole_02, LVar1, LVar2, LVar3)
EVT_END_IF
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_02, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_SET(AF_FLO_IsUnderground_Mole_02, FALSE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_02, 1)
EVT_WAIT(1)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_02, SOUND_BURROW_SURFACE, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_02, ANIM_MontyMole_Dark_Anim10)
EVT_WAIT(10)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 0)
EVT_CALL(RandInt, 35, LVar0)
EVT_ADD(LVar0, 55)
EVT_SET(MV_NextBurrowTime_Mole_02, LVar0)
EVT_ELSE
EVT_IF_GT(MV_NextBurrowTime_Mole_02, 0)
EVT_SUB(MV_NextBurrowTime_Mole_02, 1)
EVT_END_IF
EVT_END_IF
EVT_END_IF
EVT_WAIT(1)
EVT_END_LOOP
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcIdle_MontyMole_03) = {
#define LV_ShouldBurrow LVar3
EVT_LOOP(0)
EVT_IF_EQ(MV_NextBurrowTime_Mole_03, 0)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_03, TRUE)
EVT_GOTO(0)
EVT_END_IF
EVT_SET(LV_ShouldBurrow, TRUE)
EVT_ELSE
EVT_LABEL(0)
EVT_CALL(GetNpcPos, NPC_MontyMole_03, LVar0, LVar1, LVar2)
EVT_CALL(IsPlayerWithin, LVar0, LVar2, MV_NextBurrowTriggerRadius, LV_ShouldBurrow)
EVT_END_IF
EVT_CALL(GetPartnerInUse, LVar9)
EVT_IF_EQ(LVar9, PARTNER_BOW)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(MV_PauseBurrowing, TRUE)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(LV_ShouldBurrow, TRUE)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_03, FALSE)
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_03, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_03, 1)
EVT_WAIT(1)
EVT_SET(AF_FLO_IsUnderground_Mole_03, TRUE)
EVT_IF_NE(MV_NextBurrowTime_Mole_03, 0)
EVT_IF_LT(GB_StoryProgress, STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_SET(LVar1, 4)
EVT_ELSE
EVT_SET(LVar1, 10)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_03, SOUND_0262, SOUND_SPACE_DEFAULT)
EVT_CALL(ShowEmote, NPC_MontyMole_03, EMOTE_EXCLAMATION, 0, LVar1, EMOTER_NPC, 0, 0, 0, 0)
EVT_WAIT(LVar1)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 1)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_03, SOUND_BURROW_DIG, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_03, ANIM_MontyMole_Dark_Anim11)
EVT_WAIT(20)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleC, FALSE)
EVT_CALL(SetNpcPos, NPC_MontyMole_03, 0, -50, 0)
EVT_END_IF
EVT_WAIT(45)
EVT_END_IF
EVT_ELSE
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_03, TRUE)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleC, FALSE)
EVT_CALL(RandInt, ARRAY_COUNT(N(BurrowLocations_Mole_03)) - 1, LVar0)
EVT_ADD(LVar0, 1)
EVT_USE_BUF(EVT_PTR(N(BurrowLocations_Mole_03)))
EVT_LOOP(LVar0)
EVT_BUF_READ3(LVar1, LVar2, LVar3)
EVT_END_LOOP
EVT_CALL(SetNpcPos, NPC_MontyMole_03, LVar1, LVar2, LVar3)
EVT_END_IF
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_03, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_SET(AF_FLO_IsUnderground_Mole_03, FALSE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_03, 1)
EVT_WAIT(1)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_03, SOUND_BURROW_SURFACE, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_03, ANIM_MontyMole_Dark_Anim10)
EVT_WAIT(10)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 0)
EVT_CALL(RandInt, 40, LVar0)
EVT_ADD(LVar0, 50)
EVT_SET(MV_NextBurrowTime_Mole_03, LVar0)
EVT_ELSE
EVT_IF_GT(MV_NextBurrowTime_Mole_03, 0)
EVT_SUB(MV_NextBurrowTime_Mole_03, 1)
EVT_END_IF
EVT_END_IF
EVT_END_IF
EVT_WAIT(1)
EVT_END_LOOP
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcIdle_MontyMole_04) = {
#define LV_ShouldBurrow LVar3
EVT_LOOP(0)
EVT_IF_EQ(MV_NextBurrowTime_Mole_04, 0)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_04, TRUE)
EVT_GOTO(0)
EVT_END_IF
EVT_SET(LV_ShouldBurrow, TRUE)
EVT_ELSE
EVT_LABEL(0)
EVT_CALL(GetNpcPos, NPC_MontyMole_04, LVar0, LVar1, LVar2)
EVT_CALL(IsPlayerWithin, LVar0, LVar2, MV_NextBurrowTriggerRadius, LV_ShouldBurrow)
EVT_END_IF
EVT_CALL(GetPartnerInUse, LVar9)
EVT_IF_EQ(LVar9, PARTNER_BOW)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(MV_PauseBurrowing, TRUE)
EVT_SET(LV_ShouldBurrow, FALSE)
EVT_END_IF
EVT_IF_EQ(LV_ShouldBurrow, TRUE)
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_04, FALSE)
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_04, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_04, 1)
EVT_WAIT(1)
EVT_SET(AF_FLO_IsUnderground_Mole_04, TRUE)
EVT_IF_NE(MV_NextBurrowTime_Mole_04, 0)
EVT_IF_LT(GB_StoryProgress, STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_SET(LVar1, 4)
EVT_ELSE
EVT_SET(LVar1, 10)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_04, SOUND_0262, SOUND_SPACE_DEFAULT)
EVT_CALL(ShowEmote, NPC_MontyMole_04, EMOTE_EXCLAMATION, 0, LVar1, EMOTER_NPC, 0, 0, 0, 0)
EVT_WAIT(LVar1)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 1)
EVT_END_IF
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_04, SOUND_BURROW_DIG, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim11)
EVT_WAIT(20)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleD, FALSE)
EVT_CALL(SetNpcPos, NPC_MontyMole_04, 0, -50, 0)
EVT_END_IF
EVT_WAIT(45)
EVT_END_IF
EVT_ELSE
EVT_IF_EQ(AF_FLO_IsUnderground_Mole_04, TRUE)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleD, FALSE)
EVT_CALL(RandInt, ARRAY_COUNT(N(BurrowLocations_Mole_04)) - 1, LVar0)
EVT_ADD(LVar0, 1)
EVT_USE_BUF(EVT_PTR(N(BurrowLocations_Mole_04)))
EVT_LOOP(LVar0)
EVT_BUF_READ3(LVar1, LVar2, LVar3)
EVT_END_LOOP
EVT_CALL(SetNpcPos, NPC_MontyMole_04, LVar1, LVar2, LVar3)
EVT_END_IF
EVT_CALL(SetNpcFlagBits, NPC_MontyMole_04, NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_ENTITY_COLLISION, TRUE)
EVT_SET(AF_FLO_IsUnderground_Mole_04, FALSE)
EVT_CALL(NpcFacePlayer, NPC_MontyMole_04, 1)
EVT_WAIT(1)
EVT_CALL(PlaySoundAtNpc, NPC_MontyMole_04, SOUND_BURROW_SURFACE, SOUND_SPACE_DEFAULT)
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim10)
EVT_WAIT(10)
EVT_CALL(SetSelfEnemyFlagBits, ENEMY_FLAG_100000 | ENEMY_FLAG_IGNORE_TOUCH | ENEMY_FLAG_IGNORE_JUMP | ENEMY_FLAG_IGNORE_HAMMER | ENEMY_FLAG_IGNORE_PARTNER, 0)
EVT_CALL(RandInt, 45, LVar0)
EVT_ADD(LVar0, 45)
EVT_SET(MV_NextBurrowTime_Mole_04, LVar0)
EVT_ELSE
EVT_IF_GT(MV_NextBurrowTime_Mole_04, 0)
EVT_SUB(MV_NextBurrowTime_Mole_04, 1)
EVT_END_IF
EVT_END_IF
EVT_END_IF
EVT_WAIT(1)
EVT_END_LOOP
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInit_MontyMole_01) = {
EVT_CALL(BindNpcHit, NPC_SELF, EVT_PTR(N(EVS_NpcHit_MontyMole)))
EVT_CALL(BindNpcDefeat, NPC_SELF, EVT_PTR(N(EVS_NpcDefeat_MontyMole)))
EVT_CALL(EnableNpcShadow, NPC_MontyMole_01, FALSE)
EVT_SWITCH(GB_StoryProgress)
EVT_CASE_LT(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_01)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_01, ANIM_MontyMole_Dark_Anim10)
EVT_CASE_EQ(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleA, FALSE)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_01)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_01, ANIM_MontyMole_Dark_Anim10)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_01, ENEMY_FLAG_PASSIVE, 0)
EVT_ELSE
EVT_CALL(SetNpcPos, NPC_MontyMole_01, NPC_DISPOSE_LOCATION)
EVT_END_IF
EVT_CASE_DEFAULT
EVT_CALL(SetNpcPos, NPC_MontyMole_01, NPC_DISPOSE_LOCATION)
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInit_MontyMole_02) = {
EVT_CALL(BindNpcHit, NPC_SELF, EVT_PTR(N(EVS_NpcHit_MontyMole)))
EVT_CALL(BindNpcDefeat, NPC_SELF, EVT_PTR(N(EVS_NpcDefeat_MontyMole)))
EVT_CALL(EnableNpcShadow, NPC_MontyMole_02, FALSE)
EVT_SWITCH(GB_StoryProgress)
EVT_CASE_LT(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_02)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_02, ANIM_MontyMole_Dark_Anim10)
EVT_CASE_EQ(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleB, FALSE)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_02)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_02, ANIM_MontyMole_Dark_Anim10)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_02, ENEMY_FLAG_PASSIVE, 0)
EVT_ELSE
EVT_CALL(SetNpcPos, NPC_MontyMole_02, NPC_DISPOSE_LOCATION)
EVT_END_IF
EVT_CASE_DEFAULT
EVT_CALL(SetNpcPos, NPC_MontyMole_02, NPC_DISPOSE_LOCATION)
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInit_MontyMole_03) = {
EVT_CALL(BindNpcHit, NPC_SELF, EVT_PTR(N(EVS_NpcHit_MontyMole)))
EVT_CALL(BindNpcDefeat, NPC_SELF, EVT_PTR(N(EVS_NpcDefeat_MontyMole)))
EVT_CALL(EnableNpcShadow, NPC_MontyMole_03, FALSE)
EVT_SWITCH(GB_StoryProgress)
EVT_CASE_LT(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_03)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_03, ANIM_MontyMole_Dark_Anim10)
EVT_CASE_EQ(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleC, FALSE)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_03)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_03, ANIM_MontyMole_Dark_Anim10)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_03, ENEMY_FLAG_PASSIVE, 0)
EVT_ELSE
EVT_CALL(SetNpcPos, NPC_MontyMole_03, NPC_DISPOSE_LOCATION)
EVT_END_IF
EVT_CASE_DEFAULT
EVT_CALL(SetNpcPos, NPC_MontyMole_03, NPC_DISPOSE_LOCATION)
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
EvtScript N(EVS_NpcInit_MontyMole_04) = {
EVT_CALL(BindNpcHit, NPC_SELF, EVT_PTR(N(EVS_NpcHit_MontyMole)))
EVT_CALL(BindNpcDefeat, NPC_SELF, EVT_PTR(N(EVS_NpcDefeat_MontyMole)))
EVT_CALL(EnableNpcShadow, NPC_MontyMole_04, FALSE)
EVT_SWITCH(GB_StoryProgress)
EVT_CASE_LT(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_04)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim10)
EVT_CASE_EQ(STORY_CH6_ASKED_TO_DEFEAT_MONTY_MOLES)
EVT_IF_EQ(GF_FLO03_Defeated_MontyMoleD, FALSE)
EVT_CALL(BindNpcIdle, NPC_SELF, EVT_PTR(N(EVS_NpcIdle_MontyMole_04)))
EVT_CALL(SetNpcAnimation, NPC_MontyMole_04, ANIM_MontyMole_Dark_Anim10)
EVT_CALL(SetEnemyFlagBits, NPC_MontyMole_04, ENEMY_FLAG_PASSIVE, 0)
EVT_ELSE
EVT_CALL(SetNpcPos, NPC_MontyMole_04, NPC_DISPOSE_LOCATION)
EVT_END_IF
EVT_CASE_DEFAULT
EVT_CALL(SetNpcPos, NPC_MontyMole_04, NPC_DISPOSE_LOCATION)
EVT_END_SWITCH
EVT_RETURN
EVT_END
};
NpcData N(NpcData_Petunia) = {
.id = NPC_Petunia,
.pos = { -30.0f, 0.0f, 100.0f },
.yaw = 270,
.init = &N(EVS_NpcInit_Petunia),
.settings = &N(NpcSettings_Petunia),
.flags = ENEMY_FLAG_PASSIVE | ENEMY_FLAG_IGNORE_WORLD_COLLISION | ENEMY_FLAG_IGNORE_ENTITY_COLLISION | ENEMY_FLAG_FLYING,
.drops = NO_DROPS,
.animations = {
.idle = ANIM_Petunia_Idle,
.walk = ANIM_Petunia_Idle,
.run = ANIM_Petunia_Idle,
.chase = ANIM_Petunia_Idle,
.anim_4 = ANIM_Petunia_Idle,
.anim_5 = ANIM_Petunia_Idle,
.death = ANIM_Petunia_Idle,
.hit = ANIM_Petunia_Idle,
.anim_8 = ANIM_Petunia_Idle,
.anim_9 = ANIM_Petunia_Idle,
.anim_A = ANIM_Petunia_Idle,
.anim_B = ANIM_Petunia_Idle,
.anim_C = ANIM_Petunia_Idle,
.anim_D = ANIM_Petunia_Idle,
.anim_E = ANIM_Petunia_Idle,
.anim_F = ANIM_Petunia_Idle,
},
.tattle = MSG_NpcTattle_Petunia,
};
NpcData N(NpcData_Dayzee) = {
.id = NPC_Dayzee,
.pos = { -233.0f, 0.0f, -217.0f },
.yaw = 90,
.init = &N(EVS_NpcInit_Dayzee),
.settings = &N(NpcSettings_Dayzee),
.flags = ENEMY_FLAG_PASSIVE | ENEMY_FLAG_IGNORE_WORLD_COLLISION | ENEMY_FLAG_IGNORE_ENTITY_COLLISION | ENEMY_FLAG_FLYING,
.drops = NO_DROPS,
.animations = {
.idle = ANIM_Dayzee_Anim01,
.walk = ANIM_Dayzee_Anim02,
.run = ANIM_Dayzee_Anim03,
.chase = ANIM_Dayzee_Anim03,
.anim_4 = ANIM_Dayzee_Anim01,
.anim_5 = ANIM_Dayzee_Anim01,
.death = ANIM_Dayzee_Anim08,
.hit = ANIM_Dayzee_Anim08,
.anim_8 = ANIM_Dayzee_Anim06,
.anim_9 = ANIM_Dayzee_Anim07,
.anim_A = ANIM_Dayzee_Anim01,
.anim_B = ANIM_Dayzee_Anim01,
.anim_C = ANIM_Dayzee_Anim01,
.anim_D = ANIM_Dayzee_Anim01,
.anim_E = ANIM_Dayzee_Anim01,
.anim_F = ANIM_Dayzee_Anim01,
},
};
NpcData N(NpcData_MontyMole_01) = {
.id = NPC_MontyMole_01,
.pos = { -100.0f, 0.0f, 210.0f },
.yaw = 90,
.init = &N(EVS_NpcInit_MontyMole_01),
.settings = &N(NpcSettings_Dayzee),
.flags = ENEMY_FLAG_PASSIVE | ENEMY_FLAG_IGNORE_WORLD_COLLISION | ENEMY_FLAG_IGNORE_PLAYER_COLLISION | ENEMY_FLAG_IGNORE_ENTITY_COLLISION | ENEMY_FLAG_FLYING,
.drops = NO_DROPS,
.animations = {
.idle = ANIM_MontyMole_Dark_Anim01,
.walk = ANIM_MontyMole_Dark_Anim02,
.run = ANIM_MontyMole_Dark_Anim03,
.chase = ANIM_MontyMole_Dark_Anim03,
.anim_4 = ANIM_MontyMole_Dark_Anim01,
.anim_5 = ANIM_MontyMole_Dark_Anim01,
.death = ANIM_MontyMole_Dark_Anim05,
.hit = ANIM_MontyMole_Dark_Anim05,
.anim_8 = ANIM_MontyMole_Dark_Anim00,
.anim_9 = ANIM_MontyMole_Dark_Anim00,
.anim_A = ANIM_MontyMole_Dark_Anim00,
.anim_B = ANIM_MontyMole_Dark_Anim00,
.anim_C = ANIM_MontyMole_Dark_Anim00,
.anim_D = ANIM_MontyMole_Dark_Anim00,
.anim_E = ANIM_MontyMole_Dark_Anim00,
.anim_F = ANIM_MontyMole_Dark_Anim00,
},
};
NpcData N(NpcData_MontyMole_02) = {
.id = NPC_MontyMole_02,
.pos = { -130.0f, 0.0f, 0.0f },
.yaw = 90,
.init = &N(EVS_NpcInit_MontyMole_02),
.settings = &N(NpcSettings_Dayzee),
.flags = ENEMY_FLAG_PASSIVE | ENEMY_FLAG_IGNORE_WORLD_COLLISION | ENEMY_FLAG_IGNORE_PLAYER_COLLISION | ENEMY_FLAG_IGNORE_ENTITY_COLLISION | ENEMY_FLAG_FLYING,
.drops = NO_DROPS,
.animations = {
.idle = ANIM_MontyMole_Dark_Anim01,
.walk = ANIM_MontyMole_Dark_Anim02,
.run = ANIM_MontyMole_Dark_Anim03,
.chase = ANIM_MontyMole_Dark_Anim03,
.anim_4 = ANIM_MontyMole_Dark_Anim01,
.anim_5 = ANIM_MontyMole_Dark_Anim01,
.death = ANIM_MontyMole_Dark_Anim05,
.hit = ANIM_MontyMole_Dark_Anim05,
.anim_8 = ANIM_MontyMole_Dark_Anim00,
.anim_9 = ANIM_MontyMole_Dark_Anim00,
.anim_A = ANIM_MontyMole_Dark_Anim00,
.anim_B = ANIM_MontyMole_Dark_Anim00,
.anim_C = ANIM_MontyMole_Dark_Anim00,
.anim_D = ANIM_MontyMole_Dark_Anim00,
.anim_E = ANIM_MontyMole_Dark_Anim00,
.anim_F = ANIM_MontyMole_Dark_Anim00,
},
};
NpcData N(NpcData_MontyMole_03) = {
.id = NPC_MontyMole_03,
.pos = { 75.0f, 0.0f, 20.0f },
.yaw = 270,
.init = &N(EVS_NpcInit_MontyMole_03),
.settings = &N(NpcSettings_Dayzee),
.flags = ENEMY_FLAG_PASSIVE | ENEMY_FLAG_IGNORE_WORLD_COLLISION | ENEMY_FLAG_IGNORE_PLAYER_COLLISION | ENEMY_FLAG_IGNORE_ENTITY_COLLISION | ENEMY_FLAG_FLYING,
.drops = NO_DROPS,
.animations = {
.idle = ANIM_MontyMole_Dark_Anim01,
.walk = ANIM_MontyMole_Dark_Anim02,
.run = ANIM_MontyMole_Dark_Anim03,
.chase = ANIM_MontyMole_Dark_Anim03,
.anim_4 = ANIM_MontyMole_Dark_Anim01,
.anim_5 = ANIM_MontyMole_Dark_Anim01,
.death = ANIM_MontyMole_Dark_Anim05,
.hit = ANIM_MontyMole_Dark_Anim05,
.anim_8 = ANIM_MontyMole_Dark_Anim00,
.anim_9 = ANIM_MontyMole_Dark_Anim00,
.anim_A = ANIM_MontyMole_Dark_Anim00,
.anim_B = ANIM_MontyMole_Dark_Anim00,
.anim_C = ANIM_MontyMole_Dark_Anim00,
.anim_D = ANIM_MontyMole_Dark_Anim00,
.anim_E = ANIM_MontyMole_Dark_Anim00,
.anim_F = ANIM_MontyMole_Dark_Anim00,
},
};
NpcData N(NpcData_MontyMole_04) = {
.id = NPC_MontyMole_04,
.pos = { 71.0f, 0.0f, 200.0f },
.yaw = 270,
.init = &N(EVS_NpcInit_MontyMole_04),
.settings = &N(NpcSettings_Dayzee),
.flags = ENEMY_FLAG_PASSIVE | ENEMY_FLAG_IGNORE_WORLD_COLLISION | ENEMY_FLAG_IGNORE_PLAYER_COLLISION | ENEMY_FLAG_IGNORE_ENTITY_COLLISION | ENEMY_FLAG_FLYING,
.drops = NO_DROPS,
.animations = {
.idle = ANIM_MontyMole_Dark_Anim01,
.walk = ANIM_MontyMole_Dark_Anim02,
.run = ANIM_MontyMole_Dark_Anim03,
.chase = ANIM_MontyMole_Dark_Anim03,
.anim_4 = ANIM_MontyMole_Dark_Anim01,
.anim_5 = ANIM_MontyMole_Dark_Anim01,
.death = ANIM_MontyMole_Dark_Anim05,
.hit = ANIM_MontyMole_Dark_Anim05,
.anim_8 = ANIM_MontyMole_Dark_Anim00,
.anim_9 = ANIM_MontyMole_Dark_Anim00,
.anim_A = ANIM_MontyMole_Dark_Anim00,
.anim_B = ANIM_MontyMole_Dark_Anim00,
.anim_C = ANIM_MontyMole_Dark_Anim00,
.anim_D = ANIM_MontyMole_Dark_Anim00,
.anim_E = ANIM_MontyMole_Dark_Anim00,
.anim_F = ANIM_MontyMole_Dark_Anim00,
},
};
NpcGroupList N(DefaultNPCs) = {
NPC_GROUP(N(NpcData_Petunia)),
NPC_GROUP(N(NpcData_Dayzee), BTL_FLO_FORMATION_0F, BTL_FLO_STAGE_01),
NPC_GROUP(N(NpcData_MontyMole_01), BTL_FLO2_FORMATION_02, BTL_FLO2_STAGE_01),
NPC_GROUP(N(NpcData_MontyMole_02), BTL_FLO2_FORMATION_01, BTL_FLO2_STAGE_01),
NPC_GROUP(N(NpcData_MontyMole_03), BTL_FLO2_FORMATION_03, BTL_FLO2_STAGE_01),
NPC_GROUP(N(NpcData_MontyMole_04), BTL_FLO2_FORMATION_04, BTL_FLO2_STAGE_01),
{}
};
|
f83dba0af4996a93de0a5ec818f71ed533e5cea2
|
f367e4b66a1ee42e85830b31df88f63723c36a47
|
/lib/onigmo/reggnu.c
|
451c00bda50f494f10e7034240134d43a24d5661
|
[
"Apache-2.0",
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
fluent/fluent-bit
|
06873e441162b92941024e9a7e9e8fc934150bf7
|
1a41f49dc2f3ae31a780caa9ffd6137b1d703065
|
refs/heads/master
| 2023-09-05T13:44:55.347372
| 2023-09-05T10:14:33
| 2023-09-05T10:14:33
| 29,933,948
| 4,907
| 1,565
|
Apache-2.0
| 2023-09-14T10:17:02
| 2015-01-27T20:41:52
|
C
|
UTF-8
|
C
| false
| false
| 4,150
|
c
|
reggnu.c
|
/**********************************************************************
reggnu.c - Onigmo (Oniguruma-mod) (regular expression library)
**********************************************************************/
/*-
* Copyright (c) 2002-2008 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>
* Copyright (c) 2011-2016 K.Takata <kentkt AT csc DOT jp>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "regint.h"
#ifndef ONIGMOGNU_H
# include "onigmognu.h"
#endif
extern void
re_free_registers(OnigRegion* r)
{
/* 0: don't free self */
onig_region_free(r, 0);
}
extern int
re_adjust_startpos(regex_t* reg, const char* string, int size,
int startpos, int range)
{
if (startpos > 0 && ONIGENC_MBC_MAXLEN(reg->enc) != 1 && startpos < size) {
UChar *p;
UChar *s = (UChar* )string + startpos;
UChar *e = (UChar* )string + size;
if (range > 0) {
p = onigenc_get_right_adjust_char_head(reg->enc, (UChar* )string, s, e);
}
else {
p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, (UChar* )string, s, e);
}
return (int )(p - (UChar* )string);
}
return startpos;
}
extern int
re_match(regex_t* reg, const char* str, int size, int pos,
struct re_registers* regs)
{
return (int )onig_match(reg, (UChar* )str, (UChar* )(str + size),
(UChar* )(str + pos), regs, ONIG_OPTION_NONE);
}
extern int
re_search(regex_t* bufp, const char* string, int size, int startpos, int range,
struct re_registers* regs)
{
return (int )onig_search(bufp, (UChar* )string, (UChar* )(string + size),
(UChar* )(string + startpos),
(UChar* )(string + startpos + range),
regs, ONIG_OPTION_NONE);
}
extern int
re_compile_pattern(const char* pattern, int size, regex_t* reg, char* ebuf)
{
int r;
OnigErrorInfo einfo;
r = onig_compile(reg, (UChar* )pattern, (UChar* )(pattern + size), &einfo);
if (r != ONIG_NORMAL) {
if (IS_NOT_NULL(ebuf))
(void )onig_error_code_to_str((UChar* )ebuf, r, &einfo);
}
return r;
}
extern void
re_free_pattern(regex_t* reg)
{
onig_free(reg);
}
extern int
re_alloc_pattern(regex_t** reg)
{
*reg = (regex_t* )xmalloc(sizeof(regex_t));
if (IS_NULL(*reg)) return ONIGERR_MEMORY;
return onig_reg_init(*reg, ONIG_OPTION_DEFAULT,
ONIGENC_CASE_FOLD_DEFAULT,
OnigEncDefaultCharEncoding,
OnigDefaultSyntax);
}
extern void
re_set_casetable(const char* table)
{
/* onigenc_set_default_caseconv_table((UChar* )table); */
}
extern void
re_mbcinit(int mb_code)
{
OnigEncoding enc;
switch (mb_code) {
case RE_MBCTYPE_ASCII:
enc = ONIG_ENCODING_ASCII;
break;
case RE_MBCTYPE_EUC:
enc = ONIG_ENCODING_EUC_JP;
break;
case RE_MBCTYPE_SJIS:
enc = ONIG_ENCODING_SJIS;
break;
case RE_MBCTYPE_UTF8:
enc = ONIG_ENCODING_UTF8;
break;
default:
return ;
break;
}
onigenc_set_default_encoding(enc);
}
|
250631ffd197505d0bdf84bc01b6c19f2317f6c3
|
30c2631ed046d7662476b94fb7f5286c47377f60
|
/src/addons/meta/serialized.c
|
4b57878efb61f9a5deceb5c8f29a420b41969645
|
[
"MIT"
] |
permissive
|
SanderMertens/flecs
|
a840093340f0d1eb2bd30ec1585296f81f2aab39
|
41fb856c4e1162f44b59d7881ef508d64d56bf10
|
refs/heads/master
| 2023-08-24T16:21:41.790084
| 2023-08-24T08:38:57
| 2023-08-24T08:49:52
| 146,155,284
| 4,731
| 456
|
MIT
| 2023-09-05T16:01:58
| 2018-08-26T05:53:05
|
C
|
UTF-8
|
C
| false
| false
| 7,621
|
c
|
serialized.c
|
/**
* @file meta/serialized.c
* @brief Serialize type into flat operations array to speed up deserialization.
*/
#include "meta.h"
#ifdef FLECS_META
static
int flecs_meta_serialize_type(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops);
ecs_meta_type_op_kind_t flecs_meta_primitive_to_op_kind(ecs_primitive_kind_t kind) {
return EcsOpPrimitive + kind;
}
static
ecs_size_t flecs_meta_type_size(ecs_world_t *world, ecs_entity_t type) {
const EcsComponent *comp = ecs_get(world, type, EcsComponent);
ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
return comp->size;
}
static
ecs_meta_type_op_t* flecs_meta_ops_add(ecs_vec_t *ops, ecs_meta_type_op_kind_t kind) {
ecs_meta_type_op_t *op = ecs_vec_append_t(NULL, ops, ecs_meta_type_op_t);
op->kind = kind;
op->offset = 0;
op->count = 1;
op->op_count = 1;
op->size = 0;
op->name = NULL;
op->members = NULL;
op->type = 0;
op->member_index = 0;
return op;
}
static
ecs_meta_type_op_t* flecs_meta_ops_get(ecs_vec_t *ops, int32_t index) {
ecs_meta_type_op_t* op = ecs_vec_get_t(ops, ecs_meta_type_op_t, index);
ecs_assert(op != NULL, ECS_INTERNAL_ERROR, NULL);
return op;
}
static
int flecs_meta_serialize_primitive(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
const EcsPrimitive *ptr = ecs_get(world, type, EcsPrimitive);
if (!ptr) {
char *name = ecs_get_fullpath(world, type);
ecs_err("entity '%s' is not a primitive type", name);
ecs_os_free(name);
return -1;
}
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, flecs_meta_primitive_to_op_kind(ptr->kind));
op->offset = offset;
op->type = type;
op->size = flecs_meta_type_size(world, type);
return 0;
}
static
int flecs_meta_serialize_enum(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
(void)world;
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, EcsOpEnum);
op->offset = offset;
op->type = type;
op->size = ECS_SIZEOF(ecs_i32_t);
return 0;
}
static
int flecs_meta_serialize_bitmask(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
(void)world;
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, EcsOpBitmask);
op->offset = offset;
op->type = type;
op->size = ECS_SIZEOF(ecs_u32_t);
return 0;
}
static
int flecs_meta_serialize_array(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
(void)world;
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, EcsOpArray);
op->offset = offset;
op->type = type;
op->size = flecs_meta_type_size(world, type);
return 0;
}
static
int flecs_meta_serialize_array_component(
ecs_world_t *world,
ecs_entity_t type,
ecs_vec_t *ops)
{
const EcsArray *ptr = ecs_get(world, type, EcsArray);
if (!ptr) {
return -1; /* Should never happen, will trigger internal error */
}
flecs_meta_serialize_type(world, ptr->type, 0, ops);
ecs_meta_type_op_t *first = ecs_vec_first(ops);
first->count = ptr->count;
return 0;
}
static
int flecs_meta_serialize_vector(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
(void)world;
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, EcsOpVector);
op->offset = offset;
op->type = type;
op->size = flecs_meta_type_size(world, type);
return 0;
}
static
int flecs_meta_serialize_custom_type(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
(void)world;
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, EcsOpOpaque);
op->offset = offset;
op->type = type;
op->size = flecs_meta_type_size(world, type);
return 0;
}
static
int flecs_meta_serialize_struct(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
const EcsStruct *ptr = ecs_get(world, type, EcsStruct);
ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
int32_t cur, first = ecs_vec_count(ops);
ecs_meta_type_op_t *op = flecs_meta_ops_add(ops, EcsOpPush);
op->offset = offset;
op->type = type;
op->size = flecs_meta_type_size(world, type);
ecs_member_t *members = ecs_vec_first(&ptr->members);
int32_t i, count = ecs_vec_count(&ptr->members);
ecs_hashmap_t *member_index = NULL;
if (count) {
op->members = member_index = flecs_name_index_new(
world, &world->allocator);
}
for (i = 0; i < count; i ++) {
ecs_member_t *member = &members[i];
cur = ecs_vec_count(ops);
flecs_meta_serialize_type(world,
member->type, offset + member->offset, ops);
op = flecs_meta_ops_get(ops, cur);
if (!op->type) {
op->type = member->type;
}
if (op->count <= 1) {
op->count = member->count;
}
const char *member_name = member->name;
op->name = member_name;
op->op_count = ecs_vec_count(ops) - cur;
op->member_index = i;
flecs_name_index_ensure(
member_index, flecs_ito(uint64_t, cur - first - 1),
member_name, 0, 0);
}
flecs_meta_ops_add(ops, EcsOpPop);
flecs_meta_ops_get(ops, first)->op_count = ecs_vec_count(ops) - first;
return 0;
}
static
int flecs_meta_serialize_type(
ecs_world_t *world,
ecs_entity_t type,
ecs_size_t offset,
ecs_vec_t *ops)
{
const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType);
if (!ptr) {
char *path = ecs_get_fullpath(world, type);
ecs_err("missing EcsMetaType for type %s'", path);
ecs_os_free(path);
return -1;
}
switch(ptr->kind) {
case EcsPrimitiveType: return flecs_meta_serialize_primitive(world, type, offset, ops);
case EcsEnumType: return flecs_meta_serialize_enum(world, type, offset, ops);
case EcsBitmaskType: return flecs_meta_serialize_bitmask(world, type, offset, ops);
case EcsStructType: return flecs_meta_serialize_struct(world, type, offset, ops);
case EcsArrayType: return flecs_meta_serialize_array(world, type, offset, ops);
case EcsVectorType: return flecs_meta_serialize_vector(world, type, offset, ops);
case EcsOpaqueType: return flecs_meta_serialize_custom_type(world, type, offset, ops);
}
return 0;
}
static
int flecs_meta_serialize_component(
ecs_world_t *world,
ecs_entity_t type,
ecs_vec_t *ops)
{
const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType);
if (!ptr) {
char *path = ecs_get_fullpath(world, type);
ecs_err("missing EcsMetaType for type %s'", path);
ecs_os_free(path);
return -1;
}
if (ptr->kind == EcsArrayType) {
return flecs_meta_serialize_array_component(world, type, ops);
} else {
return flecs_meta_serialize_type(world, type, 0, ops);
}
}
void ecs_meta_type_serialized_init(
ecs_iter_t *it)
{
ecs_world_t *world = it->world;
int i, count = it->count;
for (i = 0; i < count; i ++) {
ecs_entity_t e = it->entities[i];
ecs_vec_t ops;
ecs_vec_init_t(NULL, &ops, ecs_meta_type_op_t, 0);
flecs_meta_serialize_component(world, e, &ops);
EcsMetaTypeSerialized *ptr = ecs_get_mut(
world, e, EcsMetaTypeSerialized);
if (ptr->ops.array) {
ecs_meta_dtor_serialized(ptr);
}
ptr->ops = ops;
}
}
#endif
|
86ed5087513f6588e05564c0922f49fde17a6a91
|
21c92afbd7fd022a206fb31294c523aebb770104
|
/SuiteSparse/GraphBLAS/Source/Template/GB_AxB_Gustavson_symbolic.c
|
e01ccc5b6aac7fbd859249ce3fefd75327f90238
|
[
"BSD-3-Clause",
"LicenseRef-scancode-free-unknown",
"LicenseRef-scancode-unknown-license-reference",
"GPL-2.0-or-later",
"GPL-3.0-only",
"LGPL-2.1-or-later",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"LicenseRef-scancode-other-copyleft",
"LicenseRef-scancode-warranty-disclaimer",
"Apache-2.0",
"LicenseRef-scancode-generic-cla"
] |
permissive
|
jlblancoc/suitesparse-metis-for-windows
|
70e6bcab2b525afb41758d61f823efa0618f67cf
|
5ee2eb4bc7bfd6d27af2f7fb027b1545cfc0fa3f
|
refs/heads/master
| 2023-08-30T21:15:39.624300
| 2023-03-09T10:16:48
| 2023-03-09T10:16:48
| 16,236,582
| 423
| 251
|
BSD-3-Clause
| 2023-03-09T10:18:08
| 2014-01-25T18:06:21
|
C
|
UTF-8
|
C
| false
| false
| 9,483
|
c
|
GB_AxB_Gustavson_symbolic.c
|
//------------------------------------------------------------------------------
// GB_AxB_Gustavson_symbolic: C=A*B symbolic analysis
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2018, All Rights Reserved.
// http://suitesparse.com See GraphBLAS/Doc/License.txt for license.
//------------------------------------------------------------------------------
{
//--------------------------------------------------------------------------
// get A and B
//--------------------------------------------------------------------------
const int64_t *Bp = B->p ;
const int64_t *Bi = B->i ;
const int64_t *Ap = A->p ;
const int64_t *Ai = A->i ;
#ifdef GB_HYPER_CASE
const int64_t *Ah = A->h ;
int64_t anvec = A->nvec ;
#endif
//--------------------------------------------------------------------------
// start the construction of the pattern of C
//--------------------------------------------------------------------------
int64_t *restrict Ci = C->i ;
int64_t *restrict Cp = C->p ;
int64_t jlast, cnz, cnz_last ;
GB_jstartup (C, &jlast, &cnz, &cnz_last) ;
//--------------------------------------------------------------------------
// symbolic pattern of C = A*B
//--------------------------------------------------------------------------
#ifdef GB_HYPER_CASE
GB_for_each_vector (B)
#else
int64_t n = C->vdim ;
for (int64_t j = 0 ; j < n ; j++)
#endif
{
#ifdef GB_HYPER_CASE
int64_t GBI1_initj (Iter, j, pB_start, pB_end) ;
#else
int64_t pB_start = Bp [j] ;
int64_t pB_end = Bp [j+1] ;
#endif
//----------------------------------------------------------------------
// reallocate C if necessary
//----------------------------------------------------------------------
// Note that cvlen is an upper bound on nnz (C (:,j)), but it can
// be a very loose bound if C is hypersparse.
int64_t cmax = cnz + cvlen ;
if (cmax > C->nzmax)
{
GB_OK (GB_ix_realloc (C, 4*(C->nzmax + cvlen), false, Context)) ;
Ci = C->i ;
}
//----------------------------------------------------------------------
// C(:,j) = set union of all A(:,k) for each nonzero B(k,j) ;
//----------------------------------------------------------------------
int64_t bjnz = pB_end - pB_start ;
#ifdef GB_HYPER_CASE
int64_t pleft = 0 ;
int64_t pright = anvec-1 ;
#endif
if (bjnz == 0)
{
//------------------------------------------------------------------
// B (:,j) is empty; nothing to do
//------------------------------------------------------------------
#ifdef GB_HYPER_CASE
continue ;
#endif
}
else if (bjnz == 1)
{
//------------------------------------------------------------------
// C (:,j) = A (:,k) for a single nonzero B(k,j)
//------------------------------------------------------------------
// C(:,j) = A(:,k)
int64_t k = Bi [pB_start] ;
// find A(:,k)
int64_t pA_start, pA_end ;
#ifdef GB_HYPER_CASE
GB_lookup (A_is_hyper, Ah, Ap, &pleft, pright, k,
&pA_start, &pA_end) ;
#else
pA_start = Ap [k] ;
pA_end = Ap [k+1] ;
#endif
for (int64_t pA = pA_start ; pA < pA_end ; pA++)
{
int64_t i = Ai [pA] ;
// C(i,j) is nonzero
Ci [cnz++] = i ;
}
}
else if (bjnz == 2)
{
//------------------------------------------------------------------
// 2-way merge of A (:,k1) and A (:,k2)
//------------------------------------------------------------------
int64_t k1 = Bi [pB_start] ;
int64_t k2 = Bi [pB_start+1] ;
ASSERT (k1 < k2) ;
int64_t p1, p1_end, p2, p2_end ;
// find A(:,k1) and A(:,k2)
#ifdef GB_HYPER_CASE
GB_lookup (A_is_hyper, Ah, Ap, &pleft, pright, k1,
&p1, &p1_end) ;
// Use pleft of k1 to trim the search for k2 since k1 < k2
GB_lookup (A_is_hyper, Ah, Ap, &pleft, pright, k2,
&p2, &p2_end) ;
#else
p1 = Ap [k1] ;
p1_end = Ap [k1+1] ;
p2 = Ap [k2] ;
p2_end = Ap [k2+1] ;
#endif
while (p1 < p1_end || p2 < p2_end)
{
int64_t i1 = (p1 < p1_end) ? Ai [p1] : cvlen ;
int64_t i2 = (p2 < p2_end) ? Ai [p2] : cvlen ;
int64_t i ;
if (i1 < i2)
{
i = i1 ;
p1++ ;
}
else if (i1 > i2)
{
i = i2 ;
p2++ ;
}
else // i1 == i2
{
i = i1 ;
p1++ ;
p2++ ;
}
// C(i,j) is nonzero
Ci [cnz++] = i ;
}
}
else
{
//------------------------------------------------------------------
// general case, nnz (B (:,j)) > 2
//------------------------------------------------------------------
// hiwater++
int64_t hiwater = GB_Sauna_reset (Sauna, 1, 0) ;
#ifdef GB_HYPER_CASE
// trim on right
if (A_is_hyper)
{
// trim Ah [0..pright] to remove any entries past
// the last B(:,j)
GB_bracket_right (Bi [pB_end-1], Ah, 0, &pright) ;
}
#endif
for (int64_t pB = pB_start ; pB < pB_end ; pB++)
{
// if C(:,j) now completely full, no need to continue
if (cnz == cmax) break ;
// symbolic saxpy C(:,j) += A(:,k)*B(k,j)
int64_t k = Bi [pB] ;
// find A(:,k), reusing pleft since Bi [...] is sorted
int64_t pA_start, pA_end ;
#ifdef GB_HYPER_CASE
GB_lookup (A_is_hyper, Ah, Ap, &pleft, pright, k,
&pA_start, &pA_end) ;
#else
pA_start = Ap [k] ;
pA_end = Ap [k+1] ;
#endif
for (int64_t pA = pA_start ; pA < pA_end ; pA++)
{
int64_t i = Ai [pA] ;
// C(i,j) is nonzero
if (Sauna_Mark [i] < hiwater)
{
// C(i,j) is nonzero, and this is the 1st time row i
// has been added to the pattern in C(:,j). Mark it so
// row i is not added again.
Sauna_Mark [i] = hiwater ;
// add to the column pattern of A*B
Ci [cnz++] = i ;
}
}
}
// sort the pattern of C(:,j)
int64_t len = cnz - cnz_last ;
if (len == cvlen)
{
// no need to sort C(:,j) if dense; just recreate it
for (int64_t pC = cnz_last, i = 0 ; pC < cnz ; pC++, i++)
{
Ci [pC] = i ;
}
}
else
{
// sort the nonzero indices in C(:,j)
GB_qsort_1 (Ci + cnz_last, len) ;
}
}
//----------------------------------------------------------------------
// log the end of vector C(:,j)
//----------------------------------------------------------------------
#ifdef GB_HYPER_CASE
// this cannot fail since C->plen is the upper bound: the number
// of non-empty columns of B.
info = GB_jappend (C, j, &jlast, cnz, &cnz_last, Context) ;
ASSERT (info == GrB_SUCCESS) ;
// if it could fail:
// GB_OK (info) ; // check result and return on error
#else
Cp [j+1] = cnz ;
if (cnz > cnz_last) C->nvec_nonempty++ ;
cnz_last = cnz ;
#endif
// it also cannot run out of space here, but can do so above
ASSERT (cnz <= C->nzmax) ;
}
//--------------------------------------------------------------------------
// finalize C and clear the Sauna
//--------------------------------------------------------------------------
#ifdef GB_HYPER_CASE
GB_jwrapup (C, jlast, cnz) ;
#else
C->magic = GB_MAGIC ;
#endif
// clear the Sauna_Mark array
GB_Sauna_reset (Sauna, 1, 0) ;
//--------------------------------------------------------------------------
// reduce the size of C->i to hold just the required space
//--------------------------------------------------------------------------
info = GB_ix_realloc (C, cnz, false, Context) ;
ASSERT (info == GrB_SUCCESS) ;
ASSERT_OK (GB_check (C, "C symbolic Gustavson C=A*B", GB0)) ;
}
|
39ce2bb0853fd7341b780f076e0583d07757f19c
|
28d0f8c01599f8f6c711bdde0b59f9c2cd221203
|
/sys/arch/rs6000/include/int_const.h
|
5ab301fb78ca48f0bfb1654b14dc06748232debc
|
[] |
no_license
|
NetBSD/src
|
1a9cbc22ed778be638b37869ed4fb5c8dd616166
|
23ee83f7c0aea0777bd89d8ebd7f0cde9880d13c
|
refs/heads/trunk
| 2023-08-31T13:24:58.105962
| 2023-08-27T15:50:47
| 2023-08-27T15:50:47
| 88,439,547
| 656
| 348
| null | 2023-07-20T20:07:24
| 2017-04-16T20:03:43
| null |
UTF-8
|
C
| false
| false
| 99
|
h
|
int_const.h
|
/* $NetBSD: int_const.h,v 1.1 2007/12/17 19:09:17 garbled Exp $ */
#include <powerpc/int_const.h>
|
a34acf6e081d7190e8a1929fd8efbe267d79950a
|
0744dcc5394cebf57ebcba343747af6871b67017
|
/os/arch/arm/src/stm32/stm32_qencoder.h
|
a909234fc4199da03d46f80a0296795a9b6e97d4
|
[
"GPL-1.0-or-later",
"BSD-3-Clause",
"ISC",
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-other-permissive",
"Apache-2.0"
] |
permissive
|
Samsung/TizenRT
|
96abf62f1853f61fcf91ff14671a5e0c6ca48fdb
|
1a5c2e00a4b1bbf4c505bbf5cc6a8259e926f686
|
refs/heads/master
| 2023-08-31T08:59:33.327998
| 2023-08-08T06:09:20
| 2023-08-31T04:38:20
| 82,517,252
| 590
| 719
|
Apache-2.0
| 2023-09-14T06:54:49
| 2017-02-20T04:38:30
|
C
|
UTF-8
|
C
| false
| false
| 5,716
|
h
|
stm32_qencoder.h
|
/****************************************************************************
*
* Copyright 2018 Samsung Electronics All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*
****************************************************************************/
/************************************************************************************
* arch/arm/src/stm32/stm32_qencoder.h
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
************************************************************************************/
#ifndef __ARCH_ARM_SRC_STM32_STM32_QENCODER_H
#define __ARCH_ARM_SRC_STM32_STM32_QENCODER_H
/************************************************************************************
* Included Files
************************************************************************************/
#include <tinyara/config.h>
#include "chip.h"
#ifdef CONFIG_QENCODER
/************************************************************************************
* Included Files
************************************************************************************/
/* Timer devices may be used for different purposes. One special purpose is as
* a quadrature encoder input device. If CONFIG_STM32_TIMn is defined then the
* CONFIG_STM32_TIMn_QE must also be defined to indicate that timer "n" is intended
* to be used for as a quadrature encoder.
*/
#ifndef CONFIG_STM32_TIM1
#undef CONFIG_STM32_TIM1_QE
#endif
#ifndef CONFIG_STM32_TIM2
#undef CONFIG_STM32_TIM2_QE
#endif
#ifndef CONFIG_STM32_TIM3
#undef CONFIG_STM32_TIM3_QE
#endif
#ifndef CONFIG_STM32_TIM4
#undef CONFIG_STM32_TIM4_QE
#endif
#ifndef CONFIG_STM32_TIM5
#undef CONFIG_STM32_TIM5_QE
#endif
#ifndef CONFIG_STM32_TIM8
#undef CONFIG_STM32_TIM8_QE
#endif
/* Only timers 2-5, and 1 & 8 can be used as a quadrature encoder (at least for the
* STM32 F4)
*/
#undef CONFIG_STM32_TIM6_QE
#undef CONFIG_STM32_TIM7_QE
#undef CONFIG_STM32_TIM9_QE
#undef CONFIG_STM32_TIM10_QE
#undef CONFIG_STM32_TIM11_QE
#undef CONFIG_STM32_TIM12_QE
#undef CONFIG_STM32_TIM13_QE
#undef CONFIG_STM32_TIM14_QE
/* Clock out frequency. This value is used to calculation the timer CLKIN in
* prescaler value.
*/
#ifndef CONFIG_STM32_TIM1_QECLKOUT
#define CONFIG_STM32_TIM1_QECLKOUT 28000000
#endif
#ifndef CONFIG_STM32_TIM2_QECLKOUT
#define CONFIG_STM32_TIM2_QECLKOUT 28000000
#endif
#ifndef CONFIG_STM32_TIM3_QECLKOUT
#define CONFIG_STM32_TIM3_QECLKOUT 28000000
#endif
#ifndef CONFIG_STM32_TIM4_QECLKOUT
#define CONFIG_STM32_TIM4_QECLKOUT 28000000
#endif
#ifndef CONFIG_STM32_TIM5_QECLKOUT
#define CONFIG_STM32_TIM5_QECLKOUT 28000000
#endif
#ifndef CONFIG_STM32_TIM8_QECLKOUT
#define CONFIG_STM32_TIM8_QECLKOUT 28000000
#endif
/************************************************************************************
* Included Files
************************************************************************************/
/************************************************************************************
* Name: stm32_qeinitialize
*
* Description:
* Initialize a quadrature encoder interface. This function must be called from
* board-specific logic..
*
* Input Parameters:
* devpath - The full path to the driver to register. E.g., "/dev/qe0"
* tim - The timer number to used. 'tim' must be an element of {1,2,3,4,5,8}
*
* Returned Values:
* Zero on success; A negated errno value is returned on failure.
*
************************************************************************************/
int stm32_qeinitialize(FAR const char *devpath, int tim);
#endif /* CONFIG_QENCODER */
#endif /* __ARCH_ARM_SRC_STM32_STM32_QENCODER_H */
|
318c58a23eb683cf1d1b2fa3940f70c3b0f7bb2d
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/u-boot_new/common/spl/spl_sata.c
|
2e7adca0ca6d903da35f5966b2a0a6afc755954a
|
[
"GPL-2.0-or-later",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 988
|
c
|
spl_sata.c
|
/*
* (C) Copyright 2013
* Texas Instruments, <www.ti.com>
*
* Dan Murphy <dmurphy@ti.com>
*
* SPDX-License-Identifier: GPL-2.0+
*
* Derived work from spl_usb.c
*/
#include <common.h>
#include <spl.h>
#include <asm/u-boot.h>
#include <sata.h>
#include <fat.h>
#include <version.h>
#include <image.h>
DECLARE_GLOBAL_DATA_PTR;
void spl_sata_load_image(void)
{
int err;
block_dev_desc_t *stor_dev;
err = init_sata(CONFIG_SPL_SATA_BOOT_DEVICE);
if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
printf("spl: sata init failed: err - %d\n", err);
#endif
hang();
} else {
/* try to recognize storage devices immediately */
stor_dev = scsi_get_dev(0);
}
#ifdef CONFIG_SPL_OS_BOOT
if (spl_start_uboot() || spl_load_image_fat_os(stor_dev,
CONFIG_SYS_SATA_FAT_BOOT_PARTITION))
#endif
err = spl_load_image_fat(stor_dev,
CONFIG_SYS_SATA_FAT_BOOT_PARTITION,
CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME);
if (err) {
puts("Error loading sata device\n");
hang();
}
}
|
c7add7ae6dcc1a80b6b1eae03d8128e4a353a5d1
|
68e115d504decf90cf8adaf1c373a220c059d8d7
|
/Include/LittleVgl/core/lv_fonts/lv_font_symbol_30.c
|
0a0f386848b701ce83e9feedbc20e5721fa6eafc
|
[
"MIT",
"GPL-1.0-or-later",
"GPL-2.0-only",
"BSD-2-Clause"
] |
permissive
|
WOA-Project/Lumia950XLPkg
|
24fcad187d71488270b853d08fcdff542bbac5a2
|
0e7e24adb2ac80672ade1e56f9b538d99941328f
|
refs/heads/master
| 2023-08-11T09:20:00.600571
| 2022-09-14T09:09:51
| 2022-09-14T09:09:51
| 132,070,715
| 264
| 64
|
BSD-2-Clause
| 2022-12-18T20:27:21
| 2018-05-04T01:44:48
|
C
|
UTF-8
|
C
| false
| false
| 682,944
|
c
|
lv_font_symbol_30.c
|
#include "../lv_misc/lv_font.h"
#if USE_LV_FONT_SYMBOL_30 != 0 /*Can be enabled in lv_conf.h*/
/***********************************************************************************
* fontawesome-webfont.ttf 30 px Font in U+f000 () .. U+f2ee () range with 1 bpp
* Sparse font with only these characters:
***********************************************************************************/
/*Store the image of the letters (glyph)*/
static const uint8_t lv_font_symbol_30_glyph_bitmap[] = {
#if USE_LV_FONT_SYMBOL_30 == 1
/*Unicode: U+f001 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x03, 0x00, //.....................+%%+
0x00, 0x00, 0x1f, 0x80, //..................+%@@@@@
0x00, 0x00, 0xff, 0x80, //...............+@@@@@@@@@
0x00, 0x0f, 0xff, 0x80, //...........+%@@@@@@@@@@@@
0x00, 0x7f, 0xff, 0x80, //.........%@@@@@@@@@@@@@@@
0x00, 0xff, 0xff, 0x80, //........@@@@@@@@@@@@@@@@@
0x00, 0xff, 0xff, 0x80, //........@@@@@@@@@@@@@@@@@
0x00, 0xff, 0xff, 0x80, //........@@@@@@@@@@@@@@@@@
0x00, 0xff, 0xff, 0x80, //........@@@@@@@@@@@@@@@@@
0x00, 0xff, 0xf1, 0x80, //........@@@@@@@@@@@%+..@@
0x00, 0xff, 0x81, 0x80, //........@@@@@@@@%+.....@@
0x00, 0xfc, 0x01, 0x80, //........@@@@@%.........@@
0x00, 0xc0, 0x01, 0x80, //........@@+............@@
0x00, 0xc0, 0x01, 0x80, //........@@.............@@
0x00, 0xc0, 0x01, 0x80, //........@@.............@@
0x00, 0xc0, 0x01, 0x80, //........@@.............@@
0x00, 0xc0, 0x01, 0x80, //........@@.............@@
0x00, 0xc0, 0x7f, 0x80, //........@@......+@@@@@%@@
0x00, 0xc1, 0xff, 0x80, //........@@.....@@@@@@@@@@
0x00, 0xc1, 0xff, 0x80, //........@@....+@@@@@@@@@@
0x00, 0xc1, 0xff, 0x80, //........@@.....@@@@@@@@@@
0x3f, 0xc1, 0xff, 0x00, //.+%@@@@%@@.....%@@@@@@@@+
0xff, 0xc0, 0x7c, 0x00, //%@@@@@@@@@.......%@@@@+..
0xff, 0xc0, 0x00, 0x00, //@@@@@@@@@@...............
0xff, 0xc0, 0x00, 0x00, //@@@@@@@@@@...............
0xff, 0x80, 0x00, 0x00, //%@@@@@@@@+...............
0x3f, 0x00, 0x00, 0x00, //.+%@@@@%.................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f008 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x7f, 0xff, 0xff, 0xfc, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xff, 0xff, 0xff, 0xfe, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xc3, 0x00, 0x01, 0x86, //@@+..+@@+.............+@@+..+@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@+...@@...............@@....@@.
0xff, 0x00, 0x01, 0xfe, //@@@@@@@@...............@@@@@@@@.
0xff, 0x00, 0x01, 0xfe, //@@@@@@@@...............@@@@@@@@.
0xc3, 0x00, 0x01, 0x86, //@@+..+@@...............@@+..+@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@+..+@@+.............+@@+..+@@.
0xff, 0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xc3, 0x00, 0x01, 0x86, //@@+...@@+.............+@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@+..+@@...............@@+..+@@.
0xff, 0x00, 0x01, 0xfe, //@@@@@@@@...............@@@@@@@@.
0xff, 0x00, 0x01, 0xfe, //@@@@@@@@...............@@@@@@@@.
0xc3, 0x00, 0x01, 0x86, //@@+...@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@....@@...............@@....@@.
0xc3, 0x00, 0x01, 0x86, //@@+...@@+.............+@@....@@.
0xff, 0xff, 0xff, 0xfe, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x7f, 0xff, 0xff, 0xfc, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f00b () , Width: 29 */
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x7f, 0x1f, 0xff, 0xf0, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x1f, 0xff, 0xf8, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0xff, 0x1f, 0xff, 0xf8, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7f, 0x1f, 0xff, 0xf0, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0xff, 0x1f, 0xff, 0xf8, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0x3f, 0xff, 0xf8, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7f, 0x1f, 0xff, 0xf0, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f00c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.....................+...
0x00, 0x00, 0x0e, 0x00, //...................+@@@..
0x00, 0x00, 0x1f, 0x00, //..................+@@@@@.
0x00, 0x00, 0x3f, 0x80, //.................+@@@@@@@
0x00, 0x00, 0x7f, 0x80, //................+@@@@@@@@
0x00, 0x00, 0xff, 0x00, //...............+@@@@@@@@+
0x10, 0x01, 0xfe, 0x00, //...%+.........+@@@@@@@@+.
0x38, 0x03, 0xfc, 0x00, //..@@@+.......+@@@@@@@@+..
0x7c, 0x07, 0xf8, 0x00, //.@@@@@+.....+@@@@@@@@+...
0xfe, 0x0f, 0xf0, 0x00, //@@@@@@@+...+@@@@@@@@+....
0xff, 0x1f, 0xe0, 0x00, //@@@@@@@@+.+@@@@@@@@+.....
0x7f, 0xff, 0xc0, 0x00, //+@@@@@@@@%@@@@@@@@+......
0x3f, 0xff, 0x80, 0x00, //.+@@@@@@@@@@@@@@@+.......
0x1f, 0xff, 0x00, 0x00, //..+@@@@@@@@@@@@@+........
0x0f, 0xfe, 0x00, 0x00, //...+@@@@@@@@@@@+.........
0x07, 0xfc, 0x00, 0x00, //....+@@@@@@@@@+..........
0x03, 0xf8, 0x00, 0x00, //.....+@@@@@@@+...........
0x01, 0xf0, 0x00, 0x00, //......+@@@@@+............
0x00, 0xe0, 0x00, 0x00, //.......+@@@+.............
0x00, 0x40, 0x00, 0x00, //........+%+..............
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f00d () , Width: 20 */
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x1c, 0x01, 0x80, //...%@%.........%@+..
0x3e, 0x03, 0xc0, //..%@@@%.......@@@@+.
0x7f, 0x07, 0xe0, //.%@@@@@%.....@@@@@@+
0x7f, 0x8f, 0xf0, //.@@@@@@@%...@@@@@@@@
0x7f, 0xdf, 0xf0, //.@@@@@@@@%.@@@@@@@@%
0x3f, 0xff, 0xe0, //..@@@@@@@@@@@@@@@@@.
0x1f, 0xff, 0xc0, //...@@@@@@@@@@@@@@@..
0x0f, 0xff, 0x80, //....@@@@@@@@@@@@@...
0x07, 0xff, 0x00, //.....@@@@@@@@@@@....
0x03, 0xfe, 0x00, //.....+@@@@@@@@@.....
0x07, 0xff, 0x00, //.....@@@@@@@@@@%....
0x0f, 0xff, 0x80, //....@@@@@@@@@@@@%...
0x1f, 0xff, 0xc0, //...@@@@@@@@@@@@@@%..
0x3f, 0xff, 0xe0, //..@@@@@@@@@@@@@@@@%.
0x7f, 0xdf, 0xf0, //.@@@@@@@@@+@@@@@@@@%
0x7f, 0x8f, 0xf0, //.@@@@@@@@...@@@@@@@@
0x7f, 0x07, 0xf0, //.@@@@@@@.....@@@@@@%
0x3e, 0x03, 0xe0, //..@@@@@.......@@@@%.
0x1c, 0x01, 0xc0, //...@@@.........@@%..
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, //....................
/*Unicode: U+f011 () , Width: 25 */
0x00, 0x18, 0x00, 0x00, //...........@@+...........
0x00, 0x3c, 0x00, 0x00, //..........@@@@...........
0x00, 0x3c, 0x00, 0x00, //..........@@@@...........
0x00, 0x3c, 0x00, 0x00, //..........@@@@...........
0x06, 0x3c, 0x60, 0x00, //.....%%...@@@@...%%......
0x0f, 0x3c, 0xf0, 0x00, //....@@@@..@@@@..@@@@.....
0x1f, 0x3c, 0xf8, 0x00, //...@@@@@..@@@@..@@@@@....
0x3f, 0x3c, 0xfc, 0x00, //..%@@@@@..@@@@..%@@@@@...
0x3e, 0x3c, 0x7c, 0x00, //.+@@@@@...@@@@...@@@@@+..
0x7c, 0x3c, 0x3e, 0x00, //.@@@@@....@@@@....@@@@@..
0x78, 0x3c, 0x1e, 0x00, //+@@@@+....@@@@.....@@@@+.
0xf8, 0x3c, 0x1f, 0x00, //%@@@@.....@@@@.....%@@@%.
0xf0, 0x3c, 0x0f, 0x00, //@@@@+.....@@@@.....+@@@@.
0xf0, 0x3c, 0x0f, 0x00, //@@@@+.....%@@@......@@@@.
0xf0, 0x00, 0x0f, 0x00, //@@@@.......++.......@@@@.
0xf0, 0x00, 0x0f, 0x00, //@@@@................@@@@.
0xf0, 0x00, 0x0f, 0x00, //@@@@+...............@@@@.
0xf8, 0x00, 0x1f, 0x00, //%@@@%..............%@@@@.
0x78, 0x00, 0x1e, 0x00, //+@@@@..............@@@@+.
0x7c, 0x00, 0x3e, 0x00, //.@@@@%............%@@@@..
0x7c, 0x00, 0x3e, 0x00, //.+@@@@+..........+@@@@%..
0x3f, 0x00, 0xfc, 0x00, //..@@@@@%........%@@@@@...
0x1f, 0xc3, 0xf8, 0x00, //...@@@@@@%+...%@@@@@@+...
0x0f, 0xff, 0xf0, 0x00, //...+@@@@@@@@@@@@@@@@+....
0x07, 0xff, 0xe0, 0x00, //....+@@@@@@@@@@@@@@+.....
0x03, 0xff, 0xc0, 0x00, //......%@@@@@@@@@@%.......
0x00, 0x7e, 0x00, 0x00, //........+@@@@@@+.........
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f013 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x3e, 0x00, 0x00, //..........@@@@@..........
0x00, 0x3e, 0x00, 0x00, //..........@@@@@..........
0x04, 0x3e, 0x10, 0x00, //.....%...+@@@@@....%.....
0x0e, 0x7f, 0x38, 0x00, //...+@@@+.%@@@@@%.+@@@....
0x1f, 0xff, 0xfc, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x3f, 0xff, 0xfe, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x1f, 0xff, 0xfc, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x0f, 0xff, 0xf8, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x0f, 0xe3, 0xf8, 0x00, //....@@@@@@@+++@@@@@@@....
0x1f, 0xc1, 0xfc, 0x00, //...%@@@@@%.....%@@@@@%...
0xff, 0x80, 0xff, 0x80, //@@@@@@@@@.......@@@@@@@@@
0xff, 0x00, 0x7f, 0x80, //@@@@@@@@+.......+@@@@@@@@
0xff, 0x00, 0x7f, 0x80, //@@@@@@@@+.......+@@@@@@@@
0xff, 0x00, 0x7f, 0x80, //@@@@@@@@+.......+@@@@@@@@
0xff, 0x80, 0xff, 0x80, //@@@@@@@@@.......@@@@@@@@@
0x1f, 0xc1, 0xfc, 0x00, //...%@@@@@%.....%@@@@@%+..
0x0f, 0xe3, 0xf8, 0x00, //....@@@@@@%+.+%@@@@@@....
0x0f, 0xff, 0xf8, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x1f, 0xff, 0xfc, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x3f, 0xff, 0xfe, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x1f, 0xff, 0xfc, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x0e, 0x7f, 0x38, 0x00, //...+@@@+.%@@@@@%.+@@@+...
0x04, 0x3e, 0x10, 0x00, //.....@....@@@@@+..+@+....
0x00, 0x3e, 0x00, 0x00, //..........@@@@@..........
0x00, 0x3e, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f014 () , Width: 23 */
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x01, 0xfe, 0x00, //.......%@@@@@@@+.......
0x01, 0xff, 0x00, //......+@@@@@@@@@.......
0x03, 0x03, 0x80, //......@@+.....%@%......
0x03, 0x01, 0x80, //.....+@@.......@@......
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@%
0x30, 0x00, 0x18, //..@@..............+@%..
0x30, 0x00, 0x18, //..@@..............+@%..
0x30, 0x00, 0x18, //..@@..............+@%..
0x30, 0x00, 0x18, //..@@...+...+...+..+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x98, //..@@..@@+.%@+.+@%.+@%..
0x33, 0x31, 0x18, //..@@..%@..%@+.+@+.+@%..
0x30, 0x00, 0x18, //..@@..............+@%..
0x30, 0x00, 0x18, //..@@..............+@%..
0x30, 0x00, 0x38, //..@@+.............%@%..
0x1f, 0xff, 0xf0, //..+@@@@@@@@@@@@@@@@@...
0x1f, 0xff, 0xe0, //...%@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
/*Unicode: U+f015 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x04, 0x1e, 0x00, //............+%+....%%%%....
0x00, 0x1f, 0x1e, 0x00, //...........%@@@%...@@@@....
0x00, 0x3f, 0x9e, 0x00, //..........@@@@@@@..@@@@....
0x00, 0x7b, 0xde, 0x00, //.........@@@@.@@@@+@@@@....
0x00, 0xf1, 0xfe, 0x00, //.......+@@@%.+.%@@@@@@@....
0x03, 0xee, 0x7e, 0x00, //......%@@@+.%@%.+@@@@@@....
0x07, 0x9f, 0x3e, 0x00, //.....%@@@+.@@@@@.+@@@@@....
0x0f, 0x3f, 0x9e, 0x00, //....@@@@.+@@@@@@@+.@@@@....
0x1e, 0xff, 0xef, 0x00, //...@@@@.%@@@@@@@@@%.%@@@+..
0x3d, 0xff, 0xf7, 0xc0, //.+@@@%.%@@@@@@@@@@@%.%@@@%.
0x7b, 0xff, 0xf9, 0xe0, //+@@@+.@@@@@@@@@@@@@@@.+@@@%
0x67, 0xff, 0xfc, 0xc0, //.@@++@@@@@@@@@@@@@@@@@+.@@+
0x0f, 0xff, 0xfe, 0x00, //....@@@@@@@@@@@@@@@@@@@..+.
0x0f, 0xff, 0xfe, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x0f, 0xff, 0xfe, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x0f, 0xe0, 0xfe, 0x00, //....@@@@@@@.....@@@@@@@....
0x0f, 0xe0, 0xfe, 0x00, //....@@@@@@@.....@@@@@@@....
0x0f, 0xe0, 0xfe, 0x00, //....@@@@@@@.....@@@@@@@....
0x0f, 0xe0, 0xfe, 0x00, //....@@@@@@@.....@@@@@@@....
0x0f, 0xe0, 0xfe, 0x00, //....@@@@@@@.....@@@@@@@....
0x0f, 0xe0, 0xfe, 0x00, //....%@@@@@@.....@@@@@@%....
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f019 () , Width: 27 */
0x00, 0x1f, 0x00, 0x00, //...........%%%%%...........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //......++++@@@@@@%++++......
0x07, 0xff, 0xfc, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x03, 0xff, 0xf8, 0x00, //.....+@@@@@@@@@@@@@@@......
0x01, 0xff, 0xf0, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0xff, 0xe0, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x7f, 0xc0, 0x00, //........+@@@@@@@@@.........
0x00, 0x3f, 0x80, 0x00, //.........+@@@@@@@..........
0x00, 0x1f, 0x00, 0x00, //..........+@@@@@...........
0x00, 0x0e, 0x00, 0x00, //...........+@@@............
0xff, 0xc4, 0x7f, 0xe0, //%@@@@@@@@%..+@...%@@@@@@@@%
0xff, 0xe0, 0xff, 0xe0, //@@@@@@@@@@%.....@@@@@@@@@@@
0xff, 0xf1, 0xff, 0xe0, //@@@@@@@@@@@@+.+@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xe6, 0x60, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xe6, 0x60, //@@@@@@@@@@@@@@@@@@@.+@@++@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f01c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x07, 0xff, 0xf0, 0x00, //....+@@@@@@@@@@@@@@@.....
0x0f, 0xff, 0xf8, 0x00, //....@@@@@@@@@@@@@@@@@....
0x0f, 0xff, 0xf8, 0x00, //...+@@@@@@@@@@@@@@@@@....
0x1e, 0x00, 0x3c, 0x00, //...@@@%...........%@@%...
0x1c, 0x00, 0x1c, 0x00, //...@@@............+@@@...
0x3c, 0x00, 0x1e, 0x00, //..%@@%.............@@@%..
0x38, 0x00, 0x0e, 0x00, //..@@@+.............+@@@..
0x78, 0x00, 0x0e, 0x00, //.%@@@...............@@@+.
0x70, 0x00, 0x0f, 0x00, //.@@@+...............%@@@.
0x70, 0x00, 0x07, 0x00, //+@@@.................@@@.
0xf0, 0x00, 0x07, 0x80, //%@@%.................@@@%
0xf0, 0x00, 0x07, 0x80, //@@@%++++.........++++%@@@
0xff, 0x80, 0xff, 0x80, //@@@@@@@@%.......@@@@@@@@@
0xff, 0x80, 0xff, 0x80, //@@@@@@@@@......+@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@%.....@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f021 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x7f, 0x00, 0x00, //........+%@@@@@%+........
0x03, 0xff, 0xc1, 0x80, //......%@@@@@@@@@@@+....@%
0x07, 0xff, 0xf3, 0x80, //.....@@@@@@@@@@@@@@@..@@@
0x0f, 0xff, 0xff, 0x80, //....@@@@@@@@@@@@@@@@@@@@@
0x1f, 0xc1, 0xff, 0x80, //...@@@@@@%+...+%@@@@@@@@@
0x3f, 0x00, 0x7f, 0x80, //..@@@@@@.........%@@@@@@@
0x3e, 0x00, 0x3f, 0x80, //.+@@@@%...........@@@@@@@
0x7c, 0x00, 0x7f, 0x80, //.@@@@@...........@@@@@@@@
0x78, 0x00, 0xff, 0x80, //+@@@@...........@@@@@@@@@
0xf8, 0x00, 0xff, 0x80, //%@@@%...........@@@@@@@@@
0x00, 0x00, 0x00, 0x00, //.+++.............+++++++.
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.++++++++............+++.
0xff, 0x80, 0x0f, 0x00, //@@@@@@@@@+..........@@@@+
0xff, 0x80, 0x0f, 0x00, //@@@@@@@@@...........@@@@.
0xff, 0x00, 0x1f, 0x00, //@@@@@@@@...........@@@@@.
0xfe, 0x00, 0x3e, 0x00, //@@@@@@@...........%@@@@+.
0xff, 0x00, 0x7e, 0x00, //@@@@@@@@.........@@@@@%..
0xff, 0xc1, 0xfc, 0x00, //@@@@@@@@@%+...+%@@@@@@...
0xff, 0xff, 0xf8, 0x00, //@@@@@@@@@@@@@@@@@@@@@....
0xe7, 0xff, 0xf0, 0x00, //@@@..@@@@@@@@@@@@@@@.....
0xc3, 0xff, 0xc0, 0x00, //@@....%@@@@@@@@@@@+......
0x00, 0x7f, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f026 () , Width: 13 */
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x10, //..........+@.
0x00, 0x70, //.........%@@+
0x00, 0xf0, //........%@@@+
0x01, 0xf0, //.......%@@@@+
0x03, 0xf0, //......%@@@@@+
0x07, 0xf0, //.++++%@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //@@@@@@@@@@@@+
0xff, 0xf0, //%@@@@@@@@@@@+
0x03, 0xf0, //......@@@@@@+
0x01, 0xf0, //.......@@@@@+
0x00, 0xf0, //........@@@@+
0x00, 0x70, //.........@@@+
0x00, 0x30, //..........@@+
0x00, 0x10, //...........%.
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x00, //.............
0x00, 0x00, //.............
/*Unicode: U+f027 () , Width: 19 */
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x10, 0x00, //..........+@.......
0x00, 0x70, 0x00, //.........%@@+......
0x00, 0xf0, 0x00, //........%@@@+......
0x01, 0xf0, 0x00, //.......%@@@@+......
0x03, 0xf0, 0x00, //......%@@@@@+......
0x07, 0xf0, 0x00, //.++++%@@@@@@+......
0xff, 0xf1, 0x80, //@@@@@@@@@@@@+..@@+.
0xff, 0xf1, 0xc0, //@@@@@@@@@@@@+..@@@.
0xff, 0xf0, 0xe0, //@@@@@@@@@@@@+...%@%
0xff, 0xf0, 0x60, //@@@@@@@@@@@@+....@@
0xff, 0xf0, 0x60, //@@@@@@@@@@@@+....@@
0xff, 0xf0, 0xe0, //@@@@@@@@@@@@+...@@%
0xff, 0xf1, 0xc0, //@@@@@@@@@@@@+..@@@.
0xff, 0xf1, 0x80, //%@@@@@@@@@@@+..%%..
0x03, 0xf0, 0x00, //......@@@@@@+......
0x01, 0xf0, 0x00, //.......@@@@@+......
0x00, 0xf0, 0x00, //........@@@@+......
0x00, 0x70, 0x00, //.........@@@+......
0x00, 0x30, 0x00, //..........@@+......
0x00, 0x10, 0x00, //...........%.......
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, //...................
/*Unicode: U+f028 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x10, 0x00, //..................+@+......
0x00, 0x00, 0x1c, 0x00, //...........+......+@@@.....
0x00, 0x30, 0x0e, 0x00, //..........@@+......+@@@....
0x00, 0x70, 0x07, 0x00, //.........@@@+........%@@...
0x00, 0xf0, 0x63, 0x80, //........@@@@+....@@+..%@@..
0x01, 0xf0, 0x71, 0x80, //.......@@@@@+....@@@+..@@+.
0x03, 0xf0, 0x38, 0xc0, //......@@@@@@+.....%@@+.+@@.
0x7f, 0xf0, 0x1c, 0xc0, //+%%%%@@@@@@@+......%@@..@@+
0xff, 0xf1, 0xcc, 0xe0, //@@@@@@@@@@@@+..@@%..@@+.%@%
0xff, 0xf1, 0xc6, 0x60, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xf0, 0x66, 0x60, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xf0, 0x66, 0x60, //@@@@@@@@@@@@+....@@..@@..@@
0xff, 0xf0, 0x66, 0x60, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xf1, 0xc6, 0x60, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xf1, 0xcc, 0xe0, //@@@@@@@@@@@@+..@@%..@@+.+@%
0x7f, 0xf0, 0x1c, 0xc0, //+%%%%@@@@@@@+..+...%@@..@@+
0x03, 0xf0, 0x38, 0xc0, //......@@@@@@+.....%@@+.+@@.
0x01, 0xf0, 0x71, 0x80, //.......@@@@@+....@@@+..@@+.
0x00, 0xf0, 0x63, 0x80, //........@@@@+....@@+..%@@..
0x00, 0x70, 0x07, 0x00, //.........@@@+........%@@...
0x00, 0x30, 0x0e, 0x00, //..........@@+......+@@@+...
0x00, 0x00, 0x1c, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x18, 0x00, //..................+@+......
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f03e () , Width: 32 */
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x7f, 0xff, 0xff, 0xfc, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xff, 0xff, 0xff, 0xfe, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc3, 0x80, 0x00, 0x06, //@@...+@@%....................@@.
0xc7, 0xc0, 0x00, 0x06, //@@..+@@@@%...................@@.
0xcf, 0xc0, 0x00, 0x06, //@@..@@@@@@...................@@.
0xcf, 0xc0, 0x18, 0x06, //@@..@@@@@@.........%@........@@.
0xcf, 0xc0, 0x3c, 0x06, //@@..%@@@@@........%@@@.......@@.
0xc7, 0x80, 0x7e, 0x06, //@@...%@@@........%@@@@@......@@.
0xc0, 0x00, 0xff, 0x06, //@@..............@@@@@@@@.....@@.
0xc0, 0x01, 0xff, 0x86, //@@.............@@@@@@@@@@....@@.
0xc0, 0x03, 0xff, 0xc6, //@@.......+....@@@@@@@@@@@@...@@.
0xc0, 0xc7, 0xff, 0xe6, //@@......@@+..@@@@@@@@@@@@@@..@@.
0xc1, 0xef, 0xff, 0xe6, //@@.....@@@@+@@@@@@@@@@@@@@@..@@.
0xc3, 0xff, 0xff, 0xe6, //@@....@@@@@@@@@@@@@@@@@@@@@..@@.
0xc7, 0xff, 0xff, 0xe6, //@@...@@@@@@@@@@@@@@@@@@@@@@..@@.
0xcf, 0xff, 0xff, 0xe6, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xcf, 0xff, 0xff, 0xe6, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xcf, 0xff, 0xff, 0xe6, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xcf, 0xff, 0xff, 0xe6, //@@..%%%%%%%%%%%%%%%%%%%%%%+..@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xff, 0xff, 0xff, 0xfe, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x7f, 0xff, 0xff, 0xfc, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f040 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //..................+......
0x00, 0x00, 0x70, 0x00, //.................@@@+....
0x00, 0x00, 0xf8, 0x00, //................@@@@@+...
0x00, 0x01, 0xfc, 0x00, //...............@@@@@@@+..
0x00, 0x01, 0xfe, 0x00, //...............@@@@@@@@+.
0x00, 0x04, 0xff, 0x00, //.............@..@@@@@@@@.
0x00, 0x0e, 0x7f, 0x00, //............@@@..@@@@@@@+
0x00, 0x1f, 0x3f, 0x00, //...........@@@@@..@@@@@@.
0x00, 0x3b, 0x9e, 0x00, //..........@@@.@@@..@@@@+.
0x00, 0x77, 0xcc, 0x00, //.........@@@.@@@@@..@@+..
0x00, 0xef, 0xe0, 0x00, //........@@@.@@@@@@@......
0x01, 0xdf, 0xf0, 0x00, //.......@@@.@@@@@@@@@.....
0x03, 0xbf, 0xe0, 0x00, //......@@@.@@@@@@@@@+.....
0x07, 0x7f, 0xc0, 0x00, //.....@@@.@@@@@@@@@+......
0x0e, 0xff, 0x80, 0x00, //....@@@.@@@@@@@@@+.......
0x1d, 0xff, 0x00, 0x00, //...@@@.@@@@@@@@@+........
0x3b, 0xfe, 0x00, 0x00, //..@@@.@@@@@@@@@+.........
0x7f, 0xfc, 0x00, 0x00, //.@@@@@@@@@@@@@+..........
0xef, 0xf8, 0x00, 0x00, //@@%.%@@@@@@@@+...........
0xc7, 0xf0, 0x00, 0x00, //@@...%@@@@@@+............
0xc3, 0xe0, 0x00, 0x00, //@@....%@@@@+.............
0xf1, 0xc0, 0x00, 0x00, //@@@@...@@@+..............
0xf3, 0x80, 0x00, 0x00, //@@@@..%@@+...............
0xff, 0x00, 0x00, 0x00, //@@@@@@@@+................
0xfe, 0x00, 0x00, 0x00, //@@@@@@@+.................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f048 () , Width: 17 */
0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, //.................
0xf0, 0x00, 0x00, //%@@%...........++
0xf0, 0x01, 0x80, //@@@@..........+@%
0xf0, 0x03, 0x80, //@@@@.........+@@%
0xf0, 0x07, 0x80, //@@@@........+@@@%
0xf0, 0x0f, 0x80, //@@@@.......+@@@@%
0xf0, 0x1f, 0x80, //@@@@......+@@@@@%
0xf0, 0x3f, 0x80, //@@@@.....+@@@@@@%
0xf0, 0x7f, 0x80, //@@@@....+@@@@@@@%
0xf0, 0xff, 0x80, //@@@@...+@@@@@@@@%
0xf1, 0xff, 0x80, //@@@@..+@@@@@@@@@%
0xf3, 0xff, 0x80, //@@@@.+@@@@@@@@@@%
0xf7, 0xff, 0x80, //@@@@+@@@@@@@@@@@%
0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@%
0xff, 0xff, 0x80, //@@@@%@@@@@@@@@@@%
0xf3, 0xff, 0x80, //@@@@.+@@@@@@@@@@%
0xf1, 0xff, 0x80, //@@@@..+@@@@@@@@@%
0xf0, 0xff, 0x80, //@@@@...+@@@@@@@@%
0xf0, 0x7f, 0x80, //@@@@....+@@@@@@@%
0xf0, 0x3f, 0x80, //@@@@.....+@@@@@@%
0xf0, 0x1f, 0x80, //@@@@......+@@@@@%
0xf0, 0x0f, 0x80, //@@@@.......+@@@@%
0xf0, 0x07, 0x80, //@@@@........+@@@%
0xf0, 0x03, 0x80, //@@@@.........+@@%
0xf0, 0x01, 0x80, //@@@@..........+@%
0xf0, 0x00, 0x80, //%@@@...........+%
0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, //.................
/*Unicode: U+f04b () , Width: 23 */
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x80, 0x00, 0x00, //@+.....................
0xe0, 0x00, 0x00, //@@@+...................
0xf8, 0x00, 0x00, //@@@@@..................
0xfe, 0x00, 0x00, //@@@@@@%................
0xff, 0x80, 0x00, //@@@@@@@@%..............
0xff, 0xc0, 0x00, //@@@@@@@@@@+............
0xff, 0xf0, 0x00, //@@@@@@@@@@@@+..........
0xff, 0xfc, 0x00, //@@@@@@@@@@@@@@.........
0xff, 0xff, 0x00, //@@@@@@@@@@@@@@@%.......
0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@%.....
0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@+...
0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@+.
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@%.
0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@%...
0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@+....
0xff, 0xff, 0x00, //@@@@@@@@@@@@@@@@+......
0xff, 0xfe, 0x00, //@@@@@@@@@@@@@@%........
0xff, 0xf8, 0x00, //@@@@@@@@@@@@%..........
0xff, 0xe0, 0x00, //@@@@@@@@@@%............
0xff, 0x80, 0x00, //@@@@@@@@@+.............
0xfe, 0x00, 0x00, //@@@@@@@+...............
0xfc, 0x00, 0x00, //@@@@@%.................
0xf0, 0x00, 0x00, //@@@%...................
0xc0, 0x00, 0x00, //@@.....................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
/*Unicode: U+f04c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0xff, 0xc1, 0xff, 0x80, //%@@@@@@@@@.....@@@@@@@@@%
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xc1, 0xff, 0x80, //%@@@@@@@@@.....@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f04d () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0xff, 0xff, 0xff, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f051 () , Width: 17 */
0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, //.................
0x00, 0x0f, 0x00, //+...........%@@%.
0x80, 0x0f, 0x00, //@+..........@@@@.
0xc0, 0x0f, 0x00, //@@+.........@@@@.
0xe0, 0x0f, 0x00, //@@@+........@@@@.
0xf0, 0x0f, 0x00, //@@@@+.......@@@@.
0xf8, 0x0f, 0x00, //@@@@@+......@@@@.
0xfc, 0x0f, 0x00, //@@@@@@+.....@@@@.
0xfe, 0x0f, 0x00, //@@@@@@@+....@@@@.
0xff, 0x0f, 0x00, //@@@@@@@@+...@@@@.
0xff, 0x8f, 0x00, //@@@@@@@@@+..@@@@.
0xff, 0xcf, 0x00, //@@@@@@@@@@+.@@@@.
0xff, 0xef, 0x00, //@@@@@@@@@@@+@@@@.
0xff, 0xff, 0x00, //@@@@@@@@@@@@@@@@.
0xff, 0xff, 0x00, //@@@@@@@@@@@%@@@@.
0xff, 0xef, 0x00, //@@@@@@@@@@%.@@@@.
0xff, 0xcf, 0x00, //@@@@@@@@@%..@@@@.
0xff, 0x8f, 0x00, //@@@@@@@@%...@@@@.
0xff, 0x0f, 0x00, //@@@@@@@%....@@@@.
0xfe, 0x0f, 0x00, //@@@@@@%.....@@@@.
0xfc, 0x0f, 0x00, //@@@@@%......@@@@.
0xf8, 0x0f, 0x00, //@@@@%.......@@@@.
0xf0, 0x0f, 0x00, //@@@%........@@@@.
0xe0, 0x0f, 0x00, //@@%.........@@@@.
0xc0, 0x0f, 0x00, //@%..........@@@@.
0x80, 0x0f, 0x00, //%...........%@@@.
0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, //.................
/*Unicode: U+f052 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x08, 0x00, 0x00, //...........+@+...........
0x00, 0x1c, 0x00, 0x00, //..........+@@@+..........
0x00, 0x3e, 0x00, 0x00, //.........+@@@@@+.........
0x00, 0x7f, 0x00, 0x00, //........+@@@@@@@+........
0x00, 0xff, 0x80, 0x00, //.......+@@@@@@@@@+.......
0x01, 0xff, 0xc0, 0x00, //......+@@@@@@@@@@@+......
0x03, 0xff, 0xe0, 0x00, //.....+@@@@@@@@@@@@@+.....
0x07, 0xff, 0xf0, 0x00, //....+@@@@@@@@@@@@@@@+....
0x0f, 0xff, 0xf8, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x1f, 0xff, 0xfc, 0x00, //..+@@@@@@@@@@@@@@@@@@@+..
0x3f, 0xff, 0xfe, 0x00, //.+@@@@@@@@@@@@@@@@@@@@@+.
0x7f, 0xff, 0xff, 0x00, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x7f, 0xff, 0xff, 0x00, //+%%%%%%%%%%%%%%%%%%%%%%%+
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f053 () , Width: 18 */
0x00, 0x00, 0x00, //..................
0x00, 0x06, 0x00, //............+@%...
0x00, 0x0f, 0x00, //...........+@@@%..
0x00, 0x1f, 0x80, //..........+@@@@@%.
0x00, 0x3f, 0x80, //.........+@@@@@@@.
0x00, 0x7f, 0x80, //........+@@@@@@@@.
0x00, 0xff, 0x00, //.......+@@@@@@@@..
0x01, 0xfe, 0x00, //......+@@@@@@@@...
0x03, 0xfc, 0x00, //.....+@@@@@@@@....
0x07, 0xf8, 0x00, //....+@@@@@@@@.....
0x0f, 0xf0, 0x00, //...+@@@@@@@@......
0x1f, 0xe0, 0x00, //..+@@@@@@@@.......
0x3f, 0xc0, 0x00, //.+@@@@@@@@........
0x7f, 0x80, 0x00, //+@@@@@@@@.........
0x7f, 0x80, 0x00, //+@@@@@@@@.........
0x3f, 0xc0, 0x00, //.+@@@@@@@@........
0x1f, 0xe0, 0x00, //..+@@@@@@@@.......
0x0f, 0xf0, 0x00, //...+@@@@@@@@......
0x07, 0xf8, 0x00, //....+@@@@@@@@.....
0x03, 0xfc, 0x00, //.....+@@@@@@@@....
0x01, 0xfe, 0x00, //......+@@@@@@@@...
0x00, 0xff, 0x00, //.......+@@@@@@@@..
0x00, 0x7f, 0x80, //........+@@@@@@@@.
0x00, 0x3f, 0x80, //.........+@@@@@@@.
0x00, 0x1f, 0x00, //..........+@@@@@+.
0x00, 0x0e, 0x00, //...........+@@@+..
0x00, 0x04, 0x00, //............+@+...
0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, //..................
/*Unicode: U+f054 () , Width: 18 */
0x00, 0x00, 0x00, //..................
0x18, 0x00, 0x00, //...@@.............
0x3c, 0x00, 0x00, //..@@@@............
0x7e, 0x00, 0x00, //.@@@@@@...........
0x7f, 0x00, 0x00, //+@@@@@@@..........
0x7f, 0x80, 0x00, //.@@@@@@@@.........
0x3f, 0xc0, 0x00, //..@@@@@@@@........
0x1f, 0xe0, 0x00, //...@@@@@@@@.......
0x0f, 0xf0, 0x00, //....@@@@@@@@......
0x07, 0xf8, 0x00, //.....@@@@@@@@.....
0x03, 0xfc, 0x00, //......@@@@@@@@....
0x01, 0xfe, 0x00, //.......@@@@@@@@...
0x00, 0xff, 0x00, //........@@@@@@@@..
0x00, 0x7f, 0x80, //.........@@@@@@@@.
0x00, 0x7f, 0x80, //.........@@@@@@@@.
0x00, 0xff, 0x00, //........@@@@@@@@..
0x01, 0xfe, 0x00, //.......@@@@@@@@...
0x03, 0xfc, 0x00, //......@@@@@@@@....
0x07, 0xf8, 0x00, //.....@@@@@@@@.....
0x0f, 0xf0, 0x00, //....@@@@@@@@......
0x1f, 0xe0, 0x00, //...@@@@@@@@.......
0x3f, 0xc0, 0x00, //..@@@@@@@@........
0x7f, 0x80, 0x00, //.@@@@@@@@.........
0x7f, 0x00, 0x00, //+@@@@@@@..........
0x7e, 0x00, 0x00, //.%@@@@@...........
0x3c, 0x00, 0x00, //..%@@@............
0x18, 0x00, 0x00, //...%@.............
0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, //..................
/*Unicode: U+f067 () , Width: 23 */
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x7c, 0x00, //.........%@@@%.........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfe, 0x00, //.+++++++@@@@@@%+++++++.
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@%
0x7f, 0xff, 0xfc, //+%%%%%%%@@@@@@@%%%%%%%.
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0xfc, 0x00, //........%@@@@@+........
0x00, 0x7c, 0x00, //........+@@@@@.........
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
/*Unicode: U+f068 () , Width: 23 */
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0xff, 0xff, 0xfc, //%@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@%
0x7f, 0xff, 0xfc, //+@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
/*Unicode: U+f071 () , Width: 29 */
0x00, 0x07, 0x00, 0x00, //.............%@%.............
0x00, 0x0f, 0x80, 0x00, //............%@@@%............
0x00, 0x0f, 0x80, 0x00, //............@@@@@............
0x00, 0x1f, 0xc0, 0x00, //...........%@@@@@%...........
0x00, 0x1f, 0xc0, 0x00, //...........@@@@@@@...........
0x00, 0x3f, 0xe0, 0x00, //..........%@@@@@@@%..........
0x00, 0x3f, 0xe0, 0x00, //..........@@@@@@@@@..........
0x00, 0x7f, 0xf0, 0x00, //.........@@@@@@@@@@@.........
0x00, 0x70, 0x70, 0x00, //........+@@@+++++@@@+........
0x00, 0xf0, 0x78, 0x00, //........@@@@.....@@@@........
0x00, 0xf0, 0x78, 0x00, //.......+@@@@.....@@@@+.......
0x01, 0xf0, 0x7c, 0x00, //.......@@@@@+...+@@@@@.......
0x01, 0xf0, 0x7c, 0x00, //......+@@@@@+...+@@@@@+......
0x03, 0xf0, 0x7e, 0x00, //......@@@@@@+...+@@@@@@......
0x07, 0xf0, 0x7f, 0x00, //.....%@@@@@@+...+@@@@@@%.....
0x07, 0xf0, 0x7f, 0x00, //.....@@@@@@@+...+@@@@@@@.....
0x0f, 0xf8, 0xff, 0x80, //....%@@@@@@@%...%@@@@@@@%....
0x0f, 0xff, 0xff, 0x80, //....@@@@@@@@@@@@@@@@@@@@@....
0x1f, 0xff, 0xff, 0xc0, //...%@@@@@@@@@@@@@@@@@@@@@%...
0x1f, 0xf0, 0x7f, 0xc0, //..+@@@@@@@@@+...+@@@@@@@@@+..
0x3f, 0xf0, 0x7f, 0xe0, //..@@@@@@@@@@+...+@@@@@@@@@@..
0x3f, 0xf0, 0x7f, 0xe0, //.+@@@@@@@@@@+...+@@@@@@@@@@+.
0x7f, 0xf8, 0xff, 0xf0, //.@@@@@@@@@@@%...%@@@@@@@@@@@.
0x7f, 0xff, 0xff, 0xf0, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xf0, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f074 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x01, 0x00, //.......................@+....
0x00, 0x00, 0x01, 0x80, //.......................@@+...
0x00, 0x00, 0x01, 0xc0, //.......................@@@+..
0xfc, 0x00, 0x7f, 0xe0, //%%%%%%+.........+%%%%%@@@@@+.
0xff, 0x03, 0xff, 0xf0, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xff, 0xc7, 0xff, 0xf8, //@@@@@@@@@+...%@@@@@@@@@@@@@@@
0xff, 0xcf, 0xff, 0xf0, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0x07, 0xcf, 0xc3, 0xe0, //+++++%@@@@++@@@@@%++++%@@@@..
0x01, 0xdf, 0x01, 0xc0, //......+@@@.@@@@@.......@@@...
0x00, 0x9e, 0x01, 0x80, //.......+@++@@@@........@@....
0x00, 0xbe, 0x01, 0x00, //........%.@@@@%........@.....
0x00, 0x3c, 0x00, 0x00, //.........+@@@@...............
0x00, 0x7c, 0x00, 0x00, //.........@@@@%...............
0x00, 0x78, 0x00, 0x00, //........+@@@@................
0x00, 0xfa, 0x01, 0x00, //........@@@@@.%........@.....
0x00, 0xf6, 0x01, 0x80, //.......+@@@@+%@........@@....
0x01, 0xf7, 0x01, 0xc0, //.......@@@@@.@@@.......@@@...
0x07, 0xef, 0xc3, 0xe0, //+++++%@@@@@.%@@@@%++++%@@@@..
0xff, 0xcf, 0xff, 0xf0, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0xff, 0xc7, 0xff, 0xf8, //@@@@@@@@@%...@@@@@@@@@@@@@@@@
0xff, 0x03, 0xff, 0xf0, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xfc, 0x00, 0x7f, 0xe0, //%@@@%%+.........+%%@@@@@@@@+.
0x00, 0x00, 0x01, 0xc0, //.......................@@@+..
0x00, 0x00, 0x01, 0x80, //.......................@@+...
0x00, 0x00, 0x01, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f077 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x0c, 0x00, 0x00, //............@@.............
0x00, 0x1e, 0x00, 0x00, //...........@@@@............
0x00, 0x3f, 0x00, 0x00, //..........@@@@@@...........
0x00, 0x7f, 0x80, 0x00, //.........@@@@@@@@..........
0x00, 0xff, 0xc0, 0x00, //........@@@@@@@@@@.........
0x01, 0xff, 0xe0, 0x00, //.......@@@@@@@@@@@@........
0x03, 0xff, 0xf0, 0x00, //......@@@@@@@@@@@@@@.......
0x07, 0xff, 0xf8, 0x00, //.....@@@@@@@@@@@@@@@@......
0x0f, 0xf3, 0xfc, 0x00, //....@@@@@@@@+.@@@@@@@@.....
0x1f, 0xe1, 0xfe, 0x00, //...@@@@@@@@+...@@@@@@@@....
0x3f, 0xc0, 0xff, 0x00, //..@@@@@@@@+.....@@@@@@@@...
0x7f, 0x80, 0x7f, 0x80, //.@@@@@@@@+.......@@@@@@@@..
0xff, 0x00, 0x3f, 0xc0, //@@@@@@@@+.........@@@@@@@@.
0xfe, 0x00, 0x1f, 0xc0, //@@@@@@@+...........@@@@@@@.
0x7c, 0x00, 0x0f, 0x80, //.@@@@@+.............@@@@@..
0x38, 0x00, 0x07, 0x00, //..@@@+...............@@@...
0x10, 0x00, 0x02, 0x00, //...%+.................%....
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f078 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x18, 0x00, 0x07, 0x00, //..+@@................%@%...
0x3c, 0x00, 0x0f, 0x80, //.+@@@@..............%@@@%..
0x7e, 0x00, 0x1f, 0xc0, //+@@@@@@............%@@@@@%.
0xff, 0x00, 0x3f, 0xc0, //@@@@@@@@..........%@@@@@@@.
0x7f, 0x80, 0x7f, 0x80, //+@@@@@@@@........%@@@@@@@+.
0x3f, 0xc0, 0xff, 0x00, //.+@@@@@@@@......%@@@@@@@+..
0x1f, 0xe1, 0xfe, 0x00, //..+@@@@@@@@....%@@@@@@@+...
0x0f, 0xf3, 0xfc, 0x00, //...+@@@@@@@@..%@@@@@@@+....
0x07, 0xff, 0xf8, 0x00, //....+@@@@@@@@%@@@@@@@+.....
0x03, 0xff, 0xf0, 0x00, //.....+@@@@@@@@@@@@@@+......
0x01, 0xff, 0xe0, 0x00, //......+@@@@@@@@@@@@+.......
0x00, 0xff, 0xc0, 0x00, //.......+@@@@@@@@@@+........
0x00, 0x7f, 0x80, 0x00, //........+@@@@@@@@+.........
0x00, 0x3f, 0x00, 0x00, //.........+@@@@@@+..........
0x00, 0x1e, 0x00, 0x00, //..........+@@@@+...........
0x00, 0x0c, 0x00, 0x00, //...........+@@+............
0x00, 0x00, 0x00, 0x00, //............++.............
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f079 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x06, 0x3f, 0xff, 0xe0, //.....%@...%@@@@@@@@@@@@@@@@.....
0x0f, 0x1f, 0xff, 0xe0, //....%@@@...@@@@@@@@@@@@@@@@.....
0x0f, 0x8f, 0xff, 0xe0, //...+@@@@@...@@@@@@@@@@@@@@@.....
0x1f, 0xc7, 0xff, 0xe0, //...@@@@@@%..+@@@@@@@@@@@@@@.....
0x3f, 0xc0, 0x01, 0xe0, //..@@@@@@@@+...........+@@@@.....
0x7f, 0xe0, 0x01, 0xe0, //.@@@@@@@@@@+...........@@@@.....
0xff, 0xf0, 0x01, 0xe0, //%@@@@@@@@@@@...........@@@@.....
0xff, 0xf0, 0x01, 0xe0, //@@@@@@@@@@@@+..........@@@@.....
0x0f, 0x00, 0x01, 0xe0, //.+++@@@@+++............@@@@.....
0x0f, 0x00, 0x01, 0xe0, //....@@@@+..............@@@@.....
0x0f, 0x00, 0x01, 0xe0, //....@@@@+...........+++@@@@+++..
0x0f, 0x00, 0x1f, 0xfe, //....@@@@+.........+@@@@@@@@@@@@.
0x0f, 0x00, 0x1f, 0xfe, //....@@@@+..........@@@@@@@@@@@%.
0x0f, 0x00, 0x0f, 0xfc, //....@@@@+...........@@@@@@@@@@..
0x0f, 0x00, 0x07, 0xf8, //....@@@@+...........+@@@@@@@@...
0x0f, 0xff, 0xc7, 0xf0, //....@@@@@@@@@@@@@@+..%@@@@@@+...
0x0f, 0xff, 0xe3, 0xe0, //....@@@@@@@@@@@@@@@...%@@@@+....
0x0f, 0xff, 0xf1, 0xe0, //....@@@@@@@@@@@@@@@@...@@@%.....
0x0f, 0xff, 0xf8, 0xc0, //....@@@@@@@@@@@@@@@@%...@%......
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f07b () , Width: 27 */
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x3f, 0xc0, 0x00, 0x00, //..%@@@@@@%+................
0x7f, 0xf0, 0x00, 0x00, //.@@@@@@@@@@%...............
0xff, 0xf0, 0x00, 0x00, //%@@@@@@@@@@@...............
0xff, 0xf0, 0x00, 0x00, //@@@@@@@@@@@@+..............
0xff, 0xff, 0xff, 0x00, //@@@@@@@@@@@@@%%%%%%%%%%%+..
0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0x7f, 0xff, 0xff, 0xc0, //+@@@@@@@@@@@@@@@@@@@@@@@@@.
0x3f, 0xff, 0xff, 0x80, //.+@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f093 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x04, 0x00, 0x00, //.............%.............
0x00, 0x0e, 0x00, 0x00, //............@@@............
0x00, 0x1f, 0x00, 0x00, //...........@@@@@...........
0x00, 0x3f, 0x80, 0x00, //..........@@@@@@@..........
0x00, 0x7f, 0xc0, 0x00, //.........@@@@@@@@@.........
0x00, 0xff, 0xe0, 0x00, //........@@@@@@@@@@@........
0x01, 0xff, 0xf0, 0x00, //.......@@@@@@@@@@@@@.......
0x03, 0xff, 0xf8, 0x00, //......@@@@@@@@@@@@@@@......
0x07, 0xff, 0xfc, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x03, 0xff, 0xf8, 0x00, //......%%%%@@@@@@@%%%%......
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x3f, 0x80, 0x00, //..........%@@@@@%..........
0x00, 0x1f, 0x00, 0x00, //..........+@@@@@...........
0xff, 0x80, 0x3f, 0xe0, //%@@@@@@@@.........@@@@@@@@%
0xff, 0xc0, 0x7f, 0xe0, //@@@@@@@@@@+.....+@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xe6, 0x60, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xe6, 0x60, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f095 () , Width: 23 */
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x18, 0x00, 0x00, //...%%+.................
0x3c, 0x00, 0x00, //.+@@@@.................
0x7e, 0x00, 0x00, //.@@@@@%................
0xfe, 0x00, 0x00, //+@@@@@@................
0xff, 0x00, 0x00, //@@@@@@@%...............
0xff, 0x00, 0x00, //@@@@@@@@...............
0xff, 0x00, 0x00, //@@@@@@@%...............
0xfe, 0x00, 0x00, //%@@@@@%................
0x7c, 0x00, 0x00, //+@@@@%.................
0x7c, 0x00, 0x00, //.@@@@+.................
0x7c, 0x00, 0x00, //.%@@@@.................
0x3e, 0x00, 0x00, //..@@@@%................
0x3e, 0x00, 0x00, //..%@@@@+...............
0x1f, 0x00, 0x00, //...@@@@@...............
0x0f, 0x80, 0x00, //...+@@@@@..............
0x07, 0xc0, 0xe0, //....+@@@@@+.....%@%....
0x07, 0xf1, 0xf8, //.....%@@@@@%...%@@@@%..
0x03, 0xff, 0xfc, //......%@@@@@@+%@@@@@@@+
0x00, 0xff, 0xfe, //.......+@@@@@@@@@@@@@@%
0x00, 0x7f, 0xfe, //........+@@@@@@@@@@@@@%
0x00, 0x3f, 0xfc, //..........%@@@@@@@@@@@.
0x00, 0x0f, 0xf8, //............%@@@@@@@@+.
0x00, 0x01, 0xf0, //..............+%@@@+...
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
/*Unicode: U+f0c4 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x0c, 0x00, 0x00, 0x00, //..++%++......................
0x7f, 0x80, 0x00, 0x00, //.@@@@@@@+....................
0xff, 0xc0, 0x00, 0x00, //@@@@@@@@@@...............+...
0xe1, 0xe0, 0x01, 0xf0, //@@@+..+%@@@............%@%@%.
0xe0, 0x70, 0x07, 0x10, //@@%.....+@@%.........%@%...@+
0xe0, 0x30, 0x0c, 0x30, //@@@......+@@.......+@%....%@.
0xf0, 0x30, 0x30, 0x60, //@@@%......@@.....+@%.....@%..
0x78, 0x70, 0xc0, 0x80, //+@@@@+...%@@....@@+....+@+...
0x3f, 0xfb, 0x03, 0x00, //.+@@@@@@@@@%@+%@+.....%@.....
0x1f, 0xee, 0x06, 0x00, //...%@@@@@@@.%@+......%%......
0x03, 0x38, 0x0c, 0x00, //.....+%%+.@@@.......@%.......
0x00, 0x1b, 0x10, 0x00, //...........%@.@@..+@+........
0x00, 0x1b, 0x78, 0x00, //..........+@%.%@.%@@%........
0x0f, 0xe0, 0xcc, 0x00, //....%@@@@%@+..+.%%..%@.......
0x3f, 0xef, 0x02, 0x00, //..%@@@@@@@@.%@@@+....+@+.....
0x7f, 0xf9, 0x81, 0x80, //.@@@@@%%%@@@%.+@@+.....@%....
0xf0, 0x30, 0x60, 0xc0, //%@@@+....+@@....+@@+....%@...
0xe0, 0x30, 0x18, 0x20, //@@@.......@@......+@%....+@+.
0xe0, 0x70, 0x06, 0x10, //@@%......@@%........+@%....@+
0xe0, 0xe0, 0x03, 0xb0, //@@@....+@@@...........%@%.%@.
0xff, 0xc0, 0x00, 0xc0, //@@@@%%@@@@+.............%@+..
0x7f, 0x80, 0x00, 0x00, //+@@@@@@@@+...................
0x3e, 0x00, 0x00, 0x00, //..%@@@%+.....................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c5 () , Width: 29 */
0x00, 0x7f, 0xc0, 0x00, //........+@@@@@@@@@+..........
0x01, 0xff, 0xe0, 0x00, //.......%@@@@@@@@@@@..........
0x03, 0xc0, 0x60, 0x00, //......%@@@.......@@..........
0x07, 0xc0, 0x60, 0x00, //.....%@@@@.......@@..........
0x0e, 0xc0, 0x60, 0x00, //....%@@.@@.......@@..........
0x1c, 0xc0, 0x60, 0x00, //...%@@..@@.......@@..........
0x38, 0xc0, 0x7f, 0xf0, //..%@@...@@.......@@%@@@@@@@@+
0x70, 0xc0, 0x7f, 0xf8, //.%@@....@@.......@@@@@@@@@@@@
0x7f, 0xc0, 0x78, 0x18, //+@@@@@@@@@.......@@@@......@@
0xff, 0xc0, 0xf8, 0x18, //@@@@@@@@@%......@@@@@......@@
0xc0, 0x01, 0xd8, 0x18, //@@.............@@@.@@......@@
0xc0, 0x03, 0x98, 0x18, //@@...........+@@@..@@......@@
0xc0, 0x07, 0x18, 0x18, //@@..........+@@@...@@......@@
0xc0, 0x0e, 0x18, 0x18, //@@.........+@@@....@@......@@
0xc0, 0x1c, 0x18, 0x18, //@@.........@@@+....@@......@@
0xc0, 0x3f, 0xf8, 0x18, //@@........%@@@@@@@@@@......@@
0xc0, 0x3f, 0xf0, 0x18, //@@........@@@@@@@@@@+......@@
0xc0, 0x30, 0x00, 0x18, //@@........@@+..............@@
0xc0, 0x30, 0x00, 0x18, //@@........@@+..............@@
0xc0, 0x30, 0x00, 0x18, //@@........@@+..............@@
0xc0, 0x30, 0x00, 0x18, //@@........@@+..............@@
0xff, 0xf0, 0x00, 0x18, //@@@@@@@@@@@@+..............@@
0xff, 0xf0, 0x00, 0x18, //%@@@@@@@@@@@+..............@@
0x00, 0x30, 0x00, 0x18, //..........@@+..............@@
0x00, 0x30, 0x00, 0x18, //..........@@+..............@@
0x00, 0x30, 0x00, 0x18, //..........@@+..............@@
0x00, 0x30, 0x00, 0x18, //..........@@+..............@@
0x00, 0x3f, 0xff, 0xf8, //..........@@@@@@@@@@@@@@@@@@@
0x00, 0x1f, 0xff, 0xf8, //..........+@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c7 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x7f, 0xff, 0xc0, 0x00, //+@@@@@@@@@@@@@@@@@+......
0xff, 0xff, 0xf0, 0x00, //@@@@@@@@@@@@@@@@@@@%.....
0xcf, 0xc1, 0xb8, 0x00, //@@..@@@@@@+....@@.@@%....
0xcf, 0xc1, 0x9c, 0x00, //@@..@@@@@@.....@@..@@%...
0xcf, 0xc1, 0x8e, 0x00, //@@..@@@@@@.....@@...@@%..
0xcf, 0xc1, 0x87, 0x00, //@@..@@@@@@.....@@....@@%.
0xcf, 0xc1, 0x83, 0x00, //@@..@@@@@@.....@@.....@@+
0xcf, 0xc1, 0x81, 0x80, //@@..@@@@@@.....@@.....+@@
0xcf, 0xc1, 0x81, 0x80, //@@..@@@@@@+....@@......@@
0xcf, 0xff, 0x81, 0x80, //@@..@@@@@@@@@@@@@......@@
0xc7, 0xff, 0x01, 0x80, //@@..+@@@@@@@@@@@+......@@
0xc0, 0x00, 0x01, 0x80, //@@.....................@@
0xc0, 0x00, 0x01, 0x80, //@@.....................@@
0xc0, 0x00, 0x01, 0x80, //@@.....................@@
0xc0, 0x00, 0x01, 0x80, //@@.....................@@
0xcf, 0xff, 0xf9, 0x80, //@@..%@@@@@@@@@@@@@@@%..@@
0xcf, 0xff, 0xf9, 0x80, //@@..@@@@@@@@@@@@@@@@@..@@
0xcc, 0x00, 0x19, 0x80, //@@..@@.............@@..@@
0xcc, 0x00, 0x19, 0x80, //@@..@@.............@@..@@
0xcc, 0x00, 0x19, 0x80, //@@..@@.............@@..@@
0xcc, 0x00, 0x19, 0x80, //@@..@@.............@@..@@
0xcc, 0x00, 0x19, 0x80, //@@..@@.............@@..@@
0xcc, 0x00, 0x19, 0x80, //@@..@@.............@@..@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f0e7 () , Width: 15 */
0x00, 0x00, //...............
0x00, 0x00, //...............
0x1f, 0xc0, //...%@@@@@@.....
0x1f, 0xc0, //...@@@@@@@.....
0x1f, 0x80, //...@@@@@@+.....
0x1f, 0x80, //..+@@@@@@......
0x3f, 0x80, //..%@@@@@%......
0x3f, 0x00, //..@@@@@@+......
0x3f, 0x00, //..@@@@@@.......
0x3f, 0x1c, //.+@@@@@%..+%@@+
0x7f, 0xfc, //.%@@@@@%@@@@@@.
0x7f, 0xfc, //.@@@@@@@@@@@@%.
0x7f, 0xf8, //.@@@@@@@@@@@@..
0x7f, 0xf8, //+@@@@@@@@@@@%..
0xff, 0xf0, //%@@@@@@@@@@@+..
0xfd, 0xf0, //@@@@@%+%@@@@...
0xc1, 0xe0, //%%+....@@@@+...
0x01, 0xe0, //.......@@@@....
0x01, 0xc0, //......+@@@+....
0x03, 0xc0, //......%@@@.....
0x03, 0x80, //......@@@+.....
0x03, 0x80, //......@@@......
0x03, 0x80, //.....+@@%......
0x07, 0x00, //.....%@@.......
0x07, 0x00, //.....@@%.......
0x06, 0x00, //.....@@........
0x06, 0x00, //....+@%........
0x0c, 0x00, //....%@.........
0x0c, 0x00, //....%%.........
0x00, 0x00, //...............
/*Unicode: U+f0f3 () , Width: 27 */
0x00, 0x04, 0x00, 0x00, //............+%+............
0x00, 0x0e, 0x00, 0x00, //............@@@............
0x00, 0x0e, 0x00, 0x00, //...........+@@@+...........
0x00, 0x7f, 0xc0, 0x00, //........+@@@@@@@@@.........
0x00, 0xff, 0xe0, 0x00, //.......+@@@@@@@@@@@+.......
0x01, 0xff, 0xf0, 0x00, //......+@@@@@@@@@@@@@+......
0x03, 0xff, 0xf8, 0x00, //......@@@@@@@@@@@@@@@......
0x03, 0xff, 0xf8, 0x00, //.....+@@@@@@@@@@@@@@@+.....
0x07, 0xff, 0xfc, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x07, 0xff, 0xfc, 0x00, //.....@@@@@@@@@@@@@@@@%.....
0x07, 0xff, 0xfc, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x07, 0xff, 0xfc, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x07, 0xff, 0xfc, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x07, 0xff, 0xfc, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x07, 0xff, 0xfc, 0x00, //....+@@@@@@@@@@@@@@@@@.....
0x0f, 0xff, 0xfc, 0x00, //....%@@@@@@@@@@@@@@@@@+....
0x0f, 0xff, 0xfe, 0x00, //....@@@@@@@@@@@@@@@@@@%....
0x0f, 0xff, 0xfe, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x1f, 0xff, 0xff, 0x00, //...%@@@@@@@@@@@@@@@@@@@%...
0x1f, 0xff, 0xff, 0x00, //...@@@@@@@@@@@@@@@@@@@@@...
0x3f, 0xff, 0xff, 0x80, //..@@@@@@@@@@@@@@@@@@@@@@%..
0x7f, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@%.
0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xc0, //.@@@@@@@@@@@@@@@@@@@@@@@@@.
0x00, 0x7f, 0xc0, 0x00, //.........%%%@@@@@%.........
0x00, 0x2f, 0x80, 0x00, //.........+@+@@@@@+.........
0x00, 0x37, 0x80, 0x00, //..........%@+%@@%..........
0x00, 0x1f, 0x00, 0x00, //...........%@@@%...........
0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f11c () , Width: 32 */
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x7f, 0xff, 0xff, 0xfc, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0xff, 0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xcc, 0xce, 0x66, 0x66, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xcc, 0xce, 0x66, 0x66, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xc0, 0x00, 0x00, 0x66, //@@.......................@@..@@.
0xc0, 0x00, 0x00, 0x66, //@@.......................@@..@@.
0xcf, 0x31, 0x99, 0xe6, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xcf, 0x31, 0x99, 0xe6, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xcc, 0xff, 0xfe, 0x66, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xcc, 0xff, 0xfe, 0x66, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xc0, 0x00, 0x00, 0x06, //@@...........................@@.
0xff, 0xff, 0xff, 0xfe, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x7f, 0xff, 0xff, 0xfc, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f124 () , Width: 23 */
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x04, //.....................%+
0x00, 0x00, 0x1e, //...................%@@%
0x00, 0x00, 0x7c, //.................%@@@@+
0x00, 0x01, 0xfc, //...............%@@@@@@.
0x00, 0x07, 0xf8, //.............%@@@@@@@+.
0x00, 0x1f, 0xf8, //...........%@@@@@@@@@..
0x00, 0x7f, 0xf0, //.........%@@@@@@@@@@+..
0x01, 0xff, 0xf0, //.......%@@@@@@@@@@@@...
0x07, 0xff, 0xe0, //.....%@@@@@@@@@@@@@+...
0x1f, 0xff, 0xe0, //...%@@@@@@@@@@@@@@@....
0x7f, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@+....
0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@.....
0x7f, 0xff, 0x80, //+%%%%%%%%%@@@@@@@+.....
0x00, 0x3f, 0x80, //..........%@@@@@@......
0x00, 0x3f, 0x00, //..........%@@@@@+......
0x00, 0x3f, 0x00, //..........%@@@@@.......
0x00, 0x3e, 0x00, //..........%@@@@+.......
0x00, 0x3e, 0x00, //..........%@@@@........
0x00, 0x3c, 0x00, //..........%@@@+........
0x00, 0x3c, 0x00, //..........%@@@.........
0x00, 0x38, 0x00, //..........%@@+.........
0x00, 0x38, 0x00, //..........%@@..........
0x00, 0x10, 0x00, //..........+@+..........
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, //.......................
/*Unicode: U+f15b () , Width: 25 */
0x7f, 0xfc, 0x00, 0x00, //+@@@@@@@@@@@@@+..........
0xff, 0xfc, 0x40, 0x00, //@@@@@@@@@@@@@@+.+%.......
0xff, 0xfc, 0x60, 0x00, //@@@@@@@@@@@@@@+.+@%......
0xff, 0xfc, 0x70, 0x00, //@@@@@@@@@@@@@@+.+@@%.....
0xff, 0xfc, 0x78, 0x00, //@@@@@@@@@@@@@@+.+@@@%....
0xff, 0xfc, 0x7c, 0x00, //@@@@@@@@@@@@@@+.+@@@@%...
0xff, 0xfc, 0x7e, 0x00, //@@@@@@@@@@@@@@+.+@@@@@%..
0xff, 0xfc, 0x7f, 0x00, //@@@@@@@@@@@@@@+.+@@@@@@%.
0xff, 0xfc, 0x00, 0x00, //@@@@@@@@@@@@@@+..+++++++.
0xff, 0xfe, 0x00, 0x00, //@@@@@@@@@@@@@@%..........
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@%%%%%%%%%
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0x00, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f1eb () , Width: 32 */
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x1f, 0xf0, 0x00, //..........+%%@@@@@@%+...........
0x00, 0xff, 0xff, 0x00, //.......+%@@@@@@@@@@@@@@%........
0x03, 0xff, 0xff, 0xc0, //.....+@@@@@@@@@@@@@@@@@@@%......
0x0f, 0xff, 0xff, 0xf0, //....%@@@@@@@@@@@@@@@@@@@@@@%....
0x1f, 0xf0, 0x1f, 0xf8, //..+@@@@@@@@%++....+%@@@@@@@@@...
0x7f, 0x80, 0x03, 0xfc, //.%@@@@@@@+............%@@@@@@@+.
0xfe, 0x00, 0x00, 0xfe, //%@@@@@@+................%@@@@@@+
0xfc, 0x1f, 0xf0, 0x3f, //@@@@@@.....%@@@@@@@%+.....@@@@@%
0x78, 0x7f, 0xfe, 0x1e, //.@@@%...+@@@@@@@@@@@@@@+...@@@%.
0x21, 0xff, 0xff, 0x8c, //..@+..+@@@@@@@@@@@@@@@@@@...%%..
0x03, 0xff, 0xff, 0xc0, //.....+@@@@@@@@@@@@@@@@@@@@+.....
0x07, 0xf8, 0x1f, 0xe0, //....+@@@@@@@%+....+%@@@@@@@.....
0x07, 0xc0, 0x03, 0xe0, //.....@@@@@...........+@@@@%.....
0x03, 0x0f, 0xe1, 0xc0, //......@@+...%@@@@@%+...%@%......
0x00, 0x3f, 0xfc, 0x00, //..........%@@@@@@@@@@+..........
0x00, 0x7f, 0xfe, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x7f, 0xfe, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x3c, 0x3c, 0x00, //..........@@@%....%@@%..........
0x00, 0x00, 0x00, 0x00, //...........+........+...........
0x00, 0x03, 0xc0, 0x00, //..............%@@%..............
0x00, 0x07, 0xc0, 0x00, //.............%@@@@+.............
0x00, 0x03, 0xc0, 0x00, //..............@@@%..............
0x00, 0x01, 0x80, 0x00, //...............%%...............
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f240 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@..+++++++++++++++++++++++++++..@@...
0xcf, 0xff, 0xff, 0xfe, 0x60, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@+..
0xcf, 0xff, 0xff, 0xfe, 0x78, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xcf, 0xff, 0xff, 0xfe, 0x78, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xcf, 0xff, 0xff, 0xfe, 0x70, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@+.
0xcf, 0xff, 0xff, 0xfe, 0x60, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f241 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@..+++++++++++++++++++++........@@...
0xcf, 0xff, 0xff, 0x80, 0x60, //@@..@@@@@@@@@@@@@@@@@@@@%........@@+..
0xcf, 0xff, 0xff, 0x80, 0x78, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x18, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xcf, 0xff, 0xff, 0x80, 0x78, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xcf, 0xff, 0xff, 0x80, 0x70, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@+.
0xcf, 0xff, 0xff, 0x80, 0x60, //@@..@@@@@@@@@@@@@@@@@@@@%........@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f242 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@..++++++++++++++...............@@...
0xcf, 0xff, 0xc0, 0x00, 0x60, //@@..@@@@@@@@@@@@@@+..............@@+..
0xcf, 0xff, 0xc0, 0x00, 0x78, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x18, //@@..@@@@@@@@@@@@@@+................@@.
0xcf, 0xff, 0xc0, 0x00, 0x78, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xcf, 0xff, 0xc0, 0x00, 0x70, //@@..@@@@@@@@@@@@@@+..............@@@+.
0xcf, 0xff, 0xc0, 0x00, 0x60, //@@..@@@@@@@@@@@@@@+..............@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f243 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@..++++++++.....................@@...
0xcf, 0xf0, 0x00, 0x00, 0x60, //@@..@@@@@@@@+....................@@+..
0xcf, 0xf0, 0x00, 0x00, 0x78, //@@..@@@@@@@@+....................@@@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x18, //@@..@@@@@@@@+......................@@.
0xcf, 0xf0, 0x00, 0x00, 0x78, //@@..@@@@@@@@+....................@@@@.
0xcf, 0xf0, 0x00, 0x00, 0x70, //@@..@@@@@@@@+....................@@@+.
0xcf, 0xf0, 0x00, 0x00, 0x60, //@@..@@@@@@@@+....................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f244 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@+..
0xc0, 0x00, 0x00, 0x00, 0x78, //@@...............................@@@%.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x18, //@@.................................@@.
0xc0, 0x00, 0x00, 0x00, 0x78, //@@...............................@@@@.
0xc0, 0x00, 0x00, 0x00, 0x70, //@@...............................@@@+.
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xc0, 0x00, 0x00, 0x00, 0x60, //@@...............................@@...
0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x7f, 0xff, 0xff, 0xff, 0xc0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f293 () , Width: 22 */
0x01, 0xfe, 0x00, //......+%@@@@@%%.......
0x07, 0xff, 0x80, //....+@@@@@@@@@@@%.....
0x1f, 0xff, 0xc0, //...%@@@@@@%@@@@@@@....
0x1f, 0xdf, 0xe0, //..+@@@@@@%.%@@@@@@@...
0x3f, 0xcf, 0xf0, //..@@@@@@@%..%@@@@@@%..
0x7f, 0xc7, 0xf0, //.%@@@@@@@%...%@@@@@@..
0x7f, 0xc3, 0xf0, //.@@@@@@@@%....%@@@@@+.
0x7f, 0xc1, 0xf8, //.@@@@@@@@%..+..%@@@@%.
0x7b, 0xc8, 0xf8, //+@@@@.%@@%..@+..%@@@@.
0xf1, 0xcc, 0x78, //%@@@+..%@%..@@...@@@@.
0xf8, 0xc8, 0xf8, //%@@@@+..%%..@+..%@@@@+
0xfc, 0x01, 0xf8, //@@@@@@+..+..+..%@@@@@+
0xfe, 0x03, 0xf8, //@@@@@@@+......%@@@@@@+
0xff, 0x07, 0xf8, //@@@@@@@@+....%@@@@@@@+
0xff, 0x87, 0xfc, //@@@@@@@@@...+@@@@@@@@%
0xff, 0x07, 0xf8, //@@@@@@@@+....%@@@@@@@+
0xfe, 0x03, 0xf8, //@@@@@@@+......%@@@@@@+
0xfc, 0x01, 0xf8, //@@@@@@+..+..+..%@@@@@+
0xf8, 0xc8, 0xf8, //%@@@@+..%%..@+..%@@@@+
0xf1, 0xcc, 0x78, //%@@@+..%@%..@@...@@@@.
0x7b, 0xc8, 0xf8, //+@@@@.%@@%..@+..%@@@@.
0x7f, 0xc1, 0xf8, //.@@@@@@@@%..+..%@@@@%.
0x7f, 0xc3, 0xf0, //.@@@@@@@@%....%@@@@@+.
0x7f, 0xc7, 0xf0, //.%@@@@@@@%...%@@@@@@..
0x3f, 0xcf, 0xf0, //..@@@@@@@%..%@@@@@@%..
0x1f, 0xdf, 0xe0, //..+@@@@@@%.%@@@@@@@...
0x1f, 0xff, 0xc0, //...%@@@@@@%@@@@@@@....
0x07, 0xff, 0x80, //....+@@@@@@@@@@@%.....
0x01, 0xfe, 0x00, //......+%@@@@@%%.......
0x00, 0x00, 0x00, //......................
#elif USE_LV_FONT_SYMBOL_30 == 2
/*Unicode: U+f001 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x40, //.....................+%%+
0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xc0, //..................+%@@@@@
0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xc0, //...............+@@@@@@@@@
0x00, 0x00, 0x01, 0xbf, 0xff, 0xff, 0xc0, //...........+%@@@@@@@@@@@@
0x00, 0x00, 0x2f, 0xff, 0xff, 0xff, 0xc0, //.........%@@@@@@@@@@@@@@@
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0xff, 0xff, 0xfe, 0x43, 0xc0, //........@@@@@@@@@@@%+..@@
0x00, 0x00, 0xff, 0xff, 0x90, 0x03, 0xc0, //........@@@@@@@@%+.....@@
0x00, 0x00, 0xff, 0xe0, 0x00, 0x03, 0xc0, //........@@@@@%.........@@
0x00, 0x00, 0xf4, 0x00, 0x00, 0x03, 0xc0, //........@@+............@@
0x00, 0x00, 0xf0, 0x00, 0x00, 0x03, 0xc0, //........@@.............@@
0x00, 0x00, 0xf0, 0x00, 0x00, 0x03, 0xc0, //........@@.............@@
0x00, 0x00, 0xf0, 0x00, 0x00, 0x03, 0xc0, //........@@.............@@
0x00, 0x00, 0xf0, 0x00, 0x00, 0x03, 0xc0, //........@@.............@@
0x00, 0x00, 0xf0, 0x00, 0x7f, 0xff, 0xc0, //........@@......+@@@@@%@@
0x00, 0x00, 0xf0, 0x03, 0xff, 0xff, 0xc0, //........@@.....@@@@@@@@@@
0x00, 0x00, 0xf0, 0x07, 0xff, 0xff, 0xc0, //........@@....+@@@@@@@@@@
0x00, 0x00, 0xf0, 0x03, 0xff, 0xff, 0xc0, //........@@.....@@@@@@@@@@
0x1b, 0xfe, 0xf0, 0x02, 0xff, 0xff, 0x40, //.+%@@@@%@@.....%@@@@@@@@+
0xbf, 0xff, 0xf0, 0x00, 0x2f, 0xf4, 0x00, //%@@@@@@@@@.......%@@@@+..
0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@...............
0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@...............
0xbf, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@+...............
0x1b, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, //.+%@@@@%.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f008 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xf4, 0x1f, 0x40, 0x00, 0x00, 0x07, 0xd0, 0x7c, //@@+..+@@+.............+@@+..+@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf4, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@+...@@...............@@....@@.
0xff, 0xff, 0x00, 0x00, 0x00, 0x03, 0xff, 0xfc, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0x00, 0x00, 0x00, 0x03, 0xff, 0xfc, //@@@@@@@@...............@@@@@@@@.
0xf4, 0x1f, 0x00, 0x00, 0x00, 0x03, 0xd0, 0x7c, //@@+..+@@...............@@+..+@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf4, 0x1f, 0x40, 0x00, 0x00, 0x07, 0xd0, 0x7c, //@@+..+@@+.............+@@+..+@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xf4, 0x0f, 0x40, 0x00, 0x00, 0x07, 0xc0, 0x3c, //@@+...@@+.............+@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf4, 0x1f, 0x00, 0x00, 0x00, 0x03, 0xd0, 0x7c, //@@+..+@@...............@@+..+@@.
0xff, 0xff, 0x00, 0x00, 0x00, 0x03, 0xff, 0xfc, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0x00, 0x00, 0x00, 0x03, 0xff, 0xfc, //@@@@@@@@...............@@@@@@@@.
0xf4, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@+...@@...............@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf0, 0x0f, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x3c, //@@....@@...............@@....@@.
0xf4, 0x0f, 0x40, 0x00, 0x00, 0x07, 0xc0, 0x3c, //@@+...@@+.............+@@....@@.
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f00b () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x7f, 0xfe, 0x03, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0xbf, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7f, 0xfe, 0x03, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0xbf, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7f, 0xfe, 0x03, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f00c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, //.....................+...
0x00, 0x00, 0x00, 0x00, 0x01, 0xfc, 0x00, //...................+@@@..
0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0x00, //..................+@@@@@.
0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xc0, //.................+@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xc0, //................+@@@@@@@@
0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0x40, //...............+@@@@@@@@+
0x02, 0x40, 0x00, 0x07, 0xff, 0xfd, 0x00, //...%+.........+@@@@@@@@+.
0x0f, 0xd0, 0x00, 0x1f, 0xff, 0xf4, 0x00, //..@@@+.......+@@@@@@@@+..
0x3f, 0xf4, 0x00, 0x7f, 0xff, 0xd0, 0x00, //.@@@@@+.....+@@@@@@@@+...
0xff, 0xfd, 0x01, 0xff, 0xff, 0x40, 0x00, //@@@@@@@+...+@@@@@@@@+....
0xff, 0xff, 0x47, 0xff, 0xfd, 0x00, 0x00, //@@@@@@@@+.+@@@@@@@@+.....
0x7f, 0xff, 0xef, 0xff, 0xf4, 0x00, 0x00, //+@@@@@@@@%@@@@@@@@+......
0x1f, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x00, //.+@@@@@@@@@@@@@@@+.......
0x07, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, //..+@@@@@@@@@@@@@+........
0x01, 0xff, 0xff, 0xfd, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@+.........
0x00, 0x7f, 0xff, 0xf4, 0x00, 0x00, 0x00, //....+@@@@@@@@@+..........
0x00, 0x1f, 0xff, 0xd0, 0x00, 0x00, 0x00, //.....+@@@@@@@+...........
0x00, 0x07, 0xff, 0x40, 0x00, 0x00, 0x00, //......+@@@@@+............
0x00, 0x01, 0xfd, 0x00, 0x00, 0x00, 0x00, //.......+@@@+.............
0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, //........+%+..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f00d () , Width: 20 */
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x02, 0xe0, 0x00, 0x02, 0xd0, //...%@%.........%@+..
0x0b, 0xf8, 0x00, 0x0f, 0xf4, //..%@@@%.......@@@@+.
0x2f, 0xfe, 0x00, 0x3f, 0xfd, //.%@@@@@%.....@@@@@@+
0x3f, 0xff, 0x80, 0xff, 0xff, //.@@@@@@@%...@@@@@@@@
0x3f, 0xff, 0xe3, 0xff, 0xff, //.@@@@@@@@%.@@@@@@@@%
0x0f, 0xff, 0xff, 0xff, 0xfc, //..@@@@@@@@@@@@@@@@@.
0x03, 0xff, 0xff, 0xff, 0xf0, //...@@@@@@@@@@@@@@@..
0x00, 0xff, 0xff, 0xff, 0xc0, //....@@@@@@@@@@@@@...
0x00, 0x3f, 0xff, 0xff, 0x00, //.....@@@@@@@@@@@....
0x00, 0x1f, 0xff, 0xfc, 0x00, //.....+@@@@@@@@@.....
0x00, 0x3f, 0xff, 0xfe, 0x00, //.....@@@@@@@@@@%....
0x00, 0xff, 0xff, 0xff, 0x80, //....@@@@@@@@@@@@%...
0x03, 0xff, 0xff, 0xff, 0xe0, //...@@@@@@@@@@@@@@%..
0x0f, 0xff, 0xff, 0xff, 0xf8, //..@@@@@@@@@@@@@@@@%.
0x3f, 0xff, 0xf7, 0xff, 0xfe, //.@@@@@@@@@+@@@@@@@@%
0x3f, 0xff, 0xc0, 0xff, 0xff, //.@@@@@@@@...@@@@@@@@
0x3f, 0xff, 0x00, 0x3f, 0xfe, //.@@@@@@@.....@@@@@@%
0x0f, 0xfc, 0x00, 0x0f, 0xf8, //..@@@@@.......@@@@%.
0x03, 0xf0, 0x00, 0x03, 0xe0, //...@@@.........@@%..
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, //....................
/*Unicode: U+f011 () , Width: 25 */
0x00, 0x00, 0x03, 0xd0, 0x00, 0x00, 0x00, //...........@@+...........
0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x28, 0x0f, 0xf0, 0x28, 0x00, 0x00, //.....%%...@@@@...%%......
0x00, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0x00, //....@@@@..@@@@..@@@@.....
0x03, 0xff, 0x0f, 0xf0, 0xff, 0xc0, 0x00, //...@@@@@..@@@@..@@@@@....
0x0b, 0xff, 0x0f, 0xf0, 0xbf, 0xf0, 0x00, //..%@@@@@..@@@@..%@@@@@...
0x1f, 0xfc, 0x0f, 0xf0, 0x3f, 0xf4, 0x00, //.+@@@@@...@@@@...@@@@@+..
0x3f, 0xf0, 0x0f, 0xf0, 0x0f, 0xfc, 0x00, //.@@@@@....@@@@....@@@@@..
0x7f, 0xd0, 0x0f, 0xf0, 0x03, 0xfd, 0x00, //+@@@@+....@@@@.....@@@@+.
0xbf, 0xc0, 0x0f, 0xf0, 0x02, 0xfe, 0x00, //%@@@@.....@@@@.....%@@@%.
0xff, 0x40, 0x0f, 0xf0, 0x01, 0xff, 0x00, //@@@@+.....@@@@.....+@@@@.
0xff, 0x40, 0x0b, 0xf0, 0x00, 0xff, 0x00, //@@@@+.....%@@@......@@@@.
0xff, 0x00, 0x01, 0x40, 0x00, 0xff, 0x00, //@@@@.......++.......@@@@.
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, //@@@@................@@@@.
0xff, 0x40, 0x00, 0x00, 0x00, 0xff, 0x00, //@@@@+...............@@@@.
0xbf, 0x80, 0x00, 0x00, 0x02, 0xff, 0x00, //%@@@%..............%@@@@.
0x7f, 0xc0, 0x00, 0x00, 0x03, 0xfd, 0x00, //+@@@@..............@@@@+.
0x3f, 0xe0, 0x00, 0x00, 0x0b, 0xfc, 0x00, //.@@@@%............%@@@@..
0x2f, 0xf4, 0x00, 0x00, 0x1f, 0xf8, 0x00, //.+@@@@+..........+@@@@%..
0x0f, 0xfe, 0x00, 0x00, 0xbf, 0xf0, 0x00, //..@@@@@%........%@@@@@...
0x03, 0xff, 0xe4, 0x0b, 0xff, 0xd0, 0x00, //...@@@@@@%+...%@@@@@@+...
0x01, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, //...+@@@@@@@@@@@@@@@@+....
0x00, 0x7f, 0xff, 0xff, 0xfd, 0x00, 0x00, //....+@@@@@@@@@@@@@@+.....
0x00, 0x0b, 0xff, 0xff, 0xe0, 0x00, 0x00, //......%@@@@@@@@@@%.......
0x00, 0x00, 0x7f, 0xfd, 0x00, 0x00, 0x00, //........+@@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f013 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x20, 0x1f, 0xfc, 0x02, 0x00, 0x00, //.....%...+@@@@@....%.....
0x01, 0xfd, 0x2f, 0xfe, 0x1f, 0xc0, 0x00, //...+@@@+.%@@@@@%.+@@@....
0x03, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x0b, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x03, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x01, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0xff, 0xfd, 0x5f, 0xff, 0xc0, 0x00, //....@@@@@@@+++@@@@@@@....
0x06, 0xff, 0xe0, 0x02, 0xff, 0xe0, 0x00, //...%@@@@@%.....%@@@@@%...
0xff, 0xff, 0xc0, 0x00, 0xff, 0xff, 0xc0, //@@@@@@@@@.......@@@@@@@@@
0xff, 0xff, 0x40, 0x00, 0x7f, 0xff, 0xc0, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0x40, 0x00, 0x7f, 0xff, 0xc0, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0x40, 0x00, 0x7f, 0xff, 0xc0, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0xc0, 0x00, 0xff, 0xff, 0xc0, //@@@@@@@@@.......@@@@@@@@@
0x02, 0xff, 0xe0, 0x02, 0xff, 0xe4, 0x00, //...%@@@@@%.....%@@@@@%+..
0x00, 0xff, 0xf9, 0x1b, 0xff, 0xc0, 0x00, //....@@@@@@%+.+%@@@@@@....
0x01, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x03, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x0b, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x03, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x01, 0xfd, 0x2f, 0xfe, 0x1f, 0xd0, 0x00, //...+@@@+.%@@@@@%.+@@@+...
0x00, 0x34, 0x0f, 0xfd, 0x07, 0x40, 0x00, //.....@....@@@@@+..+@+....
0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f014 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x02, 0xff, 0xfd, 0x00, 0x00, //.......%@@@@@@@+.......
0x00, 0x07, 0xff, 0xff, 0x00, 0x00, //......+@@@@@@@@@.......
0x00, 0x0f, 0x40, 0x0b, 0x80, 0x00, //......@@+.....%@%......
0x00, 0x1f, 0x00, 0x03, 0xc0, 0x00, //.....+@@.......@@......
0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@%
0x0f, 0x00, 0x00, 0x00, 0x07, 0x80, //..@@..............+@%..
0x0f, 0x00, 0x00, 0x00, 0x07, 0x80, //..@@..............+@%..
0x0f, 0x00, 0x00, 0x00, 0x07, 0x80, //..@@..............+@%..
0x0f, 0x01, 0x01, 0x01, 0x07, 0x80, //..@@...+...+...+..+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0f, 0x4b, 0x47, 0x87, 0x80, //..@@..@@+.%@+.+@%.+@%..
0x0f, 0x0b, 0x0b, 0x47, 0x47, 0x80, //..@@..%@..%@+.+@+.+@%..
0x0f, 0x00, 0x00, 0x00, 0x07, 0x80, //..@@..............+@%..
0x0f, 0x00, 0x00, 0x00, 0x07, 0x80, //..@@..............+@%..
0x0f, 0x40, 0x00, 0x00, 0x0b, 0x80, //..@@+.............%@%..
0x07, 0xff, 0xff, 0xff, 0xff, 0x00, //..+@@@@@@@@@@@@@@@@@...
0x02, 0xff, 0xff, 0xff, 0xfd, 0x00, //...%@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f015 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x64, 0x02, 0xa8, 0x00, //............+%+....%%%%....
0x00, 0x00, 0x02, 0xfe, 0x03, 0xfc, 0x00, //...........%@@@%...@@@@....
0x00, 0x00, 0x0f, 0xff, 0xc3, 0xfc, 0x00, //..........@@@@@@@..@@@@....
0x00, 0x00, 0x3f, 0xcf, 0xf7, 0xfc, 0x00, //.........@@@@.@@@@+@@@@....
0x00, 0x01, 0xfe, 0x12, 0xff, 0xfc, 0x00, //.......+@@@%.+.%@@@@@@@....
0x00, 0x0b, 0xf8, 0xb8, 0x7f, 0xfc, 0x00, //......%@@@+.%@%.+@@@@@@....
0x00, 0x2f, 0xd3, 0xff, 0x1f, 0xfc, 0x00, //.....%@@@+.@@@@@.+@@@@@....
0x00, 0xff, 0x1f, 0xff, 0xd3, 0xfc, 0x00, //....@@@@.+@@@@@@@+.@@@@....
0x03, 0xfc, 0xbf, 0xff, 0xf8, 0xbf, 0x40, //...@@@@.%@@@@@@@@@%.%@@@+..
0x1f, 0xe2, 0xff, 0xff, 0xfe, 0x2f, 0xe0, //.+@@@%.%@@@@@@@@@@@%.%@@@%.
0x7f, 0x8f, 0xff, 0xff, 0xff, 0xc7, 0xf8, //+@@@+.@@@@@@@@@@@@@@@.+@@@%
0x3d, 0x7f, 0xff, 0xff, 0xff, 0xf4, 0xf4, //.@@++@@@@@@@@@@@@@@@@@+.@@+
0x00, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x10, //....@@@@@@@@@@@@@@@@@@@..+.
0x00, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0xff, 0xfc, 0x00, 0xff, 0xfc, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0xff, 0xfc, 0x00, 0xff, 0xfc, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0xff, 0xfc, 0x00, 0xff, 0xfc, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0xff, 0xfc, 0x00, 0xff, 0xfc, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0xff, 0xfc, 0x00, 0xff, 0xfc, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0xbf, 0xfc, 0x00, 0xff, 0xf8, 0x00, //....%@@@@@@.....@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f019 () , Width: 27 */
0x00, 0x00, 0x02, 0xaa, 0x00, 0x00, 0x00, //...........%%%%%...........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x05, 0x5f, 0xff, 0xd5, 0x40, 0x00, //......++++@@@@@@%++++......
0x00, 0x2f, 0xff, 0xff, 0xff, 0xe0, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 0x00, //.....+@@@@@@@@@@@@@@@......
0x00, 0x07, 0xff, 0xff, 0xff, 0x40, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0x01, 0xff, 0xff, 0xfd, 0x00, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x00, 0x7f, 0xff, 0xf4, 0x00, 0x00, //........+@@@@@@@@@.........
0x00, 0x00, 0x1f, 0xff, 0xd0, 0x00, 0x00, //.........+@@@@@@@..........
0x00, 0x00, 0x07, 0xff, 0x00, 0x00, 0x00, //..........+@@@@@...........
0x00, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x00, //...........+@@@............
0xbf, 0xff, 0xe0, 0x70, 0x3f, 0xff, 0xf8, //%@@@@@@@@%..+@...%@@@@@@@@%
0xff, 0xff, 0xf8, 0x00, 0xff, 0xff, 0xfc, //@@@@@@@@@@%.....@@@@@@@@@@@
0xff, 0xff, 0xff, 0x47, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@+.+@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xfc, 0x7c, 0x7c, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xfc, 0x7d, 0x7c, //@@@@@@@@@@@@@@@@@@@.+@@++@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f01c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x7f, 0xff, 0xff, 0xff, 0x40, 0x00, //....+@@@@@@@@@@@@@@@.....
0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //....@@@@@@@@@@@@@@@@@....
0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //...+@@@@@@@@@@@@@@@@@....
0x03, 0xf8, 0x00, 0x00, 0x0b, 0xe0, 0x00, //...@@@%...........%@@%...
0x03, 0xf0, 0x00, 0x00, 0x07, 0xf0, 0x00, //...@@@............+@@@...
0x0b, 0xe0, 0x00, 0x00, 0x03, 0xf8, 0x00, //..%@@%.............@@@%..
0x0f, 0xd0, 0x00, 0x00, 0x01, 0xfc, 0x00, //..@@@+.............+@@@..
0x2f, 0xc0, 0x00, 0x00, 0x00, 0xfd, 0x00, //.%@@@...............@@@+.
0x3f, 0x40, 0x00, 0x00, 0x00, 0xbf, 0x00, //.@@@+...............%@@@.
0x7f, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, //+@@@.................@@@.
0xbe, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x80, //%@@%.................@@@%
0xfe, 0x55, 0x00, 0x00, 0x15, 0x6f, 0xc0, //@@@%++++.........++++%@@@
0xff, 0xff, 0x80, 0x00, 0xff, 0xff, 0xc0, //@@@@@@@@%.......@@@@@@@@@
0xff, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xc0, //@@@@@@@@@......+@@@@@@@@@
0xff, 0xff, 0xe0, 0x03, 0xff, 0xff, 0xc0, //@@@@@@@@@%.....@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f021 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x6f, 0xfe, 0x40, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x0b, 0xff, 0xff, 0xf4, 0x03, 0x80, //......%@@@@@@@@@@@+....@%
0x00, 0x3f, 0xff, 0xff, 0xff, 0x0f, 0xc0, //.....@@@@@@@@@@@@@@@..@@@
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //....@@@@@@@@@@@@@@@@@@@@@
0x03, 0xff, 0xe4, 0x06, 0xff, 0xff, 0xc0, //...@@@@@@%+...+%@@@@@@@@@
0x0f, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xc0, //..@@@@@@.........%@@@@@@@
0x1f, 0xf8, 0x00, 0x00, 0x0f, 0xff, 0xc0, //.+@@@@%...........@@@@@@@
0x3f, 0xf0, 0x00, 0x00, 0x3f, 0xff, 0xc0, //.@@@@@...........@@@@@@@@
0x7f, 0xc0, 0x00, 0x00, 0xff, 0xff, 0xc0, //+@@@@...........@@@@@@@@@
0xbf, 0x80, 0x00, 0x00, 0xff, 0xff, 0xc0, //%@@@%...........@@@@@@@@@
0x15, 0x00, 0x00, 0x00, 0x15, 0x55, 0x00, //.+++.............+++++++.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x15, 0x55, 0x40, 0x00, 0x00, 0x15, 0x00, //.++++++++............+++.
0xff, 0xff, 0xd0, 0x00, 0x00, 0xff, 0x40, //@@@@@@@@@+..........@@@@+
0xff, 0xff, 0xc0, 0x00, 0x00, 0xff, 0x00, //@@@@@@@@@...........@@@@.
0xff, 0xff, 0x00, 0x00, 0x03, 0xff, 0x00, //@@@@@@@@...........@@@@@.
0xff, 0xfc, 0x00, 0x00, 0x0b, 0xfd, 0x00, //@@@@@@@...........%@@@@+.
0xff, 0xff, 0x00, 0x00, 0x3f, 0xf8, 0x00, //@@@@@@@@.........@@@@@%..
0xff, 0xff, 0xe4, 0x06, 0xff, 0xf0, 0x00, //@@@@@@@@@%+...+%@@@@@@...
0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //@@@@@@@@@@@@@@@@@@@@@....
0xfc, 0x3f, 0xff, 0xff, 0xff, 0x00, 0x00, //@@@..@@@@@@@@@@@@@@@.....
0xf0, 0x0b, 0xff, 0xff, 0xf4, 0x00, 0x00, //@@....%@@@@@@@@@@@+......
0x00, 0x00, 0x6f, 0xfe, 0x40, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f026 () , Width: 13 */
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x07, 0x00, //..........+@.
0x00, 0x00, 0x2f, 0x40, //.........%@@+
0x00, 0x00, 0xbf, 0x40, //........%@@@+
0x00, 0x02, 0xff, 0x40, //.......%@@@@+
0x00, 0x0b, 0xff, 0x40, //......%@@@@@+
0x15, 0x6f, 0xff, 0x40, //.++++%@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0x40, //@@@@@@@@@@@@+
0xbf, 0xff, 0xff, 0x40, //%@@@@@@@@@@@+
0x00, 0x1f, 0xff, 0x40, //......@@@@@@+
0x00, 0x07, 0xff, 0x40, //.......@@@@@+
0x00, 0x01, 0xff, 0x40, //........@@@@+
0x00, 0x00, 0x3f, 0x40, //.........@@@+
0x00, 0x00, 0x0f, 0x40, //..........@@+
0x00, 0x00, 0x02, 0x00, //...........%.
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, //.............
/*Unicode: U+f027 () , Width: 19 */
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x07, 0x00, 0x00, //..........+@.......
0x00, 0x00, 0x2f, 0x40, 0x00, //.........%@@+......
0x00, 0x00, 0xbf, 0x40, 0x00, //........%@@@+......
0x00, 0x02, 0xff, 0x40, 0x00, //.......%@@@@+......
0x00, 0x0b, 0xff, 0x40, 0x00, //......%@@@@@+......
0x15, 0x6f, 0xff, 0x40, 0x00, //.++++%@@@@@@+......
0xff, 0xff, 0xff, 0x43, 0xd0, //@@@@@@@@@@@@+..@@+.
0xff, 0xff, 0xff, 0x43, 0xf0, //@@@@@@@@@@@@+..@@@.
0xff, 0xff, 0xff, 0x40, 0xb8, //@@@@@@@@@@@@+...%@%
0xff, 0xff, 0xff, 0x40, 0x3c, //@@@@@@@@@@@@+....@@
0xff, 0xff, 0xff, 0x40, 0x3c, //@@@@@@@@@@@@+....@@
0xff, 0xff, 0xff, 0x40, 0xf8, //@@@@@@@@@@@@+...@@%
0xff, 0xff, 0xff, 0x43, 0xf0, //@@@@@@@@@@@@+..@@@.
0xbf, 0xff, 0xff, 0x42, 0x80, //%@@@@@@@@@@@+..%%..
0x00, 0x1f, 0xff, 0x40, 0x00, //......@@@@@@+......
0x00, 0x07, 0xff, 0x40, 0x00, //.......@@@@@+......
0x00, 0x01, 0xff, 0x40, 0x00, //........@@@@+......
0x00, 0x00, 0x3f, 0x40, 0x00, //.........@@@+......
0x00, 0x00, 0x0f, 0x40, 0x00, //..........@@+......
0x00, 0x00, 0x02, 0x00, 0x00, //...........%.......
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, //...................
/*Unicode: U+f028 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x07, 0x40, 0x00, //..................+@+......
0x00, 0x00, 0x01, 0x00, 0x07, 0xf0, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x0f, 0x40, 0x01, 0xfd, 0x00, //..........@@+......+@@@....
0x00, 0x00, 0x3f, 0x40, 0x00, 0x2f, 0x00, //.........@@@+........%@@...
0x00, 0x00, 0xff, 0x40, 0x3d, 0x0b, 0xc0, //........@@@@+....@@+..%@@..
0x00, 0x03, 0xff, 0x40, 0x3f, 0x43, 0xd0, //.......@@@@@+....@@@+..@@+.
0x00, 0x0f, 0xff, 0x40, 0x0b, 0xd1, 0xf0, //......@@@@@@+.....%@@+.+@@.
0x6a, 0xbf, 0xff, 0x41, 0x02, 0xf0, 0xf4, //+%%%%@@@@@@@+......%@@..@@+
0xff, 0xff, 0xff, 0x43, 0xe0, 0xf4, 0xb8, //@@@@@@@@@@@@+..@@%..@@+.%@%
0xff, 0xff, 0xff, 0x42, 0xf4, 0x78, 0x7c, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xff, 0xff, 0x40, 0x7c, 0x3c, 0x3c, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xff, 0xff, 0x40, 0x3c, 0x3c, 0x3c, //@@@@@@@@@@@@+....@@..@@..@@
0xff, 0xff, 0xff, 0x40, 0x7c, 0x3c, 0x3c, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xff, 0xff, 0x42, 0xf4, 0x78, 0x7c, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xff, 0xff, 0x43, 0xe0, 0xf4, 0xb8, //@@@@@@@@@@@@+..@@%..@@+.+@%
0x6a, 0xbf, 0xff, 0x41, 0x02, 0xf0, 0xf4, //+%%%%@@@@@@@+..+...%@@..@@+
0x00, 0x0f, 0xff, 0x40, 0x0b, 0xd1, 0xf0, //......@@@@@@+.....%@@+.+@@.
0x00, 0x03, 0xff, 0x40, 0x3f, 0x43, 0xd0, //.......@@@@@+....@@@+..@@+.
0x00, 0x00, 0xff, 0x40, 0x3d, 0x0b, 0xc0, //........@@@@+....@@+..%@@..
0x00, 0x00, 0x3f, 0x40, 0x00, 0x2f, 0x00, //.........@@@+........%@@...
0x00, 0x00, 0x0f, 0x40, 0x01, 0xfd, 0x00, //..........@@+......+@@@+...
0x00, 0x00, 0x01, 0x00, 0x07, 0xf0, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x00, 0x00, 0x07, 0x80, 0x00, //..................+@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f03e () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...+@@%....................@@.
0xf0, 0x7f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@..+@@@@%...................@@.
0xf0, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@..@@@@@@...................@@.
0xf0, 0xff, 0xf0, 0x00, 0x02, 0xc0, 0x00, 0x3c, //@@..@@@@@@.........%@........@@.
0xf0, 0xbf, 0xf0, 0x00, 0x0b, 0xf0, 0x00, 0x3c, //@@..%@@@@@........%@@@.......@@.
0xf0, 0x2f, 0xc0, 0x00, 0x3f, 0xfc, 0x00, 0x3c, //@@...%@@@........%@@@@@......@@.
0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x3c, //@@..............@@@@@@@@.....@@.
0xf0, 0x00, 0x00, 0x03, 0xff, 0xff, 0xc0, 0x3c, //@@.............@@@@@@@@@@....@@.
0xf0, 0x00, 0x10, 0x0f, 0xff, 0xff, 0xf0, 0x3c, //@@.......+....@@@@@@@@@@@@...@@.
0xf0, 0x00, 0xf4, 0x3f, 0xff, 0xff, 0xfc, 0x3c, //@@......@@+..@@@@@@@@@@@@@@..@@.
0xf0, 0x03, 0xfd, 0xff, 0xff, 0xff, 0xfc, 0x3c, //@@.....@@@@+@@@@@@@@@@@@@@@..@@.
0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3c, //@@....@@@@@@@@@@@@@@@@@@@@@..@@.
0xf0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3c, //@@...@@@@@@@@@@@@@@@@@@@@@@..@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3c, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3c, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3c, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xf0, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa8, 0x3c, //@@..%%%%%%%%%%%%%%%%%%%%%%+..@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f040 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, //..................+......
0x00, 0x00, 0x00, 0x00, 0x3f, 0x40, 0x00, //.................@@@+....
0x00, 0x00, 0x00, 0x00, 0xff, 0xd0, 0x00, //................@@@@@+...
0x00, 0x00, 0x00, 0x03, 0xff, 0xf4, 0x00, //...............@@@@@@@+..
0x00, 0x00, 0x00, 0x03, 0xff, 0xfd, 0x00, //...............@@@@@@@@+.
0x00, 0x00, 0x00, 0x30, 0xff, 0xff, 0x40, //.............@..@@@@@@@@.
0x00, 0x00, 0x00, 0xfc, 0x3f, 0xff, 0x40, //............@@@..@@@@@@@+
0x00, 0x00, 0x03, 0xff, 0x0f, 0xff, 0x00, //...........@@@@@..@@@@@@.
0x00, 0x00, 0x0f, 0xcf, 0xc3, 0xfd, 0x00, //..........@@@.@@@..@@@@+.
0x00, 0x00, 0x3f, 0x3f, 0xf0, 0xf4, 0x00, //.........@@@.@@@@@..@@+..
0x00, 0x00, 0xfc, 0xff, 0xfc, 0x00, 0x00, //........@@@.@@@@@@@......
0x00, 0x03, 0xf3, 0xff, 0xff, 0x00, 0x00, //.......@@@.@@@@@@@@@.....
0x00, 0x0f, 0xcf, 0xff, 0xfd, 0x00, 0x00, //......@@@.@@@@@@@@@+.....
0x00, 0x3f, 0x3f, 0xff, 0xf4, 0x00, 0x00, //.....@@@.@@@@@@@@@+......
0x00, 0xfc, 0xff, 0xff, 0xd0, 0x00, 0x00, //....@@@.@@@@@@@@@+.......
0x03, 0xf3, 0xff, 0xff, 0x40, 0x00, 0x00, //...@@@.@@@@@@@@@+........
0x0f, 0xcf, 0xff, 0xfd, 0x00, 0x00, 0x00, //..@@@.@@@@@@@@@+.........
0x3f, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, //.@@@@@@@@@@@@@+..........
0xf8, 0xbf, 0xff, 0xd0, 0x00, 0x00, 0x00, //@@%.%@@@@@@@@+...........
0xf0, 0x2f, 0xff, 0x40, 0x00, 0x00, 0x00, //@@...%@@@@@@+............
0xf0, 0x0b, 0xfd, 0x00, 0x00, 0x00, 0x00, //@@....%@@@@+.............
0xff, 0x03, 0xf4, 0x00, 0x00, 0x00, 0x00, //@@@@...@@@+..............
0xff, 0x0b, 0xd0, 0x00, 0x00, 0x00, 0x00, //@@@@..%@@+...............
0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@+................
0xff, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f048 () , Width: 17 */
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0xbe, 0x00, 0x00, 0x01, 0x40, //%@@%...........++
0xff, 0x00, 0x00, 0x07, 0x80, //@@@@..........+@%
0xff, 0x00, 0x00, 0x1f, 0x80, //@@@@.........+@@%
0xff, 0x00, 0x00, 0x7f, 0x80, //@@@@........+@@@%
0xff, 0x00, 0x01, 0xff, 0x80, //@@@@.......+@@@@%
0xff, 0x00, 0x07, 0xff, 0x80, //@@@@......+@@@@@%
0xff, 0x00, 0x1f, 0xff, 0x80, //@@@@.....+@@@@@@%
0xff, 0x00, 0x7f, 0xff, 0x80, //@@@@....+@@@@@@@%
0xff, 0x01, 0xff, 0xff, 0x80, //@@@@...+@@@@@@@@%
0xff, 0x07, 0xff, 0xff, 0x80, //@@@@..+@@@@@@@@@%
0xff, 0x1f, 0xff, 0xff, 0x80, //@@@@.+@@@@@@@@@@%
0xff, 0x7f, 0xff, 0xff, 0x80, //@@@@+@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@%
0xff, 0xbf, 0xff, 0xff, 0x80, //@@@@%@@@@@@@@@@@%
0xff, 0x1f, 0xff, 0xff, 0x80, //@@@@.+@@@@@@@@@@%
0xff, 0x07, 0xff, 0xff, 0x80, //@@@@..+@@@@@@@@@%
0xff, 0x01, 0xff, 0xff, 0x80, //@@@@...+@@@@@@@@%
0xff, 0x00, 0x7f, 0xff, 0x80, //@@@@....+@@@@@@@%
0xff, 0x00, 0x1f, 0xff, 0x80, //@@@@.....+@@@@@@%
0xff, 0x00, 0x07, 0xff, 0x80, //@@@@......+@@@@@%
0xff, 0x00, 0x01, 0xff, 0x80, //@@@@.......+@@@@%
0xff, 0x00, 0x00, 0x7f, 0x80, //@@@@........+@@@%
0xff, 0x00, 0x00, 0x1f, 0x80, //@@@@.........+@@%
0xff, 0x00, 0x00, 0x07, 0x80, //@@@@..........+@%
0xbf, 0x00, 0x00, 0x01, 0x80, //%@@@...........+%
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, //.................
/*Unicode: U+f04b () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, //@+.....................
0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@+...................
0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, //@@@@@..................
0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, //@@@@@@%................
0xff, 0xff, 0x80, 0x00, 0x00, 0x00, //@@@@@@@@%..............
0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, //@@@@@@@@@@+............
0xff, 0xff, 0xff, 0x40, 0x00, 0x00, //@@@@@@@@@@@@+..........
0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //@@@@@@@@@@@@@@.........
0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, //@@@@@@@@@@@@@@@%.......
0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //@@@@@@@@@@@@@@@@@%.....
0xff, 0xff, 0xff, 0xff, 0xfd, 0x00, //@@@@@@@@@@@@@@@@@@@+...
0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@%.
0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, //@@@@@@@@@@@@@@@@@@@%...
0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, //@@@@@@@@@@@@@@@@@@+....
0xff, 0xff, 0xff, 0xff, 0x40, 0x00, //@@@@@@@@@@@@@@@@+......
0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, //@@@@@@@@@@@@@@%........
0xff, 0xff, 0xff, 0x80, 0x00, 0x00, //@@@@@@@@@@@@%..........
0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, //@@@@@@@@@@%............
0xff, 0xff, 0xd0, 0x00, 0x00, 0x00, //@@@@@@@@@+.............
0xff, 0xfd, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+...............
0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, //@@@@@%.................
0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@%...................
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, //@@.....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f04c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0xbf, 0xff, 0xf0, 0x03, 0xff, 0xff, 0x80, //%@@@@@@@@@.....@@@@@@@@@%
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xf4, 0x07, 0xff, 0xff, 0xc0, //@@@@@@@@@@+...+@@@@@@@@@@
0xbf, 0xff, 0xf0, 0x03, 0xff, 0xff, 0x80, //%@@@@@@@@@.....@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f04d () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, //%@@@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f051 () , Width: 17 */
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x40, 0x00, 0x00, 0xbe, 0x00, //+...........%@@%.
0xd0, 0x00, 0x00, 0xff, 0x00, //@+..........@@@@.
0xf4, 0x00, 0x00, 0xff, 0x00, //@@+.........@@@@.
0xfd, 0x00, 0x00, 0xff, 0x00, //@@@+........@@@@.
0xff, 0x40, 0x00, 0xff, 0x00, //@@@@+.......@@@@.
0xff, 0xd0, 0x00, 0xff, 0x00, //@@@@@+......@@@@.
0xff, 0xf4, 0x00, 0xff, 0x00, //@@@@@@+.....@@@@.
0xff, 0xfd, 0x00, 0xff, 0x00, //@@@@@@@+....@@@@.
0xff, 0xff, 0x40, 0xff, 0x00, //@@@@@@@@+...@@@@.
0xff, 0xff, 0xd0, 0xff, 0x00, //@@@@@@@@@+..@@@@.
0xff, 0xff, 0xf4, 0xff, 0x00, //@@@@@@@@@@+.@@@@.
0xff, 0xff, 0xfd, 0xff, 0x00, //@@@@@@@@@@@+@@@@.
0xff, 0xff, 0xff, 0xff, 0x00, //@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xfe, 0xff, 0x00, //@@@@@@@@@@@%@@@@.
0xff, 0xff, 0xf8, 0xff, 0x00, //@@@@@@@@@@%.@@@@.
0xff, 0xff, 0xe0, 0xff, 0x00, //@@@@@@@@@%..@@@@.
0xff, 0xff, 0x80, 0xff, 0x00, //@@@@@@@@%...@@@@.
0xff, 0xfe, 0x00, 0xff, 0x00, //@@@@@@@%....@@@@.
0xff, 0xf8, 0x00, 0xff, 0x00, //@@@@@@%.....@@@@.
0xff, 0xe0, 0x00, 0xff, 0x00, //@@@@@%......@@@@.
0xff, 0x80, 0x00, 0xff, 0x00, //@@@@%.......@@@@.
0xfe, 0x00, 0x00, 0xff, 0x00, //@@@%........@@@@.
0xf8, 0x00, 0x00, 0xff, 0x00, //@@%.........@@@@.
0xe0, 0x00, 0x00, 0xff, 0x00, //@%..........@@@@.
0x80, 0x00, 0x00, 0xbf, 0x00, //%...........%@@@.
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, //.................
/*Unicode: U+f052 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x01, 0xd0, 0x00, 0x00, 0x00, //...........+@+...........
0x00, 0x00, 0x07, 0xf4, 0x00, 0x00, 0x00, //..........+@@@+..........
0x00, 0x00, 0x1f, 0xfd, 0x00, 0x00, 0x00, //.........+@@@@@+.........
0x00, 0x00, 0x7f, 0xff, 0x40, 0x00, 0x00, //........+@@@@@@@+........
0x00, 0x01, 0xff, 0xff, 0xd0, 0x00, 0x00, //.......+@@@@@@@@@+.......
0x00, 0x07, 0xff, 0xff, 0xf4, 0x00, 0x00, //......+@@@@@@@@@@@+......
0x00, 0x1f, 0xff, 0xff, 0xfd, 0x00, 0x00, //.....+@@@@@@@@@@@@@+.....
0x00, 0x7f, 0xff, 0xff, 0xff, 0x40, 0x00, //....+@@@@@@@@@@@@@@@+....
0x01, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x07, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, //..+@@@@@@@@@@@@@@@@@@@+..
0x1f, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x00, //.+@@@@@@@@@@@@@@@@@@@@@+.
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x6a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x40, //+%%%%%%%%%%%%%%%%%%%%%%%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f053 () , Width: 18 */
0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x78, 0x00, //............+@%...
0x00, 0x00, 0x01, 0xfe, 0x00, //...........+@@@%..
0x00, 0x00, 0x07, 0xff, 0x80, //..........+@@@@@%.
0x00, 0x00, 0x1f, 0xff, 0xc0, //.........+@@@@@@@.
0x00, 0x00, 0x7f, 0xff, 0xc0, //........+@@@@@@@@.
0x00, 0x01, 0xff, 0xff, 0x00, //.......+@@@@@@@@..
0x00, 0x07, 0xff, 0xfc, 0x00, //......+@@@@@@@@...
0x00, 0x1f, 0xff, 0xf0, 0x00, //.....+@@@@@@@@....
0x00, 0x7f, 0xff, 0xc0, 0x00, //....+@@@@@@@@.....
0x01, 0xff, 0xff, 0x00, 0x00, //...+@@@@@@@@......
0x07, 0xff, 0xfc, 0x00, 0x00, //..+@@@@@@@@.......
0x1f, 0xff, 0xf0, 0x00, 0x00, //.+@@@@@@@@........
0x7f, 0xff, 0xc0, 0x00, 0x00, //+@@@@@@@@.........
0x7f, 0xff, 0xc0, 0x00, 0x00, //+@@@@@@@@.........
0x1f, 0xff, 0xf0, 0x00, 0x00, //.+@@@@@@@@........
0x07, 0xff, 0xfc, 0x00, 0x00, //..+@@@@@@@@.......
0x01, 0xff, 0xff, 0x00, 0x00, //...+@@@@@@@@......
0x00, 0x7f, 0xff, 0xc0, 0x00, //....+@@@@@@@@.....
0x00, 0x1f, 0xff, 0xf0, 0x00, //.....+@@@@@@@@....
0x00, 0x07, 0xff, 0xfc, 0x00, //......+@@@@@@@@...
0x00, 0x01, 0xff, 0xff, 0x00, //.......+@@@@@@@@..
0x00, 0x00, 0x7f, 0xff, 0xc0, //........+@@@@@@@@.
0x00, 0x00, 0x1f, 0xff, 0xc0, //.........+@@@@@@@.
0x00, 0x00, 0x07, 0xff, 0x40, //..........+@@@@@+.
0x00, 0x00, 0x01, 0xfd, 0x00, //...........+@@@+..
0x00, 0x00, 0x00, 0x74, 0x00, //............+@+...
0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, //..................
/*Unicode: U+f054 () , Width: 18 */
0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x03, 0xc0, 0x00, 0x00, 0x00, //...@@.............
0x0f, 0xf0, 0x00, 0x00, 0x00, //..@@@@............
0x3f, 0xfc, 0x00, 0x00, 0x00, //.@@@@@@...........
0x7f, 0xff, 0x00, 0x00, 0x00, //+@@@@@@@..........
0x3f, 0xff, 0xc0, 0x00, 0x00, //.@@@@@@@@.........
0x0f, 0xff, 0xf0, 0x00, 0x00, //..@@@@@@@@........
0x03, 0xff, 0xfc, 0x00, 0x00, //...@@@@@@@@.......
0x00, 0xff, 0xff, 0x00, 0x00, //....@@@@@@@@......
0x00, 0x3f, 0xff, 0xc0, 0x00, //.....@@@@@@@@.....
0x00, 0x0f, 0xff, 0xf0, 0x00, //......@@@@@@@@....
0x00, 0x03, 0xff, 0xfc, 0x00, //.......@@@@@@@@...
0x00, 0x00, 0xff, 0xff, 0x00, //........@@@@@@@@..
0x00, 0x00, 0x3f, 0xff, 0xc0, //.........@@@@@@@@.
0x00, 0x00, 0x3f, 0xff, 0xc0, //.........@@@@@@@@.
0x00, 0x00, 0xff, 0xff, 0x00, //........@@@@@@@@..
0x00, 0x03, 0xff, 0xfc, 0x00, //.......@@@@@@@@...
0x00, 0x0f, 0xff, 0xf0, 0x00, //......@@@@@@@@....
0x00, 0x3f, 0xff, 0xc0, 0x00, //.....@@@@@@@@.....
0x00, 0xff, 0xff, 0x00, 0x00, //....@@@@@@@@......
0x03, 0xff, 0xfc, 0x00, 0x00, //...@@@@@@@@.......
0x0f, 0xff, 0xf0, 0x00, 0x00, //..@@@@@@@@........
0x3f, 0xff, 0xc0, 0x00, 0x00, //.@@@@@@@@.........
0x7f, 0xff, 0x00, 0x00, 0x00, //+@@@@@@@..........
0x2f, 0xfc, 0x00, 0x00, 0x00, //.%@@@@@...........
0x0b, 0xf0, 0x00, 0x00, 0x00, //..%@@@............
0x02, 0xc0, 0x00, 0x00, 0x00, //...%@.............
0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, //..................
/*Unicode: U+f067 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x2f, 0xe0, 0x00, 0x00, //.........%@@@%.........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x15, 0x55, 0xff, 0xf9, 0x55, 0x50, //.+++++++@@@@@@%+++++++.
0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@%
0x6a, 0xaa, 0xff, 0xfe, 0xaa, 0xa0, //+%%%%%%%@@@@@@@%%%%%%%.
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0xbf, 0xf4, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x7f, 0xf0, 0x00, 0x00, //........+@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f068 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0xbf, 0xff, 0xff, 0xff, 0xff, 0xf4, //%@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@%
0x7f, 0xff, 0xff, 0xff, 0xff, 0xf4, //+@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f071 () , Width: 29 */
0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x00, //.............%@%.............
0x00, 0x00, 0x00, 0xbf, 0x80, 0x00, 0x00, 0x00, //............%@@@%............
0x00, 0x00, 0x00, 0xff, 0xc0, 0x00, 0x00, 0x00, //............@@@@@............
0x00, 0x00, 0x02, 0xff, 0xe0, 0x00, 0x00, 0x00, //...........%@@@@@%...........
0x00, 0x00, 0x03, 0xff, 0xf0, 0x00, 0x00, 0x00, //...........@@@@@@@...........
0x00, 0x00, 0x0b, 0xff, 0xf8, 0x00, 0x00, 0x00, //..........%@@@@@@@%..........
0x00, 0x00, 0x0f, 0xff, 0xfc, 0x00, 0x00, 0x00, //..........@@@@@@@@@..........
0x00, 0x00, 0x3f, 0xff, 0xff, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@.........
0x00, 0x00, 0x7f, 0x55, 0x7f, 0x40, 0x00, 0x00, //........+@@@+++++@@@+........
0x00, 0x00, 0xff, 0x00, 0x3f, 0xc0, 0x00, 0x00, //........@@@@.....@@@@........
0x00, 0x01, 0xff, 0x00, 0x3f, 0xd0, 0x00, 0x00, //.......+@@@@.....@@@@+.......
0x00, 0x03, 0xff, 0x40, 0x7f, 0xf0, 0x00, 0x00, //.......@@@@@+...+@@@@@.......
0x00, 0x07, 0xff, 0x40, 0x7f, 0xf4, 0x00, 0x00, //......+@@@@@+...+@@@@@+......
0x00, 0x0f, 0xff, 0x40, 0x7f, 0xfc, 0x00, 0x00, //......@@@@@@+...+@@@@@@......
0x00, 0x2f, 0xff, 0x40, 0x7f, 0xfe, 0x00, 0x00, //.....%@@@@@@+...+@@@@@@%.....
0x00, 0x3f, 0xff, 0x40, 0x7f, 0xff, 0x00, 0x00, //.....@@@@@@@+...+@@@@@@@.....
0x00, 0xbf, 0xff, 0x80, 0xbf, 0xff, 0x80, 0x00, //....%@@@@@@@%...%@@@@@@@%....
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //....@@@@@@@@@@@@@@@@@@@@@....
0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //...%@@@@@@@@@@@@@@@@@@@@@%...
0x07, 0xff, 0xff, 0x40, 0x7f, 0xff, 0xf4, 0x00, //..+@@@@@@@@@+...+@@@@@@@@@+..
0x0f, 0xff, 0xff, 0x40, 0x7f, 0xff, 0xfc, 0x00, //..@@@@@@@@@@+...+@@@@@@@@@@..
0x1f, 0xff, 0xff, 0x40, 0x7f, 0xff, 0xfd, 0x00, //.+@@@@@@@@@@+...+@@@@@@@@@@+.
0x3f, 0xff, 0xff, 0x80, 0xbf, 0xff, 0xff, 0x00, //.@@@@@@@@@@@%...%@@@@@@@@@@@.
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f074 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x40, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xd0, 0x00, //.......................@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xf4, 0x00, //.......................@@@+..
0xaa, 0xa4, 0x00, 0x00, 0x6a, 0xaf, 0xfd, 0x00, //%%%%%%+.........+%%%%%@@@@@+.
0xff, 0xff, 0x40, 0x0b, 0xff, 0xff, 0xff, 0x40, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xff, 0xff, 0xe0, 0x2f, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@+...%@@@@@@@@@@@@@@@
0xff, 0xff, 0xf4, 0xbf, 0xff, 0xff, 0xff, 0x00, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0x55, 0x6f, 0xf5, 0xff, 0xe5, 0x5b, 0xfc, 0x00, //+++++%@@@@++@@@@@%++++%@@@@..
0x00, 0x07, 0xf3, 0xff, 0x00, 0x03, 0xf0, 0x00, //......+@@@.@@@@@.......@@@...
0x00, 0x01, 0xd7, 0xfc, 0x00, 0x03, 0xc0, 0x00, //.......+@++@@@@........@@....
0x00, 0x00, 0x8f, 0xf8, 0x00, 0x03, 0x00, 0x00, //........%.@@@@%........@.....
0x00, 0x00, 0x1f, 0xf0, 0x00, 0x00, 0x00, 0x00, //.........+@@@@...............
0x00, 0x00, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, //.........@@@@%...............
0x00, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0x00, 0x00, //........+@@@@................
0x00, 0x00, 0xff, 0xc8, 0x00, 0x03, 0x00, 0x00, //........@@@@@.%........@.....
0x00, 0x01, 0xff, 0x6c, 0x00, 0x03, 0xc0, 0x00, //.......+@@@@+%@........@@....
0x00, 0x07, 0xff, 0x3f, 0x00, 0x03, 0xf0, 0x00, //.......@@@@@.@@@.......@@@...
0x55, 0x6f, 0xfc, 0xbf, 0xe5, 0x5b, 0xfc, 0x00, //+++++%@@@@@.%@@@@%++++%@@@@..
0xff, 0xff, 0xf4, 0xbf, 0xff, 0xff, 0xff, 0x00, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@%...@@@@@@@@@@@@@@@@
0xff, 0xff, 0x40, 0x0b, 0xff, 0xff, 0xff, 0x40, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xbf, 0xa4, 0x00, 0x00, 0x6f, 0xff, 0xfd, 0x00, //%@@@%%+.........+%%@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xf4, 0x00, //.......................@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xd0, 0x00, //.......................@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x40, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f077 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, //............@@.............
0x00, 0x00, 0x03, 0xfc, 0x00, 0x00, 0x00, //...........@@@@............
0x00, 0x00, 0x0f, 0xff, 0x00, 0x00, 0x00, //..........@@@@@@...........
0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0x00, //.........@@@@@@@@..........
0x00, 0x00, 0xff, 0xff, 0xf0, 0x00, 0x00, //........@@@@@@@@@@.........
0x00, 0x03, 0xff, 0xff, 0xfc, 0x00, 0x00, //.......@@@@@@@@@@@@........
0x00, 0x0f, 0xff, 0xff, 0xff, 0x00, 0x00, //......@@@@@@@@@@@@@@.......
0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 0x00, //.....@@@@@@@@@@@@@@@@......
0x00, 0xff, 0xff, 0x4f, 0xff, 0xf0, 0x00, //....@@@@@@@@+.@@@@@@@@.....
0x03, 0xff, 0xfd, 0x03, 0xff, 0xfc, 0x00, //...@@@@@@@@+...@@@@@@@@....
0x0f, 0xff, 0xf4, 0x00, 0xff, 0xff, 0x00, //..@@@@@@@@+.....@@@@@@@@...
0x3f, 0xff, 0xd0, 0x00, 0x3f, 0xff, 0xc0, //.@@@@@@@@+.......@@@@@@@@..
0xff, 0xff, 0x40, 0x00, 0x1f, 0xff, 0xf0, //@@@@@@@@+.........@@@@@@@@.
0xff, 0xfd, 0x00, 0x00, 0x07, 0xff, 0xf0, //@@@@@@@+...........@@@@@@@.
0x3f, 0xf4, 0x00, 0x00, 0x01, 0xff, 0xc0, //.@@@@@+.............@@@@@..
0x0f, 0xd0, 0x00, 0x00, 0x00, 0x7f, 0x00, //..@@@+...............@@@...
0x02, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, //...%+.................%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f078 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x07, 0xc0, 0x00, 0x00, 0x00, 0x2e, 0x00, //..+@@................%@%...
0x1f, 0xf0, 0x00, 0x00, 0x00, 0xbf, 0x80, //.+@@@@..............%@@@%..
0x7f, 0xfc, 0x00, 0x00, 0x02, 0xff, 0xe0, //+@@@@@@............%@@@@@%.
0xff, 0xff, 0x00, 0x00, 0x0b, 0xff, 0xf0, //@@@@@@@@..........%@@@@@@@.
0x7f, 0xff, 0xc0, 0x00, 0x2f, 0xff, 0xd0, //+@@@@@@@@........%@@@@@@@+.
0x1f, 0xff, 0xf0, 0x00, 0xbf, 0xff, 0x40, //.+@@@@@@@@......%@@@@@@@+..
0x07, 0xff, 0xfc, 0x02, 0xff, 0xfd, 0x00, //..+@@@@@@@@....%@@@@@@@+...
0x01, 0xff, 0xff, 0x0b, 0xff, 0xf4, 0x00, //...+@@@@@@@@..%@@@@@@@+....
0x00, 0x7f, 0xff, 0xef, 0xff, 0xd0, 0x00, //....+@@@@@@@@%@@@@@@@+.....
0x00, 0x1f, 0xff, 0xff, 0xff, 0x40, 0x00, //.....+@@@@@@@@@@@@@@+......
0x00, 0x07, 0xff, 0xff, 0xfd, 0x00, 0x00, //......+@@@@@@@@@@@@+.......
0x00, 0x01, 0xff, 0xff, 0xf4, 0x00, 0x00, //.......+@@@@@@@@@@+........
0x00, 0x00, 0x7f, 0xff, 0xd0, 0x00, 0x00, //........+@@@@@@@@+.........
0x00, 0x00, 0x1f, 0xff, 0x40, 0x00, 0x00, //.........+@@@@@@+..........
0x00, 0x00, 0x07, 0xfd, 0x00, 0x00, 0x00, //..........+@@@@+...........
0x00, 0x00, 0x01, 0xf4, 0x00, 0x00, 0x00, //...........+@@+............
0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, //............++.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f079 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x2c, 0x0b, 0xff, 0xff, 0xff, 0xfc, 0x00, //.....%@...%@@@@@@@@@@@@@@@@.....
0x00, 0xbf, 0x03, 0xff, 0xff, 0xff, 0xfc, 0x00, //....%@@@...@@@@@@@@@@@@@@@@.....
0x01, 0xff, 0xc0, 0xff, 0xff, 0xff, 0xfc, 0x00, //...+@@@@@...@@@@@@@@@@@@@@@.....
0x03, 0xff, 0xe0, 0x7f, 0xff, 0xff, 0xfc, 0x00, //...@@@@@@%..+@@@@@@@@@@@@@@.....
0x0f, 0xff, 0xf4, 0x00, 0x00, 0x07, 0xfc, 0x00, //..@@@@@@@@+...........+@@@@.....
0x3f, 0xff, 0xfd, 0x00, 0x00, 0x03, 0xfc, 0x00, //.@@@@@@@@@@+...........@@@@.....
0xbf, 0xff, 0xff, 0x00, 0x00, 0x03, 0xfc, 0x00, //%@@@@@@@@@@@...........@@@@.....
0xff, 0xff, 0xff, 0x40, 0x00, 0x03, 0xfc, 0x00, //@@@@@@@@@@@@+..........@@@@.....
0x15, 0xff, 0x54, 0x00, 0x00, 0x03, 0xfc, 0x00, //.+++@@@@+++............@@@@.....
0x00, 0xff, 0x40, 0x00, 0x00, 0x03, 0xfc, 0x00, //....@@@@+..............@@@@.....
0x00, 0xff, 0x40, 0x00, 0x00, 0x57, 0xfd, 0x50, //....@@@@+...........+++@@@@+++..
0x00, 0xff, 0x40, 0x00, 0x07, 0xff, 0xff, 0xfc, //....@@@@+.........+@@@@@@@@@@@@.
0x00, 0xff, 0x40, 0x00, 0x03, 0xff, 0xff, 0xf8, //....@@@@+..........@@@@@@@@@@@%.
0x00, 0xff, 0x40, 0x00, 0x00, 0xff, 0xff, 0xf0, //....@@@@+...........@@@@@@@@@@..
0x00, 0xff, 0x40, 0x00, 0x00, 0x7f, 0xff, 0xc0, //....@@@@+...........+@@@@@@@@...
0x00, 0xff, 0xff, 0xff, 0xf4, 0x2f, 0xff, 0x40, //....@@@@@@@@@@@@@@+..%@@@@@@+...
0x00, 0xff, 0xff, 0xff, 0xfc, 0x0b, 0xfd, 0x00, //....@@@@@@@@@@@@@@@...%@@@@+....
0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0xf8, 0x00, //....@@@@@@@@@@@@@@@@...@@@%.....
0x00, 0xff, 0xff, 0xff, 0xff, 0x80, 0xe0, 0x00, //....@@@@@@@@@@@@@@@@%...@%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f07b () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x0b, 0xff, 0xe4, 0x00, 0x00, 0x00, 0x00, //..%@@@@@@%+................
0x3f, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@@@%...............
0xbf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@@@@...............
0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, //@@@@@@@@@@@@+..............
0xff, 0xff, 0xff, 0xea, 0xaa, 0xaa, 0x40, //@@@@@@@@@@@@@%%%%%%%%%%%+..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //+@@@@@@@@@@@@@@@@@@@@@@@@@.
0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //.+@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f093 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, //.............%.............
0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, //............@@@............
0x00, 0x00, 0x03, 0xff, 0x00, 0x00, 0x00, //...........@@@@@...........
0x00, 0x00, 0x0f, 0xff, 0xc0, 0x00, 0x00, //..........@@@@@@@..........
0x00, 0x00, 0x3f, 0xff, 0xf0, 0x00, 0x00, //.........@@@@@@@@@.........
0x00, 0x00, 0xff, 0xff, 0xfc, 0x00, 0x00, //........@@@@@@@@@@@........
0x00, 0x03, 0xff, 0xff, 0xff, 0x00, 0x00, //.......@@@@@@@@@@@@@.......
0x00, 0x0f, 0xff, 0xff, 0xff, 0xc0, 0x00, //......@@@@@@@@@@@@@@@......
0x00, 0x3f, 0xff, 0xff, 0xff, 0xe0, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x0a, 0xaf, 0xff, 0xea, 0x80, 0x00, //......%%%%@@@@@@@%%%%......
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x0b, 0xff, 0x80, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x07, 0xff, 0x40, 0x00, 0x00, //..........+@@@@@...........
0xbf, 0xff, 0xc0, 0x00, 0x0f, 0xff, 0xf8, //%@@@@@@@@.........@@@@@@@@%
0xff, 0xff, 0xf4, 0x00, 0x7f, 0xff, 0xfc, //@@@@@@@@@@+.....+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xfc, 0x7c, 0x7c, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xfc, 0x7c, 0x7c, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f095 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x02, 0x90, 0x00, 0x00, 0x00, 0x00, //...%%+.................
0x1f, 0xf0, 0x00, 0x00, 0x00, 0x00, //.+@@@@.................
0x3f, 0xf8, 0x00, 0x00, 0x00, 0x00, //.@@@@@%................
0xbf, 0xfc, 0x00, 0x00, 0x00, 0x00, //+@@@@@@................
0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, //@@@@@@@%...............
0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@...............
0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //@@@@@@@%...............
0xbf, 0xf8, 0x00, 0x00, 0x00, 0x00, //%@@@@@%................
0x7f, 0xe0, 0x00, 0x00, 0x00, 0x00, //+@@@@%.................
0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, //.@@@@+.................
0x2f, 0xf0, 0x00, 0x00, 0x00, 0x00, //.%@@@@.................
0x0f, 0xf8, 0x00, 0x00, 0x00, 0x00, //..@@@@%................
0x0b, 0xfd, 0x00, 0x00, 0x00, 0x00, //..%@@@@+...............
0x03, 0xff, 0x00, 0x00, 0x00, 0x00, //...@@@@@...............
0x01, 0xff, 0xc0, 0x00, 0x00, 0x00, //...+@@@@@..............
0x00, 0x7f, 0xf4, 0x00, 0xf8, 0x00, //....+@@@@@+.....%@%....
0x00, 0x2f, 0xfe, 0x02, 0xff, 0x80, //.....%@@@@@%...%@@@@%..
0x00, 0x0b, 0xff, 0xeb, 0xff, 0xf4, //......%@@@@@@+%@@@@@@@+
0x00, 0x01, 0xff, 0xff, 0xff, 0xf8, //.......+@@@@@@@@@@@@@@%
0x00, 0x00, 0x7f, 0xff, 0xff, 0xf8, //........+@@@@@@@@@@@@@%
0x00, 0x00, 0x0b, 0xff, 0xff, 0xf0, //..........%@@@@@@@@@@@.
0x00, 0x00, 0x00, 0xbf, 0xff, 0xd0, //............%@@@@@@@@+.
0x00, 0x00, 0x00, 0x06, 0xfe, 0x00, //..............+%@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f0c4 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x05, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..++%++......................
0x3f, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@+....................
0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x10, 0x00, //@@@@@@@@@@...............+...
0xfd, 0x06, 0xfc, 0x00, 0x00, 0x02, 0xee, 0x00, //@@@+..+%@@@............%@%@%.
0xf8, 0x00, 0x7e, 0x00, 0x00, 0x2e, 0x03, 0x40, //@@%.....+@@%.........%@%...@+
0xfc, 0x00, 0x1f, 0x00, 0x01, 0xe0, 0x0b, 0x00, //@@@......+@@.......+@%....%@.
0xfe, 0x00, 0x0f, 0x00, 0x1e, 0x00, 0x38, 0x00, //@@@%......@@.....+@%.....@%..
0x7f, 0xd0, 0x2f, 0x01, 0xf4, 0x01, 0xd0, 0x00, //+@@@@+...%@@....@@+....+@+...
0x1f, 0xff, 0xfe, 0xdb, 0x40, 0x0b, 0x00, 0x00, //.+@@@@@@@@@%@+%@+.....%@.....
0x02, 0xff, 0xfc, 0xb8, 0x00, 0x28, 0x00, 0x00, //...%@@@@@@@.%@+......%%......
0x00, 0x1a, 0x4f, 0xc0, 0x00, 0xe0, 0x00, 0x00, //.....+%%+.@@@.......@%.......
0x00, 0x00, 0x02, 0xcf, 0x07, 0x40, 0x00, 0x00, //...........%@.@@..+@+........
0x00, 0x00, 0x07, 0x8b, 0x2f, 0x80, 0x00, 0x00, //..........+@%.%@.%@@%........
0x00, 0xbf, 0xed, 0x04, 0xa0, 0xb0, 0x00, 0x00, //....%@@@@%@+..+.%%..%@.......
0x0b, 0xff, 0xfc, 0xbf, 0x40, 0x1d, 0x00, 0x00, //..%@@@@@@@@.%@@@+....+@+.....
0x3f, 0xfa, 0xbf, 0x87, 0xd0, 0x03, 0x80, 0x00, //.@@@@@%%%@@@%.+@@+.....@%....
0xbf, 0x40, 0x1f, 0x00, 0x7d, 0x00, 0xb0, 0x00, //%@@@+....+@@....+@@+....%@...
0xfd, 0x00, 0x0f, 0x00, 0x07, 0x80, 0x1d, 0x00, //@@@.......@@......+@%....+@+.
0xf8, 0x00, 0x3e, 0x00, 0x00, 0x78, 0x03, 0x40, //@@%......@@%........+@%....@+
0xfc, 0x01, 0xfc, 0x00, 0x00, 0x0b, 0x8b, 0x00, //@@@....+@@@...........%@%.%@.
0xff, 0xaf, 0xf4, 0x00, 0x00, 0x00, 0xb4, 0x00, //@@@@%%@@@@+.............%@+..
0x7f, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@+...................
0x0b, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@%+.....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c5 () , Width: 29 */
0x00, 0x00, 0x7f, 0xff, 0xf4, 0x00, 0x00, 0x00, //........+@@@@@@@@@+..........
0x00, 0x02, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, //.......%@@@@@@@@@@@..........
0x00, 0x0b, 0xf0, 0x00, 0x3c, 0x00, 0x00, 0x00, //......%@@@.......@@..........
0x00, 0x2f, 0xf0, 0x00, 0x3c, 0x00, 0x00, 0x00, //.....%@@@@.......@@..........
0x00, 0xbc, 0xf0, 0x00, 0x3c, 0x00, 0x00, 0x00, //....%@@.@@.......@@..........
0x02, 0xf0, 0xf0, 0x00, 0x3c, 0x00, 0x00, 0x00, //...%@@..@@.......@@..........
0x0b, 0xc0, 0xf0, 0x00, 0x3e, 0xff, 0xff, 0x40, //..%@@...@@.......@@%@@@@@@@@+
0x2f, 0x00, 0xf0, 0x00, 0x3f, 0xff, 0xff, 0xc0, //.%@@....@@.......@@@@@@@@@@@@
0x7f, 0xff, 0xf0, 0x00, 0x3f, 0xc0, 0x03, 0xc0, //+@@@@@@@@@.......@@@@......@@
0xff, 0xff, 0xe0, 0x00, 0xff, 0xc0, 0x03, 0xc0, //@@@@@@@@@%......@@@@@......@@
0xf0, 0x00, 0x00, 0x03, 0xf3, 0xc0, 0x03, 0xc0, //@@.............@@@.@@......@@
0xf0, 0x00, 0x00, 0x1f, 0xc3, 0xc0, 0x03, 0xc0, //@@...........+@@@..@@......@@
0xf0, 0x00, 0x00, 0x7f, 0x03, 0xc0, 0x03, 0xc0, //@@..........+@@@...@@......@@
0xf0, 0x00, 0x01, 0xfc, 0x03, 0xc0, 0x03, 0xc0, //@@.........+@@@....@@......@@
0xf0, 0x00, 0x03, 0xf4, 0x03, 0xc0, 0x03, 0xc0, //@@.........@@@+....@@......@@
0xf0, 0x00, 0x0b, 0xff, 0xff, 0xc0, 0x03, 0xc0, //@@........%@@@@@@@@@@......@@
0xf0, 0x00, 0x0f, 0xff, 0xff, 0x40, 0x03, 0xc0, //@@........@@@@@@@@@@+......@@
0xf0, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //@@........@@+..............@@
0xf0, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //@@........@@+..............@@
0xf0, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //@@........@@+..............@@
0xf0, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //@@........@@+..............@@
0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x03, 0xc0, //@@@@@@@@@@@@+..............@@
0xbf, 0xff, 0xff, 0x40, 0x00, 0x00, 0x03, 0xc0, //%@@@@@@@@@@@+..............@@
0x00, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //..........@@+..............@@
0x00, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //..........@@+..............@@
0x00, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //..........@@+..............@@
0x00, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x03, 0xc0, //..........@@+..............@@
0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, //..........@@@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0x80, //..........+@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c7 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x7f, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, //+@@@@@@@@@@@@@@@@@+......
0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@%.....
0xf0, 0xff, 0xf4, 0x03, 0xcf, 0x80, 0x00, //@@..@@@@@@+....@@.@@%....
0xf0, 0xff, 0xf0, 0x03, 0xc3, 0xe0, 0x00, //@@..@@@@@@.....@@..@@%...
0xf0, 0xff, 0xf0, 0x03, 0xc0, 0xf8, 0x00, //@@..@@@@@@.....@@...@@%..
0xf0, 0xff, 0xf0, 0x03, 0xc0, 0x3e, 0x00, //@@..@@@@@@.....@@....@@%.
0xf0, 0xff, 0xf0, 0x03, 0xc0, 0x0f, 0x40, //@@..@@@@@@.....@@.....@@+
0xf0, 0xff, 0xf0, 0x03, 0xc0, 0x07, 0xc0, //@@..@@@@@@.....@@.....+@@
0xf0, 0xff, 0xf4, 0x03, 0xc0, 0x03, 0xc0, //@@..@@@@@@+....@@......@@
0xf0, 0xff, 0xff, 0xff, 0xc0, 0x03, 0xc0, //@@..@@@@@@@@@@@@@......@@
0xf0, 0x7f, 0xff, 0xff, 0x40, 0x03, 0xc0, //@@..+@@@@@@@@@@@+......@@
0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.....................@@
0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.....................@@
0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.....................@@
0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.....................@@
0xf0, 0xbf, 0xff, 0xff, 0xff, 0x83, 0xc0, //@@..%@@@@@@@@@@@@@@@%..@@
0xf0, 0xff, 0xff, 0xff, 0xff, 0xc3, 0xc0, //@@..@@@@@@@@@@@@@@@@@..@@
0xf0, 0xf0, 0x00, 0x00, 0x03, 0xc3, 0xc0, //@@..@@.............@@..@@
0xf0, 0xf0, 0x00, 0x00, 0x03, 0xc3, 0xc0, //@@..@@.............@@..@@
0xf0, 0xf0, 0x00, 0x00, 0x03, 0xc3, 0xc0, //@@..@@.............@@..@@
0xf0, 0xf0, 0x00, 0x00, 0x03, 0xc3, 0xc0, //@@..@@.............@@..@@
0xf0, 0xf0, 0x00, 0x00, 0x03, 0xc3, 0xc0, //@@..@@.............@@..@@
0xf0, 0xf0, 0x00, 0x00, 0x03, 0xc3, 0xc0, //@@..@@.............@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f0e7 () , Width: 15 */
0x00, 0x00, 0x00, 0x00, //...............
0x00, 0x00, 0x00, 0x00, //...............
0x02, 0xff, 0xf0, 0x00, //...%@@@@@@.....
0x03, 0xff, 0xf0, 0x00, //...@@@@@@@.....
0x03, 0xff, 0xd0, 0x00, //...@@@@@@+.....
0x07, 0xff, 0xc0, 0x00, //..+@@@@@@......
0x0b, 0xff, 0x80, 0x00, //..%@@@@@%......
0x0f, 0xff, 0x40, 0x00, //..@@@@@@+......
0x0f, 0xff, 0x00, 0x00, //..@@@@@@.......
0x1f, 0xfe, 0x06, 0xf4, //.+@@@@@%..+%@@+
0x2f, 0xfe, 0xff, 0xf0, //.%@@@@@%@@@@@@.
0x3f, 0xff, 0xff, 0xe0, //.@@@@@@@@@@@@%.
0x3f, 0xff, 0xff, 0xc0, //.@@@@@@@@@@@@..
0x7f, 0xff, 0xff, 0x80, //+@@@@@@@@@@@%..
0xbf, 0xff, 0xff, 0x40, //%@@@@@@@@@@@+..
0xff, 0xe6, 0xff, 0x00, //@@@@@%+%@@@@...
0xa4, 0x03, 0xfd, 0x00, //%%+....@@@@+...
0x00, 0x03, 0xfc, 0x00, //.......@@@@....
0x00, 0x07, 0xf4, 0x00, //......+@@@+....
0x00, 0x0b, 0xf0, 0x00, //......%@@@.....
0x00, 0x0f, 0xd0, 0x00, //......@@@+.....
0x00, 0x0f, 0xc0, 0x00, //......@@@......
0x00, 0x1f, 0x80, 0x00, //.....+@@%......
0x00, 0x2f, 0x00, 0x00, //.....%@@.......
0x00, 0x3e, 0x00, 0x00, //.....@@%.......
0x00, 0x3c, 0x00, 0x00, //.....@@........
0x00, 0x78, 0x00, 0x00, //....+@%........
0x00, 0xb0, 0x00, 0x00, //....%@.........
0x00, 0xa0, 0x00, 0x00, //....%%.........
0x00, 0x00, 0x00, 0x00, //...............
/*Unicode: U+f0f3 () , Width: 27 */
0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, //............+%+............
0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, //............@@@............
0x00, 0x00, 0x01, 0xfd, 0x00, 0x00, 0x00, //...........+@@@+...........
0x00, 0x00, 0x7f, 0xff, 0xf0, 0x00, 0x00, //........+@@@@@@@@@.........
0x00, 0x01, 0xff, 0xff, 0xfd, 0x00, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x07, 0xff, 0xff, 0xff, 0x40, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0x0f, 0xff, 0xff, 0xff, 0xc0, 0x00, //......@@@@@@@@@@@@@@@......
0x00, 0x1f, 0xff, 0xff, 0xff, 0xd0, 0x00, //.....+@@@@@@@@@@@@@@@+.....
0x00, 0x2f, 0xff, 0xff, 0xff, 0xe0, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x3f, 0xff, 0xff, 0xff, 0xe0, 0x00, //.....@@@@@@@@@@@@@@@@%.....
0x00, 0x3f, 0xff, 0xff, 0xff, 0xf0, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x3f, 0xff, 0xff, 0xff, 0xf0, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x3f, 0xff, 0xff, 0xff, 0xf0, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x3f, 0xff, 0xff, 0xff, 0xf0, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x7f, 0xff, 0xff, 0xff, 0xf0, 0x00, //....+@@@@@@@@@@@@@@@@@.....
0x00, 0xbf, 0xff, 0xff, 0xff, 0xf4, 0x00, //....%@@@@@@@@@@@@@@@@@+....
0x00, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //....@@@@@@@@@@@@@@@@@@%....
0x00, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x02, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, //...%@@@@@@@@@@@@@@@@@@@%...
0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, //...@@@@@@@@@@@@@@@@@@@@@...
0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //..@@@@@@@@@@@@@@@@@@@@@@%..
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //.%@@@@@@@@@@@@@@@@@@@@@@@%.
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //.@@@@@@@@@@@@@@@@@@@@@@@@@.
0x00, 0x00, 0x2a, 0xff, 0xe0, 0x00, 0x00, //.........%%%@@@@@%.........
0x00, 0x00, 0x1d, 0xff, 0xd0, 0x00, 0x00, //.........+@+@@@@@+.........
0x00, 0x00, 0x0b, 0x6f, 0x80, 0x00, 0x00, //..........%@+%@@%..........
0x00, 0x00, 0x02, 0xfe, 0x00, 0x00, 0x00, //...........%@@@%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f11c () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0xf0, 0xf0, 0xfc, 0x3c, 0x3c, 0x3c, 0x3c, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xf0, 0xf0, 0xf0, 0xfc, 0x3c, 0x3c, 0x3c, 0x3c, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, //@@.......................@@..@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, //@@.......................@@..@@.
0xf0, 0xff, 0x0f, 0x03, 0xc3, 0xc3, 0xfc, 0x3c, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xf0, 0xff, 0x0f, 0x03, 0xc3, 0xc3, 0xfc, 0x3c, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0xf0, 0xff, 0xff, 0xff, 0xfc, 0x3c, 0x3c, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xf0, 0xf0, 0xff, 0xff, 0xff, 0xfc, 0x3c, 0x3c, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, //@@...........................@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f124 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x24, //.....................%+
0x00, 0x00, 0x00, 0x00, 0x02, 0xf8, //...................%@@%
0x00, 0x00, 0x00, 0x00, 0x2f, 0xf4, //.................%@@@@+
0x00, 0x00, 0x00, 0x02, 0xff, 0xf0, //...............%@@@@@@.
0x00, 0x00, 0x00, 0x2f, 0xff, 0xd0, //.............%@@@@@@@+.
0x00, 0x00, 0x02, 0xff, 0xff, 0xc0, //...........%@@@@@@@@@..
0x00, 0x00, 0x2f, 0xff, 0xff, 0x40, //.........%@@@@@@@@@@+..
0x00, 0x02, 0xff, 0xff, 0xff, 0x00, //.......%@@@@@@@@@@@@...
0x00, 0x2f, 0xff, 0xff, 0xfd, 0x00, //.....%@@@@@@@@@@@@@+...
0x02, 0xff, 0xff, 0xff, 0xfc, 0x00, //...%@@@@@@@@@@@@@@@....
0x2f, 0xff, 0xff, 0xff, 0xf4, 0x00, //.%@@@@@@@@@@@@@@@@+....
0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, //@@@@@@@@@@@@@@@@@@.....
0x6a, 0xaa, 0xaf, 0xff, 0xd0, 0x00, //+%%%%%%%%%@@@@@@@+.....
0x00, 0x00, 0x0b, 0xff, 0xc0, 0x00, //..........%@@@@@@......
0x00, 0x00, 0x0b, 0xff, 0x40, 0x00, //..........%@@@@@+......
0x00, 0x00, 0x0b, 0xff, 0x00, 0x00, //..........%@@@@@.......
0x00, 0x00, 0x0b, 0xfd, 0x00, 0x00, //..........%@@@@+.......
0x00, 0x00, 0x0b, 0xfc, 0x00, 0x00, //..........%@@@@........
0x00, 0x00, 0x0b, 0xf4, 0x00, 0x00, //..........%@@@+........
0x00, 0x00, 0x0b, 0xf0, 0x00, 0x00, //..........%@@@.........
0x00, 0x00, 0x0b, 0xd0, 0x00, 0x00, //..........%@@+.........
0x00, 0x00, 0x0b, 0xc0, 0x00, 0x00, //..........%@@..........
0x00, 0x00, 0x07, 0x40, 0x00, 0x00, //..........+@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f15b () , Width: 25 */
0x7f, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, //+@@@@@@@@@@@@@+..........
0xff, 0xff, 0xff, 0xf4, 0x60, 0x00, 0x00, //@@@@@@@@@@@@@@+.+%.......
0xff, 0xff, 0xff, 0xf4, 0x78, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@%......
0xff, 0xff, 0xff, 0xf4, 0x7e, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@%.....
0xff, 0xff, 0xff, 0xf4, 0x7f, 0x80, 0x00, //@@@@@@@@@@@@@@+.+@@@%....
0xff, 0xff, 0xff, 0xf4, 0x7f, 0xe0, 0x00, //@@@@@@@@@@@@@@+.+@@@@%...
0xff, 0xff, 0xff, 0xf4, 0x7f, 0xf8, 0x00, //@@@@@@@@@@@@@@+.+@@@@@%..
0xff, 0xff, 0xff, 0xf4, 0x7f, 0xfe, 0x00, //@@@@@@@@@@@@@@+.+@@@@@@%.
0xff, 0xff, 0xff, 0xf4, 0x15, 0x55, 0x00, //@@@@@@@@@@@@@@+..+++++++.
0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@%..........
0xff, 0xff, 0xff, 0xff, 0xaa, 0xaa, 0x80, //@@@@@@@@@@@@@@@@%%%%%%%%%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f1eb () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x06, 0xbf, 0xfe, 0x40, 0x00, 0x00, //..........+%%@@@@@@%+...........
0x00, 0x01, 0xbf, 0xff, 0xff, 0xfe, 0x00, 0x00, //.......+%@@@@@@@@@@@@@@%........
0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.....+@@@@@@@@@@@@@@@@@@@%......
0x00, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, //....%@@@@@@@@@@@@@@@@@@@@@@%....
0x07, 0xff, 0xfe, 0x50, 0x06, 0xff, 0xff, 0xc0, //..+@@@@@@@@%++....+%@@@@@@@@@...
0x2f, 0xff, 0xd0, 0x00, 0x00, 0x0b, 0xff, 0xf4, //.%@@@@@@@+............%@@@@@@@+.
0xbf, 0xfd, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xfd, //%@@@@@@+................%@@@@@@+
0xff, 0xf0, 0x02, 0xff, 0xfe, 0x40, 0x0f, 0xfe, //@@@@@@.....%@@@@@@@%+.....@@@@@%
0x3f, 0x80, 0x7f, 0xff, 0xff, 0xfd, 0x03, 0xf8, //.@@@%...+@@@@@@@@@@@@@@+...@@@%.
0x0d, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 0xa0, //..@+..+@@@@@@@@@@@@@@@@@@...%%..
0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, //.....+@@@@@@@@@@@@@@@@@@@@+.....
0x00, 0x7f, 0xff, 0x90, 0x06, 0xff, 0xfc, 0x00, //....+@@@@@@@%+....+%@@@@@@@.....
0x00, 0x3f, 0xf4, 0x00, 0x00, 0x1f, 0xf8, 0x00, //.....@@@@@...........+@@@@%.....
0x00, 0x0f, 0x40, 0xbf, 0xfd, 0x02, 0xe0, 0x00, //......@@+...%@@@@@%+...%@%......
0x00, 0x00, 0x0b, 0xff, 0xff, 0xe0, 0x00, 0x00, //..........%@@@@@@@@@@+..........
0x00, 0x00, 0x3f, 0xff, 0xff, 0xf8, 0x00, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x00, 0x3f, 0xff, 0xff, 0xf8, 0x00, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x00, 0x0f, 0xe0, 0x1b, 0xe0, 0x00, 0x00, //..........@@@%....%@@%..........
0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, //...........+........+...........
0x00, 0x00, 0x00, 0x0b, 0xe0, 0x00, 0x00, 0x00, //..............%@@%..............
0x00, 0x00, 0x00, 0x2f, 0xf4, 0x00, 0x00, 0x00, //.............%@@@@+.............
0x00, 0x00, 0x00, 0x0f, 0xe0, 0x00, 0x00, 0x00, //..............@@@%..............
0x00, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0x00, //...............%%...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f240 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x54, 0x3c, 0x00, //@@..+++++++++++++++++++++++++++..@@...
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3d, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@+..
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0x40, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@+.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3c, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f241 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x55, 0x55, 0x55, 0x55, 0x55, 0x40, 0x00, 0x3c, 0x00, //@@..+++++++++++++++++++++........@@...
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3d, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@+..
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3f, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3f, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3f, 0x40, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@+.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3c, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f242 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x55, 0x55, 0x55, 0x50, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@..++++++++++++++...............@@...
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x3d, 0x00, //@@..@@@@@@@@@@@@@@+..............@@+..
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x3f, 0xc0, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@@@@@@@+................@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x3f, 0xc0, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x3f, 0x40, //@@..@@@@@@@@@@@@@@+..............@@@+.
0xf0, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@..@@@@@@@@@@@@@@+..............@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f243 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x55, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@..++++++++.....................@@...
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, //@@..@@@@@@@@+....................@@+..
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, //@@..@@@@@@@@+....................@@@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@..@@@@@@@@+......................@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, //@@..@@@@@@@@+....................@@@@.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x40, //@@..@@@@@@@@+....................@@@+.
0xf0, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@..@@@@@@@@+....................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f244 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, //@@...............................@@+..
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x80, //@@...............................@@@%.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, //@@.................................@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, //@@...............................@@@@.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x40, //@@...............................@@@+.
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f293 () , Width: 22 */
0x00, 0x06, 0xff, 0xe8, 0x00, 0x00, //......+%@@@@@%%.......
0x00, 0x7f, 0xff, 0xff, 0x80, 0x00, //....+@@@@@@@@@@@%.....
0x02, 0xff, 0xfb, 0xff, 0xf0, 0x00, //...%@@@@@@%@@@@@@@....
0x07, 0xff, 0xe2, 0xff, 0xfc, 0x00, //..+@@@@@@%.%@@@@@@@...
0x0f, 0xff, 0xe0, 0xbf, 0xfe, 0x00, //..@@@@@@@%..%@@@@@@%..
0x2f, 0xff, 0xe0, 0x2f, 0xff, 0x00, //.%@@@@@@@%...%@@@@@@..
0x3f, 0xff, 0xe0, 0x0b, 0xff, 0x40, //.@@@@@@@@%....%@@@@@+.
0x3f, 0xff, 0xe0, 0x42, 0xff, 0x80, //.@@@@@@@@%..+..%@@@@%.
0x7f, 0xcb, 0xe0, 0xd0, 0xbf, 0xc0, //+@@@@.%@@%..@+..%@@@@.
0xbf, 0x42, 0xe0, 0xf0, 0x3f, 0xc0, //%@@@+..%@%..@@...@@@@.
0xff, 0xd0, 0xa0, 0xd0, 0xbf, 0xd0, //%@@@@+..%%..@+..%@@@@+
0xff, 0xf4, 0x10, 0x42, 0xff, 0xd0, //@@@@@@+..+..+..%@@@@@+
0xff, 0xfd, 0x00, 0x0b, 0xff, 0xd0, //@@@@@@@+......%@@@@@@+
0xff, 0xff, 0x40, 0x2f, 0xff, 0xd0, //@@@@@@@@+....%@@@@@@@+
0xff, 0xff, 0xc0, 0x7f, 0xff, 0xe0, //@@@@@@@@@...+@@@@@@@@%
0xff, 0xff, 0x40, 0x2f, 0xff, 0xd0, //@@@@@@@@+....%@@@@@@@+
0xff, 0xfd, 0x00, 0x0b, 0xff, 0xd0, //@@@@@@@+......%@@@@@@+
0xff, 0xf4, 0x10, 0x42, 0xff, 0xd0, //@@@@@@+..+..+..%@@@@@+
0xff, 0xd0, 0xa0, 0xd0, 0xbf, 0xd0, //%@@@@+..%%..@+..%@@@@+
0xbf, 0x42, 0xe0, 0xf0, 0x3f, 0xc0, //%@@@+..%@%..@@...@@@@.
0x7f, 0xcb, 0xe0, 0xd0, 0xbf, 0xc0, //+@@@@.%@@%..@+..%@@@@.
0x3f, 0xff, 0xe0, 0x42, 0xff, 0x80, //.@@@@@@@@%..+..%@@@@%.
0x3f, 0xff, 0xe0, 0x0b, 0xff, 0x40, //.@@@@@@@@%....%@@@@@+.
0x2f, 0xff, 0xe0, 0x2f, 0xff, 0x00, //.%@@@@@@@%...%@@@@@@..
0x0f, 0xff, 0xe0, 0xbf, 0xfe, 0x00, //..@@@@@@@%..%@@@@@@%..
0x07, 0xff, 0xe2, 0xff, 0xfc, 0x00, //..+@@@@@@%.%@@@@@@@...
0x02, 0xff, 0xfb, 0xff, 0xf0, 0x00, //...%@@@@@@%@@@@@@@....
0x00, 0x7f, 0xff, 0xff, 0x80, 0x00, //....+@@@@@@@@@@@%.....
0x00, 0x06, 0xff, 0xf8, 0x00, 0x00, //......+%@@@@@%%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................
#elif USE_LV_FONT_SYMBOL_30 == 4
/*Unicode: U+f001 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x9b, 0x40, //.....................+%%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x6a, 0xff, 0xff, 0xe0, //..................+%@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0xcf, 0xff, 0xff, 0xff, 0xf0, //...............+@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //...........+%@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //.........%@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xf0, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x72, 0x1f, 0xf0, //........@@@@@@@@@@@%+..@@
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xa5, 0x00, 0x00, 0x1f, 0xf0, //........@@@@@@@@%+.....@@
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x30, 0x00, 0x00, 0x00, 0x1f, 0xf0, //........@@@@@%.........@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //........@@+............@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x00, 0x00, 0x12, 0x20, 0x1f, 0xf0, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x00, 0x7c, 0xff, 0xff, 0xcf, 0xf0, //........@@......+@@@@@%@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xf0, //........@@.....@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xf0, //........@@....+@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0xff, 0x10, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xd0, //........@@.....@@@@@@@@@@
0x04, 0xae, 0xff, 0xe9, 0xff, 0x10, 0x00, 0x09, 0xff, 0xff, 0xff, 0xff, 0x40, //.+%@@@@%@@.....%@@@@@@@@+
0x9f, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x00, 0x39, 0xdf, 0xec, 0x71, 0x00, //%@@@@@@@@@.......%@@@@+..
0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@...............
0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@...............
0xaf, 0xff, 0xff, 0xff, 0xf6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@+...............
0x05, 0xbf, 0xff, 0xea, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+%@@@@%.................
0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f008 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0x50, 0x04, 0xff, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xf4, 0x00, 0x4f, 0xf0, //@@+..+@@+.............+@@+..+@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x40, 0x03, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0x00, 0x3f, 0xf1, //@@+...@@...............@@....@@.
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf1, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf1, //@@@@@@@@...............@@@@@@@@.
0xff, 0x61, 0x15, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf5, 0x11, 0x5f, 0xf1, //@@+..+@@...............@@+..+@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x61, 0x15, 0xff, 0x61, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x6f, 0xf5, 0x11, 0x5f, 0xf1, //@@+..+@@+.............+@@+..+@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0x40, 0x03, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xf3, 0x00, 0x3f, 0xf1, //@@+...@@+.............+@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x50, 0x04, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf4, 0x00, 0x4f, 0xf1, //@@+..+@@...............@@+..+@@.
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf1, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf1, //@@@@@@@@...............@@@@@@@@.
0xff, 0x40, 0x03, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0x00, 0x3f, 0xf1, //@@+...@@...............@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x10, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x0f, 0xf1, //@@....@@...............@@....@@.
0xff, 0x40, 0x03, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xf3, 0x00, 0x3f, 0xf0, //@@+...@@+.............+@@....@@.
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f00b () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x7f, 0xff, 0xff, 0xfb, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0x30, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xaf, 0xff, 0xff, 0xfe, 0x10, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0x02, 0x33, 0x33, 0x30, 0x00, 0x01, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x02, 0x33, 0x33, 0x30, 0x00, 0x01, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x00, //.............................
0xaf, 0xff, 0xff, 0xfe, 0x10, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x30, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xfb, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x02, 0x33, 0x33, 0x30, 0x00, 0x01, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x00, //.............................
0xaf, 0xff, 0xff, 0xfe, 0x10, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x30, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xfb, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f00c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, //.....................+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xc1, 0x00, //...................+@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0xfc, 0x10, //..................+@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xc0, //.................+@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xf0, //................+@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0x70, //...............+@@@@@@@@+
0x00, 0x18, 0x50, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xf7, 0x00, //...%+.........+@@@@@@@@+.
0x02, 0xef, 0xf6, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, //..@@@+.......+@@@@@@@@+..
0x2e, 0xff, 0xff, 0x60, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, //.@@@@@+.....+@@@@@@@@+...
0xdf, 0xff, 0xff, 0xf6, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, //@@@@@@@+...+@@@@@@@@+....
0xff, 0xff, 0xff, 0xff, 0x60, 0x5f, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, //@@@@@@@@+.+@@@@@@@@+.....
0x5f, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, //+@@@@@@@@%@@@@@@@@+......
0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, //.+@@@@@@@@@@@@@@@+.......
0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //..+@@@@@@@@@@@@@+........
0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@+.........
0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@+..........
0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@+...........
0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@+............
0x00, 0x00, 0x00, 0x05, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@+.............
0x00, 0x00, 0x00, 0x00, 0x4b, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+%+..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f00d () , Width: 20 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x08, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x1b, 0xe6, 0x00, //...%@%.........%@+..
0x00, 0x9f, 0xff, 0xa0, 0x00, 0x00, 0x01, 0xcf, 0xff, 0x60, //..%@@@%.......@@@@+.
0x09, 0xff, 0xff, 0xfa, 0x00, 0x00, 0x1c, 0xff, 0xff, 0xf5, //.%@@@@@%.....@@@@@@+
0x2f, 0xff, 0xff, 0xff, 0xa0, 0x01, 0xcf, 0xff, 0xff, 0xfe, //.@@@@@@@%...@@@@@@@@
0x0e, 0xff, 0xff, 0xff, 0xfa, 0x1c, 0xff, 0xff, 0xff, 0xfc, //.@@@@@@@@%.@@@@@@@@%
0x03, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, //..@@@@@@@@@@@@@@@@@.
0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, //...@@@@@@@@@@@@@@@..
0x00, 0x03, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x00, //....@@@@@@@@@@@@@...
0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x00, //.....@@@@@@@@@@@....
0x00, 0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x00, 0x00, //.....+@@@@@@@@@.....
0x00, 0x00, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, //.....@@@@@@@@@@%....
0x00, 0x01, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x00, //....@@@@@@@@@@@@%...
0x00, 0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x00, //...@@@@@@@@@@@@@@%..
0x01, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, //..@@@@@@@@@@@@@@@@%.
0x0c, 0xff, 0xff, 0xff, 0xfd, 0x4e, 0xff, 0xff, 0xff, 0xf9, //.@@@@@@@@@+@@@@@@@@%
0x2f, 0xff, 0xff, 0xff, 0xd1, 0x03, 0xef, 0xff, 0xff, 0xff, //.@@@@@@@@...@@@@@@@@
0x0c, 0xff, 0xff, 0xfd, 0x10, 0x00, 0x3e, 0xff, 0xff, 0xf9, //.@@@@@@@.....@@@@@@%
0x00, 0xcf, 0xff, 0xd1, 0x00, 0x00, 0x03, 0xef, 0xff, 0x90, //..@@@@@.......@@@@%.
0x00, 0x0c, 0xfd, 0x10, 0x00, 0x00, 0x00, 0x3e, 0xf9, 0x00, //...@@@.........@@%..
0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
/*Unicode: U+f011 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x08, 0x93, 0x00, 0xff, 0xff, 0x20, 0x29, 0x81, 0x00, 0x00, 0x00, //.....%%...@@@@...%%......
0x00, 0x01, 0xdf, 0xff, 0x10, 0xff, 0xff, 0x20, 0xdf, 0xfe, 0x20, 0x00, 0x00, //....@@@@..@@@@..@@@@.....
0x00, 0x1d, 0xff, 0xff, 0x30, 0xff, 0xff, 0x21, 0xff, 0xff, 0xe2, 0x00, 0x00, //...@@@@@..@@@@..@@@@@....
0x00, 0xbf, 0xff, 0xfd, 0x00, 0xff, 0xff, 0x20, 0xbf, 0xff, 0xfd, 0x00, 0x00, //..%@@@@@..@@@@..%@@@@@...
0x05, 0xff, 0xff, 0xd1, 0x00, 0xff, 0xff, 0x20, 0x0c, 0xff, 0xff, 0x70, 0x00, //.+@@@@@...@@@@...@@@@@+..
0x0d, 0xff, 0xfe, 0x10, 0x00, 0xff, 0xff, 0x20, 0x00, 0xcf, 0xff, 0xf0, 0x00, //.@@@@@....@@@@....@@@@@..
0x4f, 0xff, 0xf4, 0x00, 0x00, 0xff, 0xff, 0x20, 0x00, 0x3f, 0xff, 0xf6, 0x00, //+@@@@+....@@@@.....@@@@+.
0x9f, 0xff, 0xc0, 0x00, 0x00, 0xff, 0xff, 0x20, 0x00, 0x0a, 0xff, 0xfb, 0x00, //%@@@@.....@@@@.....%@@@%.
0xcf, 0xff, 0x70, 0x00, 0x00, 0xff, 0xff, 0x10, 0x00, 0x05, 0xff, 0xfe, 0x00, //@@@@+.....@@@@.....+@@@@.
0xef, 0xff, 0x40, 0x00, 0x00, 0xaf, 0xfc, 0x00, 0x00, 0x02, 0xff, 0xff, 0x10, //@@@@+.....%@@@......@@@@.
0xff, 0xff, 0x20, 0x00, 0x00, 0x05, 0x60, 0x00, 0x00, 0x00, 0xff, 0xff, 0x10, //@@@@.......++.......@@@@.
0xef, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, //@@@@................@@@@.
0xdf, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0x00, //@@@@+...............@@@@.
0xaf, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0xfc, 0x00, //%@@@%..............%@@@@.
0x5f, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xf7, 0x00, //+@@@@..............@@@@+.
0x0f, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0xff, 0xf2, 0x00, //.@@@@%............%@@@@..
0x08, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xa0, 0x00, //.+@@@@+..........+@@@@%..
0x00, 0xef, 0xff, 0xf9, 0x10, 0x00, 0x00, 0x00, 0x8f, 0xff, 0xff, 0x20, 0x00, //..@@@@@%........%@@@@@...
0x00, 0x3f, 0xff, 0xff, 0xe8, 0x42, 0x13, 0x8e, 0xff, 0xff, 0xf5, 0x00, 0x00, //...@@@@@@%+...%@@@@@@+...
0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@+....
0x00, 0x00, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@@@@+.....
0x00, 0x00, 0x01, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x00, 0x00, 0x00, //......%@@@@@@@@@@%.......
0x00, 0x00, 0x00, 0x01, 0x7c, 0xef, 0xfe, 0xc7, 0x20, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f013 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x3b, 0x30, 0x04, 0xff, 0xff, 0xf3, 0x00, 0x3b, 0x30, 0x00, 0x00, //.....%...+@@@@@....%.....
0x00, 0x04, 0xff, 0xf6, 0x1a, 0xff, 0xff, 0xf9, 0x16, 0xff, 0xe3, 0x00, 0x00, //...+@@@+.%@@@@@%.+@@@....
0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x00, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0x01, 0xff, 0xff, 0xff, 0xc6, 0x46, 0xcf, 0xff, 0xff, 0xf1, 0x00, 0x00, //....@@@@@@@+++@@@@@@@....
0x01, 0x4a, 0xff, 0xff, 0xf9, 0x00, 0x00, 0x09, 0xff, 0xff, 0xf9, 0x30, 0x00, //...%@@@@@%.....%@@@@@%...
0xdf, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@.......@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x4f, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@+.......+@@@@@@@@
0xdf, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@.......@@@@@@@@@
0x01, 0x3a, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x08, 0xff, 0xff, 0xfa, 0x42, 0x00, //...%@@@@@%.....%@@@@@%+..
0x00, 0x01, 0xff, 0xff, 0xff, 0xb5, 0x35, 0xbf, 0xff, 0xff, 0xf2, 0x00, 0x00, //....@@@@@@%+.+%@@@@@@....
0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0x04, 0xff, 0xf7, 0x2a, 0xff, 0xff, 0xfa, 0x27, 0xff, 0xf5, 0x00, 0x00, //...+@@@+.%@@@@@%.+@@@+...
0x00, 0x00, 0x3c, 0x40, 0x03, 0xff, 0xff, 0xf4, 0x00, 0x4c, 0x40, 0x00, 0x00, //.....@....@@@@@+..+@+....
0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xf2, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f014 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0xff, 0xe5, 0x00, 0x00, 0x00, 0x00, //.......%@@@@@@@+.......
0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, //......+@@@@@@@@@.......
0x00, 0x00, 0x00, 0xdf, 0x70, 0x00, 0x00, 0xaf, 0x90, 0x00, 0x00, 0x00, //......@@+.....%@%......
0x00, 0x00, 0x04, 0xfe, 0x00, 0x00, 0x00, 0x3f, 0xf1, 0x00, 0x00, 0x00, //.....+@@.......@@......
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0xef, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xb0, 0x00, //..@@..............+@%..
0x00, 0xef, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xb0, 0x00, //..@@..............+@%..
0x00, 0xef, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xb0, 0x00, //..@@..............+@%..
0x00, 0xef, 0x20, 0x35, 0x00, 0x25, 0x10, 0x15, 0x10, 0x5f, 0xb0, 0x00, //..@@...+...+...+..+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xcf, 0x40, 0xaf, 0x60, 0x7f, 0x80, 0x5f, 0xb0, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0xef, 0x20, 0xbf, 0x30, 0x9f, 0x50, 0x6f, 0x70, 0x5f, 0xb0, 0x00, //..@@..%@..%@+.+@+.+@%..
0x00, 0xef, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xb0, 0x00, //..@@..............+@%..
0x00, 0xef, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xb0, 0x00, //..@@..............+@%..
0x00, 0xcf, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x90, 0x00, //..@@+.............%@%..
0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x00, //..+@@@@@@@@@@@@@@@@@...
0x00, 0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, //...%@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f015 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x70, 0x00, 0x0a, 0xbb, 0xa0, 0x00, 0x00, //............+%+....%%%%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0xff, 0xfb, 0x10, 0x2f, 0xff, 0xf0, 0x00, 0x00, //...........%@@@%...@@@@....
0x00, 0x00, 0x00, 0x00, 0x01, 0xdf, 0xff, 0xff, 0xd2, 0x2f, 0xff, 0xf0, 0x00, 0x00, //..........@@@@@@@..@@@@....
0x00, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xc3, 0xcf, 0xff, 0x7f, 0xff, 0xf0, 0x00, 0x00, //.........@@@@.@@@@+@@@@....
0x00, 0x00, 0x00, 0x06, 0xff, 0xfa, 0x05, 0x0a, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //.......+@@@%.+.%@@@@@@@....
0x00, 0x00, 0x00, 0x8f, 0xff, 0x81, 0xbf, 0xb1, 0x7f, 0xff, 0xff, 0xf0, 0x00, 0x00, //......%@@@+.%@%.+@@@@@@....
0x00, 0x00, 0x0b, 0xff, 0xf5, 0x2d, 0xff, 0xfd, 0x24, 0xff, 0xff, 0xf0, 0x00, 0x00, //.....%@@@+.@@@@@.+@@@@@....
0x00, 0x02, 0xdf, 0xfe, 0x35, 0xff, 0xff, 0xff, 0xf5, 0x2d, 0xff, 0xf3, 0x00, 0x00, //....@@@@.+@@@@@@@+.@@@@....
0x00, 0x3e, 0xff, 0xc1, 0x8f, 0xff, 0xff, 0xff, 0xff, 0x81, 0xbf, 0xff, 0x50, 0x00, //...@@@@.%@@@@@@@@@%.%@@@+..
0x06, 0xff, 0xfa, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x19, 0xff, 0xf8, 0x00, //.+@@@%.%@@@@@@@@@@@%.%@@@%.
0x5f, 0xff, 0x82, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x6f, 0xff, 0x80, //+@@@+.@@@@@@@@@@@@@@@.+@@@%
0x2e, 0xf5, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x43, 0xef, 0x40, //.@@++@@@@@@@@@@@@@@@@@+.@@+
0x03, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x14, 0x00, //....@@@@@@@@@@@@@@@@@@@..+.
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0xff, 0xff, 0xff, 0xfd, 0xcc, 0xcd, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0xbf, 0xff, 0xff, 0xf3, 0x00, 0x03, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, //....%@@@@@@.....@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f019 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xbb, 0xbb, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%%%%%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x02, 0x66, 0x66, 0xcf, 0xff, 0xff, 0xc6, 0x66, 0x61, 0x00, 0x00, 0x00, //......++++@@@@@@%++++......
0x00, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@......
0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@@@@@...........
0x01, 0x22, 0x22, 0x22, 0x20, 0x05, 0xff, 0xf3, 0x00, 0x22, 0x22, 0x22, 0x21, 0x00, //...........+@@@............
0xaf, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x4c, 0x30, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xa0, //%@@@@@@@@%..+@...%@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@%.....@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x53, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@+.+@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x5f, 0xf3, 0x4f, 0xf0, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x6f, 0xf4, 0x5f, 0xf0, //@@@@@@@@@@@@@@@@@@@.+@@++@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f01c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, 0x00, 0x00, //....+@@@@@@@@@@@@@@@.....
0x00, 0x00, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@....
0x00, 0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@....
0x00, 0x0d, 0xff, 0x91, 0x11, 0x11, 0x11, 0x11, 0x11, 0xbf, 0xfa, 0x00, 0x00, //...@@@%...........%@@%...
0x00, 0x3f, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0xff, 0x10, 0x00, //...@@@............+@@@...
0x00, 0xaf, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xff, 0x80, 0x00, //..%@@%.............@@@%..
0x01, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xe0, 0x00, //..@@@+.............+@@@..
0x08, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf5, 0x00, //.%@@@...............@@@+.
0x0e, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9f, 0xfc, 0x00, //.@@@+...............%@@@.
0x5f, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x30, //+@@@.................@@@.
0xbf, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0x90, //%@@%.................@@@%
0xff, 0xf8, 0x55, 0x55, 0x10, 0x00, 0x00, 0x00, 0x25, 0x55, 0x59, 0xff, 0xc0, //@@@%++++.........++++%@@@
0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@%.......@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@......+@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xfb, 0x33, 0x33, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@%.....@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f021 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x6a, 0xdf, 0xfe, 0xd9, 0x40, 0x00, 0x00, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x00, 0x00, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x00, 0x1d, 0xb0, //......%@@@@@@@@@@@+....@%
0x00, 0x00, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x21, 0xdf, 0xf0, //.....@@@@@@@@@@@@@@@..@@@
0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xf0, //....@@@@@@@@@@@@@@@@@@@@@
0x00, 0x2f, 0xff, 0xff, 0xfa, 0x52, 0x13, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xf0, //...@@@@@@%+...+%@@@@@@@@@
0x00, 0xdf, 0xff, 0xfc, 0x20, 0x00, 0x00, 0x00, 0x2c, 0xff, 0xff, 0xff, 0xf0, //..@@@@@@.........%@@@@@@@
0x07, 0xff, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xf0, //.+@@@@%...........@@@@@@@
0x0e, 0xff, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0xff, 0xff, 0xff, 0xf0, //.@@@@@...........@@@@@@@@
0x5f, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x01, 0xdf, 0xff, 0xff, 0xff, 0xf0, //+@@@@...........@@@@@@@@@
0x9f, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xe0, //%@@@%...........@@@@@@@@@
0x25, 0x55, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x55, 0x55, 0x55, 0x20, //.+++.............+++++++.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x36, 0x66, 0x66, 0x66, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x66, 0x20, //.++++++++............+++.
0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0x70, //@@@@@@@@@+..........@@@@+
0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0x20, //@@@@@@@@@...........@@@@.
0xff, 0xff, 0xff, 0xfd, 0x10, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xff, 0xfc, 0x00, //@@@@@@@@...........@@@@@.
0xff, 0xff, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xf5, 0x00, //@@@@@@@...........%@@@@+.
0xff, 0xff, 0xff, 0xfc, 0x20, 0x00, 0x00, 0x00, 0x2d, 0xff, 0xff, 0xb0, 0x00, //@@@@@@@@.........@@@@@%..
0xff, 0xff, 0xff, 0xff, 0xfa, 0x52, 0x12, 0x5a, 0xff, 0xff, 0xfe, 0x10, 0x00, //@@@@@@@@@%+...+%@@@@@@...
0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@@@....
0xff, 0xd1, 0x2d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, 0x00, 0x00, //@@@..@@@@@@@@@@@@@@@.....
0xcd, 0x10, 0x00, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x00, 0x00, //@@....%@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x01, 0x6a, 0xef, 0xff, 0xea, 0x60, 0x00, 0x00, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f026 () , Width: 13 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x30, //..........+@.
0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0x60, //.........%@@+
0x00, 0x00, 0x00, 0x00, 0x8f, 0xff, 0x60, //........%@@@+
0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0x60, //.......%@@@@+
0x00, 0x00, 0x00, 0x8f, 0xff, 0xff, 0x60, //......%@@@@@+
0x14, 0x44, 0x48, 0xff, 0xff, 0xff, 0x60, //.++++%@@@@@@+
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@@@@@+
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //%@@@@@@@@@@@+
0x00, 0x00, 0x04, 0xff, 0xff, 0xff, 0x60, //......@@@@@@+
0x00, 0x00, 0x00, 0x4f, 0xff, 0xff, 0x60, //.......@@@@@+
0x00, 0x00, 0x00, 0x04, 0xff, 0xff, 0x60, //........@@@@+
0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x60, //.........@@@+
0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x60, //..........@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 0x10, //...........%.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
/*Unicode: U+f027 () , Width: 19 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x30, 0x00, 0x00, 0x00, //..........+@.......
0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0x60, 0x00, 0x00, 0x00, //.........%@@+......
0x00, 0x00, 0x00, 0x00, 0x8f, 0xff, 0x60, 0x00, 0x00, 0x00, //........%@@@+......
0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, //.......%@@@@+......
0x00, 0x00, 0x00, 0x8f, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, //......%@@@@@+......
0x14, 0x44, 0x48, 0xff, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, //.++++%@@@@@@+......
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0d, 0xe4, 0x00, //@@@@@@@@@@@@+..@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0d, 0xff, 0x30, //@@@@@@@@@@@@+..@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0xaf, 0xb0, //@@@@@@@@@@@@+...%@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x2f, 0xf0, //@@@@@@@@@@@@+....@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x3f, 0xe0, //@@@@@@@@@@@@+....@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x03, 0xdf, 0x90, //@@@@@@@@@@@@+...@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x0f, 0xfd, 0x10, //@@@@@@@@@@@@+..@@@.
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x08, 0x91, 0x00, //%@@@@@@@@@@@+..%%..
0x00, 0x00, 0x04, 0xff, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, //......@@@@@@+......
0x00, 0x00, 0x00, 0x4f, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, //.......@@@@@+......
0x00, 0x00, 0x00, 0x04, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, //........@@@@+......
0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x60, 0x00, 0x00, 0x00, //.........@@@+......
0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x60, 0x00, 0x00, 0x00, //..........@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 0x10, 0x00, 0x00, 0x00, //...........%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
/*Unicode: U+f028 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x70, 0x00, 0x00, 0x00, //..................+@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x7f, 0xfd, 0x30, 0x00, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x50, 0x00, 0x00, 0x04, 0xdf, 0xf4, 0x00, 0x00, //..........@@+......+@@@....
0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0x60, 0x00, 0x02, 0x00, 0x0b, 0xff, 0x20, 0x00, //.........@@@+........%@@...
0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0x60, 0x00, 0x3f, 0xd4, 0x00, 0xbf, 0xd0, 0x00, //........@@@@+....@@+..%@@..
0x00, 0x00, 0x00, 0x1c, 0xff, 0xff, 0x60, 0x00, 0x1e, 0xff, 0x70, 0x1e, 0xf7, 0x00, //.......@@@@@+....@@@+..@@+.
0x00, 0x00, 0x01, 0xcf, 0xff, 0xff, 0x60, 0x00, 0x00, 0x9f, 0xf4, 0x05, 0xfe, 0x00, //......@@@@@@+.....%@@+.+@@.
0x6a, 0xaa, 0xad, 0xff, 0xff, 0xff, 0x60, 0x04, 0x20, 0x08, 0xfe, 0x00, 0xdf, 0x50, //+%%%%@@@@@@@+......%@@..@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x2f, 0xf8, 0x00, 0xdf, 0x60, 0x8f, 0x90, //@@@@@@@@@@@@+..@@%..@@+.%@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x09, 0xff, 0x60, 0x6f, 0xb0, 0x4f, 0xd0, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x6f, 0xd0, 0x2f, 0xe0, 0x1f, 0xe0, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xf0, //@@@@@@@@@@@@+....@@..@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x6f, 0xd0, 0x2f, 0xe0, 0x1f, 0xe0, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x09, 0xff, 0x60, 0x6f, 0xb0, 0x4f, 0xd0, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x2f, 0xf9, 0x00, 0xdf, 0x60, 0x8f, 0x90, //@@@@@@@@@@@@+..@@%..@@+.+@%
0x6a, 0xaa, 0xad, 0xff, 0xff, 0xff, 0x60, 0x04, 0x30, 0x08, 0xfe, 0x00, 0xdf, 0x50, //+%%%%@@@@@@@+..+...%@@..@@+
0x00, 0x00, 0x01, 0xcf, 0xff, 0xff, 0x60, 0x00, 0x00, 0x8f, 0xf5, 0x05, 0xfe, 0x00, //......@@@@@@+.....%@@+.+@@.
0x00, 0x00, 0x00, 0x1c, 0xff, 0xff, 0x60, 0x00, 0x1d, 0xff, 0x70, 0x0e, 0xf7, 0x00, //.......@@@@@+....@@@+..@@+.
0x00, 0x00, 0x00, 0x01, 0xcf, 0xff, 0x60, 0x00, 0x3f, 0xe5, 0x00, 0xbf, 0xd0, 0x00, //........@@@@+....@@+..%@@..
0x00, 0x00, 0x00, 0x00, 0x1c, 0xff, 0x60, 0x00, 0x02, 0x00, 0x0b, 0xff, 0x20, 0x00, //.........@@@+........%@@...
0x00, 0x00, 0x00, 0x00, 0x01, 0xcf, 0x50, 0x00, 0x00, 0x04, 0xdf, 0xf4, 0x00, 0x00, //..........@@+......+@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x7f, 0xfd, 0x30, 0x00, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x80, 0x00, 0x00, 0x00, //..................+@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f03e () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0xf0, //@@...........................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x10, 0x07, 0xee, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...+@@%....................@@.
0xff, 0x10, 0x7f, 0xff, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@..+@@@@%...................@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@..@@@@@@...................@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x0b, 0xe2, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@..@@@@@@.........%@........@@.
0xff, 0x10, 0x9f, 0xff, 0xfd, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xfe, 0x20, 0x00, 0x00, 0x0f, 0xf1, //@@..%@@@@@........%@@@.......@@.
0xff, 0x10, 0x0b, 0xff, 0xd2, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x0f, 0xf1, //@@...%@@@........%@@@@@......@@.
0xff, 0x10, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x0f, 0xf1, //@@..............@@@@@@@@.....@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x0f, 0xf1, //@@.............@@@@@@@@@@....@@.
0xff, 0x10, 0x00, 0x00, 0x25, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0f, 0xf1, //@@.......+....@@@@@@@@@@@@...@@.
0xff, 0x10, 0x00, 0x02, 0xef, 0x60, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0f, 0xf1, //@@......@@+..@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0x00, 0x2e, 0xff, 0xf7, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xf1, //@@.....@@@@+@@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0x02, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xf1, //@@....@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xf1, //@@...@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xf1, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xf1, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xf1, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0x10, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x80, 0x0f, 0xf1, //@@..%%%%%%%%%%%%%%%%%%%%%%+..@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@...........................@@.
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x1c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x20, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f040 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x00, //..................+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xff, 0x70, 0x00, 0x00, //.................@@@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xf7, 0x00, 0x00, //................@@@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0x70, 0x00, //...............@@@@@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xf7, 0x00, //...............@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x20, 0xcf, 0xff, 0xff, 0xff, 0x40, //.............@..@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xe2, 0x0c, 0xff, 0xff, 0xff, 0x70, //............@@@..@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xfd, 0xee, 0x20, 0xcf, 0xff, 0xff, 0x20, //...........@@@@@..@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xd3, 0xef, 0xe2, 0x0c, 0xff, 0xf4, 0x00, //..........@@@.@@@..@@@@+.
0x00, 0x00, 0x00, 0x00, 0x3f, 0xfd, 0x3e, 0xff, 0xfe, 0x20, 0xcf, 0x40, 0x00, //.........@@@.@@@@@..@@+..
0x00, 0x00, 0x00, 0x03, 0xff, 0xd3, 0xef, 0xff, 0xff, 0xe2, 0x03, 0x00, 0x00, //........@@@.@@@@@@@......
0x00, 0x00, 0x00, 0x3f, 0xfd, 0x3e, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, //.......@@@.@@@@@@@@@.....
0x00, 0x00, 0x03, 0xff, 0xd3, 0xef, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, //......@@@.@@@@@@@@@+.....
0x00, 0x00, 0x3f, 0xfd, 0x3e, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, //.....@@@.@@@@@@@@@+......
0x00, 0x03, 0xff, 0xd3, 0xef, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, //....@@@.@@@@@@@@@+.......
0x00, 0x3f, 0xfd, 0x3e, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, //...@@@.@@@@@@@@@+........
0x03, 0xff, 0xe3, 0xef, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@.@@@@@@@@@+.........
0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@@@@@@+..........
0xff, 0xb0, 0xaf, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@%.%@@@@@@@@+...........
0xff, 0x10, 0x0a, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@...%@@@@@@+............
0xff, 0x21, 0x00, 0xaf, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@....%@@@@+.............
0xff, 0xff, 0x20, 0x0d, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@...@@@+..............
0xff, 0xff, 0x20, 0xaf, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@..%@@+...............
0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@+................
0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f048 () , Width: 17 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x9d, 0xdb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x70, //%@@%...........++
0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x90, //@@@@..........+@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x05, 0xff, 0x90, //@@@@.........+@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x4f, 0xff, 0x90, //@@@@........+@@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x04, 0xff, 0xff, 0x90, //@@@@.......+@@@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x4f, 0xff, 0xff, 0x90, //@@@@......+@@@@@%
0xff, 0xff, 0x20, 0x00, 0x04, 0xff, 0xff, 0xff, 0x90, //@@@@.....+@@@@@@%
0xff, 0xff, 0x20, 0x00, 0x4f, 0xff, 0xff, 0xff, 0x90, //@@@@....+@@@@@@@%
0xff, 0xff, 0x20, 0x04, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@...+@@@@@@@@%
0xff, 0xff, 0x20, 0x4f, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@..+@@@@@@@@@%
0xff, 0xff, 0x24, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@.+@@@@@@@@@@%
0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@+@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@@@@@@@@@@@@@%
0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@%@@@@@@@@@@@%
0xff, 0xff, 0x26, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@.+@@@@@@@@@@%
0xff, 0xff, 0x20, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@..+@@@@@@@@@%
0xff, 0xff, 0x20, 0x06, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@...+@@@@@@@@%
0xff, 0xff, 0x20, 0x00, 0x6f, 0xff, 0xff, 0xff, 0x90, //@@@@....+@@@@@@@%
0xff, 0xff, 0x20, 0x00, 0x06, 0xff, 0xff, 0xff, 0x90, //@@@@.....+@@@@@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x6f, 0xff, 0xff, 0x90, //@@@@......+@@@@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x06, 0xff, 0xff, 0x90, //@@@@.......+@@@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x6f, 0xff, 0x90, //@@@@........+@@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x06, 0xff, 0x90, //@@@@.........+@@%
0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x6f, 0x90, //@@@@..........+@%
0xbf, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, //%@@@...........+%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
/*Unicode: U+f04b () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0xc7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@+.....................
0xff, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@+...................
0xff, 0xff, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@..................
0xff, 0xff, 0xff, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@%................
0xff, 0xff, 0xff, 0xff, 0x91, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@%..............
0xff, 0xff, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@+............
0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@+..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@.........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@%.......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x10, 0x00, 0x00, //@@@@@@@@@@@@@@@@@%.....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@+...
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x00, //@@@@@@@@@@@@@@@@@@@@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x10, //@@@@@@@@@@@@@@@@@@@@@%.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x00, //@@@@@@@@@@@@@@@@@@@%...
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x40, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@+....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x60, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@+......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@%........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@%..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@%............
0xff, 0xff, 0xff, 0xff, 0xd4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@+.............
0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+...............
0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@%.................
0xff, 0xfa, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@%...................
0xfc, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@.....................
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f04c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x9d, 0xdd, 0xdd, 0xdd, 0xdc, 0x10, 0x00, 0x1c, 0xdd, 0xdd, 0xdd, 0xdd, 0x90, //%@@@@@@@@@.....@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+...+@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x2e, 0xff, 0xff, 0xff, 0xff, 0xb0, //%@@@@@@@@@.....@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f04d () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x9d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0x70, //%@@@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f051 () , Width: 17 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9d, 0xdb, 0x00, //+...........%@@%.
0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@+..........@@@@.
0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@+.........@@@@.
0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@+........@@@@.
0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@+.......@@@@.
0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@@+......@@@@.
0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@@@+.....@@@@.
0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@@@@+....@@@@.
0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0xff, 0xff, 0x20, //@@@@@@@@+...@@@@.
0xff, 0xff, 0xff, 0xff, 0xf6, 0x00, 0xff, 0xff, 0x20, //@@@@@@@@@+..@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xff, 0xff, 0x20, //@@@@@@@@@@+.@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xff, 0xff, 0x20, //@@@@@@@@@@@+@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, //@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xff, 0x20, //@@@@@@@@@@@%@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0xff, 0xff, 0x20, //@@@@@@@@@@%.@@@@.
0xff, 0xff, 0xff, 0xff, 0xf9, 0x00, 0xff, 0xff, 0x20, //@@@@@@@@@%..@@@@.
0xff, 0xff, 0xff, 0xff, 0x90, 0x00, 0xff, 0xff, 0x20, //@@@@@@@@%...@@@@.
0xff, 0xff, 0xff, 0xf9, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@@@@%....@@@@.
0xff, 0xff, 0xff, 0x90, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@@@%.....@@@@.
0xff, 0xff, 0xf9, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@@%......@@@@.
0xff, 0xff, 0x90, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@@%.......@@@@.
0xff, 0xf9, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@@%........@@@@.
0xff, 0x90, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@@%.........@@@@.
0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x20, //@%..........@@@@.
0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xfd, 0x00, //%...........%@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
/*Unicode: U+f052 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@@@+..........
0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@+........
0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@+......
0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@+.....
0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, //....+@@@@@@@@@@@@@@@+....
0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, //..+@@@@@@@@@@@@@@@@@@@+..
0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, //.+@@@@@@@@@@@@@@@@@@@@@+.
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x78, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x60, //+%%%%%%%%%%%%%%%%%%%%%%%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, //.........................
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f053 () , Width: 18 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x80, 0x00, //............+@%...
0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xf8, 0x00, //...........+@@@%..
0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0x80, //..........+@@@@@%.
0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xf3, //.........+@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, //........+@@@@@@@@.
0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xfc, 0x00, //.......+@@@@@@@@..
0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 0x00, //......+@@@@@@@@...
0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, //.....+@@@@@@@@....
0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, //....+@@@@@@@@.....
0x00, 0x07, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, //...+@@@@@@@@......
0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, //..+@@@@@@@@.......
0x07, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, //.+@@@@@@@@........
0x5f, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@.........
0x4f, 0xff, 0xff, 0xff, 0xd1, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@.........
0x06, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x00, 0x00, 0x00, //.+@@@@@@@@........
0x00, 0x6f, 0xff, 0xff, 0xff, 0xd1, 0x00, 0x00, 0x00, //..+@@@@@@@@.......
0x00, 0x06, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x00, 0x00, //...+@@@@@@@@......
0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xd1, 0x00, 0x00, //....+@@@@@@@@.....
0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x00, //.....+@@@@@@@@....
0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xd1, 0x00, //......+@@@@@@@@...
0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0xfd, 0x10, //.......+@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xd0, //........+@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0xf2, //.........+@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0x70, //..........+@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xf7, 0x00, //...........+@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x70, 0x00, //............+@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
/*Unicode: U+f054 () , Width: 18 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x0c, 0xe3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@.............
0x00, 0xcf, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@............
0x0c, 0xff, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@...........
0x7f, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@..........
0x2e, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@.........
0x02, 0xef, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, //..@@@@@@@@........
0x00, 0x2e, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, 0x00, //...@@@@@@@@.......
0x00, 0x02, 0xef, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, //....@@@@@@@@......
0x00, 0x00, 0x2e, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, //.....@@@@@@@@.....
0x00, 0x00, 0x02, 0xef, 0xff, 0xff, 0xff, 0x30, 0x00, //......@@@@@@@@....
0x00, 0x00, 0x00, 0x2e, 0xff, 0xff, 0xff, 0xf3, 0x00, //.......@@@@@@@@...
0x00, 0x00, 0x00, 0x02, 0xef, 0xff, 0xff, 0xff, 0x30, //........@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x2e, 0xff, 0xff, 0xff, 0xf1, //.........@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xe1, //.........@@@@@@@@.
0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xfe, 0x20, //........@@@@@@@@..
0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xe2, 0x00, //.......@@@@@@@@...
0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, //......@@@@@@@@....
0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, //.....@@@@@@@@.....
0x00, 0x03, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, //....@@@@@@@@......
0x00, 0x3f, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, //...@@@@@@@@.......
0x03, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, //..@@@@@@@@........
0x3f, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@.........
0x7f, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@..........
0x0b, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, //.%@@@@@...........
0x00, 0xbf, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@............
0x00, 0x0a, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...%@.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
/*Unicode: U+f067 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x2b, 0xcc, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, //.........%@@@%.........
0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x17, 0x77, 0x77, 0x77, 0xdf, 0xff, 0xff, 0xb7, 0x77, 0x77, 0x76, 0x00, //.+++++++@@@@@@%+++++++.
0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //@@@@@@@@@@@@@@@@@@@@@@%
0x4a, 0xbb, 0xbb, 0xbb, 0xef, 0xff, 0xff, 0xdb, 0xbb, 0xbb, 0xba, 0x20, //+%%%%%%%@@@@@@@%%%%%%%.
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x4e, 0xff, 0xfd, 0x10, 0x00, 0x00, 0x00, 0x00, //........+@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f068 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x02, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x00, //.......................
0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, //%@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //@@@@@@@@@@@@@@@@@@@@@@%
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x50, //+@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f071 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............%@%.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............%@@@%............
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xff, 0xff, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%@@@@@%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@@@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0x74, 0x44, 0x7f, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, //........+@@@+++++@@@+........
0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0x30, 0x00, 0x3f, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, //........@@@@.....@@@@........
0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0x30, 0x00, 0x3f, 0xff, 0xf6, 0x00, 0x00, 0x00, 0x00, //.......+@@@@.....@@@@+.......
0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0x40, 0x00, 0x4f, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, //.......@@@@@+...+@@@@@.......
0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0x40, 0x00, 0x4f, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, //......+@@@@@+...+@@@@@+......
0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0x50, 0x00, 0x5f, 0xff, 0xff, 0xf1, 0x00, 0x00, 0x00, //......@@@@@@+...+@@@@@@......
0x00, 0x00, 0x09, 0xff, 0xff, 0xff, 0x50, 0x00, 0x6f, 0xff, 0xff, 0xf9, 0x00, 0x00, 0x00, //.....%@@@@@@+...+@@@@@@%.....
0x00, 0x00, 0x2f, 0xff, 0xff, 0xff, 0x60, 0x00, 0x6f, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, //.....@@@@@@@+...+@@@@@@@.....
0x00, 0x00, 0xaf, 0xff, 0xff, 0xff, 0x80, 0x00, 0x8f, 0xff, 0xff, 0xff, 0xa0, 0x00, 0x00, //....%@@@@@@@%...%@@@@@@@%....
0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@@@....
0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, //...%@@@@@@@@@@@@@@@@@@@@@%...
0x00, 0x4f, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, //..+@@@@@@@@@+...+@@@@@@@@@+..
0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, //..@@@@@@@@@@+...+@@@@@@@@@@..
0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, //.+@@@@@@@@@@+...+@@@@@@@@@@+.
0x0e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0x11, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, //.@@@@@@@@@@@%...%@@@@@@@@@@@.
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f074 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x50, 0x00, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf5, 0x00, 0x00, //.......................@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x50, 0x00, //.......................@@@+..
0xab, 0xbb, 0xa8, 0x50, 0x00, 0x00, 0x00, 0x01, 0x69, 0xbb, 0xbb, 0xcf, 0xff, 0xf5, 0x00, //%%%%%%+.........+%%%%%@@@@@+.
0xff, 0xff, 0xff, 0xfe, 0x50, 0x00, 0x00, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@+...%@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0x56, 0x66, 0x7b, 0xff, 0xff, 0x66, 0xff, 0xff, 0xf9, 0x66, 0x66, 0x8f, 0xff, 0xe2, 0x00, //+++++%@@@@++@@@@@%++++%@@@@..
0x00, 0x00, 0x00, 0x4f, 0xfd, 0x1e, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x3f, 0xfe, 0x20, 0x00, //......+@@@.@@@@@.......@@@...
0x00, 0x00, 0x00, 0x07, 0xf6, 0x7f, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x3f, 0xe2, 0x00, 0x00, //.......+@++@@@@........@@....
0x00, 0x00, 0x00, 0x00, 0xb1, 0xef, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x2e, 0x20, 0x00, 0x00, //........%.@@@@%........@.....
0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@...............
0x00, 0x00, 0x00, 0x00, 0x0d, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@%...............
0x00, 0x00, 0x00, 0x00, 0x5f, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@................
0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xc2, 0x90, 0x00, 0x00, 0x00, 0x2d, 0x20, 0x00, 0x00, //........@@@@@.%........@.....
0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0x49, 0xf3, 0x00, 0x00, 0x00, 0x3f, 0xe2, 0x00, 0x00, //.......+@@@@+%@........@@....
0x00, 0x00, 0x00, 0x4f, 0xff, 0xfc, 0x1f, 0xfd, 0x10, 0x00, 0x00, 0x3f, 0xfe, 0x20, 0x00, //.......@@@@@.@@@.......@@@...
0x45, 0x55, 0x6a, 0xff, 0xff, 0xf3, 0x9f, 0xff, 0xf9, 0x65, 0x55, 0x8f, 0xff, 0xe2, 0x00, //+++++%@@@@@.%@@@@%++++%@@@@..
0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xf9, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@%...@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xbc, 0xcc, 0xba, 0x60, 0x00, 0x00, 0x00, 0x02, 0x7a, 0xcc, 0xcc, 0xdf, 0xff, 0xf6, 0x00, //%@@@%%+.........+%%@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x60, 0x00, //.......................@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf6, 0x00, 0x00, //.......................@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x60, 0x00, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f077 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xde, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@@@............
0x00, 0x00, 0x00, 0x00, 0x01, 0xdf, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@...........
0x00, 0x00, 0x00, 0x00, 0x1d, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@..........
0x00, 0x00, 0x00, 0x01, 0xdf, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, //........@@@@@@@@@@.........
0x00, 0x00, 0x00, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, //.......@@@@@@@@@@@@........
0x00, 0x00, 0x01, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, //......@@@@@@@@@@@@@@.......
0x00, 0x00, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@......
0x00, 0x01, 0xdf, 0xff, 0xff, 0xff, 0x53, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, //....@@@@@@@@+.@@@@@@@@.....
0x00, 0x1d, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, //...@@@@@@@@+...@@@@@@@@....
0x01, 0xdf, 0xff, 0xff, 0xff, 0x50, 0x00, 0x03, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, //..@@@@@@@@+.....@@@@@@@@...
0x1d, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xe2, 0x00, //.@@@@@@@@+.......@@@@@@@@..
0xdf, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x04, 0xff, 0xff, 0xff, 0xfe, 0x00, //@@@@@@@@+.........@@@@@@@@.
0xcf, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0xff, 0xff, 0xfd, 0x00, //@@@@@@@+...........@@@@@@@.
0x1c, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xff, 0xff, 0xd1, 0x00, //.@@@@@+.............@@@@@..
0x01, 0xcf, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0xfd, 0x10, 0x00, //..@@@+...............@@@...
0x00, 0x09, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x91, 0x00, 0x00, //...%+.................%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f078 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, //...........................
0x00, 0x6f, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0xf8, 0x00, 0x00, //..+@@................%@%...
0x06, 0xff, 0xfc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0x80, 0x00, //.+@@@@..............%@@@%..
0x6f, 0xff, 0xff, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0xff, 0xff, 0xf8, 0x00, //+@@@@@@............%@@@@@%.
0xff, 0xff, 0xff, 0xfc, 0x10, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0xff, 0x00, //@@@@@@@@..........%@@@@@@@.
0x6f, 0xff, 0xff, 0xff, 0xc1, 0x00, 0x00, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xf7, 0x00, //+@@@@@@@@........%@@@@@@@+.
0x06, 0xff, 0xff, 0xff, 0xfc, 0x10, 0x00, 0x00, 0xbf, 0xff, 0xff, 0xff, 0x70, 0x00, //.+@@@@@@@@......%@@@@@@@+..
0x00, 0x6f, 0xff, 0xff, 0xff, 0xc1, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, //..+@@@@@@@@....%@@@@@@@+...
0x00, 0x06, 0xff, 0xff, 0xff, 0xfc, 0x10, 0xbf, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, //...+@@@@@@@@..%@@@@@@@+....
0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xcb, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, //....+@@@@@@@@%@@@@@@@+.....
0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x6f, 0xff, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@@@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@@@@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+@@+............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............++.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f079 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x0a, 0xe2, 0x00, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, //.....%@...%@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x8f, 0xfd, 0x10, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, //....%@@@...@@@@@@@@@@@@@@@@.....
0x00, 0x05, 0xff, 0xff, 0xc0, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, //...+@@@@@...@@@@@@@@@@@@@@@.....
0x00, 0x3f, 0xff, 0xff, 0xf9, 0x00, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, //...@@@@@@%..+@@@@@@@@@@@@@@.....
0x01, 0xef, 0xff, 0xff, 0xff, 0x70, 0x01, 0x11, 0x11, 0x11, 0x11, 0x5f, 0xff, 0xe0, 0x00, 0x00, //..@@@@@@@@+...........+@@@@.....
0x0d, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00, //.@@@@@@@@@@+...........@@@@.....
0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00, //%@@@@@@@@@@@...........@@@@.....
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00, //@@@@@@@@@@@@+..........@@@@.....
0x14, 0x44, 0xef, 0xff, 0x74, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00, //.+++@@@@+++............@@@@.....
0x00, 0x00, 0xdf, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00, //....@@@@+..............@@@@.....
0x00, 0x00, 0xdf, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0x44, 0x6f, 0xff, 0xf4, 0x44, 0x20, //....@@@@+...........+++@@@@+++..
0x00, 0x00, 0xdf, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //....@@@@+.........+@@@@@@@@@@@@.
0x00, 0x00, 0xdf, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //....@@@@+..........@@@@@@@@@@@%.
0x00, 0x00, 0xdf, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, //....@@@@+...........@@@@@@@@@@..
0x00, 0x00, 0xdf, 0xff, 0x62, 0x22, 0x22, 0x22, 0x21, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xe2, 0x00, //....@@@@+...........+@@@@@@@@...
0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x08, 0xff, 0xff, 0xff, 0x40, 0x00, //....@@@@@@@@@@@@@@+..%@@@@@@+...
0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, 0xbf, 0xff, 0xf6, 0x00, 0x00, //....@@@@@@@@@@@@@@@...%@@@@+....
0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x0d, 0xff, 0x90, 0x00, 0x00, //....@@@@@@@@@@@@@@@@...@@@%.....
0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x01, 0xdb, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@%...@%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f07b () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x01, 0x9c, 0xcc, 0xcc, 0xcb, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@@@@%+................
0x2e, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@@@%...............
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@@@@...............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@+..............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9, 0x60, 0x00, //@@@@@@@@@@@@@%%%%%%%%%%%+..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, //@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, //+@@@@@@@@@@@@@@@@@@@@@@@@@.
0x04, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x00, //.+@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f093 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............%.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@@@@...........
0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@.........
0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, //........@@@@@@@@@@@........
0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x20, 0x00, 0x00, 0x00, //.......@@@@@@@@@@@@@.......
0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, //......@@@@@@@@@@@@@@@......
0x00, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x03, 0x99, 0x99, 0xdf, 0xff, 0xff, 0xc9, 0x99, 0x83, 0x00, 0x00, 0x00, //......%%%%@@@@@@@%%%%......
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x01, 0x22, 0x22, 0x22, 0x10, 0x5d, 0xdd, 0xdd, 0x40, 0x12, 0x22, 0x22, 0x21, 0x00, //..........+@@@@@...........
0xaf, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x01, 0xdf, 0xff, 0xff, 0xff, 0x90, //%@@@@@@@@.........@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xfc, 0x52, 0x22, 0x22, 0x5d, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@+.....+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x5f, 0xf3, 0x4f, 0xf0, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0x5f, 0xf3, 0x4f, 0xf0, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f095 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x39, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...%%+.................
0x05, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+@@@@.................
0x1f, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@%................
0x8f, 0xff, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@................
0xdf, 0xff, 0xff, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@%...............
0xff, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@...............
0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@%...............
0xbf, 0xff, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@%................
0x6f, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@%.................
0x1f, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@+.................
0x0a, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.%@@@@.................
0x03, 0xff, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@%................
0x00, 0xaf, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@@+...............
0x00, 0x1e, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@...............
0x00, 0x04, 0xff, 0xff, 0xe3, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, //...+@@@@@..............
0x00, 0x00, 0x7f, 0xff, 0xff, 0x50, 0x00, 0x00, 0xcf, 0xb1, 0x00, 0x00, //....+@@@@@+.....%@%....
0x00, 0x00, 0x08, 0xff, 0xff, 0xfb, 0x10, 0x0a, 0xff, 0xff, 0x80, 0x00, //.....%@@@@@%...%@@@@%..
0x00, 0x00, 0x00, 0x8f, 0xff, 0xff, 0xf8, 0xaf, 0xff, 0xff, 0xfe, 0x50, //......%@@@@@@+%@@@@@@@+
0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, //.......+@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //........+@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x01, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, //..........%@@@@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xaf, 0xff, 0xff, 0xff, 0xf5, 0x00, //............%@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0xd8, 0x10, 0x00, //..............+%@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f0c4 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x47, 0x98, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..++%++......................
0x1c, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@+....................
0xcf, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x10, 0x00, //@@@@@@@@@@...............+...
0xff, 0xf5, 0x01, 0x4b, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xea, 0xe9, 0x00, //@@@+..+%@@@............%@%@%.
0xff, 0x90, 0x00, 0x00, 0x5f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x08, 0xe8, 0x00, 0x1d, 0x60, //@@%.....+@@%.........%@%...@+
0xff, 0xd0, 0x00, 0x00, 0x07, 0xfd, 0x00, 0x00, 0x00, 0x07, 0xea, 0x10, 0x01, 0xbc, 0x10, //@@@......+@@.......+@%....%@.
0xef, 0xfa, 0x00, 0x00, 0x03, 0xff, 0x00, 0x00, 0x05, 0xdb, 0x30, 0x00, 0x2d, 0x90, 0x00, //@@@%......@@.....+@%.....@%..
0x4f, 0xff, 0xe6, 0x20, 0x2b, 0xfe, 0x10, 0x04, 0xcd, 0x40, 0x00, 0x05, 0xe6, 0x00, 0x00, //+@@@@+...%@@....@@+....+@+...
0x05, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xe7, 0xbe, 0x60, 0x00, 0x00, 0x8e, 0x30, 0x00, 0x00, //.+@@@@@@@@@%@+%@+.....%@.....
0x00, 0x2b, 0xff, 0xff, 0xff, 0xc0, 0x9f, 0x80, 0x00, 0x00, 0x1b, 0xb1, 0x00, 0x00, 0x00, //...%@@@@@@@.%@+......%%......
0x00, 0x00, 0x26, 0x88, 0x63, 0xdc, 0xf2, 0x33, 0x00, 0x02, 0xd8, 0x00, 0x00, 0x00, 0x00, //.....+%%+.@@@.......@%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xf0, 0xef, 0x00, 0x5f, 0x50, 0x00, 0x00, 0x00, 0x00, //...........%@.@@..+@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xb0, 0xbc, 0x08, 0xed, 0xb1, 0x00, 0x00, 0x00, 0x00, //..........+@%.%@.%@@%........
0x00, 0x02, 0x8d, 0xff, 0xda, 0xe5, 0x02, 0x51, 0xbb, 0x10, 0xae, 0x30, 0x00, 0x00, 0x00, //....%@@@@%@+..+.%%..%@.......
0x00, 0x9f, 0xff, 0xff, 0xff, 0xd2, 0x8f, 0xff, 0x70, 0x00, 0x06, 0xf6, 0x00, 0x00, 0x00, //..%@@@@@@@@.%@@@+....+@+.....
0x0c, 0xff, 0xff, 0xb9, 0xbf, 0xff, 0xa1, 0x4c, 0xd5, 0x00, 0x00, 0x3d, 0xa0, 0x00, 0x00, //.@@@@@%%%@@@%.+@@+.....@%....
0xaf, 0xff, 0x70, 0x00, 0x05, 0xfe, 0x00, 0x00, 0x5d, 0xc4, 0x00, 0x00, 0xbd, 0x20, 0x00, //%@@@+....+@@....+@@+....%@...
0xff, 0xf4, 0x00, 0x00, 0x03, 0xff, 0x00, 0x00, 0x00, 0x6e, 0xb3, 0x00, 0x07, 0xe5, 0x00, //@@@.......@@......+@%....+@+.
0xff, 0xa0, 0x00, 0x00, 0x0c, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xa1, 0x00, 0x3e, 0x50, //@@%......@@%........+@%....@+
0xff, 0xc0, 0x00, 0x04, 0xdf, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x01, 0x8e, 0x83, 0x9e, 0x30, //@@@....+@@@...........%@%.%@.
0xff, 0xfe, 0xaa, 0xdf, 0xff, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x9d, 0x71, 0x00, //@@@@%%@@@@+.............%@+..
0x5f, 0xff, 0xff, 0xff, 0xe4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@+...................
0x03, 0xae, 0xfe, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@%+.....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c5 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x5c, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@@+..........
0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, //.......%@@@@@@@@@@@..........
0x00, 0x00, 0x00, 0x8f, 0xff, 0x21, 0x11, 0x11, 0x2f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, //......%@@@.......@@..........
0x00, 0x00, 0x08, 0xfc, 0xff, 0x10, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@@@.......@@..........
0x00, 0x00, 0x8f, 0xc1, 0xff, 0x10, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, //....%@@.@@.......@@..........
0x00, 0x09, 0xfc, 0x10, 0xff, 0x10, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, //...%@@..@@.......@@..........
0x00, 0x9f, 0xc1, 0x00, 0xff, 0x10, 0x00, 0x00, 0x0f, 0xf9, 0xef, 0xff, 0xff, 0xff, 0x70, //..%@@...@@.......@@%@@@@@@@@+
0x09, 0xfc, 0x10, 0x00, 0xff, 0x10, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //.%@@....@@.......@@@@@@@@@@@@
0x6f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x2f, 0xff, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //+@@@@@@@@@.......@@@@......@@
0xdf, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, 0x03, 0xef, 0xdf, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@@@@@@@@%......@@@@@......@@
0xff, 0x21, 0x11, 0x11, 0x00, 0x00, 0x00, 0x3e, 0xfd, 0x1f, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@.............@@@.@@......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x04, 0xff, 0xe2, 0x0f, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@...........+@@@..@@......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x5f, 0xfe, 0x20, 0x0f, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@..........+@@@...@@......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x05, 0xff, 0xf3, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@.........+@@@....@@......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x51, 0x11, 0x1f, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@.........@@@+....@@......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@........%@@@@@@@@@@......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0xef, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x1f, 0xf0, //@@........@@@@@@@@@@+......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@........@@+..............@@
0xff, 0x10, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@........@@+..............@@
0xff, 0x10, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@........@@+..............@@
0xff, 0x20, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@........@@+..............@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@@@@@@@@@@@+..............@@
0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //%@@@@@@@@@@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //..........@@@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //..........+@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c7 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x70, 0x00, 0x00, 0x00, //+@@@@@@@@@@@@@@@@@+......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@%.....
0xff, 0x20, 0xff, 0xff, 0xff, 0x50, 0x00, 0x3f, 0xf3, 0xdf, 0xb0, 0x00, 0x00, //@@..@@@@@@+....@@.@@%....
0xff, 0x10, 0xff, 0xff, 0xff, 0x30, 0x00, 0x1f, 0xf0, 0x1d, 0xfb, 0x00, 0x00, //@@..@@@@@@.....@@..@@%...
0xff, 0x10, 0xff, 0xff, 0xff, 0x30, 0x00, 0x1f, 0xf0, 0x02, 0xef, 0xb0, 0x00, //@@..@@@@@@.....@@...@@%..
0xff, 0x10, 0xff, 0xff, 0xff, 0x30, 0x00, 0x1f, 0xf0, 0x00, 0x2e, 0xfb, 0x00, //@@..@@@@@@.....@@....@@%.
0xff, 0x10, 0xff, 0xff, 0xff, 0x30, 0x00, 0x1f, 0xf0, 0x00, 0x03, 0xff, 0x70, //@@..@@@@@@.....@@.....@@+
0xff, 0x10, 0xff, 0xff, 0xff, 0x30, 0x00, 0x1f, 0xf0, 0x00, 0x00, 0x5f, 0xd0, //@@..@@@@@@.....@@.....+@@
0xff, 0x10, 0xff, 0xff, 0xff, 0x51, 0x11, 0x3f, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@..@@@@@@+....@@......@@
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x1f, 0xf0, //@@..@@@@@@@@@@@@@......@@
0xff, 0x10, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x1f, 0xf0, //@@..+@@@@@@@@@@@+......@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@.....................@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@.....................@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@.....................@@
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, //@@.....................@@
0xff, 0x10, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x1f, 0xf0, //@@..%@@@@@@@@@@@@@@@%..@@
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x1f, 0xf0, //@@..@@@@@@@@@@@@@@@@@..@@
0xff, 0x10, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, //@@..@@.............@@..@@
0xff, 0x10, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, //@@..@@.............@@..@@
0xff, 0x10, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, //@@..@@.............@@..@@
0xff, 0x10, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, //@@..@@.............@@..@@
0xff, 0x10, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, //@@..@@.............@@..@@
0xff, 0x10, 0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, //@@..@@.............@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f0e7 () , Width: 15 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............
0x00, 0x09, 0xee, 0xee, 0xec, 0x00, 0x00, 0x00, //...%@@@@@@.....
0x00, 0x0f, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, //...@@@@@@@.....
0x00, 0x3f, 0xff, 0xff, 0xf6, 0x00, 0x00, 0x00, //...@@@@@@+.....
0x00, 0x7f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, //..+@@@@@@......
0x00, 0xaf, 0xff, 0xff, 0xa0, 0x00, 0x00, 0x00, //..%@@@@@%......
0x00, 0xef, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, //..@@@@@@+......
0x02, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, //..@@@@@@.......
0x06, 0xff, 0xff, 0xf8, 0x00, 0x48, 0xcf, 0x60, //.+@@@@@%..+%@@+
0x0a, 0xff, 0xff, 0xfa, 0xcf, 0xff, 0xff, 0x20, //.%@@@@@%@@@@@@.
0x0e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x00, //.@@@@@@@@@@@@%.
0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x00, //.@@@@@@@@@@@@..
0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //+@@@@@@@@@@@%..
0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, //%@@@@@@@@@@@+..
0xdf, 0xff, 0xd9, 0x5a, 0xff, 0xfc, 0x00, 0x00, //@@@@@%+%@@@@...
0x99, 0x51, 0x00, 0x0d, 0xff, 0xf5, 0x00, 0x00, //%%+....@@@@+...
0x00, 0x00, 0x00, 0x1f, 0xff, 0xd0, 0x00, 0x00, //.......@@@@....
0x00, 0x00, 0x00, 0x5f, 0xff, 0x60, 0x00, 0x00, //......+@@@+....
0x00, 0x00, 0x00, 0x9f, 0xfe, 0x00, 0x00, 0x00, //......%@@@.....
0x00, 0x00, 0x00, 0xdf, 0xf7, 0x00, 0x00, 0x00, //......@@@+.....
0x00, 0x00, 0x01, 0xff, 0xf0, 0x00, 0x00, 0x00, //......@@@......
0x00, 0x00, 0x04, 0xff, 0x80, 0x00, 0x00, 0x00, //.....+@@%......
0x00, 0x00, 0x08, 0xff, 0x10, 0x00, 0x00, 0x00, //.....%@@.......
0x00, 0x00, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, //.....@@%.......
0x00, 0x00, 0x0f, 0xf2, 0x00, 0x00, 0x00, 0x00, //.....@@........
0x00, 0x00, 0x4f, 0xa0, 0x00, 0x00, 0x00, 0x00, //....+@%........
0x00, 0x00, 0x8f, 0x30, 0x00, 0x00, 0x00, 0x00, //....%@.........
0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00, //....%%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............
/*Unicode: U+f0f3 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............+%+............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0xff, 0xf7, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+@@@+...........
0x00, 0x00, 0x00, 0x00, 0x4d, 0xff, 0xff, 0xff, 0xfc, 0x30, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@@.........
0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0x00, 0x01, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, //......@@@@@@@@@@@@@@@......
0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@+.....
0x00, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x0d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x0e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, //....+@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, //....%@@@@@@@@@@@@@@@@@+....
0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@%....
0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x00, 0x00, //...%@@@@@@@@@@@@@@@@@@@%...
0x00, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, //...@@@@@@@@@@@@@@@@@@@@@...
0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //..@@@@@@@@@@@@@@@@@@@@@@%..
0x09, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@%.
0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x3c, 0xee, 0xee, 0xee, 0xef, 0xef, 0xff, 0xff, 0xff, 0xee, 0xee, 0xee, 0xec, 0x20, //.@@@@@@@@@@@@@@@@@@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x09, 0xbb, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, //.........%%%@@@@@%.........
0x00, 0x00, 0x00, 0x00, 0x05, 0xf5, 0xef, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@+@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x58, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@+%@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xef, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%@@@%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f11c () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x10, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x10, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x10, 0xff, 0x10, 0xdf, 0x00, 0xef, 0xe0, 0x0f, 0xe0, 0x0f, 0xd0, 0x0f, 0xf0, 0x0f, 0xf1, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xff, 0x10, 0xff, 0x00, 0xdf, 0x00, 0xef, 0xe0, 0x0f, 0xe0, 0x0f, 0xd0, 0x0f, 0xf0, 0x0f, 0xf1, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x0f, 0xf1, //@@.......................@@..@@.
0xff, 0x10, 0x01, 0x11, 0x00, 0x11, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x2f, 0xf0, 0x0f, 0xf1, //@@.......................@@..@@.
0xff, 0x10, 0xff, 0xff, 0x20, 0xff, 0x00, 0x1f, 0xf0, 0x1f, 0xf0, 0x2f, 0xff, 0xf0, 0x0f, 0xf1, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xff, 0x10, 0xff, 0xff, 0x10, 0xff, 0x00, 0x0f, 0xf0, 0x0f, 0xf0, 0x1f, 0xff, 0xf0, 0x0f, 0xf1, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x10, 0x01, 0x00, 0x01, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x00, 0x01, 0x10, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x10, 0xff, 0x10, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0f, 0xf0, 0x0f, 0xf1, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xff, 0x10, 0xff, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0f, 0xf0, 0x0f, 0xf1, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, //@@...........................@@.
0xff, 0x21, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f, 0xf1, //@@...........................@@.
0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x40, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f124 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 0x40, //.....................%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xff, 0xb0, //...................%@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xff, 0xff, 0x50, //.................%@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xff, 0xff, 0xfc, 0x00, //...............%@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xff, 0xff, 0xff, 0xf5, 0x00, //.............%@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //...........%@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, //.........%@@@@@@@@@@+..
0x00, 0x00, 0x00, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, //.......%@@@@@@@@@@@@...
0x00, 0x00, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x00, 0x00, //.....%@@@@@@@@@@@@@+...
0x00, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, //...%@@@@@@@@@@@@@@@....
0x2b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@+....
0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@.....
0x7b, 0xbb, 0xbb, 0xbb, 0xbb, 0xef, 0xff, 0xff, 0xf4, 0x00, 0x00, 0x00, //+%%%%%%%%%@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, //..........%@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, //..........%@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xf4, 0x00, 0x00, 0x00, 0x00, //..........%@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, //..........%@@@@........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, //..........%@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f15b () , Width: 25 */
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x10, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@@@@@@+..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x68, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+%.......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x6f, 0x80, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@%......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x6f, 0xf8, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@%.....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x6f, 0xff, 0x80, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@@%....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x6f, 0xff, 0xf8, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@@@%...
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x6f, 0xff, 0xff, 0x80, 0x00, //@@@@@@@@@@@@@@+.+@@@@@%..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x6f, 0xff, 0xff, 0xf8, 0x00, //@@@@@@@@@@@@@@+.+@@@@@@%.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x14, 0x44, 0x44, 0x44, 0x00, //@@@@@@@@@@@@@@+..+++++++.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@%..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xaa, 0xaa, 0xaa, 0xaa, 0x80, //@@@@@@@@@@@@@@@@%%%%%%%%%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, //@@@@@@@@@@@@@@@@@@@@@@@@@
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x60, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f1eb () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0xbd, 0xef, 0xfe, 0xca, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+%%@@@@@@%+...........
0x00, 0x00, 0x00, 0x04, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x20, 0x00, 0x00, 0x00, //.......+%@@@@@@@@@@@@@@%........
0x00, 0x00, 0x05, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x30, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@@@@@%......
0x00, 0x02, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x00, 0x00, //....%@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x5f, 0xff, 0xff, 0xff, 0xfb, 0x75, 0x32, 0x23, 0x58, 0xcf, 0xff, 0xff, 0xff, 0xd3, 0x00, //..+@@@@@@@@%++....+%@@@@@@@@@...
0x08, 0xff, 0xff, 0xff, 0xd6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8f, 0xff, 0xff, 0xff, 0x50, //.%@@@@@@@+............%@@@@@@@+.
0x8f, 0xff, 0xff, 0xf7, 0x00, 0x00, 0x00, 0x12, 0x10, 0x00, 0x00, 0x01, 0x9f, 0xff, 0xff, 0xf5, //%@@@@@@+................%@@@@@@+
0xcf, 0xff, 0xfc, 0x10, 0x00, 0x38, 0xcf, 0xff, 0xff, 0xeb, 0x72, 0x00, 0x03, 0xef, 0xff, 0xf9, //@@@@@@.....%@@@@@@@%+.....@@@@@%
0x1e, 0xff, 0x90, 0x00, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x00, 0x1c, 0xff, 0xb0, //.@@@%...+@@@@@@@@@@@@@@+...@@@%.
0x02, 0xd7, 0x00, 0x4d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x00, 0xab, 0x00, //..@+..+@@@@@@@@@@@@@@@@@@...%%..
0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@@@@@@+.....
0x00, 0x00, 0x7f, 0xff, 0xff, 0xfd, 0x84, 0x10, 0x02, 0x48, 0xdf, 0xff, 0xff, 0xf3, 0x00, 0x00, //....+@@@@@@@%+....+%@@@@@@@.....
0x00, 0x00, 0x1d, 0xff, 0xfc, 0x40, 0x00, 0x01, 0x10, 0x00, 0x06, 0xdf, 0xff, 0xa0, 0x00, 0x00, //.....@@@@@...........+@@@@%.....
0x00, 0x00, 0x01, 0xce, 0x50, 0x02, 0x8d, 0xff, 0xff, 0xc7, 0x10, 0x09, 0xfa, 0x00, 0x00, 0x00, //......@@+...%@@@@@%+...%@%......
0x00, 0x00, 0x00, 0x00, 0x01, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x10, 0x00, 0x00, 0x00, //..........%@@@@@@@@@@+..........
0x00, 0x00, 0x00, 0x00, 0x1d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xe8, 0x30, 0x04, 0x9f, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@%....%@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+........+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xbf, 0xea, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..............%@@%..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xff, 0xff, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............%@@@@+.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..............@@@%..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............%%...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f240 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x60, 0x0f, 0xf1, 0x00, //@@..+++++++++++++++++++++++++++..@@...
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xf7, 0x10, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@+..
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xff, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x03, 0x3f, 0xf1, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x03, 0x3f, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xff, 0xf0, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xfd, 0x40, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@+.
0xff, 0x10, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xf1, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f241 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x40, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@..+++++++++++++++++++++........@@...
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x0f, 0xf7, 0x10, //@@..@@@@@@@@@@@@@@@@@@@@%........@@+..
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xc0, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf1, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf2, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x0f, 0xfd, 0x40, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@+.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f242 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@..++++++++++++++...............@@...
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf7, 0x10, //@@..@@@@@@@@@@@@@@+..............@@+..
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xc0, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf1, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf2, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xfd, 0x40, //@@..@@@@@@@@@@@@@@+..............@@@+.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@..@@@@@@@@@@@@@@+..............@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f243 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x66, 0x66, 0x66, 0x66, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@..++++++++.....................@@...
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf7, 0x10, //@@..@@@@@@@@+....................@@+..
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xc0, //@@..@@@@@@@@+....................@@@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf1, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf2, //@@..@@@@@@@@+......................@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, //@@..@@@@@@@@+....................@@@@.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xfd, 0x40, //@@..@@@@@@@@+....................@@@+.
0xff, 0x10, 0xff, 0xff, 0xff, 0xff, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@..@@@@@@@@+....................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f244 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x10, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf5, 0x00, //@@...............................@@+..
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xa0, //@@...............................@@@%.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf1, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf2, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3f, 0xf2, //@@.................................@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, //@@...............................@@@@.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xfe, 0x50, //@@...............................@@@+.
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf1, 0x00, //@@...............................@@...
0xff, 0x31, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x2f, 0xf0, 0x00, //@@...............................@@...
0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x20, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f293 () , Width: 22 */
0x00, 0x00, 0x00, 0x5a, 0xde, 0xff, 0xeb, 0x82, 0x00, 0x00, 0x00, //......+%@@@@@%%.......
0x00, 0x00, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x00, 0x00, //....+@@@@@@@@@@@%.....
0x00, 0x08, 0xff, 0xff, 0xfc, 0xbf, 0xff, 0xff, 0xfe, 0x20, 0x00, //...%@@@@@@%@@@@@@@....
0x00, 0x6f, 0xff, 0xff, 0xfb, 0x0b, 0xff, 0xff, 0xff, 0xe0, 0x00, //..+@@@@@@%.%@@@@@@@...
0x01, 0xff, 0xff, 0xff, 0xfb, 0x00, 0xbf, 0xff, 0xff, 0xf9, 0x00, //..@@@@@@@%..%@@@@@@%..
0x08, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x0b, 0xff, 0xff, 0xff, 0x10, //.%@@@@@@@%...%@@@@@@..
0x0e, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x70, //.@@@@@@@@%....%@@@@@+.
0x3f, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x50, 0x0a, 0xff, 0xff, 0xb0, //.@@@@@@@@%..+..%@@@@%.
0x7f, 0xff, 0xd1, 0xaf, 0xfb, 0x00, 0xf5, 0x00, 0xaf, 0xff, 0xf0, //+@@@@.%@@%..@+..%@@@@.
0x9f, 0xff, 0x60, 0x0a, 0xfb, 0x00, 0xff, 0x20, 0x0d, 0xff, 0xf2, //%@@@+..%@%..@@...@@@@.
0xcf, 0xff, 0xf5, 0x00, 0xab, 0x00, 0xf7, 0x00, 0x8f, 0xff, 0xf4, //%@@@@+..%%..@+..%@@@@+
0xdf, 0xff, 0xff, 0x50, 0x06, 0x00, 0x70, 0x08, 0xff, 0xff, 0xf6, //@@@@@@+..+..+..%@@@@@+
0xef, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x8f, 0xff, 0xff, 0xf7, //@@@@@@@+......%@@@@@@+
0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x08, 0xff, 0xff, 0xff, 0xf7, //@@@@@@@@+....%@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xf1, 0x00, 0x4f, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@...+@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x08, 0xff, 0xff, 0xff, 0xf7, //@@@@@@@@+....%@@@@@@@+
0xef, 0xff, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x8f, 0xff, 0xff, 0xf7, //@@@@@@@+......%@@@@@@+
0xdf, 0xff, 0xff, 0x50, 0x06, 0x00, 0x70, 0x08, 0xff, 0xff, 0xf6, //@@@@@@+..+..+..%@@@@@+
0xcf, 0xff, 0xf5, 0x00, 0xab, 0x00, 0xf7, 0x00, 0x8f, 0xff, 0xf4, //%@@@@+..%%..@+..%@@@@+
0x9f, 0xff, 0x60, 0x0a, 0xfb, 0x00, 0xff, 0x20, 0x0d, 0xff, 0xf2, //%@@@+..%@%..@@...@@@@.
0x7f, 0xff, 0xd1, 0xaf, 0xfb, 0x00, 0xf5, 0x00, 0xaf, 0xff, 0xf0, //+@@@@.%@@%..@+..%@@@@.
0x3f, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x50, 0x0a, 0xff, 0xff, 0xb0, //.@@@@@@@@%..+..%@@@@%.
0x0e, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, 0xaf, 0xff, 0xff, 0x70, //.@@@@@@@@%....%@@@@@+.
0x08, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x0b, 0xff, 0xff, 0xff, 0x10, //.%@@@@@@@%...%@@@@@@..
0x01, 0xff, 0xff, 0xff, 0xfb, 0x00, 0xbf, 0xff, 0xff, 0xf9, 0x00, //..@@@@@@@%..%@@@@@@%..
0x00, 0x6f, 0xff, 0xff, 0xfb, 0x0b, 0xff, 0xff, 0xff, 0xe0, 0x00, //..+@@@@@@%.%@@@@@@@...
0x00, 0x08, 0xff, 0xff, 0xfc, 0xbf, 0xff, 0xff, 0xfe, 0x20, 0x00, //...%@@@@@@%@@@@@@@....
0x00, 0x00, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x00, 0x00, //....+@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x5a, 0xde, 0xff, 0xec, 0x82, 0x00, 0x00, 0x00, //......+%@@@@@%%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................
#elif USE_LV_FONT_SYMBOL_30 == 8
/*Unicode: U+f001 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x48, 0x94, 0xba, 0x4c, //.....................+%%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x60, 0xae, 0xf2, 0xff, 0xff, 0xff, 0xee, //..................+%@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x7a, 0xc8, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //...............+@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x48, 0x94, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //...........+%@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0xae, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //.........%@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xff, 0xff, //........@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xbc, 0x70, 0x24, 0x12, 0xff, 0xff, //........@@@@@@@@@@@%+..@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa2, 0x56, 0x0e, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //........@@@@@@@@%+.....@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x88, 0x3c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //........@@@@@%.........@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x76, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //........@@+............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x2c, 0x24, 0x08, 0x12, 0xff, 0xff, //........@@.............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x06, 0x72, 0xcc, 0xff, 0xff, 0xff, 0xf8, 0xc0, 0xff, 0xff, //........@@......+@@@@@%@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x02, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //........@@.....@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x46, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //........@@....+@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x38, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //........@@.....@@@@@@@@@@
0x00, 0x44, 0xa2, 0xe8, 0xff, 0xfc, 0xe2, 0x98, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x98, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x44, //.+%@@@@%@@.....%@@@@@@@@+
0x92, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x98, 0xd8, 0xf4, 0xec, 0xc4, 0x7a, 0x18, 0x00, //%@@@@@@@@@.......%@@@@+..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@...............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@...............
0xa6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@+...............
0x00, 0x5a, 0xb6, 0xf6, 0xff, 0xff, 0xec, 0xa4, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+%@@@@%.................
0x00, 0x00, 0x00, 0x00, 0x16, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f008 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xba, 0x1e, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xf6, 0xff, 0x5a, 0x0e, 0x0e, 0x4a, 0xff, 0xff, 0x64, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x66, 0xff, 0xff, 0x4a, 0x0e, 0x0e, 0x4a, 0xff, 0xff, 0x0a, //@@+..+@@+.............+@@+..+@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x4a, 0x00, 0x00, 0x38, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x38, 0x00, 0x00, 0x38, 0xff, 0xff, 0x12, //@@+...@@...............@@....@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0x6a, 0x12, 0x12, 0x5a, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x5a, 0x12, 0x12, 0x5a, 0xff, 0xff, 0x12, //@@+..+@@...............@@+..+@@.
0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x6a, 0x12, 0x12, 0x5a, 0xff, 0xff, 0x64, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x68, 0xff, 0xff, 0x5a, 0x12, 0x12, 0x5a, 0xff, 0xff, 0x12, //@@+..+@@+.............+@@+..+@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0x4c, 0x00, 0x00, 0x3a, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xff, 0xff, 0x3a, 0x00, 0x00, 0x3a, 0xff, 0xff, 0x12, //@@+...@@+.............+@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x5a, 0x0e, 0x0e, 0x4a, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x4a, 0x0e, 0x0e, 0x4a, 0xff, 0xff, 0x12, //@@+..+@@...............@@+..+@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, //@@@@@@@@...............@@@@@@@@.
0xff, 0xff, 0x4c, 0x00, 0x00, 0x3a, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x3a, 0x00, 0x00, 0x3a, 0xff, 0xff, 0x12, //@@+...@@...............@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@...............@@....@@.
0xf6, 0xff, 0x4c, 0x00, 0x00, 0x3a, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xff, 0xff, 0x3a, 0x00, 0x00, 0x3a, 0xff, 0xff, 0x0c, //@@+...@@+.............+@@....@@.
0xba, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x1e, 0xc2, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x26, 0x00, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x08, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f00b () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xba, 0x06, 0x00, 0x36, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7e, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x9a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0x00, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x10, 0x00, 0x52, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0x00, 0x2a, 0x32, 0x32, 0x32, 0x32, 0x30, 0x0a, 0x00, 0x00, 0x00, 0x1a, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x2a, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x02, 0x2e, 0x36, 0x36, 0x36, 0x36, 0x34, 0x0c, 0x00, 0x00, 0x00, 0x1e, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x2e, 0x02, //.............................
0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x10, 0x00, 0x54, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0x00, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x9a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xba, 0x06, 0x00, 0x36, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7e, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x02, 0x2e, 0x36, 0x36, 0x36, 0x36, 0x34, 0x0c, 0x00, 0x00, 0x00, 0x1e, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x2e, 0x02, //.............................
0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x10, 0x00, 0x54, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, //%@@@@@@@..+@@@@@@@@@@@@@@@@@%
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0x00, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.%@@@@@@@@@@@@@@@@@@
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x9a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, //@@@@@@@@..%@@@@@@@@@@@@@@@@@@
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xba, 0x06, 0x00, 0x36, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7e, //+@@@@@@%...@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f00c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x62, 0x0c, 0x00, 0x00, //.....................+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xce, 0x12, 0x00, //...................+@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xce, 0x12, //..................+@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, //.................+@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //................+@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, //...............+@@@@@@@@+
0x00, 0x00, 0x1c, 0x86, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, //...%+.........+@@@@@@@@+.
0x00, 0x22, 0xe2, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, //..@@@+.......+@@@@@@@@+..
0x22, 0xe2, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, //.@@@@@+.....+@@@@@@@@+...
0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+...+@@@@@@@@+....
0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@+.+@@@@@@@@+.....
0x5a, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@%@@@@@@@@+......
0x00, 0x5c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+@@@@@@@@@@@@@@@+.......
0x00, 0x00, 0x5c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..+@@@@@@@@@@@@@+........
0x00, 0x00, 0x00, 0x5c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x5c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@+............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xfc, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@+.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xb6, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+%+..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f00d () , Width: 20 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x8c, 0xf2, 0x9c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xbe, 0xee, 0x62, 0x00, 0x00, //...%@%.........%@+..
0x00, 0x00, 0x98, 0xff, 0xff, 0xff, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xce, 0xff, 0xff, 0xfc, 0x64, 0x00, //..%@@@%.......@@@@+.
0x00, 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x12, 0xce, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5e, //.%@@@@@%.....@@@@@@+
0x26, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x02, 0x00, 0x12, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, //.@@@@@@@%...@@@@@@@@
0x0e, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa6, 0x16, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, //.@@@@@@@@%.@@@@@@@@%
0x00, 0x32, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x14, //..@@@@@@@@@@@@@@@@@.
0x00, 0x00, 0x32, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x14, 0x00, //...@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x32, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x14, 0x00, 0x00, //....@@@@@@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0x32, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x14, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x18, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x12, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x02, 0x00, 0x00, 0x00, //.....@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x12, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x02, 0x00, 0x00, //....@@@@@@@@@@@@%...
0x00, 0x00, 0x10, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x02, 0x00, //...@@@@@@@@@@@@@@%..
0x00, 0x10, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x02, //..@@@@@@@@@@@@@@@@%.
0x04, 0xca, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x46, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x96, //.@@@@@@@@@+@@@@@@@@%
0x2a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x14, 0x00, 0x30, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, //.@@@@@@@@...@@@@@@@@
0x02, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x14, 0x00, 0x00, 0x00, 0x30, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //.@@@@@@@.....@@@@@@%
0x00, 0x0e, 0xc6, 0xff, 0xff, 0xff, 0xd2, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xec, 0xff, 0xff, 0xff, 0x9e, 0x00, //..@@@@@.......@@@@%.
0x00, 0x00, 0x0e, 0xc4, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xea, 0xff, 0x9c, 0x00, 0x00, //...@@@.........@@%..
0x00, 0x00, 0x00, 0x02, 0x2e, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x2a, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....................
/*Unicode: U+f011 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xdc, 0xe6, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xff, 0xff, 0xf4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@...........
0x00, 0x00, 0x00, 0x00, 0x0c, 0x82, 0x9e, 0x36, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x26, 0x98, 0x8e, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%%...@@@@...%%......
0x00, 0x00, 0x00, 0x1c, 0xd2, 0xff, 0xff, 0xf2, 0x14, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x04, 0xde, 0xff, 0xff, 0xe4, 0x2e, 0x00, 0x00, 0x00, 0x00, //....@@@@..@@@@..@@@@.....
0x00, 0x00, 0x14, 0xd8, 0xff, 0xff, 0xff, 0xff, 0x3a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x16, 0xff, 0xff, 0xff, 0xff, 0xea, 0x24, 0x00, 0x00, 0x00, //...@@@@@..@@@@..@@@@@....
0x00, 0x00, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x06, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x06, 0x00, 0x00, //..%@@@@@..@@@@..%@@@@@...
0x00, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x1a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x0e, 0xc2, 0xff, 0xff, 0xff, 0xff, 0x7a, 0x00, 0x00, //.+@@@@@...@@@@...@@@@@+..
0x00, 0xdc, 0xff, 0xff, 0xff, 0xe2, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x08, 0xce, 0xff, 0xff, 0xff, 0xf0, 0x0c, 0x00, //.@@@@@....@@@@....@@@@@..
0x48, 0xff, 0xff, 0xff, 0xff, 0x4a, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x30, 0xfa, 0xff, 0xff, 0xff, 0x68, 0x00, //+@@@@+....@@@@.....@@@@+.
0x94, 0xff, 0xff, 0xff, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0xac, 0xff, 0xff, 0xff, 0xb8, 0x00, //%@@@@.....@@@@.....%@@@%.
0xcc, 0xff, 0xff, 0xff, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xff, 0xff, 0xff, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x50, 0xff, 0xff, 0xff, 0xee, 0x00, //@@@@+.....@@@@.....+@@@@.
0xee, 0xff, 0xff, 0xff, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xc2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xff, 0xff, 0xff, 0xff, 0x10, //@@@@+.....%@@@......@@@@.
0xfa, 0xff, 0xff, 0xff, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x5c, 0x66, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0xff, 0xff, 0x1e, //@@@@.......++.......@@@@.
0xea, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff, 0xff, 0x0c, //@@@@................@@@@.
0xd0, 0xff, 0xff, 0xff, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xff, 0xff, 0xff, 0xf4, 0x00, //@@@@+...............@@@@.
0xa4, 0xff, 0xff, 0xff, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xc6, 0x00, //%@@@%..............%@@@@.
0x56, 0xff, 0xff, 0xff, 0xf8, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xe8, 0xff, 0xff, 0xff, 0x7a, 0x00, //+@@@@..............@@@@+.
0x0c, 0xf0, 0xff, 0xff, 0xff, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0xff, 0xff, 0xff, 0xfc, 0x26, 0x00, //.@@@@%............%@@@@..
0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x00, 0x00, //.+@@@@+..........+@@@@%..
0x00, 0x0c, 0xe6, 0xff, 0xff, 0xff, 0xff, 0x9c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x82, 0xfc, 0xff, 0xff, 0xff, 0xf4, 0x22, 0x00, 0x00, //..@@@@@%........%@@@@@...
0x00, 0x00, 0x3c, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xec, 0x8e, 0x42, 0x20, 0x1e, 0x3a, 0x82, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, //...@@@@@@%+...%@@@@@@+...
0x00, 0x00, 0x00, 0x5e, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@+....
0x00, 0x00, 0x00, 0x00, 0x42, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x98, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......%@@@@@@@@@@%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x72, 0xc2, 0xea, 0xfc, 0xff, 0xee, 0xca, 0x7e, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f013 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xff, 0xff, 0xff, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x38, 0xb4, 0x32, 0x00, 0x00, 0x42, 0xff, 0xff, 0xff, 0xff, 0xff, 0x38, 0x00, 0x00, 0x32, 0xb4, 0x30, 0x00, 0x00, 0x00, 0x00, //.....%...+@@@@@....%.....
0x00, 0x00, 0x00, 0x42, 0xf4, 0xff, 0xf6, 0x62, 0x18, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9c, 0x18, 0x6a, 0xf8, 0xff, 0xee, 0x36, 0x00, 0x00, 0x00, //...+@@@+.%@@@@@%.+@@@....
0x00, 0x00, 0x36, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xee, 0x2c, 0x00, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0x00, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x00, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x00, 0x00, 0x2a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x24, 0x00, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0x00, 0x00, 0x58, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x00, 0x1a, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x6a, 0x4c, 0x6a, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x1a, 0x00, 0x00, 0x00, //....@@@@@@@+++@@@@@@@....
0x00, 0x18, 0x40, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0x30, 0x08, 0x00, //...%@@@@@%.....%@@@@@%...
0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xcc, //@@@@@@@@@.......@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.......+@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@+.......+@@@@@@@@
0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, //@@@@@@@@@.......@@@@@@@@@
0x00, 0x16, 0x3c, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0x4c, 0x24, 0x02, //...%@@@@@%.....%@@@@@%+..
0x00, 0x00, 0x00, 0x1e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xba, 0x58, 0x3c, 0x58, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x24, 0x00, 0x00, 0x00, //....@@@@@@%+.+%@@@@@@....
0x00, 0x00, 0x00, 0x44, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x1c, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x24, 0x00, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0x00, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x00, 0x00, //..%@@@@@@@@@@@@@@@@@@@%..
0x00, 0x00, 0x38, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x40, 0x00, 0x00, //...@@@@@@@@@@@@@@@@@@@...
0x00, 0x00, 0x00, 0x44, 0xf4, 0xff, 0xfc, 0x7e, 0x2a, 0xa8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0x28, 0x78, 0xfa, 0xff, 0xfa, 0x50, 0x00, 0x00, 0x00, //...+@@@+.%@@@@@%.+@@@+...
0x00, 0x00, 0x00, 0x00, 0x3a, 0xc6, 0x40, 0x00, 0x00, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0x00, 0x00, 0x42, 0xc8, 0x46, 0x00, 0x00, 0x00, 0x00, //.....@....@@@@@+..+@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0xff, 0xff, 0xff, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x12, 0x12, 0x12, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f014 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......%@@@@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@@@@@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd2, 0xff, 0x76, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xaa, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@+.....%@%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0xff, 0xee, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xff, 0xf6, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@.......@@......
0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, //@@@@@@@@@@@@@@@@@@@@@@%
0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xba, //@@@@@@@@@@@@@@@@@@@@@@%
0x08, 0x0e, 0xec, 0xff, 0x30, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x64, 0xff, 0xba, 0x0e, 0x04, //..@@..............+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..............+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..............+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0x34, 0x58, 0x08, 0x00, 0x26, 0x5a, 0x12, 0x00, 0x1a, 0x5a, 0x1e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@...+...+...+..+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc4, 0xff, 0x44, 0x00, 0xa0, 0xff, 0x68, 0x00, 0x7c, 0xff, 0x8c, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xc6, 0xff, 0x46, 0x00, 0xa2, 0xff, 0x6a, 0x00, 0x7e, 0xff, 0x8e, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..@@+.%@+.+@%.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0xb4, 0xfc, 0x36, 0x00, 0x90, 0xff, 0x58, 0x00, 0x6c, 0xff, 0x7a, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..%@..%@+.+@+.+@%..
0x00, 0x00, 0xea, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xb6, 0x00, 0x00, //..@@..............+@%..
0x00, 0x00, 0xe8, 0xff, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xff, 0xb4, 0x00, 0x00, //..@@..............+@%..
0x00, 0x00, 0xce, 0xff, 0x56, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x8e, 0xff, 0x96, 0x00, 0x00, //..@@+.............%@%..
0x00, 0x00, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, //..+@@@@@@@@@@@@@@@@@...
0x00, 0x00, 0x06, 0xa2, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x74, 0x00, 0x00, 0x00, //...%@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x02, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f015 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xb8, 0x78, 0x02, 0x00, 0x00, 0x0c, 0xae, 0xb6, 0xb6, 0xa2, 0x00, 0x00, 0x00, 0x00, //............+%+....%%%%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xb0, 0xff, 0xff, 0xff, 0xba, 0x12, 0x00, 0x22, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //...........%@@@%...@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xd0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, 0x2c, 0x22, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@@..@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xe8, 0xff, 0xff, 0xca, 0x34, 0xc8, 0xff, 0xff, 0xf4, 0x78, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //.........@@@@.@@@@+@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xf8, 0xff, 0xff, 0xa8, 0x0c, 0x5e, 0x0c, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //.......+@@@%.+.%@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0x80, 0x14, 0xbe, 0xff, 0xbe, 0x14, 0x76, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //......%@@@+.%@%.+@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x0c, 0xb2, 0xff, 0xff, 0xf4, 0x56, 0x2e, 0xde, 0xff, 0xff, 0xff, 0xde, 0x2e, 0x4a, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //.....%@@@+.@@@@@.+@@@@@....
0x00, 0x00, 0x00, 0x20, 0xd2, 0xff, 0xff, 0xe4, 0x34, 0x56, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x56, 0x28, 0xda, 0xff, 0xff, 0xff, 0x34, 0x00, 0x00, 0x00, //....@@@@.+@@@@@@@+.@@@@....
0x00, 0x00, 0x3c, 0xea, 0xff, 0xff, 0xca, 0x1c, 0x86, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x86, 0x12, 0xba, 0xff, 0xff, 0xf6, 0x58, 0x00, 0x00, //...@@@@.%@@@@@@@@@%.%@@@+..
0x00, 0x60, 0xf8, 0xff, 0xff, 0xaa, 0x18, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x12, 0x92, 0xff, 0xff, 0xff, 0x84, 0x00, //.+@@@%.%@@@@@@@@@@@%.%@@@%.
0x5e, 0xff, 0xff, 0xff, 0x80, 0x28, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x26, 0x62, 0xf8, 0xff, 0xff, 0x8a, //+@@@+.@@@@@@@@@@@@@@@.+@@@%
0x24, 0xee, 0xf4, 0x56, 0x4c, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x4c, 0x3c, 0xe8, 0xfa, 0x44, //.@@++@@@@@@@@@@@@@@@@@+.@@+
0x00, 0x32, 0x2e, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x1c, 0x44, 0x00, //....@@@@@@@@@@@@@@@@@@@..+.
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0xc6, 0xc6, 0xc6, 0xd4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@.....@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x00, 0x00, //....%@@@@@@.....@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f019 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xb2, 0xb6, 0xb6, 0xb6, 0xb0, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%%%%%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x6c, 0x6e, 0x6e, 0x6e, 0xca, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x6e, 0x6e, 0x6e, 0x6a, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, //......++++@@@@@@%++++......
0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xfa, 0xff, 0xff, 0xff, 0xf4, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@@@@@...........
0x00, 0x1a, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x04, 0x00, 0x50, 0xfa, 0xff, 0xf2, 0x3e, 0x00, 0x06, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1a, 0x00, //...........+@@@............
0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x06, 0x00, 0x4e, 0xc8, 0x3c, 0x00, 0x0a, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, //%@@@@@@@@%..+@...%@@@@@@@@%
0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xba, 0x08, 0x00, 0x00, 0x00, 0x0e, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, //@@@@@@@@@@%.....@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x5c, 0x36, 0x60, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@@@+.+@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x12, 0x50, 0xff, 0xff, 0x36, 0x46, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x26, 0x62, 0xff, 0xff, 0x4a, 0x58, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@.+@@++@@
0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x82, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x82, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f01c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x5e, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x40, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x08, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0x00, 0x64, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0x00, 0xd0, 0xff, 0xff, 0x90, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0xb0, 0xff, 0xff, 0xaa, 0x00, 0x00, 0x00, //...@@@%...........%@@%...
0x00, 0x00, 0x3e, 0xff, 0xff, 0xfc, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0xff, 0xff, 0xfa, 0x1a, 0x00, 0x00, //...@@@............+@@@...
0x00, 0x00, 0xaa, 0xff, 0xff, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xff, 0xff, 0x84, 0x00, 0x00, //..%@@%.............@@@%..
0x00, 0x1a, 0xfa, 0xff, 0xff, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xff, 0xff, 0xe8, 0x06, 0x00, //..@@@+.............+@@@..
0x00, 0x84, 0xff, 0xff, 0xde, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf4, 0xff, 0xff, 0x5e, 0x00, //.%@@@...............@@@+.
0x06, 0xe8, 0xff, 0xff, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0xff, 0xff, 0xca, 0x00, //.@@@+...............%@@@.
0x5e, 0xff, 0xff, 0xf6, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0xff, 0xff, 0xff, 0x38, //+@@@.................@@@.
0xbc, 0xff, 0xff, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xff, 0xff, 0x96, //%@@%.................@@@%
0xf0, 0xff, 0xff, 0x86, 0x52, 0x52, 0x52, 0x52, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x52, 0x52, 0x52, 0x52, 0x9e, 0xff, 0xff, 0xcc, //@@@%++++.........++++%@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@%.......@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@......+@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0x36, 0x36, 0x36, 0x36, 0x36, 0xd4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@%.....@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f021 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x62, 0xa4, 0xda, 0xf2, 0xff, 0xee, 0xd4, 0x9a, 0x4e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x82, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x6e, 0x06, 0x00, 0x00, 0x1a, 0xd0, 0xbc, //......%@@@@@@@@@@@+....@%
0x00, 0x00, 0x00, 0x00, 0x30, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x24, 0x1c, 0xda, 0xff, 0xff, //.....@@@@@@@@@@@@@@@..@@@
0x00, 0x00, 0x00, 0x3c, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xe0, 0xff, 0xff, 0xff, //....@@@@@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x28, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xac, 0x5c, 0x2e, 0x1e, 0x30, 0x5a, 0xa6, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //...@@@@@@%+...+%@@@@@@@@@
0x00, 0x06, 0xd4, 0xff, 0xff, 0xff, 0xff, 0xce, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //..@@@@@@.........%@@@@@@@
0x00, 0x72, 0xff, 0xff, 0xff, 0xff, 0xac, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //.+@@@@%...........@@@@@@@
0x08, 0xea, 0xff, 0xff, 0xff, 0xd0, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //.@@@@@...........@@@@@@@@
0x50, 0xff, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //+@@@@...........@@@@@@@@@
0x9c, 0xff, 0xff, 0xff, 0xba, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //%@@@%...........@@@@@@@@@
0x28, 0x52, 0x52, 0x52, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x24, //.+++.............+++++++.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x3a, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x6e, 0x6e, 0x6e, 0x2c, //.++++++++............+++.
0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xff, 0xff, 0xff, 0x78, //@@@@@@@@@+..........@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xff, 0xff, 0xff, 0xff, 0x2a, //@@@@@@@@@...........@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xd6, 0xff, 0xff, 0xff, 0xce, 0x00, //@@@@@@@@...........@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xb0, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, //@@@@@@@...........%@@@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xd0, 0xff, 0xff, 0xff, 0xff, 0xba, 0x00, 0x00, //@@@@@@@@.........@@@@@%..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xa8, 0x58, 0x2a, 0x16, 0x26, 0x54, 0xa8, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x18, 0x00, 0x00, //@@@@@@@@@%+...+%@@@@@@...
0xff, 0xff, 0xff, 0xe2, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@@@....
0xff, 0xff, 0xde, 0x1e, 0x2e, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x26, 0x00, 0x00, 0x00, 0x00, //@@@..@@@@@@@@@@@@@@@.....
0xc6, 0xd8, 0x1e, 0x00, 0x00, 0x0c, 0x82, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x7e, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, //@@....%@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x62, 0xae, 0xe4, 0xfa, 0xff, 0xfa, 0xe4, 0xac, 0x66, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+%@@@@@%+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f026 () , Width: 13 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xee, 0x34, //..........+@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0xff, 0xff, 0x6a, //.........%@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0x6a, //........%@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xff, 0x6a, //.......%@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //......%@@@@@+
0x1e, 0x4a, 0x4a, 0x4a, 0x4a, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //.++++%@@@@@@+
0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //@@@@@@@@@@@@+
0xbc, 0xfa, 0xfa, 0xfa, 0xfa, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //%@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, //......@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xff, 0x6a, //.......@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0x6a, //........@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0xff, 0x6a, //.........@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0x66, //..........@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x9e, 0x16, //...........%.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............
/*Unicode: U+f027 () , Width: 19 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xee, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........%@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......%@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......%@@@@@+......
0x1e, 0x4a, 0x4a, 0x4a, 0x4a, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.++++%@@@@@@+......
0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x06, 0xda, 0xe0, 0x4a, 0x00, //@@@@@@@@@@@@+..@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x02, 0xd2, 0xff, 0xf8, 0x38, //@@@@@@@@@@@@+..@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x06, 0xa4, 0xff, 0xb8, //@@@@@@@@@@@@+...%@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x24, 0xff, 0xf0, //@@@@@@@@@@@@+....@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x3a, 0xff, 0xe4, //@@@@@@@@@@@@+....@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x32, 0xda, 0xff, 0x96, //@@@@@@@@@@@@+...@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x08, 0xf6, 0xff, 0xdc, 0x14, //@@@@@@@@@@@@+..@@@.
0xbc, 0xfa, 0xfa, 0xfa, 0xfa, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x8c, 0x90, 0x14, 0x00, //%@@@@@@@@@@@+..%%..
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x9e, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...................
/*Unicode: U+f028 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0xec, 0x7e, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, //..................+@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0xff, 0xff, 0xda, 0x32, 0x00, 0x00, 0x00, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xc8, 0xff, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0xdc, 0xff, 0xf4, 0x40, 0x00, 0x00, 0x00, //..........@@+......+@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xc8, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x20, 0x04, 0x00, 0x08, 0xb8, 0xff, 0xf4, 0x2a, 0x00, 0x00, //.........@@@+........%@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xca, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x3c, 0xff, 0xde, 0x4a, 0x00, 0x06, 0xb4, 0xff, 0xd4, 0x06, 0x00, //........@@@@+....@@+..%@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xca, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x1e, 0xe0, 0xff, 0xff, 0x72, 0x00, 0x10, 0xe8, 0xff, 0x72, 0x00, //.......@@@@@+....@@@+..@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x08, 0x92, 0xff, 0xff, 0x4e, 0x00, 0x58, 0xff, 0xec, 0x06, //......@@@@@@+.....%@@+.+@@.
0x66, 0xa2, 0xa2, 0xa2, 0xa2, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x40, 0x2e, 0x00, 0x00, 0x8a, 0xff, 0xe6, 0x0a, 0x00, 0xd8, 0xff, 0x54, //+%%%%@@@@@@@+......%@@..@@+
0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x24, 0xff, 0xfc, 0x8e, 0x00, 0x04, 0xd6, 0xff, 0x6a, 0x00, 0x82, 0xff, 0x9c, //@@@@@@@@@@@@+..@@%..@@+.%@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x02, 0x98, 0xfc, 0xff, 0x66, 0x00, 0x6c, 0xff, 0xbc, 0x00, 0x42, 0xff, 0xd2, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xd2, 0x00, 0x2c, 0xff, 0xea, 0x00, 0x1e, 0xff, 0xec, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x1e, 0xff, 0xf4, 0x00, 0x16, 0xff, 0xfa, 0x00, 0x12, 0xff, 0xfa, //@@@@@@@@@@@@+....@@..@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x6c, 0xff, 0xd2, 0x00, 0x2c, 0xff, 0xea, 0x00, 0x1e, 0xff, 0xec, //@@@@@@@@@@@@+...+@@..@@..@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x02, 0x94, 0xfc, 0xff, 0x66, 0x00, 0x6a, 0xff, 0xbe, 0x00, 0x42, 0xff, 0xd2, //@@@@@@@@@@@@+..%@@+.+@%.+@@
0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x26, 0xff, 0xff, 0x90, 0x00, 0x02, 0xd2, 0xff, 0x6c, 0x00, 0x80, 0xff, 0x9c, //@@@@@@@@@@@@+..@@%..@@+.+@%
0x6c, 0xa6, 0xa6, 0xa6, 0xa6, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x44, 0x32, 0x00, 0x00, 0x86, 0xff, 0xe8, 0x0c, 0x00, 0xd8, 0xff, 0x54, //+%%%%@@@@@@@+..+...%@@..@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x06, 0x8c, 0xff, 0xff, 0x54, 0x00, 0x56, 0xff, 0xec, 0x06, //......@@@@@@+.....%@@+.+@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xcc, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x1c, 0xdc, 0xff, 0xff, 0x78, 0x00, 0x0e, 0xe6, 0xff, 0x74, 0x00, //.......@@@@@+....@@@+..@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xcc, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xe0, 0x50, 0x00, 0x04, 0xb2, 0xff, 0xd4, 0x06, 0x00, //........@@@@+....@@+..%@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xcc, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x24, 0x06, 0x00, 0x08, 0xb4, 0xff, 0xf4, 0x2c, 0x00, 0x00, //.........@@@+........%@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xca, 0xff, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0xda, 0xff, 0xf4, 0x42, 0x00, 0x00, 0x00, //..........@@+......+@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0xff, 0xff, 0xdc, 0x32, 0x00, 0x00, 0x00, 0x00, //...........+......+@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xee, 0x80, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, //..................+@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f03e () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xba, 0x1e, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@%..
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xf6, 0xff, 0x34, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x22, 0xff, 0xff, 0x0a, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0x02, 0x7c, 0xe0, 0xea, 0x9c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...+@@%....................@@.
0xff, 0xff, 0x12, 0x00, 0x7c, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..+@@@@%...................@@.
0xff, 0xff, 0x12, 0x00, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@@@...................@@.
0xff, 0xff, 0x12, 0x00, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xe2, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@@@.........%@........@@.
0xff, 0xff, 0x12, 0x00, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xbe, 0xff, 0xff, 0xe2, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..%@@@@@........%@@@.......@@.
0xff, 0xff, 0x12, 0x00, 0x0e, 0xb4, 0xff, 0xff, 0xd4, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...%@@@........%@@@@@......@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x1a, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x26, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..............@@@@@@@@.....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x26, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@.............@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x5e, 0x00, 0x00, 0x00, 0x0c, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0xff, 0xff, 0x12, //@@.......+....@@@@@@@@@@@@...@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x22, 0xe2, 0xfc, 0x68, 0x00, 0x0c, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x00, 0x00, 0xff, 0xff, 0x12, //@@......@@+..@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x24, 0xe2, 0xff, 0xff, 0xfc, 0x72, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xff, 0x12, //@@.....@@@@+@@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x24, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xff, 0x12, //@@....@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0x24, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@@@@@@@@@@@@@@@@@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x80, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..%%%%%%%%%%%%%%%%%%%%%%+..@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xf6, 0xff, 0x2a, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x16, 0xff, 0xff, 0x0a, //@@...........................@@.
0xba, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x1e, 0xc2, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x26, 0x00, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x08, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f040 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x68, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, //..................+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xee, 0xff, 0xfc, 0x72, 0x00, 0x00, 0x00, 0x00, //.................@@@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x74, 0x00, 0x00, 0x00, //................@@@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x76, 0x00, 0x00, //...............@@@@@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0a, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x00, //...............@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xdc, 0x2e, 0x0a, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x40, //.............@..@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xea, 0x2e, 0x0a, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x74, //............@@@..@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xda, 0xe4, 0xea, 0x2e, 0x0a, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x2a, //...........@@@@@..@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3c, 0xe8, 0xff, 0xea, 0x2e, 0x0a, 0xc2, 0xff, 0xff, 0xf8, 0x4c, 0x00, //..........@@@.@@@..@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3c, 0xe4, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x0a, 0xc2, 0xf8, 0x4c, 0x00, 0x00, //.........@@@.@@@@@..@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3a, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x0a, 0x3e, 0x00, 0x00, 0x00, //........@@@.@@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3a, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x08, 0x00, 0x00, 0x00, 0x00, //.......@@@.@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3a, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@.@@@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3a, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@.@@@@@@@@@+......
0x00, 0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3a, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....@@@.@@@@@@@@@+.......
0x00, 0x00, 0x38, 0xf0, 0xff, 0xd4, 0x3a, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@.@@@@@@@@@+........
0x00, 0x38, 0xf0, 0xff, 0xee, 0x3a, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@.@@@@@@@@@+.........
0x38, 0xf0, 0xff, 0xe8, 0xfc, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@@@@@@+..........
0xf0, 0xff, 0xb6, 0x0a, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@%.%@@@@@@@@+...........
0xff, 0xff, 0x16, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@...%@@@@@@+............
0xff, 0xff, 0x28, 0x16, 0x02, 0x00, 0xa0, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@....%@@@@+.............
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x04, 0xde, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@...@@@+..............
0xff, 0xff, 0xff, 0xff, 0x26, 0x04, 0xa0, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@..%@@+...............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@+................
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+.................
0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f048 () , Width: 17 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x9a, 0xda, 0xda, 0xb2, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x72, //%@@%...........++
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xf8, 0x92, //@@@@..........+@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xf8, 0xff, 0x92, //@@@@.........+@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xf8, 0xff, 0xff, 0x92, //@@@@........+@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xf8, 0xff, 0xff, 0xff, 0x92, //@@@@.......+@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@......+@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@.....+@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x4e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@....+@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x4c, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@...+@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x4c, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@..+@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x4c, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@.+@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x70, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@+@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x90, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@%@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@.+@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@..+@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@...+@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@....+@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@.....+@@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@......+@@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@.......+@@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0x92, //@@@@........+@@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0x92, //@@@@.........+@@%
0xff, 0xff, 0xff, 0xff, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xff, 0x92, //@@@@..........+@%
0xbe, 0xff, 0xff, 0xd6, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x86, //%@@@...........+%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
/*Unicode: U+f04b () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0xcc, 0x76, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@+.....................
0xff, 0xff, 0xde, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@+...................
0xff, 0xff, 0xff, 0xff, 0xc8, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@..................
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@%................
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x92, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@%..............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x74, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@+............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@+..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@.........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@%.......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x92, 0x12, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@%.....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x74, 0x06, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@+...
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0x58, 0x00, //@@@@@@@@@@@@@@@@@@@@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xa2, 0x1a, //@@@@@@@@@@@@@@@@@@@@@%.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x32, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@%...
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x4c, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@+....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x6a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@+......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x86, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@%........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xa4, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@%..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@%............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@+.............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x6c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@+...............
0xff, 0xff, 0xff, 0xff, 0xf6, 0x88, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@%.................
0xff, 0xff, 0xfc, 0xa6, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@%...................
0xf8, 0xc2, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@.....................
0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f04c () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x9a, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xca, 0x1c, 0x00, 0x00, 0x00, 0x1e, 0xca, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0x9a, //%@@@@@@@@@.....@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@+...+@@@@@@@@@@
0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x28, 0x00, 0x00, 0x00, 0x2a, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, //%@@@@@@@@@.....@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f04d () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x9a, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0x7a, //%@@@@@@@@@@@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f051 () , Width: 17 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0xda, 0xda, 0xb4, 0x04, //+...........%@@%.
0xff, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@+..........@@@@.
0xff, 0xff, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@+.........@@@@.
0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@+........@@@@.
0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@+.......@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@+......@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@+.....@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@+....@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@+...@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@+..@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@@+.@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@@@+@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@@@%@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@@%.@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@@%..@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@@%...@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@@%....@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@@%.....@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@@%......@@@@.
0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@@%.......@@@@.
0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@@%........@@@@.
0xff, 0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@@%.........@@@@.
0xff, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x26, //@%..........@@@@.
0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0xff, 0xff, 0xd8, 0x0a, //%...........%@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.................
/*Unicode: U+f052 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xee, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@@@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@@@@@+....
0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, //...+@@@@@@@@@@@@@@@@@+...
0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, 0x00, //..+@@@@@@@@@@@@@@@@@@@+..
0x00, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, 0x00, //.+@@@@@@@@@@@@@@@@@@@@@+.
0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x5c, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x7a, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x6c, //+%%%%%%%%%%%%%%%%%%%%%%%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x12, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x0a, //.........................
0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, //@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f053 () , Width: 18 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xfc, 0x88, 0x00, 0x00, 0x00, //............+@%...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0x8a, 0x00, 0x00, //...........+@@@%..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x00, //..........+@@@@@%.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, //.........+@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x06, //........+@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, //.......+@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, //......+@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, 0x00, //.....+@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@.....
0x00, 0x00, 0x00, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, //...+@@@@@@@@......
0x00, 0x00, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..+@@@@@@@@.......
0x00, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+@@@@@@@@........
0x54, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@.........
0x46, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@.........
0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+@@@@@@@@........
0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..+@@@@@@@@.......
0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, //...+@@@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, 0x00, //.....+@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, 0x00, //......+@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x14, 0x00, //.......+@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x0a, //........+@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2c, //.........+@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x72, 0x00, //..........+@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0xff, 0xff, 0x72, 0x00, 0x00, //...........+@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0xf0, 0x70, 0x00, 0x00, 0x00, //............+@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
/*Unicode: U+f054 () , Width: 18 */
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x0c, 0xc2, 0xee, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@.............
0x00, 0x0c, 0xc4, 0xff, 0xff, 0xf2, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@............
0x0c, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@...........
0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@..........
0x26, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@.........
0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@@@@@........
0x00, 0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@@@@.......
0x00, 0x00, 0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, 0x00, //......@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, 0x00, //.......@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x3c, 0x00, //........@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x16, //.........@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x12, //.........@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, //........@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, //.......@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, //......@@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@.....
0x00, 0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@......
0x00, 0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@@@@.......
0x00, 0x3a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@@@@@........
0x32, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@.........
0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@..........
0x06, 0xb2, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.%@@@@@...........
0x00, 0x06, 0xb2, 0xff, 0xff, 0xe8, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@............
0x00, 0x00, 0x06, 0xac, 0xe0, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...%@.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..................
/*Unicode: U+f067 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xb2, 0xc6, 0xc6, 0xc6, 0x9e, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........%@@@%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x1e, 0x76, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x6e, 0x0c, //.+++++++@@@@@@%+++++++.
0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, //@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, //@@@@@@@@@@@@@@@@@@@@@@@
0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, //@@@@@@@@@@@@@@@@@@@@@@%
0x44, 0xae, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xa6, 0x24, //+%%%%%%%@@@@@@@%%%%%%%.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........%@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0xea, 0xff, 0xff, 0xff, 0xd6, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f068 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x02, 0x2e, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x26, 0x00, //.......................
0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x76, //%@@@@@@@@@@@@@@@@@@@@@+
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, //@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, //@@@@@@@@@@@@@@@@@@@@@@@
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, //@@@@@@@@@@@@@@@@@@@@@@%
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x50, //+@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f071 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xa8, 0xf6, 0xa8, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............%@%.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0xff, 0xff, 0xff, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............%@@@%............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xf4, 0xff, 0xff, 0xff, 0xf4, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%@@@@@%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@@@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xff, 0xff, 0xff, 0x7e, 0x46, 0x46, 0x46, 0x7e, 0xff, 0xff, 0xff, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@+++++@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd8, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x32, 0xff, 0xff, 0xff, 0xd8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........@@@@.....@@@@........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xff, 0xff, 0xff, 0xff, 0x38, 0x00, 0x00, 0x00, 0x3a, 0xff, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@@.....@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xe6, 0xff, 0xff, 0xff, 0xff, 0x42, 0x00, 0x00, 0x00, 0x44, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......@@@@@+...+@@@@@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4a, 0x00, 0x00, 0x00, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@+...+@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x52, 0x00, 0x00, 0x00, 0x56, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@@@@+...+@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5c, 0x00, 0x00, 0x00, 0x60, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@@@@@+...+@@@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x24, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x64, 0x00, 0x00, 0x00, 0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x22, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@+...+@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x86, 0x0e, 0x0e, 0x0e, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x00, 0x00, 0x00, 0x00, //....%@@@@@@@%...%@@@@@@@%....
0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0x00, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x00, //...%@@@@@@@@@@@@@@@@@@@@@%...
0x00, 0x00, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x48, 0x00, 0x00, //..+@@@@@@@@@+...+@@@@@@@@@+..
0x00, 0x00, 0xd2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x00, //..@@@@@@@@@@+...+@@@@@@@@@@..
0x00, 0x60, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x00, //.+@@@@@@@@@@+...+@@@@@@@@@@+.
0x06, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x12, 0x12, 0x12, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x06, //.@@@@@@@@@@@%...%@@@@@@@@@@@.
0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x74, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x48, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x46, //+@@@@@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x02, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x02, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f074 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xfc, 0x5c, 0x00, 0x00, 0x00, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xfc, 0x5c, 0x00, 0x00, 0x00, //.......................@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xfc, 0x5e, 0x00, 0x00, //.......................@@@+..
0xa2, 0xb6, 0xb6, 0xb6, 0xaa, 0x8c, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x66, 0x9e, 0xb2, 0xb6, 0xb6, 0xb6, 0xc6, 0xff, 0xff, 0xff, 0xfc, 0x5e, 0x00, //%%%%%%+.........+%%%%%@@@@@+.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x50, 0x00, 0x00, 0x00, 0x00, 0x04, 0x8c, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x60, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x06, 0xba, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, //@@@@@@@@@+...%@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x66, 0x00, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x2a, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0x58, 0x6a, 0x6a, 0x6a, 0x7c, 0xb8, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x62, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x98, 0x6e, 0x6a, 0x6a, 0x6a, 0x8a, 0xff, 0xff, 0xff, 0xe8, 0x2a, 0x00, //+++++%@@@@++@@@@@%++++%@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0xf8, 0xff, 0xdc, 0x10, 0xea, 0xff, 0xff, 0xff, 0xe6, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xe8, 0x2a, 0x00, 0x00, //......+@@@.@@@@@.......@@@...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0x62, 0x7c, 0xff, 0xff, 0xff, 0xfc, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xe8, 0x2a, 0x00, 0x00, 0x00, //.......+@++@@@@........@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xbe, 0x10, 0xec, 0xff, 0xff, 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0xe4, 0x28, 0x00, 0x00, 0x00, 0x00, //........%.@@@@%........@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x6a, 0xff, 0xff, 0xff, 0xfc, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@%...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xff, 0xff, 0xff, 0xff, 0x3a, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xc6, 0x22, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xd6, 0x20, 0x00, 0x00, 0x00, 0x00, //........@@@@@.%........@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x94, 0xfc, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xe0, 0x20, 0x00, 0x00, 0x00, //.......+@@@@+%@........@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf6, 0xff, 0xff, 0xff, 0xc8, 0x1c, 0xf6, 0xff, 0xdc, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xe0, 0x20, 0x00, 0x00, //.......@@@@@.@@@.......@@@...
0x4c, 0x5e, 0x5e, 0x5e, 0x6e, 0xa4, 0xfc, 0xff, 0xff, 0xff, 0xfa, 0x34, 0x9c, 0xff, 0xff, 0xff, 0xf4, 0x96, 0x68, 0x5e, 0x5e, 0x5e, 0x82, 0xff, 0xff, 0xff, 0xe0, 0x22, 0x00, //+++++%@@@@@.%@@@@%++++%@@@@..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x00, 0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x22, //@@@@@@@@@@+.%@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x96, 0x00, 0x00, 0x0c, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@%...@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x72, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x98, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, //@@@@@@@@+.....%@@@@@@@@@@@@@+
0xb0, 0xc2, 0xc2, 0xc2, 0xbc, 0xa2, 0x60, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x74, 0xa6, 0xc0, 0xc8, 0xc8, 0xc6, 0xd0, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, //%@@@%%+.........+%%@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0x6c, 0x00, 0x00, //.......................@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0x6c, 0x00, 0x00, 0x00, //.......................@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, //.......................@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f077 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xd8, 0xe2, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xda, 0xff, 0xff, 0xe6, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xda, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........@@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......@@@@@@@@@@@@........
0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@@@@@@@@@@@@.......
0x00, 0x00, 0x00, 0x00, 0x1c, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@......
0x00, 0x00, 0x00, 0x1c, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x3e, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@+.@@@@@@@@.....
0x00, 0x00, 0x1c, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, 0x00, //...@@@@@@@@+...@@@@@@@@....
0x00, 0x1c, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, 0x00, //..@@@@@@@@+.....@@@@@@@@...
0x1c, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x28, 0x00, //.@@@@@@@@+.......@@@@@@@@..
0xd4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x04, //@@@@@@@@+.........@@@@@@@@.
0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x02, //@@@@@@@+...........@@@@@@@.
0x10, 0xcc, 0xff, 0xff, 0xff, 0xfa, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xff, 0xff, 0xda, 0x1a, 0x00, //.@@@@@+.............@@@@@..
0x00, 0x10, 0xca, 0xff, 0xfa, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xf4, 0xff, 0xd8, 0x1a, 0x00, 0x00, //..@@@+...............@@@...
0x00, 0x00, 0x0e, 0x90, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x96, 0x18, 0x00, 0x00, 0x00, //...%+.................%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f078 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x24, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x28, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x6c, 0xfc, 0xcc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xff, 0x82, 0x00, 0x00, 0x00, //..+@@................%@%...
0x00, 0x6e, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xff, 0xff, 0xff, 0x82, 0x00, 0x00, //.+@@@@..............%@@@%..
0x6c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x82, 0x00, //+@@@@@@............%@@@@@%.
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0a, //@@@@@@@@..........%@@@@@@@.
0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, //+@@@@@@@@........%@@@@@@@+.
0x00, 0x68, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x08, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, //.+@@@@@@@@......%@@@@@@@+..
0x00, 0x00, 0x68, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x00, 0x00, 0x08, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, //..+@@@@@@@@....%@@@@@@@+...
0x00, 0x00, 0x00, 0x68, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x10, 0x08, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, //...+@@@@@@@@..%@@@@@@@+....
0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@%@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@@@@@@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xfc, 0xff, 0xff, 0xff, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@@@@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xfc, 0xff, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+@@+............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............++.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f079 () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0xa4, 0xe4, 0x2a, 0x00, 0x00, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@...%@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x86, 0xff, 0xff, 0xdc, 0x12, 0x00, 0x16, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //....%@@@...@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x04, 0x00, 0x2e, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //...+@@@@@...@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x38, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0x00, 0x00, 0x4e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@@%..+@@@@@@@@@@@@@@.....
0x00, 0x1c, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x74, 0x00, 0x00, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x50, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@@@@@+...........+@@@@.....
0x0a, 0xd0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@@@+...........@@@@.....
0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@@@@...........@@@@.....
0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@+..........@@@@.....
0x1a, 0x42, 0x42, 0x42, 0xe4, 0xff, 0xff, 0xff, 0x76, 0x42, 0x42, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //.+++@@@@+++............@@@@.....
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, //....@@@@+..............@@@@.....
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x46, 0x46, 0x6e, 0xff, 0xff, 0xff, 0xf2, 0x46, 0x46, 0x46, 0x20, 0x00, //....@@@@+...........+++@@@@+++..
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x06, //....@@@@+.........+@@@@@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0x00, //....@@@@+..........@@@@@@@@@@@%.
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x10, 0x00, //....@@@@+...........@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x60, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1a, 0x00, 0x00, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0x24, 0x00, 0x00, //....@@@@+...........+@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x66, 0x00, 0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x42, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@+..%@@@@@@+...
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3e, 0x00, 0x00, 0xb0, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@...%@@@@+....
0x00, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x20, 0x00, 0x0c, 0xd2, 0xff, 0xff, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@...@@@%.....
0x00, 0x00, 0x00, 0x00, 0xca, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x96, 0x00, 0x00, 0x1e, 0xdc, 0xb0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@%...@%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f07b () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x1e, 0x94, 0xc2, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xb0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@@@@%+................
0x2a, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@@@@%...............
0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@@@@@@@...............
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@+..............
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0x9c, 0x68, 0x06, 0x00, //@@@@@@@@@@@@@%%%%%%%%%%%+..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x0e, //@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, //@@@@@@@@@@@@@@@@@@@@@@@@@@%
0x48, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x38, //+@@@@@@@@@@@@@@@@@@@@@@@@@.
0x00, 0x48, 0xcc, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xc6, 0x3c, 0x00, //.+@@@@@@@@@@@@@@@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f093 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xb0, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............%.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf2, 0xff, 0xea, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf2, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........@@@@@...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........@@@@@@@@@@@........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......@@@@@@@@@@@@@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@@@@@@@@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x90, 0x92, 0x92, 0x92, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x92, 0x92, 0x92, 0x8e, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //......%%%%@@@@@@@%%%%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@%..........
0x00, 0x1a, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x10, 0x00, 0x52, 0xd6, 0xda, 0xda, 0xda, 0xd4, 0x40, 0x00, 0x12, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1a, 0x00, //..........+@@@@@...........
0xa0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9c, //%@@@@@@@@.........@@@@@@@@%
0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x50, 0x28, 0x26, 0x26, 0x26, 0x2a, 0x58, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, //@@@@@@@@@@+.....+@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x14, 0x54, 0xff, 0xff, 0x38, 0x48, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd4, 0x16, 0x54, 0xff, 0xff, 0x3a, 0x4a, 0xff, 0xff, //@@@@@@@@@@@@@@@@@@@.+@@.+@@
0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x90, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x90, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x08, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f095 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x38, 0x92, 0xbe, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...%%+.................
0x00, 0x5c, 0xfc, 0xff, 0xff, 0xea, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.+@@@@.................
0x18, 0xf2, 0xff, 0xff, 0xff, 0xff, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@%................
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@................
0xd2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@%...............
0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@...............
0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@%...............
0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //%@@@@@%................
0x6a, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@%.................
0x12, 0xf8, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@+.................
0x00, 0xa6, 0xff, 0xff, 0xff, 0xf0, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.%@@@@.................
0x00, 0x38, 0xff, 0xff, 0xff, 0xff, 0xae, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@%................
0x00, 0x00, 0xae, 0xff, 0xff, 0xff, 0xff, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@@+...............
0x00, 0x00, 0x18, 0xea, 0xff, 0xff, 0xff, 0xf6, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@...............
0x00, 0x00, 0x00, 0x4a, 0xfc, 0xff, 0xff, 0xff, 0xea, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //...+@@@@@..............
0x00, 0x00, 0x00, 0x00, 0x74, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x06, 0xc0, 0xff, 0xb4, 0x1e, 0x00, 0x00, 0x00, //....+@@@@@+.....%@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x1a, 0x00, 0x00, 0xa8, 0xff, 0xff, 0xff, 0xf6, 0x88, 0x0e, 0x00, //.....%@@@@@%...%@@@@%..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x80, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0x58, //......%@@@@@@+%@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, //.......+@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, //........+@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x38, //..........%@@@@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xa6, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x5c, 0x00, //............%@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x6a, 0xbc, 0xf0, 0xf4, 0xd2, 0x80, 0x18, 0x00, 0x00, //..............+%@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f0c4 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x42, 0x7e, 0x90, 0x80, 0x4e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..++%++......................
0x16, 0xc2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x80, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.@@@@@@@+....................
0xc8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x72, 0x1c, 0x00, 0x00, //@@@@@@@@@@...............+...
0xff, 0xff, 0xf0, 0x52, 0x0c, 0x16, 0x46, 0xb0, 0xff, 0xff, 0xd6, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xa0, 0xea, 0xa0, 0xec, 0x94, 0x0c, //@@@+..+%@@@............%@%@%.
0xff, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xf4, 0xff, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x88, 0xee, 0x8a, 0x0e, 0x00, 0x14, 0xda, 0x6e, //@@%.....+@@%.........%@%...@+
0xff, 0xff, 0xda, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xff, 0xda, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x70, 0xea, 0xa4, 0x1e, 0x00, 0x00, 0x10, 0xb6, 0xca, 0x16, //@@@......+@@.......+@%....%@.
0xe2, 0xff, 0xff, 0xaa, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x32, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0xdc, 0xbe, 0x32, 0x00, 0x00, 0x00, 0x2a, 0xda, 0x9a, 0x06, 0x00, //@@@%......@@.....+@%.....@%..
0x4c, 0xfc, 0xff, 0xff, 0xe0, 0x6e, 0x24, 0x06, 0x26, 0xb6, 0xff, 0xec, 0x18, 0x00, 0x00, 0x40, 0xca, 0xd4, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x52, 0xea, 0x64, 0x00, 0x00, 0x00, //+@@@@+...%@@....@@+....+@+...
0x00, 0x5c, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0xea, 0x7a, 0xb4, 0xe6, 0x66, 0x02, 0x00, 0x00, 0x00, 0x00, 0x84, 0xe0, 0x34, 0x00, 0x00, 0x00, 0x00, //.+@@@@@@@@@%@+%@+.....%@.....
0x00, 0x00, 0x2a, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x00, 0x9a, 0xf4, 0x80, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10, 0xb6, 0xba, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, //...%@@@@@@@.%@+......%%......
0x00, 0x00, 0x00, 0x00, 0x22, 0x68, 0x8c, 0x8c, 0x6a, 0x3e, 0xd8, 0xca, 0xfa, 0x20, 0x30, 0x36, 0x00, 0x00, 0x00, 0x2c, 0xda, 0x88, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+%%+.@@@.......@%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x94, 0xff, 0x0a, 0xea, 0xf6, 0x06, 0x00, 0x54, 0xf0, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%@.@@..+@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0xe0, 0xba, 0x02, 0xb4, 0xc4, 0x02, 0x86, 0xe0, 0xd6, 0xb8, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@%.%@.%@@%........
0x00, 0x00, 0x00, 0x26, 0x8c, 0xd0, 0xf2, 0xf4, 0xd2, 0xa6, 0xea, 0x5e, 0x00, 0x2e, 0x50, 0x18, 0xb6, 0xb2, 0x12, 0x0a, 0xa4, 0xe0, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....%@@@@%@+..+.%%..%@.......
0x00, 0x06, 0x92, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x22, 0x8e, 0xf4, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x68, 0xf0, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@@@@@@.%@@@+....+@+.....
0x08, 0xc4, 0xff, 0xff, 0xff, 0xf0, 0xb8, 0x9c, 0xba, 0xfc, 0xff, 0xfc, 0xa0, 0x16, 0x4a, 0xce, 0xde, 0x58, 0x00, 0x00, 0x00, 0x00, 0x32, 0xdc, 0xa6, 0x0a, 0x00, 0x00, 0x00, //.@@@@@%%%@@@%.+@@+.....@%....
0xa0, 0xff, 0xff, 0xf8, 0x7a, 0x0e, 0x00, 0x00, 0x00, 0x5e, 0xff, 0xea, 0x00, 0x00, 0x00, 0x00, 0x58, 0xda, 0xcc, 0x44, 0x00, 0x00, 0x00, 0x0e, 0xb0, 0xd4, 0x28, 0x00, 0x00, //%@@@+....+@@....+@@+....%@...
0xfc, 0xff, 0xfc, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xf2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x68, 0xe4, 0xb8, 0x30, 0x00, 0x00, 0x00, 0x74, 0xee, 0x56, 0x00, //@@@.......@@......+@%....+@+.
0xff, 0xff, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xc6, 0xff, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x78, 0xec, 0xa2, 0x1e, 0x00, 0x00, 0x3a, 0xe4, 0x54, //@@%......@@%........+@%....@+
0xff, 0xff, 0xc6, 0x04, 0x00, 0x00, 0x00, 0x42, 0xd2, 0xff, 0xfc, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x86, 0xee, 0x8e, 0x32, 0x96, 0xe8, 0x3a, //@@@....+@@@...........%@%.%@.
0xf4, 0xff, 0xff, 0xe0, 0xa2, 0xac, 0xda, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x94, 0xda, 0x7e, 0x10, 0x00, //@@@@%%@@@@+.............%@+..
0x5e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@+...................
0x00, 0x36, 0xac, 0xe8, 0xfa, 0xea, 0xb8, 0x66, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@%+.....................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............................
/*Unicode: U+f0c5 () , Width: 29 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0xca, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......%@@@@@@@@@@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0xff, 0xff, 0xff, 0x24, 0x12, 0x12, 0x12, 0x12, 0x12, 0x20, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......%@@@.......@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xce, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@@@.......@@..........
0x00, 0x00, 0x00, 0x00, 0x8e, 0xff, 0xce, 0x12, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....%@@.@@.......@@..........
0x00, 0x00, 0x00, 0x90, 0xff, 0xce, 0x12, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...%@@..@@.......@@..........
0x00, 0x00, 0x94, 0xff, 0xce, 0x12, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0x92, 0xe2, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf0, 0x78, //..%@@...@@.......@@%@@@@@@@@+
0x00, 0x98, 0xff, 0xce, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, //.%@@....@@.......@@@@@@@@@@@@
0x62, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //+@@@@@@@@@.......@@@@......@@
0xd0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe8, 0xff, 0xd0, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@@@@@@@@%......@@@@@......@@
0xfa, 0xff, 0x24, 0x12, 0x12, 0x12, 0x12, 0x12, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xee, 0xff, 0xda, 0x16, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.............@@@.@@......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0xf4, 0xff, 0xe4, 0x20, 0x00, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@...........+@@@..@@......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xf8, 0xff, 0xec, 0x2c, 0x00, 0x00, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@..........+@@@...@@......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xfa, 0xff, 0xf4, 0x38, 0x00, 0x00, 0x00, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.........+@@@....@@......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xfa, 0xff, 0xfc, 0x5c, 0x12, 0x12, 0x12, 0x12, 0xff, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.........@@@+....@@......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@........%@@@@@@@@@@......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@........@@@@@@@@@@+......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@........@@+..............@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@........@@+..............@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@........@@+..............@@
0xff, 0xff, 0x20, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xec, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@........@@+..............@@
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@@@@@@@@@@@+..............@@
0x82, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //%@@@@@@@@@@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //..........@@+..............@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //..........@@@@@@@@@@@@@@@@@@@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x8a, //..........+@@@@@@@@@@@@@@@@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x00, //.............................
/*Unicode: U+f0c7 () , Width: 25 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xd8, 0x74, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@@@@@@@@@@+......
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x04, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@@%.....
0xff, 0xff, 0x20, 0x0e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5c, 0x0e, 0x0e, 0x0e, 0x3a, 0xff, 0xff, 0x3a, 0xd6, 0xff, 0xb0, 0x04, 0x00, 0x00, 0x00, //@@..@@@@@@+....@@.@@%....
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x1a, 0xde, 0xff, 0xb0, 0x04, 0x00, 0x00, //@@..@@@@@@.....@@..@@%...
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x22, 0xe4, 0xff, 0xb0, 0x04, 0x00, //@@..@@@@@@.....@@...@@%..
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x2a, 0xec, 0xff, 0xb0, 0x02, //@@..@@@@@@.....@@....@@%.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x34, 0xf0, 0xff, 0x72, //@@..@@@@@@.....@@.....@@+
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xff, 0xd8, //@@..@@@@@@.....@@.....+@@
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x12, 0x12, 0x12, 0x3e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xff, 0xfc, //@@..@@@@@@+....@@......@@
0xff, 0xff, 0x12, 0x00, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@..@@@@@@@@@@@@@......@@
0xff, 0xff, 0x12, 0x00, 0x74, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@..+@@@@@@@@@@@+......@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.....................@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.....................@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.....................@@
0xff, 0xff, 0x12, 0x00, 0x00, 0x08, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x00, 0x00, 0x12, 0xff, 0xff, //@@.....................@@
0xff, 0xff, 0x12, 0x00, 0x90, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x8e, 0x00, 0x12, 0xff, 0xff, //@@..%@@@@@@@@@@@@@@@%..@@
0xff, 0xff, 0x12, 0x00, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x12, 0xff, 0xff, //@@..@@@@@@@@@@@@@@@@@..@@
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x12, 0xff, 0xff, //@@..@@.............@@..@@
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x12, 0xff, 0xff, //@@..@@.............@@..@@
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x12, 0xff, 0xff, //@@..@@.............@@..@@
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x12, 0xff, 0xff, //@@..@@.............@@..@@
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0x00, 0x12, 0xff, 0xff, //@@..@@.............@@..@@
0xff, 0xff, 0x16, 0x02, 0xff, 0xff, 0x16, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x16, 0xff, 0xff, 0x02, 0x16, 0xff, 0xff, //@@..@@.............@@..@@
0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, //@@@@@@@@@@@@@@@@@@@@@@@@@
0x8c, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x8c, //%@@@@@@@@@@@@@@@@@@@@@@@%
0x00, 0x08, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f0e7 () , Width: 15 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............
0x00, 0x00, 0x00, 0x94, 0xea, 0xea, 0xea, 0xea, 0xea, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, //...%@@@@@@.....
0x00, 0x00, 0x02, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@@@.....
0x00, 0x00, 0x32, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, //...@@@@@@+.....
0x00, 0x00, 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, //..+@@@@@@......
0x00, 0x00, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..%@@@@@%......
0x00, 0x00, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..@@@@@@+......
0x00, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x02, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, //..@@@@@@.......
0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8c, 0x00, 0x0a, 0x46, 0x86, 0xc6, 0xfa, 0x62, //.+@@@@@%..+%@@+
0x00, 0xa8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xc6, 0xfa, 0xff, 0xff, 0xff, 0xfc, 0x26, //.%@@@@@%@@@@@@.
0x00, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0x00, //.@@@@@@@@@@@@%.
0x24, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0x00, //.@@@@@@@@@@@@..
0x62, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, //+@@@@@@@@@@@%..
0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, //%@@@@@@@@@@@+..
0xde, 0xff, 0xff, 0xff, 0xd6, 0x96, 0x56, 0xac, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, //@@@@@%+%@@@@...
0x9c, 0x96, 0x56, 0x16, 0x00, 0x00, 0x00, 0xd6, 0xff, 0xff, 0xff, 0x56, 0x00, 0x00, 0x00, //%%+....@@@@+...
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xff, 0xff, 0xff, 0xdc, 0x02, 0x00, 0x00, 0x00, //.......@@@@....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x00, //......+@@@+....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x92, 0xff, 0xff, 0xe8, 0x06, 0x00, 0x00, 0x00, 0x00, //......%@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0xff, 0xff, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@+.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfc, 0xff, 0xf0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0xff, 0xff, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0xff, 0xf8, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0xca, 0xff, 0x9a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@%.......
0x00, 0x00, 0x00, 0x00, 0x0c, 0xfa, 0xfc, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@........
0x00, 0x00, 0x00, 0x00, 0x46, 0xff, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....+@%........
0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....%@.........
0x00, 0x00, 0x00, 0x00, 0x90, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //....%%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............
/*Unicode: U+f0f3 () , Width: 27 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xbe, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............+%+............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xfa, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //............@@@............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x7e, 0xfc, 0xff, 0xf6, 0x7a, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+@@@+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //........+@@@@@@@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+@@@@@@@@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+@@@@@@@@@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@@@@@@@@@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x00, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x02, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x00, //.....@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x4c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3a, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x00, 0x00, 0x00, //....%@@@@@@@@@@@@@@@@@+....
0x00, 0x00, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xba, 0x00, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x30, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x20, 0x00, 0x00, 0x00, //....@@@@@@@@@@@@@@@@@@@....
0x00, 0x00, 0x00, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x94, 0x00, 0x00, 0x00, //...%@@@@@@@@@@@@@@@@@@@%...
0x00, 0x00, 0x28, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x1a, 0x00, 0x00, //...@@@@@@@@@@@@@@@@@@@@@...
0x00, 0x02, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x00, 0x00, //..@@@@@@@@@@@@@@@@@@@@@@%..
0x00, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x82, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@%.
0x98, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x86, //%@@@@@@@@@@@@@@@@@@@@@@@@@%
0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, //@@@@@@@@@@@@@@@@@@@@@@@@@@@
0x36, 0xcc, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xf8, 0xe4, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xc6, 0x2a, //.@@@@@@@@@@@@@@@@@@@@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0xb8, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........%%%@@@@@%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0xf4, 0x5a, 0xec, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........+@+@@@@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xbc, 0xdc, 0x5e, 0x8e, 0xff, 0xff, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@+%@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x8c, 0xec, 0xff, 0xe8, 0x82, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........%@@@%...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........................
/*Unicode: U+f11c () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x3e, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x4a, 0x00, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x00, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0xff, 0xff, 0x20, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0x0e, 0x10, 0x00, 0x00, 0x0c, 0x10, 0x00, 0x00, 0x0c, 0x12, 0x0c, 0x00, 0x00, 0x10, 0x0e, 0x00, 0x00, 0x10, 0x0c, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0xfc, 0xff, 0x10, 0x00, 0xd8, 0xfc, 0x00, 0x00, 0xec, 0xff, 0xe8, 0x00, 0x00, 0xfc, 0xe8, 0x00, 0x00, 0xfc, 0xd8, 0x00, 0x0c, 0xff, 0xfc, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xff, 0xff, 0x12, 0x00, 0xfa, 0xfc, 0x0e, 0x00, 0xd6, 0xfa, 0x00, 0x00, 0xe8, 0xff, 0xe4, 0x00, 0x00, 0xfa, 0xe6, 0x00, 0x00, 0xfa, 0xd6, 0x00, 0x0e, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@..@@..@@@..@@..@@..@@..@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x12, //@@.......................@@..@@.
0xff, 0xff, 0x12, 0x00, 0x0e, 0x12, 0x12, 0x12, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x10, 0x0e, 0x00, 0x00, 0x10, 0x0e, 0x00, 0x00, 0x12, 0x20, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x12, //@@.......................@@..@@.
0xff, 0xff, 0x12, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x20, 0x00, 0xfc, 0xff, 0x0c, 0x00, 0x10, 0xff, 0xfc, 0x00, 0x10, 0xff, 0xfc, 0x00, 0x20, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0xfa, 0xff, 0xff, 0xff, 0x1e, 0x00, 0xfa, 0xfc, 0x0c, 0x00, 0x0e, 0xfc, 0xfa, 0x00, 0x0e, 0xfc, 0xfa, 0x00, 0x1e, 0xff, 0xff, 0xff, 0xfa, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@@@..@@...@@..@@..@@@@..@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0x0e, 0x10, 0x00, 0x00, 0x0c, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x0c, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x12, 0x00, 0xfc, 0xff, 0x10, 0x00, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x00, 0x0c, 0xff, 0xfc, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xff, 0xff, 0x12, 0x00, 0xfa, 0xfc, 0x0e, 0x00, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x00, 0x0c, 0xfc, 0xfa, 0x00, 0x00, 0xff, 0xff, 0x12, //@@..@@..@@@@@@@@@@@@@@@..@@..@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, //@@...........................@@.
0xff, 0xff, 0x24, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0xff, 0xff, 0x12, //@@...........................@@.
0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0x00, //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
0x3e, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x4a, 0x00, //.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f124 () , Width: 23 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x9e, 0x4e, //.....................%+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xb2, 0xff, 0xff, 0xb2, //...................%@@%
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xb4, 0xff, 0xff, 0xff, 0xff, 0x50, //.................%@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, //...............%@@@@@@.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, //.............%@@@@@@@+.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, //...........%@@@@@@@@@..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, //.........%@@@@@@@@@@+..
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, //.......%@@@@@@@@@@@@...
0x00, 0x00, 0x00, 0x00, 0x36, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, //.....%@@@@@@@@@@@@@+...
0x00, 0x00, 0x36, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, //...%@@@@@@@@@@@@@@@....
0x2e, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@+....
0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@@@@@.....
0x70, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, //+%%%%%%%%%@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@@......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@+......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@+.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@+........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xff, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@+.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0xff, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6a, 0xfa, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......................
/*Unicode: U+f15b () , Width: 25 */
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //+@@@@@@@@@@@@@+..........
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+%.......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@%......
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@%.....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@@%....
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@@@%...
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x00, 0x00, //@@@@@@@@@@@@@@+.+@@@@@%..
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8c, 0x00, //@@@@@@@@@@@@@@+.+@@@@@@%.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x1c, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x06, //@@@@@@@@@@@@@@+..+++++++.
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //@@@@@@@@@@@@@@%..........
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0x8a, //@@@@@@@@@@@@@@@@%%%%%%%%%
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, //@@@@@@@@@@@@@@@@@@@@@@@@@
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, //@@@@@@@@@@@@@@@@@@@@@@@@@
0x7e, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x60, //+@@@@@@@@@@@@@@@@@@@@@@@+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........................
/*Unicode: U+f1eb () , Width: 32 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x44, 0x86, 0xb2, 0xd8, 0xec, 0xf8, 0xf6, 0xe8, 0xce, 0xa8, 0x78, 0x34, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........+%%@@@@@@%+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0xa6, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x8e, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.......+%@@@@@@@@@@@@@@%........
0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@@@@@%......
0x00, 0x00, 0x00, 0x24, 0xba, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x96, 0x0e, 0x00, 0x00, 0x00, //....%@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x58, 0xf2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xba, 0x7a, 0x52, 0x34, 0x28, 0x2a, 0x38, 0x5a, 0x88, 0xcc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0x32, 0x00, 0x00, //..+@@@@@@@@%++....+%@@@@@@@@@...
0x00, 0x86, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0x6c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x86, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x52, 0x00, //.%@@@@@@@+............%@@@@@@@+.
0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x70, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x20, 0x1e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x96, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x56, //%@@@@@@+................%@@@@@@+
0xca, 0xff, 0xff, 0xff, 0xff, 0xc4, 0x1e, 0x00, 0x00, 0x00, 0x3e, 0x8c, 0xc8, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xec, 0xbc, 0x7c, 0x2a, 0x00, 0x00, 0x00, 0x3c, 0xe2, 0xff, 0xff, 0xff, 0xff, 0x90, //@@@@@@.....%@@@@@@@%+.....@@@@@%
0x1c, 0xe2, 0xff, 0xff, 0x96, 0x04, 0x00, 0x04, 0x60, 0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x46, 0x00, 0x00, 0x16, 0xc2, 0xff, 0xff, 0xbc, 0x06, //.@@@%...+@@@@@@@@@@@@@@+...@@@%.
0x00, 0x24, 0xdc, 0x7c, 0x00, 0x00, 0x48, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x28, 0x00, 0x08, 0xae, 0xbc, 0x0a, 0x00, //..@+..+@@@@@@@@@@@@@@@@@@...%%..
0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, //.....+@@@@@@@@@@@@@@@@@@@@+.....
0x00, 0x00, 0x00, 0x00, 0x72, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x82, 0x42, 0x18, 0x04, 0x0c, 0x20, 0x44, 0x8c, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@%+....+%@@@@@@@.....
0x00, 0x00, 0x00, 0x00, 0x12, 0xd4, 0xff, 0xff, 0xff, 0xc4, 0x40, 0x00, 0x00, 0x00, 0x02, 0x18, 0x14, 0x00, 0x00, 0x00, 0x02, 0x60, 0xde, 0xff, 0xff, 0xff, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, //.....@@@@@...........+@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0xca, 0xe4, 0x52, 0x00, 0x00, 0x26, 0x8a, 0xd0, 0xfc, 0xff, 0xff, 0xf8, 0xc0, 0x78, 0x12, 0x00, 0x0a, 0x92, 0xfc, 0xa4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, //......@@+...%@@@@@%+...%@%......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x00, 0x10, 0xa4, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x80, 0x02, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........%@@@@@@@@@@+..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.........@@@@@@@@@@@@@%.........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xc6, 0xff, 0xec, 0x84, 0x30, 0x08, 0x0c, 0x40, 0x9c, 0xf8, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..........@@@%....%@@%..........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x6c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...........+........+...........
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xb6, 0xf2, 0xe8, 0xa4, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..............%@@%..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0xff, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //.............%@@@@+.............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xca, 0xff, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //..............@@@%..............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xb4, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //...............%%...............
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //................................
/*Unicode: U+f240 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x16, 0xb0, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xb6, 0x18, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xfc, 0x08, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x68, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..+++++++++++++++++++++++++++..@@...
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x10, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@+..
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xcc, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x1c, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@....@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x06, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@@.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4a, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@@+.
0xff, 0xff, 0x12, 0x00, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@@@@@@@@..@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xff, 0x0a, 0x00, 0x00, //@@...............................@@...
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xbe, 0x22, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f241 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x16, 0xb0, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xb6, 0x18, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xfc, 0x08, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..+++++++++++++++++++++........@@...
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x10, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@+..
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xcc, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x1c, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x22, //@@..@@@@@@@@@@@@@@@@@@@@%..........@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x06, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4a, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@@+.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..@@@@@@@@@@@@@@@@@@@@%........@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xff, 0x0a, 0x00, 0x00, //@@...............................@@...
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xbe, 0x22, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f242 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x16, 0xb0, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xb6, 0x18, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xfc, 0x08, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..++++++++++++++...............@@...
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x10, 0x00, //@@..@@@@@@@@@@@@@@+..............@@+..
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xcc, 0x00, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x1c, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x22, //@@..@@@@@@@@@@@@@@+................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x06, //@@..@@@@@@@@@@@@@@+..............@@@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4a, 0x00, //@@..@@@@@@@@@@@@@@+..............@@@+.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..@@@@@@@@@@@@@@+..............@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xff, 0x0a, 0x00, 0x00, //@@...............................@@...
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xbe, 0x22, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f243 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x16, 0xb0, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xb6, 0x18, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xfc, 0x08, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..++++++++.....................@@...
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x10, 0x00, //@@..@@@@@@@@+....................@@+..
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xcc, 0x00, //@@..@@@@@@@@+....................@@@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x1c, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x22, //@@..@@@@@@@@+......................@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x06, //@@..@@@@@@@@+....................@@@@.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4a, 0x00, //@@..@@@@@@@@+....................@@@+.
0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@..@@@@@@@@+....................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xff, 0x0a, 0x00, 0x00, //@@...............................@@...
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xbe, 0x22, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f244 () , Width: 38 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x16, 0xb0, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xb4, 0x16, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xfa, 0x06, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x50, 0x00, 0x00, //@@...............................@@+..
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xac, 0x00, //@@...............................@@@%.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x16, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xff, 0x22, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0xf0, 0xff, 0x22, //@@.................................@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf6, 0x08, //@@...............................@@@@.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x5a, 0x00, //@@...............................@@@+.
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xff, 0xff, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x00, 0x00, //@@...............................@@...
0xf4, 0xff, 0x38, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x24, 0xff, 0xff, 0x0c, 0x00, 0x00, //@@...............................@@...
0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x00, 0x00, 0x00, //%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@...
0x18, 0xb2, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xbe, 0x22, 0x00, 0x00, 0x00, //.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%....
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................................
/*Unicode: U+f293 () , Width: 22 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x58, 0xa4, 0xd2, 0xec, 0xfa, 0xf4, 0xe4, 0xbc, 0x84, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+%@@@@@%%.......
0x00, 0x00, 0x00, 0x00, 0x5a, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x1a, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xba, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x2a, 0x00, 0x00, 0x00, //...%@@@@@@%@@@@@@@....
0x00, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x06, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0e, 0x00, 0x00, //..+@@@@@@%.%@@@@@@@...
0x00, 0x1a, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x06, 0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, 0x00, 0x00, //..@@@@@@@%..%@@@@@@%..
0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x04, 0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x16, 0x00, //.%@@@@@@@%...%@@@@@@..
0x00, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x00, 0x04, 0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0x72, 0x00, //.@@@@@@@@%....%@@@@@+.
0x30, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x5a, 0x00, 0x02, 0xa8, 0xff, 0xff, 0xff, 0xff, 0xb8, 0x00, //.@@@@@@@@%..+..%@@@@%.
0x72, 0xff, 0xff, 0xff, 0xd4, 0x18, 0xa6, 0xff, 0xff, 0xbe, 0x00, 0x00, 0xfa, 0x5a, 0x00, 0x02, 0xa4, 0xff, 0xff, 0xff, 0xf4, 0x02, //+@@@@.%@@%..@+..%@@@@.
0x9c, 0xff, 0xff, 0xff, 0x66, 0x00, 0x02, 0xa6, 0xff, 0xbe, 0x00, 0x00, 0xfc, 0xfa, 0x28, 0x00, 0x02, 0xd4, 0xff, 0xff, 0xff, 0x22, //%@@@+..%@%..@@...@@@@.
0xc0, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x00, 0x02, 0xa6, 0xbe, 0x00, 0x00, 0xfc, 0x76, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0x46, //%@@@@+..%%..@+..%@@@@+
0xde, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x00, 0x02, 0x68, 0x00, 0x00, 0x72, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0x64, //@@@@@@+..+..+..%@@@@@+
0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x70, //@@@@@@@+......%@@@@@@+
0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, //@@@@@@@@+....%@@@@@@@+
0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x14, 0x00, 0x00, 0x4a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x84, //@@@@@@@@@...+@@@@@@@@%
0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, //@@@@@@@@+....%@@@@@@@+
0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x72, //@@@@@@@+......%@@@@@@+
0xde, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x50, 0x00, 0x02, 0x68, 0x00, 0x00, 0x72, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0x66, //@@@@@@+..+..+..%@@@@@+
0xc0, 0xff, 0xff, 0xff, 0xfa, 0x52, 0x00, 0x02, 0xa6, 0xbe, 0x00, 0x00, 0xfc, 0x76, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0x48, //%@@@@+..%%..@+..%@@@@+
0x9c, 0xff, 0xff, 0xff, 0x66, 0x00, 0x02, 0xa6, 0xff, 0xbe, 0x00, 0x00, 0xfc, 0xfa, 0x28, 0x00, 0x02, 0xd4, 0xff, 0xff, 0xff, 0x24, //%@@@+..%@%..@@...@@@@.
0x72, 0xff, 0xff, 0xff, 0xd4, 0x18, 0xa6, 0xff, 0xff, 0xbe, 0x00, 0x00, 0xfa, 0x5a, 0x00, 0x02, 0xa4, 0xff, 0xff, 0xff, 0xf4, 0x02, //+@@@@.%@@%..@+..%@@@@.
0x32, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x5a, 0x00, 0x02, 0xa8, 0xff, 0xff, 0xff, 0xff, 0xb8, 0x00, //.@@@@@@@@%..+..%@@@@%.
0x00, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x00, 0x04, 0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0x72, 0x00, //.@@@@@@@@%....%@@@@@+.
0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x06, 0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x16, 0x00, //.%@@@@@@@%...%@@@@@@..
0x00, 0x1a, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x06, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, 0x00, 0x00, //..@@@@@@@%..%@@@@@@%..
0x00, 0x00, 0x6a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x08, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0e, 0x00, 0x00, //..+@@@@@@%.%@@@@@@@...
0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x2a, 0x00, 0x00, 0x00, //...%@@@@@@%@@@@@@@....
0x00, 0x00, 0x00, 0x00, 0x5a, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0x1a, 0x00, 0x00, 0x00, 0x00, //....+@@@@@@@@@@@%.....
0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x5a, 0xa8, 0xd4, 0xee, 0xfa, 0xf4, 0xe6, 0xc0, 0x88, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......+%@@@@@%%.......
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //......................
#endif
};
/*Store the glyph descriptions*/
static const lv_font_glyph_dsc_t lv_font_symbol_30_glyph_dsc[] = {
#if USE_LV_FONT_SYMBOL_30 == 1
{.w_px = 25, .glyph_index = 0}, /*Unicode: U+f001 ()*/
{.w_px = 32, .glyph_index = 120}, /*Unicode: U+f008 ()*/
{.w_px = 29, .glyph_index = 240}, /*Unicode: U+f00b ()*/
{.w_px = 25, .glyph_index = 360}, /*Unicode: U+f00c ()*/
{.w_px = 20, .glyph_index = 480}, /*Unicode: U+f00d ()*/
{.w_px = 25, .glyph_index = 570}, /*Unicode: U+f011 ()*/
{.w_px = 25, .glyph_index = 690}, /*Unicode: U+f013 ()*/
{.w_px = 23, .glyph_index = 810}, /*Unicode: U+f014 ()*/
{.w_px = 27, .glyph_index = 900}, /*Unicode: U+f015 ()*/
{.w_px = 27, .glyph_index = 1020}, /*Unicode: U+f019 ()*/
{.w_px = 25, .glyph_index = 1140}, /*Unicode: U+f01c ()*/
{.w_px = 25, .glyph_index = 1260}, /*Unicode: U+f021 ()*/
{.w_px = 13, .glyph_index = 1380}, /*Unicode: U+f026 ()*/
{.w_px = 19, .glyph_index = 1440}, /*Unicode: U+f027 ()*/
{.w_px = 27, .glyph_index = 1530}, /*Unicode: U+f028 ()*/
{.w_px = 32, .glyph_index = 1650}, /*Unicode: U+f03e ()*/
{.w_px = 25, .glyph_index = 1770}, /*Unicode: U+f040 ()*/
{.w_px = 17, .glyph_index = 1890}, /*Unicode: U+f048 ()*/
{.w_px = 23, .glyph_index = 1980}, /*Unicode: U+f04b ()*/
{.w_px = 25, .glyph_index = 2070}, /*Unicode: U+f04c ()*/
{.w_px = 25, .glyph_index = 2190}, /*Unicode: U+f04d ()*/
{.w_px = 17, .glyph_index = 2310}, /*Unicode: U+f051 ()*/
{.w_px = 25, .glyph_index = 2400}, /*Unicode: U+f052 ()*/
{.w_px = 18, .glyph_index = 2520}, /*Unicode: U+f053 ()*/
{.w_px = 18, .glyph_index = 2610}, /*Unicode: U+f054 ()*/
{.w_px = 23, .glyph_index = 2700}, /*Unicode: U+f067 ()*/
{.w_px = 23, .glyph_index = 2790}, /*Unicode: U+f068 ()*/
{.w_px = 29, .glyph_index = 2880}, /*Unicode: U+f071 ()*/
{.w_px = 29, .glyph_index = 3000}, /*Unicode: U+f074 ()*/
{.w_px = 27, .glyph_index = 3120}, /*Unicode: U+f077 ()*/
{.w_px = 27, .glyph_index = 3240}, /*Unicode: U+f078 ()*/
{.w_px = 32, .glyph_index = 3360}, /*Unicode: U+f079 ()*/
{.w_px = 27, .glyph_index = 3480}, /*Unicode: U+f07b ()*/
{.w_px = 27, .glyph_index = 3600}, /*Unicode: U+f093 ()*/
{.w_px = 23, .glyph_index = 3720}, /*Unicode: U+f095 ()*/
{.w_px = 29, .glyph_index = 3810}, /*Unicode: U+f0c4 ()*/
{.w_px = 29, .glyph_index = 3930}, /*Unicode: U+f0c5 ()*/
{.w_px = 25, .glyph_index = 4050}, /*Unicode: U+f0c7 ()*/
{.w_px = 15, .glyph_index = 4170}, /*Unicode: U+f0e7 ()*/
{.w_px = 27, .glyph_index = 4230}, /*Unicode: U+f0f3 ()*/
{.w_px = 32, .glyph_index = 4350}, /*Unicode: U+f11c ()*/
{.w_px = 23, .glyph_index = 4470}, /*Unicode: U+f124 ()*/
{.w_px = 25, .glyph_index = 4560}, /*Unicode: U+f15b ()*/
{.w_px = 32, .glyph_index = 4680}, /*Unicode: U+f1eb ()*/
{.w_px = 38, .glyph_index = 4800}, /*Unicode: U+f240 ()*/
{.w_px = 38, .glyph_index = 4950}, /*Unicode: U+f241 ()*/
{.w_px = 38, .glyph_index = 5100}, /*Unicode: U+f242 ()*/
{.w_px = 38, .glyph_index = 5250}, /*Unicode: U+f243 ()*/
{.w_px = 38, .glyph_index = 5400}, /*Unicode: U+f244 ()*/
{.w_px = 22, .glyph_index = 5550}, /*Unicode: U+f293 ()*/
#elif USE_LV_FONT_SYMBOL_30 == 2
{.w_px = 25, .glyph_index = 0}, /*Unicode: U+f001 ()*/
{.w_px = 32, .glyph_index = 210}, /*Unicode: U+f008 ()*/
{.w_px = 29, .glyph_index = 450}, /*Unicode: U+f00b ()*/
{.w_px = 25, .glyph_index = 690}, /*Unicode: U+f00c ()*/
{.w_px = 20, .glyph_index = 900}, /*Unicode: U+f00d ()*/
{.w_px = 25, .glyph_index = 1050}, /*Unicode: U+f011 ()*/
{.w_px = 25, .glyph_index = 1260}, /*Unicode: U+f013 ()*/
{.w_px = 23, .glyph_index = 1470}, /*Unicode: U+f014 ()*/
{.w_px = 27, .glyph_index = 1650}, /*Unicode: U+f015 ()*/
{.w_px = 27, .glyph_index = 1860}, /*Unicode: U+f019 ()*/
{.w_px = 25, .glyph_index = 2070}, /*Unicode: U+f01c ()*/
{.w_px = 25, .glyph_index = 2280}, /*Unicode: U+f021 ()*/
{.w_px = 13, .glyph_index = 2490}, /*Unicode: U+f026 ()*/
{.w_px = 19, .glyph_index = 2610}, /*Unicode: U+f027 ()*/
{.w_px = 27, .glyph_index = 2760}, /*Unicode: U+f028 ()*/
{.w_px = 32, .glyph_index = 2970}, /*Unicode: U+f03e ()*/
{.w_px = 25, .glyph_index = 3210}, /*Unicode: U+f040 ()*/
{.w_px = 17, .glyph_index = 3420}, /*Unicode: U+f048 ()*/
{.w_px = 23, .glyph_index = 3570}, /*Unicode: U+f04b ()*/
{.w_px = 25, .glyph_index = 3750}, /*Unicode: U+f04c ()*/
{.w_px = 25, .glyph_index = 3960}, /*Unicode: U+f04d ()*/
{.w_px = 17, .glyph_index = 4170}, /*Unicode: U+f051 ()*/
{.w_px = 25, .glyph_index = 4320}, /*Unicode: U+f052 ()*/
{.w_px = 18, .glyph_index = 4530}, /*Unicode: U+f053 ()*/
{.w_px = 18, .glyph_index = 4680}, /*Unicode: U+f054 ()*/
{.w_px = 23, .glyph_index = 4830}, /*Unicode: U+f067 ()*/
{.w_px = 23, .glyph_index = 5010}, /*Unicode: U+f068 ()*/
{.w_px = 29, .glyph_index = 5190}, /*Unicode: U+f071 ()*/
{.w_px = 29, .glyph_index = 5430}, /*Unicode: U+f074 ()*/
{.w_px = 27, .glyph_index = 5670}, /*Unicode: U+f077 ()*/
{.w_px = 27, .glyph_index = 5880}, /*Unicode: U+f078 ()*/
{.w_px = 32, .glyph_index = 6090}, /*Unicode: U+f079 ()*/
{.w_px = 27, .glyph_index = 6330}, /*Unicode: U+f07b ()*/
{.w_px = 27, .glyph_index = 6540}, /*Unicode: U+f093 ()*/
{.w_px = 23, .glyph_index = 6750}, /*Unicode: U+f095 ()*/
{.w_px = 29, .glyph_index = 6930}, /*Unicode: U+f0c4 ()*/
{.w_px = 29, .glyph_index = 7170}, /*Unicode: U+f0c5 ()*/
{.w_px = 25, .glyph_index = 7410}, /*Unicode: U+f0c7 ()*/
{.w_px = 15, .glyph_index = 7620}, /*Unicode: U+f0e7 ()*/
{.w_px = 27, .glyph_index = 7740}, /*Unicode: U+f0f3 ()*/
{.w_px = 32, .glyph_index = 7950}, /*Unicode: U+f11c ()*/
{.w_px = 23, .glyph_index = 8190}, /*Unicode: U+f124 ()*/
{.w_px = 25, .glyph_index = 8370}, /*Unicode: U+f15b ()*/
{.w_px = 32, .glyph_index = 8580}, /*Unicode: U+f1eb ()*/
{.w_px = 38, .glyph_index = 8820}, /*Unicode: U+f240 ()*/
{.w_px = 38, .glyph_index = 9120}, /*Unicode: U+f241 ()*/
{.w_px = 38, .glyph_index = 9420}, /*Unicode: U+f242 ()*/
{.w_px = 38, .glyph_index = 9720}, /*Unicode: U+f243 ()*/
{.w_px = 38, .glyph_index = 10020}, /*Unicode: U+f244 ()*/
{.w_px = 22, .glyph_index = 10320}, /*Unicode: U+f293 ()*/
#elif USE_LV_FONT_SYMBOL_30 == 4
{.w_px = 25, .glyph_index = 0}, /*Unicode: U+f001 ()*/
{.w_px = 32, .glyph_index = 390}, /*Unicode: U+f008 ()*/
{.w_px = 29, .glyph_index = 870}, /*Unicode: U+f00b ()*/
{.w_px = 25, .glyph_index = 1320}, /*Unicode: U+f00c ()*/
{.w_px = 20, .glyph_index = 1710}, /*Unicode: U+f00d ()*/
{.w_px = 25, .glyph_index = 2010}, /*Unicode: U+f011 ()*/
{.w_px = 25, .glyph_index = 2400}, /*Unicode: U+f013 ()*/
{.w_px = 23, .glyph_index = 2790}, /*Unicode: U+f014 ()*/
{.w_px = 27, .glyph_index = 3150}, /*Unicode: U+f015 ()*/
{.w_px = 27, .glyph_index = 3570}, /*Unicode: U+f019 ()*/
{.w_px = 25, .glyph_index = 3990}, /*Unicode: U+f01c ()*/
{.w_px = 25, .glyph_index = 4380}, /*Unicode: U+f021 ()*/
{.w_px = 13, .glyph_index = 4770}, /*Unicode: U+f026 ()*/
{.w_px = 19, .glyph_index = 4980}, /*Unicode: U+f027 ()*/
{.w_px = 27, .glyph_index = 5280}, /*Unicode: U+f028 ()*/
{.w_px = 32, .glyph_index = 5700}, /*Unicode: U+f03e ()*/
{.w_px = 25, .glyph_index = 6180}, /*Unicode: U+f040 ()*/
{.w_px = 17, .glyph_index = 6570}, /*Unicode: U+f048 ()*/
{.w_px = 23, .glyph_index = 6840}, /*Unicode: U+f04b ()*/
{.w_px = 25, .glyph_index = 7200}, /*Unicode: U+f04c ()*/
{.w_px = 25, .glyph_index = 7590}, /*Unicode: U+f04d ()*/
{.w_px = 17, .glyph_index = 7980}, /*Unicode: U+f051 ()*/
{.w_px = 25, .glyph_index = 8250}, /*Unicode: U+f052 ()*/
{.w_px = 18, .glyph_index = 8640}, /*Unicode: U+f053 ()*/
{.w_px = 18, .glyph_index = 8910}, /*Unicode: U+f054 ()*/
{.w_px = 23, .glyph_index = 9180}, /*Unicode: U+f067 ()*/
{.w_px = 23, .glyph_index = 9540}, /*Unicode: U+f068 ()*/
{.w_px = 29, .glyph_index = 9900}, /*Unicode: U+f071 ()*/
{.w_px = 29, .glyph_index = 10350}, /*Unicode: U+f074 ()*/
{.w_px = 27, .glyph_index = 10800}, /*Unicode: U+f077 ()*/
{.w_px = 27, .glyph_index = 11220}, /*Unicode: U+f078 ()*/
{.w_px = 32, .glyph_index = 11640}, /*Unicode: U+f079 ()*/
{.w_px = 27, .glyph_index = 12120}, /*Unicode: U+f07b ()*/
{.w_px = 27, .glyph_index = 12540}, /*Unicode: U+f093 ()*/
{.w_px = 23, .glyph_index = 12960}, /*Unicode: U+f095 ()*/
{.w_px = 29, .glyph_index = 13320}, /*Unicode: U+f0c4 ()*/
{.w_px = 29, .glyph_index = 13770}, /*Unicode: U+f0c5 ()*/
{.w_px = 25, .glyph_index = 14220}, /*Unicode: U+f0c7 ()*/
{.w_px = 15, .glyph_index = 14610}, /*Unicode: U+f0e7 ()*/
{.w_px = 27, .glyph_index = 14850}, /*Unicode: U+f0f3 ()*/
{.w_px = 32, .glyph_index = 15270}, /*Unicode: U+f11c ()*/
{.w_px = 23, .glyph_index = 15750}, /*Unicode: U+f124 ()*/
{.w_px = 25, .glyph_index = 16110}, /*Unicode: U+f15b ()*/
{.w_px = 32, .glyph_index = 16500}, /*Unicode: U+f1eb ()*/
{.w_px = 38, .glyph_index = 16980}, /*Unicode: U+f240 ()*/
{.w_px = 38, .glyph_index = 17550}, /*Unicode: U+f241 ()*/
{.w_px = 38, .glyph_index = 18120}, /*Unicode: U+f242 ()*/
{.w_px = 38, .glyph_index = 18690}, /*Unicode: U+f243 ()*/
{.w_px = 38, .glyph_index = 19260}, /*Unicode: U+f244 ()*/
{.w_px = 22, .glyph_index = 19830}, /*Unicode: U+f293 ()*/
#elif USE_LV_FONT_SYMBOL_30 == 8
{.w_px = 25, .glyph_index = 0}, /*Unicode: U+f001 ()*/
{.w_px = 32, .glyph_index = 750}, /*Unicode: U+f008 ()*/
{.w_px = 29, .glyph_index = 1710}, /*Unicode: U+f00b ()*/
{.w_px = 25, .glyph_index = 2580}, /*Unicode: U+f00c ()*/
{.w_px = 20, .glyph_index = 3330}, /*Unicode: U+f00d ()*/
{.w_px = 25, .glyph_index = 3930}, /*Unicode: U+f011 ()*/
{.w_px = 25, .glyph_index = 4680}, /*Unicode: U+f013 ()*/
{.w_px = 23, .glyph_index = 5430}, /*Unicode: U+f014 ()*/
{.w_px = 27, .glyph_index = 6120}, /*Unicode: U+f015 ()*/
{.w_px = 27, .glyph_index = 6930}, /*Unicode: U+f019 ()*/
{.w_px = 25, .glyph_index = 7740}, /*Unicode: U+f01c ()*/
{.w_px = 25, .glyph_index = 8490}, /*Unicode: U+f021 ()*/
{.w_px = 13, .glyph_index = 9240}, /*Unicode: U+f026 ()*/
{.w_px = 19, .glyph_index = 9630}, /*Unicode: U+f027 ()*/
{.w_px = 27, .glyph_index = 10200}, /*Unicode: U+f028 ()*/
{.w_px = 32, .glyph_index = 11010}, /*Unicode: U+f03e ()*/
{.w_px = 25, .glyph_index = 11970}, /*Unicode: U+f040 ()*/
{.w_px = 17, .glyph_index = 12720}, /*Unicode: U+f048 ()*/
{.w_px = 23, .glyph_index = 13230}, /*Unicode: U+f04b ()*/
{.w_px = 25, .glyph_index = 13920}, /*Unicode: U+f04c ()*/
{.w_px = 25, .glyph_index = 14670}, /*Unicode: U+f04d ()*/
{.w_px = 17, .glyph_index = 15420}, /*Unicode: U+f051 ()*/
{.w_px = 25, .glyph_index = 15930}, /*Unicode: U+f052 ()*/
{.w_px = 18, .glyph_index = 16680}, /*Unicode: U+f053 ()*/
{.w_px = 18, .glyph_index = 17220}, /*Unicode: U+f054 ()*/
{.w_px = 23, .glyph_index = 17760}, /*Unicode: U+f067 ()*/
{.w_px = 23, .glyph_index = 18450}, /*Unicode: U+f068 ()*/
{.w_px = 29, .glyph_index = 19140}, /*Unicode: U+f071 ()*/
{.w_px = 29, .glyph_index = 20010}, /*Unicode: U+f074 ()*/
{.w_px = 27, .glyph_index = 20880}, /*Unicode: U+f077 ()*/
{.w_px = 27, .glyph_index = 21690}, /*Unicode: U+f078 ()*/
{.w_px = 32, .glyph_index = 22500}, /*Unicode: U+f079 ()*/
{.w_px = 27, .glyph_index = 23460}, /*Unicode: U+f07b ()*/
{.w_px = 27, .glyph_index = 24270}, /*Unicode: U+f093 ()*/
{.w_px = 23, .glyph_index = 25080}, /*Unicode: U+f095 ()*/
{.w_px = 29, .glyph_index = 25770}, /*Unicode: U+f0c4 ()*/
{.w_px = 29, .glyph_index = 26640}, /*Unicode: U+f0c5 ()*/
{.w_px = 25, .glyph_index = 27510}, /*Unicode: U+f0c7 ()*/
{.w_px = 15, .glyph_index = 28260}, /*Unicode: U+f0e7 ()*/
{.w_px = 27, .glyph_index = 28710}, /*Unicode: U+f0f3 ()*/
{.w_px = 32, .glyph_index = 29520}, /*Unicode: U+f11c ()*/
{.w_px = 23, .glyph_index = 30480}, /*Unicode: U+f124 ()*/
{.w_px = 25, .glyph_index = 31170}, /*Unicode: U+f15b ()*/
{.w_px = 32, .glyph_index = 31920}, /*Unicode: U+f1eb ()*/
{.w_px = 38, .glyph_index = 32880}, /*Unicode: U+f240 ()*/
{.w_px = 38, .glyph_index = 34020}, /*Unicode: U+f241 ()*/
{.w_px = 38, .glyph_index = 35160}, /*Unicode: U+f242 ()*/
{.w_px = 38, .glyph_index = 36300}, /*Unicode: U+f243 ()*/
{.w_px = 38, .glyph_index = 37440}, /*Unicode: U+f244 ()*/
{.w_px = 22, .glyph_index = 38580}, /*Unicode: U+f293 ()*/
#endif
};
lv_font_t lv_font_symbol_30 = {
.unicode_first = LV_SYMBOL_GLYPH_FIRST, /*First Unicode letter in this font*/
.unicode_last = LV_SYMBOL_GLYPH_LAST, /*Last Unicode letter in this font*/
.h_px = 30, /*Font height in pixels*/
.glyph_bitmap = lv_font_symbol_30_glyph_bitmap, /*Bitmap of glyphs*/
.glyph_dsc = lv_font_symbol_30_glyph_dsc, /*Description of glyphs*/
.glyph_cnt = 50, /*Number of glyphs in the font*/
.unicode_list = NULL,
.get_bitmap = lv_font_get_bitmap_continuous, /*Function pointer to get glyph's bitmap*/
.get_width = lv_font_get_width_continuous, /*Function pointer to get glyph's width*/
#if USE_LV_FONT_SYMBOL_30 == 1
.bpp = 1, /*Bit per pixel*/
#elif USE_LV_FONT_SYMBOL_30 == 2
.bpp = 2, /*Bit per pixel*/
#elif USE_LV_FONT_SYMBOL_30 == 4
.bpp = 4, /*Bit per pixel*/
#elif USE_LV_FONT_SYMBOL_30 == 8
.bpp = 8, /*Bit per pixel*/
#endif
.monospace = 0,
.next_page = NULL, /*Pointer to a font extension*/
};
#endif /*USE_LV_FONT_SYMBOL_30*/
|
222835b3adb1f634f8b0b643672f2c1b5b6507d9
|
8a51a96f61699f0318315ccc89cef39f6866f2b5
|
/src/backend/nodes/queryjumblefuncs.c
|
281907a4d83d3f3fff51b1f821dca6ee6ac3040a
|
[
"PostgreSQL"
] |
permissive
|
postgres/postgres
|
979febf2b41c00090d1256228f768f33e7ef3b6f
|
b5934bfd6071fed3a38cea0cfaa93afda63d9c0c
|
refs/heads/master
| 2023-08-31T00:10:01.373472
| 2023-08-30T23:07:48
| 2023-08-30T23:07:48
| 927,442
| 13,691
| 4,807
|
NOASSERTION
| 2023-09-09T13:59:15
| 2010-09-21T11:35:45
|
C
|
UTF-8
|
C
| false
| false
| 10,288
|
c
|
queryjumblefuncs.c
|
/*-------------------------------------------------------------------------
*
* queryjumblefuncs.c
* Query normalization and fingerprinting.
*
* Normalization is a process whereby similar queries, typically differing only
* in their constants (though the exact rules are somewhat more subtle than
* that) are recognized as equivalent, and are tracked as a single entry. This
* is particularly useful for non-prepared queries.
*
* Normalization is implemented by fingerprinting queries, selectively
* serializing those fields of each query tree's nodes that are judged to be
* essential to the query. This is referred to as a query jumble. This is
* distinct from a regular serialization in that various extraneous
* information is ignored as irrelevant or not essential to the query, such
* as the collations of Vars and, most notably, the values of constants.
*
* This jumble is acquired at the end of parse analysis of each query, and
* a 64-bit hash of it is stored into the query's Query.queryId field.
* The server then copies this value around, making it available in plan
* tree(s) generated from the query. The executor can then use this value
* to blame query costs on the proper queryId.
*
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* src/backend/nodes/queryjumblefuncs.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "common/hashfn.h"
#include "miscadmin.h"
#include "nodes/queryjumble.h"
#include "parser/scansup.h"
#define JUMBLE_SIZE 1024 /* query serialization buffer size */
/* GUC parameters */
int compute_query_id = COMPUTE_QUERY_ID_AUTO;
/* True when compute_query_id is ON, or AUTO and a module requests them */
bool query_id_enabled = false;
static void AppendJumble(JumbleState *jstate,
const unsigned char *item, Size size);
static void RecordConstLocation(JumbleState *jstate, int location);
static void _jumbleNode(JumbleState *jstate, Node *node);
static void _jumbleA_Const(JumbleState *jstate, Node *node);
static void _jumbleList(JumbleState *jstate, Node *node);
static void _jumbleRangeTblEntry(JumbleState *jstate, Node *node);
/*
* Given a possibly multi-statement source string, confine our attention to the
* relevant part of the string.
*/
const char *
CleanQuerytext(const char *query, int *location, int *len)
{
int query_location = *location;
int query_len = *len;
/* First apply starting offset, unless it's -1 (unknown). */
if (query_location >= 0)
{
Assert(query_location <= strlen(query));
query += query_location;
/* Length of 0 (or -1) means "rest of string" */
if (query_len <= 0)
query_len = strlen(query);
else
Assert(query_len <= strlen(query));
}
else
{
/* If query location is unknown, distrust query_len as well */
query_location = 0;
query_len = strlen(query);
}
/*
* Discard leading and trailing whitespace, too. Use scanner_isspace()
* not libc's isspace(), because we want to match the lexer's behavior.
*/
while (query_len > 0 && scanner_isspace(query[0]))
query++, query_location++, query_len--;
while (query_len > 0 && scanner_isspace(query[query_len - 1]))
query_len--;
*location = query_location;
*len = query_len;
return query;
}
JumbleState *
JumbleQuery(Query *query)
{
JumbleState *jstate = NULL;
Assert(IsQueryIdEnabled());
jstate = (JumbleState *) palloc(sizeof(JumbleState));
/* Set up workspace for query jumbling */
jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE);
jstate->jumble_len = 0;
jstate->clocations_buf_size = 32;
jstate->clocations = (LocationLen *)
palloc(jstate->clocations_buf_size * sizeof(LocationLen));
jstate->clocations_count = 0;
jstate->highest_extern_param_id = 0;
/* Compute query ID and mark the Query node with it */
_jumbleNode(jstate, (Node *) query);
query->queryId = DatumGetUInt64(hash_any_extended(jstate->jumble,
jstate->jumble_len,
0));
/*
* If we are unlucky enough to get a hash of zero, use 1 instead for
* normal statements and 2 for utility queries.
*/
if (query->queryId == UINT64CONST(0))
{
if (query->utilityStmt)
query->queryId = UINT64CONST(2);
else
query->queryId = UINT64CONST(1);
}
return jstate;
}
/*
* Enables query identifier computation.
*
* Third-party plugins can use this function to inform core that they require
* a query identifier to be computed.
*/
void
EnableQueryId(void)
{
if (compute_query_id != COMPUTE_QUERY_ID_OFF)
query_id_enabled = true;
}
/*
* AppendJumble: Append a value that is substantive in a given query to
* the current jumble.
*/
static void
AppendJumble(JumbleState *jstate, const unsigned char *item, Size size)
{
unsigned char *jumble = jstate->jumble;
Size jumble_len = jstate->jumble_len;
/*
* Whenever the jumble buffer is full, we hash the current contents and
* reset the buffer to contain just that hash value, thus relying on the
* hash to summarize everything so far.
*/
while (size > 0)
{
Size part_size;
if (jumble_len >= JUMBLE_SIZE)
{
uint64 start_hash;
start_hash = DatumGetUInt64(hash_any_extended(jumble,
JUMBLE_SIZE, 0));
memcpy(jumble, &start_hash, sizeof(start_hash));
jumble_len = sizeof(start_hash);
}
part_size = Min(size, JUMBLE_SIZE - jumble_len);
memcpy(jumble + jumble_len, item, part_size);
jumble_len += part_size;
item += part_size;
size -= part_size;
}
jstate->jumble_len = jumble_len;
}
/*
* Record location of constant within query string of query tree
* that is currently being walked.
*/
static void
RecordConstLocation(JumbleState *jstate, int location)
{
/* -1 indicates unknown or undefined location */
if (location >= 0)
{
/* enlarge array if needed */
if (jstate->clocations_count >= jstate->clocations_buf_size)
{
jstate->clocations_buf_size *= 2;
jstate->clocations = (LocationLen *)
repalloc(jstate->clocations,
jstate->clocations_buf_size *
sizeof(LocationLen));
}
jstate->clocations[jstate->clocations_count].location = location;
/* initialize lengths to -1 to simplify third-party module usage */
jstate->clocations[jstate->clocations_count].length = -1;
jstate->clocations_count++;
}
}
#define JUMBLE_NODE(item) \
_jumbleNode(jstate, (Node *) expr->item)
#define JUMBLE_LOCATION(location) \
RecordConstLocation(jstate, expr->location)
#define JUMBLE_FIELD(item) \
AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item))
#define JUMBLE_FIELD_SINGLE(item) \
AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))
#define JUMBLE_STRING(str) \
do { \
if (expr->str) \
AppendJumble(jstate, (const unsigned char *) (expr->str), strlen(expr->str) + 1); \
} while(0)
#include "queryjumblefuncs.funcs.c"
static void
_jumbleNode(JumbleState *jstate, Node *node)
{
Node *expr = node;
if (expr == NULL)
return;
/* Guard against stack overflow due to overly complex expressions */
check_stack_depth();
/*
* We always emit the node's NodeTag, then any additional fields that are
* considered significant, and then we recurse to any child nodes.
*/
JUMBLE_FIELD(type);
switch (nodeTag(expr))
{
#include "queryjumblefuncs.switch.c"
case T_List:
case T_IntList:
case T_OidList:
case T_XidList:
_jumbleList(jstate, expr);
break;
default:
/* Only a warning, since we can stumble along anyway */
elog(WARNING, "unrecognized node type: %d",
(int) nodeTag(expr));
break;
}
/* Special cases to handle outside the automated code */
switch (nodeTag(expr))
{
case T_Param:
{
Param *p = (Param *) node;
/*
* Update the highest Param id seen, in order to start
* normalization correctly.
*/
if (p->paramkind == PARAM_EXTERN &&
p->paramid > jstate->highest_extern_param_id)
jstate->highest_extern_param_id = p->paramid;
}
break;
default:
break;
}
}
static void
_jumbleList(JumbleState *jstate, Node *node)
{
List *expr = (List *) node;
ListCell *l;
switch (expr->type)
{
case T_List:
foreach(l, expr)
_jumbleNode(jstate, lfirst(l));
break;
case T_IntList:
foreach(l, expr)
JUMBLE_FIELD_SINGLE(lfirst_int(l));
break;
case T_OidList:
foreach(l, expr)
JUMBLE_FIELD_SINGLE(lfirst_oid(l));
break;
case T_XidList:
foreach(l, expr)
JUMBLE_FIELD_SINGLE(lfirst_xid(l));
break;
default:
elog(ERROR, "unrecognized list node type: %d",
(int) expr->type);
return;
}
}
static void
_jumbleA_Const(JumbleState *jstate, Node *node)
{
A_Const *expr = (A_Const *) node;
JUMBLE_FIELD(isnull);
if (!expr->isnull)
{
JUMBLE_FIELD(val.node.type);
switch (nodeTag(&expr->val))
{
case T_Integer:
JUMBLE_FIELD(val.ival.ival);
break;
case T_Float:
JUMBLE_STRING(val.fval.fval);
break;
case T_Boolean:
JUMBLE_FIELD(val.boolval.boolval);
break;
case T_String:
JUMBLE_STRING(val.sval.sval);
break;
case T_BitString:
JUMBLE_STRING(val.bsval.bsval);
break;
default:
elog(ERROR, "unrecognized node type: %d",
(int) nodeTag(&expr->val));
break;
}
}
}
static void
_jumbleRangeTblEntry(JumbleState *jstate, Node *node)
{
RangeTblEntry *expr = (RangeTblEntry *) node;
JUMBLE_FIELD(rtekind);
switch (expr->rtekind)
{
case RTE_RELATION:
JUMBLE_FIELD(relid);
JUMBLE_NODE(tablesample);
JUMBLE_FIELD(inh);
break;
case RTE_SUBQUERY:
JUMBLE_NODE(subquery);
break;
case RTE_JOIN:
JUMBLE_FIELD(jointype);
break;
case RTE_FUNCTION:
JUMBLE_NODE(functions);
break;
case RTE_TABLEFUNC:
JUMBLE_NODE(tablefunc);
break;
case RTE_VALUES:
JUMBLE_NODE(values_lists);
break;
case RTE_CTE:
/*
* Depending on the CTE name here isn't ideal, but it's the only
* info we have to identify the referenced WITH item.
*/
JUMBLE_STRING(ctename);
JUMBLE_FIELD(ctelevelsup);
break;
case RTE_NAMEDTUPLESTORE:
JUMBLE_STRING(enrname);
break;
case RTE_RESULT:
break;
default:
elog(ERROR, "unrecognized RTE kind: %d", (int) expr->rtekind);
break;
}
}
|
213677acad0e77b42266cc42d1181ce0603f7653
|
e65a4dbfbfb0e54e59787ba7741efee12f7687f3
|
/games/openarena/files/patch-code_qcommon_q__platform.h
|
241faa4dcaea9bece8821f7ea02aaa00fd1b5ce5
|
[
"BSD-2-Clause"
] |
permissive
|
freebsd/freebsd-ports
|
86f2e89d43913412c4f6b2be3e255bc0945eac12
|
605a2983f245ac63f5420e023e7dce56898ad801
|
refs/heads/main
| 2023-08-30T21:46:28.720924
| 2023-08-30T19:33:44
| 2023-08-30T19:33:44
| 1,803,961
| 916
| 918
|
NOASSERTION
| 2023-09-08T04:06:26
| 2011-05-26T11:15:35
| null |
UTF-8
|
C
| false
| false
| 398
|
h
|
patch-code_qcommon_q__platform.h
|
--- code/qcommon/q_platform.h.orig 2020-11-23 13:12:36 UTC
+++ code/qcommon/q_platform.h
@@ -235,6 +235,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
#define ARCH_STRING "amd64"
#elif defined __axp__
#define ARCH_STRING "alpha"
+#elif defined __powerpc64__
+#define ARCH_STRING "ppc64"
+#elif defined __powerpc__
+#define ARCH_STRING "ppc"
#endif
#if BYTE_ORDER == BIG_ENDIAN
|
7081dc26d705f4ad0bda2e60b160ee2f43652a7b
|
de21f9075f55640514c29ef0f1fe3f0690845764
|
/regression/goto-instrument/value-set-fi-fp-removal4/test.c
|
b99e6c73e8e517829cdbed683cfeade685213e9f
|
[
"BSD-2-Clause",
"LicenseRef-scancode-unknown-license-reference",
"BSD-4-Clause"
] |
permissive
|
diffblue/cbmc
|
975a074ac445febb3b5715f8792beb545522dc18
|
decd2839c2f51a54b2ad0f3e89fdc1b4bf78cd16
|
refs/heads/develop
| 2023-08-31T05:52:05.342195
| 2023-08-30T13:31:51
| 2023-08-30T13:31:51
| 51,877,056
| 589
| 309
|
NOASSERTION
| 2023-09-14T18:49:17
| 2016-02-16T23:03:52
|
C++
|
UTF-8
|
C
| false
| false
| 242
|
c
|
test.c
|
#include <assert.h>
typedef void (*fp_t)();
void f()
{
}
void g()
{
}
int main(void)
{
// the value set for fp is empty, defaults to standard function pointer removal behaviour
fp_t other_fp = g;
other_fp = f;
fp_t fp;
fp();
}
|
534ba0c7831210899fbf16ce6e02116b8c7a597d
|
28d0f8c01599f8f6c711bdde0b59f9c2cd221203
|
/sys/arch/zaurus/dev/lcdctl.c
|
fc61eaeacdd45ca73b03adb68a5bc20461e104e8
|
[] |
no_license
|
NetBSD/src
|
1a9cbc22ed778be638b37869ed4fb5c8dd616166
|
23ee83f7c0aea0777bd89d8ebd7f0cde9880d13c
|
refs/heads/trunk
| 2023-08-31T13:24:58.105962
| 2023-08-27T15:50:47
| 2023-08-27T15:50:47
| 88,439,547
| 656
| 348
| null | 2023-07-20T20:07:24
| 2017-04-16T20:03:43
| null |
UTF-8
|
C
| false
| false
| 8,305
|
c
|
lcdctl.c
|
/* $NetBSD: lcdctl.c,v 1.3 2012/01/29 10:12:41 tsutsui Exp $ */
/*-
* Copyright (C) 2012 NONAKA Kimihiro <nonaka@netbsd.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lcdctl.c,v 1.3 2012/01/29 10:12:41 tsutsui Exp $");
#include "ioexp.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/bus.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>
#include <zaurus/zaurus/zaurus_var.h>
#include <zaurus/dev/lcdctlvar.h>
#include <zaurus/dev/zsspvar.h>
#include <zaurus/dev/scoopvar.h>
#include <zaurus/dev/ioexpvar.h>
struct lcdctl_backlight {
int duty; /* LZ9JG18 DAC value */
int cont; /* BACKLIGHT_CONT signal */
int on; /* BACKLIGHT_ON signal */
};
struct lcdctl_softc {
device_t sc_dev;
int sc_brightness;
int sc_brightnesscurval;
bool sc_islit;
bool sc_isblank;
int sc_nbacklighttbl;
const struct lcdctl_backlight *sc_backlighttbl;
};
/* for SL-C1000/SL-C3x00 */
static const struct lcdctl_backlight lcdctl_backlight_c3000[] = {
{ 0x00, 0, 0 }, /* 0: Off */
{ 0x00, 0, 1 }, /* 1: 0% */
{ 0x01, 0, 1 }, /* 2: 20% */
{ 0x07, 0, 1 }, /* 3: 40% */
{ 0x01, 1, 1 }, /* 4: 60% */
{ 0x07, 1, 1 }, /* 5: 80% */
{ 0x11, 1, 1 } /* 6: 100% */
};
static int lcdctl_match(device_t, cfdata_t, void *);
static void lcdctl_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(lcdctl, sizeof(struct lcdctl_softc),
lcdctl_match, lcdctl_attach, NULL, NULL);
static void lcdctl_brightness_up(device_t);
static void lcdctl_brightness_down(device_t);
static void lcdctl_display_on(device_t);
static void lcdctl_display_off(device_t);
static void lcdctl_set_brightness(struct lcdctl_softc *, int);
static void lcdctl_set_blank(struct lcdctl_softc *, bool);
static void lcdctl_set_backlight(struct lcdctl_softc *, bool);
static struct lcdctl_softc *lcdctl_sc;
static int
lcdctl_match(device_t parent, cfdata_t cf, void *aux)
{
struct zssp_attach_args *aa = aux;
if (strcmp("lcdctl", aa->zaa_name))
return 0;
return 1;
}
static void
lcdctl_attach(device_t parent, device_t self, void *aux)
{
struct lcdctl_softc *sc = device_private(self);
sc->sc_dev = self;
aprint_normal("\n");
aprint_naive("\n");
sc->sc_brightness = sc->sc_brightnesscurval = 1;
sc->sc_islit = true;
sc->sc_isblank = false;
if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
sc->sc_nbacklighttbl = __arraycount(lcdctl_backlight_c3000);
sc->sc_backlighttbl = lcdctl_backlight_c3000;
} else {
/* XXX: Is this okay for C7x0/860? */
sc->sc_nbacklighttbl = __arraycount(lcdctl_backlight_c3000);
sc->sc_backlighttbl = lcdctl_backlight_c3000;
}
/* Start with approximately 40% of full brightness. */
lcdctl_set_brightness(sc, 3);
lcdctl_sc = sc;
if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_UP,
lcdctl_brightness_up, true))
aprint_error_dev(self, "couldn't register event handler\n");
if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_DOWN,
lcdctl_brightness_down, true))
aprint_error_dev(self, "couldn't register event handler\n");
if (!pmf_event_register(self, PMFE_DISPLAY_ON,
lcdctl_display_on, true))
aprint_error_dev(self, "couldn't register event handler\n");
if (!pmf_event_register(self, PMFE_DISPLAY_OFF,
lcdctl_display_off, true))
aprint_error_dev(self, "couldn't register event handler\n");
}
static void
lcdctl_brightness_up(device_t dv)
{
struct lcdctl_softc *sc = device_private(dv);
lcdctl_set_brightness(sc, sc->sc_brightness + 1);
}
static void
lcdctl_brightness_down(device_t dv)
{
struct lcdctl_softc *sc = device_private(dv);
lcdctl_set_brightness(sc, sc->sc_brightness - 1);
}
static void
lcdctl_display_on(device_t dv)
{
struct lcdctl_softc *sc = device_private(dv);
lcdctl_set_blank(sc, false);
lcdctl_set_backlight(sc, true);
}
static void
lcdctl_display_off(device_t dv)
{
struct lcdctl_softc *sc = device_private(dv);
lcdctl_set_backlight(sc, false);
lcdctl_set_blank(sc, true);
}
static __inline void
set_backlight(const struct lcdctl_backlight *bl)
{
(void) zssp_ic_send(ZSSP_IC_LZ9JG18, bl->duty);
if (ZAURUS_ISC1000)
ioexp_set_backlight(bl->on, bl->cont);
else
scoop_set_backlight(bl->on, bl->cont);
}
static void
lcdctl_set_brightness_internal(struct lcdctl_softc *sc, int newval)
{
int i;
/*
* It appears that the C3000 backlight can draw too much power if we
* switch it from a low to a high brightness. Increasing brightness
* in steps avoids this issue.
*/
if (newval > sc->sc_brightnesscurval) {
for (i = sc->sc_brightnesscurval + 1; i <= newval; i++) {
set_backlight(&sc->sc_backlighttbl[i]);
delay(5000);
}
} else
set_backlight(&sc->sc_backlighttbl[newval]);
sc->sc_brightnesscurval = newval;
}
static void
lcdctl_set_brightness(struct lcdctl_softc *sc, int newval)
{
int maxval = sc->sc_nbacklighttbl - 1;
if (newval < 0)
newval = 0;
else if (newval > maxval)
newval = maxval;
if (sc->sc_islit && !sc->sc_isblank)
lcdctl_set_brightness_internal(sc, newval);
if (newval > 0)
sc->sc_brightness = newval;
}
static void
lcdctl_set_backlight(struct lcdctl_softc *sc, bool onoff)
{
if (!onoff) {
lcdctl_set_brightness(sc, 0);
sc->sc_islit = false;
} else {
sc->sc_islit = true;
lcdctl_set_brightness(sc, sc->sc_brightness);
}
}
static void
lcdctl_set_blank(struct lcdctl_softc *sc, bool isblank)
{
if (isblank) {
lcdctl_set_brightness(sc, 0);
sc->sc_isblank = true;
} else {
sc->sc_isblank = false;
lcdctl_set_brightness(sc, sc->sc_brightness);
}
}
static void
lcdctl_set_onoff(struct lcdctl_softc *sc, bool onoff)
{
if (!onoff) {
lcdctl_set_brightness(sc, 0);
} else {
lcdctl_set_brightness(sc, sc->sc_brightness);
}
}
static int
lcdctl_param_ioctl(struct lcdctl_softc *sc, u_long cmd, struct wsdisplay_param *dp)
{
int rv = EINVAL;
switch (dp->param) {
case WSDISPLAYIO_PARAM_BACKLIGHT:
if (cmd == WSDISPLAYIO_GETPARAM) {
dp->min = 0;
dp->max = 1;
dp->curval = sc->sc_islit ? 1 : 0;
rv = 0;
} else if (cmd == WSDISPLAYIO_SETPARAM) {
lcdctl_set_backlight(sc, dp->curval != 0);
rv = 0;
}
break;
case WSDISPLAYIO_PARAM_CONTRAST:
/* unsupported */
rv = ENOTTY;
break;
case WSDISPLAYIO_PARAM_BRIGHTNESS:
if (cmd == WSDISPLAYIO_GETPARAM) {
dp->min = 1;
dp->max = sc->sc_nbacklighttbl - 1;
dp->curval = sc->sc_brightness;
rv = 0;
} else if (cmd == WSDISPLAYIO_SETPARAM) {
lcdctl_set_brightness(sc, dp->curval);
rv = 0;
}
break;
}
return rv;
}
void
lcdctl_brightness(int newval)
{
if (__predict_true(lcdctl_sc != NULL))
lcdctl_set_brightness(lcdctl_sc, newval);
}
void
lcdctl_blank(bool isblank)
{
if (__predict_true(lcdctl_sc != NULL))
lcdctl_set_blank(lcdctl_sc, isblank);
}
void
lcdctl_onoff(bool onoff)
{
if (__predict_true(lcdctl_sc != NULL))
lcdctl_set_onoff(lcdctl_sc, onoff);
}
int
lcdctl_param(u_long cmd, struct wsdisplay_param *dp)
{
if (__predict_true(lcdctl_sc != NULL))
return lcdctl_param_ioctl(lcdctl_sc, cmd, dp);
return ENOTTY; /* unsupported */
}
|
167fe72a5b3ea5d531189b2db8ba3dccb1bd7c4f
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/drivers/gpu/drm/nouveau/nv50_fence.c
|
0ee363840035b1e67bd3e6c6b8bb63afbf4d8ea3
|
[
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 3,621
|
c
|
nv50_fence.c
|
/*
* Copyright 2012 Red Hat 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
*
* Authors: Ben Skeggs <bskeggs@redhat.com>
*/
#include <core/object.h>
#include <core/class.h>
#include "nouveau_drm.h"
#include "nouveau_dma.h"
#include "nv10_fence.h"
#include "nv50_display.h"
static int
nv50_fence_context_new(struct nouveau_channel *chan)
{
struct drm_device *dev = chan->drm->dev;
struct nv10_fence_priv *priv = chan->drm->fence;
struct nv10_fence_chan *fctx;
struct ttm_mem_reg *mem = &priv->bo->bo.mem;
struct nouveau_object *object;
u32 start = mem->start * PAGE_SIZE;
u32 limit = start + mem->size - 1;
int ret, i;
fctx = chan->fence = kzalloc(sizeof(*fctx), GFP_KERNEL);
if (!fctx)
return -ENOMEM;
nouveau_fence_context_new(&fctx->base);
fctx->base.emit = nv10_fence_emit;
fctx->base.read = nv10_fence_read;
fctx->base.sync = nv17_fence_sync;
ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
NvSema, 0x003d,
&(struct nv_dma_class) {
.flags = NV_DMA_TARGET_VRAM |
NV_DMA_ACCESS_RDWR,
.start = start,
.limit = limit,
}, sizeof(struct nv_dma_class),
&object);
/* dma objects for display sync channel semaphore blocks */
for (i = 0; !ret && i < dev->mode_config.num_crtc; i++) {
struct nouveau_bo *bo = nv50_display_crtc_sema(dev, i);
u32 start = bo->bo.mem.start * PAGE_SIZE;
u32 limit = start + bo->bo.mem.size - 1;
ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
NvEvoSema0 + i, 0x003d,
&(struct nv_dma_class) {
.flags = NV_DMA_TARGET_VRAM |
NV_DMA_ACCESS_RDWR,
.start = start,
.limit = limit,
}, sizeof(struct nv_dma_class),
&object);
}
if (ret)
nv10_fence_context_del(chan);
return ret;
}
int
nv50_fence_create(struct nouveau_drm *drm)
{
struct nv10_fence_priv *priv;
int ret = 0;
priv = drm->fence = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->base.dtor = nv10_fence_destroy;
priv->base.resume = nv17_fence_resume;
priv->base.context_new = nv50_fence_context_new;
priv->base.context_del = nv10_fence_context_del;
spin_lock_init(&priv->lock);
ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
0, 0x0000, NULL, &priv->bo);
if (!ret) {
ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
if (!ret) {
ret = nouveau_bo_map(priv->bo);
if (ret)
nouveau_bo_unpin(priv->bo);
}
if (ret)
nouveau_bo_ref(NULL, &priv->bo);
}
if (ret) {
nv10_fence_destroy(drm);
return ret;
}
nouveau_bo_wr32(priv->bo, 0x000, 0x00000000);
return ret;
}
|
5960b6c85a25743c566a96fe0846c92cc6ef1ebd
|
2898fa4f2ad766afa0495a837f59fe95daa081a7
|
/tests/unit-pass/reference-binding-2.C
|
3a0f68a29aab49a7cb7e35760e42076006455022
|
[
"NCSA"
] |
permissive
|
kframework/c-semantics
|
12fcc1b1bf1f7792636d1c37f6f7bb1b89a392b5
|
e6879d14455771aa0cb3e3d201131d4d763a73a2
|
refs/heads/master
| 2023-07-31T23:57:03.316456
| 2022-02-01T17:50:31
| 2022-02-01T17:50:31
| 11,747,541
| 312
| 52
|
NOASSERTION
| 2022-02-01T17:50:33
| 2013-07-29T19:13:25
|
C
|
UTF-8
|
C
| false
| false
| 63
|
c
|
reference-binding-2.C
|
int a = 1;
int main() {
int &beta = a;
beta--;
return a;
}
|
bceaef4f856768060e37f085eb83b2b6b96fc6de
|
59864cbd213b5da6f50d6255b0a021564b3d5bd4
|
/disabled-challenges/CAT/lib/cgc_libc.h
|
e0605bb7e144374b5805e5bc4dff784c2a430faa
|
[
"MIT"
] |
permissive
|
trailofbits/cb-multios
|
8af96a4fbc3b34644367faa135347f88e0e0d0a3
|
810d7b24b1f62f56ef49b148fe155b0d0629cad2
|
refs/heads/master
| 2023-09-05T03:56:20.229403
| 2022-12-27T15:47:54
| 2022-12-27T15:47:54
| 41,688,943
| 522
| 133
|
MIT
| 2023-06-29T02:47:13
| 2015-08-31T17:04:31
|
C
|
UTF-8
|
C
| false
| false
| 2,402
|
h
|
cgc_libc.h
|
/*
* Copyright (C) Narf Industries <info@narfindustries.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef LIBC_H
#define LIBC_H 1
// #define DEBUG 1
// We avoid including all of stdlib because then it would be easier to bisect
// which functions are stdlib across CBs.
#include "libcgc.h"
// #include "cgc_stdint.h"
#include "cgc_memset.h"
#include "cgc_memcpy.h"
// #include "cgc_recv_until_delim_n.h"
#include "cgc_send_bytes.h"
#include "cgc_recv_bytes.h"
// #include "cgc_char.h"
// #include "cgc_streq.h"
// #include "cgc_strlen.h"
// #include "cgc_list.h"
// #include "cgc_malloc.h"
typedef unsigned char uint8_t;
typedef uint8_t byte_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef uint8_t bool;
#define FALSE 0
#define TRUE 1
#define INT_MAX 0x7FFFFFFF
#define SUCCESS 0
#define SZ_PAGE 0x1000
#ifdef DEBUG
#include "cgc_debug.h"
#define dbg(args...) fprintf(stderr, "[D] %s:%d @ %s | ", __FILE__, __LINE__, __func__);fprintf(stderr, args);
#define err(args...) \
fprintf(stderr, "[E] %s:%d @ %s | ", __FILE__, __LINE__, __func__);\
fprintf(stderr, args);\
if(SUCCESS == ret) { ret = -1; }\
goto bail;
#else
#define dbg(args...) do { } while (0);
#define err(args...) goto bail;
#endif
#define CHK_SUCCESS(code, args...) if (SUCCESS != (ret = code)) { err(args); }
#endif
|
7aa7d67ad8e504f2297f3446c66d26668c3f75fe
|
88aca3340574f733b9ecd6f76708ecd2d57cb07e
|
/vendor/bundle/ruby/2.6.0/gems/ffi-1.15.5/ext/ffi_c/Struct.h
|
eb6edf282870639adfa037c5a124af72d67823b2
|
[
"Apache-2.0",
"MIT",
"BSD-3-Clause"
] |
permissive
|
collabnix/dockerlabs
|
65c63a8424d34120bddc0fc8d6fd54a688953491
|
0f2a6b906a8ca0ebc28561236d4d6516f93b184c
|
refs/heads/master
| 2023-09-05T07:30:30.601797
| 2023-09-05T07:25:53
| 2023-09-05T07:25:53
| 153,069,455
| 5,239
| 1,854
|
Apache-2.0
| 2023-09-03T05:51:41
| 2018-10-15T07:19:18
|
PHP
|
UTF-8
|
C
| false
| false
| 3,716
|
h
|
Struct.h
|
/*
* Copyright (c) 2008, 2009, Wayne Meissner
* Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
*
* Copyright (c) 2008-2013, Ruby FFI project contributors
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Ruby FFI project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef RBFFI_STRUCT_H
#define RBFFI_STRUCT_H
#include "extconf.h"
#include "AbstractMemory.h"
#include "Type.h"
#include <ruby/st.h>
#ifdef __cplusplus
extern "C" {
#endif
extern void rbffi_Struct_Init(VALUE ffiModule);
extern void rbffi_StructLayout_Init(VALUE ffiModule);
typedef struct StructField_ StructField;
typedef struct StructLayout_ StructLayout;
typedef struct Struct_ Struct;
struct StructField_ {
Type* type;
unsigned int offset;
int referenceIndex;
bool referenceRequired;
VALUE rbType;
VALUE rbName;
VALUE (*get)(StructField* field, Struct* s);
void (*put)(StructField* field, Struct* s, VALUE value);
MemoryOp* memoryOp;
};
struct StructLayout_ {
Type base;
StructField** fields;
int fieldCount;
int size;
int align;
ffi_type** ffiTypes;
/*
* We use the fieldName's minor 8 Bits as index to a 256 entry cache.
* This avoids full ruby hash lookups for repeated lookups.
*/
#define FIELD_CACHE_LOOKUP(this, sym) ( &(this)->cache_row[((sym) >> 8) & 0xff] )
struct field_cache_entry {
VALUE fieldName;
StructField *field;
} cache_row[0x100];
/** The number of reference tracking fields in this struct */
int referenceFieldCount;
VALUE rbFieldNames;
VALUE rbFieldMap;
VALUE rbFields;
};
struct Struct_ {
StructLayout* layout;
AbstractMemory* pointer;
VALUE* rbReferences;
VALUE rbLayout;
VALUE rbPointer;
};
extern VALUE rbffi_StructClass, rbffi_StructLayoutClass;
extern VALUE rbffi_StructLayoutFieldClass, rbffi_StructLayoutFunctionFieldClass;
extern VALUE rbffi_StructLayoutArrayFieldClass;
extern VALUE rbffi_StructInlineArrayClass;
extern VALUE rbffi_StructLayoutCharArrayClass;
#ifdef __cplusplus
}
#endif
#endif /* RBFFI_STRUCT_H */
|
b517b92615c8353c09a77d2fb53c021f1078f7dc
|
0878580d8373128457cff2809284c999caf7c7d8
|
/Source/Includes/Game.h
|
fde056f4522daddc45924f8a8a498b77f592faa6
|
[] |
no_license
|
NovFR/DoS-2-Savegame-Editor
|
a9618ca7d317055475cae3f26a8aa7dd242864e7
|
267d7b594aa4723b696bb8883698a274e70ab3d1
|
refs/heads/master
| 2023-01-28T01:25:00.186332
| 2021-04-20T10:27:38
| 2021-04-20T10:27:38
| 186,271,246
| 113
| 19
| null | null | null | null |
UTF-8
|
C
| false
| false
| 11,681
|
h
|
Game.h
|
//<<>-<>>---------------------------------------------------------------------()
/*
Structures du jeu
*/
//()-------------------------------------------------------------------<<>-<>>//
#ifndef _GAME_DEFINITIONS
#define _GAME_DEFINITIONS
// ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ //
// ¤¤¤ ¤¤¤ //
// ¤¤¤ Définitions ¤¤¤ //
// ¤¤¤ ¤¤¤ //
// ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ //
#include "XML.h"
#include "Menus.h"
#include "Definitions.h"
#define GAME_ICON_SIZE 48
#define GAME_EQUIPPED_SLOT_MAX 10
#define GAME_LEVEL_MIN 1
#define GAME_LEVEL_MAX 35
#define GAME_ATTRIBUTE_MIN 1
#define GAME_ATTRIBUTE_MAX 40
#define GAME_ATTRIBUTE_OVERRIDE 999
#define GAME_POINTS_MIN 0
#define GAME_POINTS_MAX 99
#define GAME_ABILITIES_OVERRIDE 99
#define GAME_DISPLAY_BARHEIGHT 20
#define GAME_DISPLAY_BARVPADDING 4
#define GAME_DISPLAY_BARHPADDING 4
#define GAME_LOCK_DISABLED 0x00000000 // default
#define GAME_LOCK_ENABLED 0x00000001
#define GAME_LOCK_APP 0x00000002
#define GAME_LOCK_FILE 0x00000004
#define GAME_LOCK_TREE 0x00000008
#define GAME_LOCK_SETUP 0x00000010
#define GAME_LOCK_ALL GAME_LOCK_APP|GAME_LOCK_FILE|GAME_LOCK_TREE|GAME_LOCK_SETUP
enum {
ITEM_TYPE_REAL = 1,
ITEM_TYPE_ROOT,
ITEM_TYPE_PARENT,
};
enum {
DATA_TYPE_ITEMS = 1,
DATA_TYPE_BOOSTERS,
DATA_TYPE_RUNES,
DATA_TYPE_TAGS,
DATA_TYPE_SKILLS,
DATA_TYPE_INSERTIONS,
};
enum {
DATA_TYPE_IS_ITEM = 0,
DATA_TYPE_IS_ARMOR,
DATA_TYPE_IS_WEAPON,
DATA_TYPE_IS_ACCESSORY,
};
enum {
CMP_TYPE_FULL = 1,
CMP_TYPE_BEGIN,
CMP_TYPE_END,
CMP_TYPE_CONTENT,
};
// ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ //
// ¤¤¤ ¤¤¤ //
// ¤¤¤ Structures ¤¤¤ //
// ¤¤¤ ¤¤¤ //
// ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ //
//--- Structures générales ---
typedef struct DOS2INVENTORY {
NODE node;
NODE nodeItems;
void* pParentItem;
int iTopIndex;
int iSelected;
} DOS2INVENTORY;
typedef struct DOS2CHARACTER {
NODE node;
NODE nodeInventories;
UINT uInventoryDepth;
//--- References
XML_NODE* pxnRoot;
XML_ATTR* pxaInventoryId;
XML_ATTR* pxaArmor;
XML_ATTR* pxaArmorMax;
XML_ATTR* pxaMagicArmor;
XML_ATTR* pxaMagicArmorMax;
XML_ATTR* pxaVitality;
XML_ATTR* pxaVitalityMax;
XML_ATTR* pxaMap;
XML_ATTR* pxaDamageCount;
XML_ATTR* pxaHealCount;
XML_ATTR* pxaKillCount;
XML_ATTR* pxaName;
XML_ATTR* pxaOriginName;
XML_ATTR* pxaRace;
XML_ATTR* pxaClass;
XML_ATTR* pxaExp;
XML_ATTR* pxaPoints[4];
XML_ATTR* pxaAttributes[6];
XML_ATTR* pxaAbilities[40];
XML_ATTR* pxaTalents[4];
XML_NODE* pxaTags;
DOS2INVENTORY* pdiInventory;
} DOS2CHARACTER;
typedef struct DOS2ITEM {
NODE node;
BOOL bIsBackPack;
UINT uNumItems;
WCHAR* pszDisplayName;
//--- References
XML_NODE* pxnRoot;
XML_ATTR* pxaHandle;
XML_ATTR* pxaStats;
XML_ATTR* pxaDisplayName;
XML_ATTR* pxaDescription;
XML_ATTR* pxaAmount;
XML_ATTR* pxaIsGenerated;
XML_ATTR* pxaHasCustomBase;
XML_ATTR* pxaSlot;
XML_ATTR* pxaInventory;
XML_ATTR* pxaType;
XML_ATTR* pxaLevel;
XML_ATTR* pxaLevelGroupIndex;
XML_ATTR* pxaNameIndex;
XML_ATTR* pxaRunes[3];
XML_NODE* pxnGeneration;
XML_NODE* pxnPermanentBoost;
XML_NODE* pxnBase;
XML_NODE* pxnLevelOverride;
} DOS2ITEM;
//--- Affichage ---
typedef struct DOS2ICON {
NODE node;
HICON hIcon;
WCHAR* pszName;
} DOS2ICON;
typedef struct GAMEQUALITY {
WCHAR* xmlName;
UINT uNameId;
COLORREF crColor;
} GAMEQUALITY;
typedef struct GAMEORIGIN {
WCHAR* pszName;
UINT uLocaleId;
} GAMEORIGIN;
typedef struct GAMEDRAWCONTEXT {
//--- GDI
HFONT hFont;
RECT rcArea;
RECT rcWork;
RECT rcText;
RECT rcRgn;
COLORREF crColor;
int iBack;
//--- Game
WCHAR* pszClass;
WCHAR* pszExp;
WCHAR* pszLevel;
WCHAR szLevel[4];
WCHAR* pszArmor;
WCHAR* pszMagicArmor;
WCHAR* pszVitality;
WCHAR szNextLevel[12];
struct {
SIZE sizeClass;
SIZE sizeClassSpace;
SIZE sizeLabel;
SIZE sizeSpace;
SIZE sizeLevel;
WCHAR* pszText;
} level;
} GAMEDRAWCONTEXT;
//--- Données ---
typedef struct GAMEDATABOOSTER {
WCHAR* pszType;
WCHAR* pszSlot;
} GAMEDATABOOSTER;
typedef struct GAMEDATARUNE {
WCHAR* pszBonus1;
WCHAR* pszBonus2;
WCHAR* pszBonus3;
} GAMEDATARUNE;
typedef struct GAMEDATATAG {
BOOL bProtected;
BOOL bHidden;
WCHAR* pszDescription;
} GAMEDATATAG;
typedef struct GAMEDATA {
NODE node;
WCHAR* pszId;
WCHAR* pszText;
union {
GAMEDATABOOSTER booster;
GAMEDATARUNE rune;
GAMEDATATAG tag;
};
} GAMEDATA;
typedef struct GAMEDATAFLAG {
char* pszFlagName;
UINT uType;
UINT64 uFlags;
} GAMEDATAFLAG;
typedef struct GAMEDATASCHOOL {
char* pszSchool;
UINT uLocaleId;
} GAMEDATASCHOOL;
typedef struct GAMEDATAITEM {
NODE node;
UINT uType;
UINT64 uFlags;
WCHAR* pszIconName;
struct {
WCHAR* pszFull;
WCHAR* pszBegin;
WCHAR* pszContent;
WCHAR* pszEnd;
} filter;
} GAMEDATAITEM;
typedef struct GAMEDATASKILLINFOS {
UINT uSourcePoints;
UINT uActionPoints;
UINT uMemorySlots;
UINT uIconID;
UINT uSchoolLocaleID;
} GAMEDATASKILLINFOS;
typedef struct GAMEDATASKILLOPTIONS {
BOOL bIsLearned;
BOOL bIsActivated;
BOOL bZeroMemory;
float fActiveCooldown;
double fTimeAdded;
} GAMEDATASKILLOPTIONS;
typedef struct GAMEDATASKILL {
NODE node;
WCHAR* pszId;
WCHAR* pszName;
int iIconIndex;
GAMEDATASKILLINFOS infos;
GAMEDATASKILLOPTIONS options;
} GAMEDATASKILL;
typedef struct GAMEDATAINSERT {
NODE node;
WCHAR* pszName;
WCHAR* pszContent;
CUSTOMMENUTEMPLATE cMenu;
} GAMEDATAINSERT;
typedef struct GAMEDATAPARSER {
BOOL bSuccess;
HANDLE hFile;
DWORD dwFileSize;
BYTE* pFileBuffer;
BYTE* pFilePtr;
BYTE* pLinePtr;
BYTE* pLineBegin;
BYTE* pLineEnd;
LOCALE_MISC* pLocale;
WCHAR* pszTemp;
WCHAR* pszResults[4];
union {
GAMEDATAITEM* pItem;
GAMEDATA* pData;
GAMEDATASKILL* pSkill;
GAMEDATAINSERT* pInsert;
};
} GAMEDATAPARSER;
// ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ //
// ¤¤¤ ¤¤¤ //
// ¤¤¤ Prototypes ¤¤¤ //
// ¤¤¤ ¤¤¤ //
// ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ //
// «»»» Gestion «««««««««««««««««««««««««««««««««««««««««««««««««««««««««»
int Game_CreateLayout(void);
int Game_CreateInventoryGroups(HWND);
int Game_CreateButton(HWND,int,int,int,int,WCHAR *,UINT,HWND *,UINT);
void Game_Resize(void);
void Game_InventoryMenu(HWND,UINT);
int CALLBACK Game_ItemsListSort(LPARAM,LPARAM,LPARAM);
void Game_Setup(DOS2CHARACTER *,BOOL,BOOL);
int Game_BuildPlayers(NODE *,BOOL);
void Game_ReleasePlayers(NODE *,BOOL);
DOS2INVENTORY* Game_BuildInventory(DOS2ITEM *,XML_ATTR *,NODE *);
UINT Game_GetInventoryItemsCount(XML_NODE *,WCHAR *);
void Game_ReleaseInventory(DOS2INVENTORY *);
void Game_ReleaseItem(DOS2ITEM *);
void Game_ReleaseDisplayNames(void);
void Game_CharacterChanged(BOOL);
void Game_BuildItemsList(DOS2CHARACTER *,HWND);
void Game_UpdateButtons(void);
void Game_SaveTopIndex(DOS2CHARACTER *,HWND);
void Game_SetDefsMenu(HMENU);
void Game_Lock(DWORD);
UINT Game_GetLevelFromExp(UINT);
UINT Game_GetExpFromLevel(UINT);
UINT Game_GetNextLevelFromExp(UINT);
UINT Game_GetMaxXP(void);
UINT Game_GetMaxLevel(void);
BOOL Game_IsItemEquipped(DOS2ITEM *);
void Game_ItemDisplayName(DOS2ITEM *);
void Game_ItemDisplayNameRelease(DOS2ITEM *);
XML_NODE* Game_ItemGetOwner(DOS2ITEM *,WCHAR *);
WCHAR* Game_ItemGetOwnerHandle(DOS2ITEM *,WCHAR *);
BOOL Game_ItemBelongToCharacter(DOS2ITEM *);
BOOL Game_ItemBelongToParty(DOS2ITEM *);
// «»»» Affichage «««««««««««««««««««««««««««««««««««««««««««««««««««««««»
void Game_MeasureList(MEASUREITEMSTRUCT *);
void Game_DrawList(DRAWITEMSTRUCT *);
void Game_MeasureInventory(MEASUREITEMSTRUCT *);
void Game_DrawInventory(DRAWITEMSTRUCT *);
void Game_Paint(HWND,HDC,RECT *);
void Game_PaintDecorationBorder(DRAWITEMSTRUCT *,BOOL);
void Game_PaintDecoration(HDC,int,int,HBITMAP);
void Game_PaintAttributes(HWND,HDC,RECT *);
int Game_PaintStat(HDC,HWND,RECT *,UINT,WCHAR *,UINT);
void Game_PaintValue(HDC,LONG,HWND,WCHAR *,WCHAR *,UINT);
void Game_PaintButton(DRAWITEMSTRUCT *);
void Game_PaintBag(DOS2CHARACTER *,DRAWITEMSTRUCT *);
void Game_PaintIcon(HDC,WCHAR *,UINT,RECT *,int,BOOL,BOOL);
// «»»» Fenêtre des attributs «««««««««««««««««««««««««««««««««««««««««««»
LRESULT Game_ContainerCreate(HWND);
LRESULT Game_ProcessContainerMessages(HWND,UINT,WPARAM,LPARAM);
void Game_ContainerResize(HWND,int,int);
void Game_ContainerMouseWheel(HWND,int);
void Game_ContainerScroll(UINT);
long Game_ContainerTopOffset(LONG,RECT *);
void Game_ContainerScrollInfo(UINT);
LRESULT Game_AttributesCreate(HWND);
LRESULT Game_ProcessAttributesMessages(HWND,UINT,WPARAM,LPARAM);
void Game_AttributesResize(HWND,int,int);
void Game_AttributesMakeFocusVisible(void);
// «»»» Fichiers de données «««««««««««««««««««««««««««««««««««««««««««««»
BOOL Game_LoadDataFile(HWND,WCHAR *,UINT,NODE *);
BYTE* Game_LoadSplitWord(BYTE *);
BYTE* Game_LoadLeadingSpaces(BYTE *,BYTE *,DWORD);
BYTE* Game_LoadNextLine(BYTE *,BYTE *,DWORD,BOOL);
void Game_LoadGetItemInfos(char *,GAMEDATAITEM *);
void Game_LoadGetItemInfo(char *,GAMEDATAITEM *);
void Game_UnloadDataFile(UINT,NODE *);
WCHAR* Game_GetItemIconName(WCHAR *);
WCHAR* Game_GetItemTypeName(WCHAR *);
UINT Game_GetItemType(WCHAR *);
UINT64 Game_GetItemFlags(WCHAR *);
GAMEDATAITEM* Game_GetItemData(WCHAR *);
BOOL Game_CompareStrings(WCHAR *,WCHAR *,UINT,UINT);
// «»»» Statistiques ««««««««««««««««««««««««««««««««««««««««««««««««««««»
void Game_Stats(HWND);
int Game_Stats_Init(HWND,RECT *,int,void *);
BOOL Game_Stats_Draw(UINT,DRAWITEMSTRUCT *,void *);
void Game_Stats_Click(HWND,UINT,void *);
WCHAR* Game_Stats_GetOriginName(WCHAR *);
void Game_Stats_SetNumber(HWND,UINT,WCHAR *);
int Game_Stats_SetItem(HWND,UINT,int,WCHAR *,WCHAR *,WCHAR *,UINT);
int Game_Stats_Sort(LPARAM,LPARAM,LPARAM);
// «»»» Icônes & Objets «««««««««««««««««««««««««««««««««««««««««««««««««»
void Game_ItemsCopyToClipboard(void *,UINT);
WCHAR* Game_ItemsGetDisplayName(DOS2ITEM *);
void Game_ItemsLocalizationRebuild(HWND);
DWORD WINAPI Game_ItemsLocalizationRebuildThread(DEFSCONTEXT *);
void Game_IconsRebuild(HWND);
DWORD WINAPI Game_IconsRebuildThread(DEFSCONTEXT *);
void Game_ItemsStatsRebuild(HWND);
DWORD WINAPI Game_ItemsStatsRebuildThread(DEFSCONTEXT *);
void Game_ItemsRootRebuild(HWND hWnd);
DWORD WINAPI Game_ItemsRootRebuildThread(DEFSCONTEXT *);
#endif
|
6f7327203d1791f8c60dfca0fb2c91e7fa2dff0f
|
28d0f8c01599f8f6c711bdde0b59f9c2cd221203
|
/sys/arch/ia64/disasm/disasm_format.c
|
546346929020f227780b7b3eaf600ce8d741e2c2
|
[] |
no_license
|
NetBSD/src
|
1a9cbc22ed778be638b37869ed4fb5c8dd616166
|
23ee83f7c0aea0777bd89d8ebd7f0cde9880d13c
|
refs/heads/trunk
| 2023-08-31T13:24:58.105962
| 2023-08-27T15:50:47
| 2023-08-27T15:50:47
| 88,439,547
| 656
| 348
| null | 2023-07-20T20:07:24
| 2017-04-16T20:03:43
| null |
UTF-8
|
C
| false
| false
| 9,998
|
c
|
disasm_format.c
|
/* $NetBSD: disasm_format.c,v 1.5 2016/08/05 16:45:50 scole Exp $ */
/*-
* Copyright (c) 2000-2006 Marcel Moolenaar
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "opt_ddb.h"
#include <sys/cdefs.h>
/* __FBSDID("$FreeBSD: releng/10.1/sys/ia64/disasm/disasm_format.c 159916 2006-06-24 19:21:11Z marcel $"); */
#include <sys/param.h>
#include <sys/systm.h>
#ifdef DDB
#include <ia64/disasm/disasm_int.h>
#include <ia64/disasm/disasm.h>
/*
* Mnemonics (keep in sync with enum asm_op).
*/
static const char *asm_mnemonics[] = {
"",
"add", "addl", "addp4", "adds", "alloc", "and", "andcm",
"br", "break", "brl", "brp", "bsw",
"chk", "clrrrb", "cmp", "cmp4", "cmp8xchg16", "cmpxchg1", "cmpxchg2",
"cmpxchg4", "cmpxchg8", "cover", "czx1", "czx2",
"dep",
"epc", "extr",
"famax", "famin", "fand", "fandcm", "fc", "fchkf", "fclass", "fclrf",
"fcmp", "fcvt", "fetchadd4", "fetchadd8", "flushrs", "fma", "fmax",
"fmerge", "fmin", "fmix", "fms", "fnma", "for", "fpack", "fpamax",
"fpamin", "fpcmp", "fpcvt", "fpma", "fpmax", "fpmerge", "fpmin",
"fpms", "fpnma", "fprcpa", "fprsqrta", "frcpa", "frsqrta", "fselect",
"fsetc", "fswap", "fsxt", "fwb", "fxor",
"getf",
"hint",
"invala", "itc", "itr",
"ld1", "ld16", "ld2", "ld4", "ld8", "ldf", "ldf8", "ldfd", "ldfe",
"ldfp8", "ldfpd", "ldfps", "ldfs", "lfetch", "loadrs",
"mf", "mix1", "mix2", "mix4", "mov", "movl", "mux1", "mux2",
"nop",
"or",
"pack2", "pack4", "padd1", "padd2", "padd4", "pavg1", "pavg2",
"pavgsub1", "pavgsub2", "pcmp1", "pcmp2", "pcmp4", "pmax1", "pmax2",
"pmin1", "pmin2", "pmpy2", "pmpyshr2", "popcnt", "probe", "psad1",
"pshl2", "pshl4", "pshladd2", "pshr2", "pshr4", "pshradd2", "psub1",
"psub2", "psub4", "ptc", "ptr",
"rfi", "rsm", "rum",
"setf", "shl", "shladd", "shladdp4", "shr", "shrp", "srlz", "ssm",
"st1", "st16", "st2", "st4", "st8", "stf", "stf8", "stfd", "stfe",
"stfs", "sub", "sum", "sxt1", "sxt2", "sxt4", "sync",
"tak", "tbit", "tf", "thash", "tnat", "tpa", "ttag",
"unpack1", "unpack2", "unpack4",
"vmsw",
"xchg1", "xchg2", "xchg4", "xchg8", "xma", "xor",
"zxt1", "zxt2", "zxt4"
};
/*
* Completers (keep in sync with enum asm_cmpltr_type).
*/
static const char *asm_completers[] = {
"",
".0", ".1",
".a", ".acq", ".and",
".b", ".bias",
".c.clr", ".c.clr.acq", ".c.nc", ".call", ".cexit", ".cloop", ".clr",
".ctop",
".d", ".dc.dc", ".dc.nt", ".dpnt", ".dptk",
".e", ".eq", ".excl", ".exit", ".exp",
".f", ".fault", ".few", ".fill", ".fx", ".fxu",
".g", ".ga", ".ge", ".gt",
".h", ".hu",
".i", ".ia", ".imp",
".l", ".le", ".loop", ".lr", ".lt", ".ltu",
".m", ".many",
".nc", ".ne", ".neq", ".nl", ".nle", ".nlt", ".nm", ".nr", ".ns",
".nt.dc", ".nt.nt", ".nt.tk", ".nt1", ".nt2", ".nta", ".nz",
".or", ".or.andcm", ".ord",
".pr",
".r", ".raz", ".rel", ".ret", ".rw",
".s", ".s0", ".s1", ".s2", ".s3", ".sa", ".se", ".sig", ".spill",
".spnt", ".sptk", ".sss",
".tk.dc", ".tk.nt", ".tk.tk", ".trunc",
".u", ".unc", ".unord", ".uss", ".uus", ".uuu",
".w", ".wexit", ".wtop",
".x", ".xf",
".z"
};
void
asm_completer(const struct asm_cmpltr *c, char *buf, size_t buflen)
{
strlcpy(buf, asm_completers[c->c_type], buflen);
}
void
asm_mnemonic(enum asm_op op, char *buf, size_t buflen)
{
strlcpy(buf, asm_mnemonics[(op < ASM_OP_INTERNAL_OPCODES) ? op : 0],
buflen);
}
void
asm_operand(const struct asm_oper *o, char *buf, size_t buflen, uint64_t ip)
{
const char *n;
size_t l;
n = "";
switch (o->o_type) {
case ASM_OPER_AREG:
switch ((int)o->o_value) {
case AR_K0: n = "k0"; break;
case AR_K1: n = "k1"; break;
case AR_K2: n = "k2"; break;
case AR_K3: n = "k3"; break;
case AR_K4: n = "k4"; break;
case AR_K5: n = "k5"; break;
case AR_K6: n = "k6"; break;
case AR_K7: n = "k7"; break;
case AR_RSC: n = "rsc"; break;
case AR_BSP: n = "bsp"; break;
case AR_BSPSTORE: n = "bspstore"; break;
case AR_RNAT: n = "rnat"; break;
case AR_FCR: n = "fcr"; break;
case AR_EFLAG: n = "eflag"; break;
case AR_CSD: n = "csd"; break;
case AR_SSD: n = "ssd"; break;
case AR_CFLG: n = "cflg"; break;
case AR_FSR: n = "fsr"; break;
case AR_FIR: n = "fir"; break;
case AR_FDR: n = "fdr"; break;
case AR_CCV: n = "ccv"; break;
case AR_UNAT: n = "unat"; break;
case AR_FPSR: n = "fpsr"; break;
case AR_ITC: n = "itc"; break;
case AR_PFS: n = "pfs"; break;
case AR_LC: n = "lc"; break;
case AR_EC: n = "ec"; break;
default:
snprintf(buf, buflen, "ar%d", (int)o->o_value);
return;
}
snprintf(buf, buflen, "ar.%s", n);
return;
case ASM_OPER_BREG:
if (o->o_value != 0)
snprintf(buf, buflen, "b%d", (int)o->o_value);
else
strlcpy(buf, "rp", buflen);
return;
case ASM_OPER_CPUID:
n = "cpuid";
break;
case ASM_OPER_CREG:
switch ((int)o->o_value) {
case CR_DCR: n = "dcr"; break;
case CR_ITM: n = "itm"; break;
case CR_IVA: n = "iva"; break;
case CR_PTA: n = "pta"; break;
case CR_IPSR: n = "ipsr"; break;
case CR_ISR: n = "isr"; break;
case CR_IIP: n = "iip"; break;
case CR_IFA: n = "ifa"; break;
case CR_ITIR: n = "itir"; break;
case CR_IIPA: n = "iipa"; break;
case CR_IFS: n = "ifs"; break;
case CR_IIM: n = "iim"; break;
case CR_IHA: n = "iha"; break;
case CR_LID: n = "lid"; break;
case CR_IVR: n = "ivr"; break;
case CR_TPR: n = "tpr"; break;
case CR_EOI: n = "eoi"; break;
case CR_IRR0: n = "irr0"; break;
case CR_IRR1: n = "irr1"; break;
case CR_IRR2: n = "irr2"; break;
case CR_IRR3: n = "irr3"; break;
case CR_ITV: n = "itv"; break;
case CR_PMV: n = "pmv"; break;
case CR_CMCV: n = "cmcv"; break;
case CR_LRR0: n = "lrr0"; break;
case CR_LRR1: n = "lrr1"; break;
default:
snprintf(buf, buflen, "cr%d", (int)o->o_value);
return;
}
snprintf(buf, buflen, "cr.%s", n);
return;
case ASM_OPER_DBR:
n = "dbr";
break;
case ASM_OPER_DISP:
snprintf(buf, buflen, "%lx", ip + o->o_value);
return;
case ASM_OPER_DTR:
n = "dtr";
break;
case ASM_OPER_FREG:
snprintf(buf, buflen, "f%d", (int)o->o_value);
return;
case ASM_OPER_GREG:
break;
case ASM_OPER_IBR:
n = "ibr";
break;
case ASM_OPER_IMM:
snprintf(buf, buflen, "0x%lx", o->o_value);
return;
case ASM_OPER_IP:
strlcpy(buf, "ip", buflen);
return;
case ASM_OPER_ITR:
n = "itr";
break;
case ASM_OPER_MEM:
n = "";
break;
case ASM_OPER_MSR:
n = "msr";
break;
case ASM_OPER_PKR:
n = "pkr";
break;
case ASM_OPER_PMC:
n = "pmc";
break;
case ASM_OPER_PMD:
n = "pmd";
break;
case ASM_OPER_PR:
strlcpy(buf, "pr", buflen);
return;
case ASM_OPER_PR_ROT:
strlcpy(buf, "pr.rot", buflen);
return;
case ASM_OPER_PREG:
snprintf(buf, buflen, "p%d", (int)o->o_value);
return;
case ASM_OPER_PSR:
strlcpy(buf, "psr", buflen);
return;
case ASM_OPER_PSR_L:
strlcpy(buf, "psr.l", buflen);
return;
case ASM_OPER_PSR_UM:
strlcpy(buf, "psr.um", buflen);
return;
case ASM_OPER_RR:
n = "rr";
break;
case ASM_OPER_NONE:
KASSERT(0);
break;
}
if (n[0] != '\0') {
l = snprintf(buf, buflen, "%s[", n);
if (l > buflen)
l = buflen;
buf += l;
buflen -= l;
}
switch ((int)o->o_value) {
case 1: l = strlcpy(buf, "gp", buflen); break;
case 12: l = strlcpy(buf, "sp", buflen); break;
case 13: l = strlcpy(buf, "tp", buflen); break;
default:
l = snprintf(buf, buflen, "r%d", (int)o->o_value);
if (l > buflen)
l = buflen;
break;
}
buf += l;
buflen -= l;
if (n[0] != '\0')
strlcpy(buf, "]", buflen);
}
void
asm_print_bundle(const struct asm_bundle *b, uint64_t ip)
{
asm_print_inst(b, 0, ip);
asm_print_inst(b, 1, ip);
asm_print_inst(b, 2, ip);
}
void
asm_print_inst(const struct asm_bundle *b, int slot, uint64_t ip)
{
char buf[32];
const struct asm_inst *i;
const char *tmpl;
int n, w;
tmpl = b->b_templ + slot;
if (*tmpl == ';' || (slot == 2 && b->b_templ[1] == ';'))
tmpl++;
i = b->b_inst + slot;
if (*tmpl == 'L' || i->i_op == ASM_OP_NONE)
return;
/* Address + slot. */
printf("%lx[%c] ", ip + slot, *tmpl);
/* Predicate. */
if (i->i_oper[0].o_value != 0) {
asm_operand(i->i_oper+0, buf, sizeof(buf), ip);
printf("(%s)", buf);
w = strlen(buf);
} else
w = 0;
while (w++ < 8)
printf(" ");
/* Mnemonic & completers. */
asm_mnemonic(i->i_op, buf, sizeof(buf));
printf("%s", buf);
w = strlen(buf);
n = 0;
while (n < i->i_ncmpltrs) {
asm_completer(i->i_cmpltr + n, buf, sizeof(buf));
printf(buf);
w += strlen(buf);
n++;
}
while (w++ < 15)
printf(" ");
printf(" ");
/* Operands. */
n = 1;
while (n < 7 && i->i_oper[n].o_type != ASM_OPER_NONE) {
if (n > 1) {
if (n == i->i_srcidx)
printf(" = ");
else
printf(", ");
}
asm_operand(i->i_oper + n, buf, sizeof(buf), ip);
printf("%s", buf);
n++;
}
printf("\n");
}
#endif
|
d92581b65422e66963b804acef84f2d161e27983
|
7eaf54a78c9e2117247cb2ab6d3a0c20719ba700
|
/SOFTWARE/A64-TERES/linux-a64/arch/m32r/include/asm/timex.h
|
bb9fe4feb12d51847cf0a42de2183699b270b41c
|
[
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"Linux-syscall-note",
"GPL-2.0-only",
"GPL-1.0-or-later"
] |
permissive
|
OLIMEX/DIY-LAPTOP
|
ae82f4ee79c641d9aee444db9a75f3f6709afa92
|
a3fafd1309135650bab27f5eafc0c32bc3ca74ee
|
refs/heads/rel3
| 2023-08-04T01:54:19.483792
| 2023-04-03T07:18:12
| 2023-04-03T07:18:12
| 80,094,055
| 507
| 92
|
Apache-2.0
| 2023-04-03T07:05:59
| 2017-01-26T07:25:50
|
C
|
UTF-8
|
C
| false
| false
| 542
|
h
|
timex.h
|
#ifndef _ASM_M32R_TIMEX_H
#define _ASM_M32R_TIMEX_H
/*
* linux/include/asm-m32r/timex.h
*
* m32r architecture timex specifications
*/
#define CLOCK_TICK_RATE (CONFIG_BUS_CLOCK / CONFIG_TIMER_DIVIDE)
#define CLOCK_TICK_FACTOR 20 /* Factor of both 1000000 and CLOCK_TICK_RATE */
#ifdef __KERNEL__
/*
* Standard way to access the cycle counter.
* Currently only used on SMP.
*/
typedef unsigned long long cycles_t;
static __inline__ cycles_t get_cycles (void)
{
return 0;
}
#endif /* __KERNEL__ */
#endif /* _ASM_M32R_TIMEX_H */
|
2337fa82f84341ea1f0254c0754b66e58a104537
|
79d343002bb63a44f8ab0dbac0c9f4ec54078c3a
|
/lib/libc/musl/src/process/execvp.c
|
ef3b9dd598fc57ab8f257c4043c9f00c62000234
|
[
"MIT",
"BSD-3-Clause",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-musl-exception"
] |
permissive
|
ziglang/zig
|
4aa75d8d3bcc9e39bf61d265fd84b7f005623fc5
|
f4c9e19bc3213c2bc7e03d7b06d7129882f39f6c
|
refs/heads/master
| 2023-08-31T13:16:45.980913
| 2023-08-31T05:50:29
| 2023-08-31T05:50:29
| 40,276,274
| 25,560
| 2,399
|
MIT
| 2023-09-14T21:09:50
| 2015-08-06T00:51:28
|
Zig
|
UTF-8
|
C
| false
| false
| 1,106
|
c
|
execvp.c
|
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
extern char **__environ;
int __execvpe(const char *file, char *const argv[], char *const envp[])
{
const char *p, *z, *path = getenv("PATH");
size_t l, k;
int seen_eacces = 0;
errno = ENOENT;
if (!*file) return -1;
if (strchr(file, '/'))
return execve(file, argv, envp);
if (!path) path = "/usr/local/bin:/bin:/usr/bin";
k = strnlen(file, NAME_MAX+1);
if (k > NAME_MAX) {
errno = ENAMETOOLONG;
return -1;
}
l = strnlen(path, PATH_MAX-1)+1;
for(p=path; ; p=z) {
char b[l+k+1];
z = __strchrnul(p, ':');
if (z-p >= l) {
if (!*z++) break;
continue;
}
memcpy(b, p, z-p);
b[z-p] = '/';
memcpy(b+(z-p)+(z>p), file, k+1);
execve(b, argv, envp);
switch (errno) {
case EACCES:
seen_eacces = 1;
case ENOENT:
case ENOTDIR:
break;
default:
return -1;
}
if (!*z++) break;
}
if (seen_eacces) errno = EACCES;
return -1;
}
int execvp(const char *file, char *const argv[])
{
return __execvpe(file, argv, __environ);
}
weak_alias(__execvpe, execvpe);
|
4e1aca061d83861c99bb4e135db8fc942d601268
|
f3eed0234b4d0ad2bbb2abd700cf1e2c7a0e8a1d
|
/AKWF-c/AKWF_bw_blended/AKWF_blended_0056.h
|
d91fcd22410da6ac268013bc6b71afc43efc52b3
|
[
"CC0-1.0"
] |
permissive
|
KristofferKarlAxelEkstrand/AKWF-FREE
|
b2defa1a2d389d309be6dd2e9f968923daf80d1b
|
cf8171df36e9fec25416b5f568b72a6e2cb69194
|
refs/heads/master
| 2023-07-23T18:22:36.939705
| 2023-07-10T17:14:40
| 2023-07-10T17:14:40
| 145,817,187
| 359
| 59
|
CC0-1.0
| 2023-07-10T17:14:41
| 2018-08-23T07:26:56
| null |
UTF-8
|
C
| false
| false
| 4,688
|
h
|
AKWF_blended_0056.h
|
/* Adventure Kid Waveforms (AKWF) converted for use with Teensy Audio Library
*
* Adventure Kid Waveforms(AKWF) Open waveforms library
* https://www.adventurekid.se/akrt/waveforms/adventure-kid-waveforms/
*
* This code is in the public domain, CC0 1.0 Universal (CC0 1.0)
* https://creativecommons.org/publicdomain/zero/1.0/
*
* Converted by Brad Roy, https://github.com/prosper00
*/
/* AKWF_blended_0056 256 samples
+-----------------------------------------------------------------------------------------------------------------+
| ******** * |
| ******** * |
| ******** * |
| ******** * |
| ******* * |
| ******* * |
| ******* * |
|**** * ***|
| * ******** |
| ****** ******** |
| * ******* |
| * ******* |
| * ******** |
| * ******** |
| * ******** |
+-----------------------------------------------------------------------------------------------------------------+
*/
const uint16_t AKWF_blended_0056 [] = {
32858, 33132, 33391, 33659, 33923, 34190, 34453, 34719, 34983, 35248, 35515, 35778, 36044, 36308, 36574, 36838,
37104, 37368, 37635, 37898, 38164, 38427, 38693, 38957, 39223, 39488, 39753, 40019, 40283, 40548, 40813, 41078,
41344, 41609, 41873, 42138, 42403, 42668, 42932, 43198, 43462, 43727, 43993, 44258, 44523, 44788, 45052, 45319,
45582, 45848, 46112, 46378, 46642, 46907, 47173, 47437, 47703, 47966, 48233, 48494, 48764, 49024, 49298, 49551,
49829, 50078, 50361, 50606, 50894, 51135, 51424, 51664, 51954, 52195, 52483, 52728, 53008, 53264, 53530, 53801,
54050, 54344, 54568, 54888, 55082, 55432, 55596, 55979, 56111, 56524, 56627, 57064, 57150, 57600, 57678, 58126,
58218, 58641, 58769, 59141, 59336, 59627, 59916, 60099, 60513, 60555, 61122, 61000, 61742, 61434, 62372, 61864,
63002, 62294, 63630, 62731, 64247, 63179, 64851, 63638, 65455, 64065, 65535, 62938, 27326, 22611, 25277, 23698,
25505, 24489, 25749, 25393, 25697, 27110, 7987, 0, 2606, 176, 2527, 1102, 2758, 1877, 3080, 2589,
3447, 3264, 3849, 3907, 4279, 4523, 4736, 5114, 5215, 5684, 5715, 6235, 6234, 6768, 6766, 7290,
7309, 7804, 7859, 8313, 8410, 8820, 8963, 9328, 9515, 9836, 10064, 10348, 10608, 10867, 11148, 11389,
11684, 11914, 12217, 12442, 12748, 12973, 13276, 13506, 13802, 14039, 14329, 14572, 14856, 15104, 15383, 15638,
15910, 16170, 16438, 16702, 16967, 17233, 17496, 17764, 18025, 18294, 18556, 18823, 19085, 19354, 19617, 19882,
20146, 20413, 20676, 20942, 21206, 21472, 21736, 22002, 22267, 22532, 22796, 23061, 23327, 23591, 23856, 24121,
24386, 24651, 24916, 25181, 25446, 25711, 25976, 26240, 26507, 26770, 27036, 27301, 27566, 27830, 28096, 28360,
28625, 28891, 29155, 29421, 29685, 29951, 30215, 30482, 30744, 31012, 31274, 31542, 31803, 32073, 32330, 32611,
};
|
60f0df5e3a404beec39af00daddae8646d963a95
|
f4ea6db9183b38e0cb1af1d317b0a02db24455d1
|
/test/t-language/tl-appliedlfun09.c
|
3c2a820a547881d29dc15f8b542d7057c62740d8
|
[
"BSD-3-Clause",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause"
] |
permissive
|
ldmud/ldmud
|
1446ff7101f5a47ee1dfa4cfb97d5a326f2edcce
|
f1cfc9a8d911412d854055058889bb32432da2db
|
refs/heads/master
| 2023-05-25T00:36:28.318383
| 2023-02-14T21:07:35
| 2023-02-18T10:20:44
| 1,085,012
| 124
| 71
|
NOASSERTION
| 2023-09-01T16:54:48
| 2010-11-16T12:13:17
|
C
|
UTF-8
|
C
| false
| false
| 165
|
c
|
tl-appliedlfun09.c
|
#pragma warn_applied_functions
/* Wrong argument type. */
int id(object name)
{
return 0;
}
int run_test()
{
return __MASTER_OBJECT__.warning_occured();
}
|
9d1ba5385649ae2dc4dd6d7be1cab1d444491c4b
|
315f1de5835d38669c9777e8009709d80ff3d04e
|
/spatial/core/resources/chiselgen/template-level/fringeDE1SoC/Computer_System/synthesis/submodules/sequencer/sequencer.pre.h
|
8c6596959e36765ca0d7628448a4ce3e24b474ff
|
[
"MIT"
] |
permissive
|
stanford-ppl/spatial-lang
|
751dcadfc38770f7a0b65e701f3e6aa5ef50e146
|
55e9a67b28f83caf3606e0c7bbead82a12cfbd2a
|
refs/heads/master
| 2023-03-08T17:55:24.007295
| 2018-11-14T22:07:39
| 2018-11-14T22:07:39
| 78,697,642
| 109
| 15
|
MIT
| 2018-04-12T10:44:07
| 2017-01-12T01:47:41
|
Verilog
|
UTF-8
|
C
| false
| false
| 24,219
|
h
|
sequencer.pre.h
|
#ifndef _SEQUENCER_H_
#define _SEQUENCER_H_
/*
* Copyright Altera Corporation (C) 2012-2014. All rights reserved
*
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Altera Corporation nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ALTERA CORPORATION BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if ENABLE_ASSERT
#define ERR_IE_TEXT "Internal Error: Sub-system: %s, File: %s, Line: %d\n%s%s"
extern void err_report_internal_error (const char* description, const char* module, const char* file, int line);
#define ALTERA_INTERNAL_ERROR(string) {err_report_internal_error(string, "SEQ", __FILE__, __LINE__); exit(-1);}
#define ALTERA_ASSERT(condition) \
if (!(condition)) { ALTERA_INTERNAL_ERROR(#condition); }
#define ALTERA_INFO_ASSERT(condition,text) \
if (!(condition)) { ALTERA_INTERNAL_ERROR(text); }
#else
#define ALTERA_ASSERT(condition)
#define ALTERA_INFO_ASSERT(condition,text)
#endif
#if RLDRAMII
#define RW_MGR_NUM_DM_PER_WRITE_GROUP (1)
#define RW_MGR_NUM_TRUE_DM_PER_WRITE_GROUP (1)
#else
#define RW_MGR_NUM_DM_PER_WRITE_GROUP (RW_MGR_MEM_DATA_MASK_WIDTH / RW_MGR_MEM_IF_WRITE_DQS_WIDTH)
#define RW_MGR_NUM_TRUE_DM_PER_WRITE_GROUP (RW_MGR_TRUE_MEM_DATA_MASK_WIDTH / RW_MGR_MEM_IF_WRITE_DQS_WIDTH)
#endif
#define RW_MGR_NUM_DQS_PER_WRITE_GROUP (RW_MGR_MEM_IF_READ_DQS_WIDTH / RW_MGR_MEM_IF_WRITE_DQS_WIDTH)
#define NUM_RANKS_PER_SHADOW_REG (RW_MGR_MEM_NUMBER_OF_RANKS / NUM_SHADOW_REGS)
#define RW_MGR_RUN_SINGLE_GROUP BASE_RW_MGR
#define RW_MGR_RUN_ALL_GROUPS BASE_RW_MGR + 0x0400
#if HARD_PHY
#define RW_MGR_DI_BASE (BASE_RW_MGR + 0x0020)
#else
#define RW_MGR_DI_BASE (BASE_RW_MGR + 0x0010)
#endif
#if DDR3
#define DDR3_MR1_ODT_MASK 0xFFFFFD99
#define DDR3_MR2_ODT_MASK 0xFFFFF9FF
#define DDR3_AC_MIRR_MASK 0x020A8
#if LRDIMM
// USER RTT_NOM: bits {4,3,2} of the SPD = bits {9,6,2} of the MR
#define LRDIMM_SPD_MR_RTT_NOM(spd_byte) \
( (((spd_byte) & (1 << 4)) << (9-4)) \
| (((spd_byte) & (1 << 3)) << (6-3)) \
| (((spd_byte) & (1 << 2)) << (2-2)))
// USER RTT_DRV: bits {1,0} of the SPD = bits {5,1} of the MR
#define LRDIMM_SPD_MR_RTT_DRV(spd_byte) \
( (((spd_byte) & (1 << 1)) << (5-1)) \
| (((spd_byte) & (1 << 0)) << (1-0)))
// USER RTT_WR: bits {7,6} of the SPD = bits {10,9} of the MR
#define LRDIMM_SPD_MR_RTT_WR(spd_byte) \
(((spd_byte) & (3 << 6)) << (9-6))
#endif // LRDIMM
#endif // DDR3
#define RW_MGR_LOAD_CNTR_0 BASE_RW_MGR + 0x0800
#define RW_MGR_LOAD_CNTR_1 BASE_RW_MGR + 0x0804
#define RW_MGR_LOAD_CNTR_2 BASE_RW_MGR + 0x0808
#define RW_MGR_LOAD_CNTR_3 BASE_RW_MGR + 0x080C
#define RW_MGR_LOAD_JUMP_ADD_0 BASE_RW_MGR + 0x0C00
#define RW_MGR_LOAD_JUMP_ADD_1 BASE_RW_MGR + 0x0C04
#define RW_MGR_LOAD_JUMP_ADD_2 BASE_RW_MGR + 0x0C08
#define RW_MGR_LOAD_JUMP_ADD_3 BASE_RW_MGR + 0x0C0C
#define RW_MGR_RESET_READ_DATAPATH BASE_RW_MGR + 0x1000
#define RW_MGR_SOFT_RESET BASE_RW_MGR + 0x2000
#define RW_MGR_SET_CS_AND_ODT_MASK BASE_RW_MGR + 0x1400
#define RW_MGR_SET_ACTIVE_RANK BASE_RW_MGR + 0x2400
#define RW_MGR_LOOPBACK_MODE BASE_RW_MGR + 0x0200
#define RW_MGR_ENABLE_REFRESH BASE_RW_MGR + 0x3000
#define RW_MGR_RANK_NONE 0xFF
#define RW_MGR_RANK_ALL 0x00
#define RW_MGR_ODT_MODE_OFF 0
#define RW_MGR_ODT_MODE_READ_WRITE 1
#define NUM_CALIB_REPEAT 1
#define NUM_READ_TESTS 7
#define NUM_READ_PB_TESTS 7
#define NUM_WRITE_TESTS 15
#define NUM_WRITE_PB_TESTS 31
#define PASS_ALL_BITS 1
#define PASS_ONE_BIT 0
/* calibration stages */
#define CAL_STAGE_NIL 0
#define CAL_STAGE_VFIFO 1
#define CAL_STAGE_WLEVEL 2
#define CAL_STAGE_LFIFO 3
#define CAL_STAGE_WRITES 4
#define CAL_STAGE_FULLTEST 5
#define CAL_STAGE_REFRESH 6
#define CAL_STAGE_CAL_SKIPPED 7
#define CAL_STAGE_CAL_ABORTED 8
#define CAL_STAGE_VFIFO_AFTER_WRITES 9
/* calibration substages */
#define CAL_SUBSTAGE_NIL 0
#define CAL_SUBSTAGE_GUARANTEED_READ 1
#define CAL_SUBSTAGE_DQS_EN_PHASE 2
#define CAL_SUBSTAGE_VFIFO_CENTER 3
#define CAL_SUBSTAGE_WORKING_DELAY 1
#define CAL_SUBSTAGE_LAST_WORKING_DELAY 2
#define CAL_SUBSTAGE_WLEVEL_COPY 3
#define CAL_SUBSTAGE_WRITES_CENTER 1
#define CAL_SUBSTAGE_READ_LATENCY 1
#define CAL_SUBSTAGE_REFRESH 1
#define MAX_RANKS (RW_MGR_MEM_NUMBER_OF_RANKS)
#define MAX_DQS (RW_MGR_MEM_IF_WRITE_DQS_WIDTH > RW_MGR_MEM_IF_READ_DQS_WIDTH ? RW_MGR_MEM_IF_WRITE_DQS_WIDTH : RW_MGR_MEM_IF_READ_DQS_WIDTH)
#define MAX_DQ (RW_MGR_MEM_DATA_WIDTH)
#define MAX_DM (RW_MGR_MEM_DATA_MASK_WIDTH)
/* length of VFIFO, from SW_MACROS */
#define VFIFO_SIZE (READ_VALID_FIFO_SIZE)
/* Memory for data transfer between TCL scripts and NIOS.
*
* - First word is a command request.
* - The remaining words are part of the transfer.
*/
/* Define the base address of each manager. */
/* MarkW: how should these base addresses be done for A-V? */
#define BASE_PTR_MGR SEQUENCER_PTR_MGR_INST_BASE
#if HARD_PHY
#define BASE_PHY_MGR (0x00088000)
#define BASE_RW_MGR (0x00090000)
#define BASE_DATA_MGR (0x00098000)
#else
#define BASE_PHY_MGR SEQUENCER_PHY_MGR_INST_BASE
#define BASE_RW_MGR SEQUENCER_RW_MGR_INST_BASE
#define BASE_DATA_MGR SEQUENCER_DATA_MGR_INST_BASE
#endif
#define BASE_SCC_MGR SEQUENCER_SCC_MGR_INST_BASE
#define BASE_REG_FILE SEQUENCER_REG_FILE_INST_BASE
#define BASE_TIMER SEQUENCER_TIMER_INST_BASE
#define BASE_MMR (0x000C0000)
#define BASE_TRK_MGR (0x000D0000)
/* Register file addresses. */
#define REG_FILE_SIGNATURE (BASE_REG_FILE + 0x0000)
#define REG_FILE_DEBUG_DATA_ADDR (BASE_REG_FILE + 0x0004)
#define REG_FILE_CUR_STAGE (BASE_REG_FILE + 0x0008)
#define REG_FILE_FOM (BASE_REG_FILE + 0x000C)
#define REG_FILE_FAILING_STAGE (BASE_REG_FILE + 0x0010)
#define REG_FILE_DEBUG1 (BASE_REG_FILE + 0x0014)
#define REG_FILE_DEBUG2 (BASE_REG_FILE + 0x0018)
#if TRACKING_WATCH_TEST || TRACKING_ERROR_TEST
#define REG_FILE_TRK_SAMPLE_CHECK (BASE_REG_FILE + 0x003C)
#elif MARGIN_VARIATION_TEST
#define IO_DQS_EN_DELAY_OFFSET (IORD_32DIRECT(BASE_REG_FILE + 0x003C, 0))
#endif
#if HHP_HPS
#define REG_FILE_DTAPS_PER_PTAP (BASE_REG_FILE + 0x001C)
#define REG_FILE_TRK_SAMPLE_COUNT (BASE_REG_FILE + 0x0020)
#define REG_FILE_TRK_LONGIDLE (BASE_REG_FILE + 0x0024)
#define REG_FILE_DELAYS (BASE_REG_FILE + 0x0028)
#define REG_FILE_TRK_RW_MGR_ADDR (BASE_REG_FILE + 0x002C)
#define REG_FILE_TRK_READ_DQS_WIDTH (BASE_REG_FILE + 0x0030)
#define REG_FILE_TRK_RFSH (BASE_REG_FILE + 0x0034)
#define CTRL_CONFIG_REG (BASE_MMR + 0x0000)
#else
/* Tracking slave addresses. */
#define TRK_DTAPS_PER_PTAP (BASE_TRK_MGR + 0x0000)
#define TRK_SAMPLE_COUNT (BASE_TRK_MGR + 0x0004)
#define TRK_LONGIDLE (BASE_TRK_MGR + 0x0008)
#define TRK_DELAYS (BASE_TRK_MGR + 0x000C)
#define TRK_RW_MGR_ADDR (BASE_TRK_MGR + 0x0010)
#define TRK_READ_DQS_WIDTH (BASE_TRK_MGR + 0x0014)
#define TRK_RFSH (BASE_TRK_MGR + 0x0018)
#define TRK_STALL (BASE_TRK_MGR + 0x001C)
#define TRK_V_POINTER (BASE_TRK_MGR + 0x0020)
#define TRK_STALL_REQ_VAL (0x1)
#define TRK_STALL_ACKED_VAL (0x80000000 | TRK_STALL_REQ_VAL)
#endif // HHP_HPS
/* PHY manager configuration registers. */
#define PHY_MGR_PHY_RLAT (BASE_PHY_MGR + 0x4000)
#define PHY_MGR_RESET_MEM_STBL (BASE_PHY_MGR + 0x4004)
#define PHY_MGR_MUX_SEL (BASE_PHY_MGR + 0x4008)
#define PHY_MGR_CAL_STATUS (BASE_PHY_MGR + 0x400c)
#define PHY_MGR_CAL_DEBUG_INFO (BASE_PHY_MGR + 0x4010)
#define PHY_MGR_VFIFO_RD_EN_OVRD (BASE_PHY_MGR + 0x4014)
#if CALIBRATE_BIT_SLIPS
#define PHY_MGR_FR_SHIFT (BASE_PHY_MGR + 0x4020)
#if MULTIPLE_AFI_WLAT
#define PHY_MGR_AFI_WLAT (BASE_PHY_MGR + 0x4020 + 4*RW_MGR_MEM_IF_WRITE_DQS_WIDTH)
#else
#define PHY_MGR_AFI_WLAT (BASE_PHY_MGR + 0x4018)
#endif
#else
#define PHY_MGR_AFI_WLAT (BASE_PHY_MGR + 0x4018)
#endif
#define PHY_MGR_AFI_RLAT (BASE_PHY_MGR + 0x401c)
#define PHY_MGR_CAL_RESET (0)
#define PHY_MGR_CAL_SUCCESS (1)
#define PHY_MGR_CAL_FAIL (2)
/* PHY manager command addresses. */
#define PHY_MGR_CMD_INC_VFIFO_FR (BASE_PHY_MGR + 0x0000)
#define PHY_MGR_CMD_INC_VFIFO_HR (BASE_PHY_MGR + 0x0004)
#define PHY_MGR_CMD_INC_VFIFO_HARD_PHY (BASE_PHY_MGR + 0x0004)
#define PHY_MGR_CMD_FIFO_RESET (BASE_PHY_MGR + 0x0008)
#define PHY_MGR_CMD_INC_VFIFO_FR_HR (BASE_PHY_MGR + 0x000C)
#define PHY_MGR_CMD_INC_VFIFO_QR (BASE_PHY_MGR + 0x0010)
/* PHY manager parameters. */
#define PHY_MGR_MAX_RLAT_WIDTH (BASE_PHY_MGR + 0x0000)
#define PHY_MGR_MAX_AFI_WLAT_WIDTH (BASE_PHY_MGR + 0x0004)
#define PHY_MGR_MAX_AFI_RLAT_WIDTH (BASE_PHY_MGR + 0x0008)
#define PHY_MGR_CALIB_SKIP_STEPS (BASE_PHY_MGR + 0x000c)
#define PHY_MGR_CALIB_VFIFO_OFFSET (BASE_PHY_MGR + 0x0010)
#define PHY_MGR_CALIB_LFIFO_OFFSET (BASE_PHY_MGR + 0x0014)
#define PHY_MGR_RDIMM (BASE_PHY_MGR + 0x0018)
#define PHY_MGR_MEM_T_WL (BASE_PHY_MGR + 0x001c)
#define PHY_MGR_MEM_T_RL (BASE_PHY_MGR + 0x0020)
/* Data Manager */
#define DATA_MGR_DRAM_CFG (BASE_DATA_MGR + 0x0000)
#define DATA_MGR_MEM_T_WL (BASE_DATA_MGR + 0x0004)
#define DATA_MGR_MEM_T_ADD (BASE_DATA_MGR + 0x0008)
#define DATA_MGR_MEM_T_RL (BASE_DATA_MGR + 0x000C)
#define DATA_MGR_MEM_T_RFC (BASE_DATA_MGR + 0x0010)
#define DATA_MGR_MEM_T_REFI (BASE_DATA_MGR + 0x0014)
#define DATA_MGR_MEM_T_WR (BASE_DATA_MGR + 0x0018)
#define DATA_MGR_MEM_T_MRD (BASE_DATA_MGR + 0x001C)
#define DATA_MGR_COL_WIDTH (BASE_DATA_MGR + 0x0020)
#define DATA_MGR_ROW_WIDTH (BASE_DATA_MGR + 0x0024)
#define DATA_MGR_BANK_WIDTH (BASE_DATA_MGR + 0x0028)
#define DATA_MGR_CS_WIDTH (BASE_DATA_MGR + 0x002C)
#define DATA_MGR_ITF_WIDTH (BASE_DATA_MGR + 0x0030)
#define DATA_MGR_DVC_WIDTH (BASE_DATA_MGR + 0x0034)
#if HARD_PHY
#define MEM_T_WL_ADD DATA_MGR_MEM_T_WL
#define MEM_T_RL_ADD DATA_MGR_MEM_T_RL
#else
#define MEM_T_WL_ADD PHY_MGR_MEM_T_WL
#define MEM_T_RL_ADD PHY_MGR_MEM_T_RL
#endif
#define CALIB_SKIP_DELAY_LOOPS (1 << 0)
#define CALIB_SKIP_ALL_BITS_CHK (1 << 1)
#define CALIB_SKIP_DELAY_SWEEPS (1 << 2)
#define CALIB_SKIP_VFIFO (1 << 3)
#define CALIB_SKIP_LFIFO (1 << 4)
#define CALIB_SKIP_WLEVEL (1 << 5)
#define CALIB_SKIP_WRITES (1 << 6)
#define CALIB_SKIP_FULL_TEST (1 << 7)
#define CALIB_SKIP_ALL (CALIB_SKIP_VFIFO | CALIB_SKIP_LFIFO | CALIB_SKIP_WLEVEL | CALIB_SKIP_WRITES | CALIB_SKIP_FULL_TEST)
#define CALIB_IN_RTL_SIM (1 << 8)
/* Scan chain manager command addresses */
#define WRITE_SCC_DQS_IN_DELAY(group, delay) IOWR_32DIRECT(SCC_MGR_DQS_IN_DELAY, (group) << 2, delay)
#define WRITE_SCC_DQS_EN_DELAY(group, delay) IOWR_32DIRECT(SCC_MGR_DQS_EN_DELAY, (group) << 2, (delay) + IO_DQS_EN_DELAY_OFFSET)
#define WRITE_SCC_DQS_EN_PHASE(group, phase) IOWR_32DIRECT(SCC_MGR_DQS_EN_PHASE, (group) << 2, phase)
#define WRITE_SCC_DQDQS_OUT_PHASE(group, phase) IOWR_32DIRECT(SCC_MGR_DQDQS_OUT_PHASE, (group) << 2, phase)
#define WRITE_SCC_OCT_OUT1_DELAY(group, delay) IOWR_32DIRECT(SCC_MGR_OCT_OUT1_DELAY, (group) << 2, delay)
#if HHP_HPS
#define WRITE_SCC_OCT_OUT2_DELAY(group, delay)
#else
#define WRITE_SCC_OCT_OUT2_DELAY(group, delay) IOWR_32DIRECT(SCC_MGR_OCT_OUT2_DELAY, (group) << 2, delay)
#endif
#if HHP_HPS
#define WRITE_SCC_DQS_BYPASS(group, bypass)
#else
#define WRITE_SCC_DQS_BYPASS(group, bypass) IOWR_32DIRECT(SCC_MGR_DQS_BYPASS, (group) << 2, bypass)
#endif
#define WRITE_SCC_DQ_OUT1_DELAY(pin, delay) IOWR_32DIRECT(SCC_MGR_IO_OUT1_DELAY, (pin) << 2, delay)
#if HHP_HPS
#define WRITE_SCC_DQ_OUT2_DELAY(pin, delay)
#else
#define WRITE_SCC_DQ_OUT2_DELAY(pin, delay) IOWR_32DIRECT(SCC_MGR_IO_OUT2_DELAY, (pin) << 2, delay)
#endif
#define WRITE_SCC_DQ_IN_DELAY(pin, delay) IOWR_32DIRECT(SCC_MGR_IO_IN_DELAY, (pin) << 2, delay)
#if HHP_HPS
#define WRITE_SCC_DQ_BYPASS(pin, bypass)
#else
#define WRITE_SCC_DQ_BYPASS(pin, bypass) IOWR_32DIRECT(SCC_MGR_DQ_BYPASS, (pin) << 2, bypass)
#endif
#if HHP_HPS
#define WRITE_SCC_RFIFO_MODE(pin, mode)
#else
#define WRITE_SCC_RFIFO_MODE(pin, mode) IOWR_32DIRECT(SCC_MGR_RFIFO_MODE, (pin) << 2, mode)
#endif
#if HHP_HPS
#define WRITE_SCC_HHP_EXTRAS(value) IOWR_32DIRECT(SCC_MGR_HHP_GLOBALS, SCC_MGR_HHP_EXTRAS_OFFSET, value)
#define WRITE_SCC_HHP_DQSE_MAP(value) IOWR_32DIRECT(SCC_MGR_HHP_GLOBALS, SCC_MGR_HHP_DQSE_MAP_OFFSET, value)
#else
#define WRITE_SCC_HHP_EXTRAS(value)
#define WRITE_SCC_HHP_DQSE_MAP(value)
#endif
#define WRITE_SCC_DQS_IO_OUT1_DELAY(delay) IOWR_32DIRECT(SCC_MGR_IO_OUT1_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS) << 2, delay)
#if HHP_HPS
#define WRITE_SCC_DQS_IO_OUT2_DELAY(delay)
#else
#define WRITE_SCC_DQS_IO_OUT2_DELAY(delay) IOWR_32DIRECT(SCC_MGR_IO_OUT2_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS) << 2, delay)
#endif
#define WRITE_SCC_DQS_IO_IN_DELAY(delay) IOWR_32DIRECT(SCC_MGR_IO_IN_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS) << 2, delay)
#define WRITE_SCC_DM_IO_OUT1_DELAY(pin, delay) IOWR_32DIRECT(SCC_MGR_IO_OUT1_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2, delay)
#if HHP_HPS
#define WRITE_SCC_DM_IO_OUT2_DELAY(pin, delay)
#else
#define WRITE_SCC_DM_IO_OUT2_DELAY(pin, delay) IOWR_32DIRECT(SCC_MGR_IO_OUT2_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2, delay)
#endif
#define WRITE_SCC_DM_IO_IN_DELAY(pin, delay) IOWR_32DIRECT(SCC_MGR_IO_IN_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2, delay)
#if HHP_HPS
#define WRITE_SCC_DM_BYPASS(pin, bypass)
#else
#define WRITE_SCC_DM_BYPASS(pin, bypass) IOWR_32DIRECT(SCC_MGR_DQ_BYPASS, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2, bypass)
#endif
#define READ_SCC_DQS_IN_DELAY(group) IORD_32DIRECT(SCC_MGR_DQS_IN_DELAY, (group) << 2)
#define READ_SCC_DQS_EN_DELAY(group) (IORD_32DIRECT(SCC_MGR_DQS_EN_DELAY, (group) << 2) - IO_DQS_EN_DELAY_OFFSET)
#define READ_SCC_DQS_EN_PHASE(group) IORD_32DIRECT(SCC_MGR_DQS_EN_PHASE, (group) << 2)
#define READ_SCC_DQDQS_OUT_PHASE(group) IORD_32DIRECT(SCC_MGR_DQDQS_OUT_PHASE, (group) << 2)
#define READ_SCC_OCT_OUT1_DELAY(group) IORD_32DIRECT(SCC_MGR_OCT_OUT1_DELAY, (group * RW_MGR_MEM_IF_READ_DQS_WIDTH / RW_MGR_MEM_IF_WRITE_DQS_WIDTH) << 2)
#if HHP_HPS
#define READ_SCC_OCT_OUT2_DELAY(group) 0
#else
#define READ_SCC_OCT_OUT2_DELAY(group) IORD_32DIRECT(SCC_MGR_OCT_OUT2_DELAY, (group * RW_MGR_MEM_IF_READ_DQS_WIDTH / RW_MGR_MEM_IF_WRITE_DQS_WIDTH) << 2)
#endif
#if HHP_HPS
#define READ_SCC_DQS_BYPASS(group) 0
#else
#define READ_SCC_DQS_BYPASS(group) IORD_32DIRECT(SCC_MGR_DQS_BYPASS, (group) << 2)
#endif
#if HHP_HPS
#define READ_SCC_DQS_BYPASS(group) 0
#else
#define READ_SCC_DQS_BYPASS(group) IORD_32DIRECT(SCC_MGR_DQS_BYPASS, (group) << 2)
#endif
#define READ_SCC_DQ_OUT1_DELAY(pin) IORD_32DIRECT(SCC_MGR_IO_OUT1_DELAY, (pin) << 2)
#if HHP_HPS
#define READ_SCC_DQ_OUT2_DELAY(pin) 0
#else
#define READ_SCC_DQ_OUT2_DELAY(pin) IORD_32DIRECT(SCC_MGR_IO_OUT2_DELAY, (pin) << 2)
#endif
#define READ_SCC_DQ_IN_DELAY(pin) IORD_32DIRECT(SCC_MGR_IO_IN_DELAY, (pin) << 2)
#if HHP_HPS
#define READ_SCC_DQ_BYPASS(pin) 0
#else
#define READ_SCC_DQ_BYPASS(pin) IOWR_32DIRECT(SCC_MGR_DQ_BYPASS, (pin) << 2)
#endif
#if HHP_HPS
#define READ_SCC_RFIFO_MODE(pin) 0
#else
#define READ_SCC_RFIFO_MODE(pin) IOWR_32DIRECT(SCC_MGR_RFIFO_MODE, (pin) << 2)
#endif
#define READ_SCC_DQS_IO_OUT1_DELAY() IORD_32DIRECT(SCC_MGR_IO_OUT1_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS) << 2)
#if HHP_HPS
#define READ_SCC_DQS_IO_OUT2_DELAY() 0
#else
#define READ_SCC_DQS_IO_OUT2_DELAY() IORD_32DIRECT(SCC_MGR_IO_OUT2_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS) << 2)
#endif
#define READ_SCC_DQS_IO_IN_DELAY() IORD_32DIRECT(SCC_MGR_IO_IN_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS) << 2)
#define READ_SCC_DM_IO_OUT1_DELAY(pin) IORD_32DIRECT(SCC_MGR_IO_OUT1_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2)
#if HHP_HPS
#define READ_SCC_DM_IO_OUT2_DELAY(pin) 0
#else
#define READ_SCC_DM_IO_OUT2_DELAY(pin) IORD_32DIRECT(SCC_MGR_IO_OUT2_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2)
#endif
#define READ_SCC_DM_IO_IN_DELAY(pin) IORD_32DIRECT(SCC_MGR_IO_IN_DELAY, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2)
#if HHP_HPS
#define READ_SCC_DM_BYPASS(pin) 0
#else
#define READ_SCC_DM_BYPASS(pin) IOWR_32DIRECT(SCC_MGR_DQ_BYPASS, (RW_MGR_MEM_DQ_PER_WRITE_DQS + 1 + pin) << 2)
#endif
#define SCC_MGR_GROUP_COUNTER (BASE_SCC_MGR + 0x0000)
#define SCC_MGR_DQS_IN_DELAY (BASE_SCC_MGR + 0x0100)
#define SCC_MGR_DQS_EN_PHASE (BASE_SCC_MGR + 0x0200)
#define SCC_MGR_DQS_EN_DELAY (BASE_SCC_MGR + 0x0300)
#define SCC_MGR_DQDQS_OUT_PHASE (BASE_SCC_MGR + 0x0400)
#define SCC_MGR_OCT_OUT1_DELAY (BASE_SCC_MGR + 0x0500)
#if !HHP_HPS
#define SCC_MGR_OCT_OUT2_DELAY (BASE_SCC_MGR + 0x0600)
#endif
#define SCC_MGR_IO_OUT1_DELAY (BASE_SCC_MGR + 0x0700)
#if !HHP_HPS
#define SCC_MGR_IO_OUT2_DELAY (BASE_SCC_MGR + 0x0800)
#endif
#define SCC_MGR_IO_IN_DELAY (BASE_SCC_MGR + 0x0900)
#if !HHP_HPS
/* ACV-specific commands */
#define SCC_MGR_DQS_BYPASS (BASE_SCC_MGR + 0x0A00)
#define SCC_MGR_DQ_BYPASS (BASE_SCC_MGR + 0x0B00)
#define SCC_MGR_RFIFO_MODE (BASE_SCC_MGR + 0x0C00)
#endif
#if HHP_HPS
/* HHP-HPS-specific versions of some commands */
#define SCC_MGR_DQS_EN_DELAY_GATE (BASE_SCC_MGR + 0x0600)
#define SCC_MGR_IO_OE_DELAY (BASE_SCC_MGR + 0x0800)
#define SCC_MGR_HHP_GLOBALS (BASE_SCC_MGR + 0x0A00)
#define SCC_MGR_HHP_RFILE (BASE_SCC_MGR + 0x0B00)
#endif
/* HHP-HPS-specific values */
#define SCC_MGR_HHP_EXTRAS_OFFSET 0
#define SCC_MGR_HHP_DQSE_MAP_OFFSET 1
#define SCC_MGR_DQS_ENA (BASE_SCC_MGR + 0x0E00)
#define SCC_MGR_DQS_IO_ENA (BASE_SCC_MGR + 0x0E04)
#define SCC_MGR_DQ_ENA (BASE_SCC_MGR + 0x0E08)
#define SCC_MGR_DM_ENA (BASE_SCC_MGR + 0x0E0C)
#define SCC_MGR_UPD (BASE_SCC_MGR + 0x0E20)
#define SCC_MGR_ACTIVE_RANK (BASE_SCC_MGR + 0x0E40)
#define SCC_MGR_AFI_CAL_INIT (BASE_SCC_MGR + 0x0D00)
// PHY Debug mode flag constants
#define PHY_DEBUG_IN_DEBUG_MODE 0x00000001
#define PHY_DEBUG_ENABLE_CAL_RPT 0x00000002
#define PHY_DEBUG_ENABLE_MARGIN_RPT 0x00000004
#define PHY_DEBUG_SWEEP_ALL_GROUPS 0x00000008
#define PHY_DEBUG_DISABLE_GUARANTEED_READ 0x00000010
#define PHY_DEBUG_ENABLE_NON_DESTRUCTIVE_CALIBRATION 0x00000020
// Init and Reset delay constants - Only use if defined by sequencer_defines.h,
// otherwise, revert to defaults
// Default for Tinit = (0+1) * ((202+1) * (2 * 131 + 1) + 1) = 53532 = 200.75us @ 266MHz
#ifdef TINIT_CNTR0_VAL
#define SEQ_TINIT_CNTR0_VAL TINIT_CNTR0_VAL
#else
#define SEQ_TINIT_CNTR0_VAL 0
#endif
#ifdef TINIT_CNTR1_VAL
#define SEQ_TINIT_CNTR1_VAL TINIT_CNTR1_VAL
#else
#define SEQ_TINIT_CNTR1_VAL 202
#endif
#ifdef TINIT_CNTR2_VAL
#define SEQ_TINIT_CNTR2_VAL TINIT_CNTR2_VAL
#else
#define SEQ_TINIT_CNTR2_VAL 131
#endif
// Default for Treset = (2+1) * ((252+1) * (2 * 131 + 1) + 1) = 133563 = 500.86us @ 266MHz
#ifdef TRESET_CNTR0_VAL
#define SEQ_TRESET_CNTR0_VAL TRESET_CNTR0_VAL
#else
#define SEQ_TRESET_CNTR0_VAL 2
#endif
#ifdef TRESET_CNTR1_VAL
#define SEQ_TRESET_CNTR1_VAL TRESET_CNTR1_VAL
#else
#define SEQ_TRESET_CNTR1_VAL 252
#endif
#ifdef TRESET_CNTR2_VAL
#define SEQ_TRESET_CNTR2_VAL TRESET_CNTR2_VAL
#else
#define SEQ_TRESET_CNTR2_VAL 131
#endif
/* Bitfield type changes depending on protocol */
#if QDRII
typedef long long t_btfld;
#else
typedef alt_u32 t_btfld;
#endif
#define RW_MGR_INST_ROM_WRITE BASE_RW_MGR + 0x1800
#define RW_MGR_AC_ROM_WRITE BASE_RW_MGR + 0x1C00
extern const alt_u32 inst_rom_init_size;
extern const alt_u32 inst_rom_init[];
extern const alt_u32 ac_rom_init_size;
extern const alt_u32 ac_rom_init[];
/* parameter variable holder */
typedef struct param_type {
t_btfld dm_correct_mask;
t_btfld read_correct_mask;
t_btfld read_correct_mask_vg;
t_btfld write_correct_mask;
t_btfld write_correct_mask_vg;
/* set a particular entry to 1 if we need to skip a particular rank */
alt_u32 skip_ranks[MAX_RANKS];
/* set a particular entry to 1 if we need to skip a particular group */
alt_u32 skip_groups;
/* set a particular entry to 1 if the shadow register (which represents a set of ranks) needs to be skipped */
alt_u32 skip_shadow_regs[NUM_SHADOW_REGS];
} param_t;
/* global variable holder */
typedef struct gbl_type {
alt_u32 phy_debug_mode_flags;
/* current read latency */
alt_u32 curr_read_lat;
/* current write latency */
alt_u32 curr_write_lat;
/* error code */
alt_u32 error_substage;
alt_u32 error_stage;
alt_u32 error_group;
/* figure-of-merit in, figure-of-merit out */
alt_u32 fom_in;
alt_u32 fom_out;
//USER Number of RW Mgr NOP cycles between write command and write data
#if MULTIPLE_AFI_WLAT
alt_u32 rw_wl_nop_cycles_per_group[RW_MGR_MEM_IF_WRITE_DQS_WIDTH];
#endif
alt_u32 rw_wl_nop_cycles;
} gbl_t;
// External global variables
extern gbl_t *gbl;
extern param_t *param;
// External functions
alt_u32 rw_mgr_mem_calibrate_full_test (alt_u32 min_correct, t_btfld *bit_chk, alt_u32 test_dm);
#if ENABLE_NON_DES_CAL
extern alt_u32 run_mem_calibrate (alt_u32 enable_non_des_c);
#else
extern alt_u32 run_mem_calibrate (void);
#endif
extern void rw_mgr_mem_calibrate_eye_diag_aid (void);
extern void rw_mgr_load_mrs_calib (void);
extern void rw_mgr_load_mrs_exec (void);
extern void rw_mgr_mem_initialize (void);
extern void rw_mgr_mem_dll_lock_wait(void);
extern inline void scc_mgr_set_dq_in_delay (alt_u32 write_group, alt_u32 dq_in_group, alt_u32 delay);
extern inline void scc_mgr_set_dq_out1_delay (alt_u32 write_group, alt_u32 dq_in_group, alt_u32 delay);
extern inline void scc_mgr_set_dq_out2_delay (alt_u32 write_group, alt_u32 dq_in_group, alt_u32 delay);
extern inline void scc_mgr_load_dq (alt_u32 dq_in_group);
extern inline void scc_mgr_set_dqs_bus_in_delay (alt_u32 read_group, alt_u32 delay);
extern inline void scc_mgr_load_dqs (alt_u32 dqs);
extern void scc_mgr_set_group_dqs_io_and_oct_out1_gradual (alt_u32 write_group, alt_u32 delay);
extern void scc_mgr_set_group_dqs_io_and_oct_out2_gradual (alt_u32 write_group, alt_u32 delay);
extern void scc_mgr_set_dqs_en_delay_all_ranks (alt_u32 read_group, alt_u32 delay);
extern void scc_mgr_set_dqs_en_phase_all_ranks (alt_u32 read_group, alt_u32 phase);
extern void scc_mgr_set_dqdqs_output_phase_all_ranks (alt_u32 write_group, alt_u32 phase);
extern inline void scc_mgr_set_dm_out1_delay (alt_u32 write_group, alt_u32 dm, alt_u32 delay);
extern inline void scc_mgr_set_dm_out2_delay (alt_u32 write_group, alt_u32 dm, alt_u32 delay);
extern inline void scc_mgr_load_dm (alt_u32 dm);
extern void rw_mgr_incr_vfifo_auto(alt_u32 grp);
extern void rw_mgr_decr_vfifo_auto(alt_u32 grp);
#if HPS_HW
extern int sdram_calibration(void);
#endif
#endif
|
d992412436c38b08760e44ec5395401df2c931ea
|
ffdc77394c5b5532b243cf3c33bd584cbdc65cb7
|
/mindspore/ccsrc/plugin/device/cpu/kernel/nnacl/int8/space_to_batch_int8.c
|
76eb668341dc11bbc0d4bf1959d1512a045d3153
|
[
"Apache-2.0",
"LicenseRef-scancode-proprietary-license",
"MPL-1.0",
"OpenSSL",
"LGPL-3.0-only",
"LicenseRef-scancode-warranty-disclaimer",
"BSD-3-Clause-Open-MPI",
"MIT",
"MPL-2.0-no-copyleft-exception",
"NTP",
"BSD-3-Clause",
"GPL-1.0-or-later",
"0BSD",
"MPL-2.0",
"LicenseRef-scancode-free-unknown",
"AGPL-3.0-only",
"Libpng",
"MPL-1.1",
"IJG",
"GPL-2.0-only",
"BSL-1.0",
"Zlib",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-python-cwi",
"BSD-2-Clause",
"LicenseRef-scancode-gary-s-brown",
"LGPL-2.1-only",
"LicenseRef-scancode-other-permissive",
"Python-2.0",
"LicenseRef-scancode-mit-nagy",
"LicenseRef-scancode-other-copyleft",
"LicenseRef-scancode-unknown-license-reference",
"Unlicense"
] |
permissive
|
mindspore-ai/mindspore
|
ca7d5bb51a3451c2705ff2e583a740589d80393b
|
54acb15d435533c815ee1bd9f6dc0b56b4d4cf83
|
refs/heads/master
| 2023-07-29T09:17:11.051569
| 2023-07-17T13:14:15
| 2023-07-17T13:14:15
| 239,714,835
| 4,178
| 768
|
Apache-2.0
| 2023-07-26T22:31:11
| 2020-02-11T08:43:48
|
C++
|
UTF-8
|
C
| false
| false
| 3,581
|
c
|
space_to_batch_int8.c
|
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "nnacl/int8/space_to_batch_int8.h"
#include "nnacl/common_func.h"
void DoSpaceToBatchNHWCInt8(const int8_t *input, int8_t *output, const int32_t *block_sizes, const int32_t *in_shape,
const int32_t *out_shape) {
int out_dim0 = out_shape[0];
int out_dim1 = out_shape[1];
int out_dim2 = out_shape[2];
int copy_num = out_shape[3];
int block_w = block_sizes[1];
int block_h = block_sizes[0];
int in_strides[4] = {0};
ComputeStrides(in_shape, in_strides, 4);
int out_strides[4] = {0};
ComputeStrides(out_shape, out_strides, 4);
size_t copy_size = copy_num * sizeof(int8_t);
size_t out_offset = 0;
NNACL_CHECK_ZERO_RETURN(in_shape[0]);
NNACL_CHECK_ZERO_RETURN(block_w);
for (int n = 0; n < out_dim0; ++n) {
int in_n = n % in_shape[0];
int32_t stride_w = (n / in_shape[0]) % block_w;
int32_t stride_h = (n / in_shape[0]) / block_w;
size_t in_offset0 = in_n * in_strides[0];
for (int h = 0; h < out_dim1; ++h) {
size_t in_offset1 = in_offset0 + (h * block_h + stride_h) * in_strides[1];
for (int w = 0; w < out_dim2; ++w) {
size_t in_offset2 = in_offset1 + (w * block_w + stride_w) * in_strides[2];
memcpy(output + out_offset, input + in_offset2, copy_size);
out_offset += copy_num;
}
}
}
}
void DoSpaceToBatchPaddingNHWCInt8(const int8_t *input, int8_t *output, SpaceToBatchParameter *param, int32_t zp) {
int block_shape_h = param->block_sizes_[0];
int block_shape_w = param->m_ == 2 ? param->block_sizes_[1] : 1;
int in_b = param->input_shape_[0];
int in_h = param->input_shape_[1];
int in_w = param->input_shape_[2];
int channel = param->input_shape_[3];
int out_h = param->output_shape_[1];
int out_w = param->output_shape_[2];
int pad_t = param->paddings_[0];
int pad_l = param->m_ == 2 ? param->paddings_[2] : 0;
NNACL_CHECK_ZERO_RETURN(in_b);
NNACL_CHECK_ZERO_RETURN(block_shape_w);
for (int i = 0; i < param->output_shape_[0]; ++i) {
int in_batch = i % in_b;
int offset_w = (i / in_b) % block_shape_w;
int offset_h = (i / in_b) / block_shape_w;
int in_b_offset = in_batch * in_h * in_w * channel;
int out_b_offset = i * out_h * out_w * channel;
for (int j = 0; j < out_h; ++j) {
int out_h_offset = out_b_offset + j * out_w * channel;
for (int k = 0; k < out_w; ++k) {
int8_t *out_ptr = output + out_h_offset + k * channel;
int index_h = j * block_shape_h + offset_h;
int index_w = k * block_shape_w + offset_w;
if (index_h < pad_t || index_h >= (pad_t + in_h) || index_w < pad_l || index_w >= (pad_l + in_w)) {
memset(out_ptr, zp, channel * sizeof(int8_t));
} else {
int in_plane_offset = in_b_offset + ((index_h - pad_t) * in_w + (index_w - pad_l)) * channel;
const int8_t *in_ptr = input + in_plane_offset;
memcpy(out_ptr, in_ptr, channel * sizeof(int8_t));
}
}
}
}
}
|
79b182d0165daa8eccd3f8dd251cbb831bd0a722
|
99bdb3251fecee538e0630f15f6574054dfc1468
|
/bsp/stm32/libraries/STM32WBxx_HAL/STM32WBxx_HAL_Driver/Src/stm32wbxx_hal_qspi.c
|
26391fd5ff4cb53396a7306b16c12af06ab10ed8
|
[
"Zlib",
"LicenseRef-scancode-proprietary-license",
"MIT",
"BSD-3-Clause",
"X11",
"BSD-4-Clause-UC",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
RT-Thread/rt-thread
|
03a7c52c2aeb1b06a544143b0e803d72f47d1ece
|
3602f891211904a27dcbd51e5ba72fefce7326b2
|
refs/heads/master
| 2023-09-01T04:10:20.295801
| 2023-08-31T16:20:55
| 2023-08-31T16:20:55
| 7,408,108
| 9,599
| 5,805
|
Apache-2.0
| 2023-09-14T13:37:26
| 2013-01-02T14:49:21
|
C
|
UTF-8
|
C
| false
| false
| 89,163
|
c
|
stm32wbxx_hal_qspi.c
|
/**
******************************************************************************
* @file stm32wbxx_hal_qspi.c
* @author MCD Application Team
* @brief QSPI HAL module driver.
* This file provides firmware functions to manage the following
* functionalities of the QuadSPI interface (QSPI).
* + Initialization and de-initialization functions
* + Indirect functional mode management
* + Memory-mapped functional mode management
* + Auto-polling functional mode management
* + Interrupts and flags management
* + DMA channel configuration for indirect functional mode
* + Errors management and abort functionality
*
*
@verbatim
===============================================================================
##### How to use this driver #####
===============================================================================
[..]
*** Initialization ***
======================
[..]
(#) As prerequisite, fill in the HAL_QSPI_MspInit() :
(++) Enable QuadSPI clock interface with __HAL_RCC_QUADSPI_CLK_ENABLE().
(++) Reset QuadSPI Peripheral with __HAL_RCC_QUADSPI_FORCE_RESET() and __HAL_RCC_QUADSPI_RELEASE_RESET().
(++) Enable the clocks for the QuadSPI GPIOS with __HAL_RCC_GPIOx_CLK_ENABLE().
(++) Configure these QuadSPI pins in alternate mode using HAL_GPIO_Init().
(++) If interrupt mode is used, enable and configure QuadSPI global
interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
(++) If DMA mode is used, enable the clocks for the QuadSPI DMA channel
with __HAL_RCC_DMAx_CLK_ENABLE(), configure DMA with HAL_DMA_Init(),
link it with QuadSPI handle using __HAL_LINKDMA(), enable and configure
DMA channel global interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
(#) Configure the flash size, the clock prescaler, the fifo threshold, the
clock mode, the sample shifting and the CS high time using the HAL_QSPI_Init() function.
*** Indirect functional mode ***
================================
[..]
(#) Configure the command sequence using the HAL_QSPI_Command() or HAL_QSPI_Command_IT()
functions :
(++) Instruction phase : the mode used and if present the instruction opcode.
(++) Address phase : the mode used and if present the size and the address value.
(++) Alternate-bytes phase : the mode used and if present the size and the alternate
bytes values.
(++) Dummy-cycles phase : the number of dummy cycles (mode used is same as data phase).
(++) Data phase : the mode used and if present the number of bytes.
(++) Double Data Rate (DDR) mode : the activation (or not) of this mode and the delay
if activated.
(++) Sending Instruction Only Once (SIOO) mode : the activation (or not) of this mode.
(#) If no data is required for the command, it is sent directly to the memory :
(++) In polling mode, the output of the function is done when the transfer is complete.
(++) In interrupt mode, HAL_QSPI_CmdCpltCallback() will be called when the transfer is complete.
(#) For the indirect write mode, use HAL_QSPI_Transmit(), HAL_QSPI_Transmit_DMA() or
HAL_QSPI_Transmit_IT() after the command configuration :
(++) In polling mode, the output of the function is done when the transfer is complete.
(++) In interrupt mode, HAL_QSPI_FifoThresholdCallback() will be called when the fifo threshold
is reached and HAL_QSPI_TxCpltCallback() will be called when the transfer is complete.
(++) In DMA mode, HAL_QSPI_TxHalfCpltCallback() will be called at the half transfer and
HAL_QSPI_TxCpltCallback() will be called when the transfer is complete.
(#) For the indirect read mode, use HAL_QSPI_Receive(), HAL_QSPI_Receive_DMA() or
HAL_QSPI_Receive_IT() after the command configuration :
(++) In polling mode, the output of the function is done when the transfer is complete.
(++) In interrupt mode, HAL_QSPI_FifoThresholdCallback() will be called when the fifo threshold
is reached and HAL_QSPI_RxCpltCallback() will be called when the transfer is complete.
(++) In DMA mode, HAL_QSPI_RxHalfCpltCallback() will be called at the half transfer and
HAL_QSPI_RxCpltCallback() will be called when the transfer is complete.
*** Auto-polling functional mode ***
====================================
[..]
(#) Configure the command sequence and the auto-polling functional mode using the
HAL_QSPI_AutoPolling() or HAL_QSPI_AutoPolling_IT() functions :
(++) Instruction phase : the mode used and if present the instruction opcode.
(++) Address phase : the mode used and if present the size and the address value.
(++) Alternate-bytes phase : the mode used and if present the size and the alternate
bytes values.
(++) Dummy-cycles phase : the number of dummy cycles (mode used is same as data phase).
(++) Data phase : the mode used.
(++) Double Data Rate (DDR) mode : the activation (or not) of this mode and the delay
if activated.
(++) Sending Instruction Only Once (SIOO) mode : the activation (or not) of this mode.
(++) The size of the status bytes, the match value, the mask used, the match mode (OR/AND),
the polling interval and the automatic stop activation.
(#) After the configuration :
(++) In polling mode, the output of the function is done when the status match is reached. The
automatic stop is activated to avoid an infinite loop.
(++) In interrupt mode, HAL_QSPI_StatusMatchCallback() will be called each time the status match is reached.
*** Memory-mapped functional mode ***
=====================================
[..]
(#) Configure the command sequence and the memory-mapped functional mode using the
HAL_QSPI_MemoryMapped() functions :
(++) Instruction phase : the mode used and if present the instruction opcode.
(++) Address phase : the mode used and the size.
(++) Alternate-bytes phase : the mode used and if present the size and the alternate
bytes values.
(++) Dummy-cycles phase : the number of dummy cycles (mode used is same as data phase).
(++) Data phase : the mode used.
(++) Double Data Rate (DDR) mode : the activation (or not) of this mode and the delay
if activated.
(++) Sending Instruction Only Once (SIOO) mode : the activation (or not) of this mode.
(++) The timeout activation and the timeout period.
(#) After the configuration, the QuadSPI will be used as soon as an access on the AHB is done on
the address range. HAL_QSPI_TimeOutCallback() will be called when the timeout expires.
*** Errors management and abort functionality ***
=================================================
[..]
(#) HAL_QSPI_GetError() function gives the error raised during the last operation.
(#) HAL_QSPI_Abort() and HAL_QSPI_Abort_IT() functions aborts any on-going operation and
flushes the fifo :
(++) In polling mode, the output of the function is done when the transfer
complete bit is set and the busy bit cleared.
(++) In interrupt mode, HAL_QSPI_AbortCpltCallback() will be called when
the transfer complete bit is set.
*** Control functions ***
=========================
[..]
(#) HAL_QSPI_GetState() function gives the current state of the HAL QuadSPI driver.
(#) HAL_QSPI_SetTimeout() function configures the timeout value used in the driver.
(#) HAL_QSPI_SetFifoThreshold() function configures the threshold on the Fifo of the QSPI IP.
(#) HAL_QSPI_GetFifoThreshold() function gives the current of the Fifo's threshold
*** Callback registration ***
=============================================
[..]
The compilation define USE_HAL_QSPI_REGISTER_CALLBACKS when set to 1
allows the user to configure dynamically the driver callbacks.
Use Functions HAL_QSPI_RegisterCallback() to register a user callback,
it allows to register following callbacks:
(+) ErrorCallback : callback when error occurs.
(+) AbortCpltCallback : callback when abort is completed.
(+) FifoThresholdCallback : callback when the fifo threshold is reached.
(+) CmdCpltCallback : callback when a command without data is completed.
(+) RxCpltCallback : callback when a reception transfer is completed.
(+) TxCpltCallback : callback when a transmission transfer is completed.
(+) RxHalfCpltCallback : callback when half of the reception transfer is completed.
(+) TxHalfCpltCallback : callback when half of the transmission transfer is completed.
(+) StatusMatchCallback : callback when a status match occurs.
(+) TimeOutCallback : callback when the timeout perioed expires.
(+) MspInitCallback : QSPI MspInit.
(+) MspDeInitCallback : QSPI MspDeInit.
This function takes as parameters the HAL peripheral handle, the Callback ID
and a pointer to the user callback function.
Use function HAL_QSPI_UnRegisterCallback() to reset a callback to the default
weak (surcharged) function. It allows to reset following callbacks:
(+) ErrorCallback : callback when error occurs.
(+) AbortCpltCallback : callback when abort is completed.
(+) FifoThresholdCallback : callback when the fifo threshold is reached.
(+) CmdCpltCallback : callback when a command without data is completed.
(+) RxCpltCallback : callback when a reception transfer is completed.
(+) TxCpltCallback : callback when a transmission transfer is completed.
(+) RxHalfCpltCallback : callback when half of the reception transfer is completed.
(+) TxHalfCpltCallback : callback when half of the transmission transfer is completed.
(+) StatusMatchCallback : callback when a status match occurs.
(+) TimeOutCallback : callback when the timeout perioed expires.
(+) MspInitCallback : QSPI MspInit.
(+) MspDeInitCallback : QSPI MspDeInit.
This function) takes as parameters the HAL peripheral handle and the Callback ID.
By default, after the HAL_QSPI_Init and if the state is HAL_QSPI_STATE_RESET
all callbacks are reset to the corresponding legacy weak (surcharged) functions.
Exception done for MspInit and MspDeInit callbacks that are respectively
reset to the legacy weak (surcharged) functions in the HAL_QSPI_Init
and HAL_QSPI_DeInit only when these callbacks are null (not registered beforehand).
If not, MspInit or MspDeInit are not null, the HAL_QSPI_Init and HAL_QSPI_DeInit
keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
Callbacks can be registered/unregistered in READY state only.
Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
during the Init/DeInit.
In that case first register the MspInit/MspDeInit user callbacks
using HAL_QSPI_RegisterCallback before calling HAL_QSPI_DeInit
or HAL_QSPI_Init function.
When The compilation define USE_HAL_QSPI_REGISTER_CALLBACKS is set to 0 or
not defined, the callback registering feature is not available
and weak (surcharged) callbacks are used.
*** Workarounds linked to Silicon Limitation ***
====================================================
[..]
(#) Workarounds Implemented inside HAL Driver
(++) Extra data written in the FIFO at the end of a read transfer
@endverbatim
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "stm32wbxx_hal.h"
#if defined(QUADSPI)
/** @addtogroup STM32WBxx_HAL_Driver
* @{
*/
/** @defgroup QSPI QSPI
* @brief QSPI HAL module driver
* @{
*/
#ifdef HAL_QSPI_MODULE_ENABLED
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/** @defgroup QSPI_Private_Constants QSPI Private Constants
* @{
*/
#define QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE 0x00000000U /*!<Indirect write mode*/
#define QSPI_FUNCTIONAL_MODE_INDIRECT_READ ((uint32_t)QUADSPI_CCR_FMODE_0) /*!<Indirect read mode*/
#define QSPI_FUNCTIONAL_MODE_AUTO_POLLING ((uint32_t)QUADSPI_CCR_FMODE_1) /*!<Automatic polling mode*/
#define QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED ((uint32_t)QUADSPI_CCR_FMODE) /*!<Memory-mapped mode*/
/**
* @}
*/
/* Private macro -------------------------------------------------------------*/
/** @defgroup QSPI_Private_Macros QSPI Private Macros
* @{
*/
#define IS_QSPI_FUNCTIONAL_MODE(MODE) (((MODE) == QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE) || \
((MODE) == QSPI_FUNCTIONAL_MODE_INDIRECT_READ) || \
((MODE) == QSPI_FUNCTIONAL_MODE_AUTO_POLLING) || \
((MODE) == QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED))
/**
* @}
*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
static void QSPI_DMARxCplt(DMA_HandleTypeDef *hdma);
static void QSPI_DMATxCplt(DMA_HandleTypeDef *hdma);
static void QSPI_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
static void QSPI_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
static void QSPI_DMAError(DMA_HandleTypeDef *hdma);
static void QSPI_DMAAbortCplt(DMA_HandleTypeDef *hdma);
static HAL_StatusTypeDef QSPI_WaitFlagStateUntilTimeout(QSPI_HandleTypeDef *hqspi, uint32_t Flag, FlagStatus State, uint32_t Tickstart, uint32_t Timeout);
static void QSPI_Config(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t FunctionalMode);
/* Exported functions --------------------------------------------------------*/
/** @defgroup QSPI_Exported_Functions QSPI Exported Functions
* @{
*/
/** @defgroup QSPI_Exported_Functions_Group1 Initialization/de-initialization functions
* @brief Initialization and Configuration functions
*
@verbatim
===============================================================================
##### Initialization and Configuration functions #####
===============================================================================
[..]
This subsection provides a set of functions allowing to :
(+) Initialize the QuadSPI.
(+) De-initialize the QuadSPI.
@endverbatim
* @{
*/
/**
* @brief Initialize the QSPI mode according to the specified parameters
* in the QSPI_InitTypeDef and initialize the associated handle.
* @param hqspi QSPI handle
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Init(QSPI_HandleTypeDef *hqspi)
{
HAL_StatusTypeDef status;
uint32_t tickstart = HAL_GetTick();
/* Check the QSPI handle allocation */
if(hqspi == NULL)
{
return HAL_ERROR;
}
/* Check the parameters */
assert_param(IS_QUADSPI_ALL_INSTANCE(hqspi->Instance));
assert_param(IS_QSPI_CLOCK_PRESCALER(hqspi->Init.ClockPrescaler));
assert_param(IS_QSPI_FIFO_THRESHOLD(hqspi->Init.FifoThreshold));
assert_param(IS_QSPI_SSHIFT(hqspi->Init.SampleShifting));
assert_param(IS_QSPI_FLASH_SIZE(hqspi->Init.FlashSize));
assert_param(IS_QSPI_CS_HIGH_TIME(hqspi->Init.ChipSelectHighTime));
assert_param(IS_QSPI_CLOCK_MODE(hqspi->Init.ClockMode));
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_RESET)
{
/* Allocate lock resource and initialize it */
hqspi->Lock = HAL_UNLOCKED;
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
/* Reset Callback pointers in HAL_QSPI_STATE_RESET only */
hqspi->ErrorCallback = HAL_QSPI_ErrorCallback;
hqspi->AbortCpltCallback = HAL_QSPI_AbortCpltCallback;
hqspi->FifoThresholdCallback = HAL_QSPI_FifoThresholdCallback;
hqspi->CmdCpltCallback = HAL_QSPI_CmdCpltCallback;
hqspi->RxCpltCallback = HAL_QSPI_RxCpltCallback;
hqspi->TxCpltCallback = HAL_QSPI_TxCpltCallback;
hqspi->RxHalfCpltCallback = HAL_QSPI_RxHalfCpltCallback;
hqspi->TxHalfCpltCallback = HAL_QSPI_TxHalfCpltCallback;
hqspi->StatusMatchCallback = HAL_QSPI_StatusMatchCallback;
hqspi->TimeOutCallback = HAL_QSPI_TimeOutCallback;
if(hqspi->MspInitCallback == NULL)
{
hqspi->MspInitCallback = HAL_QSPI_MspInit;
}
/* Init the low level hardware */
hqspi->MspInitCallback(hqspi);
#else
/* Init the low level hardware : GPIO, CLOCK */
HAL_QSPI_MspInit(hqspi);
#endif
/* Configure the default timeout for the QSPI memory access */
HAL_QSPI_SetTimeout(hqspi, HAL_QSPI_TIMEOUT_DEFAULT_VALUE);
}
/* Configure QSPI FIFO Threshold */
MODIFY_REG(hqspi->Instance->CR, QUADSPI_CR_FTHRES,
((hqspi->Init.FifoThreshold - 1U) << QUADSPI_CR_FTHRES_Pos));
/* Wait till BUSY flag reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, hqspi->Timeout);
if(status == HAL_OK)
{
/* Configure QSPI Clock Prescaler and Sample Shift */
MODIFY_REG(hqspi->Instance->CR, (QUADSPI_CR_PRESCALER | QUADSPI_CR_SSHIFT),
((hqspi->Init.ClockPrescaler << QUADSPI_CR_PRESCALER_Pos) |
hqspi->Init.SampleShifting));
/* Configure QSPI Flash Size, CS High Time and Clock Mode */
MODIFY_REG(hqspi->Instance->DCR, (QUADSPI_DCR_FSIZE | QUADSPI_DCR_CSHT | QUADSPI_DCR_CKMODE),
((hqspi->Init.FlashSize << QUADSPI_DCR_FSIZE_Pos) |
hqspi->Init.ChipSelectHighTime | hqspi->Init.ClockMode));
/* Enable the QSPI peripheral */
__HAL_QSPI_ENABLE(hqspi);
/* Set QSPI error code to none */
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Initialize the QSPI state */
hqspi->State = HAL_QSPI_STATE_READY;
}
/* Release Lock */
__HAL_UNLOCK(hqspi);
/* Return function status */
return status;
}
/**
* @brief De-Initialize the QSPI peripheral.
* @param hqspi QSPI handle
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_DeInit(QSPI_HandleTypeDef *hqspi)
{
/* Check the QSPI handle allocation */
if(hqspi == NULL)
{
return HAL_ERROR;
}
/* Process locked */
__HAL_LOCK(hqspi);
/* Disable the QSPI Peripheral Clock */
__HAL_QSPI_DISABLE(hqspi);
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
if(hqspi->MspDeInitCallback == NULL)
{
hqspi->MspDeInitCallback = HAL_QSPI_MspDeInit;
}
/* DeInit the low level hardware */
hqspi->MspDeInitCallback(hqspi);
#else
/* DeInit the low level hardware: GPIO, CLOCK, NVIC... */
HAL_QSPI_MspDeInit(hqspi);
#endif
/* Set QSPI error code to none */
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Initialize the QSPI state */
hqspi->State = HAL_QSPI_STATE_RESET;
/* Release Lock */
__HAL_UNLOCK(hqspi);
return HAL_OK;
}
/**
* @brief Initialize the QSPI MSP.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_MspInit(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_QSPI_MspInit can be implemented in the user file
*/
}
/**
* @brief DeInitialize the QSPI MSP.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_MspDeInit(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_QSPI_MspDeInit can be implemented in the user file
*/
}
/**
* @}
*/
/** @defgroup QSPI_Exported_Functions_Group2 Input and Output operation functions
* @brief QSPI Transmit/Receive functions
*
@verbatim
===============================================================================
##### IO operation functions #####
===============================================================================
[..]
This subsection provides a set of functions allowing to :
(+) Handle the interrupts.
(+) Handle the command sequence.
(+) Transmit data in blocking, interrupt or DMA mode.
(+) Receive data in blocking, interrupt or DMA mode.
(+) Manage the auto-polling functional mode.
(+) Manage the memory-mapped functional mode.
@endverbatim
* @{
*/
/**
* @brief Handle QSPI interrupt request.
* @param hqspi QSPI handle
* @retval None
*/
void HAL_QSPI_IRQHandler(QSPI_HandleTypeDef *hqspi)
{
__IO uint32_t *data_reg;
uint32_t flag = READ_REG(hqspi->Instance->SR);
uint32_t itsource = READ_REG(hqspi->Instance->CR);
/* QSPI Fifo Threshold interrupt occurred ----------------------------------*/
if(((flag & QSPI_FLAG_FT) != 0U) && ((itsource & QSPI_IT_FT) != 0U))
{
data_reg = &hqspi->Instance->DR;
if(hqspi->State == HAL_QSPI_STATE_BUSY_INDIRECT_TX)
{
/* Transmission process */
while(__HAL_QSPI_GET_FLAG(hqspi, QSPI_FLAG_FT) != RESET)
{
if (hqspi->TxXferCount > 0U)
{
/* Fill the FIFO until the threshold is reached */
*((__IO uint8_t *)data_reg) = *hqspi->pTxBuffPtr;
hqspi->pTxBuffPtr++;
hqspi->TxXferCount--;
}
else
{
/* No more data available for the transfer */
/* Disable the QSPI FIFO Threshold Interrupt */
__HAL_QSPI_DISABLE_IT(hqspi, QSPI_IT_FT);
break;
}
}
}
else if(hqspi->State == HAL_QSPI_STATE_BUSY_INDIRECT_RX)
{
/* Receiving Process */
while(__HAL_QSPI_GET_FLAG(hqspi, QSPI_FLAG_FT) != RESET)
{
if (hqspi->RxXferCount > 0U)
{
/* Read the FIFO until the threshold is reached */
*hqspi->pRxBuffPtr = *((__IO uint8_t *)data_reg);
hqspi->pRxBuffPtr++;
hqspi->RxXferCount--;
}
else
{
/* All data have been received for the transfer */
/* Disable the QSPI FIFO Threshold Interrupt */
__HAL_QSPI_DISABLE_IT(hqspi, QSPI_IT_FT);
break;
}
}
}
else
{
/* Nothing to do */
}
/* FIFO Threshold callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->FifoThresholdCallback(hqspi);
#else
HAL_QSPI_FifoThresholdCallback(hqspi);
#endif
}
/* QSPI Transfer Complete interrupt occurred -------------------------------*/
else if(((flag & QSPI_FLAG_TC) != 0U) && ((itsource & QSPI_IT_TC) != 0U))
{
/* Clear interrupt */
WRITE_REG(hqspi->Instance->FCR, QSPI_FLAG_TC);
/* Disable the QSPI FIFO Threshold, Transfer Error and Transfer complete Interrupts */
__HAL_QSPI_DISABLE_IT(hqspi, QSPI_IT_TC | QSPI_IT_TE | QSPI_IT_FT);
/* Transfer complete callback */
if(hqspi->State == HAL_QSPI_STATE_BUSY_INDIRECT_TX)
{
if ((hqspi->Instance->CR & QUADSPI_CR_DMAEN) != 0U)
{
/* Disable the DMA transfer by clearing the DMAEN bit in the QSPI CR register */
CLEAR_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
/* Disable the DMA channel */
__HAL_DMA_DISABLE(hqspi->hdma);
}
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* TX Complete callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->TxCpltCallback(hqspi);
#else
HAL_QSPI_TxCpltCallback(hqspi);
#endif
}
else if(hqspi->State == HAL_QSPI_STATE_BUSY_INDIRECT_RX)
{
if ((hqspi->Instance->CR & QUADSPI_CR_DMAEN) != 0U)
{
/* Disable the DMA transfer by clearing the DMAEN bit in the QSPI CR register */
CLEAR_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
/* Disable the DMA channel */
__HAL_DMA_DISABLE(hqspi->hdma);
}
else
{
data_reg = &hqspi->Instance->DR;
while(READ_BIT(hqspi->Instance->SR, QUADSPI_SR_FLEVEL) != 0U)
{
if (hqspi->RxXferCount > 0U)
{
/* Read the last data received in the FIFO until it is empty */
*hqspi->pRxBuffPtr = *((__IO uint8_t *)data_reg);
hqspi->pRxBuffPtr++;
hqspi->RxXferCount--;
}
else
{
/* All data have been received for the transfer */
break;
}
}
}
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* RX Complete callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->RxCpltCallback(hqspi);
#else
HAL_QSPI_RxCpltCallback(hqspi);
#endif
}
else if(hqspi->State == HAL_QSPI_STATE_BUSY)
{
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* Command Complete callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->CmdCpltCallback(hqspi);
#else
HAL_QSPI_CmdCpltCallback(hqspi);
#endif
}
else if(hqspi->State == HAL_QSPI_STATE_ABORT)
{
/* Reset functional mode configuration to indirect write mode by default */
CLEAR_BIT(hqspi->Instance->CCR, QUADSPI_CCR_FMODE);
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
if (hqspi->ErrorCode == HAL_QSPI_ERROR_NONE)
{
/* Abort called by the user */
/* Abort Complete callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->AbortCpltCallback(hqspi);
#else
HAL_QSPI_AbortCpltCallback(hqspi);
#endif
}
else
{
/* Abort due to an error (eg : DMA error) */
/* Error callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->ErrorCallback(hqspi);
#else
HAL_QSPI_ErrorCallback(hqspi);
#endif
}
}
else
{
/* Nothing to do */
}
}
/* QSPI Status Match interrupt occurred ------------------------------------*/
else if(((flag & QSPI_FLAG_SM) != 0U) && ((itsource & QSPI_IT_SM) != 0U))
{
/* Clear interrupt */
WRITE_REG(hqspi->Instance->FCR, QSPI_FLAG_SM);
/* Check if the automatic poll mode stop is activated */
if(READ_BIT(hqspi->Instance->CR, QUADSPI_CR_APMS) != 0U)
{
/* Disable the QSPI Transfer Error and Status Match Interrupts */
__HAL_QSPI_DISABLE_IT(hqspi, (QSPI_IT_SM | QSPI_IT_TE));
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
}
/* Status match callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->StatusMatchCallback(hqspi);
#else
HAL_QSPI_StatusMatchCallback(hqspi);
#endif
}
/* QSPI Transfer Error interrupt occurred ----------------------------------*/
else if(((flag & QSPI_FLAG_TE) != 0U) && ((itsource & QSPI_IT_TE) != 0U))
{
/* Clear interrupt */
WRITE_REG(hqspi->Instance->FCR, QSPI_FLAG_TE);
/* Disable all the QSPI Interrupts */
__HAL_QSPI_DISABLE_IT(hqspi, QSPI_IT_SM | QSPI_IT_TC | QSPI_IT_TE | QSPI_IT_FT);
/* Set error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_TRANSFER;
if ((hqspi->Instance->CR & QUADSPI_CR_DMAEN) != 0U)
{
/* Disable the DMA transfer by clearing the DMAEN bit in the QSPI CR register */
CLEAR_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
/* Disable the DMA channel */
hqspi->hdma->XferAbortCallback = QSPI_DMAAbortCplt;
if (HAL_DMA_Abort_IT(hqspi->hdma) != HAL_OK)
{
/* Set error code to DMA */
hqspi->ErrorCode |= HAL_QSPI_ERROR_DMA;
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* Error callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->ErrorCallback(hqspi);
#else
HAL_QSPI_ErrorCallback(hqspi);
#endif
}
}
else
{
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* Error callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->ErrorCallback(hqspi);
#else
HAL_QSPI_ErrorCallback(hqspi);
#endif
}
}
/* QSPI Timeout interrupt occurred -----------------------------------------*/
else if(((flag & QSPI_FLAG_TO) != 0U) && ((itsource & QSPI_IT_TO) != 0U))
{
/* Clear interrupt */
WRITE_REG(hqspi->Instance->FCR, QSPI_FLAG_TO);
/* Timeout callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->TimeOutCallback(hqspi);
#else
HAL_QSPI_TimeOutCallback(hqspi);
#endif
}
else
{
/* Nothing to do */
}
}
/**
* @brief Set the command configuration.
* @param hqspi QSPI handle
* @param cmd : structure that contains the command configuration information
* @param Timeout Timeout duration
* @note This function is used only in Indirect Read or Write Modes
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Command(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t Timeout)
{
HAL_StatusTypeDef status;
uint32_t tickstart = HAL_GetTick();
/* Check the parameters */
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode));
if (cmd->InstructionMode != QSPI_INSTRUCTION_NONE)
{
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction));
}
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode));
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize));
}
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode));
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize));
}
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles));
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode));
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode));
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode));
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_BUSY;
/* Wait till BUSY flag reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, Timeout);
if (status == HAL_OK)
{
/* Call the configuration function */
QSPI_Config(hqspi, cmd, QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE);
if (cmd->DataMode == QSPI_DATA_NONE)
{
/* When there is no data phase, the transfer start as soon as the configuration is done
so wait until TC flag is set to go back in idle state */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_TC, SET, tickstart, Timeout);
if (status == HAL_OK)
{
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_READY;
}
}
else
{
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_READY;
}
}
}
else
{
status = HAL_BUSY;
}
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Return function status */
return status;
}
/**
* @brief Set the command configuration in interrupt mode.
* @param hqspi QSPI handle
* @param cmd structure that contains the command configuration information
* @note This function is used only in Indirect Read or Write Modes
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Command_IT(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd)
{
HAL_StatusTypeDef status;
uint32_t tickstart = HAL_GetTick();
/* Check the parameters */
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode));
if (cmd->InstructionMode != QSPI_INSTRUCTION_NONE)
{
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction));
}
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode));
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize));
}
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode));
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize));
}
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles));
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode));
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode));
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode));
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_BUSY;
/* Wait till BUSY flag reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, hqspi->Timeout);
if (status == HAL_OK)
{
if (cmd->DataMode == QSPI_DATA_NONE)
{
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TE | QSPI_FLAG_TC);
}
/* Call the configuration function */
QSPI_Config(hqspi, cmd, QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE);
if (cmd->DataMode == QSPI_DATA_NONE)
{
/* When there is no data phase, the transfer start as soon as the configuration is done
so activate TC and TE interrupts */
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Enable the QSPI Transfer Error Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TE | QSPI_IT_TC);
}
else
{
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_READY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
status = HAL_BUSY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
/* Return function status */
return status;
}
/**
* @brief Transmit an amount of data in blocking mode.
* @param hqspi QSPI handle
* @param pData pointer to data buffer
* @param Timeout Timeout duration
* @note This function is used only in Indirect Write Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Transmit(QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t tickstart = HAL_GetTick();
__IO uint32_t *data_reg = &hqspi->Instance->DR;
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
if(pData != NULL )
{
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_INDIRECT_TX;
/* Configure counters and size of the handle */
hqspi->TxXferCount = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->TxXferSize = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->pTxBuffPtr = pData;
/* Configure QSPI: CCR register with functional as indirect write */
MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE);
while(hqspi->TxXferCount > 0U)
{
/* Wait until FT flag is set to send data */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_FT, SET, tickstart, Timeout);
if (status != HAL_OK)
{
break;
}
*((__IO uint8_t *)data_reg) = *hqspi->pTxBuffPtr;
hqspi->pTxBuffPtr++;
hqspi->TxXferCount--;
}
if (status == HAL_OK)
{
/* Wait until TC flag is set to go back in idle state */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_TC, SET, tickstart, Timeout);
if (status == HAL_OK)
{
/* Clear Transfer Complete bit */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);
}
}
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_READY;
}
else
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
}
}
else
{
status = HAL_BUSY;
}
/* Process unlocked */
__HAL_UNLOCK(hqspi);
return status;
}
/**
* @brief Receive an amount of data in blocking mode.
* @param hqspi QSPI handle
* @param pData pointer to data buffer
* @param Timeout Timeout duration
* @note This function is used only in Indirect Read Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Receive(QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t tickstart = HAL_GetTick();
uint32_t addr_reg = READ_REG(hqspi->Instance->AR);
__IO uint32_t *data_reg = &hqspi->Instance->DR;
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
if(pData != NULL )
{
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_INDIRECT_RX;
/* Configure counters and size of the handle */
hqspi->RxXferCount = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->RxXferSize = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->pRxBuffPtr = pData;
/* Configure QSPI: CCR register with functional as indirect read */
MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_READ);
/* Start the transfer by re-writing the address in AR register */
WRITE_REG(hqspi->Instance->AR, addr_reg);
while(hqspi->RxXferCount > 0U)
{
/* Wait until FT or TC flag is set to read received data */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, (QSPI_FLAG_FT | QSPI_FLAG_TC), SET, tickstart, Timeout);
if (status != HAL_OK)
{
break;
}
*hqspi->pRxBuffPtr = *((__IO uint8_t *)data_reg);
hqspi->pRxBuffPtr++;
hqspi->RxXferCount--;
}
if (status == HAL_OK)
{
/* Wait until TC flag is set to go back in idle state */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_TC, SET, tickstart, Timeout);
if (status == HAL_OK)
{
/* Clear Transfer Complete bit */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);
}
}
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_READY;
}
else
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
}
}
else
{
status = HAL_BUSY;
}
/* Process unlocked */
__HAL_UNLOCK(hqspi);
return status;
}
/**
* @brief Send an amount of data in non-blocking mode with interrupt.
* @param hqspi QSPI handle
* @param pData pointer to data buffer
* @note This function is used only in Indirect Write Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Transmit_IT(QSPI_HandleTypeDef *hqspi, uint8_t *pData)
{
HAL_StatusTypeDef status = HAL_OK;
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
if(pData != NULL )
{
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_INDIRECT_TX;
/* Configure counters and size of the handle */
hqspi->TxXferCount = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->TxXferSize = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->pTxBuffPtr = pData;
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TE | QSPI_FLAG_TC);
/* Configure QSPI: CCR register with functional as indirect write */
MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE);
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Enable the QSPI transfer error, FIFO threshold and transfer complete Interrupts */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TE | QSPI_IT_FT | QSPI_IT_TC);
}
else
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
status = HAL_BUSY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
return status;
}
/**
* @brief Receive an amount of data in non-blocking mode with interrupt.
* @param hqspi QSPI handle
* @param pData pointer to data buffer
* @note This function is used only in Indirect Read Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Receive_IT(QSPI_HandleTypeDef *hqspi, uint8_t *pData)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t addr_reg = READ_REG(hqspi->Instance->AR);
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
if(pData != NULL )
{
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_INDIRECT_RX;
/* Configure counters and size of the handle */
hqspi->RxXferCount = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->RxXferSize = READ_REG(hqspi->Instance->DLR) + 1U;
hqspi->pRxBuffPtr = pData;
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TE | QSPI_FLAG_TC);
/* Configure QSPI: CCR register with functional as indirect read */
MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_READ);
/* Start the transfer by re-writing the address in AR register */
WRITE_REG(hqspi->Instance->AR, addr_reg);
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Enable the QSPI transfer error, FIFO threshold and transfer complete Interrupts */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TE | QSPI_IT_FT | QSPI_IT_TC);
}
else
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
status = HAL_BUSY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
return status;
}
/**
* @brief Send an amount of data in non-blocking mode with DMA.
* @param hqspi QSPI handle
* @param pData pointer to data buffer
* @note This function is used only in Indirect Write Mode
* @note If DMA peripheral access is configured as halfword, the number
* of data and the fifo threshold should be aligned on halfword
* @note If DMA peripheral access is configured as word, the number
* of data and the fifo threshold should be aligned on word
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Transmit_DMA(QSPI_HandleTypeDef *hqspi, uint8_t *pData)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t data_size = (READ_REG(hqspi->Instance->DLR) + 1U);
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
/* Clear the error code */
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
if(pData != NULL )
{
/* Configure counters of the handle */
if (hqspi->hdma->Init.PeriphDataAlignment == DMA_PDATAALIGN_BYTE)
{
hqspi->TxXferCount = data_size;
}
else if (hqspi->hdma->Init.PeriphDataAlignment == DMA_PDATAALIGN_HALFWORD)
{
if (((data_size % 2U) != 0U) || ((hqspi->Init.FifoThreshold % 2U) != 0U))
{
/* The number of data or the fifo threshold is not aligned on halfword
=> no transfer possible with DMA peripheral access configured as halfword */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
else
{
hqspi->TxXferCount = (data_size >> 1U);
}
}
else if (hqspi->hdma->Init.PeriphDataAlignment == DMA_PDATAALIGN_WORD)
{
if (((data_size % 4U) != 0U) || ((hqspi->Init.FifoThreshold % 4U) != 0U))
{
/* The number of data or the fifo threshold is not aligned on word
=> no transfer possible with DMA peripheral access configured as word */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
else
{
hqspi->TxXferCount = (data_size >> 2U);
}
}
else
{
/* Nothing to do */
}
if (status == HAL_OK)
{
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_INDIRECT_TX;
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, (QSPI_FLAG_TE | QSPI_FLAG_TC));
/* Configure size and pointer of the handle */
hqspi->TxXferSize = hqspi->TxXferCount;
hqspi->pTxBuffPtr = pData;
/* Configure QSPI: CCR register with functional mode as indirect write */
MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE);
/* Set the QSPI DMA transfer complete callback */
hqspi->hdma->XferCpltCallback = QSPI_DMATxCplt;
/* Set the QSPI DMA Half transfer complete callback */
hqspi->hdma->XferHalfCpltCallback = QSPI_DMATxHalfCplt;
/* Set the DMA error callback */
hqspi->hdma->XferErrorCallback = QSPI_DMAError;
/* Clear the DMA abort callback */
hqspi->hdma->XferAbortCallback = NULL;
/* Configure the direction of the DMA */
hqspi->hdma->Init.Direction = DMA_MEMORY_TO_PERIPH;
MODIFY_REG(hqspi->hdma->Instance->CCR, DMA_CCR_DIR, hqspi->hdma->Init.Direction);
/* Enable the QSPI transmit DMA Channel */
if (HAL_DMA_Start_IT(hqspi->hdma, (uint32_t)pData, (uint32_t)&hqspi->Instance->DR, hqspi->TxXferSize) == HAL_OK)
{
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Enable the QSPI transfer error Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TE);
/* Enable the DMA transfer by setting the DMAEN bit in the QSPI CR register */
SET_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
}
else
{
status = HAL_ERROR;
hqspi->ErrorCode |= HAL_QSPI_ERROR_DMA;
hqspi->State = HAL_QSPI_STATE_READY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
}
else
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
status = HAL_BUSY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
return status;
}
/**
* @brief Receive an amount of data in non-blocking mode with DMA.
* @param hqspi QSPI handle
* @param pData pointer to data buffer.
* @note This function is used only in Indirect Read Mode
* @note If DMA peripheral access is configured as halfword, the number
* of data and the fifo threshold should be aligned on halfword
* @note If DMA peripheral access is configured as word, the number
* of data and the fifo threshold should be aligned on word
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Receive_DMA(QSPI_HandleTypeDef *hqspi, uint8_t *pData)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t addr_reg = READ_REG(hqspi->Instance->AR);
uint32_t data_size = (READ_REG(hqspi->Instance->DLR) + 1U);
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
/* Clear the error code */
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
if(pData != NULL )
{
/* Configure counters of the handle */
if (hqspi->hdma->Init.PeriphDataAlignment == DMA_PDATAALIGN_BYTE)
{
hqspi->RxXferCount = data_size;
}
else if (hqspi->hdma->Init.PeriphDataAlignment == DMA_PDATAALIGN_HALFWORD)
{
if (((data_size % 2U) != 0U) || ((hqspi->Init.FifoThreshold % 2U) != 0U))
{
/* The number of data or the fifo threshold is not aligned on halfword
=> no transfer possible with DMA peripheral access configured as halfword */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
else
{
hqspi->RxXferCount = (data_size >> 1U);
}
}
else if (hqspi->hdma->Init.PeriphDataAlignment == DMA_PDATAALIGN_WORD)
{
if (((data_size % 4U) != 0U) || ((hqspi->Init.FifoThreshold % 4U) != 0U))
{
/* The number of data or the fifo threshold is not aligned on word
=> no transfer possible with DMA peripheral access configured as word */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
else
{
hqspi->RxXferCount = (data_size >> 2U);
}
}
else
{
/* Nothing to do */
}
if (status == HAL_OK)
{
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_INDIRECT_RX;
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, (QSPI_FLAG_TE | QSPI_FLAG_TC));
/* Configure size and pointer of the handle */
hqspi->RxXferSize = hqspi->RxXferCount;
hqspi->pRxBuffPtr = pData;
/* Set the QSPI DMA transfer complete callback */
hqspi->hdma->XferCpltCallback = QSPI_DMARxCplt;
/* Set the QSPI DMA Half transfer complete callback */
hqspi->hdma->XferHalfCpltCallback = QSPI_DMARxHalfCplt;
/* Set the DMA error callback */
hqspi->hdma->XferErrorCallback = QSPI_DMAError;
/* Clear the DMA abort callback */
hqspi->hdma->XferAbortCallback = NULL;
/* Configure the direction of the DMA */
hqspi->hdma->Init.Direction = DMA_PERIPH_TO_MEMORY;
MODIFY_REG(hqspi->hdma->Instance->CCR, DMA_CCR_DIR, hqspi->hdma->Init.Direction);
/* Enable the DMA Channel */
if (HAL_DMA_Start_IT(hqspi->hdma, (uint32_t)&hqspi->Instance->DR, (uint32_t)pData, hqspi->RxXferSize) == HAL_OK)
{
/* Configure QSPI: CCR register with functional as indirect read */
MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_READ);
/* Start the transfer by re-writing the address in AR register */
WRITE_REG(hqspi->Instance->AR, addr_reg);
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Enable the QSPI transfer error Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TE);
/* Enable the DMA transfer by setting the DMAEN bit in the QSPI CR register */
SET_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
}
else
{
status = HAL_ERROR;
hqspi->ErrorCode |= HAL_QSPI_ERROR_DMA;
hqspi->State = HAL_QSPI_STATE_READY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
}
else
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_PARAM;
status = HAL_ERROR;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
status = HAL_BUSY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
return status;
}
/**
* @brief Configure the QSPI Automatic Polling Mode in blocking mode.
* @param hqspi QSPI handle
* @param cmd structure that contains the command configuration information.
* @param cfg structure that contains the polling configuration information.
* @param Timeout Timeout duration
* @note This function is used only in Automatic Polling Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_AutoPolling(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, QSPI_AutoPollingTypeDef *cfg, uint32_t Timeout)
{
HAL_StatusTypeDef status;
uint32_t tickstart = HAL_GetTick();
/* Check the parameters */
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode));
if (cmd->InstructionMode != QSPI_INSTRUCTION_NONE)
{
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction));
}
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode));
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize));
}
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode));
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize));
}
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles));
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode));
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode));
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode));
assert_param(IS_QSPI_INTERVAL(cfg->Interval));
assert_param(IS_QSPI_STATUS_BYTES_SIZE(cfg->StatusBytesSize));
assert_param(IS_QSPI_MATCH_MODE(cfg->MatchMode));
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_AUTO_POLLING;
/* Wait till BUSY flag reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, Timeout);
if (status == HAL_OK)
{
/* Configure QSPI: PSMAR register with the status match value */
WRITE_REG(hqspi->Instance->PSMAR, cfg->Match);
/* Configure QSPI: PSMKR register with the status mask value */
WRITE_REG(hqspi->Instance->PSMKR, cfg->Mask);
/* Configure QSPI: PIR register with the interval value */
WRITE_REG(hqspi->Instance->PIR, cfg->Interval);
/* Configure QSPI: CR register with Match mode and Automatic stop enabled
(otherwise there will be an infinite loop in blocking mode) */
MODIFY_REG(hqspi->Instance->CR, (QUADSPI_CR_PMM | QUADSPI_CR_APMS),
(cfg->MatchMode | QSPI_AUTOMATIC_STOP_ENABLE));
/* Call the configuration function */
cmd->NbData = cfg->StatusBytesSize;
QSPI_Config(hqspi, cmd, QSPI_FUNCTIONAL_MODE_AUTO_POLLING);
/* Wait until SM flag is set to go back in idle state */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_SM, SET, tickstart, Timeout);
if (status == HAL_OK)
{
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_SM);
/* Update state */
hqspi->State = HAL_QSPI_STATE_READY;
}
}
}
else
{
status = HAL_BUSY;
}
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Return function status */
return status;
}
/**
* @brief Configure the QSPI Automatic Polling Mode in non-blocking mode.
* @param hqspi QSPI handle
* @param cmd structure that contains the command configuration information.
* @param cfg structure that contains the polling configuration information.
* @note This function is used only in Automatic Polling Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_AutoPolling_IT(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, QSPI_AutoPollingTypeDef *cfg)
{
HAL_StatusTypeDef status;
uint32_t tickstart = HAL_GetTick();
/* Check the parameters */
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode));
if (cmd->InstructionMode != QSPI_INSTRUCTION_NONE)
{
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction));
}
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode));
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize));
}
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode));
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize));
}
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles));
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode));
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode));
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode));
assert_param(IS_QSPI_INTERVAL(cfg->Interval));
assert_param(IS_QSPI_STATUS_BYTES_SIZE(cfg->StatusBytesSize));
assert_param(IS_QSPI_MATCH_MODE(cfg->MatchMode));
assert_param(IS_QSPI_AUTOMATIC_STOP(cfg->AutomaticStop));
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_AUTO_POLLING;
/* Wait till BUSY flag reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, hqspi->Timeout);
if (status == HAL_OK)
{
/* Configure QSPI: PSMAR register with the status match value */
WRITE_REG(hqspi->Instance->PSMAR, cfg->Match);
/* Configure QSPI: PSMKR register with the status mask value */
WRITE_REG(hqspi->Instance->PSMKR, cfg->Mask);
/* Configure QSPI: PIR register with the interval value */
WRITE_REG(hqspi->Instance->PIR, cfg->Interval);
/* Configure QSPI: CR register with Match mode and Automatic stop mode */
MODIFY_REG(hqspi->Instance->CR, (QUADSPI_CR_PMM | QUADSPI_CR_APMS),
(cfg->MatchMode | cfg->AutomaticStop));
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TE | QSPI_FLAG_SM);
/* Call the configuration function */
cmd->NbData = cfg->StatusBytesSize;
QSPI_Config(hqspi, cmd, QSPI_FUNCTIONAL_MODE_AUTO_POLLING);
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Enable the QSPI Transfer Error and status match Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, (QSPI_IT_SM | QSPI_IT_TE));
}
else
{
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
}
else
{
status = HAL_BUSY;
/* Process unlocked */
__HAL_UNLOCK(hqspi);
}
/* Return function status */
return status;
}
/**
* @brief Configure the Memory Mapped mode.
* @param hqspi QSPI handle
* @param cmd structure that contains the command configuration information.
* @param cfg structure that contains the memory mapped configuration information.
* @note This function is used only in Memory mapped Mode
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_MemoryMapped(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, QSPI_MemoryMappedTypeDef *cfg)
{
HAL_StatusTypeDef status;
uint32_t tickstart = HAL_GetTick();
/* Check the parameters */
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode));
if (cmd->InstructionMode != QSPI_INSTRUCTION_NONE)
{
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction));
}
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode));
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize));
}
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode));
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize));
}
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles));
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode));
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode));
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode));
assert_param(IS_QSPI_TIMEOUT_ACTIVATION(cfg->TimeOutActivation));
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
hqspi->ErrorCode = HAL_QSPI_ERROR_NONE;
/* Update state */
hqspi->State = HAL_QSPI_STATE_BUSY_MEM_MAPPED;
/* Wait till BUSY flag reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, hqspi->Timeout);
if (status == HAL_OK)
{
/* Configure QSPI: CR register with timeout counter enable */
MODIFY_REG(hqspi->Instance->CR, QUADSPI_CR_TCEN, cfg->TimeOutActivation);
if (cfg->TimeOutActivation == QSPI_TIMEOUT_COUNTER_ENABLE)
{
assert_param(IS_QSPI_TIMEOUT_PERIOD(cfg->TimeOutPeriod));
/* Configure QSPI: LPTR register with the low-power timeout value */
WRITE_REG(hqspi->Instance->LPTR, cfg->TimeOutPeriod);
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TO);
/* Enable the QSPI TimeOut Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TO);
}
/* Call the configuration function */
QSPI_Config(hqspi, cmd, QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED);
}
}
else
{
status = HAL_BUSY;
}
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Return function status */
return status;
}
/**
* @brief Transfer Error callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_ErrorCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_QSPI_ErrorCallback could be implemented in the user file
*/
}
/**
* @brief Abort completed callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_AbortCpltCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE: This function should not be modified, when the callback is needed,
the HAL_QSPI_AbortCpltCallback could be implemented in the user file
*/
}
/**
* @brief Command completed callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_CmdCpltCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE: This function should not be modified, when the callback is needed,
the HAL_QSPI_CmdCpltCallback could be implemented in the user file
*/
}
/**
* @brief Rx Transfer completed callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_RxCpltCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE: This function should not be modified, when the callback is needed,
the HAL_QSPI_RxCpltCallback could be implemented in the user file
*/
}
/**
* @brief Tx Transfer completed callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_TxCpltCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE: This function should not be modified, when the callback is needed,
the HAL_QSPI_TxCpltCallback could be implemented in the user file
*/
}
/**
* @brief Rx Half Transfer completed callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_RxHalfCpltCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE: This function should not be modified, when the callback is needed,
the HAL_QSPI_RxHalfCpltCallback could be implemented in the user file
*/
}
/**
* @brief Tx Half Transfer completed callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_TxHalfCpltCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE: This function should not be modified, when the callback is needed,
the HAL_QSPI_TxHalfCpltCallback could be implemented in the user file
*/
}
/**
* @brief FIFO Threshold callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_FifoThresholdCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_QSPI_FIFOThresholdCallback could be implemented in the user file
*/
}
/**
* @brief Status Match callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_StatusMatchCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_QSPI_StatusMatchCallback could be implemented in the user file
*/
}
/**
* @brief Timeout callback.
* @param hqspi QSPI handle
* @retval None
*/
__weak void HAL_QSPI_TimeOutCallback(QSPI_HandleTypeDef *hqspi)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(hqspi);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_QSPI_TimeOutCallback could be implemented in the user file
*/
}
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
/**
* @brief Register a User QSPI Callback
* To be used instead of the weak (surcharged) predefined callback
* @param hqspi QSPI handle
* @param CallbackId ID of the callback to be registered
* This parameter can be one of the following values:
* @arg @ref HAL_QSPI_ERROR_CB_ID QSPI Error Callback ID
* @arg @ref HAL_QSPI_ABORT_CB_ID QSPI Abort Callback ID
* @arg @ref HAL_QSPI_FIFO_THRESHOLD_CB_ID QSPI FIFO Threshold Callback ID
* @arg @ref HAL_QSPI_CMD_CPLT_CB_ID QSPI Command Complete Callback ID
* @arg @ref HAL_QSPI_RX_CPLT_CB_ID QSPI Rx Complete Callback ID
* @arg @ref HAL_QSPI_TX_CPLT_CB_ID QSPI Tx Complete Callback ID
* @arg @ref HAL_QSPI_RX_HALF_CPLT_CB_ID QSPI Rx Half Complete Callback ID
* @arg @ref HAL_QSPI_TX_HALF_CPLT_CB_ID QSPI Tx Half Complete Callback ID
* @arg @ref HAL_QSPI_STATUS_MATCH_CB_ID QSPI Status Match Callback ID
* @arg @ref HAL_QSPI_TIMEOUT_CB_ID QSPI Timeout Callback ID
* @arg @ref HAL_QSPI_MSP_INIT_CB_ID QSPI MspInit callback ID
* @arg @ref HAL_QSPI_MSP_DEINIT_CB_ID QSPI MspDeInit callback ID
* @param pCallback pointer to the Callback function
* @retval status
*/
HAL_StatusTypeDef HAL_QSPI_RegisterCallback (QSPI_HandleTypeDef *hqspi, HAL_QSPI_CallbackIDTypeDef CallbackId, pQSPI_CallbackTypeDef pCallback)
{
HAL_StatusTypeDef status = HAL_OK;
if(pCallback == NULL)
{
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
return HAL_ERROR;
}
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
switch (CallbackId)
{
case HAL_QSPI_ERROR_CB_ID :
hqspi->ErrorCallback = pCallback;
break;
case HAL_QSPI_ABORT_CB_ID :
hqspi->AbortCpltCallback = pCallback;
break;
case HAL_QSPI_FIFO_THRESHOLD_CB_ID :
hqspi->FifoThresholdCallback = pCallback;
break;
case HAL_QSPI_CMD_CPLT_CB_ID :
hqspi->CmdCpltCallback = pCallback;
break;
case HAL_QSPI_RX_CPLT_CB_ID :
hqspi->RxCpltCallback = pCallback;
break;
case HAL_QSPI_TX_CPLT_CB_ID :
hqspi->TxCpltCallback = pCallback;
break;
case HAL_QSPI_RX_HALF_CPLT_CB_ID :
hqspi->RxHalfCpltCallback = pCallback;
break;
case HAL_QSPI_TX_HALF_CPLT_CB_ID :
hqspi->TxHalfCpltCallback = pCallback;
break;
case HAL_QSPI_STATUS_MATCH_CB_ID :
hqspi->StatusMatchCallback = pCallback;
break;
case HAL_QSPI_TIMEOUT_CB_ID :
hqspi->TimeOutCallback = pCallback;
break;
case HAL_QSPI_MSP_INIT_CB_ID :
hqspi->MspInitCallback = pCallback;
break;
case HAL_QSPI_MSP_DEINIT_CB_ID :
hqspi->MspDeInitCallback = pCallback;
break;
default :
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
/* update return status */
status = HAL_ERROR;
break;
}
}
else if (hqspi->State == HAL_QSPI_STATE_RESET)
{
switch (CallbackId)
{
case HAL_QSPI_MSP_INIT_CB_ID :
hqspi->MspInitCallback = pCallback;
break;
case HAL_QSPI_MSP_DEINIT_CB_ID :
hqspi->MspDeInitCallback = pCallback;
break;
default :
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
/* update return status */
status = HAL_ERROR;
break;
}
}
else
{
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
/* update return status */
status = HAL_ERROR;
}
/* Release Lock */
__HAL_UNLOCK(hqspi);
return status;
}
/**
* @brief Unregister a User QSPI Callback
* QSPI Callback is redirected to the weak (surcharged) predefined callback
* @param hqspi QSPI handle
* @param CallbackId ID of the callback to be unregistered
* This parameter can be one of the following values:
* @arg @ref HAL_QSPI_ERROR_CB_ID QSPI Error Callback ID
* @arg @ref HAL_QSPI_ABORT_CB_ID QSPI Abort Callback ID
* @arg @ref HAL_QSPI_FIFO_THRESHOLD_CB_ID QSPI FIFO Threshold Callback ID
* @arg @ref HAL_QSPI_CMD_CPLT_CB_ID QSPI Command Complete Callback ID
* @arg @ref HAL_QSPI_RX_CPLT_CB_ID QSPI Rx Complete Callback ID
* @arg @ref HAL_QSPI_TX_CPLT_CB_ID QSPI Tx Complete Callback ID
* @arg @ref HAL_QSPI_RX_HALF_CPLT_CB_ID QSPI Rx Half Complete Callback ID
* @arg @ref HAL_QSPI_TX_HALF_CPLT_CB_ID QSPI Tx Half Complete Callback ID
* @arg @ref HAL_QSPI_STATUS_MATCH_CB_ID QSPI Status Match Callback ID
* @arg @ref HAL_QSPI_TIMEOUT_CB_ID QSPI Timeout Callback ID
* @arg @ref HAL_QSPI_MSP_INIT_CB_ID QSPI MspInit callback ID
* @arg @ref HAL_QSPI_MSP_DEINIT_CB_ID QSPI MspDeInit callback ID
* @retval status
*/
HAL_StatusTypeDef HAL_QSPI_UnRegisterCallback (QSPI_HandleTypeDef *hqspi, HAL_QSPI_CallbackIDTypeDef CallbackId)
{
HAL_StatusTypeDef status = HAL_OK;
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
switch (CallbackId)
{
case HAL_QSPI_ERROR_CB_ID :
hqspi->ErrorCallback = HAL_QSPI_ErrorCallback;
break;
case HAL_QSPI_ABORT_CB_ID :
hqspi->AbortCpltCallback = HAL_QSPI_AbortCpltCallback;
break;
case HAL_QSPI_FIFO_THRESHOLD_CB_ID :
hqspi->FifoThresholdCallback = HAL_QSPI_FifoThresholdCallback;
break;
case HAL_QSPI_CMD_CPLT_CB_ID :
hqspi->CmdCpltCallback = HAL_QSPI_CmdCpltCallback;
break;
case HAL_QSPI_RX_CPLT_CB_ID :
hqspi->RxCpltCallback = HAL_QSPI_RxCpltCallback;
break;
case HAL_QSPI_TX_CPLT_CB_ID :
hqspi->TxCpltCallback = HAL_QSPI_TxCpltCallback;
break;
case HAL_QSPI_RX_HALF_CPLT_CB_ID :
hqspi->RxHalfCpltCallback = HAL_QSPI_RxHalfCpltCallback;
break;
case HAL_QSPI_TX_HALF_CPLT_CB_ID :
hqspi->TxHalfCpltCallback = HAL_QSPI_TxHalfCpltCallback;
break;
case HAL_QSPI_STATUS_MATCH_CB_ID :
hqspi->StatusMatchCallback = HAL_QSPI_StatusMatchCallback;
break;
case HAL_QSPI_TIMEOUT_CB_ID :
hqspi->TimeOutCallback = HAL_QSPI_TimeOutCallback;
break;
case HAL_QSPI_MSP_INIT_CB_ID :
hqspi->MspInitCallback = HAL_QSPI_MspInit;
break;
case HAL_QSPI_MSP_DEINIT_CB_ID :
hqspi->MspDeInitCallback = HAL_QSPI_MspDeInit;
break;
default :
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
/* update return status */
status = HAL_ERROR;
break;
}
}
else if (hqspi->State == HAL_QSPI_STATE_RESET)
{
switch (CallbackId)
{
case HAL_QSPI_MSP_INIT_CB_ID :
hqspi->MspInitCallback = HAL_QSPI_MspInit;
break;
case HAL_QSPI_MSP_DEINIT_CB_ID :
hqspi->MspDeInitCallback = HAL_QSPI_MspDeInit;
break;
default :
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
/* update return status */
status = HAL_ERROR;
break;
}
}
else
{
/* Update the error code */
hqspi->ErrorCode |= HAL_QSPI_ERROR_INVALID_CALLBACK;
/* update return status */
status = HAL_ERROR;
}
/* Release Lock */
__HAL_UNLOCK(hqspi);
return status;
}
#endif
/**
* @}
*/
/** @defgroup QSPI_Exported_Functions_Group3 Peripheral Control and State functions
* @brief QSPI control and State functions
*
@verbatim
===============================================================================
##### Peripheral Control and State functions #####
===============================================================================
[..]
This subsection provides a set of functions allowing to :
(+) Check in run-time the state of the driver.
(+) Check the error code set during last operation.
(+) Abort any operation.
@endverbatim
* @{
*/
/**
* @brief Return the QSPI handle state.
* @param hqspi QSPI handle
* @retval HAL state
*/
HAL_QSPI_StateTypeDef HAL_QSPI_GetState(QSPI_HandleTypeDef *hqspi)
{
/* Return QSPI handle state */
return hqspi->State;
}
/**
* @brief Return the QSPI error code.
* @param hqspi QSPI handle
* @retval QSPI Error Code
*/
uint32_t HAL_QSPI_GetError(QSPI_HandleTypeDef *hqspi)
{
return hqspi->ErrorCode;
}
/**
* @brief Abort the current transmission.
* @param hqspi QSPI handle
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Abort(QSPI_HandleTypeDef *hqspi)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t tickstart = HAL_GetTick();
/* Check if the state is in one of the busy states */
if (((uint32_t)hqspi->State & 0x2U) != 0U)
{
/* Process unlocked */
__HAL_UNLOCK(hqspi);
if ((hqspi->Instance->CR & QUADSPI_CR_DMAEN) != 0U)
{
/* Disable the DMA transfer by clearing the DMAEN bit in the QSPI CR register */
CLEAR_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
/* Abort DMA channel */
status = HAL_DMA_Abort(hqspi->hdma);
if(status != HAL_OK)
{
hqspi->ErrorCode |= HAL_QSPI_ERROR_DMA;
}
}
/* Configure QSPI: CR register with Abort request */
SET_BIT(hqspi->Instance->CR, QUADSPI_CR_ABORT);
/* Wait until TC flag is set to go back in idle state */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_TC, SET, tickstart, hqspi->Timeout);
if (status == HAL_OK)
{
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);
/* Wait until BUSY flag is reset */
status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_BUSY, RESET, tickstart, hqspi->Timeout);
}
if (status == HAL_OK)
{
/* Reset functional mode configuration to indirect write mode by default */
CLEAR_BIT(hqspi->Instance->CCR, QUADSPI_CCR_FMODE);
/* Update state */
hqspi->State = HAL_QSPI_STATE_READY;
}
}
return status;
}
/**
* @brief Abort the current transmission (non-blocking function)
* @param hqspi QSPI handle
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_Abort_IT(QSPI_HandleTypeDef *hqspi)
{
HAL_StatusTypeDef status = HAL_OK;
/* Check if the state is in one of the busy states */
if (((uint32_t)hqspi->State & 0x2U) != 0U)
{
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Update QSPI state */
hqspi->State = HAL_QSPI_STATE_ABORT;
/* Disable all interrupts */
__HAL_QSPI_DISABLE_IT(hqspi, (QSPI_IT_TO | QSPI_IT_SM | QSPI_IT_FT | QSPI_IT_TC | QSPI_IT_TE));
if ((hqspi->Instance->CR & QUADSPI_CR_DMAEN) != 0U)
{
/* Disable the DMA transfer by clearing the DMAEN bit in the QSPI CR register */
CLEAR_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
/* Abort DMA channel */
hqspi->hdma->XferAbortCallback = QSPI_DMAAbortCplt;
if (HAL_DMA_Abort_IT(hqspi->hdma) != HAL_OK)
{
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* Abort Complete callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->AbortCpltCallback(hqspi);
#else
HAL_QSPI_AbortCpltCallback(hqspi);
#endif
}
}
else
{
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);
/* Enable the QSPI Transfer Complete Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TC);
/* Configure QSPI: CR register with Abort request */
SET_BIT(hqspi->Instance->CR, QUADSPI_CR_ABORT);
}
}
return status;
}
/** @brief Set QSPI timeout.
* @param hqspi QSPI handle.
* @param Timeout Timeout for the QSPI memory access.
* @retval None
*/
void HAL_QSPI_SetTimeout(QSPI_HandleTypeDef *hqspi, uint32_t Timeout)
{
hqspi->Timeout = Timeout;
}
/** @brief Set QSPI Fifo threshold.
* @param hqspi QSPI handle.
* @param Threshold Threshold of the Fifo (value between 1 and 16).
* @retval HAL status
*/
HAL_StatusTypeDef HAL_QSPI_SetFifoThreshold(QSPI_HandleTypeDef *hqspi, uint32_t Threshold)
{
HAL_StatusTypeDef status = HAL_OK;
/* Process locked */
__HAL_LOCK(hqspi);
if(hqspi->State == HAL_QSPI_STATE_READY)
{
/* Synchronize init structure with new FIFO threshold value */
hqspi->Init.FifoThreshold = Threshold;
/* Configure QSPI FIFO Threshold */
MODIFY_REG(hqspi->Instance->CR, QUADSPI_CR_FTHRES,
((hqspi->Init.FifoThreshold - 1U) << QUADSPI_CR_FTHRES_Pos));
}
else
{
status = HAL_BUSY;
}
/* Process unlocked */
__HAL_UNLOCK(hqspi);
/* Return function status */
return status;
}
/** @brief Get QSPI Fifo threshold.
* @param hqspi QSPI handle.
* @retval Fifo threshold (value between 1 and 16)
*/
uint32_t HAL_QSPI_GetFifoThreshold(QSPI_HandleTypeDef *hqspi)
{
return ((READ_BIT(hqspi->Instance->CR, QUADSPI_CR_FTHRES) >> QUADSPI_CR_FTHRES_Pos) + 1U);
}
/**
* @}
*/
/**
* @}
*/
/** @defgroup QSPI_Private_Functions QSPI Private Functions
* @{
*/
/**
* @brief DMA QSPI receive process complete callback.
* @param hdma DMA handle
* @retval None
*/
static void QSPI_DMARxCplt(DMA_HandleTypeDef *hdma)
{
QSPI_HandleTypeDef* hqspi = (QSPI_HandleTypeDef*)(hdma->Parent);
hqspi->RxXferCount = 0U;
/* Enable the QSPI transfer complete Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TC);
}
/**
* @brief DMA QSPI transmit process complete callback.
* @param hdma DMA handle
* @retval None
*/
static void QSPI_DMATxCplt(DMA_HandleTypeDef *hdma)
{
QSPI_HandleTypeDef* hqspi = (QSPI_HandleTypeDef*)(hdma->Parent);
hqspi->TxXferCount = 0U;
/* Enable the QSPI transfer complete Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TC);
}
/**
* @brief DMA QSPI receive process half complete callback.
* @param hdma DMA handle
* @retval None
*/
static void QSPI_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
{
QSPI_HandleTypeDef* hqspi = (QSPI_HandleTypeDef*)(hdma->Parent);
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->RxHalfCpltCallback(hqspi);
#else
HAL_QSPI_RxHalfCpltCallback(hqspi);
#endif
}
/**
* @brief DMA QSPI transmit process half complete callback.
* @param hdma DMA handle
* @retval None
*/
static void QSPI_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
{
QSPI_HandleTypeDef* hqspi = (QSPI_HandleTypeDef*)(hdma->Parent);
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->TxHalfCpltCallback(hqspi);
#else
HAL_QSPI_TxHalfCpltCallback(hqspi);
#endif
}
/**
* @brief DMA QSPI communication error callback.
* @param hdma DMA handle
* @retval None
*/
static void QSPI_DMAError(DMA_HandleTypeDef *hdma)
{
QSPI_HandleTypeDef* hqspi = ( QSPI_HandleTypeDef* )(hdma->Parent);
hqspi->RxXferCount = 0U;
hqspi->TxXferCount = 0U;
hqspi->ErrorCode |= HAL_QSPI_ERROR_DMA;
/* Disable the DMA transfer by clearing the DMAEN bit in the QSPI CR register */
CLEAR_BIT(hqspi->Instance->CR, QUADSPI_CR_DMAEN);
/* Abort the QSPI */
(void)HAL_QSPI_Abort_IT(hqspi);
}
/**
* @brief DMA QSPI abort complete callback.
* @param hdma DMA handle
* @retval None
*/
static void QSPI_DMAAbortCplt(DMA_HandleTypeDef *hdma)
{
QSPI_HandleTypeDef* hqspi = ( QSPI_HandleTypeDef* )(hdma->Parent);
hqspi->RxXferCount = 0U;
hqspi->TxXferCount = 0U;
if(hqspi->State == HAL_QSPI_STATE_ABORT)
{
/* DMA Abort called by QSPI abort */
/* Clear interrupt */
__HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);
/* Enable the QSPI Transfer Complete Interrupt */
__HAL_QSPI_ENABLE_IT(hqspi, QSPI_IT_TC);
/* Configure QSPI: CR register with Abort request */
SET_BIT(hqspi->Instance->CR, QUADSPI_CR_ABORT);
}
else
{
/* DMA Abort called due to a transfer error interrupt */
/* Change state of QSPI */
hqspi->State = HAL_QSPI_STATE_READY;
/* Error callback */
#if (USE_HAL_QSPI_REGISTER_CALLBACKS == 1)
hqspi->ErrorCallback(hqspi);
#else
HAL_QSPI_ErrorCallback(hqspi);
#endif
}
}
/**
* @brief Wait for a flag state until timeout.
* @param hqspi QSPI handle
* @param Flag Flag checked
* @param State Value of the flag expected
* @param Tickstart Tick start value
* @param Timeout Duration of the timeout
* @retval HAL status
*/
static HAL_StatusTypeDef QSPI_WaitFlagStateUntilTimeout(QSPI_HandleTypeDef *hqspi, uint32_t Flag,
FlagStatus State, uint32_t Tickstart, uint32_t Timeout)
{
/* Wait until flag is in expected state */
while((__HAL_QSPI_GET_FLAG(hqspi, Flag)) != State)
{
/* Check for the Timeout */
if (Timeout != HAL_MAX_DELAY)
{
if(((HAL_GetTick() - Tickstart) > Timeout) || (Timeout == 0U))
{
hqspi->State = HAL_QSPI_STATE_ERROR;
hqspi->ErrorCode |= HAL_QSPI_ERROR_TIMEOUT;
return HAL_ERROR;
}
}
}
return HAL_OK;
}
/**
* @brief Configure the communication registers.
* @param hqspi QSPI handle
* @param cmd structure that contains the command configuration information
* @param FunctionalMode functional mode to configured
* This parameter can be one of the following values:
* @arg QSPI_FUNCTIONAL_MODE_INDIRECT_WRITE: Indirect write mode
* @arg QSPI_FUNCTIONAL_MODE_INDIRECT_READ: Indirect read mode
* @arg QSPI_FUNCTIONAL_MODE_AUTO_POLLING: Automatic polling mode
* @arg QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED: Memory-mapped mode
* @retval None
*/
static void QSPI_Config(QSPI_HandleTypeDef *hqspi, QSPI_CommandTypeDef *cmd, uint32_t FunctionalMode)
{
assert_param(IS_QSPI_FUNCTIONAL_MODE(FunctionalMode));
if ((cmd->DataMode != QSPI_DATA_NONE) && (FunctionalMode != QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED))
{
/* Configure QSPI: DLR register with the number of data to read or write */
WRITE_REG(hqspi->Instance->DLR, (cmd->NbData - 1U));
}
if (cmd->InstructionMode != QSPI_INSTRUCTION_NONE)
{
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
/* Configure QSPI: ABR register with alternate bytes value */
WRITE_REG(hqspi->Instance->ABR, cmd->AlternateBytes);
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
/*---- Command with instruction, address and alternate bytes ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateBytesSize | cmd->AlternateByteMode |
cmd->AddressSize | cmd->AddressMode | cmd->InstructionMode |
cmd->Instruction | FunctionalMode));
if (FunctionalMode != QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED)
{
/* Configure QSPI: AR register with address value */
WRITE_REG(hqspi->Instance->AR, cmd->Address);
}
}
else
{
/*---- Command with instruction and alternate bytes ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateBytesSize | cmd->AlternateByteMode |
cmd->AddressMode | cmd->InstructionMode |
cmd->Instruction | FunctionalMode));
}
}
else
{
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
/*---- Command with instruction and address ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateByteMode | cmd->AddressSize | cmd->AddressMode |
cmd->InstructionMode | cmd->Instruction | FunctionalMode));
if (FunctionalMode != QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED)
{
/* Configure QSPI: AR register with address value */
WRITE_REG(hqspi->Instance->AR, cmd->Address);
}
}
else
{
/*---- Command with only instruction ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateByteMode | cmd->AddressMode |
cmd->InstructionMode | cmd->Instruction | FunctionalMode));
}
}
}
else
{
if (cmd->AlternateByteMode != QSPI_ALTERNATE_BYTES_NONE)
{
/* Configure QSPI: ABR register with alternate bytes value */
WRITE_REG(hqspi->Instance->ABR, cmd->AlternateBytes);
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
/*---- Command with address and alternate bytes ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateBytesSize | cmd->AlternateByteMode |
cmd->AddressSize | cmd->AddressMode |
cmd->InstructionMode | FunctionalMode));
if (FunctionalMode != QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED)
{
/* Configure QSPI: AR register with address value */
WRITE_REG(hqspi->Instance->AR, cmd->Address);
}
}
else
{
/*---- Command with only alternate bytes ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateBytesSize | cmd->AlternateByteMode |
cmd->AddressMode | cmd->InstructionMode | FunctionalMode));
}
}
else
{
if (cmd->AddressMode != QSPI_ADDRESS_NONE)
{
/*---- Command with only address ----*/
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateByteMode | cmd->AddressSize |
cmd->AddressMode | cmd->InstructionMode | FunctionalMode));
if (FunctionalMode != QSPI_FUNCTIONAL_MODE_MEMORY_MAPPED)
{
/* Configure QSPI: AR register with address value */
WRITE_REG(hqspi->Instance->AR, cmd->Address);
}
}
else
{
/*---- Command with only data phase ----*/
if (cmd->DataMode != QSPI_DATA_NONE)
{
/* Configure QSPI: CCR register with all communications parameters */
WRITE_REG(hqspi->Instance->CCR, (cmd->DdrMode | cmd->SIOOMode |
cmd->DataMode | (cmd->DummyCycles << QUADSPI_CCR_DCYC_Pos) |
cmd->AlternateByteMode | cmd->AddressMode |
cmd->InstructionMode | FunctionalMode));
}
}
}
}
}
/**
* @}
*/
/**
* @}
*/
#endif /* HAL_QSPI_MODULE_ENABLED */
/**
* @}
*/
/**
* @}
*/
#endif /* defined(QUADSPI) || defined(QUADSPI1) || defined(QUADSPI2) */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
5e18825f75dc697bb99207700095a714607f0f4d
|
badb70a0b235c98ac034cfe5b4bfafda36647831
|
/Library/OcAppleKernelLib/PrelinkedContext.c
|
a2b3873bf076517c21a48ea81c01da4f35fa3650
|
[
"BSD-3-Clause"
] |
permissive
|
acidanthera/OpenCorePkg
|
f34a7d67b22c74fb5ab559e48519e5f5855b6751
|
1d5b1736fe5a5ef7662b5c076c6d11aac96fd5d6
|
refs/heads/master
| 2023-08-30T21:03:02.993659
| 2023-08-28T23:30:43
| 2023-08-28T23:30:43
| 179,354,282
| 13,212
| 2,999
|
BSD-3-Clause
| 2023-09-10T18:29:53
| 2019-04-03T19:14:29
|
C
|
UTF-8
|
C
| false
| false
| 46,459
|
c
|
PrelinkedContext.c
|
/** @file
Copyright (C) 2019, vit9696. All rights reserved.
All rights reserved.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <Uefi.h>
#include <IndustryStandard/AppleKmodInfo.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/OcAppleKernelLib.h>
#include <Library/OcMachoLib.h>
#include <Library/OcStringLib.h>
#include "PrelinkedInternal.h"
STATIC
UINT64
PrelinkedFindLastLoadAddress (
IN XML_NODE *KextList
)
{
UINT32 KextCount;
UINT32 KextIndex;
UINT32 FieldIndex;
UINT32 FieldCount;
XML_NODE *LastKext;
CONST CHAR8 *KextPlistKey;
XML_NODE *KextPlistValue;
UINT64 LoadAddress;
UINT64 LoadSize;
KextCount = XmlNodeChildren (KextList);
if (KextCount == 0) {
return 0;
}
//
// Here we make an assumption that last kext has the highest load address,
// yet there might be an arbitrary amount of trailing executable-less kexts.
//
for (KextIndex = 1; KextIndex <= KextCount; ++KextIndex) {
LastKext = PlistNodeCast (XmlNodeChild (KextList, KextCount - KextIndex), PLIST_NODE_TYPE_DICT);
if (LastKext == NULL) {
return 0;
}
LoadAddress = 0;
LoadSize = 0;
FieldCount = PlistDictChildren (LastKext);
for (FieldIndex = 0; FieldIndex < FieldCount; ++FieldIndex) {
KextPlistKey = PlistKeyValue (PlistDictChild (LastKext, FieldIndex, &KextPlistValue));
if (KextPlistKey == NULL) {
continue;
}
if ((LoadAddress == 0) && (AsciiStrCmp (KextPlistKey, PRELINK_INFO_EXECUTABLE_LOAD_ADDR_KEY) == 0)) {
if (!PlistIntegerValue (KextPlistValue, &LoadAddress, sizeof (LoadAddress), TRUE)) {
return 0;
}
} else if ((LoadSize == 0) && (AsciiStrCmp (KextPlistKey, PRELINK_INFO_EXECUTABLE_SIZE_KEY) == 0)) {
if (!PlistIntegerValue (KextPlistValue, &LoadSize, sizeof (LoadSize), TRUE)) {
return 0;
}
}
if ((LoadSize != 0) && (LoadAddress != 0)) {
break;
}
}
if (BaseOverflowAddU64 (LoadAddress, LoadSize, &LoadAddress)) {
return 0;
}
if (LoadAddress != 0) {
break;
}
}
return LoadAddress;
}
STATIC
EFI_STATUS
PrelinkedGetSegmentsFromMacho (
IN OC_MACHO_CONTEXT *MachoContext,
OUT MACH_SEGMENT_COMMAND_ANY **PrelinkedInfoSegment,
OUT MACH_SECTION_ANY **PrelinkedInfoSection
)
{
*PrelinkedInfoSegment = MachoGetSegmentByName (
MachoContext,
PRELINK_INFO_SEGMENT
);
if (*PrelinkedInfoSegment == NULL) {
return EFI_NOT_FOUND;
}
if ((MachoContext->Is32Bit ? (*PrelinkedInfoSegment)->Segment32.FileOffset : (*PrelinkedInfoSegment)->Segment64.FileOffset) > MAX_UINT32) {
return EFI_UNSUPPORTED;
}
*PrelinkedInfoSection = MachoGetSectionByName (
MachoContext,
*PrelinkedInfoSegment,
PRELINK_INFO_SECTION
);
if (*PrelinkedInfoSection == NULL) {
return EFI_NOT_FOUND;
}
if ((MachoContext->Is32Bit ? (*PrelinkedInfoSection)->Section32.Size : (*PrelinkedInfoSection)->Section64.Size) > MAX_UINT32) {
return EFI_UNSUPPORTED;
}
return EFI_SUCCESS;
}
EFI_STATUS
InternalConnectExternalSymtab (
IN OUT OC_MACHO_CONTEXT *Context,
OUT OC_MACHO_CONTEXT *InnerContext,
IN UINT8 *Buffer,
IN UINT32 BufferSize,
OUT BOOLEAN *KernelCollection OPTIONAL
)
{
MACH_HEADER_ANY *Header;
MACH_SEGMENT_COMMAND_64 *Segment;
BOOLEAN IsKernelCollection;
//
// Detect kernel type.
//
Header = MachoGetMachHeader (Context);
IsKernelCollection = (Context->Is32Bit ?
Header->Header32.FileType : Header->Header64.FileType) == MachHeaderFileTypeFileSet;
if (KernelCollection != NULL) {
*KernelCollection = IsKernelCollection;
}
//
// When dealing with the kernel collections the actual kernel is pointed by one of the segments.
//
if (IsKernelCollection) {
Segment = MachoGetSegmentByName64 (
Context,
"__TEXT_EXEC"
);
if ((Segment == NULL) || (Segment->VirtualAddress < Segment->FileOffset)) {
DEBUG ((
DEBUG_INFO,
"OCAK: KC symtab failed locating inner %Lx %Lx (%d)\n",
Segment != NULL ? Segment->VirtualAddress : 0,
Segment != NULL ? Segment->FileOffset : 0,
Segment != NULL
));
return EFI_INVALID_PARAMETER;
}
if (!MachoInitializeContext64 (
InnerContext,
Buffer,
BufferSize,
(UINT32)Segment->FileOffset,
(UINT32)(BufferSize - Segment->FileOffset)
))
{
DEBUG ((
DEBUG_INFO,
"OCAK: KC symtab failed initialising inner %Lx %x\n",
Segment->FileOffset,
BufferSize
));
return EFI_INVALID_PARAMETER;
}
if (!MachoInitialiseSymtabsExternal (Context, InnerContext)) {
DEBUG ((
DEBUG_INFO,
"OCAK: KC symtab failed getting symtab from inner %Lx %x\n",
Segment->FileOffset,
BufferSize
));
return EFI_INVALID_PARAMETER;
}
}
return EFI_SUCCESS;
}
EFI_STATUS
PrelinkedContextInit (
IN OUT PRELINKED_CONTEXT *Context,
IN OUT UINT8 *Prelinked,
IN UINT32 PrelinkedSize,
IN UINT32 PrelinkedAllocSize,
IN BOOLEAN Is32Bit
)
{
EFI_STATUS Status;
XML_NODE *DocumentRoot;
XML_NODE *PrelinkedInfoRoot;
CONST CHAR8 *PrelinkedInfoRootKey;
UINT64 SegmentEndOffset;
UINT32 PrelinkedInfoRootIndex;
UINT32 PrelinkedInfoRootCount;
PRELINKED_KEXT *PrelinkedKext;
ASSERT (Context != NULL);
ASSERT (Prelinked != NULL);
ASSERT (PrelinkedSize > 0);
ASSERT (PrelinkedAllocSize >= PrelinkedSize);
ZeroMem (Context, sizeof (*Context));
Context->Prelinked = Prelinked;
Context->PrelinkedSize = MACHO_ALIGN (PrelinkedSize);
Context->PrelinkedAllocSize = PrelinkedAllocSize;
Context->Is32Bit = Is32Bit;
//
// Ensure that PrelinkedSize is always aligned.
//
if (Context->PrelinkedSize != PrelinkedSize) {
if (Context->PrelinkedSize > PrelinkedAllocSize) {
return EFI_BUFFER_TOO_SMALL;
}
ZeroMem (&Prelinked[PrelinkedSize], Context->PrelinkedSize - PrelinkedSize);
}
//
// Initialise primary context.
//
if (!MachoInitializeContext (&Context->PrelinkedMachContext, Prelinked, PrelinkedSize, 0, PrelinkedSize, Context->Is32Bit)) {
return EFI_INVALID_PARAMETER;
}
Status = InternalConnectExternalSymtab (
&Context->PrelinkedMachContext,
&Context->InnerMachContext,
Context->Prelinked,
Context->PrelinkedSize,
&Context->IsKernelCollection
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Initialize kext list with kernel pseudo kext.
//
InitializeListHead (&Context->PrelinkedKexts);
InitializeListHead (&Context->InjectedKexts);
PrelinkedKext = InternalCachedPrelinkedKernel (Context);
if (PrelinkedKext == NULL) {
return EFI_INVALID_PARAMETER;
}
Context->VirtualBase = PrelinkedKext->Context.VirtualBase;
Context->PrelinkedLastAddress = MACHO_ALIGN (MachoGetLastAddress (&Context->PrelinkedMachContext));
if (Context->PrelinkedLastAddress == 0) {
return EFI_INVALID_PARAMETER;
}
//
// Register normal segment entries.
//
Status = PrelinkedGetSegmentsFromMacho (
&Context->PrelinkedMachContext,
&Context->PrelinkedInfoSegment,
&Context->PrelinkedInfoSection
);
if (EFI_ERROR (Status)) {
return Status;
}
if (Context->IsKernelCollection) {
//
// Additionally process special entries for KC.
//
Status = PrelinkedGetSegmentsFromMacho (
&Context->InnerMachContext,
(MACH_SEGMENT_COMMAND_ANY **)&Context->InnerInfoSegment,
(MACH_SECTION_ANY **)&Context->InnerInfoSection
);
if (EFI_ERROR (Status)) {
return Status;
}
Context->RegionSegment = MachoGetSegmentByName64 (
&Context->PrelinkedMachContext,
KC_REGION0_SEGMENT
);
if (Context->RegionSegment == NULL) {
return EFI_NOT_FOUND;
}
Context->LinkEditSegment = MachoGetSegmentByName (
&Context->PrelinkedMachContext,
KC_LINKEDIT_SEGMENT
);
if (Context->LinkEditSegment == NULL) {
return EFI_NOT_FOUND;
}
} else {
Context->PrelinkedTextSegment = MachoGetSegmentByName (
&Context->PrelinkedMachContext,
PRELINK_TEXT_SEGMENT
);
if (Context->PrelinkedTextSegment == NULL) {
return EFI_NOT_FOUND;
}
Context->PrelinkedTextSection = MachoGetSectionByName (
&Context->PrelinkedMachContext,
Context->PrelinkedTextSegment,
PRELINK_TEXT_SECTION
);
if (Context->PrelinkedTextSection == NULL) {
return EFI_NOT_FOUND;
}
}
Context->PrelinkedInfo = Context->Is32Bit ?
AllocateCopyPool (
Context->PrelinkedInfoSection->Section32.Size,
&Context->Prelinked[Context->PrelinkedInfoSection->Section32.Offset]
) :
AllocateCopyPool (
(UINTN)Context->PrelinkedInfoSection->Section64.Size,
&Context->Prelinked[Context->PrelinkedInfoSection->Section64.Offset]
);
if (Context->PrelinkedInfo == NULL) {
PrelinkedContextFree (Context);
return EFI_OUT_OF_RESOURCES;
}
Context->PrelinkedInfoDocument = XmlDocumentParse (
Context->PrelinkedInfo,
(UINT32)(Context->Is32Bit ?
Context->PrelinkedInfoSection->Section32.Size : Context->PrelinkedInfoSection->Section64.Size),
TRUE
);
if (Context->PrelinkedInfoDocument == NULL) {
PrelinkedContextFree (Context);
return EFI_INVALID_PARAMETER;
}
//
// For a kernel collection the this is a full plist, while for legacy prelinked format
// it starts with a <dict> node.
//
if (Context->IsKernelCollection) {
DocumentRoot = PlistDocumentRoot (Context->PrelinkedInfoDocument);
} else {
DocumentRoot = XmlDocumentRoot (Context->PrelinkedInfoDocument);
}
PrelinkedInfoRoot = PlistNodeCast (DocumentRoot, PLIST_NODE_TYPE_DICT);
if (PrelinkedInfoRoot == NULL) {
PrelinkedContextFree (Context);
return EFI_INVALID_PARAMETER;
}
if (Context->IsKernelCollection) {
//
// In KC mode last load address is the __LINKEDIT address.
//
SegmentEndOffset = Context->LinkEditSegment->Segment64.FileOffset + Context->LinkEditSegment->Segment64.FileSize;
if (MACHO_ALIGN (SegmentEndOffset) != Context->PrelinkedSize) {
PrelinkedContextFree (Context);
return EFI_INVALID_PARAMETER;
}
Context->PrelinkedLastLoadAddress = Context->LinkEditSegment->Segment64.VirtualAddress + Context->LinkEditSegment->Segment64.Size;
}
//
// In legacy mode last load address is last kext address.
//
PrelinkedInfoRootCount = PlistDictChildren (PrelinkedInfoRoot);
for (PrelinkedInfoRootIndex = 0; PrelinkedInfoRootIndex < PrelinkedInfoRootCount; ++PrelinkedInfoRootIndex) {
PrelinkedInfoRootKey = PlistKeyValue (PlistDictChild (PrelinkedInfoRoot, PrelinkedInfoRootIndex, &Context->KextList));
if (PrelinkedInfoRootKey == NULL) {
continue;
}
if (AsciiStrCmp (PrelinkedInfoRootKey, PRELINK_INFO_DICTIONARY_KEY) == 0) {
if (PlistNodeCast (Context->KextList, PLIST_NODE_TYPE_ARRAY) != NULL) {
if (Context->PrelinkedLastLoadAddress == 0) {
Context->PrelinkedLastLoadAddress = PrelinkedFindLastLoadAddress (Context->KextList);
}
if (Context->PrelinkedLastLoadAddress != 0) {
return EFI_SUCCESS;
}
}
break;
}
}
PrelinkedContextFree (Context);
return EFI_INVALID_PARAMETER;
}
VOID
PrelinkedContextFree (
IN OUT PRELINKED_CONTEXT *Context
)
{
UINT32 Index;
LIST_ENTRY *Link;
PRELINKED_KEXT *Kext;
if (Context->PrelinkedInfoDocument != NULL) {
XmlDocumentFree (Context->PrelinkedInfoDocument);
Context->PrelinkedInfoDocument = NULL;
}
if (Context->KextScratchBuffer != NULL) {
FreePool (Context->KextScratchBuffer);
Context->KextScratchBuffer = NULL;
}
if (Context->PrelinkedInfo != NULL) {
FreePool (Context->PrelinkedInfo);
Context->PrelinkedInfo = NULL;
}
if (Context->PooledBuffers != NULL) {
for (Index = 0; Index < Context->PooledBuffersCount; ++Index) {
FreePool (Context->PooledBuffers[Index]);
}
FreePool (Context->PooledBuffers);
Context->PooledBuffers = NULL;
}
if (Context->LinkBuffer != NULL) {
ZeroMem (Context->LinkBuffer, Context->LinkBufferSize);
FreePool (Context->LinkBuffer);
Context->LinkBuffer = NULL;
}
if (Context->PrelinkedStateKernel != NULL) {
FreePool (Context->PrelinkedStateKernel);
Context->PrelinkedStateKernel = NULL;
}
if (Context->PrelinkedStateKexts != NULL) {
FreePool (Context->PrelinkedStateKexts);
Context->PrelinkedStateKexts = NULL;
}
while (!IsListEmpty (&Context->PrelinkedKexts)) {
Link = GetFirstNode (&Context->PrelinkedKexts);
Kext = GET_PRELINKED_KEXT_FROM_LINK (Link);
RemoveEntryList (Link);
InternalFreePrelinkedKext (Kext);
}
ZeroMem (&Context->PrelinkedKexts, sizeof (Context->PrelinkedKexts));
//
// We do not need to iterate InjectedKexts here, as its memory was freed above.
//
ZeroMem (&Context->InjectedKexts, sizeof (Context->InjectedKexts));
}
EFI_STATUS
PrelinkedDependencyInsert (
IN OUT PRELINKED_CONTEXT *Context,
IN VOID *Buffer
)
{
VOID **NewPooledBuffers;
if (Context->PooledBuffersCount == Context->PooledBuffersAllocCount) {
NewPooledBuffers = AllocatePool (
2 * (Context->PooledBuffersAllocCount + 1) * sizeof (NewPooledBuffers[0])
);
if (NewPooledBuffers == NULL) {
return EFI_OUT_OF_RESOURCES;
}
if (Context->PooledBuffers != NULL) {
CopyMem (
&NewPooledBuffers[0],
&Context->PooledBuffers[0],
Context->PooledBuffersCount * sizeof (NewPooledBuffers[0])
);
FreePool (Context->PooledBuffers);
}
Context->PooledBuffers = NewPooledBuffers;
Context->PooledBuffersAllocCount = 2 * (Context->PooledBuffersAllocCount + 1);
}
Context->PooledBuffers[Context->PooledBuffersCount] = Buffer;
Context->PooledBuffersCount++;
return EFI_SUCCESS;
}
EFI_STATUS
PrelinkedInjectPrepare (
IN OUT PRELINKED_CONTEXT *Context,
IN UINT32 LinkedExpansion,
IN UINT32 ReservedExeSize
)
{
EFI_STATUS Status;
UINT64 SegmentEndOffset;
UINT32 AlignedExpansion;
if (Context->IsKernelCollection) {
//
// For newer variant (KC mode) __LINKEDIT is last, and we need to expand it to enable
// dyld fixup generation.
//
if ( (Context->PrelinkedAllocSize < LinkedExpansion)
|| (Context->PrelinkedAllocSize - LinkedExpansion < Context->PrelinkedSize))
{
return EFI_OUT_OF_RESOURCES;
}
ASSERT (Context->PrelinkedLastAddress == Context->PrelinkedLastLoadAddress);
//
// Ensured by PrelinkedContextInit().
//
ASSERT (Context->PrelinkedSize % MACHO_PAGE_SIZE == 0);
STATIC_ASSERT (
MACHO_PAGE_SIZE % BASE_ALIGNOF (MACH_DYLD_CHAINED_STARTS_IN_SEGMENT) == 0,
"KextsFixupChains may be unaligned"
);
Context->KextsFixupChains = (VOID *)(Context->Prelinked + Context->PrelinkedSize);
AlignedExpansion = MACHO_ALIGN (LinkedExpansion);
//
// Zero the expansion to account for padding.
//
ZeroMem (
Context->Prelinked + Context->PrelinkedSize,
AlignedExpansion
);
Context->PrelinkedSize += AlignedExpansion;
Context->PrelinkedLastAddress += AlignedExpansion;
Context->PrelinkedLastLoadAddress += AlignedExpansion;
Context->LinkEditSegment->Segment64.Size += AlignedExpansion;
Context->LinkEditSegment->Segment64.FileSize += AlignedExpansion;
} else {
//
// For older variant of the prelinkedkernel plist info is normally
// the last segment, so we may potentially save some data by removing
// it and then appending new kexts over. This is different for KC,
// where plist info is in the middle of the file. For 10.6.8 we will
// also need to move __PRELINK_STATE, which is just some blob for kextd.
//
// 10.6.8
//
// ffffff8000200000 - ffffff8000600000 (at 0000000000000000 - 0000000000400000) - __TEXT
// ffffff8000600000 - ffffff80006da000 (at 0000000000400000 - 000000000046f000) - __DATA
// ffffff8000106000 - ffffff8000107000 (at 000000000046f000 - 0000000000470000) - __INITGDT
// ffffff8000100000 - ffffff8000106000 (at 0000000000470000 - 0000000000476000) - __INITPT
// ffffff80006da000 - ffffff80006db000 (at 0000000000476000 - 0000000000477000) - __DESC
// ffffff80006db000 - ffffff80006dc000 (at 0000000000477000 - 0000000000478000) - __VECTORS
// ffffff8000108000 - ffffff800010e000 (at 0000000000478000 - 000000000047d000) - __HIB
// ffffff8000107000 - ffffff8000108000 (at 000000000047d000 - 000000000047e000) - __SLEEP
// ffffff80006dc000 - ffffff80006de000 (at 000000000047e000 - 0000000000480000) - __KLD
// ffffff80006de000 - ffffff80006de000 (at 0000000000480000 - 0000000000480000) - __LAST
// ffffff8000772000 - ffffff800100a000 (at 0000000000514000 - 0000000000dac000) - __PRELINK_TEXT
// ffffff800100a000 - ffffff800155c000 (at 0000000000dac000 - 00000000012fe000) - __PRELINK_STATE
// ffffff800155c000 - ffffff8001612000 (at 00000000012fe000 - 00000000013b4000) - __PRELINK_INFO
// 0000000000000000 - 0000000000000000 (at 0000000000513018 - 0000000000551269) - __CTF
// ffffff80006de000 - ffffff8000771018 (at 0000000000480000 - 0000000000513018) - __LINKEDIT
//
// 10.15.6
//
// ffffff8000200000 - ffffff8000c00000 (at 0000000000000000 - 0000000000a00000) - __TEXT
// ffffff8000c00000 - ffffff8000e70000 (at 0000000000a00000 - 0000000000c70000) - __DATA
// ffffff8000e70000 - ffffff8000ea9000 (at 0000000000c70000 - 0000000000ca9000) - __DATA_CONST
// ffffff8000100000 - ffffff800019e000 (at 0000000000ca9000 - 0000000000d47000) - __HIB
// ffffff8000ea9000 - ffffff8000eaa000 (at 0000000000d47000 - 0000000000d48000) - __VECTORS
// ffffff8000eaa000 - ffffff8000ec4000 (at 0000000000d48000 - 0000000000d62000) - __KLD
// ffffff8000ec4000 - ffffff8000ec5000 (at 0000000000d62000 - 0000000000d63000) - __LAST
// ffffff8001036000 - ffffff8002e24000 (at 0000000000f48000 - 0000000002d36000) - __PRELINK_TEXT
// ffffff8002e24000 - ffffff80030d2000 (at 0000000002d36000 - 0000000002fe3389) - __PRELINK_INFO
// ffffff8000ec5000 - ffffff8000ec5000 (at 0000000000d63000 - 0000000000dd7000) - __CTF
// ffffff8000ec5000 - ffffff80010358a8 (at 0000000000dd7000 - 0000000000f478a8) - __LINKEDIT
//
SegmentEndOffset = Context->Is32Bit ?
Context->PrelinkedInfoSegment->Segment32.FileOffset + Context->PrelinkedInfoSegment->Segment32.FileSize :
Context->PrelinkedInfoSegment->Segment64.FileOffset + Context->PrelinkedInfoSegment->Segment64.FileSize;
if (MACHO_ALIGN (SegmentEndOffset) == Context->PrelinkedSize) {
DEBUG ((
DEBUG_INFO,
"OCAK: Reducing %a-bit prelink size from %X to %X via plist\n",
Context->Is32Bit ? "32" : "64",
Context->PrelinkedSize,
(UINT32)MACHO_ALIGN (
Context->Is32Bit ?
Context->PrelinkedInfoSegment->Segment32.FileOffset : Context->PrelinkedInfoSegment->Segment64.FileOffset
)
));
Context->PrelinkedSize = (UINT32)MACHO_ALIGN (
Context->Is32Bit ?
Context->PrelinkedInfoSegment->Segment32.FileOffset : Context->PrelinkedInfoSegment->Segment64.FileOffset
);
} else {
DEBUG ((
DEBUG_INFO,
"OCAK: Leaving unchanged %a-bit prelink size %X due to %LX plist\n",
Context->Is32Bit ? "32" : "64",
Context->PrelinkedSize,
SegmentEndOffset
));
}
if (Context->PrelinkedStateSegment != NULL) {
SegmentEndOffset = Context->Is32Bit ?
Context->PrelinkedStateSegment->Segment32.FileOffset + Context->PrelinkedStateSegment->Segment32.FileSize :
Context->PrelinkedStateSegment->Segment64.FileOffset + Context->PrelinkedStateSegment->Segment64.FileSize;
if (MACHO_ALIGN (SegmentEndOffset) == Context->PrelinkedSize) {
DEBUG ((
DEBUG_INFO,
"OCAK: Reducing %a-bit prelink size from %X to %X via state\n",
Context->Is32Bit ? "32" : "64",
Context->PrelinkedSize,
(UINT32)MACHO_ALIGN (
Context->Is32Bit ?
Context->PrelinkedStateSegment->Segment32.FileOffset : Context->PrelinkedStateSegment->Segment64.FileOffset
)
));
Context->PrelinkedSize = (UINT32)MACHO_ALIGN (
Context->Is32Bit ?
Context->PrelinkedStateSegment->Segment32.FileOffset : Context->PrelinkedStateSegment->Segment64.FileOffset
);
//
// Need to NULL this, as they are used in address calculations
// in e.g. MachoGetLastAddress.
//
if (Context->Is32Bit) {
Context->PrelinkedStateSegment->Segment32.VirtualAddress = 0;
Context->PrelinkedStateSegment->Segment32.Size = 0;
Context->PrelinkedStateSegment->Segment32.FileOffset = 0;
Context->PrelinkedStateSegment->Segment32.FileSize = 0;
Context->PrelinkedStateSectionKernel->Section32.Address = 0;
Context->PrelinkedStateSectionKernel->Section32.Size = 0;
Context->PrelinkedStateSectionKernel->Section32.Offset = 0;
Context->PrelinkedStateSectionKexts->Section32.Address = 0;
Context->PrelinkedStateSectionKexts->Section32.Size = 0;
Context->PrelinkedStateSectionKexts->Section32.Offset = 0;
} else {
Context->PrelinkedStateSegment->Segment64.VirtualAddress = 0;
Context->PrelinkedStateSegment->Segment64.Size = 0;
Context->PrelinkedStateSegment->Segment64.FileOffset = 0;
Context->PrelinkedStateSegment->Segment64.FileSize = 0;
Context->PrelinkedStateSectionKernel->Section64.Address = 0;
Context->PrelinkedStateSectionKernel->Section64.Size = 0;
Context->PrelinkedStateSectionKernel->Section64.Offset = 0;
Context->PrelinkedStateSectionKexts->Section64.Address = 0;
Context->PrelinkedStateSectionKexts->Section64.Size = 0;
Context->PrelinkedStateSectionKexts->Section64.Offset = 0;
}
} else {
DEBUG ((
DEBUG_INFO,
"OCAK: Leaving unchanged %a-bit prelink size %X due to %LX state\n",
Context->Is32Bit ? "32" : "64",
Context->PrelinkedSize,
SegmentEndOffset
));
}
}
if (Context->Is32Bit) {
Context->PrelinkedInfoSegment->Segment32.VirtualAddress = 0;
Context->PrelinkedInfoSegment->Segment32.Size = 0;
Context->PrelinkedInfoSegment->Segment32.FileOffset = 0;
Context->PrelinkedInfoSegment->Segment32.FileSize = 0;
Context->PrelinkedInfoSection->Section32.Address = 0;
Context->PrelinkedInfoSection->Section32.Size = 0;
Context->PrelinkedInfoSection->Section32.Offset = 0;
} else {
Context->PrelinkedInfoSegment->Segment64.VirtualAddress = 0;
Context->PrelinkedInfoSegment->Segment64.Size = 0;
Context->PrelinkedInfoSegment->Segment64.FileOffset = 0;
Context->PrelinkedInfoSegment->Segment64.FileSize = 0;
Context->PrelinkedInfoSection->Section64.Address = 0;
Context->PrelinkedInfoSection->Section64.Size = 0;
Context->PrelinkedInfoSection->Section64.Offset = 0;
}
Context->PrelinkedLastAddress = MACHO_ALIGN (MachoGetLastAddress (&Context->PrelinkedMachContext));
if (Context->PrelinkedLastAddress == 0) {
return EFI_INVALID_PARAMETER;
}
//
// Prior to plist there usually is prelinked text.
//
SegmentEndOffset = Context->Is32Bit ?
Context->PrelinkedTextSegment->Segment32.FileOffset + Context->PrelinkedTextSegment->Segment32.FileSize :
Context->PrelinkedTextSegment->Segment64.FileOffset + Context->PrelinkedTextSegment->Segment64.FileSize;
if (MACHO_ALIGN (SegmentEndOffset) != Context->PrelinkedSize) {
//
// TODO: Implement prelinked text relocation when it is not preceding prelinked info
// and is not in the end of prelinked info.
//
return EFI_UNSUPPORTED;
}
}
//
// Append the injected KEXTs to the current kernel end.
//
Context->KextsFileOffset = Context->PrelinkedSize;
Context->KextsVmAddress = Context->PrelinkedLastAddress;
if (Context->IsKernelCollection) {
Status = KcInitKextFixupChains (Context, LinkedExpansion, ReservedExeSize);
if (EFI_ERROR (Status)) {
return Status;
}
}
return EFI_SUCCESS;
}
EFI_STATUS
PrelinkedInjectComplete (
IN OUT PRELINKED_CONTEXT *Context
)
{
EFI_STATUS Status;
CHAR8 *ExportedInfo;
UINT32 ExportedInfoSize;
UINT32 NewSize;
UINT32 KextsSize;
UINT32 ChainSize;
if (Context->IsKernelCollection) {
//
// Fix up the segment fixup chains structure to reflect the actually
// injected segment size.
//
KextsSize = Context->PrelinkedSize - Context->KextsFileOffset;
ChainSize = KcGetSegmentFixupChainsSize (KextsSize);
ASSERT (ChainSize != 0);
ASSERT (ChainSize <= Context->KextsFixupChains->Size);
Context->KextsFixupChains->Size = ChainSize;
Context->KextsFixupChains->PageCount = (UINT16)(KextsSize / MACHO_PAGE_SIZE);
Status = KcRebuildMachHeader (Context);
if (EFI_ERROR (Status)) {
return Status;
}
} else if ((Context->PrelinkedStateSegment != NULL) && ((Context->Is32Bit ?
Context->PrelinkedStateSegment->Segment32.VirtualAddress : Context->PrelinkedStateSegment->Segment64.VirtualAddress)
== 0))
{
Status = InternalKxldStateRebuild (Context);
if (EFI_ERROR (Status)) {
return Status;
}
}
ExportedInfo = XmlDocumentExport (Context->PrelinkedInfoDocument, &ExportedInfoSize, 0, FALSE);
if (ExportedInfo == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Include \0 terminator.
//
ExportedInfoSize++;
if ( BaseOverflowAddU32 (Context->PrelinkedSize, MACHO_ALIGN (ExportedInfoSize), &NewSize)
|| (NewSize > Context->PrelinkedAllocSize))
{
FreePool (ExportedInfo);
return EFI_BUFFER_TOO_SMALL;
}
#if 0
//
// This is a potential optimisation for smaller kexts allowing us to use less space.
// This requires disable __KREMLIN relocation segment addition.
//
if (Context->IsKernelCollection && (MACHO_ALIGN (ExportedInfoSize) <= Context->PrelinkedInfoSegment->Size)) {
CopyMem (
&Context->Prelinked[Context->PrelinkedInfoSegment->FileOffset],
ExportedInfo,
ExportedInfoSize
);
ZeroMem (
&Context->Prelinked[Context->PrelinkedInfoSegment->FileOffset + ExportedInfoSize],
Context->PrelinkedInfoSegment->FileSize - ExportedInfoSize
);
FreePool (ExportedInfo);
return EFI_SUCCESS;
}
#endif
if (Context->Is32Bit) {
Context->PrelinkedInfoSegment->Segment32.VirtualAddress = (UINT32)Context->PrelinkedLastAddress;
Context->PrelinkedInfoSegment->Segment32.Size = MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedInfoSegment->Segment32.FileOffset = Context->PrelinkedSize;
Context->PrelinkedInfoSegment->Segment32.FileSize = MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedInfoSection->Section32.Address = (UINT32)Context->PrelinkedLastAddress;
Context->PrelinkedInfoSection->Section32.Size = MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedInfoSection->Section32.Offset = Context->PrelinkedSize;
} else {
Context->PrelinkedInfoSegment->Segment64.VirtualAddress = Context->PrelinkedLastAddress;
Context->PrelinkedInfoSegment->Segment64.Size = MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedInfoSegment->Segment64.FileOffset = Context->PrelinkedSize;
Context->PrelinkedInfoSegment->Segment64.FileSize = MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedInfoSection->Section64.Address = Context->PrelinkedLastAddress;
Context->PrelinkedInfoSection->Section64.Size = MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedInfoSection->Section64.Offset = Context->PrelinkedSize;
}
if (Context->IsKernelCollection) {
//
// For newer variant of the prelinkedkernel plist we need to adapt it
// in both inner and outer images.
//
Context->InnerInfoSegment->VirtualAddress = Context->PrelinkedLastAddress;
Context->InnerInfoSegment->Size = MACHO_ALIGN (ExportedInfoSize);
Context->InnerInfoSegment->FileOffset = Context->PrelinkedSize;
Context->InnerInfoSegment->FileSize = MACHO_ALIGN (ExportedInfoSize);
Context->InnerInfoSection->Address = Context->PrelinkedLastAddress;
Context->InnerInfoSection->Size = MACHO_ALIGN (ExportedInfoSize);
Context->InnerInfoSection->Offset = Context->PrelinkedSize;
}
CopyMem (
&Context->Prelinked[Context->PrelinkedSize],
ExportedInfo,
ExportedInfoSize
);
ZeroMem (
&Context->Prelinked[Context->PrelinkedSize + ExportedInfoSize],
MACHO_ALIGN (ExportedInfoSize) - ExportedInfoSize
);
Context->PrelinkedLastAddress += MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedSize += MACHO_ALIGN (ExportedInfoSize);
Context->PrelinkedMachContext.FileSize = Context->PrelinkedSize;
if (Context->IsKernelCollection) {
//
// After rebuilding the KC we may have moved the __LINKEDIT command.
// This happens when __REGION kexts are squashed.
// Obtain its address again.
//
Context->LinkEditSegment = MachoGetSegmentByName (
&Context->PrelinkedMachContext,
KC_LINKEDIT_SEGMENT
);
}
FreePool (ExportedInfo);
return EFI_SUCCESS;
}
EFI_STATUS
PrelinkedReserveKextSize (
IN OUT UINT32 *ReservedInfoSize,
IN OUT UINT32 *ReservedExeSize,
IN UINT32 InfoPlistSize,
IN UINT8 *Executable OPTIONAL,
IN UINT32 ExecutableSize OPTIONAL,
IN BOOLEAN Is32Bit
)
{
OC_MACHO_CONTEXT Context;
//
// For new fields.
//
if (BaseOverflowAddU32 (InfoPlistSize, PLIST_EXPANSION_SIZE, &InfoPlistSize)) {
return EFI_INVALID_PARAMETER;
}
InfoPlistSize = MACHO_ALIGN (InfoPlistSize);
if (Executable != NULL) {
ASSERT (ExecutableSize > 0);
if (!MachoInitializeContext (&Context, Executable, ExecutableSize, 0, ExecutableSize, Is32Bit)) {
return EFI_INVALID_PARAMETER;
}
ExecutableSize = MachoGetExpandedImageSize (&Context);
if (ExecutableSize == 0) {
return EFI_INVALID_PARAMETER;
}
}
if ( BaseOverflowAddU32 (*ReservedInfoSize, InfoPlistSize, &InfoPlistSize)
|| BaseOverflowAddU32 (*ReservedExeSize, ExecutableSize, &ExecutableSize))
{
return EFI_INVALID_PARAMETER;
}
*ReservedInfoSize = InfoPlistSize;
*ReservedExeSize = ExecutableSize;
return EFI_SUCCESS;
}
EFI_STATUS
PrelinkedInjectKext (
IN OUT PRELINKED_CONTEXT *Context,
IN CONST CHAR8 *Identifier OPTIONAL,
IN CONST CHAR8 *BundlePath,
IN CONST CHAR8 *InfoPlist,
IN UINT32 InfoPlistSize,
IN CONST CHAR8 *ExecutablePath OPTIONAL,
IN CONST UINT8 *Executable OPTIONAL,
IN UINT32 ExecutableSize OPTIONAL,
OUT CHAR8 BundleVersion[MAX_INFO_BUNDLE_VERSION_KEY_SIZE] OPTIONAL
)
{
EFI_STATUS Status;
BOOLEAN Result;
XML_DOCUMENT *InfoPlistDocument;
XML_NODE *InfoPlistRoot;
XML_NODE *KextPlistValue;
CHAR8 *TmpInfoPlist;
CHAR8 *NewInfoPlist;
OC_MACHO_CONTEXT ExecutableContext;
CONST CHAR8 *TmpKeyValue;
UINT32 FieldCount;
UINT32 FieldIndex;
UINT32 NewInfoPlistSize;
UINT32 NewPrelinkedSize;
UINT32 AlignedExecutableSize;
BOOLEAN Failed;
UINT64 KmodAddress;
PRELINKED_KEXT *PrelinkedKext;
CHAR8 ExecutableSourceAddrStr[24];
CHAR8 ExecutableSizeStr[24];
CHAR8 ExecutableLoadAddrStr[24];
CHAR8 KmodInfoStr[24];
UINT32 KextOffset;
UINT64 FileOffset;
UINT64 LoadAddressOffset;
CONST CHAR8 *BundleVerStr;
PrelinkedKext = NULL;
ASSERT (Context != NULL);
ASSERT (BundlePath != NULL);
ASSERT (InfoPlist != NULL);
ASSERT (InfoPlistSize > 0);
KmodAddress = 0;
AlignedExecutableSize = 0;
KextOffset = 0;
//
// If an identifier was passed, ensure it does not already exist.
//
if (Identifier != NULL) {
if (InternalCachedPrelinkedKext (Context, Identifier) != NULL) {
DEBUG ((DEBUG_INFO, "OCAK: Bundle %a is already present in prelinked\n", Identifier));
return EFI_ALREADY_STARTED;
}
}
//
// Copy executable to prelinkedkernel.
//
if (Executable != NULL) {
ASSERT (ExecutableSize > 0);
if (!MachoInitializeContext (&ExecutableContext, (UINT8 *)Executable, ExecutableSize, 0, ExecutableSize, Context->Is32Bit)) {
DEBUG ((DEBUG_INFO, "OCAK: Injected kext %a/%a is not a supported executable\n", BundlePath, ExecutablePath));
return EFI_INVALID_PARAMETER;
}
//
// Append the KEXT to the current prelinked end.
//
KextOffset = Context->PrelinkedSize;
ExecutableSize = MachoExpandImage (
&ExecutableContext,
&Context->Prelinked[KextOffset],
Context->PrelinkedAllocSize - KextOffset,
TRUE,
&FileOffset
);
AlignedExecutableSize = MACHO_ALIGN (ExecutableSize);
if ( BaseOverflowAddU32 (KextOffset, AlignedExecutableSize, &NewPrelinkedSize)
|| (NewPrelinkedSize > Context->PrelinkedAllocSize)
|| (ExecutableSize == 0))
{
return EFI_BUFFER_TOO_SMALL;
}
ZeroMem (
&Context->Prelinked[KextOffset + ExecutableSize],
AlignedExecutableSize - ExecutableSize
);
if ( !MachoInitializeContext (&ExecutableContext, &Context->Prelinked[KextOffset], ExecutableSize, 0, ExecutableSize, Context->Is32Bit)
|| BaseOverflowAddU64 (Context->PrelinkedLastLoadAddress, FileOffset, &LoadAddressOffset))
{
return EFI_INVALID_PARAMETER;
}
Result = KextFindKmodAddress (&ExecutableContext, LoadAddressOffset, ExecutableSize, &KmodAddress);
if (!Result) {
return EFI_INVALID_PARAMETER;
}
}
//
// Allocate Info.plist copy for XML_DOCUMENT.
//
TmpInfoPlist = AllocateCopyPool (InfoPlistSize, InfoPlist);
if (TmpInfoPlist == NULL) {
return EFI_OUT_OF_RESOURCES;
}
InfoPlistDocument = XmlDocumentParse (TmpInfoPlist, InfoPlistSize, FALSE);
if (InfoPlistDocument == NULL) {
FreePool (TmpInfoPlist);
return EFI_INVALID_PARAMETER;
}
InfoPlistRoot = PlistNodeCast (PlistDocumentRoot (InfoPlistDocument), PLIST_NODE_TYPE_DICT);
if (InfoPlistRoot == NULL) {
XmlDocumentFree (InfoPlistDocument);
FreePool (TmpInfoPlist);
return EFI_INVALID_PARAMETER;
}
//
// We are not supposed to check for this, it is XNU responsibility, which reliably panics.
// However, to avoid certain users making this kind of mistake, we still provide some
// code in debug mode to diagnose it.
//
DEBUG_CODE_BEGIN ();
FieldCount = PlistDictChildren (InfoPlistRoot);
if (BundleVersion != NULL) {
for (FieldIndex = 0; FieldIndex < FieldCount; ++FieldIndex) {
TmpKeyValue = PlistKeyValue (PlistDictChild (InfoPlistRoot, FieldIndex, &KextPlistValue));
if (TmpKeyValue == NULL) {
continue;
}
//
// Match CFBundleVersion.
//
if (AsciiStrCmp (TmpKeyValue, INFO_BUNDLE_VERSION_KEY) == 0) {
if (PlistNodeCast (KextPlistValue, PLIST_NODE_TYPE_STRING) == NULL) {
break;
}
BundleVerStr = XmlNodeContent (KextPlistValue);
AsciiStrCpyS (BundleVersion, MAX_INFO_BUNDLE_VERSION_KEY_SIZE, BundleVerStr);
break;
}
}
}
if (Executable == NULL) {
for (FieldIndex = 0; FieldIndex < FieldCount; ++FieldIndex) {
TmpKeyValue = PlistKeyValue (PlistDictChild (InfoPlistRoot, FieldIndex, NULL));
if (TmpKeyValue == NULL) {
continue;
}
if (AsciiStrCmp (TmpKeyValue, INFO_BUNDLE_EXECUTABLE_KEY) == 0) {
DEBUG ((DEBUG_ERROR, "OCAK: Plist-only kext has %a key\n", INFO_BUNDLE_EXECUTABLE_KEY));
ASSERT (FALSE);
CpuDeadLoop ();
}
}
}
DEBUG_CODE_END ();
Failed = FALSE;
Failed |= XmlNodeAppend (InfoPlistRoot, "key", NULL, PRELINK_INFO_BUNDLE_PATH_KEY) == NULL;
Failed |= XmlNodeAppend (InfoPlistRoot, "string", NULL, BundlePath) == NULL;
if (Executable != NULL) {
Failed |= XmlNodeAppend (InfoPlistRoot, "key", NULL, PRELINK_INFO_EXECUTABLE_RELATIVE_PATH_KEY) == NULL;
Failed |= XmlNodeAppend (InfoPlistRoot, "string", NULL, ExecutablePath) == NULL;
Failed |= !AsciiUint64ToLowerHex (ExecutableSourceAddrStr, sizeof (ExecutableSourceAddrStr), Context->PrelinkedLastAddress);
Failed |= XmlNodeAppend (InfoPlistRoot, "key", NULL, PRELINK_INFO_EXECUTABLE_SOURCE_ADDR_KEY) == NULL;
Failed |= XmlNodeAppend (InfoPlistRoot, "integer", PRELINK_INFO_INTEGER_ATTRIBUTES, ExecutableSourceAddrStr) == NULL;
Failed |= !AsciiUint64ToLowerHex (ExecutableLoadAddrStr, sizeof (ExecutableLoadAddrStr), Context->PrelinkedLastLoadAddress);
Failed |= XmlNodeAppend (InfoPlistRoot, "key", NULL, PRELINK_INFO_EXECUTABLE_LOAD_ADDR_KEY) == NULL;
Failed |= XmlNodeAppend (InfoPlistRoot, "integer", PRELINK_INFO_INTEGER_ATTRIBUTES, ExecutableLoadAddrStr) == NULL;
Failed |= !AsciiUint64ToLowerHex (ExecutableSizeStr, sizeof (ExecutableSizeStr), AlignedExecutableSize);
Failed |= XmlNodeAppend (InfoPlistRoot, "key", NULL, PRELINK_INFO_EXECUTABLE_SIZE_KEY) == NULL;
Failed |= XmlNodeAppend (InfoPlistRoot, "integer", PRELINK_INFO_INTEGER_ATTRIBUTES, ExecutableSizeStr) == NULL;
Failed |= !AsciiUint64ToLowerHex (KmodInfoStr, sizeof (KmodInfoStr), KmodAddress);
Failed |= XmlNodeAppend (InfoPlistRoot, "key", NULL, PRELINK_INFO_KMOD_INFO_KEY) == NULL;
Failed |= XmlNodeAppend (InfoPlistRoot, "integer", PRELINK_INFO_INTEGER_ATTRIBUTES, KmodInfoStr) == NULL;
}
if (Failed) {
XmlDocumentFree (InfoPlistDocument);
FreePool (TmpInfoPlist);
return EFI_OUT_OF_RESOURCES;
}
if (Executable != NULL) {
PrelinkedKext = InternalLinkPrelinkedKext (
Context,
&ExecutableContext,
InfoPlistRoot,
Context->PrelinkedLastLoadAddress,
KmodAddress,
FileOffset
);
if (PrelinkedKext == NULL) {
XmlDocumentFree (InfoPlistDocument);
FreePool (TmpInfoPlist);
return EFI_INVALID_PARAMETER;
}
//
// XNU assumes that load size and source size are same, so we should append
// whatever is bigger to all sizes.
//
Context->PrelinkedSize += AlignedExecutableSize;
Context->PrelinkedLastAddress += AlignedExecutableSize;
Context->PrelinkedLastLoadAddress += AlignedExecutableSize;
if (Context->IsKernelCollection) {
//
// For KC, our KEXTs have their own segment - do not mod __PRELINK_INFO.
// Integrate the KEXT into KC by indexing its fixups and rebasing.
// Note, we are no longer using ExecutableContext here, as the context
// ownership was transferred by InternalLinkPrelinkedKext.
//
KcKextIndexFixups (Context, &PrelinkedKext->Context.MachContext);
Status = KcKextApplyFileDelta (Context, &PrelinkedKext->Context.MachContext, KextOffset);
if (EFI_ERROR (Status)) {
DEBUG ((
DEBUG_WARN,
"Failed to rebase injected kext %a/%a by %u\n",
BundlePath,
ExecutablePath,
KextOffset
));
return Status;
}
} else {
//
// For legacy prelinkedkernel we append to __PRELINK_TEXT.
//
if (Context->Is32Bit) {
Context->PrelinkedTextSegment->Segment32.Size += AlignedExecutableSize;
Context->PrelinkedTextSegment->Segment32.FileSize += AlignedExecutableSize;
Context->PrelinkedTextSection->Section32.Size += AlignedExecutableSize;
} else {
Context->PrelinkedTextSegment->Segment64.Size += AlignedExecutableSize;
Context->PrelinkedTextSegment->Segment64.FileSize += AlignedExecutableSize;
Context->PrelinkedTextSection->Section64.Size += AlignedExecutableSize;
}
}
}
//
// Strip outer plist & dict.
//
NewInfoPlist = XmlDocumentExport (InfoPlistDocument, &NewInfoPlistSize, 2, FALSE);
XmlDocumentFree (InfoPlistDocument);
FreePool (TmpInfoPlist);
if (NewInfoPlist == NULL) {
if (PrelinkedKext != NULL) {
InternalFreePrelinkedKext (PrelinkedKext);
}
return EFI_OUT_OF_RESOURCES;
}
Status = PrelinkedDependencyInsert (Context, NewInfoPlist);
if (EFI_ERROR (Status)) {
FreePool (NewInfoPlist);
if (PrelinkedKext != NULL) {
InternalFreePrelinkedKext (PrelinkedKext);
}
return Status;
}
if (XmlNodeAppend (Context->KextList, "dict", NULL, NewInfoPlist) == NULL) {
if (PrelinkedKext != NULL) {
InternalFreePrelinkedKext (PrelinkedKext);
}
return EFI_OUT_OF_RESOURCES;
}
//
// Let other kexts depend on this one.
//
if (PrelinkedKext != NULL) {
InsertTailList (&Context->PrelinkedKexts, &PrelinkedKext->Link);
//
// Additionally register this kext in the injected list, as this is required
// for KernelCollection support.
//
InsertTailList (&Context->InjectedKexts, &PrelinkedKext->InjectedLink);
}
return EFI_SUCCESS;
}
EFI_STATUS
PrelinkedContextApplyPatch (
IN OUT PRELINKED_CONTEXT *Context,
IN CONST CHAR8 *Identifier,
IN PATCHER_GENERIC_PATCH *Patch
)
{
EFI_STATUS Status;
PATCHER_CONTEXT Patcher;
ASSERT (Context != NULL);
ASSERT (Identifier != NULL);
ASSERT (Patch != NULL);
Status = PatcherInitContextFromPrelinked (&Patcher, Context, Identifier);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_INFO, "OCAK: Failed to pk find %a - %r\n", Identifier, Status));
return Status;
}
return PatcherApplyGenericPatch (&Patcher, Patch);
}
EFI_STATUS
PrelinkedContextApplyQuirk (
IN OUT PRELINKED_CONTEXT *Context,
IN KERNEL_QUIRK_NAME Quirk,
IN UINT32 KernelVersion
)
{
EFI_STATUS Status;
KERNEL_QUIRK *KernelQuirk;
PATCHER_CONTEXT Patcher;
ASSERT (Context != NULL);
KernelQuirk = &gKernelQuirks[Quirk];
ASSERT (KernelQuirk->Identifier != NULL);
Status = PatcherInitContextFromPrelinked (&Patcher, Context, KernelQuirk->Identifier);
if (!EFI_ERROR (Status)) {
return KernelQuirk->PatchFunction (&Patcher, KernelVersion);
}
//
// It is up to the function to decide whether this is critical or not.
//
DEBUG ((DEBUG_INFO, "OCAK: Failed to pk find %a - %r\n", KernelQuirk->Identifier, Status));
return KernelQuirk->PatchFunction (NULL, KernelVersion);
}
EFI_STATUS
PrelinkedContextBlock (
IN OUT PRELINKED_CONTEXT *Context,
IN CONST CHAR8 *Identifier,
IN BOOLEAN Exclude
)
{
EFI_STATUS Status;
PATCHER_CONTEXT Patcher;
ASSERT (Context != NULL);
ASSERT (Identifier != NULL);
Status = PatcherInitContextFromPrelinked (&Patcher, Context, Identifier);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_INFO, "OCAK: Failed to pk find %a - %r\n", Identifier, Status));
return Status;
}
return Exclude ? PatcherExcludePrelinkedKext (Identifier, &Patcher, Context) : PatcherBlockKext (&Patcher);
}
|
e068fac29e68f865ad4a818d4619d2edfab258b5
|
e65a4dbfbfb0e54e59787ba7741efee12f7687f3
|
/security/openssl30/files/patch-crypto_ppccap.c
|
14da11dedd4bae282a07b16ee35af8d5c270ef47
|
[
"BSD-2-Clause"
] |
permissive
|
freebsd/freebsd-ports
|
86f2e89d43913412c4f6b2be3e255bc0945eac12
|
605a2983f245ac63f5420e023e7dce56898ad801
|
refs/heads/main
| 2023-08-30T21:46:28.720924
| 2023-08-30T19:33:44
| 2023-08-30T19:33:44
| 1,803,961
| 916
| 918
|
NOASSERTION
| 2023-09-08T04:06:26
| 2011-05-26T11:15:35
| null |
UTF-8
|
C
| false
| false
| 1,171
|
c
|
patch-crypto_ppccap.c
|
--- crypto/ppccap.c.orig 2022-04-12 16:31:27 UTC
+++ crypto/ppccap.c
@@ -117,14 +117,18 @@ static unsigned long getauxval(unsigned long key)
#endif
/* I wish <sys/auxv.h> was universally available */
-#define HWCAP 16 /* AT_HWCAP */
+#ifndef AT_HWCAP
+# define AT_HWCAP 16 /* AT_HWCAP */
+#endif
#define HWCAP_PPC64 (1U << 30)
#define HWCAP_ALTIVEC (1U << 28)
#define HWCAP_FPU (1U << 27)
#define HWCAP_POWER6_EXT (1U << 9)
#define HWCAP_VSX (1U << 7)
-#define HWCAP2 26 /* AT_HWCAP2 */
+#ifndef AT_HWCAP2
+# define AT_HWCAP2 26 /* AT_HWCAP2 */
+#endif
#define HWCAP_VEC_CRYPTO (1U << 25)
#define HWCAP_ARCH_3_00 (1U << 23)
@@ -215,8 +219,8 @@ void OPENSSL_cpuid_setup(void)
#ifdef OSSL_IMPLEMENT_GETAUXVAL
{
- unsigned long hwcap = getauxval(HWCAP);
- unsigned long hwcap2 = getauxval(HWCAP2);
+ unsigned long hwcap = getauxval(AT_HWCAP);
+ unsigned long hwcap2 = getauxval(AT_HWCAP2);
if (hwcap & HWCAP_FPU) {
OPENSSL_ppccap_P |= PPC_FPU;
|
5dab4bdae202b65533873c75c22d0d3782d68ee6
|
e73547787354afd9b717ea57fe8dd0695d161821
|
/src/os/vigetmode.c
|
8ec238ac82c4f205e2c7f258f6cbf9ffe3d43946
|
[] |
no_license
|
pmret/papermario
|
8b514b19653cef8d6145e47499b3636b8c474a37
|
9774b26d93f1045dd2a67e502b6efc9599fb6c31
|
refs/heads/main
| 2023-08-31T07:09:48.951514
| 2023-08-21T18:07:08
| 2023-08-21T18:07:08
| 287,151,133
| 904
| 139
| null | 2023-09-14T02:44:23
| 2020-08-13T01:22:57
|
C
|
UTF-8
|
C
| false
| false
| 209
|
c
|
vigetmode.c
|
#include "PR/viint.h"
u32 osViGetCurrentMode(void) {
register u32 savedMask = __osDisableInt();
register u32 modeType = __osViCurr->modep->type;
__osRestoreInt(savedMask);
return modeType;
}
|
413a1ef8cb2e8bec7d0ccae93fca8da787647ea6
|
ffdc77394c5b5532b243cf3c33bd584cbdc65cb7
|
/mindspore/ccsrc/plugin/device/cpu/kernel/nnacl/fp32/power_fp32.h
|
c367f5bf6b79993ef678be6fd42928ebcc0e4220
|
[
"Apache-2.0",
"LicenseRef-scancode-proprietary-license",
"MPL-1.0",
"OpenSSL",
"LGPL-3.0-only",
"LicenseRef-scancode-warranty-disclaimer",
"BSD-3-Clause-Open-MPI",
"MIT",
"MPL-2.0-no-copyleft-exception",
"NTP",
"BSD-3-Clause",
"GPL-1.0-or-later",
"0BSD",
"MPL-2.0",
"LicenseRef-scancode-free-unknown",
"AGPL-3.0-only",
"Libpng",
"MPL-1.1",
"IJG",
"GPL-2.0-only",
"BSL-1.0",
"Zlib",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-python-cwi",
"BSD-2-Clause",
"LicenseRef-scancode-gary-s-brown",
"LGPL-2.1-only",
"LicenseRef-scancode-other-permissive",
"Python-2.0",
"LicenseRef-scancode-mit-nagy",
"LicenseRef-scancode-other-copyleft",
"LicenseRef-scancode-unknown-license-reference",
"Unlicense"
] |
permissive
|
mindspore-ai/mindspore
|
ca7d5bb51a3451c2705ff2e583a740589d80393b
|
54acb15d435533c815ee1bd9f6dc0b56b4d4cf83
|
refs/heads/master
| 2023-07-29T09:17:11.051569
| 2023-07-17T13:14:15
| 2023-07-17T13:14:15
| 239,714,835
| 4,178
| 768
|
Apache-2.0
| 2023-07-26T22:31:11
| 2020-02-11T08:43:48
|
C++
|
UTF-8
|
C
| false
| false
| 1,576
|
h
|
power_fp32.h
|
/**
* Copyright 2020-2021 Huawei Technologies Co., Ltd
*
* 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 MINDSPORE_NNACL_FP32_POWER_FP32_H_
#define MINDSPORE_NNACL_FP32_POWER_FP32_H_
#include <math.h>
#include "nnacl/op_base.h"
#include "nnacl/power_parameter.h"
typedef void (*PowerFun)(const float *, const float *, float *, int, float, float);
typedef float (*PowerScalarFun)(float x, const float *exponent);
#ifdef __cplusplus
extern "C" {
#endif
static inline bool CheckInteger(float f) { return fabsf(f - (int)(f)) < 0.000001; }
static inline float StdPowerScalar(float x, const float *exponent) { return powf(x, *exponent); }
int Power(const float *input, const float *exponent, float *output, int len, float scale, float shift, bool broadcast);
void PowerSingle(const float *input, const float *exponent, float *output, int len, float scale, float shift);
void PowerBroadCast(const float *input, const float *exponent, float *output, int len, float scale, float shift);
#ifdef __cplusplus
}
#endif
#endif // MINDSPORE_NNACL_FP32_POWER_FP32_H_
|
3f70c3ed83e5bfc877df13d872427faa8777c496
|
5ab69c8644a936a3d9dec1669a86c7369c911bf8
|
/arch/cpu/cc2538/dev/pka.h
|
7a63a3d022682cd2ca9314d0f76171f77e3a54cb
|
[
"BSD-3-Clause"
] |
permissive
|
contiki-ng/contiki-ng
|
393d36f68b98f5ee3544ea32502cf662ffb2fe9f
|
31fcaadf7a0dc8ceea07f438cd69db73174879e6
|
refs/heads/develop
| 2023-09-01T20:10:30.000765
| 2023-09-01T14:37:12
| 2023-09-01T14:37:12
| 91,191,972
| 1,242
| 788
|
BSD-3-Clause
| 2023-09-14T19:08:35
| 2017-05-13T17:37:59
|
C
|
UTF-8
|
C
| false
| false
| 52,781
|
h
|
pka.h
|
/*
* Original file:
* Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
* All rights reserved.
*
* Port to Contiki:
* Copyright (c) 2014 Andreas Dröscher <contiki@anticat.ch>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* \addtogroup cc2538
* @{
*
* \defgroup cc2538-pka cc2538 PKA engine
*
* Driver for the cc2538 PKA engine
* @{
*
* \file
* Header file for the cc2538 PKA engine driver
*/
#ifndef PKA_H_
#define PKA_H_
#include "contiki.h"
#include <stdint.h>
/*---------------------------------------------------------------------------*/
/** \name PKA memory
* @{
*/
#define PKA_RAM_BASE 0x44006000 /**< PKA Memory Address */
#define PKA_RAM_SIZE 0x800 /**< PKA Memory Size */
#define PKA_MAX_CURVE_SIZE 12 /**< Define for the maximum curve
size supported by the PKA module
in 32 bit word. */
#define PKA_MAX_LEN 12 /**< Define for the maximum length of
the big number supported by the
PKA module in 32 bit word. */
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA register offsets
* @{
*/
#define PKA_APTR 0x44004000 /**< PKA vector A address During
execution of basic PKCP
operations, this register is
double buffered and can be
written with a new value for the
next operation; when not
written, the value remains
intact. During the execution of
sequencer-controlled complex
operations, this register may
not be written and its value is
undefined at the conclusion of
the operation. The driver
software cannot rely on the
written value to remain intact. */
#define PKA_BPTR 0x44004004 /**< PKA vector B address During
execution of basic PKCP
operations, this register is
double buffered and can be
written with a new value for the
next operation; when not
written, the value remains
intact. During the execution of
sequencer-controlled complex
operations, this register may
not be written and its value is
undefined at the conclusion of
the operation. The driver
software cannot rely on the
written value to remain intact. */
#define PKA_CPTR 0x44004008 /**< PKA vector C address During
execution of basic PKCP
operations, this register is
double buffered and can be
written with a new value for the
next operation; when not
written, the value remains
intact. During the execution of
sequencer-controlled complex
operations, this register may
not be written and its value is
undefined at the conclusion of
the operation. The driver
software cannot rely on the
written value to remain intact. */
#define PKA_DPTR 0x4400400C /**< PKA vector D address During
execution of basic PKCP
operations, this register is
double buffered and can be
written with a new value for the
next operation; when not
written, the value remains
intact. During the execution of
sequencer-controlled complex
operations, this register may
not be written and its value is
undefined at the conclusion of
the operation. The driver
software cannot rely on the
written value to remain intact. */
#define PKA_ALENGTH 0x44004010 /**< PKA vector A length During
execution of basic PKCP
operations, this register is
double buffered and can be
written with a new value for the
next operation; when not
written, the value remains
intact. During the execution of
sequencer-controlled complex
operations, this register may
not be written and its value is
undefined at the conclusion of
the operation. The driver
software cannot rely on the
written value to remain intact. */
#define PKA_BLENGTH 0x44004014 /**< PKA vector B length During
execution of basic PKCP
operations, this register is
double buffered and can be
written with a new value for the
next operation; when not
written, the value remains
intact. During the execution of
sequencer-controlled complex
operations, this register may
not be written and its value is
undefined at the conclusion of
the operation. The driver
software cannot rely on the
written value to remain intact. */
#define PKA_SHIFT 0x44004018 /**< PKA bit shift value For basic
PKCP operations, modifying the
contents of this register is
made impossible while the
operation is being performed.
For the ExpMod-variable and
ExpMod-CRT operations, this
register is used to indicate the
number of odd powers to use
(directly as a value in the
range 1-16). For the ModInv and
ECC operations, this register is
used to hold a completion code. */
#define PKA_FUNCTION 0x4400401C /**< PKA function This register
contains the control bits to
start basic PKCP as well as
complex sequencer operations.
The run bit can be used to poll
for the completion of the
operation. Modifying bits [11:0]
is made impossible during the
execution of a basic PKCP
operation. During the execution
of sequencer-controlled complex
operations, this register is
modified; the run and stall
result bits are set to zero at
the conclusion, but other bits
are undefined. Attention:
Continuously reading this
register to poll the run bit is
not allowed when executing
complex sequencer operations
(the sequencer cannot access the
PKCP when this is done). Leave
at least one sysclk cycle
between poll operations. */
#define PKA_COMPARE 0x44004020 /**< PKA compare result This
register provides the result of
a basic PKCP compare operation.
It is updated when the run bit
in the PKA_FUNCTION register is
reset at the end of that
operation. Status after a
complex sequencer operation is
unknown */
#define PKA_MSW 0x44004024 /**< PKA most-significant-word of
result vector This register
indicates the (word) address in
the PKA RAM where the most
significant nonzero 32-bit word
of the result is stored. Should
be ignored for modulo
operations. For basic PKCP
operations, this register is
updated when the run bit in the
PKA_FUNCTION register is reset
at the end of the operation. For
the complex-sequencer controlled
operations, updating of the
final value matching the actual
result is done near the end of
the operation; note that the
result is only meaningful if no
errors were detected and that
for ECC operations, the PKA_MSW
register will provide
information for the x-coordinate
of the result point only. */
#define PKA_DIVMSW 0x44004028 /**< PKA most-significant-word of
divide remainder This register
indicates the (32-bit word)
address in the PKA RAM where the
most significant nonzero 32-bit
word of the remainder result for
the basic divide and modulo
operations is stored. Bits [4:0]
are loaded with the bit number
of the most-significant nonzero
bit in the most-significant
nonzero word when MS one control
bit is set. For divide, modulo,
and MS one reporting, this
register is updated when the RUN
bit in the PKA_FUNCTION register
is reset at the end of the
operation. For the complex
sequencer controlled operations,
updating of bits [4:0] of this
register with the
most-significant bit location of
the actual result is done near
the end of the operation. The
result is meaningful only if no
errors were detected and that
for ECC operations; the
PKA_DIVMSW register provides
information for the x-coordinate
of the result point only. */
#define PKA_SEQ_CTRL 0x440040C8 /**< PKA sequencer control and
status register The sequencer is
interfaced with the outside
world through a single control
and status register. With the
exception of bit [31], the
actual use of bits in the
separate sub-fields of this
register is determined by the
sequencer firmware. This
register need only be accessed
when the sequencer program is
stored in RAM. The reset value
of the RESTE bit depends upon
the option chosen for sequencer
program storage. */
#define PKA_OPTIONS 0x440040F4 /**< PKA hardware options register
This register provides the host
with a means to determine the
hardware configuration
implemented in this PKA engine,
focused on options that have an
effect on software interacting
with the module. Note: (32 x
(1st LNME nr. of PEs + 1st LNME
FIFO RAM depth - 10)) equals the
maximum modulus vector length
(in bits) that can be handled by
the modular exponentiation and
ECC operations executed on a PKA
engine that includes an LNME. */
#define PKA_SW_REV 0x440040F8 /**< PKA firmware revision and
capabilities register This
register allows the host access
to the internal firmware
revision number of the PKA
Engine for software driver
matching and diagnostic
purposes. This register also
contains a field that encodes
the capabilities of the embedded
firmware. The PKA_SW_REV
register is written by the
firmware within a few clock
cycles after starting up that
firmware. The hardware reset
value is zero, indicating that
the information has not been
written yet. */
#define PKA_REVISION 0x440040FC /**< PKA hardware revision register
This register allows the host
access to the hardware revision
number of the PKA engine for
software driver matching and
diagnostic purposes. It is
always located at the highest
address in the access space of
the module and contains an
encoding of the EIP number (with
its complement as signature) for
recognition of the hardware
module. */
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_APTR register registers bit fields
* @{
*/
#define PKA_APTR_APTR_M 0x000007FF /**< This register specifies the
location of vector A within the
PKA RAM. Vectors are identified
through the location of their
least-significant 32-bit word.
Note that bit [0] must be zero
to ensure that the vector starts
at an 8-byte boundary. */
#define PKA_APTR_APTR_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_BPTR register registers bit fields
* @{
*/
#define PKA_BPTR_BPTR_M 0x000007FF /**< This register specifies the
location of vector B within the
PKA RAM. Vectors are identified
through the location of their
least-significant 32-bit word.
Note that bit [0] must be zero
to ensure that the vector starts
at an 8-byte boundary. */
#define PKA_BPTR_BPTR_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_CPTR register registers bit fields
* @{
*/
#define PKA_CPTR_CPTR_M 0x000007FF /**< This register specifies the
location of vector C within the
PKA RAM. Vectors are identified
through the location of their
least-significant 32-bit word.
Note that bit [0] must be zero
to ensure that the vector starts
at an 8-byte boundary. */
#define PKA_CPTR_CPTR_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_DPTR register registers bit fields
* @{
*/
#define PKA_DPTR_DPTR_M 0x000007FF /**< This register specifies the
location of vector D within the
PKA RAM. Vectors are identified
through the location of their
least-significant 32-bit word.
Note that bit [0] must be zero
to ensure that the vector starts
at an 8-byte boundary. */
#define PKA_DPTR_DPTR_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_ALENGTH register registers bit fields
* @{
*/
#define PKA_ALENGTH_ALENGTH_M 0x000001FF /**< This register specifies the
length (in 32-bit words) of
Vector A. */
#define PKA_ALENGTH_ALENGTH_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_BLENGTH register registers bit fields
* @{
*/
#define PKA_BLENGTH_BLENGTH_M 0x000001FF /**< This register specifies the
length (in 32-bit words) of
Vector B. */
#define PKA_BLENGTH_BLENGTH_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_SHIFT register registers bit fields
* @{
*/
#define PKA_SHIFT_NUM_BITS_TO_SHIFT_M \
0x0000001F /**< This register specifies the
number of bits to shift the
input vector (in the range 0-31)
during a Rshift or Lshift
operation. */
#define PKA_SHIFT_NUM_BITS_TO_SHIFT_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_FUNCTION register registers bit fields
* @{
*/
#define PKA_FUNCTION_STALL_RESULT \
0x01000000 /**< When written with a 1b,
updating of the PKA_COMPARE,
PKA_MSW and PKA_DIVMSW
registers, as well as resetting
the run bit is stalled beyond
the point that a running
operation is actually finished.
Use this to allow software
enough time to read results from
a previous operation when the
newly started operation is known
to take only a short amount of
time. If a result is waiting,
the result registers is updated
and the run bit is reset in the
clock cycle following writing
the stall result bit back to 0b.
The Stall result function may
only be used for basic PKCP
operations. */
#define PKA_FUNCTION_STALL_RESULT_M \
0x01000000
#define PKA_FUNCTION_STALL_RESULT_S 24
#define PKA_FUNCTION_RUN 0x00008000 /**< The host sets this bit to
instruct the PKA module to begin
processing the basic PKCP or
complex sequencer operation.
This bit is reset low
automatically when the operation
is complete. The complement of
this bit is output as
interrupts[1]. After a reset,
the run bit is always set to 1b.
Depending on the option, program
ROM or program RAM, the
following applies: Program ROM -
The first sequencer instruction
sets the bit to 0b. This is done
immediately after the hardware
reset is released. Program RAM -
The sequencer must set the bit
to 0b. As a valid firmware may
not have been loaded, the
sequencer is held in software
reset after the hardware reset
is released (the reset bit in
PKA_SEQ_CRTL is set to 1b).
After the FW image is loaded and
the Reset bit is cleared, the
sequencer starts to execute the
FW. The first instruction clears
the run bit. In both cases a few
clock cycles are needed before
the first instruction is
executed and the run bit state
has been propagated. */
#define PKA_FUNCTION_RUN_M 0x00008000
#define PKA_FUNCTION_RUN_S 15
#define PKA_FUNCTION_SEQUENCER_OPERATIONS_M \
0x00007000 /**< These bits select the complex
sequencer operation to perform:
000b: None 001b: ExpMod-CRT
010b: ExpMod-ACT4 (compatible
with EIP2315) 011b: ECC-ADD (if
available in firmware, otherwise
reserved) 100b: ExpMod-ACT2
(compatible with EIP2316) 101b:
ECC-MUL (if available in
firmware, otherwise reserved)
110b: ExpMod-variable 111b:
ModInv (if available in
firmware, otherwise reserved)
The encoding of these operations
is determined by sequencer
firmware. */
#define PKA_FUNCTION_SEQUENCER_OPERATIONS_S 12
#define PKA_FUNCTION_COPY 0x00000800 /**< Perform copy operation */
#define PKA_FUNCTION_COPY_M 0x00000800
#define PKA_FUNCTION_COPY_S 11
#define PKA_FUNCTION_COMPARE 0x00000400 /**< Perform compare operation */
#define PKA_FUNCTION_COMPARE_M 0x00000400
#define PKA_FUNCTION_COMPARE_S 10
#define PKA_FUNCTION_MODULO 0x00000200 /**< Perform modulo operation */
#define PKA_FUNCTION_MODULO_M 0x00000200
#define PKA_FUNCTION_MODULO_S 9
#define PKA_FUNCTION_DIVIDE 0x00000100 /**< Perform divide operation */
#define PKA_FUNCTION_DIVIDE_M 0x00000100
#define PKA_FUNCTION_DIVIDE_S 8
#define PKA_FUNCTION_LSHIFT 0x00000080 /**< Perform left shift operation */
#define PKA_FUNCTION_LSHIFT_M 0x00000080
#define PKA_FUNCTION_LSHIFT_S 7
#define PKA_FUNCTION_RSHIFT 0x00000040 /**< Perform right shift operation */
#define PKA_FUNCTION_RSHIFT_M 0x00000040
#define PKA_FUNCTION_RSHIFT_S 6
#define PKA_FUNCTION_SUBTRACT 0x00000020 /**< Perform subtract operation */
#define PKA_FUNCTION_SUBTRACT_M 0x00000020
#define PKA_FUNCTION_SUBTRACT_S 5
#define PKA_FUNCTION_ADD 0x00000010 /**< Perform add operation */
#define PKA_FUNCTION_ADD_M 0x00000010
#define PKA_FUNCTION_ADD_S 4
#define PKA_FUNCTION_MS_ONE 0x00000008 /**< Loads the location of the Most
Significant one bit within the
result word indicated in the
PKA_MSW register into bits [4:0]
of the PKA_DIVMSW register - can
only be used with basic PKCP
operations, except for Divide,
Modulo and Compare. */
#define PKA_FUNCTION_MS_ONE_M 0x00000008
#define PKA_FUNCTION_MS_ONE_S 3
#define PKA_FUNCTION_ADDSUB 0x00000002 /**< Perform combined add/subtract
operation */
#define PKA_FUNCTION_ADDSUB_M 0x00000002
#define PKA_FUNCTION_ADDSUB_S 1
#define PKA_FUNCTION_MULTIPLY 0x00000001 /**< Perform multiply operation */
#define PKA_FUNCTION_MULTIPLY_M 0x00000001
#define PKA_FUNCTION_MULTIPLY_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_COMPARE register registers bit fields
* @{
*/
#define PKA_COMPARE_A_GREATER_THAN_B \
0x00000004 /**< Vector_A is greater than
Vector_B */
#define PKA_COMPARE_A_GREATER_THAN_B_M \
0x00000004
#define PKA_COMPARE_A_GREATER_THAN_B_S 2
#define PKA_COMPARE_A_LESS_THAN_B \
0x00000002 /**< Vector_A is less than Vector_B */
#define PKA_COMPARE_A_LESS_THAN_B_M \
0x00000002
#define PKA_COMPARE_A_LESS_THAN_B_S 1
#define PKA_COMPARE_A_EQUALS_B 0x00000001 /**< Vector_A is equal to Vector_B */
#define PKA_COMPARE_A_EQUALS_B_M \
0x00000001
#define PKA_COMPARE_A_EQUALS_B_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_MSW register registers bit fields
* @{
*/
#define PKA_MSW_RESULT_IS_ZERO 0x00008000 /**< The result vector is all
zeroes, ignore the address
returned in bits [10:0] */
#define PKA_MSW_RESULT_IS_ZERO_M \
0x00008000
#define PKA_MSW_RESULT_IS_ZERO_S 15
#define PKA_MSW_MSW_ADDRESS_M 0x000007FF /**< Address of the most-significant
nonzero 32-bit word of the
result vector in PKA RAM */
#define PKA_MSW_MSW_ADDRESS_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_DIVMSW register registers bit fields
* @{
*/
#define PKA_DIVMSW_RESULT_IS_ZERO \
0x00008000 /**< The result vector is all
zeroes, ignore the address
returned in bits [10:0] */
#define PKA_DIVMSW_RESULT_IS_ZERO_M \
0x00008000
#define PKA_DIVMSW_RESULT_IS_ZERO_S 15
#define PKA_DIVMSW_MSW_ADDRESS_M \
0x000007FF /**< Address of the most significant
nonzero 32-bit word of the
remainder result vector in PKA
RAM */
#define PKA_DIVMSW_MSW_ADDRESS_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_SEQ_CTRL register registers bit fields
* @{
*/
#define PKA_SEQ_CTRL_RESET 0x80000000 /**< Option program ROM: Reset value
= 0. Read/Write, reset value 0b
(ZERO). Writing 1b resets the
sequencer, write to 0b to
restart operations again. As the
reset value is 0b, the sequencer
will automatically start
operations executing from
program ROM. This bit should
always be written with zero and
ignored when reading this
register. Option Program RAM:
Reset value =1. Read/Write,
reset value 1b (ONE). When 1b,
the sequencer is held in a reset
state and the PKA_PROGRAM area
is accessible for loading the
sequencer program (while the
PKA_DATA_RAM is inaccessible),
write to 0b to (re)start
sequencer operations and disable
PKA_PROGRAM area accessibility
(also enables the PKA_DATA_RAM
accesses). Resetting the
sequencer (in order to load
other firmware) should only be
done when the PKA Engine is not
performing any operations (i.e.
the run bit in the PKA_FUNCTION
register should be zero). */
#define PKA_SEQ_CTRL_RESET_M 0x80000000
#define PKA_SEQ_CTRL_RESET_S 31
#define PKA_SEQ_CTRL_SEQUENCER_STATUS_M \
0x0000FF00 /**< These read-only bits can be
used by the sequencer to
communicate status to the
outside world. Bit [8] is also
used as sequencer interrupt,
with the complement of this bit
ORed into the run bit in
PKA_FUNCTION. This field should
always be written with zeroes
and ignored when reading this
register. */
#define PKA_SEQ_CTRL_SEQUENCER_STATUS_S 8
#define PKA_SEQ_CTRL_SW_CONTROL_STATUS_M \
0x000000FF /**< These bits can be used by
software to trigger sequencer
operations. External logic can
set these bits by writing 1b,
cannot reset them by writing 0b.
The sequencer can reset these
bits by writing 0b, cannot set
them by writing 1b. Setting the
run bit in PKA_FUNCTION together
with a nonzero sequencer
operations field automatically
sets bit [0] here. This field
should always be written with
zeroes and ignored when reading
this register. */
#define PKA_SEQ_CTRL_SW_CONTROL_STATUS_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_OPTIONS register registers bit fields
* @{
*/
#define PKA_OPTIONS_FIRST_LNME_FIFO_DEPTH_M \
0xFF000000 /**< Number of words in the first
LNME's FIFO RAM Should be
ignored if LNME configuration is
0. The contents of this field
indicate the actual depth as
selected by the LNME FIFO RAM
size strap input, fifo_size_sel.
Note: Reset value is undefined */
#define PKA_OPTIONS_FIRST_LNME_FIFO_DEPTH_S 24
#define PKA_OPTIONS_FIRST_LNME_NR_OF_PES_M \
0x003F0000 /**< Number of processing elements
in the pipeline of the first
LNME Should be ignored if LNME
configuration is 0. Note: Reset
value is undefined. */
#define PKA_OPTIONS_FIRST_LNME_NR_OF_PES_S 16
#define PKA_OPTIONS_MMM3A 0x00001000 /**< Reserved for a future
functional extension to the LNME
Always 0b */
#define PKA_OPTIONS_MMM3A_M 0x00001000
#define PKA_OPTIONS_MMM3A_S 12
#define PKA_OPTIONS_INT_MASKING 0x00000800 /**< Value 0b indicates that the
main interrupt output (bit [1]
of the interrupts output bus) is
the direct complement of the run
bit in the PKA_CONTROL register,
value 1b indicates that
interrupt masking logic is
present for this output. Note:
Reset value is undefined */
#define PKA_OPTIONS_INT_MASKING_M \
0x00000800
#define PKA_OPTIONS_INT_MASKING_S 11
#define PKA_OPTIONS_PROTECTION_OPTION_M \
0x00000700 /**< Value 0 indicates no additional
protection against side channel
attacks, value 1 indicates the
SCAP option, value 3 indicates
the PROT option; other values
are reserved. Note: Reset value
is undefined */
#define PKA_OPTIONS_PROTECTION_OPTION_S 8
#define PKA_OPTIONS_PROGRAM_RAM 0x00000080 /**< Value 1b indicates sequencer
program storage in RAM, value 0b
in ROM. Note: Reset value is
undefined */
#define PKA_OPTIONS_PROGRAM_RAM_M \
0x00000080
#define PKA_OPTIONS_PROGRAM_RAM_S 7
#define PKA_OPTIONS_SEQUENCER_CONFIGURATION_M \
0x00000060 /**< Value 1 indicates a standard
sequencer; other values are
reserved. */
#define PKA_OPTIONS_SEQUENCER_CONFIGURATION_S 5
#define PKA_OPTIONS_LNME_CONFIGURATION_M \
0x0000001C /**< Value 0 indicates NO LNME,
value 1 indicates one standard
LNME (with alpha = 32, beta =
8); other values reserved. Note:
Reset value is undefined */
#define PKA_OPTIONS_LNME_CONFIGURATION_S 2
#define PKA_OPTIONS_PKCP_CONFIGURATION_M \
0x00000003 /**< Value 1 indicates a PKCP with a
16x16 multiplier, value 2
indicates a PKCP with a 32x32
multiplier, other values
reserved. Note: Reset value is
undefined. */
#define PKA_OPTIONS_PKCP_CONFIGURATION_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_SW_REV register registers bit fields
* @{
*/
#define PKA_SW_REV_FW_CAPABILITIES_M \
0xF0000000 /**< 4-bit binary encoding for the
functionality implemented in the
firmware. Value 0 indicates
basic ModExp with/without CRT.
Value 1 adds Modular Inversion,
value 2 adds Modular Inversion
and ECC operations. Values 3-15
are reserved. */
#define PKA_SW_REV_FW_CAPABILITIES_S 28
#define PKA_SW_REV_MAJOR_FW_REVISION_M \
0x0F000000 /**< 4-bit binary encoding of the
major firmware revision number */
#define PKA_SW_REV_MAJOR_FW_REVISION_S 24
#define PKA_SW_REV_MINOR_FW_REVISION_M \
0x00F00000 /**< 4-bit binary encoding of the
minor firmware revision number */
#define PKA_SW_REV_MINOR_FW_REVISION_S 20
#define PKA_SW_REV_FW_PATCH_LEVEL_M \
0x000F0000 /**< 4-bit binary encoding of the
firmware patch level, initial
release will carry value zero
Patches are used to remove bugs
without changing the
functionality or interface of a
module. */
#define PKA_SW_REV_FW_PATCH_LEVEL_S 16
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA_REVISION register registers bit fields
* @{
*/
#define PKA_REVISION_MAJOR_HW_REVISION_M \
0x0F000000 /**< 4-bit binary encoding of the
major hardware revision number */
#define PKA_REVISION_MAJOR_HW_REVISION_S 24
#define PKA_REVISION_MINOR_HW_REVISION_M \
0x00F00000 /**< 4-bit binary encoding of the
minor hardware revision number */
#define PKA_REVISION_MINOR_HW_REVISION_S 20
#define PKA_REVISION_HW_PATCH_LEVEL_M \
0x000F0000 /**< 4-bit binary encoding of the
hardware patch level, initial
release will carry value zero
Patches are used to remove bugs
without changing the
functionality or interface of a
module. */
#define PKA_REVISION_HW_PATCH_LEVEL_S 16
#define PKA_REVISION_COMPLEMENT_OF_BASIC_EIP_NUMBER_M \
0x0000FF00 /**< Bit-by-bit logic complement of
bits [7:0], EIP-28 gives 0xE3 */
#define PKA_REVISION_COMPLEMENT_OF_BASIC_EIP_NUMBER_S 8
#define PKA_REVISION_BASIC_EIP_NUMBER_M \
0x000000FF /**< 8-bit binary encoding of the
EIP number, EIP-28 gives 0x1C */
#define PKA_REVISION_BASIC_EIP_NUMBER_S 0
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA driver return codes
* @{
*/
#define PKA_STATUS_SUCCESS 0 /**< Success */
#define PKA_STATUS_FAILURE 1 /**< Failure */
#define PKA_STATUS_INVALID_PARAM 2 /**< Invalid parameter */
#define PKA_STATUS_BUF_UNDERFLOW 3 /**< Buffer underflow */
#define PKA_STATUS_RESULT_0 4 /**< Result is all zeros */
#define PKA_STATUS_A_GR_B 5 /**< Big number compare return status if
the first big num is greater than
the second. */
#define PKA_STATUS_A_LT_B 6 /**< Big number compare return status if
the first big num is less than the
second. */
#define PKA_STATUS_OPERATION_INPRG 7 /**< PKA operation is in progress. */
#define PKA_STATUS_OPERATION_NOT_INPRG 8 /**< No PKA operation is in progress. */
#define PKA_STATUS_SIGNATURE_INVALID 9 /**< Signature is invalid. */
/** @} */
/*---------------------------------------------------------------------------*/
/** \name PKA functions
* @{
*/
/** \brief Enables and resets the PKA engine
*/
void pka_init(void);
/** \brief Enables the PKA engine
*/
void pka_enable(void);
/** \brief Disables the PKA engine
* \note Call this function to save power when the engine is unused.
*/
void pka_disable(void);
/** \brief Checks the status of the PKA engine operation
* \retval false Result not yet available, and no error occurred
* \retval true Result available, or error occurred
*/
uint8_t pka_check_status(void);
/** \brief Registers a process to be notified of the completion of a PKA
* operation
* \param p Process to be polled upon IRQ
* \note This function is only supposed to be called by the PKA drivers.
*/
void pka_register_process_notification(struct process *p);
/** @} */
#endif /* PKA_H_ */
/**
* @}
* @}
*/
|
95becca9132b4e4742953529a25c3d355855e7e9
|
6f8a060973c7a12316e14b4de80ca38de745fd40
|
/clang_delta/tests/empty-struct-to-int/test3.c
|
b196a00b158409b7b3e7f5620646ee3ad4ef77a4
|
[
"NCSA",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
csmith-project/creduce
|
f88cd0ea5a01ff5d75ef43c460ce762392e14076
|
92502474f38e37d17a3404ea69fb4b6bb42b4233
|
refs/heads/master
| 2023-06-21T12:39:00.661693
| 2023-06-08T08:21:57
| 2023-06-08T08:21:57
| 3,572,572
| 918
| 118
|
NOASSERTION
| 2023-06-08T08:20:58
| 2012-02-28T15:55:07
|
C++
|
UTF-8
|
C
| false
| false
| 246
|
c
|
test3.c
|
// RUN: %clang_delta --transformation=empty-struct-to-int --counter=1 %s 2>&1 | %remove_lit_checks | FileCheck %s
// CHECK-NOT: struct S
struct S;
// CHECK: int *s;
struct S *s;
// CHECK-NOT: struct S
struct S {
// CHECK-NOT: int i
int i;
};
|
ae6ced14ac95b11443aed85e736473a25dd92988
|
9e50ffd3ec7300e541a2e985193916badd8c07f2
|
/Example_oc/Pods/Headers/Private/Specta/SpectaDSL.h
|
fd1ad3756823e464cd1a2f24bd64b5381e9d4a05
|
[
"MIT"
] |
permissive
|
zhenglibao/FlexLib
|
cbc03d6e20933ee94a81e64ace2fa36c0b91e064
|
ca67797970aed6a41817f643741a0f62e57da34b
|
refs/heads/master
| 2023-05-02T03:30:13.829384
| 2023-04-13T07:34:05
| 2023-04-13T07:34:05
| 113,294,355
| 1,732
| 288
|
MIT
| 2021-05-06T06:14:56
| 2017-12-06T09:13:46
|
Objective-C
|
UTF-8
|
C
| false
| false
| 41
|
h
|
SpectaDSL.h
|
../../../Specta/Specta/Specta/SpectaDSL.h
|
219cc0cdb1598b7594c76c239ae0e3380421f8d4
|
2c73a693c2b3c162eae2ab94f649d8c4494878ba
|
/components/lvgl/gen/lv_widgets/luat_lv_canvas.c
|
d4a89256344d76c735c69c60667fa5d5c6379026
|
[
"MIT"
] |
permissive
|
openLuat/LuatOS
|
185e1e140aed908434168133571ddcafe98f4e12
|
4b29d5121ab4f7133630331e8502c526c7856897
|
refs/heads/master
| 2023-08-23T04:57:23.263539
| 2023-08-23T04:46:46
| 2023-08-23T04:46:46
| 230,403,844
| 378
| 93
|
MIT
| 2021-12-17T02:19:30
| 2019-12-27T08:29:19
|
C
|
UTF-8
|
C
| false
| false
| 7,678
|
c
|
luat_lv_canvas.c
|
#include "luat_base.h"
#include "lvgl.h"
#include "luat_lvgl.h"
// lv_obj_t* lv_canvas_create(lv_obj_t* par, lv_obj_t* copy)
int luat_lv_canvas_create(lua_State *L) {
LV_DEBUG("CALL lv_canvas_create");
lv_obj_t* par = (lv_obj_t*)lua_touserdata(L, 1);
lv_obj_t* copy = (lv_obj_t*)lua_touserdata(L, 2);
lv_obj_t* ret = NULL;
ret = lv_canvas_create(par ,copy);
if (ret) lua_pushlightuserdata(L, ret); else lua_pushnil(L);
return 1;
}
// void lv_canvas_set_px(lv_obj_t* canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
int luat_lv_canvas_set_px(lua_State *L) {
LV_DEBUG("CALL lv_canvas_set_px");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 2);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 3);
lv_color_t c = {0};
c.full = luaL_checkinteger(L, 4);
lv_canvas_set_px(canvas ,x ,y ,c);
return 0;
}
// void lv_canvas_set_palette(lv_obj_t* canvas, uint8_t id, lv_color_t c)
int luat_lv_canvas_set_palette(lua_State *L) {
LV_DEBUG("CALL lv_canvas_set_palette");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
uint8_t id = (uint8_t)luaL_checkinteger(L, 2);
lv_color_t c = {0};
c.full = luaL_checkinteger(L, 3);
lv_canvas_set_palette(canvas ,id ,c);
return 0;
}
// lv_color_t lv_canvas_get_px(lv_obj_t* canvas, lv_coord_t x, lv_coord_t y)
int luat_lv_canvas_get_px(lua_State *L) {
LV_DEBUG("CALL lv_canvas_get_px");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 2);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 3);
lv_color_t ret;
ret = lv_canvas_get_px(canvas ,x ,y);
lua_pushinteger(L, ret.full);
return 1;
}
// lv_img_dsc_t* lv_canvas_get_img(lv_obj_t* canvas)
int luat_lv_canvas_get_img(lua_State *L) {
LV_DEBUG("CALL lv_canvas_get_img");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_img_dsc_t* ret = NULL;
ret = lv_canvas_get_img(canvas);
if (ret) lua_pushlightuserdata(L, ret); else lua_pushnil(L);
return 1;
}
// void lv_canvas_copy_buf(lv_obj_t* canvas, void* to_copy, lv_coord_t x, lv_coord_t y, lv_coord_t w, lv_coord_t h)
int luat_lv_canvas_copy_buf(lua_State *L) {
LV_DEBUG("CALL lv_canvas_copy_buf");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
void* to_copy = (void*)lua_touserdata(L, 2);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 3);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 4);
lv_coord_t w = (lv_coord_t)luaL_checknumber(L, 5);
lv_coord_t h = (lv_coord_t)luaL_checknumber(L, 6);
lv_canvas_copy_buf(canvas ,to_copy ,x ,y ,w ,h);
return 0;
}
// void lv_canvas_transform(lv_obj_t* canvas, lv_img_dsc_t* img, int16_t angle, uint16_t zoom, lv_coord_t offset_x, lv_coord_t offset_y, int32_t pivot_x, int32_t pivot_y, bool antialias)
int luat_lv_canvas_transform(lua_State *L) {
LV_DEBUG("CALL lv_canvas_transform");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_img_dsc_t* img = (lv_img_dsc_t*)lua_touserdata(L, 2);
int16_t angle = (int16_t)luaL_checkinteger(L, 3);
uint16_t zoom = (uint16_t)luaL_checkinteger(L, 4);
lv_coord_t offset_x = (lv_coord_t)luaL_checknumber(L, 5);
lv_coord_t offset_y = (lv_coord_t)luaL_checknumber(L, 6);
int32_t pivot_x = (int32_t)luaL_checkinteger(L, 7);
int32_t pivot_y = (int32_t)luaL_checkinteger(L, 8);
bool antialias = (bool)lua_toboolean(L, 9);
lv_canvas_transform(canvas ,img ,angle ,zoom ,offset_x ,offset_y ,pivot_x ,pivot_y ,antialias);
return 0;
}
// void lv_canvas_blur_hor(lv_obj_t* canvas, lv_area_t* area, uint16_t r)
int luat_lv_canvas_blur_hor(lua_State *L) {
LV_DEBUG("CALL lv_canvas_blur_hor");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_area_t* area = (lv_area_t*)lua_touserdata(L, 2);
uint16_t r = (uint16_t)luaL_checkinteger(L, 3);
lv_canvas_blur_hor(canvas ,area ,r);
return 0;
}
// void lv_canvas_blur_ver(lv_obj_t* canvas, lv_area_t* area, uint16_t r)
int luat_lv_canvas_blur_ver(lua_State *L) {
LV_DEBUG("CALL lv_canvas_blur_ver");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_area_t* area = (lv_area_t*)lua_touserdata(L, 2);
uint16_t r = (uint16_t)luaL_checkinteger(L, 3);
lv_canvas_blur_ver(canvas ,area ,r);
return 0;
}
// void lv_canvas_fill_bg(lv_obj_t* canvas, lv_color_t color, lv_opa_t opa)
int luat_lv_canvas_fill_bg(lua_State *L) {
LV_DEBUG("CALL lv_canvas_fill_bg");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_color_t color = {0};
color.full = luaL_checkinteger(L, 2);
lv_opa_t opa = (lv_opa_t)luaL_checknumber(L, 3);
lv_canvas_fill_bg(canvas ,color ,opa);
return 0;
}
// void lv_canvas_draw_rect(lv_obj_t* canvas, lv_coord_t x, lv_coord_t y, lv_coord_t w, lv_coord_t h, lv_draw_rect_dsc_t* rect_dsc)
int luat_lv_canvas_draw_rect(lua_State *L) {
LV_DEBUG("CALL lv_canvas_draw_rect");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 2);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 3);
lv_coord_t w = (lv_coord_t)luaL_checknumber(L, 4);
lv_coord_t h = (lv_coord_t)luaL_checknumber(L, 5);
lv_draw_rect_dsc_t* rect_dsc = (lv_draw_rect_dsc_t*)lua_touserdata(L, 6);
lv_canvas_draw_rect(canvas ,x ,y ,w ,h ,rect_dsc);
return 0;
}
// void lv_canvas_draw_text(lv_obj_t* canvas, lv_coord_t x, lv_coord_t y, lv_coord_t max_w, lv_draw_label_dsc_t* label_draw_dsc, char* txt, lv_label_align_t align)
int luat_lv_canvas_draw_text(lua_State *L) {
LV_DEBUG("CALL lv_canvas_draw_text");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 2);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 3);
lv_coord_t max_w = (lv_coord_t)luaL_checknumber(L, 4);
lv_draw_label_dsc_t* label_draw_dsc = (lv_draw_label_dsc_t*)lua_touserdata(L, 5);
char* txt = (char*)luaL_checkstring(L, 6);
lv_label_align_t align = (lv_label_align_t)luaL_checkinteger(L, 7);
lv_canvas_draw_text(canvas ,x ,y ,max_w ,label_draw_dsc ,txt ,align);
return 0;
}
// void lv_canvas_draw_img(lv_obj_t* canvas, lv_coord_t x, lv_coord_t y, void* src, lv_draw_img_dsc_t* img_draw_dsc)
int luat_lv_canvas_draw_img(lua_State *L) {
LV_DEBUG("CALL lv_canvas_draw_img");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 2);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 3);
void* src = (void*)lua_touserdata(L, 4);
lv_draw_img_dsc_t* img_draw_dsc = (lv_draw_img_dsc_t*)lua_touserdata(L, 5);
lv_canvas_draw_img(canvas ,x ,y ,src ,img_draw_dsc);
return 0;
}
// void lv_canvas_draw_arc(lv_obj_t* canvas, lv_coord_t x, lv_coord_t y, lv_coord_t r, int32_t start_angle, int32_t end_angle, lv_draw_line_dsc_t* arc_draw_dsc)
int luat_lv_canvas_draw_arc(lua_State *L) {
LV_DEBUG("CALL lv_canvas_draw_arc");
lv_obj_t* canvas = (lv_obj_t*)lua_touserdata(L, 1);
lv_coord_t x = (lv_coord_t)luaL_checknumber(L, 2);
lv_coord_t y = (lv_coord_t)luaL_checknumber(L, 3);
lv_coord_t r = (lv_coord_t)luaL_checknumber(L, 4);
int32_t start_angle = (int32_t)luaL_checkinteger(L, 5);
int32_t end_angle = (int32_t)luaL_checkinteger(L, 6);
lv_draw_line_dsc_t* arc_draw_dsc = (lv_draw_line_dsc_t*)lua_touserdata(L, 7);
lv_canvas_draw_arc(canvas ,x ,y ,r ,start_angle ,end_angle ,arc_draw_dsc);
return 0;
}
|
3aea3dfead4b873cb7b6d3402e4acf1925c378c3
|
505585f1d89447adea3f9519f12255602acdb1b2
|
/src/arkode/fcmix/farkdense.c
|
08b7e28c1d1b3fc6aac72dabff5d263531be1d59
|
[
"BSD-3-Clause"
] |
permissive
|
LLNL/sundials
|
11a879f8c8e7a5e40d78d13d0f9baed04d37a280
|
1ea097bb3bce207335ac35f0b5e78df5d71c6409
|
refs/heads/main
| 2023-08-31T12:36:23.500757
| 2023-07-20T16:50:46
| 2023-07-20T16:50:46
| 105,918,649
| 396
| 120
|
BSD-3-Clause
| 2023-09-14T20:38:05
| 2017-10-05T17:20:03
|
C
|
UTF-8
|
C
| false
| false
| 2,977
|
c
|
farkdense.c
|
/*---------------------------------------------------------------
* Programmer(s): Daniel R. Reynolds @ SMU
*---------------------------------------------------------------
* SUNDIALS Copyright Start
* Copyright (c) 2002-2023, Lawrence Livermore National Security
* and Southern Methodist University.
* All rights reserved.
*
* See the top-level LICENSE and NOTICE files for details.
*
* SPDX-License-Identifier: BSD-3-Clause
* SUNDIALS Copyright End
*---------------------------------------------------------------
* Fortran/C interface routines for ARKODE/ARKLS, for the case
* of a user-supplied Jacobian approximation routine.
*--------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include "farkode.h"
#include "arkode_impl.h"
#include <arkode/arkode_arkstep.h>
#include <sunmatrix/sunmatrix_dense.h>
/*=============================================================*/
/* Prototype of the Fortran routine */
#ifdef __cplusplus /* wrapper to enable C++ usage */
extern "C" {
#endif
extern void FARK_DJAC(long int *N, realtype *T, realtype *Y,
realtype *FY, realtype *DJAC,
realtype *H, long int *IPAR,
realtype *RPAR, realtype *V1,
realtype *V2, realtype *V3, int *ier);
#ifdef __cplusplus
}
#endif
/*=============================================================*/
/* Fortran interface to C routine ARKStepSetJacFn; see
farkode.h for additional information */
void FARK_DENSESETJAC(int *flag, int *ier)
{
if (*flag == 0) {
*ier = ARKStepSetJacFn(ARK_arkodemem, NULL);
} else {
*ier = ARKStepSetJacFn(ARK_arkodemem, FARKDenseJac);
}
return;
}
/*=============================================================*/
/* C interface to user-supplied Fortran routine FARKDJAC; see
farkode.h for additional information */
int FARKDenseJac(realtype t, N_Vector y, N_Vector fy, SUNMatrix J,
void *user_data, N_Vector vtemp1, N_Vector vtemp2,
N_Vector vtemp3)
{
realtype *ydata, *fydata, *jacdata, *v1data, *v2data, *v3data;
realtype h;
long int N;
FARKUserData ARK_userdata;
int ier = 0;
/* Initialize all pointers to NULL */
ydata = fydata = jacdata = v1data = v2data = v3data = NULL;
ARKStepGetLastStep(ARK_arkodemem, &h);
ydata = N_VGetArrayPointer(y);
fydata = N_VGetArrayPointer(fy);
v1data = N_VGetArrayPointer(vtemp1);
v2data = N_VGetArrayPointer(vtemp2);
v3data = N_VGetArrayPointer(vtemp3);
N = SUNDenseMatrix_Columns(J);
jacdata = SUNDenseMatrix_Column(J,0);
ARK_userdata = (FARKUserData) user_data;
FARK_DJAC(&N, &t, ydata, fydata, jacdata, &h,
ARK_userdata->ipar, ARK_userdata->rpar, v1data,
v2data, v3data, &ier);
return(ier);
}
/*===============================================================
EOF
===============================================================*/
|
729daddf8cb1c41f63b0ee0d6339c9220b6c157d
|
3f55217e912141e04815bc8bcb6fbd5638d0896e
|
/src/common/xf.c
|
907bec3659fc4af0e05368d315cb868191d13f91
|
[
"BSD-2-Clause"
] |
permissive
|
NREL/Radiance
|
bfbb93c99d86368ad0f27052a2a5504aeced47f8
|
2fcca99ace2f2435f32a09525ad31f2b3be3c1bc
|
refs/heads/master
| 2021-12-26T12:42:04.586614
| 2021-12-18T00:43:56
| 2021-12-18T00:43:56
| 8,210,805
| 164
| 68
|
NOASSERTION
| 2019-06-06T19:57:11
| 2013-02-15T00:47:56
|
C
|
UTF-8
|
C
| false
| false
| 4,376
|
c
|
xf.c
|
#ifndef lint
static const char RCSid[] = "$Id: xf.c,v 2.8 2020/04/02 20:44:15 greg Exp $";
#endif
/*
* xf.c - routines to convert transform arguments into 4X4 matrix.
*
* External symbols declared in rtmath.h
*/
#include <stdlib.h>
#include "rtmath.h"
#include "rtio.h"
#define d2r(a) ((PI/180.)*(a))
#define checkarg(a,l) if (av[i][a] || badarg(ac-i-1,av+i+1,l)) goto done
int
xf(XF *ret, int ac, char *av[]) /* get transform specification */
{
MAT4 xfmat, m4;
double xfsca, dtmp;
int i, icnt;
setident4(ret->xfm);
ret->sca = 1.0;
icnt = 1;
setident4(xfmat);
xfsca = 1.0;
for (i = 0; i < ac && av[i][0] == '-'; i++) {
setident4(m4);
switch (av[i][1]) {
case 't': /* translate */
checkarg(2,"fff");
m4[3][0] = atof(av[++i]);
m4[3][1] = atof(av[++i]);
m4[3][2] = atof(av[++i]);
break;
case 'r': /* rotate */
switch (av[i][2]) {
case 'x':
checkarg(3,"f");
dtmp = d2r(atof(av[++i]));
m4[1][1] = m4[2][2] = cos(dtmp);
m4[2][1] = -(m4[1][2] = sin(dtmp));
break;
case 'y':
checkarg(3,"f");
dtmp = d2r(atof(av[++i]));
m4[0][0] = m4[2][2] = cos(dtmp);
m4[0][2] = -(m4[2][0] = sin(dtmp));
break;
case 'z':
checkarg(3,"f");
dtmp = d2r(atof(av[++i]));
m4[0][0] = m4[1][1] = cos(dtmp);
m4[1][0] = -(m4[0][1] = sin(dtmp));
break;
default:
goto done;
}
break;
case 's': /* scale */
checkarg(2,"f");
dtmp = atof(av[i+1]);
if (dtmp == 0.0) goto done;
i++;
xfsca *=
m4[0][0] =
m4[1][1] =
m4[2][2] = dtmp;
break;
case 'm': /* mirror */
switch (av[i][2]) {
case 'x':
checkarg(3,"");
xfsca *=
m4[0][0] = -1.0;
break;
case 'y':
checkarg(3,"");
xfsca *=
m4[1][1] = -1.0;
break;
case 'z':
checkarg(3,"");
xfsca *=
m4[2][2] = -1.0;
break;
default:
goto done;
}
break;
case 'i': /* iterate */
checkarg(2,"i");
while (icnt-- > 0) {
multmat4(ret->xfm, ret->xfm, xfmat);
ret->sca *= xfsca;
}
icnt = atoi(av[++i]);
setident4(xfmat);
xfsca = 1.0;
continue;
default:
goto done;
}
multmat4(xfmat, xfmat, m4);
}
done:
while (icnt-- > 0) {
multmat4(ret->xfm, ret->xfm, xfmat);
ret->sca *= xfsca;
}
return(i);
}
int
invxf(XF *ret, int ac, char *av[]) /* invert transform specification */
{
MAT4 xfmat, m4;
double xfsca, dtmp;
int i, icnt;
setident4(ret->xfm);
ret->sca = 1.0;
icnt = 1;
setident4(xfmat);
xfsca = 1.0;
for (i = 0; i < ac && av[i][0] == '-'; i++) {
setident4(m4);
switch (av[i][1]) {
case 't': /* translate */
checkarg(2,"fff");
m4[3][0] = -atof(av[++i]);
m4[3][1] = -atof(av[++i]);
m4[3][2] = -atof(av[++i]);
break;
case 'r': /* rotate */
switch (av[i][2]) {
case 'x':
checkarg(3,"f");
dtmp = -d2r(atof(av[++i]));
m4[1][1] = m4[2][2] = cos(dtmp);
m4[2][1] = -(m4[1][2] = sin(dtmp));
break;
case 'y':
checkarg(3,"f");
dtmp = -d2r(atof(av[++i]));
m4[0][0] = m4[2][2] = cos(dtmp);
m4[0][2] = -(m4[2][0] = sin(dtmp));
break;
case 'z':
checkarg(3,"f");
dtmp = -d2r(atof(av[++i]));
m4[0][0] = m4[1][1] = cos(dtmp);
m4[1][0] = -(m4[0][1] = sin(dtmp));
break;
default:
goto done;
}
break;
case 's': /* scale */
checkarg(2,"f");
dtmp = atof(av[i+1]);
if (dtmp == 0.0) goto done;
i++;
xfsca *=
m4[0][0] =
m4[1][1] =
m4[2][2] = 1.0 / dtmp;
break;
case 'm': /* mirror */
switch (av[i][2]) {
case 'x':
checkarg(3,"");
xfsca *=
m4[0][0] = -1.0;
break;
case 'y':
checkarg(3,"");
xfsca *=
m4[1][1] = -1.0;
break;
case 'z':
checkarg(3,"");
xfsca *=
m4[2][2] = -1.0;
break;
default:
goto done;
}
break;
case 'i': /* iterate */
checkarg(2,"i");
while (icnt-- > 0) {
multmat4(ret->xfm, xfmat, ret->xfm);
ret->sca *= xfsca;
}
icnt = atoi(av[++i]);
setident4(xfmat);
xfsca = 1.0;
break;
default:
goto done;
}
multmat4(xfmat, m4, xfmat); /* left multiply */
}
done:
while (icnt-- > 0) {
multmat4(ret->xfm, xfmat, ret->xfm);
ret->sca *= xfsca;
}
return(i);
}
int
fullxf(FULLXF *fx, int ac, char *av[]) /* compute both forward and inverse */
{
xf(&fx->f, ac, av);
return(invxf(&fx->b, ac, av));
}
|
14b237013eb1bd8778662cf0981b5ba20ccd5359
|
1efb2283837c9b70bc6449cec877799e4efa3268
|
/src/mpi/coll/src/csel_container.c
|
633ed7a0438f582fad5aec240beecc5aa66cd87a
|
[
"mpich2"
] |
permissive
|
pmodels/mpich
|
d2392e8e30536cad3e500c16aa1e71211101d83f
|
2d265f9f5f93ebdd07ad547423bc6212868262a4
|
refs/heads/main
| 2023-09-04T05:50:15.041823
| 2023-09-01T23:07:33
| 2023-09-01T23:07:33
| 70,918,679
| 506
| 313
|
NOASSERTION
| 2023-09-14T14:38:36
| 2016-10-14T14:39:42
|
C
|
UTF-8
|
C
| false
| false
| 50,735
|
c
|
csel_container.c
|
/*
* Copyright (C) by Argonne National Laboratory
* See COPYRIGHT in top-level directory
*/
#include "mpiimpl.h"
#include "coll_impl.h"
#include "csel_container.h"
#include "mpl.h"
static void parse_container_params(struct json_object *obj, MPII_Csel_container_s * cnt)
{
MPIR_Assert(obj != NULL);
char *ckey;
switch (cnt->id) {
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_tree:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.ibcast.intra_tsp_tree.chunk_size =
atoi(ckey + strlen("chunk_size="));
else if (!strncmp(ckey, "tree_type=", strlen("tree_type=")))
cnt->u.ibcast.intra_tsp_tree.tree_type = atoi(ckey + strlen("tree_type="));
else if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.ibcast.intra_tsp_tree.k = atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_ring:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.ibcast.intra_tsp_ring.chunk_size =
atoi(ckey + strlen("chunk_size="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_tree:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "tree_type=", strlen("tree_type=")))
cnt->u.bcast.intra_tree.tree_type = atoi(ckey + strlen("tree_type="));
else if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.bcast.intra_tree.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "is_non_blocking=", strlen("is_non_blocking=")))
cnt->u.bcast.intra_tree.k = atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_pipelined_tree:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "tree_type=", strlen("tree_type=")))
cnt->u.bcast.intra_pipelined_tree.tree_type =
atoi(ckey + strlen("tree_type="));
else if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.bcast.intra_pipelined_tree.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "is_non_blocking=", strlen("is_non_blocking=")))
cnt->u.bcast.intra_pipelined_tree.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.bcast.intra_pipelined_tree.chunk_size =
atoi(ckey + strlen("chunk_size="));
else if (!strncmp(ckey, "recv_pre_posted=", strlen("recv_pre_posted=")))
cnt->u.bcast.intra_pipelined_tree.recv_pre_posted =
atoi(ckey + strlen("recv_pre_posted="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_tree:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "buffer_per_child=", strlen("buffer_per_child=")))
cnt->u.ireduce.intra_tsp_tree.buffer_per_child =
atoi(ckey + strlen("buffer_per_child="));
else if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.ireduce.intra_tsp_tree.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "tree_type=", strlen("tree_type=")))
cnt->u.ireduce.intra_tsp_tree.tree_type = atoi(ckey + strlen("tree_type="));
else if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.ireduce.intra_tsp_tree.chunk_size =
atoi(ckey + strlen("chunk_size="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_ring:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "buffer_per_child=", strlen("buffer_per_child=")))
cnt->u.ireduce.intra_tsp_ring.buffer_per_child =
atoi(ckey + strlen("buffer_per_child="));
else if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.ireduce.intra_tsp_tree.chunk_size =
atoi(ckey + strlen("chunk_size="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_tree:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "buffer_per_child=", strlen("buffer_per_child=")))
cnt->u.iallreduce.intra_tsp_tree.buffer_per_child =
atoi(ckey + strlen("buffer_per_child="));
else if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.iallreduce.intra_tsp_tree.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "tree_type=", strlen("tree_type=")))
cnt->u.iallreduce.intra_tsp_tree.tree_type =
atoi(ckey + strlen("tree_type="));
else if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.iallreduce.intra_tsp_tree.chunk_size =
atoi(ckey + strlen("chunk_size="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_tree:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "buffer_per_child=", strlen("buffer_per_child=")))
cnt->u.allreduce.intra_tree.buffer_per_child =
atoi(ckey + strlen("buffer_per_child="));
else if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.allreduce.intra_tree.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "tree_type=", strlen("tree_type=")))
cnt->u.allreduce.intra_tree.tree_type = atoi(ckey + strlen("tree_type="));
else if (!strncmp(ckey, "chunk_size=", strlen("chunk_size=")))
cnt->u.allreduce.intra_tree.chunk_size = atoi(ckey + strlen("chunk_size="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recexch:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.allreduce.intra_recexch.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "single_phase_recv=", strlen("single_phase_recv=")))
cnt->u.allreduce.intra_recexch.single_phase_recv =
atoi(ckey + strlen("single_phase_recv="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_k_reduce_scatter_allgather:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.allreduce.intra_k_reduce_scatter_allgather.k =
atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "single_phase_recv=", strlen("single_phase_recv=")))
cnt->u.allreduce.intra_k_reduce_scatter_allgather.single_phase_recv =
atoi(ckey + strlen("single_phase_recv="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "scatterv_k=", strlen("scatterv_k=")))
cnt->u.ibcast.intra_tsp_scatterv_recexch_allgatherv.scatterv_k =
atoi(ckey + strlen("scatterv_k="));
else if (!strncmp(ckey, "allgatherv_k=", strlen("allgatherv_k=")))
cnt->u.ibcast.intra_tsp_scatterv_recexch_allgatherv.allgatherv_k =
atoi(ckey + strlen("allgatherv_k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_single_buffer:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.iallreduce.intra_tsp_recexch_single_buffer.k =
atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.iallreduce.intra_tsp_recexch_multiple_buffer.k =
atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.iallreduce.intra_tsp_recexch_reduce_scatter_recexch_allgatherv.k =
atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_k_brucks:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.allgather.intra_k_brucks.k = atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_doubling:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.allgather.intra_recexch_doubling.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "single_phase_recv=", strlen("single_phase_recv=")))
cnt->u.allgather.intra_recexch_doubling.single_phase_recv =
atoi(ckey + strlen("single_phase_recv="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_halving:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.allgather.intra_recexch_halving.k = atoi(ckey + strlen("k="));
else if (!strncmp(ckey, "single_phase_recv=", strlen("single_phase_recv=")))
cnt->u.allgather.intra_recexch_halving.single_phase_recv =
atoi(ckey + strlen("single_phase_recv="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_k_brucks:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.alltoall.intra_k_brucks.k = atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_k_dissemination:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.barrier.intra_k_dissemination.k = atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_recexch:
{
json_object_object_foreach(obj, key, val) {
ckey = MPL_strdup_no_spaces(key);
if (!strncmp(ckey, "k=", strlen("k=")))
cnt->u.barrier.intra_recexch.k = atoi(ckey + strlen("k="));
MPL_free(ckey);
}
}
break;
default:
/* Algorithm does not have parameters */
break;
}
}
void *MPII_Create_container(struct json_object *obj)
{
MPII_Csel_container_s *cnt = MPL_malloc(sizeof(MPII_Csel_container_s), MPL_MEM_COLL);
json_object_object_foreach(obj, key, val) {
char *ckey = MPL_strdup_no_spaces(key);
if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_k_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_k_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_recursive_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_recexch_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_recexch_halving"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_halving;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_inter_local_gather_remote_bcast"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_inter_local_gather_remote_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Allgather_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_intra_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_intra_recursive_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_intra_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_inter_remote_gather_local_bcast"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_inter_remote_gather_local_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_recursive_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_reduce_scatter_allgather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_reduce_scatter_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_recexch"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recexch;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_k_reduce_scatter_allgather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_k_reduce_scatter_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_inter_reduce_exchange_bcast"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_inter_reduce_exchange_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_k_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_k_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_pairwise"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_pairwise;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_pairwise_sendrecv_replace"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_pairwise_sendrecv_replace;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_scattered"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_scattered;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_inter_pairwise_exchange"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_inter_pairwise_exchange;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_intra_pairwise_sendrecv_replace"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_intra_pairwise_sendrecv_replace;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_intra_scattered"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_intra_scattered;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_inter_pairwise_exchange"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_inter_pairwise_exchange;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_intra_pairwise_sendrecv_replace"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_intra_pairwise_sendrecv_replace;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_intra_scattered"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_intra_scattered;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_inter_pairwise_exchange"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_inter_pairwise_exchange;
else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Barrier_intra_k_dissemination"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_k_dissemination;
else if (!strcmp(ckey, "algorithm=MPIR_Barrier_intra_recexch"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_recexch;
else if (!strcmp(ckey, "algorithm=MPIR_Barrier_intra_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Barrier_inter_bcast"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_inter_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Barrier_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_scatter_recursive_doubling_allgather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_scatter_recursive_doubling_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_scatter_ring_allgather"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_scatter_ring_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_pipelined_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_pipelined_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_inter_remote_send_local_bcast"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_inter_remote_send_local_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Bcast_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Exscan_intra_recursive_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Exscan_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Exscan_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Exscan_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Gather_intra_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_intra_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Gather_inter_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_inter_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Gather_inter_local_gather_remote_send"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_inter_local_gather_remote_send;
else if (!strcmp(ckey, "algorithm=MPIR_Gather_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Gatherv_allcomm_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gatherv_allcomm_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Gatherv_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gatherv_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_sched_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_sched_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_recexch_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_recexch_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_recexch_halving"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_recexch_halving;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_inter_sched_local_gather_remote_bcast"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_inter_sched_local_gather_remote_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_sched_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_sched_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_recexch_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_recexch_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_recexch_halving"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_recexch_halving;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_inter_sched_remote_gather_local_bcast"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_inter_sched_remote_gather_local_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_naive"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_naive;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_reduce_scatter_allgather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_reduce_scatter_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_recexch_single_buffer"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_single_buffer;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_ring;
else if (!strcmp
(ckey,
"algorithm=MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_inter_sched_remote_reduce_local_bcast"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_inter_sched_remote_reduce_local_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_tsp_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_tsp_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_tsp_scattered"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_scattered;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_brucks"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_brucks;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_inplace"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_inplace;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_pairwise"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_pairwise;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_permuted_sendrecv"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_permuted_sendrecv;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_inter_sched_pairwise_exchange"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_inter_sched_pairwise_exchange;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_sched_blocked"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_sched_blocked;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_sched_inplace"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_sched_inplace;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_tsp_scattered"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_scattered;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_tsp_blocked"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_blocked;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_tsp_inplace"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_inplace;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_inter_sched_pairwise_exchange"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_inter_sched_pairwise_exchange;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_tsp_blocked"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_tsp_blocked;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_tsp_inplace"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_tsp_inplace;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_sched_blocked"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_sched_blocked;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_sched_inplace"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_sched_inplace;
else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_inter_sched_pairwise_exchange"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_inter_sched_pairwise_exchange;
else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_intra_tsp_recexch"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_tsp_recexch;
else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_intra_tsp_k_dissem"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_tsp_k_dissemination;
else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_inter_sched_bcast"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_inter_sched_bcast;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_tsp_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_tsp_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_sched_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_binomial;
else if (!strcmp
(ckey, "algorithm=MPIR_Ibcast_intra_sched_scatter_recursive_doubling_allgather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_scatter_recursive_doubling_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_sched_scatter_ring_allgather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_scatter_ring_allgather;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_sched_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_inter_sched_flat"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_inter_sched_flat;
else if (!strcmp(ckey, "algorithm=MPIR_Iexscan_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iexscan_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Igather_intra_tsp_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_intra_tsp_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Igather_intra_sched_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_intra_sched_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Igather_inter_sched_long"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_inter_sched_long;
else if (!strcmp(ckey, "algorithm=MPIR_Igather_inter_sched_short"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_inter_sched_short;
else if (!strcmp(ckey, "algorithm=MPIR_Igatherv_allcomm_tsp_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igatherv_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Igatherv_allcomm_sched_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igatherv_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgather_allcomm_tsp_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgather_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgather_allcomm_sched_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgather_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgatherv_allcomm_tsp_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgatherv_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgatherv_allcomm_sched_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgatherv_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoall_allcomm_tsp_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoall_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoall_allcomm_sched_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoall_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallv_allcomm_tsp_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallv_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallv_allcomm_sched_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallv_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallw_allcomm_tsp_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallw_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallw_allcomm_sched_linear"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallw_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_tsp_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_tsp_ring"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_ring;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_sched_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_sched_reduce_scatter_gather"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_reduce_scatter_gather;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_sched_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_inter_sched_local_reduce_remote_send"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_inter_sched_local_reduce_remote_send;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_noncommutative"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_noncommutative;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_pairwise"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_pairwise;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_recursive_halving"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_recursive_halving;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_tsp_recexch"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_tsp_recexch;
else if (!strcmp
(ckey, "algorithm=MPIR_Ireduce_scatter_inter_sched_remote_reduce_local_scatterv"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_inter_sched_remote_reduce_local_scatterv;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_tsp_recexch"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_tsp_recexch;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_noncommutative"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_noncommutative;
else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_pairwise"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_pairwise;
else if (!strcmp
(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_recursive_doubling;
else if (!strcmp
(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_recursive_halving"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_recursive_halving;
else if (!strcmp
(ckey,
"algorithm=MPIR_Ireduce_scatter_block_inter_sched_remote_reduce_local_scatterv"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_inter_sched_remote_reduce_local_scatterv;
else if (!strcmp(ckey, "algorithm=MPIR_Iscan_intra_sched_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_sched_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iscan_intra_sched_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_sched_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Iscan_intra_tsp_recursive_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_tsp_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_intra_tsp_tree"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_intra_tsp_tree;
else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_intra_sched_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_intra_sched_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_inter_sched_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_inter_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_inter_sched_remote_send_local_scatter"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_inter_sched_remote_send_local_scatter;
else if (!strcmp(ckey, "algorithm=MPIR_Iscatterv_allcomm_tsp_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatterv_allcomm_tsp_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Iscatterv_allcomm_sched_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatterv_allcomm_sched_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_allgather_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_allgather_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_allgatherv_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_allgatherv_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_alltoall_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoall_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_alltoallv_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoallv_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_alltoallw_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoallw_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_intra_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_intra_reduce_scatter_gather"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_reduce_scatter_gather;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_intra_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_inter_local_reduce_remote_send"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_inter_local_reduce_remote_send;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_noncommutative"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_noncommutative;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_pairwise"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_pairwise;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_recursive_halving"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_recursive_halving;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_inter_remote_reduce_local_scatter"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_inter_remote_reduce_local_scatter;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_noncommutative"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_noncommutative;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_pairwise"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_pairwise;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_recursive_doubling"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_recursive_halving"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_recursive_halving;
else if (!strcmp
(ckey, "algorithm=MPIR_Reduce_scatter_block_inter_remote_reduce_local_scatter"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_inter_remote_reduce_local_scatter;
else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Scan_intra_recursive_doubling"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_intra_recursive_doubling;
else if (!strcmp(ckey, "algorithm=MPIR_Scan_intra_smp"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_intra_smp;
else if (!strcmp(ckey, "algorithm=MPIR_Scan_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Scatter_intra_binomial"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_intra_binomial;
else if (!strcmp(ckey, "algorithm=MPIR_Scatter_inter_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_inter_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Scatter_inter_remote_send_local_scatter"))
cnt->id =
MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_inter_remote_send_local_scatter;
else if (!strcmp(ckey, "algorithm=MPIR_Scatter_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_allcomm_nb;
else if (!strcmp(ckey, "algorithm=MPIR_Scatterv_allcomm_linear"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_linear;
else if (!strcmp(ckey, "algorithm=MPIR_Scatterv_allcomm_nb"))
cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_nb;
else {
fprintf(stderr, "unrecognized key %s\n", key);
MPIR_Assert(0);
}
MPL_free(ckey);
}
/* process algorithm parameters */
parse_container_params(json_object_object_get(obj, key), cnt);
return (void *) cnt;
}
|
78e5e226020731e6438e146d8a068959c8dc00ec
|
25e99a0af5751865bce1702ee85cc5c080b0715c
|
/c++/code/myserver/framework/const/common_def.h
|
364e9f05b4b49dff2d83d330dbc1ae46cf8f9ce7
|
[] |
no_license
|
jasonblog/note
|
215837f6a08d07abe3e3d2be2e1f183e14aa4a30
|
4471f95736c60969a718d854cab929f06726280a
|
refs/heads/master
| 2023-05-31T13:02:27.451743
| 2022-04-04T11:28:06
| 2022-04-04T11:28:06
| 35,311,001
| 130
| 67
| null | 2023-02-10T21:26:36
| 2015-05-09T02:04:40
|
C
|
UTF-8
|
C
| false
| false
| 265
|
h
|
common_def.h
|
//
// Created by DGuco on 17-6-3.
//
#ifndef SERVER_COMMONDEF_H
#define SERVER_COMMONDEF_H
// 管道标识符
enum enLockIdx {
IDX_PIPELOCK_C2S = 0,
IDX_PIPELOCK_S2C = 1,
IDX_PIPELOCK_A2C = 2,
IDX_PIPELOCK_S2L = 3,
};
#endif //SERVER_COMMONDEF_H
|
04fb640762895682bae9cd077dd40c1797f129ba
|
0577a46d8d28e1fd8636893bbdd2b18270bb8eb8
|
/update_notifier/thirdparty/wxWidgets/art/tango/go_first.h
|
bac212d7d40c15ed0bb7a1c44e02c38e8a4da4ba
|
[
"BSD-3-Clause"
] |
permissive
|
ric2b/Vivaldi-browser
|
388a328b4cb838a4c3822357a5529642f86316a5
|
87244f4ee50062e59667bf8b9ca4d5291b6818d7
|
refs/heads/master
| 2022-12-21T04:44:13.804535
| 2022-12-17T16:30:35
| 2022-12-17T16:30:35
| 86,637,416
| 166
| 41
|
BSD-3-Clause
| 2021-03-31T18:49:30
| 2017-03-29T23:09:05
| null |
UTF-8
|
C
| false
| false
| 13,717
|
h
|
go_first.h
|
/* go_first.png - 666 bytes */
static const unsigned char go_first_16x16_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10,
0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0x04, 0x73, 0x42, 0x49,
0x54, 0x08, 0x08, 0x08, 0x08, 0x7c, 0x08, 0x64,
0x88, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45, 0x58,
0x74, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72,
0x65, 0x00, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x6e,
0x6b, 0x73, 0x63, 0x61, 0x70, 0x65, 0x2e, 0x6f,
0x72, 0x67, 0x9b, 0xee, 0x3c, 0x1a, 0x00, 0x00,
0x02, 0x2c, 0x49, 0x44, 0x41, 0x54, 0x38, 0x8d,
0x7d, 0x53, 0x4d, 0x48, 0x54, 0x51, 0x18, 0x3d,
0xdf, 0xbd, 0xef, 0x8d, 0x33, 0x19, 0x46, 0x09,
0x31, 0x41, 0x4d, 0x45, 0x41, 0xc2, 0x50, 0x54,
0x8b, 0xa6, 0xe6, 0x41, 0x20, 0x65, 0xa5, 0x26,
0x24, 0xb8, 0x48, 0x5c, 0x84, 0xa0, 0x41, 0x20,
0x6d, 0x66, 0x84, 0xb6, 0x41, 0xb4, 0x9a, 0x60,
0xd6, 0x19, 0x34, 0xb4, 0x28, 0xa8, 0x45, 0x20,
0xd3, 0xa6, 0x82, 0xa0, 0x18, 0xc8, 0x12, 0xc1,
0x4c, 0x88, 0x08, 0x8a, 0x99, 0x10, 0xed, 0xc7,
0xd1, 0x9c, 0x9f, 0x37, 0xef, 0xfe, 0xb5, 0x08,
0xc9, 0x91, 0x37, 0x73, 0xe1, 0x6e, 0xee, 0x77,
0xce, 0xe1, 0x1c, 0xbe, 0x73, 0x11, 0x4f, 0x58,
0x26, 0x9e, 0xb0, 0x8c, 0x31, 0x06, 0x8d, 0x6e,
0x3c, 0x61, 0x8d, 0x38, 0xe3, 0x56, 0xce, 0x6f,
0x66, 0xa1, 0xc9, 0x71, 0x92, 0xf6, 0x56, 0x22,
0x64, 0x22, 0xe1, 0x83, 0x3d, 0xf9, 0xc5, 0x2f,
0x21, 0x3f, 0x0c, 0x6b, 0x42, 0x3e, 0x0c, 0xc2,
0xfc, 0xb9, 0x13, 0x03, 0x7d, 0x63, 0xfd, 0xb7,
0x7c, 0xc9, 0x00, 0xfc, 0x1d, 0x38, 0x49, 0x7b,
0xb4, 0x35, 0xd4, 0x96, 0x1e, 0xee, 0x1d, 0x0f,
0x85, 0xdb, 0x23, 0xc4, 0x18, 0x6f, 0xe8, 0xb2,
0x4e, 0x60, 0xdd, 0x72, 0x47, 0xe4, 0x58, 0xcf,
0x60, 0xd7, 0x58, 0xa8, 0x2c, 0x8b, 0x98, 0x5b,
0x78, 0x85, 0xe3, 0x7b, 0xce, 0x83, 0x38, 0x5c,
0x27, 0x69, 0x9b, 0x3a, 0x36, 0x61, 0x89, 0xe2,
0x09, 0x6b, 0xfd, 0xf1, 0x08, 0x31, 0x96, 0xed,
0x3d, 0x35, 0xb8, 0x2b, 0x16, 0x3d, 0x6b, 0x7f,
0x5b, 0xfe, 0x80, 0x62, 0x65, 0x11, 0x86, 0x34,
0x62, 0x7b, 0xfb, 0xa0, 0xa1, 0xa0, 0xb5, 0x82,
0xd2, 0x12, 0x4a, 0x4b, 0x48, 0x25, 0x71, 0xfb,
0xfe, 0xf5, 0xff, 0x0e, 0xda, 0x5a, 0xdb, 0xa7,
0x2e, 0x77, 0x5d, 0x0b, 0x6e, 0xdf, 0xb6, 0x83,
0x66, 0x0a, 0xcf, 0x21, 0xb4, 0x0b, 0xe2, 0x06,
0x20, 0x8d, 0x5c, 0xe1, 0x11, 0x34, 0x14, 0xa4,
0xf6, 0x20, 0x64, 0x0d, 0x9e, 0xf0, 0x70, 0x7a,
0xdf, 0x50, 0x7d, 0x84, 0xab, 0x97, 0x6e, 0x84,
0x96, 0xdd, 0xef, 0x98, 0xce, 0xbf, 0x05, 0x88,
0xc0, 0x19, 0x03, 0x67, 0x80, 0x86, 0x80, 0x2b,
0x57, 0xe1, 0xea, 0x35, 0xb8, 0xa2, 0x04, 0xa9,
0x15, 0xa0, 0x18, 0x24, 0xbc, 0x7a, 0x81, 0xb5,
0x5a, 0x11, 0x2b, 0xd5, 0x1f, 0xf8, 0x59, 0x2e,
0xc0, 0x93, 0x2e, 0x14, 0xaf, 0x42, 0xf3, 0x2a,
0x8c, 0x2d, 0x60, 0xd9, 0x04, 0xc6, 0x09, 0x86,
0x03, 0x1a, 0x06, 0x4a, 0x1a, 0xb8, 0xea, 0x0f,
0x80, 0x0d, 0x6b, 0xcc, 0x4c, 0xa6, 0xab, 0xb5,
0xb2, 0x32, 0x87, 0x76, 0xc6, 0x50, 0x55, 0x2b,
0xa8, 0xa8, 0x22, 0x14, 0xf3, 0xc0, 0x6d, 0x82,
0x15, 0x60, 0xb0, 0x5a, 0x18, 0xec, 0x16, 0x06,
0x2b, 0xc0, 0xc0, 0x6d, 0x02, 0xb1, 0x4d, 0x5b,
0xa8, 0x79, 0x95, 0xd8, 0xb3, 0xd7, 0x8f, 0xb3,
0x47, 0x3b, 0x62, 0xe1, 0x33, 0xd1, 0x2b, 0x81,
0x8f, 0xbf, 0x5f, 0xe0, 0x97, 0xfc, 0x0a, 0x6e,
0x11, 0x2e, 0x1e, 0x48, 0x82, 0x71, 0x02, 0x00,
0x68, 0xf5, 0xcf, 0x81, 0x92, 0xa6, 0x5e, 0x20,
0x97, 0x12, 0x73, 0x4e, 0xd2, 0x8e, 0xce, 0x7e,
0x9a, 0xca, 0x2c, 0x2c, 0xe5, 0xbb, 0xbb, 0x3b,
0xfb, 0xb7, 0xac, 0xd2, 0x7e, 0x7c, 0x2e, 0xbd,
0x01, 0x31, 0xc2, 0x9d, 0xbb, 0x37, 0x5d, 0xe1,
0x9a, 0xe0, 0xe6, 0x35, 0xd6, 0xf5, 0x20, 0x97,
0x12, 0x25, 0x00, 0x03, 0x4e, 0xd2, 0x1e, 0x7d,
0x38, 0x79, 0x2f, 0x7d, 0xa1, 0xb3, 0x37, 0xe4,
0xec, 0x1e, 0x22, 0x00, 0x10, 0xae, 0x09, 0xe6,
0x52, 0x82, 0x36, 0x17, 0xc9, 0xb7, 0xca, 0xb9,
0x94, 0x98, 0x10, 0xc2, 0x3b, 0x99, 0x7d, 0xf9,
0xb4, 0xf0, 0x7e, 0xfa, 0x5d, 0x4d, 0x08, 0xcf,
0x0f, 0xd6, 0x58, 0x60, 0x3d, 0x92, 0xd1, 0x88,
0xce, 0xce, 0xcf, 0x64, 0x1f, 0x3c, 0x99, 0xa8,
0x34, 0xc2, 0x35, 0xfd, 0x8d, 0x1b, 0x22, 0x8d,
0x30, 0x8e, 0x61, 0x3f, 0xcc, 0x5f, 0x5a, 0xcc,
0x0f, 0xfb, 0xcc, 0x70, 0xa3, 0x34, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82};
/* go_first.png - 1501 bytes */
static const unsigned char go_first_24x24_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18,
0x10, 0x06, 0x00, 0x00, 0x00, 0xb0, 0xe7, 0xe1,
0xbb, 0x00, 0x00, 0x00, 0x06, 0x62, 0x4b, 0x47,
0x44, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x09,
0x58, 0xf7, 0xdc, 0x00, 0x00, 0x00, 0x09, 0x70,
0x48, 0x59, 0x73, 0x00, 0x00, 0x00, 0x48, 0x00,
0x00, 0x00, 0x48, 0x00, 0x46, 0xc9, 0x6b, 0x3e,
0x00, 0x00, 0x00, 0x09, 0x76, 0x70, 0x41, 0x67,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18,
0x00, 0x78, 0x4c, 0xa5, 0xa6, 0x00, 0x00, 0x05,
0x3a, 0x49, 0x44, 0x41, 0x54, 0x58, 0xc3, 0xed,
0x96, 0x5f, 0x48, 0x54, 0x4f, 0x14, 0xc7, 0xcf,
0xcc, 0xdc, 0xbd, 0xbb, 0x6e, 0xca, 0xaf, 0x16,
0xc5, 0x4d, 0x2a, 0x23, 0x35, 0x24, 0x89, 0x84,
0x24, 0x58, 0xb5, 0x55, 0x50, 0xb4, 0x3f, 0x1a,
0x54, 0xba, 0x52, 0x41, 0xff, 0x2c, 0x22, 0xa3,
0x7c, 0xc8, 0x20, 0xab, 0x87, 0x08, 0x4a, 0x29,
0x83, 0xe8, 0xc5, 0x0a, 0x31, 0x02, 0x5f, 0xb2,
0xa2, 0x17, 0xb3, 0x40, 0x2c, 0x7c, 0x48, 0x2a,
0x4d, 0x13, 0xc2, 0x50, 0xca, 0xa8, 0x2d, 0xd4,
0x34, 0x95, 0x4d, 0xf7, 0xcf, 0xbd, 0x77, 0xee,
0xfc, 0x1e, 0xe6, 0x37, 0x5c, 0x77, 0x7f, 0x9a,
0x3f, 0x75, 0xdf, 0x7e, 0x1d, 0xb8, 0x9c, 0x3b,
0xf7, 0xce, 0x9d, 0xf9, 0x7c, 0xcf, 0x9c, 0x33,
0x73, 0x01, 0xfe, 0xd8, 0x1f, 0x5b, 0x94, 0x21,
0x71, 0x93, 0x9e, 0x5e, 0x51, 0x21, 0x49, 0x43,
0x43, 0x00, 0x8c, 0x01, 0xc4, 0xc6, 0xce, 0xd0,
0x15, 0x01, 0x7c, 0xfd, 0xda, 0xde, 0x5e, 0x53,
0xa3, 0x69, 0xf1, 0xf1, 0xf3, 0x9d, 0x28, 0x3d,
0xfd, 0xf4, 0x69, 0x49, 0xda, 0xbd, 0x1b, 0x21,
0x8c, 0x01, 0x4e, 0x9e, 0x7c, 0xf9, 0xf2, 0xda,
0x35, 0x4d, 0xcb, 0xce, 0x5e, 0xac, 0x00, 0xc9,
0xb8, 0xe5, 0xe0, 0xc7, 0x8f, 0x97, 0x94, 0x9c,
0x3b, 0x37, 0xfd, 0x29, 0x63, 0x8c, 0x01, 0xdc,
0xba, 0xd5, 0xd8, 0x58, 0x55, 0x15, 0x17, 0x37,
0x3f, 0x60, 0x84, 0xb8, 0xf0, 0xaa, 0xaa, 0x15,
0x2b, 0x62, 0x62, 0x12, 0x12, 0x4e, 0x9d, 0xfa,
0xf6, 0xed, 0xc7, 0x8f, 0x4f, 0x9f, 0x22, 0x22,
0xc2, 0xb5, 0x02, 0x78, 0xb6, 0x17, 0x0f, 0x1e,
0xbc, 0x7b, 0x57, 0x5d, 0x3d, 0xff, 0x01, 0x39,
0x78, 0x54, 0x14, 0x8f, 0x74, 0x4b, 0xcb, 0x86,
0x0d, 0x49, 0x49, 0x0e, 0x47, 0x79, 0xf9, 0xd1,
0xa3, 0x3b, 0x76, 0x54, 0x56, 0x86, 0x0f, 0x5c,
0x98, 0xb4, 0xf8, 0x21, 0xa6, 0x83, 0x27, 0x26,
0x72, 0xf0, 0xd6, 0xd6, 0xdc, 0xdc, 0x4d, 0x9b,
0x76, 0xed, 0x5a, 0xbe, 0x3c, 0x2d, 0x2d, 0x39,
0x39, 0x2b, 0xcb, 0x64, 0x92, 0x24, 0x42, 0x4c,
0xa6, 0x70, 0xe3, 0x87, 0x41, 0x00, 0x07, 0xcf,
0xcf, 0x97, 0x24, 0x49, 0x32, 0x9b, 0x1b, 0x1b,
0x8b, 0x8a, 0x72, 0x72, 0x0e, 0x1d, 0x8a, 0x8a,
0x8a, 0x89, 0xb1, 0xd9, 0xec, 0x76, 0x84, 0x3a,
0x3b, 0xdd, 0xee, 0xa7, 0x4f, 0x01, 0x36, 0x6f,
0x4e, 0x48, 0x70, 0xb9, 0x00, 0x10, 0x22, 0x04,
0xc0, 0xef, 0xe7, 0xdf, 0x31, 0x36, 0xf7, 0x0c,
0x08, 0x01, 0x0c, 0x0f, 0xf3, 0xda, 0xb3, 0xdb,
0xc3, 0x26, 0x80, 0x17, 0x7d, 0x65, 0xe5, 0xd2,
0xa5, 0x91, 0x91, 0xd1, 0xd1, 0x17, 0x2e, 0x14,
0x17, 0xe7, 0xe6, 0x96, 0x96, 0x5a, 0xad, 0x5e,
0x2f, 0x63, 0xe3, 0xe3, 0x00, 0x9d, 0x9d, 0x6e,
0x77, 0x73, 0x33, 0x80, 0x24, 0x61, 0x2c, 0xcb,
0x00, 0xba, 0xae, 0xeb, 0x9a, 0x06, 0x70, 0xf1,
0xe2, 0xe1, 0xc3, 0x75, 0x75, 0x16, 0x0b, 0xc6,
0x7c, 0xad, 0x10, 0x12, 0x9e, 0x5f, 0x02, 0x59,
0xd8, 0xf9, 0xf3, 0xb7, 0x6f, 0xef, 0xdf, 0x3f,
0xd3, 0xa6, 0xb2, 0x20, 0x01, 0x08, 0x65, 0x64,
0x9c, 0x39, 0x23, 0x49, 0x8f, 0x1f, 0xaf, 0x5a,
0x65, 0xb7, 0x27, 0x25, 0xe5, 0xe5, 0x6d, 0xdf,
0x9e, 0x99, 0xe9, 0x72, 0x59, 0xad, 0x03, 0x03,
0xe3, 0xe3, 0x3d, 0x3d, 0x00, 0xc3, 0xc3, 0x1e,
0xcf, 0xe7, 0xcf, 0x00, 0x84, 0x60, 0x2c, 0x49,
0xc6, 0x26, 0xd0, 0xd2, 0xd2, 0xd7, 0x77, 0xf7,
0xae, 0xf1, 0x9c, 0x10, 0x84, 0x24, 0x69, 0xba,
0x80, 0x60, 0x21, 0x4e, 0x67, 0x42, 0x42, 0x49,
0xc9, 0xdc, 0x44, 0xff, 0x41, 0xc0, 0xf4, 0x78,
0x00, 0xa4, 0xa6, 0x26, 0x27, 0x3b, 0x1c, 0x5b,
0xb7, 0xa6, 0xa5, 0xa5, 0xa4, 0x64, 0x66, 0x9a,
0xcd, 0x1d, 0x1d, 0x6e, 0xf7, 0x93, 0x27, 0x00,
0xbf, 0x7e, 0x05, 0x02, 0xe3, 0xe3, 0x3c, 0xe2,
0x26, 0x13, 0x80, 0xae, 0x33, 0xa6, 0xeb, 0x5c,
0x80, 0xae, 0x03, 0xe8, 0x3a, 0x00, 0x17, 0xc4,
0xdf, 0x33, 0x86, 0x90, 0xa6, 0xf1, 0xd1, 0x39,
0x38, 0x63, 0x18, 0x1b, 0x82, 0x35, 0x4d, 0xd7,
0x55, 0x35, 0x0c, 0x02, 0x44, 0x44, 0xb6, 0x6c,
0xc9, 0xc9, 0x29, 0x28, 0x20, 0x64, 0xd9, 0xb2,
0x25, 0x4b, 0xec, 0x76, 0x42, 0x5e, 0xbc, 0xe8,
0xef, 0x6f, 0x68, 0x00, 0xd0, 0x34, 0xc6, 0x14,
0x85, 0x47, 0x96, 0x83, 0x71, 0x58, 0x71, 0x01,
0x48, 0x12, 0xa5, 0x00, 0xaa, 0x8a, 0xd0, 0xd4,
0x14, 0x00, 0xa5, 0x94, 0x2a, 0x0a, 0x80, 0xa6,
0x69, 0x9a, 0xdf, 0xcf, 0x41, 0x15, 0xc5, 0x10,
0x20, 0x49, 0x08, 0x59, 0x2c, 0x00, 0xaa, 0xca,
0x98, 0xd7, 0x1b, 0x96, 0x15, 0x08, 0x36, 0x5d,
0x67, 0x4c, 0xd3, 0x00, 0x54, 0x55, 0xd7, 0x03,
0x01, 0x00, 0x55, 0xa5, 0xd4, 0xef, 0xe7, 0x29,
0x10, 0x08, 0x18, 0x11, 0xc7, 0x58, 0x96, 0x45,
0x89, 0x6a, 0x1a, 0x80, 0x24, 0x99, 0x4c, 0x18,
0x03, 0x60, 0xcc, 0x4f, 0x07, 0x8c, 0x09, 0xe1,
0xc1, 0xe1, 0x2b, 0xcc, 0x98, 0xae, 0x33, 0x06,
0x10, 0x08, 0x50, 0xea, 0xf3, 0x01, 0x4c, 0x4d,
0x51, 0x3a, 0x36, 0x36, 0x37, 0x0f, 0x9e, 0xab,
0x03, 0x63, 0xfc, 0x7a, 0xf6, 0xac, 0xb5, 0xb5,
0xa9, 0x49, 0xd7, 0xfb, 0xfa, 0x3e, 0x7e, 0xec,
0xed, 0x0d, 0x04, 0xb2, 0xb3, 0x13, 0x13, 0xf7,
0xec, 0x01, 0x88, 0x8c, 0x34, 0x9b, 0x6d, 0x36,
0x80, 0x40, 0x40, 0xd3, 0xbc, 0x5e, 0x00, 0x4a,
0x31, 0x0e, 0x04, 0x00, 0x00, 0x08, 0xe1, 0xe0,
0xb2, 0x8c, 0x31, 0x80, 0xc9, 0x64, 0x36, 0x63,
0x0c, 0x20, 0xcb, 0x16, 0x0b, 0xf7, 0x56, 0x2b,
0xc6, 0x00, 0x66, 0x73, 0x44, 0x04, 0x6f, 0x47,
0x44, 0x10, 0x02, 0x60, 0x32, 0x59, 0x2c, 0x84,
0x18, 0x42, 0x17, 0x2d, 0x80, 0xe3, 0x1b, 0xf7,
0x5d, 0x5d, 0xef, 0xdf, 0xbf, 0x7e, 0xfd, 0xfc,
0x79, 0x6b, 0x6b, 0x7b, 0x7b, 0x73, 0xb3, 0xcf,
0xe7, 0x70, 0xc4, 0xc7, 0xef, 0xdc, 0x09, 0xb0,
0x7a, 0xb5, 0xcd, 0xb6, 0x7e, 0xbd, 0x11, 0x59,
0x01, 0x40, 0x88, 0xc9, 0xc4, 0xbd, 0x2c, 0x23,
0xc4, 0x01, 0xa7, 0x03, 0xcb, 0xb2, 0xd5, 0x2a,
0xc0, 0x79, 0x0a, 0xf1, 0x7e, 0x18, 0xe3, 0x19,
0xd8, 0x08, 0x59, 0x74, 0x0a, 0xbd, 0x7a, 0x75,
0xe3, 0x06, 0xa5, 0xc7, 0x8e, 0x29, 0xca, 0x91,
0x23, 0x03, 0x03, 0xe5, 0xe5, 0x1e, 0xcf, 0xe4,
0x64, 0x43, 0xc3, 0x89, 0x13, 0xdb, 0xb6, 0x65,
0x65, 0x15, 0x15, 0x59, 0x2c, 0xd1, 0xd1, 0x7f,
0xfd, 0x15, 0x1b, 0x0b, 0xf0, 0xe1, 0xc3, 0xc4,
0x44, 0x5b, 0x1b, 0x00, 0xc6, 0x3c, 0x49, 0x0a,
0x0a, 0xd6, 0xac, 0xa9, 0xa8, 0x00, 0x20, 0x44,
0xa4, 0x90, 0x48, 0x29, 0x0e, 0x4a, 0xa9, 0xa6,
0x31, 0x06, 0x40, 0xa9, 0xaa, 0xf2, 0x3a, 0xe2,
0xed, 0x60, 0x93, 0x65, 0xee, 0xfd, 0x7e, 0x11,
0xd0, 0x05, 0x9e, 0x03, 0xb2, 0xdc, 0xd5, 0x55,
0x57, 0x47, 0x69, 0x7d, 0xfd, 0xda, 0xb5, 0x05,
0x05, 0x3f, 0x7f, 0x0e, 0x0c, 0x3c, 0x7c, 0xe8,
0xf7, 0xdf, 0xbb, 0x77, 0xf5, 0x6a, 0x7e, 0xbe,
0xd3, 0x59, 0x58, 0x68, 0xb5, 0x66, 0x64, 0xac,
0x5c, 0xe9, 0x72, 0x21, 0xd4, 0xdd, 0x3d, 0x3a,
0xda, 0xd4, 0x64, 0x7c, 0x59, 0x53, 0x73, 0xe7,
0xce, 0xa5, 0x4b, 0x8a, 0x42, 0xa9, 0xa2, 0x30,
0x26, 0x80, 0x7e, 0x67, 0x08, 0x01, 0x8c, 0x8c,
0xfc, 0x13, 0x6f, 0x29, 0xd8, 0xab, 0xea, 0x02,
0x05, 0x88, 0xe5, 0x25, 0xa4, 0xbf, 0xbf, 0xa9,
0x49, 0xd7, 0xdf, 0xbc, 0xf1, 0x78, 0xdc, 0x6e,
0x9f, 0xaf, 0xb4, 0x54, 0x55, 0x55, 0xf5, 0xd1,
0xa3, 0x9b, 0x37, 0x1d, 0x8e, 0x8d, 0x1b, 0x9d,
0x4e, 0x9b, 0x2d, 0x23, 0x23, 0x25, 0x65, 0xef,
0x5e, 0x49, 0xd2, 0x75, 0x4a, 0x79, 0x84, 0x39,
0x78, 0x7b, 0xfb, 0xf5, 0xeb, 0x9a, 0x96, 0x99,
0xc9, 0xc7, 0xe1, 0x55, 0x63, 0x78, 0x11, 0xe1,
0xd0, 0xb6, 0x98, 0xd7, 0xa8, 0x8e, 0x05, 0x0a,
0xe0, 0x1b, 0x24, 0x00, 0xa5, 0xc2, 0x0f, 0x0d,
0xf5, 0xf4, 0x30, 0xf6, 0xe5, 0x8b, 0xc7, 0xf3,
0xfd, 0xbb, 0xa6, 0x1d, 0x38, 0x40, 0xa9, 0xa2,
0xb4, 0xb5, 0x5d, 0xbe, 0x3c, 0x3a, 0x3a, 0x36,
0x36, 0x32, 0xb2, 0x6e, 0x5d, 0x5e, 0x9e, 0xd3,
0x59, 0x58, 0x68, 0xb1, 0x04, 0x8f, 0x63, 0x7c,
0x1f, 0xec, 0xc5, 0xf8, 0xc2, 0x8b, 0x64, 0x0a,
0x9d, 0xf7, 0x37, 0x02, 0x8a, 0x8b, 0x53, 0x53,
0xcf, 0x9e, 0x35, 0x0e, 0x96, 0x60, 0x53, 0x94,
0xe0, 0x48, 0x18, 0x13, 0x78, 0xbd, 0xa3, 0xa3,
0x00, 0xaa, 0xda, 0xd1, 0x51, 0x5b, 0x4b, 0x69,
0x59, 0x99, 0xaa, 0x1e, 0x3c, 0xd8, 0xdb, 0x5b,
0x56, 0x36, 0x31, 0x31, 0x31, 0x31, 0x36, 0xe6,
0x72, 0xf1, 0x7e, 0x42, 0x88, 0xcf, 0x17, 0x3c,
0x9e, 0x38, 0xba, 0x42, 0xdb, 0xa1, 0x7e, 0x46,
0x01, 0xfc, 0xa7, 0xa9, 0xb6, 0xf6, 0xfe, 0xfd,
0x2b, 0x57, 0x66, 0xfb, 0xf7, 0x18, 0x1c, 0x0c,
0x5e, 0x52, 0x31, 0x90, 0xf8, 0xcf, 0x14, 0x13,
0x13, 0x22, 0x4e, 0x83, 0xee, 0xee, 0xfa, 0x7a,
0x4a, 0xab, 0xab, 0x15, 0xc5, 0xe5, 0x1a, 0x1c,
0x7c, 0xfb, 0x36, 0x2a, 0x2a, 0x2e, 0x0e, 0xe3,
0x7d, 0xfb, 0x78, 0xbf, 0xc9, 0x49, 0xee, 0x35,
0x6d, 0x66, 0x50, 0x31, 0x5e, 0xa8, 0xd0, 0x69,
0xd4, 0x30, 0x2f, 0x13, 0xa0, 0xa2, 0xf8, 0x44,
0x5b, 0x14, 0x95, 0xd8, 0xe6, 0x44, 0xae, 0xe2,
0x59, 0xb6, 0xe9, 0xd0, 0x14, 0x11, 0x81, 0x10,
0xe0, 0x22, 0xf7, 0x05, 0xb0, 0xe8, 0xf7, 0x6f,
0x9b, 0xa7, 0x80, 0x50, 0x33, 0x8a, 0x79, 0xe6,
0x76, 0xe8, 0xbe, 0x3d, 0x1b, 0x78, 0xa8, 0xff,
0x1f, 0xd9, 0xdf, 0xdd, 0x50, 0x87, 0x70, 0x35,
0xc2, 0x80, 0x45, 0x00, 0x00, 0x00, 0x22, 0x7a,
0x54, 0x58, 0x74, 0x53, 0x6f, 0x66, 0x74, 0x77,
0x61, 0x72, 0x65, 0x00, 0x00, 0x78, 0xda, 0x2b,
0x2f, 0x2f, 0xd7, 0xcb, 0xcc, 0xcb, 0x2e, 0x4e,
0x4e, 0x2c, 0x48, 0xd5, 0xcb, 0x2f, 0x4a, 0x07,
0x00, 0x36, 0xd8, 0x06, 0x58, 0x10, 0x53, 0xca,
0x5c, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82};
|
9aaecf516d4e40e9c166b66d4154c8ea6dc7657b
|
30c2631ed046d7662476b94fb7f5286c47377f60
|
/test/api/src/Pairs.c
|
6f2c33af2ba0a85e99890824bde851d2020be9b9
|
[
"MIT"
] |
permissive
|
SanderMertens/flecs
|
a840093340f0d1eb2bd30ec1585296f81f2aab39
|
41fb856c4e1162f44b59d7881ef508d64d56bf10
|
refs/heads/master
| 2023-08-24T16:21:41.790084
| 2023-08-24T08:38:57
| 2023-08-24T08:49:52
| 146,155,284
| 4,731
| 456
|
MIT
| 2023-09-05T16:01:58
| 2018-08-26T05:53:05
|
C
|
UTF-8
|
C
| false
| false
| 79,258
|
c
|
Pairs.c
|
#include <api.h>
typedef struct Rel {
float value;
} Rel;
typedef struct RelA {
float value;
} RelA;
typedef struct RelB {
float value;
} RelB;
typedef struct Obj {
float value;
} Obj;
void ProcessPairs(ecs_iter_t *it) {
Rel *tr = ecs_field(it, Rel, 1);
probe_iter(it);
if (tr) {
int32_t i;
for (i = 0; i < it->count; i ++) {
tr[i].value ++;
}
}
}
void Pairs_type_w_one_pair(void) {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ECS_SYSTEM(world, ProcessPairs, EcsOnUpdate, (Rel, *));
/* Ensure that pair is matched against different components */
ecs_entity_t e1 = ecs_set_pair(world, 0, Rel, ecs_id(Position), {
.value = 10
});
test_assert(e1 != 0);
test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
ecs_entity_t e2 = ecs_set_pair(world, 0, Rel, ecs_id(Velocity), {
.value = 20
});
test_assert(e2 != 0);
test_assert( ecs_has_pair(world, e2, ecs_id(Rel), ecs_id(Velocity)));
Probe ctx = {0};
ecs_set_ctx(world, &ctx, NULL);
ecs_progress(world, 0);
const Rel* tr = ecs_get_pair(world, e1, Rel, ecs_id(Position));
test_assert(tr != NULL);
test_int(tr->value, 11);
tr = ecs_get_pair(world, e2, Rel, ecs_id(Velocity));
test_assert(tr != NULL);
test_int(tr->value, 21);
test_int(ctx.count, 2);
test_int(ctx.invoked, 2);
test_int(ctx.system, ProcessPairs);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e1);
test_int(ctx.e[1], e2);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Position));
c = ctx.c[1][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Velocity));
test_int(ctx.s[0][0], 0);
test_int(ctx.s[1][0], 0);
ecs_fini(world);
}
void Pairs_type_w_two_pairs(void) {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ECS_SYSTEM(world, ProcessPairs, EcsOnUpdate, (Rel, *));
/* Ensure that pair is matched against different components on same entity */
ecs_entity_t e1 = ecs_new(world, 0);
ecs_set_pair(world, e1, Rel, ecs_id(Position), {
.value = 10
});
test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
ecs_set_pair(world, e1, Rel, ecs_id(Velocity), {
.value = 20
});
test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Velocity)));
ecs_entity_t e2 = ecs_new(world, 0);
ecs_set_pair(world, e2, Rel, ecs_id(Position), {
.value = 30
});
test_assert( ecs_has_pair(world, e2, ecs_id(Rel), ecs_id(Position)));
ecs_set_pair(world, e2, Rel, ecs_id(Velocity), {
.value = 40
});
test_assert( ecs_has_pair(world, e2, ecs_id(Rel), ecs_id(Position)));
Probe ctx = {0};
ecs_set_ctx(world, &ctx, NULL);
ecs_progress(world, 0);
const Rel* tr = ecs_get_pair(world, e1, Rel, ecs_id(Position));
test_assert(tr != NULL);
test_int(tr->value, 11);
tr = ecs_get_pair(world, e1, Rel, ecs_id(Velocity));
test_assert(tr != NULL);
test_int(tr->value, 21);
tr = ecs_get_pair(world, e2, Rel, ecs_id(Position));
test_assert(tr != NULL);
test_int(tr->value, 31);
tr = ecs_get_pair(world, e2, Rel, ecs_id(Velocity));
test_assert(tr != NULL);
test_int(tr->value, 41);
test_int(ctx.count, 4);
test_int(ctx.invoked, 2);
test_int(ctx.system, ProcessPairs);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e1);
test_int(ctx.e[1], e2);
test_int(ctx.e[2], e1);
test_int(ctx.e[3], e2);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Position));
c = ctx.c[1][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Velocity));
test_int(ctx.s[0][0], 0);
test_int(ctx.s[1][0], 0);
test_int(ctx.s[2][0], 0);
test_int(ctx.s[3][0], 0);
ecs_fini(world);
}
void Pairs_add_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ecs_entity_t e1 = ecs_new(world, 0);
test_assert(e1 != 0);
ecs_add_pair(world, e1, ecs_id(Rel), ecs_id(Position));
test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
ecs_fini(world);
}
void Pairs_remove_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ecs_entity_t e1 = ecs_set_pair(world, 0, Rel, ecs_id(Position), {
.value = 10
});
test_assert(e1 != 0);
test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
ecs_remove_pair(world, e1, ecs_id(Rel), ecs_id(Position));
test_assert( !ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
ecs_fini(world);
}
void ProcessPairTags(ecs_iter_t *it) {
probe_iter(it);
}
void Pairs_add_tag_pair_for_tag(void) {
ecs_world_t *world = ecs_init();
ECS_TAG(world, Tag1);
ECS_TAG(world, Tag2);
ECS_TAG(world, Rel);
ECS_SYSTEM(world, ProcessPairTags, EcsOnUpdate, (Rel, *));
/* Ensure that pair is matched against different components */
ecs_entity_t e1 = ecs_new(world, 0);
ecs_add_pair(world, e1, Rel, Tag1);
test_assert(e1 != 0);
test_assert( ecs_has_pair(world, e1, Rel, Tag1));
ecs_entity_t e2 = ecs_new(world, 0);
ecs_add_pair(world, e2, Rel, Tag2);
test_assert(e2 != 0);
test_assert( ecs_has_pair(world, e2, Rel, Tag2));
Probe ctx = {0};
ecs_set_ctx(world, &ctx, NULL);
ecs_progress(world, 0);
test_int(ctx.count, 2);
test_int(ctx.invoked, 2);
test_int(ctx.system, ProcessPairTags);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e1);
test_int(ctx.e[1], e2);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, Tag1);
c = ctx.c[1][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, Tag2);
test_int(ctx.s[0][0], 0);
test_int(ctx.s[1][0], 0);
ecs_fini(world);
}
void ProcessValuePairs(ecs_iter_t *it) {
/* Strictly speaking this can be either Position or Velocity, but they have
* the same layout. */
Position *p = ecs_field(it, Position, 1);
probe_iter(it);
if (p) {
int32_t i;
for (i = 0; i < it->count; i ++) {
p[i].x += 10;
p[i].y += 20;
}
}
}
void Pairs_add_tag_pair_for_component(void) {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_TAG(world, Rel);
ECS_SYSTEM(world, ProcessValuePairs, EcsOnUpdate, (Rel, *));
ecs_entity_t e1 = ecs_set_pair_object(world, 0, Rel, Position, {
.x = 1,
.y = 2
});
test_assert( ecs_has_pair(world, e1, Rel, ecs_id(Position)));
ecs_entity_t e2 = ecs_set_pair_object(world, 0, Rel, Velocity, {
.x = 3,
.y = 4
});
test_assert( ecs_has_pair(world, e2, Rel, ecs_id(Velocity)));
Probe ctx = {0};
ecs_set_ctx(world, &ctx, NULL);
ecs_progress(world, 0);
test_int(ctx.count, 2);
test_int(ctx.invoked, 2);
test_int(ctx.system, ProcessValuePairs);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e1);
test_int(ctx.e[1], e2);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, ecs_id(Position));
c = ctx.c[1][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, ecs_id(Velocity));
test_int(ctx.s[0][0], 0);
test_int(ctx.s[1][0], 0);
ecs_fini(world);
}
void ProcessTwoPairs(ecs_iter_t *it) {
RelA *tr_a = ecs_field(it, RelA, 1);
RelB *tr_b = ecs_field(it, RelB, 2);
probe_iter(it);
int32_t i;
for (i = 0; i < it->count; i ++) {
tr_a[i].value ++;
tr_b[i].value ++;
}
}
void Pairs_query_2_pairs(void) {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, RelA);
ECS_COMPONENT(world, RelB);
ECS_SYSTEM(world, ProcessTwoPairs, EcsOnUpdate, (RelA, *), (RelB, *));
/* Create entity with both RelA and RelB */
ecs_entity_t e1 = ecs_set_pair(world, 0, RelA, ecs_id(Position), {
.value = 1
});
ecs_set_pair(world, e1, RelB, ecs_id(Position), {
.value = 2
});
test_assert( ecs_has_pair(world, e1, ecs_id(RelA), ecs_id(Position)));
test_assert( ecs_has_pair(world, e1, ecs_id(RelB), ecs_id(Position)));
/* Create entity with only RelA. Should not be matched with system */
ecs_entity_t e2 = ecs_set_pair(world, 0, RelA, ecs_id(Position), {
.value = 3
});
test_assert( ecs_has_pair(world, e2, ecs_id(RelA), ecs_id(Position)));
/* Run system */
Probe ctx = {0};
ecs_set_ctx(world, &ctx, NULL);
ecs_progress(world, 0);
const RelA *tr_a = ecs_get_pair(world, e1, RelA, ecs_id(Position));
test_int(tr_a->value, 2);
const RelB *tr_b = ecs_get_pair(world, e1, RelB, ecs_id(Position));
test_int(tr_b->value, 3);
tr_a = ecs_get_pair(world, e2, RelA, ecs_id(Position));
test_int(tr_a->value, 3);
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, ProcessTwoPairs);
test_int(ctx.term_count, 2);
test_null(ctx.param);
test_int(ctx.e[0], e1);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(RelA));
test_int(lo, ecs_id(Position));
c = ctx.c[0][1];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(RelB));
test_int(lo, ecs_id(Position));
ecs_fini(world);
}
void Pairs_query_2_pairs_2_instances_per_type(void) {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, RelA);
ECS_COMPONENT(world, RelB);
ECS_SYSTEM(world, ProcessTwoPairs, EcsOnUpdate, (RelA, *), (RelB, *));
/* Create entity with both RelA and RelB, applied to two components*/
ecs_entity_t e1 = ecs_set_pair(world, 0, RelA, ecs_id(Position), {
.value = 1
});
ecs_set_pair(world, e1, RelB, ecs_id(Position), {
.value = 2
});
ecs_set_pair(world, e1, RelA, ecs_id(Velocity), {
.value = 3
});
ecs_set_pair(world, e1, RelB, ecs_id(Velocity), {
.value = 4
});
test_assert( ecs_has_pair(world, e1, ecs_id(RelA), ecs_id(Position)));
test_assert( ecs_has_pair(world, e1, ecs_id(RelB), ecs_id(Position)));
test_assert( ecs_has_pair(world, e1, ecs_id(RelA), ecs_id(Velocity)));
test_assert( ecs_has_pair(world, e1, ecs_id(RelB), ecs_id(Velocity)));
/* Run system */
Probe ctx = {0};
ecs_set_ctx(world, &ctx, NULL);
ecs_progress(world, 0);
const RelA *tr_a = ecs_get_pair(world, e1, RelA, ecs_id(Position));
test_int(tr_a->value, 3);
tr_a = ecs_get_pair(world, e1, RelA, ecs_id(Velocity));
test_int(tr_a->value, 5);
const RelB *tr_b = ecs_get_pair(world, e1, RelB, ecs_id(Position));
test_int(tr_b->value, 4);
tr_b = ecs_get_pair(world, e1, RelB, ecs_id(Velocity));
test_int(tr_b->value, 6);
test_int(ctx.count, 4);
test_int(ctx.invoked, 4);
test_int(ctx.system, ProcessTwoPairs);
test_int(ctx.term_count, 2);
test_null(ctx.param);
test_int(ctx.e[0], e1);
test_int(ctx.e[1], e1);
test_int(ctx.e[2], e1);
test_int(ctx.e[3], e1);
ecs_fini(world);
}
void Pairs_override_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Rel);
ecs_entity_t base = ecs_new(world, 0);
ecs_set_pair(world, base, Rel, ecs_id(Position), {.value = 10});
ecs_entity_t instance = ecs_new_w_pair(world, EcsIsA, base);
test_assert(ecs_has_pair(world, instance, ecs_id(Rel), ecs_id(Position)));
const Rel *t = ecs_get_pair(world, instance, Rel, ecs_id(Position));
test_assert(t != NULL);
test_int(t->value, 10);
const Rel *t_2 = ecs_get_pair(world, base, Rel, ecs_id(Position));
test_assert(t_2 != NULL);
test_assert(t == t_2);
ecs_add_pair(world, instance, ecs_id(Rel), ecs_id(Position));
t = ecs_get_pair(world, instance, Rel, ecs_id(Position));
test_assert(t != NULL);
test_int(t->value, 10);
test_assert(t != t_2);
ecs_fini(world);
}
void Pairs_override_tag_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Rel);
ecs_entity_t base = ecs_new(world, 0);
ecs_set_pair_object(world, base, Rel, Position, {.x = 10, .y = 20});
ecs_entity_t instance = ecs_new_w_pair(world, EcsIsA, base);
test_assert(ecs_has_pair(world, instance, Rel, ecs_id(Position)));
const Position *t = ecs_get_pair_object(world, instance, Rel, Position);
test_assert(t != NULL);
test_int(t->x, 10);
test_int(t->y, 20);
const Position *t_2 = ecs_get_pair_object(world, base, Rel, Position);
test_assert(t_2 != NULL);
test_assert(t == t_2);
ecs_add_pair(world, instance, Rel, ecs_id(Position));
t = ecs_get_pair_object(world, instance, Rel, Position);
test_assert(t != NULL);
test_int(t->x, 10);
test_int(t->y, 20);
test_assert(t != t_2);
ecs_fini(world);
}
static
void PairTrigger(ecs_iter_t *it) {
probe_iter(it);
}
void Pairs_on_add_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ECS_OBSERVER(world, PairTrigger, EcsOnAdd, (Rel, *));
Probe ctx = { 0 };
ecs_set_ctx(world, &ctx, NULL);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Position));
ecs_os_zeromem(&ctx);
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Velocity));
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
c = ctx.c[0][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Velocity));
ecs_fini(world);
}
void Pairs_on_add_pair_tag(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Rel);
ECS_OBSERVER(world, PairTrigger, EcsOnAdd, (Rel, Position));
Probe ctx = { 0 };
ecs_set_ctx(world, &ctx, NULL);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, Rel, ecs_id(Position));
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, ecs_id(Position));
ecs_fini(world);
}
void Pairs_on_remove_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ECS_OBSERVER(world, PairTrigger, EcsOnRemove, (Rel, *));
Probe ctx = { 0 };
ecs_set_ctx(world, &ctx, NULL);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Velocity));
test_int(ctx.count, 0);
ecs_remove_pair(world, e, ecs_id(Rel), ecs_id(Position));
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Position));
ecs_os_zeromem(&ctx);
ecs_remove_pair(world, e, ecs_id(Rel), ecs_id(Velocity));
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
c = ctx.c[0][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Velocity));
ecs_fini(world);
}
void Pairs_on_remove_pair_tag(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Rel);
ECS_OBSERVER(world, PairTrigger, EcsOnRemove, (Rel, Position));
Probe ctx = { 0 };
ecs_set_ctx(world, &ctx, NULL);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, Rel, ecs_id(Position));
test_int(ctx.count, 0);
ecs_remove_pair(world, e, Rel, ecs_id(Position));
test_int(ctx.count, 1);
test_int(ctx.invoked, 1);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, ecs_id(Position));
ecs_fini(world);
}
void Pairs_on_remove_pair_on_delete(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Rel);
ECS_OBSERVER(world, PairTrigger, EcsOnRemove, (Rel, *));
Probe ctx = { 0 };
ecs_set_ctx(world, &ctx, NULL);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Velocity));
test_int(ctx.count, 0);
ecs_delete(world, e);
test_int(ctx.count, 2);
test_int(ctx.invoked, 2);
test_int(ctx.system, PairTrigger);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Position));
test_int(ctx.e[1], e);
c = ctx.c[1][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, ecs_id(Rel));
test_int(lo, ecs_id(Velocity));
ecs_fini(world);
}
static
void PairTriggerPosition(ecs_iter_t *it) {
PairTrigger(it);
}
static
void PairTriggerVelocity(ecs_iter_t *it) {
PairTrigger(it);
}
void Pairs_on_remove_pair_tag_on_delete(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_TAG(world, Rel);
ECS_OBSERVER(world, PairTriggerPosition, EcsOnRemove, (Rel, Position));
ECS_OBSERVER(world, PairTriggerVelocity, EcsOnRemove, (Rel, Velocity));
Probe ctx = { 0 };
ecs_set_ctx(world, &ctx, NULL);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, Rel, ecs_id(Position));
ecs_add_pair(world, e, Rel, ecs_id(Velocity));
test_int(ctx.count, 0);
ecs_delete(world, e);
test_int(ctx.count, 2);
test_int(ctx.invoked, 2);
test_int(ctx.system, PairTriggerVelocity);
test_int(ctx.term_count, 1);
test_null(ctx.param);
test_int(ctx.e[0], e);
ecs_entity_t c = ctx.c[0][0];
ecs_entity_t hi = ECS_PAIR_FIRST(c);
ecs_entity_t lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, ecs_id(Position));
test_int(ctx.e[1], e);
c = ctx.c[1][0];
hi = ECS_PAIR_FIRST(c);
lo = ECS_PAIR_SECOND(c);
test_int(hi, Rel);
test_int(lo, ecs_id(Velocity));
ecs_fini(world);
}
void Pairs_pair_w_component_query(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Rel);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
ecs_query_t *q = ecs_query_new(world, "(Rel, Position)");
int32_t count = 0;
ecs_iter_t it = ecs_query_iter(world, q);
while (ecs_query_next(&it)) {
Rel *t = ecs_field(&it, Rel, 1);
test_assert(t != NULL);
int i;
for (i = 0; i < it.count; i ++) {
test_assert(it.entities[i] == e);
}
count += it.count;
}
test_assert(count == 1);
ecs_fini(world);
}
void Pairs_query_pair_or_component(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Rel);
ecs_entity_t e1 = ecs_new(world, 0);
ecs_add_pair(world, e1, Rel, ecs_id(Position));
ecs_entity_t e2 = ecs_new(world, Position);
ecs_query_t *q = ecs_query_new(world, "(Rel, Position) || Position");
int32_t count = 0;
ecs_iter_t it = ecs_query_iter(world, q);
while (ecs_query_next(&it)) {
int i;
for (i = 0; i < it.count; i ++) {
test_assert(it.entities[i] == e1 || it.entities[i] == e2);
}
count += it.count;
}
test_assert(count == 2);
ecs_fini(world);
}
void Pairs_query_pair_or_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ecs_entity_t e1 = ecs_new(world, 0);
ecs_add_pair(world, e1, RelA, ecs_id(Position));
ecs_entity_t e2 = ecs_new(world, Position);
ecs_add_pair(world, e2, RelB, ecs_id(Position));
ecs_query_t *q = ecs_query_new(world, "(RelA, Position) || (RelB, Position)");
int32_t count = 0;
ecs_iter_t it = ecs_query_iter(world, q);
while (ecs_query_next(&it)) {
int i;
for (i = 0; i < it.count; i ++) {
test_assert(it.entities[i] == e1 || it.entities[i] == e2);
}
count += it.count;
}
test_int(count, 2);
ecs_fini(world);
}
void Pairs_query_not_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Rel);
ecs_entity_t e1 = ecs_new(world, Position);
ecs_entity_t e2 = ecs_new(world, Position);
ecs_add_pair(world, e2, Rel, ecs_id(Position));
ecs_query_t *q = ecs_query_new(world, "!(Rel, Position), Position");
int32_t count = 0;
ecs_iter_t it = ecs_query_iter(world, q);
while (ecs_query_next(&it)) {
Position *t = ecs_field(&it, Position, 1);
test_assert(t == NULL);
Position *p = ecs_field(&it, Position, 2);
test_assert(p != NULL);
int i;
for (i = 0; i < it.count; i ++) {
test_assert(it.entities[i] == e1);
}
count += it.count;
}
test_assert(count == 1);
ecs_fini(world);
}
void Pairs_get_typeid_w_recycled_rel(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t o = ecs_new_id(world);
test_assert(o != 0);
ecs_entity_t dummy = ecs_new_id(world);
ecs_delete(world, dummy); // force recycle
// don't use ECS_COMPONENT, because it will try to get low ids first
ecs_entity_t pos = ecs_set(world, 0, EcsComponent, {1, 1});
test_assert(pos != 0);
test_assert((uint32_t)pos != pos); // ensure recycled
ecs_id_t pair = ecs_pair(pos, o);
ecs_entity_t tid = ecs_get_typeid(world, pair);
test_assert(tid != 0);
test_assert(tid == pos);
ecs_fini(world);
}
void Pairs_get_typeid_w_recycled_obj(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t r = ecs_new_id(world);
test_assert(r != 0);
ecs_entity_t dummy = ecs_new_id(world);
ecs_delete(world, dummy); // force recycle
// don't use ECS_COMPONENT, because it will try to get low ids first
ecs_entity_t pos = ecs_set(world, 0, EcsComponent, {1, 1});
test_assert(pos != 0);
test_assert((uint32_t)pos != pos); // ensure recycled
ecs_id_t pair = ecs_pair(r, pos);
ecs_entity_t tid = ecs_get_typeid(world, pair);
test_assert(tid != 0);
test_assert(tid == pos);
ecs_fini(world);
}
void Pairs_id_str_w_recycled_rel(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t o = ecs_set_name(world, 0, "o");
test_assert(o != 0);
ecs_entity_t dummy = ecs_new_id(world);
ecs_delete(world, dummy); // force recycle
ecs_entity_t r = ecs_set_name(world, 0, "r");
test_assert(r != 0);
test_assert((uint32_t)r != r); // ensure recycled
char *str = ecs_id_str(world, ecs_pair(r, o));
test_str(str, "(r,o)");
ecs_os_free(str);
ecs_fini(world);
}
void Pairs_id_str_w_recycled_obj(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t r = ecs_set_name(world, 0, "r");
test_assert(r != 0);
ecs_entity_t dummy = ecs_new_id(world);
ecs_delete(world, dummy); // force recycle
ecs_entity_t o = ecs_set_name(world, 0, "o");
test_assert(o != 0);
test_assert((uint32_t)o != o); // ensure recycled
char *str = ecs_id_str(world, ecs_pair(r, o));
test_str(str, "(r,o)");
ecs_os_free(str);
ecs_fini(world);
}
void Pairs_set_object_w_zero_sized_rel_comp(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t r = ecs_set(world, 0, EcsComponent, {0});
ECS_COMPONENT(world, Position);
ecs_entity_t e = ecs_set_pair_object(world, 0, r, Position, {10, 20});
const Position *p = ecs_get_pair_object(world, e, r, Position);
test_assert(p != NULL);
test_int(p->x, 10);
test_int(p->y, 20);
ecs_fini(world);
}
void Pairs_dsl_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.expr = "(Rel, Obj)"
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_dsl_pair_w_pred_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.expr = "(*, Obj)"
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e3);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_dsl_pair_w_obj_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.expr = "(Rel_2, *)"
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e3);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e4);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_dsl_pair_w_both_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ECS_TAG(world, Tag);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.expr = "(*, *), Tag" // add Tag or we'd match builtin entities
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj), Tag} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2), Tag} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj), Tag} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2), Tag} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e2);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj_2));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e3);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e4);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_dsl_pair_w_explicit_subj_this(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.expr = "Rel($This, Obj)"
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_dsl_pair_w_explicit_subj(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ECS_TAG(world, Tag);
ecs_entity_t Subj = ecs_entity_init(world, &(ecs_entity_desc_t){
.name = "Subj", .add = {ecs_pair(Rel, Obj)} });
test_assert(Subj != 0);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.expr = "Rel(Subj, Obj), Tag"
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2), Tag} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e4);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_int(ecs_field_src(&it, 1), Subj);
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_api_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.terms = {{ecs_pair(Rel, Obj)}}
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_api_pair_w_pred_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.terms = {{ecs_pair(EcsWildcard, Obj)}}
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e3);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_api_pair_w_obj_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.terms = {{ecs_pair(Rel_2, EcsWildcard)}}
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e3);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e4);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_api_pair_w_both_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ECS_TAG(world, Tag);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
// add Tag or we'd match builtin entities
.filter.terms = {{ecs_pair(EcsWildcard, EcsWildcard)}, {Tag}}
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj), Tag} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2), Tag} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj), Tag} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2), Tag} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e2);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj_2));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e3);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e4);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_api_pair_w_explicit_subj_this(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.terms = {
{ ecs_pair(Rel, Obj), .src.id = EcsThis }
}
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2)} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e1);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_api_pair_w_explicit_subj(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Rel_2);
ECS_TAG(world, Obj);
ECS_TAG(world, Obj_2);
ECS_TAG(world, Tag);
ecs_entity_t Subj = ecs_entity_init(world, &(ecs_entity_desc_t){
.name = "Subj", .add = {ecs_pair(Rel, Obj)} });
test_assert(Subj != 0);
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
.filter.terms = {{ecs_pair(Rel, Obj), .src.id = Subj}, {Tag}}
});
test_assert(q != NULL);
ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj)} });
test_assert(e1 != 0);
ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel, Obj_2)} });
test_assert(e2 != 0);
ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj)} });
test_assert(e3 != 0);
ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
.add = {ecs_pair(Rel_2, Obj_2), Tag} });
test_assert(e4 != 0);
ecs_iter_t it = ecs_query_iter(world, q);
test_bool(ecs_query_next(&it), true);
test_int(it.count, 1);
test_int(it.entities[0], e4);
test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
test_int(ecs_field_src(&it, 1), Subj);
test_bool(ecs_query_next(&it), false);
ecs_fini(world);
}
void Pairs_typeid_from_tag(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t tag = ecs_new_id(world);
test_assert(tag != 0);
ecs_entity_t id = ecs_get_typeid(world, tag);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_typeid_from_component(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Rel);
ecs_id_t rel_id = ecs_id(Rel);
test_assert(rel_id != 0);
ecs_entity_t id = ecs_get_typeid(world, rel_id);
test_assert(id != 0);
test_assert(id == rel_id);
ecs_fini(world);
}
void Pairs_typeid_from_pair(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t rel_id = ecs_new_id(world);
test_assert(rel_id != 0);
ecs_entity_t obj_id = ecs_new_id(world);
test_assert(obj_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_rel_type(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Rel);
ecs_id_t rel_id = ecs_id(Rel);
test_assert(rel_id != 0);
ecs_entity_t obj_id = ecs_new_id(world);
test_assert(obj_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id != 0);
test_assert(id == rel_id);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_obj_type(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Obj);
ecs_id_t obj_id = ecs_id(Obj);
test_assert(obj_id != 0);
ecs_entity_t rel_id = ecs_new_id(world);
test_assert(rel_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id != 0);
test_assert(id == obj_id);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_rel_obj_type(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Rel);
ecs_id_t rel_id = ecs_id(Rel);
test_assert(rel_id != 0);
ECS_COMPONENT(world, Obj);
ecs_id_t obj_id = ecs_id(Obj);
test_assert(obj_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id != 0);
test_assert(id == rel_id);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_rel_0_obj_type(void) {
ecs_world_t *world = ecs_mini();
ecs_id_t rel_id = ecs_set(world, 0, EcsComponent, {0});
test_assert(rel_id != 0);
ECS_COMPONENT(world, Obj);
ecs_id_t obj_id = ecs_id(Obj);
test_assert(obj_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id != 0);
test_assert(id == obj_id);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_rel_obj_0_type(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Rel);
ecs_id_t rel_id = ecs_id(Rel);
test_assert(rel_id != 0);
ecs_id_t obj_id = ecs_set(world, 0, EcsComponent, {0});
test_assert(obj_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id != 0);
test_assert(id == rel_id);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_rel_0_obj_0_type(void) {
ecs_world_t *world = ecs_mini();
ecs_id_t rel_id = ecs_set(world, 0, EcsComponent, {0});
test_assert(rel_id != 0);
ecs_id_t obj_id = ecs_set(world, 0, EcsComponent, {0});
test_assert(obj_id != 0);
ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_typeid_from_pair_with_0_obj(void) {
ecs_world_t *world = ecs_mini();
ecs_id_t pair_id = ecs_pair(EcsChildOf, 0);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_override(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Rel);
ecs_id_t rel_id = ecs_id(Rel);
test_assert(rel_id != 0);
ecs_entity_t obj_id = ecs_new_id(world);
test_assert(obj_id != 0);
ecs_id_t pair_id = ECS_OVERRIDE | ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_typeid_from_pair_w_toggle(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Rel);
ecs_id_t rel_id = ecs_id(Rel);
test_assert(rel_id != 0);
ecs_entity_t obj_id = ecs_new_id(world);
test_assert(obj_id != 0);
ecs_id_t pair_id = ECS_TOGGLE | ecs_pair(rel_id, obj_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_tag_pair_w_rel_comp(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Obj);
ecs_add_id(world, ecs_id(Position), EcsTag);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(ecs_id(Position), Obj);
ecs_add_id(world, e, pair_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_tag_pair_w_obj_comp(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_COMPONENT(world, Position);
ecs_add_id(world, Rel, EcsTag);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(Rel, ecs_id(Position));
ecs_add_id(world, e, pair_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_tag_pair_w_rel_obj_comp(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_add_id(world, ecs_id(Position), EcsTag);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(ecs_id(Position), ecs_id(Velocity));
ecs_add_id(world, e, pair_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_get_tag_pair_w_rel_comp(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Obj);
ecs_add_id(world, ecs_id(Position), EcsTag);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(ecs_id(Position), Obj);
ecs_add_id(world, e, pair_id);
test_expect_abort();
ecs_get_id(world, e, pair_id);
}
void Pairs_get_tag_pair_w_obj_comp(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_add_id(world, ecs_id(Position), EcsTag);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(ecs_id(Position), ecs_id(Velocity));
ecs_add_id(world, e, pair_id);
test_expect_abort();
ecs_get_id(world, e, pair_id);
}
void Pairs_get_tag_pair_w_rel_obj_comp(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_add_id(world, ecs_id(Position), EcsTag);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(ecs_id(Position), ecs_id(Velocity));
ecs_add_id(world, e, pair_id);
test_expect_abort();
ecs_get_id(world, e, pair_id);
}
void Pairs_tag_pair_w_childof_w_comp(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(EcsChildOf, ecs_id(Position));
ecs_add_id(world, e, pair_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_tag_pair_w_isa_w_comp(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ecs_entity_t e = ecs_new_id(world);
ecs_id_t pair_id = ecs_pair(EcsIsA, ecs_id(Position));
ecs_add_id(world, e, pair_id);
ecs_entity_t id = ecs_get_typeid(world, pair_id);
test_assert(id == 0);
ecs_fini(world);
}
void Pairs_get_1_target(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t e = ecs_new_id(world);
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t obj = ecs_new_id(world);
ecs_add_pair(world, e, rel, obj);
test_assert(ecs_has_pair(world, e, rel, obj));
test_assert(ecs_get_target(world, e, rel, 0) == obj);
ecs_fini(world);
}
void Pairs_get_1_target_not_found(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t e = ecs_new_id(world);
ecs_entity_t rel = ecs_new_id(world);
test_assert(ecs_get_target(world, e, rel, 0) == 0);
ecs_fini(world);
}
void Pairs_get_n_targets(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t e = ecs_new_id(world);
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t obj_1 = ecs_new_id(world);
ecs_entity_t obj_2 = ecs_new_id(world);
ecs_entity_t obj_3 = ecs_new_id(world);
ecs_add_pair(world, e, rel, obj_1);
ecs_add_pair(world, e, rel, obj_2);
ecs_add_pair(world, e, rel, obj_3);
test_assert(ecs_has_pair(world, e, rel, obj_1));
test_assert(ecs_has_pair(world, e, rel, obj_2));
test_assert(ecs_has_pair(world, e, rel, obj_3));
test_assert(ecs_get_target(world, e, rel, 0) == obj_1);
test_assert(ecs_get_target(world, e, rel, 1) == obj_2);
test_assert(ecs_get_target(world, e, rel, 2) == obj_3);
test_assert(ecs_get_target(world, e, rel, 3) == 0);
ecs_fini(world);
}
void Pairs_get_target_from_base(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t tgt = ecs_new_id(world);
ecs_entity_t base = ecs_new_w_pair(world, rel, tgt);
ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
test_assert(ecs_get_target(world, base, rel, 0) == tgt);
test_assert(ecs_get_target(world, inst, rel, 0) == tgt);
ecs_fini(world);
}
void Pairs_get_target_from_2nd_base(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t tgt = ecs_new_id(world);
ecs_entity_t base_1 = ecs_new_id(world);
ecs_entity_t base_2 = ecs_new_w_pair(world, rel, tgt);
ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_1);
ecs_add_pair(world, inst, EcsIsA, base_2);
test_assert(ecs_get_target(world, base_1, rel, 0) == 0);
test_assert(ecs_get_target(world, base_2, rel, 0) == tgt);
test_assert(ecs_get_target(world, inst, rel, 0) == tgt);
ecs_fini(world);
}
void Pairs_get_target_from_base_w_pair_on_instance(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t tgt_a = ecs_new_id(world);
ecs_entity_t tgt_b = ecs_new_id(world);
ecs_entity_t base = ecs_new_w_pair(world, rel, tgt_b);
ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
ecs_add_pair(world, inst, rel, tgt_a);
test_assert(ecs_get_target(world, base, rel, 0) == tgt_b);
test_assert(ecs_get_target(world, inst, rel, 0) == tgt_a);
test_assert(ecs_get_target(world, inst, rel, 1) == tgt_b);
ecs_fini(world);
}
void Pairs_get_childof_target_from_base(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t parent = ecs_new_id(world);
ecs_entity_t base = ecs_new_w_pair(world, EcsChildOf, parent);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
test_assert(ecs_has_pair(world, base, EcsChildOf, parent));
test_assert(!ecs_has_pair(world, e, EcsChildOf, parent));
test_assert(ecs_get_target(world, e, EcsChildOf, 0) == 0);
test_assert(ecs_get_target(world, e, EcsChildOf, 1) == 0);
ecs_fini(world);
}
void Pairs_get_dontinherit_target_from_base(void) {
ecs_world_t *world = ecs_mini();
ECS_ENTITY(world, Rel, DontInherit);
ecs_entity_t parent = ecs_new_id(world);
ecs_entity_t base = ecs_new_w_pair(world, Rel, parent);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
test_assert(ecs_has_pair(world, base, Rel, parent));
test_assert(!ecs_has_pair(world, e, Rel, parent));
test_assert(ecs_get_target(world, e, Rel, 0) == 0);
test_assert(ecs_get_target(world, e, Rel, 1) == 0);
ecs_fini(world);
}
void Pairs_get_parent(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t parent = ecs_new_id(world);
ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
test_assert(ecs_get_target(world, e, EcsChildOf, 0) == parent);
test_assert(ecs_get_parent(world, e) == parent);
ecs_fini(world);
}
void Pairs_get_parent_from_root(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t e = ecs_new_id(world);
test_assert(ecs_get_parent(world, e) == 0);
ecs_fini(world);
}
void Pairs_get_target_for_id_from_self(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t base = ecs_new(world, Tag);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_add_id(world, e, Tag);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
test_assert(result != 0);
test_assert(result == e);
ecs_fini(world);
}
void Pairs_get_target_for_id_from_base(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t base = ecs_new(world, Tag);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
test_assert(result != 0);
test_assert(result == base);
ecs_fini(world);
}
void Pairs_get_target_for_id_from_nested_base(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t base = ecs_new(world, Tag);
ecs_entity_t base_2 = ecs_new_w_pair(world, EcsIsA, base);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_2);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
test_assert(result != 0);
test_assert(result == base);
ecs_fini(world);
}
void Pairs_get_target_for_id_not_found(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t base = ecs_new_id(world);
ecs_entity_t base_2 = ecs_new_w_pair(world, EcsIsA, base);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_2);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
test_assert(result == 0);
ecs_fini(world);
}
void Pairs_get_target_for_wildcard_from_self(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Obj);
ecs_id_t pair = ecs_pair(Rel, Obj);
ecs_entity_t base = ecs_new_w_id(world, pair);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_add_id(world, e, pair);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA,
ecs_pair(Rel, EcsWildcard));
test_assert(result != 0);
test_assert(result == e);
ecs_fini(world);
}
void Pairs_get_target_for_wildcard_from_base(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Obj);
ecs_id_t pair = ecs_pair(Rel, Obj);
ecs_entity_t base = ecs_new_w_id(world, pair);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA,
ecs_pair(Rel, EcsWildcard));
test_assert(result != 0);
test_assert(result == base);
ecs_fini(world);
}
void Pairs_get_target_for_wildcard_from_nested_base(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Obj);
ecs_id_t pair = ecs_pair(Rel, Obj);
ecs_entity_t base = ecs_new_w_id(world, pair);
ecs_entity_t base_2 = ecs_new_w_pair(world, EcsIsA, base);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_2);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA,
ecs_pair(Rel, EcsWildcard));
test_assert(result != 0);
test_assert(result == base);
ecs_fini(world);
}
void Pairs_ignore_childof_from_base(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Obj);
ecs_entity_t parent = ecs_new_id(world);
ecs_entity_t base = ecs_new_w_pair(world, EcsChildOf, parent);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA,
ecs_pair(EcsChildOf, parent));
test_assert(result == 0);
ecs_fini(world);
}
void Pairs_get_target_for_id_from_empty(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t e = ecs_new_id(world);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
test_assert(result == 0);
ecs_fini(world);
}
void Pairs_get_target_for_id_from_empty_no_rel(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t e = ecs_new_id(world);
ecs_entity_t result = ecs_get_target_for_id(world, e, 0, Tag);
test_assert(result == 0);
ecs_fini(world);
}
void Pairs_get_target_for_id_not_empty_not_found(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ECS_TAG(world, TagB);
ecs_entity_t e = ecs_new(world, TagA);
ecs_entity_t result = ecs_get_target_for_id(world, e, 0, TagB);
test_assert(result == 0);
ecs_fini(world);
}
void Pairs_get_target_for_id_from_stage(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t base = ecs_new(world, Tag);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_world_t *stage = ecs_get_stage(world, 0);
ecs_readonly_begin(world);
ecs_entity_t result = ecs_get_target_for_id(stage, e, EcsIsA, Tag);
test_assert(result != 0);
test_assert(result == base);
ecs_readonly_end(world);
ecs_fini(world);
}
void Pairs_get_target_for_id_no_id(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t base = ecs_new(world, Tag);
ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
ecs_add_id(world, e, Tag);
ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, 0);
test_assert(result != 0);
test_assert(result == base);
ecs_fini(world);
}
void Pairs_add_exclusive_relation_twice(void) {
ecs_world_t *world = ecs_mini();
ECS_ENTITY(world, Rel, Exclusive);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, Rel, ObjA);
test_assert( ecs_has_pair(world, e, Rel, ObjA));
ecs_add_pair(world, e, Rel, ObjB);
test_assert( ecs_has_pair(world, e, Rel, ObjB));
test_assert( !ecs_has_pair(world, e, Rel, ObjA));
ecs_fini(world);
}
void Pairs_add_same_exclusive_relation_twice(void) {
ecs_world_t *world = ecs_mini();
ECS_ENTITY(world, Rel, Exclusive);
ECS_TAG(world, ObjA);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, Rel, ObjA);
test_assert( ecs_has_pair(world, e, Rel, ObjA));
ecs_add_pair(world, e, Rel, ObjA);
test_assert( ecs_has_pair(world, e, Rel, ObjA));
ecs_fini(world);
}
void Pairs_set_exclusive_relation_twice(void) {
ecs_world_t *world = ecs_mini();
ECS_COMPONENT(world, Position);
ECS_TAG(world, Start);
ECS_TAG(world, Stop);
ecs_add_id(world, ecs_id(Position), EcsExclusive);
ecs_entity_t e = ecs_new_id(world);
ecs_set_pair(world, e, Position, Start, {10, 20});
test_assert( ecs_has_pair(world, e, ecs_id(Position), Start));
ecs_set_pair(world, e, Position, Stop, {20, 30});
test_assert( ecs_has_pair(world, e, ecs_id(Position), Stop));
test_assert( !ecs_has_pair(world, e, ecs_id(Position), Start));
const Position *p = ecs_get_pair(world, e, Position, Stop);
test_assert(p != NULL);
test_int(p->x, 20);
test_int(p->y, 30);
p = ecs_get_pair(world, e, Position, Start);
test_assert(p == NULL);
ecs_fini(world);
}
void Pairs_add_exclusive_non_empty_table(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ECS_TAG(world, TagB);
ECS_TAG(world, TagC);
ECS_TAG(world, TagD);
ECS_ENTITY(world, Rel, Exclusive);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_entity_t e = ecs_new_id(world);
ecs_add(world, e, TagA);
ecs_add(world, e, TagB);
ecs_add(world, e, TagC);
ecs_add(world, e, TagD);
ecs_add_pair(world, e, Rel, ObjA);
test_assert( ecs_has_pair(world, e, Rel, ObjA));
ecs_add_pair(world, e, Rel, ObjB);
test_assert( ecs_has_pair(world, e, Rel, ObjB));
test_assert( !ecs_has_pair(world, e, Rel, ObjA));
ecs_fini(world);
}
void Pairs_add_exclusive_non_empty_table_w_pairs(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, RelA);
ECS_ENTITY(world, Rel, Exclusive);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ECS_TAG(world, RelB);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, RelA, ObjA);
ecs_add_pair(world, e, RelB, ObjA);
ecs_add_pair(world, e, Rel, ObjA);
test_assert( ecs_has_pair(world, e, Rel, ObjA));
ecs_add_pair(world, e, Rel, ObjB);
test_assert( ecs_has_pair(world, e, Rel, ObjB));
test_assert( !ecs_has_pair(world, e, Rel, ObjA));
ecs_fini(world);
}
void Pairs_add_pair_to_entity_w_exclusive_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, ObjA);
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, EcsChildOf, ObjA);
test_assert( ecs_has_pair(world, e, EcsChildOf, ObjA));
ecs_add_pair(world, e, RelA, ObjA);
test_assert( ecs_has_pair(world, e, RelA, ObjA));
ecs_add_pair(world, e, RelB, ObjA);
test_assert( ecs_has_pair(world, e, RelB, ObjA));
ecs_fini(world);
}
void Pairs_add_pair_to_entity_w_scope(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, ObjA);
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ecs_set_scope(world, ObjA);
ecs_entity_t e = ecs_new(world, 0);
ecs_add_pair(world, e, RelA, ObjA);
test_assert( ecs_has_pair(world, e, RelA, ObjA));
ecs_add_pair(world, e, RelB, ObjA);
test_assert( ecs_has_pair(world, e, RelB, ObjA));
ecs_set_scope(world, 0);
ecs_fini(world);
}
void Pairs_add_existing_exclusive_pair_after_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ECS_TAG(world, ObjA);
ecs_entity_t parent = ecs_new_id(world);
ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
ecs_add_pair(world, e, EcsChildOf, ObjA);
test_assert( ecs_has_pair(world, e, EcsChildOf, ObjA));
ecs_add_pair(world, e, RelA, ObjA);
test_assert( ecs_has_pair(world, e, EcsChildOf, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjA));
ecs_add_pair(world, e, EcsChildOf, ObjA);
test_assert( ecs_has_pair(world, e, EcsChildOf, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjA));
ecs_add_pair(world, e, RelB, ObjA);
test_assert( ecs_has_pair(world, e, EcsChildOf, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjA));
test_assert( ecs_has_pair(world, e, RelB, ObjA));
ecs_fini(world);
}
void Pairs_add_remove_exclusive_property(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t rel = ecs_new_w_id(world, EcsExclusive);
ecs_remove_id(world, rel, EcsExclusive);
ecs_entity_t tgt_1 = ecs_new_id(world);
ecs_entity_t tgt_2 = ecs_new_id(world);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, rel, tgt_1);
test_assert( ecs_has_pair(world, e, rel, tgt_1));
ecs_add_pair(world, e, rel, tgt_2);
test_assert( ecs_has_pair(world, e, rel, tgt_2));
test_assert( ecs_has_pair(world, e, rel, tgt_1));
ecs_fini(world);
}
void Pairs_add_symmetric_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_add_id(world, Rel, EcsSymmetric);
ecs_add_pair(world, ObjA, Rel, ObjB);
test_assert(ecs_has_pair(world, ObjA, Rel, ObjB));
test_assert(ecs_has_pair(world, ObjB, Rel, ObjA));
ecs_fini(world);
}
void Pairs_remove_symmetric_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_add_id(world, Rel, EcsSymmetric);
ecs_add_pair(world, ObjA, Rel, ObjB);
test_assert(ecs_has_pair(world, ObjA, Rel, ObjB));
test_assert(ecs_has_pair(world, ObjB, Rel, ObjA));
ecs_remove_pair(world, ObjA, Rel, ObjB);
test_assert(!ecs_has_pair(world, ObjA, Rel, ObjB));
test_assert(!ecs_has_pair(world, ObjB, Rel, ObjA));
ecs_fini(world);
}
void Pairs_delete_entity_w_symmetric_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_add_id(world, Rel, EcsSymmetric);
ecs_add_pair(world, ObjA, Rel, ObjB);
test_assert(ecs_has_pair(world, ObjA, Rel, ObjB));
test_assert(ecs_has_pair(world, ObjB, Rel, ObjA));
ecs_delete(world, ObjA);
test_assert(!ecs_has_pair(world, ObjB, Rel, ObjA));
ecs_fini(world);
}
void Pairs_add_symmetric_exclusive_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ECS_TAG(world, ObjC);
ecs_add_id(world, Rel, EcsSymmetric);
ecs_add_id(world, Rel, EcsExclusive);
ecs_add_pair(world, ObjA, Rel, ObjB);
test_assert(ecs_has_pair(world, ObjA, Rel, ObjB));
test_assert(ecs_has_pair(world, ObjB, Rel, ObjA));
ecs_add_pair(world, ObjA, Rel, ObjC);
test_assert(ecs_has_pair(world, ObjA, Rel, ObjC));
test_assert(!ecs_has_pair(world, ObjB, Rel, ObjA));
test_assert(ecs_has_pair(world, ObjC, Rel, ObjA));
ecs_fini(world);
}
void Pairs_add_symmetric_recycled_relation(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t obj_a = ecs_new_id(world);
ecs_entity_t obj_b = ecs_new_id(world);
ecs_delete(world, rel);
rel = ecs_new_id(world);
ecs_delete(world, obj_a);
obj_a = ecs_new_id(world);
ecs_delete(world, obj_b);
obj_b = ecs_new_id(world);
test_assert(rel != (uint32_t)rel);
test_assert(obj_a != (uint32_t)obj_a);
test_assert(obj_b != (uint32_t)obj_b);
ecs_add_id(world, rel, EcsSymmetric);
ecs_add_pair(world, obj_a, rel, obj_b);
test_assert(ecs_has_pair(world, obj_a, rel, obj_b));
test_assert(ecs_has_pair(world, obj_b, rel, obj_a));
ecs_fini(world);
}
void Pairs_with(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ECS_ENTITY(world, TagB, (With, TagA));
ecs_entity_t e = ecs_new_id(world);
ecs_add(world, e, TagB);
test_assert( ecs_has(world, e, TagA));
test_assert( ecs_has(world, e, TagB));
ecs_fini(world);
}
void Pairs_2_with(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ECS_TAG(world, TagB);
ECS_ENTITY(world, TagC, (With, TagA), (With, TagB));
ecs_entity_t e = ecs_new_id(world);
ecs_add(world, e, TagC);
test_assert( ecs_has(world, e, TagA));
test_assert( ecs_has(world, e, TagB));
test_assert( ecs_has(world, e, TagC));
ecs_fini(world);
}
void Pairs_nested_with(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ECS_ENTITY(world, TagB, (With, TagA));
ECS_ENTITY(world, TagC, (With, TagB));
ecs_entity_t e = ecs_new_id(world);
ecs_add(world, e, TagC);
test_assert( ecs_has(world, e, TagA));
test_assert( ecs_has(world, e, TagB));
test_assert( ecs_has(world, e, TagC));
ecs_fini(world);
}
void Pairs_with_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Obj);
ECS_TAG(world, RelA);
ECS_ENTITY(world, RelB, (With, RelA));
ecs_entity_t e = ecs_new_w_pair(world, RelB, Obj);
test_assert( ecs_has_pair(world, e, RelA, Obj));
test_assert( ecs_has_pair(world, e, RelB, Obj));
ecs_fini(world);
}
void Pairs_2_with_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Obj);
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ECS_ENTITY(world, RelC, (With, RelA), (With, RelB));
ecs_entity_t e = ecs_new_w_pair(world, RelC, Obj);
test_assert( ecs_has_pair(world, e, RelA, Obj));
test_assert( ecs_has_pair(world, e, RelB, Obj));
ecs_fini(world);
}
void Pairs_nested_with_relation(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Obj);
ECS_TAG(world, RelA);
ECS_ENTITY(world, RelB, (With, RelA));
ECS_ENTITY(world, RelC, (With, RelB));
ecs_entity_t e = ecs_new_w_pair(world, RelC, Obj);
test_assert( ecs_has_pair(world, e, RelA, Obj));
test_assert( ecs_has_pair(world, e, RelB, Obj));
test_assert( ecs_has_pair(world, e, RelC, Obj));
ecs_fini(world);
}
void Pairs_with_for_existing(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ECS_TAG(world, TagB);
ecs_entity_t e = ecs_new_id(world);
ecs_add(world, e, TagB);
test_assert( !ecs_has(world, e, TagA));
test_assert( ecs_has(world, e, TagB));
test_expect_abort();
ecs_add_pair(world, TagB, EcsWith, TagA);
}
void Pairs_65k_relations(void) {
ecs_world_t *world = ecs_mini();
ecs_set_entity_range(world, 65536, 0);
ecs_entity_t rel = ecs_new_id(world);
ecs_entity_t obj = ecs_new_id(world);
ecs_entity_t e = ecs_new_w_pair(world, rel, obj);
test_assert(ecs_has_pair(world, e, rel, obj));
ecs_fini(world);
}
void Pairs_remove_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, RelA, ObjA);
ecs_add_pair(world, e, RelA, ObjB);
ecs_add_pair(world, e, RelB, ObjA);
ecs_add_pair(world, e, RelB, ObjB);
test_assert( ecs_has_pair(world, e, RelA, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjB));
test_assert( ecs_has_pair(world, e, RelB, ObjA));
test_assert( ecs_has_pair(world, e, RelB, ObjB));
ecs_remove_pair(world, e, RelA, EcsWildcard);
test_assert( !ecs_has_pair(world, e, RelA, ObjA));
test_assert( !ecs_has_pair(world, e, RelA, ObjB));
test_assert( ecs_has_pair(world, e, RelB, ObjA));
test_assert( ecs_has_pair(world, e, RelB, ObjB));
ecs_fini(world);
}
void Pairs_remove_relation_wildcard(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, RelA, ObjA);
ecs_add_pair(world, e, RelA, ObjB);
ecs_add_pair(world, e, RelB, ObjA);
ecs_add_pair(world, e, RelB, ObjB);
test_assert( ecs_has_pair(world, e, RelA, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjB));
test_assert( ecs_has_pair(world, e, RelB, ObjA));
test_assert( ecs_has_pair(world, e, RelB, ObjB));
ecs_remove_pair(world, e, EcsWildcard, ObjA);
test_assert( !ecs_has_pair(world, e, RelA, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjB));
test_assert( !ecs_has_pair(world, e, RelB, ObjA));
test_assert( ecs_has_pair(world, e, RelB, ObjB));
ecs_fini(world);
}
void Pairs_add_not_alive_relation(void) {
ecs_world_t *world = ecs_mini();
ecs_entity_t obj = ecs_new_id(world);
ecs_entity_t e = ecs_new_w_pair(world, 2000, obj);
test_assert(ecs_has_pair(world, e, 2000, obj));
ecs_fini(world);
}
void Pairs_remove_wildcard_all(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, RelA);
ECS_TAG(world, RelB);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, RelA, ObjA);
ecs_add_pair(world, e, RelA, ObjB);
ecs_add_pair(world, e, RelB, ObjA);
ecs_add_pair(world, e, RelB, ObjB);
test_assert( ecs_has_pair(world, e, RelA, ObjA));
test_assert( ecs_has_pair(world, e, RelA, ObjB));
test_assert( ecs_has_pair(world, e, RelB, ObjA));
test_assert( ecs_has_pair(world, e, RelB, ObjB));
ecs_remove_pair(world, e, EcsWildcard, EcsWildcard);
test_assert( !ecs_has_pair(world, e, RelA, ObjA));
test_assert( !ecs_has_pair(world, e, RelA, ObjB));
test_assert( !ecs_has_pair(world, e, RelB, ObjA));
test_assert( !ecs_has_pair(world, e, RelB, ObjB));
ecs_fini(world);
}
void Pairs_inherit_exclusive(void) {
ecs_world_t *world = ecs_mini();
ECS_ENTITY(world, Rel, Exclusive);
ECS_TAG(world, ObjA);
ECS_TAG(world, ObjB);
ecs_entity_t base = ecs_new_w_pair(world, Rel, ObjA);
ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
test_assert( ecs_has_pair(world, inst, Rel, ObjA));
ecs_add_pair(world, inst, Rel, ObjB);
test_assert( ecs_has_pair(world, inst, Rel, ObjB));
test_assert( !ecs_has_pair(world, inst, Rel, ObjA));
ecs_fini(world);
}
void Pairs_dont_inherit(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, TagA);
ecs_add_id(world, TagA, EcsDontInherit);
ECS_TAG(world, TagB);
ecs_entity_t base = ecs_new_w_id(world, TagA);
ecs_add(world, base, TagB);
ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
test_assert( ecs_has(world, base, TagA));
test_assert( !ecs_has(world, inst, TagA));
test_assert( ecs_has(world, base, TagB));
test_assert( ecs_has(world, inst, TagB));
ecs_fini(world);
}
void Pairs_has_wildcard_w_pair(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Rel);
ECS_TAG(world, Obj);
ecs_entity_t e = ecs_new_w_pair(world, Rel, Obj);
test_bool(ecs_has_pair(world, e, EcsWildcard, EcsWildcard), true);
test_bool(ecs_has_pair(world, e, Rel, EcsWildcard), true);
test_bool(ecs_has_pair(world, e, EcsWildcard, Obj), true);
test_bool(ecs_has_pair(world, e, Rel, Obj), true);
test_bool(ecs_has_id(world, e, EcsWildcard), false);
ecs_fini(world);
}
void Pairs_has_pair_wildcard_w_tag(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Tag);
ecs_entity_t e = ecs_new(world, Tag);
test_bool(ecs_has_pair(world, e, EcsWildcard, EcsWildcard), false);
test_bool(ecs_has_id(world, e, Tag), true);
test_bool(ecs_has_id(world, e, EcsWildcard), true);
ecs_fini(world);
}
void Pairs_oneof_self(void) {
ecs_world_t *world = ecs_mini();
ECS_ENTITY(world, Rel, OneOf);
ECS_ENTITY(world, ObjA, (ChildOf, Rel));
ECS_ENTITY(world, ObjB, (ChildOf, Rel));
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, Rel, ObjA);
test_assert(ecs_has_pair(world, e, Rel, ObjA));
ecs_add_pair(world, e, Rel, ObjB);
test_assert(ecs_has_pair(world, e, Rel, ObjB));
ecs_fini(world);
}
void Pairs_oneof_other(void) {
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Parent);
ECS_ENTITY(world, Rel, (OneOf, Parent));
ECS_ENTITY(world, ObjA, (ChildOf, Parent));
ECS_ENTITY(world, ObjB, (ChildOf, Parent));
ecs_entity_t e = ecs_new_id(world);
ecs_add_pair(world, e, Rel, ObjA);
test_assert(ecs_has_pair(world, e, Rel, ObjA));
ecs_add_pair(world, e, Rel, ObjB);
test_assert(ecs_has_pair(world, e, Rel, ObjB));
ecs_fini(world);
}
void Pairs_oneof_self_constraint_violated(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_ENTITY(world, Rel, OneOf);
ECS_ENTITY(world, ObjA, (ChildOf, Rel));
ECS_ENTITY(world, ObjB, (ChildOf, Rel));
ECS_TAG(world, ObjC);
ecs_entity_t e = ecs_new_id(world);
test_expect_abort();
ecs_add_pair(world, e, Rel, ObjC);
}
void Pairs_oneof_other_constraint_violated(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Parent);
ECS_ENTITY(world, Rel, (OneOf, Parent));
ECS_ENTITY(world, ObjA, (ChildOf, Parent));
ECS_ENTITY(world, ObjB, (ChildOf, Parent));
ECS_TAG(world, ObjC);
ecs_entity_t e = ecs_new_id(world);
test_expect_abort();
ecs_add_pair(world, e, Rel, ObjC);
}
void Pairs_oneof_other_rel_parent_constraint_violated(void) {
install_test_abort();
ecs_world_t *world = ecs_mini();
ECS_TAG(world, Parent);
ECS_ENTITY(world, Rel, (OneOf, Parent));
ECS_ENTITY(world, ObjA, (ChildOf, Parent));
ECS_ENTITY(world, ObjB, (ChildOf, Parent));
ECS_ENTITY(world, ObjC, (ChildOf, Rel));
ecs_entity_t e = ecs_new_id(world);
test_expect_abort();
ecs_add_pair(world, e, Rel, ObjC);
}
|
4555c82564fb75b1fb2cf98f3dc13d2cabb0f99e
|
99bdb3251fecee538e0630f15f6574054dfc1468
|
/bsp/phytium/libraries/standalone/drivers/adc/fadc/fadc_hw.c
|
9695f562cdf5fe0f1bd9d9eb59c8586c64c16c58
|
[
"BSD-2-Clause",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0",
"Zlib",
"LicenseRef-scancode-proprietary-license",
"MIT",
"BSD-3-Clause",
"X11",
"BSD-4-Clause-UC"
] |
permissive
|
RT-Thread/rt-thread
|
03a7c52c2aeb1b06a544143b0e803d72f47d1ece
|
3602f891211904a27dcbd51e5ba72fefce7326b2
|
refs/heads/master
| 2023-09-01T04:10:20.295801
| 2023-08-31T16:20:55
| 2023-08-31T16:20:55
| 7,408,108
| 9,599
| 5,805
|
Apache-2.0
| 2023-09-14T13:37:26
| 2013-01-02T14:49:21
|
C
|
UTF-8
|
C
| false
| false
| 2,699
|
c
|
fadc_hw.c
|
/*
* Copyright : (C) 2022 Phytium Information Technology, Inc.
* All Rights Reserved.
*
* This program is OPEN SOURCE software: you can redistribute it and/or modify it
* under the terms of the Phytium Public License as published by the Phytium Technology Co.,Ltd,
* either version 1.0 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 Phytium Public License for more details.
*
*
* FilePath: fadc_hw.c
* Date: 2022-02-10 14:53:42
* LastEditTime: 2022-02-25 11:45:05
* Description: This file is for adc register implementation.
*
* Modify History:
* Ver Who Date Changes
* ----- ------ -------- --------------------------------------
* 1.0 wangxiaodong 2022/4/15 init commit
*/
#include "fparameters.h"
#include "fadc_hw.h"
#include "stdio.h"
#define FADC_DEBUG_TAG "FT_ADC_HW"
#define FADC_DEBUG(format, ...) FT_DEBUG_PRINT_D(FADC_DEBUG_TAG, format, ##__VA_ARGS__)
#define FADC_INFO(format, ...) FT_DEBUG_PRINT_I(FADC_DEBUG_TAG, format, ##__VA_ARGS__)
#define FADC_WARN(format, ...) FT_DEBUG_PRINT_W(FADC_DEBUG_TAG, format, ##__VA_ARGS__)
#define FADC_ERROR(format, ...) FT_DEBUG_PRINT_E(FADC_DEBUG_TAG, format, ##__VA_ARGS__)
/**
* @name: FAdcDump
* @msg: debug register value for adc channel.
* @param {uintptr} base_addr, base address of FADC controller
* @param {u8} channel, adc channel number
* @return {*}
*/
void FAdcDump(uintptr base_addr, u8 channel)
{
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_CTRL_REG_OFFSET, FADC_READ_REG32(base_addr, FADC_CTRL_REG_OFFSET));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_INTER_REG_OFFSET, FADC_READ_REG32(base_addr, FADC_INTER_REG_OFFSET));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_STATE_REG_OFFSET, FADC_READ_REG32(base_addr, FADC_STATE_REG_OFFSET));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_INTRMASK_REG_OFFSET, FADC_READ_REG32(base_addr, FADC_INTRMASK_REG_OFFSET));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_INTR_REG_OFFSET, FADC_READ_REG32(base_addr, FADC_INTR_REG_OFFSET));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_COV_RESULT_REG_OFFSET(channel), FADC_READ_REG32(base_addr, FADC_COV_RESULT_REG_OFFSET(channel)));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_FINISH_CNT_REG_OFFSET(channel), FADC_READ_REG32(base_addr, FADC_FINISH_CNT_REG_OFFSET(channel)));
FADC_INFO("Off[0x%02x]: = 0x%08x", FADC_HIS_LIMIT_REG_OFFSET(channel), FADC_READ_REG32(base_addr, FADC_HIS_LIMIT_REG_OFFSET(channel)));
FADC_INFO("");
}
|
a41a66ee814a6586e2fd3512cff23ebfab2e664a
|
7744859512f027ef0da8b1bde0f8518e631b98eb
|
/soh/assets/scenes/indoors/nakaniwa/nakaniwa_scene.h
|
123004dbfe70adb385220807897191dcc52635ea
|
[] |
no_license
|
HarbourMasters/Shipwright
|
7f70b9470e4f9a117f3fe2d6e4deb776b8742182
|
0e7c6585239c0d7ea2c039b8b8cb7eaedf8928a9
|
refs/heads/develop
| 2023-08-31T20:50:56.253521
| 2023-08-30T17:34:06
| 2023-08-30T17:34:06
| 472,575,717
| 2,104
| 459
| null | 2023-09-14T20:29:01
| 2022-03-22T01:42:52
|
C
|
UTF-8
|
C
| false
| false
| 1,377
|
h
|
nakaniwa_scene.h
|
#pragma once
#include "align_asset_macro.h"
#define dgZeldasCourtyardGanonCs "__OTR__scenes/nonmq/nakaniwa_scene/gZeldasCourtyardGanonCs"
static const ALIGN_ASSET(2) char gZeldasCourtyardGanonCs[] = dgZeldasCourtyardGanonCs;
#define dgZeldasCourtyardWindowCs "__OTR__scenes/nonmq/nakaniwa_scene/gZeldasCourtyardWindowCs"
static const ALIGN_ASSET(2) char gZeldasCourtyardWindowCs[] = dgZeldasCourtyardWindowCs;
#define dgZeldasCourtyardMeetCs "__OTR__scenes/nonmq/nakaniwa_scene/gZeldasCourtyardMeetCs"
static const ALIGN_ASSET(2) char gZeldasCourtyardMeetCs[] = dgZeldasCourtyardMeetCs;
#define dgZeldasCourtyardLullabyCs "__OTR__scenes/nonmq/nakaniwa_scene/gZeldasCourtyardLullabyCs"
static const ALIGN_ASSET(2) char gZeldasCourtyardLullabyCs[] = dgZeldasCourtyardLullabyCs;
#define dnakaniwa_sceneCollisionHeader_001BC8 "__OTR__scenes/nonmq/nakaniwa_scene/nakaniwa_sceneCollisionHeader_001BC8"
static const ALIGN_ASSET(2) char nakaniwa_sceneCollisionHeader_001BC8[] = dnakaniwa_sceneCollisionHeader_001BC8;
#define dnakaniwa_sceneCollisionHeader_001BC8 "__OTR__scenes/nonmq/nakaniwa_scene/nakaniwa_sceneCollisionHeader_001BC8"
#define dnakaniwa_sceneCollisionHeader_001BC8 "__OTR__scenes/nonmq/nakaniwa_scene/nakaniwa_sceneCollisionHeader_001BC8"
#define dnakaniwa_sceneCollisionHeader_001BC8 "__OTR__scenes/nonmq/nakaniwa_scene/nakaniwa_sceneCollisionHeader_001BC8"
|
e6853343f919710933ebefc2d0cfd5ef0b54f7cf
|
baf824f8819f90928e11480d0eae89efb60341a1
|
/ports/nxp_rt1050_60/sdcard.c
|
479cf72042e9b03d950a4ff3a56b46c089bb6e10
|
[
"GPL-1.0-or-later",
"MIT"
] |
permissive
|
RockySong/micropython-rocky
|
549770723ba92cb311c468880ead0ffdd4fa8fe5
|
2d728f414bf8d041ca609e00448850759aade3cd
|
refs/heads/omv_initial_integrate
| 2021-05-12T12:20:18.404341
| 2021-01-15T01:15:48
| 2021-01-15T01:15:48
| 117,408,452
| 198
| 90
|
MIT
| 2020-08-25T03:31:32
| 2018-01-14T06:40:36
|
C
|
UTF-8
|
C
| false
| false
| 22,807
|
c
|
sdcard.c
|
/*
* This file is part of the Micro Python project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2013, 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <string.h>
#include "py/nlr.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "lib/oofatfs/ff.h"
#include "extmod/vfs_fat.h"
#include "fsl_debug_console.h"
#include "fsl_sdmmc_host.h"
#include "fsl_sd.h"
#include "sdcard.h"
#include "pin.h"
#include "genhdr/pins.h"
#include "bufhelper.h"
#include "dma.h"
#include "irq.h"
#include "composite.h" // for "USB_DEVICE_INTERRUPT_PRIORITY" macro
#undef usb_echo
#define usb_echo(...) mp_printf(MP_PYTHON_PRINTER, __VA_ARGS__)
#if MICROPY_HW_HAS_SDCARD
// TODO: Since SDIO is fundamentally half-duplex, we really only need to
// tie up one DMA channel. However, the HAL DMA API doesn't
// seem to provide a convenient way to change the direction. I believe that
// its as simple as changing the CR register and the Init.Direction field
// and make DMA_SetConfig public.
// TODO: I think that as an optimization, we can allocate these dynamically
// if an sd card is detected. This will save approx 260 bytes of RAM
// when no sdcard was being used.
// static SD_HandleTypeDef g_sd;
// static DMA_HandleTypeDef sd_rx_dma, sd_tx_dma;
/* State in Card driver. */
typedef sd_card_t SD_HandleTypeDef;
// g_sd must NOT be put in cacheable RAM
sd_card_t g_sd;
/*! @brief SDMMC host detect card configuration */
bool s_cardInserted = false;
void SDCARD_DetectCallBack(bool isInserted, void *userData)
{
s_cardInserted = isInserted;
}
static const sdmmchost_detect_card_t s_sdCardDetect = {
#ifndef BOARD_SD_DETECT_TYPE
.cdType = kSDMMCHOST_DetectCardByGpioCD,
#else
.cdType = BOARD_SD_DETECT_TYPE,
#endif
.cdTimeOut_ms = (~0U),
.cardInserted = SDCARD_DetectCallBack,
.cardRemoved = SDCARD_DetectCallBack,
};
void _sdcard_pin_init(void)
{
CLOCK_EnableClock(kCLOCK_Iomuxc); /* iomuxc clock (iomuxc_clk_enable): 0x03u */
IOMUXC_SetPinMux(
IOMUXC_GPIO_AD_B0_05_GPIO1_IO05, /* GPIO_AD_B0_05 is configured as GPIO1_IO05 */
0U); /* Software Input On Field: Input Path is determined by functionality */ /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux( // SD_CD
IOMUXC_GPIO_B1_12_GPIO2_IO28, /* GPIO_B1_12 is configured as GPIO2_IO28 */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_B1_14_USDHC1_VSELECT, /* GPIO_B1_14 is configured as USDHC1_VSELECT */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_SD_B0_00_USDHC1_CMD, /* GPIO_SD_B0_00 is configured as USDHC1_CMD */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_SD_B0_01_USDHC1_CLK, /* GPIO_SD_B0_01 is configured as USDHC1_CLK */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0, /* GPIO_SD_B0_02 is configured as USDHC1_DATA0 */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1, /* GPIO_SD_B0_03 is configured as USDHC1_DATA1 */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2, /* GPIO_SD_B0_04 is configured as USDHC1_DATA2 */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinMux(
IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3, /* GPIO_SD_B0_05 is configured as USDHC1_DATA3 */
0U); /* Software Input On Field: Input Path is determined by functionality */
IOMUXC_SetPinConfig(
IOMUXC_GPIO_AD_B0_05_GPIO1_IO05, /* GPIO_AD_B0_05 PAD functional properties : */
0x10B0u); /* Slew Rate Field: Slow Slew Rate
Drive Strength Field: R0/6
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Keeper
Pull Up / Down Config. Field: 100K Ohm Pull Down
Hyst. Enable Field: Hysteresis Disabled */
IOMUXC_SetPinConfig( // SD0_CD_SW
IOMUXC_GPIO_B1_12_GPIO2_IO28, /* GPIO_B1_12 PAD functional properties : */
0x017089u); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
IOMUXC_SetPinConfig( // SD0_VSELECT
IOMUXC_GPIO_B1_14_USDHC1_VSELECT, /* GPIO_B1_14 PAD functional properties : */
0x0170A1u); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0/4
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
IOMUXC_SetPinConfig(
IOMUXC_GPIO_SD_B0_00_USDHC1_CMD, /* GPIO_SD_B0_00 PAD functional properties : */
0x017089u); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
uint32_t padDrv = 1<<0 | 3<<6 | 5<<3;
IOMUXC_SetPinConfig(
IOMUXC_GPIO_SD_B0_01_USDHC1_CLK, /* GPIO_SD_B0_01 PAD functional properties : */
0x014000u | padDrv); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Disabled
Pull / Keep Select Field: Keeper
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
IOMUXC_SetPinConfig(
IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0, /* GPIO_SD_B0_02 PAD functional properties : */
0x017000u | padDrv); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
IOMUXC_SetPinConfig(
IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1, /* GPIO_SD_B0_03 PAD functional properties : */
0x017000u | padDrv); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
IOMUXC_SetPinConfig(
IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2, /* GPIO_SD_B0_04 PAD functional properties : */
0x017000u | padDrv); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
IOMUXC_SetPinConfig(
IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3, /* GPIO_SD_B0_05 PAD functional properties : */
0x017000u | padDrv); /* Slew Rate Field: Fast Slew Rate
Drive Strength Field: R0(260 Ohm @ 3.3V, 150 Ohm@1.8V, 240 Ohm for DDR)
Speed Field: medium(100MHz)
Open Drain Enable Field: Open Drain Disabled
Pull / Keep Enable Field: Pull/Keeper Enabled
Pull / Keep Select Field: Pull
Pull Up / Down Config. Field: 47K Ohm Pull Up
Hyst. Enable Field: Hysteresis Enabled */
}
static void USDHCClockConfiguration(void)
{
/*configure system pll PFD2 fractional divider to 18*/
CLOCK_InitSysPfd(kCLOCK_Pfd0, 0x12U);
/* Configure USDHC clock source and divider */
CLOCK_SetDiv(kCLOCK_Usdhc1Div, 0U);
CLOCK_SetMux(kCLOCK_Usdhc1Mux, 1U);
}
status_t sdcard_init(void) {
// invalidate the g_sd
// sdtest_main();
g_sd.isHostReady = 0;
_sdcard_pin_init();
USDHCClockConfiguration();
status_t error = kStatus_Success;
NVIC_SetPriority(SD_HOST_IRQ, IRQ_PRI_SDIO);
g_sd.host.base = SD_HOST_BASEADDR;
g_sd.host.sourceClock_Hz = SD_HOST_CLK_FREQ;
g_sd.usrParam.cd = &s_sdCardDetect;
/* Init card. */
if (SD_HostInit(&g_sd))
{
mp_print_str(MP_PYTHON_PRINTER, "\n SD card init failed \n");
error = kStatus_Fail;
} else {
}
SD_PowerOnCard(g_sd.host.base, g_sd.usrParam.pwr);
/* wait card insert */
uint32_t t1 = HAL_GetTick();
while (!s_cardInserted)
{
if (HAL_GetTick() - t1 > 200)
break;
}
if(s_cardInserted){
PRINTF("\r\nCard inserted.\r\n");
/* reset host once card re-plug in */
SD_HostReset(&(g_sd.host));
/* Init card. */
if (SD_CardInit(&g_sd))
{
PRINTF("\r\nSD card init failed.\r\n");
return -1;
}
}
else{
PRINTF("Without card inserted, booting from flash.\r\n");
}
return error;
}
status_t sdcard_deinit(void)
{
SD_Deinit(&g_sd);
return kStatus_Success;
}
void HAL_SD_MspInit(SD_HandleTypeDef *hsd) {
// todo: low level init
}
void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd) {
// todo: low level deinit
}
bool sdcard_is_present(void) {
if (SD_IsCardPresent(&g_sd) && g_sd.isHostReady)
return 1;
return 0;}
bool sdcard_power_on(void) {
if (!sdcard_is_present()) {
return false;
}
if (g_sd.isHostReady) {
return true;
}
if (sdcard_init() == kStatus_Success)
return 1;
sdcard_deinit();
return 0;
}
void sdcard_power_off(void) {
if (!g_sd.isHostReady) {
return;
}
SD_Deinit(&g_sd);
}
uint32_t sdcard_get_lba_count(void)
{
return g_sd.blockCount;
}
uint64_t sdcard_get_capacity_in_bytes(void) {
if (g_sd.isHostReady == 0) {
return 0;
}
return (uint64_t)g_sd.blockCount * g_sd.blockSize;
}
__STATIC_INLINE uint32_t MyNVIC_GetEnabledIRQ(IRQn_Type IRQn)
{
return((uint32_t)(((NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
}
mp_uint_t sdcard_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks) {
// check that SD card is initialised
status_t ret;
if (g_sd.isHostReady == 0) {
return kStatus_Fail;
}
uint32_t usbIrqEn = MyNVIC_GetEnabledIRQ(USB_OTG1_IRQn);
if (usbIrqEn)
NVIC_DisableIRQ(USB_OTG1_IRQn);
ret = SD_ReadBlocks(&g_sd, dest, block_num, num_blocks);
if (usbIrqEn)
NVIC_EnableIRQ(USB_OTG1_IRQn);
return ret;
}
mp_uint_t sdcard_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks) {
// check that SD card is initialised
// check that SD card is initialised
status_t ret;
if (g_sd.isHostReady == 0) {
return kStatus_Fail;
}
uint32_t usbIrqEn = MyNVIC_GetEnabledIRQ(USB_OTG1_IRQn);
if (usbIrqEn)
NVIC_DisableIRQ(USB_OTG1_IRQn);
ret = SD_WriteBlocks(&g_sd, src, block_num, num_blocks);
if (usbIrqEn)
NVIC_EnableIRQ(USB_OTG1_IRQn);
return ret;
}
/******************************************************************************/
// Micro Python bindings
//
// Expose the SD card as an object with the block protocol.
// there is a singleton SDCard object
const mp_obj_base_t pyb_sdcard_obj = {&pyb_sdcard_type};
STATIC mp_obj_t pyb_sdcard_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
// check arguments
mp_arg_check_num(n_args, n_kw, 0, 0, false);
// return singleton object
return (mp_obj_t)&pyb_sdcard_obj;
}
STATIC mp_obj_t sd_present(mp_obj_t self) {
return mp_obj_new_bool(sdcard_is_present());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(sd_present_obj, sd_present);
STATIC mp_obj_t sd_power(mp_obj_t self, mp_obj_t state) {
bool result;
if (mp_obj_is_true(state)) {
result = sdcard_power_on();
} else {
sdcard_power_off();
result = true;
}
return mp_obj_new_bool(result);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(sd_power_obj, sd_power);
STATIC mp_obj_t sd_info(mp_obj_t self) {
if (g_sd.isHostReady == 0 || SD_IsCardPresent(&g_sd)) {
return mp_const_none;
}
// cardinfo.SD_csd and cardinfo.SD_cid have lots of info but we don't use them
mp_obj_t tuple[3] = {
mp_obj_new_int_from_ull(g_sd.blockCount * g_sd.blockSize),
mp_obj_new_int_from_uint(g_sd.blockSize),
mp_obj_new_int(g_sd.busClock_Hz / 1000),
};
return mp_obj_new_tuple(3, tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(sd_info_obj, sd_info);
// now obsolete, kept for backwards compatibility
STATIC mp_obj_t sd_read(mp_obj_t self, mp_obj_t block_num) {
uint8_t *dest = m_new(uint8_t, SDCARD_BLOCK_SIZE);
mp_uint_t ret = sdcard_read_blocks(dest, mp_obj_get_int(block_num), 1);
if (ret != 0) {
m_del(uint8_t, dest, SDCARD_BLOCK_SIZE);
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "sdcard_read_blocks failed [%u]", ret));
}
return mp_obj_new_bytearray_by_ref(SDCARD_BLOCK_SIZE, dest);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(sd_read_obj, sd_read);
// now obsolete, kept for backwards compatibility
STATIC mp_obj_t sd_write(mp_obj_t self, mp_obj_t block_num, mp_obj_t data) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len % SDCARD_BLOCK_SIZE != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "writes must be a multiple of %d bytes", SDCARD_BLOCK_SIZE));
}
mp_uint_t ret = sdcard_write_blocks(bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / SDCARD_BLOCK_SIZE);
if (ret != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "sdcard_write_blocks failed [%u]", ret));
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(sd_write_obj, sd_write);
STATIC mp_obj_t pyb_sdcard_readblocks(mp_obj_t self, mp_obj_t block_num, mp_obj_t buf) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_WRITE);
mp_uint_t ret = sdcard_read_blocks(bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / SDCARD_BLOCK_SIZE);
return mp_obj_new_bool(ret == 0);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sdcard_readblocks_obj, pyb_sdcard_readblocks);
STATIC mp_obj_t pyb_sdcard_writeblocks(mp_obj_t self, mp_obj_t block_num, mp_obj_t buf) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
mp_uint_t ret = sdcard_write_blocks(bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / SDCARD_BLOCK_SIZE);
return mp_obj_new_bool(ret == 0);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sdcard_writeblocks_obj, pyb_sdcard_writeblocks);
STATIC mp_obj_t pyb_sdcard_ioctl(mp_obj_t self, mp_obj_t cmd_in, mp_obj_t arg_in) {
mp_int_t cmd = mp_obj_get_int(cmd_in);
switch (cmd) {
case MP_BLOCKDEV_IOCTL_INIT:
if (!sdcard_power_on()) {
return MP_OBJ_NEW_SMALL_INT(-1); // error
}
return MP_OBJ_NEW_SMALL_INT(0); // success
case MP_BLOCKDEV_IOCTL_DEINIT:
sdcard_power_off();
return MP_OBJ_NEW_SMALL_INT(0); // success
case MP_BLOCKDEV_IOCTL_SYNC:
// nothing to do
return MP_OBJ_NEW_SMALL_INT(0); // success
case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
return MP_OBJ_NEW_SMALL_INT(sdcard_get_capacity_in_bytes() / SDCARD_BLOCK_SIZE);
case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
return MP_OBJ_NEW_SMALL_INT(SDCARD_BLOCK_SIZE);
default: // unknown command
return MP_OBJ_NEW_SMALL_INT(-1); // error
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sdcard_ioctl_obj, pyb_sdcard_ioctl);
STATIC const mp_rom_map_elem_t pyb_sdcard_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_present), MP_ROM_PTR(&sd_present_obj) },
{ MP_ROM_QSTR(MP_QSTR_power), MP_ROM_PTR(&sd_power_obj) },
{ MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&sd_info_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&sd_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&sd_write_obj) },
// block device protocol
{ MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&pyb_sdcard_readblocks_obj) },
{ MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&pyb_sdcard_writeblocks_obj) },
{ MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&pyb_sdcard_ioctl_obj) },
};
STATIC MP_DEFINE_CONST_DICT(pyb_sdcard_locals_dict, pyb_sdcard_locals_dict_table);
const mp_obj_type_t pyb_sdcard_type = {
{ &mp_type_type },
.name = MP_QSTR_SDCard,
.make_new = pyb_sdcard_make_new,
.locals_dict = (mp_obj_dict_t*)&pyb_sdcard_locals_dict,
};
void sdcard_init_vfs(fs_user_mount_t *vfs, int part) {
vfs->base.type = &mp_fat_vfs_type;
vfs->blockdev.flags |= MP_BLOCKDEV_FLAG_NATIVE | MP_BLOCKDEV_FLAG_HAVE_IOCTL;
vfs->fatfs.drv = vfs;
vfs->fatfs.part = part;
vfs->blockdev.readblocks[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_readblocks_obj);
vfs->blockdev.readblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
vfs->blockdev.readblocks[2] = MP_OBJ_FROM_PTR(sdcard_read_blocks); // native version
vfs->blockdev.writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_writeblocks_obj);
vfs->blockdev.writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
vfs->blockdev.writeblocks[2] = MP_OBJ_FROM_PTR(sdcard_write_blocks); // native version
vfs->blockdev.u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_ioctl_obj);
vfs->blockdev.u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
}
#endif // MICROPY_HW_HAS_SDCARD
|
74df2b2f47ce090b668ff4bf07ec0b83068c7a2c
|
76f7459a09acb9be2d52407132f5ff8955627da2
|
/frame/compat/cblas/src/extra/cblas_saxpby.c
|
685282123055a88d4cf9a7b979c8969459db99fa
|
[
"BSD-3-Clause"
] |
permissive
|
flame/blis
|
448bc0ad139b726188129c5627c304274b41c3c1
|
6dcf7666eff14348e82fbc2750be4b199321e1b9
|
refs/heads/master
| 2023-09-01T14:56:11.920485
| 2023-08-27T19:18:57
| 2023-08-27T19:18:57
| 16,143,904
| 1,696
| 361
|
NOASSERTION
| 2023-08-27T19:18:58
| 2014-01-22T15:58:24
|
C
|
UTF-8
|
C
| false
| false
| 647
|
c
|
cblas_saxpby.c
|
#include "blis.h"
#ifdef BLIS_ENABLE_CBLAS
/*
* cblas_saxpby.c
*
* The program is a C interface to saxpby.
* It calls the fortran wrapper before calling saxpby.
*
* Copyright (C) 2020, Advanced Micro Devices, Inc.
*/
#include "cblas.h"
#include "cblas_f77.h"
void cblas_saxpby( f77_int N, float alpha,
const float *X, f77_int incX,
float beta,
float *Y, f77_int incY)
{
#ifdef F77_INT
F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
#else
#define F77_N N
#define F77_incX incX
#define F77_incY incY
#endif
F77_saxpby( &F77_N, &alpha, X, &F77_incX, &beta, Y, &F77_incY);
}
#endif
|
7e5149c040844be8cec362f914a5d11f6d8b37b3
|
99bdb3251fecee538e0630f15f6574054dfc1468
|
/components/net/lwip/lwip-2.1.2/src/api/api_lib.c
|
e03b8b74515862e0b998bf253898c5a435fa4d0b
|
[
"BSD-3-Clause",
"Apache-2.0"
] |
permissive
|
RT-Thread/rt-thread
|
03a7c52c2aeb1b06a544143b0e803d72f47d1ece
|
3602f891211904a27dcbd51e5ba72fefce7326b2
|
refs/heads/master
| 2023-09-01T04:10:20.295801
| 2023-08-31T16:20:55
| 2023-08-31T16:20:55
| 7,408,108
| 9,599
| 5,805
|
Apache-2.0
| 2023-09-14T13:37:26
| 2013-01-02T14:49:21
|
C
|
UTF-8
|
C
| false
| false
| 44,046
|
c
|
api_lib.c
|
/**
* @file
* Sequential API External module
*
* @defgroup netconn Netconn API
* @ingroup sequential_api
* Thread-safe, to be called from non-TCPIP threads only.
* TX/RX handling based on @ref netbuf (containing @ref pbuf)
* to avoid copying data around.
*
* @defgroup netconn_common Common functions
* @ingroup netconn
* For use with TCP and UDP
*
* @defgroup netconn_tcp TCP only
* @ingroup netconn
* TCP only functions
*
* @defgroup netconn_udp UDP only
* @ingroup netconn
* UDP only functions
*/
/*
* Copyright (c) 2001-2004 Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
* This file is part of the lwIP TCP/IP stack.
*
* Author: Adam Dunkels <adam@sics.se>
*/
/* This is the part of the API that is linked with
the application */
#include "lwip/opt.h"
#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */
#include "lwip/api.h"
#include "lwip/memp.h"
#include "lwip/ip.h"
#include "lwip/raw.h"
#include "lwip/udp.h"
#include "lwip/priv/api_msg.h"
#include "lwip/priv/tcp_priv.h"
#include "lwip/priv/tcpip_priv.h"
#ifdef LWIP_HOOK_FILENAME
#include LWIP_HOOK_FILENAME
#endif
#include <string.h>
#define API_MSG_VAR_REF(name) API_VAR_REF(name)
#define API_MSG_VAR_DECLARE(name) API_VAR_DECLARE(struct api_msg, name)
#define API_MSG_VAR_ALLOC(name) API_VAR_ALLOC(struct api_msg, MEMP_API_MSG, name, ERR_MEM)
#define API_MSG_VAR_ALLOC_RETURN_NULL(name) API_VAR_ALLOC(struct api_msg, MEMP_API_MSG, name, NULL)
#define API_MSG_VAR_FREE(name) API_VAR_FREE(MEMP_API_MSG, name)
#if TCP_LISTEN_BACKLOG
/* need to allocate API message for accept so empty message pool does not result in event loss
* see bug #47512: MPU_COMPATIBLE may fail on empty pool */
#define API_MSG_VAR_ALLOC_ACCEPT(msg) API_MSG_VAR_ALLOC(msg)
#define API_MSG_VAR_FREE_ACCEPT(msg) API_MSG_VAR_FREE(msg)
#else /* TCP_LISTEN_BACKLOG */
#define API_MSG_VAR_ALLOC_ACCEPT(msg)
#define API_MSG_VAR_FREE_ACCEPT(msg)
#endif /* TCP_LISTEN_BACKLOG */
#if LWIP_NETCONN_FULLDUPLEX
#define NETCONN_RECVMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->recvmbox) && (((conn)->flags & NETCONN_FLAG_MBOXINVALID) == 0))
#define NETCONN_ACCEPTMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->acceptmbox) && (((conn)->flags & (NETCONN_FLAG_MBOXCLOSED|NETCONN_FLAG_MBOXINVALID)) == 0))
#define NETCONN_MBOX_WAITING_INC(conn) SYS_ARCH_INC(conn->mbox_threads_waiting, 1)
#define NETCONN_MBOX_WAITING_DEC(conn) SYS_ARCH_DEC(conn->mbox_threads_waiting, 1)
#else /* LWIP_NETCONN_FULLDUPLEX */
#define NETCONN_RECVMBOX_WAITABLE(conn) sys_mbox_valid(&(conn)->recvmbox)
#define NETCONN_ACCEPTMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->acceptmbox) && (((conn)->flags & NETCONN_FLAG_MBOXCLOSED) == 0))
#define NETCONN_MBOX_WAITING_INC(conn)
#define NETCONN_MBOX_WAITING_DEC(conn)
#endif /* LWIP_NETCONN_FULLDUPLEX */
static err_t netconn_close_shutdown(struct netconn *conn, u8_t how);
/**
* Call the lower part of a netconn_* function
* This function is then running in the thread context
* of tcpip_thread and has exclusive access to lwIP core code.
*
* @param fn function to call
* @param apimsg a struct containing the function to call and its parameters
* @return ERR_OK if the function was called, another err_t if not
*/
static err_t
netconn_apimsg(tcpip_callback_fn fn, struct api_msg *apimsg)
{
err_t err;
#ifdef LWIP_DEBUG
/* catch functions that don't set err */
apimsg->err = ERR_VAL;
#endif /* LWIP_DEBUG */
#if LWIP_NETCONN_SEM_PER_THREAD
apimsg->op_completed_sem = LWIP_NETCONN_THREAD_SEM_GET();
#endif /* LWIP_NETCONN_SEM_PER_THREAD */
err = tcpip_send_msg_wait_sem(fn, apimsg, LWIP_API_MSG_SEM(apimsg));
if (err == ERR_OK) {
return apimsg->err;
}
return err;
}
/**
* Create a new netconn (of a specific type) that has a callback function.
* The corresponding pcb is also created.
*
* @param t the type of 'connection' to create (@see enum netconn_type)
* @param proto the IP protocol for RAW IP pcbs
* @param callback a function to call on status changes (RX available, TX'ed)
* @return a newly allocated struct netconn or
* NULL on memory error
*/
struct netconn *
netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback)
{
struct netconn *conn;
API_MSG_VAR_DECLARE(msg);
API_MSG_VAR_ALLOC_RETURN_NULL(msg);
conn = netconn_alloc(t, callback);
if (conn != NULL) {
err_t err;
API_MSG_VAR_REF(msg).msg.n.proto = proto;
API_MSG_VAR_REF(msg).conn = conn;
err = netconn_apimsg(lwip_netconn_do_newconn, &API_MSG_VAR_REF(msg));
if (err != ERR_OK) {
LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);
LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox));
#if LWIP_TCP
LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox));
#endif /* LWIP_TCP */
#if !LWIP_NETCONN_SEM_PER_THREAD
LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed));
sys_sem_free(&conn->op_completed);
#endif /* !LWIP_NETCONN_SEM_PER_THREAD */
sys_mbox_free(&conn->recvmbox);
memp_free(MEMP_NETCONN, conn);
API_MSG_VAR_FREE(msg);
return NULL;
}
}
API_MSG_VAR_FREE(msg);
return conn;
}
/**
* @ingroup netconn_common
* Close a netconn 'connection' and free all its resources but not the netconn itself.
* UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate
* after this returns.
*
* @param conn the netconn to delete
* @return ERR_OK if the connection was deleted
*/
err_t
netconn_prepare_delete(struct netconn *conn)
{
err_t err;
API_MSG_VAR_DECLARE(msg);
/* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */
if (conn == NULL) {
return ERR_OK;
}
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER
/* get the time we started, which is later compared to
sys_now() + conn->send_timeout */
API_MSG_VAR_REF(msg).msg.sd.time_started = sys_now();
#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */
#if LWIP_TCP
API_MSG_VAR_REF(msg).msg.sd.polls_left =
((LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT + TCP_SLOW_INTERVAL - 1) / TCP_SLOW_INTERVAL) + 1;
#endif /* LWIP_TCP */
#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */
err = netconn_apimsg(lwip_netconn_do_delconn, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
if (err != ERR_OK) {
return err;
}
return ERR_OK;
}
/**
* @ingroup netconn_common
* Close a netconn 'connection' and free its resources.
* UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate
* after this returns.
*
* @param conn the netconn to delete
* @return ERR_OK if the connection was deleted
*/
err_t
netconn_delete(struct netconn *conn)
{
err_t err;
/* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */
if (conn == NULL) {
return ERR_OK;
}
#if LWIP_NETCONN_FULLDUPLEX
if (conn->flags & NETCONN_FLAG_MBOXINVALID) {
/* Already called netconn_prepare_delete() before */
err = ERR_OK;
} else
#endif /* LWIP_NETCONN_FULLDUPLEX */
{
err = netconn_prepare_delete(conn);
}
if (err == ERR_OK) {
netconn_free(conn);
}
return err;
}
/**
* Get the local or remote IP address and port of a netconn.
* For RAW netconns, this returns the protocol instead of a port!
*
* @param conn the netconn to query
* @param addr a pointer to which to save the IP address
* @param port a pointer to which to save the port (or protocol for RAW)
* @param local 1 to get the local IP address, 0 to get the remote one
* @return ERR_CONN for invalid connections
* ERR_OK if the information was retrieved
*/
err_t
netconn_getaddr(struct netconn *conn, ip_addr_t *addr, u16_t *port, u8_t local)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_getaddr: invalid conn", (conn != NULL), return ERR_ARG;);
LWIP_ERROR("netconn_getaddr: invalid addr", (addr != NULL), return ERR_ARG;);
LWIP_ERROR("netconn_getaddr: invalid port", (port != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.ad.local = local;
#if LWIP_MPU_COMPATIBLE
err = netconn_apimsg(lwip_netconn_do_getaddr, &API_MSG_VAR_REF(msg));
*addr = msg->msg.ad.ipaddr;
*port = msg->msg.ad.port;
#else /* LWIP_MPU_COMPATIBLE */
msg.msg.ad.ipaddr = addr;
msg.msg.ad.port = port;
err = netconn_apimsg(lwip_netconn_do_getaddr, &msg);
#endif /* LWIP_MPU_COMPATIBLE */
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_common
* Bind a netconn to a specific local IP address and port.
* Binding one netconn twice might not always be checked correctly!
*
* @param conn the netconn to bind
* @param addr the local IP address to bind the netconn to
* (use IP4_ADDR_ANY/IP6_ADDR_ANY to bind to all addresses)
* @param port the local port to bind the netconn to (not used for RAW)
* @return ERR_OK if bound, any other err_t on failure
*/
err_t
netconn_bind(struct netconn *conn, const ip_addr_t *addr, u16_t port)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_bind: invalid conn", (conn != NULL), return ERR_ARG;);
#if LWIP_IPV4
/* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */
if (addr == NULL) {
addr = IP4_ADDR_ANY;
}
#endif /* LWIP_IPV4 */
#if LWIP_IPV4 && LWIP_IPV6
/* "Socket API like" dual-stack support: If IP to bind to is IP6_ADDR_ANY,
* and NETCONN_FLAG_IPV6_V6ONLY is 0, use IP_ANY_TYPE to bind
*/
if ((netconn_get_ipv6only(conn) == 0) &&
ip_addr_cmp(addr, IP6_ADDR_ANY)) {
addr = IP_ANY_TYPE;
}
#endif /* LWIP_IPV4 && LWIP_IPV6 */
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.bc.ipaddr = API_MSG_VAR_REF(addr);
API_MSG_VAR_REF(msg).msg.bc.port = port;
err = netconn_apimsg(lwip_netconn_do_bind, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_common
* Bind a netconn to a specific interface and port.
* Binding one netconn twice might not always be checked correctly!
*
* @param conn the netconn to bind
* @param if_idx the local interface index to bind the netconn to
* @return ERR_OK if bound, any other err_t on failure
*/
err_t
netconn_bind_if(struct netconn *conn, u8_t if_idx)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_bind_if: invalid conn", (conn != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.bc.if_idx = if_idx;
err = netconn_apimsg(lwip_netconn_do_bind_if, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_common
* Connect a netconn to a specific remote IP address and port.
*
* @param conn the netconn to connect
* @param addr the remote IP address to connect to
* @param port the remote port to connect to (no used for RAW)
* @return ERR_OK if connected, return value of tcp_/udp_/raw_connect otherwise
*/
err_t
netconn_connect(struct netconn *conn, const ip_addr_t *addr, u16_t port)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_connect: invalid conn", (conn != NULL), return ERR_ARG;);
#if LWIP_IPV4
/* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */
if (addr == NULL) {
addr = IP4_ADDR_ANY;
}
#endif /* LWIP_IPV4 */
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.bc.ipaddr = API_MSG_VAR_REF(addr);
API_MSG_VAR_REF(msg).msg.bc.port = port;
err = netconn_apimsg(lwip_netconn_do_connect, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_udp
* Disconnect a netconn from its current peer (only valid for UDP netconns).
*
* @param conn the netconn to disconnect
* @return See @ref err_t
*/
err_t
netconn_disconnect(struct netconn *conn)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_disconnect: invalid conn", (conn != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
err = netconn_apimsg(lwip_netconn_do_disconnect, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_tcp
* Set a TCP netconn into listen mode
*
* @param conn the tcp netconn to set to listen mode
* @param backlog the listen backlog, only used if TCP_LISTEN_BACKLOG==1
* @return ERR_OK if the netconn was set to listen (UDP and RAW netconns
* don't return any error (yet?))
*/
err_t
netconn_listen_with_backlog(struct netconn *conn, u8_t backlog)
{
#if LWIP_TCP
API_MSG_VAR_DECLARE(msg);
err_t err;
/* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */
LWIP_UNUSED_ARG(backlog);
LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
#if TCP_LISTEN_BACKLOG
API_MSG_VAR_REF(msg).msg.lb.backlog = backlog;
#endif /* TCP_LISTEN_BACKLOG */
err = netconn_apimsg(lwip_netconn_do_listen, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
#else /* LWIP_TCP */
LWIP_UNUSED_ARG(conn);
LWIP_UNUSED_ARG(backlog);
return ERR_ARG;
#endif /* LWIP_TCP */
}
/**
* @ingroup netconn_tcp
* Accept a new connection on a TCP listening netconn.
*
* @param conn the TCP listen netconn
* @param new_conn pointer where the new connection is stored
* @return ERR_OK if a new connection has been received or an error
* code otherwise
*/
err_t
netconn_accept(struct netconn *conn, struct netconn **new_conn)
{
#if LWIP_TCP
err_t err;
void *accept_ptr;
struct netconn *newconn;
#if TCP_LISTEN_BACKLOG
API_MSG_VAR_DECLARE(msg);
#endif /* TCP_LISTEN_BACKLOG */
LWIP_ERROR("netconn_accept: invalid pointer", (new_conn != NULL), return ERR_ARG;);
*new_conn = NULL;
LWIP_ERROR("netconn_accept: invalid conn", (conn != NULL), return ERR_ARG;);
/* NOTE: Although the opengroup spec says a pending error shall be returned to
send/recv/getsockopt(SO_ERROR) only, we return it for listening
connections also, to handle embedded-system errors */
err = netconn_err(conn);
if (err != ERR_OK) {
/* return pending error */
return err;
}
if (!NETCONN_ACCEPTMBOX_WAITABLE(conn)) {
/* don't accept if closed: this might block the application task
waiting on acceptmbox forever! */
return ERR_CLSD;
}
API_MSG_VAR_ALLOC_ACCEPT(msg);
NETCONN_MBOX_WAITING_INC(conn);
if (netconn_is_nonblocking(conn)) {
if (sys_arch_mbox_tryfetch(&conn->acceptmbox, &accept_ptr) == SYS_ARCH_TIMEOUT) {
API_MSG_VAR_FREE_ACCEPT(msg);
NETCONN_MBOX_WAITING_DEC(conn);
return ERR_WOULDBLOCK;
}
} else {
#if LWIP_SO_RCVTIMEO
if (sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, conn->recv_timeout) == SYS_ARCH_TIMEOUT) {
API_MSG_VAR_FREE_ACCEPT(msg);
NETCONN_MBOX_WAITING_DEC(conn);
return ERR_TIMEOUT;
}
#else
sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, 0);
#endif /* LWIP_SO_RCVTIMEO*/
}
NETCONN_MBOX_WAITING_DEC(conn);
#if LWIP_NETCONN_FULLDUPLEX
if (conn->flags & NETCONN_FLAG_MBOXINVALID) {
if (lwip_netconn_is_deallocated_msg(accept_ptr)) {
/* the netconn has been closed from another thread */
API_MSG_VAR_FREE_ACCEPT(msg);
return ERR_CONN;
}
}
#endif
/* Register event with callback */
API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0);
if (lwip_netconn_is_err_msg(accept_ptr, &err)) {
/* a connection has been aborted: e.g. out of pcbs or out of netconns during accept */
API_MSG_VAR_FREE_ACCEPT(msg);
return err;
}
if (accept_ptr == NULL) {
/* connection has been aborted */
API_MSG_VAR_FREE_ACCEPT(msg);
return ERR_CLSD;
}
newconn = (struct netconn *)accept_ptr;
#if TCP_LISTEN_BACKLOG
/* Let the stack know that we have accepted the connection. */
API_MSG_VAR_REF(msg).conn = newconn;
/* don't care for the return value of lwip_netconn_do_recv */
netconn_apimsg(lwip_netconn_do_accepted, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
#endif /* TCP_LISTEN_BACKLOG */
*new_conn = newconn;
/* don't set conn->last_err: it's only ERR_OK, anyway */
return ERR_OK;
#else /* LWIP_TCP */
LWIP_UNUSED_ARG(conn);
LWIP_UNUSED_ARG(new_conn);
return ERR_ARG;
#endif /* LWIP_TCP */
}
/**
* @ingroup netconn_common
* Receive data: actual implementation that doesn't care whether pbuf or netbuf
* is received (this is internal, it's just here for describing common errors)
*
* @param conn the netconn from which to receive data
* @param new_buf pointer where a new pbuf/netbuf is stored when received data
* @param apiflags flags that control function behaviour. For now only:
* - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data
* @return ERR_OK if data has been received, an error code otherwise (timeout,
* memory error or another error)
* ERR_CONN if not connected
* ERR_CLSD if TCP connection has been closed
* ERR_WOULDBLOCK if the netconn is nonblocking but would block to wait for data
* ERR_TIMEOUT if the netconn has a receive timeout and no data was received
*/
static err_t
netconn_recv_data(struct netconn *conn, void **new_buf, u8_t apiflags)
{
void *buf = NULL;
u16_t len;
LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;);
*new_buf = NULL;
LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;);
if (!NETCONN_RECVMBOX_WAITABLE(conn)) {
err_t err = netconn_err(conn);
if (err != ERR_OK) {
/* return pending error */
return err;
}
return ERR_CONN;
}
NETCONN_MBOX_WAITING_INC(conn);
if (netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK) ||
(conn->flags & NETCONN_FLAG_MBOXCLOSED) || (conn->pending_err != ERR_OK)) {
if (sys_arch_mbox_tryfetch(&conn->recvmbox, &buf) == SYS_ARCH_TIMEOUT) {
err_t err;
NETCONN_MBOX_WAITING_DEC(conn);
err = netconn_err(conn);
if (err != ERR_OK) {
/* return pending error */
return err;
}
if (conn->flags & NETCONN_FLAG_MBOXCLOSED) {
return ERR_CONN;
}
return ERR_WOULDBLOCK;
}
} else {
#if LWIP_SO_RCVTIMEO
if (sys_arch_mbox_fetch(&conn->recvmbox, &buf, conn->recv_timeout) == SYS_ARCH_TIMEOUT) {
NETCONN_MBOX_WAITING_DEC(conn);
return ERR_TIMEOUT;
}
#else
sys_arch_mbox_fetch(&conn->recvmbox, &buf, 0);
#endif /* LWIP_SO_RCVTIMEO*/
}
NETCONN_MBOX_WAITING_DEC(conn);
#if LWIP_NETCONN_FULLDUPLEX
if (conn->flags & NETCONN_FLAG_MBOXINVALID) {
if (lwip_netconn_is_deallocated_msg(buf)) {
/* the netconn has been closed from another thread */
API_MSG_VAR_FREE_ACCEPT(msg);
return ERR_CONN;
}
}
#endif
#if LWIP_TCP
#if (LWIP_UDP || LWIP_RAW)
if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP)
#endif /* (LWIP_UDP || LWIP_RAW) */
{
err_t err;
/* Check if this is an error message or a pbuf */
if (lwip_netconn_is_err_msg(buf, &err)) {
/* new_buf has been zeroed above already */
if (err == ERR_CLSD) {
/* connection closed translates to ERR_OK with *new_buf == NULL */
return ERR_OK;
}
return err;
}
len = ((struct pbuf *)buf)->tot_len;
}
#endif /* LWIP_TCP */
#if LWIP_TCP && (LWIP_UDP || LWIP_RAW)
else
#endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */
#if (LWIP_UDP || LWIP_RAW)
{
LWIP_ASSERT("buf != NULL", buf != NULL);
len = netbuf_len((struct netbuf *)buf);
}
#endif /* (LWIP_UDP || LWIP_RAW) */
#if LWIP_SO_RCVBUF
SYS_ARCH_DEC(conn->recv_avail, len);
#endif /* LWIP_SO_RCVBUF */
/* Register event with callback */
API_EVENT(conn, NETCONN_EVT_RCVMINUS, len);
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv_data: received %p, len=%"U16_F"\n", buf, len));
*new_buf = buf;
/* don't set conn->last_err: it's only ERR_OK, anyway */
return ERR_OK;
}
#if LWIP_TCP
static err_t
netconn_tcp_recvd_msg(struct netconn *conn, size_t len, struct api_msg *msg)
{
LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) &&
NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;);
msg->conn = conn;
msg->msg.r.len = len;
return netconn_apimsg(lwip_netconn_do_recv, msg);
}
err_t
netconn_tcp_recvd(struct netconn *conn, size_t len)
{
err_t err;
API_MSG_VAR_DECLARE(msg);
LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) &&
NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
err = netconn_tcp_recvd_msg(conn, len, &API_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
static err_t
netconn_recv_data_tcp(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags)
{
err_t err;
struct pbuf *buf;
API_MSG_VAR_DECLARE(msg);
#if LWIP_MPU_COMPATIBLE
msg = NULL;
#endif
if (!NETCONN_RECVMBOX_WAITABLE(conn)) {
/* This only happens when calling this function more than once *after* receiving FIN */
return ERR_CONN;
}
if (netconn_is_flag_set(conn, NETCONN_FIN_RX_PENDING)) {
netconn_clear_flags(conn, NETCONN_FIN_RX_PENDING);
goto handle_fin;
}
if (!(apiflags & NETCONN_NOAUTORCVD)) {
/* need to allocate API message here so empty message pool does not result in event loss
* see bug #47512: MPU_COMPATIBLE may fail on empty pool */
API_MSG_VAR_ALLOC(msg);
}
err = netconn_recv_data(conn, (void **)new_buf, apiflags);
if (err != ERR_OK) {
if (!(apiflags & NETCONN_NOAUTORCVD)) {
API_MSG_VAR_FREE(msg);
}
return err;
}
buf = *new_buf;
if (!(apiflags & NETCONN_NOAUTORCVD)) {
/* Let the stack know that we have taken the data. */
u16_t len = buf ? buf->tot_len : 1;
/* don't care for the return value of lwip_netconn_do_recv */
/* @todo: this should really be fixed, e.g. by retrying in poll on error */
netconn_tcp_recvd_msg(conn, len, &API_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
}
/* If we are closed, we indicate that we no longer wish to use the socket */
if (buf == NULL) {
if (apiflags & NETCONN_NOFIN) {
/* received a FIN but the caller cannot handle it right now:
re-enqueue it and return "no data" */
netconn_set_flags(conn, NETCONN_FIN_RX_PENDING);
return ERR_WOULDBLOCK;
} else {
handle_fin:
API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0);
if (conn->pcb.ip == NULL) {
/* race condition: RST during recv */
err = netconn_err(conn);
if (err != ERR_OK) {
return err;
}
return ERR_RST;
}
/* RX side is closed, so deallocate the recvmbox */
netconn_close_shutdown(conn, NETCONN_SHUT_RD);
/* Don' store ERR_CLSD as conn->err since we are only half-closed */
return ERR_CLSD;
}
}
return err;
}
/**
* @ingroup netconn_tcp
* Receive data (in form of a pbuf) from a TCP netconn
*
* @param conn the netconn from which to receive data
* @param new_buf pointer where a new pbuf is stored when received data
* @return ERR_OK if data has been received, an error code otherwise (timeout,
* memory error or another error, @see netconn_recv_data)
* ERR_ARG if conn is not a TCP netconn
*/
err_t
netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf)
{
LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) &&
NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;);
return netconn_recv_data_tcp(conn, new_buf, 0);
}
/**
* @ingroup netconn_tcp
* Receive data (in form of a pbuf) from a TCP netconn
*
* @param conn the netconn from which to receive data
* @param new_buf pointer where a new pbuf is stored when received data
* @param apiflags flags that control function behaviour. For now only:
* - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data
* @return ERR_OK if data has been received, an error code otherwise (timeout,
* memory error or another error, @see netconn_recv_data)
* ERR_ARG if conn is not a TCP netconn
*/
err_t
netconn_recv_tcp_pbuf_flags(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags)
{
LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) &&
NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;);
return netconn_recv_data_tcp(conn, new_buf, apiflags);
}
#endif /* LWIP_TCP */
/**
* Receive data (in form of a netbuf) from a UDP or RAW netconn
*
* @param conn the netconn from which to receive data
* @param new_buf pointer where a new netbuf is stored when received data
* @return ERR_OK if data has been received, an error code otherwise (timeout,
* memory error or another error)
* ERR_ARG if conn is not a UDP/RAW netconn
*/
err_t
netconn_recv_udp_raw_netbuf(struct netconn *conn, struct netbuf **new_buf)
{
LWIP_ERROR("netconn_recv_udp_raw_netbuf: invalid conn", (conn != NULL) &&
NETCONNTYPE_GROUP(netconn_type(conn)) != NETCONN_TCP, return ERR_ARG;);
return netconn_recv_data(conn, (void **)new_buf, 0);
}
/**
* Receive data (in form of a netbuf) from a UDP or RAW netconn
*
* @param conn the netconn from which to receive data
* @param new_buf pointer where a new netbuf is stored when received data
* @param apiflags flags that control function behaviour. For now only:
* - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data
* @return ERR_OK if data has been received, an error code otherwise (timeout,
* memory error or another error)
* ERR_ARG if conn is not a UDP/RAW netconn
*/
err_t
netconn_recv_udp_raw_netbuf_flags(struct netconn *conn, struct netbuf **new_buf, u8_t apiflags)
{
LWIP_ERROR("netconn_recv_udp_raw_netbuf: invalid conn", (conn != NULL) &&
NETCONNTYPE_GROUP(netconn_type(conn)) != NETCONN_TCP, return ERR_ARG;);
return netconn_recv_data(conn, (void **)new_buf, apiflags);
}
/**
* @ingroup netconn_common
* Receive data (in form of a netbuf containing a packet buffer) from a netconn
*
* @param conn the netconn from which to receive data
* @param new_buf pointer where a new netbuf is stored when received data
* @return ERR_OK if data has been received, an error code otherwise (timeout,
* memory error or another error)
*/
err_t
netconn_recv(struct netconn *conn, struct netbuf **new_buf)
{
#if LWIP_TCP
struct netbuf *buf = NULL;
err_t err;
#endif /* LWIP_TCP */
LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;);
*new_buf = NULL;
LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;);
#if LWIP_TCP
#if (LWIP_UDP || LWIP_RAW)
if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP)
#endif /* (LWIP_UDP || LWIP_RAW) */
{
struct pbuf *p = NULL;
/* This is not a listening netconn, since recvmbox is set */
buf = (struct netbuf *)memp_malloc(MEMP_NETBUF);
if (buf == NULL) {
return ERR_MEM;
}
err = netconn_recv_data_tcp(conn, &p, 0);
if (err != ERR_OK) {
memp_free(MEMP_NETBUF, buf);
return err;
}
LWIP_ASSERT("p != NULL", p != NULL);
buf->p = p;
buf->ptr = p;
buf->port = 0;
ip_addr_set_zero(&buf->addr);
*new_buf = buf;
/* don't set conn->last_err: it's only ERR_OK, anyway */
return ERR_OK;
}
#endif /* LWIP_TCP */
#if LWIP_TCP && (LWIP_UDP || LWIP_RAW)
else
#endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */
{
#if (LWIP_UDP || LWIP_RAW)
return netconn_recv_data(conn, (void **)new_buf, 0);
#endif /* (LWIP_UDP || LWIP_RAW) */
}
}
/**
* @ingroup netconn_udp
* Send data (in form of a netbuf) to a specific remote IP address and port.
* Only to be used for UDP and RAW netconns (not TCP).
*
* @param conn the netconn over which to send data
* @param buf a netbuf containing the data to send
* @param addr the remote IP address to which to send the data
* @param port the remote port to which to send the data
* @return ERR_OK if data was sent, any other err_t on error
*/
err_t
netconn_sendto(struct netconn *conn, struct netbuf *buf, const ip_addr_t *addr, u16_t port)
{
if (buf != NULL) {
ip_addr_set(&buf->addr, addr);
buf->port = port;
return netconn_send(conn, buf);
}
return ERR_VAL;
}
/**
* @ingroup netconn_udp
* Send data over a UDP or RAW netconn (that is already connected).
*
* @param conn the UDP or RAW netconn over which to send data
* @param buf a netbuf containing the data to send
* @return ERR_OK if data was sent, any other err_t on error
*/
err_t
netconn_send(struct netconn *conn, struct netbuf *buf)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_send: invalid conn", (conn != NULL), return ERR_ARG;);
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %"U16_F" bytes\n", buf->p->tot_len));
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.b = buf;
err = netconn_apimsg(lwip_netconn_do_send, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_tcp
* Send data over a TCP netconn.
*
* @param conn the TCP netconn over which to send data
* @param dataptr pointer to the application buffer that contains the data to send
* @param size size of the application data to send
* @param apiflags combination of following flags :
* - NETCONN_COPY: data will be copied into memory belonging to the stack
* - NETCONN_MORE: for TCP connection, PSH flag will be set on last segment sent
* - NETCONN_DONTBLOCK: only write the data if all data can be written at once
* @param bytes_written pointer to a location that receives the number of written bytes
* @return ERR_OK if data was sent, any other err_t on error
*/
err_t
netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size,
u8_t apiflags, size_t *bytes_written)
{
struct netvector vector;
vector.ptr = dataptr;
vector.len = size;
return netconn_write_vectors_partly(conn, &vector, 1, apiflags, bytes_written);
}
/**
* Send vectorized data atomically over a TCP netconn.
*
* @param conn the TCP netconn over which to send data
* @param vectors array of vectors containing data to send
* @param vectorcnt number of vectors in the array
* @param apiflags combination of following flags :
* - NETCONN_COPY: data will be copied into memory belonging to the stack
* - NETCONN_MORE: for TCP connection, PSH flag will be set on last segment sent
* - NETCONN_DONTBLOCK: only write the data if all data can be written at once
* @param bytes_written pointer to a location that receives the number of written bytes
* @return ERR_OK if data was sent, any other err_t on error
*/
err_t
netconn_write_vectors_partly(struct netconn *conn, struct netvector *vectors, u16_t vectorcnt,
u8_t apiflags, size_t *bytes_written)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
u8_t dontblock;
size_t size;
int i;
LWIP_ERROR("netconn_write: invalid conn", (conn != NULL), return ERR_ARG;);
LWIP_ERROR("netconn_write: invalid conn->type", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP), return ERR_VAL;);
dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK);
#if LWIP_SO_SNDTIMEO
if (conn->send_timeout != 0) {
dontblock = 1;
}
#endif /* LWIP_SO_SNDTIMEO */
if (dontblock && !bytes_written) {
/* This implies netconn_write() cannot be used for non-blocking send, since
it has no way to return the number of bytes written. */
return ERR_VAL;
}
/* sum up the total size */
size = 0;
for (i = 0; i < vectorcnt; i++) {
size += vectors[i].len;
if (size < vectors[i].len) {
/* overflow */
return ERR_VAL;
}
}
if (size == 0) {
return ERR_OK;
} else if (size > SSIZE_MAX) {
ssize_t limited;
/* this is required by the socket layer (cannot send full size_t range) */
if (!bytes_written) {
return ERR_VAL;
}
/* limit the amount of data to send */
limited = SSIZE_MAX;
size = (size_t)limited;
}
API_MSG_VAR_ALLOC(msg);
/* non-blocking write sends as much */
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.w.vector = vectors;
API_MSG_VAR_REF(msg).msg.w.vector_cnt = vectorcnt;
API_MSG_VAR_REF(msg).msg.w.vector_off = 0;
API_MSG_VAR_REF(msg).msg.w.apiflags = apiflags;
API_MSG_VAR_REF(msg).msg.w.len = size;
API_MSG_VAR_REF(msg).msg.w.offset = 0;
#if LWIP_SO_SNDTIMEO
if (conn->send_timeout != 0) {
/* get the time we started, which is later compared to
sys_now() + conn->send_timeout */
API_MSG_VAR_REF(msg).msg.w.time_started = sys_now();
} else {
API_MSG_VAR_REF(msg).msg.w.time_started = 0;
}
#endif /* LWIP_SO_SNDTIMEO */
/* For locking the core: this _can_ be delayed on low memory/low send buffer,
but if it is, this is done inside api_msg.c:do_write(), so we can use the
non-blocking version here. */
err = netconn_apimsg(lwip_netconn_do_write, &API_MSG_VAR_REF(msg));
if (err == ERR_OK) {
if (bytes_written != NULL) {
*bytes_written = API_MSG_VAR_REF(msg).msg.w.offset;
}
/* for blocking, check all requested bytes were written, NOTE: send_timeout is
treated as dontblock (see dontblock assignment above) */
if (!dontblock) {
LWIP_ASSERT("do_write failed to write all bytes", API_MSG_VAR_REF(msg).msg.w.offset == size);
}
}
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_tcp
* Close or shutdown a TCP netconn (doesn't delete it).
*
* @param conn the TCP netconn to close or shutdown
* @param how fully close or only shutdown one side?
* @return ERR_OK if the netconn was closed, any other err_t on error
*/
static err_t
netconn_close_shutdown(struct netconn *conn, u8_t how)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_UNUSED_ARG(how);
LWIP_ERROR("netconn_close: invalid conn", (conn != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
API_MSG_VAR_REF(msg).conn = conn;
#if LWIP_TCP
/* shutting down both ends is the same as closing */
API_MSG_VAR_REF(msg).msg.sd.shut = how;
#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER
/* get the time we started, which is later compared to
sys_now() + conn->send_timeout */
API_MSG_VAR_REF(msg).msg.sd.time_started = sys_now();
#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */
API_MSG_VAR_REF(msg).msg.sd.polls_left =
((LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT + TCP_SLOW_INTERVAL - 1) / TCP_SLOW_INTERVAL) + 1;
#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */
#endif /* LWIP_TCP */
err = netconn_apimsg(lwip_netconn_do_close, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_tcp
* Close a TCP netconn (doesn't delete it).
*
* @param conn the TCP netconn to close
* @return ERR_OK if the netconn was closed, any other err_t on error
*/
err_t
netconn_close(struct netconn *conn)
{
/* shutting down both ends is the same as closing */
return netconn_close_shutdown(conn, NETCONN_SHUT_RDWR);
}
/**
* @ingroup netconn_common
* Get and reset pending error on a netconn
*
* @param conn the netconn to get the error from
* @return and pending error or ERR_OK if no error was pending
*/
err_t
netconn_err(struct netconn *conn)
{
err_t err;
SYS_ARCH_DECL_PROTECT(lev);
if (conn == NULL) {
return ERR_OK;
}
SYS_ARCH_PROTECT(lev);
err = conn->pending_err;
conn->pending_err = ERR_OK;
SYS_ARCH_UNPROTECT(lev);
return err;
}
/**
* @ingroup netconn_tcp
* Shut down one or both sides of a TCP netconn (doesn't delete it).
*
* @param conn the TCP netconn to shut down
* @param shut_rx shut down the RX side (no more read possible after this)
* @param shut_tx shut down the TX side (no more write possible after this)
* @return ERR_OK if the netconn was closed, any other err_t on error
*/
err_t
netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx)
{
return netconn_close_shutdown(conn, (u8_t)((shut_rx ? NETCONN_SHUT_RD : 0) | (shut_tx ? NETCONN_SHUT_WR : 0)));
}
#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD)
/**
* @ingroup netconn_udp
* Join multicast groups for UDP netconns.
*
* @param conn the UDP netconn for which to change multicast addresses
* @param multiaddr IP address of the multicast group to join or leave
* @param netif_addr the IP address of the network interface on which to send
* the igmp message
* @param join_or_leave flag whether to send a join- or leave-message
* @return ERR_OK if the action was taken, any err_t on error
*/
err_t
netconn_join_leave_group(struct netconn *conn,
const ip_addr_t *multiaddr,
const ip_addr_t *netif_addr,
enum netconn_igmp join_or_leave)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
#if LWIP_IPV4
/* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */
if (multiaddr == NULL) {
multiaddr = IP4_ADDR_ANY;
}
if (netif_addr == NULL) {
netif_addr = IP4_ADDR_ANY;
}
#endif /* LWIP_IPV4 */
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.jl.multiaddr = API_MSG_VAR_REF(multiaddr);
API_MSG_VAR_REF(msg).msg.jl.netif_addr = API_MSG_VAR_REF(netif_addr);
API_MSG_VAR_REF(msg).msg.jl.join_or_leave = join_or_leave;
err = netconn_apimsg(lwip_netconn_do_join_leave_group, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
/**
* @ingroup netconn_udp
* Join multicast groups for UDP netconns.
*
* @param conn the UDP netconn for which to change multicast addresses
* @param multiaddr IP address of the multicast group to join or leave
* @param if_idx the index of the netif
* @param join_or_leave flag whether to send a join- or leave-message
* @return ERR_OK if the action was taken, any err_t on error
*/
err_t
netconn_join_leave_group_netif(struct netconn *conn,
const ip_addr_t *multiaddr,
u8_t if_idx,
enum netconn_igmp join_or_leave)
{
API_MSG_VAR_DECLARE(msg);
err_t err;
LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;);
API_MSG_VAR_ALLOC(msg);
#if LWIP_IPV4
/* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */
if (multiaddr == NULL) {
multiaddr = IP4_ADDR_ANY;
}
if (if_idx == NETIF_NO_INDEX) {
return ERR_IF;
}
#endif /* LWIP_IPV4 */
API_MSG_VAR_REF(msg).conn = conn;
API_MSG_VAR_REF(msg).msg.jl.multiaddr = API_MSG_VAR_REF(multiaddr);
API_MSG_VAR_REF(msg).msg.jl.if_idx = if_idx;
API_MSG_VAR_REF(msg).msg.jl.join_or_leave = join_or_leave;
err = netconn_apimsg(lwip_netconn_do_join_leave_group_netif, &API_MSG_VAR_REF(msg));
API_MSG_VAR_FREE(msg);
return err;
}
#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */
#if LWIP_DNS
/**
* @ingroup netconn_common
* Execute a DNS query, only one IP address is returned
*
* @param name a string representation of the DNS host name to query
* @param addr a preallocated ip_addr_t where to store the resolved IP address
* @param dns_addrtype IP address type (IPv4 / IPv6)
* @return ERR_OK: resolving succeeded
* ERR_MEM: memory error, try again later
* ERR_ARG: dns client not initialized or invalid hostname
* ERR_VAL: dns server response was invalid
*/
#if LWIP_IPV4 && LWIP_IPV6
err_t
netconn_gethostbyname_addrtype(const char *name, ip_addr_t *addr, u8_t dns_addrtype)
#else
err_t
netconn_gethostbyname(const char *name, ip_addr_t *addr)
#endif
{
API_VAR_DECLARE(struct dns_api_msg, msg);
#if !LWIP_MPU_COMPATIBLE
sys_sem_t sem;
#endif /* LWIP_MPU_COMPATIBLE */
err_t err;
err_t cberr;
LWIP_ERROR("netconn_gethostbyname: invalid name", (name != NULL), return ERR_ARG;);
LWIP_ERROR("netconn_gethostbyname: invalid addr", (addr != NULL), return ERR_ARG;);
#if LWIP_MPU_COMPATIBLE
if (strlen(name) >= DNS_MAX_NAME_LENGTH) {
return ERR_ARG;
}
#endif
#ifdef LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE
#if LWIP_IPV4 && LWIP_IPV6
if (LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, dns_addrtype, &err)) {
#else
if (LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, NETCONN_DNS_DEFAULT, &err)) {
#endif /* LWIP_IPV4 && LWIP_IPV6 */
return err;
}
#endif /* LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE */
API_VAR_ALLOC(struct dns_api_msg, MEMP_DNS_API_MSG, msg, ERR_MEM);
#if LWIP_MPU_COMPATIBLE
strncpy(API_VAR_REF(msg).name, name, DNS_MAX_NAME_LENGTH - 1);
API_VAR_REF(msg).name[DNS_MAX_NAME_LENGTH - 1] = 0;
#else /* LWIP_MPU_COMPATIBLE */
msg.err = &err;
msg.sem = &sem;
API_VAR_REF(msg).addr = API_VAR_REF(addr);
API_VAR_REF(msg).name = name;
#endif /* LWIP_MPU_COMPATIBLE */
#if LWIP_IPV4 && LWIP_IPV6
API_VAR_REF(msg).dns_addrtype = dns_addrtype;
#endif /* LWIP_IPV4 && LWIP_IPV6 */
#if LWIP_NETCONN_SEM_PER_THREAD
API_VAR_REF(msg).sem = LWIP_NETCONN_THREAD_SEM_GET();
#else /* LWIP_NETCONN_SEM_PER_THREAD*/
err = sys_sem_new(API_EXPR_REF(API_VAR_REF(msg).sem), 0);
if (err != ERR_OK) {
API_VAR_FREE(MEMP_DNS_API_MSG, msg);
return err;
}
#endif /* LWIP_NETCONN_SEM_PER_THREAD */
cberr = tcpip_send_msg_wait_sem(lwip_netconn_do_gethostbyname, &API_VAR_REF(msg), API_EXPR_REF(API_VAR_REF(msg).sem));
#if !LWIP_NETCONN_SEM_PER_THREAD
sys_sem_free(API_EXPR_REF(API_VAR_REF(msg).sem));
#endif /* !LWIP_NETCONN_SEM_PER_THREAD */
if (cberr != ERR_OK) {
API_VAR_FREE(MEMP_DNS_API_MSG, msg);
return cberr;
}
#if LWIP_MPU_COMPATIBLE
*addr = msg->addr;
err = msg->err;
#endif /* LWIP_MPU_COMPATIBLE */
API_VAR_FREE(MEMP_DNS_API_MSG, msg);
return err;
}
#endif /* LWIP_DNS*/
#if LWIP_NETCONN_SEM_PER_THREAD
void
netconn_thread_init(void)
{
sys_sem_t *sem = LWIP_NETCONN_THREAD_SEM_GET();
if ((sem == NULL) || !sys_sem_valid(sem)) {
/* call alloc only once */
LWIP_NETCONN_THREAD_SEM_ALLOC();
LWIP_ASSERT("LWIP_NETCONN_THREAD_SEM_ALLOC() failed", sys_sem_valid(LWIP_NETCONN_THREAD_SEM_GET()));
}
}
void
netconn_thread_cleanup(void)
{
sys_sem_t *sem = LWIP_NETCONN_THREAD_SEM_GET();
if ((sem != NULL) && sys_sem_valid(sem)) {
/* call free only once */
LWIP_NETCONN_THREAD_SEM_FREE();
}
}
#endif /* LWIP_NETCONN_SEM_PER_THREAD */
#endif /* LWIP_NETCONN */
|
10c3e6c101215c4817d4f13ef3440dd083a6d491
|
41eb0837713f297134529591b66f3d4d82bcf98e
|
/src/Raine/source/games/kaiserkn.c
|
ef8ab09c8792611b31f145314ad0d20767d8f0b7
|
[] |
no_license
|
AlexxandreFS/Batocera.PLUS
|
27b196b3cbb781b6fc99e62cad855396d1d5f8f2
|
997ee763ae7135fdf0c34a081e789918bd2eb169
|
refs/heads/master
| 2023-08-17T21:52:39.083687
| 2023-08-17T15:03:44
| 2023-08-17T15:03:44
| 215,869,486
| 135
| 57
| null | 2023-08-14T14:46:14
| 2019-10-17T19:23:42
|
C
|
SHIFT_JIS
|
C
| false
| false
| 18,923
|
c
|
kaiserkn.c
|
#define DRV_DEF_INPUT f3_system_inputs_6_button
#define DRV_DEF_DSW NULL
#define DRV_DEF_EXEC ExecuteF3SystemFrameB
#define DRV_DEF_SOUND f3_sound
/******************************************************************************/
/* */
/* KAISER KNUCKLE (C) 1994 TAITO CORPORATION */
/* */
/******************************************************************************/
#include "gameinc.h"
#include "f3system.h"
#include "tc003vcu.h"
#include "tc200obj.h"
#include "savegame.h"
#include "sasound.h"
static struct ROM_INFO rom_kaiserkn[] =
{
{ "d84-01.rom", 0x00200000, 0x9ad22149, 0, 0, 0, },
{ "d84-02.rom", 0x00200000, 0x9e1827e4, 0, 0, 0, },
{ "d84-03.rom", 0x00200000, 0xd786f552, 0, 0, 0, },
{ "d84-04.rom", 0x00200000, 0xd1f32b5d, 0, 0, 0, },
{ "d84-05.rom", 0x00200000, 0x31a3c75d, 0, 0, 0, },
{ "d84-06.rom", 0x00200000, 0xfa924dab, 0, 0, 0, },
{ "d84-07.rom", 0x00200000, 0x54517a6b, 0, 0, 0, },
{ "d84-08.rom", 0x00200000, 0x07347bf1, 0, 0, 0, },
{ "d84-09.rom", 0x00200000, 0xfaa78d98, 0, 0, 0, },
{ "d84-10.rom", 0x00200000, 0xb84b7320, 0, 0, 0, },
{ "d84-11.rom", 0x00200000, 0xa062c1d4, 0, 0, 0, },
{ "d84-12.rom", 0x00200000, 0x66a7a9aa, 0, 0, 0, },
{ "d84-13.rom", 0x00200000, 0xae125516, 0, 0, 0, },
{ "d84-14.rom", 0x00200000, 0x2b2e693e, 0, 0, 0, },
{ "d84-15.rom", 0x00100000, 0x31ceb152, 0, 0, 0, },
{ "d84-16.rom", 0x00100000, 0xbcff9b2d, 0, 0, 0, },
{ "d84-17.rom", 0x00100000, 0x0be37cc3, 0, 0, 0, },
{ "d84-18.rom", 0x00100000, 0xe812bcc5, 0, 0, 0, },
{ "d84-19.rom", 0x00080000, 0x6ddf77e5, 0, 0, 0, },
{ "d84-20.rom", 0x00080000, 0xf85041e5, 0, 0, 0, },
{ "d84-21.rom", 0x00080000, 0x89f68b66, 0, 0, 0, },
{ "d84-29.rom", 0x00080000, 0x9821f17a, 0, 0, 0, },
{ "d84-23.rom", 0x00080000, 0x39f12a9b, 0, 0, 0, },
{ "d84-24.rom", 0x00080000, 0xbf20c755, 0, 0, 0, },
{ "d84-25.rom", 0x00080000, 0x2840893f, 0, 0, 0, },
LOAD8_16( REGION_ROM2, 0x000000, 0x00040000,
"d84-26.rom", 0x4f5b8563, "d84-27.rom", 0xfb0cb1ba),
{ NULL, 0, 0, 0, 0, 0, },
};
static struct ROMSW_DATA romsw_data_kaiser_knuckle_0[] =
{
{ "Taito Japan", 0x01 },
{ "Taito America (Global Champion)", 0x02 },
{ "Taito", 0x03 },
{ NULL, 0 },
};
static struct ROMSW_INFO romsw_kaiserkn[] =
{
{ 0x1FFFFF, 0x03, romsw_data_kaiser_knuckle_0 },
{ 0, 0, NULL },
};
static struct ROM_INFO rom_dankuga[] =
{
{ "d84-01.rom", 0x00200000, 0x9ad22149, 0, 0, 0, },
{ "d84-02.rom", 0x00200000, 0x9e1827e4, 0, 0, 0, },
{ "d84-03.rom", 0x00200000, 0xd786f552, 0, 0, 0, },
{ "d84-04.rom", 0x00200000, 0xd1f32b5d, 0, 0, 0, },
{ "d84-05.rom", 0x00200000, 0x31a3c75d, 0, 0, 0, },
{ "d84-06.rom", 0x00200000, 0xfa924dab, 0, 0, 0, },
{ "d84-07.rom", 0x00200000, 0x54517a6b, 0, 0, 0, },
{ "d84-08.rom", 0x00200000, 0x07347bf1, 0, 0, 0, },
{ "d84-09.rom", 0x00200000, 0xfaa78d98, 0, 0, 0, },
{ "d84-10.rom", 0x00200000, 0xb84b7320, 0, 0, 0, },
{ "d84-11.rom", 0x00200000, 0xa062c1d4, 0, 0, 0, },
{ "d84-12.rom", 0x00200000, 0x66a7a9aa, 0, 0, 0, },
{ "d84-13.rom", 0x00200000, 0xae125516, 0, 0, 0, },
{ "d84-14.rom", 0x00200000, 0x2b2e693e, 0, 0, 0, },
{ "d84-15.rom", 0x00100000, 0x31ceb152, 0, 0, 0, },
{ "d84-16.rom", 0x00100000, 0xbcff9b2d, 0, 0, 0, },
{ "d84-17.rom", 0x00100000, 0x0be37cc3, 0, 0, 0, },
{ "d84-18.rom", 0x00100000, 0xe812bcc5, 0, 0, 0, },
{ "d84-19.rom", 0x00080000, 0x6ddf77e5, 0, 0, 0, },
{ "d84-20.rom", 0x00080000, 0xf85041e5, 0, 0, 0, },
{ "d84-21.rom", 0x00080000, 0x89f68b66, 0, 0, 0, },
{ "dkg_mpr0.bin", 0x00080000, 0xad6ada07, 0, 0, 0, },
{ "dkg_mpr1.bin", 0x00080000, 0x97566f69, 0, 0, 0, },
{ "dkg_mpr2.bin", 0x00080000, 0x18a4748b, 0, 0, 0, },
{ "dkg_mpr3.bin", 0x00080000, 0xee1531ca, 0, 0, 0, },
LOAD8_16( REGION_ROM2, 0x000000, 0x00040000,
"d84-26.rom", 0x4f5b8563, "d84-27.rom", 0xfb0cb1ba),
{ NULL, 0, 0, 0, 0, 0, },
};
static struct ROMSW_DATA romsw_data_kaiser_knuckle_alt_0[] =
{
{ "Taito Japan", 0x01 },
{ "Taito America (Global Champion)", 0x02 },
{ "Taito", 0x03 },
{ NULL, 0 },
};
static struct ROMSW_INFO romsw_dankuga[] =
{
{ 0x1FFFFF, 0x01, romsw_data_kaiser_knuckle_alt_0 },
{ 0, 0, NULL },
};
static UINT8 *RAM_BG0;
static UINT8 *RAM_BG1;
static UINT8 *RAM_BG2;
static UINT8 *RAM_BG3;
static UINT8 *RAM_SCR0;
static UINT8 *RAM_SCR1;
static UINT8 *RAM_SCR2;
static UINT8 *RAM_SCR3;
static UINT32 SCR0_XOFS;
static UINT32 SCR1_XOFS;
static UINT32 SCR2_XOFS;
static UINT32 SCR3_XOFS;
static UINT32 SCR0_YOFS;
static UINT32 SCR1_YOFS;
static UINT32 SCR2_YOFS;
static UINT32 SCR3_YOFS;
static UINT8 *GFX2;
static UINT8 *GFX_BG0;
static UINT8 *GFX_BG0_SOLID;
static UINT8 *GFX_SPR;
static UINT8 *GFX_SPR_SOLID;
static void load_kaiserkn(void)
{
int ta,tb,tc;
RAMSize=0x80000;
if(!(RAM=AllocateMem(0x80000))) return;
if(!(ROM=AllocateMem(0x200000))) return;
if(!(GFX2=AllocateMem(0x9BAE00))) return;
if(!(GFX=AllocateMem(0x1900400))) return; // ouch!!
GFX_BG0=GFX2;
GFX_SPR=GFX;
if(!load_rom("d84-03.rom", ROM, 0x200000)) return; // 16x16 SPRITES ($8000)
tb=0;
for(ta=0;ta<0x200000;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
if(!load_rom("d84-04.rom", ROM, 0x200000)) return; // 16x16 SPRITES
tb=2;
for(ta=0;ta<0x200000;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
tb=0;
if(!load_rom("d84-05.rom", ROM, 0x200000)) return; // 16x16 SPRITES (MASK)
for(ta=0;ta<0x200000;ta++){
tc=ROM[ta];
GFX[tb+3]|=((tc&0x40)>>6)<<4;
GFX[tb+2]|=((tc&0x10)>>4)<<4;
GFX[tb+1]|=((tc&0x04)>>2)<<4;
GFX[tb+0]|=((tc&0x01)>>0)<<4;
tb+=4;
}
if(!load_rom("d84-06.rom", ROM, 0x200000)) return; // 16x16 SPRITES ($8000)
tb=0x800000;
for(ta=0;ta<0x200000;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
if(!load_rom("d84-07.rom", ROM, 0x200000)) return; // 16x16 SPRITES
tb=0x800002;
for(ta=0;ta<0x200000;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
tb=0x800000;
if(!load_rom("d84-08.rom", ROM, 0x200000)) return; // 16x16 SPRITES (MASK)
for(ta=0;ta<0x200000;ta++){
tc=ROM[ta];
GFX[tb+3]|=((tc&0x40)>>6)<<4;
GFX[tb+2]|=((tc&0x10)>>4)<<4;
GFX[tb+1]|=((tc&0x04)>>2)<<4;
GFX[tb+0]|=((tc&0x01)>>0)<<4;
tb+=4;
}
if(!load_rom("d84-09.rom", ROM, 0x200000)) return; // 16x16 SPRITES ($8000)
tb=0x1000000;
for(ta=0;ta<0x200000;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
if(!load_rom("d84-10.rom", ROM, 0x200000)) return; // 16x16 SPRITES
tb=0x1000002;
for(ta=0;ta<0x200000;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
tb=0x1000000;
if(!load_rom("d84-11.rom", ROM, 0x200000)) return; // 16x16 SPRITES (MASK)
for(ta=0;ta<0x200000;ta++){
tc=ROM[ta];
GFX[tb+3]|=((tc&0x40)>>6)<<4;
GFX[tb+2]|=((tc&0x10)>>4)<<4;
GFX[tb+1]|=((tc&0x04)>>2)<<4;
GFX[tb+0]|=((tc&0x01)>>0)<<4;
tb+=4;
}
if(!load_rom("d84-19.rom", ROM, 0x40100)) return; // 16x16 SPRITES ($1004)
tb=0x1800000;
for(ta=0;ta<0x40100;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
if(!load_rom("d84-20.rom", ROM, 0x40100)) return; // 16x16 SPRITES
tb=0x1800002;
for(ta=0;ta<0x40100;ta++,tb+=4){
WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
}
tb=0x1800000;
if(!load_rom("d84-21.rom", ROM, 0x40100)) return; // 16x16 SPRITES (MASK)
for(ta=0;ta<0x40100;ta++){
tc=ROM[ta];
GFX[tb+3]|=((tc&0x40)>>6)<<4;
GFX[tb+2]|=((tc&0x10)>>4)<<4;
GFX[tb+1]|=((tc&0x04)>>2)<<4;
GFX[tb+0]|=((tc&0x01)>>0)<<4;
tb+=4;
}
tb=0;
if(!load_rom("d84-12.rom", ROM, 0x200000)) return; // 16x16 TILES ($8000)
for(ta=0;ta<0x200000;ta+=2){
GFX_BG0[tb++]=ROM[ta]&15;
GFX_BG0[tb++]=ROM[ta]>>4;
GFX_BG0[tb++]=ROM[ta+1]&15;
GFX_BG0[tb++]=ROM[ta+1]>>4;
tb+=4;
}
tb=4;
if(!load_rom("d84-13.rom", ROM, 0x200000)) return; // 16x16 TILES
for(ta=0;ta<0x200000;ta+=2){
GFX_BG0[tb++]=ROM[ta]&15;
GFX_BG0[tb++]=ROM[ta]>>4;
GFX_BG0[tb++]=ROM[ta+1]&15;
GFX_BG0[tb++]=ROM[ta+1]>>4;
tb+=4;
}
tb=0;
if(!load_rom("d84-14.rom", ROM, 0x200000)) return; // 16x16 TILES (MASK)
for(ta=0;ta<0x200000;ta+=2){
tc=ROM[ta];
GFX_BG0[tb+7]|=((tc&0x80)>>7)<<4;
GFX_BG0[tb+6]|=((tc&0x40)>>6)<<4;
GFX_BG0[tb+5]|=((tc&0x20)>>5)<<4;
GFX_BG0[tb+4]|=((tc&0x10)>>4)<<4;
GFX_BG0[tb+3]|=((tc&0x08)>>3)<<4;
GFX_BG0[tb+2]|=((tc&0x04)>>2)<<4;
GFX_BG0[tb+1]|=((tc&0x02)>>1)<<4;
GFX_BG0[tb+0]|=((tc&0x01)>>0)<<4;
tb+=8;
}
tb=0x800000;
if(!load_rom("d84-16.rom", ROM, 0x6EB80)) return; // 16x16 TILES ($1BAE)
for(ta=0;ta<0x6EB80;ta+=2){
GFX_BG0[tb++]=ROM[ta]&15;
GFX_BG0[tb++]=ROM[ta]>>4;
GFX_BG0[tb++]=ROM[ta+1]&15;
GFX_BG0[tb++]=ROM[ta+1]>>4;
tb+=4;
}
tb=0x800004;
if(!load_rom("d84-17.rom", ROM, 0x6EB80)) return; // 16x16 TILES
for(ta=0;ta<0x6EB80;ta+=2){
GFX_BG0[tb++]=ROM[ta]&15;
GFX_BG0[tb++]=ROM[ta]>>4;
GFX_BG0[tb++]=ROM[ta+1]&15;
GFX_BG0[tb++]=ROM[ta+1]>>4;
tb+=4;
}
tb=0x800000;
if(!load_rom("d84-18.rom", ROM, 0x6EB80)) return; // 16x16 TILES (MASK)
for(ta=0;ta<0x6EB80;ta+=2){
tc=ROM[ta];
GFX_BG0[tb+7]|=((tc&0x80)>>7)<<4;
GFX_BG0[tb+6]|=((tc&0x40)>>6)<<4;
GFX_BG0[tb+5]|=((tc&0x20)>>5)<<4;
GFX_BG0[tb+4]|=((tc&0x10)>>4)<<4;
GFX_BG0[tb+3]|=((tc&0x08)>>3)<<4;
GFX_BG0[tb+2]|=((tc&0x04)>>2)<<4;
GFX_BG0[tb+1]|=((tc&0x02)>>1)<<4;
GFX_BG0[tb+0]|=((tc&0x01)>>0)<<4;
tb+=8;
}
GFX_BG0_SOLID = MakeSolidTileMap16x16(GFX_BG0, 0x09BAE);
GFX_SPR_SOLID = make_solid_mask_16x16(GFX_SPR, 0x19004);
// Setup 68020 Memory Map
// ----------------------
AddF3MemoryMap(0x200000);
RAM_BG1=RAM+0x30000;
RAM_BG2=RAM+0x31000;
RAM_BG3=RAM+0x32000;
RAM_BG0=RAM+0x33000;
RAM_SCR1=RAM+0x6A000;
RAM_SCR2=RAM+0x6A002;
RAM_SCR3=RAM+0x6A004;
RAM_SCR0=RAM+0x6A006;
SCR1_XOFS=(0xF600)+(1<<6);
SCR2_XOFS=(0xF700)+(1<<6);
SCR3_XOFS=(0xF800)+(1<<6);
SCR0_XOFS=(0xF900)+(1<<6);
SCR1_YOFS=(0x0780-(16<<7));
SCR2_YOFS=(0x0780-(16<<7));
SCR3_YOFS=(0x0780-(16<<7));
SCR0_YOFS=(0x0780-(16<<7));
if(!load_rom_index(24, RAM, 0x80000)) return;
for(ta=0;ta<0x80000;ta++){
ROM[(ta<<2)+0]=RAM[ta];
}
if(!load_rom_index(23, RAM, 0x80000)) return;
for(ta=0;ta<0x80000;ta++){
ROM[(ta<<2)+1]=RAM[ta];
}
if(!load_rom_index(22, RAM, 0x80000)) return;
for(ta=0;ta<0x80000;ta++){
ROM[(ta<<2)+2]=RAM[ta];
}
if(!load_rom_index(21, RAM, 0x80000)) return;
for(ta=0;ta<0x80000;ta++){
ROM[(ta<<2)+3]=RAM[ta];
}
// 68000 code
M68000ROM = load_region[REGION_ROM2];
if(!(PCMROM=AllocateMem(0xc00000))) return;
load_be("d84-01.rom",PCMROM,0x200000);
load_be("d84-02.rom",PCMROM+0x400000,0x200000);
max_banks_this_game=4;
memset(PCMROM+0x800000,0,0x3fffff);
memset(RAM+0x00000,0x00,0x80000);
memset(RAM+0x69000,0xFF,0x01000);
if(is_current_game("kaiserkn")){
// FIX ROM CHECKSUM
WriteWord68k(&ROM[0x11CE],0x4E75); // rts
// EEPROM HACKS
WriteWord68k(&ROM[0xC30C],0x7F00); // raine #$00 <eeprom read>
WriteWord68k(&ROM[0xC30E],0x4E75); // rts
WriteWord68k(&ROM[0xC388],0x7F01); // raine #$01 <eeprom write>
WriteWord68k(&ROM[0xC38A],0x4E75); // rts
// SPEED HACK#1
WriteLong68k(&ROM[0x0534],0x4E714E71);
WriteLong68k(&ROM[0x025C],0x7F024E71); // raine #$02 <stop cpu>
WriteLong68k(&ROM[0x0260],0x4E714E71); // nop
WriteWord68k(&ROM[0x0264],0x60EC);
}
else{
// FIX ROM CHECKSUM
WriteWord68k(&ROM[0x11F4],0x4E75); // rts
// EEPROM HACKS
WriteWord68k(&ROM[0xD93A],0x7F00); // raine #$00 <eeprom read>
WriteWord68k(&ROM[0xD93C],0x4E75); // rts
WriteWord68k(&ROM[0xD9B6],0x7F01); // raine #$01 <eeprom write>
WriteWord68k(&ROM[0xD9B8],0x4E75); // rts
// SPEED HACK#1
WriteLong68k(&ROM[0x052E],0x4E714E71);
WriteLong68k(&ROM[0x025C],0x7F024E71); // raine #$02 <stop cpu>
WriteLong68k(&ROM[0x0260],0x4E714E71); // nop
WriteWord68k(&ROM[0x0264],0x60EC);
}
F3SystemEEPROMAccess=&F3SysEEPROMAccessMode1;
set_colour_mapper(&col_map_xxxx_xxxx_rrrr_rrrr_gggg_gggg_bbbb_bbbb);
InitPaletteMap(RAM+0x60000, 0x200, 0x40, 0x8000);
init_tc003vcu(0,16);
// Init tc0200obj emulation
// ------------------------
tc0200obj.RAM = RAM+0x20000;
tc0200obj.RAM_B = RAM+0x28000;
tc0200obj.GFX = GFX_SPR;
tc0200obj.MASK = GFX_SPR_SOLID;
tc0200obj.tile_mask = 0x1FFFF;
tc0200obj.ofs_x = 0; //-0x2E;
tc0200obj.ofs_y = -16; //-0x18;
tc0200obj.cols = 32;
init_tc0200obj();
init_f3_system_ioc(F3_IOC_2P_6BUTTON);
init_m68k();
setup_sound_68000();
}
static void DrawKaiserKnuckle(void)
{
int x16,y16,zz,zzz,zzzz;
int ta,x,y;
UINT8 *MAP;
ClearPaletteMap();
if(check_layer_enabled(f3_bg0_id)){
MAKE_SCROLL_512x512_4_16(
(0-320)-((ReadWord68k(&RAM_SCR0[0])-SCR0_XOFS)>>6),
(0-224)-((ReadWord68k(&RAM_SCR0[8])-SCR0_YOFS)>>7)
);
START_SCROLL_512x512_4_16_R180(64,64,320,224);
MAP_PALETTE_MAPPED_NEW(
ReadWord68k(&RAM_BG0[zz])&0x1FF,
32, MAP
);
(*Draw16x16_Mapped_Flip_Rot[3-((RAM_BG0[zz]&0xC0)>>6)])(&GFX_BG0[ReadWord68k(&RAM_BG0[zz+2])<<8],x,y,MAP);
END_SCROLL_512x512_4_16();
}
if(check_layer_enabled(f3_bg1_id)){
MAKE_SCROLL_512x512_4_16(
(0-320)-((ReadWord68k(&RAM_SCR1[0])-SCR1_XOFS)>>6),
(0-224)-((ReadWord68k(&RAM_SCR1[8])-SCR1_YOFS)>>7)
);
START_SCROLL_512x512_4_16_R180(64,64,320,224);
ta=ReadWord68k(&RAM_BG1[zz+2]);
if(ta!=0){
MAP_PALETTE_MAPPED_NEW(
ReadWord68k(&RAM_BG1[zz])&0x1FF,
32, MAP
);
if(GFX_BG0_SOLID[ta]==0){
switch(RAM_BG1[zz]&0xC0){
case 0xC0: Draw16x16_Trans_Mapped_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x80: Draw16x16_Trans_Mapped_FlipY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x40: Draw16x16_Trans_Mapped_FlipX_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x00: Draw16x16_Trans_Mapped_FlipXY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
}
}
else{
switch(RAM_BG1[zz]&0xC0){
case 0xC0: Draw16x16_Mapped_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x80: Draw16x16_Mapped_FlipY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x40: Draw16x16_Mapped_FlipX_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x00: Draw16x16_Mapped_FlipXY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
}
}
}
END_SCROLL_512x512_4_16();
}
if(check_layer_enabled(f3_bg2_id)){
MAKE_SCROLL_512x512_4_16(
(0-320)-((ReadWord68k(&RAM_SCR2[0])-SCR2_XOFS)>>6),
(0-224)-((ReadWord68k(&RAM_SCR2[8])-SCR2_YOFS)>>7)
);
START_SCROLL_512x512_4_16_R180(64,64,320,224);
ta=ReadWord68k(&RAM_BG2[zz+2]);
if(ta!=0){
MAP_PALETTE_MAPPED_NEW(
ReadWord68k(&RAM_BG2[zz])&0x1FF,
32, MAP
);
if(GFX_BG0_SOLID[ta]==0){
switch(RAM_BG2[zz]&0xC0){
case 0xC0: Draw16x16_Trans_Mapped_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x80: Draw16x16_Trans_Mapped_FlipY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x40: Draw16x16_Trans_Mapped_FlipX_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x00: Draw16x16_Trans_Mapped_FlipXY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
}
}
else{
switch(RAM_BG2[zz]&0xC0){
case 0xC0: Draw16x16_Mapped_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x80: Draw16x16_Mapped_FlipY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x40: Draw16x16_Mapped_FlipX_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x00: Draw16x16_Mapped_FlipXY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
}
}
}
END_SCROLL_512x512_4_16();
}
if(check_layer_enabled(f3_bg3_id)){
MAKE_SCROLL_512x512_4_16(
(0-320)-((ReadWord68k(&RAM_SCR3[0])-SCR3_XOFS)>>6),
(0-224)-((ReadWord68k(&RAM_SCR3[8])-SCR3_YOFS)>>7)
);
START_SCROLL_512x512_4_16_R180(64,64,320,224);
ta=ReadWord68k(&RAM_BG3[zz+2]);
if(ta!=0){
MAP_PALETTE_MAPPED_NEW(
ReadWord68k(&RAM_BG3[zz])&0x1FF,
32, MAP
);
if(GFX_BG0_SOLID[ta]==0){
switch(RAM_BG3[zz]&0xC0){
case 0xC0: Draw16x16_Trans_Mapped_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x80: Draw16x16_Trans_Mapped_FlipY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x40: Draw16x16_Trans_Mapped_FlipX_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x00: Draw16x16_Trans_Mapped_FlipXY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
}
}
else{
switch(RAM_BG3[zz]&0xC0){
case 0xC0: Draw16x16_Mapped_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x80: Draw16x16_Mapped_FlipY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x40: Draw16x16_Mapped_FlipX_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
case 0x00: Draw16x16_Mapped_FlipXY_Rot(&GFX_BG0[ta<<8],x,y,MAP); break;
}
}
}
END_SCROLL_512x512_4_16();
}
render_tc0200obj_mapped_f3system_r180();
if(check_layer_enabled(f3_bg5_id)){
f3video_render_fg0_r180();
}
}
static struct VIDEO_INFO video_kaiserkn =
{
DrawKaiserKnuckle,
320,
224,
64,
VIDEO_ROTATE_NORMAL| VIDEO_ROTATABLE,
};
static struct DIR_INFO dir_kaiserkn[] =
{
{ "kaiser_knuckle", },
{ "kaiserkn", },
{ NULL, },
};
GAME( kaiserkn, "Kaiser Knuckle", TAITO, 1994, GAME_BEAT,
.romsw = romsw_kaiserkn,
.video = &video_kaiserkn,
.long_name_jpn = "カイザーナックル",
.board = "D84",
);
static struct DIR_INFO dir_dankuga[] =
{
{ "dankuga", },
{ ROMOF("kaiserkn"), },
{ CLONEOF("kaiserkn"), },
{ NULL, },
};
CLNE( dankuga,kaiserkn, "Dankuga", TAITO, 1994, GAME_BEAT,
.romsw = romsw_dankuga,
.video = &video_kaiserkn,
.long_name_jpn = "カイザーナックル (alternate)",
.board = "D84",
);
|
01b95205b3c715c771595d5543e6faa3320954fd
|
db6f3e6486ad8367c62163a4f124da185a64ab5d
|
/src/ctypesparser/doxygen.h
|
687bd77d3b33434a29014cdb90b5a43ad72947c3
|
[
"MIT",
"Zlib",
"JSON",
"LicenseRef-scancode-unknown-license-reference",
"MPL-2.0",
"BSD-3-Clause",
"GPL-2.0-only",
"NCSA",
"WTFPL",
"BSL-1.0",
"LicenseRef-scancode-proprietary-license",
"Apache-2.0"
] |
permissive
|
avast/retdec
|
c199854e06454a0e41f5af046ba6f5b9bfaaa4b4
|
b9791c884ad8f5b1c1c7f85c88301316010bc6f2
|
refs/heads/master
| 2023-08-31T16:03:49.626430
| 2023-08-07T08:15:07
| 2023-08-14T14:09:09
| 113,967,646
| 3,111
| 483
|
MIT
| 2023-08-17T05:02:35
| 2017-12-12T09:04:24
|
C++
|
UTF-8
|
C
| false
| false
| 397
|
h
|
doxygen.h
|
/**
* @file src/ctypesparser/doxygen.h
* @brief Doxygen documentation of the ctypesparser namespace.
* @copyright (c) 2017 Avast Software, licensed under the MIT license
*/
// As there is no better place to comment this namespace, we do this in the
// present file.
/// @file src/ctypesparser/doxygen.h
/// @namespace retdec::ctypesparser Parser for C-types information from JSON to ctypes.
|
16570e0e4e8eb6a0b1c52970968e328a1268718b
|
c26d7b0ed875357278e61627da2da0650da77986
|
/src/libc/gen/frexp.c
|
3cc8a03b43d96c6bae06730fd3f4becb68f67015
|
[
"BSD-3-Clause"
] |
permissive
|
RetroBSD/retrobsd
|
5343d9e3c424637fc3ad5b03fe720b2744490025
|
486f81f6abff01c7dcc207235cd2979b226a95ff
|
refs/heads/master
| 2023-09-02T23:12:05.110883
| 2023-07-07T18:41:40
| 2023-07-07T18:41:40
| 18,598,087
| 282
| 59
|
BSD-3-Clause
| 2023-07-18T07:35:36
| 2014-04-09T13:25:46
|
C
|
UTF-8
|
C
| false
| false
| 581
|
c
|
frexp.c
|
/*
* the call
* x = frexp(arg,&exp);
* must return a double fp quantity x which is <1.0
* and the corresponding binary exponent "exp".
* such that
* arg = x*2^exp
* if the argument is 0.0, return 0.0 mantissa and 0 exponent.
*/
#include <math.h>
double
frexp(x, i)
double x;
int *i;
{
int neg;
int j;
j = 0;
neg = 0;
if (x < 0) {
x = -x;
neg = 1;
}
if (x >= 1.0)
while (x >= 1.0) {
j = j+1;
x = x/2;
}
else if (x < 0.5 && x != 0.0)
while (x < 0.5) {
j = j-1;
x = 2*x;
}
*i = j;
if (neg)
x = -x;
return(x);
}
|
96198508acca52d62f18dcf4f1854b9e44f70124
|
89adda6b74cf044491fc3aea784f75abf8855bc7
|
/srcs/vm/x86_user.c
|
3559ef98b0d896a788238bcf31067a16cb348da0
|
[
"MIT"
] |
permissive
|
gamozolabs/falkervisor_grilled_cheese
|
00288953a577132d62858593ce31bc518edc4aff
|
9d7ef8e17c44c0f8ed8a5c6ee47d875fb6de4449
|
refs/heads/master
| 2022-07-09T19:19:45.496207
| 2022-06-24T00:08:44
| 2022-06-24T00:08:44
| 148,107,646
| 162
| 30
| null | 2020-08-12T23:16:23
| 2018-09-10T06:15:11
|
C
|
UTF-8
|
C
| false
| false
| 999
|
c
|
x86_user.c
|
#include <grilled_cheese.h>
#include <vm/vm.h>
rstate_t
x86_user_create(_In_ struct _vm *vm)
{
vm->step = x86_user_step;
vm->map_phys = x86_user_map_phys;
vm->dump_state = x86_user_dump_state;
vm->guest_phys_to_host_phys = x86_user_guest_virt_to_host_phys;
vm->guest_virt_to_host_phys = x86_user_guest_virt_to_host_phys;
return RSTATE_SUCCESS;
}
rstate_t
x86_user_step(_In_ struct _vm *vm)
{
return RSTATE_SUCCESS;
}
rstate_t
x86_user_map_phys(
_In_ struct _vm *vm,
_In_ uint64_t address,
_In_ int readable,
_In_ int writable,
_In_ int executable,
_In_ uint64_t backing_page)
{
return RSTATE_SUCCESS;
}
void
x86_user_dump_state(_In_ struct _vm *vm)
{
vm_x86_dump_state(vm);
return;
}
rstate_t
x86_user_guest_virt_to_host_phys(
_In_ struct _vm *vm,
_In_ uint64_t guest_vaddr,
_In_ int is_read,
_In_ int is_write,
_In_ int is_exec,
_Out_ uintptr_t *host_paddr)
{
return RSTATE_SUCCESS;
}
|
6e0217ed513530e4c7c94806cc32c00e8139edc1
|
20e1c2f5cfac01f6b007124fa7792dd69751a6bb
|
/src/os/shared/src/osapi-dir.c
|
2404d5ceec07aca4017602a63333ba77aaa06715
|
[
"Apache-2.0"
] |
permissive
|
nasa/osal
|
71f159b767ba4a8c39df48f238b4f296cc571ac8
|
99e3b4007da51031b521d90390526e123ff740b4
|
refs/heads/main
| 2023-09-01T06:33:53.932829
| 2023-08-18T14:27:02
| 2023-08-18T14:27:02
| 4,814,601
| 493
| 229
|
Apache-2.0
| 2023-09-13T13:57:40
| 2012-06-27T23:10:37
|
C
|
UTF-8
|
C
| false
| false
| 7,797
|
c
|
osapi-dir.c
|
/************************************************************************
* NASA Docket No. GSC-18,719-1, and identified as “core Flight System: Bootes”
*
* Copyright (c) 2020 United States Government as represented by the
* Administrator of the National Aeronautics and Space Administration.
* All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
************************************************************************/
/**
* \file
* \ingroup shared
* \author joseph.p.hickey@nasa.gov
*
* This file contains some of the OS APIs abstraction layer code
* that is shared/common across all OS-specific implementations.
*/
/****************************************************************************************
INCLUDE FILES
***************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "osapi-filesys.h"
/*
* User defined include files
*/
#include "os-shared-dir.h"
#include "os-shared-idmap.h"
/*
* Sanity checks on the user-supplied configuration
* The relevant OS_MAX limit should be defined and greater than zero
*/
#if !defined(OS_MAX_NUM_OPEN_DIRS) || (OS_MAX_NUM_OPEN_DIRS <= 0)
#error "osconfig.h must define OS_MAX_NUM_OPEN_DIRS to a valid value"
#endif
/*
* Global data for the API
*/
enum
{
LOCAL_NUM_OBJECTS = OS_MAX_NUM_OPEN_DIRS,
LOCAL_OBJID_TYPE = OS_OBJECT_TYPE_OS_DIR
};
OS_dir_internal_record_t OS_dir_table[LOCAL_NUM_OBJECTS];
/****************************************************************************************
DIRECTORY API
***************************************************************************************/
/*----------------------------------------------------------------
*
* Purpose: Local helper routine, not part of OSAL API.
* Init function for OS-independent layer
*
*-----------------------------------------------------------------*/
int32 OS_DirAPI_Init(void)
{
memset(OS_dir_table, 0, sizeof(OS_dir_table));
return OS_SUCCESS;
}
/*----------------------------------------------------------------
*
* Purpose: Implemented per public OSAL API
* See description in API and header file for detail
*
*-----------------------------------------------------------------*/
int32 OS_mkdir(const char *path, uint32 access)
{
int32 return_code;
char local_path[OS_MAX_LOCAL_PATH_LEN];
return_code = OS_TranslatePath(path, local_path);
if (return_code == OS_SUCCESS)
{
return_code = OS_DirCreate_Impl(local_path, access);
}
return return_code;
}
/*----------------------------------------------------------------
*
* Purpose: Implemented per public OSAL API
* See description in API and header file for detail
*
*-----------------------------------------------------------------*/
int32 OS_DirectoryOpen(osal_id_t *dir_id, const char *path)
{
char local_path[OS_MAX_LOCAL_PATH_LEN];
OS_object_token_t token;
OS_dir_internal_record_t *dir;
int32 return_code;
/* Check parameters */
OS_CHECK_POINTER(dir_id);
return_code = OS_TranslatePath(path, local_path);
if (return_code == OS_SUCCESS)
{
/* Note - the common ObjectIdAllocate routine will lock the object type and leave it locked. */
return_code = OS_ObjectIdAllocateNew(LOCAL_OBJID_TYPE, NULL, &token);
if (return_code == OS_SUCCESS)
{
dir = OS_OBJECT_TABLE_GET(OS_dir_table, token);
/* Reset the table entry and save the name */
OS_OBJECT_INIT(token, dir, dir_name, path);
/* Now call the OS-specific implementation. */
return_code = OS_DirOpen_Impl(&token, local_path);
/* Check result, finalize record, and unlock global table. */
return_code = OS_ObjectIdFinalizeNew(return_code, &token, dir_id);
}
}
return return_code;
}
/*----------------------------------------------------------------
*
* Purpose: Implemented per public OSAL API
* See description in API and header file for detail
*
*-----------------------------------------------------------------*/
int32 OS_DirectoryClose(osal_id_t dir_id)
{
OS_object_token_t token;
int32 return_code;
/* Make sure the file descriptor is legit before using it */
return_code = OS_ObjectIdGetById(OS_LOCK_MODE_EXCLUSIVE, LOCAL_OBJID_TYPE, dir_id, &token);
if (return_code == OS_SUCCESS)
{
return_code = OS_DirClose_Impl(&token);
/* Complete the operation via the common routine */
return_code = OS_ObjectIdFinalizeDelete(return_code, &token);
}
return return_code;
}
/*----------------------------------------------------------------
*
* Purpose: Implemented per public OSAL API
* See description in API and header file for detail
*
*-----------------------------------------------------------------*/
int32 OS_DirectoryRead(osal_id_t dir_id, os_dirent_t *dirent)
{
OS_object_token_t token;
int32 return_code;
/* Check parameters */
OS_CHECK_POINTER(dirent);
/* Make sure the file descriptor is legit before using it */
return_code = OS_ObjectIdGetById(OS_LOCK_MODE_GLOBAL, LOCAL_OBJID_TYPE, dir_id, &token);
if (return_code == OS_SUCCESS)
{
/*
* Call the underlying implementation to perform the read
*
* NOTE: This does not map "virtual mount points" that
* may appear in the dir listing back to the virtualized
* name. For instance, if the (real) /eeprom directory
* is virtualized to /cf via the OS_VolumeTable, and one
* reads the "/" directory, the application will see the
* real name (eeprom) and not the virtualized name (cf).
*/
return_code = OS_DirRead_Impl(&token, dirent);
OS_ObjectIdRelease(&token);
}
return return_code;
}
/*----------------------------------------------------------------
*
* Purpose: Implemented per public OSAL API
* See description in API and header file for detail
*
*-----------------------------------------------------------------*/
int32 OS_DirectoryRewind(osal_id_t dir_id)
{
OS_object_token_t token;
int32 return_code;
/* Make sure the file descriptor is legit before using it */
return_code = OS_ObjectIdGetById(OS_LOCK_MODE_NONE, LOCAL_OBJID_TYPE, dir_id, &token);
if (return_code == OS_SUCCESS)
{
return_code = OS_DirRewind_Impl(&token);
}
return return_code;
}
/*----------------------------------------------------------------
*
* Purpose: Implemented per public OSAL API
* See description in API and header file for detail
*
*-----------------------------------------------------------------*/
int32 OS_rmdir(const char *path)
{
int32 return_code;
char local_path[OS_MAX_LOCAL_PATH_LEN];
return_code = OS_TranslatePath(path, local_path);
if (return_code == OS_SUCCESS)
{
return_code = OS_DirRemove_Impl(local_path);
}
return return_code;
}
|
e61b3d4355d6347c70c3b7f202673d746226c6a8
|
5afa01fb706bc29154491c441ec801585622e38c
|
/tests/promise_test.c
|
02f55ec85075a8dd102123739045e523134a9e0c
|
[
"Apache-2.0",
"BSD-3-Clause",
"GPL-2.0-only"
] |
permissive
|
awslabs/aws-c-common
|
5af461d3b3586a569a1809c7b8f32091eec1a151
|
4dcc41cf4d1f868dcdd622c65c09bda972f75ad2
|
refs/heads/main
| 2023-08-29T14:07:10.856557
| 2023-08-25T07:40:54
| 2023-08-25T07:40:54
| 117,142,517
| 249
| 159
|
Apache-2.0
| 2023-09-12T19:02:25
| 2018-01-11T19:17:12
|
C
|
UTF-8
|
C
| false
| false
| 5,735
|
c
|
promise_test.c
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/common/clock.h>
#include <aws/common/promise.h>
#include <aws/common/thread.h>
#include <aws/testing/aws_test_harness.h>
struct promise_test_work {
struct aws_allocator *allocator;
struct aws_promise *promise;
uint64_t work_time;
int error_code;
void *value;
void (*dtor)(void *);
};
static void s_promise_test_worker(void *data) {
struct promise_test_work *work = data;
aws_promise_acquire(work->promise);
aws_thread_current_sleep(work->work_time);
if (work->error_code) {
aws_promise_fail(work->promise, work->error_code);
} else {
aws_promise_complete(work->promise, work->value, work->dtor);
}
aws_promise_release(work->promise);
}
static struct aws_thread s_promise_test_launch_worker(struct promise_test_work *work) {
const struct aws_thread_options *thread_options = aws_default_thread_options();
AWS_FATAL_ASSERT(thread_options);
struct aws_thread worker_thread;
AWS_FATAL_ASSERT(aws_thread_init(&worker_thread, work->allocator) == AWS_OP_SUCCESS);
AWS_FATAL_ASSERT(aws_thread_launch(&worker_thread, s_promise_test_worker, work, thread_options) == AWS_OP_SUCCESS);
return worker_thread;
}
struct pmr_payload {
struct aws_allocator *allocator;
};
void s_promise_test_free(void *ptr) {
struct pmr_payload *payload = ptr;
aws_mem_release(payload->allocator, payload);
}
static int s_promise_test_wait_forever(struct aws_allocator *allocator, void *ctx) {
(void)ctx;
struct aws_promise *promise = aws_promise_new(allocator);
ASSERT_NOT_NULL(promise);
struct pmr_payload *payload = aws_mem_acquire(allocator, 42);
payload->allocator = allocator;
struct promise_test_work work = {
.allocator = allocator,
.promise = promise,
.work_time = 2 * 1000 * 1000,
.value = payload,
.dtor = s_promise_test_free,
};
struct aws_thread worker_thread = s_promise_test_launch_worker(&work);
aws_promise_wait(promise);
ASSERT_SUCCESS(aws_thread_join(&worker_thread));
aws_promise_release(promise);
return 0;
}
AWS_TEST_CASE(promise_test_wait_forever, s_promise_test_wait_forever)
static int s_promise_test_wait_for_a_bit(struct aws_allocator *allocator, void *ctx) {
(void)ctx;
struct aws_promise *promise = aws_promise_new(allocator);
ASSERT_NOT_NULL(promise);
struct promise_test_work work = {
.allocator = allocator,
.promise = promise,
.work_time = 3 * 1000 * 1000,
};
struct aws_thread worker_thread = s_promise_test_launch_worker(&work);
/* wait until the worker finishes, in 500ms intervals */
while (!aws_promise_wait_for(promise, 500))
;
ASSERT_TRUE(aws_promise_error_code(promise) == 0);
ASSERT_NULL(aws_promise_value(promise));
ASSERT_SUCCESS(aws_thread_join(&worker_thread));
aws_promise_release(promise);
return 0;
}
AWS_TEST_CASE(promise_test_wait_for_a_bit, s_promise_test_wait_for_a_bit)
static int s_promise_test_finish_immediately(struct aws_allocator *allocator, void *ctx) {
(void)ctx;
struct aws_promise *promise = aws_promise_new(allocator);
ASSERT_NOT_NULL(promise);
struct promise_test_work work = {
.allocator = allocator,
.promise = promise,
.work_time = 0,
};
struct aws_thread worker_thread = s_promise_test_launch_worker(&work);
aws_promise_wait(promise);
ASSERT_TRUE(aws_promise_error_code(promise) == 0);
ASSERT_NULL(aws_promise_value(promise));
aws_promise_release(promise);
ASSERT_SUCCESS(aws_thread_join(&worker_thread));
return 0;
}
AWS_TEST_CASE(promise_test_finish_immediately, s_promise_test_finish_immediately)
static int s_promise_test_finish_before_wait(struct aws_allocator *allocator, void *ctx) {
(void)ctx;
struct aws_promise *promise = aws_promise_new(allocator);
ASSERT_NOT_NULL(promise);
aws_promise_fail(promise, 1024);
aws_promise_wait(promise);
ASSERT_TRUE(aws_promise_error_code(promise) == 1024);
ASSERT_NULL(aws_promise_value(promise));
aws_promise_release(promise);
return 0;
}
AWS_TEST_CASE(promise_test_finish_before_wait, s_promise_test_finish_before_wait)
void s_promise_test_waiter(void *data) {
struct promise_test_work *work = data;
aws_promise_acquire(work->promise);
/* sleep 0.2 seconds */
aws_thread_current_sleep(1000 * 1000 * 2);
aws_promise_wait(work->promise);
AWS_FATAL_ASSERT(aws_promise_error_code(work->promise) == 0);
aws_promise_release(work->promise);
}
static int s_promise_test_multiple_waiters(struct aws_allocator *allocator, void *ctx) {
(void)ctx;
struct aws_promise *promise = aws_promise_new(allocator);
ASSERT_NOT_NULL(promise);
struct promise_test_work work = {
.allocator = allocator,
.promise = promise,
.work_time = 2 * 1000 * 1000,
.value = promise,
};
struct aws_thread threads[8];
const struct aws_thread_options *worker_options = aws_default_thread_options();
for (int idx = 0; idx < AWS_ARRAY_SIZE(threads); ++idx) {
aws_thread_init(&threads[idx], allocator);
aws_thread_launch(&threads[idx], s_promise_test_waiter, &work, worker_options);
}
aws_thread_current_sleep(1000 * 1000 * 4);
aws_promise_complete(promise, promise, NULL);
aws_promise_release(promise);
for (int idx = 0; idx < AWS_ARRAY_SIZE(threads); ++idx) {
ASSERT_SUCCESS(aws_thread_join(&threads[idx]));
}
return 0;
}
AWS_TEST_CASE(promise_test_multiple_waiters, s_promise_test_multiple_waiters)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.