repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
lzx8589561/X-UI
|
main/ui/page/dialplate/dialplate_view.h
|
<gh_stars>1-10
#ifndef __DIALPLATE_VIEW_H
#define __DIALPLATE_VIEW_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lvgl/lvgl.h"
typedef struct dialplate_view_t *dialplate_view_heandler;
typedef struct
{
lv_obj_t* cont;
lv_obj_t* lableValue;
lv_obj_t* lableUnit;
} SubInfo_t;
struct dialplate_view_t{
struct
{
lv_obj_t* cont;
lv_obj_t* labelSpeed;
lv_obj_t* labelUint;
} topInfo;
struct
{
lv_obj_t* cont;
SubInfo_t labelInfoGrp[4];
} bottomInfo;
struct
{
lv_obj_t* cont;
lv_obj_t* btnMap;
lv_obj_t* btnRec;
lv_obj_t* btnMenu;
} btnCont;
lv_anim_timeline_t* anim_timeline;
};
void dialplate_view_create(lv_obj_t *root);
void dialplate_view_delete();
void dialplate_view_appear_anim_start(bool reverse);
extern dialplate_view_heandler dialplate_view_ui;
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif // !__VIEW_H
|
lzx8589561/X-UI
|
main/ui/page/start_up/start_up.c
|
#include <stdlib.h>
#include "start_up.h"
#include "start_up_view.h"
#include "../../ui_page_manager.h"
#include "../status_bar/status_bar.h"
static page_base_handler pb = NULL;
startup_view_handler startup_view_ui = NULL;
static void start_up_on_timer(lv_timer_t* timer);
static void start_up_on_event(lv_event_t* event);
static void on_custom_attr_config()
{
// 开启页面缓存
set_custom_cache_enable(pb, false);
// 禁用动画
set_custom_load_anim_type(pb, LOAD_ANIM_NONE, 500, lv_anim_path_ease_out);
}
static void on_view_load()
{
startup_view_ui = calloc(1, sizeof (struct startup_view_t));
startup_view_create(pb->root);
lv_timer_t* timer = lv_timer_create(start_up_on_timer, 2000, pb);
lv_timer_set_repeat_count(timer, 1);
}
static void on_view_did_load()
{
lv_obj_fade_out(pb->root, 500, 1500);
}
static void on_view_will_appear()
{
lv_anim_timeline_start(startup_view_ui->anim_timeline);
}
static void on_view_did_appear()
{
}
static void on_view_will_disappear()
{
}
static void on_view_did_disappear()
{
status_bar_appear(true);
}
static void on_view_did_unload()
{
startup_view_delete();
// 清除页面指针
free(startup_view_ui);
}
void start_up_on_timer(lv_timer_t* timer)
{
// 开始跳转到首页
pm_push("page/dialplate", NULL);
}
void start_up_on_event(lv_event_t* event)
{
// lv_obj_t* obj = lv_event_get_target(event);
// lv_event_code_t code = lv_event_get_code(event);
// Startup* instance = (Startup*)lv_obj_get_user_data(obj);
//
// if (obj == instance->root)
// {
// if (code == LV_EVENT_LEAVE)
// {
// //instance->Manager->Pop();
// }
// }
}
page_base_handler ui_page_register_start_up(){
UI_PAGE_FUN_INIT();
return pb;
}
|
lzx8589561/X-UI
|
main/ui/page/dialplate/dialplate.h
|
<gh_stars>1-10
#ifndef __DIALPLATE_PRESENTER_H
#define __DIALPLATE_PRESENTER_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lvgl/lvgl.h"
/**
* 定义页面单独的一些交互实体
*/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif
|
lzx8589561/X-UI
|
main/ui/app_page_factory.c
|
<reponame>lzx8589561/X-UI
#include "ui_page_manager.h"
/**
* 页面定义
* @param name 页面名称
* @return 页面处理器
*/
page_base_handler pm_create_page(const char* name){
APP_CLASS_MATCH(start_up);
APP_CLASS_MATCH(dialplate);
return NULL;
}
|
lzx8589561/X-UI
|
main/controller/dialplate_controller.c
|
#include <sys/cdefs.h>
#include <stdio.h>
#include "esp_system.h"
#include "esp_event.h"
#include "esp_log.h"
#include <freertos/task.h>
#include "dialplate_controller.h"
#include "../ui/ui_page_manager.h"
#include "../ui/app_entity_def.h"
static int a1 = 1;
static int a2 = 1;
static int a3 = 1;
/***
* 消息回调接收 （由UI线程调用）
* @param data_msg 消息
*/
static void on_data_event(dc_data_msg_t *data_msg) {
if (data_msg->sync) {
// 处理同步消息 同步消息不可做耗时操作
switch (data_msg->msg_type) {
case TEST_MSG_SYNC_TEST_DATA: {
char *str = calloc(50, sizeof(char));
sprintf(str, "s%d", a1);
// 放入返回数据
data_msg->sync_result = str;
break;
}
}
}else{
// 处理异步消息 如处理需要耗时，创建一个新的任务去处理
}
}
/**
* 任务定时向UI发送数据示例
*/
_Noreturn static void dialplate_update_task() {
while (1) {
// 申请的内存会在发送完成后自动释放
dc_data_msg_t *msg = dc_create_msg("test_topic");
msg->msg_type = TEST_MSG_TEST_DATA;
test_data_t *data = calloc(1, sizeof(test_data_t));
data->attr1 = a1;
data->attr2 = a2;
data->attr3 = a3;
msg->data = data;
// 发布消息
dc_publish(msg);
// 变化数据
a1++;
a2 += 2;
a3 += 3;
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
void dialplate_controller_init() {
// 订阅主题
dc_subscribe("test_topic", on_data_event);
xTaskCreate((TaskFunction_t) dialplate_update_task, "dialplate_update_task",
2048, NULL, 5,
NULL);
}
|
maxux/zdbfs
|
src/zdbfs.c
|
<gh_stars>0
#define FUSE_USE_VERSION 34
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <fuse_lowlevel.h>
#include <hiredis/hiredis.h>
#include <signal.h>
#include <linux/fs.h>
#include <sys/epoll.h>
#include <sys/ioctl.h>
#include <stddef.h>
#include "zdbfs.h"
#include "init.h"
#include "zdb.h"
#include "inode.h"
#include "cache.h"
#include "system.h"
//
// volatile inode
//
// this is a special extension defined to auto-cleanup
// zdb_inode_t at the end of a function, adding 'volino'
// in front of a zdb_inode_t * variable will call the cleanup
// handler as soon as the function returns, whenever it is
//
// this ensure there is never any leak about inode inside
// a function without having to write free explicitly on each
// error case
//
#define volino __attribute__((cleanup(__cleanup_inode)))
#define volstr __attribute__((cleanup(__cleanup_malloc)))
#define zdbfs_macro_stats_incr(fs, field) { fs->stats.field += 1; }
#define zdbfs_macro_stats_add(fs, field, value) { fs->stats.field += value; }
void __cleanup_inode(void *p) {
zdb_inode_t *x = * (zdb_inode_t **) p;
if(x == NULL)
return;
if(x->ino == 0)
zdbfs_inode_free(x);
}
void __cleanup_malloc(void *p) {
void *x = * (void **) p;
free(x);
}
//
// general helpers
//
int zdbfs_log_enabled(fuse_req_t req) {
zdbfs_t *fs = fuse_req_userdata(req);
return (fs->logfd != NULL);
}
void zdbfs_log(fuse_req_t req, char *call, const char *fmt, ...) {
zdbfs_t *fs = fuse_req_userdata(req);
va_list args;
time_t timestamp = time(NULL);
struct tm *ptime = localtime(×tamp);
char datestr[128];
va_start(args, fmt);
strftime(datestr, sizeof(datestr), "%Y-%m-%d %H:%M:%S", ptime);
fprintf(fs->logfd, "%s [%s] ", datestr, call);
vfprintf(fs->logfd, fmt, args);
fprintf(fs->logfd, "\n");
va_end(args);
}
// propagate an error to fuse with verbosity
void zdbfs_fuse_error(fuse_req_t req, int err, uint64_t ino) {
#ifdef RELEASE
(void) ino;
#endif
zdbfs_t *fs = fuse_req_userdata(req);
zdbfs_macro_stats_incr(fs, errors);
zdbfs_debug("[/] syscall: error reply: ino %lu: %s\n", ino, strerror(err));
fuse_reply_err(req, err);
}
//
// fuse syscall implementation
//
static void zdbfs_fuse_init(void *userdata, struct fuse_conn_info *conn) {
(void) userdata;
zdbfs_syscall("init", "[%d]", conn->want);
}
static void zdbfs_fuse_getattr(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {
zdbfs_t *fs = fuse_req_userdata(req);
struct stat stbuf;
volino zdb_inode_t *inode = NULL;
(void) fi;
zdbfs_syscall("getattr", "ino: %ld", ino);
zdbfs_macro_stats_incr(fs, syscall_getattr);
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, ENOENT, ino);
zdbfs_inode_to_stat(&stbuf, inode, ino);
fuse_reply_attr(req, &stbuf, ZDBFS_KERNEL_CACHE_TIME);
}
static void zdbfs_fuse_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr, int to_set, struct fuse_file_info *fi) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
struct stat stbuf;
(void) fi;
zdbfs_syscall("setattr", "ino: %ld", ino);
zdbfs_macro_stats_incr(fs, syscall_setattr);
// fetching current inode state
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, ENOENT, ino);
memset(&stbuf, 0, sizeof(stbuf));
// update inode based on request
if(to_set & FUSE_SET_ATTR_MODE)
inode->mode = attr->st_mode;
if(to_set & FUSE_SET_ATTR_UID)
inode->uid = attr->st_uid;
if(to_set & FUSE_SET_ATTR_GID)
inode->gid = attr->st_gid;
if(to_set & FUSE_SET_ATTR_SIZE)
inode->size = attr->st_size;
if(to_set & FUSE_SET_ATTR_ATIME)
inode->atime = attr->st_atim.tv_sec;
if(to_set & FUSE_SET_ATTR_MTIME)
inode->mtime = attr->st_mtim.tv_sec;
if(to_set & FUSE_SET_ATTR_ATIME_NOW)
inode->atime = time(NULL);
if(to_set & FUSE_SET_ATTR_MTIME_NOW)
inode->mtime = time(NULL);
if(to_set & FUSE_SET_ATTR_CTIME)
inode->ctime = attr->st_ctim.tv_sec;
// save updated inode to backend
if(zdbfs_inode_store_metadata(req, inode, ino) != ino)
return zdbfs_fuse_error(req, EIO, ino);
// send updated information back to caller
zdbfs_inode_to_stat(&stbuf, inode, ino);
fuse_reply_attr(req, &stbuf, ZDBFS_KERNEL_CACHE_TIME);
}
static void zdbfs_fuse_lookup(fuse_req_t req, fuse_ino_t parent, const char *name) {
struct fuse_entry_param e;
volino zdb_inode_t *directory = NULL;
volino zdb_inode_t *inode = NULL;
zdb_direntry_t *entry;
zdbfs_syscall("lookup", "parent: %ld, name: %s", parent, name);
if(!(directory = zdbfs_directory_fetch(req, parent)))
return;
// checking for entry in that directory
if(!(entry = zdbfs_inode_lookup_direntry(directory, name)))
return zdbfs_fuse_error(req, ENOENT, parent);
if(!(inode = zdbfs_inode_fetch(req, entry->ino)))
return zdbfs_fuse_error(req, ENOENT, entry->ino);
zdbfs_inode_to_fuse_param(&e, inode, entry->ino);
fuse_reply_entry(req, &e);
}
static void zdbfs_fuse_create(fuse_req_t req, fuse_ino_t parent, const char *name, mode_t mode, struct fuse_file_info *fi) {
zdbfs_t *fs = fuse_req_userdata(req);
struct fuse_entry_param e;
volino zdb_inode_t *inode = NULL;
volino zdb_inode_t *create = NULL;
uint32_t ino;
zdbfs_syscall("create", "parent: %ld, name: %s", parent, name);
zdbfs_macro_stats_incr(fs, syscall_create);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, parent, name);
zdbfs_log(req, "create", "%s [mode %o]", path, mode);
}
if(!(inode = zdbfs_directory_fetch(req, parent)))
return;
// new file
create = zdbfs_inode_new_file(req, mode);
if((ino = zdbfs_inode_store_metadata(req, create, 0)) == 0)
return zdbfs_fuse_error(req, EIO, parent);
// update directory with new entry
zdbfs_inode_dir_append(inode, ino, name);
if(zdbfs_inode_store_metadata(req, inode, parent) != parent)
return zdbfs_fuse_error(req, EIO, parent);
zdbfs_inode_to_fuse_param(&e, create, ino);
fuse_reply_create(req, &e, fi);
}
static void zdbfs_fuse_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name, mode_t mode) {
zdbfs_t *fs = fuse_req_userdata(req);
struct fuse_entry_param e;
const struct fuse_ctx *ctx = fuse_req_ctx(req);
volino zdb_inode_t *inode = NULL;
volino zdb_inode_t *newdir = NULL;
zdbfs_syscall("mkdir", "parent: %ld, name: %s", parent, name);
zdbfs_macro_stats_incr(fs, syscall_mkdir);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, parent, name);
zdbfs_log(req, "mkdir", "%s [mode %o]", path, mode);
}
if(!(inode = zdbfs_directory_fetch(req, parent)))
return;
// create new empty dir, sending it to the backend
newdir = zdbfs_inode_new_dir(parent, mode);
newdir->uid = ctx->uid;
newdir->gid = ctx->gid;
uint32_t ino;
if((ino = zdbfs_inode_store_metadata(req, newdir, 0)) == 0)
return zdbfs_fuse_error(req, EIO, 0);
zdbfs_inode_dir_append(inode, ino, name);
if(zdbfs_inode_store_metadata(req, inode, parent) != parent)
return zdbfs_fuse_error(req, EIO, parent);
zdbfs_inode_to_fuse_param(&e, newdir, ino);
fuse_reply_entry(req, &e);
}
static void zdbfs_fuse_readdir(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
(void) fi;
zdbfs_syscall("readdir", "ino: %lu, size: %lu, offset: %ld", ino, size, off);
zdbfs_macro_stats_incr(fs, syscall_readdir);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, ino, NULL);
zdbfs_log(req, "readdir", "%s", path);
}
if(!(inode = zdbfs_directory_fetch(req, ino))) {
zdbfs_critical("[-] readdir: failed to fetch inode %lu\n", ino);
return;
}
// force entry to be cached, speed up chunked access
zdbfs_cache_add(req, ino, inode);
// fillin direntry with inode contents
zdbfs_debug("[+] readdir: %lu: okay, fillin entries\n", ino);
zdb_dir_root_t *root = zdbfs_inode_dir_root_get(inode);
// fuse documentation says that 'off_t off' is an arbitrary offset
// used to know from where to start to read the directory content, this
// offset is for and by us, to keep track of directory position when multiple
// calls are made because the buffer cannot be filled in one shot
//
// this offset needs to contains enough information to know from where to start
// and cannot be a simple index since it needs to be able to send a list even if
// that list is modified between calls, we won't really support this and use
// that offset with some trick
//
// in order to know where to jump instantly, 'off' is a 64 bits unsigned integer,
// we will set the dirlist entry as first byte and use the rest list index
//
// 0xaabbbbbbbbbbbbbb
// ^^^^^^^^^^^^^^^^
// | +- list entry index
// +- dirlist index
size_t diroff = (off & 0xff00000000000000) >> 56;
size_t entoff = (off & 0x00ffffffffffffff);
zdbfs_lowdebug("readdir: offset: %lx, dirlist: %lu, entry: %lu", off, diroff, entoff);
buffer_t buffer;
buffer.length = size;
// temp stat buffer to hold ino number
struct stat stbuf;
memset(&stbuf, 0, sizeof(stbuf));
// currently used buffer size
size_t bufused = 0;
// allocate buffer large enough (cannot be larger than received
// size parameter, let just allocate that one)
if(!(buffer.buffer = calloc(buffer.length, 1)))
zdbfs_sysfatal("readdir: calloc");
// keep track of a pointer we advance
// for each entries
uint8_t *ptr = buffer.buffer;
for(size_t d = diroff; d < DIRLIST_SIZE; d++) {
// ignore empty list
if(root->dirlist[d] == NULL)
continue;
zdb_dir_t *dir = root->dirlist[d];
// zdbfs_debug("[+] readdir: list %lu: total entries: %u\n", d, dir->length);
for(off_t i = entoff; i < dir->length; i++) {
zdb_direntry_t *entry = dir->entries[i];
size_t entlen = fuse_add_direntry(req, NULL, 0, entry->name, NULL, 0);
if(bufused + entlen > buffer.length) {
zdbfs_debug("[+] readdir: not space to add more entries, next time\n");
// cannot hold more entries this time, let's
// return what we have now
goto done; // FIXME ?
}
// computing next offset
off_t newoff = (d << 56) | ((i + 1) & 0x00ffffffffffffff);
// printf("NEW OFF %lx [%lu / %lu]\n", newoff, d, i + 1);
// set ino id and entry
stbuf.st_ino = entry->ino;
// stbuf.st_mode = S_IFREG; // FIXME: workaround for d_type
fuse_add_direntry(req, (char *) ptr, buffer.length - bufused, entry->name, &stbuf, newoff);
ptr += entlen;
bufused += entlen;
}
// reset entry offset for next branch list
entoff = 0;
}
done:
fuse_reply_buf(req, buffer.buffer, bufused);
// cleanup our buffer
free(buffer.buffer);
}
static void zdbfs_fuse_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
zdbfs_syscall("open", "ino %lu: request", ino);
zdbfs_macro_stats_incr(fs, syscall_open);
if(zdbfs_log_enabled(req)) {
zdbfs_log(req, "open", "inode %ld", ino);
}
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, ENOENT, ino);
if(S_ISDIR(inode->mode))
return zdbfs_fuse_error(req, EISDIR, ino);
if(fi->flags & O_RDONLY) {
zdbfs_debug("[+] open: read only requested %lu\n", ino);
fuse_reply_open(req, fi);
return;
}
// FIXME: implement O_RDONLY, O_WRONLY, O_RDWR permission
// FIXME: support O_APPEND
// FIXME: support cache-writeback feature
if(fi->flags & O_TRUNC) {
zdbfs_debug("[+] open: truncating file %lu\n", ino);
// FIXME: discard blocks ?
inode->size = 0;
// saving possible inode change (if nothing changed, set call will
// have no effect on zdb size)
if(zdbfs_inode_store_metadata(req, inode, ino) != ino)
return zdbfs_fuse_error(req, EIO, ino);
fuse_reply_open(req, fi);
return;
}
/*
if((fi->flags & O_ACCMODE) != O_RDONLY) {
fuse_reply_err(req, EACCES);
return;
}
*/
fuse_reply_open(req, fi);
}
static void zdbfs_fuse_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {
zdbfs_t *fs = fuse_req_userdata(req);
(void) fi;
volino zdb_inode_t *inode = NULL;
size_t fetched = 0;
char *buffer;
off_t ooff = off; // copy original offset
zdbfs_syscall("read", "ino %lu: size %lu, off: %lu", ino, size, off);
zdbfs_macro_stats_incr(fs, syscall_read);
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, EIO, ino);
// zdbfs_inode_dump(inode);
if(!(buffer = calloc(size, 1)))
zdbfs_sysfatal("read: buffer: malloc");
// for each block to read
while(fetched < size) {
uint32_t block = zdbfs_offset_to_block(off);
// checking if request is aligned with our block
size_t alignment = (off % ZDBFS_BLOCK_SIZE);
if(zdbfs_inode_block_get(inode, block) == 0) {
// block id from requested offset returned 0
// this mean this block doesn't exists _or_ the block
// is set to 0, if the block doesn't contains any data
// if it's a hole, in case of a hole, we need to returns
// valid response and not truncated response
zdbfs_debug("[+] read: requested block does not exists or empty\n");
size_t eob = ZDBFS_BLOCK_SIZE - alignment;
zdbfs_debug("[+] read: skipping this block, moving forward: %lu bytes\n", eob);
fetched += eob;
off += eob;
continue;
}
zdb_reply_t *reply;
if(!(reply = zdbfs_inode_block_fetch(req, inode, ino, block))) {
free(buffer);
return zdbfs_fuse_error(req, EIO, ino);
}
if(reply->length < alignment) {
zdbfs_debug("[+] read: try to read further than any data on this block\n");
zdbfs_zdb_reply_free(reply);
// act like block were not found, we don't have
// any data useful on this block, we are probably in
// a hole
size_t eob = ZDBFS_BLOCK_SIZE - alignment;
fetched += eob;
off += eob;
continue;
}
// fetched block contains something we need
// the full block can be used, or partial content
// partial content can be anywhere and any length inside
// the block
// computing remaining size to fetch
size_t remain = size - fetched;
// checking if the whole block can be used or not
size_t chunk = (remain <= reply->length - alignment) ? remain : reply->length - alignment;
zdbfs_debug("[+] read: copying %lu bytes (block align: %lu)\n", chunk, alignment);
memcpy(buffer + fetched, reply->value + alignment, chunk);
// cleaning block read
zdbfs_zdb_reply_free(reply);
if(chunk == 0) {
if(ooff + fetched >= inode->size) {
// eof reached
zdbfs_debug("[+] read: nothing more to read [%lu >= %lu]\n", off + fetched, inode->size);
break;
}
zdbfs_debug("[+] read: nothing left on that block, trying next one\n");
// block doesn't contains any relevant data anymore
// let's try maybe next block (if any, if none, will
// fails on the beginin of the next loop)
chunk = ZDBFS_BLOCK_SIZE - alignment;
zdbfs_debug("[+] read: skipping last %lu bytes to reach next block\n", chunk);
}
fetched += chunk;
off += chunk;
}
// avoid overrun if we skipped hole larger
// than expected
if(fetched > size)
fetched = size;
// if the chunk requested is in range of the file
// we are maybe inside a hole and we need to reply
// the full length
if(off + size < inode->size && fetched != size) {
zdbfs_debug("[+] read: growing chunk read, hole possible\n");
fetched = size;
}
zdbfs_macro_stats_add(fs, read_bytes, fetched);
fuse_reply_buf(req, buffer, fetched);
free(buffer);
}
static void zdbfs_fuse_write(fuse_req_t req, fuse_ino_t ino, const char *buf, size_t size, off_t off, struct fuse_file_info *fi) {
(void) fi;
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
zdb_reply_t *reply;
size_t sent = 0;
zdbfs_syscall("write", "ino %lu: size %lu, off: %lu", ino, size, off);
zdbfs_macro_stats_incr(fs, syscall_write);
// fetch file inode which contains blockslist
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, ENOENT, ino);
// sending each blocks
while(sent < size) {
// set blockid as 0 (insert new)
uint32_t blockid = 0;
// alignment is the offset inside this block
uint32_t alignment = (off + sent) % ZDBFS_BLOCK_SIZE;
// compute which block we use at this offset
size_t block = zdbfs_offset_to_block(off + sent);
// compute how many bytes to write _maximum_ on this chunk
// this can be larger than blocksize
size_t towrite = (size - sent > ZDBFS_BLOCK_SIZE) ? ZDBFS_BLOCK_SIZE : size - sent;
// keep track of this chunk length
size_t writepass = towrite;
// link buffer to global allocated buffer
char *buffer = fs->tmpblock;
// if there are any alignment, we need to take it in account
if(towrite + alignment > ZDBFS_BLOCK_SIZE)
writepass = ZDBFS_BLOCK_SIZE - alignment;
// set this chunk size
// size_t blocksize = alignment + writepass;
size_t blocksize = alignment + writepass;
zdbfs_debug("[+] write: block alignment: %u, write: %lu, pass: %lu\n", alignment, towrite, writepass);
// FIXME: optimize ?
memset(fs->tmpblock, 0, ZDBFS_BLOCK_SIZE);
blockid = zdbfs_inode_block_get(inode, block);
if(blockid != 0) {
// target block found on the blockslist, which mean
// the block already exists in the backend, we need
// to fetch this block to update it with new data
zdbfs_debug("[+] write: block already in the backend: %u\n", blockid);
// resize this block size by expected buffer length
// following inline move
blocksize = alignment + writepass;
// fetch the block from backend
if(!(reply = zdbfs_inode_block_fetch(req, inode, ino, block)))
return zdbfs_fuse_error(req, EIO, ino);
if(reply->length > ZDBFS_BLOCK_SIZE) {
// critical: the fetched block from backend is larger
// than our configured blocksize, we can't do anything
// with this, blocklist is not inline with backend
printf("[-] write: block read from backend larger than our blocksize\n");
zdbfs_zdb_reply_free(reply);
return zdbfs_fuse_error(req, EINVAL, ino);
}
// if fetched block is larger than what we need to write
// updating blocksize to read size, we will write only on
// the expected segment but send the full block
if(reply->length > blocksize)
blocksize = reply->length;
// copying block from backend into temporarily buffer
memcpy(buffer, reply->value, reply->length);
// FIXME
zdbfs_zdb_reply_free(reply);
}
zdbfs_debug("[+] write: writing %lu bytes segment\n", writepass);
zdbfs_debug("[+] write: block write: %lu bytes (sent: %lu, block: %u)\n", blocksize, sent, blockid);
// merge existing block buffer with write chunk
memcpy(buffer + alignment, buf + sent, writepass);
// send block to the backend, this can be a new block or an existing
// block updated
if((blockid = zdbfs_inode_block_store(req, inode, ino, block, buffer, blocksize)) == 0)
return zdbfs_fuse_error(req, zdb_errno, ino);
// jump to the next chunk to write
sent += writepass;
}
if(off + size > inode->size)
inode->size = off + size;
zdbfs_debug("[+] write: all blocks written (%lu bytes)\n", sent);
if(zdbfs_inode_store_metadata(req, inode, ino) == 0)
return zdbfs_fuse_error(req, zdb_errno, 0);
zdbfs_macro_stats_add(fs, write_bytes, sent);
fuse_reply_write(req, sent);
}
static void zdbfs_fuse_symlink(fuse_req_t req, const char *link, fuse_ino_t parent, const char *name) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *newlink = NULL;
volino zdb_inode_t *directory = NULL;
uint32_t ino = 0;
struct fuse_entry_param e;
zdbfs_syscall("symlink", "ino %lu/%s -> %s", parent, name, link);
zdbfs_macro_stats_incr(fs, syscall_symlink);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, parent, name);
zdbfs_log(req, "symlink", "%s -> %s", path, link);
}
// fetching original inode information
if(!(directory = zdbfs_inode_fetch(req, parent)))
return zdbfs_fuse_error(req, ENOENT, parent);
// checking if destination does not already exists
if(zdbfs_inode_lookup_direntry(directory, name))
return zdbfs_fuse_error(req, EEXIST, parent);
// create new symlink inode
newlink = zdbfs_inode_new_symlink(req, link);
// save new symlink inode
if((ino = zdbfs_inode_store_metadata(req, newlink, 0)) == 0)
return zdbfs_fuse_error(req, EIO, 0);
// append new entry on the destination directory
zdbfs_inode_dir_append(directory, ino, name);
// saving new directory contents
if(zdbfs_inode_store_metadata(req, directory, parent) != parent)
return zdbfs_fuse_error(req, EIO, ino);
zdbfs_inode_to_fuse_param(&e, newlink, ino);
fuse_reply_entry(req, &e);
}
static void zdbfs_fuse_readlink(fuse_req_t req, fuse_ino_t ino) {
volino zdb_inode_t *inode = NULL;
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, ENOENT, ino);
const char *link = zdbfs_inode_symlink_get(inode);
fuse_reply_readlink(req, link);
}
static void zdbfs_fuse_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, const char *newname) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
volino zdb_inode_t *newdir = NULL;
struct fuse_entry_param e;
zdbfs_syscall("link", "ino %lu -> %lu, %s", ino, newparent, newname);
zdbfs_macro_stats_incr(fs, syscall_link);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, newparent, newname);
zdbfs_log(req, "link", "%lu -> %s", ino, path);
}
// fetching original inode information
if(!(inode = zdbfs_inode_fetch(req, ino)))
return zdbfs_fuse_error(req, ENOENT, ino);
// fetching destination directory information
if(!(newdir = zdbfs_inode_fetch(req, newparent)))
return zdbfs_fuse_error(req, ENOENT, newparent);
// checking if destination does not already exists
if(zdbfs_inode_lookup_direntry(newdir, newname))
return zdbfs_fuse_error(req, EEXIST, newparent);
// create new entry on the destination directory
zdbfs_inode_dir_append(newdir, ino, newname);
// increase link-count of original inode
inode->links += 1;
// saving new directory contents
if(zdbfs_inode_store_metadata(req, inode, ino) != ino)
return zdbfs_fuse_error(req, EIO, ino);
// saving inode information
if(zdbfs_inode_store_metadata(req, newdir, newparent) != newparent)
return zdbfs_fuse_error(req, EIO, newparent);
zdbfs_inode_to_fuse_param(&e, inode, ino);
fuse_reply_entry(req, &e);
}
static void zdbfs_fuse_unlink(fuse_req_t req, fuse_ino_t parent, const char *name) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
volino zdb_inode_t *file = NULL;
zdb_direntry_t *entry;
int linkinfo;
//
// FIXME: no forget support
//
zdbfs_syscall("unlink", "parent %lu, name: %s", parent, name);
zdbfs_macro_stats_incr(fs, syscall_unlink);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, parent, name);
zdbfs_log(req, "unlink", "%s", path);
}
// fetch parent directory
if(!(inode = zdbfs_inode_fetch(req, parent)))
return zdbfs_fuse_error(req, ENOENT, parent);
// lookup for file entry in the directory
if(!(entry = zdbfs_inode_lookup_direntry(inode, name)))
return zdbfs_fuse_error(req, ENOENT, parent);
// fetching inode information about the file
if(!(file = zdbfs_inode_fetch(req, entry->ino)))
return zdbfs_fuse_error(req, ENOENT, entry->ino);
// remove blocks
if((linkinfo = zdbfs_inode_unlink(req, file, entry->ino)) == 1)
return zdbfs_fuse_error(req, EIO, entry->ino);
// reset file pointer if dropped
if(linkinfo == 0)
file = NULL; // avoid volino double free
// remove file from directory list
if(zdbfs_inode_remove_entry(inode, name) != 0)
return zdbfs_fuse_error(req, ENOENT, parent);
// save parent directory new list
if(zdbfs_inode_store_metadata(req, inode, parent) != parent)
return zdbfs_fuse_error(req, EIO, parent);
// success
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *inode = NULL;
volino zdb_inode_t *target = NULL;
inocache_t *inocache;
//
// FIXME: no forget support
//
zdbfs_syscall("rmdir", "parent %lu, name: %s", parent, name);
zdbfs_macro_stats_incr(fs, syscall_rmdir);
if(zdbfs_log_enabled(req)) {
volstr char *path = zdbfs_inode_resolv(req, parent, NULL);
zdbfs_log(req, "rmdir", "%s", path);
}
if(!(inode = zdbfs_inode_fetch(req, parent)))
return zdbfs_fuse_error(req, ENOENT, parent);
zdb_direntry_t *expected;
if(!(expected = zdbfs_inode_lookup_direntry(inode, name))) {
zdbfs_debug("[+] rmdir: child not found (%s) on parent: %lu\n", name, parent);
return zdbfs_fuse_error(req, ENOENT, parent);
}
zdbfs_debug("[+] rmdir: entry found, inspecting ino: %lu\n", expected->ino);
if(!(target = zdbfs_inode_fetch(req, expected->ino)))
return zdbfs_fuse_error(req, ENOENT, expected->ino);
zdb_dir_t *targetdir = zdbfs_inode_dir_get(target, name);
if(targetdir->length > 2) {
zdbfs_debug("[+] rmdir: target directory not empty (length: %u)\n", targetdir->length);
return zdbfs_fuse_error(req, ENOTEMPTY, expected->ino);
}
// invalidate cache if present
if((inocache = zdbfs_cache_get(req, expected->ino))) {
zdbfs_debug("[+] rmdir: target inode still in cache, cleaning\n");
zdbfs_cache_drop(req, inocache);
// avoid double free by volino
target = NULL;
}
// remove inode from backend
if(zdb_del(fs->metactx, expected->ino) != 0)
return zdbfs_fuse_error(req, EIO, expected->ino);
// this should never fails since it matched just before
if(zdbfs_inode_remove_entry(inode, name) != 0)
return zdbfs_fuse_error(req, ENOENT, parent);
if(zdbfs_inode_store_metadata(req, inode, parent) != parent)
return zdbfs_fuse_error(req, EIO, parent);
// success
fuse_reply_err(req, 0);
}
// special handler for rename on the same directory
static void zdbfs_fuse_rename_same(fuse_req_t req, fuse_ino_t parent, const char *name, const char *newname, unsigned int flags) {
volino zdb_inode_t *directory = NULL;
volino zdb_inode_t *existing = NULL;
uint32_t sourceino = 0;
int linkinfo;
zdbfs_syscall("rename", "%lu, name: %s -> name: %s", parent, name, newname);
if(zdbfs_log_enabled(req)) {
zdbfs_log(req, "rename", "%ld: %s -> %s", parent, name, newname);
}
if(!(directory = zdbfs_inode_fetch(req, parent)))
return zdbfs_fuse_error(req, ENOENT, parent);
// ensure source exists
zdb_direntry_t *entry;
if(!(entry = zdbfs_inode_lookup_direntry(directory, name)))
return zdbfs_fuse_error(req, ENOENT, parent);
// keep track of the source inode id
sourceino = entry->ino;
zdb_direntry_t *target;
if((target = zdbfs_inode_lookup_direntry(directory, newname))) {
zdbfs_debug("[+] rename: target already exists\n");
// fetching target inode
if(!(existing = zdbfs_inode_fetch(req, target->ino)))
return zdbfs_fuse_error(req, EIO, target->ino);
// target already exists
// checking flags and unlink it if needed
if(flags & RENAME_NOREPLACE)
return zdbfs_fuse_error(req, EEXIST, target->ino);
if((linkinfo = zdbfs_inode_unlink(req, existing, target->ino)) == 1)
return zdbfs_fuse_error(req, EIO, entry->ino);
// reset file pointer if dropped
if(linkinfo == 0)
existing = NULL; // avoid volino double free
// remove target from directory
zdbfs_inode_remove_entry(directory, newname);
}
// remove original (flag it to delete)
zdbfs_inode_remove_entry(directory, name);
// create new direntry using same inode id
zdbfs_inode_dir_append(directory, sourceino, newname);
// save updated parent
if(zdbfs_inode_store_metadata(req, directory, parent) != parent)
return zdbfs_fuse_error(req, EIO, parent);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_rename(fuse_req_t req, fuse_ino_t parent, const char *name, fuse_ino_t newparent, const char *newname, unsigned int flags) {
zdbfs_t *fs = fuse_req_userdata(req);
volino zdb_inode_t *old = NULL;
volino zdb_inode_t *new = NULL;
volino zdb_inode_t *existing = NULL;
uint32_t sourceino = 0;
zdbfs_macro_stats_incr(fs, syscall_rename);
if(parent == newparent)
return zdbfs_fuse_rename_same(req, parent, name, newname, flags);
zdbfs_syscall("rename", "%lu, name: %s -> %lu, name: %s", parent, name, newparent, newname);
if(zdbfs_log_enabled(req)) {
volstr char *path1 = zdbfs_inode_resolv(req, parent, name);
volstr char *path2 = zdbfs_inode_resolv(req, newparent, newname);
zdbfs_log(req, "rename", "%s -> %s", path1, path2);
}
// first checking old and new inodes
if(!(old = zdbfs_inode_fetch(req, parent)))
return zdbfs_fuse_error(req, ENOENT, parent);
// only fetch new parent if it's another directory
if(!(new = zdbfs_inode_fetch(req, newparent)))
return zdbfs_fuse_error(req, ENOENT, newparent);
// ensure source exists
zdb_direntry_t *entry;
if(!(entry = zdbfs_inode_lookup_direntry(old, name)))
return zdbfs_fuse_error(req, ENOENT, parent);
// keep track of the source inode id
sourceino = entry->ino;
// check if target already exists
zdb_direntry_t *nentry;
if((nentry = zdbfs_inode_lookup_direntry(new, newname))) {
zdbfs_debug("[+] rename: target already exists\n");
if(!(existing = zdbfs_inode_fetch(req, nentry->ino)))
return zdbfs_fuse_error(req, EIO, nentry->ino);
// target already exists
// checking flags and unlink it if needed
if(flags & RENAME_NOREPLACE)
return zdbfs_fuse_error(req, EEXIST, nentry->ino);
if(zdbfs_inode_unlink(req, existing, nentry->ino) == 0) {
// unlink removed cache already, should
// not be freed another time later
existing = NULL;
}
// remove target from directory
zdbfs_inode_remove_entry(new, newname);
}
// remove original
zdbfs_inode_remove_entry(old, name);
// copy direntry and copy it to new parent
zdbfs_inode_dir_append(new, sourceino, newname);
// save updated parents
if(zdbfs_inode_store_metadata(req, old, parent) != parent)
return zdbfs_fuse_error(req, EIO, parent);
// saving new parent if it's not the same
if(zdbfs_inode_store_metadata(req, new, newparent) != newparent)
return zdbfs_fuse_error(req, EIO, newparent);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_flush(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {
(void) fi;
zdbfs_syscall("flush", "ino: %lu", ino);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {
(void) fi;
inocache_t *inocache;
zdbfs_syscall("release", "ino: %lu", ino);
if(!(inocache = zdbfs_cache_get(req, ino))) {
zdbfs_debug("[+] release: entry not found in cache, nothing to do\n");
fuse_reply_err(req, 0);
return;
}
// release
if(zdbfs_cache_release(req, inocache) == 0)
return zdbfs_fuse_error(req, zdb_errno, ino);
// zdbfs_inode_dump(inocache->inode);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_fsync(fuse_req_t req, fuse_ino_t ino, int datasync, struct fuse_file_info *fi) {
(void) fi;
(void) datasync;
zdbfs_syscall("fsync", "ino: %lu", ino);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup) {
zdbfs_syscall("forget", "ino: %lu, nlookup: %lu", ino, nlookup);
fuse_reply_none(req);
}
static void zdbfs_fuse_opendir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {
(void) fi;
zdbfs_syscall("opendir", "ino: %lu", ino);
fuse_reply_open(req, fi);
}
static void zdbfs_fuse_releasedir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {
(void) fi;
zdbfs_syscall("releasedir", "ino: %lu", ino);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync, struct fuse_file_info *fi) {
(void) fi;
(void) datasync;
zdbfs_syscall("fsyncdir", "ino: %lu", ino);
fuse_reply_err(req, 0);
}
static void zdbfs_fuse_statfs(fuse_req_t req, fuse_ino_t ino) {
zdbfs_t *fs = fuse_req_userdata(req);
zdb_nsinfo_t *metadata;
zdb_nsinfo_t *data;
(void) ino;
zdbfs_syscall("statfs", "ino: %lu", ino);
zdbfs_macro_stats_incr(fs, syscall_statsfs);
if(!(metadata = zdb_nsinfo(fs->metactx, fs->opts->meta_ns)))
return zdbfs_fuse_error(req, EIO, ino);
if(!(data = zdb_nsinfo(fs->datactx, fs->opts->data_ns)))
return zdbfs_fuse_error(req, EIO, ino);
// hardcode 10G for debug
uint64_t sizefs = 10ull * 1024 * 1024 * 1024;
size_t fragment = 1024; // optional, could be 1 and no division
// maximum inodes is uint64_t maximun value
// (maximum keys available on namespace), which is quite high
// we report 1 TB which is already a lot, but this limit is not
// a real limit
// available inodes is total inodes without
// current amount of entries
// FIXME: should be substracted by next entries
struct statvfs vfs = {
.f_bsize = ZDBFS_BLOCK_SIZE,
.f_frsize = fragment,
.f_blocks = sizefs / fragment,
.f_bfree = (sizefs - data->datasize) / fragment,
.f_bavail = (sizefs - data->datasize) / fragment,
.f_files = 0xffffffffff,
.f_ffree = 0xffffffffff - metadata->entries,
.f_favail = 0xffffffffff - metadata->entries,
.f_fsid = 1,
.f_flag = 0,
.f_namemax = 255,
};
free(metadata);
free(data);
fuse_reply_statfs(req, &vfs);
}
static void zdbfs_fuse_ioctl(fuse_req_t req, fuse_ino_t ino, int _cmd, void *arg, struct fuse_file_info *fi, unsigned flags, const void *in, size_t insz, size_t outsz) {
unsigned int cmd = (unsigned int) _cmd;
zdbfs_t *fs = fuse_req_userdata(req);
(void) arg;
(void) in;
(void) insz;
(void) outsz;
(void) fi;
zdbfs_syscall("ioctl", "ino: %lu, cmd: %u", ino, cmd);
zdbfs_macro_stats_incr(fs, syscall_ioctl);
if(flags & FUSE_IOCTL_COMPAT)
return zdbfs_fuse_error(req, ENOSYS, ino);
// checking which ioctl requested
if(cmd == ZDBFS_IOCTL_SNAPSHOT) {
zdbfs_debug("[+] ioctl: snapshot: requested\n");
size_t flushed = zdbfs_cache_clean(fs);
zdbfs_debug("[+] ioctl: snapshot: cache flushed: %lu entries\n", flushed);
uint64_t now = time(NULL);
fuse_reply_ioctl(req, 0, &now, sizeof(uint64_t));
return;
}
if(cmd == ZDBFS_IOCTL_STATISTICS) {
zdbfs_debug("[+] ioctl: statistics: requested\n");
if(zdbfs_cache_enabled(fs)) {
zdbfs_lowdebug("statistics: computing cache size [branches %d]", ZDBFS_INOROOT_BRANCHES);
fs->stats.cache_branches = ZDBFS_INOROOT_BRANCHES;
fs->stats.cache_entries = zdbfs_cache_stats_entries(fs);
fs->stats.cache_blocksize = zdbfs_cache_stats_blocksize(fs);
fs->stats.cache_blocks = zdbfs_cache_stats_blocks(fs);
fs->stats.cache_branches_allocated = zdbfs_cache_stats_branches_entries(fs);
}
fuse_reply_ioctl(req, 0, &fs->stats, sizeof(stats_t));
return;
}
// invalid ioctl
zdbfs_fuse_error(req, EINVAL, ino);
}
static void zdbfs_stats_dump(zdbfs_t *fs) {
stats_t *s = &fs->stats;
printf("[+] stats: fuse: requests: %lu\n", s->fuse_reqs);
}
// custom event loop made around libfuse
// this event loop mostly just introduce an async read of
// the fuse file descriptor with a custom timeout
//
// this enable the process to do background tasks when the filesystem
// is not under heavy load
int zdbfs_fuse_session_loop(struct fuse_session *se, zdbfs_t *fs, int timeout) {
int res = 0;
int ffd;
int evfd;
struct epoll_event event;
struct epoll_event *events = NULL;
size_t proceed = 0;
struct fuse_buf fbuf = {
.mem = NULL,
};
// initialize empty struct
memset(&event, 0, sizeof(struct epoll_event));
// fetch fuse file descriptor
ffd = fuse_session_fd(se);
// initialize epoll with fuse file descriptor
if((evfd = epoll_create1(0)) < 0)
zdbfs_sysfatal("fuse: loop: epoll_create1");
event.data.fd = ffd;
event.events = EPOLLIN;
// only watch for read event
if(epoll_ctl(evfd, EPOLL_CTL_ADD, ffd, &event) < 0)
zdbfs_sysfatal("fuse: loop: epoll_ctl");
if(!(events = calloc(ZDBFS_EPOLL_MAXEVENTS, sizeof event)))
zdbfs_sysfatal("fuse: loop: events: calloc");
//
// main fuse loop (single threaded)
//
while(!fuse_session_exited(se)) {
int n = epoll_wait(evfd, events, ZDBFS_EPOLL_MAXEVENTS, timeout);
// call background cache scrubbing it
// there is a timeout (filesystem not under pressure)
// or if we proceed for specific amount of requests
//
// if the filesystem is under pressure, there can be
// no timeout for a long time and cache can be filled up
// quickly, this force scrubbing to happen
if(n == 0 || proceed > 8192) {
// zdbfs_cache_stats(fs);
size_t flushed = zdbfs_cache_sync(fs);
if(flushed > 0) {
zdbfs_debug("[+] cache: flushed %lu inodes\n", flushed);
if(fs->logfd)
fflush(fs->logfd);
}
// reset request counter
proceed = 0;
continue;
}
// fuse session is terminated if signal
// handler was executed, this function won't be
// interrupted by signal
if(fuse_session_exited(se))
break;
res = fuse_session_receive_buf(se, &fbuf);
proceed += 1;
if(res == -EINTR)
continue;
if(res <= 0)
break;
fuse_session_process_buf(se, &fbuf);
fs->stats.fuse_reqs += 1;
}
free(fbuf.mem);
free(events);
if(res > 0)
res = 0;
fuse_session_reset(se);
return res;
}
static const struct fuse_lowlevel_ops zdbfs_fuse_oper = {
.init = zdbfs_fuse_init,
.lookup = zdbfs_fuse_lookup,
.getattr = zdbfs_fuse_getattr,
.setattr = zdbfs_fuse_setattr,
.readdir = zdbfs_fuse_readdir,
.open = zdbfs_fuse_open,
.read = zdbfs_fuse_read,
.write = zdbfs_fuse_write,
.mkdir = zdbfs_fuse_mkdir,
.create = zdbfs_fuse_create,
.unlink = zdbfs_fuse_unlink,
.rmdir = zdbfs_fuse_rmdir,
.rename = zdbfs_fuse_rename,
.flush = zdbfs_fuse_flush,
.link = zdbfs_fuse_link,
.symlink = zdbfs_fuse_symlink,
.readlink = zdbfs_fuse_readlink,
.release = zdbfs_fuse_release,
.fsync = zdbfs_fuse_fsync,
.forget = zdbfs_fuse_forget,
.opendir = zdbfs_fuse_opendir,
.releasedir = zdbfs_fuse_releasedir,
.fsyncdir = zdbfs_fuse_fsyncdir,
.statfs = zdbfs_fuse_statfs,
.ioctl = zdbfs_fuse_ioctl,
};
int main(int argc, char *argv[]) {
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_session *se;
struct fuse_cmdline_opts fopts;
zdbfs_t zdbfs;
zdbfs_info("initializing zdbfs v%s", ZDBFS_VERSION);
// catch segmentation fault for backtrace
zdbfs_system_signal(SIGSEGV, zdbfs_system_sighandler);
if(zdbfs_init_args(&zdbfs, &args, &fopts) != 0)
return 1;
if(zdbfs_init_runtime(&zdbfs) != 0)
return 1;
if(zdbfs_zdb_connect(&zdbfs) != 0)
return 1;
zdbfs_inode_init(&zdbfs);
//
// fuse initialization
//
zdbfs_debug("[+] fuse: initializing session\n");
if(!(se = fuse_session_new(&args, &zdbfs_fuse_oper, sizeof(zdbfs_fuse_oper), &zdbfs)))
return 1;
zdbfs_debug("[+] fuse: initializing signals\n");
if(fuse_set_signal_handlers(se) != 0)
return 1;
zdbfs_debug("[+] fuse: mounting session\n");
if(fuse_session_mount(se, fopts.mountpoint) != 0)
return 1;
//
// processing events
//
zdbfs_success("fuse: ready, waiting events: %s", fopts.mountpoint);
if(zdbfs.background) {
zdbfs_debug("[+] fuse: forking, going to background\n");
fuse_daemonize(0);
}
int ret = zdbfs_fuse_session_loop(se, &zdbfs, 1000);
// (void) config;
//
// cleaning up
//
printf("\n[+] fuse: stopping filesystem\n");
printf("[+] cache: forcing cache flush\n");
size_t flushed = zdbfs_cache_clean(&zdbfs);
printf("[+] cache: flushed, %lu entries written\n", flushed);
zdbfs_stats_dump(&zdbfs);
zdbfs_cache_stats(&zdbfs);
zdbfs_debug("[+] fuse: cleaning environment\n");
fuse_session_unmount(se);
fuse_remove_signal_handlers(se);
fuse_session_destroy(se);
// flag filesystem not in use anymore
zdbfs_inode_init_release(&zdbfs);
// disconnect redis
zdbfs_zdb_free(&zdbfs);
// free blocks and inodes cache
zdbfs_init_free(&zdbfs, &fopts);
fuse_opt_free_args(&args);
return ret;
}
|
maxux/zdbfs
|
src/init.h
|
#ifndef ZDBFS_INIT_H
#define ZDBFS_INIT_H
int zdbfs_init_args(zdbfs_t *fs, struct fuse_args *args, struct fuse_cmdline_opts *fopts);
int zdbfs_init_runtime(zdbfs_t *fs);
int zdbfs_init_free(zdbfs_t *fs, struct fuse_cmdline_opts *fopts);
#endif
|
maxux/zdbfs
|
src/system.c
|
<gh_stars>1-10
#define FUSE_USE_VERSION 34
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <fuse_lowlevel.h>
#include <hiredis/hiredis.h>
#include <signal.h>
#include <string.h>
#include <ctype.h>
#include <stddef.h>
#include "zdbfs.h"
#define UNW_LOCAL_ONLY
#include <libunwind.h>
//
// error handling/printing
//
void warns(char *help, char *value) {
fprintf(stderr, "[-] %s: %s\n", help, value);
}
void dies(char *help, char *value) {
warns(help, value);
exit(EXIT_FAILURE);
}
//
// debug purpose
//
void zdbfs_system_fulldump(void *_data, size_t len) {
uint8_t *data = _data;
unsigned int i, j;
printf("[*] data fulldump [%p -> %p] (%lu bytes)\n", data, data + len, len);
printf("[*] 0x0000: ");
for(i = 0; i < len; ) {
printf("%02x ", data[i++]);
if(i % 16 == 0) {
printf("|");
for(j = i - 16; j < i; j++)
printf("%c", ((isprint(data[j]) ? data[j] : '.')));
printf("|\n[*] 0x%04x: ", i);
}
}
if(i % 16) {
printf("%-*s |", 5 * (16 - (i % 16)), " ");
for(j = i - (i % 16); j < len; j++)
printf("%c", ((isprint(data[j]) ? data[j] : '.')));
printf("%-*s|\n", 16 - ((int) len % 16), " ");
}
printf("\n");
}
void zdbfs_system_backtrace() {
unw_cursor_t cursor;
unw_context_t context;
// grab the machine context and initialize the cursor
if(unw_getcontext(&context) < 0)
dies("backtrce", "cannot get local machine state");
if(unw_init_local2(&cursor, &context, UNW_INIT_SIGNAL_FRAME) < 0)
dies("backtrace", "cannot initialize cursor for local unwinding");
// currently the IP is within backtrace() itself so this loop
// deliberately skips the first frame.
while(unw_step(&cursor) > 0) {
unw_word_t offset, pc;
char sym[4096];
if(unw_get_reg(&cursor, UNW_REG_IP, &pc))
dies("backtrace", "cannot read program counter");
printf("0x%lx: ", pc);
if(unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
printf("(%s+0x%lx)\n", sym, offset);
} else {
printf("[no symbol name found]\n");
}
}
}
int zdbfs_system_signal(int signal, void (*function)(int)) {
struct sigaction sig;
int ret;
sigemptyset(&sig.sa_mask);
sig.sa_handler = function;
sig.sa_flags = 0;
if((ret = sigaction(signal, &sig, NULL)) == -1)
zdbfs_sysfatal("sigaction");
return ret;
}
void zdbfs_system_sighandler(int signal) {
switch(signal) {
case SIGSEGV:
fprintf(stderr, "[-] fatal: segmentation fault\n");
zdbfs_system_backtrace();
break;
}
// forward original error code
exit(128 + signal);
}
|
maxux/zdbfs
|
src/system.h
|
<gh_stars>1-10
#ifndef ZDBFS_SYSTEM_H
#define ZDBFS_SYSTEM_H
void zdbfs_system_fulldump(void *_data, size_t len);
void zdbfs_system_backtrace();
void zdbfs_system_sighandler(int signal);
int zdbfs_system_signal(int signal, void (*function)(int));
void warns(char *help, char *value);
void dies(char *help, char *value);
#endif
|
maxux/zdbfs
|
src/init.c
|
#define FUSE_USE_VERSION 34
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fuse_lowlevel.h>
#include <stddef.h>
#include <hiredis/hiredis.h>
#include <errno.h>
#include "zdbfs.h"
#include "init.h"
#include "system.h"
//
// argument options
//
#define zdb_opt_field(f) offsetof(zdbfs_options, f)
static struct fuse_opt zdbfs_opts[] = {
{"mh=%s", zdb_opt_field(meta_host), 0},
{"mp=%d", zdb_opt_field(meta_port), 0},
{"mn=%s", zdb_opt_field(meta_ns), 0},
{"ms=%s", zdb_opt_field(meta_pass), 0},
{"dh=%s", zdb_opt_field(data_host), 0},
{"dp=%d", zdb_opt_field(data_port), 0},
{"dn=%s", zdb_opt_field(data_ns), 0},
{"ds=%s", zdb_opt_field(data_pass), 0},
{"th=%s", zdb_opt_field(temp_host), 0},
{"tp=%d", zdb_opt_field(temp_port), 0},
{"tn=%s", zdb_opt_field(temp_ns), 0},
{"ts=%s", zdb_opt_field(temp_pass), 0},
{"nocache", zdb_opt_field(nocache), 0},
{"autons", zdb_opt_field(autons), 0},
{"background", zdb_opt_field(background), 0},
{"logfile=%s", zdb_opt_field(logfile), 0},
{"cachesize=%d", zdb_opt_field(cachesize), 0},
FUSE_OPT_END
};
int zdbfs_init_args(zdbfs_t *fs, struct fuse_args *args, struct fuse_cmdline_opts *fopts) {
// setting default values
memset(fs, 0, sizeof(zdbfs_t));
if(!(fs->opts = calloc(sizeof(zdbfs_options), 1)))
zdbfs_sysfatal("init: opts: calloc");
fs->opts->nocache = -1;
fs->opts->background = -1;
fs->opts->autons = -1;
fs->opts->cachesize = ZDBFS_BLOCKS_CACHE_LIMIT;
fs->opts->meta_host = strdup("localhost");
fs->opts->meta_port = 9900;
fs->opts->meta_ns = strdup("zdbfs-meta");
fs->opts->data_host = strdup("localhost");
fs->opts->data_port = 9900;
fs->opts->data_ns = strdup("zdbfs-data");
fs->opts->temp_host = strdup("localhost");
fs->opts->temp_port = 9900;
fs->opts->temp_ns = strdup("zdbfs-temp");
fs->opts->temp_pass = strdup("<PASSWORD>");
// parsing fuse options
if(fuse_parse_cmdline(args, fopts) != 0)
return 1;
if(fopts->show_help) {
printf("usage: zdbfs [options] <mountpoint>\n\n");
fuse_cmdline_help();
fuse_lowlevel_help();
return 1;
} else if(fopts->show_version) {
printf("FUSE library version %s\n", fuse_pkgversion());
fuse_lowlevel_version();
return 1;
}
if(fopts->mountpoint == NULL) {
printf("usage: zdbfs [options] <mountpoint>\n");
printf(" zdbfs --help\n");
return 1;
}
// parsing zdbfs options
if(fuse_opt_parse(args, fs->opts, zdbfs_opts, NULL) == -1)
return 1;
return 0;
}
int zdbfs_init_runtime(zdbfs_t *fs) {
if(fs->opts->temp_pass == NULL && strlen(fs->opts->temp_pass) == 0)
dies("zdb: temporary namespace", "password cannot be empty");
// enable cache by default
fs->caching = (fs->opts->nocache == 0) ? 0 : 1;
fs->background = (fs->opts->background == 0) ? 1 : 0;
fs->autons = (fs->opts->autons == 0) ? 1 : 0;
fs->logfile = fs->opts->logfile;
fs->cachesize = fs->opts->cachesize;
zdbfs_verbose("[+] blocks cache size: %lu KB\n", (fs->cachesize * ZDBFS_BLOCK_SIZE) / 1024);
// initialize cache
if(!(fs->tmpblock = malloc(ZDBFS_BLOCK_SIZE)))
zdbfs_sysfatal("cache: malloc: block");
// initialize cache root branches
if(!(fs->inoroot = (inoroot_t *) calloc(sizeof(inoroot_t), 1)))
zdbfs_sysfatal("init: inoroot: calloc");
// set amount of branches defined
fs->inoroot->length = ZDBFS_INOROOT_BRANCHES;
// pre-allocate empty branches
if(!(fs->inoroot->branches = (inobranch_t *) calloc(sizeof(inobranch_t), fs->inoroot->length)))
zdbfs_sysfatal("init: inobranches: malloc");
// check cache status
if(fs->caching == 0)
zdbfs_warning("warning: cache disabled [%d]", fs->caching);
if(fs->logfile) {
zdbfs_debug("[+] logfile enabled: %s\n", fs->logfile);
if(!(fs->logfd = fopen(fs->logfile, "a")))
zdbfs_sysfatal("could not open logfile");
}
// set stats schema version
fs->stats.version = ZDBFS_STATS_VERSION;
return 0;
}
int zdbfs_init_free(zdbfs_t *fs, struct fuse_cmdline_opts *fopts) {
free(fopts->mountpoint);
free(fs->tmpblock);
for(size_t i = 0; i < fs->inoroot->length; i++)
free(fs->inoroot->branches[i].inocache);
free(fs->inoroot->branches);
free(fs->inoroot);
free(fs->logfile);
if(fs->logfd)
fclose(fs->logfd);
free(fs->opts->meta_host);
free(fs->opts->meta_ns);
free(fs->opts->meta_pass);
free(fs->opts->data_host);
free(fs->opts->data_ns);
free(fs->opts->data_pass);
free(fs->opts->temp_host);
free(fs->opts->temp_ns);
free(fs->opts->temp_pass);
free(fs->opts);
return 0;
}
|
maxux/zdbfs
|
src/inode.h
|
#ifndef ZDBFS_INODE_H
#define ZDBFS_INODE_H
int zdbfs_inode_init(zdbfs_t *fs);
size_t zdbfs_inode_dirlist_id(const char *name);
void zdbfs_inode_dump(zdb_inode_t *inode);
size_t zdbfs_offset_to_block(off_t off);
size_t zdbfs_inode_dir_size(zdb_dir_t *dir);
size_t zdbfs_inode_file_size(zdb_inode_t *inode);
zdb_dir_t *zdbfs_dir_new();
zdb_inode_t *zdbfs_inode_deserialize_dir(zdb_t *backend, zdb_inode_t *inode, uint8_t *buffer, size_t length);
zdb_inode_t *zdbfs_inode_deserialize_file(zdb_inode_t *inode, uint8_t *buffer, size_t length);
zdb_inode_t *zdbfs_inode_deserialize(zdb_t *backend, uint8_t *buffer, size_t length);
buffer_t zdbfs_inode_serialize_file(zdb_inode_t *inode);
buffer_t zdbfs_inode_serialize_dir(zdb_t *backend, zdb_inode_t *inode);
size_t zdbfs_direntry_size(zdb_direntry_t *entry);
zdb_direntry_t *zdbfs_direntry_new(uint64_t ino, const char *name);
zdb_dir_t *zdbfs_dir_append(zdb_dir_t *dir, zdb_direntry_t *entry);
buffer_t zdbfs_inode_serialize(zdb_t *backend, zdb_inode_t *inode);
void zdbfs_inode_free(zdb_inode_t *inode);
zdb_dir_t *zdbfs_inode_dir_get(zdb_inode_t *inode, const char *name);
zdb_dir_root_t *zdbfs_inode_dir_root_get(zdb_inode_t *inode);
zdb_dir_root_t *zdbfs_inode_dir_root_set(zdb_inode_t *inode, zdb_dir_root_t *root);
zdb_dir_t *zdbfs_inode_dir_append(zdb_inode_t *inode, uint64_t ino, const char *name);
void zdbfs_inode_block_set(zdb_inode_t *inode, size_t block, uint32_t blockid);
uint32_t zdbfs_inode_block_get(zdb_inode_t *inode, size_t block);
zdb_reply_t *zdbfs_inode_block_fetch(fuse_req_t req, zdb_inode_t *file, uint64_t ino, uint32_t block);
uint32_t zdbfs_inode_block_store(fuse_req_t req, zdb_inode_t *inode, uint64_t ino, uint32_t blockid, const char *buffer, size_t buflen);
zdb_blocks_t *zdbfs_inode_blocks_get(zdb_inode_t *inode);
int zdbfs_inode_blocks_remove(fuse_req_t req, zdb_inode_t *inode);
int zdbfs_inode_remove_entry(zdb_inode_t *inode, const char *name);
int zdbfs_inode_unlink(fuse_req_t req, zdb_inode_t *file, uint64_t ino);
zdb_direntry_t *zdbfs_inode_lookup_direntry(zdb_inode_t *inode, const char *name);
void zdbfs_inode_to_stat(struct stat *st, zdb_inode_t *inode, uint64_t ino);
void zdbfs_inode_to_fuse_param(struct fuse_entry_param *param, zdb_inode_t *inode, uint64_t ino);
zdb_inode_t *zdbfs_inode_new_file(fuse_req_t req, uint32_t mode);
zdb_inode_t *zdbfs_inode_new_symlink(fuse_req_t req, const char *link);
zdb_inode_t *zdbfs_inode_new_dir(uint64_t parent, uint32_t mode);
const char *zdbfs_inode_symlink_get(zdb_inode_t *inode);
zdb_inode_t *zdbfs_inode_fetch(fuse_req_t req, fuse_ino_t ino);
zdb_inode_t *zdbfs_directory_fetch(fuse_req_t req, fuse_ino_t ino);
uint64_t zdbfs_inode_store_backend(zdb_t *backend, zdb_inode_t *inode, uint64_t ino);
uint64_t zdbfs_inode_store_metadata(fuse_req_t req, zdb_inode_t *inode, uint64_t ino);
uint64_t zdbfs_inode_store_data(fuse_req_t req, zdb_inode_t *inode, uint64_t ino);
int zdbfs_inode_init_release(zdbfs_t *fs);
char *zdbfs_inode_resolv(fuse_req_t req, fuse_ino_t target, const char *name);
#endif
|
maxux/zdbfs
|
src/cache.h
|
#ifndef ZDBFS_CACHE_H
#define ZDBFS_CACHE_H
int zdbfs_cache_enabled(zdbfs_t *fs);
double zdbfs_cache_time_now();
inocache_t *zdbfs_cache_get(fuse_req_t req, uint64_t ino);
inocache_t *zdbfs_cache_add(fuse_req_t req, uint64_t ino, zdb_inode_t *inode);
int zdbfs_cache_release(fuse_req_t req, inocache_t *inocache);
void zdbfs_cache_drop(fuse_req_t req, inocache_t *cache);
// check for cache content and apply old changes
size_t zdbfs_cache_sync(zdbfs_t *fs);
size_t zdbfs_cache_clean(zdbfs_t *fs);
// dump cache statistics
void zdbfs_cache_stats(zdbfs_t *fs);
size_t zdbfs_cache_stats_entries(zdbfs_t *fs);
size_t zdbfs_cache_stats_blocksize(zdbfs_t *fs);
size_t zdbfs_cache_stats_blocks(zdbfs_t *fs);
size_t zdbfs_cache_stats_branches_entries(zdbfs_t *fs);
// blocks
blockcache_t *zdbfs_cache_block_get(fuse_req_t req, inocache_t *cache, uint32_t blockidx);
blockcache_t *zdbfs_cache_block_add(fuse_req_t req, inocache_t *cache, uint32_t blockidx);
blockcache_t *zdbfs_cache_block_update(blockcache_t *cache, const char *data, size_t blocksize);
void zdbfs_cache_block_free(inocache_t *cache);
#endif
|
AnnikaLau/cq-formation-openacc
|
cpp/step3.kernels/matrix_functions.h
|
<reponame>AnnikaLau/cq-formation-openacc<gh_stars>1-10
/*
* Copyright 2016 NVIDIA Corporation
*
* 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.
*/
#pragma once
#include "vector.h"
#include "matrix.h"
void matvec(const matrix& A, const vector& x, const vector &y) {
unsigned int num_rows=A.num_rows;
unsigned int *row_offsets=A.row_offsets;
unsigned int *cols=A.cols;
double *__restrict Acoefs=A.coefs;
double *__restrict xcoefs=x.coefs;
double *__restrict ycoefs=y.coefs;
#pragma acc kernels present(row_offsets,cols,Acoefs,xcoefs,ycoefs)
{
#pragma acc loop device_type(nvidia) gang worker(32)
for(int i=0;i<num_rows;i++) {
double sum=0;
int row_start=row_offsets[i];
int row_end=row_offsets[i+1];
#pragma acc loop device_type(nvidia) vector(32)
for(int j=row_start;j<row_end;j++) {
unsigned int Acol=cols[j];
double Acoef=Acoefs[j];
double xcoef=xcoefs[Acol];
sum+=Acoef*xcoef;
}
ycoefs[i]=sum;
}
}
}
|
followthwhiterabbit/GLCD_slideshow_project
|
GLCD.c
|
/////////////////////////////////////////////////////////////////////////
//// GLCD.C ////
//// ////
//// This file contains drivers for using a Hantronix HDM64GS12 with ////
//// an LED backlight. The HDM64GS12 is 128 pixles across and 64 ////
//// pixels down. The driver treats the upper left pixel as (0,0). ////
//// ////
//// LCD Pin connections: ////
//// (These can be changed as needed in the following defines). ////
//// * 1: VSS is connected to GND ////
//// * 2: VDD is connected to +5V ////
//// * 3: V0 - LCD operating voltage is connected from a 20k Ohm POT////
//// * 4: D/I - Data or Instruction is connected to B2 ////
//// * 5: R/W - Read or Write is connected to B4 ////
//// * 6: Enable is connected to B5 ////
//// *7-14: Data Bus 0 to 7 is connected to port d ////
//// *15: Chip Select 1 is connected to B0 ////
//// *16: Chip Select 2 is connected to B1 ////
//// *17: Reset is connected to C0 ////
//// *18: Negative voltage is also connected to the 20k Ohm POT ////
//// *19: Positive voltage for LED backlight is connected to +5V ////
//// *20: Negavtive voltage for LED backlight is connected to GND ////
//// ////
//// glcd_init(mode) ////
//// * Must be called before any other function. ////
//// - mode can be ON or OFF to turn the LCD on or off ////
//// ////
//// glcd_pixel(x,y,color) ////
//// * Sets the pixel to the given color. ////
//// - color can be ON or OFF ////
//// ////
//// glcd_line(x1,y1,x2,y2,color) ////
//// * Draws a line from the first point to the second point ////
//// with the given color. ////
//// - color can be ON or OFF ////
//// ////
//// glcd_rect(x1,y1,x2,y2,fill,color) ////
//// * Draws a rectangle with upper left point (x1,y1) and lower ////
//// right point (x2,y2). ////
//// - fill can be YES or NO ////
//// - color can be ON or OFF ////
//// ////
//// glcd_bar(x1,y1,x2,y2,width,color) ////
//// * Draws a bar (wide line) from the first point to the ////
//// second point. ////
//// - width is the number of pixels wide ////
//// - color is ON or OFF ////
//// ////
//// glcd_circle(x,y,radius,fill,color) ////
//// * Draws a circle with center at (x,y) ////
//// - fill can be YES or NO ////
//// - color can be ON or OFF ////
//// ////
//// glcd_text57(x,y,textptr,size,color) ////
//// * Write the null terminated text pointed to by textptr with ////
//// the upper left coordinate of the first character at (x,y).////
//// Characters are 5 pixels wide and 7 pixels tall. ////
//// - size is an integer that scales the size of the text ////
//// - color is ON or OFF ////
//// * Note - The given text is character wrapped. If this ////
//// function is used on a different size display, then change ////
//// the GLCD_WIDTH define appropriately. ////
//// ////
//// glcd_fillScreen(color) ////
//// * Fills the entire LCD with the given color. ////
//// - color can be ON or OFF ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
/////////////////////////////////////////////////////////////////////////
#ifndef GLCD_C
#define GLCD_C
#ifndef GLCD_WIDTH
#define GLCD_WIDTH 128 // Used for text wrapping by glcd_text57 function
#endif
#define ON 1
#define OFF 0
#define YES 1
#define NO 0
#ifndef GLCD_CS1
#define GLCD_CS1 PIN_B0 // Chip Selection 1
#endif
#ifndef GLCD_CS2
#define GLCD_CS2 PIN_B1 // Chip Selection 2
#endif
#ifndef GLCD_DI
#define GLCD_DI PIN_B2 // Data or Instruction input
#endif
#ifndef GLCD_RW
#define GLCD_RW PIN_B4 // Read/Write
#endif
#ifndef GLCD_E
#define GLCD_E PIN_B5 // Enable
#endif
#ifndef GLCD_RST
#define GLCD_RST PIN_C0 // Reset
#endif
BYTE glcd_readByte(BYTE chip);
void glcd_writeByte(BYTE chip, BYTE data);
void glcd_fillScreen(int1 color);
const BYTE TEXT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
0x00, 0x00, 0x5F, 0x00, 0x00, // !
0x00, 0x03, 0x00, 0x03, 0x00, // "
0x14, 0x3E, 0x14, 0x3E, 0x14, // #
0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
0x43, 0x33, 0x08, 0x66, 0x61, // %
0x36, 0x49, 0x55, 0x22, 0x50, // &
0x00, 0x05, 0x03, 0x00, 0x00, // '
0x00, 0x1C, 0x22, 0x41, 0x00, // (
0x00, 0x41, 0x22, 0x1C, 0x00, // )
0x14, 0x08, 0x3E, 0x08, 0x14, // *
0x08, 0x08, 0x3E, 0x08, 0x08, // +
0x00, 0x50, 0x30, 0x00, 0x00, // ,
0x08, 0x08, 0x08, 0x08, 0x08, // -
0x00, 0x60, 0x60, 0x00, 0x00, // .
0x20, 0x10, 0x08, 0x04, 0x02, // /
0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
0x04, 0x02, 0x7F, 0x00, 0x00, // 1
0x42, 0x61, 0x51, 0x49, 0x46, // 2
0x22, 0x41, 0x49, 0x49, 0x36, // 3
0x18, 0x14, 0x12, 0x7F, 0x10, // 4
0x27, 0x45, 0x45, 0x45, 0x39, // 5
0x3E, 0x49, 0x49, 0x49, 0x32, // 6
0x01, 0x01, 0x71, 0x09, 0x07, // 7
0x36, 0x49, 0x49, 0x49, 0x36, // 8
0x26, 0x49, 0x49, 0x49, 0x3E, // 9
0x00, 0x36, 0x36, 0x00, 0x00, // :
0x00, 0x56, 0x36, 0x00, 0x00, // ;
0x08, 0x14, 0x22, 0x41, 0x00, // <
0x14, 0x14, 0x14, 0x14, 0x14, // =
0x00, 0x41, 0x22, 0x14, 0x08, // >
0x02, 0x01, 0x51, 0x09, 0x06, // ?
0x3E, 0x41, 0x59, 0x55, 0x5E, // @
0x7E, 0x09, 0x09, 0x09, 0x7E, // A
0x7F, 0x49, 0x49, 0x49, 0x36, // B
0x3E, 0x41, 0x41, 0x41, 0x22, // C
0x7F, 0x41, 0x41, 0x41, 0x3E, // D
0x7F, 0x49, 0x49, 0x49, 0x41, // E
0x7F, 0x09, 0x09, 0x09, 0x01, // F
0x3E, 0x41, 0x41, 0x49, 0x3A, // G
0x7F, 0x08, 0x08, 0x08, 0x7F, // H
0x00, 0x41, 0x7F, 0x41, 0x00, // I
0x30, 0x40, 0x40, 0x40, 0x3F, // J
0x7F, 0x08, 0x14, 0x22, 0x41, // K
0x7F, 0x40, 0x40, 0x40, 0x40, // L
0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
0x7F, 0x02, 0x04, 0x08, 0x7F, // N
0x3E, 0x41, 0x41, 0x41, 0x3E, // O
0x7F, 0x09, 0x09, 0x09, 0x06, // P
0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
0x7F, 0x09, 0x09, 0x09, 0x76};// R
const BYTE TEXT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S
0x01, 0x01, 0x7F, 0x01, 0x01, // T
0x3F, 0x40, 0x40, 0x40, 0x3F, // U
0x1F, 0x20, 0x40, 0x20, 0x1F, // V
0x7F, 0x20, 0x10, 0x20, 0x7F, // W
0x41, 0x22, 0x1C, 0x22, 0x41, // X
0x07, 0x08, 0x70, 0x08, 0x07, // Y
0x61, 0x51, 0x49, 0x45, 0x43, // Z
0x00, 0x7F, 0x41, 0x00, 0x00, // [
0x02, 0x04, 0x08, 0x10, 0x20, // \
0x00, 0x00, 0x41, 0x7F, 0x00, // ]
0x04, 0x02, 0x01, 0x02, 0x04, // ^
0x40, 0x40, 0x40, 0x40, 0x40, // _
0x00, 0x01, 0x02, 0x04, 0x00, // `
0x20, 0x54, 0x54, 0x54, 0x78, // a
0x7F, 0x44, 0x44, 0x44, 0x38, // b
0x38, 0x44, 0x44, 0x44, 0x44, // c
0x38, 0x44, 0x44, 0x44, 0x7F, // d
0x38, 0x54, 0x54, 0x54, 0x18, // e
0x04, 0x04, 0x7E, 0x05, 0x05, // f
0x08, 0x54, 0x54, 0x54, 0x3C, // g
0x7F, 0x08, 0x04, 0x04, 0x78, // h
0x00, 0x44, 0x7D, 0x40, 0x00, // i
0x20, 0x40, 0x44, 0x3D, 0x00, // j
0x7F, 0x10, 0x28, 0x44, 0x00, // k
0x00, 0x41, 0x7F, 0x40, 0x00, // l
0x7C, 0x04, 0x78, 0x04, 0x78, // m
0x7C, 0x08, 0x04, 0x04, 0x78, // n
0x38, 0x44, 0x44, 0x44, 0x38, // o
0x7C, 0x14, 0x14, 0x14, 0x08, // p
0x08, 0x14, 0x14, 0x14, 0x7C, // q
0x00, 0x7C, 0x08, 0x04, 0x04, // r
0x48, 0x54, 0x54, 0x54, 0x20, // s
0x04, 0x04, 0x3F, 0x44, 0x44, // t
0x3C, 0x40, 0x40, 0x20, 0x7C, // u
0x1C, 0x20, 0x40, 0x20, 0x1C, // v
0x3C, 0x40, 0x30, 0x40, 0x3C, // w
0x44, 0x28, 0x10, 0x28, 0x44, // x
0x0C, 0x50, 0x50, 0x50, 0x3C, // y
0x44, 0x64, 0x54, 0x4C, 0x44, // z
0x00, 0x08, 0x36, 0x41, 0x41, // {
0x00, 0x00, 0x7F, 0x00, 0x00, // |
0x41, 0x41, 0x36, 0x08, 0x00, // }
0x02, 0x01, 0x02, 0x04, 0x02};// ~
// Purpose: Initialize a graphic LCD. This must be called before any
// other glcd function is used.
// Inputs: The initialization mode
// OFF - Turns the LCD off
// ON - Turns the LCD on
// Date: 5/28/2003
void glcd_init(int1 mode)
{
// Initialze some pins
output_high(GLCD_RST);
output_low(GLCD_E);
output_low(GLCD_CS1);
output_low(GLCD_CS2);
output_low(GLCD_DI); // Set for instruction
glcd_writeByte(GLCD_CS1, 0xC0); // Specify first RAM line at the top
glcd_writeByte(GLCD_CS2, 0xC0); // of the screen
glcd_writeByte(GLCD_CS1, 0x40); // Set the column address to 0
glcd_writeByte(GLCD_CS2, 0x40);
glcd_writeByte(GLCD_CS1, 0xB8); // Set the page address to 0
glcd_writeByte(GLCD_CS2, 0xB8);
if(mode == ON)
{
glcd_writeByte(GLCD_CS1, 0x3F); // Turn the display on
glcd_writeByte(GLCD_CS2, 0x3F);
}
else
{
glcd_writeByte(GLCD_CS1, 0x3E); // Turn the display off
glcd_writeByte(GLCD_CS2, 0x3E);
}
glcd_fillScreen(OFF); // Clear the display
}
// Purpose: Turn a pixel on a graphic LCD on or off
// Inputs: x - the x coordinate of the pixel
// y - the y coordinate of the pixel
// color - ON or OFF
// Output: 1 if coordinate out of range, 0 if in range
void glcd_pixel(int8 x, int8 y, int1 color)
{
BYTE data;
BYTE chip = GLCD_CS1; // Stores which chip to use on the LCD
if(x > 63) // Check for first or second display area
{
x -= 64;
chip = GLCD_CS2;
}
output_low(GLCD_DI); // Set for instruction
bit_clear(x,7); // Clear the MSB. Part of an instruction code
bit_set(x,6); // Set bit 6. Also part of an instruction code
glcd_writeByte(chip, x); // Set the horizontal address
glcd_writeByte(chip, (y/8 & 0b10111111) | 0b10111000); // Set the vertical page address
output_high(GLCD_DI); // Set for data
data = glcd_readByte(chip);
if(color == ON)
bit_set(data, y%8); // Turn the pixel on
else // or
bit_clear(data, y%8); // turn the pixel off
output_low(GLCD_DI); // Set for instruction
glcd_writeByte(chip, x); // Set the horizontal address
output_high(GLCD_DI); // Set for data
glcd_writeByte(chip, data); // Write the pixel data
}
// Purpose: Draw a line on a graphic LCD using Bresenham's
// line drawing algorithm
// Inputs: (x1, y1) - the start coordinate
// (x2, y2) - the end coordinate
// color - ON or OFF
// Dependencies: glcd_pixel()
void glcd_line(int8 x1, int8 y1, int8 x2, int8 y2, int1 color)
{
signed int x, y, addx, addy, dx, dy;
signed long P;
int i;
dx = abs((signed int)(x2 - x1));
dy = abs((signed int)(y2 - y1));
x = x1;
y = y1;
if(x1 > x2)
addx = -1;
else
addx = 1;
if(y1 > y2)
addy = -1;
else
addy = 1;
if(dx >= dy)
{
P = 2*dy - dx;
for(i=0; i<=dx; ++i)
{
glcd_pixel(x, y, color);
if(P < 0)
{
P += 2*dy;
x += addx;
}
else
{
P += 2*dy - 2*dx;
x += addx;
y += addy;
}
}
}
else
{
P = 2*dx - dy;
for(i=0; i<=dy; ++i)
{
glcd_pixel(x, y, color);
if(P < 0)
{
P += 2*dx;
y += addy;
}
else
{
P += 2*dx - 2*dy;
x += addx;
y += addy;
}
}
}
}
// Purpose: Draw a rectangle on a graphic LCD
// Inputs: (x1, y1) - the start coordinate
// (x2, y2) - the end coordinate
// fill - YES or NO
// color - ON or OFF
// Dependencies: glcd_pixel(), glcd_line()
void glcd_rect(int8 x1, int8 y1, int8 x2, int8 y2, int fill, int1 color)
{
if(fill)
{
int y, ymax; // Find the y min and max
if(y1 < y2)
{
y = y1;
ymax = y2;
}
else
{
y = y2;
ymax = y1;
}
for(; y<=ymax; ++y) // Draw lines to fill the rectangle
glcd_line(x1, y, x2, y, color);
}
else
{
glcd_line(x1, y1, x2, y1, color); // Draw the 4 sides
glcd_line(x1, y2, x2, y2, color);
glcd_line(x1, y1, x1, y2, color);
glcd_line(x2, y1, x2, y2, color);
}
}
// Purpose: Draw a bar (wide line) on a graphic LCD
// Inputs: (x1, y1) - the start coordinate
// (x2, y2) - the end coordinate
// width - The number of pixels wide
// color - ON or OFF
void glcd_bar(int x1, int y1, int x2, int y2, int width, int1 color)
{
signed int x, y, addx, addy, j;
signed long P, dx, dy, c1, c2;
int i;
dx = abs((signed int)(x2 - x1));
dy = abs((signed int)(y2 - y1));
x = x1;
y = y1;
c1 = -dx*x1 - dy*y1;
c2 = -dx*x2 - dy*y2;
if(x1 > x2)
{
addx = -1;
c1 = -dx*x2 - dy*y2;
c2 = -dx*x1 - dy*y1;
}
else
addx = 1;
if(y1 > y2)
{
addy = -1;
c1 = -dx*x2 - dy*y2;
c2 = -dx*x1 - dy*y1;
}
else
addy = 1;
if(dx >= dy)
{
P = 2*dy - dx;
for(i=0; i<=dx; ++i)
{
for(j=-(width/2); j<width/2+width%2; ++j)
{
if(dx*x+dy*(y+j)+c1 >= 0 && dx*x+dy*(y+j)+c2 <=0)
glcd_pixel(x, y+j, color);
}
if(P < 0)
{
P += 2*dy;
x += addx;
}
else
{
P += 2*dy - 2*dx;
x += addx;
y += addy;
}
}
}
else
{
P = 2*dx - dy;
for(i=0; i<=dy; ++i)
{
if(P < 0)
{
P += 2*dx;
y += addy;
}
else
{
P += 2*dx - 2*dy;
x += addx;
y += addy;
}
for(j=-(width/2); j<width/2+width%2; ++j)
{
if(dx*x+dy*(y+j)+c1 >= 0 && dx*x+dy*(y+j)+c2 <=0)
glcd_pixel(x+j, y, color);
}
}
}
}
// Purpose: Draw a circle on a graphic LCD
// Inputs: (x,y) - the center of the circle
// radius - the radius of the circle
// fill - YES or NO
// color - ON or OFF
void glcd_circle(int x, int y, int radius, int1 fill, int1 color)
{
signed int a, b, P;
a = 0;
b = radius;
P = 1 - radius;
do
{
if(fill)
{
glcd_line(x-a, y+b, x+a, y+b, color);
glcd_line(x-a, y-b, x+a, y-b, color);
glcd_line(x-b, y+a, x+b, y+a, color);
glcd_line(x-b, y-a, x+b, y-a, color);
}
else
{
glcd_pixel(a+x, b+y, color);
glcd_pixel(b+x, a+y, color);
glcd_pixel(x-a, b+y, color);
glcd_pixel(x-b, a+y, color);
glcd_pixel(b+x, y-a, color);
glcd_pixel(a+x, y-b, color);
glcd_pixel(x-a, y-b, color);
glcd_pixel(x-b, y-a, color);
}
if(P < 0)
P+= 3 + 2*a++;
else
P+= 5 + 2*(a++ - b--);
} while(a <= b);
}
// Purpose: Write text on a graphic LCD
// Inputs: (x,y) - The upper left coordinate of the first letter
// textptr - A pointer to an array of text to display
// size - The size of the text: 1 = 5x7, 2 = 10x14, ...
// color - ON or OFF
void glcd_text57(int x, int y, char* textptr, int size, int1 color)
{
int i, j, k, l, m; // Loop counters
BYTE pixelData[5]; // Stores character data
for(i=0; textptr[i] != '\0'; ++i, ++x) // Loop through the passed string
{
if(textptr[i] < 'S') // Checks if the letter is in the first text array
memcpy(pixelData, TEXT[textptr[i]-' '], 5);
else if(textptr[i] <= '~') // Check if the letter is in the second array
memcpy(pixelData, TEXT2[textptr[i]-'S'], 5);
else
memcpy(pixelData, TEXT[0], 5); // Default to space
if(x+5*size >= GLCD_WIDTH) // Performs character wrapping
{
x = 0; // Set x at far left position
y += 7*size + 1; // Set y at next position down
}
for(j=0; j<5; ++j, x+=size) // Loop through character byte data
{
for(k=0; k<7*size; ++k) // Loop through the vertical pixels
{
if(bit_test(pixelData[j], k)) // Check if the pixel should be set
{
for(l=0; l<size; ++l) // The next two loops change the
{ // character's size
for(m=0; m<size; ++m)
{
glcd_pixel(x+m, y+k*size+l, color); // Draws the pixel
}
}
}
}
}
}
}
// Purpose: Fill the LCD screen with the passed in color.
// Works much faster than drawing a rectangle to fill the screen.
// Inputs: ON - turn all the pixels on
// OFF - turn all the pixels off
// Dependencies: glcd_writeByte()
void glcd_fillScreen(int1 color)
{
int i, j;
// Loop through the vertical pages
for(i = 0; i < 8; ++i)
{
output_low(GLCD_DI); // Set for instruction
glcd_writeByte(GLCD_CS1, 0b01000000); // Set horizontal address to 0
glcd_writeByte(GLCD_CS2, 0b01000000);
glcd_writeByte(GLCD_CS1, i | 0b10111000); // Set page address
glcd_writeByte(GLCD_CS2, i | 0b10111000);
output_high(GLCD_DI); // Set for data
// Loop through the horizontal sections
for(j = 0; j < 64; ++j)
{
glcd_writeByte(GLCD_CS1, 0xFF*color); // Turn pixels on or off
glcd_writeByte(GLCD_CS2, 0xFF*color); // Turn pixels on or off
}
}
}
// Purpose: Write a byte of data to the specified chip
// Inputs: chipSelect - which chip to write the data to
// data - the byte of data to write
void glcd_writeByte(char chip, BYTE data)
{
if(chip == GLCD_CS1) // Choose which chip to write to
output_high(GLCD_CS1);
else
output_high(GLCD_CS2);
output_low(GLCD_RW); // Set for writing
output_d(data); // Put the data on the port
output_high(GLCD_E); // Pulse the enable pin
delay_us(2);
output_low(GLCD_E);
output_low(GLCD_CS1); // Reset the chip select lines
output_low(GLCD_CS2);
}
// Purpose: Reads a byte of data from the specified chip
// Ouputs: A byte of data read from the chip
BYTE glcd_readByte(BYTE chip)
{
BYTE data; // Stores the data read from the LCD
if(chip == GLCD_CS1) // Choose which chip to read from
output_high(GLCD_CS1);
else
output_high(GLCD_CS2);
input_d(); // Set port d to input
output_high(GLCD_RW); // Set for reading
output_high(GLCD_E); // Pulse the enable pin
delay_us(2);
output_low(GLCD_E);
delay_us(2);
output_high(GLCD_E); // Pulse the enable pin
delay_us(2);
data = input_d(); // Get the data from the display's output register
output_low(GLCD_E);
output_low(GLCD_CS1); // Reset the chip select lines
output_low(GLCD_CS2);
return data; // Return the read data
}
#endif
|
followthwhiterabbit/GLCD_slideshow_project
|
temp_proje.c
|
/*
Mechatronics Engineering Microprocessors Final Project
Slide Show Using GLCD
Author : <NAME>
ID : 140223014
Date: 29/12/2020
*/
#if defined(__PCM__)
#include <16F877.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#endif
// fast_io initializations
#use fast_io(A)
//#use fast_io(b)
#use fast_io(C)
//#use fast_io(d)
#use fast_io(E)
//after setting up the time, we start displaying by choosing start button
#define ayar_buton pin_e0
#define onay_buton pin_a1
//7 segment define statements
#define display_1 pin_e1
#define display_2 pin_e2
// GLCD define and include statements
#define GLCD_CS1 pin_b0 // chip select 1
#define GLCD_CS2 pin_b1 // chip select 2
#define GLCD_DI pin_b2 // Data or instruction input
#define GLCD_RW pin_b3 // Read and Write pin
#define GLCD_E pin_b4 // GLCD enable
#define GLCD_RST pin_b5 // GLCD reset
#include <GLCD.c>
//EEPROM define and include statements
#define EEPROM_SDA pin_b6
#define EEPROM_SCL pin_b7
#include <24512.c>
#define INTS_PER_SECOND 152 // (20000000/(4*128*256))
#define PICTURE_COUNT 4 // number of pictures to show up
int numbers[16] ={0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7C, 0x07, 0x7F, 0x6F, 0x77 , 0x7C, 0x39, 0x5E, 0x79, 0x71};
// numbers as hex codes for two digit seven segments
int16 resim, blinkcounter;
unsigned char mode, cmode, setm, sayi, dig[2];
char text1[22];
int1 blink, direct;
int8 seg;
int8 timeout, time[PICTURE_COUNT]; // A running seconds counter
int8 int_count; // Number of interrupts left before a second has elapsed
int1 on_down, on_down_onay; // on_down and on_down_onay are defined as booleans
/*
void sevenseg(void)
{
if (blink)
{
output_c( numbers[ dig[0] ] );
output_low(display_2);
Delay_ms(2);
output_high(display_2);
output_c( numbers [dig[1]] );
output_low(display_1);
Delay_ms(2);
output_high(display_1);
}
}
*/
#int_rtcc
void clock_isr()
{
//------------------------------------------
if (blinkcounter>5)
{
blinkcounter=0;
blink=!blink; // blink happens
}
else blinkcounter++;
//-------------------------------------------
output_high(display_1);
output_high(display_2);
if ((blink)||(direct))
{
if (seg==0)
{
seg=1;
output_low(display_1);
}
else
{
seg=0;
output_low(display_2);
}
output_c(numbers[dig[seg]]);
}
//--------------------------------------------
if(--int_count==0)
{ // per second.
if (timeout>0) timeout--;
int_count=INTS_PER_SECOND;
}
}
void Picture_load()
{
int16 i,j,x,y,t,start_adr;
unsigned char a;
x=127;
y=0;
t=0;
start_adr = 61 + (resim*1024)+1024;
for(i = 0 ; i < 1024 ; i++)
{
a = read_ext_eeprom(start_adr);
t=1;
for(j = 0; j < 8; j++)
{
glcd_pixel( x, y, ( (a & t)==0) );
if (x==0)
{
x=127;
y++;
}
else x--;
t=t*2;
}
start_adr--;
}
}
void main()
{
int j;
setup_psp(PSP_DISABLED);
setup_timer_1(T1_DISABLED); // timer1 disabled
setup_timer_2(T2_DISABLED,0,1); // timer 2 disabled
setup_CCP1(CCP_OFF);
setup_CCP2(CCP_OFF);
set_tris_a(0x03); // 0b0000 0011 ra1 and ra0 are inputs
set_tris_b(0xC0); //rb6 and rb7 are inputs
set_tris_c(0x00); //all c pins are output
set_tris_d(0x00); //all d pins are output
set_tris_e(0x01); //0b 0000 0001
output_a(0x00);
output_b(0x00);
output_d(0x00);
output_e(0x06); //0b 0000 0110
output_low(display_2);
output_low(display_1);
int_count=INTS_PER_SECOND;
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128|RTCC_8_BIT);
enable_interrupts(INT_RTCC);
enable_interrupts(GLOBAL);
setup_adc_ports(AN0); // ANO analog
setup_adc(ADC_CLOCK_INTERNAL);
set_adc_channel(0);
glcd_init(on);
//glcd_rect(10, 10, 20, 20, 1, 1);
init_ext_eeprom();
/*
for(j = 0; j < 8; j++)
{
a = read_ext_eeprom(j);
sprintf(text1,"%02X ",a);
glcd_text57(0, j*8, &text1[0], 1, 1);
}
*/
sprintf(text1,"<NAME>");
glcd_text57(0, 0, &text1[0], 1, 1);
sprintf(text1,"140223014");
glcd_text57(34,10,&text1[0], 1, 1);
sprintf(text1,"Seyit Kaan");
glcd_text57(32, 20, &text1[0], 1, 1);
sprintf(text1,"Karaalioglu");
glcd_text57(28, 30, &text1[0], 1, 1);
sprintf(text1, "click");
glcd_text57(40, 45, &text1[0], 1, 1);
sprintf(text1, "ayar buton");
glcd_text57(30, 55, &text1[0], 1, 1);
Delay_ms(1500);
//-----------------------------
// load values from internal eeprom
cmode = read_eeprom( 0 );
resim = read_eeprom( 1 );
for(j=0; j<PICTURE_COUNT; ++j)
{
time[j] = read_eeprom( 2+ j );
}
// defaults
time[0]= 9;
time[1]= 2;
time[2]= 11;
time[3]= 5;
cmode=2; //
resim=0; // we define resim variable for the logos
//-----------------------
mode = 1;
direct=true;
blinkcounter=0;
sayi=resim+1;
dig[0]=0;
dig[1]=0;
timeout=0;
on_down=false;
//setup_wdt(WDT_2304MS);
while(true)
{
if(input(onay_buton))
{
if (mode!=0)
{
if (!on_down_onay)
{
on_down_onay=true;
if (cmode<2) cmode++; else cmode=0;
glcd_rect(0, 0, 127, 15, 1, 1);
switch (cmode)
{
case 0: sprintf(text1,"1..n"); break;
case 1: sprintf(text1,"n..1"); break;
case 2: sprintf(text1,"1..n..1"); break;
}
glcd_text57(0, 0, &text1[0], 1, 0);
}
}
}
else on_down_onay=false;
if(input(ayar_buton) )
{
if (!on_down)
{
on_down=true;
iF(mode!=0)
{
mode = 0;
resim=0;
// Picture_load();
}
else
{
if (mode==0)
{
if (resim< (PICTURE_COUNT-1))
{
resim++;
}
else resim=0;
// Picture_load();
}
}
}
}
else on_down=false;
switch (mode)
{
case 0:
direct=false;
sayi = read_adc()/16;
if (sayi<16)
{
dig[0]=sayi;
time[resim]= sayi;
}
dig[1]=resim+1;
if(input(onay_buton))
{
for(j=0; j<PICTURE_COUNT; ++j)
{
write_eeprom( 2+ j,time[j] );
}
mode = 1;
}
/*
dig[0]=sayi;
if (sayi==15)
sayi=0; else sayi++;
*/
break;
case 1:
direct=true;
Picture_load();
timeout = time[resim];
mode=2;
dig[1]=resim;
dig[0]=timeout;
break;
//--------------------------------
case 2:
direct=true;
if (timeout==0)
{
//-------------------------------------------
if (cmode==0)
{
//0 to n;
if (resim==(PICTURE_COUNT-1))
{
resim=0;
}
else resim++;
}
else if (cmode==1)
{
//n to 0
if (resim==0)
{
resim=PICTURE_COUNT-1;
}
else resim--;
}
else
{
//0 to n to 0
if (setm==0)
{
if (resim==(PICTURE_COUNT-1))
{
resim=PICTURE_COUNT-2;
setm=1;
}
else resim++;
}
else
{
if (resim==0)
{
resim=1;
setm=0;
}
else resim--;
}
}
write_eeprom( 2, resim );
//-------------------------------------------
mode=1;
sayi = resim+1;
}
dig[1]=resim;
dig[0]=timeout;
break;
}
restart_wdt();
}
}
|
magster28/Preferences
|
Preference.h
|
// FOR HISTORICAL PURPOSES ONLY
//
// Preference.h
// Photo Math
//
// Created by <NAME> on 6/16/13.
// Copyright (c) 2013 Magster. All rights reserved.
//
// 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
// AUTHOR, THE VOICES IN HIS HEAD 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.
//
// This class is meant to be as resuaable as possible. Just change the keys and the
// implementations of the classes below.
// In addition, this class makes use of a SINGLE instance of the sharedPreference object
// so that it can be used throughout the application.
//
// USAGE:
// The instance of this class will be a shared instance that is persisted throughout the application lifecycle.
// Preference *appPrefs = [Preference sharedInstance]; -- INVOKE THE SHARED INSTANCE
// appPrefs.lastUpdateDate = [NSDate date]; -- SET VALUES
// [appPrefs savePreferences]; -- SAVE THE PREFERENCES
//
// Additional keys to be used to save additional preferences,
// you need to define the Constants for the key String and then the corresponding public field.
//
// Version History
// Version Date Modified By Modification Details
// 0.11 2013/09/18 <NAME> Removed Night Mode
// 0.12 2013/09/20 <NAME> Added the Current Version of the App
// 1.01 2013/10/07 <NAME> Moved the #defines to externs constant Strings for Performance
#import <Foundation/Foundation.h>
/* Keys for the NSUserDefaults file */
// Key for the Last Date and time updated
//#define KEY_LAST_TIME_UPDATED @"last_time_updated"
// Key for the App is used more than Once
//#define KEY_IS_USED_MORE_THAN_ONCE @"is_used_more_than_once"
// Key for the Night Mode of the App
//#define KEY_NIGHT_MODE @"night_mode"
/// Key for the Current Version of App
//#define KEY_CURRENT_VERION @"current_version"
@interface Preference : NSObject
#pragma mark - PUBLIC API
/*!
* Last Time the app was used
*/
@property (nonatomic) NSDate *lastUpdateDate;
/*!
* Appliation has been used more than once. This is a flag that will have a
* NO value only for the First time the application is run
*/
@property (nonatomic) BOOL isUsedMoreThanOnce;
/*!
* The Current Version string for the application
*/
@property (nonatomic, strong) NSString *currentVersion;
#pragma mark - CLASS METHOD
+(Preference *) sharedInstance;
#pragma mark - PUBLIC FUNCTIONS
-(void) savePreferences;
-(void) setDefaultPreferences;
@end
|
desertkun/GameCenterAuth
|
Unity/GameCenterAuth.h
|
#ifndef GameCenterAuth_h
#define GameCenterAuth_h
typedef void ( __stdcall *GenerateSucceeded )(
const char* publicKeyUrl,
uint64_t timestamp,
const char* signature,
const char* salt,
const char* playerID,
const char* alias,
const char* bundleID
);
typedef void ( __stdcall *GenerateFailed )(
const char* reason
);
extern "C"
{
void GenerateIdentityVerificationSignature(GenerateSucceeded OnSucceeded, GenerateFailed OnFailed);
}
#endif
|
freedomsb/v4l2_h264_rtsp
|
H264LiveSourceWithx264.h
|
<filename>H264LiveSourceWithx264.h
/*===============================================================================
Project: H264LiveStreamer
Module: H264LiveSourceWithx264.h
Copyright (c) 2014-2015, <NAME> <<EMAIL>>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
=============================================================================*/
#include <queue>
#include "x264Encoder.h"
//#include "opencv2/opencv.hpp"
class LiveSourceWithx264:public FramedSource
{
public:
static LiveSourceWithx264* createNew(UsageEnvironment& env);
static EventTriggerId eventTriggerId;
protected:
LiveSourceWithx264(UsageEnvironment& env);
virtual ~LiveSourceWithx264(void);
private:
virtual void doGetNextFrame();
static void deliverFrame0(void* clientData);
void deliverFrame();
void encodeNewFrame();
static unsigned referenceCount;
std::queue<x264_nal_t> nalQueue;
timeval currentTime;
// videoCaptureDevice is my BGR data source. You can have according to your need
//cv::VideoCapture videoCaptureDevice;
//cv::Mat rawImage;
// Remember the x264 encoder wrapper we wrote in the start
x264Encoder *encoder;
};
|
freedomsb/v4l2_h264_rtsp
|
x264Encoder.h
|
<reponame>freedomsb/v4l2_h264_rtsp<gh_stars>0
/*===============================================================================
Project: H264LiveStreamer
Module: x264Encoder.h
Copyright (c) 2014-2015, <NAME> <<EMAIL>>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
=============================================================================*/
#ifndef __X264_ENCODER_H
#define __X264_ENCODER_H
#ifdef __cplusplus
#define __STDINT_MACROS
#define __STDC_CONSTANT_MACROS
#endif
#include <iostream>
#include <concurrent_queue.h>
//#include <opencv2/opencv.hpp>
#include <queue>
#include <stdint.h>
extern "C" {
#include <x264.h>
#include <avcodec.h>
}
struct SwsContext;
class x264Encoder
{
public:
x264Encoder(void);
~x264Encoder(void);
public:
void initilize();
void unInitilize();
void encodeFrame(AVPicture *pPictureSrc);
bool isNalsAvailableInOutputQueue();
x264_nal_t getNalUnit();
private:
// Use this context to convert your BGR Image to YUV image since x264 do not support RGB input
SwsContext* convertContext;
std::queue<x264_nal_t> outputQueue;
x264_param_t parameters;
x264_picture_t picture_in,picture_out;
x264_t* encoder;
};
#endif
|
freedomsb/v4l2_h264_rtsp
|
capture.c
|
<reponame>freedomsb/v4l2_h264_rtsp<filename>capture.c
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <dirent.h>
#include <stdio.h>
#include <fcntl.h> /* low-level i/o */
#include <asm/types.h> /* for videodev2.h */
#include <linux/videodev2.h>
#include "capture.h"
static inline int camera_ioctl(int fd, int request, void *arg)
{
int r = -1;
do {
r = ioctl(fd, request, arg);
} while (r < 0 && EINTR == errno);
return r;
}
int camera_open(struct camera *cam)
{
struct stat st;
if (stat(cam->device_name, &st) < 0) {
printf("Cannot identify '%s': %d, %s\n", cam->device_name,
errno, strerror(errno));
return -1;
}
if (!S_ISCHR(st.st_mode)) {
printf("%s is no device\n", cam->device_name);
return -1;
}
cam->fd = open(cam->device_name, O_RDWR, 0); // | O_NONBLOCK
if (cam->fd < 0) {
printf("Cannot open '%s': %d, %s\n", cam->device_name, errno,
strerror(errno));
return -1;
}
return 0;
}
int camera_close(struct camera *cam)
{
if (cam->fd < 0)
return -1;
if (close(cam->fd) < 0) {
printf("can not close camera!\n");
return -1;
}
cam->fd = -1;
return -1;
}
static void camera_init_mmap(struct camera *cam)
{
struct v4l2_requestbuffers req;
struct v4l2_buffer buf;
memset(&buf, 0, sizeof(struct v4l2_buffer));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
memset(&req, 0, sizeof(struct v4l2_requestbuffers));
req.count = 4;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
//分配内存
if (camera_ioctl(cam->fd, VIDIOC_REQBUFS, &req) < 0) {
if (EINVAL == errno) {
printf("%s does not support memory mapping\n", cam->device_name);
return;
} else {
printf("VIDIOC_REQBUFS\n");
return;
}
}
if (req.count < 2) {
printf("Insufficient buffer memory on %s\n", cam->device_name);
return;
}
cam->buffers = calloc(req.count, sizeof(*(cam->buffers)));
if (!cam->buffers) {
printf("Out of memory\n");
return;
}
for (cam->buff_num = 0; cam->buff_num < req.count; cam->buff_num++) {
buf.index = cam->buff_num;
//将VIDIOC_REQBUFS中分配的数据缓存转换成物理地址
if (camera_ioctl(cam->fd, VIDIOC_QUERYBUF, &buf) < 0) {
printf("VIDIOC_QUERYBUF\n");
return;
}
cam->buffers[cam->buff_num].length = buf.length;
cam->buffers[cam->buff_num].start = mmap(NULL /* start anywhere */ ,
buf.length,
PROT_READ | PROT_WRITE
/* required */ ,
MAP_SHARED /* recommended */ ,
cam->fd, buf.m.offset);
if (MAP_FAILED == cam->buffers[cam->buff_num].start) {
printf("mmap\n");
return;
}
}
return;
}
void camera_init(struct camera *cam)
{
unsigned int min;
struct v4l2_capability *cap = &(cam->v4l2_cap);
struct v4l2_cropcap *cropcap = &(cam->v4l2_cropcap);
struct v4l2_crop *crop = &(cam->crop);
struct v4l2_format *fmt = &(cam->v4l2_fmt);
if (camera_ioctl(cam->fd, VIDIOC_QUERYCAP, cap) < 0) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n", cam->device_name);
return;
} else {
printf("VIDIOC_QUERYCAP\n");
return;
}
}
if (!(cap->capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n", cam->device_name);
return;
}
if (!(cap->capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
cam->device_name);
return;
}
printf("\nVIDOOC_QUERYCAP\n");
printf("the camera driver is %s\n", cap->driver);
printf("the camera card is %s\n", cap->card);
printf("the camera bus info is %s\n", cap->bus_info);
printf("the version is %d\n", cap->version);
/* Select video input, video standard and tune here. */
cropcap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop->c.width = cam->width;
crop->c.height = cam->height;
crop->c.left = 0;
crop->c.top = 0;
crop->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt->fmt.pix.width = cam->width;
fmt->fmt.pix.height = cam->height;
fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; //yuv422
//fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420 //yuv420
fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; //隔行扫描
if (camera_ioctl(cam->fd, VIDIOC_S_FMT, fmt) < 0) {
printf("VIDIOC_S_FMT\n");
return;
}
/* Note VIDIOC_S_FMT may change width and height. */
/* Buggy driver paranoia. */
min = fmt->fmt.pix.width * 2;
if (fmt->fmt.pix.bytesperline < min)
fmt->fmt.pix.bytesperline = min;
min = fmt->fmt.pix.bytesperline * fmt->fmt.pix.height;
if (fmt->fmt.pix.sizeimage < min)
fmt->fmt.pix.sizeimage = min;
camera_init_mmap(cam);
return;
}
void camera_uninit(struct camera *cam)
{
uint32_t i;
for (i = 0; i < cam->buff_num; ++i) {
if (munmap(cam->buffers[i].start, cam->buffers[i].length) < 0) {
printf("munmap\n");
return;
}
}
free(cam->buffers);
return;
}
void camera_capturing_start(struct camera *cam)
{
uint32_t i;
struct v4l2_buffer buf;
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
memset(&buf, 0, sizeof(struct v4l2_buffer));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
for (i = 0; i < cam->buff_num; ++i) {
buf.index = i;
if (camera_ioctl(cam->fd, VIDIOC_QBUF, &buf) < 0) {
printf("VIDIOC_DQBUF\n");
return;
}
}
if (camera_ioctl(cam->fd, VIDIOC_STREAMON, &type) < 0) {
printf("VIDIOC_STREAMON\n");
return;
}
return;
}
void camera_capturing_stop(struct camera *cam)
{
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (camera_ioctl(cam->fd, VIDIOC_STREAMOFF, &type) < 0) {
printf("VIDIOC_STREAMOFF\n");
return;
}
return;
}
// static void camera_encode_frame(struct camera *cam, uint8_t * yuv_frame,
// size_t yuv_length)
// {
// int h264_length = 0;
// //这里有一个问题，通过测试发现前6帧都是0，所以这里我跳过了为0的帧
// if (yuv_frame[0] == '\0')
// return;
// h264_length = h264_compress_frame(&cam->en, -1, yuv_frame, cam->h264_buf);
// if (h264_length > 0) {
// //写h264文件
// fwrite(cam->h264_buf, h264_length, 1, cam->h264_fp);
// }
// return;
// }
// int read_and_encode_frame(struct camera *cam)
// {
// struct v4l2_buffer buf;
// memset(&buf, 0, sizeof(struct v4l2_buffer));
// buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
// buf.memory = V4L2_MEMORY_MMAP;
// //this operator below will change buf.index(0 <= buf.index <= 3)
// if (camera_ioctl(cam->fd, VIDIOC_DQBUF, &buf) < 0) {
// switch (errno) {
// case EAGAIN:
// return 0;
// case EIO:
// /* Could ignore EIO, see spec. */
// /* fall through */
// default:
// printf("VIDIOC_DQBUF\n");
// return -1;
// }
// }
// camera_encode_frame(cam, cam->buffers[buf.index].start, buf.length);
// if (camera_ioctl(cam->fd, VIDIOC_QBUF, &buf) < 0) {
// printf("VIDIOC_DQBUF\n");
// return -1;
// }
// return 0;
// }
int read_frame(AVPicture *pPictureSrc,struct camera *cam)
{
struct v4l2_buffer buf;
struct v4l2_format *fmt = &(cam->v4l2_fmt);
memset(&buf, 0, sizeof(struct v4l2_buffer));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
//this operator below will change buf.index(0 <= buf.index <= 3)
if (camera_ioctl(cam->fd, VIDIOC_DQBUF, &buf) < 0) {
switch (errno) {
case EAGAIN:
return 0;
case EIO:
/* Could ignore EIO, see spec. */
/* fall through */
default:
printf("VIDIOC_DQBUF\n");
return -1;
}
}
pPictureSrc->data[0] = cam->buffers[buf.index].start; //(unsigned char *)
pPictureSrc->data[1] = pPictureSrc->data[2] = pPictureSrc->data[3] = NULL;
pPictureSrc->linesize[0] = fmt->fmt.pix.bytesperline;
int i = 0;
for (i = 1; i < 8; i++)
{
pPictureSrc->linesize[i] = 0;
}
//printf("read frame!\n");
//camera_encode_frame(cam, cam->buffers[buf.index].start, buf.length);
if (camera_ioctl(cam->fd, VIDIOC_QBUF, &buf) < 0) {
printf("VIDIOC_DQBUF\n");
return -1;
}
return 0;
}
|
freedomsb/v4l2_h264_rtsp
|
capture.h
|
#ifndef _VIDEO_CAPTURE_H_
#define _VIDEO_CAPTURE_H_
#include <stdint.h>
#include <stdio.h>
#include <avcodec.h>
#include <linux/videodev2.h>
struct buffer {
uint8_t *start;
size_t length;
};
struct camera {
char *device_name;
int fd;
int width;
int height;
int display_depth;
int buff_num;
struct buffer *buffers;
struct v4l2_capability v4l2_cap;
struct v4l2_cropcap v4l2_cropcap;
struct v4l2_format v4l2_fmt;
struct v4l2_crop crop;
};
int camera_open(struct camera *cam);
void camera_init(struct camera *cam);
void camera_capturing_start(struct camera *cam);
void camera_capturing_stop(struct camera *cam);
void camera_uninit(struct camera *cam);
int camera_close(struct camera *cam);
int read_frame(AVPicture *pPictureSrc,struct camera *cam);
#endif
|
rr-/shot
|
src/monitor_mgr_win.c
|
<filename>src/monitor_mgr_win.c
#include <assert.h>
#include <windows.h>
#include "monitor_mgr.h"
#define UNUSED(x) (void)(x)
static BOOL CALLBACK callback(
HMONITOR hmonitor, HDC hdc, LPRECT rect, LPARAM data)
{
UNUSED(hmonitor);
UNUSED(hdc);
MonitorManager *mgr = (MonitorManager*)data;
assert(mgr);
Monitor *monitor = monitor_create(
mgr->monitor_count == 0,
rect->left,
rect->top,
rect->right - rect->left,
rect->bottom - rect->top);
assert(monitor);
monitor_mgr_add(mgr, monitor);
return TRUE;
}
MonitorManager *monitor_mgr_create()
{
MonitorManager *mgr = malloc(sizeof(MonitorManager));
mgr->monitor_count = 0;
mgr->monitors = NULL;
EnumDisplayMonitors(0, NULL, callback, (LPARAM)mgr);
return mgr;
}
|
fixstars/ion-bb-genesis-cloud
|
rt_display.h
|
<reponame>fixstars/ion-bb-genesis-cloud
#ifndef ION_BB_GENESIS_CLOUD_RT_DISPLAY_H
#define ION_BB_GENESIS_CLOUD_RT_DISPLAY_H
#include <stdexcept>
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <HalideBuffer.h>
#include "rt_common.h"
namespace {
class FBDev {
public:
FBDev(int32_t width, int32_t height) : width_(width), height_(height), device_is_available_(true) {
using namespace std;
const char *dev_name = "/dev/fb0";
fd_ = open(dev_name, O_RDWR);
if (fd_ == -1)
{
device_is_available_ = false;
return;
}
// Get fixed screen information
if (ioctl(fd_, FBIOGET_FSCREENINFO, &finfo_) == -1)
{
throw runtime_error("Error reading fixed information");
}
// Get variable screen information
if (ioctl(fd_, FBIOGET_VSCREENINFO, &vinfo_) == -1)
{
throw runtime_error("Error reading variable information");
}
// std::cout << format("xoffset: %d, yoffset: %d\nxres: %d, yres: %d\nbits_per_pixel: %d, line_length: %d\n",
// vinfo_.xoffset, vinfo_.yoffset, vinfo_.xres, vinfo_.yres, vinfo_.bits_per_pixel, finfo_.line_length);
unsigned int screensize = (vinfo_.xres * vinfo_.yres * vinfo_.bits_per_pixel) >> 3; /* (>>3): bits to bytes */
fbp_ = reinterpret_cast<uint8_t *>(mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0));
if (fbp_ == reinterpret_cast<uint8_t *>(-1))
{
throw runtime_error("Error mapping framebuffer device to memory");
}
}
void put(Halide::Runtime::Buffer<uint8_t>& buf) {
for(int y = 0; y < height_; y++)
{
for(int x = 0; x < width_; x++)
{
unsigned int location = (x + vinfo_.xoffset) * (vinfo_.bits_per_pixel >> 3) + (y + vinfo_.yoffset) * finfo_.line_length;
fbp_[location + 0] = buf(2, x, y); // B
fbp_[location + 1] = buf(1, x, y); // G
fbp_[location + 2] = buf(0, x, y); // R
}
}
}
bool is_available() {
return device_is_available_;
}
private:
int32_t width_;
int32_t height_;
int fd_;
uint8_t *fbp_;
struct fb_fix_screeninfo finfo_;
struct fb_var_screeninfo vinfo_;
bool device_is_available_;
};
}
extern "C"
int ION_EXPORT ion_bb_genesis_cloud_display(int32_t width, int32_t height, halide_buffer_t *in, halide_buffer_t *out) {
try {
static FBDev fbdev(width, height);
if (in->is_bounds_query() || out->is_bounds_query()) {
if (in->is_bounds_query()) {
in->dim[0].min = 0;
in->dim[0].extent = 3;
in->dim[1].min = 0;
in->dim[1].extent = width;
in->dim[2].min = 0;
in->dim[2].extent = height;
}
} else {
Halide::Runtime::Buffer<uint8_t> ibuf(*in);
if (fbdev.is_available()) {
fbdev.put(ibuf);
}
}
return 0;
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
return -1;
} catch (...) {
std::cerr << "Unknown" << std::endl;
return -1;
}
}
#endif
|
fixstars/ion-bb-genesis-cloud
|
rt.h
|
#ifndef ION_BB_GENESIS_CLOUD_RT_H
#define ION_BB_GENESIS_CLOUD_RT_H
#include <iostream>
#include <cstring>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#include <HalideBuffer.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include "httplib.h"
#include "rt_common.h"
#include "rt_camera.h"
#include "rt_display.h"
#ifdef _WIN32
#define ION_EXPORT __declspec(dllexport)
#else
#define ION_EXPORT
#endif
namespace ion {
namespace bb {
namespace genesis_cloud {
std::tuple<std::string, std::string> parse_url(const std::string &url) {
auto protocol_end_pos = url.find("://");
if (protocol_end_pos == std::string::npos) {
return std::tuple<std::string, std::string>("", "");
}
auto host_name_pos = protocol_end_pos + 3;
auto path_name_pos = url.find("/", host_name_pos);
auto host_name = url.substr(0, path_name_pos);
auto path_name = url.substr(path_name_pos);
return std::tuple<std::string, std::string>(host_name, path_name);
}
std::unordered_map<int32_t, cv::Mat> camera_stub_cache;
} // namespace dnn
} // namespace bb
} // namespace ion
extern "C"
int ION_EXPORT ion_bb_genesis_cloud_image_loader(halide_buffer_t *in, halide_buffer_t *out) {
if (in->is_bounds_query()) {
// NOP
} else {
const char *url = reinterpret_cast<const char *>(in->host);
static std::unordered_map<const char*, cv::Mat> decoded;
if (decoded.count(url) == 0) {
std::string host_name;
std::string path_name;
std::tie(host_name, path_name) = ion::bb::genesis_cloud::parse_url(url);
if (host_name.empty() || path_name.empty()) {
std::cerr << "Invalid URL is specified" << std::endl;
return -1;
}
httplib::Client cli(host_name.c_str());
cli.set_follow_location(true);
auto res = cli.Get(path_name.c_str());
if (res && res->status == 200) {
std::vector<char> data(res->body.size());
std::memcpy(data.data(), res->body.c_str(), res->body.size());
cv::Mat frame = cv::imdecode(cv::InputArray(data), cv::IMREAD_COLOR);
decoded[url] = frame;
}
}
const cv::Mat& img(decoded[url]);
if (out->is_bounds_query()) {
out->dim[0].min = 0;
out->dim[0].extent = 3;
out->dim[1].min = 0;
out->dim[1].extent = img.cols;
out->dim[2].min = 0;
out->dim[2].extent = img.rows;
} else {
std::memcpy(out->host, img.data, img.total() * img.elemSize());
}
}
return 0;
}
extern "C"
int ION_EXPORT ion_bb_genesis_cloud_image_saver(halide_buffer_t *in, int32_t in_extent_1, int32_t in_extent_2, halide_buffer_t *path, halide_buffer_t *out) {
if (in->is_bounds_query()) {
in->dim[0].min = 0;
in->dim[0].extent = 3;
in->dim[1].min = 0;
in->dim[1].extent = in_extent_1;
in->dim[2].min = 0;
in->dim[2].extent = in_extent_2;
} else {
cv::Mat img(std::vector<int>{in_extent_2, in_extent_1}, CV_8UC3, in->host);
cv::imwrite(reinterpret_cast<const char*>(path->host), img);
}
return 0;
}
#undef ION_EXPORT
#endif
|
fixstars/ion-bb-genesis-cloud
|
rt_camera.h
|
#ifndef ION_BB_GENESIS_CLOUD_RT_CAMERA_H
#define ION_BB_GENESIS_CLOUD_RT_CAMERA_H
#include <stdexcept>
#include <vector>
#include <unordered_map>
#include <errno.h>
#include <fcntl.h>
#include <linux/videodev2.h>
#include <sys/epoll.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <HalideBuffer.h>
#include "rt_common.h"
#include "httplib.h"
namespace {
int xioctl(int fd, int request, void * arg) {
int r;
do {
r = ioctl(fd, request, arg);
}
while (-1 == r && EINTR == errno);
return r;
}
class V4L2 {
struct Buffer {
void *start;
size_t length;
};
public:
V4L2(int32_t width, int32_t height) : device_is_available_(true) {
using namespace std;
//
// Initialize device
//
const char *dev_name = "/dev/video0";
struct stat st;
if (-1 == stat(dev_name, &st)) {
device_is_available_ = false;
return;
}
if (!S_ISCHR(st.st_mode)) {
std::cerr << format("%s is no device", dev_name) << std::endl;
device_is_available_ = false;
return;
}
fd_ = open(dev_name, O_RDWR | O_NONBLOCK, 0);
if (-1 == fd_) {
std::cerr << format("Cannot open '%s': %d, %s", dev_name, errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
struct v4l2_capability cap;
if (-1 == xioctl(fd_, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
std::cerr << format("%s is no V4L2 device", dev_name) << std::endl;
device_is_available_ = false;
return;
} else {
std::cerr << format("%s error %d, %s\n", "VIDIOC_QUERYCAP", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
std::cerr << format("%s is no video capture device", dev_name) << std::endl;
device_is_available_ = false;
return;
}
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
std::cerr << format("%s does not support streaming i/o", dev_name) << std::endl;
device_is_available_ = false;
return;
}
uint32_t desired_pixel_format = V4L2_PIX_FMT_YUYV;
struct v4l2_fmtdesc fmtdesc;
memset(&fmtdesc,0,sizeof(fmtdesc));
fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
bool supported = false;
while (0 == xioctl(fd_, VIDIOC_ENUM_FMT, &fmtdesc))
{
if (fmtdesc.pixelformat == desired_pixel_format) {
supported = true;
}
fmtdesc.index++;
}
if (!supported) {
std::cerr << format("%s does not support desired pixel format", dev_name) << std::endl;
device_is_available_ = false;
return;
}
struct v4l2_format fmt {
.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
.fmt = {
.pix = {
.width = static_cast<__u32>(width),
.height = static_cast<__u32>(height),
.pixelformat = desired_pixel_format,
.field = V4L2_FIELD_INTERLACED,
}
},
};
if (-1 == xioctl(fd_, VIDIOC_S_FMT, &fmt)){
std::cerr << format("%s error %d, %s\n", "VIDIOC_S_FMT", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
if (width != fmt.fmt.pix.width || height != fmt.fmt.pix.height) {
std::cerr << format("%s does not support desired resolution", dev_name) << std::endl;
device_is_available_ = false;
return;
}
/* YUYV sampling 4 2 2, so bytes per pixel is 2*/
unsigned int min;
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min){
fmt.fmt.pix.bytesperline = min;
}
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min){
fmt.fmt.pix.sizeimage = min;
}
//
// Initialize mapped memory
//
struct v4l2_requestbuffers req;
req.count = 4;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(fd_, VIDIOC_REQBUFS, &req)) {
if (EINVAL == errno) {
std::cerr << format("%s does not support memory mapping\n", dev_name) << std::endl;
device_is_available_ = false;
return;
} else {
std::cerr << format("%s error %d, %s\n", "VIDIOC_REQBUFS", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
}
/* video output requires at least two buffers, one displayed and one filled by the application */
if (req.count < 2) {
std::cerr << format("Insufficient buffer memory on %s\n", dev_name) << std::endl;
device_is_available_ = false;
return;
}
for (int i=0; i<req.count; ++i) {
struct v4l2_buffer buf;
buf.index = static_cast<__u32>(i);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
/* Query the status of a buffer */
if (-1 == xioctl(fd_, VIDIOC_QUERYBUF, &buf)){
std::cerr << format("%s error %d, %s\n", "VIDIOC_QUERYBUF", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
Buffer buffer;
buffer.start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, buf.m.offset);
buffer.length = buf.length;
if (MAP_FAILED == buffer.start) {
std::cerr << format("%s error %d, %s\n", "mmap", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
buffers_.push_back(buffer);
}
//
// Start capture
//
for (int i = 0; i < buffers_.size(); ++i) {
struct v4l2_buffer buf;
buf.index = static_cast<__u32>(i);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
/* enqueue an empty (capturing) or filled (output) buffer in the driver's incoming queue */
if (-1 == xioctl(fd_, VIDIOC_QBUF, &buf)){
std::cerr << format("%s error %d, %s\n", "VIDIOC_QBUF", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
}
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
/* Start streaming I/O */
if (-1 == xioctl(fd_, VIDIOC_STREAMON, &type)){
std::cerr << format("%s error %d, %s\n", "VIDIOC_STREAMON", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
//
// Initialize event
//
efd_ = epoll_create1(0);
if (-1 == efd_)
{
std::cerr << format("%s error %d, %s\n", "epoll_create1", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
struct epoll_event event;
event.events = EPOLLIN | EPOLLET;
event.data.fd = fd_;
if (-1 == epoll_ctl(efd_, EPOLL_CTL_ADD, fd_, &event)) {
std::cerr << format("%s error %d, %s\n", "epoll_ctl", errno, strerror(errno)) << std::endl;
device_is_available_ = false;
return;
}
}
void get(Halide::Runtime::Buffer<uint8_t>& buf) {
using namespace std;
epoll_event event;
if (-1 == epoll_wait(efd_, &event, 1, -1)) {
throw runtime_error(format("%s error %d, %s\n", "epoll_wait", errno, strerror(errno)));
}
if (event.data.fd != fd_) {
throw runtime_error("Unreachable");
}
struct v4l2_buffer v4l2_buf;
v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
v4l2_buf.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(fd_, VIDIOC_DQBUF, &v4l2_buf)) {
if (EAGAIN == errno) {
return;
} else {
throw runtime_error(format("%s error %d, %s\n", "VIDIOC_DQBUF", errno, strerror(errno)));
}
}
memcpy(buf.data(), buffers_[v4l2_buf.index].start, buf.size_in_bytes());
/* queue-in buffer */
if (-1 == xioctl(fd_, VIDIOC_QBUF, &v4l2_buf)){
throw runtime_error(format("%s error %d, %s\n", "VIDIOC_QBUF", errno, strerror(errno)));
}
}
void dispose() {
}
bool is_available() {
return device_is_available_;
}
private:
int fd_;
std::vector<Buffer> buffers_;
bool device_is_available_;
int efd_;
};
std::tuple<std::string, std::string> parse_url(const std::string &url) {
auto protocol_end_pos = url.find("://");
if (protocol_end_pos == std::string::npos) {
return std::tuple<std::string, std::string>("", "");
}
auto host_name_pos = protocol_end_pos + 3;
auto path_name_pos = url.find("/", host_name_pos);
auto host_name = url.substr(0, path_name_pos);
auto path_name = url.substr(path_name_pos);
return std::tuple<std::string, std::string>(host_name, path_name);
}
std::unordered_map<std::string, std::vector<uint8_t>> camera_cache;
}
extern "C"
int ION_EXPORT ion_bb_genesis_cloud_camera(halide_buffer_t *session_id_buf,
int32_t width,
int32_t height,
halide_buffer_t *url_buf,
halide_buffer_t *out) {
try {
static V4L2 v4l2(width, height);
std::string session_id(reinterpret_cast<const char *>(session_id_buf->host));
if (out->is_bounds_query()) {
out->dim[0].min = 0;
out->dim[0].extent = 2 * width; // YUYV
out->dim[1].min = 0;
out->dim[1].extent = height;
} else {
Halide::Runtime::Buffer<uint8_t> obuf(*out);
if (v4l2.is_available()) {
v4l2.get(obuf);
} else {
auto it = camera_cache.find(session_id);
if (it != camera_cache.end()) {
memcpy(out->host, it->second.data(), it->second.size());
return 0;
}
const char *url = reinterpret_cast<const char *>(url_buf->host);
std::string host_name;
std::string path_name;
std::tie(host_name, path_name) = parse_url(url);
cv::Mat img;
bool img_loaded = false;
if (host_name.empty() || path_name.empty()) {
// fallback to local file
img = cv::imread(url);
if (!img.empty()) {
img_loaded = true;
}
} else {
httplib::Client cli(host_name.c_str());
cli.set_follow_location(true);
auto res = cli.Get(path_name.c_str());
if (res && res->status == 200) {
std::vector<char> data(res->body.size());
std::memcpy(data.data(), res->body.c_str(), res->body.size());
img = cv::imdecode(cv::InputArray(data), cv::IMREAD_COLOR);
img_loaded = true;
}
}
if (!img_loaded) {
// Simulation mode
for (int y=0; y<height; ++y) {
for (int x=0; x<2*width; ++x) {
obuf(x, y) = (y * 2 * width + x) % 255;
}
}
return 0;
}
cv::resize(img, img, cv::Size(width, height));
cv::cvtColor(img, img, cv::COLOR_BGR2YCrCb);
std::vector<uint8_t> yuyv_img(2*width*height);
for (int y=0; y<height; ++y) {
for (int x=0; x<width; ++x) {
// Y
yuyv_img[2*width*y+2*x+0] = img.at<cv::Vec3b>(y, x)[0];
// Cb or Cr
yuyv_img[2*width*y+2*x+1] = ((x % 2) == 1) ? img.at<cv::Vec3b>(y, x)[1] : img.at<cv::Vec3b>(y, x)[2];
}
}
memcpy(out->host, yuyv_img.data(), yuyv_img.size());
camera_cache[session_id] = yuyv_img;
}
}
return 0;
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
return -1;
} catch (...) {
std::cerr << "Unknown" << std::endl;
return -1;
}
}
#endif
|
fixstars/ion-bb-genesis-cloud
|
rt_common.h
|
<reponame>fixstars/ion-bb-genesis-cloud<filename>rt_common.h
#ifndef ION_BB_GENESIS_CLOUD_RT_COMMON_H
#define ION_BB_GENESIS_CLOUD_RT_COMMON_H
#ifdef _WIN32
#define ION_EXPORT __declspec(dllexport)
#else
#define ION_EXPORT
#endif
#include <cstdio>
#include <string>
namespace {
template<typename... Rest>
std::string format(const char *fmt, const Rest&... rest)
{
int length = snprintf(NULL, 0, fmt, rest...) + 1; // Explicit place for null termination
std::vector<char> buf(length, 0);
snprintf(&buf[0], length, fmt, rest...);
std::string s(buf.begin(), std::find(buf.begin(), buf.end(), '\0'));
return s;
}
}
#endif
|
peteshand/kinect-azure
|
src/structs.h
|
#ifndef kinect_azure_structs_h
#define kinect_azure_structs_h
#ifdef KINECT_AZURE_ENABLE_BODY_TRACKING
typedef struct _JSJoint
{
float cameraX = 0;
float cameraY = 0;
float cameraZ = 0;
//
float orientationX = 0;
float orientationY = 0;
float orientationZ = 0;
float orientationW = 0;
//
float colorX = 0;
float colorY = 0;
//
float depthX = 0;
float depthY = 0;
//
int confidence = 0;
} JSJoint;
typedef struct _JSSkeleton
{
JSJoint joints[K4ABT_JOINT_COUNT];
} JSSkeleton;
typedef struct _JSBody
{
int id = 0;
JSSkeleton skeleton;
} JSBody;
typedef struct _JSBodyFrame
{
JSBody* bodies = NULL;
int numBodies = 0;
void reset() {
if (bodies != NULL) {
delete [] bodies;
bodies = NULL;
}
numBodies = 0;
}
} JSBodyFrame;
#endif // KINECT_AZURE_ENABLE_BODY_TRACKING
typedef struct _JSImageFrame
{
uint8_t* image_data = NULL;
size_t image_length = 0;
int stride_bytes = 0;
int width = 0;
int height = 0;
void reset() {
if (image_data != NULL) {
delete [] image_data;
image_data = NULL;
}
image_length = 0;
stride_bytes = 0;
width = 0;
height = 0;
}
} JSImageFrame;
typedef struct _JSFrame
{
#ifdef KINECT_AZURE_ENABLE_BODY_TRACKING
JSBodyFrame bodyFrame;
#endif // KINECT_AZURE_ENABLE_BODY_TRACKING
JSImageFrame colorImageFrame;
JSImageFrame depthImageFrame;
JSImageFrame irImageFrame;
JSImageFrame depthToColorImageFrame;
JSImageFrame colorToDepthImageFrame;
void reset() {
colorImageFrame.reset();
depthImageFrame.reset();
irImageFrame.reset();
depthToColorImageFrame.reset();
colorToDepthImageFrame.reset();
}
void resetBodyFrame() {
#ifdef KINECT_AZURE_ENABLE_BODY_TRACKING
bodyFrame.reset();
#endif // KINECT_AZURE_ENABLE_BODY_TRACKING
}
} JSFrame;
typedef struct _CustomDeviceConfig
{
bool include_depth_to_color = false;
bool include_color_to_depth = false;
bool flip_BGRA_to_RGBA = false;
void reset() {
include_depth_to_color = false;
include_color_to_depth = false;
flip_BGRA_to_RGBA = false;
}
} CustomDeviceConfig;
#endif
|
dennis/bzlauncher
|
src/search32.h
|
#ifndef SEARCH32_PNG_H
#define SEARCH32_PNG_H
static const unsigned char search32_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a, 0xf4, 0x00, 0x00, 0x00,
0x04, 0x73, 0x42, 0x49, 0x54, 0x08, 0x08, 0x08, 0x08, 0x7c, 0x08, 0x64,
0x88, 0x00, 0x00, 0x08, 0x5e, 0x49, 0x44, 0x41, 0x54, 0x58, 0x85, 0xcd,
0x96, 0x7f, 0x6c, 0x5b, 0xd5, 0x15, 0xc7, 0xbf, 0xf7, 0xfd, 0x8a, 0xfd,
0x9e, 0xed, 0xd8, 0x4e, 0x4c, 0x92, 0xd6, 0xa9, 0x0b, 0x49, 0x5b, 0xd2,
0x1f, 0x21, 0x2d, 0xb4, 0x05, 0xd3, 0x41, 0xa7, 0xa6, 0x4d, 0xe9, 0x08,
0xec, 0x07, 0xa0, 0xb1, 0xaa, 0x93, 0xa6, 0x6e, 0x4c, 0xd3, 0xa4, 0xb1,
0x7f, 0x60, 0x65, 0x42, 0xc2, 0x62, 0x52, 0x58, 0xa5, 0xae, 0x0c, 0xfe,
0x42, 0xdb, 0x98, 0x36, 0x75, 0x93, 0xa6, 0x75, 0xa0, 0x22, 0xa4, 0x4d,
0x29, 0x4c, 0x4d, 0xd2, 0xd2, 0x65, 0x1a, 0x8c, 0xf4, 0x57, 0x92, 0xa6,
0xb6, 0xe3, 0xc4, 0x6d, 0xb0, 0x63, 0x3b, 0xf1, 0x8f, 0xf7, 0xec, 0xe7,
0xf7, 0xe3, 0xde, 0xfd, 0xd1, 0xa6, 0xb2, 0xba, 0x86, 0x34, 0xdb, 0xfe,
0xd8, 0x91, 0x8e, 0xde, 0xb9, 0x57, 0xf7, 0xbc, 0xf3, 0xb9, 0xe7, 0xbc,
0x73, 0xef, 0x03, 0x96, 0x29, 0x91, 0x48, 0x84, 0x8b, 0x44, 0x22, 0xdc,
0x72, 0xfd, 0x16, 0x13, 0xb2, 0xd4, 0x82, 0xc3, 0x87, 0x0f, 0xbb, 0x09,
0x21, 0x5f, 0xa3, 0x94, 0x3e, 0x41, 0x08, 0xf9, 0x12, 0xcf, 0xf3, 0x12,
0x00, 0xd8, 0xb6, 0x6d, 0x13, 0x42, 0xfe, 0xcc, 0x18, 0x7b, 0x8f, 0x31,
0xf6, 0xa7, 0x43, 0x87, 0x0e, 0x15, 0xfe, 0xa7, 0x00, 0x47, 0x8f, 0x1e,
0x75, 0x1a, 0x86, 0xf1, 0xbc, 0xdf, 0xef, 0x7f, 0x6d, 0xfb, 0xf6, 0xed,
0x08, 0x85, 0x42, 0x50, 0x14, 0x05, 0x3c, 0xcf, 0x83, 0x52, 0x0a, 0xc3,
0x30, 0x90, 0xc9, 0x64, 0x30, 0x36, 0x36, 0x86, 0xd1, 0xd1, 0x51, 0x98,
0xa6, 0xf9, 0x72, 0xa5, 0x52, 0x79, 0x23, 0x12, 0x89, 0xa8, 0xff, 0x35,
0xc0, 0x91, 0x23, 0x47, 0x42, 0x8c, 0xb1, 0xb3, 0xbd, 0xbd, 0xbd, 0x2b,
0xda, 0xdb, 0xdb, 0xa1, 0xaa, 0x2a, 0x34, 0x4d, 0x83, 0x69, 0x9a, 0xb0,
0x6d, 0x1b, 0x1c, 0xc7, 0x41, 0x14, 0x45, 0x28, 0x8a, 0x02, 0xb7, 0xdb,
0x8d, 0x52, 0xa9, 0x84, 0xa1, 0xa1, 0x21, 0x8c, 0x8f, 0x8f, 0x97, 0x09,
0x21, 0x9d, 0x2f, 0xbe, 0xf8, 0x62, 0xec, 0x3f, 0x06, 0x38, 0x7c, 0xf8,
0x70, 0x50, 0x96, 0xe5, 0xe4, 0x81, 0x03, 0x07, 0x20, 0x08, 0x02, 0x32,
0x99, 0x0c, 0x2e, 0x27, 0xe7, 0x4a, 0x7f, 0x3c, 0x73, 0x35, 0x3e, 0x76,
0xb5, 0x1c, 0xd0, 0x4d, 0xab, 0x01, 0xe0, 0xe0, 0x94, 0xb8, 0xdc, 0xfa,
0xa0, 0x2b, 0xfb, 0xec, 0xa3, 0xab, 0xd6, 0xdc, 0xbf, 0x3e, 0xe4, 0x94,
0x65, 0x19, 0x9f, 0x7c, 0xf2, 0x09, 0xce, 0x9c, 0x39, 0x03, 0xcb, 0xb2,
0xd6, 0xbc, 0xf4, 0xd2, 0x4b, 0xd1, 0x65, 0x03, 0xbc, 0xf9, 0xe6, 0x9b,
0x75, 0xd5, 0x6a, 0x35, 0x7a, 0xf0, 0xe0, 0xc1, 0x20, 0x00, 0xa4, 0x67,
0xb3, 0xf8, 0xe9, 0x3b, 0xe3, 0x17, 0x2f, 0x26, 0x4a, 0xa1, 0xe6, 0x26,
0x6f, 0xe2, 0xae, 0x06, 0x4f, 0xda, 0xa5, 0x38, 0x34, 0x00, 0x50, 0x35,
0x5d, 0x99, 0xcd, 0x15, 0x9b, 0x52, 0xe9, 0xfc, 0xdd, 0x5d, 0x6d, 0x9e,
0x6b, 0xaf, 0x7e, 0x73, 0xeb, 0xba, 0xc6, 0x06, 0x1f, 0x86, 0x87, 0x87,
0x31, 0x3c, 0x3c, 0x3c, 0x57, 0xa9, 0x54, 0x5a, 0x23, 0x91, 0x48, 0x79,
0x29, 0x00, 0xa1, 0x76, 0x50, 0xa9, 0x54, 0xbe, 0xb7, 0x77, 0xef, 0xde,
0xa0, 0x20, 0x08, 0xf8, 0xec, 0xb3, 0x14, 0x7e, 0xf0, 0xcb, 0x91, 0x89,
0xaa, 0xcd, 0xcb, 0x8f, 0x3c, 0xb8, 0x6e, 0xf0, 0xa1, 0x7b, 0x03, 0xfe,
0xb6, 0x66, 0x57, 0xc8, 0xe5, 0x10, 0x1c, 0xba, 0x49, 0xcd, 0x6c, 0xb1,
0x5a, 0xba, 0x98, 0x2c, 0xa6, 0xae, 0x5c, 0xcd, 0x4f, 0x9e, 0x1f, 0x4b,
0x6e, 0xfc, 0xce, 0xcf, 0xcf, 0x24, 0x7e, 0xfb, 0xc2, 0xce, 0xd5, 0x5d,
0x5d, 0x5d, 0x48, 0xa5, 0x52, 0xfe, 0x44, 0x22, 0xf1, 0x3c, 0x80, 0xd7,
0x96, 0x02, 0xe0, 0x17, 0x8c, 0xa3, 0x47, 0x8f, 0x3a, 0x65, 0x59, 0x3e,
0xdd, 0xdd, 0xdd, 0x8d, 0xd9, 0xd9, 0x59, 0xbc, 0xfe, 0xde, 0xc4, 0xa5,
0xb4, 0x4a, 0x85, 0x5d, 0xe1, 0x75, 0xe3, 0x5f, 0xdf, 0x11, 0x5a, 0x7f,
0x6f, 0xd0, 0xd3, 0xe2, 0x91, 0x45, 0x59, 0xe0, 0x38, 0x5e, 0xe0, 0x39,
0x5e, 0x76, 0xf0, 0xd2, 0xaa, 0x06, 0xa5, 0xde, 0xa3, 0x48, 0x9c, 0x25,
0x48, 0x57, 0x92, 0xe9, 0x42, 0xe3, 0xc4, 0x54, 0x36, 0xff, 0xd8, 0x43,
0xed, 0x7e, 0x45, 0x51, 0x30, 0x31, 0x31, 0xb1, 0x2b, 0x1c, 0x0e, 0xff,
0x6c, 0x60, 0x60, 0xc0, 0xf8, 0x3c, 0x80, 0x9b, 0xfd, 0x6c, 0x59, 0xd6,
0xe3, 0x9b, 0x37, 0x6f, 0x86, 0xaa, 0xaa, 0xb8, 0x96, 0x55, 0xab, 0xff,
0x88, 0x16, 0xee, 0xba, 0x7f, 0x43, 0x68, 0xec, 0xf1, 0x2d, 0x2b, 0xd7,
0xf9, 0x14, 0x49, 0xe1, 0x39, 0xc2, 0x4b, 0x02, 0x2f, 0xf0, 0x3c, 0x21,
0x3c, 0x47, 0x18, 0xcf, 0x11, 0x4a, 0x08, 0xd8, 0xaa, 0x46, 0xb9, 0x7e,
0x85, 0xdf, 0x29, 0xdf, 0xd7, 0xb1, 0xea, 0xd2, 0xdf, 0xc6, 0xe7, 0xea,
0xaf, 0x4c, 0xa5, 0x69, 0x43, 0x43, 0x03, 0x5a, 0x5b, 0x5b, 0x21, 0xcb,
0xf2, 0x57, 0x97, 0xca, 0xc0, 0x4d, 0x00, 0xc6, 0xd8, 0x93, 0xcd, 0xcd,
0xcd, 0x28, 0x97, 0xcb, 0xf8, 0xc3, 0xe0, 0xd4, 0x4c, 0x73, 0xc0, 0x3b,
0xd3, 0xd5, 0xde, 0xe0, 0x77, 0x39, 0x04, 0x87, 0x4d, 0x19, 0xa3, 0x8c,
0x99, 0xa6, 0x4d, 0x75, 0xc6, 0x50, 0x05, 0x50, 0xe5, 0x41, 0xaa, 0x1c,
0x81, 0x4e, 0x38, 0xa2, 0x17, 0x34, 0x23, 0xcf, 0x71, 0x9c, 0xd5, 0x14,
0xf0, 0x5e, 0xfb, 0x4d, 0xff, 0x58, 0x4e, 0x14, 0x45, 0xac, 0x58, 0xb1,
0x02, 0x8c, 0xb1, 0x27, 0xef, 0x18, 0x00, 0xc0, 0x16, 0x49, 0x92, 0x60,
0xdb, 0x36, 0xce, 0x4f, 0xab, 0xee, 0x46, 0xbf, 0x2b, 0xd3, 0xea, 0x77,
0x7a, 0x4c, 0xdb, 0xb6, 0x6d, 0x4a, 0x75, 0xd3, 0x64, 0x65, 0xd3, 0x66,
0x9a, 0x4d, 0xa1, 0x31, 0xca, 0xca, 0x94, 0xa1, 0x0c, 0xa0, 0x52, 0xd4,
0xcc, 0x59, 0xad, 0x62, 0xcd, 0x01, 0xa4, 0x14, 0xf0, 0x7b, 0xd2, 0x1f,
0x47, 0xf3, 0xa2, 0x6d, 0xdb, 0xf0, 0xf9, 0x7c, 0x00, 0xd0, 0xb5, 0x14,
0x40, 0xed, 0x47, 0x18, 0x22, 0x84, 0x80, 0x52, 0x8a, 0xb2, 0x4e, 0xdd,
0xb2, 0xcb, 0xa1, 0xd5, 0x89, 0xbc, 0x68, 0x51, 0xe8, 0x9c, 0x05, 0x0a,
0x50, 0xca, 0x51, 0xd8, 0x1c, 0x47, 0x2c, 0xca, 0x98, 0xc9, 0xc0, 0x4c,
0xc6, 0x60, 0x5d, 0x48, 0x16, 0xc6, 0x40, 0x88, 0x0e, 0x30, 0xea, 0x54,
0xc4, 0x8c, 0x5a, 0x31, 0x15, 0xc3, 0x30, 0xe0, 0x74, 0x3a, 0x01, 0x60,
0xe5, 0x72, 0x00, 0x2a, 0x8c, 0x31, 0x99, 0x10, 0x02, 0xdc, 0x68, 0x4f,
0xdd, 0xb4, 0x75, 0x91, 0xe7, 0x18, 0x21, 0xb0, 0x61, 0x73, 0x16, 0xc7,
0xc1, 0xe2, 0x18, 0x33, 0xc1, 0x60, 0xd8, 0x94, 0x59, 0x57, 0xd2, 0x6a,
0x74, 0x72, 0x56, 0x4d, 0x82, 0x41, 0xe1, 0x08, 0x21, 0x04, 0xc4, 0x09,
0xe0, 0xe6, 0x81, 0x05, 0x80, 0x2e, 0x07, 0xe0, 0x33, 0xdb, 0xb6, 0x1b,
0x04, 0x41, 0x80, 0xcb, 0xc9, 0x6b, 0x65, 0x55, 0x57, 0x72, 0x25, 0x23,
0x2f, 0x0a, 0x9c, 0x04, 0xc0, 0x04, 0xa5, 0x06, 0x27, 0xf0, 0x86, 0x40,
0x48, 0x95, 0x31, 0xa6, 0xc7, 0x52, 0xda, 0xe8, 0xe9, 0x8b, 0xe9, 0x69,
0x02, 0xc8, 0x00, 0x21, 0x0c, 0x4c, 0x28, 0x15, 0x2b, 0x0e, 0x8f, 0x22,
0xe9, 0x8c, 0x31, 0xb1, 0x52, 0xa9, 0x00, 0x40, 0x72, 0x39, 0x00, 0x7f,
0x9f, 0x9f, 0x9f, 0xdf, 0xd8, 0xd2, 0xd2, 0x82, 0x07, 0xda, 0xeb, 0x31,
0x91, 0x51, 0x03, 0x97, 0xaf, 0x16, 0xc6, 0x38, 0x02, 0xa7, 0xcf, 0x2d,
0x41, 0x16, 0x79, 0xc3, 0xd2, 0xed, 0x7c, 0xb1, 0x6a, 0x4e, 0x9f, 0x8f,
0x17, 0x46, 0x53, 0xf3, 0x9a, 0xca, 0x18, 0x64, 0x8e, 0x70, 0x1c, 0x05,
0xea, 0x08, 0x60, 0xce, 0xe6, 0x8a, 0x2b, 0xc3, 0x1d, 0x0d, 0x22, 0x00,
0x64, 0x32, 0x19, 0x58, 0x96, 0x35, 0x74, 0xc7, 0x00, 0x8c, 0xb1, 0xf7,
0x2e, 0x5f, 0xbe, 0x7c, 0xb0, 0xad, 0xad, 0x0d, 0xcf, 0x7c, 0x61, 0xb5,
0xef, 0xf9, 0x5f, 0x8c, 0x20, 0x93, 0x0f, 0x8c, 0xe4, 0x8a, 0xc6, 0x0c,
0x05, 0xf2, 0x00, 0xf2, 0x1c, 0x50, 0xb0, 0x81, 0x3c, 0x18, 0xf2, 0x04,
0xcc, 0x06, 0x88, 0x48, 0xc1, 0x6c, 0x00, 0xd4, 0xb4, 0x29, 0x5f, 0x28,
0xa8, 0xf7, 0xed, 0xdf, 0xb5, 0xd9, 0x61, 0x18, 0x06, 0xa6, 0xa6, 0xa6,
0xa0, 0x69, 0xda, 0x89, 0xa5, 0x00, 0x6e, 0x76, 0x81, 0xae, 0xeb, 0xfd,
0xd3, 0xd3, 0xd3, 0xb3, 0xf3, 0xf3, 0xf3, 0x58, 0xdf, 0x1e, 0xc4, 0x17,
0x37, 0x35, 0x8a, 0xe7, 0xc6, 0xa7, 0x1f, 0xa4, 0x1c, 0xcf, 0x81, 0x23,
0x1c, 0x07, 0xc6, 0x53, 0x30, 0x8e, 0x70, 0x4c, 0x00, 0xc7, 0x9c, 0x8c,
0x17, 0x64, 0x00, 0x22, 0x07, 0xc2, 0x33, 0x4a, 0xf8, 0x8b, 0xa3, 0xd3,
0x5f, 0xd9, 0xb7, 0x2d, 0xe8, 0x6a, 0xf4, 0x48, 0x48, 0xa7, 0xd3, 0x88,
0xc5, 0x62, 0x93, 0x92, 0x24, 0xfd, 0xe5, 0x8e, 0x01, 0x22, 0x91, 0x88,
0x41, 0x29, 0xfd, 0xf1, 0xe0, 0xe0, 0x20, 0x00, 0xe0, 0x47, 0xdf, 0xd8,
0xe6, 0x6a, 0x74, 0x92, 0xe0, 0xc8, 0xb9, 0xd8, 0x63, 0x56, 0xc5, 0x74,
0x51, 0x02, 0x89, 0x80, 0x38, 0x60, 0x13, 0x85, 0x27, 0x9c, 0x87, 0x07,
0xbc, 0x20, 0x44, 0xa9, 0x1a, 0x55, 0xef, 0xc8, 0xa5, 0xd8, 0xb7, 0x57,
0x35, 0x3a, 0xd6, 0xff, 0xf0, 0xa9, 0xcd, 0xe2, 0xfc, 0xfc, 0x3c, 0x86,
0x86, 0x86, 0xa0, 0xaa, 0x6a, 0x31, 0x91, 0x48, 0x48, 0x4b, 0x01, 0xf0,
0xb5, 0x83, 0xe7, 0x9e, 0x7b, 0xee, 0x7c, 0x32, 0x99, 0x7c, 0xd4, 0x30,
0x8c, 0xd5, 0xa1, 0x50, 0x08, 0x4f, 0xec, 0x68, 0x97, 0x62, 0xc9, 0x59,
0xcf, 0x47, 0xe7, 0x93, 0x0f, 0x68, 0x9a, 0x21, 0x81, 0xc1, 0x14, 0xeb,
0x04, 0xd3, 0xaa, 0x5a, 0x72, 0x66, 0xae, 0x78, 0xf7, 0x54, 0x32, 0xd3,
0x9d, 0x98, 0xce, 0x7c, 0x77, 0xcf, 0x96, 0xd6, 0x96, 0x57, 0xbf, 0xb5,
0x5d, 0x98, 0x9f, 0xcb, 0xa1, 0xae, 0xae, 0x0e, 0x5e, 0xaf, 0x17, 0xd5,
0x6a, 0xb5, 0x39, 0x1a, 0x8d, 0xee, 0x0a, 0x06, 0x83, 0xef, 0xc7, 0x62,
0x31, 0x6d, 0x31, 0x80, 0x7f, 0xbb, 0x8e, 0xfb, 0xfa, 0xfa, 0x02, 0x82,
0x20, 0x7c, 0xb4, 0x61, 0xc3, 0x86, 0x35, 0x5b, 0xb7, 0x6e, 0x85, 0xcf,
0xe7, 0xc3, 0xf8, 0x54, 0x16, 0xef, 0x0c, 0x5e, 0xb6, 0x87, 0xc7, 0xb2,
0x56, 0xae, 0x54, 0x15, 0x00, 0x46, 0x1a, 0x3d, 0x0e, 0x7b, 0xc7, 0xa6,
0x16, 0xe1, 0xa9, 0x9d, 0xf7, 0x92, 0x46, 0x05, 0xc8, 0xe5, 0x72, 0x70,
0x38, 0x1c, 0x88, 0xc7, 0xe3, 0x38, 0x77, 0xee, 0x1c, 0xfc, 0x7e, 0x3f,
0x54, 0x55, 0xc5, 0x89, 0x13, 0x27, 0x26, 0x01, 0xf4, 0xf6, 0xf7, 0xf7,
0x5f, 0xba, 0x23, 0x00, 0x00, 0x38, 0x72, 0xe4, 0x48, 0x23, 0xa5, 0xf4,
0x78, 0x73, 0x73, 0xf3, 0xce, 0xce, 0xce, 0x4e, 0x34, 0x35, 0x35, 0x41,
0x51, 0x14, 0x88, 0xa2, 0x08, 0x9e, 0xe7, 0x61, 0xdb, 0x36, 0x2c, 0xcb,
0x42, 0xb9, 0x5c, 0x86, 0xa6, 0x69, 0x48, 0xa7, 0xd3, 0x38, 0x7d, 0xfa,
0x34, 0x76, 0xef, 0xde, 0x8d, 0x44, 0x22, 0x81, 0x6a, 0xb5, 0x8a, 0x54,
0x2a, 0x05, 0x9f, 0xcf, 0x07, 0xc6, 0x18, 0xde, 0x7d, 0xf7, 0xdd, 0x42,
0xa5, 0x52, 0x79, 0xe6, 0x83, 0x0f, 0x3e, 0x38, 0xf9, 0xb9, 0x25, 0x58,
0x90, 0x93, 0x27, 0x4f, 0x96, 0x1f, 0x7e, 0xf8, 0xe1, 0x63, 0xba, 0xae,
0x4f, 0xc5, 0xe3, 0xf1, 0xae, 0x4c, 0x26, 0xe3, 0x2d, 0x95, 0x4a, 0x50,
0x55, 0x15, 0xc5, 0x62, 0x11, 0xf9, 0x7c, 0x1e, 0xe9, 0x74, 0x1a, 0xf1,
0x78, 0x1c, 0x23, 0x23, 0x23, 0x18, 0x1e, 0x1e, 0xbe, 0x90, 0xcd, 0x66,
0xa7, 0x35, 0x4d, 0x5b, 0xd9, 0xd2, 0xd2, 0x02, 0xc3, 0x30, 0xe0, 0xf5,
0x7a, 0x91, 0xcd, 0x66, 0x21, 0x8a, 0x22, 0x3a, 0x3b, 0x3b, 0x1d, 0xc9,
0x64, 0xf2, 0xd9, 0x60, 0x30, 0x98, 0x89, 0xc5, 0x62, 0x1f, 0x2f, 0x99,
0x81, 0x5a, 0x89, 0x44, 0x22, 0x82, 0x2c, 0xcb, 0xdd, 0x00, 0xbe, 0x0c,
0xe0, 0x01, 0xc6, 0xd8, 0x8a, 0x1b, 0x7e, 0x33, 0x94, 0xd2, 0xc1, 0x52,
0xa9, 0xf4, 0x7e, 0x5f, 0x5f, 0xdf, 0xc0, 0xd3, 0x4f, 0x3f, 0x2d, 0x02,
0xf8, 0x7d, 0x47, 0x47, 0xc7, 0x53, 0xe1, 0x70, 0x18, 0xe5, 0xf2, 0xf5,
0x7f, 0x91, 0x54, 0x2a, 0x05, 0x49, 0x92, 0x20, 0xcb, 0x32, 0x4e, 0x9d,
0x3a, 0x85, 0x64, 0x32, 0xf9, 0xba, 0xdb, 0xed, 0x7e, 0xe1, 0xf8, 0xf1,
0xe3, 0xf6, 0x1d, 0x01, 0xdc, 0x02, 0xbb, 0xa0, 0x8b, 0xfa, 0xee, 0xd9,
0xb3, 0xe7, 0x27, 0x6b, 0xd7, 0xae, 0x3d, 0xb4, 0x6f, 0xdf, 0x3e, 0x18,
0x86, 0x01, 0xc3, 0x30, 0x50, 0x28, 0x14, 0x60, 0xdb, 0x36, 0x3c, 0x1e,
0x0f, 0x3e, 0xfd, 0xf4, 0x53, 0x5c, 0xb8, 0x70, 0xe1, 0x7d, 0x5d, 0xd7,
0x9f, 0x19, 0x18, 0x18, 0xd0, 0x6f, 0x5b, 0x02, 0x5c, 0x6f, 0x4f, 0x1e,
0xd7, 0x0f, 0x2a, 0x01, 0x80, 0x74, 0x1b, 0x15, 0x6f, 0x37, 0x17, 0x8b,
0xc5, 0x4e, 0xbb, 0xdd, 0xee, 0xa9, 0x44, 0x22, 0xd1, 0xb3, 0x71, 0xe3,
0x46, 0x5e, 0x14, 0x45, 0x10, 0x42, 0x40, 0x08, 0x41, 0x7d, 0x7d, 0x3d,
0x7a, 0x7b, 0x7b, 0x71, 0xed, 0xda, 0xb5, 0x75, 0xd9, 0x6c, 0x56, 0x88,
0x46, 0xa3, 0x7f, 0xad, 0xdd, 0x05, 0xb9, 0x11, 0x94, 0xab, 0x01, 0x58,
0xb0, 0xb9, 0x63, 0xc7, 0x8e, 0xad, 0xda, 0xb4, 0x69, 0x53, 0x9b, 0xd7,
0xeb, 0x5d, 0xed, 0x74, 0x3a, 0x9b, 0x08, 0x21, 0xb2, 0x6d, 0xdb, 0x86,
0xae, 0xeb, 0xd9, 0xb9, 0xb9, 0xb9, 0xe4, 0xe8, 0xe8, 0x68, 0xfc, 0xc0,
0x81, 0x03, 0x71, 0x00, 0x0c, 0x00, 0x0d, 0x87, 0xc3, 0xdb, 0x02, 0x81,
0xc0, 0xef, 0xf6, 0xef, 0xdf, 0xef, 0x55, 0x14, 0x05, 0x94, 0x52, 0x74,
0x74, 0x74, 0x40, 0x92, 0x24, 0xcc, 0xcc, 0xcc, 0xe0, 0x95, 0x57, 0x5e,
0xb9, 0xda, 0xdf, 0xdf, 0xdf, 0xca, 0xdd, 0x12, 0x7c, 0x41, 0x85, 0x1a,
0x15, 0xbb, 0xbb, 0xbb, 0xdd, 0x2d, 0x2d, 0x2d, 0xad, 0x6e, 0xb7, 0x7b,
0x9d, 0xcb, 0xe5, 0xba, 0xcf, 0xe5, 0x72, 0xed, 0xa8, 0xaf, 0xaf, 0xdf,
0xeb, 0xf1, 0x78, 0x1e, 0x55, 0x14, 0x65, 0x8b, 0xa2, 0x28, 0x6b, 0x75,
0x5d, 0xf7, 0x06, 0x02, 0x01, 0x17, 0x80, 0x3a, 0x00, 0x75, 0x67, 0xcf,
0x9e, 0xfd, 0xe7, 0xe4, 0xe4, 0xe4, 0xde, 0xb7, 0xdf, 0x7e, 0xfb, 0x4a,
0x36, 0x9b, 0x45, 0x28, 0x14, 0x82, 0x20, 0x08, 0x10, 0x04, 0x01, 0x85,
0x42, 0x01, 0x00, 0x2c, 0x00, 0xdc, 0x42, 0x06, 0x6a, 0x77, 0xcd, 0x2f,
0x62, 0x73, 0x4e, 0xa7, 0x53, 0xe8, 0xec, 0xec, 0x74, 0x04, 0x83, 0x41,
0x67, 0x5d, 0x5d, 0x9d, 0x98, 0xc9, 0x64, 0xec, 0xc9, 0xc9, 0x49, 0x33,
0x1a, 0x8d, 0x1a, 0xb8, 0x7e, 0xf5, 0x2e, 0xa8, 0xbd, 0xf0, 0xbc, 0xe7,
0x9e, 0x7b, 0x3c, 0x6d, 0x6d, 0x6d, 0xbf, 0xea, 0xe9, 0xe9, 0x79, 0xa4,
0xa7, 0xa7, 0x07, 0xb9, 0x5c, 0x0e, 0x6f, 0xbd, 0xf5, 0x16, 0xb2, 0xd9,
0xec, 0xcb, 0x1f, 0x7e, 0xf8, 0x61, 0xdf, 0x62, 0x25, 0x58, 0xb4, 0x14,
0x37, 0xd6, 0x2d, 0x3c, 0x6b, 0xfd, 0x59, 0x8d, 0xd6, 0xc2, 0x50, 0xb7,
0xdb, 0xcd, 0x6f, 0xdb, 0xb6, 0xed, 0xfb, 0x82, 0x20, 0x3c, 0xcb, 0x18,
0xb3, 0x00, 0xfc, 0x3a, 0x1c, 0x0e, 0xbf, 0x11, 0x89, 0x44, 0xe8, 0x62,
0x5d, 0x50, 0x1b, 0x8c, 0xc7, 0xe2, 0x81, 0x6f, 0x05, 0xb8, 0x1d, 0xc8,
0x42, 0x36, 0x16, 0x94, 0xd5, 0xf8, 0x2c, 0xbb, 0x0d, 0x6f, 0xf5, 0x59,
0xb0, 0x6b, 0x5f, 0xca, 0x6e, 0x33, 0xf7, 0xff, 0x2b, 0xff, 0x02, 0x4d,
0x1a, 0xf6, 0x7a, 0xb1, 0x86, 0x40, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x49,
0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif
|
dennis/bzlauncher
|
src/stop22.h
|
<gh_stars>1-10
#ifndef STOP22_PNG_H
#define STOP22_PNG_H
static const unsigned char stop22_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16,
0x08, 0x06, 0x00, 0x00, 0x00, 0xc4, 0xb4, 0x6c, 0x3b, 0x00, 0x00, 0x00,
0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9,
0x43, 0xbb, 0x7f, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00,
0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18,
0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xd5, 0x0a, 0x11,
0x17, 0x2b, 0x00, 0x43, 0x2b, 0x47, 0xfb, 0x00, 0x00, 0x04, 0x85, 0x49,
0x44, 0x41, 0x54, 0x38, 0xcb, 0x8d, 0x95, 0x5b, 0x68, 0x54, 0x47, 0x18,
0xc7, 0x7f, 0x73, 0xce, 0x6e, 0xf6, 0x92, 0x6c, 0xe2, 0x0d, 0xb5, 0xb5,
0x6a, 0x48, 0x5b, 0x4d, 0x0d, 0x16, 0xdc, 0x66, 0xc5, 0x18, 0x0d, 0x16,
0x95, 0x52, 0x0a, 0x81, 0xbe, 0x44, 0xc4, 0x06, 0x94, 0xb6, 0xd8, 0x42,
0x29, 0xb6, 0x54, 0x8b, 0xd1, 0x07, 0x95, 0xc4, 0x7a, 0x81, 0xfa, 0xd0,
0x87, 0x42, 0xfb, 0x16, 0xa1, 0x50, 0x41, 0x10, 0xa9, 0xad, 0xb6, 0x09,
0xa5, 0x28, 0xda, 0x82, 0xa6, 0x18, 0x73, 0xd1, 0xb4, 0x49, 0x9b, 0xdb,
0xba, 0xbb, 0x49, 0xdc, 0xdd, 0xec, 0xd9, 0xeb, 0x39, 0x73, 0xa6, 0x0f,
0xbb, 0xae, 0xc6, 0x44, 0xe9, 0xc0, 0xc7, 0x3c, 0xcc, 0xcc, 0x6f, 0xbe,
0xf9, 0x2e, 0xff, 0x11, 0x3c, 0x63, 0x1c, 0x87, 0x25, 0x80, 0x78, 0xc6,
0x96, 0x48, 0x0b, 0xd8, 0x73, 0x2d, 0x3c, 0xf5, 0xd0, 0x49, 0xf8, 0x42,
0xc1, 0xa7, 0x02, 0xe4, 0x5c, 0xeb, 0x0a, 0x34, 0x01, 0xe7, 0x25, 0xbc,
0xd3, 0x02, 0xea, 0x7f, 0x81, 0x4f, 0xc2, 0xe9, 0xea, 0x86, 0x86, 0x8f,
0xb6, 0x36, 0x35, 0xb9, 0x75, 0x97, 0x0b, 0x94, 0x2a, 0x9a, 0xb2, 0x6d,
0xb0, 0x2c, 0xac, 0x54, 0x8a, 0x9f, 0xdb, 0xdb, 0x33, 0x83, 0x7d, 0x7d,
0xdf, 0x4b, 0xd8, 0xf3, 0x24, 0x7c, 0x16, 0xf8, 0x04, 0x9c, 0xa9, 0xae,
0xaf, 0xff, 0x60, 0xdb, 0xce, 0x9d, 0xee, 0x78, 0x5f, 0x1f, 0xa9, 0xf1,
0x71, 0xb0, 0x6d, 0xb0, 0xed, 0x3c, 0x54, 0x4a, 0x94, 0x94, 0xb8, 0x17,
0x2d, 0x62, 0xfe, 0x9a, 0x35, 0x5c, 0x39, 0x77, 0x2e, 0x33, 0xd4, 0xdb,
0xfb, 0xdd, 0xe7, 0xf0, 0xee, 0xe3, 0x1c, 0xfd, 0x09, 0xe8, 0x57, 0xd5,
0x75, 0x75, 0xef, 0x6f, 0xdb, 0xb5, 0xcb, 0x13, 0xef, 0xeb, 0x23, 0x1d,
0x0a, 0x21, 0x44, 0xe1, 0x6e, 0xa5, 0x1e, 0xcd, 0x4a, 0x61, 0x19, 0x06,
0x96, 0x61, 0x50, 0x53, 0x5f, 0xef, 0x88, 0xc6, 0xe3, 0xd5, 0xaf, 0x85,
0xc3, 0xcb, 0x3b, 0xe0, 0x87, 0x59, 0xe0, 0x13, 0xf0, 0xf5, 0xea, 0x40,
0x60, 0xcf, 0xf6, 0xe6, 0x66, 0x4f, 0xac, 0xa7, 0x87, 0x74, 0x24, 0x42,
0xcc, 0xe3, 0x41, 0x2a, 0x85, 0xcb, 0xb6, 0x67, 0x84, 0xc3, 0x10, 0x82,
0xe9, 0x92, 0x12, 0x1c, 0xb1, 0x18, 0x66, 0x32, 0xc9, 0x9a, 0xf5, 0xeb,
0x9d, 0x53, 0xb1, 0x58, 0x4d, 0xed, 0xc4, 0xc4, 0xd2, 0x0e, 0xf8, 0xa9,
0x08, 0x3e, 0x01, 0xdf, 0xae, 0xf6, 0xfb, 0x9b, 0xb7, 0xef, 0xde, 0xed,
0x89, 0xde, 0xbe, 0x4d, 0x3a, 0x12, 0x21, 0xea, 0x76, 0x23, 0xaa, 0xaa,
0xc8, 0x98, 0x26, 0x76, 0x36, 0x5b, 0x84, 0x27, 0x84, 0x20, 0xe1, 0xf3,
0xe1, 0x5d, 0xbb, 0x96, 0x78, 0x38, 0x8c, 0x23, 0x16, 0xc3, 0x4a, 0xa5,
0x78, 0xc5, 0xef, 0x77, 0x46, 0x13, 0x89, 0xb5, 0xb5, 0x13, 0x13, 0x0b,
0x3b, 0xe0, 0x8a, 0x06, 0x20, 0x1c, 0x8e, 0xf7, 0xb6, 0x37, 0x37, 0x7b,
0xa2, 0x5d, 0x5d, 0x64, 0x42, 0x21, 0x72, 0x4a, 0x91, 0xb5, 0x2c, 0x16,
0xec, 0xd8, 0xc1, 0xd2, 0x7d, 0xfb, 0x48, 0xf9, 0x7c, 0x4c, 0x0b, 0x81,
0xa1, 0x69, 0x18, 0x65, 0x65, 0xac, 0x6a, 0x6d, 0x65, 0xc5, 0xde, 0xbd,
0x98, 0x42, 0x90, 0x56, 0x0a, 0x23, 0x12, 0xe1, 0xc1, 0xe0, 0x20, 0x5b,
0xb7, 0x6c, 0xf1, 0x68, 0x1e, 0xcf, 0x27, 0x00, 0x1a, 0x80, 0xae, 0xeb,
0x68, 0x42, 0x90, 0xbe, 0x7f, 0x1f, 0x0a, 0x4f, 0xf7, 0x5a, 0x16, 0xa1,
0x33, 0x67, 0x10, 0x42, 0xb0, 0xec, 0xc0, 0x01, 0x52, 0xe5, 0xe5, 0x18,
0xa5, 0xa5, 0xbc, 0xdc, 0xda, 0x8a, 0xb3, 0xb4, 0x94, 0xbf, 0x0e, 0x1d,
0xc2, 0x6d, 0x9a, 0xb8, 0x00, 0xa5, 0x14, 0x46, 0x38, 0x8c, 0xae, 0x69,
0xa8, 0x42, 0x2e, 0x1c, 0xc5, 0xba, 0x54, 0x2a, 0x9f, 0x79, 0x21, 0x40,
0x29, 0x2a, 0x6c, 0x9b, 0xf8, 0xd4, 0x14, 0xc1, 0xd3, 0xa7, 0x59, 0x71,
0xf0, 0x20, 0x2f, 0x1e, 0x3f, 0x8e, 0xae, 0x69, 0x68, 0x4a, 0x31, 0x70,
0xf8, 0x30, 0x04, 0x83, 0xf8, 0x72, 0x39, 0x94, 0x52, 0x28, 0xa5, 0xb0,
0x95, 0x02, 0x29, 0x8b, 0x49, 0xd6, 0x1e, 0x55, 0xbc, 0x2a, 0x96, 0xd3,
0xc3, 0x92, 0x2a, 0xcf, 0xe5, 0x60, 0x72, 0x92, 0xa9, 0x0b, 0x17, 0x70,
0x7a, 0x3c, 0x38, 0xbd, 0x5e, 0x22, 0x17, 0x2f, 0x62, 0x8d, 0x8d, 0x15,
0xa1, 0xb6, 0x6d, 0x63, 0x3f, 0x84, 0xcb, 0x47, 0xbd, 0xe4, 0x78, 0x1c,
0x8c, 0x6d, 0xe7, 0x3d, 0xd7, 0xf2, 0xf7, 0x25, 0x74, 0x1d, 0xe9, 0x76,
0xb3, 0xb8, 0xb1, 0x11, 0x4d, 0x08, 0x34, 0xe0, 0xb9, 0xc6, 0x46, 0xe2,
0xb7, 0x6e, 0x61, 0x49, 0x89, 0xea, 0xee, 0x46, 0x9a, 0x26, 0xb6, 0x69,
0xa2, 0x34, 0x0d, 0x4a, 0x4a, 0xf2, 0xce, 0xcd, 0xf2, 0x58, 0xca, 0x7c,
0x33, 0x48, 0x49, 0x02, 0x30, 0x3c, 0x1e, 0x5e, 0x3a, 0x76, 0x0c, 0x67,
0x59, 0x19, 0xff, 0x9c, 0x3a, 0x45, 0xdf, 0xfe, 0xfd, 0x68, 0x42, 0x50,
0x73, 0xf4, 0x28, 0x53, 0xe3, 0xe3, 0xc4, 0xa5, 0x24, 0xd9, 0xd3, 0x43,
0xf2, 0xde, 0x3d, 0x8c, 0xfe, 0x7e, 0xe4, 0xf0, 0x30, 0xb6, 0x69, 0xce,
0x04, 0x3f, 0x84, 0x2a, 0x29, 0xc9, 0x48, 0x49, 0x72, 0xde, 0x3c, 0x56,
0xb5, 0xb5, 0xa1, 0x7b, 0xbd, 0xfc, 0xdd, 0xd6, 0x46, 0xa6, 0xab, 0x8b,
0xe8, 0xd9, 0xb3, 0xf4, 0x1f, 0x39, 0x82, 0xd3, 0xe5, 0x62, 0x63, 0x7b,
0x3b, 0x19, 0x97, 0x8b, 0x14, 0x79, 0x15, 0x72, 0x2c, 0x5e, 0x8c, 0xf2,
0xf9, 0x66, 0x86, 0x42, 0x4a, 0x89, 0x39, 0x38, 0x88, 0x98, 0x9a, 0x22,
0x15, 0x0c, 0x62, 0x99, 0x26, 0x6c, 0xda, 0x44, 0xe2, 0xe6, 0x4d, 0xee,
0x5f, 0xba, 0x44, 0xee, 0xfa, 0x75, 0x4a, 0x47, 0x47, 0x29, 0x07, 0x12,
0x97, 0x2f, 0xd3, 0xad, 0x69, 0xbc, 0xd0, 0xd4, 0x84, 0xab, 0xa2, 0x02,
0x2b, 0x2f, 0x48, 0xe8, 0x2e, 0x17, 0x62, 0xe9, 0xd2, 0x99, 0x2d, 0xbd,
0xcd, 0xb6, 0xad, 0xb1, 0xe1, 0xe1, 0xba, 0x75, 0x0d, 0x0d, 0xce, 0x5c,
0x24, 0x42, 0x6e, 0x62, 0x02, 0x67, 0x22, 0xc1, 0x83, 0x70, 0x18, 0x35,
0x32, 0x82, 0x67, 0x60, 0x00, 0xbb, 0x00, 0xd0, 0xa6, 0xa7, 0x89, 0xde,
0xb9, 0x43, 0x2e, 0x99, 0xc4, 0x15, 0x8d, 0x92, 0x1b, 0x19, 0xc1, 0xb3,
0x72, 0x25, 0x55, 0x81, 0x00, 0x3d, 0x37, 0x6e, 0x98, 0xa1, 0xc9, 0xc9,
0xdb, 0x1d, 0xf0, 0x8d, 0x0e, 0xd0, 0x01, 0x57, 0xeb, 0x52, 0x29, 0x35,
0x3a, 0x36, 0xb6, 0x71, 0xdd, 0xe6, 0xcd, 0xce, 0x9c, 0x61, 0x90, 0x09,
0x06, 0xd1, 0x86, 0x86, 0xd0, 0x43, 0xa1, 0x22, 0xd4, 0x2e, 0x98, 0x53,
0x4a, 0x72, 0xbd, 0xbd, 0x64, 0x47, 0x46, 0x28, 0xad, 0xac, 0xa4, 0x32,
0x10, 0xe0, 0x4e, 0x6f, 0xaf, 0xf9, 0xe7, 0xdd, 0xbb, 0x7f, 0xd8, 0xf0,
0x7a, 0x27, 0x58, 0x45, 0xad, 0xe8, 0x80, 0xab, 0x1b, 0xd3, 0x69, 0x39,
0x3a, 0x3e, 0x5e, 0xef, 0xaf, 0xaf, 0x77, 0xe6, 0x92, 0x49, 0xb2, 0xf1,
0x78, 0x11, 0xa6, 0xe6, 0x98, 0xcb, 0x2a, 0x2b, 0x59, 0x59, 0x5b, 0xcb,
0xef, 0x9d, 0x9d, 0xd9, 0xfe, 0xb1, 0xb1, 0x5f, 0x6d, 0x78, 0xb3, 0x05,
0xb2, 0xb3, 0xd4, 0xad, 0x03, 0xae, 0xd5, 0x65, 0x32, 0xe6, 0x68, 0x30,
0xb8, 0xc9, 0x1f, 0x08, 0x38, 0x73, 0x99, 0x0c, 0xd9, 0x74, 0x1a, 0x74,
0x1d, 0xa5, 0xeb, 0xa0, 0x69, 0xa8, 0x82, 0x95, 0x57, 0x55, 0xb1, 0xdc,
0xef, 0xe7, 0xda, 0x2f, 0xbf, 0x64, 0x86, 0x62, 0xb1, 0x1f, 0x6d, 0x78,
0xbb, 0x05, 0xac, 0xa7, 0xe9, 0xb1, 0x13, 0x58, 0xf2, 0x31, 0x7c, 0x56,
0xe3, 0xf3, 0x7d, 0xf8, 0xd6, 0x86, 0x0d, 0x25, 0xce, 0xf9, 0xf3, 0x11,
0x65, 0x65, 0xf9, 0xe2, 0x2f, 0x68, 0xb2, 0x92, 0x12, 0xe5, 0xf5, 0xd2,
0x79, 0xfe, 0xbc, 0xd9, 0x1d, 0x8f, 0xff, 0xf6, 0x25, 0x1c, 0xb2, 0x21,
0x02, 0x84, 0x81, 0xf4, 0x93, 0xe0, 0x52, 0x60, 0x39, 0xf0, 0x3c, 0xb0,
0xac, 0x09, 0x76, 0xbc, 0x0a, 0x6f, 0x00, 0x42, 0xe5, 0xf7, 0x09, 0x05,
0x42, 0xe4, 0xa3, 0xa0, 0x04, 0xa8, 0x01, 0xe8, 0x6f, 0x87, 0x73, 0xc0,
0x38, 0x10, 0x04, 0xfe, 0x05, 0x06, 0x01, 0x53, 0xcc, 0xf1, 0x55, 0x79,
0x01, 0x1f, 0x50, 0x01, 0x2c, 0x04, 0x16, 0x00, 0x8b, 0x80, 0x79, 0x85,
0x17, 0x19, 0x40, 0x1c, 0x78, 0x50, 0xb0, 0x28, 0x30, 0x0d, 0xc4, 0x28,
0xc4, 0x17, 0xe0, 0x3f, 0x98, 0x97, 0x64, 0xf0, 0xa2, 0x79, 0x08, 0xf3,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif
|
dennis/bzlauncher
|
src/bzflag32.h
|
#ifndef BZFLAG32_PNG_H
#define BZFLAG32_PNG_H
static const unsigned char bzflag32_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a, 0xf4, 0x00, 0x00, 0x08,
0x6f, 0x49, 0x44, 0x41, 0x54, 0x58, 0x85, 0xb5, 0x97, 0x6b, 0x8c, 0x5d,
0x55, 0x15, 0xc7, 0x7f, 0x7b, 0xef, 0xf3, 0xb8, 0xe7, 0xce, 0x4c, 0x67,
0x3a, 0xd3, 0x99, 0x4e, 0xa7, 0xd8, 0x61, 0xa4, 0x3c, 0x06, 0x82, 0xf2,
0x2a, 0x20, 0xe0, 0x83, 0x42, 0x20, 0xb1, 0xd1, 0xd4, 0x40, 0x05, 0xbe,
0x68, 0x42, 0x0d, 0x6a, 0x7c, 0x80, 0x98, 0xa8, 0x25, 0x34, 0x31, 0x06,
0x89, 0x89, 0x02, 0x7e, 0x30, 0x50, 0x8d, 0x09, 0x11, 0x12, 0x84, 0x80,
0x10, 0xac, 0x50, 0x45, 0xe7, 0x03, 0x60, 0x29, 0x05, 0x2c, 0x16, 0x3a,
0x85, 0x76, 0x68, 0x87, 0x69, 0xa7, 0x9d, 0x17, 0x9d, 0xfb, 0x38, 0xf7,
0x9c, 0x7b, 0xde, 0xdb, 0x0f, 0xe7, 0xce, 0x9d, 0x3b, 0x6d, 0x63, 0xf8,
0xc2, 0x4a, 0x4e, 0xee, 0x3d, 0x8f, 0xb5, 0xd6, 0x7f, 0xff, 0xd6, 0xda,
0xfb, 0xec, 0x03, 0x4b, 0xad, 0x17, 0x98, 0x00, 0xf4, 0x27, 0x74, 0xec,
0x03, 0x8a, 0xad, 0x09, 0x45, 0xcb, 0xff, 0x2e, 0xc3, 0x30, 0xfe, 0xfa,
0xd0, 0x83, 0x0f, 0x7e, 0xfe, 0xc2, 0x0b, 0x2f, 0x24, 0x8e, 0x63, 0xfe,
0xaf, 0x09, 0x81, 0x10, 0xb9, 0xbb, 0xd6, 0x1a, 0xb4, 0x6e, 0x5e, 0x3f,
0x9d, 0x99, 0xa6, 0xc9, 0xae, 0x5d, 0xbb, 0xd8, 0xb2, 0x65, 0xcb, 0x0b,
0xc0, 0xcd, 0x40, 0xd0, 0x7a, 0xbf, 0x4b, 0x29, 0xf5, 0xea, 0x53, 0x4f,
0x3e, 0xa9, 0x3f, 0xb6, 0x65, 0x99, 0xf6, 0x3c, 0x4f, 0x7b, 0x9e, 0xf7,
0xf1, 0x7d, 0xb4, 0xd6, 0xdb, 0xb6, 0x6d, 0xd3, 0xc0, 0xdf, 0x00, 0x7b,
0x21, 0xf9, 0x0a, 0xc3, 0x30, 0x5e, 0x59, 0x48, 0x9e, 0x25, 0xa9, 0xce,
0x92, 0xf4, 0x54, 0xcf, 0x24, 0x5d, 0x3c, 0xb4, 0xd6, 0x87, 0x0f, 0x1d,
0xd2, 0x23, 0x23, 0x23, 0x7a, 0x64, 0x64, 0x44, 0x1f, 0x3d, 0x72, 0xa4,
0x29, 0xaa, 0x79, 0x9c, 0x46, 0xf0, 0xc2, 0xf5, 0xdf, 0x6f, 0xdb, 0xa6,
0x05, 0x6c, 0x07, 0x8a, 0x0a, 0x78, 0xef, 0xb7, 0x0f, 0x3d, 0xf4, 0x99,
0xdb, 0x37, 0x6f, 0x46, 0x27, 0x09, 0xa0, 0x11, 0x42, 0x70, 0xe2, 0xc4,
0x47, 0x94, 0x4b, 0x25, 0xdc, 0x6a, 0x95, 0x2c, 0x4d, 0x29, 0xd8, 0x05,
0xb4, 0xce, 0x10, 0x68, 0x10, 0x82, 0xd9, 0x99, 0x19, 0xa6, 0x66, 0x66,
0x88, 0xe3, 0x98, 0x9e, 0xee, 0x6e, 0x96, 0x77, 0x77, 0x43, 0x9a, 0xe6,
0xa5, 0x90, 0x92, 0x4a, 0xb9, 0x4c, 0x69, 0x7e, 0x9e, 0x9a, 0xeb, 0x12,
0xc7, 0x31, 0x8e, 0xe3, 0x40, 0x96, 0x97, 0xea, 0xd2, 0x75, 0xeb, 0xb0,
0x6d, 0xfb, 0x9c, 0x91, 0x91, 0x91, 0x8d, 0x06, 0xb0, 0xe6, 0x82, 0xe1,
0x61, 0x00, 0xb2, 0x34, 0x45, 0x29, 0xc5, 0xe1, 0xc3, 0x87, 0x78, 0x73,
0xcf, 0x1e, 0xd2, 0x34, 0x05, 0xc0, 0xb2, 0x2c, 0xbe, 0x78, 0xcd, 0x35,
0xf4, 0xf6, 0xf4, 0xa0, 0xb5, 0x46, 0x08, 0x49, 0x10, 0x04, 0xb8, 0xd5,
0x2a, 0x00, 0x51, 0x18, 0x82, 0xd6, 0xf9, 0x3d, 0xa9, 0x98, 0x99, 0x9e,
0xe6, 0xd5, 0x9d, 0x3b, 0x89, 0xa2, 0x08, 0x00, 0xa5, 0x14, 0x57, 0xae,
0x5b, 0xc7, 0xe0, 0xd0, 0x10, 0x3a, 0x49, 0x10, 0x4a, 0xf2, 0xb9, 0x2b,
0xae, 0x00, 0xb8, 0xc0, 0x00, 0x88, 0xc3, 0x10, 0xd2, 0x0c, 0x9d, 0xa6,
0x20, 0x04, 0xe3, 0x1f, 0x7e, 0xc8, 0xfc, 0xfc, 0x3c, 0x86, 0x61, 0x00,
0x50, 0xa9, 0x54, 0x98, 0x9e, 0x9a, 0xa2, 0xb7, 0xbb, 0x1b, 0x92, 0x04,
0x84, 0x20, 0x0c, 0x02, 0xaa, 0xae, 0x0b, 0x40, 0x18, 0x04, 0xf9, 0xf5,
0x24, 0x01, 0x53, 0x70, 0x7c, 0x72, 0x92, 0xd9, 0xb9, 0x39, 0xcc, 0x86,
0x7f, 0x92, 0x24, 0x1c, 0x99, 0x9c, 0x64, 0x70, 0xf0, 0x4c, 0xc8, 0xb2,
0x5c, 0x74, 0x90, 0xf7, 0x60, 0xfe, 0x44, 0x9a, 0x42, 0x14, 0xa2, 0xa3,
0x08, 0xb2, 0x8c, 0xb0, 0x5e, 0xc7, 0x75, 0xdd, 0xa6, 0x80, 0x24, 0x49,
0x48, 0xc2, 0x10, 0xe2, 0x98, 0x2c, 0x49, 0x50, 0x40, 0xe0, 0xfb, 0x4d,
0x02, 0x61, 0xbd, 0x0e, 0x59, 0xd6, 0x24, 0x18, 0x85, 0x21, 0xb5, 0x93,
0xfc, 0xa3, 0x20, 0x80, 0x2c, 0xcd, 0x9f, 0xd1, 0x1a, 0xdd, 0x10, 0x62,
0x00, 0xa4, 0x71, 0x0c, 0x51, 0x44, 0x1a, 0x45, 0xa8, 0x34, 0xc3, 0xaf,
0xd5, 0xa8, 0x56, 0xab, 0xcd, 0x00, 0x51, 0x14, 0x51, 0xf7, 0x3c, 0x88,
0x63, 0x74, 0x63, 0x7a, 0x06, 0xbe, 0x4f, 0xb9, 0x55, 0x40, 0x1c, 0xe7,
0x3d, 0x24, 0x04, 0x75, 0xdf, 0xa7, 0x5c, 0x2e, 0x63, 0x59, 0x56, 0xee,
0x9f, 0x24, 0xd4, 0x3d, 0xbf, 0x41, 0x29, 0x85, 0x38, 0x6e, 0x92, 0x30,
0x00, 0x74, 0x18, 0xa2, 0xeb, 0x01, 0x3a, 0x0c, 0xc9, 0x4c, 0x93, 0xba,
0xe7, 0x51, 0xad, 0x56, 0x31, 0x4d, 0x93, 0x2c, 0xcb, 0x40, 0x08, 0x3a,
0x2c, 0x0b, 0x1d, 0xc7, 0xa8, 0x34, 0x83, 0x38, 0x59, 0x4a, 0xc0, 0xcf,
0x83, 0x1b, 0x69, 0x06, 0x32, 0xa3, 0xa3, 0x50, 0xc0, 0xf7, 0x7d, 0xea,
0xf5, 0x3a, 0x52, 0x08, 0xa2, 0x24, 0x21, 0xf0, 0x3d, 0x88, 0x93, 0x7c,
0x00, 0x4a, 0x92, 0x25, 0x49, 0x0b, 0x81, 0x30, 0x22, 0xad, 0xfb, 0x24,
0x61, 0x88, 0x8a, 0xcd, 0x9c, 0x80, 0xeb, 0x62, 0x28, 0x85, 0x94, 0x92,
0x6f, 0x7c, 0x79, 0x03, 0xfd, 0xed, 0x1d, 0xec, 0xdd, 0xbb, 0x17, 0x01,
0x0c, 0xae, 0x5e, 0x4d, 0xe4, 0xf9, 0x54, 0x17, 0x9a, 0x30, 0x08, 0x28,
0xcf, 0xce, 0x71, 0x64, 0x7a, 0x0a, 0x80, 0xa1, 0xfe, 0x55, 0x7c, 0x75,
0xfd, 0x7a, 0x9e, 0xd8, 0xbe, 0x1d, 0xb4, 0x26, 0x4e, 0x12, 0xea, 0xbe,
0x9f, 0x53, 0x8a, 0x22, 0x90, 0x22, 0xa7, 0xb1, 0x20, 0x20, 0xab, 0xd7,
0x49, 0x5c, 0x97, 0x2c, 0x8a, 0xc9, 0x0c, 0x83, 0xba, 0xeb, 0xe2, 0x36,
0x1a, 0xec, 0x96, 0x6b, 0xd7, 0xb3, 0xa6, 0xab, 0x8b, 0x9f, 0x3f, 0xf2,
0x30, 0xb3, 0xa5, 0x12, 0x49, 0x9a, 0xf2, 0x9d, 0x9b, 0x6e, 0x22, 0x89,
0xc2, 0xe6, 0x33, 0x3a, 0x0c, 0xd9, 0xf5, 0xd6, 0x9b, 0xfc, 0xe1, 0x99,
0x67, 0x30, 0x94, 0x62, 0x55, 0x5f, 0x1f, 0x5b, 0xee, 0xb8, 0x83, 0x2f,
0x5c, 0x72, 0x09, 0xcf, 0x8f, 0x8c, 0xa0, 0xb5, 0x26, 0xf0, 0x7d, 0x74,
0x14, 0x91, 0x45, 0x11, 0x5a, 0x88, 0x66, 0x29, 0xf3, 0x12, 0xf8, 0x3e,
0x69, 0xa5, 0x4a, 0x1a, 0xc5, 0x64, 0xa6, 0x81, 0xef, 0xba, 0xd4, 0x6a,
0x35, 0x00, 0x7a, 0x0b, 0x36, 0x2f, 0xbc, 0xf2, 0x32, 0x07, 0xc6, 0xc7,
0x29, 0xd8, 0x36, 0x61, 0x14, 0x11, 0x7b, 0x1e, 0x7e, 0xd5, 0x65, 0xbe,
0x5c, 0x06, 0xa0, 0xee, 0xd6, 0x30, 0x2d, 0x93, 0x5a, 0xad, 0x86, 0x6d,
0x59, 0xbc, 0x37, 0x36, 0xc6, 0xcb, 0xbb, 0x77, 0xd3, 0xdb, 0xd9, 0x89,
0xe7, 0x79, 0x64, 0x59, 0x96, 0xf7, 0x50, 0x14, 0xa1, 0xc3, 0x30, 0x17,
0x1d, 0xb5, 0x08, 0x48, 0x3d, 0x8f, 0xb4, 0x52, 0x69, 0x0a, 0xa8, 0x57,
0x5d, 0x5c, 0xcf, 0x43, 0x00, 0x7e, 0xa5, 0x4a, 0xe8, 0xba, 0x78, 0xbe,
0x4f, 0x9a, 0x24, 0xd4, 0xc3, 0x90, 0x5a, 0xb9, 0x42, 0x5f, 0xb1, 0xc8,
0xba, 0xb5, 0x6b, 0x01, 0xe8, 0x29, 0x16, 0x99, 0xae, 0x94, 0xa9, 0xf9,
0x3e, 0x5e, 0xad, 0xc6, 0x89, 0x52, 0x89, 0xe3, 0xfb, 0x46, 0xf1, 0x1d,
0x87, 0x89, 0xa3, 0x47, 0xe9, 0x68, 0x6b, 0x23, 0x0c, 0xc2, 0xa5, 0x02,
0xe2, 0xa8, 0xa5, 0x04, 0x9e, 0x47, 0x36, 0x5f, 0x22, 0x8b, 0xf3, 0x12,
0x04, 0x35, 0x17, 0xaf, 0x21, 0x20, 0x76, 0x5d, 0x82, 0x9a, 0x87, 0xef,
0xfb, 0x44, 0x61, 0x48, 0xd1, 0xb2, 0x38, 0xab, 0xb3, 0x93, 0xa1, 0x81,
0x01, 0x7a, 0x6c, 0x1b, 0x65, 0x59, 0x0c, 0x0f, 0x0c, 0xf0, 0xd6, 0xb1,
0x63, 0x8c, 0x8d, 0x8e, 0x72, 0xa2, 0x41, 0xe5, 0xc3, 0x8e, 0x65, 0x2c,
0x77, 0x8a, 0xbc, 0x3f, 0x3a, 0x0a, 0xc0, 0x25, 0x03, 0x03, 0xe0, 0xba,
0x64, 0x80, 0xce, 0x32, 0xb2, 0x56, 0x02, 0xb5, 0xd7, 0xdf, 0x20, 0x59,
0x35, 0x40, 0xa6, 0x35, 0xa9, 0x94, 0xd4, 0xab, 0x2e, 0x7e, 0x43, 0x40,
0x54, 0xad, 0x12, 0xb8, 0x2e, 0x35, 0xcf, 0xa3, 0xcd, 0xb6, 0xb9, 0x77,
0xe3, 0xd7, 0x28, 0xcd, 0x97, 0xf8, 0xe9, 0xe3, 0x8f, 0x31, 0x39, 0x37,
0x47, 0xa5, 0x52, 0xa1, 0x98, 0x65, 0xfc, 0xe6, 0xca, 0xab, 0xd9, 0x7a,
0xe9, 0xe5, 0xdc, 0x35, 0xf2, 0x12, 0x00, 0xd2, 0xb6, 0x91, 0x76, 0xf3,
0x7d, 0xc3, 0xcc, 0xd8, 0x21, 0xbc, 0x9d, 0xbb, 0x48, 0x86, 0x06, 0xb1,
0x57, 0xf6, 0x43, 0xd4, 0x42, 0xa0, 0xfe, 0xef, 0x77, 0x29, 0x45, 0x19,
0xf6, 0x55, 0x97, 0x63, 0x77, 0x75, 0x11, 0xfa, 0x3e, 0x7e, 0x10, 0x20,
0xb4, 0x26, 0x72, 0x6b, 0x84, 0x9e, 0x87, 0xeb, 0x79, 0xdc, 0x78, 0xde,
0x79, 0x9c, 0x51, 0x70, 0xd8, 0xf8, 0xf0, 0xef, 0x38, 0x3e, 0x37, 0x87,
0xdf, 0xe8, 0x13, 0x80, 0xcd, 0x2f, 0xed, 0xe0, 0xb5, 0x6f, 0x7d, 0x9b,
0xab, 0x3f, 0x38, 0xc0, 0xce, 0x89, 0x09, 0x84, 0x54, 0x08, 0x43, 0x35,
0xef, 0x2b, 0xcb, 0x44, 0xc7, 0x11, 0xf5, 0x7d, 0xfb, 0x31, 0xa3, 0x78,
0xe9, 0x34, 0x94, 0x6d, 0x06, 0xe1, 0xe8, 0x38, 0xfe, 0xf4, 0x1c, 0x7a,
0xf8, 0x6c, 0xdc, 0xb9, 0x39, 0xea, 0xbe, 0x9f, 0xcf, 0x61, 0xd7, 0xa5,
0x5e, 0x75, 0xa9, 0xba, 0x2e, 0x6b, 0xc3, 0x84, 0x3f, 0x3e, 0xf5, 0x14,
0x1f, 0x8c, 0x8f, 0x73, 0xb2, 0x55, 0xc2, 0x90, 0xed, 0xe3, 0x87, 0xb8,
0x7a, 0xe8, 0x2c, 0x76, 0x4e, 0x4c, 0x80, 0x61, 0x20, 0x1a, 0x0b, 0x59,
0x8e, 0x44, 0x22, 0x0a, 0x85, 0x7c, 0x50, 0x47, 0x8e, 0x12, 0xcf, 0xce,
0x2e, 0x0a, 0xc0, 0x90, 0x48, 0xdb, 0x26, 0x09, 0x22, 0x82, 0x77, 0xde,
0x67, 0xa6, 0x32, 0x4d, 0xc9, 0xcf, 0xa7, 0xd8, 0xfc, 0xbe, 0x51, 0x66,
0xcb, 0x65, 0x42, 0xd7, 0xa5, 0x76, 0xec, 0x18, 0x13, 0x95, 0xf2, 0x29,
0xc9, 0x9b, 0x98, 0xfd, 0x3a, 0x9d, 0x45, 0x07, 0x00, 0xa1, 0xd4, 0x29,
0x02, 0xa4, 0x69, 0x21, 0x93, 0x14, 0x29, 0x25, 0xba, 0xea, 0x2e, 0x0a,
0x10, 0x4a, 0x22, 0x2d, 0x03, 0x01, 0x48, 0xdb, 0x02, 0x77, 0x71, 0x57,
0x93, 0x46, 0x31, 0x59, 0x96, 0x2e, 0xd6, 0xb5, 0x35, 0xe8, 0x49, 0x26,
0x4d, 0x13, 0x69, 0x9a, 0x2c, 0xc4, 0x44, 0x2d, 0x96, 0x40, 0x4a, 0x81,
0xb0, 0x4c, 0x44, 0x9a, 0x20, 0xa4, 0x82, 0x46, 0x9c, 0x5c, 0x80, 0xa1,
0xc0, 0x50, 0x08, 0x29, 0x10, 0xa6, 0x81, 0x10, 0xb2, 0x25, 0xa8, 0x91,
0x3b, 0x00, 0x98, 0x46, 0xd3, 0xf1, 0x74, 0x26, 0x8c, 0x96, 0x51, 0x9f,
0x52, 0x02, 0x85, 0xb0, 0x6d, 0x44, 0xe3, 0x8d, 0x2b, 0x96, 0x0a, 0x30,
0x10, 0xb6, 0x85, 0x10, 0x22, 0x27, 0x20, 0x5b, 0xf6, 0x75, 0xa6, 0xd9,
0x6c, 0x26, 0x61, 0x9a, 0xa4, 0xa7, 0xdf, 0xf2, 0xe5, 0xb4, 0x84, 0x40,
0x2c, 0x10, 0x38, 0x59, 0x80, 0x6a, 0x08, 0x48, 0x62, 0x94, 0xcc, 0x07,
0xbc, 0x28, 0x40, 0xc9, 0xc6, 0xc8, 0x73, 0x4c, 0xc8, 0x45, 0x02, 0xc2,
0x30, 0x9a, 0x28, 0x0d, 0xcb, 0xe2, 0xfc, 0x55, 0x03, 0xbc, 0x5b, 0x2e,
0x61, 0x1b, 0x66, 0xbe, 0xff, 0x94, 0x12, 0x10, 0x44, 0x69, 0xc2, 0xb9,
0x67, 0x9e, 0x49, 0xa9, 0x31, 0x33, 0xa4, 0x61, 0x20, 0x2d, 0x73, 0x31,
0x8e, 0x94, 0xa8, 0x42, 0x01, 0x99, 0xc4, 0x79, 0x9e, 0x56, 0x02, 0x18,
0x06, 0xc2, 0xb2, 0x10, 0x90, 0xff, 0xb6, 0x08, 0x90, 0x96, 0x85, 0x56,
0xf9, 0xf9, 0x2b, 0x93, 0x47, 0xb9, 0xe7, 0xfa, 0x1b, 0xb8, 0xe1, 0xe2,
0x8b, 0x91, 0x96, 0x9d, 0x8b, 0x35, 0xcd, 0xdc, 0xc7, 0x30, 0x28, 0x38,
0x0e, 0xf7, 0xfc, 0xe9, 0xd1, 0x9c, 0x86, 0x92, 0x60, 0x5a, 0x4b, 0x08,
0x60, 0x59, 0x39, 0x05, 0x21, 0x10, 0xaa, 0x45, 0x80, 0x34, 0x14, 0xd2,
0x34, 0x90, 0x52, 0xa0, 0x0a, 0xf6, 0x12, 0x02, 0x86, 0x6d, 0x33, 0xd0,
0xd5, 0x05, 0xc0, 0x8b, 0x07, 0x0f, 0xf0, 0xe2, 0xc1, 0x03, 0x2c, 0x80,
0x4d, 0x5a, 0xf0, 0x1b, 0x27, 0x9d, 0xaf, 0x5a, 0xd9, 0xbf, 0xa4, 0x3c,
0x42, 0xe5, 0x04, 0x44, 0x12, 0x83, 0xa6, 0x49, 0x67, 0xb1, 0x07, 0x0a,
0x0d, 0x65, 0x27, 0x11, 0x78, 0xfc, 0xfd, 0xfd, 0x3c, 0xb6, 0xe9, 0x16,
0x26, 0x82, 0x80, 0x37, 0x26, 0x8f, 0x32, 0x35, 0x3f, 0xdf, 0x4c, 0xf4,
0xa9, 0xde, 0x3e, 0x2c, 0xcb, 0x64, 0xae, 0x5c, 0xa6, 0xea, 0x79, 0x98,
0x86, 0xc1, 0xaa, 0xbe, 0x3e, 0xbe, 0x74, 0xd9, 0x65, 0x7c, 0x7d, 0xc3,
0x06, 0xbe, 0xf2, 0xfd, 0xef, 0x2d, 0x29, 0x01, 0x05, 0x1b, 0x19, 0x85,
0x28, 0x4d, 0xb3, 0xac, 0x12, 0x40, 0x99, 0x26, 0x62, 0x01, 0xa5, 0x6d,
0xa3, 0x5b, 0x9a, 0xf0, 0xad, 0xa9, 0xe3, 0xdc, 0xfe, 0xfc, 0xb3, 0xfc,
0xea, 0xe6, 0x4d, 0xfc, 0xe7, 0x17, 0xf7, 0x71, 0xce, 0x19, 0x67, 0x00,
0xd0, 0xd5, 0xde, 0xce, 0x3f, 0x1e, 0x78, 0x80, 0xb1, 0x67, 0x9f, 0xe3,
0x07, 0xb7, 0xde, 0x06, 0xc0, 0x55, 0x17, 0x5d, 0xc4, 0xf8, 0x3f, 0xff,
0xc5, 0xfd, 0x77, 0xff, 0x98, 0x8d, 0x3f, 0xba, 0x8b, 0x77, 0xc6, 0xc6,
0x9a, 0x71, 0xb4, 0x52, 0x50, 0x28, 0x20, 0x6c, 0x1b, 0x6c, 0x1b, 0xa3,
0x50, 0x68, 0x12, 0xa8, 0xce, 0x66, 0xc9, 0xb2, 0x82, 0xe3, 0x10, 0xa3,
0x91, 0x4e, 0x01, 0xcb, 0x58, 0x6c, 0x1e, 0x80, 0xd7, 0x27, 0x26, 0x78,
0xe2, 0xbf, 0x6f, 0xf3, 0x93, 0x9b, 0x37, 0xf1, 0xe7, 0x9f, 0xdd, 0x43,
0xa8, 0x24, 0x66, 0xb1, 0xc8, 0xc0, 0xe0, 0x20, 0xa1, 0x52, 0xdc, 0xb9,
0x79, 0x33, 0xdf, 0xbc, 0xed, 0x56, 0x8a, 0x6d, 0xed, 0x88, 0xee, 0x6e,
0x1e, 0xf9, 0xfd, 0x36, 0xde, 0xde, 0xbf, 0x7f, 0x49, 0x0c, 0xd3, 0xb2,
0xc0, 0xb6, 0x11, 0xb6, 0x8d, 0x69, 0x18, 0x1c, 0x9e, 0x9e, 0x06, 0x98,
0x52, 0xc0, 0x73, 0xaf, 0x7d, 0x34, 0xb7, 0xfe, 0xb3, 0xbd, 0x7d, 0xbd,
0x67, 0xaf, 0x58, 0x41, 0x62, 0x9a, 0x9c, 0xd3, 0xdf, 0xcf, 0x9e, 0x8f,
0x66, 0x31, 0x94, 0x41, 0x87, 0x5d, 0xe0, 0xe2, 0xa1, 0x21, 0xb6, 0x6c,
0xba, 0x05, 0xa7, 0xab, 0x8b, 0x15, 0xfd, 0x2b, 0x59, 0xb9, 0x7a, 0x35,
0x7d, 0xab, 0x57, 0x23, 0xdb, 0x8a, 0x08, 0xa7, 0x80, 0xd3, 0xd5, 0x49,
0xcf, 0xca, 0x95, 0xb4, 0x2f, 0x5f, 0x8e, 0x56, 0x92, 0xe1, 0xf3, 0x86,
0xd9, 0xf3, 0xce, 0x5e, 0xe2, 0x24, 0xa1, 0x73, 0xd9, 0x32, 0x3e, 0x3d,
0x38, 0xc8, 0xaf, 0xb7, 0x6e, 0x65, 0x45, 0x57, 0x17, 0x76, 0xd1, 0xe1,
0x99, 0x1d, 0x3b, 0xf8, 0xee, 0xfd, 0xbf, 0xdc, 0x9d, 0x66, 0xd9, 0xfa,
0x05, 0xd6, 0x6b, 0x1c, 0x29, 0xff, 0xfe, 0xe8, 0x75, 0x37, 0x0e, 0x5f,
0xb7, 0x76, 0x2d, 0xb2, 0xad, 0x0d, 0xdd, 0x56, 0x24, 0x73, 0x1c, 0x64,
0x47, 0x3b, 0xc5, 0xe5, 0xcb, 0x51, 0x1d, 0xed, 0xe8, 0x62, 0x1b, 0xb2,
0xbd, 0x0d, 0xd5, 0xd6, 0x86, 0x70, 0x0a, 0x50, 0x70, 0x72, 0xa4, 0xa6,
0x99, 0xcf, 0x6b, 0xa5, 0xf2, 0x6f, 0x43, 0x65, 0x80, 0xce, 0xc0, 0xaf,
0x43, 0x9a, 0xe4, 0x4d, 0xad, 0x35, 0x24, 0x29, 0x7f, 0x79, 0xfa, 0x69,
0x6e, 0xbb, 0xf3, 0x87, 0xbb, 0xe3, 0x38, 0xde, 0x00, 0x9c, 0x68, 0x5d,
0x56, 0xd6, 0xb4, 0x2b, 0xb5, 0xe3, 0xbe, 0x6b, 0xaf, 0x3f, 0xbf, 0x7f,
0x45, 0x0f, 0xc2, 0x71, 0x90, 0x8e, 0x83, 0x74, 0x0a, 0xc8, 0x62, 0x31,
0x7f, 0x91, 0x38, 0x0e, 0xca, 0xc9, 0x93, 0x0a, 0xdb, 0x42, 0x58, 0x56,
0xbe, 0xf4, 0x2a, 0x95, 0x37, 0x99, 0x90, 0xf9, 0x22, 0x96, 0x35, 0x3e,
0x54, 0x75, 0x96, 0xef, 0x7e, 0x93, 0x14, 0xa1, 0x35, 0x07, 0x0f, 0x1e,
0xe4, 0xee, 0xad, 0xf7, 0xee, 0x0e, 0x1b, 0xc9, 0x39, 0x8d, 0x9d, 0x0b,
0x54, 0xf8, 0xe4, 0x3e, 0xcf, 0x8f, 0x03, 0x03, 0xad, 0x09, 0xff, 0x07,
0x3b, 0xa2, 0xe6, 0xcf, 0x08, 0x74, 0x13, 0x5e, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif
|
dennis/bzlauncher
|
src/refresh32.h
|
#ifndef REFRESH32_PNG_H
#define REFRESH32_PNG_H
static const unsigned char refresh32_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a, 0xf4, 0x00, 0x00, 0x00,
0x04, 0x73, 0x42, 0x49, 0x54, 0x08, 0x08, 0x08, 0x08, 0x7c, 0x08, 0x64,
0x88, 0x00, 0x00, 0x07, 0x9f, 0x49, 0x44, 0x41, 0x54, 0x58, 0x85, 0xc5,
0x97, 0x69, 0x6c, 0x54, 0xd7, 0x15, 0xc7, 0xff, 0xf7, 0xde, 0xb7, 0xcc,
0xe6, 0x19, 0x0f, 0xb6, 0xd9, 0x71, 0x0d, 0x69, 0x6a, 0x84, 0xa1, 0x2c,
0x06, 0x5c, 0x35, 0xe4, 0x03, 0x28, 0x25, 0x25, 0x51, 0x8b, 0x42, 0x15,
0x5a, 0xe3, 0x80, 0x9a, 0x14, 0xe3, 0xa6, 0x8a, 0x14, 0xb5, 0x52, 0x94,
0x96, 0xb6, 0x52, 0xfb, 0xa1, 0xf9, 0x50, 0xa9, 0xad, 0xd4, 0x46, 0x45,
0xa1, 0x2c, 0x69, 0xb0, 0x49, 0x05, 0xa1, 0xca, 0xd2, 0xaa, 0x09, 0x11,
0x71, 0x43, 0x09, 0x4d, 0x00, 0x63, 0x96, 0x1a, 0x12, 0x88, 0xb1, 0x0d,
0x78, 0xb7, 0x67, 0xb3, 0x67, 0xe6, 0xad, 0xf7, 0xf4, 0xc3, 0xcc, 0xd0,
0xe7, 0x05, 0xdb, 0xdf, 0x7a, 0xa4, 0xab, 0x37, 0xf7, 0xcd, 0xb9, 0xe7,
0xff, 0x3b, 0x77, 0xce, 0x3d, 0xef, 0x0d, 0xf0, 0x7f, 0x36, 0x36, 0x13,
0xa7, 0xd5, 0x4f, 0x37, 0x2e, 0xf3, 0xf9, 0xd5, 0xef, 0x28, 0x1c, 0x8f,
0x3b, 0x0e, 0x55, 0x38, 0xae, 0x5b, 0xc4, 0x39, 0x73, 0x18, 0x58, 0x96,
0x0b, 0xd6, 0x6e, 0xbb, 0xf2, 0x23, 0xd7, 0x75, 0xde, 0x31, 0x93, 0xbe,
0x33, 0x6d, 0xc7, 0xb7, 0x5b, 0x53, 0xc5, 0x5a, 0x5b, 0x7f, 0xe4, 0x5b,
0x17, 0xfe, 0xb4, 0xf3, 0xc4, 0x8c, 0x00, 0xd6, 0xd5, 0x1f, 0xad, 0xd2,
0x35, 0x7e, 0x30, 0x12, 0xf2, 0x2d, 0xdd, 0xb0, 0xb2, 0x3c, 0x54, 0x3e,
0xaf, 0x58, 0x84, 0x83, 0x1a, 0x74, 0x4d, 0x81, 0x23, 0x25, 0x4c, 0xc3,
0xc6, 0x70, 0xca, 0x40, 0xcf, 0x60, 0xca, 0xbd, 0x7c, 0x73, 0x20, 0x7d,
0xb7, 0x3f, 0x45, 0x8c, 0xd3, 0x41, 0xd3, 0xa2, 0xdf, 0xb7, 0x1e, 0xac,
0xeb, 0x1a, 0x1f, 0xaf, 0xfa, 0x99, 0xc6, 0xcd, 0xe0, 0x78, 0xaf, 0xe5,
0xc0, 0x53, 0xf7, 0x74, 0xef, 0x0b, 0xb0, 0xae, 0xbe, 0xe9, 0xbb, 0x7e,
0x5d, 0xf9, 0xc3, 0xf6, 0xaf, 0x55, 0x05, 0x97, 0x2e, 0x2e, 0x65, 0x44,
0x80, 0x24, 0x02, 0x49, 0x82, 0x4b, 0x04, 0x29, 0x73, 0x7e, 0x04, 0x80,
0x33, 0x40, 0xe1, 0x0c, 0xa9, 0x8c, 0x8d, 0xd6, 0x1b, 0x7d, 0xf6, 0xe9,
0xf3, 0x9d, 0xb6, 0x43, 0x6e, 0x93, 0x23, 0xb1, 0xb7, 0x65, 0xff, 0x8e,
0x21, 0x00, 0x58, 0xfb, 0xbd, 0xc6, 0x87, 0x14, 0x45, 0x9c, 0xb4, 0x5d,
0x37, 0x30, 0x2d, 0xc0, 0xba, 0x86, 0xa6, 0x6d, 0x01, 0x5d, 0x3d, 0xf2,
0xfc, 0xb7, 0x6b, 0x02, 0xc5, 0x61, 0x1f, 0x64, 0x5e, 0x90, 0x40, 0x20,
0x99, 0x03, 0x71, 0x24, 0x81, 0x88, 0x20, 0x25, 0x41, 0x12, 0x20, 0x29,
0x07, 0xa2, 0xab, 0x1c, 0xae, 0x24, 0x7c, 0x74, 0xe9, 0xb6, 0x7d, 0xba,
0xa5, 0xd3, 0x70, 0x80, 0x06, 0x26, 0xe9, 0xba, 0x10, 0xfc, 0x5f, 0x5b,
0x37, 0x55, 0x85, 0xde, 0x38, 0x79, 0x05, 0x5e, 0x00, 0x65, 0xbc, 0xf8,
0xfa, 0x5d, 0x7f, 0x2e, 0xe1, 0x8c, 0x1f, 0x6a, 0x78, 0xa2, 0x3a, 0x30,
0x2b, 0xe2, 0x83, 0x4b, 0x04, 0xc3, 0x72, 0x10, 0x4b, 0x64, 0x61, 0x58,
0x0e, 0x14, 0x21, 0x50, 0x14, 0xd4, 0x10, 0x09, 0xe9, 0x20, 0x02, 0x6c,
0x57, 0xc2, 0x72, 0x24, 0x48, 0x12, 0x6c, 0x49, 0x30, 0x6d, 0x17, 0x82,
0x33, 0x3c, 0xbc, 0xba, 0x42, 0xad, 0xac, 0x28, 0x53, 0xff, 0x72, 0xf2,
0xca, 0x81, 0x78, 0x32, 0x1b, 0x78, 0x62, 0xd3, 0x32, 0x5a, 0x38, 0x37,
0x3c, 0x21, 0xd9, 0x09, 0x00, 0x14, 0x50, 0xeb, 0xd7, 0x2f, 0x9f, 0xaf,
0xcf, 0x2b, 0x2b, 0xc2, 0xd5, 0xf6, 0x01, 0x7a, 0xff, 0xe3, 0x5b, 0x72,
0x30, 0x91, 0xe1, 0x8c, 0x81, 0x11, 0x51, 0xce, 0x87, 0x48, 0x0a, 0xce,
0xec, 0xc5, 0xf3, 0xa3, 0xe6, 0xaa, 0xa5, 0xf3, 0x43, 0x95, 0x15, 0x25,
0xdc, 0xa7, 0x32, 0xa4, 0x4d, 0x17, 0x19, 0xd3, 0x46, 0x32, 0x63, 0x21,
0x95, 0x49, 0x21, 0xa8, 0x2b, 0xd8, 0xb1, 0x65, 0x55, 0x20, 0x6b, 0xd8,
0xd0, 0x74, 0x95, 0xb9, 0x92, 0xa6, 0x07, 0xd0, 0x05, 0xdf, 0x53, 0x53,
0xb5, 0xc0, 0x77, 0xe8, 0xed, 0x8b, 0xee, 0xad, 0xbb, 0x09, 0x38, 0x92,
0x84, 0xe0, 0xdc, 0xb4, 0x2c, 0xa7, 0x9b, 0xb8, 0xbb, 0xa3, 0x65, 0xff,
0xae, 0x4f, 0x00, 0xa0, 0x7a, 0xcf, 0xb1, 0xc8, 0xf5, 0x5b, 0x43, 0x35,
0xed, 0xdd, 0xf1, 0xdd, 0x80, 0x7c, 0x7c, 0x4d, 0xe5, 0x02, 0xb6, 0xa2,
0x72, 0x9e, 0x1f, 0x5c, 0x20, 0x6d, 0xb8, 0x70, 0x25, 0x10, 0x4f, 0xdb,
0x18, 0x35, 0x5d, 0xcc, 0x89, 0xe8, 0x68, 0xef, 0x1b, 0xc5, 0xb2, 0x85,
0x13, 0x77, 0x60, 0x4c, 0x0d, 0x54, 0xef, 0x79, 0x25, 0xe0, 0x57, 0x8a,
0x07, 0x57, 0x56, 0xce, 0xd1, 0x2e, 0x7e, 0xda, 0x87, 0x68, 0x38, 0xa8,
0x28, 0x0a, 0x47, 0xdf, 0x50, 0x22, 0x2e, 0x1c, 0xf5, 0x8b, 0xff, 0x3e,
0xb8, 0x3d, 0x36, 0x59, 0xcd, 0xac, 0x78, 0xb6, 0x29, 0xea, 0x77, 0xf9,
0xb3, 0x82, 0xb3, 0x9f, 0x7c, 0x65, 0xe5, 0x22, 0xdf, 0xca, 0xca, 0x79,
0xca, 0x60, 0xd2, 0x44, 0x3c, 0x63, 0x43, 0x4a, 0x42, 0x21, 0xf3, 0xb5,
0x0f, 0x44, 0xf1, 0xeb, 0x57, 0xcf, 0x50, 0xcb, 0x81, 0x3a, 0x5e, 0x58,
0xcb, 0xbd, 0x81, 0x38, 0x15, 0x2d, 0x26, 0x50, 0xe0, 0xd2, 0x67, 0xbd,
0xe2, 0x0b, 0x0b, 0x4a, 0x58, 0x49, 0x34, 0x18, 0x13, 0x42, 0xf4, 0x83,
0x58, 0xdb, 0xfd, 0xc4, 0x01, 0xe0, 0xea, 0xbe, 0xba, 0xf8, 0xb9, 0xfd,
0xb5, 0x2f, 0x19, 0x16, 0x55, 0x9e, 0xbd, 0xdc, 0x75, 0xf2, 0xd5, 0x37,
0x2f, 0xa0, 0x24, 0xa4, 0xa0, 0xbc, 0x34, 0x00, 0xa2, 0x5c, 0xb1, 0x02,
0x00, 0xe7, 0x0c, 0x9c, 0xc1, 0x1c, 0xa3, 0xe9, 0x9d, 0x48, 0x26, 0xb9,
0x61, 0x39, 0xd0, 0x7c, 0xbe, 0xe1, 0x90, 0xdf, 0xf7, 0x41, 0x40, 0xd7,
0x3f, 0x70, 0x1c, 0xe7, 0x26, 0x91, 0x3b, 0xe1, 0x4c, 0x4f, 0x66, 0xad,
0x87, 0x6a, 0x7b, 0x00, 0xfa, 0x58, 0x51, 0xb8, 0xa5, 0x28, 0x0a, 0xe2,
0xa3, 0x16, 0x88, 0x00, 0x22, 0x80, 0x31, 0x80, 0xb3, 0x89, 0x87, 0x6e,
0x4c, 0x0d, 0x28, 0x36, 0x5c, 0x47, 0x00, 0xb3, 0xa3, 0xa1, 0x7f, 0x04,
0x03, 0xfa, 0x35, 0xc6, 0x79, 0xb2, 0x38, 0x12, 0x0c, 0x0c, 0x0d, 0x8f,
0xcc, 0xa8, 0x63, 0x56, 0xd7, 0x37, 0x7e, 0x3f, 0xec, 0xd7, 0x7f, 0x5c,
0xfb, 0xd8, 0x2a, 0xad, 0x3f, 0x69, 0x20, 0x91, 0xb6, 0x20, 0x91, 0xeb,
0x15, 0x85, 0x1d, 0x98, 0x12, 0x20, 0xeb, 0xc8, 0x2e, 0x55, 0x70, 0x8c,
0x66, 0xb2, 0x1f, 0xf6, 0x77, 0x3b, 0xed, 0xb6, 0x22, 0x46, 0x93, 0xd9,
0x84, 0xe9, 0xba, 0xf6, 0xe8, 0x74, 0xe2, 0x35, 0x0d, 0x4d, 0x5b, 0x7d,
0xba, 0xf6, 0xdb, 0x5d, 0xdf, 0x58, 0xed, 0xd7, 0x75, 0x15, 0x41, 0x9f,
0x86, 0xf2, 0xd2, 0x00, 0xc0, 0x00, 0x06, 0x06, 0x55, 0x70, 0x08, 0x06,
0x0f, 0x4e, 0xce, 0x26, 0x20, 0xad, 0x7b, 0xfa, 0xf5, 0x45, 0xe7, 0x0f,
0xd7, 0xde, 0x99, 0x49, 0xc6, 0x05, 0x5b, 0xb3, 0xfb, 0xb5, 0x4d, 0x0c,
0xfc, 0xd4, 0x4c, 0xfd, 0xa7, 0xec, 0x84, 0xd5, 0xbb, 0x1b, 0x49, 0x70,
0x96, 0x2d, 0xcc, 0x25, 0x91, 0x42, 0x04, 0x75, 0xb2, 0x40, 0xd2, 0xd5,
0x66, 0xb7, 0x1e, 0xde, 0x3e, 0x38, 0x53, 0xe1, 0x27, 0x9f, 0x3c, 0x26,
0xba, 0x22, 0x46, 0xf9, 0xb9, 0x03, 0xbb, 0x3a, 0x0a, 0xf7, 0x26, 0xf4,
0x01, 0x00, 0x78, 0xf9, 0x85, 0xaf, 0xfb, 0x81, 0x5c, 0xf1, 0x48, 0x22,
0xd8, 0xae, 0x84, 0x94, 0xb9, 0x42, 0xea, 0xe8, 0x4d, 0x62, 0xdf, 0x89,
0xf3, 0x29, 0xdb, 0x72, 0xab, 0xa7, 0x13, 0x6f, 0x6e, 0xee, 0xf0, 0x6d,
0xdc, 0xb8, 0xd8, 0x28, 0xcc, 0xdb, 0x8b, 0xad, 0x6f, 0x32, 0xe2, 0x7f,
0x85, 0x27, 0x71, 0x3e, 0xd9, 0x42, 0x49, 0x84, 0xcb, 0x9d, 0x09, 0xb4,
0x76, 0xc4, 0x71, 0xb9, 0x33, 0x81, 0x6b, 0x77, 0x52, 0x88, 0x8d, 0x9a,
0x18, 0x88, 0x67, 0x70, 0xe0, 0xcd, 0x96, 0xb4, 0xe3, 0x3a, 0x9b, 0x2f,
0x1e, 0xdc, 0xf9, 0xf9, 0x94, 0xe9, 0x12, 0x31, 0x37, 0xaa, 0x96, 0x37,
0xb7, 0x0d, 0xcc, 0xfd, 0x9f, 0x18, 0xb9, 0x40, 0xae, 0x89, 0x4d, 0x09,
0x30, 0xde, 0x66, 0x85, 0x34, 0xa8, 0x82, 0xe1, 0x8f, 0xc7, 0xce, 0x49,
0xc3, 0x76, 0xeb, 0x0a, 0xdd, 0x70, 0x2a, 0xfb, 0xc5, 0x2f, 0xc1, 0xae,
0xdf, 0xcd, 0x3e, 0x2c, 0x20, 0xab, 0x4e, 0x5d, 0xed, 0x7f, 0xa0, 0xb9,
0xb9, 0x59, 0x51, 0x55, 0x6d, 0x6b, 0xee, 0x5b, 0x63, 0x1a, 0x00, 0x4f,
0xa1, 0x32, 0x06, 0x94, 0x14, 0x69, 0xc8, 0x64, 0x6d, 0x00, 0xc4, 0x05,
0x78, 0x6d, 0xf5, 0x9e, 0xa3, 0xa5, 0xd3, 0x01, 0x74, 0x46, 0x2e, 0x85,
0xe3, 0x69, 0xf7, 0xab, 0x00, 0x5f, 0xa6, 0x70, 0xaa, 0x6a, 0x8b, 0xcf,
0xd9, 0x48, 0x24, 0x77, 0x30, 0x06, 0x58, 0x42, 0x8c, 0x4c, 0x09, 0xe0,
0x7d, 0x66, 0x10, 0x01, 0x37, 0x7b, 0x47, 0x20, 0x39, 0xc7, 0x0f, 0x77,
0x3e, 0x84, 0x0d, 0x6b, 0xca, 0xb7, 0x09, 0x8e, 0xf6, 0x75, 0xf5, 0x47,
0x9e, 0xaf, 0xa9, 0x6b, 0x9c, 0xd8, 0xdc, 0xf3, 0x96, 0x96, 0xf6, 0xa3,
0xaa, 0xc2, 0xaa, 0x38, 0xa3, 0x65, 0x89, 0xb4, 0xb5, 0xf6, 0xf8, 0xe9,
0xeb, 0x4d, 0x45, 0xe1, 0x22, 0xc1, 0x39, 0x1f, 0xb9, 0xba, 0xaf, 0x2e,
0x5e, 0xf0, 0x9b, 0xb4, 0x08, 0x25, 0x11, 0x38, 0x63, 0x98, 0x5f, 0xea,
0x47, 0x4f, 0x2c, 0x0b, 0xdb, 0x25, 0xc4, 0x46, 0x2c, 0xc4, 0x46, 0x80,
0x25, 0x8b, 0xca, 0xd4, 0x59, 0xd1, 0x22, 0xf5, 0xf2, 0xa7, 0xbd, 0x2f,
0x75, 0x76, 0x0f, 0xfd, 0x6a, 0x7d, 0xc3, 0xd1, 0x13, 0xb6, 0x23, 0x5f,
0xd3, 0x0c, 0x9c, 0xff, 0xa4, 0xe9, 0xa9, 0x54, 0xf5, 0x8b, 0xef, 0x47,
0x8a, 0x84, 0xef, 0xb9, 0xd1, 0xb4, 0xf3, 0xe2, 0xf2, 0x8a, 0x50, 0xea,
0xed, 0xb3, 0x77, 0xe6, 0x9e, 0xb9, 0xd4, 0xb1, 0x20, 0x10, 0xf0, 0x91,
0x2f, 0xe0, 0x53, 0x13, 0x89, 0xd4, 0x05, 0xaf, 0xd6, 0xa4, 0xc7, 0xf0,
0x77, 0x3f, 0xda, 0x8c, 0xac, 0xe5, 0x22, 0x91, 0xca, 0x22, 0x1c, 0xf2,
0xa3, 0x2f, 0x91, 0x45, 0xf7, 0x70, 0x16, 0xfd, 0x09, 0x13, 0xae, 0x94,
0xd0, 0x55, 0x81, 0x68, 0x50, 0x85, 0x94, 0x84, 0xae, 0x9e, 0x98, 0x7b,
0xb7, 0x27, 0x96, 0x8e, 0x8f, 0x64, 0x74, 0x21, 0x14, 0x9d, 0x71, 0x05,
0x94, 0x7f, 0x76, 0x4b, 0xc7, 0x41, 0x20, 0xa8, 0xbb, 0xd1, 0x68, 0x58,
0xd1, 0x03, 0x7e, 0xdc, 0xe9, 0xea, 0x19, 0xc9, 0x9a, 0xe6, 0x0f, 0x2e,
0xbe, 0xb2, 0xa3, 0x71, 0xca, 0x1d, 0x20, 0x02, 0x6e, 0xde, 0x49, 0xc8,
0xc3, 0x6f, 0xb5, 0xf0, 0x07, 0xcb, 0x4b, 0xb2, 0x5b, 0x36, 0x3c, 0xe8,
0x57, 0x04, 0x07, 0x63, 0x04, 0x02, 0x90, 0x31, 0x1d, 0xa4, 0x0d, 0x07,
0x42, 0x30, 0x44, 0xa3, 0x61, 0x31, 0xbb, 0x2c, 0x12, 0x26, 0x09, 0x8c,
0xa4, 0x0d, 0xa4, 0x0d, 0x1b, 0x8e, 0x4b, 0xe0, 0x9c, 0x31, 0xae, 0x68,
0x70, 0x49, 0x2a, 0x8e, 0x0b, 0xa4, 0x92, 0x69, 0x58, 0x86, 0x31, 0x6a,
0xc6, 0xd5, 0x63, 0x5e, 0xad, 0xf1, 0x00, 0x0c, 0x00, 0x6e, 0xf5, 0x26,
0xd0, 0xf8, 0xf7, 0xd6, 0x91, 0xe1, 0xdb, 0xe7, 0x1f, 0xb5, 0x53, 0x15,
0x9b, 0x3a, 0x7a, 0x62, 0x3f, 0x5f, 0xb3, 0x74, 0xa1, 0xba, 0xa4, 0x62,
0xb6, 0x92, 0x4c, 0xdb, 0x88, 0xa5, 0x2d, 0xd8, 0x0e, 0xc1, 0x72, 0x24,
0x4c, 0x5b, 0x42, 0x12, 0xdd, 0x5b, 0xce, 0x35, 0x1d, 0x42, 0xe6, 0xfa,
0x86, 0xe5, 0xba, 0x00, 0x31, 0x64, 0x32, 0x59, 0x0c, 0xf6, 0xf5, 0x67,
0x8d, 0x44, 0xcf, 0xae, 0xb6, 0xe3, 0x2f, 0x30, 0xe4, 0x6a, 0x4f, 0x02,
0x80, 0xf0, 0x88, 0x73, 0x00, 0xfa, 0x82, 0xea, 0x6d, 0x3f, 0xbb, 0x72,
0xa3, 0x3f, 0x3d, 0x74, 0xfb, 0x52, 0xed, 0xad, 0x77, 0x7f, 0x73, 0xab,
0xbf, 0xed, 0xbd, 0xcf, 0xcc, 0x6c, 0xf2, 0x6f, 0x23, 0x7c, 0xf6, 0xbc,
0xcf, 0x6f, 0xc7, 0x17, 0xfa, 0x75, 0x05, 0x73, 0xa2, 0x21, 0xee, 0xd7,
0x15, 0x30, 0x86, 0xfc, 0x7b, 0x21, 0x40, 0x32, 0x77, 0x95, 0x24, 0xf3,
0x79, 0xe4, 0x76, 0x2b, 0x3e, 0x9c, 0x94, 0x03, 0xbd, 0x83, 0x99, 0xcc,
0x60, 0x7b, 0x43, 0xdb, 0x89, 0xbd, 0x67, 0xf3, 0x3a, 0x39, 0x07, 0x40,
0xb2, 0x7b, 0xe8, 0x80, 0x06, 0x40, 0xab, 0xde, 0xdd, 0x98, 0xca, 0x26,
0x6e, 0x3f, 0x73, 0xed, 0x8d, 0xbd, 0xcd, 0x85, 0x7b, 0x85, 0x51, 0x5a,
0xf5, 0xc8, 0x92, 0xf9, 0xcb, 0x1f, 0xab, 0xf5, 0x45, 0x4a, 0x1f, 0x29,
0x0e, 0x07, 0x65, 0x69, 0x69, 0xd4, 0x1f, 0x0c, 0xf8, 0x98, 0xa6, 0xa9,
0x00, 0x63, 0x70, 0x24, 0x60, 0x9a, 0x36, 0xd2, 0x86, 0x85, 0x64, 0x32,
0xed, 0x26, 0x63, 0x89, 0xac, 0x6d, 0x66, 0xfe, 0xd3, 0x7d, 0xf1, 0xad,
0x9f, 0xf6, 0x5f, 0x79, 0xa7, 0x03, 0x80, 0x35, 0x6e, 0x98, 0xcc, 0x93,
0xbd, 0x06, 0x40, 0xff, 0x72, 0xed, 0xcb, 0x7b, 0xae, 0xbc, 0xfe, 0xdc,
0x51, 0x00, 0xfa, 0x38, 0x80, 0x7b, 0x73, 0xcd, 0x1f, 0x29, 0x2a, 0x5b,
0xbe, 0x65, 0x65, 0xf1, 0xc2, 0x15, 0x35, 0x7a, 0x51, 0xd9, 0x97, 0xb8,
0xa6, 0x97, 0x81, 0xb8, 0x42, 0x8c, 0x09, 0x06, 0x39, 0x2a, 0x1d, 0xb3,
0xd7, 0x88, 0xf7, 0x7d, 0x38, 0x74, 0xe3, 0x9f, 0xef, 0x0e, 0x5c, 0x3f,
0xd5, 0x59, 0x10, 0xf3, 0x0a, 0xe7, 0xaf, 0x86, 0xf7, 0x14, 0x4c, 0x2a,
0x96, 0x1f, 0xea, 0xb8, 0xcf, 0x6a, 0xbe, 0x7e, 0x84, 0x77, 0x3b, 0x01,
0x38, 0x00, 0x6c, 0xcf, 0x18, 0x9f, 0xf1, 0x98, 0xec, 0x01, 0x98, 0xde,
0x22, 0xb4, 0x31, 0xf6, 0x58, 0x16, 0x82, 0xba, 0xf9, 0xc0, 0x4e, 0x7e,
0x61, 0x41, 0x58, 0x60, 0x6c, 0x23, 0xa3, 0xbc, 0xaf, 0xd7, 0xdf, 0xf6,
0xac, 0xf3, 0x42, 0x19, 0xf9, 0xeb, 0xa4, 0x7f, 0x4c, 0x0a, 0x3f, 0x87,
0x8a, 0xb1, 0xd9, 0x8e, 0x17, 0x2e, 0x14, 0x53, 0x21, 0x46, 0x01, 0xb8,
0x00, 0x3d, 0x19, 0x48, 0x41, 0xf8, 0x5e, 0xaf, 0x9d, 0xee, 0x55, 0x4b,
0xe4, 0x85, 0x0b, 0x10, 0xdc, 0x03, 0xe0, 0x15, 0x2f, 0x00, 0x78, 0x21,
0xbc, 0xc2, 0x4e, 0xfe, 0xde, 0x04, 0x9b, 0xd1, 0xbb, 0xde, 0x24, 0x6b,
0xbc, 0xa3, 0x20, 0xee, 0x85, 0x98, 0xf8, 0x0f, 0xe4, 0x3e, 0xf6, 0x5f,
0x84, 0x3d, 0xc2, 0x88, 0x6d, 0x32, 0x73, 0x76, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif
|
dennis/bzlauncher
|
src/favorite32.h
|
#ifndef FAVORITE32_PNG_H
#define FAVORITE32_PNG_H
static const unsigned char favorite32_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a, 0xf4, 0x00, 0x00, 0x00,
0x04, 0x73, 0x42, 0x49, 0x54, 0x08, 0x08, 0x08, 0x08, 0x7c, 0x08, 0x64,
0x88, 0x00, 0x00, 0x05, 0xc7, 0x49, 0x44, 0x41, 0x54, 0x58, 0x85, 0xed,
0x96, 0x5b, 0x8c, 0x1d, 0x75, 0x1d, 0xc7, 0x3f, 0x33, 0x73, 0x66, 0xce,
0x65, 0xf7, 0xec, 0xd6, 0xad, 0x66, 0x8b, 0xe9, 0x65, 0x5b, 0x69, 0x11,
0x2b, 0x48, 0x2c, 0x94, 0xb6, 0x98, 0x6e, 0x6b, 0x45, 0x31, 0x04, 0x7d,
0xb0, 0xd1, 0xc4, 0x07, 0x13, 0x7d, 0xd1, 0x04, 0x83, 0x09, 0x49, 0x1f,
0x8a, 0x12, 0x57, 0x4c, 0x7c, 0xf1, 0x49, 0xf1, 0x12, 0x7d, 0x10, 0x2a,
0x08, 0x08, 0x82, 0xf0, 0x20, 0x15, 0x8b, 0x16, 0x08, 0x6c, 0xc1, 0x4b,
0x8b, 0xa6, 0xcd, 0x6a, 0xa5, 0x97, 0xbd, 0x75, 0xaf, 0x67, 0x97, 0xb3,
0xe7, 0x3a, 0xf3, 0xbf, 0xfc, 0x7c, 0x38, 0x67, 0xb6, 0x67, 0xcf, 0xce,
0x6e, 0xf7, 0x4d, 0x1f, 0xfc, 0x25, 0xdf, 0xcc, 0xcc, 0x7f, 0x7e, 0xf3,
0xfb, 0x7e, 0x7f, 0x97, 0xff, 0xcc, 0xc0, 0xff, 0xed, 0xbf, 0x6c, 0xce,
0x6a, 0x37, 0xbf, 0x03, 0x9f, 0x0e, 0x1c, 0xee, 0xc3, 0x75, 0x77, 0x09,
0xe4, 0x5c, 0x08, 0xc5, 0xda, 0x73, 0x5a, 0x78, 0x2c, 0x03, 0x4f, 0x1c,
0x81, 0x4a, 0xec, 0xfb, 0x10, 0xec, 0x4d, 0xb9, 0x7c, 0xc3, 0xc1, 0xb9,
0x43, 0xa0, 0x1b, 0xb0, 0xae, 0xc8, 0x65, 0xe3, 0xf0, 0x8c, 0x63, 0xf9,
0xf9, 0x03, 0x30, 0xb3, 0x66, 0x01, 0x03, 0xd0, 0x93, 0x76, 0xf8, 0x65,
0x90, 0x09, 0x0e, 0xde, 0xdc, 0x7f, 0x53, 0x6e, 0xf3, 0x2d, 0x3b, 0xc8,
0x74, 0x66, 0xd0, 0xa1, 0x66, 0x7c, 0x68, 0x98, 0x7f, 0x0e, 0x9e, 0xab,
0xcd, 0x4c, 0xce, 0x85, 0xc6, 0xca, 0x57, 0x03, 0x78, 0x49, 0x1c, 0x1e,
0xf3, 0x82, 0xd4, 0xa1, 0x0f, 0xef, 0xfe, 0x60, 0x76, 0xcb, 0xee, 0x9d,
0x4e, 0x7e, 0x7d, 0x17, 0x56, 0x1b, 0xa6, 0xfe, 0x3d, 0xc2, 0xf9, 0xc1,
0xb3, 0xd1, 0xc8, 0xa5, 0xa9, 0x48, 0xac, 0x7c, 0xfd, 0x5b, 0x70, 0xec,
0x9a, 0x02, 0x7e, 0x08, 0xe9, 0xb2, 0xeb, 0x9c, 0xde, 0x76, 0xc3, 0x75,
0x3b, 0x76, 0x7f, 0xae, 0x3f, 0xe5, 0x22, 0xd8, 0x28, 0x42, 0xc4, 0x80,
0x08, 0x8e, 0xe7, 0xe3, 0x06, 0x01, 0xd3, 0xa3, 0xb3, 0xbc, 0xfa, 0xd4,
0xab, 0xb5, 0x5a, 0x3d, 0xca, 0x7e, 0xe0, 0xc6, 0xcd, 0x6a, 0xcf, 0xe1,
0x03, 0xbe, 0x63, 0xea, 0xd8, 0x7a, 0x0d, 0x31, 0x11, 0x8e, 0x9b, 0xc2,
0x0d, 0x32, 0x78, 0x1d, 0x5d, 0x14, 0xc6, 0x66, 0x78, 0xed, 0x57, 0x27,
0xaa, 0xb5, 0x4a, 0xf8, 0xb3, 0xa3, 0x70, 0xff, 0xaa, 0x02, 0xbe, 0xe7,
0xf2, 0x78, 0xdf, 0xd6, 0xde, 0xc3, 0x7b, 0x3e, 0xdf, 0x9f, 0x96, 0xb0,
0x86, 0xd5, 0xaa, 0x71, 0x43, 0x2c, 0x20, 0x20, 0x34, 0x84, 0xf8, 0x69,
0x24, 0xe8, 0x60, 0x74, 0x68, 0x94, 0xbe, 0x9b, 0x37, 0x63, 0xe6, 0x0b,
0x88, 0xd1, 0x20, 0xd2, 0x00, 0x82, 0x88, 0x80, 0xe3, 0x90, 0xea, 0xea,
0xc1, 0x06, 0x9d, 0xbc, 0xf8, 0xe3, 0x67, 0xab, 0xd5, 0x72, 0xfd, 0xc8,
0x51, 0xcb, 0x4f, 0x12, 0x05, 0x0c, 0xc0, 0xf5, 0x59, 0xdf, 0x7b, 0xfb,
0xf0, 0x7d, 0xf7, 0x74, 0xd8, 0xa8, 0x8a, 0x68, 0x05, 0x56, 0x9a, 0x02,
0xda, 0x02, 0x03, 0x8e, 0xeb, 0xe1, 0x75, 0x76, 0xa3, 0xdf, 0x9d, 0x07,
0x31, 0x57, 0xfd, 0xa0, 0xe1, 0xd3, 0xf4, 0xc7, 0x0a, 0xa9, 0xee, 0xf5,
0xe8, 0x20, 0xcf, 0xf3, 0x3f, 0x7a, 0xb6, 0x28, 0xca, 0x6e, 0x3d, 0x0a,
0xf3, 0x00, 0xa9, 0x56, 0x01, 0xbe, 0xcb, 0x91, 0x1b, 0x6e, 0xda, 0x98,
0x91, 0xa8, 0x8e, 0xad, 0x56, 0xc0, 0xd2, 0x08, 0xb0, 0x42, 0x60, 0xb1,
0x82, 0xad, 0x56, 0x17, 0xcf, 0x5b, 0xfd, 0x96, 0x1c, 0x45, 0x88, 0xa6,
0xaf, 0xe0, 0x75, 0xbf, 0x9f, 0xbe, 0x0d, 0x3d, 0xd9, 0x8b, 0xe3, 0xb3,
0x0f, 0x60, 0x39, 0xb2, 0x4c, 0x80, 0x83, 0x73, 0xcf, 0xa6, 0x1b, 0x37,
0x79, 0xa6, 0x52, 0x42, 0xa2, 0x68, 0xb1, 0xe4, 0x57, 0x49, 0x97, 0x07,
0x46, 0x40, 0x9c, 0xab, 0xad, 0x41, 0x04, 0x5b, 0x0e, 0xd1, 0xe5, 0x3a,
0xa6, 0x16, 0x61, 0xeb, 0x0a, 0x09, 0x35, 0xb6, 0xae, 0xf0, 0xf2, 0x33,
0xf4, 0x5d, 0xbf, 0x2d, 0xb8, 0x34, 0x36, 0xfb, 0x45, 0x48, 0x10, 0x60,
0x44, 0xde, 0xd7, 0xd9, 0x91, 0x45, 0x4a, 0x73, 0x88, 0xd6, 0x4b, 0x03,
0x2f, 0x69, 0x03, 0x8b, 0x6d, 0x88, 0xd7, 0xc4, 0x58, 0xa2, 0xc9, 0x22,
0x6a, 0xaa, 0x84, 0x55, 0x86, 0x24, 0x33, 0x95, 0x32, 0xf9, 0x0d, 0xbd,
0x68, 0xa1, 0x37, 0x5e, 0x6b, 0xaf, 0x80, 0x88, 0xb5, 0x98, 0x28, 0x82,
0x78, 0xa0, 0xda, 0xb2, 0x5e, 0x24, 0x6e, 0x69, 0x8d, 0x5e, 0x08, 0xa9,
0x5d, 0x2a, 0x80, 0xb6, 0x89, 0xc4, 0x8b, 0xf1, 0x3d, 0x0f, 0xa5, 0x0d,
0xae, 0x43, 0x35, 0x7e, 0x7c, 0x89, 0x00, 0xd7, 0xa5, 0x54, 0xab, 0xd4,
0x7a, 0x02, 0x6b, 0x10, 0x15, 0x35, 0x16, 0xad, 0x34, 0x7c, 0x17, 0x45,
0x2c, 0xad, 0x44, 0x38, 0x53, 0x41, 0x4d, 0x95, 0x16, 0xf5, 0xac, 0x66,
0x5e, 0x67, 0x27, 0xa5, 0xc2, 0x1c, 0x0e, 0x8c, 0x2e, 0x72, 0x2e, 0x71,
0x48, 0xb9, 0x67, 0xe7, 0xc6, 0x0b, 0x38, 0xa4, 0x90, 0x50, 0x23, 0xa1,
0xc2, 0x46, 0x1a, 0x89, 0x14, 0x12, 0x35, 0xae, 0x25, 0x52, 0x88, 0x52,
0x58, 0xa5, 0x08, 0x47, 0xe6, 0x51, 0x93, 0x6b, 0x23, 0x07, 0x48, 0x6f,
0xea, 0xe3, 0xf2, 0xbf, 0x2e, 0x84, 0x46, 0x78, 0x34, 0x51, 0x40, 0xa4,
0x79, 0x74, 0xe4, 0xe2, 0x54, 0xcd, 0xcd, 0x75, 0x62, 0xb5, 0xc2, 0x2a,
0x8d, 0x68, 0x85, 0x28, 0xdd, 0x80, 0x36, 0x88, 0x32, 0x98, 0x72, 0x44,
0xed, 0xe2, 0xbb, 0xa8, 0x62, 0xb8, 0x36, 0x66, 0x20, 0xd5, 0xb3, 0x1e,
0x95, 0x5f, 0xc7, 0xc8, 0xc4, 0xac, 0x32, 0xf0, 0x48, 0xa2, 0x00, 0x63,
0xcc, 0x93, 0x93, 0x13, 0xc5, 0x4a, 0xb1, 0x18, 0xe2, 0x66, 0xf3, 0x88,
0x32, 0x48, 0xd4, 0x20, 0x15, 0xa5, 0x31, 0xf5, 0x88, 0x68, 0xaa, 0x44,
0x7d, 0x6c, 0x01, 0x89, 0x92, 0x07, 0x2d, 0xc9, 0xdc, 0x20, 0x4d, 0xfe,
0xd6, 0x7d, 0xbc, 0xf1, 0xd2, 0xc9, 0xaa, 0x20, 0xdf, 0x1e, 0x80, 0xd9,
0x44, 0x01, 0x03, 0x50, 0x57, 0x46, 0xee, 0x7d, 0xfd, 0xc4, 0xdf, 0x2b,
0x74, 0x6f, 0x00, 0xd7, 0xc7, 0xd4, 0x14, 0xba, 0x58, 0x27, 0x9c, 0xaa,
0x12, 0x8e, 0x95, 0xd1, 0x25, 0xb5, 0xe6, 0x92, 0x03, 0x38, 0xbe, 0x4f,
0xd7, 0x1d, 0xfd, 0xfc, 0xf9, 0xb5, 0x53, 0x61, 0x69, 0xa1, 0x72, 0x6a,
0x87, 0xe5, 0x07, 0xad, 0xf7, 0xbd, 0xf6, 0x07, 0x4e, 0xc2, 0xb9, 0x7e,
0xb1, 0x9b, 0xa7, 0x87, 0xa7, 0x3f, 0xb4, 0x65, 0xfb, 0x4e, 0x5f, 0x5d,
0x99, 0x45, 0x2f, 0xd4, 0x90, 0x6b, 0x4c, 0x78, 0x32, 0x79, 0x40, 0xf7,
0xfe, 0x43, 0xbc, 0x7d, 0xfa, 0xac, 0x1a, 0xbe, 0x30, 0x3a, 0xac, 0x84,
0x43, 0xf7, 0x42, 0x7d, 0x55, 0x01, 0x00, 0x5f, 0x13, 0x8e, 0x5f, 0x89,
0xf4, 0xed, 0xd3, 0xd3, 0xb3, 0x1b, 0xb7, 0xdd, 0xb6, 0xcb, 0x97, 0x52,
0x09, 0x1b, 0xd6, 0x93, 0x5c, 0x57, 0x34, 0x37, 0x9d, 0x61, 0xdd, 0xc1,
0x3b, 0xf9, 0xeb, 0xe0, 0xdf, 0xd4, 0xf0, 0x3b, 0xc3, 0xe7, 0x5d, 0x91,
0x7d, 0x0f, 0x42, 0x71, 0x99, 0xc8, 0x95, 0x02, 0x3c, 0x0d, 0xde, 0x3b,
0x0e, 0x4f, 0x75, 0xe4, 0x32, 0x77, 0xf7, 0x7f, 0x72, 0x7f, 0xd6, 0x5c,
0x3a, 0x4f, 0x34, 0x39, 0xb1, 0x36, 0xf2, 0x6c, 0x8e, 0xee, 0x03, 0x77,
0xf2, 0xd6, 0xc9, 0xc1, 0x70, 0x6c, 0x78, 0x6c, 0x48, 0x09, 0xfd, 0x03,
0xb0, 0x90, 0xe4, 0x9b, 0x58, 0x01, 0x80, 0x67, 0x40, 0x5e, 0x86, 0xdf,
0xfc, 0x51, 0xe9, 0xf7, 0x5c, 0xbe, 0x30, 0x7c, 0x4b, 0xdf, 0x6d, 0x1f,
0xf5, 0xd3, 0xd9, 0x2c, 0x7a, 0xae, 0xb0, 0x2a, 0xb9, 0x97, 0xef, 0x62,
0xdd, 0xc1, 0x4f, 0x31, 0xf8, 0x87, 0x57, 0xc2, 0xc9, 0xd1, 0x89, 0x33,
0xbe, 0x70, 0xe0, 0x9b, 0x50, 0x5e, 0xc9, 0x7f, 0xd5, 0x3f, 0xa2, 0xd8,
0x1e, 0x82, 0xaf, 0xa4, 0x5c, 0xf7, 0xe1, 0x7d, 0x07, 0x6e, 0xcf, 0xbd,
0xb7, 0x23, 0x4d, 0xf9, 0xcc, 0x5f, 0x10, 0xad, 0x97, 0xf9, 0xa5, 0x7a,
0xd6, 0x93, 0xff, 0xd8, 0xc7, 0x79, 0xe5, 0xb7, 0x2f, 0xd6, 0x0b, 0xb3,
0x73, 0xa7, 0xb2, 0xc2, 0xdd, 0xf7, 0x43, 0x6d, 0x55, 0xc1, 0xd7, 0xe0,
0x76, 0x01, 0xff, 0x24, 0x0c, 0xed, 0x14, 0x79, 0xb3, 0x70, 0x79, 0xfc,
0x33, 0xa9, 0x4c, 0xc6, 0xdf, 0xb8, 0x77, 0xaf, 0xa3, 0xa6, 0x26, 0x9b,
0x1f, 0xac, 0x86, 0x05, 0x1b, 0xae, 0x23, 0xbb, 0x67, 0x3f, 0x2f, 0x3f,
0xfd, 0x7c, 0xad, 0x30, 0xbf, 0x70, 0xe2, 0x98, 0xf0, 0xa5, 0x27, 0xc1,
0x34, 0x63, 0x34, 0xbf, 0xcb, 0x6b, 0x17, 0x90, 0x02, 0x32, 0x40, 0x0e,
0xe8, 0x00, 0x3a, 0xde, 0x82, 0x79, 0x81, 0xe3, 0xb9, 0xe9, 0xc2, 0xc1,
0x85, 0xd9, 0x42, 0x6e, 0xfb, 0x5d, 0x77, 0x79, 0xa6, 0x38, 0x8f, 0x29,
0x97, 0x48, 0x6f, 0xd9, 0x4a, 0xf0, 0x91, 0x5b, 0xf9, 0xfd, 0x13, 0xcf,
0xd5, 0x27, 0xaa, 0xb5, 0xe7, 0xbe, 0x2f, 0x3c, 0x38, 0xd3, 0x88, 0x9d,
0x06, 0xfc, 0x26, 0x62, 0xae, 0x25, 0x2f, 0x90, 0xa4, 0x16, 0xa4, 0x5b,
0x10, 0xb4, 0x1c, 0x03, 0x20, 0xe8, 0x85, 0xae, 0x2f, 0x3b, 0x7c, 0xb7,
0x37, 0x97, 0xdd, 0xf5, 0x89, 0x2f, 0x7c, 0x36, 0x1d, 0x38, 0x50, 0x0e,
0x15, 0x27, 0x7e, 0xfd, 0x42, 0x38, 0x6c, 0xf4, 0xe3, 0x3f, 0xb5, 0x3c,
0x02, 0x28, 0x20, 0x6a, 0x43, 0xd8, 0x44, 0x44, 0x63, 0x2b, 0xda, 0xa4,
0x0a, 0xf8, 0x6d, 0x02, 0x62, 0x64, 0x80, 0x2c, 0x90, 0xa9, 0x80, 0x7f,
0x0a, 0xde, 0xdc, 0x68, 0x74, 0x7a, 0xfa, 0x1f, 0x43, 0xdb, 0xd3, 0xb9,
0xac, 0xf7, 0xfa, 0xf1, 0x3f, 0x45, 0x67, 0xb4, 0xf9, 0xc5, 0x31, 0xe1,
0x77, 0xcd, 0xea, 0xb9, 0x4d, 0x38, 0x6d, 0x49, 0xb6, 0xb6, 0x42, 0x27,
0x09, 0x48, 0xb5, 0xc0, 0x4f, 0x38, 0xf7, 0x01, 0x5f, 0x20, 0x75, 0x5a,
0x38, 0x9f, 0xb6, 0x32, 0xe1, 0x8e, 0x8c, 0xef, 0x1d, 0x14, 0x79, 0xf8,
0x05, 0x78, 0xa3, 0x99, 0x95, 0x6d, 0x96, 0xb9, 0x1d, 0xba, 0xed, 0x5c,
0x27, 0xb5, 0xc0, 0x4d, 0xc8, 0x7e, 0x59, 0x1b, 0x5a, 0x04, 0x79, 0x79,
0x48, 0x97, 0x1a, 0xa5, 0xb5, 0x2d, 0x81, 0x57, 0x2a, 0x7f, 0x8c, 0x6a,
0x5c, 0x89, 0x95, 0xb6, 0xe1, 0x6a, 0xa4, 0xf1, 0x40, 0x79, 0x6d, 0x25,
0x6e, 0xcd, 0x5e, 0xd3, 0x98, 0x83, 0x18, 0xb1, 0x88, 0x5a, 0xf3, 0x7a,
0xd1, 0xae, 0xf5, 0x1e, 0xf0, 0x9a, 0x84, 0x4b, 0xb2, 0x6e, 0x22, 0xee,
0x71, 0x6c, 0xc2, 0xf2, 0x16, 0xc4, 0x19, 0xab, 0xe6, 0xfa, 0x32, 0x5b,
0xd3, 0x8b, 0xa8, 0xcd, 0xbf, 0x75, 0xb8, 0x62, 0xc4, 0x83, 0x15, 0x0b,
0x58, 0x71, 0xdf, 0xff, 0xcf, 0xd9, 0x7f, 0x00, 0xab, 0x13, 0x35, 0x3d,
0x4f, 0x21, 0x19, 0x04, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
#endif
|
dennis/bzlauncher
|
src/gui.h
|
<filename>src/gui.h
///////////////////////////////////////////////////////////////////////////
// C++ code generated with wxFormBuilder (version Sep 28 2007)
// http://www.wxformbuilder.org/
//
// PLEASE DO "NOT" EDIT THIS FILE!
///////////////////////////////////////////////////////////////////////////
#ifndef __gui__
#define __gui__
#include "stop22.h"
#include "search32.h"
#include "refresh32.h"
#include "ping32.h"
#include "favorite32.h"
#include "bzflag32.h"
#include "about32.h"
#include "../config.h"
#include <wx/string.h>
#include <wx/bitmap.h>
#include <wx/image.h>
#include <wx/menu.h>
#include <wx/gdicmn.h>
#include <wx/font.h>
#include <wx/colour.h>
#include <wx/settings.h>
#include <wx/statusbr.h>
#include <wx/toolbar.h>
#include <wx/aui/auibook.h>
#include <wx/sizer.h>
#include <wx/stattext.h>
#include <wx/textctrl.h>
#include <wx/bmpbuttn.h>
#include <wx/button.h>
#include <wx/panel.h>
#include <wx/frame.h>
#include <wx/hyperlink.h>
#include <wx/statbmp.h>
#include <wx/dialog.h>
#include <wx/statline.h>
#include <wx/combobox.h>
#include <wx/gauge.h>
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
/// Class MainFrame
///////////////////////////////////////////////////////////////////////////////
class MainFrame : public wxFrame
{
private:
protected:
enum
{
ID_CLOSE_VIEW = 1000,
ID_REFRESH_LIST,
ID_SEARCH,
ID_TOOLBAR,
ID_QUIT,
ID_LAUNCH,
ID_PING,
ID_FAVORITE,
ID_ABOUT,
};
wxMenuBar* menubar;
wxMenu* actionMenu;
wxMenu* serverMenu;
wxMenu* helpMenu;
wxStatusBar* statusBar;
wxToolBar* toolBar;
wxAuiNotebook* tabs;
wxPanel* findPanel;
wxStaticText* m_staticText1;
wxTextCtrl* queryText;
wxBitmapButton* closeBtn;
// Virtual event handlers, overide them in your derived class
virtual void EventCloseView( wxCommandEvent& event ){ event.Skip(); }
virtual void EventRefresh( wxCommandEvent& event ){ event.Skip(); }
virtual void EventToolbarToggle( wxCommandEvent& event ){ event.Skip(); }
virtual void EventQuit( wxCommandEvent& event ){ event.Skip(); }
virtual void EventLaunch( wxCommandEvent& event ){ event.Skip(); }
virtual void EventSearch( wxCommandEvent& event ){ event.Skip(); }
virtual void EventPingServer( wxCommandEvent& event ){ event.Skip(); }
virtual void EventFavoriteToggle( wxCommandEvent& event ){ event.Skip(); }
virtual void EventShowAbout( wxCommandEvent& event ){ event.Skip(); }
virtual void EventViewChanged( wxAuiNotebookEvent& event ){ event.Skip(); }
virtual void EventViewClose( wxAuiNotebookEvent& event ){ event.Skip(); }
virtual void EventSearchText( wxCommandEvent& event ){ event.Skip(); }
public:
MainFrame( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("BZLauncher " VERSION ""), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 597,601 ), long style = wxDEFAULT_FRAME_STYLE|wxTAB_TRAVERSAL|wxWANTS_CHARS );
};
///////////////////////////////////////////////////////////////////////////////
/// Class AboutDlg
///////////////////////////////////////////////////////////////////////////////
class AboutDlg : public wxDialog
{
private:
protected:
wxHyperlinkCtrl* m_hyperlink1;
wxStaticBitmap* m_bitmap1;
wxTextCtrl* m_textCtrl2;
wxButton* m_button3;
// Virtual event handlers, overide them in your derived class
virtual void EventClose( wxCommandEvent& event ){ event.Skip(); }
public:
AboutDlg( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("About"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxDEFAULT_DIALOG_STYLE );
};
///////////////////////////////////////////////////////////////////////////////
/// Class ServerDlg
///////////////////////////////////////////////////////////////////////////////
class ServerDlg : public wxDialog
{
private:
protected:
wxStaticText* serverHostPort;
wxStaticText* serverName;
wxStaticText* notice;
wxStaticLine* m_staticline2;
wxStaticText* playersLbl;
wxTextCtrl* playersVal;
wxStaticText* shotsLbl;
wxTextCtrl* shotsVal;
wxStaticText* rogueLbl;
wxTextCtrl* rogueVal;
wxStaticText* gameTypeLbl;
wxTextCtrl* gameTypeVal;
wxStaticText* redLbl;
wxTextCtrl* redVal;
wxStaticText* superFlagsLbl;
wxTextCtrl* superFlagsVal;
wxStaticText* greenLbl;
wxTextCtrl* greenVal;
wxStaticText* antidoteLbl;
wxTextCtrl* antidoteVal;
wxStaticText* blueLbl;
wxTextCtrl* blueVal;
wxStaticText* ricochetLbl;
wxTextCtrl* ricochetVal;
wxStaticText* purpleLbl;
wxTextCtrl* purpleVal;
wxStaticText* handicapLbl;
wxTextCtrl* handicapVal;
wxStaticText* observersLbl;
wxTextCtrl* observersVal;
wxStaticText* jumpLbl;
wxTextCtrl* jumpVal;
wxStaticLine* m_staticline3;
wxButton* launchBtn;
wxComboBox* teamCbx;
wxButton* closeBtn;
// Virtual event handlers, overide them in your derived class
virtual void onLaunch( wxCommandEvent& event ){ event.Skip(); }
virtual void EventClose( wxCommandEvent& event ){ event.Skip(); }
public:
ServerDlg( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("Server details"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxDEFAULT_DIALOG_STYLE );
};
///////////////////////////////////////////////////////////////////////////////
/// Class UpdatingDlg
///////////////////////////////////////////////////////////////////////////////
class UpdatingDlg : public wxDialog
{
private:
protected:
wxGauge* processIndicator;
public:
UpdatingDlg( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("Updating"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE|wxSTAY_ON_TOP );
};
#endif //__gui__
|
dennis/bzlauncher
|
src/ping32.h
|
<reponame>dennis/bzlauncher
#ifndef PING32_PNG_H
#define PING32_PNG_H
static const unsigned char ping32_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a, 0xf4, 0x00, 0x00, 0x00,
0x04, 0x73, 0x42, 0x49, 0x54, 0x08, 0x08, 0x08, 0x08, 0x7c, 0x08, 0x64,
0x88, 0x00, 0x00, 0x07, 0xf3, 0x49, 0x44, 0x41, 0x54, 0x58, 0x85, 0xc5,
0x97, 0x79, 0x90, 0x54, 0xc5, 0x1d, 0xc7, 0x3f, 0xdd, 0xfd, 0xde, 0xbc,
0x79, 0x33, 0xbb, 0xec, 0xc2, 0xee, 0xb2, 0x88, 0x20, 0x22, 0xb2, 0x1e,
0xa8, 0x49, 0x0c, 0x67, 0x44, 0x0c, 0x11, 0xd0, 0xa4, 0x52, 0x31, 0x1a,
0xff, 0xb3, 0x4a, 0x2d, 0x93, 0xbf, 0xf2, 0x8f, 0xa5, 0x04, 0x44, 0x42,
0x92, 0xc9, 0x41, 0x8a, 0xc4, 0x22, 0x49, 0x99, 0x98, 0x58, 0x26, 0x46,
0xe3, 0x51, 0xa5, 0xa4, 0x24, 0x31, 0x6a, 0x3c, 0x00, 0x39, 0x16, 0x5d,
0x57, 0x16, 0xac, 0x20, 0x9b, 0x45, 0x77, 0x57, 0x60, 0x0f, 0x04, 0xf6,
0x9a, 0x9d, 0x7b, 0xde, 0xd1, 0x9d, 0x3f, 0x66, 0x80, 0x81, 0xec, 0xe2,
0x91, 0xb2, 0xd2, 0x55, 0xbf, 0xea, 0xd7, 0xfd, 0xa6, 0xdf, 0xf7, 0xd3,
0xdf, 0xfe, 0xbd, 0x7e, 0x3d, 0xf0, 0x7f, 0x2e, 0xe2, 0xd3, 0x0c, 0x5a,
0xbf, 0x7e, 0x7d, 0x63, 0x24, 0x6a, 0x3d, 0x1e, 0x86, 0xc1, 0x8d, 0x20,
0x7e, 0xe6, 0xd8, 0xde, 0xc6, 0x7b, 0xee, 0x49, 0x24, 0x3f, 0x73, 0x80,
0x44, 0x22, 0x21, 0x9d, 0x98, 0x7d, 0xa7, 0x92, 0xf2, 0xd7, 0x57, 0x5d,
0xf5, 0xb9, 0xd8, 0x95, 0x73, 0xae, 0xb4, 0xb6, 0xef, 0xdc, 0xee, 0xf5,
0x1f, 0xed, 0xf7, 0x30, 0xfc, 0x5c, 0x62, 0x3d, 0xb8, 0x6a, 0xd5, 0xaa,
0xec, 0x67, 0x02, 0xb0, 0x61, 0xc3, 0xfa, 0x1b, 0x94, 0x25, 0x7f, 0xe5,
0x38, 0xee, 0xec, 0x5b, 0xbe, 0x75, 0xab, 0x7d, 0x5e, 0xe3, 0x14, 0x82,
0x30, 0xc4, 0xb2, 0x2c, 0x06, 0x06, 0x4e, 0xf0, 0xcf, 0x97, 0x5f, 0xf4,
0x86, 0x86, 0x06, 0x3d, 0xad, 0xf5, 0x1f, 0x7c, 0x69, 0x7e, 0xbb, 0x6e,
0xe5, 0xba, 0xde, 0xff, 0x19, 0x60, 0xd3, 0xa6, 0x4d, 0xaa, 0xfb, 0xf0,
0xfb, 0xb7, 0x5a, 0xca, 0xfa, 0x91, 0x94, 0x72, 0xf6, 0xf5, 0x5f, 0x59,
0x2e, 0xaf, 0x98, 0x73, 0xa5, 0x0c, 0x02, 0x9f, 0xe4, 0xe8, 0x30, 0x76,
0x24, 0x82, 0x40, 0x12, 0x8d, 0x46, 0x71, 0x9c, 0x28, 0x83, 0x83, 0x03,
0xec, 0xde, 0xbd, 0xb3, 0xd8, 0xd5, 0xdd, 0x6d, 0x4b, 0x29, 0x9e, 0xf7,
0x43, 0xb3, 0x71, 0xed, 0xea, 0xb5, 0x6f, 0x7c, 0x62, 0x80, 0x07, 0x1e,
0x48, 0x4c, 0x0e, 0x8c, 0x7d, 0x9b, 0xa5, 0xd4, 0xca, 0x48, 0xc4, 0x69,
0x58, 0xbe, 0x7c, 0x85, 0x3d, 0xfb, 0xe2, 0x26, 0xa1, 0xb5, 0x26, 0x95,
0x4a, 0x92, 0x4c, 0x8d, 0x52, 0x2c, 0xe4, 0x99, 0x3a, 0xf5, 0x7c, 0x30,
0x60, 0xc2, 0x10, 0x21, 0x05, 0x8e, 0xe3, 0x12, 0x8d, 0xc6, 0xc8, 0xe5,
0xb2, 0xec, 0x7d, 0xa7, 0x2d, 0x68, 0x6d, 0x7d, 0x4b, 0x2a, 0x29, 0x3f,
0x08, 0xc2, 0xf0, 0x77, 0x11, 0xcb, 0x7f, 0xf2, 0xde, 0x7b, 0x13, 0xc3,
0xe3, 0x02, 0x24, 0x12, 0x89, 0xa8, 0xeb, 0x46, 0x56, 0x48, 0x25, 0xbf,
0xa3, 0x8d, 0xfe, 0xda, 0xd4, 0xa9, 0x53, 0x83, 0x6b, 0xae, 0xb9, 0xd6,
0xb9, 0x60, 0xfa, 0x0c, 0x7c, 0xdf, 0x23, 0x93, 0xc9, 0x90, 0xc9, 0xa6,
0x29, 0x14, 0xf2, 0x60, 0x00, 0x21, 0x98, 0xd2, 0x38, 0x05, 0x93, 0xcf,
0x61, 0xd2, 0x19, 0xc8, 0xe5, 0xd0, 0x96, 0x05, 0x75, 0x93, 0x88, 0xc4,
0xab, 0x89, 0xb9, 0x31, 0x0c, 0x70, 0xf8, 0xf0, 0x21, 0x9a, 0x9b, 0x77,
0x14, 0x87, 0x86, 0x87, 0x25, 0x42, 0x6e, 0xd6, 0xbe, 0xff, 0xe0, 0x9a,
0x35, 0xeb, 0xde, 0x3c, 0x03, 0x20, 0x91, 0x48, 0x44, 0xa2, 0x31, 0xbb,
0x18, 0x8d, 0xba, 0x66, 0xf1, 0xe2, 0xc5, 0xa6, 0x69, 0xf6, 0xa5, 0x32,
0x1e, 0x8b, 0x91, 0x2b, 0xe4, 0xc9, 0x64, 0xd2, 0xe4, 0x72, 0x59, 0x7c,
0xcf, 0x03, 0x21, 0x10, 0xe5, 0x00, 0xa8, 0xaf, 0x9d, 0x08, 0x9e, 0x87,
0xc9, 0x64, 0x60, 0x70, 0x00, 0x93, 0xce, 0xa0, 0x8b, 0x45, 0xcc, 0x45,
0x33, 0xd1, 0x0d, 0xf5, 0x58, 0x96, 0x8d, 0xeb, 0xc6, 0x70, 0x9d, 0x18,
0xa3, 0xa9, 0x24, 0xbb, 0x76, 0xed, 0xd4, 0x07, 0xdf, 0xeb, 0x90, 0x4a,
0x44, 0xaa, 0x4e, 0x26, 0xab, 0x55, 0x06, 0x09, 0x00, 0xee, 0xb8, 0xfd,
0x4e, 0x51, 0x5d, 0x35, 0x41, 0x8c, 0x24, 0x87, 0x18, 0x1e, 0x1e, 0xc0,
0xf3, 0x3d, 0x82, 0x20, 0x40, 0x0a, 0x89, 0x90, 0xb2, 0x5c, 0x97, 0x21,
0x10, 0x18, 0x29, 0x21, 0x1a, 0xc5, 0x44, 0x1d, 0x4c, 0xcd, 0x04, 0xe8,
0xec, 0x42, 0x1c, 0x3f, 0x86, 0x78, 0xf3, 0x18, 0xe6, 0xea, 0x2f, 0xe0,
0x4d, 0x3b, 0x9f, 0x62, 0xb1, 0xc0, 0x28, 0x23, 0x4c, 0x9a, 0x54, 0xcf,
0x75, 0xd7, 0x7d, 0x59, 0x76, 0x76, 0xbd, 0x97, 0x59, 0xb5, 0xf2, 0xf4,
0x9b, 0x22, 0xcb, 0x0e, 0x68, 0xcb, 0x52, 0x5d, 0xa9, 0x54, 0x8a, 0x74,
0x76, 0x94, 0x63, 0xc7, 0x3f, 0x24, 0x9d, 0xc9, 0x10, 0xf8, 0x01, 0x52,
0x2a, 0xa4, 0x52, 0x28, 0xa9, 0x90, 0x4a, 0xa2, 0xa4, 0x42, 0xa9, 0x52,
0x18, 0x63, 0x20, 0x9b, 0xc5, 0xe4, 0x72, 0x18, 0xa5, 0xd0, 0x97, 0x34,
0x61, 0x2e, 0x9c, 0x09, 0xa9, 0x34, 0x6a, 0xeb, 0xeb, 0x88, 0x4c, 0x06,
0x00, 0x6d, 0x34, 0x45, 0xaf, 0xc8, 0xd0, 0xd0, 0x10, 0x52, 0xc8, 0xce,
0xca, 0x1c, 0x90, 0x27, 0x2f, 0x0c, 0xb4, 0x8f, 0x8c, 0x0c, 0x63, 0x29,
0x1b, 0xa5, 0x2c, 0xa4, 0x14, 0x08, 0x29, 0x11, 0x42, 0x20, 0x85, 0x44,
0xca, 0x4a, 0x71, 0x0b, 0xa5, 0x2c, 0xcc, 0xe0, 0x20, 0xa6, 0xb7, 0x17,
0xb1, 0xff, 0x5d, 0xc4, 0xbe, 0x77, 0xc0, 0x2b, 0xa2, 0x2f, 0x6d, 0x42,
0x4f, 0x9b, 0x0a, 0xc3, 0xc3, 0xc8, 0x9d, 0xcd, 0x18, 0xc0, 0x60, 0xb0,
0x2d, 0x9b, 0x81, 0x81, 0x13, 0x26, 0x08, 0xc3, 0x7d, 0x63, 0x02, 0x04,
0x7e, 0xd8, 0xd2, 0xd3, 0xd3, 0x53, 0x8c, 0xd8, 0x11, 0x2c, 0xcb, 0x42,
0x70, 0x7a, 0xbd, 0x85, 0x10, 0x08, 0x29, 0x90, 0xf2, 0x24, 0x88, 0xc4,
0xc2, 0x60, 0x62, 0x2e, 0xba, 0xb6, 0x16, 0x93, 0x4e, 0x23, 0x3a, 0x0e,
0x22, 0xb7, 0x6d, 0xc7, 0x18, 0x43, 0xb8, 0x60, 0x3e, 0x78, 0x1e, 0x56,
0x4b, 0x2b, 0xe4, 0x4b, 0x49, 0x1b, 0xb1, 0x1d, 0xba, 0xbb, 0xbb, 0x8a,
0xda, 0x98, 0x37, 0xc7, 0x04, 0x10, 0xc6, 0xbc, 0xd1, 0xd9, 0xf5, 0xbe,
0x65, 0xd9, 0x36, 0x96, 0xad, 0x4a, 0x09, 0x07, 0xa7, 0x01, 0x2a, 0x81,
0xa4, 0x44, 0x46, 0x1c, 0x8c, 0xe3, 0xa0, 0xeb, 0xeb, 0x08, 0x17, 0x2d,
0x84, 0x4c, 0x06, 0xb1, 0xa7, 0x0d, 0x8e, 0xf4, 0x60, 0xa2, 0x2e, 0x7a,
0xfa, 0x74, 0x44, 0x32, 0x89, 0x3a, 0xd0, 0x8e, 0x54, 0x12, 0x21, 0xa0,
0xb7, 0xaf, 0x37, 0xaa, 0xd0, 0xcd, 0x63, 0x02, 0x14, 0x0a, 0x41, 0x9b,
0xef, 0xfb, 0x26, 0x97, 0xcb, 0x11, 0x73, 0x63, 0x27, 0x97, 0xa5, 0x5c,
0x9b, 0x33, 0xda, 0x00, 0xea, 0x91, 0x3f, 0x12, 0xb9, 0xf1, 0xeb, 0x58,
0x8f, 0x3c, 0x8a, 0x71, 0x22, 0x84, 0x73, 0x2e, 0x47, 0x1c, 0x3b, 0x8e,
0x6a, 0x7d, 0xbb, 0x34, 0x62, 0xd2, 0x44, 0x48, 0xa7, 0x91, 0xdd, 0x87,
0x70, 0x22, 0x2e, 0x23, 0xc9, 0x11, 0x94, 0xad, 0x86, 0x56, 0xaf, 0xfe,
0xc1, 0xd8, 0x39, 0x90, 0x48, 0x24, 0x0a, 0x52, 0xa9, 0xed, 0x7d, 0xfd,
0xbd, 0xc6, 0x8d, 0xc6, 0x51, 0x4a, 0x95, 0x44, 0x8d, 0x29, 0x6d, 0x36,
0xc6, 0x60, 0x8c, 0x41, 0x1b, 0x83, 0xd6, 0x1a, 0xf9, 0xdc, 0x66, 0xc8,
0xe7, 0x51, 0x9b, 0xff, 0x56, 0xea, 0xaf, 0x8a, 0x23, 0x06, 0x07, 0x11,
0x5d, 0xdd, 0xa5, 0xdf, 0xba, 0x2e, 0x22, 0x9f, 0x47, 0x9c, 0x38, 0x81,
0x1b, 0x75, 0xe9, 0xec, 0xea, 0x0c, 0x4d, 0xa0, 0x9f, 0xe3, 0xac, 0x22,
0x2b, 0x1b, 0x61, 0x18, 0x3e, 0xf3, 0xce, 0xbe, 0x36, 0xcf, 0x75, 0x63,
0x58, 0x96, 0xaa, 0x10, 0xd5, 0xa5, 0xd0, 0x1a, 0xad, 0x43, 0x74, 0x18,
0xe2, 0xdf, 0x7c, 0x13, 0xb8, 0x2e, 0xc1, 0x2d, 0x37, 0x61, 0x8c, 0x41,
0x0c, 0x97, 0x36, 0x39, 0xdd, 0x50, 0x5f, 0x1a, 0x97, 0x4e, 0x97, 0x26,
0x30, 0xa1, 0x1a, 0x37, 0xea, 0xb2, 0x6f, 0xef, 0x5e, 0xad, 0x85, 0xfe,
0xeb, 0xd9, 0x00, 0x56, 0x65, 0xc3, 0x04, 0xe2, 0xf9, 0xbe, 0xfe, 0xfe,
0x87, 0x83, 0x20, 0x20, 0xea, 0x46, 0x29, 0x16, 0x3d, 0xb4, 0xd6, 0x67,
0x8e, 0x30, 0x12, 0x8d, 0x26, 0xbc, 0xe3, 0x76, 0xac, 0x6f, 0xdf, 0x59,
0xea, 0xcb, 0xe6, 0x90, 0x6f, 0xbd, 0x8d, 0xa9, 0xab, 0xc3, 0x5b, 0xb2,
0x18, 0x63, 0x0c, 0xf2, 0xc4, 0x09, 0x4c, 0xd4, 0x45, 0xcd, 0x99, 0xc3,
0x48, 0x72, 0x84, 0x7c, 0x3e, 0x97, 0x2a, 0x66, 0xc3, 0x1d, 0xe7, 0x74,
0x60, 0xed, 0xda, 0xb5, 0x43, 0x52, 0xc8, 0xcd, 0x1d, 0x1d, 0xed, 0x61,
0x75, 0xbc, 0x06, 0xa5, 0x64, 0x79, 0xd6, 0xa5, 0x08, 0xc3, 0x90, 0x30,
0x2c, 0x39, 0xa0, 0xb3, 0xd9, 0x52, 0xe2, 0x1d, 0x3d, 0x8a, 0x7a, 0xe5,
0x55, 0x88, 0x44, 0xf0, 0x17, 0xce, 0x47, 0x5f, 0x34, 0x13, 0xb2, 0x39,
0x44, 0xf7, 0x07, 0x98, 0x89, 0x35, 0xc4, 0xaf, 0x5d, 0x42, 0xdb, 0xde,
0x3d, 0x5e, 0xa8, 0xf5, 0x43, 0x89, 0x44, 0x22, 0x38, 0x27, 0x00, 0x40,
0x18, 0xf8, 0xbf, 0xd9, 0xfd, 0x46, 0xb3, 0x71, 0xa3, 0x31, 0x22, 0x51,
0x07, 0xa3, 0x0d, 0x5a, 0x87, 0xa7, 0xc4, 0xc3, 0x30, 0x20, 0xd0, 0x21,
0xba, 0x50, 0x80, 0x0f, 0x3f, 0x84, 0x23, 0x3d, 0xe0, 0x38, 0x04, 0x97,
0x5f, 0x86, 0xf7, 0xcd, 0x6f, 0x60, 0x8c, 0xc1, 0x6a, 0xde, 0x0d, 0xb6,
0x4d, 0xb8, 0x64, 0x09, 0xc2, 0x8d, 0xb1, 0x7f, 0xff, 0xbf, 0x64, 0x68,
0x9b, 0x87, 0xcf, 0xd6, 0x02, 0x50, 0x67, 0x77, 0x6c, 0xdd, 0xfa, 0x7a,
0xdf, 0xb2, 0x15, 0x4b, 0x57, 0x34, 0xd4, 0x37, 0x4c, 0x6b, 0xa8, 0x9b,
0x2c, 0x72, 0xf9, 0x2c, 0x41, 0x10, 0x60, 0x2a, 0x12, 0xd1, 0x18, 0x83,
0xb6, 0x2d, 0x54, 0xd4, 0x81, 0xb8, 0x8b, 0xbe, 0xf0, 0x42, 0x82, 0xcb,
0x2e, 0xc1, 0x28, 0x89, 0x3a, 0xd0, 0x8e, 0xf5, 0xee, 0x01, 0x4c, 0x24,
0x42, 0xf5, 0x5d, 0x77, 0xd1, 0x76, 0x60, 0xbf, 0xdf, 0xd7, 0xd7, 0xfb,
0xe7, 0xfb, 0x57, 0x7e, 0xff, 0x99, 0xb1, 0x00, 0xfe, 0xcb, 0x01, 0x00,
0x2f, 0xd0, 0xdf, 0x7b, 0xf5, 0xb5, 0x57, 0x42, 0xd7, 0x8d, 0xe1, 0xba,
0x6e, 0x69, 0x73, 0x39, 0xdb, 0x85, 0x30, 0xc4, 0x4c, 0xa8, 0x26, 0x6c,
0x6c, 0x24, 0xac, 0x99, 0x80, 0xf1, 0x8a, 0xc8, 0xfd, 0x07, 0x90, 0xef,
0x77, 0xa1, 0xab, 0xe2, 0x70, 0xf3, 0x4d, 0xe8, 0xaa, 0x2a, 0xde, 0x6a,
0x6d, 0x09, 0x8d, 0x56, 0x3f, 0x19, 0x4b, 0x67, 0x4c, 0x07, 0x00, 0xb6,
0x6d, 0xd9, 0xd6, 0x7f, 0xfd, 0xb2, 0xa5, 0x4d, 0x42, 0x8a, 0xcb, 0x2e,
0x9e, 0xd5, 0xa4, 0xb2, 0xb9, 0x0c, 0x9e, 0xe7, 0x63, 0xb4, 0x3e, 0xe5,
0x00, 0x61, 0x80, 0x23, 0x65, 0x29, 0x01, 0x87, 0x86, 0xb0, 0x0e, 0x1d,
0x86, 0x54, 0x0a, 0xa3, 0x14, 0xe1, 0x82, 0x79, 0x4c, 0xbe, 0x7a, 0x3e,
0x2f, 0xbe, 0xf4, 0x42, 0x31, 0x99, 0x1c, 0xfd, 0xf1, 0x7d, 0xab, 0xd7,
0xbc, 0x3c, 0x1e, 0xc0, 0x98, 0x0e, 0x00, 0x08, 0x53, 0xb8, 0xa7, 0xa5,
0xa5, 0x25, 0x97, 0x4a, 0xa5, 0x98, 0xdc, 0x30, 0x05, 0xdb, 0xb6, 0x4e,
0x39, 0x10, 0x04, 0x01, 0x81, 0x31, 0xe8, 0x30, 0xc4, 0x78, 0x45, 0x74,
0xe0, 0xa3, 0x5d, 0x97, 0xf0, 0x82, 0xe9, 0x78, 0x8b, 0x17, 0x51, 0x77,
0xc5, 0xe7, 0xe9, 0xec, 0x7a, 0x4f, 0x1f, 0xe9, 0x39, 0x72, 0xb8, 0xa6,
0x7a, 0xe2, 0xc6, 0xf1, 0x34, 0xc6, 0x75, 0x00, 0xe0, 0xb5, 0xd7, 0x76,
0xe4, 0xae, 0x5f, 0xbe, 0xf4, 0xdd, 0x8e, 0x8e, 0x8e, 0x5b, 0x17, 0x2e,
0x58, 0xa4, 0xa4, 0x14, 0xe4, 0xf3, 0x39, 0xfc, 0xc0, 0x3f, 0xb5, 0x37,
0xb8, 0xd5, 0x55, 0x60, 0xdb, 0x68, 0xd7, 0x25, 0xa8, 0xaf, 0x43, 0xd7,
0xd4, 0x50, 0x5b, 0xd7, 0x40, 0x10, 0x84, 0x3c, 0xbb, 0xe9, 0xd9, 0x3c,
0xda, 0xbf, 0xee, 0xee, 0xbb, 0xef, 0x1d, 0xf8, 0x54, 0x00, 0x00, 0x5b,
0xb7, 0xbc, 0xde, 0xb9, 0x6c, 0xd9, 0xd2, 0x09, 0x3d, 0x7d, 0x47, 0xe6,
0xce, 0x9f, 0xb7, 0xc8, 0x02, 0x4d, 0xae, 0x90, 0x23, 0xf0, 0x7d, 0x8c,
0x36, 0xc4, 0xe2, 0x31, 0x8c, 0x94, 0x18, 0x55, 0xfa, 0x76, 0xd4, 0x56,
0xd7, 0x52, 0x55, 0x55, 0xc3, 0x5f, 0x9e, 0x7a, 0xcc, 0x0b, 0x8a, 0xfe,
0x6d, 0xf7, 0xdd, 0xb7, 0xee, 0x9c, 0xe7, 0xc1, 0x8f, 0x04, 0x00, 0xb8,
0xe6, 0x4b, 0xd7, 0x6e, 0x2f, 0x14, 0x0b, 0x0b, 0x8f, 0xf6, 0xf7, 0xcd,
0x98, 0xf7, 0xc5, 0x05, 0x4a, 0x59, 0x92, 0xa2, 0x57, 0xa4, 0x50, 0x28,
0x12, 0xaf, 0x8a, 0x9f, 0xfa, 0x3e, 0x4c, 0xaa, 0x9d, 0x44, 0x75, 0xbc,
0x86, 0x27, 0x9e, 0x7a, 0xcc, 0x4f, 0x26, 0x47, 0x1f, 0xba, 0x7f, 0xcd,
0xba, 0x87, 0x00, 0x7d, 0xae, 0x67, 0x7f, 0x14, 0x80, 0x05, 0xb8, 0x3b,
0x76, 0xec, 0x88, 0xff, 0xbb, 0xbd, 0xe3, 0xd5, 0x59, 0xb3, 0x66, 0x5e,
0xd1, 0xd3, 0xd7, 0x3b, 0x63, 0xde, 0xd5, 0xf3, 0x55, 0x55, 0xbc, 0x8a,
0x50, 0x07, 0x08, 0x09, 0x52, 0x0a, 0xce, 0x9b, 0x7c, 0x3e, 0x11, 0xcb,
0xe1, 0x89, 0x27, 0x1f, 0xf7, 0x7b, 0xfb, 0xfa, 0x9e, 0x4c, 0xfc, 0xf0,
0xa7, 0xbf, 0x00, 0x1c, 0xc0, 0x2e, 0x6b, 0x98, 0xf1, 0x60, 0xc6, 0x03,
0x88, 0x00, 0x2e, 0x10, 0x03, 0x62, 0xe9, 0x74, 0xda, 0x7d, 0xbb, 0x75,
0xcf, 0xce, 0xa6, 0xd9, 0xb3, 0x66, 0x1c, 0x3c, 0xd8, 0x31, 0xeb, 0x92,
0xa6, 0x4b, 0xe5, 0xb4, 0x69, 0x33, 0x70, 0x22, 0x0e, 0x93, 0xeb, 0xa7,
0x70, 0xfc, 0xf8, 0x31, 0x9e, 0x7a, 0xfa, 0x89, 0xf0, 0xd0, 0xe1, 0x43,
0x4f, 0xff, 0x72, 0xc3, 0xc6, 0xdf, 0x97, 0xe1, 0x15, 0xa5, 0x24, 0x17,
0xe5, 0xd0, 0x63, 0x41, 0x8c, 0x07, 0x60, 0x9f, 0x1d, 0xbe, 0xef, 0xdb,
0xcd, 0xbb, 0x76, 0xb7, 0x4c, 0x69, 0x6c, 0x1c, 0x3a, 0x7a, 0xac, 0x7f,
0x7e, 0x72, 0x74, 0xc4, 0x34, 0x36, 0x34, 0xca, 0x2d, 0xdb, 0xb6, 0x04,
0xbb, 0x76, 0xed, 0xf2, 0xf6, 0xb4, 0xb6, 0x6d, 0x78, 0xf4, 0x4f, 0x8f,
0xff, 0xbd, 0x42, 0x48, 0x03, 0x61, 0x45, 0xf8, 0x63, 0x01, 0x8c, 0xf7,
0xc7, 0x44, 0x50, 0xb2, 0xd0, 0x2d, 0xd7, 0x27, 0x23, 0x02, 0x44, 0xe6,
0xce, 0x9d, 0x3b, 0xfd, 0x86, 0xaf, 0x2e, 0xfb, 0x6e, 0x75, 0x75, 0xf5,
0x8a, 0xd1, 0xd1, 0xd1, 0x57, 0xfe, 0xf1, 0xc2, 0x4b, 0xbf, 0x6f, 0xdf,
0xdf, 0x7e, 0xbc, 0x2c, 0xe2, 0x03, 0xc5, 0x8a, 0xc8, 0x03, 0x39, 0xca,
0x07, 0xdf, 0x8f, 0x0b, 0x50, 0x79, 0xdf, 0x2a, 0x0b, 0x9f, 0x04, 0x38,
0x65, 0x6f, 0x7d, 0x7d, 0xbd, 0x3d, 0x38, 0x38, 0x18, 0x70, 0x7a, 0x8d,
0x83, 0x0a, 0x80, 0xc2, 0x78, 0xb3, 0xfe, 0x24, 0x00, 0xe3, 0x8d, 0x11,
0x15, 0xd7, 0xa7, 0x0f, 0x4e, 0x67, 0x1e, 0x9a, 0x3e, 0x56, 0xf9, 0x0f,
0xd9, 0x62, 0xfe, 0xad, 0x6e, 0x90, 0x13, 0xf4, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif
|
dennis/bzlauncher
|
src/about32.h
|
#ifndef ABOUT32_PNG_H
#define ABOUT32_PNG_H
static const unsigned char about32_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a, 0xf4, 0x00, 0x00, 0x00,
0x04, 0x73, 0x42, 0x49, 0x54, 0x08, 0x08, 0x08, 0x08, 0x7c, 0x08, 0x64,
0x88, 0x00, 0x00, 0x08, 0x6e, 0x49, 0x44, 0x41, 0x54, 0x58, 0x85, 0xc5,
0x97, 0x7b, 0x70, 0x55, 0xd5, 0x15, 0xc6, 0x7f, 0x7b, 0x9f, 0x73, 0x6e,
0x6e, 0x6e, 0xde, 0xb9, 0x97, 0x20, 0x84, 0x47, 0x5e, 0x04, 0x12, 0x02,
0x11, 0x05, 0x05, 0x22, 0x05, 0x44, 0x0a, 0xa2, 0x28, 0xd6, 0xe2, 0x4c,
0xa7, 0x75, 0xa8, 0x76, 0xac, 0xa3, 0x33, 0x3a, 0x63, 0x67, 0xb4, 0xd3,
0x87, 0x6d, 0x1c, 0x2b, 0x7d, 0x4d, 0xff, 0x68, 0xcb, 0xd8, 0x56, 0x1d,
0x29, 0x76, 0xaa, 0x45, 0xc6, 0xe7, 0x0c, 0xa1, 0xa9, 0xa0, 0x11, 0x5a,
0x01, 0x8d, 0x41, 0x1e, 0x01, 0xcc, 0x83, 0x24, 0x4a, 0x42, 0x42, 0x72,
0xf3, 0xbc, 0xaf, 0xdc, 0xdc, 0xb3, 0x77, 0xff, 0x38, 0xe7, 0xde, 0x24,
0xd5, 0x19, 0x69, 0xa7, 0x33, 0xee, 0x99, 0x35, 0xe7, 0xdc, 0x39, 0x77,
0xaf, 0xf5, 0x9d, 0x6f, 0x7d, 0x6b, 0xad, 0xb3, 0xe1, 0x4b, 0x5e, 0xe2,
0x4a, 0xff, 0xb8, 0x6e, 0x5d, 0xad, 0xd9, 0x91, 0x61, 0xad, 0x11, 0x88,
0xed, 0x02, 0xb1, 0x46, 0x43, 0x00, 0xc8, 0x71, 0x1f, 0x8f, 0x08, 0x18,
0x10, 0xe8, 0x23, 0x36, 0x7a, 0x5f, 0x71, 0x78, 0xe2, 0x48, 0x43, 0x43,
0x6d, 0xe2, 0xff, 0x02, 0xa0, 0x68, 0x5b, 0x6d, 0xae, 0x18, 0x4f, 0xfb,
0x31, 0x82, 0xfb, 0xca, 0xe6, 0xcd, 0xe0, 0xc6, 0x15, 0xa5, 0x59, 0x2b,
0xaa, 0xe6, 0x8a, 0xab, 0x02, 0x59, 0xf8, 0xb3, 0xd3, 0x01, 0x18, 0x1c,
0x8d, 0xd2, 0x1b, 0x1c, 0xa3, 0xb1, 0xf9, 0xa2, 0x3e, 0xf4, 0x41, 0xfb,
0x58, 0x6b, 0xe7, 0x65, 0xd0, 0x3c, 0xab, 0xd3, 0xc6, 0x7f, 0xd6, 0xf9,
0x7a, 0xed, 0xf0, 0xff, 0x0c, 0xa0, 0x68, 0xf3, 0xce, 0x87, 0xa5, 0x21,
0x9e, 0xdc, 0x5c, 0xb3, 0x28, 0xfd, 0xfe, 0xaf, 0xaf, 0xb4, 0xca, 0xe7,
0x05, 0xae, 0x88, 0xb3, 0xb6, 0x4f, 0x83, 0x3c, 0xf3, 0xca, 0xf1, 0x89,
0xfd, 0x87, 0xcf, 0x46, 0x95, 0x96, 0x8f, 0x77, 0xd6, 0x7d, 0xff, 0x77,
0xff, 0x15, 0x80, 0xa2, 0x75, 0xb5, 0x5e, 0xed, 0xf3, 0xfe, 0x75, 0x71,
0xe9, 0xcc, 0x4d, 0x4f, 0x3e, 0xf8, 0xd5, 0x8c, 0xca, 0xe2, 0x02, 0x10,
0x8e, 0xe3, 0x7f, 0x9d, 0xfc, 0x84, 0x13, 0x1f, 0x5f, 0x22, 0x38, 0x1a,
0x61, 0x70, 0x24, 0x86, 0x10, 0x10, 0xc8, 0x4d, 0xc7, 0x9f, 0x93, 0xc1,
0xb2, 0xf2, 0x59, 0xac, 0x5e, 0x3a, 0x97, 0x92, 0x39, 0xf9, 0x00, 0x7c,
0xdc, 0xd9, 0xcf, 0xe3, 0x4f, 0xbf, 0x15, 0x3e, 0xdd, 0xd6, 0x5b, 0x4f,
0x38, 0xfa, 0xcd, 0xce, 0x86, 0xda, 0xd8, 0x17, 0x02, 0x58, 0xbc, 0xbd,
0xd6, 0x13, 0x0e, 0xa7, 0xbd, 0xbf, 0x6d, 0x7d, 0x55, 0xc5, 0x4f, 0xee,
0xdf, 0xe0, 0x49, 0xf7, 0x58, 0xb4, 0x7e, 0x1a, 0xe4, 0xb9, 0x37, 0x1a,
0x69, 0x3c, 0xdb, 0x8d, 0x34, 0x24, 0x86, 0x94, 0x08, 0x21, 0x90, 0x52,
0x20, 0x10, 0x29, 0x2f, 0x5a, 0x6b, 0xb4, 0xd6, 0x2c, 0xaf, 0x28, 0x64,
0xc7, 0x2d, 0x57, 0x53, 0x3a, 0x27, 0x9f, 0x58, 0x3c, 0xc1, 0x53, 0xcf,
0xbe, 0x1d, 0x7f, 0xe5, 0xd0, 0xe9, 0x73, 0x3e, 0x5f, 0xec, 0xba, 0xe6,
0x7d, 0xb5, 0xf1, 0xa9, 0xf1, 0x8c, 0xe9, 0xe1, 0xb5, 0xc8, 0x2c, 0x3e,
0xf6, 0xea, 0xb6, 0x1b, 0xab, 0x56, 0xee, 0x7c, 0x68, 0x53, 0x9a, 0x65,
0x1a, 0xbc, 0xde, 0x70, 0x96, 0x27, 0x9e, 0x7b, 0x9b, 0x4b, 0x03, 0x21,
0x4c, 0xd3, 0xc0, 0x9a, 0x62, 0xa6, 0x61, 0x60, 0x9a, 0x06, 0x86, 0x29,
0x31, 0x0c, 0x89, 0x69, 0x18, 0x48, 0x43, 0x72, 0x29, 0x18, 0xe2, 0xad,
0xe3, 0xed, 0x64, 0xf9, 0xd2, 0xa8, 0x2c, 0x9e, 0xc1, 0x8d, 0x2b, 0x4a,
0x8d, 0xbe, 0xa1, 0x70, 0xde, 0xc9, 0x96, 0x81, 0x6b, 0x86, 0x5b, 0x0e,
0xee, 0x85, 0x27, 0x3e, 0x1f, 0x40, 0xf1, 0x16, 0xef, 0xa3, 0xab, 0xae,
0x2e, 0xba, 0xf7, 0x37, 0x8f, 0xdc, 0x92, 0x6e, 0x18, 0x92, 0xdf, 0xef,
0x3d, 0xca, 0x9e, 0xfd, 0x1f, 0x61, 0x18, 0x06, 0xa6, 0x69, 0x62, 0x59,
0x6e, 0x70, 0xcb, 0xf9, 0x6d, 0x9a, 0xc6, 0xa4, 0x49, 0x03, 0xc3, 0x65,
0xc7, 0x30, 0x24, 0x00, 0x8d, 0xe7, 0x7b, 0x08, 0x45, 0xe2, 0x5c, 0x5b,
0x31, 0x9b, 0x35, 0xcb, 0x8a, 0xcd, 0x33, 0xed, 0x7d, 0x73, 0x43, 0xd9,
0xfb, 0xe3, 0x43, 0x2d, 0x07, 0xdf, 0xfb, 0x4c, 0x0a, 0x0a, 0xef, 0xd8,
0xe9, 0xcf, 0xd4, 0x56, 0xcb, 0x9b, 0xbf, 0xfd, 0x76, 0xfe, 0xbc, 0x99,
0xb9, 0xbc, 0x54, 0x7f, 0x92, 0xe7, 0xde, 0xf8, 0x10, 0xd3, 0x32, 0xa7,
0xbc, 0xad, 0x64, 0x69, 0xd9, 0x0c, 0x96, 0x94, 0x14, 0x50, 0x51, 0x14,
0xa0, 0x20, 0xcf, 0x47, 0x6e, 0x56, 0x3a, 0xe3, 0xf1, 0x04, 0x7d, 0x83,
0x61, 0x9a, 0x5a, 0xfa, 0xa8, 0x3f, 0xde, 0x41, 0x28, 0x1a, 0xc7, 0x56,
0x0a, 0xdb, 0x56, 0x24, 0x6c, 0xc5, 0xdd, 0x9b, 0x97, 0x72, 0xe7, 0xfa,
0x0a, 0x2e, 0x5e, 0x1e, 0x65, 0xeb, 0xc3, 0xbb, 0x07, 0x47, 0x89, 0x97,
0x77, 0xbf, 0xf6, 0xc3, 0xe0, 0x34, 0x06, 0xfc, 0xa5, 0x37, 0xed, 0xba,
0xe7, 0xf6, 0xe5, 0xd7, 0xdf, 0xbc, 0x7a, 0xa1, 0x3c, 0x73, 0xa1, 0x8f,
0x9f, 0xef, 0x39, 0x8c, 0x69, 0x18, 0x58, 0x2e, 0x00, 0xcb, 0x72, 0xee,
0x7f, 0xfd, 0xc0, 0x57, 0x58, 0x34, 0xdf, 0xcf, 0x8c, 0x5c, 0x1f, 0x3e,
0xaf, 0x07, 0xc3, 0x90, 0xa4, 0x79, 0x4c, 0xf2, 0xb2, 0xbc, 0x2c, 0x9a,
0x9f, 0xcf, 0xaa, 0xaa, 0xd9, 0x9c, 0x6a, 0xef, 0x27, 0x16, 0xb7, 0x1d,
0x9d, 0x00, 0xa7, 0xda, 0xfb, 0xa8, 0x2e, 0x9b, 0x49, 0x49, 0x61, 0x1e,
0x13, 0xb6, 0xf2, 0x9c, 0x38, 0xdd, 0x5d, 0x30, 0xd4, 0x72, 0xf0, 0x4d,
0x00, 0x09, 0xb0, 0x78, 0x5d, 0x6d, 0xa6, 0x65, 0xca, 0xbb, 0xee, 0xb9,
0x6d, 0x85, 0xa1, 0xd1, 0x3c, 0xbd, 0xef, 0x38, 0x52, 0xc8, 0x69, 0x14,
0x3b, 0x40, 0x4c, 0x84, 0x10, 0x08, 0xe1, 0x10, 0x17, 0x4f, 0x28, 0xe2,
0x09, 0x85, 0x94, 0x12, 0xe9, 0x0a, 0x33, 0x3f, 0xcb, 0xcb, 0xf6, 0xf5,
0x0b, 0xb1, 0x2c, 0x13, 0x8f, 0x65, 0x62, 0x59, 0x26, 0x86, 0x34, 0xd8,
0xbd, 0xff, 0x23, 0x34, 0x70, 0xf7, 0x96, 0x6b, 0x0c, 0xd3, 0x34, 0xee,
0x5a, 0xbc, 0xae, 0x36, 0x13, 0xc0, 0x04, 0x88, 0xf8, 0xbc, 0x5b, 0xd6,
0x5e, 0x5d, 0x2c, 0xf3, 0xb3, 0xd3, 0x39, 0xd5, 0xd6, 0x4b, 0xcb, 0x27,
0x41, 0x3c, 0x1e, 0x73, 0x8a, 0xe8, 0xdc, 0x34, 0x98, 0x06, 0x09, 0x5b,
0x71, 0xfc, 0x7c, 0x3f, 0xef, 0x35, 0xf7, 0xd2, 0x3b, 0x14, 0xc1, 0x10,
0x82, 0x0d, 0xcb, 0xe7, 0x73, 0x7b, 0x4d, 0x69, 0x0a, 0x5c, 0xe5, 0x7c,
0x3f, 0x1e, 0xcb, 0x24, 0x21, 0x6d, 0x5c, 0xac, 0x74, 0x74, 0x0f, 0x73,
0xae, 0x73, 0x80, 0xca, 0xa2, 0x00, 0x6b, 0xaf, 0x2d, 0x91, 0x07, 0x8f,
0xb6, 0x6e, 0x01, 0x5e, 0x96, 0x8e, 0xf6, 0xf5, 0x8e, 0x9b, 0xae, 0x5b,
0xe0, 0x43, 0xc0, 0x91, 0x8f, 0xba, 0x1c, 0x31, 0x19, 0x4e, 0xde, 0x0d,
0x37, 0xf7, 0x49, 0x30, 0xbf, 0x78, 0xe9, 0x04, 0xaf, 0xfd, 0xf3, 0x02,
0x03, 0xa3, 0xe3, 0xa4, 0x79, 0x2c, 0x2c, 0x8f, 0xc5, 0xd9, 0xae, 0x41,
0xb4, 0xd6, 0x29, 0x31, 0x4b, 0x49, 0x8a, 0xb1, 0xa9, 0x2c, 0xbe, 0xdf,
0xdc, 0x0d, 0xc0, 0xc6, 0x95, 0xe5, 0x3e, 0x21, 0xc5, 0x8e, 0x14, 0x03,
0x68, 0x96, 0x55, 0x95, 0xcd, 0x04, 0xa0, 0xf5, 0x93, 0xe0, 0x34, 0x35,
0x9b, 0xc6, 0x64, 0x2a, 0x2c, 0xd3, 0x24, 0x34, 0x6e, 0x63, 0x59, 0xa6,
0x0b, 0x4e, 0x22, 0xa5, 0x60, 0xcd, 0x92, 0xc2, 0x54, 0x0f, 0xd0, 0x5a,
0x73, 0xb1, 0x3f, 0x8c, 0x65, 0x19, 0xae, 0x6b, 0x8d, 0xd6, 0xa0, 0x94,
0xe6, 0xc2, 0xa5, 0x21, 0x00, 0x2a, 0x4b, 0x0a, 0xd0, 0x5a, 0x2f, 0x9b,
0x04, 0x20, 0xf0, 0x17, 0xe4, 0x67, 0x02, 0x4e, 0x5f, 0x97, 0x6e, 0xf0,
0xa9, 0xe6, 0x00, 0x91, 0x93, 0x3d, 0xc0, 0xb5, 0x9a, 0xc5, 0x57, 0xb1,
0xaa, 0x72, 0x66, 0x2a, 0xb8, 0xad, 0x14, 0xef, 0x9e, 0xee, 0xc3, 0x32,
0x0d, 0xd0, 0x4e, 0x73, 0x52, 0x4a, 0x63, 0x18, 0x92, 0x91, 0xd0, 0x38,
0x08, 0xc1, 0x8c, 0xdc, 0x0c, 0x34, 0xda, 0x3f, 0x95, 0x01, 0xf2, 0xdc,
0xc1, 0x32, 0x16, 0x89, 0xbb, 0xa2, 0x12, 0x93, 0x40, 0xa4, 0x93, 0x12,
0xc3, 0x6d, 0x3c, 0xc9, 0xd2, 0x5c, 0xbb, 0x74, 0x16, 0x6b, 0x16, 0x4f,
0x09, 0x6e, 0xdb, 0x1c, 0x68, 0xec, 0xa6, 0x67, 0x30, 0x8a, 0x69, 0x18,
0x4e, 0x60, 0x25, 0x31, 0x6c, 0xc7, 0x4f, 0x24, 0xe6, 0x0c, 0xc8, 0x9c,
0xcc, 0xb4, 0x54, 0xfd, 0xcb, 0x64, 0x37, 0x18, 0x1a, 0x8d, 0xba, 0x0f,
0xbd, 0x48, 0x21, 0xa6, 0x9b, 0x94, 0x18, 0x52, 0x4c, 0x63, 0xa3, 0xba,
0x38, 0x9f, 0xd5, 0x8b, 0x02, 0x28, 0xa5, 0x50, 0x4a, 0x61, 0xdb, 0x36,
0x75, 0x1f, 0x5e, 0xe2, 0xe3, 0xee, 0x31, 0xb7, 0x3b, 0x4e, 0x6f, 0x4c,
0x52, 0x0a, 0xb2, 0x33, 0xbd, 0x00, 0x8c, 0x84, 0xc7, 0x53, 0x2d, 0x48,
0x02, 0x08, 0x4d, 0xb0, 0x7f, 0x28, 0x0c, 0x40, 0x20, 0xcf, 0x87, 0x10,
0x38, 0x8a, 0x96, 0x8e, 0x49, 0x29, 0x10, 0x2e, 0x2b, 0x49, 0x87, 0xd7,
0x2f, 0xf4, 0xa7, 0x82, 0x2b, 0xa5, 0x38, 0xd6, 0x32, 0x44, 0x57, 0x7f,
0xd4, 0x65, 0xca, 0x01, 0x9c, 0x64, 0x52, 0xb8, 0x2f, 0x92, 0x9f, 0xed,
0x00, 0x08, 0x0e, 0x47, 0x10, 0x10, 0x9c, 0x04, 0x20, 0xe4, 0x89, 0xe6,
0x0b, 0x97, 0x01, 0x58, 0x38, 0x2f, 0xe0, 0xd4, 0xb9, 0x10, 0x08, 0x40,
0x20, 0xdc, 0xf2, 0x22, 0x55, 0x66, 0x52, 0x08, 0xb2, 0xd3, 0x8d, 0x14,
0xf5, 0x4a, 0x29, 0xda, 0xfa, 0x22, 0x29, 0x86, 0xa4, 0x10, 0x08, 0x91,
0xbc, 0x3a, 0x7b, 0x11, 0x82, 0x92, 0xd9, 0x79, 0x00, 0x9c, 0xeb, 0xec,
0x47, 0x48, 0x79, 0x22, 0xa5, 0x01, 0xad, 0xf5, 0x9e, 0x43, 0xc7, 0xdb,
0xd6, 0xdd, 0xb1, 0xbe, 0xd2, 0x57, 0xb3, 0x74, 0x2e, 0x07, 0x8e, 0xb6,
0x4d, 0xf6, 0x68, 0x91, 0xbc, 0x4c, 0x19, 0x9c, 0x42, 0xf0, 0x87, 0xfa,
0x0e, 0xd2, 0x3c, 0x16, 0x1e, 0x8f, 0x85, 0xc7, 0x63, 0xa2, 0x34, 0xa9,
0x06, 0xe5, 0xe2, 0x9f, 0xb2, 0x9c, 0xdd, 0xcb, 0x17, 0xcd, 0x02, 0xe0,
0xad, 0x63, 0xad, 0x11, 0x65, 0xab, 0x3d, 0x29, 0x00, 0xbe, 0x48, 0xac,
0xee, 0x48, 0xd3, 0x05, 0x35, 0x3c, 0x16, 0xa3, 0xb2, 0xa4, 0x80, 0x05,
0xf3, 0xfc, 0x74, 0xf5, 0x8e, 0x90, 0x14, 0x68, 0xf2, 0x4d, 0xd1, 0xc9,
0xb2, 0xd2, 0xec, 0x58, 0x3b, 0x27, 0x35, 0x92, 0x01, 0x5e, 0x3e, 0xd6,
0x8f, 0x52, 0xca, 0x61, 0x24, 0xb9, 0x07, 0x8d, 0x76, 0x9d, 0x14, 0xcd,
0xca, 0x61, 0xc1, 0x9c, 0x7c, 0x46, 0x43, 0xe3, 0xbc, 0xf3, 0x7e, 0xab,
0xf2, 0x45, 0x62, 0x75, 0xa9, 0x14, 0x34, 0x37, 0xd4, 0x86, 0x12, 0x09,
0xb5, 0xf7, 0x2f, 0x75, 0x4d, 0xb6, 0x00, 0xee, 0xbd, 0x75, 0x19, 0x42,
0x08, 0xd7, 0x99, 0x53, 0xc7, 0xc9, 0x7b, 0xa5, 0x34, 0xca, 0x56, 0x58,
0x06, 0x58, 0x06, 0x98, 0xd2, 0xb1, 0xf8, 0x44, 0x82, 0x89, 0x84, 0x4d,
0xc2, 0x56, 0x28, 0x5b, 0x39, 0xff, 0x53, 0x1a, 0xad, 0x1c, 0xe0, 0x77,
0xad, 0xaf, 0x00, 0x01, 0x7f, 0xfb, 0xc7, 0x49, 0xdb, 0xb6, 0xd5, 0xde,
0xe6, 0x86, 0xda, 0xd0, 0x64, 0x15, 0x00, 0xf1, 0x84, 0xf5, 0xd8, 0xee,
0xd7, 0x3e, 0x18, 0xee, 0xee, 0x1f, 0x63, 0xd1, 0x7c, 0x3f, 0xdf, 0xd8,
0x58, 0xe5, 0x04, 0x57, 0x4e, 0x8e, 0xed, 0xe4, 0xd5, 0x9d, 0x70, 0x53,
0x05, 0xa8, 0x94, 0x22, 0x3e, 0x31, 0xc1, 0xc4, 0x84, 0x4d, 0x22, 0x61,
0x93, 0xb0, 0x6d, 0x6c, 0xdb, 0x4e, 0x3d, 0xdb, 0x5a, 0x53, 0x46, 0x69,
0x61, 0x2e, 0x7d, 0xc1, 0x10, 0x7f, 0xda, 0x77, 0x6c, 0x38, 0x16, 0xb7,
0x1e, 0x4b, 0xc6, 0x4d, 0x4d, 0xc3, 0xd1, 0xf6, 0xfa, 0x68, 0x4e, 0xd9,
0x06, 0xdd, 0xd1, 0x33, 0x5c, 0xb3, 0xb9, 0xa6, 0xdc, 0xaa, 0x2c, 0x0a,
0x10, 0x8e, 0x4d, 0xd0, 0xde, 0x3d, 0xe4, 0x28, 0x5a, 0x48, 0xa7, 0x22,
0x84, 0x93, 0xd1, 0x6b, 0x4a, 0x73, 0xb1, 0xb5, 0x26, 0x61, 0x3b, 0xa0,
0x3e, 0x68, 0x1b, 0x26, 0x61, 0x2b, 0x07, 0x80, 0xcb, 0xc4, 0x44, 0xc2,
0xe6, 0x86, 0x25, 0x85, 0x6c, 0x5d, 0x5d, 0x4a, 0xc2, 0x56, 0xfc, 0x60,
0x57, 0x7d, 0xa4, 0xad, 0xab, 0xff, 0xa9, 0xae, 0x03, 0x8f, 0x1e, 0xfa,
0x0f, 0x89, 0x25, 0x97, 0x16, 0xa5, 0xb7, 0xfe, 0xea, 0xf5, 0xed, 0x9b,
0xaa, 0x37, 0xfd, 0xf4, 0xbb, 0x1b, 0xd2, 0x84, 0x10, 0x1c, 0x6a, 0xec,
0x60, 0xef, 0xa1, 0x73, 0x48, 0x29, 0xdd, 0xe9, 0x96, 0xfc, 0x18, 0x71,
0x9b, 0x93, 0x5b, 0x66, 0x5a, 0x83, 0xd2, 0x0e, 0xfd, 0x09, 0x37, 0x05,
0xb7, 0xad, 0x2e, 0xe1, 0x86, 0x25, 0x85, 0x68, 0x60, 0xe7, 0xf3, 0x0d,
0xe3, 0x2f, 0xd6, 0x35, 0xd5, 0xb7, 0xbd, 0xf9, 0xe8, 0x36, 0x10, 0xfa,
0x33, 0x0c, 0x38, 0xeb, 0x09, 0x66, 0x57, 0xdf, 0xf0, 0xea, 0xc9, 0xf3,
0x03, 0x5b, 0x07, 0x46, 0xa2, 0x81, 0x55, 0x4b, 0xe7, 0x19, 0x0b, 0xe6,
0xfa, 0xa9, 0x2e, 0x2b, 0x20, 0x38, 0x1a, 0xa5, 0x6f, 0x28, 0xe2, 0x40,
0x76, 0xb7, 0x27, 0xf3, 0x3c, 0xf5, 0xe3, 0x23, 0x61, 0xdb, 0x2c, 0x28,
0xcc, 0xe5, 0x5b, 0x1b, 0x2b, 0xa8, 0x2a, 0x0e, 0x30, 0x3e, 0x61, 0xf3,
0xcb, 0x17, 0x0e, 0xc7, 0x5f, 0xac, 0x6b, 0x3a, 0x93, 0x96, 0x16, 0xd9,
0xdc, 0x7f, 0x76, 0xbd, 0x3d, 0xbd, 0x3e, 0x3e, 0x67, 0xcd, 0x59, 0xf5,
0x48, 0xba, 0x95, 0x1f, 0x78, 0xa9, 0xba, 0x7c, 0xce, 0xc6, 0xa7, 0x1e,
0xba, 0xd9, 0x57, 0xea, 0x7e, 0xe5, 0x5e, 0xbc, 0x3c, 0xca, 0xa9, 0xf6,
0x7e, 0x5a, 0xbb, 0x87, 0x18, 0x0b, 0x4f, 0x30, 0x16, 0x8b, 0x23, 0x85,
0x20, 0x27, 0xd3, 0x4b, 0x8e, 0x2f, 0x8d, 0xb2, 0xc2, 0x5c, 0xaa, 0x8a,
0xfd, 0xcc, 0x0e, 0x38, 0x73, 0xa5, 0xe3, 0xd2, 0x30, 0x3f, 0xda, 0xf5,
0xf7, 0x68, 0x53, 0xf3, 0x85, 0x77, 0x7b, 0x8f, 0xbd, 0x70, 0x5f, 0x74,
0xb0, 0x2d, 0x08, 0x44, 0xbf, 0x10, 0x00, 0xe0, 0x03, 0xb2, 0x0b, 0xd7,
0x7e, 0xef, 0x41, 0x6f, 0x76, 0xe0, 0x91, 0x3b, 0x37, 0x2c, 0xf3, 0x7e,
0xe7, 0x6b, 0x2b, 0xcc, 0xf9, 0x57, 0xe5, 0x5e, 0xd1, 0x51, 0xea, 0xd3,
0xcb, 0xa3, 0x3c, 0xff, 0x46, 0x63, 0xe2, 0xe5, 0x03, 0x1f, 0x8e, 0x47,
0x83, 0x5d, 0xcf, 0x74, 0x1f, 0xfd, 0xe3, 0x6e, 0x60, 0xcc, 0xb5, 0x21,
0x40, 0x7d, 0x11, 0x80, 0x34, 0x20, 0x0b, 0xc8, 0x4a, 0x2f, 0x28, 0x9d,
0xed, 0xaf, 0xdc, 0xf6, 0x80, 0x95, 0xe1, 0xdf, 0x56, 0x55, 0x3a, 0x4b,
0x6c, 0x5e, 0x53, 0x99, 0x7e, 0x6d, 0x45, 0xa1, 0x98, 0x91, 0xe7, 0x23,
0x27, 0xc3, 0x0b, 0x02, 0x46, 0x43, 0xe3, 0x0c, 0x8c, 0x44, 0x68, 0x3a,
0xdf, 0xa3, 0xeb, 0x0e, 0x37, 0xc7, 0xce, 0xb4, 0xf6, 0xe8, 0xd8, 0x58,
0x4f, 0x7d, 0xf0, 0xd4, 0xab, 0x7f, 0x1e, 0x1f, 0xee, 0xe9, 0x75, 0x03,
0x87, 0x80, 0x41, 0x20, 0x7c, 0x25, 0x0c, 0x80, 0x53, 0xa2, 0x19, 0x40,
0x36, 0x90, 0x61, 0x59, 0xbe, 0xac, 0xec, 0xf2, 0x8d, 0x2b, 0x7d, 0x05,
0x0b, 0x36, 0x5a, 0xe9, 0xd9, 0xd5, 0x60, 0xe4, 0x68, 0x21, 0x7d, 0x8e,
0x13, 0x15, 0x45, 0xdb, 0xa3, 0xf1, 0xf0, 0xd0, 0x99, 0x48, 0xdf, 0xf9,
0x77, 0x46, 0xdb, 0xde, 0x69, 0x4a, 0x24, 0x62, 0x21, 0x1c, 0xba, 0x43,
0xc0, 0xb0, 0x0b, 0xe2, 0x33, 0xe7, 0xc5, 0x2b, 0x3d, 0x9c, 0x1a, 0x80,
0x05, 0x78, 0x5d, 0x76, 0xbc, 0x38, 0x5d, 0xd4, 0x72, 0x81, 0x2a, 0xc0,
0x06, 0xe2, 0xae, 0xc5, 0x80, 0x71, 0xf7, 0xfe, 0x8a, 0x0e, 0xa9, 0x5f,
0xda, 0xfa, 0x37, 0x3d, 0x87, 0xb9, 0xea, 0xf9, 0xa4, 0xbb, 0x03, 0x00,
0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif
|
microsoft/ai-freezer-monitor
|
AIFreezerMonitor/database.h
|
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
//
// Class that represents Adafruit IO feed
#include "AdafruitIO_WiFi.h"
class database
{
public:
database(char *name);
void write(float data);
void init();
private:
AdafruitIO_Feed *feed;
void run();
};
|
microsoft/ai-freezer-monitor
|
FreezerTempAlert/cls.h
|
<filename>FreezerTempAlert/cls.h<gh_stars>1-10
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
//
// all classes used in program
#include <Wire.h>
#include <Adafruit_I2CDevice.h>
#include <Adafruit_I2CRegister.h>
#include "Adafruit_MCP9600.h"
#include "AdafruitIO_WiFi.h"
#ifndef CLS_H_
#define CLS_H_
#define MCP9600_DEFAULT_I2C 0x67
class temp_sensor
{
public:
temp_sensor(uint8_t i2c = MCP9600_DEFAULT_I2C);
float temperature();
void init();
private:
Adafruit_MCP9600 _mcp;
uint8_t _i2cAddress;
};
class database
{
public:
database();
void write(float data);
void init();
private:
AdafruitIO_Feed *temperature;
void run();
};
class alert_handler
{
public:
alert_handler();
void send();
private:
AdafruitIO_Feed *temp_alert;
};
class SimpleTimer
{
private:
uint64_t _start;
uint64_t _stop;
uint64_t _elapsed;
uint64_t _interval;
public:
SimpleTimer(long interval, bool readyStatus = false);
void start();
void stop();
float elapsed();
bool isReady();
uint32_t interval;
private:
bool _ready;
};
#endif
|
microsoft/ai-freezer-monitor
|
AIFreezerMonitor/predictor.h
|
<reponame>microsoft/ai-freezer-monitor
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
//
// Utilities used to process data for ML
#ifndef PREDICTOR_H_
#define PREDICTOR_H_
float normalize(float value, float min, float max);
float meanOf(float *value, int array_size);
float mae(float *x, float *y, int array_size);
#endif
|
pauljlohman/Pegasus
|
libraries/Pegasus_CtrlData/Pegasus_Log.h
|
/*
Atmel i2c Serial EEPROM
256-Kbit (32,768 bytes)
AT24C256C 8SOIC
64-byte page
*/
#include "EEPROM_I2C.h"
#ifndef PEGASUS_LOG_H
#define PEGASUS_LOG_H
// log label
#define LOG_IMU 0x20 // yaw, pitch, roll
#define LOG_PID 0x40 // yaw, pitch, roll
#define LOG_RX 0x60 // yaw, pitch, roll, throttle
#define LOG_MP 0x80 // FL, FR, BR, BL
/*
6 byte format
IMU and PID format
label lll..... 3 bits
time .ttttttt tttttttt 15 bits
roll /x ......xx xxxxxxxx 10 bits
pitch/y ......yy yyyyyyyy 10 bits
yaw /z ......zz zzzzzzzz 10 bits
lllttttt tttttttt ttxxxxxx xxxxyyyy yyyyyyzz zzzzzzzz
lllttttt tttttttt ttrrrrrr rrrrpppp ppppppyy yyyyyyyy
RX and MP format
label lll..... 3 bits
time ...ttttt tttttttt 13 bits
roll /FL xxxxxxxx 8 bits
pitch /FR yyyyyyyy 8 bits
yaw /BR zzzzzzzz 8 bits
throttle/BL wwwwwwww 8 bits
lllttttt tttttttt xxxxxxxx yyyyyyyy zzzzzzzz wwwwwwww
*/
#define BUFSIZE 30
class Pegasus_Log{
EEPROM_I2C mem;
byte buf[BUFSIZE];
byte logSize = 0; //size in bytes
unsigned short memAddr = 0;
unsigned short byteCapacity = 32768;
// constants
float imu_f = 511.0 / 180.0;
short pid_f = 128;
short mp_f = 65535 / 255;
float rx_f = 127.0 / 45.0;
public:
void init(){
mem.devAddr = B1010000;
};
void clear(){
mem.clear(byteCapacity);
};
void append_IMU(unsigned long t, float x, float y, float z){
if(logSize+6 > BUFSIZE){
return;//writeLog();
}
uint16_t us;
int16_t s;
// 65535ms ~ 1min, greatest 15 bits
// uint16_t(t >> 1) & 0x7FFF = 0ttttttt tttttttt
us = (uint16_t)(t >> 1) & 0x7FFF;
// byte(0ttttttt tttttttt >> 10) = 000ttttt
// lll00000 | 000ttttt = lllttttt
buf[logSize] = LOG_IMU | (byte)(us >> 10); logSize++;
// byte(0ttttttt tttttttt >> 2) = tttttttt
buf[logSize] = (byte)(us >> 2); logSize++;
// byte(0ttttttt tttttttt << 6) = tt000000
buf[logSize] = (byte)(us << 6);
// scale 180 to 511
// int16_t(x) & 0x3FF = 000000xx xxxxxxxx
s = (int16_t)(x * imu_f) & 0x3FF;
// byte(000000xx xxxxxxxx >> 4) = 00xxxxxx
// tt000000 | 00xxxxxx = ttxxxxxx
buf[logSize] = buf[logSize] | (byte)(s >> 4); logSize++;
//byte(000000xx xxxxxxxx << 4) = xxxx0000
buf[logSize] = (byte)(s << 4);
// scale 180 to 511
// int16_t(y) & 0x3FF = 000000yy yyyyyyyy
s = (int16_t)(y * imu_f) & 0x3FF;
// byte(000000yy yyyyyyyy >> 6) = 0000yyyy
// xxxx0000 | 0000yyyy = xxxxyyyy
buf[logSize] = buf[logSize] | (byte)(s >> 6); logSize++;
// byte(000000yy yyyyyyyy << 2) = yyyyyy00
buf[logSize] = (byte)(s << 2);
// scale 180 to 511
// int16_t(z) & 0x3FF = 000000zz zzzzzzzz
s = (int16_t)(z * imu_f) & 0x3FF;
// byte(000000zz zzzzzzzz >> 8) = 000000zz
// yyyyyy00 | 000000zz = yyyyyyzz
buf[logSize] = buf[logSize] | (byte)(s >> 8); logSize++;
//byte(000000zz zzzzzzzz) = zzzzzzzz
buf[logSize] = (byte)(s); logSize++;
};
void append_PID(unsigned long t, long roll, long pitch, long yaw){
if(logSize+6 > BUFSIZE){
return;//writeLog();
}
uint16_t us;
int16_t s;
// 65535ms ~ 1min, greatest 15 bits
// uint16_t(t >> 1) & 0x7FFF = 0ttttttt tttttttt
us = (uint16_t)(t >> 1) & 0x7FFF;
// byte(0ttttttt tttttttt >> 10) = 000ttttt
// lll00000 | 000ttttt = lllttttt
buf[logSize] = LOG_PID | (byte)(us >> 10); logSize++;
// byte(0ttttttt tttttttt >> 2) = tttttttt
buf[logSize] = (byte)(us >> 2); logSize++;
// byte(0ttttttt tttttttt << 6) = tt000000
buf[logSize] = (byte)(us << 6);
// f = 511 = 65535 * 0.0077973601892119;
// int16_t(roll / f) & 0x3FF = 000000xx xxxxxxxx
s = (int16_t)(roll / pid_f) & 0x3FF;
// byte(000000xx xxxxxxxx >> 4) = 00xxxxxx
// tt000000 | 00xxxxxx = ttxxxxxx
buf[logSize] = buf[logSize] | (byte)(s >> 4); logSize++;
//byte(000000xx xxxxxxxx << 4) = xxxx0000
buf[logSize] = (byte)(s << 4);
// int16_t(pitch / f) & 0x3FF = 000000yy yyyyyyyy
s = (int16_t)(pitch / pid_f) & 0x3FF;
// byte(000000yy yyyyyyyy >> 6) = 0000yyyy
// xxxx0000 | 0000yyyy = xxxxyyyy
buf[logSize] = buf[logSize] | (byte)(s >> 6); logSize++;
// byte(000000yy yyyyyyyy << 2) = yyyyyy00
buf[logSize] = (byte)(s << 2);
// f = 511 = 65535 * 0.0077973601892119;
// int16_t(yaw / f) & 0x3FF = 000000zz zzzzzzzz
s = (int16_t)(yaw / pid_f) & 0x3FF;
// byte(000000zz zzzzzzzz >> 8) = 000000zz
// yyyyyy00 | 000000zz = yyyyyyzz
buf[logSize] = buf[logSize] | (byte)(s >> 8); logSize++;
//byte(000000zz zzzzzzzz) = zzzzzzzz
buf[logSize] = (byte)s; logSize++;
};
void append_MP(unsigned long t, long fl, long fr, long br, long bl){
if(logSize+6 > BUFSIZE){
return;//writeLog();
}
byte x, y, z, w;
x = (byte)(fl / mp_f);
y = (byte)(fr / mp_f);
z = (byte)(br / mp_f);
w = (byte)(bl / mp_f);
append_v4(LOG_MP, t, x, y, z, w);
};
void append_RX(unsigned long t, float roll, float pitch, float yaw, unsigned short throttle){
if(logSize+6 > BUFSIZE){
return;//writeLog();
}
int8_t x, y, z, w;
x = (int8_t)(roll * rx_f);
y = (int8_t)(pitch * rx_f);
z = (int8_t)(yaw * rx_f);
w = (byte)(throttle / mp_f);
append_v4(LOG_RX, t, x, y, z, w);
};
void append_v4(byte label, unsigned long t, byte x, byte y, byte z, byte w){
uint16_t us;
// 65535ms ~ 1min, greatest 13 bits
// uint16_t(t >> 3) & 0x1FFF = 000ttttt tttttttt
us = (uint16_t)(t >> 3) & 0x1FFF;
// byte(000ttttt tttttttt >> 8) = 000ttttt
// lll00000 | 000ttttt = lllttttt
buf[logSize] = label | (byte)(us >> 8); logSize++;
// byte(000ttttt tttttttt) = tttttttt
buf[logSize] = (byte)us; logSize++;
buf[logSize] = x; logSize++;
buf[logSize] = y; logSize++;
buf[logSize] = z; logSize++;
buf[logSize] = w; logSize++;
};
byte getLogSize(){
return logSize;
};
void writeOnFull(){
if (logSize >= BUFSIZE){
writeLog();
}
};
void writeLog(){
// Serial.printf("Saving %i bytes at %i \n",logSize, memAddr);
// for(byte i=0; i<logSize; i++){
// Serial.printf("%X ", buf[i]);
// } Serial.println();
mem.write(memAddr, logSize, buf);
memAddr = getSafeAddr( memAddr + logSize);
logSize = 0;
// Serial.printf("Done\n");
};
unsigned short getSafeAddr(unsigned short addr){
if( (addr + 4) % 64 == 0 ){
return (addr + 4) % byteCapacity;
}else{
return addr % byteCapacity;
}
};
void readLog(){
byte rBuf[6];
byte label;
unsigned short i = 0;
unsigned short previous_i = 0;
Serial.print("Reading Saved Log\n");
while(i<byteCapacity){
i = getSafeAddr(i);
if(i<previous_i){break;}//prevent wrapping back
previous_i = i;
mem.read(i, 6, rBuf);
label = rBuf[0] & 0xE0;
switch (label){
case LOG_IMU:
print_IMU(rBuf);
break;
case LOG_PID:
print_PID(rBuf);
break;
case LOG_RX:
print_RX(rBuf);
break;
case LOG_MP:
print_MP(rBuf);
break;
default: // unknown label
Serial.printf("ERROR at %i, ", i);
for(byte j=0; j<6; j++){
Serial.printf("%X ",rBuf[j]);
}
Serial.println();
return;
}
i += 6;
}
Serial.print("End Reading Log\n");
};
void print_IMU(byte *d){
Serial.print("IMU ");
/*
for(byte j=0; j<6; j++){
Serial.printf("%X ",d[j]);
} Serial.println();
*/
uint16_t us;
int16_t s;
// ushort(lllttttt) << 11 = ttttt000 00000000
// ttttt000 00000000 | ushort(tttttttt) << 3 = tttttttt ttttt000
// tttttttt ttttt000 | ((ttxxxxxx >> 5) & 0x6) = tttttttt ttttttt0
us = (uint16_t)d[0] << 11;
us = us | ((uint16_t)d[1] << 3);
us = us | ((d[2] >> 5) & 0x6);
Serial.printf("%u ",us); // time
// (ttxxxxxx << 8) | xxxxyyyy = ttxxxxxxx xxxxyyyy
// ttxxxxxx xxxxyyyy & 0x3FF0 = 00xxxxxx xxxx0000
// 00xxxxxx xxxx0000 << 2 = xxxxxxxx xx000000
// xxxxxxxx xx000000 >> 6 = ......xx xxxxxxxx
s = ((int16_t)d[2] << 8) | (int16_t)d[3];
s = s & 0x3FF0;
s = s << 2;
s = s >> 6;
Serial.printf("%.2f ",s / imu_f); // x angle
// (xxxxyyyy << 8) | yyyyyyzz = xxxxyyyy yyyyyyzz
// xxxxyyyy yyyyyyzz & 0xFC = 0000yyyy yyyyyy00
// 0000yyyy yyyyyy00 << 4 = yyyyyyyy yy000000
// yyyyyyyy yy000000 >> 6 = ......yy yyyyyyyy
s = ((int16_t)d[3] << 8) | (int16_t)d[4];
s = s & 0xFFC;
s = s << 4;
s = s >> 6;
Serial.printf("%.2f ",s / imu_f); // y angle
// (yyyyyyzz << 8) | zzzzzzzz = yyyyyyzz zzzzzzzz
// yyyyyyzz zzzzzzzz & 0x3FF = 000000zz zzzzzzzz
// 000000zz zzzzzzzz << 6 = zzzzzzzz zz000000
// zzzzzzzz zz000000 >> 6 = ......zz zzzzzzzz
s = ((int16_t)d[4] << 8) | (int16_t)d[5];
s = s & 0x3FF;
s = s << 6;
s = s >> 6;
Serial.printf("%.2f\n",s / imu_f); // z angle
};
void print_PID(byte *d){
Serial.print("PID ");
/*
for(byte j=0; j<6; j++){
Serial.printf("%X ",d[j]);
} Serial.println();
*/
uint16_t us;
int16_t s;
// ushort(lllttttt) << 11 = ttttt000 00000000
// ttttt000 00000000 | ushort(tttttttt) << 3 = tttttttt ttttt000
// tttttttt ttttt000 | ((ttrrrrrr >> 5) & 0x6) = tttttttt ttttttt0
us = (uint16_t)d[0] << 11;
us = us | ((uint16_t)d[1] << 3);
us = us | ((d[2] >> 5) & 0x6);
Serial.printf("%u ",us); // time
// (ttrrrrrr << 8) | rrrrpppp = ttrrrrrr rrrrpppp
// ttrrrrrr rrrrpppp & 0x3FF0 = 00rrrrrr rrrr0000
// 00rrrrrr rrrr0000 << 2 = rrrrrrrr rr000000
// rrrrrrrr rr000000 >> 6 = ......rr rrrrrrrr
s = ((int16_t)d[2] << 8) | (int16_t)d[3];
s = s & 0x3FF0;
s = s << 2;
s = s >> 6;
Serial.printf("%i ",s * pid_f); // roll
// (rrrrpppp << 8) | ppppppyy = rrrrpppp ppppppyy
// rrrrpppp ppppppyy & 0xFC = 0000pppp pppppp00
// 0000pppp pppppp00 << 4 = pppppppp pp000000
// pppppppp pp000000 >> 6 = ......pp pppppppp
s = ((int16_t)d[3] << 8) | (int16_t)d[4];
s = s & 0xFFC;
s = s << 4;
s = s >> 6;
Serial.printf("%i ",s * pid_f); // pitch
// (ppppppyy << 8) | yyyyyyyy = ppppppyy yyyyyyyy
// ppppppyy yyyyyyyy & 0x3FF = 000000yy yyyyyyyy
// 000000yy yyyyyyyy << 6 = yyyyyyyy yy000000
// yyyyyyyy yy000000 >> 6 = ......yy yyyyyyyy
s = ((int16_t)d[4] << 8) | (int16_t)d[5];
s = s & 0x3FF;
s = s << 6;
s = s >> 6;
Serial.printf("%i\n",s * pid_f); // yaw
};
void print_RX(byte *d){
Serial.print("Nav ");
/*
for(byte j=0; j<6; j++){
Serial.printf("%X ",d[j]);
} Serial.println();
*/
uint16_t us;
int8_t s;
// lllttttt & 0x1F = 000ttttt
// ushort(000ttttt) << 11 = ttttt000 00000000
// ttttt000 00000000 | ushort(tttttttt) << 3 = tttttttt ttttt000
us = (uint16_t)(d[0] & 0x1F) << 11;
us = us | (uint16_t)d[1] << 3;
Serial.printf("%u ",us); // time
s = (int16_t)d[2];
Serial.printf("%.2f ",s / rx_f); // roll
s = (int16_t)d[3];
Serial.printf("%.2f ",s / rx_f); // pitch
s = (int16_t)d[4];
Serial.printf("%.2f ",s / rx_f); // yaw
us = (uint16_t)d[5];
Serial.printf("%u\n",us * mp_f); // throttle
};
void print_MP(byte *d){
Serial.print("MP ");
/*
for(byte j=0; j<6; j++){
Serial.printf("%X ",d[j]);
} Serial.println();
*/
uint16_t us;
// lllttttt & 0x1F = 000ttttt
// ushort(000ttttt) << 11 = ttttt000 00000000
// ttttt000 00000000 | ushort(tttttttt) << 3 = tttttttt ttttt000
us = (uint16_t)(d[0] & 0x1F) << 11;
us = us | (uint16_t)d[1] << 3;
Serial.printf("%u ",us); // time
us = (uint16_t)d[2];
Serial.printf("%u ",us * mp_f); // FL
us = (uint16_t)d[3];
Serial.printf("%u ",us * mp_f); // FR:
us = (uint16_t)d[4];
Serial.printf("%u ",us * mp_f); // BR
us = (uint16_t)d[5];
Serial.printf("%u\n",us * mp_f);// BL
};
};
#endif // PEGASUS_LOG_H
|
pauljlohman/Pegasus
|
libraries/ZETA1/radio_config_rake.h
|
/*! @file radio_config.h
* @brief This file contains the automatically generated
* configurations.
*
* @n WDS GUI Version: 3.2.10.0
* @n Device: Si4455 Rev.: B1
*
API Rev B1A
Freq. 915 Mhz, 250 kHz spacing
FSK 20kbs
preamble 8 bytes, std pattern
sync word 2 bytes
payload 16 bytes
CRC transmit and checked at end
Interrupts
PH Packet_RX
PH Packet_Sent
GPIO
NIRQ active low interrupt signal, pull-up
FRR
A Chip inter pending
B Modem inter pending
C Packet Handler inter pending
D Latched RSSI value as defined in MODEM_RSSI_CONTROL
*/
#ifndef RADIO_CONFIG_H_
#define RADIO_CONFIG_H_
#include "si4455_defs.h"
// USER DEFINED PARAMETERS
// Define your own parameters here
// INPUT DATA
/*
// Crys_freq(Hz): 30000000 Crys_tol(ppm): 30 IF_mode: 2 High_perf_Ch_Fil: 1 OSRtune: 0 Ch_Fil_Bw_AFC: 0 ANT_DIV: 0 PM_pattern: 0
// MOD_type: 2 Rsymb(sps): 20000 Fdev(Hz): 30000 RXBW(Hz): 185000 Manchester: 0 AFC_en: 1 Rsymb_error: 0.0 Chip-Version: 2
// RF Freq.(MHz): 915 API_TC: 28 fhst: 250000 inputBW: 0 BERT: 0 RAW_dout: 0 D_source: 0 Hi_pfm_div: 0
//
// # WB filter 3 (BW = 185.22 kHz); NB-filter 3 (BW = 185.22 kHz)
//
// Modulation index: 3
*/
// CONFIGURATION PARAMETERS
#define RADIO_CONFIGURATION_DATA_RADIO_XO_FREQ 30000000L
#define RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER 0x00
#define RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH 0x10
#define RADIO_CONFIGURATION_DATA_RADIO_STATE_AFTER_POWER_UP 0x03
#define RADIO_CONFIGURATION_DATA_RADIO_DELAY_CNT_AFTER_RESET 0xF000
// CONFIGURATION COMMANDS
/*
// Command: RF_POWER_UP
// Description: Command to power-up the device and select the operational mode and functionality.
*/
#define RF_POWER_UP 0x02, 0x01, 0x00, 0x01, 0xC9, 0xC3, 0x80
/*
// Set properties: RF_INT_CTL_ENABLE_2
// Number of properties: 2
// Group ID: 0x01
// Start ID: 0x00
// Default values: 0x04, 0x00,
// Descriptions:
// INT_CTL_ENABLE - This property provides for global enabling of the three interrupt groups (Chip, Modem and Packet Handler) in order to generate HW interrupts at the NIRQ pin.
// INT_CTL_PH_ENABLE - Enable individual interrupt sources within the Packet Handler Interrupt Group to generate a HW interrupt on the NIRQ output pin.
*/
#define RF_INT_CTL_ENABLE_2 0x11, 0x01, 0x02, 0x00, 0x01, 0x30
/*
// Set properties: RF_FRR_CTL_A_MODE_4
// Number of properties: 4
// Group ID: 0x02
// Start ID: 0x00
// Default values: 0x01, 0x02, 0x09, 0x00,
// Descriptions:
// FRR_CTL_A_MODE - Fast Response Register A Configuration.
// FRR_CTL_B_MODE - Fast Response Register B Configuration.
// FRR_CTL_C_MODE - Fast Response Register C Configuration.
// FRR_CTL_D_MODE - Fast Response Register D Configuration.
*/
#define RF_FRR_CTL_A_MODE_4 0x11, 0x02, 0x04, 0x00, 0x08, 0x06, 0x04, 0x0A
/*
// Set properties: RF_EZCONFIG_XO_TUNE_1
// Number of properties: 1
// Group ID: 0x24
// Start ID: 0x03
// Default values: 0x40,
// Descriptions:
// EZCONFIG_XO_TUNE - Configure the internal capacitor frequency tuning bank for the crystal oscillator.
*/
#define RF_EZCONFIG_XO_TUNE_1 0x11, 0x24, 0x01, 0x03, 0x52
/*
// Command: RF_WRITE_TX_FIFO
// Description: Writes data byte(s) to the TX FIFO.
*/
#define RF_WRITE_TX_FIFO 0x66, 0x92, 0x6B, 0xF5, 0xD2, 0x58, 0x06, 0xC7, 0x83, 0x63, 0x44, 0xF7, 0xB2, 0x44, 0x81, 0x49, 0x18, 0x1D, 0x1B, 0x3C, \
0x62, 0x79, 0x71, 0x52, 0xA6, 0xF9, 0x4A, 0x89, 0x2A, 0x3D, 0x58, 0x74, 0xC2, 0x4D, 0x23, 0x9F, 0x28, 0x1C, 0x95, 0x74, \
0x2A, 0x34, 0x3E, 0x10, 0x2D, 0xFC, 0x20, 0x58, 0xBB, 0x98, 0xC2, 0x76, 0x2B, 0xA2, 0x8A, 0xCA, 0x18, 0xBB, 0xBA, 0xA4, \
0x06, 0x32, 0xF6, 0xA4, 0x1E, 0x59, 0x7F, 0x12, 0x0D, 0xB5, 0x12, 0xD5, 0x3B, 0xC4, 0x26, 0x6F, 0x90, 0x04, 0xAB, 0xC1, \
0x83, 0x82, 0x0D, 0x00, 0xA6, 0x66, 0x82, 0xF6, 0x9D, 0x82, 0x6D, 0x8F, 0xB4, 0xFA, 0xCF, 0x12, 0x79, 0xF4, 0x0C, 0x41, \
0xBE, 0x91, 0xEC, 0x40, 0x2A, 0xA2, 0xDA, 0x4F, 0xDC, 0x54, 0x90, 0x2B, 0x59, 0x59
/*
// Command: RF_NOP
// Description: No Operation command.
*/
#define RF_NOP 0x00
/*
// Command: RF_WRITE_TX_FIFO_1
// Description: Writes data byte(s) to the TX FIFO.
*/
#define RF_WRITE_TX_FIFO_1 0x66, 0x15, 0xFF, 0xFA, 0x9F, 0xE5, 0x53, 0x1E, 0x36, 0x96, 0xC8, 0x86, 0x28, 0xE2, 0x80, 0xA0, 0xA8, 0x8F, 0xF5, 0xDE, \
0x08, 0x19, 0x45, 0x8E, 0x6B, 0x65, 0x68, 0xA0, 0x6B, 0xA5, 0x9B, 0x6A, 0xFA, 0x75, 0x1B, 0x84, 0x23, 0x97, 0x93, 0xAB, \
0x9D, 0x79, 0x7B, 0x23, 0x28, 0x31, 0x7D, 0x0D, 0xE2, 0x55, 0x3F, 0x60, 0x30, 0x2F, 0x66, 0xDF, 0x64, 0x91, 0x16, 0xB8, \
0x10, 0xF2, 0x67, 0xDD, 0x61, 0x83, 0x6E, 0xC4, 0x0E, 0xBD, 0x84, 0x29, 0x13, 0x7D, 0x4F, 0x33, 0xF5, 0x93, 0x73, 0xE0, \
0x92, 0x2D, 0xA6, 0x95, 0x5E, 0xB8, 0x79, 0x26, 0x3A, 0x45, 0x23, 0xEF, 0x38, 0xAF, 0x13, 0x23, 0x3D, 0x49, 0x50, 0xF0, \
0x3D, 0xAF, 0x48, 0xFD, 0x4C, 0xAD, 0x6E, 0x20, 0x56, 0x39, 0x45, 0xA8
/*
// Command: RF_EZCONFIG_CHECK
// Description: Validates the EZConfig array was written correctly.
*/
#define RF_EZCONFIG_CHECK 0x19, 0xAB, 0x29
/*
// Command: RF_GPIO_PIN_CFG
// Description: Configures the GPIO pins.
*/
#define RF_GPIO_PIN_CFG 0x13, 0x01, 0x01, 0x01, 0x01, 0x67, 0x00, 0x00
// AUTOMATICALLY GENERATED CODE!
// DO NOT EDIT/MODIFY BELOW THIS LINE!
// --------------------------------------------
#ifndef FIRMWARE_LOAD_COMPILE
#define RADIO_CONFIGURATION_DATA_ARRAY { \
0x07, RF_POWER_UP, \
0x06, RF_INT_CTL_ENABLE_2, \
0x08, RF_FRR_CTL_A_MODE_4, \
0x05, RF_EZCONFIG_XO_TUNE_1, \
0x72, RF_WRITE_TX_FIFO, \
0x01, RF_NOP, \
0x70, RF_WRITE_TX_FIFO_1, \
0x03, RF_EZCONFIG_CHECK, \
0x08, RF_GPIO_PIN_CFG, \
0x00 \
}
#else
#define RADIO_CONFIGURATION_DATA_ARRAY { 0 }
#endif
// DEFAULT VALUES FOR CONFIGURATION PARAMETERS
#define RADIO_CONFIGURATION_DATA_RADIO_XO_FREQ_DEFAULT 30000000L
#define RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER_DEFAULT 0x00
#define RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH_DEFAULT 0x10
#define RADIO_CONFIGURATION_DATA_RADIO_STATE_AFTER_POWER_UP_DEFAULT 0x01
#define RADIO_CONFIGURATION_DATA_RADIO_DELAY_CNT_AFTER_RESET_DEFAULT 0x1000
#define RADIO_CONFIGURATION_DATA_RADIO_PATCH_INCLUDED 0x00
#define RADIO_CONFIGURATION_DATA_RADIO_PATCH_SIZE 0x00
#define RADIO_CONFIGURATION_DATA_RADIO_PATCH { }
#ifndef RADIO_CONFIGURATION_DATA_ARRAY
#error "This property must be defined!"
#endif
#ifndef RADIO_CONFIGURATION_DATA_RADIO_XO_FREQ
#define RADIO_CONFIGURATION_DATA_RADIO_XO_FREQ RADIO_CONFIGURATION_DATA_RADIO_XO_FREQ_DEFAULT
#endif
#ifndef RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER
#define RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER_DEFAULT
#endif
#ifndef RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH
#define RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH_DEFAULT
#endif
#ifndef RADIO_CONFIGURATION_DATA_RADIO_STATE_AFTER_POWER_UP
#define RADIO_CONFIGURATION_DATA_RADIO_STATE_AFTER_POWER_UP RADIO_CONFIGURATION_DATA_RADIO_STATE_AFTER_POWER_UP_DEFAULT
#endif
#ifndef RADIO_CONFIGURATION_DATA_RADIO_DELAY_CNT_AFTER_RESET
#define RADIO_CONFIGURATION_DATA_RADIO_DELAY_CNT_AFTER_RESET RADIO_CONFIGURATION_DATA_RADIO_DELAY_CNT_AFTER_RESET_DEFAULT
#endif
#define RADIO_CONFIGURATION_DATA { \
Radio_Configuration_Data_Array, \
RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER, \
RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH, \
RADIO_CONFIGURATION_DATA_RADIO_STATE_AFTER_POWER_UP, \
RADIO_CONFIGURATION_DATA_RADIO_DELAY_CNT_AFTER_RESET \
}
#endif /* RADIO_CONFIG_H_ */
|
pauljlohman/Pegasus
|
libraries/MPU9255/MPU9255.h
|
// I2Cdev library collection - MPU9255 I2C device class
// Based on InvenSense MPU-9255 register map document rev. 2.0, 5/19/2011 (RM-MPU-6000A-00)
// 10/3/2011 by <NAME> <<EMAIL>>
// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
//
// Changelog:
// ... - ongoing debug release
// NOTE: THIS IS ONLY A PARIAL RELEASE. THIS DEVICE CLASS IS CURRENTLY UNDERGOING ACTIVE
// DEVELOPMENT AND IS STILL MISSING SOME IMPORTANT FEATURES. PLEASE KEEP THIS IN MIND IF
// YOU DECIDE TO USE THIS PARTICULAR CODE FOR ANYTHING.
/* ============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2012 <NAME>
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 _MPU9255_H_
#define _MPU9255_H_
#include "I2Cdev.h"
// Tom Carpenter's conditional PROGMEM code
// http://forum.arduino.cc/index.php?topic=129407.0
#ifdef __AVR__
#include <avr/pgmspace.h>
#else
// Teensy 3.0 library conditional PROGMEM code from <NAME>
#ifndef __PGMSPACE_H_
#define __PGMSPACE_H_ 1
#include <inttypes.h>
#define PROGMEM
#define PGM_P const char *
#define PSTR(str) (str)
#define F(x) x
typedef void prog_void;
typedef char prog_char;
typedef unsigned char prog_uchar;
typedef int8_t prog_int8_t;
typedef uint8_t prog_uint8_t;
typedef int16_t prog_int16_t;
typedef uint16_t prog_uint16_t;
typedef int32_t prog_int32_t;
typedef uint32_t prog_uint32_t;
#define strcpy_P(dest, src) strcpy((dest), (src))
#define strcat_P(dest, src) strcat((dest), (src))
#define strcmp_P(a, b) strcmp((a), (b))
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#define pgm_read_float(addr) (*(const float *)(addr))
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
#define pgm_read_word_near(addr) pgm_read_word(addr)
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
#define pgm_read_float_near(addr) pgm_read_float(addr)
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
#define pgm_read_word_far(addr) pgm_read_word(addr)
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
#define pgm_read_float_far(addr) pgm_read_float(addr)
#endif
#endif
//Magnetometer Registers
#define AK8963C_ADDRESS 0x0C
// Read-only Reg
#define AK8963C_WIA 0x00 // should be 0x48
#define AK8963C_INFO 0x01 // ??
#define AK8963C_ST1 0x02 // Status1 - [0] DRDY "Data Ready", [1] DOR "Data Overrun"
#define AK8963C_HXL 0x03 //
#define AK8963C_HXH 0x04 //
#define AK8963C_HYL 0x05 //
#define AK8963C_HYH 0x06 //
#define AK8963C_HZL 0x07 //
#define AK8963C_HZH 0x08 //
#define AK8963C_ST2 0x09 //
// Write/Read Reg
#define AK8963C_CNTL1 0x0A // Control1 - [3:0] Operation mode setting, [4] Output bit setting
#define AK8963C_CNTL2 0x0B //
#define AK8963C_ASTC 0x0C // [6] SELF
#define AK8963C_TS1 0x0D //
#define AK8963C_TS2 0x0E //
#define AK8963C_I2CDIS 0x0F //
// Read-only Reg ( ROM )
#define AK8963C_ASAX 0x10 //
#define AK8963C_ASAY 0x11 //
#define AK8963C_ASAZ 0x12 //
// Magnetometer Operation Modes
#define AK8963C_BITSET_14 0x00 // 14 bit
#define AK8963C_BITSET_16 0x10 // 16 bit
#define AK8963C_OPMODE_PWRDWN 0x00 // power down
#define AK8963C_OPMODE_SINGLE 0x01 // Single measurement mode
#define AK8963C_OPMODE_CONT8HZ 0x02 // Continuous measurement mode 1 8Hz, 125ms period
#define AK8963C_OPMODE_CONT100HZ 0x06 // Continuous measurement mode 2 100Hz, 10ms period
#define AK8963C_OPMODE_SELFTEST 0x08 // Self-test mode
#define AK8963C_OPMODE_FUSEROM 0x0F
#define MPU9255_ADDRESS_AD0_LOW 0x68 // address pin low (GND), default for InvenSense evaluation board
#define MPU9255_ADDRESS_AD0_HIGH 0x69 // address pin high (VCC)
#define MPU9255_DEFAULT_ADDRESS MPU9255_ADDRESS_AD0_LOW
#define MPU9255_RA_XG_OFFS_TC 0x00 //[7] PWR_MODE, [6:1] XG_OFFS_TC, [0] OTP_BNK_VLD
#define MPU9255_RA_YG_OFFS_TC 0x01 //[7] PWR_MODE, [6:1] YG_OFFS_TC, [0] OTP_BNK_VLD
#define MPU9255_RA_ZG_OFFS_TC 0x02 //[7] PWR_MODE, [6:1] ZG_OFFS_TC, [0] OTP_BNK_VLD
#define MPU9255_RA_X_FINE_GAIN 0x03 //[7:0] X_FINE_GAIN
#define MPU9255_RA_Y_FINE_GAIN 0x04 //[7:0] Y_FINE_GAIN
#define MPU9255_RA_Z_FINE_GAIN 0x05 //[7:0] Z_FINE_GAIN
#define MPU9255_RA_XA_OFFS_H 0x06 //[15:0] XA_OFFS
#define MPU9255_RA_XA_OFFS_L_TC 0x07
#define MPU9255_RA_YA_OFFS_H 0x08 //[15:0] YA_OFFS
#define MPU9255_RA_YA_OFFS_L_TC 0x09
#define MPU9255_RA_ZA_OFFS_H 0x0A //[15:0] ZA_OFFS
#define MPU9255_RA_ZA_OFFS_L_TC 0x0B
#define MPU9255_RA_XG_OFFS_USRH 0x13 //[15:0] XG_OFFS_USR
#define MPU9255_RA_XG_OFFS_USRL 0x14
#define MPU9255_RA_YG_OFFS_USRH 0x15 //[15:0] YG_OFFS_USR
#define MPU9255_RA_YG_OFFS_USRL 0x16
#define MPU9255_RA_ZG_OFFS_USRH 0x17 //[15:0] ZG_OFFS_USR
#define MPU9255_RA_ZG_OFFS_USRL 0x18
#define MPU9255_RA_SMPLRT_DIV 0x19
#define MPU9255_RA_CONFIG 0x1A
#define MPU9255_RA_GYRO_CONFIG 0x1B
#define MPU9255_RA_ACCEL_CONFIG 0x1C
#define MPU9255_RA_FF_THR 0x1D
#define MPU9255_RA_FF_DUR 0x1E
#define MPU9255_RA_MOT_THR 0x1F
#define MPU9255_RA_MOT_DUR 0x20
#define MPU9255_RA_ZRMOT_THR 0x21
#define MPU9255_RA_ZRMOT_DUR 0x22
#define MPU9255_RA_FIFO_EN 0x23
#define MPU9255_RA_I2C_MST_CTRL 0x24
#define MPU9255_RA_I2C_SLV0_ADDR 0x25
#define MPU9255_RA_I2C_SLV0_REG 0x26
#define MPU9255_RA_I2C_SLV0_CTRL 0x27
#define MPU9255_RA_I2C_SLV1_ADDR 0x28
#define MPU9255_RA_I2C_SLV1_REG 0x29
#define MPU9255_RA_I2C_SLV1_CTRL 0x2A
#define MPU9255_RA_I2C_SLV2_ADDR 0x2B
#define MPU9255_RA_I2C_SLV2_REG 0x2C
#define MPU9255_RA_I2C_SLV2_CTRL 0x2D
#define MPU9255_RA_I2C_SLV3_ADDR 0x2E
#define MPU9255_RA_I2C_SLV3_REG 0x2F
#define MPU9255_RA_I2C_SLV3_CTRL 0x30
#define MPU9255_RA_I2C_SLV4_ADDR 0x31
#define MPU9255_RA_I2C_SLV4_REG 0x32
#define MPU9255_RA_I2C_SLV4_DO 0x33
#define MPU9255_RA_I2C_SLV4_CTRL 0x34
#define MPU9255_RA_I2C_SLV4_DI 0x35
#define MPU9255_RA_I2C_MST_STATUS 0x36
#define MPU9255_RA_INT_PIN_CFG 0x37
#define MPU9255_RA_INT_ENABLE 0x38
#define MPU9255_RA_DMP_INT_STATUS 0x39
#define MPU9255_RA_INT_STATUS 0x3A
#define MPU9255_RA_ACCEL_XOUT_H 0x3B
#define MPU9255_RA_ACCEL_XOUT_L 0x3C
#define MPU9255_RA_ACCEL_YOUT_H 0x3D
#define MPU9255_RA_ACCEL_YOUT_L 0x3E
#define MPU9255_RA_ACCEL_ZOUT_H 0x3F
#define MPU9255_RA_ACCEL_ZOUT_L 0x40
#define MPU9255_RA_TEMP_OUT_H 0x41
#define MPU9255_RA_TEMP_OUT_L 0x42
#define MPU9255_RA_GYRO_XOUT_H 0x43
#define MPU9255_RA_GYRO_XOUT_L 0x44
#define MPU9255_RA_GYRO_YOUT_H 0x45
#define MPU9255_RA_GYRO_YOUT_L 0x46
#define MPU9255_RA_GYRO_ZOUT_H 0x47
#define MPU9255_RA_GYRO_ZOUT_L 0x48
#define MPU9255_RA_EXT_SENS_DATA_00 0x49
#define MPU9255_RA_EXT_SENS_DATA_01 0x4A
#define MPU9255_RA_EXT_SENS_DATA_02 0x4B
#define MPU9255_RA_EXT_SENS_DATA_03 0x4C
#define MPU9255_RA_EXT_SENS_DATA_04 0x4D
#define MPU9255_RA_EXT_SENS_DATA_05 0x4E
#define MPU9255_RA_EXT_SENS_DATA_06 0x4F
#define MPU9255_RA_EXT_SENS_DATA_07 0x50
#define MPU9255_RA_EXT_SENS_DATA_08 0x51
#define MPU9255_RA_EXT_SENS_DATA_09 0x52
#define MPU9255_RA_EXT_SENS_DATA_10 0x53
#define MPU9255_RA_EXT_SENS_DATA_11 0x54
#define MPU9255_RA_EXT_SENS_DATA_12 0x55
#define MPU9255_RA_EXT_SENS_DATA_13 0x56
#define MPU9255_RA_EXT_SENS_DATA_14 0x57
#define MPU9255_RA_EXT_SENS_DATA_15 0x58
#define MPU9255_RA_EXT_SENS_DATA_16 0x59
#define MPU9255_RA_EXT_SENS_DATA_17 0x5A
#define MPU9255_RA_EXT_SENS_DATA_18 0x5B
#define MPU9255_RA_EXT_SENS_DATA_19 0x5C
#define MPU9255_RA_EXT_SENS_DATA_20 0x5D
#define MPU9255_RA_EXT_SENS_DATA_21 0x5E
#define MPU9255_RA_EXT_SENS_DATA_22 0x5F
#define MPU9255_RA_EXT_SENS_DATA_23 0x60
#define MPU9255_RA_MOT_DETECT_STATUS 0x61
#define MPU9255_RA_I2C_SLV0_DO 0x63
#define MPU9255_RA_I2C_SLV1_DO 0x64
#define MPU9255_RA_I2C_SLV2_DO 0x65
#define MPU9255_RA_I2C_SLV3_DO 0x66
#define MPU9255_RA_I2C_MST_DELAY_CTRL 0x67
#define MPU9255_RA_SIGNAL_PATH_RESET 0x68
#define MPU9255_RA_MOT_DETECT_CTRL 0x69
#define MPU9255_RA_USER_CTRL 0x6A
#define MPU9255_RA_PWR_MGMT_1 0x6B
#define MPU9255_RA_PWR_MGMT_2 0x6C
#define MPU9255_RA_BANK_SEL 0x6D
#define MPU9255_RA_MEM_START_ADDR 0x6E
#define MPU9255_RA_MEM_R_W 0x6F
#define MPU9255_RA_DMP_CFG_1 0x70
#define MPU9255_RA_DMP_CFG_2 0x71
#define MPU9255_RA_FIFO_COUNTH 0x72
#define MPU9255_RA_FIFO_COUNTL 0x73
#define MPU9255_RA_FIFO_R_W 0x74
#define MPU9255_RA_WHO_AM_I 0x75
#define MPU9255_TC_PWR_MODE_BIT 7
#define MPU9255_TC_OFFSET_BIT 6
#define MPU9255_TC_OFFSET_LENGTH 6
#define MPU9255_TC_OTP_BNK_VLD_BIT 0
#define MPU9255_VDDIO_LEVEL_VLOGIC 0
#define MPU9255_VDDIO_LEVEL_VDD 1
#define MPU9255_CFG_EXT_SYNC_SET_BIT 5
#define MPU9255_CFG_EXT_SYNC_SET_LENGTH 3
#define MPU9255_CFG_DLPF_CFG_BIT 2
#define MPU9255_CFG_DLPF_CFG_LENGTH 3
#define MPU9255_EXT_SYNC_DISABLED 0x0
#define MPU9255_EXT_SYNC_TEMP_OUT_L 0x1
#define MPU9255_EXT_SYNC_GYRO_XOUT_L 0x2
#define MPU9255_EXT_SYNC_GYRO_YOUT_L 0x3
#define MPU9255_EXT_SYNC_GYRO_ZOUT_L 0x4
#define MPU9255_EXT_SYNC_ACCEL_XOUT_L 0x5
#define MPU9255_EXT_SYNC_ACCEL_YOUT_L 0x6
#define MPU9255_EXT_SYNC_ACCEL_ZOUT_L 0x7
#define MPU9255_DLPF_BW_256 0x00
#define MPU9255_DLPF_BW_188 0x01
#define MPU9255_DLPF_BW_98 0x02
#define MPU9255_DLPF_BW_42 0x03
#define MPU9255_DLPF_BW_20 0x04
#define MPU9255_DLPF_BW_10 0x05
#define MPU9255_DLPF_BW_5 0x06
#define MPU9255_GCONFIG_FS_SEL_BIT 4
#define MPU9255_GCONFIG_FS_SEL_LENGTH 2
#define MPU9255_GYRO_FS_250 0x00
#define MPU9255_GYRO_FS_500 0x01
#define MPU9255_GYRO_FS_1000 0x02
#define MPU9255_GYRO_FS_2000 0x03
#define MPU9255_ACONFIG_XA_ST_BIT 7
#define MPU9255_ACONFIG_YA_ST_BIT 6
#define MPU9255_ACONFIG_ZA_ST_BIT 5
#define MPU9255_ACONFIG_AFS_SEL_BIT 4
#define MPU9255_ACONFIG_AFS_SEL_LENGTH 2
#define MPU9255_ACONFIG_ACCEL_HPF_BIT 2
#define MPU9255_ACONFIG_ACCEL_HPF_LENGTH 3
#define MPU9255_ACCEL_FS_2 0x00
#define MPU9255_ACCEL_FS_4 0x01
#define MPU9255_ACCEL_FS_8 0x02
#define MPU9255_ACCEL_FS_16 0x03
#define MPU9255_DHPF_RESET 0x00
#define MPU9255_DHPF_5 0x01
#define MPU9255_DHPF_2P5 0x02
#define MPU9255_DHPF_1P25 0x03
#define MPU9255_DHPF_0P63 0x04
#define MPU9255_DHPF_HOLD 0x07
#define MPU9255_TEMP_FIFO_EN_BIT 7
#define MPU9255_XG_FIFO_EN_BIT 6
#define MPU9255_YG_FIFO_EN_BIT 5
#define MPU9255_ZG_FIFO_EN_BIT 4
#define MPU9255_ACCEL_FIFO_EN_BIT 3
#define MPU9255_SLV2_FIFO_EN_BIT 2
#define MPU9255_SLV1_FIFO_EN_BIT 1
#define MPU9255_SLV0_FIFO_EN_BIT 0
#define MPU9255_MULT_MST_EN_BIT 7
#define MPU9255_WAIT_FOR_ES_BIT 6
#define MPU9255_SLV_3_FIFO_EN_BIT 5
#define MPU9255_I2C_MST_P_NSR_BIT 4
#define MPU9255_I2C_MST_CLK_BIT 3
#define MPU9255_I2C_MST_CLK_LENGTH 4
#define MPU9255_CLOCK_DIV_348 0x0
#define MPU9255_CLOCK_DIV_333 0x1
#define MPU9255_CLOCK_DIV_320 0x2
#define MPU9255_CLOCK_DIV_308 0x3
#define MPU9255_CLOCK_DIV_296 0x4
#define MPU9255_CLOCK_DIV_286 0x5
#define MPU9255_CLOCK_DIV_276 0x6
#define MPU9255_CLOCK_DIV_267 0x7
#define MPU9255_CLOCK_DIV_258 0x8
#define MPU9255_CLOCK_DIV_500 0x9
#define MPU9255_CLOCK_DIV_471 0xA
#define MPU9255_CLOCK_DIV_444 0xB
#define MPU9255_CLOCK_DIV_421 0xC
#define MPU9255_CLOCK_DIV_400 0xD
#define MPU9255_CLOCK_DIV_381 0xE
#define MPU9255_CLOCK_DIV_364 0xF
#define MPU9255_I2C_SLV_RW_BIT 7
#define MPU9255_I2C_SLV_ADDR_BIT 6
#define MPU9255_I2C_SLV_ADDR_LENGTH 7
#define MPU9255_I2C_SLV_EN_BIT 7
#define MPU9255_I2C_SLV_BYTE_SW_BIT 6
#define MPU9255_I2C_SLV_REG_DIS_BIT 5
#define MPU9255_I2C_SLV_GRP_BIT 4
#define MPU9255_I2C_SLV_LEN_BIT 3
#define MPU9255_I2C_SLV_LEN_LENGTH 4
#define MPU9255_I2C_SLV4_RW_BIT 7
#define MPU9255_I2C_SLV4_ADDR_BIT 6
#define MPU9255_I2C_SLV4_ADDR_LENGTH 7
#define MPU9255_I2C_SLV4_EN_BIT 7
#define MPU9255_I2C_SLV4_INT_EN_BIT 6
#define MPU9255_I2C_SLV4_REG_DIS_BIT 5
#define MPU9255_I2C_SLV4_MST_DLY_BIT 4
#define MPU9255_I2C_SLV4_MST_DLY_LENGTH 5
#define MPU9255_MST_PASS_THROUGH_BIT 7
#define MPU9255_MST_I2C_SLV4_DONE_BIT 6
#define MPU9255_MST_I2C_LOST_ARB_BIT 5
#define MPU9255_MST_I2C_SLV4_NACK_BIT 4
#define MPU9255_MST_I2C_SLV3_NACK_BIT 3
#define MPU9255_MST_I2C_SLV2_NACK_BIT 2
#define MPU9255_MST_I2C_SLV1_NACK_BIT 1
#define MPU9255_MST_I2C_SLV0_NACK_BIT 0
#define MPU9255_INTCFG_INT_LEVEL_BIT 7
#define MPU9255_INTCFG_INT_OPEN_BIT 6
#define MPU9255_INTCFG_LATCH_INT_EN_BIT 5
#define MPU9255_INTCFG_INT_RD_CLEAR_BIT 4
#define MPU9255_INTCFG_FSYNC_INT_LEVEL_BIT 3
#define MPU9255_INTCFG_FSYNC_INT_EN_BIT 2
#define MPU9255_INTCFG_I2C_BYPASS_EN_BIT 1
#define MPU9255_INTCFG_CLKOUT_EN_BIT 0
#define MPU9255_INTMODE_ACTIVEHIGH 0x00
#define MPU9255_INTMODE_ACTIVELOW 0x01
#define MPU9255_INTDRV_PUSHPULL 0x00
#define MPU9255_INTDRV_OPENDRAIN 0x01
#define MPU9255_INTLATCH_50USPULSE 0x00
#define MPU9255_INTLATCH_WAITCLEAR 0x01
#define MPU9255_INTCLEAR_STATUSREAD 0x00
#define MPU9255_INTCLEAR_ANYREAD 0x01
#define MPU9255_INTERRUPT_FF_BIT 7
#define MPU9255_INTERRUPT_MOT_BIT 6
#define MPU9255_INTERRUPT_ZMOT_BIT 5
#define MPU9255_INTERRUPT_FIFO_OFLOW_BIT 4
#define MPU9255_INTERRUPT_I2C_MST_INT_BIT 3
#define MPU9255_INTERRUPT_PLL_RDY_INT_BIT 2
#define MPU9255_INTERRUPT_DMP_INT_BIT 1
#define MPU9255_INTERRUPT_DATA_RDY_BIT 0
// TODO: figure out what these actually do
// UMPL source code is not very obivous
#define MPU9255_DMPINT_5_BIT 5
#define MPU9255_DMPINT_4_BIT 4
#define MPU9255_DMPINT_3_BIT 3
#define MPU9255_DMPINT_2_BIT 2
#define MPU9255_DMPINT_1_BIT 1
#define MPU9255_DMPINT_0_BIT 0
#define MPU9255_MOTION_MOT_XNEG_BIT 7
#define MPU9255_MOTION_MOT_XPOS_BIT 6
#define MPU9255_MOTION_MOT_YNEG_BIT 5
#define MPU9255_MOTION_MOT_YPOS_BIT 4
#define MPU9255_MOTION_MOT_ZNEG_BIT 3
#define MPU9255_MOTION_MOT_ZPOS_BIT 2
#define MPU9255_MOTION_MOT_ZRMOT_BIT 0
#define MPU9255_DELAYCTRL_DELAY_ES_SHADOW_BIT 7
#define MPU9255_DELAYCTRL_I2C_SLV4_DLY_EN_BIT 4
#define MPU9255_DELAYCTRL_I2C_SLV3_DLY_EN_BIT 3
#define MPU9255_DELAYCTRL_I2C_SLV2_DLY_EN_BIT 2
#define MPU9255_DELAYCTRL_I2C_SLV1_DLY_EN_BIT 1
#define MPU9255_DELAYCTRL_I2C_SLV0_DLY_EN_BIT 0
#define MPU9255_PATHRESET_GYRO_RESET_BIT 2
#define MPU9255_PATHRESET_ACCEL_RESET_BIT 1
#define MPU9255_PATHRESET_TEMP_RESET_BIT 0
#define MPU9255_DETECT_ACCEL_ON_DELAY_BIT 5
#define MPU9255_DETECT_ACCEL_ON_DELAY_LENGTH 2
#define MPU9255_DETECT_FF_COUNT_BIT 3
#define MPU9255_DETECT_FF_COUNT_LENGTH 2
#define MPU9255_DETECT_MOT_COUNT_BIT 1
#define MPU9255_DETECT_MOT_COUNT_LENGTH 2
#define MPU9255_DETECT_DECREMENT_RESET 0x0
#define MPU9255_DETECT_DECREMENT_1 0x1
#define MPU9255_DETECT_DECREMENT_2 0x2
#define MPU9255_DETECT_DECREMENT_4 0x3
#define MPU9255_USERCTRL_DMP_EN_BIT 7
#define MPU9255_USERCTRL_FIFO_EN_BIT 6
#define MPU9255_USERCTRL_I2C_MST_EN_BIT 5
#define MPU9255_USERCTRL_I2C_IF_DIS_BIT 4
#define MPU9255_USERCTRL_DMP_RESET_BIT 3
#define MPU9255_USERCTRL_FIFO_RESET_BIT 2
#define MPU9255_USERCTRL_I2C_MST_RESET_BIT 1
#define MPU9255_USERCTRL_SIG_COND_RESET_BIT 0
#define MPU9255_PWR1_DEVICE_RESET_BIT 7
#define MPU9255_PWR1_SLEEP_BIT 6
#define MPU9255_PWR1_CYCLE_BIT 5
#define MPU9255_PWR1_TEMP_DIS_BIT 3
#define MPU9255_PWR1_CLKSEL_BIT 2
#define MPU9255_PWR1_CLKSEL_LENGTH 3
#define MPU9255_CLOCK_INTERNAL 0x00
#define MPU9255_CLOCK_PLL_XGYRO 0x01
#define MPU9255_CLOCK_PLL_YGYRO 0x02
#define MPU9255_CLOCK_PLL_ZGYRO 0x03
#define MPU9255_CLOCK_PLL_EXT32K 0x04
#define MPU9255_CLOCK_PLL_EXT19M 0x05
#define MPU9255_CLOCK_KEEP_RESET 0x07
#define MPU9255_PWR2_LP_WAKE_CTRL_BIT 7
#define MPU9255_PWR2_LP_WAKE_CTRL_LENGTH 2
#define MPU9255_PWR2_STBY_XA_BIT 5
#define MPU9255_PWR2_STBY_YA_BIT 4
#define MPU9255_PWR2_STBY_ZA_BIT 3
#define MPU9255_PWR2_STBY_XG_BIT 2
#define MPU9255_PWR2_STBY_YG_BIT 1
#define MPU9255_PWR2_STBY_ZG_BIT 0
#define MPU9255_WAKE_FREQ_1P25 0x0
#define MPU9255_WAKE_FREQ_2P5 0x1
#define MPU9255_WAKE_FREQ_5 0x2
#define MPU9255_WAKE_FREQ_10 0x3
#define MPU9255_BANKSEL_PRFTCH_EN_BIT 6
#define MPU9255_BANKSEL_CFG_USER_BANK_BIT 5
#define MPU9255_BANKSEL_MEM_SEL_BIT 4
#define MPU9255_BANKSEL_MEM_SEL_LENGTH 5
#define MPU9255_WHO_AM_I_BIT 8
#define MPU9255_WHO_AM_I_LENGTH 8
#define MPU9255_DMP_MEMORY_BANKS 8
#define MPU9255_DMP_MEMORY_BANK_SIZE 256
#define MPU9255_DMP_MEMORY_CHUNK_SIZE 16
// note: DMP code memory blocks defined at end of header file
class MPU9255 {
public:
MPU9255();
MPU9255(uint8_t address);
void initialize();
bool testConnection();
// AUX_VDDIO register
uint8_t getAuxVDDIOLevel();
void setAuxVDDIOLevel(uint8_t level);
// SMPLRT_DIV register
uint8_t getRate();
void setRate(uint8_t rate);
// CONFIG register
uint8_t getExternalFrameSync();
void setExternalFrameSync(uint8_t sync);
uint8_t getDLPFMode();
void setDLPFMode(uint8_t bandwidth);
// GYRO_CONFIG register
uint8_t getFullScaleGyroRange();
void setFullScaleGyroRange(uint8_t range);
// ACCEL_CONFIG register
bool getAccelXSelfTest();
void setAccelXSelfTest(bool enabled);
bool getAccelYSelfTest();
void setAccelYSelfTest(bool enabled);
bool getAccelZSelfTest();
void setAccelZSelfTest(bool enabled);
uint8_t getFullScaleAccelRange();
void setFullScaleAccelRange(uint8_t range);
uint8_t getDHPFMode();
void setDHPFMode(uint8_t mode);
// FF_THR register
uint8_t getFreefallDetectionThreshold();
void setFreefallDetectionThreshold(uint8_t threshold);
// FF_DUR register
uint8_t getFreefallDetectionDuration();
void setFreefallDetectionDuration(uint8_t duration);
// MOT_THR register
uint8_t getMotionDetectionThreshold();
void setMotionDetectionThreshold(uint8_t threshold);
// MOT_DUR register
uint8_t getMotionDetectionDuration();
void setMotionDetectionDuration(uint8_t duration);
// ZRMOT_THR register
uint8_t getZeroMotionDetectionThreshold();
void setZeroMotionDetectionThreshold(uint8_t threshold);
// ZRMOT_DUR register
uint8_t getZeroMotionDetectionDuration();
void setZeroMotionDetectionDuration(uint8_t duration);
// FIFO_EN register
bool getTempFIFOEnabled();
void setTempFIFOEnabled(bool enabled);
bool getXGyroFIFOEnabled();
void setXGyroFIFOEnabled(bool enabled);
bool getYGyroFIFOEnabled();
void setYGyroFIFOEnabled(bool enabled);
bool getZGyroFIFOEnabled();
void setZGyroFIFOEnabled(bool enabled);
bool getAccelFIFOEnabled();
void setAccelFIFOEnabled(bool enabled);
bool getSlave2FIFOEnabled();
void setSlave2FIFOEnabled(bool enabled);
bool getSlave1FIFOEnabled();
void setSlave1FIFOEnabled(bool enabled);
bool getSlave0FIFOEnabled();
void setSlave0FIFOEnabled(bool enabled);
// I2C_MST_CTRL register
bool getMultiMasterEnabled();
void setMultiMasterEnabled(bool enabled);
bool getWaitForExternalSensorEnabled();
void setWaitForExternalSensorEnabled(bool enabled);
bool getSlave3FIFOEnabled();
void setSlave3FIFOEnabled(bool enabled);
bool getSlaveReadWriteTransitionEnabled();
void setSlaveReadWriteTransitionEnabled(bool enabled);
uint8_t getMasterClockSpeed();
void setMasterClockSpeed(uint8_t speed);
// I2C_SLV* registers (Slave 0-3)
uint8_t getSlaveAddress(uint8_t num);
void setSlaveAddress(uint8_t num, uint8_t address);
uint8_t getSlaveRegister(uint8_t num);
void setSlaveRegister(uint8_t num, uint8_t reg);
bool getSlaveEnabled(uint8_t num);
void setSlaveEnabled(uint8_t num, bool enabled);
bool getSlaveWordByteSwap(uint8_t num);
void setSlaveWordByteSwap(uint8_t num, bool enabled);
bool getSlaveWriteMode(uint8_t num);
void setSlaveWriteMode(uint8_t num, bool mode);
bool getSlaveWordGroupOffset(uint8_t num);
void setSlaveWordGroupOffset(uint8_t num, bool enabled);
uint8_t getSlaveDataLength(uint8_t num);
void setSlaveDataLength(uint8_t num, uint8_t length);
// I2C_SLV* registers (Slave 4)
uint8_t getSlave4Address();
void setSlave4Address(uint8_t address);
uint8_t getSlave4Register();
void setSlave4Register(uint8_t reg);
void setSlave4OutputByte(uint8_t data);
bool getSlave4Enabled();
void setSlave4Enabled(bool enabled);
bool getSlave4InterruptEnabled();
void setSlave4InterruptEnabled(bool enabled);
bool getSlave4WriteMode();
void setSlave4WriteMode(bool mode);
uint8_t getSlave4MasterDelay();
void setSlave4MasterDelay(uint8_t delay);
uint8_t getSlate4InputByte();
// I2C_MST_STATUS register
bool getPassthroughStatus();
bool getSlave4IsDone();
bool getLostArbitration();
bool getSlave4Nack();
bool getSlave3Nack();
bool getSlave2Nack();
bool getSlave1Nack();
bool getSlave0Nack();
// INT_PIN_CFG register
bool getInterruptMode();
void setInterruptMode(bool mode);
bool getInterruptDrive();
void setInterruptDrive(bool drive);
bool getInterruptLatch();
void setInterruptLatch(bool latch);
bool getInterruptLatchClear();
void setInterruptLatchClear(bool clear);
bool getFSyncInterruptLevel();
void setFSyncInterruptLevel(bool level);
bool getFSyncInterruptEnabled();
void setFSyncInterruptEnabled(bool enabled);
bool getI2CBypassEnabled();
void setI2CBypassEnabled(bool enabled);
bool getClockOutputEnabled();
void setClockOutputEnabled(bool enabled);
// INT_ENABLE register
uint8_t getIntEnabled();
void setIntEnabled(uint8_t enabled);
bool getIntFreefallEnabled();
void setIntFreefallEnabled(bool enabled);
bool getIntMotionEnabled();
void setIntMotionEnabled(bool enabled);
bool getIntZeroMotionEnabled();
void setIntZeroMotionEnabled(bool enabled);
bool getIntFIFOBufferOverflowEnabled();
void setIntFIFOBufferOverflowEnabled(bool enabled);
bool getIntI2CMasterEnabled();
void setIntI2CMasterEnabled(bool enabled);
bool getIntDataReadyEnabled();
void setIntDataReadyEnabled(bool enabled);
// INT_STATUS register
uint8_t getIntStatus();
bool getIntFreefallStatus();
bool getIntMotionStatus();
bool getIntZeroMotionStatus();
bool getIntFIFOBufferOverflowStatus();
bool getIntI2CMasterStatus();
bool getIntDataReadyStatus();
// ACCEL_*OUT_* registers
void getMotion9(int16_t* ax, int16_t* ay, int16_t* az, int16_t* gx, int16_t* gy, int16_t* gz, int16_t* mx, int16_t* my, int16_t* mz);
void getMotion6(int16_t* ax, int16_t* ay, int16_t* az, int16_t* gx, int16_t* gy, int16_t* gz);
void getAcceleration(int16_t* x, int16_t* y, int16_t* z);
int16_t getAccelerationX();
int16_t getAccelerationY();
int16_t getAccelerationZ();
// TEMP_OUT_* registers
int16_t getTemperature();
// GYRO_*OUT_* registers
void getRotation(int16_t* x, int16_t* y, int16_t* z);
int16_t getRotationX();
int16_t getRotationY();
int16_t getRotationZ();
// Magnetometer
void magInitialize();
void magSelfTest(int16_t *x, int16_t *y, int16_t *z);
bool getMagReading(int16_t *x, int16_t *y, int16_t *z);
void getMagAdjustment(int8_t *x, int8_t *y, int8_t *z);
void setMagAdjustment(int8_t x, int8_t y, int8_t z);
// EXT_SENS_DATA_* registers
uint8_t getExternalSensorByte(int position);
uint16_t getExternalSensorWord(int position);
uint32_t getExternalSensorDWord(int position);
// MOT_DETECT_STATUS register
bool getXNegMotionDetected();
bool getXPosMotionDetected();
bool getYNegMotionDetected();
bool getYPosMotionDetected();
bool getZNegMotionDetected();
bool getZPosMotionDetected();
bool getZeroMotionDetected();
// I2C_SLV*_DO register
void setSlaveOutputByte(uint8_t num, uint8_t data);
// I2C_MST_DELAY_CTRL register
bool getExternalShadowDelayEnabled();
void setExternalShadowDelayEnabled(bool enabled);
bool getSlaveDelayEnabled(uint8_t num);
void setSlaveDelayEnabled(uint8_t num, bool enabled);
// SIGNAL_PATH_RESET register
void resetGyroscopePath();
void resetAccelerometerPath();
void resetTemperaturePath();
// MOT_DETECT_CTRL register
uint8_t getAccelerometerPowerOnDelay();
void setAccelerometerPowerOnDelay(uint8_t delay);
uint8_t getFreefallDetectionCounterDecrement();
void setFreefallDetectionCounterDecrement(uint8_t decrement);
uint8_t getMotionDetectionCounterDecrement();
void setMotionDetectionCounterDecrement(uint8_t decrement);
// USER_CTRL register
bool getFIFOEnabled();
void setFIFOEnabled(bool enabled);
bool getI2CMasterModeEnabled();
void setI2CMasterModeEnabled(bool enabled);
void switchSPIEnabled(bool enabled);
void resetFIFO();
void resetI2CMaster();
void resetSensors();
// PWR_MGMT_1 register
void reset();
bool getSleepEnabled();
void setSleepEnabled(bool enabled);
bool getWakeCycleEnabled();
void setWakeCycleEnabled(bool enabled);
bool getTempSensorEnabled();
void setTempSensorEnabled(bool enabled);
uint8_t getClockSource();
void setClockSource(uint8_t source);
// PWR_MGMT_2 register
uint8_t getWakeFrequency();
void setWakeFrequency(uint8_t frequency);
bool getStandbyXAccelEnabled();
void setStandbyXAccelEnabled(bool enabled);
bool getStandbyYAccelEnabled();
void setStandbyYAccelEnabled(bool enabled);
bool getStandbyZAccelEnabled();
void setStandbyZAccelEnabled(bool enabled);
bool getStandbyXGyroEnabled();
void setStandbyXGyroEnabled(bool enabled);
bool getStandbyYGyroEnabled();
void setStandbyYGyroEnabled(bool enabled);
bool getStandbyZGyroEnabled();
void setStandbyZGyroEnabled(bool enabled);
// FIFO_COUNT_* registers
uint16_t getFIFOCount();
// FIFO_R_W register
uint8_t getFIFOByte();
void setFIFOByte(uint8_t data);
void getFIFOBytes(uint8_t *data, uint8_t length);
// WHO_AM_I register
uint8_t getDeviceID();
void setDeviceID(uint8_t id);
// ======== UNDOCUMENTED/DMP REGISTERS/METHODS ========
// XG_OFFS_TC register
uint8_t getOTPBankValid();
void setOTPBankValid(bool enabled);
int8_t getXGyroOffsetTC();
void setXGyroOffsetTC(int8_t offset);
// YG_OFFS_TC register
int8_t getYGyroOffsetTC();
void setYGyroOffsetTC(int8_t offset);
// ZG_OFFS_TC register
int8_t getZGyroOffsetTC();
void setZGyroOffsetTC(int8_t offset);
// X_FINE_GAIN register
int8_t getXFineGain();
void setXFineGain(int8_t gain);
// Y_FINE_GAIN register
int8_t getYFineGain();
void setYFineGain(int8_t gain);
// Z_FINE_GAIN register
int8_t getZFineGain();
void setZFineGain(int8_t gain);
// XA_OFFS_* registers
int16_t getXAccelOffset();
void setXAccelOffset(int16_t offset);
// YA_OFFS_* register
int16_t getYAccelOffset();
void setYAccelOffset(int16_t offset);
// ZA_OFFS_* register
int16_t getZAccelOffset();
void setZAccelOffset(int16_t offset);
// XG_OFFS_USR* registers
int16_t getXGyroOffset();
void setXGyroOffset(int16_t offset);
// YG_OFFS_USR* register
int16_t getYGyroOffset();
void setYGyroOffset(int16_t offset);
// ZG_OFFS_USR* register
int16_t getZGyroOffset();
void setZGyroOffset(int16_t offset);
// INT_ENABLE register (DMP functions)
bool getIntPLLReadyEnabled();
void setIntPLLReadyEnabled(bool enabled);
bool getIntDMPEnabled();
void setIntDMPEnabled(bool enabled);
// DMP_INT_STATUS
bool getDMPInt5Status();
bool getDMPInt4Status();
bool getDMPInt3Status();
bool getDMPInt2Status();
bool getDMPInt1Status();
bool getDMPInt0Status();
// INT_STATUS register (DMP functions)
bool getIntPLLReadyStatus();
bool getIntDMPStatus();
// USER_CTRL register (DMP functions)
bool getDMPEnabled();
void setDMPEnabled(bool enabled);
void resetDMP();
// BANK_SEL register
void setMemoryBank(uint8_t bank, bool prefetchEnabled=false, bool userBank=false);
// MEM_START_ADDR register
void setMemoryStartAddress(uint8_t address);
// MEM_R_W register
uint8_t readMemoryByte();
void writeMemoryByte(uint8_t data);
void readMemoryBlock(uint8_t *data, uint16_t dataSize, uint8_t bank=0, uint8_t address=0);
bool writeMemoryBlock(const uint8_t *data, uint16_t dataSize, uint8_t bank=0, uint8_t address=0, bool verify=true, bool useProgMem=false);
bool writeProgMemoryBlock(const uint8_t *data, uint16_t dataSize, uint8_t bank=0, uint8_t address=0, bool verify=true);
bool writeDMPConfigurationSet(const uint8_t *data, uint16_t dataSize, bool useProgMem=false);
bool writeProgDMPConfigurationSet(const uint8_t *data, uint16_t dataSize);
// DMP_CFG_1 register
uint8_t getDMPConfig1();
void setDMPConfig1(uint8_t config);
// DMP_CFG_2 register
uint8_t getDMPConfig2();
void setDMPConfig2(uint8_t config);
// special methods for MotionApps 2.0 implementation
#ifdef MPU9255_INCLUDE_DMP_MOTIONAPPS20
uint8_t *dmpPacketBuffer;
uint16_t dmpPacketSize;
uint8_t dmpInitialize();
bool dmpPacketAvailable();
uint8_t dmpSetFIFORate(uint8_t fifoRate);
uint8_t dmpGetFIFORate();
uint8_t dmpGetSampleStepSizeMS();
uint8_t dmpGetSampleFrequency();
int32_t dmpDecodeTemperature(int8_t tempReg);
// Register callbacks after a packet of FIFO data is processed
//uint8_t dmpRegisterFIFORateProcess(inv_obj_func func, int16_t priority);
//uint8_t dmpUnregisterFIFORateProcess(inv_obj_func func);
uint8_t dmpRunFIFORateProcesses();
// Setup FIFO for various output
uint8_t dmpSendQuaternion(uint_fast16_t accuracy);
uint8_t dmpSendGyro(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendAccel(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendLinearAccel(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendLinearAccelInWorld(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendControlData(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendSensorData(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendExternalSensorData(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendGravity(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendPacketNumber(uint_fast16_t accuracy);
uint8_t dmpSendQuantizedAccel(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendEIS(uint_fast16_t elements, uint_fast16_t accuracy);
// Get Fixed Point data from FIFO
uint8_t dmpGetAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetQuaternion(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuaternion(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuaternion(Quaternion *q, const uint8_t* packet=0);
uint8_t dmpGet6AxisQuaternion(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGet6AxisQuaternion(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGet6AxisQuaternion(Quaternion *q, const uint8_t* packet=0);
uint8_t dmpGetRelativeQuaternion(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetRelativeQuaternion(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetRelativeQuaternion(Quaternion *data, const uint8_t* packet=0);
uint8_t dmpGetGyro(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyro(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyro(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpSetLinearAccelFilterCoefficient(float coef);
uint8_t dmpGetLinearAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetLinearAccel(VectorInt16 *v, VectorInt16 *vRaw, VectorFloat *gravity);
uint8_t dmpGetLinearAccelInWorld(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccelInWorld(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccelInWorld(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetLinearAccelInWorld(VectorInt16 *v, VectorInt16 *vReal, Quaternion *q);
uint8_t dmpGetGyroAndAccelSensor(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroAndAccelSensor(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroAndAccelSensor(VectorInt16 *g, VectorInt16 *a, const uint8_t* packet=0);
uint8_t dmpGetGyroSensor(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroSensor(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroSensor(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetControlData(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetTemperature(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGravity(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGravity(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGravity(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetGravity(VectorFloat *v, Quaternion *q);
uint8_t dmpGetUnquantizedAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetUnquantizedAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetUnquantizedAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetQuantizedAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuantizedAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuantizedAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetExternalSensorData(int32_t *data, uint16_t size, const uint8_t* packet=0);
uint8_t dmpGetEIS(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetEuler(float *data, Quaternion *q);
uint8_t dmpGetYawPitchRoll(float *data, Quaternion *q, VectorFloat *gravity);
// Get Floating Point data from FIFO
uint8_t dmpGetAccelFloat(float *data, const uint8_t* packet=0);
uint8_t dmpGetQuaternionFloat(float *data, const uint8_t* packet=0);
uint8_t dmpProcessFIFOPacket(const unsigned char *dmpData);
uint8_t dmpReadAndProcessFIFOPacket(uint8_t numPackets, uint8_t *processed=NULL);
uint8_t dmpSetFIFOProcessedCallback(void (*func) (void));
uint8_t dmpInitFIFOParam();
uint8_t dmpCloseFIFO();
uint8_t dmpSetGyroDataSource(uint8_t source);
uint8_t dmpDecodeQuantizedAccel();
uint32_t dmpGetGyroSumOfSquare();
uint32_t dmpGetAccelSumOfSquare();
void dmpOverrideQuaternion(long *q);
uint16_t dmpGetFIFOPacketSize();
#endif
// special methods for MotionApps 4.1 implementation
#ifdef MPU9255_INCLUDE_DMP_MOTIONAPPS41
uint8_t *dmpPacketBuffer;
uint16_t dmpPacketSize;
uint8_t dmpInitialize();
bool dmpPacketAvailable();
uint8_t dmpSetFIFORate(uint8_t fifoRate);
uint8_t dmpGetFIFORate();
uint8_t dmpGetSampleStepSizeMS();
uint8_t dmpGetSampleFrequency();
int32_t dmpDecodeTemperature(int8_t tempReg);
// Register callbacks after a packet of FIFO data is processed
//uint8_t dmpRegisterFIFORateProcess(inv_obj_func func, int16_t priority);
//uint8_t dmpUnregisterFIFORateProcess(inv_obj_func func);
uint8_t dmpRunFIFORateProcesses();
// Setup FIFO for various output
uint8_t dmpSendQuaternion(uint_fast16_t accuracy);
uint8_t dmpSendGyro(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendAccel(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendLinearAccel(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendLinearAccelInWorld(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendControlData(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendSensorData(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendExternalSensorData(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendGravity(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendPacketNumber(uint_fast16_t accuracy);
uint8_t dmpSendQuantizedAccel(uint_fast16_t elements, uint_fast16_t accuracy);
uint8_t dmpSendEIS(uint_fast16_t elements, uint_fast16_t accuracy);
// Get Fixed Point data from FIFO
uint8_t dmpGetAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetQuaternion(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuaternion(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuaternion(Quaternion *q, const uint8_t* packet=0);
uint8_t dmpGet6AxisQuaternion(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGet6AxisQuaternion(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGet6AxisQuaternion(Quaternion *q, const uint8_t* packet=0);
uint8_t dmpGetRelativeQuaternion(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetRelativeQuaternion(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetRelativeQuaternion(Quaternion *data, const uint8_t* packet=0);
uint8_t dmpGetGyro(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyro(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyro(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetMag(int16_t *data, const uint8_t* packet=0);
uint8_t dmpSetLinearAccelFilterCoefficient(float coef);
uint8_t dmpGetLinearAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetLinearAccel(VectorInt16 *v, VectorInt16 *vRaw, VectorFloat *gravity);
uint8_t dmpGetLinearAccelInWorld(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccelInWorld(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetLinearAccelInWorld(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetLinearAccelInWorld(VectorInt16 *v, VectorInt16 *vReal, Quaternion *q);
uint8_t dmpGetGyroAndAccelSensor(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroAndAccelSensor(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroAndAccelSensor(VectorInt16 *g, VectorInt16 *a, const uint8_t* packet=0);
uint8_t dmpGetGyroSensor(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroSensor(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGyroSensor(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetControlData(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetTemperature(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGravity(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetGravity(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetGravity(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetGravity(VectorFloat *v, Quaternion *q);
uint8_t dmpGetUnquantizedAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetUnquantizedAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetUnquantizedAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetQuantizedAccel(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuantizedAccel(int16_t *data, const uint8_t* packet=0);
uint8_t dmpGetQuantizedAccel(VectorInt16 *v, const uint8_t* packet=0);
uint8_t dmpGetExternalSensorData(int32_t *data, uint16_t size, const uint8_t* packet=0);
uint8_t dmpGetEIS(int32_t *data, const uint8_t* packet=0);
uint8_t dmpGetEuler(float *data, Quaternion *q);
uint8_t dmpGetYawPitchRoll(float *data, Quaternion *q, VectorFloat *gravity);
// Get Floating Point data from FIFO
uint8_t dmpGetAccelFloat(float *data, const uint8_t* packet=0);
uint8_t dmpGetQuaternionFloat(float *data, const uint8_t* packet=0);
uint8_t dmpProcessFIFOPacket(const unsigned char *dmpData);
uint8_t dmpReadAndProcessFIFOPacket(uint8_t numPackets, uint8_t *processed=NULL);
uint8_t dmpSetFIFOProcessedCallback(void (*func) (void));
uint8_t dmpInitFIFOParam();
uint8_t dmpCloseFIFO();
uint8_t dmpSetGyroDataSource(uint8_t source);
uint8_t dmpDecodeQuantizedAccel();
uint32_t dmpGetGyroSumOfSquare();
uint32_t dmpGetAccelSumOfSquare();
void dmpOverrideQuaternion(long *q);
uint16_t dmpGetFIFOPacketSize();
#endif
private:
uint8_t devAddr;
uint8_t buffer[14];
};
#endif /* _MPU9255_H_ */
|
pauljlohman/Pegasus
|
libraries/Stick/StickXY.h
|
/*
Joystick library
http://www.third-helix.com/2013/04/12/doing-thumbstick-dead-zones-right.html
*/
#ifndef STICKXY_H
#define STICKXY_H
//#include <Dampen.h>
#include <RollingAverage.h>
class StickXY {
byte pinX, pinY;
//Dampen dampenX, dampenY;
RollingAverage avgX;
RollingAverage avgY;
float centerX = 512.0;
float centerY = 512.0;
float outerEdge = 0.0;
float deadZone = 0.0;
float mapf(float x, float in_min, float in_max, float out_min, float out_max){
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
};
float vecLen(float x, float y){
return sqrt(x*x+y*y);
};
public:
float x, y;
void config(byte _pinX, byte _pinY, float _outerEdge, float _deadZone, float _dampen){
pinX = _pinX;
pinY = _pinY;
outerEdge = _outerEdge;
deadZone = _deadZone;
//dampenX.config(_dampen);
//dampenY.config(_dampen);
avgX.config(4);
avgY.config(4);
};
void calibrate(){
centerX = 0.0;
centerY = 0.0;
for(int i=0; i<200; i++){
centerX += float(analogRead(pinX));
centerY += float(analogRead(pinY));
delay(2);
}
centerX /= 200.0;
centerY /= 200.0;
};
void update(){
//unsigned long time = millis();
x = float(analogRead(pinX));
y = float(analogRead(pinY));
//Serial.printf("raw %f %f %i\n", x, y, time);
//x = dampenX.update(x);
//y = dampenY.update(y);
x = avgX.update(x);
y = avgY.update(y);
//Serial.printf("damp %f %f %i\n", x, y, time);
//float len = vecLen(x-centerX, y-centerY);
if(x < centerX-deadZone){
x = mapf(x, 0.0+outerEdge, centerX-deadZone, -511.0, 0.0);
}else if(x > centerX+deadZone){
x = mapf(x, centerX+deadZone, 1024.0-outerEdge, 0.0, 511.0);
}else{
x = 0.0;
}
if(y < centerY-deadZone){
y = mapf(y, 0.0+outerEdge, centerY-deadZone, -511.0, 0.0);
}else if(y > centerY+deadZone){
y = mapf(y, centerY+deadZone, 1024.0-outerEdge, 0.0, 511.0);
}else{
y = 0.0;
}
//Serial.printf("map %f %f %i\n", x, y, time);
};
};
#endif // STICKXY_H
|
pauljlohman/Pegasus
|
libraries/Pegasus_CtrlData/Pegasus_CtrlData.h
|
/*
RX data format, tested with 16 byte packet, 128 bits
minimum data requirements
yaw, pitch, roll, throttle, a few extra bits
11 bit resolution(2048) for yaw, pitch, roll, and throttle,
and 4 bits for control is probably enough
If bit packed thats 6 bytes
BIT PACKED FORMAT
7 6 5 4 3 2 1 0
0 e e e e y y y y
1 y y y y y y y p
2 p p p p p p p p
3 p p r r r r r r
4 r r r r r t t t
5 t t t t t t t t
UNPACKING BIT
"e" control_code byte
7 6 5 4 3 2 1 0
x x x x 07 06 05 04
"y" yaw word
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
x x x x x 03 02 01 00 17 16 15 14 13 12 11
"p" pitch word
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
x x x x x 10 27 26 25 24 23 22 21 20 37 36
"r" roll word
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
x x x x x 35 34 33 32 31 30 47 46 45 44 43
"t" throttle word
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
x x x x x 42 41 40 57 56 55 54 53 52 51 50
If byte packed it's 9 bytes, more byte aligned, better resolution
ALIGNED PACKET FORMAT
control_code = byte 0
yaw = byte 1(upper), byte 2(lower),
pitch = byte 3(upper), byte 4(lower),
roll = byte 5(upper), byte 6(lower),
throttle = byte 7(upper), byte 8(lower)
*/
#ifndef PEGASUS_CTRLDATA_H
#define PEGASUS_CTRLDATA_H
class Pegasus_CtrlData {
public:
byte control_code = 0;
static const byte KILL_CODE = 182; // 1011,0110
static const byte NAV_CODE = 15; // 0000,1111
static const byte PID_YAW_CODE = 218; // 1101,1010
static const byte PID_PITCH_CODE = 165; // 1010,0101
static const byte PID_ROLL_CODE = 92; // 0101,1100
// Nav Mode; 0=absolute(stable), 1=relative(acro), etc
static const byte FLY_ABS = 0;
static const byte FLY_REL = 1;
byte navModeYaw = FLY_REL;
byte navModePitch = FLY_ABS;
byte navModeRoll = FLY_ABS;
byte navModeThrottle = FLY_ABS;
// Nav Range
byte navRangeYaw = 0;
byte navRangePitch = 0;
byte navRangeRoll = 0;
unsigned short navRangeThrottle = 0;
// PID settings
// Yaw
short Kp_yaw = 0;
short Ki_yaw = 0;
short Kd_yaw = 0;
// Pitch
short Kp_pitch = 0;
short Ki_pitch = 0;
short Kd_pitch = 0;
// Roll
short Kp_roll = 0;
short Ki_roll = 0;
short Kd_roll = 0;
bool live = true;
short buf[4];
float yawf, pitchf, rollf, throttlef;
void pack(byte *b){
b[0] = control_code;
b[1] = byte(buf[0] >> 8);
b[2] = byte(buf[0]);
b[3] = byte(buf[1] >> 8);
b[4] = byte(buf[1]);
b[5] = byte(buf[2] >> 8);
b[6] = byte(buf[2]);
b[7] = byte(buf[3] >> 8);
b[8] = byte(buf[3]);
};
void unpack(byte *b){
control_code = b[0];
switch (control_code){
case KILL_CODE:
live = false;
break;
case NAV_CODE: // control packet
live = true;
yawf = getShort(b[1], b[2]) / 100.0;
pitchf = getShort(b[3], b[4]) / 100.0;
rollf = getShort(b[5], b[6]) / 100.0;
throttlef = (unsigned short)(getShort(b[7], b[8])) / 1.0;
break;
case PID_YAW_CODE: // PID settings for yaw mode
Kp_yaw = getShort(b[1], b[2]);
Ki_yaw = getShort(b[3], b[4]);
Kd_yaw = getShort(b[5], b[6]);
break;
case PID_PITCH_CODE: // PID settings for pitch mode
Kp_pitch = getShort(b[1], b[2]);
Ki_pitch = getShort(b[3], b[4]);
Kd_pitch = getShort(b[5], b[6]);
break;
case PID_ROLL_CODE: // PID settings for roll mode
Kp_roll = getShort(b[1], b[2]);
Ki_roll = getShort(b[3], b[4]);
Kd_roll = getShort(b[5], b[6]);
break;
}
};
short getShort(short upper, short lower){
return (upper << 8) | lower;
};
};
#endif // PEGASUS_CTRLDATA_H
|
pauljlohman/Pegasus
|
libraries/EEPROM/EEPROM_I2C.h
|
/*
written for EEPROM Microchip 24LC256
typical EEPROM pin layout
___
A0| U |Vcc
A1| |WP
A2| |SCL
Vss|___|SDA
Pin Function
A0 : User Configurable Chip Select
A1 : User Configurable Chip Select
A2 : User Configurable Chip Select
VSS : Ground
SDA : Serial Data, 10kOhm pull-up for 100kHz, 2kOhm for 400kHz and 1 MHz
SCL : Serial Clock
WP : Write-Protect Input, low - write enabled, high - write disabled
VCC : +2.5V to 5.5V
Addressing
starts 1010
the next three bits are the chip select bits (A2, A1, A0)
the last bit is 1 for read, 0 for write
Device address format: start bit, 1, 0, 1, 0, A2, A1, A0, R/W, Acknowledge bit
the next 2 bytes define the date address
Data address format: x,14,13,12,11,10,9,8, 7,6,5,4,3,2,1,0
write operation are limited to a single page
page address are a int multiple of the page size
There is 5 ms write cycle time regardless of length of data written
24LC256
256 kbit = 32,000 bytes
64 byte page size
100 kHz and 400 kHz
AT24C256C
256 Kbit = 32,768 bytes
64 byte page size
400kHz and 1MHz
see
Wire.setClock (400000)
*/
//#include <Wire.h> //better to include in upper level
#ifndef EEPROM_I2C_H
#define EEPROM_I2C_H
class EEPROM_I2C{
unsigned short timeout = 1000;
unsigned long lastWrite = 0;
byte buf[2];
public:
byte devAddr = B1010000; // 0xA0
unsigned short pageSize = 64; // I've seen 16 suggested regardless of actual page size
byte readByte(unsigned short address){
read(address, 1, buf);
return buf[0];
};
short readShort(unsigned short address_high){
read(address_high, 2, buf);
return word(buf[0], buf[1]);
};
void read(unsigned short address, byte length, byte *data){
waitTillReady();
byte c = 0;
unsigned long t = millis();
//Serial.printf("start Read at %i\n", address);
Wire.beginTransmission(devAddr);
Wire.send( byte(address >> 8) ); // MSB
Wire.send( byte(address & 0xFF) ); // LSB
Wire.endTransmission();
Wire.beginTransmission(devAddr);
Wire.requestFrom(devAddr, length);
for (; Wire.available() && (millis() - t < timeout); c++) {
data[c] = Wire.receive();
}
Wire.endTransmission();
};
void writeByte(unsigned short address, byte value){
buf[0] = value;
write(address, 1, buf);
};
void writeShort(unsigned short address_high, short value){
buf[0] = byte(value >> 8);
buf[1] = byte(value);
write(address_high, 2, buf);
};
void write(unsigned short address, byte length, byte *data){
waitTillReady();
// start write session
//Serial.printf("start write at %i\n", address);
Wire.beginTransmission(devAddr);
Wire.send(byte(address >> 8)); // MSB
Wire.send(byte(address & 0xFF)); // LSB
for (byte i=0; i<length; i++) {
bool pageBreak = ((address % pageSize) == 0) && (i != 0); // address
if (pageBreak){
Wire.endTransmission();
lastWrite = millis();
//Serial.println("page break");
//Serial.printf("start write at %i\n", address);
// start new page write session
waitTillReady();
Wire.beginTransmission(devAddr);
Wire.send(byte(address >> 8)); // MSB
Wire.send(byte(address & 0xFF)); // LSB
}
Wire.send(data[i]);
//Serial.printf("%X ",data[i]);
address++;
}
Wire.endTransmission();
lastWrite = millis();
//Serial.println();
};
void clear(unsigned short byteCapacity){
for(unsigned short i=0; i<(byteCapacity/pageSize); i++){
unsigned short address = i * pageSize;
waitTillReady();
Wire.beginTransmission(devAddr);
Wire.send(byte(address >> 8)); // MSB
Wire.send(byte(address & 0xFF)); // LSB
for (byte j=0; j<pageSize; j++) {
Wire.send(0);
}
Wire.endTransmission();
lastWrite = millis();
}
};
void waitTillReady(){
//Serial.print("Waiting till Ready...");
// wait till previous write has completed
unsigned long elapsed = millis() - lastWrite;
if(elapsed<5){
delay(5-elapsed);
}
//Serial.println("Ready!");
};
};
#endif // EEPROM_I2C_H
|
pauljlohman/Pegasus
|
libraries/IMU/GyroAngle.h
|
<reponame>pauljlohman/Pegasus<filename>libraries/IMU/GyroAngle.h
/*
MPU9255
GYROSCOPE
FS_SEL | Full Scale Range | LSB Sensitivity
-------+--------------------+----------------
0 | +/- 250 degrees/s | 131.072 LSB/deg/s
1 | +/- 500 degrees/s | 65.536 LSB/deg/s
2 | +/- 1000 degrees/s | 32.768 LSB/deg/s
3 | +/- 2000 degrees/s | 16.384 LSB/deg/s
X (ROLL)
longitudinal axis runs from front to back
positive value raises the left side and lowers the right
Y (PITCH)
lateral axis runs left to right
positive value raises the nose and lowers the tail
Z (YAW)
vertical axis runs top to bottom
positive value moves the nose right
*/
#ifndef GYROANGLE_H
#define GYROANGLE_H
class GyroAngle{
float radToDegree = 57.295779513082320876798154814105;// 180 / PI
float degreeToRad = 0.01745329251994329576923690768489;// PI / 180
unsigned long dpu; // degrees per time unit
float deltaDPU;
float correctionWeight = 0.1;
float gyroWeight = 1.0-correctionWeight;
// x:57.60, y:35.87, z:29.05 offset value, tested at @ 2000
float offsetX, offsetY, offsetZ;
// true inverts axis
bool invX, invY, invZ;
float wrapAngle(float v){
if(v > 180.0){
return v - 360.0;
}
if(v < -180.0){
return v + 360.0;
}
return v;
};
float angleDelta(float a, float b){
a *= degreeToRad;
b *= degreeToRad;
float v = atan2f(sinf(a-b), cosf(a-b));
return v * radToDegree;
};
float angleInterpolate(float a, float b, float w){
//http://stackoverflow.com/a/30129248
a *= degreeToRad;
b *= degreeToRad;
float CS = (1.0-w) * cosf(a) + w * cosf(b);
float SN = (1.0-w) * sinf(a) + w * sinf(b);
float c = atan2f(SN,CS);
return c * radToDegree;
};
public:
// angle rate
float rateX, rateY, rateZ;
// integrated angle rate and corrected using accelerometer
float posX, posY, posZ;
// integrated angle rate
float rsumX, rsumY, rsumZ;
void config(unsigned short FullScaleRangeDPS,
unsigned long deltaTime,
float correction_weight,
bool ix, bool iy, bool iz
)
{
dpu = (1.0 / (FullScaleRangeDPS / 32768.0)) * deltaTime;
correctionWeight = constrain(correction_weight, 0.0, 1.0);
gyroWeight = 1.0 - correctionWeight;
invX = ix;
invY = iy;
invZ = iz;
};
void init(float ox, float oy, float oz, float ax, float ay, float az){
offsetX = invX ? -ox : ox;
offsetY = invY ? -oy : oy;
offsetZ = invZ ? -oz : oz;
posX = ax;
posY = ay;
posZ = az;
};
void update(short x, short y, short z, unsigned long deltaTime){
x = invX ? -x : x;
y = invY ? -y : y;
z = invZ ? -z : z;
deltaDPU = dpu / float(deltaTime);
rateX = (x - offsetX) / deltaDPU;
rateY = (y - offsetY) / deltaDPU;
rateZ = (z - offsetZ) / deltaDPU;
// sum angle using rate only
rsumX += rateX;
rsumY += rateY;
rsumZ += rateZ;
rsumX = wrapAngle(rsumX);
rsumY = wrapAngle(rsumY);
rsumZ = wrapAngle(rsumZ);
posX += rateX;
posY += rateY;
posZ += rateZ;
posX = wrapAngle(posX);
posY = wrapAngle(posY);
posZ = wrapAngle(posZ);
};
void correct(float cx, float cy, float cz){
/*
posX = (posX * gyroWeight) + (cx * correctionWeight);
posY = (posY * gyroWeight) + (cy * correctionWeight);
posZ = (posZ * gyroWeight) + (cz * correctionWeight);
*/
posX = angleInterpolate(posX, cx, correctionWeight);
posY = angleInterpolate(posY, cy, correctionWeight);
posZ = angleInterpolate(posZ, cz, correctionWeight);
};
void correctXY(float cx, float cy){
/*
posX = (posX * gyroWeight) + (cx * correctionWeight);
posY = (posY * gyroWeight) + (cy * correctionWeight);
*/
posX = angleInterpolate(posX, cx, correctionWeight);
posY = angleInterpolate(posY, cy, correctionWeight);
};
void correctZ(float cz){
//posZ = (posZ * gyroWeight) + (cz * correctionWeight);
posZ = angleInterpolate(posZ, cz, correctionWeight);
};
void zeroZ(){
posZ = 0.0;
rsumZ = 0.0;
};
};
#endif // GYROANGLE_H
|
pauljlohman/Pegasus
|
libraries/XRotor/XRotor.h
|
<filename>libraries/XRotor/XRotor.h
#ifndef XRotor_H
#define XRotor_H
#include <Arduino.h>
#include <math.h>
//#include <Servo.h>
class XRotor {
unsigned int pwmWriteFrequency;
byte pwmResolution;
unsigned int escMin;
unsigned int escMax;
long remap(long long value, long long low1, long long high1, long long low2, long long high2);
public:
void config(long inputMin, long inputMax, unsigned int frequency, byte resolution);
void init(byte pin);
void update(byte pin, long signal);
unsigned int getMinThrottle(){ return escMin;};
unsigned int getMaxThrottle(){ return escMax;};
long signalMin;
long signalMax;
void demo(byte pin);
};
#endif // XRotor_H
|
pauljlohman/Pegasus
|
libraries/Pegasus_CtrlData/Pegasus_ConfigMem.h
|
<reponame>pauljlohman/Pegasus
#include "EEPROM_I2C.h"
// ADDRESS
// NAV MODE 4 bytes
//+0 yaw, +1 pitch, +2 roll, +3 throttle
#define ADDR_NAV_MODE 0
// NAV RANGE 5 bytes
//+0 yaw, +1 pitch, +2 roll, +3 throttle
#define ADDR_NAV_RANGE_REL 4
#define ADDR_NAV_RANGE_ABS 9
// PID 6 bytes, 3 uint16
//+0 upper P, +1 lower P, +2 upper I, +3 lower I, +4 upper D, +5 lower D
#define ADDR_PID_YAW 14
#define ADDR_PID_PITCH 20
#define ADDR_PID_ROLL 26
#ifndef PEGASUS_CONFIGMEM_H
#define PEGASUS_CONFIGMEM_H
class Pegasus_ConfigMem{
EEPROM_I2C mem;
byte buf[2];
public:
void init(){
mem.devAddr = B1010000;
};
// write Nav Mode
void write_NavMode_Yaw(byte mode){
mem.writeByte(ADDR_NAV_MODE+0, mode);
};
void write_NavMode_Pitch(byte mode){
mem.writeByte(ADDR_NAV_MODE+1, mode);
};
void write_NavMode_Roll(byte mode){
mem.writeByte(ADDR_NAV_MODE+2, mode);
};
void write_NavMode_Throttle(byte mode){
mem.writeByte(ADDR_NAV_MODE+3, mode);
};
// write Nav Range Relative
void write_NavRange_Yaw_Rel(byte range){
mem.writeByte(ADDR_NAV_RANGE_REL+0, range);
};
void write_NavRange_Pitch_Rel(byte range){
mem.writeByte(ADDR_NAV_RANGE_REL+1, range);
};
void write_NavRange_Roll_Rel(byte range){
mem.writeByte(ADDR_NAV_RANGE_REL+2, range);
};
void write_NavRange_Throttle_Rel(uint16_t range){
buf[0] = byte(range >> 8);
buf[1] = byte(range);
mem.write(ADDR_NAV_RANGE_REL+3, 2, buf);
};
// write Nav Range Absolute
void write_NavRange_Yaw_Abs(byte range){
mem.writeByte(ADDR_NAV_RANGE_ABS+0, range);
};
void write_NavRange_Pitch_Abs(byte range){
mem.writeByte(ADDR_NAV_RANGE_ABS+1, range);
};
void write_NavRange_Roll_Abs(byte range){
mem.writeByte(ADDR_NAV_RANGE_ABS+2, range);
};
void write_NavRange_Throttle_Abs(uint16_t range){
buf[0] = byte(range >> 8);
buf[1] = byte(range);
mem.write(ADDR_NAV_RANGE_ABS+3, 2, buf);
};
// write PID Yaw
void write_PID_Yaw_P(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_YAW+0, 2, buf);
};
void write_PID_Yaw_I(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_YAW+2, 2, buf);
};
void write_PID_Yaw_D(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_YAW+4, 2, buf);
};
// write PID Pitch
void write_PID_Pitch_P(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_PITCH+0, 2, buf);
};
void write_PID_Pitch_I(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_PITCH+2, 2, buf);
};
void write_PID_Pitch_D(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_PITCH+4, 2, buf);
};
// write PID Roll
void write_PID_Roll_P(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_ROLL+0, 2, buf);
};
void write_PID_Roll_I(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_ROLL+2, 2, buf);
};
void write_PID_Roll_D(uint16_t v){
buf[0] = byte(v >> 8);
buf[1] = byte(v);
mem.write(ADDR_PID_ROLL+4, 2, buf);
};
// read Nav Mode
byte read_NavMode_Yaw(){
return mem.readByte(ADDR_NAV_MODE+0);
};
byte read_NavMode_Pitch(){
return mem.readByte(ADDR_NAV_MODE+1);
};
byte read_NavMode_Roll(){
return mem.readByte(ADDR_NAV_MODE+2);
};
byte read_NavMode_Throttle(){
return mem.readByte(ADDR_NAV_MODE+3);
};
// read Nav Range Relative
byte read_NavRange_Yaw_Rel(){
return mem.readByte(ADDR_NAV_RANGE_REL+0);
};
byte read_NavRange_Pitch_Rel(){
return mem.readByte(ADDR_NAV_RANGE_REL+1);
};
byte read_NavRange_Roll_Rel(){
return mem.readByte(ADDR_NAV_RANGE_REL+2);
};
uint16_t read_NavRange_Throttle_Rel(){
mem.read(ADDR_NAV_RANGE_REL+3, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
// read Nav Range Absolute
byte read_NavRange_Yaw_Abs(){
return mem.readByte(ADDR_NAV_RANGE_ABS+0);
};
byte read_NavRange_Pitch_Abs(){
return mem.readByte(ADDR_NAV_RANGE_ABS+1);
};
byte read_NavRange_Roll_Abs(){
return mem.readByte(ADDR_NAV_RANGE_ABS+2);
};
uint16_t read_NavRange_Throttle_Abs(){
mem.read(ADDR_NAV_RANGE_ABS+3, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
// read PID Yaw Relative
uint16_t read_PID_Yaw_P(){
mem.read(ADDR_PID_YAW+0, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
uint16_t read_PID_Yaw_I(){
mem.read(ADDR_PID_YAW+2, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
uint16_t read_PID_Yaw_D(){
mem.read(ADDR_PID_YAW+4, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
// read PID Pitch Relative
uint16_t read_PID_Pitch_P(){
mem.read(ADDR_PID_PITCH+0, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
uint16_t read_PID_Pitch_I(){
mem.read(ADDR_PID_PITCH+2, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
uint16_t read_PID_Pitch_D(){
mem.read(ADDR_PID_PITCH+4, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
// read PID Roll Relative
uint16_t read_PID_Roll_P(){
mem.read(ADDR_PID_ROLL+0, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
uint16_t read_PID_Roll_I(){
mem.read(ADDR_PID_ROLL+2, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
uint16_t read_PID_Roll_D(){
mem.read(ADDR_PID_ROLL+4, 2, buf);
return ((uint16_t)buf[0]<<8) | buf[1];
};
void format(){
// write Nav Mode
write_NavMode_Yaw(1);
write_NavMode_Pitch(0);
write_NavMode_Roll(0);
write_NavMode_Throttle(0);
// write Nav Range Relative
write_NavRange_Yaw_Rel(2);
write_NavRange_Pitch_Rel(4);
write_NavRange_Roll_Rel(4);
write_NavRange_Throttle_Rel(8);
// write Nav Range Absolute
write_NavRange_Yaw_Abs(15);
write_NavRange_Pitch_Abs(30);
write_NavRange_Roll_Abs(30);
write_NavRange_Throttle_Abs(32767);
// write PID
write_PID_Yaw_P(100);
write_PID_Yaw_I(50);
write_PID_Yaw_D(30);
write_PID_Pitch_P(120);
write_PID_Pitch_I(70);
write_PID_Pitch_D(50);
write_PID_Roll_P(120);
write_PID_Roll_I(70);
write_PID_Roll_D(50);
};
};
#endif // Pegasus_ConfigMem
|
pauljlohman/Pegasus
|
libraries/Stick/CapacitiveSwitch.h
|
/*
Joystick library
http://www.third-helix.com/2013/04/12/doing-thumbstick-dead-zones-right.html
*/
#ifndef CAPACITIVESWITCH_H
#define CAPACITIVESWITCH_H
class CapacitiveSwitch {
byte pin;
long threshold = 1700;
short offset = 50;
short countRange = 200;
short count = 0;
public:
void config(byte _pin, long _threshold, short _offset, short _countRange){
pin = _pin;
threshold = _threshold;
offset = _offset;
countRange = _countRange;
};
void setThreshold(long _threshold){
threshold = _threshold;
};
void calibrate(){
float avg = 0.0;
for(int i=0; i<200; i++){
avg += float(touchRead(pin));
delay(2);
}
avg /= 200.0;
threshold = long(avg);
};
bool check(bool currentState){
count += touchRead(pin) > (threshold + offset) ? 1 : -1;
count = max(count, 0);
count = min(count, countRange);
if( count > countRange-1){
return true;
}
if( count < 1){
return false;
}
return currentState;
};
};
#endif // CAPACITIVESWITCH_H
|
pauljlohman/Pegasus
|
libraries/PID/pPID.h
|
/*
https://en.wikipedia.org/wiki/PID_controller
PID controller
(P) Accounts for present value of the error.
i.e. if the error is large, the control output will also be large.
(I) Accounts for past values of the error.
i.e. if the current output is not sufficiently strong, error will accumulate over time,
and the controller will respond by applying a stronger action.
(D) Accounts for possible future values of the error, based on its current rate of change.
Tuning:
From http://robotics.stackexchange.com/questions/167/what-are-good-strategies-for-tuning-pid-loops
1.Set all gains to zero.
2.Increase P gain until the response to a disturbance is steady oscillation.
3.Increase D gain until the the oscillations go away (i.e. it's critically damped).
4.Repeat steps 2 and 3 until increasing the D gain does not stop the oscillations.
5.Set P and D to the last stable values.
6.Increase I gain until it brings you to the set point with the number of oscillations desired.
(normally zero but a quicker response can be had if you don't mind a couple oscillations of overshoot)
Reference
http://controlguru.com/table-of-contents/
https://en.wikipedia.org/wiki/PID_controller
http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/
https://github.com/nzjrs/pid
*/
#ifndef PPID_H
#define PPID_H
class pPID{
float error;
float previous_measured_point;
float integral;
float derivative;
float Kp, Ki, Kd;
float outMin, outMax;
float output;
float clamp(float v){
if(v > outMax){
v = outMax;
}else if(v < outMin){
v = outMin;
}
return v;
};
public:
float compute(float set_point, float measured_point){
error = set_point - measured_point;
integral += Ki * error;
integral = clamp(integral);
derivative = measured_point - previous_measured_point;
previous_measured_point = measured_point;
output = Kp * error;
output += integral;
output -= Kd * derivative;
//output = max( min(output, outMax), outMin);
output = clamp(output);
return output;
};
void config(unsigned short sampleSi, float p, float i, float d, float outputMin, float outputMax){
float samplesPerSec = sampleSi / 1000000.0; // microseconds
Kp = p;
Ki = i * samplesPerSec;
Kd = d / samplesPerSec;
outMin = outputMin;
outMax = outputMax;
output = clamp(output);
integral = clamp(integral);
};
float getError(){return error;};
float getIntegral(){return integral;};
float getDerivative(){return derivative;};
};
#endif // pPID_H
|
pauljlohman/Pegasus
|
libraries/IMU/AccelAngle.h
|
<reponame>pauljlohman/Pegasus<gh_stars>1-10
/*
MPU9255 - ACCELEROMETER
AFS_SEL | Full Scale Range | LSB Sensitivity
--------+------------------+----------------
0 | +/- 2g | 16384 LSB/g
1 | +/- 4g | 8192 LSB/g
2 | +/- 8g | 4096 LSB/g
3 | +/- 16g | 2048 LSB/g
Sensitivity Change vs. Temperature
-40°C to +85°C AFS_SEL:0 is ±0.026 %/°C
Zero-G Level Change vs. Temperature
X (ROLL)
longitudinal axis runs from front to back
positive value raises the left side and lowers the right
Y (PITCH)
lateral axis runs left to right
positive value raises the nose and lowers the tail
Z (YAW)
vertical axis runs top to bottom
positive value moves the nose right
MPU9255 - AK8963C - COMPASS
Full scale measurement range is ±4800µT
Y axis runs front to back
X axis runs left to right
z axis runs bottom to top
*/
#ifndef ACCELANGLE_H
#define ACCELANGLE_H
#include "math.h"
class AccelAngle{
float radToDegree = 57.295779513082320876798154814105;// 180 / PI
float degreeToRad = 0.01745329251994329576923690768489;// PI / 180
// invert output angle
bool invX, invY, invZ;
// resting position
float Xoffset, Yoffset, Zoffset;
float vecLength(float &_x, float &_y, float &_z){
return sqrt(_x*_x + _y*_y + _z*_z);
};
void vecNormalize(float &_x, float &_y, float &_z) {
float m = vecLength(_x,_y,_z);
_x /= m;
_y /= m;
_z /= m;
};
public:
// angular position
float x, y, z;
// gravity total
float g = 0;
void config(bool _x, bool _y, bool _z){
invX = _x;
invY = _y;
invZ = _z;
};
void setRestingPosition(float _x, float _y, float _z){
Xoffset = _x;
Yoffset = _y;
Zoffset = _z;
};
void update(short _x, short _y, short _z){
float xf = float(_x)-Xoffset;
float yf = float(_y)-Yoffset;
float zf = float(_z);//-Zoffset;
// get total gravity and normalize
//float g = vecLength(xf,yf,zf);
// roll relative to z
x = atan2f(yf, sqrt(xf*xf + zf*zf)) * radToDegree;
// pitch relative to z
y = atan2f(-xf, sqrt(yf*yf + zf*zf)) * radToDegree;
// yaw position calculated in compass
z = 0.0;
// attempt to provide range past 90, mostly good till close to 180 in either axis
if(zf < 0){
if(abs(x) > abs(y)){
if(x > 0){
x = 180 - x;
}else{
x = -180 - x;
}
}else{
if(y > 0){
y = 180 - y ;
}else{
y = -180 - y;
}
}
}
x = invX ? -x : x;
y = invY ? -y : y;
z = invX ? -z : z;
};
};
#endif // ACCELANGLE_H
/*
//get Quaternion between two vectors
Quaternion q;
vector a = crossproduct(v1, v2)
q.xyz = a;
q.w = sqrt((v1.Length ^ 2) * (v2.Length ^ 2)) + dotproduct(v1, v2)
rotating
around the Z-axis
|cos ? -sin ? 0| |x| |x cos ? - y sin ?| |x'|
|sin ? cos ? 0| |y| = |x sin ? + y cos ?| = |y'|
| 0 0 1| |z| | z | |z'|
around the Y-axis
| cos ? 0 sin ?| |x| | x cos ? + z sin ?| |x'|
| 0 1 0| |y| = | y | = |y'|
|-sin ? 0 cos ?| |z| |-x sin ? + z cos ?| |z'|
around the X-axis
|1 0 0| |x| | x | |x'|
|0 cos ? -sin ?| |y| = |y cos ? - z sin ?| = |y'|
|0 sin ? cos ?| |z| |y sin ? + z cos ?| |z'|
*/
|
pauljlohman/Pegasus
|
libraries/Stick/Stick.h
|
/*
Joystick library
http://www.third-helix.com/2013/04/12/doing-thumbstick-dead-zones-right.html
*/
#ifndef STICK_H
#define STICK_H
#include <RollingAverage.h>
class Stick {
byte pin;
RollingAverage avg;
float center = 512.0;
float outerEdge = 0.0;
float deadZone = 0.0;
float range = 512.0;
bool flip = false;
float mapf(float x, float in_min, float in_max, float out_min, float out_max){
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
};
public:
float v;
void config(byte _pin, float _outerEdge, float _deadZone, float _outputRange, bool _flip){
pin = _pin;
outerEdge = _outerEdge;
deadZone = _deadZone;
range = _outputRange;
flip = _flip;
avg.config(4);
};
void setOutputRange(float _outputRange){
range = _outputRange;
};
void calibrate(){
center = 0.0;
for(int i=0; i<200; i++){
center += float(analogRead(pin));
delay(2);
}
center /= 200.0;
};
void update(){
//unsigned long time = millis();
v = float(analogRead(pin));
//Serial.printf("raw %f\n", v, time);
v = avg.update(v);
//Serial.printf("damp %f %i\n", v, time);
v = flip ? 1024.0 - v : v;
if(v < center-deadZone){
v = mapf(v, 0.0+outerEdge, center-deadZone, -range, 0.0);
}else if(v > center+deadZone){
v = mapf(v, center+deadZone, 1024.0-outerEdge, 0.0, range);
}else{
v = 0.0;
}
//Serial.printf("map %f %i\n", v, time);
};
};
#endif // STICK_H
|
pauljlohman/Pegasus
|
libraries/Stick/Pot.h
|
#ifndef POT_H
#define POT_H
#include <RollingAverage.h>
class Pot {
byte pin;
RollingAverage avg;
float range = 512.0;
bool flip = false;
public:
float v;
void config(byte _pin, float _outputRange, bool _flip){
pin = _pin;
range = _outputRange;
flip = _flip;
avg.config(4);
};
void setOutputRange(float _outputRange){
range = _outputRange;
};
void update(){
//unsigned long time = millis();
v = float(analogRead(pin));
//Serial.printf("raw %f\n", v, time);
v = avg.update(v);
//Serial.printf("damp %f %i\n", v, time);
v = flip ? 1024.0 - v : v;
v = v * (range/1024.0);
//Serial.printf("map %f %i\n", v, time);
};
};
#endif // POT_H
|
pauljlohman/Pegasus
|
libraries/Smooth/RollingAverage.h
|
<reponame>pauljlohman/Pegasus<filename>libraries/Smooth/RollingAverage.h
/*
RollingAverage ra1;
ra1.bankSize = 32;
float a1 = ra1.update( analogRead(9)-512);
*/
#ifndef ROLLINGAVERAGE_H
#define ROLLINGAVERAGE_H
#define MAXBANKSIZE 8
class RollingAverage{
float sample[MAXBANKSIZE] = {0.0};
byte bankSize = MAXBANKSIZE;
byte sampCount = 0;
byte index = 0;
float average;
public:
void config(byte _bankSize){
bankSize = constrain(_bankSize, 1, MAXBANKSIZE);
};
float update(float value){
sampCount = min(bankSize, sampCount+1);
average -= sample[index];
//float temp = value / float(sampCount);
float temp = value / float(bankSize);
sample[index] = temp;
average += temp;
index++;
if(index >= bankSize){
index = 0;
}
if(sampCount >= bankSize){
return average;
}else{
return value;
}
};
};
#endif
|
pauljlohman/Pegasus
|
libraries/Smooth/Dampen.h
|
<reponame>pauljlohman/Pegasus
/*
*/
#ifndef DAMPEN_H
#define DAMPEN_H
class Dampen{
bool isFirstSample = true;
float dry = 0.01;
float wet = 1.0-dry;
float outValue;
public:
void config(float f){
f = constrain(f,0.0,1.0);
dry = 1.0 - f;
wet = f;
};
float update(float value){
if(isFirstSample){
isFirstSample = false;
outValue = value;
}
outValue = (value*dry) + (outValue*wet);
return outValue;
};
};
#endif
|
pauljlohman/Pegasus
|
libraries/IMU/CompassAngle.h
|
/*
MPU9255 - AK8963C - COMPASS
Full scale measurement range is ±4800µT
Y axis runs front to back
X axis runs left to right
z axis runs bottom to top
(YAW)
positive value moves the nose right
*/
#ifndef COMPASSANGLE_H
#define COMPASSANGLE_H
#include "math.h"
class CompassAngle{
float radToDegree = 180.0 / 3.1415926535897932384626433832795;
float Xoffset, Yoffset, Zoffset;
float Xscale, Yscale, Zscale;
float yawOffset = 0.0;
float raw_yaw = 0.0;
void vectorReject(float ax, float ay, float az, float bx, float by, float bz, float &_x, float &_y, float &_z){
// project vector a onto plane b
// a - ((a dot b)/(b dot b))*b
float AdotB = dot(ax,ay,az,bx,by,bz);
float BdotB = dot(bx,by,bz,bx,by,bz);
float temp = AdotB / BdotB;
float abx = bx * temp;
float aby = by * temp;
float abz = bz * temp;
_x = ax - abx;
_y = ay - aby;
_z = az - abz;
};
float dot(float ax, float ay, float az, float bx, float by, float bz){
return ax*bx + ay*by + az*bz;
};
void cross(float ax, float ay, float az, float bx, float by, float bz, float &_x, float &_y, float &_z){
_x = ay*bz - az*by;
_y = az*bx - ax*bz;
_z = ax*by - ay*bx;
};
float vecLength(float &_x, float &_y, float &_z){
return sqrt(_x*_x + _y*_y + _z*_z);
};
void vecNormalize(float &_x, float &_y, float &_z) {
float m = vecLength(_x,_y,_z);
_x /= m;
_y /= m;
_z /= m;
};
float wrapAngle(float v){
if(v > 180.0){
return v - 360.0;
}
if(v < -180.0){
return v + 360.0;
}
return v;
};
public:
float yaw;
//float mx, my, mz; //expose for debug purposes
//float rx, ry, rz; //expose for debug purposes
void config(float xo, float yo, float zo, float xs, float ys, float zs){
Xoffset = xo;
Yoffset = yo;
Zoffset = zo;
Xscale = xs;
Yscale = ys;
Zscale = zs;
};
void zero(){
yawOffset = raw_yaw;
};
void update(short _x, short _y, short _z, short ux, short uy, short uz){
_x = (_x - Xoffset) * Xscale;
_y = (_y - Yoffset) * Yscale;
_z = (_z - Zoffset) * Zscale;
// transform compass to align with acc on mpu-9255
float mx, my, mz;
mx = _y*-1;
my = _x*-1;
mz = _z;
vecNormalize(mx, my, mz);
float upX = float(ux);
float upY = float(uy);
float upZ = float(uz);
vecNormalize(upX, upY, upZ);
// reject compass vector onto up vector plane
float rx, ry, rz;
vectorReject(mx, my, mz, upX, upY, upZ, rx, ry, rz);
yaw = atan2f(rx, ry) * radToDegree;
yaw = yaw * -1; //invert output to get clockwise behavior, complies with common flight scheme
raw_yaw = yaw;
yaw = wrapAngle(yaw - yawOffset);
};
};
#endif
/*
//get Quaternion between two vectors
Quaternion q;
vector a = crossproduct(v1, v2)
q.xyz = a;
q.w = sqrt((v1.Length ^ 2) * (v2.Length ^ 2)) + dotproduct(v1, v2)
rotating
around the Z-axis
|cos ? -sin ? 0| |x| |x cos ? - y sin ?| |x'|
|sin ? cos ? 0| |y| = |x sin ? + y cos ?| = |y'|
| 0 0 1| |z| | z | |z'|
around the Y-axis
| cos ? 0 sin ?| |x| | x cos ? + z sin ?| |x'|
| 0 1 0| |y| = | y | = |y'|
|-sin ? 0 cos ?| |z| |-x sin ? + z cos ?| |z'|
around the X-axis
|1 0 0| |x| | x | |x'|
|0 cos ? -sin ?| |y| = |y cos ? - z sin ?| = |y'|
|0 sin ? cos ?| |z| |y sin ? + z cos ?| |z'|
*/
|
pauljlohman/Pegasus
|
libraries/CurveRemap/CurveRemap.h
|
#ifndef CURVEREMAP_H
#define CURVEREMAP_H
class CurveRemap{
private:
// http://codereview.stackexchange.com/a/33043
byte greatestIndexNotExceeding(unsigned short *arr, unsigned short limit, byte lb, byte ub) {
byte mid = (lb + ub) / 2;
// Need to go lower but can't
if (mid == lb && arr[mid] > limit) {
return 0;// divergence from original which was -1;
}
// Found a candidate, and can't go higher
if (arr[mid] <= limit && (mid == ub || arr[mid + 1] > limit)) {
return mid;
}
if (arr[mid] <= limit) {
// Consider upper half
return greatestIndexNotExceeding(arr, limit, mid + 1, ub);
} else {
// Consider lower half
return greatestIndexNotExceeding(arr, limit, lb, mid);
}
};
public:
unsigned short interp(unsigned short value, unsigned short *x, unsigned short *y, byte arrayLength){
byte lb = greatestIndexNotExceeding(x, value, 0, arrayLength-1); // returns lower bound
byte ub = min(lb+1, arrayLength-1); // upper bound
float f = lb==ub ? 1.0 : (value-x[lb]) / float(x[ub] - x[lb]);
//Serial.printf("v %i, lb[%i] %i, ub[%i] %i, f %0.2f, y ", value, lb, x[lb], ub, x[ub], f);
return y[lb] + (f * (y[ub]-y[lb]));
};
};
#endif // CURVEREMAP_H
/*
http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/
// largest value <= key
// Invariant: A[l] <= key and A[r] > key
// Boundary: |r - l| = 1
// Input: A[l .... r-1]
// Precondition: A[l] <= key <= A[r]
int Floor(int A[], int l, int r, int key)
{
int m;
while( r - l > 1 )
{
m = l + (r - l)/2;
if( A[m] <= key )
l = m;
else
r = m;
}
return A[l];
}
// Initial call
int Floor(int A[], int size, int key)
{
// Add error checking if key < A[0]
if( key < A[0] )
return -1;
// Observe boundaries
return Floor(A, 0, size, key);
}
*/
|
pauljlohman/Pegasus
|
libraries/ZETA1/ZETA1.h
|
/* For Silicon Labs’ Si4455 Transceiver rev B1A
Developed on RFSolutions ZETA-915, Teensy LC, Arduino IDE
fixed packet length, can be configured using WDS
consolidated used functions into single class
re-facter to support blocking or non blocking flow
*/
#ifndef ZETA1_H
#define ZETA1_H
#include <Arduino.h>
#include <SPI.h>
#include "radio_config_peggy.h"
class ZETA1 {
byte CSPin; // chip select pin, "nSEL" input pin on ZETA
byte nIRQPin; // interrupt pin on ZETA
byte SDNPin; // set high to shutdown radio, low to enable
byte CTSPin; // connected to GPIO1 on ZETA, by default it goes high when clear to send commands
byte channelNumber = RADIO_CONFIGURATION_DATA_CHANNEL_NUMBER;
bool ctsWentHigh = false;
union si4455_cmd_reply_union Si4455Cmd;
byte radioCmd[16];
public:
ZETA1(byte CS, byte INT, byte SDN);
bool checkCTS();
void waitTillReplyReady();
void waitTillClearToSend();
void sendBytes(byte byteCount, byte *data);
void sendByte(byte data);
void getReply(byte byteCount, byte *data);
byte initialize();
void getInterruptStatus(byte PH_CLR_PEND, byte MODEM_CLR_PEND, byte CHIP_CLR_PEND);
void debugInterruptStatus();
byte sendCmdGetResp(byte cmdByteCount, byte* pCmdData, byte respByteCount, byte* pRespData);
void writeEZConfigArray(byte byteCount, const byte* pEzConfigArray);
void reset();
byte nirqLevel();
void fifoInfo(bool resetRX, bool resetTX);
void startRX();
void startTX(byte *data);
byte checkReceived(byte *data);
bool checkTransmitted(void);
const byte packetLength = RADIO_CONFIGURATION_DATA_RADIO_PACKET_LENGTH;
enum
{
SI4455_SUCCESS,
SI4455_NO_PATCH,
SI4455_CTS_TIMEOUT,
SI4455_PATCH_FAIL,
SI4455_COMMAND_ERROR
};
};
#endif // ZETA1_H
|
trukanduk/pq_huffman
|
src/huffman_decode.c
|
#include "huffman.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
typedef struct _huffman_decoder_node {
int symbol;
struct _huffman_decoder_node* children[2];
} huffman_decoder_node_t;
typedef struct _huffman_decoder {
huffman_decoder_node_t* root_node;
huffman_decoder_node_t* current_node;
int alphabet_size;
int is_context;
int noparent_symbol_length;
int prev_symbol;
int current_noparent_symbol_length;
int current_noparent_symbol;
} huffman_decoder_t;
static void huffman_decoder_init_empty_node(huffman_decoder_node_t* node) {
node->symbol = HUFFMAN_NO_SYMBOL;
node->children[0] = NULL;
node->children[1] = NULL;
}
static huffman_decoder_node_t* huffman_decoder_add_code(huffman_decoder_node_t* node, int symbol,
const huffman_code_item_t* item, int depth) {
if (!node) {
node = malloc(sizeof(*node));
huffman_decoder_init_empty_node(node);
}
if (depth == item->bit_length) {
node->symbol = symbol;
} else {
int byte_offset = depth / BYTE_NUM_BITS;
int bit_offset = depth % BYTE_NUM_BITS;
int bit_value = (item->code[byte_offset] >> (BYTE_NUM_BITS - bit_offset - 1)) & 1;
node->children[bit_value] = huffman_decoder_add_code(node->children[bit_value], symbol,
item, depth + 1);
}
return node;
}
static huffman_decoder_node_t* huffman_decoder_free_trie(huffman_decoder_node_t* node,
int free_this) {
if (!node) {
return NULL;
}
huffman_decoder_free_trie(node->children[0], 1);
huffman_decoder_free_trie(node->children[1], 1);
if (free_this) {
free(node);
}
return NULL;
}
huffman_decoder_t* huffman_decoder_create(const huffman_codebook_t* codebook) {
// TODO: allocate nodes pool
huffman_decoder_t* decoder = malloc(sizeof(huffman_decoder_t));
decoder->alphabet_size = codebook->alphabet_size;
decoder->is_context = codebook->is_context;
decoder->prev_symbol = HUFFMAN_NO_SYMBOL;
decoder->current_noparent_symbol_length = 0;
decoder->current_noparent_symbol = 0;
decoder->noparent_symbol_length = 1;
while ((1 << decoder->noparent_symbol_length) < decoder->alphabet_size) {
++decoder->noparent_symbol_length;
}
if (decoder->is_context) {
decoder->root_node = malloc(sizeof(*decoder->root_node) * decoder->alphabet_size);
for (int src_symbol_id = 0; src_symbol_id < decoder->alphabet_size; ++src_symbol_id) {
huffman_decoder_init_empty_node(decoder->root_node + src_symbol_id);
for (int symbol_id = 0; symbol_id < codebook->alphabet_size; ++symbol_id) {
huffman_decoder_add_code(
decoder->root_node + src_symbol_id, symbol_id,
&codebook->items[src_symbol_id * decoder->alphabet_size + symbol_id], 0);
}
}
decoder->current_node = NULL;
} else {
decoder->root_node = NULL;
for (int symbol_id = 0; symbol_id < codebook->alphabet_size; ++symbol_id) {
decoder->root_node = huffman_decoder_add_code(decoder->root_node, symbol_id,
&codebook->items[symbol_id], 0);
}
decoder->current_node = decoder->root_node;
}
return decoder;
}
huffman_decoder_t* huffman_decoder_destroy(huffman_decoder_t* decoder) {
if (decoder->is_context) {
for (int symbol_id = 0; symbol_id < decoder->alphabet_size; ++symbol_id) {
huffman_decoder_free_trie(decoder->root_node + symbol_id, 0);
}
free(decoder->root_node);
decoder->root_node = NULL;
} else {
decoder->root_node = huffman_decoder_free_trie(decoder->root_node, 1);
}
decoder->current_node = NULL;
free(decoder);
return NULL;
}
void huffman_decoder_reset(huffman_decoder_t* decoder) {
huffman_decoder_set_prev_symbol(decoder, HUFFMAN_NO_SYMBOL);
}
void huffman_decoder_set_prev_symbol(huffman_decoder_t* decoder, int prev_symbol) {
if (!decoder->is_context) {
decoder->current_node = decoder->root_node;
return;
}
decoder->current_noparent_symbol_length = 0;
decoder->current_noparent_symbol = 0;
decoder->prev_symbol = prev_symbol;
if (prev_symbol == HUFFMAN_NO_SYMBOL) {
decoder->current_node = NULL;
} else {
assert(prev_symbol < decoder->alphabet_size);
decoder->current_node = decoder->root_node + prev_symbol;
}
}
int huffman_decoder_push_bit(huffman_decoder_t* decoder, int bit_value) {
if (decoder->is_context && decoder->prev_symbol == HUFFMAN_NO_SYMBOL) {
// NOTE: warming mode
decoder->current_noparent_symbol = (decoder->current_noparent_symbol << 1) + (bit_value & 1);
++decoder->current_noparent_symbol_length;
if (decoder->current_noparent_symbol_length >= decoder->noparent_symbol_length) {
int current_symbol = decoder->current_noparent_symbol;
assert(decoder->current_noparent_symbol < decoder->alphabet_size);
huffman_decoder_set_prev_symbol(decoder, current_symbol);
return current_symbol;
} else {
return HUFFMAN_NO_SYMBOL;
}
}
decoder->current_node = decoder->current_node->children[bit_value & 1];
if (!decoder->current_node) {
huffman_decoder_reset(decoder);
return HUFFMAN_INVALID_SYMBOL;
} else if (decoder->current_node->symbol != HUFFMAN_NO_SYMBOL) {
int symbol = decoder->current_node->symbol;
huffman_decoder_set_prev_symbol(decoder, symbol);
return symbol;
} else {
return HUFFMAN_NO_SYMBOL;
}
}
int huffman_decoder_push_bits(huffman_decoder_t* decoder, const byte_t* bits, int bit_length) {
int push_result = HUFFMAN_NO_SYMBOL;
int bit_index = 0;
for (bit_index = 0;
bit_index < bit_length && push_result == HUFFMAN_NO_SYMBOL;
++bit_index)
{
int byte_offset = bit_index / BYTE_NUM_BITS;
int bit_offset = bit_index % BYTE_NUM_BITS;
int bit_value = (bits[byte_offset] >> (BYTE_NUM_BITS - bit_offset - 1)) & 1;
push_result = huffman_decoder_push_bit(decoder, bit_value);
}
return (bit_index == bit_length) ? push_result : HUFFMAN_INVALID_SYMBOL;
}
int huffman_decoder_read_symbol(huffman_decoder_t* decoder, bit_stream_t* stream) {
int symbol = HUFFMAN_NO_SYMBOL;
while (symbol == HUFFMAN_NO_SYMBOL) {
int bit_value = bit_stream_read_bit(stream);
symbol = huffman_decoder_push_bit(decoder, bit_value);
}
return symbol;
}
#ifdef _HUFFMAN_DECODE_TEST
#define NUM_SYMBOLS 6
static void non_context_test() {
double counts[NUM_SYMBOLS] = {1.0, 4.0, 3.0, 8.0, 3.0, 8.0};
huffman_codebook_t codebook;
huffman_codebook_encode_init(&codebook, NUM_SYMBOLS, &counts[0]);
huffman_decoder_t* decoder = huffman_decoder_create(&codebook);
int seq[] = {
0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};
char* decoded = malloc(32 * sizeof(*decoded));
for (int i = 0; i < 31; ++i) {
int symbol = seq[i];
const huffman_code_item_t* item = &codebook.items[symbol];
int result = huffman_decoder_push_bits(decoder, item->code, item->bit_length);
assert(result >= 0 && "Cannot decode symbol");
decoded[i] = 'a' + result;
}
decoded[31] = '\0';
printf("Decoded: '%s'\n", decoded);
assert(!strcmp(decoded, "abacabadabacabaeabacabadabacaba"));
free(decoded);
decoded = NULL;
decoder = huffman_decoder_destroy(decoder);
huffman_codebook_destroy(&codebook);
}
static void context_test() {
double counts[NUM_SYMBOLS * NUM_SYMBOLS] = {
1.0, 4.0, 3.0, 8.0, 3.0, 8.0,
3.0, 9.0, 4.0, 5.0, 2.0, 4.0,
9.0, 4.0, 3.0, 2.0, 8.0, 7.0,
6.0, 5.0, 4.0, 3.0, 2.0, 1.0,
5.0, 4.0, 2.0, 6.0, 9.0, 4.0,
3.0, 7.0, 3.0, 6.0, 9.0, 3.0
};
huffman_codebook_t codebook;
huffman_codebook_context_encode_init(&codebook, NUM_SYMBOLS, &counts[0]);
huffman_decoder_t* decoder = huffman_decoder_create(&codebook);
char decoded[NUM_SYMBOLS * 2 + 1];
char expected[NUM_SYMBOLS * 2 + 1];
decoded[NUM_SYMBOLS * 2] = 0;
expected[NUM_SYMBOLS * 2] = 0;
for (int starting_symbol_id = 0; starting_symbol_id < NUM_SYMBOLS; ++starting_symbol_id) {
huffman_decoder_reset(decoder);
int prev_symbol = HUFFMAN_NO_SYMBOL;
for (int symbol_id = 0; symbol_id < NUM_SYMBOLS; ++symbol_id) {
int got_symbol;
if (prev_symbol == HUFFMAN_NO_SYMBOL) {
byte_t symbol_byte = starting_symbol_id << (BYTE_NUM_BITS - 3);
got_symbol = huffman_decoder_push_bits(decoder, &symbol_byte, 3);
} else {
const huffman_code_item_t* item = codebook.items
+ prev_symbol * NUM_SYMBOLS + starting_symbol_id;
got_symbol = huffman_decoder_push_bits(decoder, item->code, item->bit_length);
}
if (got_symbol < 0) {
printf("Got %d symbol!\n", got_symbol);
}
decoded[symbol_id * 2] = 'a' + got_symbol;
expected[symbol_id * 2] = 'a' + starting_symbol_id;
const huffman_code_item_t* item = codebook.items
+ starting_symbol_id * NUM_SYMBOLS + symbol_id;
got_symbol = huffman_decoder_push_bits(decoder, item->code, item->bit_length);
if (got_symbol < 0) {
printf("Got %d symbol!\n", got_symbol);
}
decoded[symbol_id * 2 + 1] = 'a' + got_symbol;
expected[symbol_id * 2 + 1] = 'a' + symbol_id;
prev_symbol = symbol_id;
}
printf("Decoded %d: %s (expected %s)\n", starting_symbol_id, decoded, expected);
assert(!strcmp(decoded, expected));
}
decoder = huffman_decoder_destroy(decoder);
huffman_codebook_destroy(&codebook);
}
int main() {
non_context_test();
context_test();
return 0;
}
#undef NUM_SYMBOLS
#endif // _HUFFMAN_DECODE_TEST
|
trukanduk/pq_huffman
|
src/fast_nn_result_data.c
|
<reponame>trukanduk/pq_huffman
#include "fast_nn_result_data.h"
#include <stdio.h>
#include <stdlib.h>
void result_data_init(result_data_t* result_data, long long initial_capacity) {
result_data->capacity = 0;
result_data->indices = NULL;
result_data->dists = NULL;
result_data_realloc(result_data, initial_capacity);
}
static void result_data_free_data(result_data_t* result_data) {
if (result_data->indices) {
free(result_data->indices);
result_data->indices = NULL;
}
if (result_data->dists) {
free(result_data->dists);
result_data->dists = NULL;
}
}
void result_data_realloc(result_data_t* result_data, long long new_capacity) {
if (result_data->capacity >= new_capacity) {
return;
}
result_data_free_data(result_data);
result_data->capacity = new_capacity;
result_data->indices = malloc(sizeof(*result_data->indices) * result_data->capacity);
result_data->dists = malloc(sizeof(*result_data->dists) * result_data->capacity);
}
void result_data_destroy(result_data_t* result_data) {
result_data_free_data(result_data);
result_data->capacity = 0;
}
|
trukanduk/pq_huffman
|
src/mst.h
|
<filename>src/mst.h
#ifndef _MST_H
#define _MST_H
#include <stdio.h>
#include "misc.h"
#include "huffman.h"
#include "stats.h"
// NOTE: Internal computing structure
typedef struct _mst_edge {
vector_id_t source;
vector_id_t target;
float dist;
} mst_edge_t;
// NOTE: This way is not very optimal but pretty simple.
typedef struct _tree_edge {
vector_id_t target;
// float dist; // NOTE: We don't need dists info
} tree_edge_t;
typedef struct _tree_vertex {
tree_edge_t* edges;
long long num_edges;
} tree_vertex_t;
typedef struct _tree {
long long num_vertices;
tree_vertex_t* vertices;
long long num_edges; // NOTE: Formally it is a forest, not tree
tree_edge_t* edges;
} tree_t;
// TODO: FIXME: float pq_penalty, const byte_t* pq_indices
mst_edge_t* load_mst_edges_from_nn_filenames(long long num_vectors, int num_nn_to_load, int pq_m,
float pq_penalty, const byte_t* pq_indices,
const char* indices_filename,
const char* dist_filename);
mst_edge_t* load_mst_edges_from_nn_files(long long num_vectors, int num_nn_to_load, int pq_m,
float pq_penalty, const byte_t* pq_indices,
FILE* indices_file, FILE* dist_file);
void minimum_spanning_tree(tree_t* tree, long long num_vertices, int num_nn, mst_edge_t* edges);
void tree_destroy(tree_t* tree);
void tree_save_filename(const tree_t* tree, const char* filename);
void tree_save_file(const tree_t* tree, FILE* file);
void tree_load_filename(tree_t* tree, const char* filename);
void tree_load_file(tree_t* tree, FILE* file);
// TODO: Move to separate file
// TODO: bfs
int tree_collect_vertices_dfs(const tree_t* tree, vector_id_t* vertices, int* num_children);
#define TRAVERSER_NO_PARENT_VECTOR ((vector_id_t)-1)
typedef struct _tree_traverser_item {
vector_id_t vertex_id;
int num_children;
} tree_traverser_item_t;
typedef struct _tree_traverser {
long long num_vertices;
long long stack_size;
tree_traverser_item_t* stack;
} tree_traverser_t;
void tree_traverser_init(tree_traverser_t* traverser, long long num_vertices);
void tree_traverser_destroy(tree_traverser_t* traverser);
void tree_traverser_reset(tree_traverser_t* traverser);
vector_id_t tree_traverser_get_active_parent(const tree_traverser_t* traverser);
void tree_traverser_push_vertex(tree_traverser_t* traverser, vector_id_t vertex_id,
int num_children);
double* tree_collect_num_children_stats(long long num_vectors, const int* num_children,
int* alphabet_size_out);
int tree_collect_indices_stats(long long num_vectors, int pq_m, const byte_t* pq_indices,
const vector_id_t* vertices, const int* num_children, double* stats);
void tree_estimate_huffman_encoding(huffman_stats_t* indices_stats, huffman_stats_t* children_stats,
const tree_t* tree, int pq_m, const byte_t* pq_indices);
#endif // _MST_H
|
trukanduk/pq_huffman
|
src/pq_encoder.c
|
#include "pq.h"
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <yael/kmeans.h>
#include "vecs_io.h"
#include "misc.h"
typedef struct _config {
const char* input_filename;
const char* output_template;
int m;
int num_bits_per_code;
int num_threads;
int use_opq;
int compute_error;
int kmeans_iterations;
long long num_vectors;
int num_dimensions;
int num_dimensions_per_part;
int num_clusters;
char* output_vectors;
char* output_centroids;
char* output_error;
} config_t;
typedef struct _centroids_codebook {
int num_clusters;
int num_dimensions;
int num_parts;
float* centroids_pool;
float** centroids;
} centroids_codebook_t;
enum {
LOAD_BATCH_SIZE = 128 * 1024
};
static void load_input_file_meta(const char* input_filename, long long* num_vectors,
int* num_dimensions) {
FILE* f = fopen(input_filename, "rb");
fread(num_dimensions, 1, sizeof(*num_dimensions), f);
long long file_row_size = *num_dimensions * sizeof(float) + sizeof(int);
fseek(f, 0, SEEK_END);
long long file_size = ftell(f);
*num_vectors = file_size / file_row_size;
assert(file_size % file_row_size == 0);
fclose(f);
}
static void load_vectors_dimensions(const char* input_filename, long long num_vectors,
int from_dimension, int num_dimensions, float* output) {
FILE* f = fopen(input_filename, "rb");
int file_num_dimensions;
fread(&file_num_dimensions, 1, sizeof(file_num_dimensions), f);
fseek(f, 0, SEEK_SET);
long long file_row_size = file_num_dimensions * sizeof(float) + sizeof(int);
float* batch = malloc(file_row_size * LOAD_BATCH_SIZE);
long long got_vectors = 0LL;
while (got_vectors < num_vectors) {
long long current_batch_size = iminll(num_vectors - got_vectors, LOAD_BATCH_SIZE);
long long red_rows = fread(batch, file_row_size, current_batch_size, f);
for (long long row_index = 0; row_index < red_rows; ++row_index) {
memcpy(output + (got_vectors + row_index) * num_dimensions,
batch + (file_num_dimensions + 1) * row_index + from_dimension + 1,
num_dimensions * sizeof(float));
}
got_vectors += red_rows;
}
free(batch);
batch = NULL;
fclose(f);
}
static double compute_error(const char* input_filename, long long num_vectors,
const unsigned char* indices, const centroids_codebook_t* codebook) {
FILE* f = fopen(input_filename, "rb");
int file_num_dimensions;
fread(&file_num_dimensions, 1, sizeof(file_num_dimensions), f);
fseek(f, 0, SEEK_SET);
long long file_row_size = file_num_dimensions * sizeof(float) + sizeof(int);
float* batch = malloc(file_row_size * LOAD_BATCH_SIZE);
long long got_vectors = 0LL;
double sum_error = 0.0;
while (got_vectors < num_vectors) {
long long current_batch_size = iminll(num_vectors - got_vectors, LOAD_BATCH_SIZE);
long long red_rows = fread(batch, file_row_size, current_batch_size, f);
for (long long row_index = 0; row_index < red_rows; ++row_index) {
const unsigned char* vec_indices =
indices + codebook->num_parts * (got_vectors + row_index);
const float* vec_start = batch + (file_num_dimensions + 1) * row_index + 1;
for (int part_index = 0; part_index < codebook->num_parts; ++part_index) {
const float* centroid = codebook->centroids[part_index] +
codebook->num_dimensions * vec_indices[part_index];
for (int dim_index = 0; dim_index < codebook->num_dimensions; ++dim_index) {
float vec_v = vec_start[codebook->num_dimensions * part_index + dim_index];
float cent_v = centroid[dim_index];
float delta = vec_v - cent_v;
sum_error += 1.0 * delta * delta;
}
}
}
got_vectors += red_rows;
}
free(batch);
batch = NULL;
fclose(f);
return sum_error / num_vectors;
}
static void print_help(const char* argv0) {
fprintf(stderr,
"Usage: ./%s <input file> <output template> <m> "
"[--num-threads <nt>] [--compute-error]\n",
argv0);
exit(1);
}
static void parse_args(config_t* config, int argc, const char* argv[]) {
if (argc < 4) {
fprintf(stderr, "Expected 3 positionsl arguments\n");
print_help(argv[0]);
}
int show_help = 0;
config->output_vectors = NULL;
config->output_centroids = NULL;
config->output_error = NULL;
config->input_filename = argv[1];
config->output_template = argv[2];
config->m = atoi(argv[3]);
config->compute_error = 0;
config->num_bits_per_code = 8; // TODO:
config->num_threads = 1; // TODO:
config->use_opq = 0; // TODO:
config->kmeans_iterations = 10;
if (config->m <= 0) {
fprintf(stderr, "Invalid m: %d\n", config->m);
print_help(argv[0]);
}
for (int arg_index = 4; arg_index < argc; ++arg_index) {
if (!strcmp(argv[arg_index], "--num-threads")) {
config->num_threads = atoi(argv[++arg_index]);
} else if (!strcmp(argv[arg_index], "--compute-error")) {
config->compute_error = 1;
} else if (!strcmp(argv[arg_index], "--kmeans-iterations")) {
config->kmeans_iterations = atoi(argv[++arg_index]);
} else {
fprintf(stderr, "Unknown argument: %s\n", argv[arg_index]);
show_help = 1;
}
}
if (show_help) {
print_help(argv[0]);
}
load_input_file_meta(config->input_filename, &config->num_vectors, &config->num_dimensions);
config->num_dimensions_per_part = config->num_dimensions / config->m;
assert(config->num_dimensions % config->m == 0);
config->num_clusters = (1 << config->num_bits_per_code);
config->output_vectors = concat(config->output_template, "pq_indices.bvecsl");
config->output_centroids = concat(config->output_template, "pq_centroids.fvecsl");
config->output_error = concat(config->output_template, "pq_error");
}
static void config_free(config_t* config) {
if (config->output_vectors) {
free(config->output_vectors);
config->output_vectors = NULL;
}
if (config->output_centroids) {
free(config->output_centroids);
config->output_centroids = NULL;
}
if (config->output_error) {
free(config->output_error);
config->output_error = NULL;
}
}
static void copy_cluster_indices(unsigned char* result, int offset, const int* clusters,
long long num_vectors, int m) {
#if 0
unsigned char* res_it = result;
const int* clusters_it = clusters;
for (; clusters_it != clusters + num_vectors; res_it += m, ++clusters_it) {
*res_it = *clusters_it;
}
#else
for (long long i = 0; i < num_vectors; ++i) {
result[i * m + offset] = (unsigned char) clusters[i];
}
#endif
}
static void save_indices(const char* output_filename, const unsigned char* result,
long long num_vectors, int m) {
FILE* f = fopen(output_filename, "wb");
save_vecs_light_meta_file(f, num_vectors, m);
fwrite(result, m * sizeof(*result), num_vectors, f);
fclose(f);
}
static void save_error(const char* output_filename, const float* dists_sum, long long num_vectors) {
double sum = 0.0;
for (const float* dist_it = dists_sum; dist_it != dists_sum + num_vectors; ++dist_it) {
sum += sqrt(*dist_it);
}
FILE* f = fopen(output_filename, "a");
fprintf(f, "%lf\n", sum);
fclose(f);
}
// TODO: Move to library part
static void centroids_codebook_init(centroids_codebook_t* codebook, int num_parts,
int num_clusters, int num_dimensions) {
codebook->num_parts = num_parts;
codebook->num_clusters = num_clusters;
codebook->num_dimensions = num_dimensions;
codebook->centroids_pool = malloc(sizeof(*codebook->centroids_pool) * num_parts
* num_clusters * num_dimensions);
codebook->centroids = malloc(sizeof(*codebook->centroids) * num_parts);
for (int part_index = 0; part_index < num_parts; ++part_index) {
codebook->centroids[part_index] = codebook->centroids_pool
+ part_index * num_clusters * num_dimensions;
}
}
static void centroids_codebook_destroy(centroids_codebook_t* codebook) {
free(codebook->centroids_pool);
codebook->centroids_pool = NULL;
free(codebook->centroids);
codebook->centroids = NULL;
}
static void centroids_codebook_save(const centroids_codebook_t* codebook, const char* filename) {
FILE* f = fopen(filename, "wb");
save_vecs_light_meta_file(f, codebook->num_parts * codebook->num_clusters,
codebook->num_dimensions);
fwrite(codebook->centroids_pool, sizeof(*codebook->centroids_pool) * codebook->num_dimensions,
codebook->num_parts * codebook->num_clusters, f);
fclose(f);
}
static void run(const config_t* config) {
float* data = malloc(sizeof(*data) * config->num_vectors * config->num_dimensions_per_part);
unsigned char* result = calloc(sizeof(*result) * config->num_vectors * config->m, 1);
int* clusters = malloc(sizeof(*clusters) * config->num_vectors);
centroids_codebook_t codebook;
centroids_codebook_init(&codebook, config->m, config->num_clusters,
config->num_dimensions_per_part);
for (int part_index = 0; part_index < config->m; ++part_index) {
printf("Starting part %d\n", part_index);
load_vectors_dimensions(config->input_filename, config->num_vectors,
config->num_dimensions_per_part * part_index,
config->num_dimensions_per_part, data);
kmeans(config->num_dimensions_per_part, config->num_vectors, config->num_clusters,
config->kmeans_iterations, data, config->num_threads | KMEANS_INIT_BERKELEY,
time(NULL), 1, codebook.centroids[part_index], NULL, clusters, NULL);
copy_cluster_indices(result, part_index, clusters, config->num_vectors, config->m);
}
// for (int part_index = 0; part_index < config->m; ++part_index) {
// printf("PART %d\n", part_index);
// for (int index = 0; index < config->num_clusters; ++index) {
// for (int d = 0; d < config->num_dimensions_per_part; ++d) {
// printf("%f ", codebook.centroids[part_index][index * config->num_dimensions_per_part + d]);
// }
// printf("\n");
// }
// printf("\n\n");
// }
centroids_codebook_save(&codebook, config->output_centroids);
save_indices(config->output_vectors, result, config->num_vectors, config->m);
if (config->compute_error) {
double error = compute_error(config->input_filename, config->num_vectors, result,
&codebook);
FILE* f = fopen(config->output_error, "a");
fprintf(f, "%lf\n", error);
fclose(f);
}
centroids_codebook_destroy(&codebook);
free(clusters);
clusters = NULL;
free(result);
result = NULL;
free(data);
data = NULL;
}
int main(int argc, const char* argv[]) {
config_t config;
parse_args(&config, argc, argv);
run(&config);
config_free(&config);
return 0;
}
|
trukanduk/pq_huffman
|
src/fast_nn_block_loader.h
|
#ifndef _FAST_NN_BLOCK_LOADER_H_
#define _FAST_NN_BLOCK_LOADER_H_
#include "fast_nn_block.h"
#include "fast_nn_blocks_info.h"
#include <pthread.h>
void get_vectors_in_block(const char* input_filename, blocks_info_t* blocks_info,
long long* block_indices, float* block, long long* num_vectors_in_block,
long long max_num_vectors_in_block, int num_vectors, int num_dimensions,
long long block_id);
void get_vectors_in_block_batches(FILE* f, blocks_info_t* blocks_info, long long* block_indices,
float* block, long long* num_vectors_in_block,
long long max_num_vectors_in_block, int num_vectors,
int num_dimensions, long long block_id, int rows_in_batch);
void block_loader_filter_block(pthread_mutex_t* mutex, blocks_info_t* blocks_info,
long long* block_indices, float* block,
long long* num_vectors_in_block, long long max_num_vectors_in_block,
int num_dimensions, long long block_id, long long batch_start_index,
long long rows_in_batch, float* batch_start);
typedef struct _block_loader {
pthread_t thread;
const char* input_filename;
blocks_info_t* blocks_info;
long long* block_indices;
float* block;
long long* num_vectors_in_block;
long long max_num_vectors_in_block;
int num_vectors;
int num_dimensions;
long long block_id;
int num_threads;
} block_loader_t;
void block_loader_init(block_loader_t* block_loader, const char* input_filename,
blocks_info_t* blocks_info, long long* block_indices, float* block,
long long* num_vectors_in_block, long long max_num_vectors_in_block,
int num_vectors, int num_dimensions, long long block_id);
void block_loader_join(block_loader_t* block_loader);
void* block_loader_main_thread(void* arg);
#endif // _FAST_NN_BLOCK_LOADER_H_
|
trukanduk/pq_huffman
|
src/read_dists.c
|
<filename>src/read_dists.c
#include <stdio.h>
#define NUM_NN 200
#define NUM_VECTORS 10000
typedef struct _temp_file_item {
long long index;
float dist;
} temp_file_item_t;
int main(int argc, const char* argv[]) {
FILE* f = fopen(argv[1], "rb");
double sum = 0.0;
double min = 100500.0;
double max = -100500.0;
float data[NUM_NN];
temp_file_item_t tdata[NUM_NN];
for (int i = 0; i < NUM_VECTORS; ++i) {
#if 0
fread(&tdata[0], NUM_NN, sizeof(*tdata), f);
if (tdata[0].dist > 100) {
printf("%d: ", i);
for (int j = 0; j < NUM_NN; ++j) {
printf("(%f, %lld) ", tdata[j].dist, tdata[j].index);
}
printf("\n");
}
#endif
#if 1
fread(&data[0], NUM_NN, sizeof(float), f);
for (int j = 0; j < NUM_NN; ++j) {
if (data[j] > 10) {
printf("%d %d\n", i, j);
break;
}
sum += data[j];
// printf("%f\n", data[i]);
}
#endif
#if 0
if (i != 34) {
continue;
}
printf("%d: ", i);
for (int j = 1; j <= NUM_NN; ++j) {
printf("%f ", data[j]);
}
printf("\n");
#endif
#if 0
for (int j = 1; j <= NUM_NN; ++j) {
if (data[j] < min) {
min = data[j];
}
if (data[j] > max) {
max = data[j];
}
}
#endif
}
printf("Sum dists %lf %lf %lf\n", sum, min, max);
return 0;
}
|
trukanduk/pq_huffman
|
src/dsu.c
|
<gh_stars>1-10
#include "dsu.h"
#include <stdlib.h>
void dsu_init(dsu_t* dsu, long long num_elements) {
dsu->num_elements = num_elements;
dsu->items = malloc(sizeof(*dsu->items) * dsu->num_elements);
dsu_item_t* items_it = dsu->items;
for (long long item_id = 0; item_id < dsu->num_elements; ++item_id, ++items_it) {
items_it->rank = 0;
items_it->parent_id = item_id;
}
}
void dsu_destroy(dsu_t* dsu) {
dsu->num_elements = 0;
free(dsu->items);
dsu->items = NULL;
}
vector_id_t dsu_find_set(dsu_t* dsu, vector_id_t element) {
// OPTIMIZE: Make non-recursive?
dsu_item_t* item = dsu->items + element;
if (element == item->parent_id) {
return element;
}
vector_id_t root = dsu_find_set(dsu, item->parent_id);
item->parent_id = root;
return root;
}
int dsu_is_one_set(dsu_t* dsu, vector_id_t first, vector_id_t second) {
return (dsu_find_set(dsu, first) == dsu_find_set(dsu, second));
}
void dsu_union(dsu_t* dsu, vector_id_t first, vector_id_t second) {
vector_id_t first_root = dsu_find_set(dsu, first);
vector_id_t second_root = dsu_find_set(dsu, second);
if (first_root == second_root) {
return;
}
dsu_item_t* first_root_item = dsu->items + first_root;
dsu_item_t* second_root_item = dsu->items + second_root;
if (first_root_item->rank < first_root_item->rank) {
dsu_item_t* tmp = first_root_item;
first_root_item = second_root_item;
second_root_item = first_root_item;
vector_id_t tmpv = first_root;
first_root = second_root;
second_root = tmpv;
}
second_root_item->parent_id = first_root;
if (first_root_item->rank == second_root_item->rank) {
++first_root_item->rank;
}
}
|
trukanduk/pq_huffman
|
src/fast_nn_block_loader2.c
|
#include "fast_nn_block_loader2.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "vecs_io.h"
#include "misc.h"
enum {
BATCH_SIZE = 1000 * 1000
};
static void* block_loader2_thread(void* arg);
void block_loader2_init_from_blocks(block_loader2_t* block_loader, const char* input_filename,
long long num_vectors, int num_dimensions,
const blocks_info_t* blocks_info, block_t* blocks,
long long num_blocks) {
block_loader->thread = NULL;
block_loader->input_filename = input_filename;
block_loader->num_vectors = num_vectors;
block_loader->num_dimensions = num_dimensions;
block_loader->common_prefix = 0;
block_loader->blocks_info = blocks_info;
block_loader->num_blocks_to_load = num_blocks;
block_loader->blocks = blocks;
block_loader->global_indices_capacity = 500;
block_loader->global_indices_size = 0;
block_loader->global_indices =
malloc(sizeof(*block_loader->global_indices) * block_loader->global_indices_capacity);
}
void block_loader2_set_common_prefix(block_loader2_t* block_loader, int common_prefix) {
block_loader->common_prefix = (block_loader->num_blocks_to_load > 1 ? common_prefix : 0);
}
void block_loader2_set_start_block_id(block_loader2_t* block_loader, long long start_block) {
for (int block_index = 0; block_index < block_loader->num_blocks_to_load; ++block_index) {
block_set_id(block_loader->blocks + block_index, start_block + block_index);
}
}
void block_loader2_set_start_block_id_with_prefix(block_loader2_t* block_loader,
long long start_block, int common_prefix) {
block_loader2_set_common_prefix(block_loader, common_prefix);
block_loader2_set_start_block_id(block_loader, start_block);
}
void block_loader2_destroy(block_loader2_t* block_loader) {
block_loader2_join(block_loader);
// TODO:
}
void block_loader2_start(block_loader2_t* block_loader) {
if (block_loader->thread) {
fprintf(stderr, "Block loader2 is not joined yet!\n");
block_loader2_join(block_loader);
}
block_loader->thread = malloc(sizeof(block_loader->thread));
pthread_create(block_loader->thread, NULL, block_loader2_thread, (void*) block_loader);
}
void block_loader2_join(block_loader2_t* block_loader) {
if (block_loader->thread) {
pthread_join(*block_loader->thread, NULL);
free(block_loader->thread);
block_loader->thread = NULL;
}
}
static void block_loader2_push_index(block_loader2_t* block_loader, long long index) {
if (block_loader->global_indices_size >= block_loader->global_indices_capacity) {
block_loader->global_indices_capacity = (block_loader->global_indices_capacity + 1) * 2;
long long new_size = sizeof(*block_loader->global_indices)
* block_loader->global_indices_capacity;
block_loader->global_indices = realloc(block_loader->global_indices, new_size);
}
block_loader->global_indices[block_loader->global_indices_size++] = index;
}
void* block_loader2_thread(void* arg) {
block_loader2_t* block_loader = (block_loader2_t*) arg;
FILE* file = fopen(block_loader->input_filename, "rb");
if (!file) {
fprintf(stderr, "Cannot open %s file\n", block_loader->input_filename);
exit(1);
}
for (int i = 0; i < block_loader->num_blocks_to_load; ++i) {
assert(block_loader->blocks[i].size == 0);
// block_loader->blocks[i].size = 0;
}
long long num_processed = 0;
block_loader->global_indices_size = 0;
float* batch = malloc(
sizeof(*batch) * (block_loader->num_dimensions + 1) * block_loader->num_vectors);
while (num_processed < block_loader->num_vectors) {
long long current_batch_size = iminll(BATCH_SIZE, block_loader->num_vectors - num_processed);
fread(batch, current_batch_size, sizeof(*batch) * (block_loader->num_dimensions + 1), file);
const float* batch_it = batch;
for (int vec_index = 0;
vec_index != current_batch_size;
++vec_index, batch_it += block_loader->num_dimensions + 1)
{
int vector_taken = 0;
if (block_loader->common_prefix > 0) {
int is_in_any_block = is_vector_in_blocks_prefix(
batch_it + 1, block_loader->num_dimensions, block_loader->blocks_info,
block_loader->blocks[0].id, block_loader->common_prefix);
if (!is_in_any_block) {
continue;
}
}
for (int block_index = 0;
block_index < block_loader->num_blocks_to_load;
++block_index)
{
block_t* block = block_loader->blocks + block_index;
int in_block = is_vector_in_block(batch_it + 1, block_loader->num_dimensions,
block_loader->blocks_info, block->id);
if (in_block) {
// if (!is_in_any_block) {
// printf("%lld %lld %d\n", block_loader->blocks->id, block->id, block_index);
// }
if (!vector_taken) {
block_loader2_push_index(block_loader, num_processed + vec_index);
vector_taken = 1;
}
block_push(block, block_loader->global_indices_size - 1, batch_it + 1);
}
}
}
assert(batch_it == batch + current_batch_size * (block_loader->num_dimensions + 1));
num_processed += current_batch_size;
}
free(batch);
batch = NULL;
fclose(file);
return NULL;
}
|
trukanduk/pq_huffman
|
src/concurrent_queue.h
|
#ifndef _CONCURRENT_QUEUE_H
#define _CONCURRENT_QUEUE_H
#include <pthread.h>
#include <semaphore.h>
typedef struct _concurrent_queue {
pthread_mutex_t mutex;
sem_t sem;
int size;
int first_datum_index;
int next_push_index;
int capacity;
void** data;
} concurrent_queue_t;
void concurrent_queue_init(concurrent_queue_t* queue, int count);
void concurrent_queue_destroy(concurrent_queue_t* queue);
int concurrent_queue_empty(concurrent_queue_t* queue);
int concurrent_queue_empty_noblock(concurrent_queue_t* queue);
int concurrent_queue_full(concurrent_queue_t* queue);
int concurrent_queue_full_noblock(concurrent_queue_t* queue);
int concurrent_queue_size(concurrent_queue_t* queue);
int concurrent_queue_size_noblock(concurrent_queue_t* queue);
void concurrent_queue_clear(concurrent_queue_t* queue);
void concurrent_queue_clear_noblock(concurrent_queue_t* queue);
int concurrent_queue_push(concurrent_queue_t* queue, void* datum, int round_time, int num_rounds);
int concurrent_queue_try_push(concurrent_queue_t* queue, void* datum);
int concurrent_queue_try_push_noblock(concurrent_queue_t* queue, void* datum);
void* concurrent_queue_pop(concurrent_queue_t* queue);
void* concurrent_queue_try_pop(concurrent_queue_t* queue);
void* concurrent_queue_try_pop_noblock(concurrent_queue_t* queue);
void concurrent_queue_print(concurrent_queue_t* queue, const char* action);
#endif // _CONCURRENT_QUEUE_H
|
trukanduk/pq_huffman
|
src/fast_nn_block_loader.c
|
#include "fast_nn_block_loader.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <math.h>
#include "misc.h"
#define NUM_ROWS_IN_BATCH 10000
#define DATASET_ITEM_SIZE 4L
#define DATASET_DIMS_ITEM_SIZE 4L
#define NUM_ROWS_IN_BATCH 10000
#define NUM_ROWS_IN_BATCH_BATCH 500
static int make_dataset_row_size(int num_dimensions) {
return num_dimensions * DATASET_ITEM_SIZE + DATASET_DIMS_ITEM_SIZE;
}
void get_vectors_in_block(const char* input_filename, blocks_info_t* blocks_info,
long long* block_indices, float* block, long long* num_vectors_in_block,
long long max_num_vectors_in_block, int num_vectors, int num_dimensions,
long long block_id)
{
if (num_vectors_in_block) {
*num_vectors_in_block = 0LL;
}
FILE* f = fopen(input_filename, "rb");
get_vectors_in_block_batches(f, blocks_info, block_indices, block, num_vectors_in_block,
max_num_vectors_in_block, num_vectors, num_dimensions,
block_id, NUM_ROWS_IN_BATCH);
fclose(f);
}
void get_vectors_in_block_batches(FILE* f, blocks_info_t* blocks_info, long long* block_indices,
float* block, long long* num_vectors_in_block,
long long max_num_vectors_in_block, int num_vectors,
int num_dimensions, long long block_id, int rows_in_batch)
{
long long rows_processed = 0;
long long row_size = make_dataset_row_size(num_dimensions);
float* batch = malloc(row_size * rows_in_batch);
while (rows_processed < num_vectors) {
if (max_num_vectors_in_block > 0LL && (*num_vectors_in_block > max_num_vectors_in_block)) {
break;
}
long long current_batch_size = iminll(rows_in_batch, num_vectors - rows_processed);
fread(batch, row_size, current_batch_size, f);
block_loader_filter_block(NULL, blocks_info, block_indices, block, num_vectors_in_block,
max_num_vectors_in_block, num_dimensions, block_id,
rows_processed, current_batch_size, batch);
rows_processed += current_batch_size;
}
free(batch);
batch = NULL;
}
void block_loader_filter_block(pthread_mutex_t* mutex, blocks_info_t* blocks_info,
long long* block_indices, float* block,
long long* num_vectors_in_block, long long max_num_vectors_in_block,
int num_dimensions, long long block_id, long long batch_start_index,
long long rows_in_batch, float* batch_start)
{
for (int i = 0; i < rows_in_batch; ++i) {
float* vector_start = batch_start + i * (num_dimensions + 1) + 1;
int is_in_block = is_vector_in_block(vector_start, num_dimensions,
blocks_info, block_id);
if (!is_in_block) {
continue;
}
if (mutex) {
pthread_mutex_lock(mutex);
}
if (max_num_vectors_in_block > 0 && *num_vectors_in_block >= max_num_vectors_in_block) {
++(*num_vectors_in_block);
if (mutex) {
pthread_mutex_unlock(mutex);
}
return;
}
if (block) {
memcpy(block + (*num_vectors_in_block) * num_dimensions,
vector_start, num_dimensions * sizeof(*block));
}
if (block_indices) {
block_indices[*num_vectors_in_block] =
batch_start_index + i;
}
++(*num_vectors_in_block);
if (mutex) {
pthread_mutex_unlock(mutex);
}
}
}
void block_loader_init(block_loader_t* block_loader, const char* input_filename,
blocks_info_t* blocks_info, long long* block_indices, float* block,
long long* num_vectors_in_block, long long max_num_vectors_in_block,
int num_vectors, int num_dimensions, long long block_id)
{
block_loader->input_filename = input_filename;
block_loader->blocks_info = blocks_info;
block_loader->block_indices = block_indices;
block_loader->block = block;
block_loader->num_vectors_in_block = num_vectors_in_block;
block_loader->max_num_vectors_in_block = max_num_vectors_in_block;
block_loader->num_vectors = num_vectors;
block_loader->num_dimensions = num_dimensions;
block_loader->block_id = block_id;
pthread_create(&block_loader->thread, NULL, block_loader_main_thread,
(void*)block_loader);
}
void block_loader_join(block_loader_t* block_loader) {
pthread_join(block_loader->thread, NULL);
}
void* block_loader_main_thread(void* arg) {
block_loader_t* block_loader = (block_loader_t*) arg;
get_vectors_in_block(block_loader->input_filename, block_loader->blocks_info,
block_loader->block_indices, block_loader->block,
block_loader->num_vectors_in_block, block_loader->max_num_vectors_in_block,
block_loader->num_vectors, block_loader->num_dimensions,
block_loader->block_id);
}
|
trukanduk/pq_huffman
|
src/fast_nn_result_data.h
|
<filename>src/fast_nn_result_data.h
#ifndef _FAST_NN_RESUT_DATA_H_
#define _FAST_NN_RESUT_DATA_H_
typedef struct _result_data {
long long capacity;
int* indices;
float* dists;
} result_data_t;
void result_data_init(result_data_t* result_data, long long initial_capacity);
void result_data_realloc(result_data_t* result_data, long long minimal_capacity);
void result_data_destroy(result_data_t* result_data);
#endif // _FAST_NN_RESUT_DATA_H_
|
trukanduk/pq_huffman
|
src/bitstream.h
|
<filename>src/bitstream.h<gh_stars>1-10
#ifndef _BITSTREAM_H
#define _BITSTREAM_H
#include <stdio.h>
#include "misc.h"
enum {
BYTE_NUM_BITS = sizeof(byte_t) * 8
};
typedef struct _bit_stream bit_stream_t;
bit_stream_t* bit_stream_create_from_file(FILE* file);
bit_stream_t* bit_stream_create_from_file_buffered(FILE* file, long long buffer_size_bytes);
bit_stream_t* bit_stream_destroy(bit_stream_t* stream); // NOTE: Always returns NULL
bit_stream_t* bit_stream_destroy_file(bit_stream_t* stream, int close_file); // NOTE: Always returns NULL
int bit_stream_flush(bit_stream_t* stream, int add_pad);
int bit_stream_write(bit_stream_t* stream, const byte_t* data, long long bit_length);
void bit_stream_read(bit_stream_t* stream, byte_t* data, long long bit_length);
int bit_stream_read_bit(bit_stream_t* stream);
#endif // _BITSTREAM_H
|
trukanduk/pq_huffman
|
src/stats.h
|
#ifndef _HUFFMAN_STATS_H
#define _HUFFMAN_STATS_H
#include <stdio.h>
typedef struct _huffman_stats {
long long num_vectors;
int m;
int k_star;
double sum_length;
double* partial_lengths;
int num_roots;
} huffman_stats_t;
void huffman_stats_init(huffman_stats_t* stats, long long num_vectors, int m, int k_star);
void huffman_stats_destroy(huffman_stats_t* stats);
void huffman_stats_push(huffman_stats_t* stats, int part, double length);
void huffman_stats_print(const huffman_stats_t* stats);
void huffman_stats_print_filename(const huffman_stats_t* stats, const char* filename);
void huffman_stats_print_file(const huffman_stats_t* stats, FILE* file);
#endif // _HUFFMAN_STATS_H
|
trukanduk/pq_huffman
|
src/huffman_decoder.c
|
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "bitstream.h"
#include "huffman.h"
#include "misc.h"
#include "mst.h"
#include "vecs_io.h"
enum {
ACTION_DECODE = 0, // NOTE: Read input file and decode the data.
// Drop data if no output expected
ACTION_CHECK = 1, // NOTE: Fully read to memory, decode, sort result,
// then read source indices, sort them and compare
// byte-by-byte. Needed for tests
DEFAULT_BATCH_SIZE = 1000 * 1000 // NOTE: 1M vectors
};
typedef struct _config {
const char* input_huffman_template;
const char* output_filename; // NOTE: NULL if no output required
const char* pq_indices_filename; // NOTE: Nullable - has sense only
// for action=ACTION_CHECK
int action;
int m;
long long num_vectors;
int tree;
char* input_huffman_indices_filename;
char* input_huffman_codebooks_filename;
char* input_huffman_children_filename;
char* input_huffman_children_codebook_filename;
} config_t;
static void print_help(const char* argv0) {
fprintf(stderr, "Usage: %s <huffman output template> [--output-file <output file>]"
" [--check-file <pq indices file>] [--tree]\n", argv0);
exit(1);
}
static int load_m_from_codebooks_file(const char* input_huffman_codebooks_filename) {
FILE* f = fopen(input_huffman_codebooks_filename, "rb");
unsigned int m = 0;
fread(&m, sizeof(m), 1, f);
fclose(f);
return m;
}
static void parse_args(config_t* config, int argc, const char* argv[]) {
if (argc < 2) {
fprintf(stderr, "Too few arguments\n");
print_help(argv[0]);
}
config->input_huffman_template = argv[1];
config->num_vectors = 0;
config->action = ACTION_DECODE;
config->output_filename = NULL;
config->pq_indices_filename = NULL;
config->tree = 0;
config->input_huffman_indices_filename = NULL;
config->input_huffman_codebooks_filename = NULL;
config->input_huffman_children_filename = NULL;
config->input_huffman_children_codebook_filename = NULL;
int show_help = 0;
for (const char** arg = argv + 2; *arg; ++arg) {
if (!strcmp(*arg, "--output-file")) {
++arg;
config->output_filename = *arg;
} else if (!strcmp(*arg, "--check-file")) {
++arg;
config->action = ACTION_CHECK;
config->pq_indices_filename = *arg;
} else if (!strcmp(*arg, "--tree")) {
config->tree = 1;
} else {
fprintf(stderr, "Unknown arg: %s\n", *arg);
show_help = 1;
}
}
if (show_help) {
print_help(argv[0]);
}
config->input_huffman_indices_filename = concat(config->input_huffman_template, "huffman_indices.bin");
config->input_huffman_codebooks_filename = concat(config->input_huffman_template, "huffman_codebooks.bin");
config->input_huffman_children_filename = concat(config->input_huffman_template, "huffman_children.bin");
config->input_huffman_children_codebook_filename = concat(config->input_huffman_template, "huffman_children_codebooks.bin");
config->num_vectors = load_vecs_num_vectors_filename(config->input_huffman_indices_filename);
config->m = load_m_from_codebooks_file(config->input_huffman_codebooks_filename);
}
static void config_free(config_t* config) {
if (config->input_huffman_indices_filename) {
free(config->input_huffman_indices_filename);
config->input_huffman_indices_filename = NULL;
}
if (config->input_huffman_codebooks_filename) {
free(config->input_huffman_codebooks_filename);
config->input_huffman_codebooks_filename = NULL;
}
if (config->input_huffman_children_filename) {
free(config->input_huffman_children_filename);
config->input_huffman_children_filename = NULL;
}
if (config->input_huffman_children_codebook_filename) {
free(config->input_huffman_children_codebook_filename);
config->input_huffman_children_codebook_filename = NULL;
}
}
typedef struct _codebooks_array {
huffman_codebook_t* codebooks;
huffman_decoder_t** decoders;
int m;
} codebooks_array_t;
static void codebooks_array_init(codebooks_array_t* codebooks_array, const config_t* config) {
codebooks_array->m = config->m;
codebooks_array->codebooks = malloc(sizeof(*codebooks_array->codebooks) * codebooks_array->m);
codebooks_array->decoders = malloc(sizeof(*codebooks_array->decoders) * codebooks_array->m);
FILE* codebooks_file = fopen(config->input_huffman_codebooks_filename, "rb");
fseek(codebooks_file, sizeof(int), SEEK_CUR); // NOTE: Skip m
for (int part_index = 0; part_index < codebooks_array->m; ++part_index) {
huffman_codebook_load(codebooks_array->codebooks + part_index, codebooks_file);
codebooks_array->decoders[part_index] =
huffman_decoder_create(codebooks_array->codebooks + part_index);
}
fclose(codebooks_file);
}
static void codebooks_array_destroy(codebooks_array_t* codebooks_array) {
for (int part_index = 0; part_index < codebooks_array->m; ++part_index) {
codebooks_array->decoders[part_index] =
huffman_decoder_destroy(codebooks_array->decoders[part_index]);
huffman_codebook_destroy(codebooks_array->codebooks + part_index);
}
free(codebooks_array->decoders);
codebooks_array->decoders = NULL;
free(codebooks_array->codebooks);
codebooks_array->codebooks = NULL;
codebooks_array->m = 0;
}
static long long minll(long long left, long long right) {
return (left < right ? left : right);
}
static int sort_indices_comparator_m;
static int sort_indices_comparator(const void* left, const void* right) {
return strncmp(left, right, sort_indices_comparator_m);
}
static void run(const config_t* config) {
codebooks_array_t codebooks_array;
codebooks_array_init(&codebooks_array, config);
huffman_codebook_t children_codebook;
huffman_decoder_t* children_decoder = NULL;
FILE* children_file = NULL;
bit_stream_t* children_stream = NULL;
tree_traverser_t traverser;
if (config->tree) {
FILE* codebook_file = fopen(config->input_huffman_children_codebook_filename, "rb");
huffman_codebook_load(&children_codebook, codebook_file);
fclose(codebook_file);
children_decoder = huffman_decoder_create(&children_codebook);
children_file = fopen(config->input_huffman_children_filename, "rb");
children_stream = bit_stream_create_from_file(children_file);
tree_traverser_init(&traverser, config->num_vectors);
} else {
tree_traverser_init(&traverser, 10); // NOTE: need exactly one item but lets allocate 10
}
printf("Codebooks loaded\n");
FILE* output_file = NULL;
if (config->output_filename) {
output_file = fopen(config->output_filename, "wb");
}
long long batch_size = DEFAULT_BATCH_SIZE;
if (config->action == ACTION_CHECK || config->tree) {
batch_size = config->num_vectors; // NOTE: Need to store all in memory :(
}
byte_t* decoded_batch = calloc(sizeof(byte_t) * config->m, batch_size);
FILE* encoded_file = fopen(config->input_huffman_indices_filename, "rb");
fseek(encoded_file, sizeof(long long), SEEK_CUR); // NOTE: Skip num vectors
bit_stream_t* encoded_stream = bit_stream_create_from_file(encoded_file);
long long got_vectors = 0;
while (got_vectors < config->num_vectors) {
// NOTE: Fill single batch on iteration.
long long current_batch_size = minll(config->num_vectors - got_vectors, batch_size);
byte_t* batch_it = decoded_batch;
for (long long vec_index = 0; vec_index < current_batch_size; ++vec_index) {
vector_id_t prev_vector_id = -1;
const byte_t* prev_vector = NULL;
if (config->tree) {
prev_vector_id = tree_traverser_get_active_parent(&traverser);
if (prev_vector_id != TRAVERSER_NO_PARENT_VECTOR) {
prev_vector = decoded_batch + config->m * prev_vector_id;
}
}
for (int part_index = 0; part_index < config->m; ++part_index, ++batch_it) {
if (config->tree) {
if (prev_vector) {
huffman_decoder_set_prev_symbol(codebooks_array.decoders[part_index],
prev_vector[part_index]);
} else {
huffman_decoder_set_prev_symbol(codebooks_array.decoders[part_index],
HUFFMAN_NO_SYMBOL);
}
}
int symbol = huffman_decoder_read_symbol(codebooks_array.decoders[part_index],
encoded_stream);
assert(symbol != HUFFMAN_INVALID_SYMBOL);
*batch_it = symbol;
}
int num_children = config->tree
? huffman_decoder_read_symbol(children_decoder, children_stream)
: 1;
tree_traverser_push_vertex(&traverser, got_vectors + vec_index, num_children);
}
assert(batch_it == decoded_batch + config->m * current_batch_size);
if (output_file) {
fwrite(decoded_batch, sizeof(*decoded_batch) * config->m, current_batch_size,
output_file);
}
got_vectors += current_batch_size;
}
printf("Decoded\n");
if (config->action == ACTION_CHECK) {
assert(config->pq_indices_filename != NULL);
long long indices_size = config->m * config->num_vectors;
byte_t* orig_indices = malloc(sizeof(*orig_indices) * indices_size);
FILE* indices_file = fopen(config->pq_indices_filename, "rb");
fread(orig_indices, sizeof(byte_t), config->num_vectors * config->m, indices_file);
fclose(indices_file);
sort_indices_comparator_m = config->m;
qsort(orig_indices, config->num_vectors, config->m * sizeof(byte_t),
sort_indices_comparator);
printf("Orig sorted\n");
qsort(decoded_batch, config->num_vectors, config->m * sizeof(byte_t),
sort_indices_comparator);
printf("Decoded sorted\n");
assert(!strncmp(orig_indices, decoded_batch, sizeof(byte_t) * indices_size));
printf("Check OK!\n");
free(orig_indices);
orig_indices = NULL;
}
encoded_stream = bit_stream_destroy(encoded_stream);
fclose(encoded_file);
encoded_file = NULL;
free(decoded_batch);
decoded_batch = NULL;
if (output_file) {
fclose(output_file);
output_file = NULL;
}
tree_traverser_destroy(&traverser);
if (config->tree) {
bit_stream_destroy(children_stream);
fclose(children_file);
huffman_decoder_destroy(children_decoder);
huffman_codebook_destroy(&children_codebook);
}
codebooks_array_destroy(&codebooks_array);
}
int main(int argc, const char* argv[]) {
config_t config;
parse_args(&config, argc, argv);
run(&config);
config_free(&config);
return 0;
}
|
trukanduk/pq_huffman
|
src/compute_nn_fast.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include <assert.h>
#include <pthread.h>
#include <semaphore.h>
#include <yael/nn.h>
#include "concurrent_queue.h"
#include "misc.h"
#include "fast_nn_temp_file.h"
#include "fast_nn_block.h"
#include "fast_nn_blocks_info.h"
#include "fast_nn_block_loader.h"
#include "fast_nn_block_loader2.h"
#include "fast_nn_result_data.h"
#define DATASET_ITEM_SIZE 4L
#define DATASET_DIMS_ITEM_SIZE 4L
#define NUM_ROWS_IN_BATCH 10000
#define NUM_ROWS_IN_BATCH_BATCH 500
static int make_dataset_row_size(int num_dimensions) {
return num_dimensions * DATASET_ITEM_SIZE + DATASET_DIMS_ITEM_SIZE;
}
// Input data
void partial_load_vectors(const char* input_filename, int num_dimensions, int num_vectors_to_load,
const int* vectors_indices_to_load, float* output_vectors);
void load_vectors_dim(const char* input_filename, long long num_vectors, int num_dimensions,
int dimension_to_load, float* output);
void load_vectors_dim_batches(FILE* input_file, long long num_vectors, int num_dimensions,
int dimension_to_load, float* output, int rows_in_batch);
void partial_load_vectors(const char* input_filename, int num_dimensions, int num_vectors_to_load,
const int* vectors_indices_to_load, float* output_vectors)
{
FILE* f = fopen(input_filename, "rb");
int row_size = make_dataset_row_size(num_dimensions);
for (
int i = 0;
i < num_vectors_to_load;
++i, ++vectors_indices_to_load, output_vectors += num_dimensions)
{
int vector_index = *vectors_indices_to_load;
fseek(f, row_size * vector_index + DATASET_DIMS_ITEM_SIZE, SEEK_SET);
fread((void*) output_vectors, num_dimensions, DATASET_ITEM_SIZE, f);
}
fclose(f);
}
void load_vectors_dim(const char* input_filename, long long num_vectors, int num_dimensions,
int dimension_to_load, float* output)
{
FILE* f = fopen(input_filename, "rb");
load_vectors_dim_batches(f, num_vectors, num_dimensions, dimension_to_load, output,
NUM_ROWS_IN_BATCH);
fclose(f);
}
void load_vectors_dim_batches(FILE* input_file, long long num_vectors, int num_dimensions,
int dimension_to_load, float* output, int rows_in_batch)
{
int row_size = make_dataset_row_size(num_dimensions);
fseek(input_file, DATASET_ITEM_SIZE * dimension_to_load + DATASET_DIMS_ITEM_SIZE, SEEK_SET);
for (int i = 0; i < num_vectors; ++i) {
fread((void*) output++, 1, sizeof(*output), input_file);
fseek(input_file, row_size - DATASET_ITEM_SIZE, SEEK_CUR);
}
}
// Parse args
typedef struct _config {
// NOTE: Required args
const char* input_filename;
const char* output_files_template;
int num_nn;
// NOTE: Optional args
const char* temp_file;
const char* blocks_info_cache;
int delete_temp_file;
int init_temp_file;
int num_dims_to_split;
double block_overlap_fraction;
int num_blocks_per_dim;
int num_threads;
int with_blocks_stat;
long long end_block_id;
long long begin_block_id;
long long num_dimensions_on_pass;
// NOTE: computed args
const char* output_indices_filename;
const char* output_dists_filename;
FILE* blocks_stat_file;
// NOTE: dataset info
int num_vectors;
int num_dimensions;
} config_t;
typedef struct _dataset_metainfo {
long long num_vectors;
int num_dimensions;
} dataset_metainfo_t;
void print_help(const char* argv0);
dataset_metainfo_t get_metainfo(const char* input_filename);
config_t parse_args(int argc, const char* argv[]);
void config_free(config_t* config);
void print_help(const char* argv0) {
fprintf(stderr, "Usage: %s <input dataset path> <output files template> <num_nn> [optional args]\n", argv0);
fprintf(stderr, "Optionl args:\n");
fprintf(stderr, " --temp-file <file> temp file path (default is nn_temp.vecs)\n");
fprintf(stderr, " --delete-temp-file, --no-delete-temp-file delete temp file when done (default is true)\n");
fprintf(stderr, " --init-temp-file, --no-init-temp-file clear old results of temp file (default is true)\n");
fprintf(stderr, " --num-dims <value> num dimensions to process (default is 5)\n");
fprintf(stderr, " --num-blocks-per-dim <value> num blocks for each dimension (default is 2)\n");
fprintf(stderr, " --block-overlap-fraction <value> fraction of dimension foroverlap (default is 0.3)\n");
fprintf(stderr, " --blocks-info-cache <value> blocks info cache file (default is none)\n");
fprintf(stderr, " --num-dimensions-at-pass <value> num dimensions to process on pass(default is 0)\n");
fprintf(stderr, " --blocks-from <value> --blocks-to <value> start from/end on given block ids (default is all)\n");
}
dataset_metainfo_t get_metainfo(const char* input_filename) {
FILE* f = fopen(input_filename, "rb");
dataset_metainfo_t metainfo;
metainfo.num_dimensions = 0;
fread(&metainfo.num_dimensions, DATASET_DIMS_ITEM_SIZE, 1, f);
fseek(f, 0, SEEK_END);
long long filesize = ftell(f);
fclose(f);
long long row_size = make_dataset_row_size(metainfo.num_dimensions);
metainfo.num_vectors = filesize / row_size;
printf("num vectors %lld * row_size %lld (num_dim %d) == filesize %lld\n", metainfo.num_vectors,
row_size, metainfo.num_dimensions, filesize);
assert(metainfo.num_vectors * row_size == filesize);
return metainfo;
}
config_t parse_args(int argc, const char* argv[]) {
const char* argv0 = argv[0];
if (argc < 3) {
fprintf(stderr, "Too few required args\n");
print_help(argv0);
exit(1);
}
int arg_index = 1;
config_t config;
config.input_filename = argv[arg_index++];
config.output_files_template = argv[arg_index++];
config.num_nn = atoi(argv[arg_index++]);
config.temp_file = "nn_temp.vecs";
config.blocks_info_cache = NULL;
config.delete_temp_file = 1;
config.init_temp_file = 1;
config.num_dims_to_split = 5;
config.block_overlap_fraction = 0.3;
config.num_blocks_per_dim = 3;
config.num_threads = 1;
config.with_blocks_stat = 0;
config.begin_block_id = 0;
config.end_block_id = -1;
config.num_dimensions_on_pass = 0;
config.output_indices_filename = NULL;
config.output_dists_filename = NULL;
config.blocks_stat_file = NULL;
config.num_vectors = 0;
config.num_dimensions = 0;
int ok = 1;
while (arg_index < argc) {
if (!strcmp(argv[arg_index], "--with-blocks-stat")) {
config.with_blocks_stat = 1;
} else if (!strcmp(argv[arg_index], "--no-delete-temp-file")) {
config.delete_temp_file = 0;
} else if (!strcmp(argv[arg_index], "--delete-temp-file")) {
config.delete_temp_file = 1;
} else if (!strcmp(argv[arg_index], "--no-init-temp-file")) {
config.init_temp_file = 0;
} else if (!strcmp(argv[arg_index], "--init-temp-file")) {
config.init_temp_file = 1;
} else if (!strcmp(argv[arg_index], "--temp-file")) {
config.temp_file = argv[++arg_index];
} else if (!strcmp(argv[arg_index], "--blocks-info-cache")) {
config.blocks_info_cache = argv[++arg_index];
} else if (!strcmp(argv[arg_index], "--num-dims")) {
config.num_dims_to_split = atoi(argv[++arg_index]);
} else if (!strcmp(argv[arg_index], "--block-overlap-fraction")) {
config.block_overlap_fraction = atof(argv[++arg_index]);
} else if (!strcmp(argv[arg_index], "--num-blocks-per-dim")) {
config.num_blocks_per_dim = atoi(argv[++arg_index]);
} else if (!strcmp(argv[arg_index], "--num-threads")) {
config.num_threads = atoi(argv[++arg_index]);
} else if (!strcmp(argv[arg_index], "--blocks-from")) {
config.begin_block_id = atoll(argv[++arg_index]);
} else if (!strcmp(argv[arg_index], "--blocks-to")) {
config.end_block_id = atoll(argv[++arg_index]) - 1;
} else if (!strcmp(argv[arg_index], "--num-dimensions-at-pass")) {
config.num_dimensions_on_pass = atoll(argv[++arg_index]);
} else {
fprintf(stderr, "Unknown arg %s\n", argv[arg_index]);
ok = 0;
}
++arg_index;
}
if (!ok) {
exit(1);
}
config.output_indices_filename = concat(config.output_files_template, "nn_indices.ivecsl");
config.output_dists_filename = concat(config.output_files_template, "nn_dist.fvecsl");
if (config.with_blocks_stat) {
char* blocks_stat_filename = concat(config.output_files_template, "blocks_stat.txt");
config.blocks_stat_file = fopen(blocks_stat_filename, "w");
free(blocks_stat_filename);
}
dataset_metainfo_t metainfo = get_metainfo(config.input_filename);
config.num_vectors = metainfo.num_vectors;
config.num_dimensions = metainfo.num_dimensions;
return config;
}
void config_free(config_t* config) {
if (config->output_indices_filename) {
free((void*) config->output_indices_filename);
config->output_indices_filename = NULL;
}
if (config->output_dists_filename) {
free((void*) config->output_dists_filename);
config->output_dists_filename = NULL;
}
if (config->blocks_stat_file) {
fclose(config->blocks_stat_file);
config->blocks_stat_file = NULL;
}
}
int main(int argc, const char* argv[]);
void test_block_loaders(config_t* config, blocks_info_t* blocks_info);
void test_block_loaders(config_t* config, blocks_info_t* blocks_info) {
#define NUM_BLOCKS_PER_STEP 5
for (
long long block_id = 0;
block_id < blocks_info->num_blocks_total;
block_id += NUM_BLOCKS_PER_STEP)
{
long long num_blocks_this_step = \
(block_id + NUM_BLOCKS_PER_STEP < blocks_info->num_blocks_total
? NUM_BLOCKS_PER_STEP
: blocks_info->num_blocks_total - block_id);
long long num_vectors_in_block[NUM_BLOCKS_PER_STEP];
block_loader_t block_loaders[NUM_BLOCKS_PER_STEP];
fprintf(stderr, "Starting blocks %lld - %lld of %lld\n", block_id,
block_id + NUM_BLOCKS_PER_STEP - 1, blocks_info->num_blocks_total);
for (int i = 0; i < num_blocks_this_step; ++i) {
num_vectors_in_block[i] = 0LL;
block_loader_init(&block_loaders[i], config->input_filename, blocks_info, NULL, NULL,
&num_vectors_in_block[i], 0LL, config->num_vectors,
config->num_dimensions, block_id + i);
}
for (int i = 0; i < num_blocks_this_step; ++i) {
block_loader_join(&block_loaders[i]);
}
}
#undef NUM_BLOCKS_PER_STEP
}
static void init_block(long long capacity, int num_dimensions, float** block,
long long** block_indices)
{
if (*block) {
free(*block);
*block = NULL;
}
if (*block_indices) {
free(*block_indices);
*block_indices = NULL;
}
long long block_row_size = sizeof(**block) * num_dimensions;
*block = malloc(block_row_size * capacity);
*block_indices = malloc(sizeof(**block_indices) * capacity);
}
float get_real_dist(float* a, float* b, int nd) {
float result = 0.0;
for (int i = 0; i < nd; ++i) {
float tmp = a[i] - b[i];
result += tmp*tmp;
}
return result;
}
#if 0
void run(config_t* config, blocks_info_t* blocks_info) {
#define NUM_BUFFERS 3
block_loader_t block_loaders[NUM_BUFFERS];
long long block_capacities[NUM_BUFFERS];
long long* block_indices[NUM_BUFFERS];
long long block_sizes[NUM_BUFFERS];
float* blocks[NUM_BUFFERS];
temp_file_loader_t temp_file_loaders[NUM_BUFFERS];
for (int i = 0; i < NUM_BUFFERS; ++i) {
block_capacities[i] = (5LL * config->num_vectors + blocks_info->num_blocks_total - 1)
/ blocks_info->num_blocks_total;
block_indices[i] = NULL;
blocks[i] = NULL;
block_sizes[i] = 0LL;
init_block(block_capacities[i], config->num_dimensions, &blocks[i],
&block_indices[i]);
temp_file_loader_init(&temp_file_loaders[i], config->temp_file, config->num_nn,
block_capacities[i]);
}
block_loader_init(&block_loaders[0], config->input_filename, blocks_info,
block_indices[0], blocks[0], &block_sizes[0],
block_capacities[0], config->num_vectors,
config->num_dimensions, 0LL);
long long result_capacity = block_capacities[0];
long long result_indices_row_size = sizeof(int) * (config->num_nn + 1);
long long result_dists_row_size = sizeof(float) * (config->num_nn + 1);
int* result_indices = malloc(result_indices_row_size * result_capacity);
float* result_dists = malloc(result_dists_row_size * result_capacity);
long long begin_block_id = config->begin_block_id;
if (begin_block_id > blocks_info->num_blocks_total) {
begin_block_id = blocks_info->num_blocks_total;
}
long long end_block_id = config->end_block_id;
if (end_block_id < 0 || end_block_id > blocks_info->num_blocks_total) {
end_block_id = blocks_info->num_blocks_total;
} else if (end_block_id > config->begin_block_id) {
end_block_id = config->begin_block_id;
}
for (long long block_id = begin_block_id; block_id < end_block_id; ++block_id) {
if (block_id % 100 == 0) {
printf("Start block %6lld / %6lld (%6lld / %6lld)\n",
block_id - begin_block_id, end_block_id - begin_block_id,
block_id, blocks_info->num_blocks_total);
}
int active_buffer = block_id % NUM_BUFFERS;
int next_buffer = (active_buffer + 1) % NUM_BUFFERS;
int prev_buffer = (active_buffer - 1 + NUM_BUFFERS) % NUM_BUFFERS;
// printf("Starting block %lld\n", block_id);
if (block_id + 1 != blocks_info->num_blocks_total) {
temp_file_loader_save_join(&temp_file_loaders[next_buffer]);
block_loader_init(&block_loaders[next_buffer], config->input_filename, blocks_info,
block_indices[next_buffer], blocks[next_buffer],
&block_sizes[next_buffer], block_capacities[next_buffer],
config->num_vectors, config->num_dimensions, block_id + 1);
}
block_loader_join(&block_loaders[active_buffer]);
// TODO: always return real size of block
while (block_sizes[active_buffer] > block_capacities[active_buffer]) {
fprintf(stderr, "No enough block size. Capacity is %lld\n",
block_capacities[active_buffer]);
block_capacities[active_buffer] *= 2;
init_block(block_capacities[active_buffer], config->num_dimensions,
&blocks[active_buffer], &block_indices[active_buffer]);
block_loader_init(&block_loaders[active_buffer], config->input_filename, blocks_info,
block_indices[active_buffer], blocks[active_buffer],
&block_sizes[active_buffer], block_capacities[active_buffer],
config->num_vectors, config->num_dimensions, block_id);
block_loader_join(&block_loaders[active_buffer]);
}
temp_file_loader_load(&temp_file_loaders[active_buffer], block_sizes[active_buffer],
block_indices[active_buffer]);
if (block_sizes[active_buffer] > result_capacity) {
free(result_indices);
result_indices = NULL;
free(result_dists);
result_dists = NULL;
result_capacity = block_sizes[active_buffer];
result_indices = malloc(result_indices_row_size * result_capacity);
result_dists = malloc(result_dists_row_size * result_capacity);
}
int block_size = block_sizes[active_buffer];
if (config->blocks_stat_file) {
fprintf(config->blocks_stat_file, "%d ", block_size);
}
// printf("Starting knn for block %lld of size %d\n", block_id, block_size);
int num_nn_real = iminll(config->num_nn, block_size - 1);
knn_full_thread(2, block_size, block_size, config->num_dimensions,
num_nn_real + 1, blocks[active_buffer],
blocks[active_buffer], NULL, result_indices, result_dists,
config->num_threads);
// printf("Done knn for block %lld\n", block_id);
temp_file_loader_load_join(&temp_file_loaders[active_buffer]);
// printf("Starting merge for block %lld\n", block_id);
long long temp_file_row_size = make_temp_file_row_size(config->num_nn);
nn_item_t temp_item;
for (long long vec_index = 0; vec_index < block_size; ++vec_index) {
nn_item_t* heap = temp_file_loaders[active_buffer].vectors
+ config->num_nn * vec_index;
int* vec_indices = result_indices + (num_nn_real + 1) * vec_index;
float* vec_dists = result_dists + (num_nn_real + 1) * vec_index;
for (int nn_index = 1; nn_index <= num_nn_real; ++nn_index) {
temp_item.index = block_indices[active_buffer][vec_indices[nn_index]];
temp_item.dist = vec_dists[nn_index];
// float real_dist = get_real_dist(
// blocks[active_buffer] + vec_index * config->num_dimensions,
// blocks[active_buffer] + vec_indices[nn_index] * config->num_dimensions,
// config->num_dimensions);
fast_nn_heap_push(heap, &temp_item, config->num_nn);
}
}
// printf("Done merge for block %lld\n", block_id);
temp_file_loader_save(&temp_file_loaders[active_buffer]);
temp_file_loader_save_join(&temp_file_loaders[active_buffer]);
}
free(result_indices);
result_indices = NULL;
free(result_dists);
result_dists = NULL;
for (int i = 0; i < NUM_BUFFERS; ++i) {
temp_file_loader_save_join(&temp_file_loaders[i]);
temp_file_loader_destroy(&temp_file_loaders[i]);
free(blocks[i]);
blocks[i] = NULL;
free(block_indices[i]);
block_indices[i] = NULL;
}
#undef NUM_BUFFERS
}
#else
static void run_block(const config_t* config, const blocks_info_t* blocks_info,
const block_t* block, result_data_t* result_data) {
result_data_realloc(result_data, block->size * (config->num_nn + 1));
if (config->blocks_stat_file) {
fprintf(config->blocks_stat_file, "%d ", block->size);
}
// printf("Starting knn for block %lld of size %d\n", block_id, block->size);
int num_nn_real = iminll(config->num_nn, block->size - 1);
knn_full_thread(2, block->size, block->size, config->num_dimensions,
num_nn_real + 1, block->data, block->data, NULL,
result_data->indices, result_data->dists, config->num_threads);
// printf("Done knn for block %lld\n", block->id);
}
static void run_merge_block(const config_t* config, const result_data_t* result_data,
const block_loader2_t* block_loader, const block_t* block,
temp_file_loader_t* temp_file_loader) {
// printf("Starting merge for block %lld\n", block_id);
nn_item_t temp_item;
int num_nn_real = iminll(config->num_nn, block->size - 1);
for (long long vec_index = 0; vec_index < block->size; ++vec_index) {
long long vec_temp_index = block->indices[vec_index];
nn_item_t* heap = temp_file_loader->vectors + config->num_nn * vec_temp_index;
int* vec_indices = result_data->indices + (num_nn_real + 1) * vec_index;
float* vec_dists = result_data->dists + (num_nn_real + 1) * vec_index;
for (int nn_index = 1; nn_index <= num_nn_real; ++nn_index) {
long long block_index = vec_indices[nn_index];
long long temp_index = block->indices[block_index];
long long global_index = block_loader->global_indices[temp_index];
temp_item.index = global_index;
temp_item.dist = vec_dists[nn_index];
fast_nn_heap_push(heap, &temp_item, config->num_nn);
}
}
}
static void run(const config_t* config, const blocks_info_t* blocks_info) {
#define NUM_BUFFERS 3
block_t* blocks;
block_loader2_t block_loaders[NUM_BUFFERS];
temp_file_loader_t temp_file_loaders[NUM_BUFFERS];
long long num_blocks_on_pass = 1;
for (int i = 0; i < config->num_dimensions_on_pass; ++i) {
num_blocks_on_pass *= config->num_blocks_per_dim;
}
blocks = malloc(sizeof(*blocks) * num_blocks_on_pass * NUM_BUFFERS);
long long block_initial_capacity =
(5LL * config->num_vectors + blocks_info->num_blocks_total - 1)
/ blocks_info->num_blocks_total;
for (int i = 0; i < num_blocks_on_pass * NUM_BUFFERS; ++i) {
block_init(blocks + i, 0, config->num_dimensions, block_initial_capacity, BLOCK_INIT_ALL);
}
for (int i = 0; i < NUM_BUFFERS; ++i) {
block_loader2_init_from_blocks(block_loaders + i, config->input_filename,
config->num_vectors, config->num_dimensions, blocks_info,
blocks + i * num_blocks_on_pass, num_blocks_on_pass);
block_loader2_set_common_prefix(
block_loaders + i, blocks_info->num_dimensions - config->num_dimensions_on_pass);
temp_file_loader_init(&temp_file_loaders[i], config->temp_file, config->num_nn,
block_initial_capacity);
}
result_data_t* result_data = malloc(sizeof(*result_data) * num_blocks_on_pass);
for (int i = 0; i < num_blocks_on_pass; ++i) {
result_data_init(result_data + i, block_initial_capacity * config->num_nn);
}
long long begin_block_id = config->begin_block_id;
if (begin_block_id > blocks_info->num_blocks_total) {
begin_block_id = blocks_info->num_blocks_total;
}
long long end_block_id = config->end_block_id;
if (end_block_id < 0 || end_block_id > blocks_info->num_blocks_total) {
end_block_id = blocks_info->num_blocks_total;
} else if (end_block_id > config->begin_block_id) {
end_block_id = config->begin_block_id;
}
block_loader2_set_start_block_id(block_loaders, begin_block_id);
block_loader2_start(block_loaders);
for (long long block_id = begin_block_id;
block_id < end_block_id;
block_id += num_blocks_on_pass)
{
if (block_id % 10 == 0) {
printf("Start block %6lld / %6lld (%6lld / %6lld)\n",
block_id - begin_block_id, end_block_id - begin_block_id,
block_id, blocks_info->num_blocks_total);
}
int active_buffer = block_id % NUM_BUFFERS;
int next_buffer = (active_buffer + 1) % NUM_BUFFERS;
int prev_buffer = (active_buffer - 1 + NUM_BUFFERS) % NUM_BUFFERS;
// printf("Starting block %lld\n", block_id);
if (block_id + num_blocks_on_pass < end_block_id) {
block_loader2_join(block_loaders + next_buffer);
block_loader2_set_start_block_id(block_loaders + next_buffer,
block_id + num_blocks_on_pass);
block_loader2_start(block_loaders + next_buffer);
}
block_loader2_join(block_loaders + active_buffer);
temp_file_loader_save_join(temp_file_loaders + prev_buffer);
temp_file_loader_load(temp_file_loaders + active_buffer,
block_loaders[active_buffer].global_indices_size,
block_loaders[active_buffer].global_indices);
for (int block_index = 0;
block_index < num_blocks_on_pass && block_id + block_index < end_block_id;
++block_index)
{
block_t* block = block_loaders[active_buffer].blocks + block_index;
run_block(config, blocks_info, block, result_data + block_index);
}
// printf("Done knn for block %lld\n", block_id);
temp_file_loader_load_join(&temp_file_loaders[active_buffer]);
for (int block_index = 0;
block_index < num_blocks_on_pass && block_id + block_index < end_block_id;
++block_index)
{
block_t* block = block_loaders[active_buffer].blocks + block_index;
run_merge_block(config, result_data + block_index, block_loaders + active_buffer,
block, &temp_file_loaders[active_buffer]);
}
// printf("Done merge for block %lld\n", block_id);
////////////////////////////////////////////////////////////////////////
temp_file_loader_save(&temp_file_loaders[active_buffer]);
// temp_file_loader_save_join(&temp_file_loaders[active_buffer]);
}
for (int i = 0; i < NUM_BUFFERS; ++i) {
temp_file_loader_save_join(&temp_file_loaders[i]);
temp_file_loader_destroy(&temp_file_loaders[i]);
// TODO: cleanup
}
#undef NUM_BUFFERS
}
#endif
int main(int argc, const char* argv[]) {
setvbuf(stdout, NULL, _IONBF, 0);
config_t config = parse_args(argc, argv);
if (config.init_temp_file) {
init_temp_file(config.temp_file, config.num_vectors, config.num_nn);
printf("Temp file: Done\n");
}
blocks_info_t blocks_info;
if (!config.blocks_info_cache
|| !blocks_info_load_filename(&blocks_info, config.blocks_info_cache))
{
blocks_info_init(&blocks_info, config.input_filename, config.num_vectors,
config.num_dimensions, config.num_dims_to_split, config.num_blocks_per_dim,
config.block_overlap_fraction);
if (config.blocks_info_cache) {
blocks_info_save_filename(&blocks_info, config.blocks_info_cache);
}
printf("Blocks info: Done\n");
} else {
printf("Blocks info: Loaded\n");
}
run(&config, &blocks_info);
// test_block_loaders(&config, &blocks_info);
temp_file_to_result(config.temp_file, config.output_indices_filename,
config.output_dists_filename, config.num_vectors, config.num_nn);
if (config.delete_temp_file) {
remove(config.temp_file);
}
config_free(&config);
return 0;
}
|
trukanduk/pq_huffman
|
src/fast_nn_temp_file.c
|
#include "fast_nn_temp_file.h"
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include "vecs_io.h"
// Max heap
int fast_nn_heap_search_indices_collisions(nn_item_t* begin, nn_item_t* end,
const nn_item_t* item)
{
for (nn_item_t* i = begin; i != end; ++i) {
if (i->index == item->index) {
return 1;
}
}
return 0;
}
static void fast_nn_heap_push_impl(nn_item_t* heap, const nn_item_t* item, int num_nn) {
int item_index = 0;
while (1) {
int left_child_index = 2 * (item_index + 1) - 1;
int right_child_index = 2 * (item_index + 1);
int index_to_swap = item_index;
if (right_child_index < num_nn
&& heap[right_child_index].dist > heap[left_child_index].dist
&& heap[right_child_index].dist > item->dist)
{
index_to_swap = right_child_index;
} else if (left_child_index < num_nn && heap[left_child_index].dist > item->dist) {
index_to_swap = left_child_index;
} else {
break;
}
heap[item_index] = heap[index_to_swap];
item_index = index_to_swap;
}
heap[item_index] = *item;
}
void fast_nn_heap_push(nn_item_t* heap, const nn_item_t* item, int num_nn) {
if (item->dist >= heap[0].dist || fast_nn_heap_search_indices_collisions(heap, heap + num_nn, item)) {
return; // Drop this new item
}
fast_nn_heap_push_impl(heap, item, num_nn);
}
void fast_nn_heap_sort(nn_item_t* heap, int num_nn, vector_id_t* indices, float* dists) {
while (--num_nn >= 0) {
indices[num_nn] = heap[0].index;
dists[num_nn] = heap[0].dist;
fast_nn_heap_push_impl(heap, &heap[num_nn], num_nn);
}
}
// Temp file
enum {
DEFAULT_BATCH_SIZE = 10000
};
static void* temp_file_loader_load_thread(void* arg) {
temp_file_loader_t* loader = (temp_file_loader_t*)arg;
partial_load_temp_file(loader->temp_file_name, loader->num_nn, loader->num_vectors_to_load,
loader->vectors_indices, loader->vectors);
}
static void* temp_file_loader_save_thread(void* arg) {
temp_file_loader_t* loader = (temp_file_loader_t*)arg;
partial_save_temp_file(loader->temp_file_name, loader->num_nn, loader->num_vectors_to_load,
loader->vectors_indices, loader->vectors);
}
void init_temp_file(const char* temp_file_name, long long num_vectors, int num_nn) {
FILE* f = fopen(temp_file_name, "wb");
init_temp_file_batches(f, num_vectors, num_nn, DEFAULT_BATCH_SIZE);
fclose(f);
}
int make_temp_file_row_size(int num_nn) {
return num_nn * sizeof(nn_item_t);
}
void init_empty_batch_for_temp_file(nn_item_t* batch, int num_nn, long long rows_in_batch) {
int row_size = make_temp_file_row_size(num_nn);
// NOTE: init first row directly
for (int i = 0; i < num_nn; ++i) {
batch[i].index = UINT_MAX;
batch[i].dist = INFINITY;
}
// NOTE: copy prefix of batch
int batch_filled_rows = 1;
while (batch_filled_rows < rows_in_batch) {
int rows_to_copy = iminll(batch_filled_rows, rows_in_batch - batch_filled_rows);
memcpy(batch + num_nn * batch_filled_rows, batch, row_size * rows_to_copy);
batch_filled_rows += rows_to_copy;
}
}
void init_temp_file_batches(FILE* temp_file, long long num_vectors, int num_nn,
long long rows_in_batch)
{
if (num_vectors < rows_in_batch) {
rows_in_batch = num_vectors;
}
long long row_size = make_temp_file_row_size(num_nn);
nn_item_t* batch = malloc(row_size * rows_in_batch);
init_empty_batch_for_temp_file(batch, num_nn, rows_in_batch);
long long num_rows_written = 0;
while (num_rows_written < num_vectors) {
long long num_rows_to_write = iminll(rows_in_batch, num_vectors - num_rows_written);
fwrite(batch, row_size, num_rows_to_write, temp_file);
num_rows_written += num_rows_to_write;
}
free(batch);
}
void partial_load_temp_file(const char* temp_file_name, int num_nn, long long num_vectors_to_load,
const long long* vectors_indices_to_load,
nn_item_t* output_vectors)
{
FILE* f = fopen(temp_file_name, "rb");
long long row_size = make_temp_file_row_size(num_nn);
for (
long long i = 0;
i < num_vectors_to_load;
++i, ++vectors_indices_to_load, output_vectors += num_nn)
{
long long vector_index = *vectors_indices_to_load;
fseek(f, row_size * vector_index, SEEK_SET);
fread((void*) output_vectors, 1, row_size, f);
}
fclose(f);
}
void partial_save_temp_file(const char* temp_file_name, int num_nn, long long num_vectors_to_save,
const long long* vectors_indices_to_save,
nn_item_t* vectors_to_save)
{
FILE* f = fopen(temp_file_name, "r+b");
long long row_size = make_temp_file_row_size(num_nn);
for (
long long i = 0;
i < num_vectors_to_save;
++i, ++vectors_indices_to_save, vectors_to_save += num_nn)
{
long long vector_index = *vectors_indices_to_save;
fseek(f, row_size * vector_index, SEEK_SET);
fwrite((void*) vectors_to_save, 1, row_size, f);
}
fclose(f);
}
void temp_file_loader_init(temp_file_loader_t* loader, const char* temp_file_name, int num_nn,
long long initial_capacity)
{
loader->temp_file_name = temp_file_name;
loader->num_nn = num_nn;
loader->vectors_capacity = 0;
loader->vectors = NULL;
_temp_file_loader_alloc_vectors(loader, initial_capacity);
loader->num_vectors_to_load = 0;
loader->vectors_indices = NULL;
loader->thread_active = 0;
}
void _temp_file_loader_alloc_vectors(temp_file_loader_t* loader, long long capacity) {
if (loader->vectors_capacity >= capacity) {
return;
}
if (loader->vectors) {
free(loader->vectors);
loader->vectors = NULL;
}
loader->vectors_capacity = capacity;
long long row_size = make_temp_file_row_size(loader->num_nn);
loader->vectors = malloc(row_size * loader->vectors_capacity);
}
void temp_file_loader_load(temp_file_loader_t* loader, long long num_vectors_to_load,
long long* vectors_indices)
{
if (loader->thread_active) {
fprintf(stderr, "Loader is busy. Wait for thread join");
temp_file_loader_join(loader);
}
loader->num_vectors_to_load = num_vectors_to_load;
loader->vectors_indices = vectors_indices;
if (loader->num_vectors_to_load > loader->vectors_capacity) {
_temp_file_loader_alloc_vectors(loader, loader->num_vectors_to_load);
}
loader->thread_active = 1;
pthread_create(&loader->thread, NULL, temp_file_loader_load_thread, (void*)loader);
}
void temp_file_loader_load_join(temp_file_loader_t* loader) {
temp_file_loader_join(loader);
}
void temp_file_loader_save(temp_file_loader_t* loader) {
if (loader->thread_active) {
fprintf(stderr, "Loader is busy. Wait for thread join");
temp_file_loader_join(loader);
}
loader->thread_active = 1;
pthread_create(&loader->thread, NULL, temp_file_loader_save_thread, (void*)loader);
}
void temp_file_loader_save_join(temp_file_loader_t* loader) {
temp_file_loader_join(loader);
}
void temp_file_loader_join(temp_file_loader_t* loader) {
if (loader->thread_active) {
pthread_join(loader->thread, NULL);
}
loader->thread_active = 0;
}
void temp_file_loader_destroy(temp_file_loader_t* loader) {
temp_file_loader_join(loader);
loader->temp_file_name = NULL;
loader->num_nn = 0;
if (loader->vectors) {
free(loader->vectors);
}
loader->vectors = NULL;
loader->vectors_capacity = 0;
loader->num_vectors_to_load = 0;
loader->vectors_indices = NULL;
}
// Temp file to result
void temp_file_to_result(const char* temp_file, const char* indices_file, const char* dists_file,
long long num_vectors, int num_nn)
{
FILE* temp_f = fopen(temp_file, "rb");
FILE* indices_f = fopen(indices_file, "wb");
FILE* dists_f = fopen(dists_file, "wb");
temp_file_to_result_batches(temp_f, indices_f, dists_f, num_vectors, num_nn, DEFAULT_BATCH_SIZE);
fclose(temp_f);
fclose(indices_f);
fclose(dists_f);
}
void temp_file_to_result_batches(FILE* temp_file, FILE* indices_file, FILE* dists_file,
long long num_vectors, int num_nn, long long batch_size)
{
long long tempfile_row_size = make_temp_file_row_size(num_nn);
long long indices_row_size = sizeof(vector_id_t) * num_nn;
long long dists_row_size = sizeof(float) * num_nn;
nn_item_t* tempfile_batch = malloc(tempfile_row_size * batch_size);
vector_id_t* indices_batch = malloc(indices_row_size * batch_size);
float* dists_batch = malloc(dists_row_size * batch_size);
save_vecs_light_meta_file(indices_file, num_vectors, num_nn);
save_vecs_light_meta_file(dists_file, num_vectors, num_nn);
long long rows_processed = 0;
while (rows_processed < num_vectors) {
long long current_batch_size = iminll(batch_size, num_vectors - rows_processed);
fread(tempfile_batch, tempfile_row_size, current_batch_size, temp_file);
for (long long row_index = 0; row_index < current_batch_size; ++row_index) {
fast_nn_heap_sort(tempfile_batch + num_nn * row_index, num_nn,
indices_batch + num_nn * row_index, dists_batch + num_nn * row_index);
}
fwrite(indices_batch, indices_row_size, current_batch_size, indices_file);
fwrite(dists_batch, dists_row_size, current_batch_size, dists_file);
rows_processed += current_batch_size;
}
free(dists_batch);
free(indices_batch);
free(tempfile_batch);
}
|
trukanduk/pq_huffman
|
src/dsu.h
|
#ifndef _DSU_H
#define _DSU_H
#include "misc.h"
typedef struct _dsu_item {
vector_id_t parent_id; // NOTE: not pointer to save memory (if vector_id_t = int)
int rank;
} dsu_item_t;
typedef struct _dsu {
long long num_elements;
dsu_item_t* items;
} dsu_t;
void dsu_init(dsu_t* dsu, long long num_elements);
void dsu_destroy(dsu_t* dsu);
vector_id_t dsu_find_set(dsu_t* dsu, vector_id_t element);
int dsu_is_one_set(dsu_t* dsu, vector_id_t first, vector_id_t second);
void dsu_union(dsu_t* dsu, vector_id_t first, vector_id_t second);
#endif // _DSU_H
|
trukanduk/pq_huffman
|
src/fast_nn_block.c
|
<filename>src/fast_nn_block.c
#include "fast_nn_block.h"
#include <stdlib.h>
#include <string.h>
void block_init(block_t* block, long long block_id, int num_dimensions, long long initial_capacity,
int init_flags)
{
block->id = block_id;
block->num_dimensions = num_dimensions;
block->capacity = 100;
block->size = 0;
block->data = NULL;
block->indices = NULL;
if (init_flags & BLOCK_INIT_WITH_DATA) {
block->data = malloc(sizeof(*block->data) * block->num_dimensions * block->capacity);
}
if (init_flags & BLOCK_INIT_WITH_INDICES) {
block->indices = malloc(sizeof(*block->indices) * block->capacity);
}
}
void block_destroy(block_t* block) {
block->id = -1;
block->num_dimensions = 0;
block->capacity = 0;
block->size = 0;
if (block->data) {
free(block->data);
block->data = NULL;
}
if (block->indices) {
free(block->indices);
block->indices = NULL;
}
}
void block_push(block_t* block, long long index, const float* vector) {
if (block->size >= block->capacity) {
block_realloc(block, (block->capacity + 1) * 2);
}
if (block->indices) {
block->indices[block->size] = index;
}
if (block->data) {
memcpy(block->data + block->size * block->num_dimensions, vector,
sizeof(*vector) * block->num_dimensions);
}
++block->size;
}
void block_realloc(block_t* block, long long new_capacity) {
if (block->data) {
block->data = realloc(block->data,
sizeof(*block->data) * new_capacity * block->num_dimensions);
}
if (block->indices) {
block->indices = realloc(block->indices,
sizeof(*block->indices) * new_capacity);
}
block->capacity = new_capacity;
}
void block_set_id(block_t* block, long long block_id) {
block->id = block_id;
block->size = 0;
}
|
trukanduk/pq_huffman
|
src/misc.c
|
#include "misc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int imin(int a, int b) {
return (a < b ? a : b);
}
long long iminll(long long a, long long b) {
return (a < b ? a : b);
}
long long iclampll(long long value, long long min_value, long long max_value) {
if (value <= min_value) {
return min_value;
} else if (value >= max_value) {
return max_value;
} else {
return value;
}
}
char* concat(const char* prefix, const char* suffix) {
int prefix_length = strlen(prefix);
int suffix_length = strlen(suffix);
char* result = malloc(sizeof(*result) * (prefix_length + suffix_length + 1));
char* result_it = result;
for (const char* prefix_it = prefix; *prefix_it; ++prefix_it, ++result_it) {
*result_it = *prefix_it;
}
for (const char* suffix_it = suffix; *suffix_it; ++suffix_it, ++result_it) {
*result_it = *suffix_it;
}
*result_it = '\0';
return result;
}
long long load_num_elements(const char* filename, long long element_size) {
FILE* f = fopen(filename, "rb");
fseek(f, 0, SEEK_END);
long long file_size = ftell(f);
fclose(f);
long long result = file_size / element_size;
assert(result * element_size == file_size);
return result;
}
|
trukanduk/pq_huffman
|
src/vecs_io.h
|
#ifndef _VECS_IO_H
#define _VECS_IO_H
#include <stdio.h>
#include "misc.h"
byte_t* load_vecs_light_filename(const char* filename, size_t element_size,
long long* num_elements_out, int* num_dimensions_out);
byte_t* load_vecs_light_file(FILE* file, size_t element_size,
long long* num_elements_out, int* num_dimensions_out);
void load_vecs_light_meta_filename(const char* filename, long long* num_elements_out,
int* num_dimensions_out);
void load_vecs_light_meta_file(FILE* file, long long* num_elements_out,
int* num_dimensions_out);
long long load_vecs_num_vectors_filename(const char* filename);
int load_vecs_num_dimensions_filename(const char* filename);
void save_vecs_light_meta_file(FILE* file, long long num_elements, int num_dimensions);
#endif //_VECS_IO_H
|
trukanduk/pq_huffman
|
src/huffman_encoder.c
|
<filename>src/huffman_encoder.c
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "bitstream.h"
#include "huffman.h"
#include "stats.h"
#include "misc.h"
#include "vecs_io.h"
#include "mst.h"
enum {
SORT_NOSORT = 0,
SORT_SORT = 1,
SORT_SHUFFLE = 2
};
typedef struct _config {
const char* pq_input_template;
const char* tree_input;
const char* output_template;
int m;
int k_star;
int only_estimate;
int sort;
int context;
char* pq_input_indices;
// char* pq_input_centroids;
char* output_codebooks;
char* output_children_codebook;
char* output_encoded_indices;
char* output_encoded_children;
char* output_stats;
char* output_children_stats;
long long num_vectors;
} config_t;
static void print_help(const char* argv0) {
fprintf(stderr, "Usage: %s <pq-output-template> <output-template> <m>"
" [--no-sort] [--no-context] [--only-estimate] [--tree <tree path>]\n", argv0);
exit(1);
}
static long long load_num_vectors(const char* filename, int m) {
FILE* f = fopen(filename, "rb");
fseek(f, 0, SEEK_END);
long long file_size = ftell(f);
fclose(f);
return file_size / m;
}
static void parse_args(config_t* config, int argc, const char* argv[]) {
if (argc < 4) {
fprintf(stderr, "Too few positional arguments\n");
print_help(argv[0]);
}
config->pq_input_template = argv[1];
config->output_template = argv[2];
config->tree_input = NULL;
config->m = atoi(argv[3]);
config->only_estimate = 0;
config->sort = SORT_SORT;
config->context = 1;
for (const char** arg = argv + 4; *arg; ++arg) {
if (!strcmp(*arg, "--only-estimate")) {
config->only_estimate = 1;
} else if (!strcmp(*arg, "--no-sort")) {
config->sort = SORT_NOSORT;
} else if (!strcmp(*arg, "--shuffle")) {
config->sort = SORT_SHUFFLE;
} else if (!strcmp(*arg, "--no-context")) {
config->context = 0;
} else if (!strcmp(*arg, "--tree")) {
++arg;
config->tree_input = *arg;
} else {
fprintf(stderr, "Unknown arg: %s\n", *arg);
print_help(argv[0]);
}
}
config->k_star = (1 << 8); // TODO:
config->pq_input_indices = concat(config->pq_input_template, "pq_indices.bvecsl");
// config->pq_input_centroids = concat(config->pq_input_template, "pq_centroids.fvecsl");
config->output_codebooks = concat(config->output_template, "huffman_codebooks.bin");
config->output_children_codebook = concat(config->output_template,
"huffman_children_codebooks.bin");
config->output_encoded_indices = concat(config->output_template, "huffman_indices.bin");
config->output_encoded_children = concat(config->output_template, "huffman_children.bin");
config->output_stats = concat(config->output_template, "huffman_stats.txt");
config->output_children_stats = concat(config->output_template, "huffman_children_stats.txt");
config->num_vectors = load_vecs_num_vectors_filename(config->pq_input_indices);
}
static void config_free(config_t* config) {
if (config->pq_input_indices) {
free(config->pq_input_indices);
config->pq_input_indices = NULL;
}
// if (config->pq_input_centroids) {
// free(config->pq_input_centroids);
// config->pq_input_centroids = NULL;
// }
if (config->output_codebooks) {
free(config->output_codebooks);
config->output_codebooks = NULL;
}
if (config->output_children_codebook) {
free(config->output_children_codebook);
config->output_children_codebook = NULL;
}
if (config->output_encoded_indices) {
free(config->output_encoded_indices);
config->output_encoded_indices = NULL;
}
if (config->output_encoded_children) {
free(config->output_encoded_children);
config->output_encoded_children = NULL;
}
if (config->output_stats) {
free(config->output_stats);
config->output_stats = NULL;
}
if (config->output_children_stats) {
free(config->output_children_stats);
config->output_children_stats = NULL;
}
}
static double* collect_non_context_stats(const config_t* config, const byte_t* data) {
double* stats = malloc(sizeof(*stats) * config->m * config->k_star);
for (int i = 0; i < config->m * config->k_star; ++i) {
stats[i] = 0.0;
}
for (const byte_t* vec_it = data;
vec_it != data + config->m * config->num_vectors;
vec_it += config->m)
{
for (int i = 0; i < config->m; ++i) {
stats[config->k_star * i + *(vec_it + i)] += 1;
}
}
for (int i = 0; i < config->m; ++i) {
double stats_sum = 0.0;
for (double* stat_it = stats + config->k_star * i;
stat_it != stats + config->k_star * (i + 1);
++stat_it)
{
stats_sum += *stat_it;
}
assert((long long) stats_sum == config->num_vectors);
}
return stats;
}
static double* collect_context_stats(const config_t* config, const byte_t* data,
const vector_id_t* vertices, const int* num_children,
int* num_roots_out) {
int alphabet_size = config->k_star * config->k_star;
double* stats = malloc(sizeof(*stats) * config->m * alphabet_size);
for (int i = 0; i < config->m * alphabet_size; ++i) {
stats[i] = 0.0;
}
int num_roots = 1;
if (vertices) {
num_roots = tree_collect_indices_stats(config->num_vectors, config->m, data, vertices,
num_children, stats);
} else {
const byte_t* current_vec = data + config->m;
const byte_t* prev_vec = data;
for (;
current_vec != data + config->m * config->num_vectors;
current_vec += config->m, prev_vec += config->m)
{
for (int i = 0; i < config->m; ++i) {
stats[i * alphabet_size + (prev_vec[i] << BYTE_NUM_BITS) + current_vec[i]] += 1;
}
}
for (int i = 0; i < config->m; ++i) {
double stats_sum = 0.0;
for (double* stat_it = stats + alphabet_size * i;
stat_it != stats + alphabet_size * (i + 1);
++stat_it)
{
stats_sum += *stat_it;
}
assert(((long long) stats_sum + 1) == config->num_vectors);
}
}
if (num_roots_out) {
*num_roots_out = num_roots;
}
return stats;
}
static void encode_non_context_data(const config_t* config, const byte_t* data,
const huffman_codebook_t* codebooks, bit_stream_t* stream) {
for (const byte_t* vector = data;
vector != data + config->m * config->num_vectors;
vector += config->m)
{
for (int i = 0; i < config->m; ++i) {
const huffman_code_item_t* item = &codebooks[i].items[vector[i]];
bit_stream_write(stream, item->code, item->bit_length);
}
}
}
static void encode_context_data(const config_t* config, const byte_t* data,
const huffman_codebook_t* codebooks, bit_stream_t* stream) {
const byte_t* vec_it = data;
const byte_t* prev_vec_it = NULL;
for (;
vec_it != data + config->m * config->num_vectors;
prev_vec_it = vec_it, vec_it += config->m)
{
for (int i = 0; i < config->m; ++i) {
if (prev_vec_it) {
int code_index = (prev_vec_it[i] << 8) + vec_it[i];
const huffman_code_item_t* item = &codebooks[i].items[code_index];
bit_stream_write(stream, item->code, item->bit_length);
} else {
bit_stream_write(stream, vec_it + i, BYTE_NUM_BITS);
}
}
}
}
static void encode_tree_data(const config_t* config, const byte_t* data,
const huffman_codebook_t* codebooks, bit_stream_t* stream,
const vector_id_t* vertices, const int* num_children) {
tree_traverser_t traverser;
tree_traverser_init(&traverser, config->num_vectors);
const int* num_children_it = num_children;
const vector_id_t* vertices_it = vertices;
long long total_written = 0;
for (long long vec_index = 0; vec_index < config->num_vectors; ++vec_index) {
vector_id_t current_vector_id = vertices_it ? *vertices_it : vec_index;
const byte_t* current_vector = data + 1LL * current_vector_id * config->m;
vector_id_t prev_vector_id = tree_traverser_get_active_parent(&traverser);
const byte_t* prev_vector = prev_vector_id != TRAVERSER_NO_PARENT_VECTOR
? data + 1LL * prev_vector_id * config->m
: NULL;
for (int part_index = 0; part_index < config->m; ++part_index) {
const huffman_codebook_t* codebook = codebooks + part_index;
if (prev_vector) {
long long item_index = config->k_star * prev_vector[part_index]
+ current_vector[part_index];
const huffman_code_item_t* item = &codebook->items[item_index];
bit_stream_write(stream, item->code, item->bit_length);
assert(item->bit_length > 0);
total_written += item->bit_length;
} else {
bit_stream_write(stream, current_vector + part_index, BYTE_NUM_BITS);
total_written += BYTE_NUM_BITS;
}
}
int current_num_children = num_children_it ? *num_children_it : 1;
tree_traverser_push_vertex(&traverser, current_vector_id, current_num_children);
if (num_children) {
++num_children_it;
}
if (vertices) {
++vertices_it;
}
}
assert(traverser.stack_size == 0);
// printf("WRITTEN %lld\n", total_written);
tree_traverser_destroy(&traverser);
}
static void shuffle(const config_t* config, byte_t* data) {
byte_t* tmp = malloc(sizeof(byte_t) * config->m);
long long vec_size = config->m * sizeof(byte_t);
for (long long i = config->num_vectors - 1; i >= 1; --i) {
long long j = 1LL * rand() * i / RAND_MAX;
memmove(tmp, data + i * config->m, vec_size);
memmove(data + i * config->m, data + j * config->m, vec_size);
memmove(data + j * config->m, tmp, vec_size);
}
free(tmp);
}
static int sort_indices_comparator_m;
static int sort_indices_comparator(const void* left, const void* right) {
return strncmp(left, right, sort_indices_comparator_m);
}
static void run(const config_t* config) {
long long data_size = config->m * config->num_vectors;
huffman_stats_t encode_stats;
huffman_stats_init(&encode_stats, config->num_vectors, config->m, config->k_star);
byte_t* data = load_vecs_light_filename(config->pq_input_indices, sizeof(byte_t), NULL, NULL);
if (config->sort == SORT_SHUFFLE) {
shuffle(config, data);
} else if (config->sort == SORT_SORT) {
sort_indices_comparator_m = config->m;
qsort(data, config->num_vectors, config->m * sizeof(byte_t), sort_indices_comparator);
}
double* stats;
int alphabet_size = config->k_star;
vector_id_t* vertices = NULL;
int* num_children = NULL;
if (config->tree_input) {
tree_t tree;
tree_load_filename(&tree, config->tree_input);
vertices = malloc(sizeof(*vertices) * config->num_vectors);
num_children = malloc(sizeof(*num_children) * config->num_vectors);
tree_collect_vertices_dfs(&tree, vertices, num_children);
tree_destroy(&tree);
}
int num_roots = 0;
if (config->context) {
stats = collect_context_stats(config, data, vertices, num_children, &num_roots);
alphabet_size *= config->k_star;
encode_stats.num_roots = num_roots;
// huffman_counts_context_dump(stats, config->k_star, stdout);
} else {
stats = collect_non_context_stats(config, data);
}
if (num_children) {
int children_alphabet_size = 0;
double* symbol_counts = tree_collect_num_children_stats(config->num_vectors, num_children,
&children_alphabet_size);
huffman_codebook_t codebook;
huffman_codebook_encode_init(&codebook, children_alphabet_size, symbol_counts);
FILE* codebook_file = fopen(config->output_children_codebook, "wb");
huffman_codebook_save(&codebook, codebook_file);
fclose(codebook_file);
FILE* children_file = fopen(config->output_encoded_children, "wb");
bit_stream_t* bitstream = bit_stream_create_from_file(children_file);
for (const int* children_it = num_children;
children_it != num_children + config->num_vectors;
++children_it)
{
const huffman_code_item_t* item = &codebook.items[*children_it];
bit_stream_write(bitstream, item->code, item->bit_length);
}
bit_stream_destroy(bitstream);
fclose(children_file);
huffman_stats_t stats;
huffman_stats_init(&stats, config->num_vectors, 1, config->k_star);
double estimation = huffman_estimate_size(&codebook, symbol_counts);
huffman_stats_push(&stats, 0, estimation);
huffman_stats_print_filename(&stats, config->output_children_stats);
huffman_stats_destroy(&stats);
huffman_codebook_destroy(&codebook);
free(symbol_counts);
}
huffman_codebook_t* codebooks = malloc(sizeof(*codebooks) * config->m);
for (int i = 0; i < config->m; ++i) {
double* stats_part = stats + alphabet_size * i;
if (config->context) {
huffman_codebook_context_encode_init(codebooks + i, config->k_star, stats_part);
} else {
huffman_codebook_encode_init(codebooks + i, config->k_star, stats_part);
}
double estimation = huffman_estimate_size(&codebooks[i], stats_part);
huffman_stats_push(&encode_stats, i, estimation);
}
huffman_stats_print(&encode_stats);
huffman_stats_print_filename(&encode_stats, config->output_stats);
huffman_stats_destroy(&encode_stats);
if (config->only_estimate) {
// TODO: free resources
return;
}
FILE* codebooks_file = fopen(config->output_codebooks, "wb");
unsigned int m_int = config->m;
fwrite(&m_int, sizeof(m_int), 1, codebooks_file);
long long sum_length = 0;
for (int i = 0; i < config->m; ++i) {
for (int j = 0; j < 256 * 256; ++j) {
sum_length += codebooks[i].items[j].bit_length;
}
huffman_codebook_save(codebooks + i, codebooks_file);
}
printf("SUM LENGTH %lld, MEAN %lf\n", sum_length, 1.0 * sum_length / 256 / 256 / config->m);
fclose(codebooks_file);
// huffman_codebook_dump(codebooks, stdout);
FILE* encoded_indices_file = fopen(config->output_encoded_indices, "wb");
unsigned long long num_vectors_ll = config->num_vectors;
fwrite(&num_vectors_ll, sizeof(num_vectors_ll), 1, encoded_indices_file);
bit_stream_t* stream = bit_stream_create_from_file(encoded_indices_file);
if (config->tree_input) {
printf("use tree encoder\n");
encode_tree_data(config, data, codebooks, stream, vertices, num_children);
} else if (config->context) {
printf("use context encoder\n");
encode_context_data(config, data, codebooks, stream);
} else {
printf("use non-context encoder\n");
encode_non_context_data(config, data, codebooks, stream);
}
stream = bit_stream_destroy(stream);
fclose(encoded_indices_file);
for (int i = 0; i < config->m; ++i) {
huffman_codebook_destroy(&codebooks[i]);
}
if (config->tree_input) {
free(vertices);
free(num_children);
}
free(stats);
free(data);
}
int main(int argc, const char* argv[]) {
srand(time(NULL));
config_t config;
parse_args(&config, argc, argv);
run(&config);
config_free(&config);
return 0;
}
|
trukanduk/pq_huffman
|
src/stats.c
|
#include "stats.h"
#include <stdlib.h>
void huffman_stats_init(huffman_stats_t* stats, long long num_vectors, int m, int k_star) {
stats->num_vectors = num_vectors;
stats->m = m;
stats->k_star = k_star;
stats->sum_length = 0.0;
stats->partial_lengths = malloc(sizeof(*stats->partial_lengths) * stats->m);
for (double* length_it = stats->partial_lengths;
length_it != stats->partial_lengths + stats->m;
++length_it)
{
*length_it = 0.0;
}
stats->num_roots = 0;
}
void huffman_stats_destroy(huffman_stats_t* stats) {
stats->num_vectors = 0;
stats->m = 0;
stats->k_star = 0;
stats->sum_length = 0.0;
if (stats->partial_lengths) {
free(stats->partial_lengths);
stats->partial_lengths = NULL;
}
stats->num_roots = 0;
}
void huffman_stats_push(huffman_stats_t* stats, int part, double value) {
stats->sum_length += value;
stats->partial_lengths[part] = value;
}
void huffman_stats_print(const huffman_stats_t* stats) {
huffman_stats_print_file(stats, stdout);
}
void huffman_stats_print_filename(const huffman_stats_t* stats, const char* filename) {
FILE* file = fopen(filename, "a");
huffman_stats_print_file(stats, file);
fclose(file);
}
static void huffman_stats_print_stats_impl(FILE* file, double bit_length, int m,
const huffman_stats_t* stats) {
fprintf(file, "\"length_bit\": %.1lf, \"length_bytes\": %.1lf, ", bit_length, bit_length / 8);
fprintf(file, "\"compression_rate\": %.3lf, \"bits_per_byte\": %.2lf",
bit_length / (stats->num_vectors * m * 8),
bit_length / (stats->num_vectors * m));
}
void huffman_stats_print_file(const huffman_stats_t* stats, FILE* file) {
fprintf(file, "{\"num_vectors\": %lld, \"m\": %d, \"k_star\": %d, ",
stats->num_vectors, stats->m, stats->k_star);
double additional_bits_length = 8 * stats->num_roots;
huffman_stats_print_stats_impl(file, stats->sum_length + additional_bits_length * stats->m,
stats->m, stats);
if (stats->num_roots) {
fprintf(file, ", \"num_roots\": %d", stats->num_roots);
}
fprintf(file, ", \"partials\": [");
for (int i = 0; i < stats->m; ++i) {
if (i > 0) {
fprintf(file, ", ");
}
fprintf(file, "{");
huffman_stats_print_stats_impl(file, stats->partial_lengths[i] + additional_bits_length,
1, stats);
fprintf(file, "}");
}
fprintf(file, "]}\n");
}
|
trukanduk/pq_huffman
|
src/concurrent_queue.c
|
#include "concurrent_queue.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include "misc.h"
void concurrent_queue_print(concurrent_queue_t* queue, const char* action) {
#ifdef _QUEUE_DEBUG
int semv = -1;
sem_getvalue(&queue->sem, &semv);
printf("Queue %s c=%2d, s=%2d, sem=%2d, d=%2d, p=%2d\n", action, queue->capacity, queue->size,
semv, queue->first_datum_index, queue->next_push_index);
#endif
}
void concurrent_queue_init(concurrent_queue_t* queue, int count) {
pthread_mutex_init(&queue->mutex, NULL);
sem_init(&queue->sem, 0, 0);
queue->size = 0;
queue->first_datum_index = 0;
queue->next_push_index = 0;
queue->capacity = count;
queue->data = malloc(sizeof(*queue->data) * count);
}
void concurrent_queue_destroy(concurrent_queue_t* queue) {
pthread_mutex_destroy(&queue->mutex);
free(queue->data);
sem_destroy(&queue->sem);
queue->size = 0;
queue->first_datum_index = 0;
queue->next_push_index = 0;
queue->capacity = 0;
queue->data = NULL;
}
int concurrent_queue_empty(concurrent_queue_t* queue) {
return concurrent_queue_empty_noblock(queue);
}
int concurrent_queue_empty_noblock(concurrent_queue_t* queue) {
return (queue->size == 0);
}
int concurrent_queue_full(concurrent_queue_t* queue) {
return concurrent_queue_full_noblock(queue);
}
int concurrent_queue_full_noblock(concurrent_queue_t* queue) {
return (queue->size == queue->capacity);
}
int concurrent_queue_size(concurrent_queue_t* queue) {
return concurrent_queue_size_noblock(queue);
}
int concurrent_queue_size_noblock(concurrent_queue_t* queue) {
return queue->size;
}
void concurrent_queue_clear(concurrent_queue_t* queue) {
pthread_mutex_lock(&queue->mutex);
concurrent_queue_clear_noblock(queue);
pthread_mutex_unlock(&queue->mutex);
}
void concurrent_queue_clear_noblock(concurrent_queue_t* queue) {
queue->size = 0;
queue->first_datum_index = queue->next_push_index;
}
int concurrent_queue_push(concurrent_queue_t* queue, void* datum, int round_time, int num_rounds) {
if (num_rounds < 0) {
num_rounds = INT_MAX;
}
int round = 0;
int result = 0;
while (round++ < num_rounds && !(result = concurrent_queue_try_push(queue, datum))) {
fprintf(stderr, "Cannot push task to concurrent queue\n");
usleep(round_time * MS);
}
return result;
}
int concurrent_queue_try_push(concurrent_queue_t* queue, void* datum) {
pthread_mutex_lock(&queue->mutex);
int result = concurrent_queue_try_push_noblock(queue, datum);
pthread_mutex_unlock(&queue->mutex);
return result;
}
int concurrent_queue_try_push_noblock(concurrent_queue_t* queue, void* datum) {
if (concurrent_queue_full_noblock(queue)) {
return 0;
}
queue->data[queue->next_push_index] = datum;
queue->next_push_index = (queue->next_push_index + 1) % queue->capacity;
++queue->size;
sem_post(&queue->sem);
concurrent_queue_print(queue, "push");
return 1;
}
void* concurrent_queue_pop(concurrent_queue_t* queue) {
void* result = NULL;
while (!result) {
sem_wait(&queue->sem);
result = concurrent_queue_try_pop(queue);
if (!result) {
fprintf(stderr, "Queue is broken! got empty result from queue");
sem_post(&queue->sem);
}
}
return result;
}
void* concurrent_queue_try_pop(concurrent_queue_t* queue) {
pthread_mutex_lock(&queue->mutex);
void* result = concurrent_queue_try_pop_noblock(queue);
pthread_mutex_unlock(&queue->mutex);
return result;
}
void* concurrent_queue_try_pop_noblock(concurrent_queue_t* queue) {
if (concurrent_queue_empty_noblock(queue)) {
return NULL;
}
void* result = queue->data[queue->first_datum_index];
queue->first_datum_index = (queue->first_datum_index + 1) % queue->capacity;
--queue->size;
concurrent_queue_print(queue, "pop");
return result;
}
|
trukanduk/pq_huffman
|
src/mst.c
|
#include "mst.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "dsu.h"
#include "vecs_io.h"
enum {
NN_LOADER_BATCH_SIZE = 128 * 1024 // NOTE: vectors
};
static int mst_dist_comparator(const void* first, const void* second) {
float first_dist = ((const mst_edge_t*) first)->dist;
float second_dist = ((const mst_edge_t*) second)->dist;
float diff = first_dist - second_dist;
if (fabs(diff) < 1e-9) {
return 0;
} else if (diff < 0) {
return -1;
} else {
return 1;
}
}
static int mst_source_comparator(const void* first, const void* second) {
long long first_dist = ((const mst_edge_t*) first)->source;
long long second_dist = ((const mst_edge_t*) second)->source;
return first_dist - second_dist;
}
static void swap_edges(mst_edge_t* first, mst_edge_t* second) {
if (first == second) {
return;
}
vector_id_t tmp_vec = first->source;
first->source = second->source;
second->source = tmp_vec;
tmp_vec = first->target;
first->target = second->target;
second->target = tmp_vec;
double tmp_dist = first->dist;
first->dist = second->dist;
second->dist = tmp_dist;
}
static void restore_tree_edges_pointers(tree_t* tree) {
tree_edge_t* tree_edge_it = tree->edges;
for (tree_vertex_t* vertex_it = tree->vertices;
vertex_it != tree->vertices + tree->num_vertices;
tree_edge_it += vertex_it->num_edges, ++vertex_it)
{
vertex_it->edges = tree_edge_it;
}
assert(tree_edge_it == tree->edges + tree->num_edges);
}
mst_edge_t* load_mst_edges_from_nn_filenames(long long num_vectors, int num_nn_to_load, int pq_m,
float pq_penalty, const byte_t* pq_indices,
const char* indices_filename,
const char* dist_filename) {
FILE* indices_file = fopen(indices_filename, "rb");
FILE* dist_file = fopen(dist_filename, "rb");
mst_edge_t* result = load_mst_edges_from_nn_files(num_vectors, num_nn_to_load, pq_m,
pq_penalty, pq_indices, indices_file,
dist_file);
fclose(indices_file);
fclose(dist_file);
return result;
}
mst_edge_t* load_mst_edges_from_nn_files(long long num_vectors, int num_nn_to_load, int pq_m,
float pq_penalty, const byte_t* pq_indices,
FILE* indices_file, FILE* dist_file) {
long long num_vectors_ind, num_vectors_dist;
int num_nn, num_nn_dist;
load_vecs_light_meta_file(indices_file, &num_vectors_ind, &num_nn);
load_vecs_light_meta_file(dist_file, &num_vectors_dist, &num_nn_dist);
if (num_vectors_ind != num_vectors || num_vectors != num_vectors_dist || num_nn != num_nn_dist) {
fprintf(stderr, "Does indices and dist files are of the same dataset?\n");
fprintf(stderr, "\tN_expected=%lld, N_indices=%lld, N_dist=%lld,"
"NNN_indices=%d, NNN_dist=%d\n", num_vectors, num_vectors_ind, num_vectors_dist,
num_nn, num_nn_dist);
assert(num_vectors != num_vectors_ind);
assert(num_vectors != num_vectors_dist);
assert(num_nn != num_nn_dist);
}
assert(num_nn_to_load <= num_nn);
mst_edge_t* result = malloc(sizeof(*result) * num_vectors * num_nn_to_load);
mst_edge_t* result_it = result;
vector_id_t* indices_batch = malloc(sizeof(*indices_batch) * num_nn * NN_LOADER_BATCH_SIZE);
float* dist_batch = malloc(sizeof(*dist_batch) * num_nn * NN_LOADER_BATCH_SIZE);
mst_edge_t* row_tmp_batch = malloc(sizeof(*row_tmp_batch) * num_nn);
long long got_vectors = 0;
while (got_vectors < num_vectors) {
long long current_batch_size = iminll(NN_LOADER_BATCH_SIZE, num_vectors - got_vectors);
fread(indices_batch, sizeof(vector_id_t) * num_nn, current_batch_size, indices_file);
fread(dist_batch, sizeof(float) * num_nn, current_batch_size, dist_file);
for (long long vec_index = 0; vec_index < current_batch_size; ++vec_index) {
const byte_t* source_pq_indices = pq_indices + (got_vectors + vec_index) * pq_m;
for (int nn_index = 0; nn_index < num_nn; ++nn_index) {
row_tmp_batch[nn_index].source = got_vectors + vec_index;
row_tmp_batch[nn_index].target = indices_batch[num_nn * vec_index + nn_index];
row_tmp_batch[nn_index].dist = dist_batch[num_nn * vec_index + nn_index];
const byte_t* target_pq_indices = pq_indices + row_tmp_batch[nn_index].target * pq_m;
if (pq_penalty > 0.0f) {
int pq_indices_hamming_distance = 0;
for (int part_index = 0; part_index < pq_m; ++part_index) {
pq_indices_hamming_distance += (source_pq_indices[part_index] != target_pq_indices[part_index]);
}
// printf("%d %f %f\n", pq_indices_hamming_distance, row_tmp_batch[nn_index].dist, pq_indices_hamming_distance * pq_penalty);
if (isinf(pq_penalty)) {
row_tmp_batch[nn_index].dist = pq_indices_hamming_distance;
} else {
row_tmp_batch[nn_index].dist += pq_indices_hamming_distance * pq_penalty;
}
}
}
if (pq_penalty > 0.0f) {
qsort(row_tmp_batch, num_nn, sizeof(mst_edge_t), mst_dist_comparator);
}
memcpy(result_it, row_tmp_batch, num_nn_to_load * sizeof(mst_edge_t));
result_it += num_nn_to_load;
// for (int nn_index = 0; nn_index < num_nn_to_load; ++nn_index, ++result_it) {
// result_it->source = got_vectors + vec_index;
// result_it->target = indices_batch[num_nn * vec_index + nn_index];
// result_it->dist = dist_batch[num_nn * vec_index + nn_index];
// }
}
got_vectors += current_batch_size;
}
assert(result_it == result + num_vectors * num_nn_to_load);
free(indices_batch);
indices_batch = NULL;
free(dist_batch);
dist_batch = NULL;
#if 0
result_it = result;
got_vectors = 0;
while (got_vectors < num_vectors) {
long long current_batch_size = iminll(NN_LOADER_BATCH_SIZE, num_vectors - got_vectors);
fread(dist_batch, sizeof(vector_id_t) * num_nn, current_batch_size, dist_file);
for (long long vec_index = 0; vec_index < current_batch_size; ++vec_index) {
for (int nn_index = 0; nn_index < num_nn_to_load; ++nn_index, ++result_it) {
result_it->dist = dist_batch[num_nn * vec_index + nn_index];
}
}
got_vectors += current_batch_size;
}
assert(result_it == result + num_vectors * num_nn_to_load);
free(dist_batch);
dist_batch = NULL;
#endif
return result;
}
void minimum_spanning_tree(tree_t* tree, long long num_vertices, int num_nn, mst_edge_t* edges) {
tree->num_vertices = num_vertices;
qsort(edges, num_vertices * num_nn, sizeof(*edges), mst_dist_comparator);
tree->vertices = malloc(sizeof(*tree->vertices) * num_vertices);
for (tree_vertex_t* vertex_it = tree->vertices;
vertex_it != tree->vertices + num_vertices;
++vertex_it)
{
vertex_it->num_edges = 0;
vertex_it->edges = NULL;
}
dsu_t dsu;
dsu_init(&dsu, num_vertices);
tree->num_edges = 0;
mst_edge_t* edges_it = edges;
mst_edge_t* good_edges_it = edges;
for (; tree->num_edges + 1 < num_vertices && edges_it != edges + num_vertices * num_nn;
++edges_it) {
if (dsu_is_one_set(&dsu, edges_it->source, edges_it->target)) {
continue;
}
++tree->vertices[edges_it->source].num_edges;
dsu_union(&dsu, edges_it->source, edges_it->target);
swap_edges(edges_it, good_edges_it++);
++tree->num_edges;
}
assert(tree->num_edges * 2 <= num_vertices * num_nn && "Need at least two nn-vectors");
edges_it = edges;
mst_edge_t* good_edges_end = good_edges_it;
for (; edges_it != good_edges_end; ++edges_it, ++good_edges_it) {
good_edges_it->source = edges_it->target;
good_edges_it->target = edges_it->source;
good_edges_it->dist = edges_it->dist;
++tree->vertices[edges_it->target].num_edges;
}
tree->num_edges *= 2;
qsort(edges, tree->num_edges, sizeof(*edges), mst_source_comparator);
tree->edges = malloc(sizeof(*tree->edges) * tree->num_edges);
tree_edge_t* tree_edge_it = tree->edges;
edges_it = edges;
long long edge_num = 0;
vector_id_t expected_source = 0;
long long assigned_vertices = 0;
for (; edges_it != edges + tree->num_edges;
++edges_it, ++tree_edge_it, ++edge_num, ++assigned_vertices)
{
while (edge_num >= tree->vertices[expected_source].num_edges) {
edge_num -= tree->vertices[expected_source].num_edges;
++expected_source;
}
// printf("%lld %d %d %d\n", edge_num, tree->vertices[expected_source].num_edges, edges_it->source, expected_source);
assert(edges_it->source == expected_source);
assert(edges_it->target < num_vertices);
tree_edge_it->target = edges_it->target;
}
assert(assigned_vertices == tree->num_edges);
restore_tree_edges_pointers(tree);
}
void tree_destroy(tree_t* tree) {
free(tree->edges);
tree->edges = NULL;
free(tree->vertices);
tree->vertices = NULL;
tree->num_vertices = 0;
tree->num_edges = 0;
}
void tree_save_filename(const tree_t* tree, const char* filename) {
FILE* f = fopen(filename, "wb");
tree_save_file(tree, f);
fclose(f);
}
void tree_save_file(const tree_t* tree, FILE* file) {
fwrite(&tree->num_vertices, sizeof(tree->num_vertices), 1, file);
fwrite(&tree->num_edges, sizeof(tree->num_edges), 1, file);
// FIXME: Fix this if tree_edge will have more fields
fwrite(tree->edges, sizeof(*tree->edges), tree->num_edges, file);
int* children_counts = malloc(sizeof(*children_counts) * tree->num_vertices);
for (long long i = 0; i < tree->num_vertices; ++i) {
children_counts[i] = tree->vertices[i].num_edges;
}
fwrite(children_counts, sizeof(*children_counts), tree->num_vertices, file);
free(children_counts);
}
void tree_load_filename(tree_t* tree, const char* filename) {
FILE* f = fopen(filename, "rb");
tree_load_file(tree, f);
fclose(f);
}
void tree_load_file(tree_t* tree, FILE* file) {
fread(&tree->num_vertices, sizeof(tree->num_vertices), 1, file);
fread(&tree->num_edges, sizeof(tree->num_edges), 1, file);
tree->edges = malloc(sizeof(*tree->edges) * tree->num_edges);
// FIXME:
fread(tree->edges, sizeof(*tree->edges), tree->num_edges, file);
tree->vertices = malloc(sizeof(*tree->vertices) * tree->num_vertices);
int* children_counts = malloc(sizeof(*children_counts) * tree->num_vertices);
fread(children_counts, sizeof(*children_counts), tree->num_vertices, file);
for (long long i = 0; i < tree->num_vertices; ++i) {
tree->vertices[i].num_edges = children_counts[i];
}
restore_tree_edges_pointers(tree);
free(children_counts);
}
int tree_collect_vertices_dfs(const tree_t* tree, vector_id_t* vertices, int* num_children) {
vector_id_t* stack = malloc(sizeof(*stack) * tree->num_vertices);
char* visited = calloc(sizeof(*visited), tree->num_vertices);
// NOTE: may be null's
vector_id_t* vertices_it = vertices;
int* num_children_it = num_children;
long long num_processed_vertices = 0;
vector_id_t last_known_root_vector = 0;
int num_roots = 0;
long long num_edges_sum = 0;
long long stack_size = 0;
while (num_processed_vertices < tree->num_vertices) {
if (stack_size == 0) {
while (last_known_root_vector < tree->num_vertices && visited[last_known_root_vector]) {
++last_known_root_vector;
}
assert(last_known_root_vector < tree->num_vertices);
stack[stack_size++] = last_known_root_vector;
visited[last_known_root_vector] += 1;
++num_roots;
}
vector_id_t current_vertex_id = stack[--stack_size];
assert (visited[current_vertex_id] == 1);
// printf("Vertex %d, stack size %d\n", current_vertex_id, stack_size);
// if (visited[current_vertex_id]) {
// continue;
// }
// visited[current_vertex_id] = 1;
const tree_vertex_t* current_vertex = tree->vertices + current_vertex_id;
if (vertices_it) {
*vertices_it = current_vertex_id;
++vertices_it;
}
if (num_children) {
#if 1
*num_children_it = 0;
for (const tree_edge_t* edge = current_vertex->edges;
edge != current_vertex->edges + current_vertex->num_edges;
++edge)
{
if (!visited[edge->target]) {
++*num_children_it;
}
}
num_edges_sum += *num_children_it;
#else
*num_children_it = current_vertex->num_edges;
#endif
++num_children_it;
}
++num_processed_vertices;
for (const tree_edge_t* edges_it = current_vertex->edges;
edges_it != current_vertex->edges + current_vertex->num_edges;
++edges_it)
{
// printf("%lld \n", current_vertex_id);
// printf("Edge %lld, vis=%d\n", edges_it - tree->edges < tree->num_edges, visited[edges_it->target]);
if (!visited[edges_it->target]) {
// printf("Target %d\n", edges_it->target);
visited[edges_it->target] += 1;
stack[stack_size++] = edges_it->target;
}
}
}
assert(num_edges_sum == tree->num_vertices - num_roots);
free(visited);
free(stack);
return num_roots;
}
void tree_traverser_init(tree_traverser_t* traverser, long long num_vertices) {
traverser->num_vertices = num_vertices;
traverser->stack_size = 0;
traverser->stack = malloc(sizeof(*traverser->stack) * num_vertices);
}
void tree_traverser_destroy(tree_traverser_t* traverser) {
traverser->num_vertices = 0;
traverser->stack_size = 0;
free(traverser->stack);
traverser->stack = NULL;
}
void tree_traverser_reset(tree_traverser_t* traverser) {
traverser->stack_size = 0;
}
vector_id_t tree_traverser_get_active_parent(const tree_traverser_t* traverser) {
if (traverser->stack_size > 0) {
return traverser->stack[traverser->stack_size - 1].vertex_id;
} else {
return TRAVERSER_NO_PARENT_VECTOR;
}
}
void tree_traverser_push_vertex(tree_traverser_t* traverser, vector_id_t vertex_id,
int num_children) {
if (traverser->stack_size > 0) {
--traverser->stack[traverser->stack_size - 1].num_children;
if (!traverser->stack[traverser->stack_size - 1].num_children) {
--traverser->stack_size;
}
}
if (num_children) {
traverser->stack[traverser->stack_size].vertex_id = vertex_id;
traverser->stack[traverser->stack_size].num_children = num_children;
++traverser->stack_size;
}
}
double* tree_collect_num_children_stats(long long num_vectors, const int* num_children,
int* alphabet_size_out) {
int alphabet_size = 0;
for (const int* num_children_it = num_children;
num_children_it != num_children + num_vectors;
++num_children_it)
{
if (alphabet_size < *num_children_it) {
alphabet_size = *num_children_it;
}
}
++alphabet_size;
printf("Max num children: %d\n", alphabet_size);
double* stats = malloc(sizeof(*stats) * alphabet_size);
for (double* stats_it = stats; stats_it != stats + alphabet_size; ++stats_it) {
*stats_it = 0.0;
}
for (const int* num_children_it = num_children;
num_children_it != num_children + num_vectors;
++num_children_it)
{
stats[*num_children_it] += 1.0;
}
// huffman_codebook_encode_init(codebook, alphabet_size, stats);
// free(stats);
if (alphabet_size_out) {
*alphabet_size_out = alphabet_size;
}
return stats;
}
#define K_STAR (1 << 8)
int tree_collect_indices_stats(long long num_vectors, int pq_m, const byte_t* pq_indices,
const vector_id_t* vertices, const int* num_children,
double* stats) {
for (double* stats_it = stats; stats_it != stats + pq_m * K_STAR * K_STAR; ++stats_it) {
*stats_it = 0.0;
}
tree_traverser_t traverser;
if (vertices) {
tree_traverser_init(&traverser, num_vectors);
}
const vector_id_t* vertices_it = vertices;
const int* num_children_it = num_children;
int num_components = 0;
for (long long vec_index = 0; vec_index < num_vectors; ++vec_index) {
vector_id_t current_vector_id = vertices_it ? *vertices_it : vec_index;
vector_id_t prev_vector_id = tree_traverser_get_active_parent(&traverser);
if (prev_vector_id != TRAVERSER_NO_PARENT_VECTOR) {
const byte_t* prev_vector = pq_indices + 1LL * prev_vector_id * pq_m;
const byte_t* current_vector = pq_indices + 1LL * current_vector_id * pq_m;
for (int part_index = 0; part_index < pq_m; ++part_index) {
double* stats_part = stats + part_index * K_STAR * K_STAR;
stats_part[prev_vector[part_index] * K_STAR + current_vector[part_index]] += 1.0;
}
} else {
++num_components;
}
int current_num_children = num_children_it ? *num_children_it : 1;
tree_traverser_push_vertex(&traverser, current_vector_id, current_num_children);
if (vertices_it) {
++vertices_it;
}
if (num_children_it) {
++num_children_it;
}
}
#if 0
for (int part_index = 0; part_index < pq_m; ++part_index) {
double* stats_part = stats + part_index * K_STAR * K_STAR;
huffman_codebook_context_encode_init(codebooks + part_index, K_STAR, stats_part);
}
#endif
if (vertices) {
tree_traverser_destroy(&traverser);
}
return num_components;
}
void tree_estimate_huffman_encoding(huffman_stats_t* indices_stats, huffman_stats_t* children_stats,
const tree_t* tree, int pq_m, const byte_t* pq_indices) {
// TODO: Merge with huffman_encoder
vector_id_t* vertices = malloc(sizeof(*vertices) * tree->num_vertices);
int* num_children = malloc(sizeof(*num_children) * tree->num_vertices);
double* indices_symbol_stats = malloc(sizeof(*indices_symbol_stats) * K_STAR * K_STAR * pq_m);
tree_collect_vertices_dfs(tree, vertices, num_children);
int num_components = tree_collect_indices_stats(tree->num_vertices, pq_m, pq_indices, vertices,
num_children, indices_symbol_stats);
huffman_codebook_t codebook;
huffman_stats_init(indices_stats, tree->num_vertices, pq_m, K_STAR);
indices_stats->num_roots = num_components;
for (int part_index = 0; part_index < pq_m; ++part_index) {
huffman_codebook_context_encode_init(&codebook, K_STAR, indices_symbol_stats + part_index * K_STAR * K_STAR);
double estimated = huffman_estimate_size(&codebook, indices_symbol_stats + part_index * K_STAR * K_STAR);
huffman_stats_push(indices_stats, part_index, estimated);
huffman_codebook_destroy(&codebook);
}
int num_children_alphabet_size = 0;
double* num_children_symbol_stats =
tree_collect_num_children_stats(tree->num_vertices, num_children,
&num_children_alphabet_size); // malloc inside
huffman_codebook_encode_init(&codebook, num_children_alphabet_size, num_children_symbol_stats);
double num_children_estimation = huffman_estimate_size(&codebook, num_children_symbol_stats);
huffman_stats_init(children_stats, tree->num_vertices, 1, num_children_alphabet_size);
huffman_stats_push(children_stats, 0, num_children_estimation);
huffman_codebook_destroy(&codebook);
free(num_children_symbol_stats);
free(indices_symbol_stats);
free(vertices);
free(num_children);
}
|
trukanduk/pq_huffman
|
src/huffman_codebook.c
|
#include "huffman.h"
#include <assert.h>
#include <stdlib.h>
void huffman_dump_code(const huffman_code_item_t* item, FILE* f) {
if (!item->code) {
fprintf(f, "-");
return;
}
for (int bit_index = 0; bit_index < item->bit_length; ++bit_index) {
int byte_offset = bit_index / BYTE_NUM_BITS;
int bit_offset = bit_index % BYTE_NUM_BITS;
int bit_value = (item->code[byte_offset] >> (BYTE_NUM_BITS - bit_offset - 1)) & 1;
fprintf(f, "%d", bit_value);
}
fprintf(f, " (%d)", item->bit_length);
}
void huffman_codebook_dump(const huffman_codebook_t* codebook, FILE* f) {
for (int item_index = 0; item_index < codebook->num_items; ++item_index) {
if (codebook->is_context) {
int src_symbol = item_index / codebook->alphabet_size;
int dst_symbol = item_index % codebook->alphabet_size;
fprintf(f, "%d -> %d: ", src_symbol, dst_symbol);
} else {
fprintf(f, "%d: ", item_index);
}
huffman_dump_code(codebook->items + item_index, f);
fprintf(f, "\n");
}
}
void huffman_counts_context_dump(const double* symbol_counts, int alphabet_size, FILE* f) {
for (int from = 0; from < alphabet_size; ++from) {
for (int to = 0; to < alphabet_size; ++to) {
fprintf(f, "%d -> %d: %lf\n", from, to, symbol_counts[from * alphabet_size + to]);
}
}
}
static void huffman_codebook_write_bit_length(FILE* file, unsigned int bit_length) {
unsigned int bit_length_rest = bit_length;
int continous_flag = 1;
for (int byte_index = 0; byte_index < sizeof(bit_length) && continous_flag; ++byte_index) {
byte_t byte = bit_length_rest & 0x7f;
continous_flag = (bit_length_rest != byte);
if (continous_flag) {
byte |= (1 << 7);
}
fwrite(&byte, 1, sizeof(byte), file);
bit_length_rest >>= 7;
}
if (continous_flag) {
fprintf(stderr, "Cannot write bit_length of code because it's too large: %u\n", bit_length);
}
}
static unsigned int huffman_codebook_read_bit_length(FILE* file) {
unsigned int bit_length = 0U;
int continous_flag = 1;
for (int byte_index = 0; byte_index < sizeof(bit_length) && continous_flag; ++byte_index) {
byte_t byte = 0;
fread(&byte, 1, sizeof(byte), file);
bit_length |= ((unsigned int) (byte & 0x7f) << (7 * byte_index));
continous_flag = (byte >> 7) & 1;
}
return bit_length;
}
void huffman_codebook_save(const huffman_codebook_t* codebook, FILE* file) {
fwrite(&codebook->alphabet_size, 1, sizeof(codebook->alphabet_size), file);
byte_t is_context_byte = codebook->is_context;
fwrite(&is_context_byte, 1, sizeof(is_context_byte), file);
for (const huffman_code_item_t* item = codebook->items;
item != codebook->items + codebook->num_items;
++item)
{
huffman_codebook_write_bit_length(file, item->bit_length);
}
bit_stream_t* stream = bit_stream_create_from_file(file);
for (const huffman_code_item_t* item = codebook->items;
item != codebook->items + codebook->num_items;
++item)
{
bit_stream_write(stream, item->code, item->bit_length);
}
stream = bit_stream_destroy_file(stream, 0);
}
void huffman_codebook_load(huffman_codebook_t* codebook, FILE* file) {
fread(&codebook->alphabet_size, 1, sizeof(codebook->alphabet_size), file);
byte_t is_context_byte = 0;
fread(&is_context_byte, 1, sizeof(is_context_byte), file);
codebook->is_context = is_context_byte;
codebook->num_items = codebook->alphabet_size;
if (codebook->is_context) {
codebook->num_items *= codebook->alphabet_size;
}
codebook->items = malloc(sizeof(*codebook->items) * codebook->num_items);
int bitfield_num_bytes = 0;
for (huffman_code_item_t* item = codebook->items;
item != codebook->items + codebook->num_items;
++item)
{
item->bit_length = huffman_codebook_read_bit_length(file);
bitfield_num_bytes += (item->bit_length + BYTE_NUM_BITS - 1) / BYTE_NUM_BITS;
}
codebook->codefield = malloc(sizeof(byte_t) * bitfield_num_bytes);
byte_t* next_code = codebook->codefield;
bit_stream_t* stream = bit_stream_create_from_file(file);
for (huffman_code_item_t* item = codebook->items;
item != codebook->items + codebook->num_items;
++item)
{
if (item->bit_length > 0) {
bit_stream_read(stream, next_code, item->bit_length);
item->code = next_code;
next_code += (item->bit_length + BYTE_NUM_BITS - 1) / BYTE_NUM_BITS;
} else {
item->code = NULL;
}
}
stream = bit_stream_destroy_file(stream, 0);
}
void huffman_codebook_destroy(huffman_codebook_t* codebook) {
free(codebook->codefield);
codebook->codefield = NULL;
free(codebook->items);
codebook->items = NULL;
codebook->alphabet_size = 0;
codebook->is_context = 0;
}
#ifdef _HUFFMAN_CODEBOOK_TEST
// #define NUM_SYMBOLS (1 << 15)
void run(int context, int num_symbols) {
printf("Starting %s test\n", context ? "context" : "non-context");
int num_items = num_symbols;
if (context) {
num_items *= num_symbols;
}
double* counts = malloc(sizeof(*counts) * num_items);
counts[0] = 0.0;
counts[1] = 1.0;
for (int i = 2; i < num_items; ++i) {
counts[i] = counts[i - 1] + counts[i - 2];
}
huffman_codebook_t codebook;
if (context) {
huffman_codebook_context_encode_init(&codebook, num_symbols, counts);
} else {
huffman_codebook_encode_init(&codebook, num_symbols, counts);
}
// printf("The longest code is %d (1<<7 = %d)\n", codebook.items[1].bit_length, 1 << 7);
FILE* f = fopen("/tmp/codebook.bin", "wb");
int x = 0;
fwrite(&x, sizeof(x), 1, f);
huffman_codebook_save(&codebook, f);
huffman_codebook_save(&codebook, f);
fclose(f);
huffman_codebook_t codebook2;
huffman_codebook_t codebook3;
f = fopen("/tmp/codebook.bin", "rb");
fread(&x, sizeof(x), 1, f);
huffman_codebook_load(&codebook2, f);
huffman_codebook_load(&codebook3, f);
fclose(f);
assert(codebook.is_context == codebook2.is_context);
assert(codebook.is_context == codebook2.is_context);
assert(codebook.alphabet_size == codebook2.alphabet_size);
assert(codebook.alphabet_size == codebook3.alphabet_size);
for (int i = 0; i < num_items; ++i) {
assert(codebook.items[i].bit_length == codebook2.items[i].bit_length);
assert(codebook.items[i].bit_length == codebook3.items[i].bit_length);
for (int bit_index = 0; bit_index < codebook.items[i].bit_length; ++bit_index) {
int byte_offset = bit_index / BYTE_NUM_BITS;
int bit_offset = bit_index % BYTE_NUM_BITS;
byte_t byte1 = codebook.items[i].code[byte_offset];
byte_t byte2 = codebook2.items[i].code[byte_offset];
byte_t byte3 = codebook3.items[i].code[byte_offset];
int bit1 = (byte1 >> (BYTE_NUM_BITS - bit_offset - 1)) & 1;
int bit2 = (byte2 >> (BYTE_NUM_BITS - bit_offset - 1)) & 1;
int bit3 = (byte3 >> (BYTE_NUM_BITS - bit_offset - 1)) & 1;
assert(bit1 == bit2);
assert(bit1 == bit3);
}
}
huffman_codebook_destroy(&codebook3);
huffman_codebook_destroy(&codebook2);
huffman_codebook_destroy(&codebook);
free(counts);
printf("OK\n\n");
}
// NOTE: max length should be greater then 0x7f = 127 to test multi-byte bit_length compression
int main() {
run(0, 1<<10);
run(1, 1<<5);
return 0;
}
#endif // _HUFFMAN_CODEBOOK_TEST
|
trukanduk/pq_huffman
|
src/fast_nn_block_loader2.h
|
<reponame>trukanduk/pq_huffman
#ifndef _FAST_NN_BLOCK_LOADER2_H_
#define _FAST_NN_BLOCK_LOADER2_H_
#include "fast_nn_block.h"
#include "fast_nn_blocks_info.h"
#include <pthread.h>
typedef struct _block_loader2 {
pthread_t* thread;
const char* input_filename;
long long num_vectors;
int num_dimensions;
const blocks_info_t* blocks_info;
int common_prefix;
int num_blocks_to_load;
block_t* blocks;
long long global_indices_capacity;
long long global_indices_size;
long long* global_indices;
} block_loader2_t;
void block_loader2_init_from_blocks(block_loader2_t* block_loader, const char* input_filename,
long long num_vectors, int num_dimensions,
const blocks_info_t* block_info, block_t* blocks,
long long num_blocks);
void block_loader2_set_common_prefix(block_loader2_t* block_loader, int common_prefix);
void block_loader2_set_start_block_id(block_loader2_t* block_loader, long long start_block);
void block_loader2_set_start_block_id_with_prefix(block_loader2_t* block_loader,
long long start_block,
int common_prefix);
void block_loader2_destroy(block_loader2_t* block_loader);
void block_loader2_start(block_loader2_t* block_loader);
void block_loader2_join(block_loader2_t* block_loader);
#endif // _FAST_NN_BLOCK_LOADER2_H_
|
trukanduk/pq_huffman
|
src/fast_nn_temp_file.h
|
#ifndef _FAST_NN_TEMP_FILE_H
#define _FAST_NN_TEMP_FILE_H
#include <stdio.h>
#include <pthread.h>
#include "misc.h"
// Max heap
// TODO: generalize and move to common code
typedef struct _nn_item {
vector_id_t index;
float dist;
} nn_item_t;
int fast_nn_heap_search_indices_collisions(nn_item_t* begin, nn_item_t* end,
const nn_item_t* item);
void fast_nn_heap_push(nn_item_t* heap, const nn_item_t* item, int num_nn);
void fast_nn_heap_sort(nn_item_t* heap, int num_nn, vector_id_t* indices, float* dists);
// Temp file
void init_temp_file(const char* temp_file_name, long long num_vectors, int num_nn);
int make_temp_file_row_size(int num_nn);
void init_empty_batch_for_temp_file(nn_item_t* batch, int num_nn, long long rows_in_batch);
void init_temp_file_batches(FILE* temp_file, long long num_vectors, int num_nn,
long long rows_in_batch);
void partial_load_temp_file(const char* temp_file_name, int num_nn, long long num_vectors_to_load,
const long long* vectors_indices_to_load,
nn_item_t* output_vectors);
void partial_save_temp_file(const char* temp_file_name, int num_nn, long long num_vectors_to_save,
const long long* vectors_indices_to_save,
nn_item_t* vectors_to_save);
typedef struct _temp_file_loader {
const char* temp_file_name;
int num_nn;
nn_item_t* vectors;
long long vectors_capacity;
long long num_vectors_to_load;
long long* vectors_indices;
pthread_t thread;
int thread_active;
} temp_file_loader_t;
void temp_file_loader_init(temp_file_loader_t* loader, const char* temp_file_name, int num_nn,
long long initial_capacity);
void _temp_file_loader_alloc_vectors(temp_file_loader_t* loader, long long capacity);
void temp_file_loader_load(temp_file_loader_t* loader, long long num_vectors_to_load,
long long* vectors_indices);
void temp_file_loader_load_join(temp_file_loader_t* loader);
void temp_file_loader_save(temp_file_loader_t* loader);
void temp_file_loader_save_join(temp_file_loader_t* loader);
void temp_file_loader_join(temp_file_loader_t* loader);
void temp_file_loader_destroy(temp_file_loader_t* loader);
void temp_file_to_result(const char* temp_file, const char* indices_file, const char* dists_file,
long long num_vectors, int num_nn);
void temp_file_to_result_batches(FILE* temp_file, FILE* indices_file, FILE* dists_file,
long long num_vectors, int num_nn, long long batch_size);
#endif // _FAST_NN_TEMP_FILE_H
|
trukanduk/pq_huffman
|
src/fast_nn_blocks_info.c
|
#include "fast_nn_blocks_info.h"
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <math.h>
#include "misc.h"
#include "vecs_io.h"
#define DATASET_ITEM_SIZE 4L
#define DATASET_DIMS_ITEM_SIZE 4L
#define NUM_ROWS_IN_BATCH 10000
#define NUM_ROWS_IN_BATCH_BATCH 500
static int make_dataset_row_size(int num_dimensions) {
return num_dimensions * DATASET_ITEM_SIZE + DATASET_DIMS_ITEM_SIZE;
}
static void load_vectors_dim_batches(FILE* input_file, long long num_vectors, int num_dimensions,
int dimension_to_load, float* output, int rows_in_batch)
{
int row_size = make_dataset_row_size(num_dimensions);
fseek(input_file, DATASET_ITEM_SIZE * dimension_to_load + DATASET_DIMS_ITEM_SIZE, SEEK_SET);
for (int i = 0; i < num_vectors; ++i) {
fread((void*) output++, 1, sizeof(*output), input_file);
fseek(input_file, row_size - DATASET_ITEM_SIZE, SEEK_CUR);
}
}
static void load_vectors_dim(const char* input_filename, long long num_vectors, int num_dimensions,
int dimension_to_load, float* output)
{
FILE* f = fopen(input_filename, "rb");
load_vectors_dim_batches(f, num_vectors, num_dimensions, dimension_to_load, output,
NUM_ROWS_IN_BATCH);
fclose(f);
}
static int float_cmp(const void* left, const void* right) {
float v = * (float*) left - * (float*) right;
if (fabs(v) < 1e-9) {
return 0;
} else if (v < 0) {
return -1;
} else {
return 1;
}
}
void dimension_info_build(block_dimension_info_t* dimension_info,
const char* input_filename, long long num_vectors, int num_dimensions,
int dimension_to_use, int num_blocks, double block_overlap_fraction)
{
float* dimension = malloc(sizeof(*dimension) * num_vectors);
load_vectors_dim(input_filename, num_vectors, num_dimensions, dimension_to_use, dimension);
qsort(dimension, num_vectors, sizeof(*dimension), float_cmp);
dimension_info->dimension = dimension_to_use;
dimension_info->num_blocks = num_blocks;
dimension_info->block_overlap_fraction = block_overlap_fraction;
dimension_info->block_id_mask = 1;
for (int i = 0; i < dimension_to_use; ++i) {
dimension_info->block_id_mask *= num_blocks;
}
dimension_info->block_starts = malloc(sizeof(*dimension_info->block_starts) * num_blocks * 2);
dimension_info->block_ends = dimension_info->block_starts + num_blocks;
printf("dim %d in [%lf, %lf], num_blocks %d, overlap %lf, mask %lld\n", dimension_to_use,
dimension[0], dimension[num_vectors - 1], num_blocks, block_overlap_fraction, dimension_info->block_id_mask);
long long num_overlapped = (long long)(num_vectors * block_overlap_fraction / 2);
for (int i = 0; i < num_blocks; ++i) {
long long start_index = num_vectors * i / num_blocks - num_overlapped;
start_index = iclampll(start_index, 0, num_vectors);
dimension_info->block_starts[i] = dimension[start_index];
long long end_index = num_vectors * (i + 1) / num_blocks + num_overlapped;
end_index = iclampll(end_index, 0, num_vectors);
dimension_info->block_ends[i] = dimension[iminll(end_index, num_vectors - 1)];
printf("start %e (%lld) end %e (%lld)\n", dimension_info->block_starts[i], start_index, dimension_info->block_ends[i], end_index);
}
dimension_info->block_starts[0] = dimension[0] - 1.0;
dimension_info->block_ends[num_blocks - 1] = dimension[num_vectors - 1] + 1.0;
for(int i = 0; i < num_blocks; ++i) {
}
free(dimension);
}
void dimension_info_destroy(block_dimension_info_t* dimension_info) {
dimension_info->dimension = -1;
free(dimension_info->block_starts);
dimension_info->block_starts = NULL;
dimension_info->block_ends = NULL;
}
void blocks_info_init(blocks_info_t* blocks_info, const char* input_filename, long long num_vectors,
int num_dimensions, int num_dimensions_to_split, int num_blocks,
double block_overlap_fraction)
{
blocks_info->num_dimensions = num_dimensions_to_split;
blocks_info->block_overlap_fraction = block_overlap_fraction;
blocks_info->num_blocks_per_dim = num_blocks;
blocks_info->dimension_infos =
malloc(sizeof(*blocks_info->dimension_infos) * num_dimensions_to_split);
blocks_info->num_blocks_total = 1;
for (int i = 0; i < num_dimensions_to_split; ++i) {
printf("Starting block info for dimension %d\n", i);
int dimension = num_dimensions_to_split - i - 1;
dimension_info_build(blocks_info->dimension_infos + i, input_filename, num_vectors,
num_dimensions, dimension, num_blocks, block_overlap_fraction);
blocks_info->num_blocks_total *= num_blocks;
}
}
void blocks_info_save_filename(const blocks_info_t* blocks_info, const char* filename) {
FILE* file = fopen(filename, "wb");
if (!file) {
fprintf(stderr, "Cannot open file: %s\n", filename);
return;
}
blocks_info_save_file(blocks_info, file);
fclose(file);
}
void blocks_info_save_file(const blocks_info_t* blocks_info, FILE* file) {
fwrite(&blocks_info->num_dimensions, 1, sizeof(blocks_info->num_dimensions), file);
fwrite(&blocks_info->block_overlap_fraction, 1, sizeof(blocks_info->block_overlap_fraction),
file);
fwrite(&blocks_info->num_blocks_per_dim, 1, sizeof(blocks_info->num_blocks_per_dim), file);
fwrite(&blocks_info->num_blocks_total, 1, sizeof(blocks_info->num_blocks_total), file);
for (int dim_index = 0; dim_index < blocks_info->num_dimensions; ++dim_index) {
const block_dimension_info_t* dimension_info = blocks_info->dimension_infos + dim_index;
fwrite(&dimension_info->dimension, 1, sizeof(dimension_info->dimension), file);
fwrite(&dimension_info->block_id_mask, 1, sizeof(dimension_info->block_id_mask), file);
fwrite(dimension_info->block_starts, dimension_info->num_blocks * 2,
sizeof(*dimension_info->block_starts), file);
}
}
int blocks_info_load_filename(blocks_info_t* blocks_info, const char* filename) {
FILE* file = fopen(filename, "rb");
if (!file) {
fprintf(stderr, "No dimensions info file: %s\n", filename);
return 0;
}
blocks_info_load_file(blocks_info, file);
fclose(file);
return 1;
}
void blocks_info_load_file(blocks_info_t* blocks_info, FILE* file) {
fread(&blocks_info->num_dimensions, 1, sizeof(blocks_info->num_dimensions), file);
fread(&blocks_info->block_overlap_fraction, 1, sizeof(blocks_info->block_overlap_fraction),
file);
fread(&blocks_info->num_blocks_per_dim, 1, sizeof(blocks_info->num_blocks_per_dim), file);
fread(&blocks_info->num_blocks_total, 1, sizeof(blocks_info->num_blocks_total), file);
blocks_info->dimension_infos = malloc(
sizeof(*blocks_info->dimension_infos) * blocks_info->num_dimensions);
for (int dim_index = 0; dim_index < blocks_info->num_dimensions; ++dim_index) {
block_dimension_info_t* dimension_info = blocks_info->dimension_infos + dim_index;
fread(&dimension_info->dimension, 1, sizeof(dimension_info->dimension), file);
dimension_info->num_blocks = blocks_info->num_blocks_per_dim;
dimension_info->block_overlap_fraction = blocks_info->block_overlap_fraction;
fread(&dimension_info->block_id_mask, 1, sizeof(dimension_info->block_id_mask), file);
dimension_info->block_starts = malloc(
sizeof(*dimension_info->block_starts) * dimension_info->num_blocks * 2);
dimension_info->block_ends = dimension_info->block_starts + dimension_info->num_blocks;
fread(dimension_info->block_starts, dimension_info->num_blocks * 2,
sizeof(*dimension_info->block_starts), file);
}
}
void blocks_info_destroy(blocks_info_t* blocks_info) {
for (int i = 0; i < blocks_info->num_dimensions; ++i) {
dimension_info_destroy(blocks_info->dimension_infos + i);
}
blocks_info->num_dimensions = 0;
blocks_info->block_overlap_fraction = 0;
blocks_info->num_blocks_total = 0;
blocks_info->num_blocks_per_dim = 0;
free(blocks_info->dimension_infos);
blocks_info->dimension_infos = NULL;
}
static int verbose = 0;
int is_vector_in_block(const float* vector, int num_dimensions, const blocks_info_t* blocks_info,
long long block_id)
{
// verbose = 1;
return is_vector_in_blocks_slice(vector, num_dimensions, blocks_info, block_id, 0,
blocks_info->num_dimensions);
}
int is_vector_in_blocks_prefix(const float* vector, int num_dimensions,
const blocks_info_t* blocks_info,
long long block_id, int prefix_length)
{
// verbose = 1;
return is_vector_in_blocks_slice(vector, num_dimensions, blocks_info, block_id, 0,
prefix_length);
}
int is_vector_in_blocks_suffix(const float* vector, int num_dimensions,
const blocks_info_t* blocks_info,
long long block_id, int prefix_length)
{
return is_vector_in_blocks_slice(vector, num_dimensions, blocks_info, block_id, prefix_length,
blocks_info->num_dimensions);
}
int is_vector_in_blocks_slice(const float* vector, int num_dimensions,
const blocks_info_t* blocks_info,
long long block_id, int start_dimension, int end_dimension)
{
verbose = 0;
if (verbose)
printf("From %d to %d: ", start_dimension, end_dimension);
const block_dimension_info_t* dimension_infos = blocks_info->dimension_infos + start_dimension;
for (int i = start_dimension; i < end_dimension; ++i, ++dimension_infos) {
float dimension_value = vector[dimension_infos->dimension];
long long dim_block_id = block_id
/ dimension_infos->block_id_mask
% blocks_info->num_blocks_per_dim;
if (verbose)
printf("(%d, %f, did=%lld, id=%lld, m=%lld) ", dimension_infos->dimension, dimension_value, dim_block_id, block_id, dimension_infos->block_id_mask);
if (dimension_value < dimension_infos->block_starts[dim_block_id]
|| dimension_value > dimension_infos->block_ends[dim_block_id])
{
if (verbose) printf("\\0\n");
verbose = 0;
return 0;
}
}
if (verbose) printf("\\1\n");
verbose = 0;
return 1;
}
|
trukanduk/pq_huffman
|
src/bitstream.c
|
#include "bitstream.h"
#include <string.h>
#include <stdlib.h>
#include <assert.h>
// #define _BITSTREAM_DEBUG
struct _bit_stream {
FILE* file;
byte_t* buffer;
int mode;
long long buffer_capacity;
long long buffer_filled_bits;
long long buffer_read_position;
};
enum {
DEFAULT_BUFFER_SIZE = 128 * 1024 * 1024,
BIT_STREAM_MODE_UNKNOWN = 0,
BIT_STREAM_MODE_READ = 1,
BIT_STREAM_MODE_WRITE = 2
};
bit_stream_t* bit_stream_create_from_file(FILE* file) {
return bit_stream_create_from_file_buffered(file, DEFAULT_BUFFER_SIZE);
}
bit_stream_t* bit_stream_create_from_file_buffered(FILE* file, long long buffer_size_bytes) {
bit_stream_t* stream = malloc(sizeof(bit_stream_t));
stream->file = file;
stream->buffer = malloc(sizeof(byte_t) * buffer_size_bytes);
stream->mode = BIT_STREAM_MODE_UNKNOWN;
stream->buffer_capacity = buffer_size_bytes * BYTE_NUM_BITS;
stream->buffer_filled_bits = 0;
stream->buffer_read_position = 0;
return stream;
}
bit_stream_t* bit_stream_destroy(bit_stream_t* stream) {
return bit_stream_destroy_file(stream, 0);
}
bit_stream_t* bit_stream_destroy_file(bit_stream_t* stream, int close_file) {
if (stream->mode == BIT_STREAM_MODE_WRITE) {
bit_stream_flush(stream, 1);
} else if (stream->mode == BIT_STREAM_MODE_READ) {
long long unused_bits = stream->buffer_filled_bits - stream->buffer_read_position;
long long pos_before = ftell(stream->file);
fseek(stream->file, - unused_bits / BYTE_NUM_BITS, SEEK_CUR);
long long pos_after = ftell(stream->file);
assert(pos_before - unused_bits / BYTE_NUM_BITS == pos_after
&& "Cannot seek back a file");
}
if (close_file) {
fclose(stream->file);
}
free(stream->buffer);
stream->buffer_capacity = 0;
stream->buffer_filled_bits = 0;
stream->buffer_read_position = 0;
free(stream);
return NULL;
}
static void bit_stream_write_impl(bit_stream_t* stream, const byte_t* data, long long bit_length) {
assert(stream->mode == BIT_STREAM_MODE_UNKNOWN || stream->mode == BIT_STREAM_MODE_WRITE);
assert(stream->buffer_filled_bits + bit_length <= stream->buffer_capacity &&
"bit_stream buffer overflow");
stream->mode = BIT_STREAM_MODE_WRITE;
long long buffer_byte = stream->buffer_filled_bits / BYTE_NUM_BITS;
int buffer_bit_offset = stream->buffer_filled_bits % BYTE_NUM_BITS;
for (long long data_bit = 0; data_bit < bit_length; ++data_bit) {
// FIXME: bit significance is platform-dependent in general. So we ca write bytes
// in reversed order for some non-standard platform.
// NOTE: write bit-by-bit to simplify the process.
byte_t data_byte = data[data_bit / BYTE_NUM_BITS];
int data_bit_offset = data_bit % BYTE_NUM_BITS;
if ((data_byte >> (BYTE_NUM_BITS - data_bit_offset - 1)) & 0x01) {
stream->buffer[buffer_byte] |= (1 << (BYTE_NUM_BITS - buffer_bit_offset - 1));
} else {
stream->buffer[buffer_byte] &= ~(1 << (BYTE_NUM_BITS - buffer_bit_offset - 1));
}
++buffer_bit_offset;
if (buffer_bit_offset == BYTE_NUM_BITS) {
buffer_bit_offset = 0;
++buffer_byte;
}
}
stream->buffer_filled_bits += bit_length;
}
int bit_stream_flush(bit_stream_t* stream, int add_pad) {
if (add_pad && stream->buffer_filled_bits % BYTE_NUM_BITS != 0) {
byte_t pad = 0;
int pad_size = BYTE_NUM_BITS - stream->buffer_filled_bits % BYTE_NUM_BITS;
bit_stream_write_impl(stream, &pad, pad_size);
assert(stream->buffer_filled_bits % BYTE_NUM_BITS == 0 &&
"bit_stream: something wrong with padding");
}
long long num_bytes_to_write = stream->buffer_filled_bits / BYTE_NUM_BITS;
long long bytes_written = fwrite(stream->buffer, sizeof(byte_t), num_bytes_to_write,
stream->file);
if (ferror(stream->file)) {
perror("bit_stream: cannot flush");
assert(0 && "bit_stream: cannot flush");
}
assert(bytes_written == num_bytes_to_write && "bit_stream: cannot flush");
if (stream->buffer_filled_bits % BYTE_NUM_BITS != 0) {
stream->buffer[0] = stream->buffer[num_bytes_to_write];
}
stream->buffer_filled_bits -= (num_bytes_to_write * BYTE_NUM_BITS);
return 1; // TODO
}
int bit_stream_write(bit_stream_t* stream, const byte_t* data, long long bit_length) {
while (bit_length > 0) {
long long batch_length = bit_length;
// imin(bit_length, stream->buffer_capacity - stream->buffer_filled_bits);
if (stream->buffer_filled_bits + batch_length > stream->buffer_capacity) {
batch_length = (stream->buffer_capacity - stream->buffer_filled_bits) / BYTE_NUM_BITS * BYTE_NUM_BITS;
}
bit_stream_write_impl(stream, data, batch_length);
if (stream->buffer_filled_bits + BYTE_NUM_BITS > stream->buffer_capacity) {
bit_stream_flush(stream, 0);
}
bit_length -= batch_length;
data += batch_length / BYTE_NUM_BITS;
}
return 1; // TODO:
}
static void bit_stream_read_buffer(bit_stream_t* stream) {
long long bytes_red = fread(stream->buffer, sizeof(byte_t),
stream->buffer_capacity / BYTE_NUM_BITS, stream->file);
stream->buffer_filled_bits = bytes_red * BYTE_NUM_BITS;
if (stream->buffer_filled_bits != stream->buffer_capacity && ferror(stream->file)) {
perror("bit_stream: error reading file");
}
if (feof(stream->file) && bytes_red == 0) {
fprintf(stderr, "bit_stream: eof\n");
exit(1);
}
stream->buffer_read_position = 0;
stream->mode = BIT_STREAM_MODE_READ;
}
void bit_stream_read(bit_stream_t* stream, byte_t* data, long long bit_length) {
for (long long bit_index = 0; bit_index < bit_length; ++bit_index) {
long long byte_offset = bit_index / BYTE_NUM_BITS;
int bit_offset = bit_index % BYTE_NUM_BITS;
int bit_value = bit_stream_read_bit(stream);
if (bit_value) {
data[byte_offset] |= (1 << (BYTE_NUM_BITS - bit_offset - 1));
} else {
data[byte_offset] &= ~(1 << (BYTE_NUM_BITS - bit_offset - 1));
}
}
}
int bit_stream_read_bit(bit_stream_t* stream) {
assert(stream->mode == BIT_STREAM_MODE_UNKNOWN || stream->mode == BIT_STREAM_MODE_READ);
if (stream->buffer_read_position == stream->buffer_filled_bits) {
bit_stream_read_buffer(stream);
if (stream->buffer_read_position == stream->buffer_filled_bits) {
return EOF;
}
}
long long byte_num = stream->buffer_read_position / BYTE_NUM_BITS;
int bit_num = stream->buffer_read_position % BYTE_NUM_BITS;
++stream->buffer_read_position;
return (stream->buffer[byte_num] >> (BYTE_NUM_BITS - bit_num - 1)) & 0x01;
}
#ifdef _BITSTREAM_TEST
int main() {
FILE* f = fopen("/tmp/foo.bin", "wb");
bit_stream_t* stream = bit_stream_create_from_file_buffered(f, 2);
byte_t data[7] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde};
bit_stream_write(stream, data, 4); // 0x1
bit_stream_write(stream, data + 1, 12); // 0x345
bit_stream_write(stream, data + 3, 28); // 0x789abcd
stream = bit_stream_destroy(stream);
fclose(f);
// return 0;
f = fopen("/tmp/foo.bin", "rb");
stream = bit_stream_create_from_file_buffered(f, 2);
char got_str[4 + 12 + 28 + 1];
int str_index = 0;
int bit;
while ((bit = bit_stream_read_bit(stream)) != EOF) {
got_str[str_index++] = '0' + bit;
}
got_str[str_index] = '\0';
printf("Red %d bits: '%s'\n", str_index, got_str);
// 2 3 4 6 7 8 9 a b c d pad
assert(!strcmp(&got_str[0], "000100110100010101111000100110101011110011010000"));
assert(bit_stream_read_bit(stream) == EOF);
stream = bit_stream_destroy(stream);
fclose(f);
return 0;
}
#endif // _BITSTREAM_TEST
|
trukanduk/pq_huffman
|
src/misc.h
|
#ifndef _HUFFMAN_MISC_H
#define _HUFFMAN_MISC_H
typedef unsigned int vector_id_t;
int imin(int a, int b);
long long iminll(long long a, long long b);
long long iclampll(long long value, long long min_value, long long max_value);
// NOTE: Allocates with malloc
char* concat(const char* prefix, const char* suffix);
long long load_num_elements(const char* filename, long long element_size);
#ifndef __linux__
# error "need usleep function!"
#endif
#include <unistd.h>
int usleep(unsigned usec);
#define MS 1000
typedef unsigned char byte_t;
#endif // _HUFFMAN_MISC_H
|
trukanduk/pq_huffman
|
src/huffman.h
|
#ifndef _HUFFMAN_H
#define _HUFFMAN_H
#include "bitstream.h"
enum {
HUFFMAN_NO_SYMBOL = -1,
HUFFMAN_INVALID_SYMBOL = -2
};
typedef struct _huffman_decoder huffman_decoder_t;
typedef struct _huffman_code_item {
const byte_t* code;
int bit_length;
} huffman_code_item_t;
typedef struct _huffman_codebook {
byte_t* codefield;
int alphabet_size;
int is_context;
int num_items; // NOTE: = alphabet_size * (is_context ? alphabet_size : 1)
huffman_code_item_t* items;
} huffman_codebook_t;
// NOTE: Debug functions:
void huffman_dump_code(const huffman_code_item_t* item, FILE* f);
void huffman_codebook_dump(const huffman_codebook_t* codebook, FILE* f);
void huffman_counts_context_dump(const double* symbol_counts, int alphabet_size, FILE* f);
void huffman_codebook_save(const huffman_codebook_t* codebook, FILE* file);
void huffman_codebook_load(huffman_codebook_t* codebook, FILE* file);
void huffman_codebook_encode_init(huffman_codebook_t* codebook, int alphabet_size, const double* symbol_counts);
void huffman_codebook_context_encode_init(huffman_codebook_t* codebook, int alphabet_size, const double* symbol_counts);
void huffman_codebook_destroy(huffman_codebook_t* codebook);
double huffman_estimate_size(const huffman_codebook_t* codebook, const double* symbol_counts);
huffman_decoder_t* huffman_decoder_create(const huffman_codebook_t* codebook);
huffman_decoder_t* huffman_decoder_destroy(huffman_decoder_t* decoder); // NOTE: returns NULL
void huffman_decoder_reset(huffman_decoder_t* decoder);
void huffman_decoder_set_prev_symbol(huffman_decoder_t* decoder, int prev_symbol);
int huffman_decoder_push_bit(huffman_decoder_t* decoder, int bit_value);
int huffman_decoder_push_bits(huffman_decoder_t* decoder, const byte_t* bits, int bit_length);
int huffman_decoder_read_symbol(huffman_decoder_t* decoder, bit_stream_t* stream);
#endif // _HUFFMAN_H
|
trukanduk/pq_huffman
|
src/prepend_vecsl_meta.c
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "vecs_io.h"
enum {
XVECSL_SUFFIX_LENGTH = 7 // .xvecsl
};
int main(int argc, const char* argv[]) {
if (argc < 4) {
fprintf(stderr, "Usage: %s <filename> <num_vectors> <num_dimensions>\n", argv[0]);
return 1;
}
const char* filename = argv[1];
int num_vectors = atoi(argv[2]);
int num_dimensions = atoi(argv[3]);
int filename_length = strlen(filename);
const char* extension = filename + filename_length - XVECSL_SUFFIX_LENGTH;
assert(extension[0] == '.');
assert(!strcmp(extension + 2, "vecsl"));
char vecs_type = extension[1];
long long element_size = 0;
if (vecs_type == 'i' || vecs_type == 'f') {
element_size = 4;
} else if (vecs_type == 'l') {
element_size = 8;
} else if (vecs_type == 'b') {
element_size = 1;
} else {
fprintf(stderr, "Unknown extension type: '%s'\n", extension);
return 1;
}
FILE* f = fopen(filename, "rb");
if (!f) {
fprintf(stderr, "File %s not found\n", filename);
return 1;
}
long long num_elements = 1LL * num_vectors * num_dimensions;
fseek(f, 0, SEEK_END);
long long file_size = ftell(f);
if (file_size == num_elements * element_size + 8) {
printf("File %s already processed\n", filename);
return 0;
} else if (file_size != num_elements * element_size) {
fprintf(stderr, "Invalid size/dimension of file %s. File size if %lld (expected %lld)\n",
filename, file_size, num_elements * element_size);
return 1;
}
fseek(f, 0, SEEK_SET);
byte_t* data = malloc(element_size * num_vectors * num_dimensions);
long long got_elements = fread(data, element_size, num_elements, f);
if (got_elements != num_elements) {
fprintf(stderr, "Cannot read enough data from %s: requested %lld, got %lld",
filename, num_elements, got_elements);
return 1;
}
fclose(f);
f = fopen(filename, "wb");
save_vecs_light_meta_file(f, num_vectors, num_dimensions);
fwrite(data, element_size, num_elements, f);
fclose(f);
return 0;
}
|
trukanduk/pq_huffman
|
src/mst_builder.c
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mst.h"
#include "misc.h"
#include "vecs_io.h"
typedef struct _config {
const char* nn_input_template;
const char* pq_input_template; // NOTE: May be null - if no pq penalties expected
const char* output_template;
int num_nn_to_load;
float pq_penalty; // NOTE: Not used by now
char* nn_indices_filename;
char* nn_dist_filename;
char* pq_indices_filename; // NOTE: May be null
char* output_tree_filename;
char* output_stats_filename;
char* output_stats_num_children_filename;
long long num_vectors;
int pq_m; // NOTE: Used only iff pq_input_template is given
} config_t;
static void print_help(const char* argv0) {
fprintf(stderr, "Usage: %s <nn-input-template> <output-template> <num-nn-to-use>"
" [--pq-template <pq output template>]"
" [--pq-penalty <pq penalty size>]\n", argv0);
exit(1);
}
static void parse_args(config_t* config, int argc, const char* argv[]) {
if (argc < 4) {
fprintf(stderr, "Too few arguments\n");
print_help(argv[0]);
}
config->nn_input_template = argv[1];
config->output_template = argv[2];
config->num_nn_to_load = atoi(argv[3]);
config->pq_input_template = NULL;
config->pq_penalty = 0.0;
for (const char** arg = argv + 4; *arg; ++arg) {
if (!strcmp(*arg, "--pq-template")) {
++arg;
config->pq_input_template = *arg;
} else if (!strcmp(*arg, "--pq-penalty")) {
++arg;
config->pq_penalty = atof(*arg);
} else {
fprintf(stderr, "Unknown argument: %s\n", *arg);
print_help(argv[0]);
}
}
config->nn_indices_filename = concat(config->nn_input_template, "nn_indices.ivecsl");
config->nn_dist_filename = concat(config->nn_input_template, "nn_dist.fvecsl");
if (config->pq_input_template) {
config->pq_indices_filename = concat(config->pq_input_template, "pq_indices.bvecsl");
config->pq_m = load_vecs_num_dimensions_filename(config->pq_indices_filename);
}
config->output_tree_filename = concat(config->output_template, "mst.tree");
config->output_stats_filename = concat(config->output_template, "stats.json");
config->output_stats_num_children_filename = concat(config->output_template,
"stats_num_children.json");
config->num_vectors = load_vecs_num_vectors_filename(config->nn_indices_filename);
}
static void config_destroy(config_t* config) {
config->num_vectors = 0;
config->pq_m = 0;
free(config->nn_indices_filename);
config->nn_indices_filename = NULL;
free(config->nn_dist_filename);
config->nn_dist_filename = NULL;
free(config->pq_indices_filename);
config->pq_indices_filename = NULL;
free(config->output_tree_filename);
config->output_tree_filename = NULL;
free(config->output_stats_filename);
config->output_stats_filename = NULL;
free(config->output_stats_num_children_filename);
config->output_stats_num_children_filename = NULL;
}
static void run(const config_t* config) {
byte_t* pq_indices = NULL;
if (config->pq_indices_filename) {
pq_indices = load_vecs_light_filename(config->pq_indices_filename, sizeof(byte_t),
NULL, NULL);
}
mst_edge_t* edges = load_mst_edges_from_nn_filenames(config->num_vectors,
config->num_nn_to_load, config->pq_m,
config->pq_penalty, pq_indices,
config->nn_indices_filename,
config->nn_dist_filename);
tree_t tree;
minimum_spanning_tree(&tree, config->num_vectors, config->num_nn_to_load, edges);
free(edges);
edges = NULL;
tree_save_filename(&tree, config->output_tree_filename);
huffman_stats_t indices_stats;
huffman_stats_t children_stats;
tree_estimate_huffman_encoding(&indices_stats, &children_stats, &tree, config->pq_m,
pq_indices);
huffman_stats_print(&indices_stats);
huffman_stats_print_filename(&indices_stats, config->output_stats_filename);
huffman_stats_print_filename(&children_stats, config->output_stats_num_children_filename);
huffman_stats_destroy(&indices_stats);
huffman_stats_destroy(&children_stats);
if (pq_indices) {
free(pq_indices);
pq_indices = NULL;
}
}
int main(int argc, const char* argv[]) {
config_t config;
parse_args(&config, argc, argv);
run(&config);
config_destroy(&config);
return 0;
}
|
trukanduk/pq_huffman
|
src/fast_nn_blocks_info.h
|
<reponame>trukanduk/pq_huffman
#ifndef _FAST_NN_BLOCKS_INFO_H_
#define _FAST_NN_BLOCKS_INFO_H_
#include "fast_nn_block.h"
#include <stdio.h>
typedef struct _block_dimension_info {
int dimension;
int num_blocks;
double block_overlap_fraction;
long long block_id_mask;
float* block_starts;
float* block_ends;
} block_dimension_info_t;
typedef struct _blocks_info {
int num_dimensions;
double block_overlap_fraction;
int num_blocks_per_dim;
long long num_blocks_total;
block_dimension_info_t* dimension_infos;
} blocks_info_t;
void dimension_info_build(block_dimension_info_t* dimension_info, const char* input_filename,
long long num_vectors, int num_dimensions, int dimension_to_use,
int num_blocks, double block_overlap_fraction);
void dimension_info_destroy(block_dimension_info_t* dimension_info);
void blocks_info_init(blocks_info_t* blocks_info, const char* input_filename, long long num_vectors,
int num_dimensions, int num_dimensions_to_split, int num_blocks,
double block_overlap_fraction);
void blocks_info_save_filename(const blocks_info_t* blocks_info, const char* filename);
void blocks_info_save_file(const blocks_info_t* blocks_info, FILE* file);
int blocks_info_load_filename(blocks_info_t* blocks_info, const char* filename);
void blocks_info_load_file(blocks_info_t* blocks_info, FILE* file);
void blocks_info_destroy(blocks_info_t* blocks_info);
int is_vector_in_block(const float* vector, int num_dimensions, const blocks_info_t* blocks_info,
long long block_id);
int is_vector_in_blocks_prefix(const float* vector, int num_dimensions,
const blocks_info_t* blocks_info, long long block_id,
int prefix_length);
int is_vector_in_blocks_suffix(const float* vector, int num_dimensions,
const blocks_info_t* blocks_info, long long block_id,
int prefix_length);
int is_vector_in_blocks_slice(const float* vector, int num_dimensions,
const blocks_info_t* blocks_info, long long block_id,
int start_dimension, int end_dimension);
#endif // _FAST_NN_BLOCKS_INFO_H_
|
trukanduk/pq_huffman
|
src/huffman_encode.c
|
#include "huffman.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct _huffman_encoding_tree_node {
double sum_count;
int symbol_id; // NOTE: -1 if is not leaf
struct _huffman_encoding_tree_node* children[2];
} huffman_encoding_tree_node_t;
typedef struct _huffman_encoding_heap {
huffman_encoding_tree_node_t** elements;
int size;
int capacity;
} huffman_encoding_heap_t;
static void huffman_heap_init(huffman_encoding_heap_t* heap, int capacity) {
heap->capacity = capacity;
heap->size = 0;
heap->elements = calloc(sizeof(huffman_encoding_tree_node_t*), capacity);
}
static void huffman_heap_destroy(huffman_encoding_heap_t* heap) {
free(heap->elements);
heap->elements = NULL;
heap->capacity = 0;
heap->size = 0;
}
static void huffman_encoding_heap_push(huffman_encoding_heap_t* heap,
huffman_encoding_tree_node_t* element) {
int index = heap->size++;
while (index > 0) {
int parent_index = (index + 1) / 2 - 1;
if (element->sum_count >= heap->elements[parent_index]->sum_count) {
break;
}
heap->elements[index] = heap->elements[parent_index];
index = parent_index;
}
heap->elements[index] = element;
}
static huffman_encoding_tree_node_t* huffman_encoding_heap_pop(huffman_encoding_heap_t* heap) {
huffman_encoding_tree_node_t* result = heap->elements[0];
huffman_encoding_tree_node_t* push_node = heap->elements[--heap->size];
int index = 0;
while (index < heap->size) {
int left_child = (index + 1) * 2 - 1;
int right_child = (index + 1) * 2;
if (left_child < heap->size
&& push_node->sum_count > heap->elements[left_child]->sum_count
&& (right_child >= heap->size
|| heap->elements[left_child]->sum_count <= heap->elements[right_child]->sum_count))
{
heap->elements[index] = heap->elements[left_child];
index = left_child;
} else if (right_child < heap->size
&& push_node->sum_count > heap->elements[right_child]->sum_count
&& heap->elements[right_child]->sum_count
<= heap->elements[left_child]->sum_count)
{
heap->elements[index] = heap->elements[right_child];
index = right_child;
} else {
break;
}
}
heap->elements[index] = push_node;
return result;
}
static void huffman_encoding_traverse_tree_collect_statistics(huffman_encoding_tree_node_t* node,
int current_depth,
int* sum_length_bytes,
int* max_length_bytes) {
if (!node) {
return;
}
if (node->symbol_id != HUFFMAN_NO_SYMBOL) {
int current_length_bytes = (current_depth + BYTE_NUM_BITS - 1) / BYTE_NUM_BITS;
*sum_length_bytes += current_length_bytes;
if (*max_length_bytes < current_length_bytes) {
*max_length_bytes = current_length_bytes;
}
} else {
huffman_encoding_traverse_tree_collect_statistics(node->children[0], current_depth + 1,
sum_length_bytes, max_length_bytes);
huffman_encoding_traverse_tree_collect_statistics(node->children[1], current_depth + 1,
sum_length_bytes, max_length_bytes);
}
}
static void huffman_encoding_traverse_tree_collect_codes(huffman_codebook_t* codebook,
int items_offset,
int* code_byte_start,
huffman_encoding_tree_node_t* node,
int current_depth,
byte_t* current_code) {
if (!node) {
return;
}
if (node->symbol_id != HUFFMAN_NO_SYMBOL) {
int code_length_bytes = (current_depth + BYTE_NUM_BITS - 1) / BYTE_NUM_BITS;
memcpy(codebook->codefield + *code_byte_start, current_code, code_length_bytes);
codebook->items[items_offset + node->symbol_id].code =
codebook->codefield + *code_byte_start;
codebook->items[items_offset + node->symbol_id].bit_length = current_depth;
*code_byte_start += code_length_bytes;
} else {
int code_byte = current_depth / BYTE_NUM_BITS;
int code_bit = current_depth % BYTE_NUM_BITS;
// NOTE: start with 1 to keep zero in current bit after done
current_code[code_byte] |= (1 << (BYTE_NUM_BITS - code_bit - 1));
huffman_encoding_traverse_tree_collect_codes(codebook, items_offset, code_byte_start,
node->children[1], current_depth + 1,
current_code);
current_code[code_byte] &= ~(1 << (BYTE_NUM_BITS - code_bit - 1));
huffman_encoding_traverse_tree_collect_codes(codebook, items_offset, code_byte_start,
node->children[0], current_depth + 1,
current_code);
}
}
typedef struct _huffman_encoder_impl {
int alphabet_size;
huffman_encoding_tree_node_t* tree_nodes;
// huffman_encoding_heap_t heap;
huffman_encoding_tree_node_t* root_node;
} huffman_encoder_impl_t;
static void huffman_codebook_init_encoder(huffman_encoder_impl_t* encoder, int alphabet_size,
const double* symbol_counts) {
int num_nodes = 2 * alphabet_size - 1;
encoder->alphabet_size = alphabet_size;
encoder->tree_nodes = malloc(sizeof(huffman_encoding_tree_node_t) * num_nodes);
huffman_encoding_heap_t heap;
huffman_heap_init(&heap, alphabet_size);
for (int node_index = 0; node_index < num_nodes; ++node_index) {
// NOTE: Create node for zero symbols but don't push them to queue
encoder->tree_nodes[node_index].children[0] = NULL;
encoder->tree_nodes[node_index].children[1] = NULL;
if (node_index < alphabet_size) {
encoder->tree_nodes[node_index].sum_count = symbol_counts[node_index];
encoder->tree_nodes[node_index].symbol_id = node_index;
if (symbol_counts[node_index] > 0.0f) {
huffman_encoding_heap_push(&heap, &encoder->tree_nodes[node_index]);
}
} else {
encoder->tree_nodes[node_index].sum_count = 0.0;
encoder->tree_nodes[node_index].symbol_id = HUFFMAN_NO_SYMBOL;
}
}
int used_nodes = alphabet_size;
if (heap.size == 1) {
// NOTE: Special case: no iterations will be performed,
// but we want to have at least one bit to simplify the process
huffman_encoding_tree_node_t* leaf_node = huffman_encoding_heap_pop(&heap);
huffman_encoding_tree_node_t* new_node = &encoder->tree_nodes[used_nodes++];
new_node->sum_count = leaf_node->sum_count;
new_node->children[0] = leaf_node;
huffman_encoding_heap_push(&heap, new_node);
}
while (heap.size > 1) {
huffman_encoding_tree_node_t* zero_node = huffman_encoding_heap_pop(&heap);
huffman_encoding_tree_node_t* one_node = huffman_encoding_heap_pop(&heap);
huffman_encoding_tree_node_t* new_node = &encoder->tree_nodes[used_nodes++];
new_node->sum_count = zero_node->sum_count + one_node->sum_count;
new_node->children[0] = zero_node;
new_node->children[1] = one_node;
huffman_encoding_heap_push(&heap, new_node);
}
encoder->root_node = heap.elements[0];
huffman_heap_destroy(&heap);
}
static void huffman_codebook_encoder_free(huffman_encoder_impl_t* encoder) {
if (encoder->tree_nodes) {
free(encoder->tree_nodes);
encoder->tree_nodes = NULL;
}
encoder->root_node = NULL;
}
static void huffman_codebook_init_items(huffman_codebook_t* codebook) {
codebook->items = malloc(codebook->num_items * sizeof(*codebook->items));
for (int symbol_id = 0; symbol_id < codebook->num_items; ++symbol_id) {
codebook->items[symbol_id].bit_length = 0;
codebook->items[symbol_id].code = NULL;
}
}
void huffman_codebook_encode_init(huffman_codebook_t* codebook, int alphabet_size,
const double* symbol_counts) {
huffman_encoder_impl_t encoder;
huffman_codebook_init_encoder(&encoder, alphabet_size, symbol_counts);
int bytes_to_allocate = 0;
int longest_code_bytes = 0;
huffman_encoding_traverse_tree_collect_statistics(encoder.root_node, 0, &bytes_to_allocate,
&longest_code_bytes);
codebook->codefield = malloc(bytes_to_allocate * sizeof(byte_t));
codebook->alphabet_size = alphabet_size;
codebook->is_context = 0;
codebook->num_items = alphabet_size;
huffman_codebook_init_items(codebook);
int code_byte_start = 0;
byte_t* current_code = calloc(sizeof(*current_code), longest_code_bytes);
huffman_encoding_traverse_tree_collect_codes(codebook, 0, &code_byte_start, encoder.root_node,
0, current_code);
free(current_code);
current_code = NULL;
huffman_codebook_encoder_free(&encoder);
}
void huffman_codebook_context_encode_init(huffman_codebook_t* codebook, int alphabet_size,
const double* symbol_counts) {
huffman_encoder_impl_t* encoders = malloc(sizeof(*encoders) * alphabet_size);
for (int encoder_index = 0; encoder_index < alphabet_size; ++encoder_index) {
huffman_codebook_init_encoder(encoders + encoder_index, alphabet_size,
symbol_counts + encoder_index * alphabet_size);
}
int bytes_to_allocate = 0;
int longest_code_bytes = 0;
for (int encoder_index = 0; encoder_index < alphabet_size; ++encoder_index) {
huffman_encoding_traverse_tree_collect_statistics(encoders[encoder_index].root_node, 0,
&bytes_to_allocate, &longest_code_bytes);
}
codebook->codefield = malloc(bytes_to_allocate * sizeof(byte_t));
codebook->alphabet_size = alphabet_size;
codebook->is_context = 1;
codebook->num_items = alphabet_size * alphabet_size;
huffman_codebook_init_items(codebook);
int code_byte_start = 0;
byte_t* current_code = calloc(sizeof(*current_code), longest_code_bytes);
for (int encoder_index = 0; encoder_index < alphabet_size; ++encoder_index) {
huffman_encoding_traverse_tree_collect_codes(codebook, encoder_index * alphabet_size,
&code_byte_start,
encoders[encoder_index].root_node,
0, current_code);
}
free(current_code);
current_code = NULL;
for (int encoder_index = 0; encoder_index < alphabet_size; ++encoder_index) {
huffman_codebook_encoder_free(encoders + encoder_index);
}
}
double huffman_estimate_size(const huffman_codebook_t* codebook, const double* symbol_counts) {
double result = 0;
for (int symbol_id = 0; symbol_id < codebook->num_items; ++symbol_id) {
result += symbol_counts[symbol_id] * codebook->items[symbol_id].bit_length;
}
return result;
}
#ifdef _HUFFMAN_ENCODE_TEST
#define NUM_SYMBOLS 10
static void run_test(int context, int num_nonzero_elements, int verbose) {
double counts[NUM_SYMBOLS * NUM_SYMBOLS] = {0.0, 21.0, 13.0, 8.0, 5.0, 3.0, 2.0, 1.0, 1.0, 0.0};
if (num_nonzero_elements < 3 && num_nonzero_elements >= 0) { // NOTE: zero, one, two, many!
for (int i = num_nonzero_elements + 1; i < NUM_SYMBOLS; ++i) {
counts[i] = 0.0;
}
}
if (context) {
for (int i = NUM_SYMBOLS; i < NUM_SYMBOLS * NUM_SYMBOLS; ++i) {
counts[i] = counts[i - NUM_SYMBOLS + 1];
}
}
huffman_codebook_t codebook;
if (context) {
huffman_codebook_context_encode_init(&codebook, NUM_SYMBOLS, &counts[0]);
} else {
huffman_codebook_encode_init(&codebook, NUM_SYMBOLS, &counts[0]);
}
assert(NUM_SYMBOLS * (context ? NUM_SYMBOLS : 1) == codebook.num_items);
if (verbose) {
huffman_codebook_dump(&codebook, stdout);
}
huffman_codebook_destroy(&codebook);
}
int main(int argc, const char* argv[]) {
int verbose = argv[1] && (!strcmp(argv[1], "--verbose") || !strcmp(argv[1], "-v"));
run_test(0, -1, verbose);
run_test(0, 1, verbose);
run_test(0, 0, verbose);
run_test(1, -1, verbose);
return 0;
}
#undef NUM_SYMBOLS
#endif // _HUFFMAN_ENCODE_TEST
|
trukanduk/pq_huffman
|
src/fast_nn_block.h
|
#ifndef _FAST_NN_BLOCK_H_
#define _FAST_NN_BLOCK_H_
typedef struct _block {
long long id;
int num_dimensions;
long long capacity;
long long* indices;
float* data;
long long size;
} block_t;
enum {
BLOCK_INIT_WITH_DATA = 0x01,
BLOCK_INIT_WITH_INDICES = 0x02,
BLOCK_INIT_ALL = 0xff
};
void block_init(block_t* block, long long block_id, int num_dimensions, long long initial_capacity,
int init_flags);
void block_destroy(block_t* block);
void block_push(block_t* block, long long index, const float* vector);
void block_realloc(block_t* block, long long new_capacity);
void block_set_id(block_t* block, long long block_id);
#endif // _FAST_NN_BLOCK_H_
|
trukanduk/pq_huffman
|
src/vecs_io.c
|
<filename>src/vecs_io.c<gh_stars>1-10
#include "vecs_io.h"
#include <assert.h>
#include <stdlib.h>
typedef unsigned int header_item_t;
byte_t* load_vecs_light_filename(const char* filename, size_t element_size,
long long* num_elements_out, int* num_dimensions_out) {
FILE* f = fopen(filename, "rb");
byte_t* result = load_vecs_light_file(f, element_size, num_elements_out, num_dimensions_out);
fclose(f);
return result;
}
byte_t* load_vecs_light_file(FILE* file, size_t element_size,
long long* num_elements_out, int* num_dimensions_out)
{
long long num_elements;
int num_dimensions;
load_vecs_light_meta_file(file, &num_elements, &num_dimensions);
if (num_elements_out) {
*num_elements_out = num_elements;
}
if (num_dimensions_out) {
*num_dimensions_out = num_dimensions;
}
byte_t* data = malloc(element_size * num_elements * num_dimensions);
long long got_bytes = fread(data, element_size, num_elements * num_dimensions, file);
assert(got_bytes == num_elements * num_dimensions);
return data;
}
void load_vecs_light_meta_filename(const char* filename, long long* num_elements_out,
int* num_dimensions_out) {
FILE* f = fopen(filename, "rb");
load_vecs_light_meta_file(f, num_elements_out, num_dimensions_out);
fclose(f);
}
void load_vecs_light_meta_file(FILE* file, long long* num_elements_out,
int* num_dimensions_out) {
header_item_t num_elements = 0; // NOTE: Should be replaced with long long in future
fread(&num_elements, sizeof(num_elements), 1, file);
if (num_elements_out) {
*num_elements_out = num_elements;
}
header_item_t num_dimensions = 0;
fread(&num_dimensions, sizeof(num_dimensions), 1, file);
if (num_dimensions_out) {
*num_dimensions_out = num_dimensions;
}
}
long long load_vecs_num_vectors_filename(const char* filename) {
long long result = 0;
load_vecs_light_meta_filename(filename, &result, NULL);
return result;
}
int load_vecs_num_dimensions_filename(const char* filename) {
int result = 0;
load_vecs_light_meta_filename(filename, NULL, &result);
return result;
}
void save_vecs_light_meta_file(FILE* file, long long num_elements, int num_dimensions) {
header_item_t num_elements_item = num_elements;
fwrite(&num_elements_item, sizeof(num_elements_item), 1, file);
header_item_t num_dimensions_item = num_dimensions;
fwrite(&num_dimensions_item, sizeof(num_dimensions_item), 1, file);
}
|
trukanduk/pq_huffman
|
src/nn_huffman_estimator.c
|
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "bitstream.h"
#include "huffman.h"
#include "stats.h"
#include "misc.h"
#include "vecs_io.h"
typedef struct _config {
const char* pq_input_template;
const char* nn_input_template;
const char* output_template;
int m;
int k_star;
char* pq_input_indices;
char* nn_input_indices;
char* output_stats;
long long num_vectors;
int num_nn;
} config_t;
static void print_help(const char* argv0) {
fprintf(stderr, "Usage: %s <pq-input-template> <nn-input-template>"
" <output-template> <m>\n", argv0);
exit(1);
}
static void parse_args(config_t* config, int argc, const char* argv[]) {
if (argc < 5) {
fprintf(stderr, "Too few positional arguments\n");
print_help(argv[0]);
}
config->pq_input_template = argv[1];
config->nn_input_template = argv[2];
config->output_template = argv[3];
config->m = atoi(argv[4]);
config->k_star = (1 << 8); // TODO:
config->pq_input_indices = concat(config->pq_input_template, "pq_indices.bvecsl");
config->nn_input_indices = concat(config->nn_input_template, "nn_indices.ivecsl");
config->output_stats = concat(config->output_template, "huffman_stats.txt");
load_vecs_light_meta_filename(config->nn_input_indices, &config->num_vectors, &config->num_nn);
}
static void config_free(config_t* config) {
if (config->pq_input_indices) {
free(config->pq_input_indices);
config->pq_input_indices = NULL;
}
if (config->nn_input_indices) {
free(config->nn_input_indices);
config->nn_input_indices = NULL;
}
if (config->output_stats) {
free(config->output_stats);
config->output_stats = NULL;
}
}
static long long collect_stats_at_kth_nn(const config_t* config, const byte_t* pq_indices,
const vector_id_t* nn_indices, double* stats,
int nn_index) {
long long num_stats_per_codebook = config->k_star * config->k_star;
long long num_stats_per_nn = config->m * num_stats_per_codebook;
for (int i = 0; i < num_stats_per_nn; ++i) {
stats[i] = 0.0;
}
const vector_id_t* nn_it;
const byte_t* source_vector_it;
long long num_known = 0;
for (nn_it = nn_indices, source_vector_it = pq_indices;
source_vector_it != pq_indices + config->m * config->num_vectors;
nn_it += config->num_nn, source_vector_it += config->m)
{
if (nn_it[nn_index] == -1) {
continue;
}
++num_known;
const byte_t* target_vector = pq_indices + config->m * nn_it[nn_index];
for (int i = 0; i < config->m; ++i) {
double* codebook_stats = stats + num_stats_per_codebook * i;
codebook_stats[source_vector_it[i] * config->k_star + target_vector[i]] += 1;
}
}
for (int i = 0; i < config->m; ++i) {
double stats_sum = 0.0;
for (double* stat_it = stats + num_stats_per_codebook * i;
stat_it != stats + num_stats_per_codebook * (i + 1);
++stat_it)
{
stats_sum += *stat_it;
}
assert((long long) stats_sum == num_known);
}
return num_known;
}
static void run(const config_t* config) {
long long data_size = config->m * config->num_vectors;
long long num_vectors_pq;
int pq_m;
byte_t* pq_indices = load_vecs_light_filename(config->pq_input_indices, sizeof(byte_t),
&num_vectors_pq, &pq_m);
assert(num_vectors_pq == config->num_vectors);
assert(pq_m == config->m);
long long num_vectors_nn;
int num_nn;
vector_id_t* nn_indices = (vector_id_t*) load_vecs_light_filename(config->nn_input_indices,
sizeof(vector_id_t),
&num_vectors_nn,
&num_nn);
assert(num_vectors_nn == config->num_vectors);
assert(num_nn == config->num_nn);
FILE* stats_file = fopen(config->output_stats, "a");
fprintf(stats_file, "[");
double* stats = malloc(sizeof(*stats) * config->m * config->k_star * config->k_star);
huffman_codebook_t* codebooks = malloc(sizeof(*codebooks) * config->m);
for (int nn_index = 0; nn_index < config->num_nn; ++nn_index) {
long long num_known_vectors = collect_stats_at_kth_nn(config, pq_indices, nn_indices,
stats, nn_index);
huffman_stats_t encode_stats;
huffman_stats_init(&encode_stats, config->num_vectors, config->m, config->k_star);
for (int part_index = 0; part_index < config->m; ++part_index) {
double* stats_part = stats + config->k_star * config->k_star * part_index;
huffman_codebook_t* codebook = codebooks + part_index;
huffman_codebook_context_encode_init(codebook, config->k_star, stats_part);
double estimation = huffman_estimate_size(codebook, stats_part);
estimation += 8 * (config->num_vectors - num_known_vectors);
huffman_stats_push(&encode_stats, part_index, estimation);
}
huffman_stats_print(&encode_stats);
huffman_stats_print_file(&encode_stats, stats_file);
huffman_stats_destroy(&encode_stats);
for (int part_index = 0; part_index < config->m; ++part_index) {
huffman_codebook_destroy(codebooks + part_index);
}
fprintf(stats_file, ", ");
printf("\n");
}
fprintf(stats_file, "]\n");
fclose(stats_file);
stats_file = NULL;
free(stats);
free(pq_indices);
free(nn_indices);
}
int main(int argc, const char* argv[]) {
srand(time(NULL));
config_t config;
parse_args(&config, argc, argv);
run(&config);
config_free(&config);
return 0;
}
|
ticky/gstest
|
gstest.c
|
<filename>gstest.c
#include <stdio.h>
#include <malloc.h>
#include <gsKit.h>
#include <dmaKit.h>
#include <gsToolkit.h>
int main(int argc, char *argv[]) {
GSGLOBAL *gsGlobal = gsKit_init_global();
// Initialise DMAKit
dmaKit_init(
D_CTRL_RELE_OFF,
D_CTRL_MFD_OFF,
D_CTRL_STS_UNSPEC,
D_CTRL_STD_OFF,
D_CTRL_RCYC_8,
1 << DMA_CHANNEL_GIF
);
// Initialise the DMAKit's channel
dmaKit_chan_init(DMA_CHANNEL_GIF);
// gsGlobal->BGColor->Red = 0x87;
// gsGlobal->BGColor->Green = 0x47;
// gsGlobal->BGColor->Blue = 0xbd;
gsKit_init_screen(gsGlobal);
gsKit_mode_switch(gsGlobal, GS_PERSISTENT);
u64 myColor = GS_SETREG_RGBAQ(0x87,0x47,0xbd,0x00,0x00);
gsKit_clear(gsGlobal, myColor);
gsKit_mode_switch(gsGlobal, GS_ONESHOT);
gsKit_queue_exec(gsGlobal);
gsKit_sync_flip(gsGlobal);
gsKit_deinit_global(gsGlobal);
return 0;
}
|
Setonas/setonas
|
Python/importlib.h
|
<reponame>Setonas/setonas
/* Auto-generated by Modules/_freeze_importlib.c */
const unsigned char _Py_M__importlib[] = {
99,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
0,64,0,0,0,115,231,4,0,0,100,0,0,90,0,0,
100,164,0,90,1,0,100,4,0,100,5,0,132,0,0,90,
2,0,100,6,0,100,7,0,132,0,0,90,3,0,100,8,
0,100,9,0,132,0,0,90,4,0,100,10,0,100,11,0,
132,0,0,90,5,0,100,12,0,100,13,0,132,0,0,90,
6,0,100,14,0,100,15,0,132,0,0,90,7,0,100,16,
0,100,17,0,132,0,0,90,8,0,100,18,0,100,19,0,
132,0,0,90,9,0,100,20,0,100,21,0,132,0,0,90,
10,0,100,22,0,100,23,0,100,24,0,132,1,0,90,11,
0,100,25,0,100,26,0,132,0,0,90,12,0,100,27,0,
100,28,0,132,0,0,90,13,0,101,14,0,101,12,0,106,
15,0,131,1,0,90,16,0,71,100,29,0,100,30,0,132,
0,0,100,30,0,131,2,0,90,17,0,105,0,0,90,18,
0,105,0,0,90,19,0,71,100,31,0,100,32,0,132,0,
0,100,32,0,101,20,0,131,3,0,90,21,0,71,100,33,
0,100,34,0,132,0,0,100,34,0,131,2,0,90,22,0,
71,100,35,0,100,36,0,132,0,0,100,36,0,131,2,0,
90,23,0,71,100,37,0,100,38,0,132,0,0,100,38,0,
131,2,0,90,24,0,100,39,0,100,40,0,132,0,0,90,
25,0,100,41,0,100,42,0,132,0,0,90,26,0,100,43,
0,100,44,0,132,0,0,90,27,0,100,45,0,106,28,0,
100,46,0,100,47,0,131,2,0,100,48,0,23,90,29,0,
101,30,0,106,31,0,101,29,0,100,47,0,131,2,0,90,
32,0,100,49,0,90,33,0,100,50,0,100,51,0,103,2,
0,90,34,0,100,52,0,103,1,0,90,35,0,100,53,0,
103,1,0,90,36,0,100,54,0,100,55,0,100,56,0,132,
1,0,90,37,0,100,57,0,100,58,0,132,0,0,90,38,
0,100,59,0,100,60,0,132,0,0,90,39,0,100,61,0,
100,62,0,132,0,0,90,40,0,100,63,0,100,64,0,100,
65,0,100,66,0,132,0,1,90,41,0,100,67,0,100,68,
0,132,0,0,90,42,0,100,69,0,100,70,0,132,0,0,
90,43,0,100,71,0,100,72,0,132,0,0,90,44,0,100,
73,0,100,74,0,132,0,0,90,45,0,100,75,0,100,76,
0,132,0,0,90,46,0,100,54,0,100,54,0,100,54,0,
100,77,0,100,78,0,132,3,0,90,47,0,100,54,0,100,
54,0,100,54,0,100,79,0,100,80,0,132,3,0,90,48,
0,100,81,0,100,81,0,100,82,0,100,83,0,132,2,0,
90,49,0,100,84,0,100,85,0,132,0,0,90,50,0,100,
86,0,100,87,0,132,0,0,90,51,0,71,100,88,0,100,
89,0,132,0,0,100,89,0,131,2,0,90,52,0,71,100,
90,0,100,91,0,132,0,0,100,91,0,131,2,0,90,53,
0,100,92,0,100,54,0,100,93,0,100,54,0,100,94,0,
100,95,0,132,0,2,90,54,0,101,55,0,131,0,0,90,
56,0,100,54,0,100,96,0,100,54,0,100,97,0,101,56,
0,100,98,0,100,99,0,132,1,2,90,57,0,100,54,0,
100,54,0,100,100,0,100,101,0,132,2,0,90,58,0,71,
100,102,0,100,103,0,132,0,0,100,103,0,131,2,0,90,
59,0,100,54,0,100,104,0,100,105,0,132,1,0,90,60,
0,71,100,106,0,100,107,0,132,0,0,100,107,0,131,2,
0,90,61,0,71,100,108,0,100,109,0,132,0,0,100,109,
0,131,2,0,90,62,0,71,100,110,0,100,111,0,132,0,
0,100,111,0,131,2,0,90,63,0,71,100,112,0,100,113,
0,132,0,0,100,113,0,131,2,0,90,64,0,71,100,114,
0,100,115,0,132,0,0,100,115,0,101,64,0,131,3,0,
90,65,0,71,100,116,0,100,117,0,132,0,0,100,117,0,
131,2,0,90,66,0,71,100,118,0,100,119,0,132,0,0,
100,119,0,101,66,0,101,65,0,131,4,0,90,67,0,71,
100,120,0,100,121,0,132,0,0,100,121,0,101,66,0,101,
64,0,131,4,0,90,68,0,103,0,0,90,69,0,71,100,
122,0,100,123,0,132,0,0,100,123,0,131,2,0,90,70,
0,71,100,124,0,100,125,0,132,0,0,100,125,0,131,2,
0,90,71,0,71,100,126,0,100,127,0,132,0,0,100,127,
0,131,2,0,90,72,0,71,100,128,0,100,129,0,132,0,
0,100,129,0,131,2,0,90,73,0,71,100,130,0,100,131,
0,132,0,0,100,131,0,131,2,0,90,74,0,71,100,132,
0,100,133,0,132,0,0,100,133,0,131,2,0,90,75,0,
100,134,0,100,135,0,132,0,0,90,76,0,100,136,0,100,
137,0,132,0,0,90,77,0,100,54,0,100,138,0,100,139,
0,132,1,0,90,78,0,100,140,0,100,141,0,132,0,0,
90,79,0,100,142,0,90,80,0,101,80,0,100,143,0,23,
90,81,0,100,144,0,100,145,0,132,0,0,90,82,0,100,
146,0,100,147,0,132,0,0,90,83,0,100,54,0,100,81,
0,100,148,0,100,149,0,132,2,0,90,84,0,100,150,0,
100,151,0,132,0,0,90,85,0,100,152,0,100,153,0,132,
0,0,90,86,0,100,154,0,100,155,0,132,0,0,90,87,
0,100,54,0,100,54,0,102,0,0,100,81,0,100,156,0,
100,157,0,132,4,0,90,88,0,100,158,0,100,159,0,132,
0,0,90,89,0,100,160,0,100,161,0,132,0,0,90,90,
0,100,162,0,100,163,0,132,0,0,90,91,0,100,54,0,
83,41,165,97,83,1,0,0,67,111,114,101,32,105,109,112,
108,101,109,101,110,116,97,116,105,111,110,32,111,102,32,105,
109,112,111,114,116,46,10,10,84,104,105,115,32,109,111,100,
117,108,101,32,105,115,32,78,79,84,32,109,101,97,110,116,
32,116,111,32,98,101,32,100,105,114,101,99,116,108,121,32,
105,109,112,111,114,116,101,100,33,32,73,116,32,104,97,115,
32,98,101,101,110,32,100,101,115,105,103,110,101,100,32,115,
117,99,104,10,116,104,97,116,32,105,116,32,99,97,110,32,
98,101,32,98,111,111,116,115,116,114,97,112,112,101,100,32,
105,110,116,111,32,80,121,116,104,111,110,32,97,115,32,116,
104,101,32,105,109,112,108,101,109,101,110,116,97,116,105,111,
110,32,111,102,32,105,109,112,111,114,116,46,32,65,115,10,
115,117,99,104,32,105,116,32,114,101,113,117,105,114,101,115,
32,116,104,101,32,105,110,106,101,99,116,105,111,110,32,111,
102,32,115,112,101,99,105,102,105,99,32,109,111,100,117,108,
101,115,32,97,110,100,32,97,116,116,114,105,98,117,116,101,
115,32,105,110,32,111,114,100,101,114,32,116,111,10,119,111,
114,107,46,32,79,110,101,32,115,104,111,117,108,100,32,117,
115,101,32,105,109,112,111,114,116,108,105,98,32,97,115,32,
116,104,101,32,112,117,98,108,105,99,45,102,97,99,105,110,
103,32,118,101,114,115,105,111,110,32,111,102,32,116,104,105,
115,32,109,111,100,117,108,101,46,10,10,218,3,119,105,110,
218,6,99,121,103,119,105,110,218,6,100,97,114,119,105,110,
99,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,
0,67,0,0,0,115,49,0,0,0,116,0,0,106,1,0,
106,2,0,116,3,0,131,1,0,114,33,0,100,1,0,100,
2,0,132,0,0,125,0,0,110,12,0,100,3,0,100,2,
0,132,0,0,125,0,0,124,0,0,83,41,4,78,99,0,
0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,83,
0,0,0,115,13,0,0,0,100,1,0,116,0,0,106,1,
0,107,6,0,83,41,2,122,53,84,114,117,101,32,105,102,
32,102,105,108,101,110,97,109,101,115,32,109,117,115,116,32,
98,101,32,99,104,101,99,107,101,100,32,99,97,115,101,45,
105,110,115,101,110,115,105,116,105,118,101,108,121,46,115,12,
0,0,0,80,89,84,72,79,78,67,65,83,69,79,75,41,
2,218,3,95,111,115,90,7,101,110,118,105,114,111,110,169,
0,114,4,0,0,0,114,4,0,0,0,250,29,60,102,114,
111,122,101,110,32,105,109,112,111,114,116,108,105,98,46,95,
98,111,111,116,115,116,114,97,112,62,218,11,95,114,101,108,
97,120,95,99,97,115,101,30,0,0,0,115,2,0,0,0,
0,2,122,37,95,109,97,107,101,95,114,101,108,97,120,95,
99,97,115,101,46,60,108,111,99,97,108,115,62,46,95,114,
101,108,97,120,95,99,97,115,101,99,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,83,0,0,0,115,4,
0,0,0,100,1,0,83,41,2,122,53,84,114,117,101,32,
105,102,32,102,105,108,101,110,97,109,101,115,32,109,117,115,
116,32,98,101,32,99,104,101,99,107,101,100,32,99,97,115,
101,45,105,110,115,101,110,115,105,116,105,118,101,108,121,46,
70,114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,6,0,0,0,34,
0,0,0,115,2,0,0,0,0,2,41,4,218,3,115,121,
115,218,8,112,108,97,116,102,111,114,109,218,10,115,116,97,
114,116,115,119,105,116,104,218,27,95,67,65,83,69,95,73,
78,83,69,78,83,73,84,73,86,69,95,80,76,65,84,70,
79,82,77,83,41,1,114,6,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,218,16,95,109,97,107,
101,95,114,101,108,97,120,95,99,97,115,101,28,0,0,0,
115,8,0,0,0,0,1,18,1,15,4,12,3,114,11,0,
0,0,99,1,0,0,0,0,0,0,0,1,0,0,0,3,
0,0,0,67,0,0,0,115,26,0,0,0,116,0,0,124,
0,0,131,1,0,100,1,0,64,106,1,0,100,2,0,100,
3,0,131,2,0,83,41,4,122,42,67,111,110,118,101,114,
116,32,97,32,51,50,45,98,105,116,32,105,110,116,101,103,
101,114,32,116,111,32,108,105,116,116,108,101,45,101,110,100,
105,97,110,46,108,3,0,0,0,255,127,255,127,3,0,233,
4,0,0,0,218,6,108,105,116,116,108,101,41,2,218,3,
105,110,116,218,8,116,111,95,98,121,116,101,115,41,1,218,
1,120,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,218,7,95,119,95,108,111,110,103,40,0,0,0,115,2,
0,0,0,0,2,114,17,0,0,0,99,1,0,0,0,0,
0,0,0,1,0,0,0,3,0,0,0,67,0,0,0,115,
16,0,0,0,116,0,0,106,1,0,124,0,0,100,1,0,
131,2,0,83,41,2,122,47,67,111,110,118,101,114,116,32,
52,32,98,121,116,101,115,32,105,110,32,108,105,116,116,108,
101,45,101,110,100,105,97,110,32,116,111,32,97,110,32,105,
110,116,101,103,101,114,46,114,13,0,0,0,41,2,114,14,
0,0,0,218,10,102,114,111,109,95,98,121,116,101,115,41,
1,90,9,105,110,116,95,98,121,116,101,115,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,7,95,114,95,
108,111,110,103,45,0,0,0,115,2,0,0,0,0,2,114,
19,0,0,0,99,0,0,0,0,0,0,0,0,1,0,0,
0,3,0,0,0,71,0,0,0,115,26,0,0,0,116,0,
0,106,1,0,100,1,0,100,2,0,132,0,0,124,0,0,
68,131,1,0,131,1,0,83,41,3,122,31,82,101,112,108,
97,99,101,109,101,110,116,32,102,111,114,32,111,115,46,112,
97,116,104,46,106,111,105,110,40,41,46,99,1,0,0,0,
0,0,0,0,2,0,0,0,4,0,0,0,83,0,0,0,
115,37,0,0,0,103,0,0,124,0,0,93,27,0,125,1,
0,124,1,0,114,6,0,124,1,0,106,0,0,116,1,0,
131,1,0,145,2,0,113,6,0,83,114,4,0,0,0,41,
2,218,6,114,115,116,114,105,112,218,15,112,97,116,104,95,
115,101,112,97,114,97,116,111,114,115,41,2,218,2,46,48,
218,4,112,97,114,116,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,250,10,60,108,105,115,116,99,111,109,112,
62,52,0,0,0,115,2,0,0,0,9,1,122,30,95,112,
97,116,104,95,106,111,105,110,46,60,108,111,99,97,108,115,
62,46,60,108,105,115,116,99,111,109,112,62,41,2,218,8,
112,97,116,104,95,115,101,112,218,4,106,111,105,110,41,1,
218,10,112,97,116,104,95,112,97,114,116,115,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,10,95,112,97,
116,104,95,106,111,105,110,50,0,0,0,115,4,0,0,0,
0,2,15,1,114,28,0,0,0,99,1,0,0,0,0,0,
0,0,5,0,0,0,5,0,0,0,67,0,0,0,115,134,
0,0,0,116,0,0,116,1,0,131,1,0,100,1,0,107,
2,0,114,52,0,124,0,0,106,2,0,116,3,0,131,1,
0,92,3,0,125,1,0,125,2,0,125,3,0,124,1,0,
124,3,0,102,2,0,83,120,69,0,116,4,0,124,0,0,
131,1,0,68,93,55,0,125,4,0,124,4,0,116,1,0,
107,6,0,114,65,0,124,0,0,106,5,0,124,4,0,100,
2,0,100,1,0,131,1,1,92,2,0,125,1,0,125,3,
0,124,1,0,124,3,0,102,2,0,83,113,65,0,87,100,
3,0,124,0,0,102,2,0,83,41,4,122,32,82,101,112,
108,97,99,101,109,101,110,116,32,102,111,114,32,111,115,46,
112,97,116,104,46,115,112,108,105,116,40,41,46,233,1,0,
0,0,90,8,109,97,120,115,112,108,105,116,218,0,41,6,
218,3,108,101,110,114,21,0,0,0,218,10,114,112,97,114,
116,105,116,105,111,110,114,25,0,0,0,218,8,114,101,118,
101,114,115,101,100,218,6,114,115,112,108,105,116,41,5,218,
4,112,97,116,104,90,5,102,114,111,110,116,218,1,95,218,
4,116,97,105,108,114,16,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,218,11,95,112,97,116,104,
95,115,112,108,105,116,56,0,0,0,115,16,0,0,0,0,
2,18,1,24,1,10,1,19,1,12,1,27,1,14,1,114,
38,0,0,0,99,1,0,0,0,0,0,0,0,1,0,0,
0,2,0,0,0,67,0,0,0,115,13,0,0,0,116,0,
0,106,1,0,124,0,0,131,1,0,83,41,1,122,126,83,
116,97,116,32,116,104,101,32,112,97,116,104,46,10,10,32,
32,32,32,77,97,100,101,32,97,32,115,101,112,97,114,97,
116,101,32,102,117,110,99,116,105,111,110,32,116,111,32,109,
97,107,101,32,105,116,32,101,97,115,105,101,114,32,116,111,
32,111,118,101,114,114,105,100,101,32,105,110,32,101,120,112,
101,114,105,109,101,110,116,115,10,32,32,32,32,40,101,46,
103,46,32,99,97,99,104,101,32,115,116,97,116,32,114,101,
115,117,108,116,115,41,46,10,10,32,32,32,32,41,2,114,
3,0,0,0,90,4,115,116,97,116,41,1,114,35,0,0,
0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
218,10,95,112,97,116,104,95,115,116,97,116,68,0,0,0,
115,2,0,0,0,0,7,114,39,0,0,0,99,2,0,0,
0,0,0,0,0,3,0,0,0,11,0,0,0,67,0,0,
0,115,58,0,0,0,121,16,0,116,0,0,124,0,0,131,
1,0,125,2,0,87,110,22,0,4,116,1,0,107,10,0,
114,40,0,1,1,1,100,1,0,83,89,110,1,0,88,124,
2,0,106,2,0,100,2,0,64,124,1,0,107,2,0,83,
41,3,122,49,84,101,115,116,32,119,104,101,116,104,101,114,
32,116,104,101,32,112,97,116,104,32,105,115,32,116,104,101,
32,115,112,101,99,105,102,105,101,100,32,109,111,100,101,32,
116,121,112,101,46,70,105,0,240,0,0,41,3,114,39,0,
0,0,218,7,79,83,69,114,114,111,114,218,7,115,116,95,
109,111,100,101,41,3,114,35,0,0,0,218,4,109,111,100,
101,90,9,115,116,97,116,95,105,110,102,111,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,18,95,112,97,
116,104,95,105,115,95,109,111,100,101,95,116,121,112,101,78,
0,0,0,115,10,0,0,0,0,2,3,1,16,1,13,1,
9,1,114,43,0,0,0,99,1,0,0,0,0,0,0,0,
1,0,0,0,3,0,0,0,67,0,0,0,115,13,0,0,
0,116,0,0,124,0,0,100,1,0,131,2,0,83,41,2,
122,31,82,101,112,108,97,99,101,109,101,110,116,32,102,111,
114,32,111,115,46,112,97,116,104,46,105,115,102,105,108,101,
46,105,0,128,0,0,41,1,114,43,0,0,0,41,1,114,
35,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,218,12,95,112,97,116,104,95,105,115,102,105,108,
101,87,0,0,0,115,2,0,0,0,0,2,114,44,0,0,
0,99,1,0,0,0,0,0,0,0,1,0,0,0,3,0,
0,0,67,0,0,0,115,34,0,0,0,124,0,0,115,21,
0,116,0,0,106,1,0,131,0,0,125,0,0,110,0,0,
116,2,0,124,0,0,100,1,0,131,2,0,83,41,2,122,
30,82,101,112,108,97,99,101,109,101,110,116,32,102,111,114,
32,111,115,46,112,97,116,104,46,105,115,100,105,114,46,105,
0,64,0,0,41,3,114,3,0,0,0,218,6,103,101,116,
99,119,100,114,43,0,0,0,41,1,114,35,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,11,
95,112,97,116,104,95,105,115,100,105,114,92,0,0,0,115,
6,0,0,0,0,2,6,1,15,1,114,46,0,0,0,105,
182,1,0,0,99,3,0,0,0,0,0,0,0,6,0,0,
0,17,0,0,0,67,0,0,0,115,192,0,0,0,100,1,
0,106,0,0,124,0,0,116,1,0,124,0,0,131,1,0,
131,2,0,125,3,0,116,2,0,106,3,0,124,3,0,116,
2,0,106,4,0,116,2,0,106,5,0,66,116,2,0,106,
6,0,66,124,2,0,100,2,0,64,131,3,0,125,4,0,
121,60,0,116,7,0,106,8,0,124,4,0,100,3,0,131,
2,0,143,20,0,125,5,0,124,5,0,106,9,0,124,1,
0,131,1,0,1,87,100,4,0,81,88,116,2,0,106,10,
0,124,3,0,124,0,0,131,2,0,1,87,110,59,0,4,
116,11,0,107,10,0,114,187,0,1,1,1,121,17,0,116,
2,0,106,12,0,124,3,0,131,1,0,1,87,110,18,0,
4,116,11,0,107,10,0,114,179,0,1,1,1,89,110,1,
0,88,130,0,0,89,110,1,0,88,100,4,0,83,41,5,
122,162,66,101,115,116,45,101,102,102,111,114,116,32,102,117,
110,99,116,105,111,110,32,116,111,32,119,114,105,116,101,32,
100,97,116,97,32,116,111,32,97,32,112,97,116,104,32,97,
116,111,109,105,99,97,108,108,121,46,10,32,32,32,32,66,
101,32,112,114,101,112,97,114,101,100,32,116,111,32,104,97,
110,100,108,101,32,97,32,70,105,108,101,69,120,105,115,116,
115,69,114,114,111,114,32,105,102,32,99,111,110,99,117,114,
114,101,110,116,32,119,114,105,116,105,110,103,32,111,102,32,
116,104,101,10,32,32,32,32,116,101,109,112,111,114,97,114,
121,32,102,105,108,101,32,105,115,32,97,116,116,101,109,112,
116,101,100,46,122,5,123,125,46,123,125,105,182,1,0,0,
90,2,119,98,78,41,13,218,6,102,111,114,109,97,116,218,
2,105,100,114,3,0,0,0,90,4,111,112,101,110,90,6,
79,95,69,88,67,76,90,7,79,95,67,82,69,65,84,90,
8,79,95,87,82,79,78,76,89,218,3,95,105,111,218,6,
70,105,108,101,73,79,218,5,119,114,105,116,101,218,7,114,
101,112,108,97,99,101,114,40,0,0,0,90,6,117,110,108,
105,110,107,41,6,114,35,0,0,0,218,4,100,97,116,97,
114,42,0,0,0,90,8,112,97,116,104,95,116,109,112,90,
2,102,100,218,4,102,105,108,101,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,13,95,119,114,105,116,101,
95,97,116,111,109,105,99,99,0,0,0,115,26,0,0,0,
0,5,24,1,9,1,33,1,3,3,21,1,19,1,20,1,
13,1,3,1,17,1,13,1,5,1,114,55,0,0,0,99,
2,0,0,0,0,0,0,0,3,0,0,0,7,0,0,0,
67,0,0,0,115,95,0,0,0,120,69,0,100,1,0,100,
2,0,100,3,0,100,4,0,103,4,0,68,93,49,0,125,
2,0,116,0,0,124,1,0,124,2,0,131,2,0,114,19,
0,116,1,0,124,0,0,124,2,0,116,2,0,124,1,0,
124,2,0,131,2,0,131,3,0,1,113,19,0,113,19,0,
87,124,0,0,106,3,0,106,4,0,124,1,0,106,3,0,
131,1,0,1,100,5,0,83,41,6,122,47,83,105,109,112,
108,101,32,115,117,98,115,116,105,116,117,116,101,32,102,111,
114,32,102,117,110,99,116,111,111,108,115,46,117,112,100,97,
116,101,95,119,114,97,112,112,101,114,46,218,10,95,95,109,
111,100,117,108,101,95,95,218,8,95,95,110,97,109,101,95,
95,218,12,95,95,113,117,97,108,110,97,109,101,95,95,218,
7,95,95,100,111,99,95,95,78,41,5,218,7,104,97,115,
97,116,116,114,218,7,115,101,116,97,116,116,114,218,7,103,
101,116,97,116,116,114,218,8,95,95,100,105,99,116,95,95,
218,6,117,112,100,97,116,101,41,3,90,3,110,101,119,90,
3,111,108,100,114,52,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,5,95,119,114,97,112,121,
0,0,0,115,8,0,0,0,0,2,25,1,15,1,32,1,
114,65,0,0,0,99,1,0,0,0,0,0,0,0,1,0,
0,0,2,0,0,0,67,0,0,0,115,16,0,0,0,116,
0,0,116,1,0,131,1,0,124,0,0,131,1,0,83,41,
1,78,41,2,218,4,116,121,112,101,114,7,0,0,0,41,
1,218,4,110,97,109,101,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,218,11,95,110,101,119,95,109,111,100,
117,108,101,129,0,0,0,115,2,0,0,0,0,1,114,68,
0,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,
2,0,0,0,64,0,0,0,115,58,0,0,0,101,0,0,
90,1,0,100,0,0,90,2,0,100,1,0,90,3,0,100,
2,0,100,3,0,132,0,0,90,4,0,100,4,0,100,5,
0,132,0,0,90,5,0,100,6,0,100,7,0,132,0,0,
90,6,0,100,8,0,83,41,9,218,13,95,77,97,110,97,
103,101,82,101,108,111,97,100,122,63,77,97,110,97,103,101,
115,32,116,104,101,32,112,111,115,115,105,98,108,101,32,99,
108,101,97,110,45,117,112,32,111,102,32,115,121,115,46,109,
111,100,117,108,101,115,32,102,111,114,32,108,111,97,100,95,
109,111,100,117,108,101,40,41,46,99,2,0,0,0,0,0,
0,0,2,0,0,0,2,0,0,0,67,0,0,0,115,13,
0,0,0,124,1,0,124,0,0,95,0,0,100,0,0,83,
41,1,78,41,1,218,5,95,110,97,109,101,41,2,218,4,
115,101,108,102,114,67,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,8,95,95,105,110,105,116,
95,95,141,0,0,0,115,2,0,0,0,0,1,122,22,95,
77,97,110,97,103,101,82,101,108,111,97,100,46,95,95,105,
110,105,116,95,95,99,1,0,0,0,0,0,0,0,1,0,
0,0,2,0,0,0,67,0,0,0,115,25,0,0,0,124,
0,0,106,0,0,116,1,0,106,2,0,107,6,0,124,0,
0,95,3,0,100,0,0,83,41,1,78,41,4,114,70,0,
0,0,114,7,0,0,0,218,7,109,111,100,117,108,101,115,
218,10,95,105,115,95,114,101,108,111,97,100,41,1,114,71,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,218,9,95,95,101,110,116,101,114,95,95,144,0,0,
0,115,2,0,0,0,0,1,122,23,95,77,97,110,97,103,
101,82,101,108,111,97,100,46,95,95,101,110,116,101,114,95,
95,99,1,0,0,0,0,0,0,0,2,0,0,0,11,0,
0,0,71,0,0,0,115,80,0,0,0,116,0,0,100,1,
0,100,2,0,132,0,0,124,1,0,68,131,1,0,131,1,
0,114,76,0,124,0,0,106,1,0,12,114,76,0,121,17,
0,116,2,0,106,3,0,124,0,0,106,4,0,61,87,113,
76,0,4,116,5,0,107,10,0,114,72,0,1,1,1,89,
113,76,0,88,110,0,0,100,0,0,83,41,3,78,99,1,
0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,115,
0,0,0,115,27,0,0,0,124,0,0,93,17,0,125,1,
0,124,1,0,100,0,0,107,9,0,86,1,113,3,0,100,
0,0,83,41,1,78,114,4,0,0,0,41,2,114,22,0,
0,0,218,3,97,114,103,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,250,9,60,103,101,110,101,120,112,114,
62,148,0,0,0,115,2,0,0,0,6,0,122,41,95,77,
97,110,97,103,101,82,101,108,111,97,100,46,95,95,101,120,
105,116,95,95,46,60,108,111,99,97,108,115,62,46,60,103,
101,110,101,120,112,114,62,41,6,218,3,97,110,121,114,74,
0,0,0,114,7,0,0,0,114,73,0,0,0,114,70,0,
0,0,218,8,75,101,121,69,114,114,111,114,41,2,114,71,
0,0,0,218,4,97,114,103,115,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,8,95,95,101,120,105,116,
95,95,147,0,0,0,115,10,0,0,0,0,1,35,1,3,
1,17,1,13,1,122,22,95,77,97,110,97,103,101,82,101,
108,111,97,100,46,95,95,101,120,105,116,95,95,78,41,7,
114,57,0,0,0,114,56,0,0,0,114,58,0,0,0,114,
59,0,0,0,114,72,0,0,0,114,75,0,0,0,114,81,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,69,0,0,0,137,0,0,0,
115,8,0,0,0,12,2,6,2,12,3,12,3,114,69,0,
0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,1,
0,0,0,64,0,0,0,115,16,0,0,0,101,0,0,90,
1,0,100,0,0,90,2,0,100,1,0,83,41,2,218,14,
95,68,101,97,100,108,111,99,107,69,114,114,111,114,78,41,
3,114,57,0,0,0,114,56,0,0,0,114,58,0,0,0,
114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,82,0,0,0,162,0,0,0,115,2,0,
0,0,12,1,114,82,0,0,0,99,0,0,0,0,0,0,
0,0,0,0,0,0,2,0,0,0,64,0,0,0,115,82,
0,0,0,101,0,0,90,1,0,100,0,0,90,2,0,100,
1,0,90,3,0,100,2,0,100,3,0,132,0,0,90,4,
0,100,4,0,100,5,0,132,0,0,90,5,0,100,6,0,
100,7,0,132,0,0,90,6,0,100,8,0,100,9,0,132,
0,0,90,7,0,100,10,0,100,11,0,132,0,0,90,8,
0,100,12,0,83,41,13,218,11,95,77,111,100,117,108,101,
76,111,99,107,122,169,65,32,114,101,99,117,114,115,105,118,
101,32,108,111,99,107,32,105,109,112,108,101,109,101,110,116,
97,116,105,111,110,32,119,104,105,99,104,32,105,115,32,97,
98,108,101,32,116,111,32,100,101,116,101,99,116,32,100,101,
97,100,108,111,99,107,115,10,32,32,32,32,40,101,46,103,
46,32,116,104,114,101,97,100,32,49,32,116,114,121,105,110,
103,32,116,111,32,116,97,107,101,32,108,111,99,107,115,32,
65,32,116,104,101,110,32,66,44,32,97,110,100,32,116,104,
114,101,97,100,32,50,32,116,114,121,105,110,103,32,116,111,
10,32,32,32,32,116,97,107,101,32,108,111,99,107,115,32,
66,32,116,104,101,110,32,65,41,46,10,32,32,32,32,99,
2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,
67,0,0,0,115,70,0,0,0,116,0,0,106,1,0,131,
0,0,124,0,0,95,2,0,116,0,0,106,1,0,131,0,
0,124,0,0,95,3,0,124,1,0,124,0,0,95,4,0,
100,0,0,124,0,0,95,5,0,100,1,0,124,0,0,95,
6,0,100,1,0,124,0,0,95,7,0,100,0,0,83,41,
2,78,233,0,0,0,0,41,8,218,7,95,116,104,114,101,
97,100,90,13,97,108,108,111,99,97,116,101,95,108,111,99,
107,218,4,108,111,99,107,218,6,119,97,107,101,117,112,114,
67,0,0,0,218,5,111,119,110,101,114,218,5,99,111,117,
110,116,218,7,119,97,105,116,101,114,115,41,2,114,71,0,
0,0,114,67,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,72,0,0,0,172,0,0,0,115,
12,0,0,0,0,1,15,1,15,1,9,1,9,1,9,1,
122,20,95,77,111,100,117,108,101,76,111,99,107,46,95,95,
105,110,105,116,95,95,99,1,0,0,0,0,0,0,0,4,
0,0,0,2,0,0,0,67,0,0,0,115,88,0,0,0,
116,0,0,106,1,0,131,0,0,125,1,0,124,0,0,106,
2,0,125,2,0,120,60,0,116,3,0,106,4,0,124,2,
0,131,1,0,125,3,0,124,3,0,100,0,0,107,8,0,
114,55,0,100,1,0,83,124,3,0,106,2,0,125,2,0,
124,2,0,124,1,0,107,2,0,114,24,0,100,2,0,83,
113,24,0,87,100,0,0,83,41,3,78,70,84,41,5,114,
85,0,0,0,218,9,103,101,116,95,105,100,101,110,116,114,
88,0,0,0,218,12,95,98,108,111,99,107,105,110,103,95,
111,110,218,3,103,101,116,41,4,114,71,0,0,0,218,2,
109,101,218,3,116,105,100,114,86,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,12,104,97,115,
95,100,101,97,100,108,111,99,107,180,0,0,0,115,18,0,
0,0,0,2,12,1,9,1,3,1,15,1,12,1,4,1,
9,1,12,1,122,24,95,77,111,100,117,108,101,76,111,99,
107,46,104,97,115,95,100,101,97,100,108,111,99,107,99,1,
0,0,0,0,0,0,0,2,0,0,0,16,0,0,0,67,
0,0,0,115,215,0,0,0,116,0,0,106,1,0,131,0,
0,125,1,0,124,0,0,116,2,0,124,1,0,60,122,178,
0,120,171,0,124,0,0,106,3,0,143,130,0,1,124,0,
0,106,4,0,100,1,0,107,2,0,115,68,0,124,0,0,
106,5,0,124,1,0,107,2,0,114,96,0,124,1,0,124,
0,0,95,5,0,124,0,0,4,106,4,0,100,2,0,55,
2,95,4,0,100,3,0,83,124,0,0,106,6,0,131,0,
0,114,127,0,116,7,0,100,4,0,124,0,0,22,131,1,
0,130,1,0,110,0,0,124,0,0,106,8,0,106,9,0,
100,5,0,131,1,0,114,163,0,124,0,0,4,106,10,0,
100,2,0,55,2,95,10,0,110,0,0,87,100,6,0,81,
88,124,0,0,106,8,0,106,9,0,131,0,0,1,124,0,
0,106,8,0,106,11,0,131,0,0,1,113,28,0,87,87,
100,6,0,116,2,0,124,1,0,61,88,100,6,0,83,41,
7,122,185,10,32,32,32,32,32,32,32,32,65,99,113,117,
105,114,101,32,116,104,101,32,109,111,100,117,108,101,32,108,
111,99,107,46,32,32,73,102,32,97,32,112,111,116,101,110,
116,105,97,108,32,100,101,97,100,108,111,99,107,32,105,115,
32,100,101,116,101,99,116,101,100,44,10,32,32,32,32,32,
32,32,32,97,32,95,68,101,97,100,108,111,99,107,69,114,
114,111,114,32,105,115,32,114,97,105,115,101,100,46,10,32,
32,32,32,32,32,32,32,79,116,104,101,114,119,105,115,101,
44,32,116,104,101,32,108,111,99,107,32,105,115,32,97,108,
119,97,121,115,32,97,99,113,117,105,114,101,100,32,97,110,
100,32,84,114,117,101,32,105,115,32,114,101,116,117,114,110,
101,100,46,10,32,32,32,32,32,32,32,32,114,84,0,0,
0,114,29,0,0,0,84,122,23,100,101,97,100,108,111,99,
107,32,100,101,116,101,99,116,101,100,32,98,121,32,37,114,
70,78,41,12,114,85,0,0,0,114,91,0,0,0,114,92,
0,0,0,114,86,0,0,0,114,89,0,0,0,114,88,0,
0,0,114,96,0,0,0,114,82,0,0,0,114,87,0,0,
0,218,7,97,99,113,117,105,114,101,114,90,0,0,0,218,
7,114,101,108,101,97,115,101,41,2,114,71,0,0,0,114,
95,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,97,0,0,0,192,0,0,0,115,32,0,0,
0,0,6,12,1,10,1,3,1,3,1,10,1,30,1,9,
1,15,1,4,1,12,1,19,1,18,1,24,2,13,1,21,
2,122,19,95,77,111,100,117,108,101,76,111,99,107,46,97,
99,113,117,105,114,101,99,1,0,0,0,0,0,0,0,2,
0,0,0,10,0,0,0,67,0,0,0,115,165,0,0,0,
116,0,0,106,1,0,131,0,0,125,1,0,124,0,0,106,
2,0,143,138,0,1,124,0,0,106,3,0,124,1,0,107,
3,0,114,52,0,116,4,0,100,1,0,131,1,0,130,1,
0,110,0,0,124,0,0,106,5,0,100,2,0,107,4,0,
115,73,0,116,6,0,130,1,0,124,0,0,4,106,5,0,
100,3,0,56,2,95,5,0,124,0,0,106,5,0,100,2,
0,107,2,0,114,155,0,100,0,0,124,0,0,95,3,0,
124,0,0,106,7,0,114,155,0,124,0,0,4,106,7,0,
100,3,0,56,2,95,7,0,124,0,0,106,8,0,106,9,
0,131,0,0,1,113,155,0,110,0,0,87,100,0,0,81,
88,100,0,0,83,41,4,78,122,31,99,97,110,110,111,116,
32,114,101,108,101,97,115,101,32,117,110,45,97,99,113,117,
105,114,101,100,32,108,111,99,107,114,84,0,0,0,114,29,
0,0,0,41,10,114,85,0,0,0,114,91,0,0,0,114,
86,0,0,0,114,88,0,0,0,218,12,82,117,110,116,105,
109,101,69,114,114,111,114,114,89,0,0,0,218,14,65,115,
115,101,114,116,105,111,110,69,114,114,111,114,114,90,0,0,
0,114,87,0,0,0,114,98,0,0,0,41,2,114,71,0,
0,0,114,95,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,98,0,0,0,217,0,0,0,115,
22,0,0,0,0,1,12,1,10,1,15,1,15,1,21,1,
15,1,15,1,9,1,9,1,15,1,122,19,95,77,111,100,
117,108,101,76,111,99,107,46,114,101,108,101,97,115,101,99,
1,0,0,0,0,0,0,0,1,0,0,0,4,0,0,0,
67,0,0,0,115,25,0,0,0,100,1,0,106,0,0,124,
0,0,106,1,0,116,2,0,124,0,0,131,1,0,131,2,
0,83,41,2,78,122,23,95,77,111,100,117,108,101,76,111,
99,107,40,123,33,114,125,41,32,97,116,32,123,125,41,3,
114,47,0,0,0,114,67,0,0,0,114,48,0,0,0,41,
1,114,71,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,218,8,95,95,114,101,112,114,95,95,230,
0,0,0,115,2,0,0,0,0,1,122,20,95,77,111,100,
117,108,101,76,111,99,107,46,95,95,114,101,112,114,95,95,
78,41,9,114,57,0,0,0,114,56,0,0,0,114,58,0,
0,0,114,59,0,0,0,114,72,0,0,0,114,96,0,0,
0,114,97,0,0,0,114,98,0,0,0,114,101,0,0,0,
114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,83,0,0,0,166,0,0,0,115,12,0,
0,0,12,4,6,2,12,8,12,12,12,25,12,13,114,83,
0,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,
2,0,0,0,64,0,0,0,115,70,0,0,0,101,0,0,
90,1,0,100,0,0,90,2,0,100,1,0,90,3,0,100,
2,0,100,3,0,132,0,0,90,4,0,100,4,0,100,5,
0,132,0,0,90,5,0,100,6,0,100,7,0,132,0,0,
90,6,0,100,8,0,100,9,0,132,0,0,90,7,0,100,
10,0,83,41,11,218,16,95,68,117,109,109,121,77,111,100,
117,108,101,76,111,99,107,122,86,65,32,115,105,109,112,108,
101,32,95,77,111,100,117,108,101,76,111,99,107,32,101,113,
117,105,118,97,108,101,110,116,32,102,111,114,32,80,121,116,
104,111,110,32,98,117,105,108,100,115,32,119,105,116,104,111,
117,116,10,32,32,32,32,109,117,108,116,105,45,116,104,114,
101,97,100,105,110,103,32,115,117,112,112,111,114,116,46,99,
2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,
67,0,0,0,115,22,0,0,0,124,1,0,124,0,0,95,
0,0,100,1,0,124,0,0,95,1,0,100,0,0,83,41,
2,78,114,84,0,0,0,41,2,114,67,0,0,0,114,89,
0,0,0,41,2,114,71,0,0,0,114,67,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,72,
0,0,0,238,0,0,0,115,4,0,0,0,0,1,9,1,
122,25,95,68,117,109,109,121,77,111,100,117,108,101,76,111,
99,107,46,95,95,105,110,105,116,95,95,99,1,0,0,0,
0,0,0,0,1,0,0,0,3,0,0,0,67,0,0,0,
115,19,0,0,0,124,0,0,4,106,0,0,100,1,0,55,
2,95,0,0,100,2,0,83,41,3,78,114,29,0,0,0,
84,41,1,114,89,0,0,0,41,1,114,71,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,97,
0,0,0,242,0,0,0,115,4,0,0,0,0,1,15,1,
122,24,95,68,117,109,109,121,77,111,100,117,108,101,76,111,
99,107,46,97,99,113,117,105,114,101,99,1,0,0,0,0,
0,0,0,1,0,0,0,3,0,0,0,67,0,0,0,115,
49,0,0,0,124,0,0,106,0,0,100,1,0,107,2,0,
114,30,0,116,1,0,100,2,0,131,1,0,130,1,0,110,
0,0,124,0,0,4,106,0,0,100,3,0,56,2,95,0,
0,100,0,0,83,41,4,78,114,84,0,0,0,122,31,99,
97,110,110,111,116,32,114,101,108,101,97,115,101,32,117,110,
45,97,99,113,117,105,114,101,100,32,108,111,99,107,114,29,
0,0,0,41,2,114,89,0,0,0,114,99,0,0,0,41,
1,114,71,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,98,0,0,0,246,0,0,0,115,6,
0,0,0,0,1,15,1,15,1,122,24,95,68,117,109,109,
121,77,111,100,117,108,101,76,111,99,107,46,114,101,108,101,
97,115,101,99,1,0,0,0,0,0,0,0,1,0,0,0,
4,0,0,0,67,0,0,0,115,25,0,0,0,100,1,0,
106,0,0,124,0,0,106,1,0,116,2,0,124,0,0,131,
1,0,131,2,0,83,41,2,78,122,28,95,68,117,109,109,
121,77,111,100,117,108,101,76,111,99,107,40,123,33,114,125,
41,32,97,116,32,123,125,41,3,114,47,0,0,0,114,67,
0,0,0,114,48,0,0,0,41,1,114,71,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,101,
0,0,0,251,0,0,0,115,2,0,0,0,0,1,122,25,
95,68,117,109,109,121,77,111,100,117,108,101,76,111,99,107,
46,95,95,114,101,112,114,95,95,78,41,8,114,57,0,0,
0,114,56,0,0,0,114,58,0,0,0,114,59,0,0,0,
114,72,0,0,0,114,97,0,0,0,114,98,0,0,0,114,
101,0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,114,102,0,0,0,234,0,0,
0,115,10,0,0,0,12,2,6,2,12,4,12,4,12,5,
114,102,0,0,0,99,0,0,0,0,0,0,0,0,0,0,
0,0,2,0,0,0,64,0,0,0,115,52,0,0,0,101,
0,0,90,1,0,100,0,0,90,2,0,100,1,0,100,2,
0,132,0,0,90,3,0,100,3,0,100,4,0,132,0,0,
90,4,0,100,5,0,100,6,0,132,0,0,90,5,0,100,
7,0,83,41,8,218,18,95,77,111,100,117,108,101,76,111,
99,107,77,97,110,97,103,101,114,99,2,0,0,0,0,0,
0,0,2,0,0,0,2,0,0,0,67,0,0,0,115,22,
0,0,0,124,1,0,124,0,0,95,0,0,100,0,0,124,
0,0,95,1,0,100,0,0,83,41,1,78,41,2,114,70,
0,0,0,218,5,95,108,111,99,107,41,2,114,71,0,0,
0,114,67,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,72,0,0,0,1,1,0,0,115,4,
0,0,0,0,1,9,1,122,27,95,77,111,100,117,108,101,
76,111,99,107,77,97,110,97,103,101,114,46,95,95,105,110,
105,116,95,95,99,1,0,0,0,0,0,0,0,1,0,0,
0,10,0,0,0,67,0,0,0,115,53,0,0,0,122,22,
0,116,0,0,124,0,0,106,1,0,131,1,0,124,0,0,
95,2,0,87,100,0,0,116,3,0,106,4,0,131,0,0,
1,88,124,0,0,106,2,0,106,5,0,131,0,0,1,100,
0,0,83,41,1,78,41,6,218,16,95,103,101,116,95,109,
111,100,117,108,101,95,108,111,99,107,114,70,0,0,0,114,
104,0,0,0,218,4,95,105,109,112,218,12,114,101,108,101,
97,115,101,95,108,111,99,107,114,97,0,0,0,41,1,114,
71,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,75,0,0,0,5,1,0,0,115,8,0,0,
0,0,1,3,1,22,2,11,1,122,28,95,77,111,100,117,
108,101,76,111,99,107,77,97,110,97,103,101,114,46,95,95,
101,110,116,101,114,95,95,99,1,0,0,0,0,0,0,0,
3,0,0,0,1,0,0,0,79,0,0,0,115,17,0,0,
0,124,0,0,106,0,0,106,1,0,131,0,0,1,100,0,
0,83,41,1,78,41,2,114,104,0,0,0,114,98,0,0,
0,41,3,114,71,0,0,0,114,80,0,0,0,218,6,107,
119,97,114,103,115,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,81,0,0,0,12,1,0,0,115,2,0,
0,0,0,1,122,27,95,77,111,100,117,108,101,76,111,99,
107,77,97,110,97,103,101,114,46,95,95,101,120,105,116,95,
95,78,41,6,114,57,0,0,0,114,56,0,0,0,114,58,
0,0,0,114,72,0,0,0,114,75,0,0,0,114,81,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,103,0,0,0,255,0,0,0,115,
6,0,0,0,12,2,12,4,12,7,114,103,0,0,0,99,
1,0,0,0,0,0,0,0,3,0,0,0,11,0,0,0,
3,0,0,0,115,142,0,0,0,100,1,0,125,1,0,121,
17,0,116,0,0,136,0,0,25,131,0,0,125,1,0,87,
110,18,0,4,116,1,0,107,10,0,114,43,0,1,1,1,
89,110,1,0,88,124,1,0,100,1,0,107,8,0,114,138,
0,116,2,0,100,1,0,107,8,0,114,83,0,116,3,0,
136,0,0,131,1,0,125,1,0,110,12,0,116,4,0,136,
0,0,131,1,0,125,1,0,135,0,0,102,1,0,100,2,
0,100,3,0,134,0,0,125,2,0,116,5,0,106,6,0,
124,1,0,124,2,0,131,2,0,116,0,0,136,0,0,60,
110,0,0,124,1,0,83,41,4,122,109,71,101,116,32,111,
114,32,99,114,101,97,116,101,32,116,104,101,32,109,111,100,
117,108,101,32,108,111,99,107,32,102,111,114,32,97,32,103,
105,118,101,110,32,109,111,100,117,108,101,32,110,97,109,101,
46,10,10,32,32,32,32,83,104,111,117,108,100,32,111,110,
108,121,32,98,101,32,99,97,108,108,101,100,32,119,105,116,
104,32,116,104,101,32,105,109,112,111,114,116,32,108,111,99,
107,32,116,97,107,101,110,46,78,99,1,0,0,0,0,0,
0,0,1,0,0,0,2,0,0,0,19,0,0,0,115,11,
0,0,0,116,0,0,136,0,0,61,100,0,0,83,41,1,
78,41,1,218,13,95,109,111,100,117,108,101,95,108,111,99,
107,115,41,1,114,36,0,0,0,41,1,114,67,0,0,0,
114,4,0,0,0,114,5,0,0,0,218,2,99,98,32,1,
0,0,115,2,0,0,0,0,1,122,28,95,103,101,116,95,
109,111,100,117,108,101,95,108,111,99,107,46,60,108,111,99,
97,108,115,62,46,99,98,41,7,114,109,0,0,0,114,79,
0,0,0,114,85,0,0,0,114,102,0,0,0,114,83,0,
0,0,218,8,95,119,101,97,107,114,101,102,90,3,114,101,
102,41,3,114,67,0,0,0,114,86,0,0,0,114,110,0,
0,0,114,4,0,0,0,41,1,114,67,0,0,0,114,5,
0,0,0,114,105,0,0,0,18,1,0,0,115,24,0,0,
0,0,4,6,1,3,1,17,1,13,1,5,1,12,1,12,
1,15,2,12,1,18,2,25,1,114,105,0,0,0,99,1,
0,0,0,0,0,0,0,2,0,0,0,11,0,0,0,67,
0,0,0,115,71,0,0,0,116,0,0,124,0,0,131,1,
0,125,1,0,116,1,0,106,2,0,131,0,0,1,121,14,
0,124,1,0,106,3,0,131,0,0,1,87,110,18,0,4,
116,4,0,107,10,0,114,56,0,1,1,1,89,110,11,0,
88,124,1,0,106,5,0,131,0,0,1,100,1,0,83,41,
2,97,21,1,0,0,82,101,108,101,97,115,101,32,116,104,
101,32,103,108,111,98,97,108,32,105,109,112,111,114,116,32,
108,111,99,107,44,32,97,110,100,32,97,99,113,117,105,114,
101,115,32,116,104,101,110,32,114,101,108,101,97,115,101,32,
116,104,101,10,32,32,32,32,109,111,100,117,108,101,32,108,
111,99,107,32,102,111,114,32,97,32,103,105,118,101,110,32,
109,111,100,117,108,101,32,110,97,109,101,46,10,32,32,32,
32,84,104,105,115,32,105,115,32,117,115,101,100,32,116,111,
32,101,110,115,117,114,101,32,97,32,109,111,100,117,108,101,
32,105,115,32,99,111,109,112,108,101,116,101,108,121,32,105,
110,105,116,105,97,108,105,122,101,100,44,32,105,110,32,116,
104,101,10,32,32,32,32,101,118,101,110,116,32,105,116,32,
105,115,32,98,101,105,110,103,32,105,109,112,111,114,116,101,
100,32,98,121,32,97,110,111,116,104,101,114,32,116,104,114,
101,97,100,46,10,10,32,32,32,32,83,104,111,117,108,100,
32,111,110,108,121,32,98,101,32,99,97,108,108,101,100,32,
119,105,116,104,32,116,104,101,32,105,109,112,111,114,116,32,
108,111,99,107,32,116,97,107,101,110,46,78,41,6,114,105,
0,0,0,114,106,0,0,0,114,107,0,0,0,114,97,0,
0,0,114,82,0,0,0,114,98,0,0,0,41,2,114,67,
0,0,0,114,86,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,19,95,108,111,99,107,95,117,
110,108,111,99,107,95,109,111,100,117,108,101,37,1,0,0,
115,14,0,0,0,0,7,12,1,10,1,3,1,14,1,13,
3,5,2,114,112,0,0,0,99,1,0,0,0,0,0,0,
0,3,0,0,0,3,0,0,0,79,0,0,0,115,13,0,
0,0,124,0,0,124,1,0,124,2,0,142,0,0,83,41,
1,97,46,1,0,0,114,101,109,111,118,101,95,105,109,112,
111,114,116,108,105,98,95,102,114,97,109,101,115,32,105,110,
32,105,109,112,111,114,116,46,99,32,119,105,108,108,32,97,
108,119,97,121,115,32,114,101,109,111,118,101,32,115,101,113,
117,101,110,99,101,115,10,32,32,32,32,111,102,32,105,109,
112,111,114,116,108,105,98,32,102,114,97,109,101,115,32,116,
104,97,116,32,101,110,100,32,119,105,116,104,32,97,32,99,
97,108,108,32,116,111,32,116,104,105,115,32,102,117,110,99,
116,105,111,110,10,10,32,32,32,32,85,115,101,32,105,116,
32,105,110,115,116,101,97,100,32,111,102,32,97,32,110,111,
114,109,97,108,32,99,97,108,108,32,105,110,32,112,108,97,
99,101,115,32,119,104,101,114,101,32,105,110,99,108,117,100,
105,110,103,32,116,104,101,32,105,109,112,111,114,116,108,105,
98,10,32,32,32,32,102,114,97,109,101,115,32,105,110,116,
114,111,100,117,99,101,115,32,117,110,119,97,110,116,101,100,
32,110,111,105,115,101,32,105,110,116,111,32,116,104,101,32,
116,114,97,99,101,98,97,99,107,32,40,101,46,103,46,32,
119,104,101,110,32,101,120,101,99,117,116,105,110,103,10,32,
32,32,32,109,111,100,117,108,101,32,99,111,100,101,41,10,
32,32,32,32,114,4,0,0,0,41,3,218,1,102,114,80,
0,0,0,90,4,107,119,100,115,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,25,95,99,97,108,108,95,
119,105,116,104,95,102,114,97,109,101,115,95,114,101,109,111,
118,101,100,57,1,0,0,115,2,0,0,0,0,8,114,114,
0,0,0,105,238,12,0,0,233,2,0,0,0,114,13,0,
0,0,115,2,0,0,0,13,10,90,11,95,95,112,121,99,
97,99,104,101,95,95,122,3,46,112,121,122,3,46,115,101,
122,4,46,112,121,99,122,4,46,112,121,111,78,99,2,0,
0,0,0,0,0,0,11,0,0,0,6,0,0,0,67,0,
0,0,115,192,0,0,0,124,1,0,100,1,0,107,8,0,
114,25,0,116,0,0,106,1,0,106,2,0,12,110,3,0,
124,1,0,125,2,0,124,2,0,114,46,0,116,3,0,125,
3,0,110,6,0,116,4,0,125,3,0,116,5,0,124,0,
0,131,1,0,92,2,0,125,4,0,125,5,0,124,5,0,
106,6,0,100,2,0,131,1,0,92,3,0,125,6,0,125,
7,0,125,8,0,116,0,0,106,7,0,106,8,0,125,9,
0,124,9,0,100,1,0,107,8,0,114,133,0,116,9,0,
100,3,0,131,1,0,130,1,0,110,0,0,100,4,0,106,
10,0,124,6,0,114,151,0,124,6,0,110,3,0,124,8,
0,124,7,0,124,9,0,124,3,0,100,5,0,25,103,4,
0,131,1,0,125,10,0,116,11,0,124,4,0,116,12,0,
124,10,0,131,3,0,83,41,6,97,244,1,0,0,71,105,
118,101,110,32,116,104,101,32,112,97,116,104,32,116,111,32,
97,32,46,112,121,32,102,105,108,101,44,32,114,101,116,117,
114,110,32,116,104,101,32,112,97,116,104,32,116,111,32,105,
116,115,32,46,112,121,99,47,46,112,121,111,32,102,105,108,
101,46,10,10,32,32,32,32,84,104,101,32,46,112,121,32,
102,105,108,101,32,100,111,101,115,32,110,111,116,32,110,101,
101,100,32,116,111,32,101,120,105,115,116,59,32,116,104,105,
115,32,115,105,109,112,108,121,32,114,101,116,117,114,110,115,
32,116,104,101,32,112,97,116,104,32,116,111,32,116,104,101,
10,32,32,32,32,46,112,121,99,47,46,112,121,111,32,102,
105,108,101,32,99,97,108,99,117,108,97,116,101,100,32,97,
115,32,105,102,32,116,104,101,32,46,112,121,32,102,105,108,
101,32,119,101,114,101,32,105,109,112,111,114,116,101,100,46,
32,32,84,104,101,32,101,120,116,101,110,115,105,111,110,10,
32,32,32,32,119,105,108,108,32,98,101,32,46,112,121,99,
32,117,110,108,101,115,115,32,115,121,115,46,102,108,97,103,
115,46,111,112,116,105,109,105,122,101,32,105,115,32,110,111,
110,45,122,101,114,111,44,32,116,104,101,110,32,105,116,32,
119,105,108,108,32,98,101,32,46,112,121,111,46,10,10,32,
32,32,32,73,102,32,100,101,98,117,103,95,111,118,101,114,
114,105,100,101,32,105,115,32,110,111,116,32,78,111,110,101,
44,32,116,104,101,110,32,105,116,32,109,117,115,116,32,98,
101,32,97,32,98,111,111,108,101,97,110,32,97,110,100,32,
105,115,32,117,115,101,100,32,105,110,10,32,32,32,32,112,
108,97,99,101,32,111,102,32,115,121,115,46,102,108,97,103,
115,46,111,112,116,105,109,105,122,101,46,10,10,32,32,32,
32,73,102,32,115,121,115,46,105,109,112,108,101,109,101,110,
116,97,116,105,111,110,46,99,97,99,104,101,95,116,97,103,
32,105,115,32,78,111,110,101,32,116,104,101,110,32,78,111,
116,73,109,112,108,101,109,101,110,116,101,100,69,114,114,111,
114,32,105,115,32,114,97,105,115,101,100,46,10,10,32,32,
32,32,78,218,1,46,122,36,115,121,115,46,105,109,112,108,
101,109,101,110,116,97,116,105,111,110,46,99,97,99,104,101,
95,116,97,103,32,105,115,32,78,111,110,101,114,30,0,0,
0,114,84,0,0,0,41,13,114,7,0,0,0,218,5,102,
108,97,103,115,218,8,111,112,116,105,109,105,122,101,218,23,
68,69,66,85,71,95,66,89,84,69,67,79,68,69,95,83,
85,70,70,73,88,69,83,218,27,79,80,84,73,77,73,90,
69,68,95,66,89,84,69,67,79,68,69,95,83,85,70,70,
73,88,69,83,114,38,0,0,0,114,32,0,0,0,218,14,
105,109,112,108,101,109,101,110,116,97,116,105,111,110,218,9,
99,97,99,104,101,95,116,97,103,218,19,78,111,116,73,109,
112,108,101,109,101,110,116,101,100,69,114,114,111,114,114,26,
0,0,0,114,28,0,0,0,218,8,95,80,89,67,65,67,
72,69,41,11,114,35,0,0,0,90,14,100,101,98,117,103,
95,111,118,101,114,114,105,100,101,218,5,100,101,98,117,103,
218,8,115,117,102,102,105,120,101,115,218,4,104,101,97,100,
114,37,0,0,0,218,4,98,97,115,101,218,3,115,101,112,
218,4,114,101,115,116,90,3,116,97,103,218,8,102,105,108,
101,110,97,109,101,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,218,17,99,97,99,104,101,95,102,114,111,109,
95,115,111,117,114,99,101,181,1,0,0,115,22,0,0,0,
0,13,31,1,6,1,9,2,6,1,18,1,24,1,12,1,
12,1,15,1,43,1,114,132,0,0,0,99,1,0,0,0,
0,0,0,0,5,0,0,0,5,0,0,0,67,0,0,0,
115,193,0,0,0,116,0,0,106,1,0,106,2,0,100,1,
0,107,8,0,114,33,0,116,3,0,100,2,0,131,1,0,
130,1,0,110,0,0,116,4,0,124,0,0,131,1,0,92,
2,0,125,1,0,125,2,0,116,4,0,124,1,0,131,1,
0,92,2,0,125,1,0,125,3,0,124,3,0,116,5,0,
107,3,0,114,108,0,116,6,0,100,3,0,106,7,0,116,
5,0,124,0,0,131,2,0,131,1,0,130,1,0,110,0,
0,124,2,0,106,8,0,100,4,0,131,1,0,100,5,0,
107,3,0,114,153,0,116,6,0,100,6,0,106,7,0,124,
2,0,131,1,0,131,1,0,130,1,0,110,0,0,124,2,
0,106,9,0,100,4,0,131,1,0,100,7,0,25,125,4,
0,116,10,0,124,1,0,124,4,0,116,11,0,100,7,0,
25,23,131,2,0,83,41,8,97,121,1,0,0,71,105,118,
101,110,32,116,104,101,32,112,97,116,104,32,116,111,32,97,
32,46,112,121,99,46,47,46,112,121,111,32,102,105,108,101,
44,32,114,101,116,117,114,110,32,116,104,101,32,112,97,116,
104,32,116,111,32,105,116,115,32,46,112,121,32,102,105,108,
101,46,10,10,32,32,32,32,84,104,101,32,46,112,121,99,
47,46,112,121,111,32,102,105,108,101,32,100,111,101,115,32,
110,111,116,32,110,101,101,100,32,116,111,32,101,120,105,115,
116,59,32,116,104,105,115,32,115,105,109,112,108,121,32,114,
101,116,117,114,110,115,32,116,104,101,32,112,97,116,104,32,
116,111,10,32,32,32,32,116,104,101,32,46,112,121,32,102,
105,108,101,32,99,97,108,99,117,108,97,116,101,100,32,116,
111,32,99,111,114,114,101,115,112,111,110,100,32,116,111,32,
116,104,101,32,46,112,121,99,47,46,112,121,111,32,102,105,
108,101,46,32,32,73,102,32,112,97,116,104,32,100,111,101,
115,10,32,32,32,32,110,111,116,32,99,111,110,102,111,114,
109,32,116,111,32,80,69,80,32,51,49,52,55,32,102,111,
114,109,97,116,44,32,86,97,108,117,101,69,114,114,111,114,
32,119,105,108,108,32,98,101,32,114,97,105,115,101,100,46,
32,73,102,10,32,32,32,32,115,121,115,46,105,109,112,108,
101,109,101,110,116,97,116,105,111,110,46,99,97,99,104,101,
95,116,97,103,32,105,115,32,78,111,110,101,32,116,104,101,
110,32,78,111,116,73,109,112,108,101,109,101,110,116,101,100,
69,114,114,111,114,32,105,115,32,114,97,105,115,101,100,46,
10,10,32,32,32,32,78,122,36,115,121,115,46,105,109,112,
108,101,109,101,110,116,97,116,105,111,110,46,99,97,99,104,
101,95,116,97,103,32,105,115,32,78,111,110,101,122,37,123,
125,32,110,111,116,32,98,111,116,116,111,109,45,108,101,118,
101,108,32,100,105,114,101,99,116,111,114,121,32,105,110,32,
123,33,114,125,114,116,0,0,0,114,115,0,0,0,122,28,
101,120,112,101,99,116,101,100,32,111,110,108,121,32,50,32,
100,111,116,115,32,105,110,32,123,33,114,125,114,84,0,0,
0,41,12,114,7,0,0,0,114,121,0,0,0,114,122,0,
0,0,114,123,0,0,0,114,38,0,0,0,114,124,0,0,
0,218,10,86,97,108,117,101,69,114,114,111,114,114,47,0,
0,0,114,89,0,0,0,218,9,112,97,114,116,105,116,105,
111,110,114,28,0,0,0,218,15,83,79,85,82,67,69,95,
83,85,70,70,73,88,69,83,41,5,114,35,0,0,0,114,
127,0,0,0,90,16,112,121,99,97,99,104,101,95,102,105,
108,101,110,97,109,101,90,7,112,121,99,97,99,104,101,90,
13,98,97,115,101,95,102,105,108,101,110,97,109,101,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,218,17,115,
111,117,114,99,101,95,102,114,111,109,95,99,97,99,104,101,
208,1,0,0,115,24,0,0,0,0,9,18,1,15,1,18,
1,18,1,12,1,9,1,18,1,21,1,9,1,15,1,19,
1,114,136,0,0,0,99,1,0,0,0,0,0,0,0,5,
0,0,0,12,0,0,0,67,0,0,0,115,174,0,0,0,
116,0,0,124,0,0,131,1,0,100,1,0,107,2,0,114,
22,0,100,2,0,83,124,0,0,106,1,0,100,3,0,131,
1,0,92,3,0,125,1,0,125,2,0,125,3,0,116,2,
0,124,3,0,131,1,0,1,124,1,0,12,115,91,0,124,
3,0,106,3,0,131,0,0,100,7,0,100,8,0,133,2,
0,25,100,6,0,107,3,0,114,95,0,124,0,0,83,121,
16,0,116,4,0,124,0,0,131,1,0,125,4,0,87,110,
40,0,4,116,5,0,116,6,0,102,2,0,107,10,0,114,
153,0,1,1,1,124,0,0,100,2,0,100,9,0,133,2,
0,25,125,4,0,89,110,1,0,88,116,7,0,124,4,0,
131,1,0,114,170,0,124,4,0,83,124,0,0,83,41,10,
122,188,67,111,110,118,101,114,116,32,97,32,98,121,116,101,
99,111,100,101,32,102,105,108,101,32,112,97,116,104,32,116,
111,32,97,32,115,111,117,114,99,101,32,112,97,116,104,32,
40,105,102,32,112,111,115,115,105,98,108,101,41,46,10,10,
32,32,32,32,84,104,105,115,32,102,117,110,99,116,105,111,
110,32,101,120,105,115,116,115,32,112,117,114,101,108,121,32,
102,111,114,32,98,97,99,107,119,97,114,100,115,45,99,111,
109,112,97,116,105,98,105,108,105,116,121,32,102,111,114,10,
32,32,32,32,80,121,73,109,112,111,114,116,95,69,120,101,
99,67,111,100,101,77,111,100,117,108,101,87,105,116,104,70,
105,108,101,110,97,109,101,115,40,41,32,105,110,32,116,104,
101,32,67,32,65,80,73,46,10,10,32,32,32,32,114,84,
0,0,0,78,114,116,0,0,0,233,3,0,0,0,114,29,
0,0,0,90,2,112,121,233,253,255,255,255,233,255,255,255,
255,114,139,0,0,0,41,8,114,31,0,0,0,114,32,0,
0,0,218,5,112,114,105,110,116,218,5,108,111,119,101,114,
114,136,0,0,0,114,123,0,0,0,114,133,0,0,0,114,
44,0,0,0,41,5,218,13,98,121,116,101,99,111,100,101,
95,112,97,116,104,114,130,0,0,0,114,36,0,0,0,90,
9,101,120,116,101,110,115,105,111,110,218,11,115,111,117,114,
99,101,95,112,97,116,104,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,218,15,95,103,101,116,95,115,111,117,
114,99,101,102,105,108,101,231,1,0,0,115,22,0,0,0,
0,7,18,1,4,1,24,1,10,1,35,1,4,1,3,1,
16,1,19,1,21,1,114,144,0,0,0,99,1,0,0,0,
0,0,0,0,2,0,0,0,11,0,0,0,67,0,0,0,
115,60,0,0,0,121,19,0,116,0,0,124,0,0,131,1,
0,106,1,0,125,1,0,87,110,24,0,4,116,2,0,107,
10,0,114,45,0,1,1,1,100,1,0,125,1,0,89,110,
1,0,88,124,1,0,100,2,0,79,125,1,0,124,1,0,
83,41,3,122,51,67,97,108,99,117,108,97,116,101,32,116,
104,101,32,109,111,100,101,32,112,101,114,109,105,115,115,105,
111,110,115,32,102,111,114,32,97,32,98,121,116,101,99,111,
100,101,32,102,105,108,101,46,105,182,1,0,0,233,128,0,
0,0,41,3,114,39,0,0,0,114,41,0,0,0,114,40,
0,0,0,41,2,114,35,0,0,0,114,42,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,10,
95,99,97,108,99,95,109,111,100,101,251,1,0,0,115,12,
0,0,0,0,2,3,1,19,1,13,1,11,3,10,1,114,
146,0,0,0,218,9,118,101,114,98,111,115,105,116,121,114,
29,0,0,0,99,1,0,0,0,1,0,0,0,3,0,0,
0,4,0,0,0,71,0,0,0,115,81,0,0,0,116,0,
0,106,1,0,106,2,0,124,1,0,107,5,0,114,77,0,
124,0,0,106,3,0,100,6,0,131,1,0,115,46,0,100,
3,0,124,0,0,23,125,0,0,110,0,0,116,4,0,124,
0,0,106,5,0,124,2,0,140,0,0,100,4,0,116,0,
0,106,6,0,131,1,1,1,110,0,0,100,5,0,83,41,
7,122,61,80,114,105,110,116,32,116,104,101,32,109,101,115,
115,97,103,101,32,116,111,32,115,116,100,101,114,114,32,105,
102,32,45,118,47,80,89,84,72,79,78,86,69,82,66,79,
83,69,32,105,115,32,116,117,114,110,101,100,32,111,110,46,
250,1,35,250,7,105,109,112,111,114,116,32,122,2,35,32,
114,54,0,0,0,78,41,2,114,148,0,0,0,114,149,0,
0,0,41,7,114,7,0,0,0,114,117,0,0,0,218,7,
118,101,114,98,111,115,101,114,9,0,0,0,114,140,0,0,
0,114,47,0,0,0,218,6,115,116,100,101,114,114,41,3,
218,7,109,101,115,115,97,103,101,114,147,0,0,0,114,80,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,218,16,95,118,101,114,98,111,115,101,95,109,101,115,
115,97,103,101,7,2,0,0,115,8,0,0,0,0,2,18,
1,15,1,13,1,114,153,0,0,0,99,1,0,0,0,0,
0,0,0,2,0,0,0,4,0,0,0,3,0,0,0,115,
38,0,0,0,100,1,0,135,0,0,102,1,0,100,2,0,
100,3,0,134,1,0,125,1,0,116,0,0,124,1,0,136,
0,0,131,2,0,1,124,1,0,83,41,4,122,252,68,101,
99,111,114,97,116,111,114,32,116,111,32,118,101,114,105,102,
121,32,116,104,97,116,32,116,104,101,32,109,111,100,117,108,
101,32,98,101,105,110,103,32,114,101,113,117,101,115,116,101,
100,32,109,97,116,99,104,101,115,32,116,104,101,32,111,110,
101,32,116,104,101,10,32,32,32,32,108,111,97,100,101,114,
32,99,97,110,32,104,97,110,100,108,101,46,10,10,32,32,
32,32,84,104,101,32,102,105,114,115,116,32,97,114,103,117,
109,101,110,116,32,40,115,101,108,102,41,32,109,117,115,116,
32,100,101,102,105,110,101,32,95,110,97,109,101,32,119,104,
105,99,104,32,116,104,101,32,115,101,99,111,110,100,32,97,
114,103,117,109,101,110,116,32,105,115,10,32,32,32,32,99,
111,109,112,97,114,101,100,32,97,103,97,105,110,115,116,46,
32,73,102,32,116,104,101,32,99,111,109,112,97,114,105,115,
111,110,32,102,97,105,108,115,32,116,104,101,110,32,73,109,
112,111,114,116,69,114,114,111,114,32,105,115,32,114,97,105,
115,101,100,46,10,10,32,32,32,32,78,99,2,0,0,0,
0,0,0,0,4,0,0,0,5,0,0,0,31,0,0,0,
115,83,0,0,0,124,1,0,100,0,0,107,8,0,114,24,
0,124,0,0,106,0,0,125,1,0,110,40,0,124,0,0,
106,0,0,124,1,0,107,3,0,114,64,0,116,1,0,100,
1,0,124,1,0,22,100,2,0,124,1,0,131,1,1,130,
1,0,110,0,0,136,0,0,124,0,0,124,1,0,124,2,
0,124,3,0,142,2,0,83,41,3,78,122,23,108,111,97,
100,101,114,32,99,97,110,110,111,116,32,104,97,110,100,108,
101,32,37,115,114,67,0,0,0,41,2,114,67,0,0,0,
218,11,73,109,112,111,114,116,69,114,114,111,114,41,4,114,
71,0,0,0,114,67,0,0,0,114,80,0,0,0,114,108,
0,0,0,41,1,218,6,109,101,116,104,111,100,114,4,0,
0,0,114,5,0,0,0,218,19,95,99,104,101,99,107,95,
110,97,109,101,95,119,114,97,112,112,101,114,23,2,0,0,
115,10,0,0,0,0,1,12,1,12,1,15,1,25,1,122,
40,95,99,104,101,99,107,95,110,97,109,101,46,60,108,111,
99,97,108,115,62,46,95,99,104,101,99,107,95,110,97,109,
101,95,119,114,97,112,112,101,114,41,1,114,65,0,0,0,
41,2,114,155,0,0,0,114,156,0,0,0,114,4,0,0,
0,41,1,114,155,0,0,0,114,5,0,0,0,218,11,95,
99,104,101,99,107,95,110,97,109,101,15,2,0,0,115,6,
0,0,0,0,8,21,6,13,1,114,157,0,0,0,99,1,
0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,3,
0,0,0,115,35,0,0,0,135,0,0,102,1,0,100,1,
0,100,2,0,134,0,0,125,1,0,116,0,0,124,1,0,
136,0,0,131,2,0,1,124,1,0,83,41,3,122,49,68,
101,99,111,114,97,116,111,114,32,116,111,32,118,101,114,105,
102,121,32,116,104,101,32,110,97,109,101,100,32,109,111,100,
117,108,101,32,105,115,32,98,117,105,108,116,45,105,110,46,
99,2,0,0,0,0,0,0,0,2,0,0,0,4,0,0,
0,19,0,0,0,115,58,0,0,0,124,1,0,116,0,0,
106,1,0,107,7,0,114,45,0,116,2,0,100,1,0,106,
3,0,124,1,0,131,1,0,100,2,0,124,1,0,131,1,
1,130,1,0,110,0,0,136,0,0,124,0,0,124,1,0,
131,2,0,83,41,3,78,122,29,123,33,114,125,32,105,115,
32,110,111,116,32,97,32,98,117,105,108,116,45,105,110,32,
109,111,100,117,108,101,114,67,0,0,0,41,4,114,7,0,
0,0,218,20,98,117,105,108,116,105,110,95,109,111,100,117,
108,101,95,110,97,109,101,115,114,154,0,0,0,114,47,0,
0,0,41,2,114,71,0,0,0,218,8,102,117,108,108,110,
97,109,101,41,1,218,3,102,120,110,114,4,0,0,0,114,
5,0,0,0,218,25,95,114,101,113,117,105,114,101,115,95,
98,117,105,108,116,105,110,95,119,114,97,112,112,101,114,35,
2,0,0,115,8,0,0,0,0,1,15,1,18,1,12,1,
122,52,95,114,101,113,117,105,114,101,115,95,98,117,105,108,
116,105,110,46,60,108,111,99,97,108,115,62,46,95,114,101,
113,117,105,114,101,115,95,98,117,105,108,116,105,110,95,119,
114,97,112,112,101,114,41,1,114,65,0,0,0,41,2,114,
160,0,0,0,114,161,0,0,0,114,4,0,0,0,41,1,
114,160,0,0,0,114,5,0,0,0,218,17,95,114,101,113,
117,105,114,101,115,95,98,117,105,108,116,105,110,33,2,0,
0,115,6,0,0,0,0,2,18,5,13,1,114,162,0,0,
0,99,1,0,0,0,0,0,0,0,2,0,0,0,3,0,
0,0,3,0,0,0,115,35,0,0,0,135,0,0,102,1,
0,100,1,0,100,2,0,134,0,0,125,1,0,116,0,0,
124,1,0,136,0,0,131,2,0,1,124,1,0,83,41,3,
122,47,68,101,99,111,114,97,116,111,114,32,116,111,32,118,
101,114,105,102,121,32,116,104,101,32,110,97,109,101,100,32,
109,111,100,117,108,101,32,105,115,32,102,114,111,122,101,110,
46,99,2,0,0,0,0,0,0,0,2,0,0,0,4,0,
0,0,19,0,0,0,115,58,0,0,0,116,0,0,106,1,
0,124,1,0,131,1,0,115,45,0,116,2,0,100,1,0,
106,3,0,124,1,0,131,1,0,100,2,0,124,1,0,131,
1,1,130,1,0,110,0,0,136,0,0,124,0,0,124,1,
0,131,2,0,83,41,3,78,122,27,123,33,114,125,32,105,
115,32,110,111,116,32,97,32,102,114,111,122,101,110,32,109,
111,100,117,108,101,114,67,0,0,0,41,4,114,106,0,0,
0,218,9,105,115,95,102,114,111,122,101,110,114,154,0,0,
0,114,47,0,0,0,41,2,114,71,0,0,0,114,159,0,
0,0,41,1,114,160,0,0,0,114,4,0,0,0,114,5,
0,0,0,218,24,95,114,101,113,117,105,114,101,115,95,102,
114,111,122,101,110,95,119,114,97,112,112,101,114,46,2,0,
0,115,8,0,0,0,0,1,15,1,18,1,12,1,122,50,
95,114,101,113,117,105,114,101,115,95,102,114,111,122,101,110,
46,60,108,111,99,97,108,115,62,46,95,114,101,113,117,105,
114,101,115,95,102,114,111,122,101,110,95,119,114,97,112,112,
101,114,41,1,114,65,0,0,0,41,2,114,160,0,0,0,
114,164,0,0,0,114,4,0,0,0,41,1,114,160,0,0,
0,114,5,0,0,0,218,16,95,114,101,113,117,105,114,101,
115,95,102,114,111,122,101,110,44,2,0,0,115,6,0,0,
0,0,2,18,5,13,1,114,165,0,0,0,99,2,0,0,
0,0,0,0,0,5,0,0,0,4,0,0,0,67,0,0,
0,115,87,0,0,0,124,0,0,106,0,0,124,1,0,131,
1,0,92,2,0,125,2,0,125,3,0,124,2,0,100,1,
0,107,8,0,114,83,0,116,1,0,124,3,0,131,1,0,
114,83,0,100,2,0,125,4,0,116,2,0,106,3,0,124,
4,0,106,4,0,124,3,0,100,3,0,25,131,1,0,116,
5,0,131,2,0,1,110,0,0,124,2,0,83,41,4,122,
155,84,114,121,32,116,111,32,102,105,110,100,32,97,32,108,
111,97,100,101,114,32,102,111,114,32,116,104,101,32,115,112,
101,99,105,102,105,101,100,32,109,111,100,117,108,101,32,98,
121,32,100,101,108,101,103,97,116,105,110,103,32,116,111,10,
32,32,32,32,115,101,108,102,46,102,105,110,100,95,108,111,
97,100,101,114,40,41,46,10,10,32,32,32,32,84,104,105,
115,32,109,101,116,104,111,100,32,105,115,32,100,101,112,114,
101,99,97,116,101,100,32,105,110,32,102,97,118,111,114,32,
111,102,32,102,105,110,100,101,114,46,102,105,110,100,95,115,
112,101,99,40,41,46,10,10,32,32,32,32,78,122,44,78,
111,116,32,105,109,112,111,114,116,105,110,103,32,100,105,114,
101,99,116,111,114,121,32,123,125,58,32,109,105,115,115,105,
110,103,32,95,95,105,110,105,116,95,95,114,84,0,0,0,
41,6,218,11,102,105,110,100,95,108,111,97,100,101,114,114,
31,0,0,0,218,9,95,119,97,114,110,105,110,103,115,218,
4,119,97,114,110,114,47,0,0,0,218,13,73,109,112,111,
114,116,87,97,114,110,105,110,103,41,5,114,71,0,0,0,
114,159,0,0,0,218,6,108,111,97,100,101,114,218,8,112,
111,114,116,105,111,110,115,218,3,109,115,103,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,17,95,102,105,
110,100,95,109,111,100,117,108,101,95,115,104,105,109,55,2,
0,0,115,10,0,0,0,0,10,21,1,24,1,6,1,32,
1,114,173,0,0,0,99,2,0,0,0,0,0,0,0,5,
0,0,0,3,0,0,0,67,0,0,0,115,93,0,0,0,
116,0,0,124,1,0,124,0,0,131,2,0,125,2,0,116,
1,0,124,2,0,131,1,0,125,3,0,124,1,0,116,2,
0,106,3,0,107,6,0,114,79,0,116,2,0,106,3,0,
124,1,0,25,125,4,0,124,3,0,106,4,0,124,4,0,
131,1,0,1,116,2,0,106,3,0,124,1,0,25,83,124,
3,0,106,5,0,131,0,0,83,100,1,0,83,41,2,122,
128,76,111,97,100,32,116,104,101,32,115,112,101,99,105,102,
105,101,100,32,109,111,100,117,108,101,32,105,110,116,111,32,
115,121,115,46,109,111,100,117,108,101,115,32,97,110,100,32,
114,101,116,117,114,110,32,105,116,46,10,10,32,32,32,32,
84,104,105,115,32,109,101,116,104,111,100,32,105,115,32,100,
101,112,114,101,99,97,116,101,100,46,32,32,85,115,101,32,
108,111,97,100,101,114,46,101,120,101,99,95,109,111,100,117,
108,101,32,105,110,115,116,101,97,100,46,10,10,32,32,32,
32,78,41,6,218,16,115,112,101,99,95,102,114,111,109,95,
108,111,97,100,101,114,218,12,95,83,112,101,99,77,101,116,
104,111,100,115,114,7,0,0,0,114,73,0,0,0,218,4,
101,120,101,99,218,4,108,111,97,100,41,5,114,71,0,0,
0,114,159,0,0,0,218,4,115,112,101,99,218,7,109,101,
116,104,111,100,115,218,6,109,111,100,117,108,101,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,218,17,95,108,
111,97,100,95,109,111,100,117,108,101,95,115,104,105,109,72,
2,0,0,115,14,0,0,0,0,6,15,1,12,1,15,1,
13,1,13,1,11,2,114,181,0,0,0,99,4,0,0,0,
0,0,0,0,11,0,0,0,19,0,0,0,67,0,0,0,
115,255,1,0,0,105,0,0,125,4,0,124,2,0,100,1,
0,107,9,0,114,31,0,124,2,0,124,4,0,100,2,0,
60,110,6,0,100,3,0,125,2,0,124,3,0,100,1,0,
107,9,0,114,62,0,124,3,0,124,4,0,100,4,0,60,
110,0,0,124,0,0,100,1,0,100,5,0,133,2,0,25,
125,5,0,124,0,0,100,5,0,100,6,0,133,2,0,25,
125,6,0,124,0,0,100,6,0,100,7,0,133,2,0,25,
125,7,0,124,5,0,116,0,0,107,3,0,114,171,0,100,
8,0,106,1,0,124,2,0,124,5,0,131,2,0,125,8,
0,116,2,0,100,9,0,124,8,0,131,2,0,1,116,3,
0,124,8,0,124,4,0,141,1,0,130,1,0,110,122,0,
116,4,0,124,6,0,131,1,0,100,5,0,107,3,0,114,
232,0,100,10,0,106,1,0,124,2,0,131,1,0,125,8,
0,116,2,0,100,9,0,124,8,0,131,2,0,1,116,5,
0,124,8,0,131,1,0,130,1,0,110,61,0,116,4,0,
124,7,0,131,1,0,100,5,0,107,3,0,114,37,1,100,
11,0,106,1,0,124,2,0,131,1,0,125,8,0,116,2,
0,100,9,0,124,8,0,131,2,0,1,116,5,0,124,8,
0,131,1,0,130,1,0,110,0,0,124,1,0,100,1,0,
107,9,0,114,241,1,121,20,0,116,6,0,124,1,0,100,
12,0,25,131,1,0,125,9,0,87,110,18,0,4,116,7,
0,107,10,0,114,89,1,1,1,1,89,110,65,0,88,116,
8,0,124,6,0,131,1,0,124,9,0,107,3,0,114,154,
1,100,13,0,106,1,0,124,2,0,131,1,0,125,8,0,
116,2,0,100,9,0,124,8,0,131,2,0,1,116,3,0,
124,8,0,124,4,0,141,1,0,130,1,0,110,0,0,121,
18,0,124,1,0,100,14,0,25,100,15,0,64,125,10,0,
87,110,18,0,4,116,7,0,107,10,0,114,192,1,1,1,
1,89,113,241,1,88,116,8,0,124,7,0,131,1,0,124,
10,0,107,3,0,114,241,1,116,3,0,100,13,0,106,1,
0,124,2,0,131,1,0,124,4,0,141,1,0,130,1,0,
113,241,1,110,0,0,124,0,0,100,7,0,100,1,0,133,
2,0,25,83,41,16,97,122,1,0,0,86,97,108,105,100,
97,116,101,32,116,104,101,32,104,101,97,100,101,114,32,111,
102,32,116,104,101,32,112,97,115,115,101,100,45,105,110,32,
98,121,116,101,99,111,100,101,32,97,103,97,105,110,115,116,
32,115,111,117,114,99,101,95,115,116,97,116,115,32,40,105,
102,10,32,32,32,32,103,105,118,101,110,41,32,97,110,100,
32,114,101,116,117,114,110,105,110,103,32,116,104,101,32,98,
121,116,101,99,111,100,101,32,116,104,97,116,32,99,97,110,
32,98,101,32,99,111,109,112,105,108,101,100,32,98,121,32,
99,111,109,112,105,108,101,40,41,46,10,10,32,32,32,32,
65,108,108,32,111,116,104,101,114,32,97,114,103,117,109,101,
110,116,115,32,97,114,101,32,117,115,101,100,32,116,111,32,
101,110,104,97,110,99,101,32,101,114,114,111,114,32,114,101,
112,111,114,116,105,110,103,46,10,10,32,32,32,32,73,109,
112,111,114,116,69,114,114,111,114,32,105,115,32,114,97,105,
115,101,100,32,119,104,101,110,32,116,104,101,32,109,97,103,
105,99,32,110,117,109,98,101,114,32,105,115,32,105,110,99,
111,114,114,101,99,116,32,111,114,32,116,104,101,32,98,121,
116,101,99,111,100,101,32,105,115,10,32,32,32,32,102,111,
117,110,100,32,116,111,32,98,101,32,115,116,97,108,101,46,
32,69,79,70,69,114,114,111,114,32,105,115,32,114,97,105,
115,101,100,32,119,104,101,110,32,116,104,101,32,100,97,116,
97,32,105,115,32,102,111,117,110,100,32,116,111,32,98,101,
10,32,32,32,32,116,114,117,110,99,97,116,101,100,46,10,
10,32,32,32,32,78,114,67,0,0,0,122,10,60,98,121,
116,101,99,111,100,101,62,114,35,0,0,0,114,12,0,0,
0,233,8,0,0,0,233,12,0,0,0,122,30,98,97,100,
32,109,97,103,105,99,32,110,117,109,98,101,114,32,105,110,
32,123,33,114,125,58,32,123,33,114,125,122,2,123,125,122,
43,114,101,97,99,104,101,100,32,69,79,70,32,119,104,105,
108,101,32,114,101,97,100,105,110,103,32,116,105,109,101,115,
116,97,109,112,32,105,110,32,123,33,114,125,122,48,114,101,
97,99,104,101,100,32,69,79,70,32,119,104,105,108,101,32,
114,101,97,100,105,110,103,32,115,105,122,101,32,111,102,32,
115,111,117,114,99,101,32,105,110,32,123,33,114,125,218,5,
109,116,105,109,101,122,26,98,121,116,101,99,111,100,101,32,
105,115,32,115,116,97,108,101,32,102,111,114,32,123,33,114,
125,218,4,115,105,122,101,108,3,0,0,0,255,127,255,127,
3,0,41,9,218,12,77,65,71,73,67,95,78,85,77,66,
69,82,114,47,0,0,0,114,153,0,0,0,114,154,0,0,
0,114,31,0,0,0,218,8,69,79,70,69,114,114,111,114,
114,14,0,0,0,114,79,0,0,0,114,19,0,0,0,41,
11,114,53,0,0,0,218,12,115,111,117,114,99,101,95,115,
116,97,116,115,114,67,0,0,0,114,35,0,0,0,90,11,
101,120,99,95,100,101,116,97,105,108,115,90,5,109,97,103,
105,99,90,13,114,97,119,95,116,105,109,101,115,116,97,109,
112,90,8,114,97,119,95,115,105,122,101,114,152,0,0,0,
218,12,115,111,117,114,99,101,95,109,116,105,109,101,218,11,
115,111,117,114,99,101,95,115,105,122,101,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,218,25,95,118,97,108,
105,100,97,116,101,95,98,121,116,101,99,111,100,101,95,104,
101,97,100,101,114,88,2,0,0,115,76,0,0,0,0,11,
6,1,12,1,13,3,6,1,12,1,13,1,16,1,16,1,
16,1,12,1,18,1,13,1,18,1,18,1,15,1,13,1,
15,1,18,1,15,1,13,1,15,1,12,1,3,1,20,1,
13,1,5,2,18,1,15,1,13,1,18,1,3,1,18,1,
13,1,5,2,18,1,15,1,15,1,114,191,0,0,0,99,
4,0,0,0,0,0,0,0,5,0,0,0,6,0,0,0,
67,0,0,0,115,115,0,0,0,116,0,0,106,1,0,124,
0,0,131,1,0,125,4,0,116,2,0,124,4,0,116,3,
0,131,2,0,114,78,0,116,4,0,100,1,0,124,2,0,
131,2,0,1,124,3,0,100,2,0,107,9,0,114,74,0,
116,5,0,106,6,0,124,4,0,124,3,0,131,2,0,1,
110,0,0,124,4,0,83,116,7,0,100,3,0,106,8,0,
124,2,0,131,1,0,100,4,0,124,1,0,100,5,0,124,
2,0,131,1,2,130,1,0,100,2,0,83,41,6,122,60,
67,111,109,112,105,108,101,32,98,121,116,101,99,111,100,101,
32,97,115,32,114,101,116,117,114,110,101,100,32,98,121,32,
95,118,97,108,105,100,97,116,101,95,98,121,116,101,99,111,
100,101,95,104,101,97,100,101,114,40,41,46,122,21,99,111,
100,101,32,111,98,106,101,99,116,32,102,114,111,109,32,123,
33,114,125,78,122,23,78,111,110,45,99,111,100,101,32,111,
98,106,101,99,116,32,105,110,32,123,33,114,125,114,67,0,
0,0,114,35,0,0,0,41,9,218,7,109,97,114,115,104,
97,108,90,5,108,111,97,100,115,218,10,105,115,105,110,115,
116,97,110,99,101,218,10,95,99,111,100,101,95,116,121,112,
101,114,153,0,0,0,114,106,0,0,0,90,16,95,102,105,
120,95,99,111,95,102,105,108,101,110,97,109,101,114,154,0,
0,0,114,47,0,0,0,41,5,114,53,0,0,0,114,67,
0,0,0,114,142,0,0,0,114,143,0,0,0,218,4,99,
111,100,101,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,218,17,95,99,111,109,112,105,108,101,95,98,121,116,
101,99,111,100,101,143,2,0,0,115,16,0,0,0,0,2,
15,1,15,1,13,1,12,1,19,1,4,2,18,1,114,196,
0,0,0,114,84,0,0,0,99,3,0,0,0,0,0,0,
0,4,0,0,0,3,0,0,0,67,0,0,0,115,76,0,
0,0,116,0,0,116,1,0,131,1,0,125,3,0,124,3,
0,106,2,0,116,3,0,124,1,0,131,1,0,131,1,0,
1,124,3,0,106,2,0,116,3,0,124,2,0,131,1,0,
131,1,0,1,124,3,0,106,2,0,116,4,0,106,5,0,
124,0,0,131,1,0,131,1,0,1,124,3,0,83,41,1,
122,80,67,111,109,112,105,108,101,32,97,32,99,111,100,101,
32,111,98,106,101,99,116,32,105,110,116,111,32,98,121,116,
101,99,111,100,101,32,102,111,114,32,119,114,105,116,105,110,
103,32,111,117,116,32,116,111,32,97,32,98,121,116,101,45,
99,111,109,112,105,108,101,100,10,32,32,32,32,102,105,108,
101,46,41,6,218,9,98,121,116,101,97,114,114,97,121,114,
186,0,0,0,218,6,101,120,116,101,110,100,114,17,0,0,
0,114,192,0,0,0,90,5,100,117,109,112,115,41,4,114,
195,0,0,0,114,184,0,0,0,114,190,0,0,0,114,53,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,218,17,95,99,111,100,101,95,116,111,95,98,121,116,
101,99,111,100,101,155,2,0,0,115,10,0,0,0,0,3,
12,1,19,1,19,1,22,1,114,199,0,0,0,99,1,0,
0,0,0,0,0,0,5,0,0,0,4,0,0,0,67,0,
0,0,115,89,0,0,0,100,1,0,100,2,0,108,0,0,
125,1,0,116,1,0,106,2,0,124,0,0,131,1,0,106,
3,0,125,2,0,124,1,0,106,4,0,124,2,0,131,1,
0,125,3,0,116,1,0,106,5,0,100,2,0,100,3,0,
131,2,0,125,4,0,124,4,0,106,6,0,124,0,0,106,
6,0,124,3,0,100,1,0,25,131,1,0,131,1,0,83,
41,4,122,121,68,101,99,111,100,101,32,98,121,116,101,115,
32,114,101,112,114,101,115,101,110,116,105,110,103,32,115,111,
117,114,99,101,32,99,111,100,101,32,97,110,100,32,114,101,
116,117,114,110,32,116,104,101,32,115,116,114,105,110,103,46,
10,10,32,32,32,32,85,110,105,118,101,114,115,97,108,32,
110,101,119,108,105,110,101,32,115,117,112,112,111,114,116,32,
105,115,32,117,115,101,100,32,105,110,32,116,104,101,32,100,
101,99,111,100,105,110,103,46,10,32,32,32,32,114,84,0,
0,0,78,84,41,7,218,8,116,111,107,101,110,105,122,101,
114,49,0,0,0,90,7,66,121,116,101,115,73,79,90,8,
114,101,97,100,108,105,110,101,90,15,100,101,116,101,99,116,
95,101,110,99,111,100,105,110,103,90,25,73,110,99,114,101,
109,101,110,116,97,108,78,101,119,108,105,110,101,68,101,99,
111,100,101,114,218,6,100,101,99,111,100,101,41,5,218,12,
115,111,117,114,99,101,95,98,121,116,101,115,114,200,0,0,
0,90,21,115,111,117,114,99,101,95,98,121,116,101,115,95,
114,101,97,100,108,105,110,101,218,8,101,110,99,111,100,105,
110,103,90,15,110,101,119,108,105,110,101,95,100,101,99,111,
100,101,114,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,218,13,100,101,99,111,100,101,95,115,111,117,114,99,
101,165,2,0,0,115,10,0,0,0,0,5,12,1,18,1,
15,1,18,1,114,204,0,0,0,99,1,0,0,0,0,0,
0,0,5,0,0,0,35,0,0,0,67,0,0,0,115,15,
1,0,0,116,0,0,124,0,0,100,1,0,100,0,0,131,
3,0,125,1,0,116,1,0,124,1,0,100,2,0,131,2,
0,114,74,0,121,17,0,124,1,0,106,2,0,124,0,0,
131,1,0,83,87,113,74,0,4,116,3,0,107,10,0,114,
70,0,1,1,1,89,113,74,0,88,110,0,0,121,13,0,
124,0,0,106,4,0,125,2,0,87,110,18,0,4,116,5,
0,107,10,0,114,107,0,1,1,1,89,110,29,0,88,124,
2,0,100,0,0,107,9,0,114,136,0,116,6,0,124,2,
0,131,1,0,106,2,0,131,0,0,83,121,13,0,124,0,
0,106,7,0,125,3,0,87,110,24,0,4,116,5,0,107,
10,0,114,175,0,1,1,1,100,3,0,125,3,0,89,110,
1,0,88,121,13,0,124,0,0,106,8,0,125,4,0,87,
110,59,0,4,116,5,0,107,10,0,114,250,0,1,1,1,
124,1,0,100,0,0,107,8,0,114,230,0,100,4,0,106,
9,0,124,3,0,131,1,0,83,100,5,0,106,9,0,124,
3,0,124,1,0,131,2,0,83,89,110,17,0,88,100,6,
0,106,9,0,124,3,0,124,4,0,131,2,0,83,100,0,
0,83,41,7,78,218,10,95,95,108,111,97,100,101,114,95,
95,218,11,109,111,100,117,108,101,95,114,101,112,114,250,1,
63,122,13,60,109,111,100,117,108,101,32,123,33,114,125,62,
122,20,60,109,111,100,117,108,101,32,123,33,114,125,32,40,
123,33,114,125,41,62,122,23,60,109,111,100,117,108,101,32,
123,33,114,125,32,102,114,111,109,32,123,33,114,125,62,41,
10,114,62,0,0,0,114,60,0,0,0,114,206,0,0,0,
218,9,69,120,99,101,112,116,105,111,110,218,8,95,95,115,
112,101,99,95,95,218,14,65,116,116,114,105,98,117,116,101,
69,114,114,111,114,114,175,0,0,0,114,57,0,0,0,218,
8,95,95,102,105,108,101,95,95,114,47,0,0,0,41,5,
114,180,0,0,0,114,170,0,0,0,114,178,0,0,0,114,
67,0,0,0,114,131,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,12,95,109,111,100,117,108,
101,95,114,101,112,114,179,2,0,0,115,46,0,0,0,0,
2,18,1,15,4,3,1,17,1,13,1,8,1,3,1,13,
1,13,1,5,2,12,1,16,4,3,1,13,1,13,1,11,
1,3,1,13,1,13,1,12,1,13,2,21,2,114,212,0,
0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,2,
0,0,0,64,0,0,0,115,52,0,0,0,101,0,0,90,
1,0,100,0,0,90,2,0,100,1,0,100,2,0,132,0,
0,90,3,0,100,3,0,100,4,0,132,0,0,90,4,0,
100,5,0,100,6,0,132,0,0,90,5,0,100,7,0,83,
41,8,218,17,95,105,110,115,116,97,108,108,101,100,95,115,
97,102,101,108,121,99,2,0,0,0,0,0,0,0,2,0,
0,0,2,0,0,0,67,0,0,0,115,25,0,0,0,124,
1,0,124,0,0,95,0,0,124,1,0,106,1,0,124,0,
0,95,2,0,100,0,0,83,41,1,78,41,3,218,7,95,
109,111,100,117,108,101,114,209,0,0,0,218,5,95,115,112,
101,99,41,2,114,71,0,0,0,114,180,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,72,0,
0,0,217,2,0,0,115,4,0,0,0,0,1,9,1,122,
26,95,105,110,115,116,97,108,108,101,100,95,115,97,102,101,
108,121,46,95,95,105,110,105,116,95,95,99,1,0,0,0,
0,0,0,0,1,0,0,0,3,0,0,0,67,0,0,0,
115,38,0,0,0,100,1,0,124,0,0,106,0,0,95,1,
0,124,0,0,106,2,0,116,3,0,106,4,0,124,0,0,
106,0,0,106,5,0,60,100,0,0,83,41,2,78,84,41,
6,114,215,0,0,0,218,13,95,105,110,105,116,105,97,108,
105,122,105,110,103,114,214,0,0,0,114,7,0,0,0,114,
73,0,0,0,114,67,0,0,0,41,1,114,71,0,0,0,
114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
75,0,0,0,221,2,0,0,115,4,0,0,0,0,4,12,
1,122,27,95,105,110,115,116,97,108,108,101,100,95,115,97,
102,101,108,121,46,95,95,101,110,116,101,114,95,95,99,1,
0,0,0,0,0,0,0,3,0,0,0,17,0,0,0,71,
0,0,0,115,121,0,0,0,122,101,0,124,0,0,106,0,
0,125,2,0,116,1,0,100,1,0,100,2,0,132,0,0,
124,1,0,68,131,1,0,131,1,0,114,78,0,121,17,0,
116,2,0,106,3,0,124,2,0,106,4,0,61,87,113,100,
0,4,116,5,0,107,10,0,114,74,0,1,1,1,89,113,
100,0,88,110,22,0,116,6,0,100,3,0,124,2,0,106,
4,0,124,2,0,106,7,0,131,3,0,1,87,100,0,0,
100,4,0,124,0,0,106,0,0,95,8,0,88,100,0,0,
83,41,5,78,99,1,0,0,0,0,0,0,0,2,0,0,
0,3,0,0,0,115,0,0,0,115,27,0,0,0,124,0,
0,93,17,0,125,1,0,124,1,0,100,0,0,107,9,0,
86,1,113,3,0,100,0,0,83,41,1,78,114,4,0,0,
0,41,2,114,22,0,0,0,114,76,0,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,114,77,0,0,
0,231,2,0,0,115,2,0,0,0,6,0,122,45,95,105,
110,115,116,97,108,108,101,100,95,115,97,102,101,108,121,46,
95,95,101,120,105,116,95,95,46,60,108,111,99,97,108,115,
62,46,60,103,101,110,101,120,112,114,62,122,18,105,109,112,
111,114,116,32,123,33,114,125,32,35,32,123,33,114,125,70,
41,9,114,215,0,0,0,114,78,0,0,0,114,7,0,0,
0,114,73,0,0,0,114,67,0,0,0,114,79,0,0,0,
114,153,0,0,0,114,170,0,0,0,114,216,0,0,0,41,
3,114,71,0,0,0,114,80,0,0,0,114,178,0,0,0,
114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
81,0,0,0,228,2,0,0,115,18,0,0,0,0,1,3,
1,9,1,25,1,3,1,17,1,13,1,8,2,26,2,122,
26,95,105,110,115,116,97,108,108,101,100,95,115,97,102,101,
108,121,46,95,95,101,120,105,116,95,95,78,41,6,114,57,
0,0,0,114,56,0,0,0,114,58,0,0,0,114,72,0,
0,0,114,75,0,0,0,114,81,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,213,0,0,0,215,2,0,0,115,6,0,0,0,12,2,
12,4,12,7,114,213,0,0,0,99,0,0,0,0,0,0,
0,0,0,0,0,0,8,0,0,0,64,0,0,0,115,172,
0,0,0,101,0,0,90,1,0,100,0,0,90,2,0,100,
1,0,90,3,0,100,2,0,100,3,0,100,4,0,100,3,
0,100,5,0,100,3,0,100,6,0,100,7,0,132,0,3,
90,4,0,100,8,0,100,9,0,132,0,0,90,5,0,100,
10,0,100,11,0,132,0,0,90,6,0,101,7,0,100,12,
0,100,13,0,132,0,0,131,1,0,90,8,0,101,8,0,
106,9,0,100,14,0,100,13,0,132,0,0,131,1,0,90,
8,0,101,7,0,100,15,0,100,16,0,132,0,0,131,1,
0,90,10,0,101,7,0,100,17,0,100,18,0,132,0,0,
131,1,0,90,11,0,101,11,0,106,9,0,100,19,0,100,
18,0,132,0,0,131,1,0,90,11,0,100,3,0,83,41,
20,218,10,77,111,100,117,108,101,83,112,101,99,97,208,5,
0,0,84,104,101,32,115,112,101,99,105,102,105,99,97,116,
105,111,110,32,102,111,114,32,97,32,109,111,100,117,108,101,
44,32,117,115,101,100,32,102,111,114,32,108,111,97,100,105,
110,103,46,10,10,32,32,32,32,65,32,109,111,100,117,108,
101,39,115,32,115,112,101,99,32,105,115,32,116,104,101,32,
115,111,117,114,99,101,32,102,111,114,32,105,110,102,111,114,
109,97,116,105,111,110,32,97,98,111,117,116,32,116,104,101,
32,109,111,100,117,108,101,46,32,32,70,111,114,10,32,32,
32,32,100,97,116,97,32,97,115,115,111,99,105,97,116,101,
100,32,119,105,116,104,32,116,104,101,32,109,111,100,117,108,
101,44,32,105,110,99,108,117,100,105,110,103,32,115,111,117,
114,99,101,44,32,117,115,101,32,116,104,101,32,115,112,101,
99,39,115,10,32,32,32,32,108,111,97,100,101,114,46,10,
10,32,32,32,32,96,110,97,109,101,96,32,105,115,32,116,
104,101,32,97,98,115,111,108,117,116,101,32,110,97,109,101,
32,111,102,32,116,104,101,32,109,111,100,117,108,101,46,32,
32,96,108,111,97,100,101,114,96,32,105,115,32,116,104,101,
32,108,111,97,100,101,114,10,32,32,32,32,116,111,32,117,
115,101,32,119,104,101,110,32,108,111,97,100,105,110,103,32,
116,104,101,32,109,111,100,117,108,101,46,32,32,96,112,97,
114,101,110,116,96,32,105,115,32,116,104,101,32,110,97,109,
101,32,111,102,32,116,104,101,10,32,32,32,32,112,97,99,
107,97,103,101,32,116,104,101,32,109,111,100,117,108,101,32,
105,115,32,105,110,46,32,32,84,104,101,32,112,97,114,101,
110,116,32,105,115,32,100,101,114,105,118,101,100,32,102,114,
111,109,32,116,104,101,32,110,97,109,101,46,10,10,32,32,
32,32,96,105,115,95,112,97,99,107,97,103,101,96,32,100,
101,116,101,114,109,105,110,101,115,32,105,102,32,116,104,101,
32,109,111,100,117,108,101,32,105,115,32,99,111,110,115,105,
100,101,114,101,100,32,97,32,112,97,99,107,97,103,101,32,
111,114,10,32,32,32,32,110,111,116,46,32,32,79,110,32,
109,111,100,117,108,101,115,32,116,104,105,115,32,105,115,32,
114,101,102,108,101,99,116,101,100,32,98,121,32,116,104,101,
32,96,95,95,112,97,116,104,95,95,96,32,97,116,116,114,
105,98,117,116,101,46,10,10,32,32,32,32,96,111,114,105,
103,105,110,96,32,105,115,32,116,104,101,32,115,112,101,99,
105,102,105,99,32,108,111,99,97,116,105,111,110,32,117,115,
101,100,32,98,121,32,116,104,101,32,108,111,97,100,101,114,
32,102,114,111,109,32,119,104,105,99,104,32,116,111,10,32,
32,32,32,108,111,97,100,32,116,104,101,32,109,111,100,117,
108,101,44,32,105,102,32,116,104,97,116,32,105,110,102,111,
114,109,97,116,105,111,110,32,105,115,32,97,118,97,105,108,
97,98,108,101,46,32,32,87,104,101,110,32,102,105,108,101,
110,97,109,101,32,105,115,10,32,32,32,32,115,101,116,44,
32,111,114,105,103,105,110,32,119,105,108,108,32,109,97,116,
99,104,46,10,10,32,32,32,32,96,104,97,115,95,108,111,
99,97,116,105,111,110,96,32,105,110,100,105,99,97,116,101,
115,32,116,104,97,116,32,97,32,115,112,101,99,39,115,32,
34,111,114,105,103,105,110,34,32,114,101,102,108,101,99,116,
115,32,97,32,108,111,99,97,116,105,111,110,46,10,32,32,
32,32,87,104,101,110,32,116,104,105,115,32,105,115,32,84,
114,117,101,44,32,96,95,95,102,105,108,101,95,95,96,32,
97,116,116,114,105,98,117,116,101,32,111,102,32,116,104,101,
32,109,111,100,117,108,101,32,105,115,32,115,101,116,46,10,
10,32,32,32,32,96,99,97,99,104,101,100,96,32,105,115,
32,116,104,101,32,108,111,99,97,116,105,111,110,32,111,102,
32,116,104,101,32,99,97,99,104,101,100,32,98,121,116,101,
99,111,100,101,32,102,105,108,101,44,32,105,102,32,97,110,
121,46,32,32,73,116,10,32,32,32,32,99,111,114,114,101,
115,112,111,110,100,115,32,116,111,32,116,104,101,32,96,95,
95,99,97,99,104,101,100,95,95,96,32,97,116,116,114,105,
98,117,116,101,46,10,10,32,32,32,32,96,115,117,98,109,
111,100,117,108,101,95,115,101,97,114,99,104,95,108,111,99,
97,116,105,111,110,115,96,32,105,115,32,116,104,101,32,115,
101,113,117,101,110,99,101,32,111,102,32,112,97,116,104,32,
101,110,116,114,105,101,115,32,116,111,10,32,32,32,32,115,
101,97,114,99,104,32,119,104,101,110,32,105,109,112,111,114,
116,105,110,103,32,115,117,98,109,111,100,117,108,101,115,46,
32,32,73,102,32,115,101,116,44,32,105,115,95,112,97,99,
107,97,103,101,32,115,104,111,117,108,100,32,98,101,10,32,
32,32,32,84,114,117,101,45,45,97,110,100,32,70,97,108,
115,101,32,111,116,104,101,114,119,105,115,101,46,10,10,32,
32,32,32,80,97,99,107,97,103,101,115,32,97,114,101,32,
115,105,109,112,108,121,32,109,111,100,117,108,101,115,32,116,
104,97,116,32,40,109,97,121,41,32,104,97,118,101,32,115,
117,98,109,111,100,117,108,101,115,46,32,32,73,102,32,97,
32,115,112,101,99,10,32,32,32,32,104,97,115,32,97,32,
110,111,110,45,78,111,110,101,32,118,97,108,117,101,32,105,
110,32,96,115,117,98,109,111,100,117,108,101,95,115,101,97,
114,99,104,95,108,111,99,97,116,105,111,110,115,96,44,32,
116,104,101,32,105,109,112,111,114,116,10,32,32,32,32,115,
121,115,116,101,109,32,119,105,108,108,32,99,111,110,115,105,
100,101,114,32,109,111,100,117,108,101,115,32,108,111,97,100,
101,100,32,102,114,111,109,32,116,104,101,32,115,112,101,99,
32,97,115,32,112,97,99,107,97,103,101,115,46,10,10,32,
32,32,32,79,110,108,121,32,102,105,110,100,101,114,115,32,
40,115,101,101,32,105,109,112,111,114,116,108,105,98,46,97,
98,99,46,77,101,116,97,80,97,116,104,70,105,110,100,101,
114,32,97,110,100,10,32,32,32,32,105,109,112,111,114,116,
108,105,98,46,97,98,99,46,80,97,116,104,69,110,116,114,
121,70,105,110,100,101,114,41,32,115,104,111,117,108,100,32,
109,111,100,105,102,121,32,77,111,100,117,108,101,83,112,101,
99,32,105,110,115,116,97,110,99,101,115,46,10,10,32,32,
32,32,218,6,111,114,105,103,105,110,78,218,12,108,111,97,
100,101,114,95,115,116,97,116,101,218,10,105,115,95,112,97,
99,107,97,103,101,99,3,0,0,0,3,0,0,0,6,0,
0,0,2,0,0,0,67,0,0,0,115,79,0,0,0,124,
1,0,124,0,0,95,0,0,124,2,0,124,0,0,95,1,
0,124,3,0,124,0,0,95,2,0,124,4,0,124,0,0,
95,3,0,124,5,0,114,48,0,103,0,0,110,3,0,100,
0,0,124,0,0,95,4,0,100,1,0,124,0,0,95,5,
0,100,0,0,124,0,0,95,6,0,100,0,0,83,41,2,
78,70,41,7,114,67,0,0,0,114,170,0,0,0,114,218,
0,0,0,114,219,0,0,0,218,26,115,117,98,109,111,100,
117,108,101,95,115,101,97,114,99,104,95,108,111,99,97,116,
105,111,110,115,218,13,95,115,101,116,95,102,105,108,101,97,
116,116,114,218,7,95,99,97,99,104,101,100,41,6,114,71,
0,0,0,114,67,0,0,0,114,170,0,0,0,114,218,0,
0,0,114,219,0,0,0,114,220,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,72,0,0,0,
23,3,0,0,115,14,0,0,0,0,2,9,1,9,1,9,
1,9,1,21,3,9,1,122,19,77,111,100,117,108,101,83,
112,101,99,46,95,95,105,110,105,116,95,95,99,1,0,0,
0,0,0,0,0,2,0,0,0,4,0,0,0,67,0,0,
0,115,153,0,0,0,100,1,0,106,0,0,124,0,0,106,
1,0,131,1,0,100,2,0,106,0,0,124,0,0,106,2,
0,131,1,0,103,2,0,125,1,0,124,0,0,106,3,0,
100,0,0,107,9,0,114,79,0,124,1,0,106,4,0,100,
3,0,106,0,0,124,0,0,106,3,0,131,1,0,131,1,
0,1,110,0,0,124,0,0,106,5,0,100,0,0,107,9,
0,114,122,0,124,1,0,106,4,0,100,4,0,106,0,0,
124,0,0,106,5,0,131,1,0,131,1,0,1,110,0,0,
100,5,0,106,0,0,124,0,0,106,6,0,106,7,0,100,
6,0,106,8,0,124,1,0,131,1,0,131,2,0,83,41,
7,78,122,9,110,97,109,101,61,123,33,114,125,122,11,108,
111,97,100,101,114,61,123,33,114,125,122,11,111,114,105,103,
105,110,61,123,33,114,125,122,29,115,117,98,109,111,100,117,
108,101,95,115,101,97,114,99,104,95,108,111,99,97,116,105,
111,110,115,61,123,125,122,6,123,125,40,123,125,41,122,2,
44,32,41,9,114,47,0,0,0,114,67,0,0,0,114,170,
0,0,0,114,218,0,0,0,218,6,97,112,112,101,110,100,
114,221,0,0,0,218,9,95,95,99,108,97,115,115,95,95,
114,57,0,0,0,114,26,0,0,0,41,2,114,71,0,0,
0,114,80,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,101,0,0,0,35,3,0,0,115,16,
0,0,0,0,1,15,1,21,1,15,1,28,1,15,1,12,
1,16,1,122,19,77,111,100,117,108,101,83,112,101,99,46,
95,95,114,101,112,114,95,95,99,2,0,0,0,0,0,0,
0,3,0,0,0,11,0,0,0,67,0,0,0,115,145,0,
0,0,124,0,0,106,0,0,125,2,0,121,107,0,124,0,
0,106,1,0,124,1,0,106,1,0,107,2,0,111,114,0,
124,0,0,106,2,0,124,1,0,106,2,0,107,2,0,111,
114,0,124,0,0,106,3,0,124,1,0,106,3,0,107,2,
0,111,114,0,124,2,0,124,1,0,106,0,0,107,2,0,
111,114,0,124,0,0,106,4,0,124,1,0,106,4,0,107,
2,0,111,114,0,124,0,0,106,5,0,124,1,0,106,5,
0,107,2,0,83,87,110,22,0,4,116,6,0,107,10,0,
114,140,0,1,1,1,100,1,0,83,89,110,1,0,88,100,
0,0,83,41,2,78,70,41,7,114,221,0,0,0,114,67,
0,0,0,114,170,0,0,0,114,218,0,0,0,218,6,99,
97,99,104,101,100,218,12,104,97,115,95,108,111,99,97,116,
105,111,110,114,210,0,0,0,41,3,114,71,0,0,0,218,
5,111,116,104,101,114,218,4,115,109,115,108,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,6,95,95,101,
113,95,95,45,3,0,0,115,20,0,0,0,0,1,9,1,
3,1,18,1,18,1,18,1,15,1,18,1,20,1,13,1,
122,17,77,111,100,117,108,101,83,112,101,99,46,95,95,101,
113,95,95,99,1,0,0,0,0,0,0,0,2,0,0,0,
11,0,0,0,67,0,0,0,115,158,0,0,0,124,0,0,
106,0,0,100,0,0,107,8,0,114,151,0,124,0,0,106,
1,0,100,0,0,107,9,0,114,151,0,124,0,0,106,2,
0,114,151,0,124,0,0,106,1,0,125,1,0,124,1,0,
106,3,0,116,4,0,116,5,0,131,1,0,131,1,0,114,
112,0,121,19,0,116,6,0,124,1,0,131,1,0,124,0,
0,95,0,0,87,113,145,0,4,116,7,0,107,10,0,114,
108,0,1,1,1,89,113,145,0,88,113,148,0,124,1,0,
106,3,0,116,4,0,116,8,0,131,1,0,131,1,0,114,
148,0,124,1,0,124,0,0,95,0,0,113,148,0,113,151,
0,110,0,0,124,0,0,106,0,0,83,41,1,78,41,9,
114,223,0,0,0,114,218,0,0,0,114,222,0,0,0,218,
8,101,110,100,115,119,105,116,104,218,5,116,117,112,108,101,
114,135,0,0,0,114,132,0,0,0,114,123,0,0,0,218,
17,66,89,84,69,67,79,68,69,95,83,85,70,70,73,88,
69,83,41,2,114,71,0,0,0,114,131,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,226,0,
0,0,57,3,0,0,115,22,0,0,0,0,2,15,1,24,
1,9,1,21,1,3,1,19,1,13,1,8,1,21,1,18,
1,122,17,77,111,100,117,108,101,83,112,101,99,46,99,97,
99,104,101,100,99,2,0,0,0,0,0,0,0,2,0,0,
0,2,0,0,0,67,0,0,0,115,13,0,0,0,124,1,
0,124,0,0,95,0,0,100,0,0,83,41,1,78,41,1,
114,223,0,0,0,41,2,114,71,0,0,0,114,226,0,0,
0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,226,0,0,0,71,3,0,0,115,2,0,0,0,0,2,
99,1,0,0,0,0,0,0,0,1,0,0,0,2,0,0,
0,67,0,0,0,115,46,0,0,0,124,0,0,106,0,0,
100,1,0,107,8,0,114,35,0,124,0,0,106,1,0,106,
2,0,100,2,0,131,1,0,100,3,0,25,83,124,0,0,
106,1,0,83,100,1,0,83,41,4,122,32,84,104,101,32,
110,97,109,101,32,111,102,32,116,104,101,32,109,111,100,117,
108,101,39,115,32,112,97,114,101,110,116,46,78,114,116,0,
0,0,114,84,0,0,0,41,3,114,221,0,0,0,114,67,
0,0,0,114,32,0,0,0,41,1,114,71,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,6,
112,97,114,101,110,116,75,3,0,0,115,6,0,0,0,0,
3,15,1,20,2,122,17,77,111,100,117,108,101,83,112,101,
99,46,112,97,114,101,110,116,99,1,0,0,0,0,0,0,
0,1,0,0,0,1,0,0,0,67,0,0,0,115,7,0,
0,0,124,0,0,106,0,0,83,41,1,78,41,1,114,222,
0,0,0,41,1,114,71,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,114,227,0,0,0,83,3,
0,0,115,2,0,0,0,0,2,122,23,77,111,100,117,108,
101,83,112,101,99,46,104,97,115,95,108,111,99,97,116,105,
111,110,99,2,0,0,0,0,0,0,0,2,0,0,0,2,
0,0,0,67,0,0,0,115,19,0,0,0,116,0,0,124,
1,0,131,1,0,124,0,0,95,1,0,100,0,0,83,41,
1,78,41,2,218,4,98,111,111,108,114,222,0,0,0,41,
2,114,71,0,0,0,218,5,118,97,108,117,101,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,114,227,0,0,
0,87,3,0,0,115,2,0,0,0,0,2,41,12,114,57,
0,0,0,114,56,0,0,0,114,58,0,0,0,114,59,0,
0,0,114,72,0,0,0,114,101,0,0,0,114,230,0,0,
0,218,8,112,114,111,112,101,114,116,121,114,226,0,0,0,
218,6,115,101,116,116,101,114,114,234,0,0,0,114,227,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,217,0,0,0,242,2,0,0,115,
20,0,0,0,12,35,6,2,15,1,15,11,12,10,12,12,
18,14,21,4,18,8,18,4,114,217,0,0,0,114,218,0,
0,0,114,220,0,0,0,99,2,0,0,0,2,0,0,0,
5,0,0,0,15,0,0,0,67,0,0,0,115,193,0,0,
0,116,0,0,124,1,0,100,1,0,131,2,0,114,83,0,
124,3,0,100,2,0,107,8,0,114,43,0,116,1,0,124,
0,0,100,3,0,124,1,0,131,1,1,83,124,3,0,114,
55,0,103,0,0,110,3,0,100,2,0,125,4,0,116,1,
0,124,0,0,100,3,0,124,1,0,100,4,0,124,4,0,
131,1,2,83,124,3,0,100,2,0,107,8,0,114,168,0,
116,0,0,124,1,0,100,5,0,131,2,0,114,159,0,121,
19,0,124,1,0,106,2,0,124,0,0,131,1,0,125,3,
0,87,113,165,0,4,116,3,0,107,10,0,114,155,0,1,
1,1,100,2,0,125,3,0,89,113,165,0,88,113,168,0,
100,6,0,125,3,0,110,0,0,116,4,0,124,0,0,124,
1,0,100,7,0,124,2,0,100,5,0,124,3,0,131,2,
2,83,41,8,122,53,82,101,116,117,114,110,32,97,32,109,
111,100,117,108,101,32,115,112,101,99,32,98,97,115,101,100,
32,111,110,32,118,97,114,105,111,117,115,32,108,111,97,100,
101,114,32,109,101,116,104,111,100,115,46,218,12,103,101,116,
95,102,105,108,101,110,97,109,101,78,114,170,0,0,0,114,
221,0,0,0,114,220,0,0,0,70,114,218,0,0,0,41,
5,114,60,0,0,0,218,23,115,112,101,99,95,102,114,111,
109,95,102,105,108,101,95,108,111,99,97,116,105,111,110,114,
220,0,0,0,114,154,0,0,0,114,217,0,0,0,41,5,
114,67,0,0,0,114,170,0,0,0,114,218,0,0,0,114,
220,0,0,0,90,6,115,101,97,114,99,104,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,174,0,0,0,
92,3,0,0,115,28,0,0,0,0,2,15,1,12,1,16,
1,18,1,15,1,7,2,12,1,15,1,3,1,19,1,13,
1,14,3,9,2,114,174,0,0,0,114,170,0,0,0,114,
221,0,0,0,99,2,0,0,0,2,0,0,0,9,0,0,
0,19,0,0,0,67,0,0,0,115,110,1,0,0,124,1,
0,100,1,0,107,8,0,114,79,0,100,2,0,125,1,0,
116,0,0,124,2,0,100,3,0,131,2,0,114,79,0,121,
19,0,124,2,0,106,1,0,124,0,0,131,1,0,125,1,
0,87,113,76,0,4,116,2,0,107,10,0,114,72,0,1,
1,1,89,113,76,0,88,113,79,0,110,0,0,116,3,0,
124,0,0,124,2,0,100,4,0,124,1,0,131,2,1,125,
4,0,100,5,0,124,4,0,95,4,0,124,2,0,100,1,
0,107,8,0,114,203,0,120,79,0,116,5,0,131,0,0,
68,93,61,0,92,2,0,125,5,0,125,6,0,124,1,0,
106,6,0,116,7,0,124,6,0,131,1,0,131,1,0,114,
131,0,124,5,0,124,0,0,124,1,0,131,2,0,125,2,
0,124,2,0,124,4,0,95,8,0,80,113,131,0,113,131,
0,87,100,1,0,83,110,0,0,124,3,0,116,9,0,107,
8,0,114,38,1,116,0,0,124,2,0,100,6,0,131,2,
0,114,47,1,121,19,0,124,2,0,106,10,0,124,0,0,
131,1,0,125,7,0,87,110,18,0,4,116,2,0,107,10,
0,114,13,1,1,1,1,89,113,35,1,88,124,7,0,114,
35,1,103,0,0,124,4,0,95,11,0,113,35,1,113,47,
1,110,9,0,124,3,0,124,4,0,95,11,0,124,4,0,
106,11,0,103,0,0,107,2,0,114,106,1,124,1,0,114,
106,1,116,12,0,124,1,0,131,1,0,100,7,0,25,125,
8,0,124,4,0,106,11,0,106,13,0,124,8,0,131,1,
0,1,113,106,1,110,0,0,124,4,0,83,41,8,97,61,
1,0,0,82,101,116,117,114,110,32,97,32,109,111,100,117,
108,101,32,115,112,101,99,32,98,97,115,101,100,32,111,110,
32,97,32,102,105,108,101,32,108,111,99,97,116,105,111,110,
46,10,10,32,32,32,32,84,111,32,105,110,100,105,99,97,
116,101,32,116,104,97,116,32,116,104,101,32,109,111,100,117,
108,101,32,105,115,32,97,32,112,97,99,107,97,103,101,44,
32,115,101,116,10,32,32,32,32,115,117,98,109,111,100,117,
108,101,95,115,101,97,114,99,104,95,108,111,99,97,116,105,
111,110,115,32,116,111,32,97,32,108,105,115,116,32,111,102,
32,100,105,114,101,99,116,111,114,121,32,112,97,116,104,115,
46,32,32,65,110,10,32,32,32,32,101,109,112,116,121,32,
108,105,115,116,32,105,115,32,115,117,102,102,105,99,105,101,
110,116,44,32,116,104,111,117,103,104,32,105,116,115,32,110,
111,116,32,111,116,104,101,114,119,105,115,101,32,117,115,101,
102,117,108,32,116,111,32,116,104,101,10,32,32,32,32,105,
109,112,111,114,116,32,115,121,115,116,101,109,46,10,10,32,
32,32,32,84,104,101,32,108,111,97,100,101,114,32,109,117,
115,116,32,116,97,107,101,32,97,32,115,112,101,99,32,97,
115,32,105,116,115,32,111,110,108,121,32,95,95,105,110,105,
116,95,95,40,41,32,97,114,103,46,10,10,32,32,32,32,
78,122,9,60,117,110,107,110,111,119,110,62,114,239,0,0,
0,114,218,0,0,0,84,114,220,0,0,0,114,84,0,0,
0,41,14,114,60,0,0,0,114,239,0,0,0,114,154,0,
0,0,114,217,0,0,0,114,222,0,0,0,218,27,95,103,
101,116,95,115,117,112,112,111,114,116,101,100,95,102,105,108,
101,95,108,111,97,100,101,114,115,114,231,0,0,0,114,232,
0,0,0,114,170,0,0,0,218,9,95,80,79,80,85,76,
65,84,69,114,220,0,0,0,114,221,0,0,0,114,38,0,
0,0,114,224,0,0,0,41,9,114,67,0,0,0,218,8,
108,111,99,97,116,105,111,110,114,170,0,0,0,114,221,0,
0,0,114,178,0,0,0,218,12,108,111,97,100,101,114,95,
99,108,97,115,115,114,126,0,0,0,114,220,0,0,0,90,
7,100,105,114,110,97,109,101,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,240,0,0,0,117,3,0,0,
115,60,0,0,0,0,12,12,4,6,1,15,2,3,1,19,
1,13,1,11,8,21,1,9,3,12,1,22,1,21,1,15,
1,9,1,8,2,7,3,12,2,15,1,3,1,19,1,13,
1,5,2,6,1,18,2,9,1,15,1,6,1,16,1,22,
2,114,240,0,0,0,99,3,0,0,0,0,0,0,0,8,
0,0,0,53,0,0,0,67,0,0,0,115,124,1,0,0,
121,13,0,124,0,0,106,0,0,125,3,0,87,110,18,0,
4,116,1,0,107,10,0,114,33,0,1,1,1,89,110,17,
0,88,124,3,0,100,0,0,107,9,0,114,50,0,124,3,
0,83,124,0,0,106,2,0,125,4,0,124,1,0,100,0,
0,107,8,0,114,108,0,121,13,0,124,0,0,106,3,0,
125,1,0,87,113,108,0,4,116,1,0,107,10,0,114,104,
0,1,1,1,89,113,108,0,88,110,0,0,121,13,0,124,
0,0,106,4,0,125,5,0,87,110,24,0,4,116,1,0,
107,10,0,114,147,0,1,1,1,100,0,0,125,5,0,89,
110,1,0,88,124,2,0,100,0,0,107,8,0,114,224,0,
124,5,0,100,0,0,107,8,0,114,215,0,121,13,0,124,
1,0,106,5,0,125,2,0,87,113,221,0,4,116,1,0,
107,10,0,114,211,0,1,1,1,100,0,0,125,2,0,89,
113,221,0,88,113,224,0,124,5,0,125,2,0,110,0,0,
121,13,0,124,0,0,106,6,0,125,6,0,87,110,24,0,
4,116,1,0,107,10,0,114,7,1,1,1,1,100,0,0,
125,6,0,89,110,1,0,88,121,19,0,116,7,0,124,0,
0,106,8,0,131,1,0,125,7,0,87,110,24,0,4,116,
1,0,107,10,0,114,53,1,1,1,1,100,0,0,125,7,
0,89,110,1,0,88,116,9,0,124,4,0,124,1,0,100,
1,0,124,2,0,131,2,1,125,3,0,124,5,0,100,0,
0,107,8,0,114,93,1,100,2,0,110,3,0,100,3,0,
124,3,0,95,10,0,124,6,0,124,3,0,95,11,0,124,
7,0,124,3,0,95,12,0,124,3,0,83,41,4,78,114,
218,0,0,0,70,84,41,13,114,209,0,0,0,114,210,0,
0,0,114,57,0,0,0,114,205,0,0,0,114,211,0,0,
0,90,7,95,79,82,73,71,73,78,218,10,95,95,99,97,
99,104,101,100,95,95,218,4,108,105,115,116,218,8,95,95,
112,97,116,104,95,95,114,217,0,0,0,114,222,0,0,0,
114,226,0,0,0,114,221,0,0,0,41,8,114,180,0,0,
0,114,170,0,0,0,114,218,0,0,0,114,178,0,0,0,
114,67,0,0,0,114,243,0,0,0,114,226,0,0,0,114,
221,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,218,17,95,115,112,101,99,95,102,114,111,109,95,
109,111,100,117,108,101,181,3,0,0,115,72,0,0,0,0,
2,3,1,13,1,13,1,5,2,12,1,4,2,9,1,12,
1,3,1,13,1,13,2,8,1,3,1,13,1,13,1,11,
1,12,1,12,1,3,1,13,1,13,1,14,2,9,1,3,
1,13,1,13,1,11,1,3,1,19,1,13,1,11,2,21,
1,27,1,9,1,9,1,114,248,0,0,0,99,0,0,0,
0,0,0,0,0,0,0,0,0,6,0,0,0,64,0,0,
0,115,142,0,0,0,101,0,0,90,1,0,100,0,0,90,
2,0,100,1,0,90,3,0,100,2,0,100,3,0,132,0,
0,90,4,0,100,4,0,100,5,0,132,0,0,90,5,0,
100,6,0,100,7,0,100,8,0,100,9,0,100,10,0,100,
11,0,132,0,2,90,6,0,100,12,0,100,13,0,132,0,
0,90,7,0,100,14,0,100,15,0,132,0,0,90,8,0,
100,16,0,100,17,0,132,0,0,90,9,0,100,18,0,100,
19,0,132,0,0,90,10,0,100,20,0,100,21,0,132,0,
0,90,11,0,100,22,0,100,23,0,132,0,0,90,12,0,
100,24,0,83,41,25,114,175,0,0,0,122,77,67,111,110,
118,101,110,105,101,110,99,101,32,119,114,97,112,112,101,114,
32,97,114,111,117,110,100,32,115,112,101,99,32,111,98,106,
101,99,116,115,32,116,111,32,112,114,111,118,105,100,101,32,
115,112,101,99,45,115,112,101,99,105,102,105,99,10,32,32,
32,32,109,101,116,104,111,100,115,46,99,2,0,0,0,0,
0,0,0,2,0,0,0,2,0,0,0,67,0,0,0,115,
13,0,0,0,124,1,0,124,0,0,95,0,0,100,0,0,
83,41,1,78,41,1,114,178,0,0,0,41,2,114,71,0,
0,0,114,178,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,72,0,0,0,233,3,0,0,115,
2,0,0,0,0,1,122,21,95,83,112,101,99,77,101,116,
104,111,100,115,46,95,95,105,110,105,116,95,95,99,1,0,
0,0,0,0,0,0,3,0,0,0,3,0,0,0,67,0,
0,0,115,158,0,0,0,124,0,0,106,0,0,125,1,0,
124,1,0,106,1,0,100,1,0,107,8,0,114,30,0,100,
2,0,110,6,0,124,1,0,106,1,0,125,2,0,124,1,
0,106,2,0,100,1,0,107,8,0,114,104,0,124,1,0,
106,3,0,100,1,0,107,8,0,114,82,0,100,3,0,106,
4,0,124,2,0,131,1,0,83,100,4,0,106,4,0,124,
2,0,124,1,0,106,3,0,131,2,0,83,110,50,0,124,
1,0,106,5,0,114,132,0,100,5,0,106,4,0,124,2,
0,124,1,0,106,2,0,131,2,0,83,100,6,0,106,4,
0,124,1,0,106,1,0,124,1,0,106,2,0,131,2,0,
83,100,1,0,83,41,7,122,38,82,101,116,117,114,110,32,
116,104,101,32,114,101,112,114,32,116,111,32,117,115,101,32,
102,111,114,32,116,104,101,32,109,111,100,117,108,101,46,78,
114,207,0,0,0,122,13,60,109,111,100,117,108,101,32,123,
33,114,125,62,122,20,60,109,111,100,117,108,101,32,123,33,
114,125,32,40,123,33,114,125,41,62,122,23,60,109,111,100,
117,108,101,32,123,33,114,125,32,102,114,111,109,32,123,33,
114,125,62,122,18,60,109,111,100,117,108,101,32,123,33,114,
125,32,40,123,125,41,62,41,6,114,178,0,0,0,114,67,
0,0,0,114,218,0,0,0,114,170,0,0,0,114,47,0,
0,0,114,227,0,0,0,41,3,114,71,0,0,0,114,178,
0,0,0,114,67,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,206,0,0,0,236,3,0,0,
115,18,0,0,0,0,3,9,1,30,1,15,1,15,1,13,
2,22,2,9,1,19,2,122,24,95,83,112,101,99,77,101,
116,104,111,100,115,46,109,111,100,117,108,101,95,114,101,112,
114,218,9,95,111,118,101,114,114,105,100,101,70,218,11,95,
102,111,114,99,101,95,110,97,109,101,84,99,2,0,0,0,
2,0,0,0,6,0,0,0,59,0,0,0,67,0,0,0,
115,75,2,0,0,124,0,0,106,0,0,125,4,0,124,2,
0,115,45,0,124,3,0,115,45,0,116,1,0,124,1,0,
100,1,0,100,2,0,131,3,0,100,2,0,107,8,0,114,
85,0,121,16,0,124,4,0,106,2,0,124,1,0,95,3,
0,87,113,85,0,4,116,4,0,107,10,0,114,81,0,1,
1,1,89,113,85,0,88,110,0,0,124,2,0,115,115,0,
116,1,0,124,1,0,100,3,0,100,2,0,131,3,0,100,
2,0,107,8,0,114,221,0,124,4,0,106,5,0,125,5,
0,124,5,0,100,2,0,107,8,0,114,184,0,124,4,0,
106,6,0,100,2,0,107,9,0,114,184,0,116,7,0,106,
8,0,116,7,0,131,1,0,125,5,0,124,4,0,106,6,
0,124,5,0,95,9,0,113,184,0,110,0,0,121,13,0,
124,5,0,124,1,0,95,10,0,87,113,221,0,4,116,4,
0,107,10,0,114,217,0,1,1,1,89,113,221,0,88,110,
0,0,124,2,0,115,251,0,116,1,0,124,1,0,100,4,
0,100,2,0,131,3,0,100,2,0,107,8,0,114,35,1,
121,16,0,124,4,0,106,11,0,124,1,0,95,12,0,87,
113,35,1,4,116,4,0,107,10,0,114,31,1,1,1,1,
89,113,35,1,88,110,0,0,121,13,0,124,4,0,124,1,
0,95,13,0,87,110,18,0,4,116,4,0,107,10,0,114,
68,1,1,1,1,89,110,1,0,88,124,2,0,115,99,1,
116,1,0,124,1,0,100,5,0,100,2,0,131,3,0,100,
2,0,107,8,0,114,157,1,124,4,0,106,6,0,100,2,
0,107,9,0,114,157,1,121,16,0,124,4,0,106,6,0,
124,1,0,95,14,0,87,113,154,1,4,116,4,0,107,10,
0,114,150,1,1,1,1,89,113,154,1,88,113,157,1,110,
0,0,124,4,0,106,15,0,114,71,2,124,2,0,115,196,
1,116,1,0,124,1,0,100,6,0,100,2,0,131,3,0,
100,2,0,107,8,0,114,236,1,121,16,0,124,4,0,106,
16,0,124,1,0,95,17,0,87,113,236,1,4,116,4,0,
107,10,0,114,232,1,1,1,1,89,113,236,1,88,110,0,
0,124,2,0,115,10,2,116,1,0,124,1,0,100,7,0,
100,2,0,131,3,0,100,2,0,107,8,0,114,71,2,124,
4,0,106,18,0,100,2,0,107,9,0,114,68,2,121,16,
0,124,4,0,106,18,0,124,1,0,95,19,0,87,113,65,
2,4,116,4,0,107,10,0,114,61,2,1,1,1,89,113,
65,2,88,113,68,2,113,71,2,110,0,0,100,2,0,83,
41,8,97,29,2,0,0,83,101,116,32,116,104,101,32,109,
111,100,117,108,101,39,115,32,97,116,116,114,105,98,117,116,
101,115,46,10,10,32,32,32,32,32,32,32,32,65,108,108,
32,109,105,115,115,105,110,103,32,105,109,112,111,114,116,45,
114,101,108,97,116,101,100,32,109,111,100,117,108,101,32,97,
116,116,114,105,98,117,116,101,115,32,119,105,108,108,32,98,
101,32,115,101,116,46,32,32,72,101,114,101,10,32,32,32,
32,32,32,32,32,105,115,32,104,111,119,32,116,104,101,32,
115,112,101,99,32,97,116,116,114,105,98,117,116,101,115,32,
109,97,112,32,111,110,116,111,32,116,104,101,32,109,111,100,
117,108,101,58,10,10,32,32,32,32,32,32,32,32,115,112,
101,99,46,110,97,109,101,32,45,62,32,109,111,100,117,108,
101,46,95,95,110,97,109,101,95,95,10,32,32,32,32,32,
32,32,32,115,112,101,99,46,108,111,97,100,101,114,32,45,
62,32,109,111,100,117,108,101,46,95,95,108,111,97,100,101,
114,95,95,10,32,32,32,32,32,32,32,32,115,112,101,99,
46,112,97,114,101,110,116,32,45,62,32,109,111,100,117,108,
101,46,95,95,112,97,99,107,97,103,101,95,95,10,32,32,
32,32,32,32,32,32,115,112,101,99,32,45,62,32,109,111,
100,117,108,101,46,95,95,115,112,101,99,95,95,10,10,32,
32,32,32,32,32,32,32,79,112,116,105,111,110,97,108,58,
10,32,32,32,32,32,32,32,32,115,112,101,99,46,111,114,
105,103,105,110,32,45,62,32,109,111,100,117,108,101,46,95,
95,102,105,108,101,95,95,32,40,105,102,32,115,112,101,99,
46,115,101,116,95,102,105,108,101,97,116,116,114,32,105,115,
32,116,114,117,101,41,10,32,32,32,32,32,32,32,32,115,
112,101,99,46,99,97,99,104,101,100,32,45,62,32,109,111,
100,117,108,101,46,95,95,99,97,99,104,101,100,95,95,32,
40,105,102,32,95,95,102,105,108,101,95,95,32,97,108,115,
111,32,115,101,116,41,10,32,32,32,32,32,32,32,32,115,
112,101,99,46,115,117,98,109,111,100,117,108,101,95,115,101,
97,114,99,104,95,108,111,99,97,116,105,111,110,115,32,45,
62,32,109,111,100,117,108,101,46,95,95,112,97,116,104,95,
95,32,40,105,102,32,115,101,116,41,10,10,32,32,32,32,
32,32,32,32,114,57,0,0,0,78,114,205,0,0,0,218,
11,95,95,112,97,99,107,97,103,101,95,95,114,247,0,0,
0,114,211,0,0,0,114,245,0,0,0,41,20,114,178,0,
0,0,114,62,0,0,0,114,67,0,0,0,114,57,0,0,
0,114,210,0,0,0,114,170,0,0,0,114,221,0,0,0,
218,16,95,78,97,109,101,115,112,97,99,101,76,111,97,100,
101,114,218,7,95,95,110,101,119,95,95,218,5,95,112,97,
116,104,114,205,0,0,0,114,234,0,0,0,114,251,0,0,
0,114,209,0,0,0,114,247,0,0,0,114,227,0,0,0,
114,218,0,0,0,114,211,0,0,0,114,226,0,0,0,114,
245,0,0,0,41,6,114,71,0,0,0,114,180,0,0,0,
114,249,0,0,0,114,250,0,0,0,114,178,0,0,0,114,
170,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,218,17,105,110,105,116,95,109,111,100,117,108,101,
95,97,116,116,114,115,252,3,0,0,115,88,0,0,0,0,
17,9,6,12,1,24,1,3,1,16,1,13,1,8,3,30,
1,9,1,12,2,15,1,15,1,18,1,3,1,13,1,13,
1,8,3,30,1,3,1,16,1,13,1,8,3,3,1,13,
1,13,1,5,3,30,1,15,1,3,1,16,1,13,1,11,
2,9,2,30,1,3,1,16,1,13,1,8,3,30,1,15,
1,3,1,16,1,13,1,122,30,95,83,112,101,99,77,101,
116,104,111,100,115,46,105,110,105,116,95,109,111,100,117,108,
101,95,97,116,116,114,115,99,1,0,0,0,0,0,0,0,
3,0,0,0,3,0,0,0,67,0,0,0,115,101,0,0,
0,124,0,0,106,0,0,125,1,0,116,1,0,124,1,0,
106,2,0,100,1,0,131,2,0,114,48,0,124,1,0,106,
2,0,106,3,0,124,1,0,131,1,0,125,2,0,110,6,
0,100,2,0,125,2,0,124,2,0,100,2,0,107,8,0,
114,84,0,116,4,0,124,1,0,106,5,0,131,1,0,125,
2,0,110,0,0,124,0,0,106,6,0,124,2,0,131,1,
0,1,124,2,0,83,41,3,122,153,82,101,116,117,114,110,
32,97,32,110,101,119,32,109,111,100,117,108,101,32,116,111,
32,98,101,32,108,111,97,100,101,100,46,10,10,32,32,32,
32,32,32,32,32,84,104,101,32,105,109,112,111,114,116,45,
114,101,108,97,116,101,100,32,109,111,100,117,108,101,32,97,
116,116,114,105,98,117,116,101,115,32,97,114,101,32,97,108,
115,111,32,115,101,116,32,119,105,116,104,32,116,104,101,10,
32,32,32,32,32,32,32,32,97,112,112,114,111,112,114,105,
97,116,101,32,118,97,108,117,101,115,32,102,114,111,109,32,
116,104,101,32,115,112,101,99,46,10,10,32,32,32,32,32,
32,32,32,218,13,99,114,101,97,116,101,95,109,111,100,117,
108,101,78,41,7,114,178,0,0,0,114,60,0,0,0,114,
170,0,0,0,114,0,1,0,0,114,68,0,0,0,114,67,
0,0,0,114,255,0,0,0,41,3,114,71,0,0,0,114,
178,0,0,0,114,180,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,6,99,114,101,97,116,101,
76,4,0,0,115,16,0,0,0,0,7,9,2,18,3,21,
2,6,1,12,4,18,1,13,1,122,19,95,83,112,101,99,
77,101,116,104,111,100,115,46,99,114,101,97,116,101,99,2,
0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,67,
0,0,0,115,23,0,0,0,124,0,0,106,0,0,106,1,
0,106,2,0,124,1,0,131,1,0,1,100,1,0,83,41,
2,122,189,68,111,32,101,118,101,114,121,116,104,105,110,103,
32,110,101,99,101,115,115,97,114,121,32,116,111,32,101,120,
101,99,117,116,101,32,116,104,101,32,109,111,100,117,108,101,
46,10,10,32,32,32,32,32,32,32,32,84,104,101,32,110,
97,109,101,115,112,97,99,101,32,111,102,32,96,109,111,100,
117,108,101,96,32,105,115,32,117,115,101,100,32,97,115,32,
116,104,101,32,116,97,114,103,101,116,32,111,102,32,101,120,
101,99,117,116,105,111,110,46,10,32,32,32,32,32,32,32,
32,84,104,105,115,32,109,101,116,104,111,100,32,117,115,101,
115,32,116,104,101,32,108,111,97,100,101,114,39,115,32,96,
101,120,101,99,95,109,111,100,117,108,101,40,41,96,32,109,
101,116,104,111,100,46,10,10,32,32,32,32,32,32,32,32,
78,41,3,114,178,0,0,0,114,170,0,0,0,218,11,101,
120,101,99,95,109,111,100,117,108,101,41,2,114,71,0,0,
0,114,180,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,218,5,95,101,120,101,99,99,4,0,0,
115,2,0,0,0,0,7,122,18,95,83,112,101,99,77,101,
116,104,111,100,115,46,95,101,120,101,99,99,2,0,0,0,
0,0,0,0,4,0,0,0,11,0,0,0,67,0,0,0,
115,17,1,0,0,124,0,0,106,0,0,106,1,0,125,2,
0,116,2,0,106,3,0,131,0,0,1,116,4,0,124,2,
0,131,1,0,143,226,0,1,116,5,0,106,6,0,106,7,
0,124,2,0,131,1,0,124,1,0,107,9,0,114,95,0,
100,1,0,106,8,0,124,2,0,131,1,0,125,3,0,116,
9,0,124,3,0,100,2,0,124,2,0,131,1,1,130,1,
0,110,0,0,124,0,0,106,0,0,106,10,0,100,3,0,
107,8,0,114,181,0,124,0,0,106,0,0,106,11,0,100,
3,0,107,8,0,114,158,0,116,9,0,100,4,0,100,2,
0,124,0,0,106,0,0,106,1,0,131,1,1,130,1,0,
110,0,0,124,0,0,106,12,0,124,1,0,100,5,0,100,
6,0,131,1,1,1,124,1,0,83,124,0,0,106,12,0,
124,1,0,100,5,0,100,6,0,131,1,1,1,116,13,0,
124,0,0,106,0,0,106,10,0,100,7,0,131,2,0,115,
243,0,124,0,0,106,0,0,106,10,0,106,14,0,124,2,
0,131,1,0,1,110,13,0,124,0,0,106,15,0,124,1,
0,131,1,0,1,87,100,3,0,81,88,116,5,0,106,6,
0,124,2,0,25,83,41,8,122,51,69,120,101,99,117,116,
101,32,116,104,101,32,115,112,101,99,32,105,110,32,97,110,
32,101,120,105,115,116,105,110,103,32,109,111,100,117,108,101,
39,115,32,110,97,109,101,115,112,97,99,101,46,122,30,109,
111,100,117,108,101,32,123,33,114,125,32,110,111,116,32,105,
110,32,115,121,115,46,109,111,100,117,108,101,115,114,67,0,
0,0,78,122,14,109,105,115,115,105,110,103,32,108,111,97,
100,101,114,114,249,0,0,0,84,114,2,1,0,0,41,16,
114,178,0,0,0,114,67,0,0,0,114,106,0,0,0,218,
12,97,99,113,117,105,114,101,95,108,111,99,107,114,103,0,
0,0,114,7,0,0,0,114,73,0,0,0,114,93,0,0,
0,114,47,0,0,0,114,154,0,0,0,114,170,0,0,0,
114,221,0,0,0,114,255,0,0,0,114,60,0,0,0,218,
11,108,111,97,100,95,109,111,100,117,108,101,114,3,1,0,
0,41,4,114,71,0,0,0,114,180,0,0,0,114,67,0,
0,0,114,172,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,176,0,0,0,109,4,0,0,115,
32,0,0,0,0,2,12,1,10,1,13,1,24,1,15,1,
21,1,18,1,18,1,27,2,19,1,4,1,19,1,21,4,
22,2,19,1,122,17,95,83,112,101,99,77,101,116,104,111,
100,115,46,101,120,101,99,99,1,0,0,0,0,0,0,0,
3,0,0,0,27,0,0,0,67,0,0,0,115,24,1,0,
0,124,0,0,106,0,0,125,1,0,124,1,0,106,1,0,
106,2,0,124,1,0,106,3,0,131,1,0,1,116,4,0,
106,5,0,124,1,0,106,3,0,25,125,2,0,116,6,0,
124,2,0,100,1,0,100,0,0,131,3,0,100,0,0,107,
8,0,114,108,0,121,16,0,124,1,0,106,1,0,124,2,
0,95,7,0,87,113,108,0,4,116,8,0,107,10,0,114,
104,0,1,1,1,89,113,108,0,88,110,0,0,116,6,0,
124,2,0,100,2,0,100,0,0,131,3,0,100,0,0,107,
8,0,114,215,0,121,59,0,124,2,0,106,9,0,124,2,
0,95,10,0,116,11,0,124,2,0,100,3,0,131,2,0,
115,190,0,124,1,0,106,3,0,106,12,0,100,4,0,131,
1,0,100,5,0,25,124,2,0,95,10,0,110,0,0,87,
113,215,0,4,116,8,0,107,10,0,114,211,0,1,1,1,
89,113,215,0,88,110,0,0,116,6,0,124,2,0,100,6,
0,100,0,0,131,3,0,100,0,0,107,8,0,114,20,1,
121,13,0,124,1,0,124,2,0,95,13,0,87,113,20,1,
4,116,8,0,107,10,0,114,16,1,1,1,1,89,113,20,
1,88,110,0,0,124,2,0,83,41,7,78,114,205,0,0,
0,114,251,0,0,0,114,247,0,0,0,114,116,0,0,0,
114,84,0,0,0,114,209,0,0,0,41,14,114,178,0,0,
0,114,170,0,0,0,114,5,1,0,0,114,67,0,0,0,
114,7,0,0,0,114,73,0,0,0,114,62,0,0,0,114,
205,0,0,0,114,210,0,0,0,114,57,0,0,0,114,251,
0,0,0,114,60,0,0,0,114,32,0,0,0,114,209,0,
0,0,41,3,114,71,0,0,0,114,178,0,0,0,114,180,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,218,25,95,108,111,97,100,95,98,97,99,107,119,97,
114,100,95,99,111,109,112,97,116,105,98,108,101,133,4,0,
0,115,42,0,0,0,0,4,9,1,19,2,16,1,24,1,
3,1,16,1,13,1,8,1,24,1,3,4,12,1,15,1,
32,1,13,1,8,1,24,1,3,1,13,1,13,1,8,1,
122,38,95,83,112,101,99,77,101,116,104,111,100,115,46,95,
108,111,97,100,95,98,97,99,107,119,97,114,100,95,99,111,
109,112,97,116,105,98,108,101,99,1,0,0,0,0,0,0,
0,2,0,0,0,11,0,0,0,67,0,0,0,115,179,0,
0,0,124,0,0,106,0,0,106,1,0,100,0,0,107,9,
0,114,52,0,116,2,0,124,0,0,106,0,0,106,1,0,
100,1,0,131,2,0,115,52,0,124,0,0,106,3,0,131,
0,0,83,110,0,0,124,0,0,106,4,0,131,0,0,125,
1,0,116,5,0,124,1,0,131,1,0,143,84,0,1,124,
0,0,106,0,0,106,1,0,100,0,0,107,8,0,114,143,
0,124,0,0,106,0,0,106,6,0,100,0,0,107,8,0,
114,156,0,116,7,0,100,2,0,100,3,0,124,0,0,106,
0,0,106,8,0,131,1,1,130,1,0,113,156,0,110,13,
0,124,0,0,106,9,0,124,1,0,131,1,0,1,87,100,
0,0,81,88,116,10,0,106,11,0,124,0,0,106,0,0,
106,8,0,25,83,41,4,78,114,2,1,0,0,122,14,109,
105,115,115,105,110,103,32,108,111,97,100,101,114,114,67,0,
0,0,41,12,114,178,0,0,0,114,170,0,0,0,114,60,
0,0,0,114,6,1,0,0,114,1,1,0,0,114,213,0,
0,0,114,221,0,0,0,114,154,0,0,0,114,67,0,0,
0,114,3,1,0,0,114,7,0,0,0,114,73,0,0,0,
41,2,114,71,0,0,0,114,180,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,14,95,108,111,
97,100,95,117,110,108,111,99,107,101,100,163,4,0,0,115,
20,0,0,0,0,2,18,2,21,1,13,2,12,1,13,1,
18,1,18,1,30,3,19,5,122,27,95,83,112,101,99,77,
101,116,104,111,100,115,46,95,108,111,97,100,95,117,110,108,
111,99,107,101,100,99,1,0,0,0,0,0,0,0,1,0,
0,0,8,0,0,0,67,0,0,0,115,49,0,0,0,116,
0,0,106,1,0,131,0,0,1,116,2,0,124,0,0,106,
3,0,106,4,0,131,1,0,143,15,0,1,124,0,0,106,
5,0,131,0,0,83,87,100,1,0,81,88,100,1,0,83,
41,2,122,207,82,101,116,117,114,110,32,97,32,110,101,119,
32,109,111,100,117,108,101,32,111,98,106,101,99,116,44,32,
108,111,97,100,101,100,32,98,121,32,116,104,101,32,115,112,
101,99,39,115,32,108,111,97,100,101,114,46,10,10,32,32,
32,32,32,32,32,32,84,104,101,32,109,111,100,117,108,101,
32,105,115,32,110,111,116,32,97,100,100,101,100,32,116,111,
32,105,116,115,32,112,97,114,101,110,116,46,10,10,32,32,
32,32,32,32,32,32,73,102,32,97,32,109,111,100,117,108,
101,32,105,115,32,97,108,114,101,97,100,121,32,105,110,32,
115,121,115,46,109,111,100,117,108,101,115,44,32,116,104,97,
116,32,101,120,105,115,116,105,110,103,32,109,111,100,117,108,
101,32,103,101,116,115,10,32,32,32,32,32,32,32,32,99,
108,111,98,98,101,114,101,100,46,10,10,32,32,32,32,32,
32,32,32,78,41,6,114,106,0,0,0,114,4,1,0,0,
114,103,0,0,0,114,178,0,0,0,114,67,0,0,0,114,
7,1,0,0,41,1,114,71,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,177,0,0,0,186,
4,0,0,115,6,0,0,0,0,9,10,1,19,1,122,17,
95,83,112,101,99,77,101,116,104,111,100,115,46,108,111,97,
100,78,41,13,114,57,0,0,0,114,56,0,0,0,114,58,
0,0,0,114,59,0,0,0,114,72,0,0,0,114,206,0,
0,0,114,255,0,0,0,114,1,1,0,0,114,3,1,0,
0,114,176,0,0,0,114,6,1,0,0,114,7,1,0,0,
114,177,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,114,175,0,0,0,226,3,
0,0,115,20,0,0,0,12,3,6,4,12,3,12,16,24,
80,12,23,12,10,12,24,12,30,12,23,114,175,0,0,0,
99,4,0,0,0,0,0,0,0,6,0,0,0,11,0,0,
0,67,0,0,0,115,201,0,0,0,124,0,0,106,0,0,
100,1,0,131,1,0,125,4,0,124,0,0,106,0,0,100,
2,0,131,1,0,125,5,0,124,4,0,115,102,0,124,5,
0,114,54,0,124,5,0,106,1,0,125,4,0,113,102,0,
124,2,0,124,3,0,107,2,0,114,84,0,116,2,0,124,
1,0,124,2,0,131,2,0,125,4,0,113,102,0,116,3,
0,124,1,0,124,2,0,131,2,0,125,4,0,110,0,0,
124,5,0,115,132,0,116,4,0,124,1,0,124,2,0,100,
3,0,124,4,0,131,2,1,125,5,0,110,0,0,121,44,
0,124,5,0,124,0,0,100,2,0,60,124,4,0,124,0,
0,100,1,0,60,124,2,0,124,0,0,100,4,0,60,124,
3,0,124,0,0,100,5,0,60,87,110,18,0,4,116,5,
0,107,10,0,114,196,0,1,1,1,89,110,1,0,88,100,
0,0,83,41,6,78,114,205,0,0,0,114,209,0,0,0,
114,170,0,0,0,114,211,0,0,0,114,245,0,0,0,41,
6,114,93,0,0,0,114,170,0,0,0,218,20,83,111,117,
114,99,101,108,101,115,115,70,105,108,101,76,111,97,100,101,
114,218,16,83,111,117,114,99,101,70,105,108,101,76,111,97,
100,101,114,114,240,0,0,0,114,208,0,0,0,41,6,90,
2,110,115,114,67,0,0,0,90,8,112,97,116,104,110,97,
109,101,90,9,99,112,97,116,104,110,97,109,101,114,170,0,
0,0,114,178,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,218,14,95,102,105,120,95,117,112,95,
109,111,100,117,108,101,200,4,0,0,115,34,0,0,0,0,
2,15,1,15,1,6,1,6,1,12,1,12,1,18,2,18,
1,6,1,24,1,3,1,10,1,10,1,10,1,14,1,13,
2,114,10,1,0,0,99,0,0,0,0,0,0,0,0,0,
0,0,0,5,0,0,0,64,0,0,0,115,181,0,0,0,
101,0,0,90,1,0,100,0,0,90,2,0,100,1,0,90,
3,0,101,4,0,100,2,0,100,3,0,132,0,0,131,1,
0,90,5,0,101,6,0,100,4,0,100,4,0,100,5,0,
100,6,0,132,2,0,131,1,0,90,7,0,101,6,0,100,
4,0,100,7,0,100,8,0,132,1,0,131,1,0,90,8,
0,101,6,0,101,9,0,100,9,0,100,10,0,132,0,0,
131,1,0,131,1,0,90,10,0,101,6,0,101,9,0,100,
11,0,100,12,0,132,0,0,131,1,0,131,1,0,90,11,
0,101,6,0,101,9,0,100,13,0,100,14,0,132,0,0,
131,1,0,131,1,0,90,12,0,101,6,0,101,9,0,100,
15,0,100,16,0,132,0,0,131,1,0,131,1,0,90,13,
0,100,4,0,83,41,17,218,15,66,117,105,108,116,105,110,
73,109,112,111,114,116,101,114,122,144,77,101,116,97,32,112,
97,116,104,32,105,109,112,111,114,116,32,102,111,114,32,98,
117,105,108,116,45,105,110,32,109,111,100,117,108,101,115,46,
10,10,32,32,32,32,65,108,108,32,109,101,116,104,111,100,
115,32,97,114,101,32,101,105,116,104,101,114,32,99,108,97,
115,115,32,111,114,32,115,116,97,116,105,99,32,109,101,116,
104,111,100,115,32,116,111,32,97,118,111,105,100,32,116,104,
101,32,110,101,101,100,32,116,111,10,32,32,32,32,105,110,
115,116,97,110,116,105,97,116,101,32,116,104,101,32,99,108,
97,115,115,46,10,10,32,32,32,32,99,1,0,0,0,0,
0,0,0,1,0,0,0,2,0,0,0,67,0,0,0,115,
16,0,0,0,100,1,0,106,0,0,124,0,0,106,1,0,
131,1,0,83,41,2,122,115,82,101,116,117,114,110,32,114,
101,112,114,32,102,111,114,32,116,104,101,32,109,111,100,117,
108,101,46,10,10,32,32,32,32,32,32,32,32,84,104,101,
32,109,101,116,104,111,100,32,105,115,32,100,101,112,114,101,
99,97,116,101,100,46,32,32,84,104,101,32,105,109,112,111,
114,116,32,109,97,99,104,105,110,101,114,121,32,100,111,101,
115,32,116,104,101,32,106,111,98,32,105,116,115,101,108,102,
46,10,10,32,32,32,32,32,32,32,32,122,24,60,109,111,
100,117,108,101,32,123,33,114,125,32,40,98,117,105,108,116,
45,105,110,41,62,41,2,114,47,0,0,0,114,57,0,0,
0,41,1,114,180,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,206,0,0,0,234,4,0,0,
115,2,0,0,0,0,7,122,27,66,117,105,108,116,105,110,
73,109,112,111,114,116,101,114,46,109,111,100,117,108,101,95,
114,101,112,114,78,99,4,0,0,0,0,0,0,0,4,0,
0,0,5,0,0,0,67,0,0,0,115,58,0,0,0,124,
2,0,100,0,0,107,9,0,114,16,0,100,0,0,83,116,
0,0,106,1,0,124,1,0,131,1,0,114,50,0,116,2,
0,124,1,0,124,0,0,100,1,0,100,2,0,131,2,1,
83,100,0,0,83,100,0,0,83,41,3,78,114,218,0,0,
0,122,8,98,117,105,108,116,45,105,110,41,3,114,106,0,
0,0,90,10,105,115,95,98,117,105,108,116,105,110,114,174,
0,0,0,41,4,218,3,99,108,115,114,159,0,0,0,114,
35,0,0,0,218,6,116,97,114,103,101,116,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,9,102,105,110,
100,95,115,112,101,99,243,4,0,0,115,10,0,0,0,0,
2,12,1,4,1,15,1,19,2,122,25,66,117,105,108,116,
105,110,73,109,112,111,114,116,101,114,46,102,105,110,100,95,
115,112,101,99,99,3,0,0,0,0,0,0,0,4,0,0,
0,3,0,0,0,67,0,0,0,115,41,0,0,0,124,0,
0,106,0,0,124,1,0,124,2,0,131,2,0,125,3,0,
124,3,0,100,1,0,107,9,0,114,37,0,124,3,0,106,
1,0,83,100,1,0,83,41,2,122,175,70,105,110,100,32,
116,104,101,32,98,117,105,108,116,45,105,110,32,109,111,100,
117,108,101,46,10,10,32,32,32,32,32,32,32,32,73,102,
32,39,112,97,116,104,39,32,105,115,32,101,118,101,114,32,
115,112,101,99,105,102,105,101,100,32,116,104,101,110,32,116,
104,101,32,115,101,97,114,99,104,32,105,115,32,99,111,110,
115,105,100,101,114,101,100,32,97,32,102,97,105,108,117,114,
101,46,10,10,32,32,32,32,32,32,32,32,84,104,105,115,
32,109,101,116,104,111,100,32,105,115,32,100,101,112,114,101,
99,97,116,101,100,46,32,32,85,115,101,32,102,105,110,100,
95,115,112,101,99,40,41,32,105,110,115,116,101,97,100,46,
10,10,32,32,32,32,32,32,32,32,78,41,2,114,14,1,
0,0,114,170,0,0,0,41,4,114,12,1,0,0,114,159,
0,0,0,114,35,0,0,0,114,178,0,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,218,11,102,105,
110,100,95,109,111,100,117,108,101,252,4,0,0,115,4,0,
0,0,0,9,18,1,122,27,66,117,105,108,116,105,110,73,
109,112,111,114,116,101,114,46,102,105,110,100,95,109,111,100,
117,108,101,99,2,0,0,0,0,0,0,0,3,0,0,0,
10,0,0,0,67,0,0,0,115,59,0,0,0,116,0,0,
124,1,0,131,1,0,143,23,0,1,116,1,0,116,2,0,
106,3,0,124,1,0,131,2,0,125,2,0,87,100,1,0,
81,88,124,0,0,124,2,0,95,4,0,100,2,0,124,2,
0,95,5,0,124,2,0,83,41,3,122,23,76,111,97,100,
32,97,32,98,117,105,108,116,45,105,110,32,109,111,100,117,
108,101,46,78,114,30,0,0,0,41,6,114,69,0,0,0,
114,114,0,0,0,114,106,0,0,0,90,12,105,110,105,116,
95,98,117,105,108,116,105,110,114,205,0,0,0,114,251,0,
0,0,41,3,114,12,1,0,0,114,159,0,0,0,114,180,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,5,1,0,0,8,5,0,0,115,10,0,0,0,
0,6,13,1,24,1,9,1,9,1,122,27,66,117,105,108,
116,105,110,73,109,112,111,114,116,101,114,46,108,111,97,100,
95,109,111,100,117,108,101,99,2,0,0,0,0,0,0,0,
2,0,0,0,1,0,0,0,67,0,0,0,115,4,0,0,
0,100,1,0,83,41,2,122,57,82,101,116,117,114,110,32,
78,111,110,101,32,97,115,32,98,117,105,108,116,45,105,110,
32,109,111,100,117,108,101,115,32,100,111,32,110,111,116,32,
104,97,118,101,32,99,111,100,101,32,111,98,106,101,99,116,
115,46,78,114,4,0,0,0,41,2,114,12,1,0,0,114,
159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,218,8,103,101,116,95,99,111,100,101,20,5,0,
0,115,2,0,0,0,0,4,122,24,66,117,105,108,116,105,
110,73,109,112,111,114,116,101,114,46,103,101,116,95,99,111,
100,101,99,2,0,0,0,0,0,0,0,2,0,0,0,1,
0,0,0,67,0,0,0,115,4,0,0,0,100,1,0,83,
41,2,122,56,82,101,116,117,114,110,32,78,111,110,101,32,
97,115,32,98,117,105,108,116,45,105,110,32,109,111,100,117,
108,101,115,32,100,111,32,110,111,116,32,104,97,118,101,32,
115,111,117,114,99,101,32,99,111,100,101,46,78,114,4,0,
0,0,41,2,114,12,1,0,0,114,159,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,218,10,103,
101,116,95,115,111,117,114,99,101,26,5,0,0,115,2,0,
0,0,0,4,122,26,66,117,105,108,116,105,110,73,109,112,
111,114,116,101,114,46,103,101,116,95,115,111,117,114,99,101,
99,2,0,0,0,0,0,0,0,2,0,0,0,1,0,0,
0,67,0,0,0,115,4,0,0,0,100,1,0,83,41,2,
122,52,82,101,116,117,114,110,32,70,97,108,115,101,32,97,
115,32,98,117,105,108,116,45,105,110,32,109,111,100,117,108,
101,115,32,97,114,101,32,110,101,118,101,114,32,112,97,99,
107,97,103,101,115,46,70,114,4,0,0,0,41,2,114,12,
1,0,0,114,159,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,220,0,0,0,32,5,0,0,
115,2,0,0,0,0,4,122,26,66,117,105,108,116,105,110,
73,109,112,111,114,116,101,114,46,105,115,95,112,97,99,107,
97,103,101,41,14,114,57,0,0,0,114,56,0,0,0,114,
58,0,0,0,114,59,0,0,0,218,12,115,116,97,116,105,
99,109,101,116,104,111,100,114,206,0,0,0,218,11,99,108,
97,115,115,109,101,116,104,111,100,114,14,1,0,0,114,15,
1,0,0,114,162,0,0,0,114,5,1,0,0,114,16,1,
0,0,114,17,1,0,0,114,220,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,11,1,0,0,225,4,0,0,115,28,0,0,0,12,7,
6,2,18,9,3,1,21,8,3,1,18,11,3,1,21,11,
3,1,21,5,3,1,21,5,3,1,114,11,1,0,0,99,
0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,
64,0,0,0,115,193,0,0,0,101,0,0,90,1,0,100,
0,0,90,2,0,100,1,0,90,3,0,101,4,0,100,2,
0,100,3,0,132,0,0,131,1,0,90,5,0,101,6,0,
100,4,0,100,4,0,100,5,0,100,6,0,132,2,0,131,
1,0,90,7,0,101,6,0,100,4,0,100,7,0,100,8,
0,132,1,0,131,1,0,90,8,0,101,4,0,100,9,0,
100,10,0,132,0,0,131,1,0,90,9,0,101,6,0,100,
11,0,100,12,0,132,0,0,131,1,0,90,10,0,101,6,
0,101,11,0,100,13,0,100,14,0,132,0,0,131,1,0,
131,1,0,90,12,0,101,6,0,101,11,0,100,15,0,100,
16,0,132,0,0,131,1,0,131,1,0,90,13,0,101,6,
0,101,11,0,100,17,0,100,18,0,132,0,0,131,1,0,
131,1,0,90,14,0,100,4,0,83,41,19,218,14,70,114,
111,122,101,110,73,109,112,111,114,116,101,114,122,142,77,101,
116,97,32,112,97,116,104,32,105,109,112,111,114,116,32,102,
111,114,32,102,114,111,122,101,110,32,109,111,100,117,108,101,
115,46,10,10,32,32,32,32,65,108,108,32,109,101,116,104,
111,100,115,32,97,114,101,32,101,105,116,104,101,114,32,99,
108,97,115,115,32,111,114,32,115,116,97,116,105,99,32,109,
101,116,104,111,100,115,32,116,111,32,97,118,111,105,100,32,
116,104,101,32,110,101,101,100,32,116,111,10,32,32,32,32,
105,110,115,116,97,110,116,105,97,116,101,32,116,104,101,32,
99,108,97,115,115,46,10,10,32,32,32,32,99,1,0,0,
0,0,0,0,0,1,0,0,0,2,0,0,0,67,0,0,
0,115,16,0,0,0,100,1,0,106,0,0,124,0,0,106,
1,0,131,1,0,83,41,2,122,115,82,101,116,117,114,110,
32,114,101,112,114,32,102,111,114,32,116,104,101,32,109,111,
100,117,108,101,46,10,10,32,32,32,32,32,32,32,32,84,
104,101,32,109,101,116,104,111,100,32,105,115,32,100,101,112,
114,101,99,97,116,101,100,46,32,32,84,104,101,32,105,109,
112,111,114,116,32,109,97,99,104,105,110,101,114,121,32,100,
111,101,115,32,116,104,101,32,106,111,98,32,105,116,115,101,
108,102,46,10,10,32,32,32,32,32,32,32,32,122,22,60,
109,111,100,117,108,101,32,123,33,114,125,32,40,102,114,111,
122,101,110,41,62,41,2,114,47,0,0,0,114,57,0,0,
0,41,1,218,1,109,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,206,0,0,0,48,5,0,0,115,2,
0,0,0,0,7,122,26,70,114,111,122,101,110,73,109,112,
111,114,116,101,114,46,109,111,100,117,108,101,95,114,101,112,
114,78,99,4,0,0,0,0,0,0,0,4,0,0,0,5,
0,0,0,67,0,0,0,115,42,0,0,0,116,0,0,106,
1,0,124,1,0,131,1,0,114,34,0,116,2,0,124,1,
0,124,0,0,100,1,0,100,2,0,131,2,1,83,100,0,
0,83,100,0,0,83,41,3,78,114,218,0,0,0,90,6,
102,114,111,122,101,110,41,3,114,106,0,0,0,114,163,0,
0,0,114,174,0,0,0,41,4,114,12,1,0,0,114,159,
0,0,0,114,35,0,0,0,114,13,1,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,114,14,1,0,
0,57,5,0,0,115,6,0,0,0,0,2,15,1,19,2,
122,24,70,114,111,122,101,110,73,109,112,111,114,116,101,114,
46,102,105,110,100,95,115,112,101,99,99,3,0,0,0,0,
0,0,0,3,0,0,0,2,0,0,0,67,0,0,0,115,
23,0,0,0,116,0,0,106,1,0,124,1,0,131,1,0,
114,19,0,124,0,0,83,100,1,0,83,41,2,122,93,70,
105,110,100,32,97,32,102,114,111,122,101,110,32,109,111,100,
117,108,101,46,10,10,32,32,32,32,32,32,32,32,84,104,
105,115,32,109,101,116,104,111,100,32,105,115,32,100,101,112,
114,101,99,97,116,101,100,46,32,32,85,115,101,32,102,105,
110,100,95,115,112,101,99,40,41,32,105,110,115,116,101,97,
100,46,10,10,32,32,32,32,32,32,32,32,78,41,2,114,
106,0,0,0,114,163,0,0,0,41,3,114,12,1,0,0,
114,159,0,0,0,114,35,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,114,15,1,0,0,64,5,
0,0,115,2,0,0,0,0,7,122,26,70,114,111,122,101,
110,73,109,112,111,114,116,101,114,46,102,105,110,100,95,109,
111,100,117,108,101,99,1,0,0,0,0,0,0,0,3,0,
0,0,4,0,0,0,67,0,0,0,115,95,0,0,0,124,
0,0,106,0,0,106,1,0,125,1,0,116,2,0,106,3,
0,124,1,0,131,1,0,115,57,0,116,4,0,100,1,0,
106,5,0,124,1,0,131,1,0,100,2,0,124,1,0,131,
1,1,130,1,0,110,0,0,116,6,0,116,2,0,106,7,
0,124,1,0,131,2,0,125,2,0,116,8,0,124,2,0,
124,0,0,106,9,0,131,2,0,1,100,0,0,83,41,3,
78,122,27,123,33,114,125,32,105,115,32,110,111,116,32,97,
32,102,114,111,122,101,110,32,109,111,100,117,108,101,114,67,
0,0,0,41,10,114,209,0,0,0,114,67,0,0,0,114,
106,0,0,0,114,163,0,0,0,114,154,0,0,0,114,47,
0,0,0,114,114,0,0,0,218,17,103,101,116,95,102,114,
111,122,101,110,95,111,98,106,101,99,116,114,176,0,0,0,
114,63,0,0,0,41,3,114,180,0,0,0,114,67,0,0,
0,114,195,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,2,1,0,0,73,5,0,0,115,12,
0,0,0,0,2,12,1,15,1,18,1,12,1,18,1,122,
26,70,114,111,122,101,110,73,109,112,111,114,116,101,114,46,
101,120,101,99,95,109,111,100,117,108,101,99,2,0,0,0,
0,0,0,0,2,0,0,0,3,0,0,0,67,0,0,0,
115,13,0,0,0,116,0,0,124,0,0,124,1,0,131,2,
0,83,41,1,122,95,76,111,97,100,32,97,32,102,114,111,
122,101,110,32,109,111,100,117,108,101,46,10,10,32,32,32,
32,32,32,32,32,84,104,105,115,32,109,101,116,104,111,100,
32,105,115,32,100,101,112,114,101,99,97,116,101,100,46,32,
32,85,115,101,32,101,120,101,99,95,109,111,100,117,108,101,
40,41,32,105,110,115,116,101,97,100,46,10,10,32,32,32,
32,32,32,32,32,41,1,114,181,0,0,0,41,2,114,12,
1,0,0,114,159,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,5,1,0,0,82,5,0,0,
115,2,0,0,0,0,7,122,26,70,114,111,122,101,110,73,
109,112,111,114,116,101,114,46,108,111,97,100,95,109,111,100,
117,108,101,99,2,0,0,0,0,0,0,0,2,0,0,0,
2,0,0,0,67,0,0,0,115,13,0,0,0,116,0,0,
106,1,0,124,1,0,131,1,0,83,41,1,122,45,82,101,
116,117,114,110,32,116,104,101,32,99,111,100,101,32,111,98,
106,101,99,116,32,102,111,114,32,116,104,101,32,102,114,111,
122,101,110,32,109,111,100,117,108,101,46,41,2,114,106,0,
0,0,114,22,1,0,0,41,2,114,12,1,0,0,114,159,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,16,1,0,0,91,5,0,0,115,2,0,0,0,
0,4,122,23,70,114,111,122,101,110,73,109,112,111,114,116,
101,114,46,103,101,116,95,99,111,100,101,99,2,0,0,0,
0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,
115,4,0,0,0,100,1,0,83,41,2,122,54,82,101,116,
117,114,110,32,78,111,110,101,32,97,115,32,102,114,111,122,
101,110,32,109,111,100,117,108,101,115,32,100,111,32,110,111,
116,32,104,97,118,101,32,115,111,117,114,99,101,32,99,111,
100,101,46,78,114,4,0,0,0,41,2,114,12,1,0,0,
114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,17,1,0,0,97,5,0,0,115,2,0,
0,0,0,4,122,25,70,114,111,122,101,110,73,109,112,111,
114,116,101,114,46,103,101,116,95,115,111,117,114,99,101,99,
2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,
67,0,0,0,115,13,0,0,0,116,0,0,106,1,0,124,
1,0,131,1,0,83,41,1,122,46,82,101,116,117,114,110,
32,84,114,117,101,32,105,102,32,116,104,101,32,102,114,111,
122,101,110,32,109,111,100,117,108,101,32,105,115,32,97,32,
112,97,99,107,97,103,101,46,41,2,114,106,0,0,0,90,
17,105,115,95,102,114,111,122,101,110,95,112,97,99,107,97,
103,101,41,2,114,12,1,0,0,114,159,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,220,0,
0,0,103,5,0,0,115,2,0,0,0,0,4,122,25,70,
114,111,122,101,110,73,109,112,111,114,116,101,114,46,105,115,
95,112,97,99,107,97,103,101,41,15,114,57,0,0,0,114,
56,0,0,0,114,58,0,0,0,114,59,0,0,0,114,18,
1,0,0,114,206,0,0,0,114,19,1,0,0,114,14,1,
0,0,114,15,1,0,0,114,2,1,0,0,114,5,1,0,
0,114,165,0,0,0,114,16,1,0,0,114,17,1,0,0,
114,220,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,114,20,1,0,0,39,5,
0,0,115,28,0,0,0,12,7,6,2,18,9,3,1,21,
6,3,1,18,8,18,9,18,9,3,1,21,5,3,1,21,
5,3,1,114,20,1,0,0,99,0,0,0,0,0,0,0,
0,0,0,0,0,5,0,0,0,64,0,0,0,115,121,0,
0,0,101,0,0,90,1,0,100,0,0,90,2,0,100,1,
0,90,3,0,100,2,0,90,4,0,100,3,0,90,5,0,
100,4,0,90,6,0,101,7,0,100,5,0,100,6,0,132,
0,0,131,1,0,90,8,0,101,7,0,100,7,0,100,8,
0,132,0,0,131,1,0,90,9,0,101,7,0,100,9,0,
100,9,0,100,10,0,100,11,0,132,2,0,131,1,0,90,
10,0,101,7,0,100,9,0,100,12,0,100,13,0,132,1,
0,131,1,0,90,11,0,100,9,0,83,41,14,218,21,87,
105,110,100,111,119,115,82,101,103,105,115,116,114,121,70,105,
110,100,101,114,122,62,77,101,116,97,32,112,97,116,104,32,
102,105,110,100,101,114,32,102,111,114,32,109,111,100,117,108,
101,115,32,100,101,99,108,97,114,101,100,32,105,110,32,116,
104,101,32,87,105,110,100,111,119,115,32,114,101,103,105,115,
116,114,121,46,122,59,83,111,102,116,119,97,114,101,92,80,
121,116,104,111,110,92,80,121,116,104,111,110,67,111,114,101,
92,123,115,121,115,95,118,101,114,115,105,111,110,125,92,77,
111,100,117,108,101,115,92,123,102,117,108,108,110,97,109,101,
125,122,65,83,111,102,116,119,97,114,101,92,80,121,116,104,
111,110,92,80,121,116,104,111,110,67,111,114,101,92,123,115,
121,115,95,118,101,114,115,105,111,110,125,92,77,111,100,117,
108,101,115,92,123,102,117,108,108,110,97,109,101,125,92,68,
101,98,117,103,70,99,2,0,0,0,0,0,0,0,2,0,
0,0,11,0,0,0,67,0,0,0,115,67,0,0,0,121,
23,0,116,0,0,106,1,0,116,0,0,106,2,0,124,1,
0,131,2,0,83,87,110,37,0,4,116,3,0,107,10,0,
114,62,0,1,1,1,116,0,0,106,1,0,116,0,0,106,
4,0,124,1,0,131,2,0,83,89,110,1,0,88,100,0,
0,83,41,1,78,41,5,218,7,95,119,105,110,114,101,103,
90,7,79,112,101,110,75,101,121,90,17,72,75,69,89,95,
67,85,82,82,69,78,84,95,85,83,69,82,114,40,0,0,
0,90,18,72,75,69,89,95,76,79,67,65,76,95,77,65,
67,72,73,78,69,41,2,114,12,1,0,0,218,3,107,101,
121,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
218,14,95,111,112,101,110,95,114,101,103,105,115,116,114,121,
122,5,0,0,115,8,0,0,0,0,2,3,1,23,1,13,
1,122,36,87,105,110,100,111,119,115,82,101,103,105,115,116,
114,121,70,105,110,100,101,114,46,95,111,112,101,110,95,114,
101,103,105,115,116,114,121,99,2,0,0,0,0,0,0,0,
6,0,0,0,16,0,0,0,67,0,0,0,115,142,0,0,
0,124,0,0,106,0,0,114,21,0,124,0,0,106,1,0,
125,2,0,110,9,0,124,0,0,106,2,0,125,2,0,124,
2,0,106,3,0,100,1,0,124,1,0,100,2,0,116,4,
0,106,5,0,100,0,0,100,3,0,133,2,0,25,131,0,
2,125,3,0,121,46,0,124,0,0,106,6,0,124,3,0,
131,1,0,143,25,0,125,4,0,116,7,0,106,8,0,124,
4,0,100,4,0,131,2,0,125,5,0,87,100,0,0,81,
88,87,110,22,0,4,116,9,0,107,10,0,114,137,0,1,
1,1,100,0,0,83,89,110,1,0,88,124,5,0,83,41,
5,78,114,159,0,0,0,90,11,115,121,115,95,118,101,114,
115,105,111,110,114,137,0,0,0,114,30,0,0,0,41,10,
218,11,68,69,66,85,71,95,66,85,73,76,68,218,18,82,
69,71,73,83,84,82,89,95,75,69,89,95,68,69,66,85,
71,218,12,82,69,71,73,83,84,82,89,95,75,69,89,114,
47,0,0,0,114,7,0,0,0,218,7,118,101,114,115,105,
111,110,114,26,1,0,0,114,24,1,0,0,90,10,81,117,
101,114,121,86,97,108,117,101,114,40,0,0,0,41,6,114,
12,1,0,0,114,159,0,0,0,90,12,114,101,103,105,115,
116,114,121,95,107,101,121,114,25,1,0,0,90,4,104,107,
101,121,218,8,102,105,108,101,112,97,116,104,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,16,95,115,101,
97,114,99,104,95,114,101,103,105,115,116,114,121,129,5,0,
0,115,22,0,0,0,0,2,9,1,12,2,9,1,15,1,
22,1,3,1,18,1,28,1,13,1,9,1,122,38,87,105,
110,100,111,119,115,82,101,103,105,115,116,114,121,70,105,110,
100,101,114,46,95,115,101,97,114,99,104,95,114,101,103,105,
115,116,114,121,78,99,4,0,0,0,0,0,0,0,8,0,
0,0,14,0,0,0,67,0,0,0,115,155,0,0,0,124,
0,0,106,0,0,124,1,0,131,1,0,125,4,0,124,4,
0,100,0,0,107,8,0,114,31,0,100,0,0,83,121,14,
0,116,1,0,124,4,0,131,1,0,1,87,110,22,0,4,
116,2,0,107,10,0,114,69,0,1,1,1,100,0,0,83,
89,110,1,0,88,120,78,0,116,3,0,131,0,0,68,93,
67,0,92,2,0,125,5,0,125,6,0,124,4,0,106,4,
0,116,5,0,124,6,0,131,1,0,131,1,0,114,80,0,
116,6,0,124,1,0,124,5,0,124,1,0,124,4,0,131,
2,0,100,1,0,124,4,0,131,2,1,125,7,0,124,7,
0,83,113,80,0,87,100,0,0,83,41,2,78,114,218,0,
0,0,41,7,114,32,1,0,0,114,39,0,0,0,114,40,
0,0,0,114,241,0,0,0,114,231,0,0,0,114,232,0,
0,0,114,174,0,0,0,41,8,114,12,1,0,0,114,159,
0,0,0,114,35,0,0,0,114,13,1,0,0,114,31,1,
0,0,114,170,0,0,0,114,126,0,0,0,114,178,0,0,
0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,14,1,0,0,144,5,0,0,115,24,0,0,0,0,2,
15,1,12,1,4,1,3,1,14,1,13,1,9,1,22,1,
21,1,21,1,9,1,122,31,87,105,110,100,111,119,115,82,
101,103,105,115,116,114,121,70,105,110,100,101,114,46,102,105,
110,100,95,115,112,101,99,99,3,0,0,0,0,0,0,0,
4,0,0,0,3,0,0,0,67,0,0,0,115,45,0,0,
0,124,0,0,106,0,0,124,1,0,124,2,0,131,2,0,
125,3,0,124,3,0,100,1,0,107,9,0,114,37,0,124,
3,0,106,1,0,83,100,1,0,83,100,1,0,83,41,2,
122,108,70,105,110,100,32,109,111,100,117,108,101,32,110,97,
109,101,100,32,105,110,32,116,104,101,32,114,101,103,105,115,
116,114,121,46,10,10,32,32,32,32,32,32,32,32,84,104,
105,115,32,109,101,116,104,111,100,32,105,115,32,100,101,112,
114,101,99,97,116,101,100,46,32,32,85,115,101,32,101,120,
101,99,95,109,111,100,117,108,101,40,41,32,105,110,115,116,
101,97,100,46,10,10,32,32,32,32,32,32,32,32,78,41,
2,114,14,1,0,0,114,170,0,0,0,41,4,114,12,1,
0,0,114,159,0,0,0,114,35,0,0,0,114,178,0,0,
0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,15,1,0,0,159,5,0,0,115,8,0,0,0,0,7,
18,1,12,1,7,2,122,33,87,105,110,100,111,119,115,82,
101,103,105,115,116,114,121,70,105,110,100,101,114,46,102,105,
110,100,95,109,111,100,117,108,101,41,12,114,57,0,0,0,
114,56,0,0,0,114,58,0,0,0,114,59,0,0,0,114,
29,1,0,0,114,28,1,0,0,114,27,1,0,0,114,19,
1,0,0,114,26,1,0,0,114,32,1,0,0,114,14,1,
0,0,114,15,1,0,0,114,4,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,23,1,0,0,
110,5,0,0,115,20,0,0,0,12,2,6,3,6,3,6,
2,6,2,18,7,18,15,3,1,21,14,3,1,114,23,1,
0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,2,
0,0,0,64,0,0,0,115,52,0,0,0,101,0,0,90,
1,0,100,0,0,90,2,0,100,1,0,90,3,0,100,2,
0,100,3,0,132,0,0,90,4,0,100,4,0,100,5,0,
132,0,0,90,5,0,101,6,0,90,7,0,100,6,0,83,
41,7,218,13,95,76,111,97,100,101,114,66,97,115,105,99,
115,122,83,66,97,115,101,32,99,108,97,115,115,32,111,102,
32,99,111,109,109,111,110,32,99,111,100,101,32,110,101,101,
100,101,100,32,98,121,32,98,111,116,104,32,83,111,117,114,
99,101,76,111,97,100,101,114,32,97,110,100,10,32,32,32,
32,83,111,117,114,99,101,108,101,115,115,70,105,108,101,76,
111,97,100,101,114,46,99,2,0,0,0,0,0,0,0,5,
0,0,0,3,0,0,0,67,0,0,0,115,88,0,0,0,
116,0,0,124,0,0,106,1,0,124,1,0,131,1,0,131,
1,0,100,1,0,25,125,2,0,124,2,0,106,2,0,100,
2,0,100,1,0,131,2,0,100,3,0,25,125,3,0,124,
1,0,106,3,0,100,2,0,131,1,0,100,4,0,25,125,
4,0,124,3,0,100,5,0,107,2,0,111,87,0,124,4,
0,100,5,0,107,3,0,83,41,6,122,141,67,111,110,99,
114,101,116,101,32,105,109,112,108,101,109,101,110,116,97,116,
105,111,110,32,111,102,32,73,110,115,112,101,99,116,76,111,
97,100,101,114,46,105,115,95,112,97,99,107,97,103,101,32,
98,121,32,99,104,101,99,107,105,110,103,32,105,102,10,32,
32,32,32,32,32,32,32,116,104,101,32,112,97,116,104,32,
114,101,116,117,114,110,101,100,32,98,121,32,103,101,116,95,
102,105,108,101,110,97,109,101,32,104,97,115,32,97,32,102,
105,108,101,110,97,109,101,32,111,102,32,39,95,95,105,110,
105,116,95,95,46,112,121,39,46,114,29,0,0,0,114,116,
0,0,0,114,84,0,0,0,114,115,0,0,0,114,72,0,
0,0,41,4,114,38,0,0,0,114,239,0,0,0,114,34,
0,0,0,114,32,0,0,0,41,5,114,71,0,0,0,114,
159,0,0,0,114,131,0,0,0,90,13,102,105,108,101,110,
97,109,101,95,98,97,115,101,90,9,116,97,105,108,95,110,
97,109,101,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,220,0,0,0,178,5,0,0,115,8,0,0,0,
0,3,25,1,22,1,19,1,122,24,95,76,111,97,100,101,
114,66,97,115,105,99,115,46,105,115,95,112,97,99,107,97,
103,101,99,2,0,0,0,0,0,0,0,3,0,0,0,4,
0,0,0,67,0,0,0,115,80,0,0,0,124,0,0,106,
0,0,124,1,0,106,1,0,131,1,0,125,2,0,124,2,
0,100,1,0,107,8,0,114,57,0,116,2,0,100,2,0,
106,3,0,124,1,0,106,1,0,131,1,0,131,1,0,130,
1,0,110,0,0,116,4,0,116,5,0,124,2,0,124,1,
0,106,6,0,131,3,0,1,100,1,0,83,41,3,122,19,
69,120,101,99,117,116,101,32,116,104,101,32,109,111,100,117,
108,101,46,78,122,52,99,97,110,110,111,116,32,108,111,97,
100,32,109,111,100,117,108,101,32,123,33,114,125,32,119,104,
101,110,32,103,101,116,95,99,111,100,101,40,41,32,114,101,
116,117,114,110,115,32,78,111,110,101,41,7,114,16,1,0,
0,114,57,0,0,0,114,154,0,0,0,114,47,0,0,0,
114,114,0,0,0,114,176,0,0,0,114,63,0,0,0,41,
3,114,71,0,0,0,114,180,0,0,0,114,195,0,0,0,
114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
2,1,0,0,186,5,0,0,115,10,0,0,0,0,2,18,
1,12,1,9,1,18,1,122,25,95,76,111,97,100,101,114,
66,97,115,105,99,115,46,101,120,101,99,95,109,111,100,117,
108,101,78,41,8,114,57,0,0,0,114,56,0,0,0,114,
58,0,0,0,114,59,0,0,0,114,220,0,0,0,114,2,
1,0,0,114,181,0,0,0,114,5,1,0,0,114,4,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,114,33,1,0,0,173,5,0,0,115,8,0,0,0,12,
3,6,2,12,8,12,8,114,33,1,0,0,99,0,0,0,
0,0,0,0,0,0,0,0,0,4,0,0,0,64,0,0,
0,115,106,0,0,0,101,0,0,90,1,0,100,0,0,90,
2,0,100,1,0,100,2,0,132,0,0,90,3,0,100,3,
0,100,4,0,132,0,0,90,4,0,100,5,0,100,6,0,
132,0,0,90,5,0,100,7,0,100,8,0,132,0,0,90,
6,0,100,9,0,100,10,0,132,0,0,90,7,0,100,11,
0,100,18,0,100,13,0,100,14,0,132,0,1,90,8,0,
100,15,0,100,16,0,132,0,0,90,9,0,100,17,0,83,
41,19,218,12,83,111,117,114,99,101,76,111,97,100,101,114,
99,2,0,0,0,0,0,0,0,2,0,0,0,1,0,0,
0,67,0,0,0,115,10,0,0,0,116,0,0,130,1,0,
100,1,0,83,41,2,122,178,79,112,116,105,111,110,97,108,
32,109,101,116,104,111,100,32,116,104,97,116,32,114,101,116,
117,114,110,115,32,116,104,101,32,109,111,100,105,102,105,99,
97,116,105,111,110,32,116,105,109,101,32,40,97,110,32,105,
110,116,41,32,102,111,114,32,116,104,101,10,32,32,32,32,
32,32,32,32,115,112,101,99,105,102,105,101,100,32,112,97,
116,104,44,32,119,104,101,114,101,32,112,97,116,104,32,105,
115,32,97,32,115,116,114,46,10,10,32,32,32,32,32,32,
32,32,82,97,105,115,101,115,32,73,79,69,114,114,111,114,
32,119,104,101,110,32,116,104,101,32,112,97,116,104,32,99,
97,110,110,111,116,32,98,101,32,104,97,110,100,108,101,100,
46,10,32,32,32,32,32,32,32,32,78,41,1,218,7,73,
79,69,114,114,111,114,41,2,114,71,0,0,0,114,35,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,218,10,112,97,116,104,95,109,116,105,109,101,199,5,0,
0,115,2,0,0,0,0,6,122,23,83,111,117,114,99,101,
76,111,97,100,101,114,46,112,97,116,104,95,109,116,105,109,
101,99,2,0,0,0,0,0,0,0,2,0,0,0,3,0,
0,0,67,0,0,0,115,20,0,0,0,105,1,0,124,0,
0,106,0,0,124,1,0,131,1,0,100,1,0,54,83,41,
2,97,170,1,0,0,79,112,116,105,111,110,97,108,32,109,
101,116,104,111,100,32,114,101,116,117,114,110,105,110,103,32,
97,32,109,101,116,97,100,97,116,97,32,100,105,99,116,32,
102,111,114,32,116,104,101,32,115,112,101,99,105,102,105,101,
100,32,112,97,116,104,10,32,32,32,32,32,32,32,32,116,
111,32,98,121,32,116,104,101,32,112,97,116,104,32,40,115,
116,114,41,46,10,32,32,32,32,32,32,32,32,80,111,115,
115,105,98,108,101,32,107,101,121,115,58,10,32,32,32,32,
32,32,32,32,45,32,39,109,116,105,109,101,39,32,40,109,
97,110,100,97,116,111,114,121,41,32,105,115,32,116,104,101,
32,110,117,109,101,114,105,99,32,116,105,109,101,115,116,97,
109,112,32,111,102,32,108,97,115,116,32,115,111,117,114,99,
101,10,32,32,32,32,32,32,32,32,32,32,99,111,100,101,
32,109,111,100,105,102,105,99,97,116,105,111,110,59,10,32,
32,32,32,32,32,32,32,45,32,39,115,105,122,101,39,32,
40,111,112,116,105,111,110,97,108,41,32,105,115,32,116,104,
101,32,115,105,122,101,32,105,110,32,98,121,116,101,115,32,
111,102,32,116,104,101,32,115,111,117,114,99,101,32,99,111,
100,101,46,10,10,32,32,32,32,32,32,32,32,73,109,112,
108,101,109,101,110,116,105,110,103,32,116,104,105,115,32,109,
101,116,104,111,100,32,97,108,108,111,119,115,32,116,104,101,
32,108,111,97,100,101,114,32,116,111,32,114,101,97,100,32,
98,121,116,101,99,111,100,101,32,102,105,108,101,115,46,10,
32,32,32,32,32,32,32,32,82,97,105,115,101,115,32,73,
79,69,114,114,111,114,32,119,104,101,110,32,116,104,101,32,
112,97,116,104,32,99,97,110,110,111,116,32,98,101,32,104,
97,110,100,108,101,100,46,10,32,32,32,32,32,32,32,32,
114,184,0,0,0,41,1,114,36,1,0,0,41,2,114,71,
0,0,0,114,35,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,10,112,97,116,104,95,115,116,
97,116,115,207,5,0,0,115,2,0,0,0,0,11,122,23,
83,111,117,114,99,101,76,111,97,100,101,114,46,112,97,116,
104,95,115,116,97,116,115,99,4,0,0,0,0,0,0,0,
4,0,0,0,3,0,0,0,67,0,0,0,115,16,0,0,
0,124,0,0,106,0,0,124,2,0,124,3,0,131,2,0,
83,41,1,122,228,79,112,116,105,111,110,97,108,32,109,101,
116,104,111,100,32,119,104,105,99,104,32,119,114,105,116,101,
115,32,100,97,116,97,32,40,98,121,116,101,115,41,32,116,
111,32,97,32,102,105,108,101,32,112,97,116,104,32,40,97,
32,115,116,114,41,46,10,10,32,32,32,32,32,32,32,32,
73,109,112,108,101,109,101,110,116,105,110,103,32,116,104,105,
115,32,109,101,116,104,111,100,32,97,108,108,111,119,115,32,
102,111,114,32,116,104,101,32,119,114,105,116,105,110,103,32,
111,102,32,98,121,116,101,99,111,100,101,32,102,105,108,101,
115,46,10,10,32,32,32,32,32,32,32,32,84,104,101,32,
115,111,117,114,99,101,32,112,97,116,104,32,105,115,32,110,
101,101,100,101,100,32,105,110,32,111,114,100,101,114,32,116,
111,32,99,111,114,114,101,99,116,108,121,32,116,114,97,110,
115,102,101,114,32,112,101,114,109,105,115,115,105,111,110,115,
10,32,32,32,32,32,32,32,32,41,1,218,8,115,101,116,
95,100,97,116,97,41,4,114,71,0,0,0,114,143,0,0,
0,90,10,99,97,99,104,101,95,112,97,116,104,114,53,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,218,15,95,99,97,99,104,101,95,98,121,116,101,99,111,
100,101,220,5,0,0,115,2,0,0,0,0,8,122,28,83,
111,117,114,99,101,76,111,97,100,101,114,46,95,99,97,99,
104,101,95,98,121,116,101,99,111,100,101,99,3,0,0,0,
0,0,0,0,3,0,0,0,1,0,0,0,67,0,0,0,
115,4,0,0,0,100,1,0,83,41,2,122,150,79,112,116,
105,111,110,97,108,32,109,101,116,104,111,100,32,119,104,105,
99,104,32,119,114,105,116,101,115,32,100,97,116,97,32,40,
98,121,116,101,115,41,32,116,111,32,97,32,102,105,108,101,
32,112,97,116,104,32,40,97,32,115,116,114,41,46,10,10,
32,32,32,32,32,32,32,32,73,109,112,108,101,109,101,110,
116,105,110,103,32,116,104,105,115,32,109,101,116,104,111,100,
32,97,108,108,111,119,115,32,102,111,114,32,116,104,101,32,
119,114,105,116,105,110,103,32,111,102,32,98,121,116,101,99,
111,100,101,32,102,105,108,101,115,46,10,32,32,32,32,32,
32,32,32,78,114,4,0,0,0,41,3,114,71,0,0,0,
114,35,0,0,0,114,53,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,114,38,1,0,0,230,5,
0,0,115,0,0,0,0,122,21,83,111,117,114,99,101,76,
111,97,100,101,114,46,115,101,116,95,100,97,116,97,99,2,
0,0,0,0,0,0,0,5,0,0,0,16,0,0,0,67,
0,0,0,115,105,0,0,0,124,0,0,106,0,0,124,1,
0,131,1,0,125,2,0,121,19,0,124,0,0,106,1,0,
124,2,0,131,1,0,125,3,0,87,110,58,0,4,116,2,
0,107,10,0,114,94,0,1,125,4,0,1,122,26,0,116,
3,0,100,1,0,100,2,0,124,1,0,131,1,1,124,4,
0,130,2,0,87,89,100,3,0,100,3,0,125,4,0,126,
4,0,88,110,1,0,88,116,4,0,124,3,0,131,1,0,
83,41,4,122,52,67,111,110,99,114,101,116,101,32,105,109,
112,108,101,109,101,110,116,97,116,105,111,110,32,111,102,32,
73,110,115,112,101,99,116,76,111,97,100,101,114,46,103,101,
116,95,115,111,117,114,99,101,46,122,39,115,111,117,114,99,
101,32,110,111,116,32,97,118,97,105,108,97,98,108,101,32,
116,104,114,111,117,103,104,32,103,101,116,95,100,97,116,97,
40,41,114,67,0,0,0,78,41,5,114,239,0,0,0,218,
8,103,101,116,95,100,97,116,97,114,40,0,0,0,114,154,
0,0,0,114,204,0,0,0,41,5,114,71,0,0,0,114,
159,0,0,0,114,35,0,0,0,114,202,0,0,0,218,3,
101,120,99,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,17,1,0,0,237,5,0,0,115,14,0,0,0,
0,2,15,1,3,1,19,1,18,1,9,1,31,1,122,23,
83,111,117,114,99,101,76,111,97,100,101,114,46,103,101,116,
95,115,111,117,114,99,101,218,9,95,111,112,116,105,109,105,
122,101,114,29,0,0,0,99,3,0,0,0,1,0,0,0,
4,0,0,0,9,0,0,0,67,0,0,0,115,31,0,0,
0,116,0,0,116,1,0,124,1,0,124,2,0,100,1,0,
100,2,0,100,3,0,100,4,0,124,3,0,131,4,2,83,
41,5,122,130,82,101,116,117,114,110,32,116,104,101,32,99,
111,100,101,32,111,98,106,101,99,116,32,99,111,109,112,105,
108,101,100,32,102,114,111,109,32,115,111,117,114,99,101,46,
10,10,32,32,32,32,32,32,32,32,84,104,101,32,39,100,
97,116,97,39,32,97,114,103,117,109,101,110,116,32,99,97,
110,32,98,101,32,97,110,121,32,111,98,106,101,99,116,32,
116,121,112,101,32,116,104,97,116,32,99,111,109,112,105,108,
101,40,41,32,115,117,112,112,111,114,116,115,46,10,32,32,
32,32,32,32,32,32,114,176,0,0,0,218,12,100,111,110,
116,95,105,110,104,101,114,105,116,84,114,118,0,0,0,41,
2,114,114,0,0,0,218,7,99,111,109,112,105,108,101,41,
4,114,71,0,0,0,114,53,0,0,0,114,35,0,0,0,
114,42,1,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,218,14,115,111,117,114,99,101,95,116,111,95,
99,111,100,101,247,5,0,0,115,4,0,0,0,0,5,18,
1,122,27,83,111,117,114,99,101,76,111,97,100,101,114,46,
115,111,117,114,99,101,95,116,111,95,99,111,100,101,99,2,
0,0,0,0,0,0,0,10,0,0,0,43,0,0,0,67,
0,0,0,115,177,1,0,0,124,0,0,106,0,0,124,1,
0,131,1,0,125,2,0,100,1,0,125,3,0,121,16,0,
116,1,0,124,2,0,131,1,0,125,4,0,87,110,24,0,
4,116,2,0,107,10,0,114,63,0,1,1,1,100,1,0,
125,4,0,89,110,202,0,88,121,19,0,124,0,0,106,3,
0,124,2,0,131,1,0,125,5,0,87,110,18,0,4,116,
4,0,107,10,0,114,103,0,1,1,1,89,110,162,0,88,
116,5,0,124,5,0,100,2,0,25,131,1,0,125,3,0,
121,19,0,124,0,0,106,6,0,124,4,0,131,1,0,125,
6,0,87,110,18,0,4,116,7,0,107,10,0,114,159,0,
1,1,1,89,110,106,0,88,121,34,0,116,8,0,124,6,
0,100,3,0,124,5,0,100,4,0,124,1,0,100,5,0,
124,4,0,131,1,3,125,7,0,87,110,24,0,4,116,9,
0,116,10,0,102,2,0,107,10,0,114,220,0,1,1,1,
89,110,45,0,88,116,11,0,100,6,0,124,4,0,124,2,
0,131,3,0,1,116,12,0,124,7,0,100,4,0,124,1,
0,100,7,0,124,4,0,100,8,0,124,2,0,131,1,3,
83,124,0,0,106,6,0,124,2,0,131,1,0,125,8,0,
124,0,0,106,13,0,124,8,0,124,2,0,131,2,0,125,
9,0,116,11,0,100,9,0,124,2,0,131,2,0,1,116,
14,0,106,15,0,12,114,173,1,124,4,0,100,1,0,107,
9,0,114,173,1,124,3,0,100,1,0,107,9,0,114,173,
1,116,16,0,124,9,0,124,3,0,116,17,0,124,8,0,
131,1,0,131,3,0,125,6,0,121,36,0,124,0,0,106,
18,0,124,2,0,124,4,0,124,6,0,131,3,0,1,116,
11,0,100,10,0,124,4,0,131,2,0,1,87,113,173,1,
4,116,2,0,107,10,0,114,169,1,1,1,1,89,113,173,
1,88,110,0,0,124,9,0,83,41,11,122,190,67,111,110,
99,114,101,116,101,32,105,109,112,108,101,109,101,110,116,97,
116,105,111,110,32,111,102,32,73,110,115,112,101,99,116,76,
111,97,100,101,114,46,103,101,116,95,99,111,100,101,46,10,
10,32,32,32,32,32,32,32,32,82,101,97,100,105,110,103,
32,111,102,32,98,121,116,101,99,111,100,101,32,114,101,113,
117,105,114,101,115,32,112,97,116,104,95,115,116,97,116,115,
32,116,111,32,98,101,32,105,109,112,108,101,109,101,110,116,
101,100,46,32,84,111,32,119,114,105,116,101,10,32,32,32,
32,32,32,32,32,98,121,116,101,99,111,100,101,44,32,115,
101,116,95,100,97,116,97,32,109,117,115,116,32,97,108,115,
111,32,98,101,32,105,109,112,108,101,109,101,110,116,101,100,
46,10,10,32,32,32,32,32,32,32,32,78,114,184,0,0,
0,114,188,0,0,0,114,67,0,0,0,114,35,0,0,0,
122,13,123,125,32,109,97,116,99,104,101,115,32,123,125,114,
142,0,0,0,114,143,0,0,0,122,19,99,111,100,101,32,
111,98,106,101,99,116,32,102,114,111,109,32,123,125,122,10,
119,114,111,116,101,32,123,33,114,125,41,19,114,239,0,0,
0,114,132,0,0,0,114,123,0,0,0,114,37,1,0,0,
114,35,1,0,0,114,14,0,0,0,114,40,1,0,0,114,
40,0,0,0,114,191,0,0,0,114,154,0,0,0,114,187,
0,0,0,114,153,0,0,0,114,196,0,0,0,114,45,1,
0,0,114,7,0,0,0,218,19,100,111,110,116,95,119,114,
105,116,101,95,98,121,116,101,99,111,100,101,114,199,0,0,
0,114,31,0,0,0,114,39,1,0,0,41,10,114,71,0,
0,0,114,159,0,0,0,114,143,0,0,0,114,189,0,0,
0,114,142,0,0,0,218,2,115,116,114,53,0,0,0,218,
10,98,121,116,101,115,95,100,97,116,97,114,202,0,0,0,
90,11,99,111,100,101,95,111,98,106,101,99,116,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,114,16,1,0,
0,255,5,0,0,115,78,0,0,0,0,7,15,1,6,1,
3,1,16,1,13,1,11,2,3,1,19,1,13,1,5,2,
16,1,3,1,19,1,13,1,5,2,3,1,9,1,12,1,
13,1,19,1,5,2,9,1,7,1,15,1,6,1,7,1,
15,1,18,1,13,1,22,1,12,1,9,1,15,1,3,1,
19,1,17,1,13,1,8,1,122,21,83,111,117,114,99,101,
76,111,97,100,101,114,46,103,101,116,95,99,111,100,101,78,
114,139,0,0,0,41,10,114,57,0,0,0,114,56,0,0,
0,114,58,0,0,0,114,36,1,0,0,114,37,1,0,0,
114,39,1,0,0,114,38,1,0,0,114,17,1,0,0,114,
45,1,0,0,114,16,1,0,0,114,4,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,34,1,
0,0,197,5,0,0,115,14,0,0,0,12,2,12,8,12,
13,12,10,12,7,12,10,18,8,114,34,1,0,0,99,0,
0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
0,0,0,115,112,0,0,0,101,0,0,90,1,0,100,0,
0,90,2,0,100,1,0,90,3,0,100,2,0,100,3,0,
132,0,0,90,4,0,100,4,0,100,5,0,132,0,0,90,
5,0,100,6,0,100,7,0,132,0,0,90,6,0,101,7,
0,135,0,0,102,1,0,100,8,0,100,9,0,134,0,0,
131,1,0,90,8,0,101,7,0,100,10,0,100,11,0,132,
0,0,131,1,0,90,9,0,100,12,0,100,13,0,132,0,
0,90,10,0,135,0,0,83,41,14,218,10,70,105,108,101,
76,111,97,100,101,114,122,103,66,97,115,101,32,102,105,108,
101,32,108,111,97,100,101,114,32,99,108,97,115,115,32,119,
104,105,99,104,32,105,109,112,108,101,109,101,110,116,115,32,
116,104,101,32,108,111,97,100,101,114,32,112,114,111,116,111,
99,111,108,32,109,101,116,104,111,100,115,32,116,104,97,116,
10,32,32,32,32,114,101,113,117,105,114,101,32,102,105,108,
101,32,115,121,115,116,101,109,32,117,115,97,103,101,46,99,
3,0,0,0,0,0,0,0,3,0,0,0,2,0,0,0,
67,0,0,0,115,22,0,0,0,124,1,0,124,0,0,95,
0,0,124,2,0,124,0,0,95,1,0,100,1,0,83,41,
2,122,75,67,97,99,104,101,32,116,104,101,32,109,111,100,
117,108,101,32,110,97,109,101,32,97,110,100,32,116,104,101,
32,112,97,116,104,32,116,111,32,116,104,101,32,102,105,108,
101,32,102,111,117,110,100,32,98,121,32,116,104,101,10,32,
32,32,32,32,32,32,32,102,105,110,100,101,114,46,78,41,
2,114,67,0,0,0,114,35,0,0,0,41,3,114,71,0,
0,0,114,159,0,0,0,114,35,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,72,0,0,0,
56,6,0,0,115,4,0,0,0,0,3,9,1,122,19,70,
105,108,101,76,111,97,100,101,114,46,95,95,105,110,105,116,
95,95,99,2,0,0,0,0,0,0,0,2,0,0,0,2,
0,0,0,67,0,0,0,115,34,0,0,0,124,0,0,106,
0,0,124,1,0,106,0,0,107,2,0,111,33,0,124,0,
0,106,1,0,124,1,0,106,1,0,107,2,0,83,41,1,
78,41,2,114,225,0,0,0,114,63,0,0,0,41,2,114,
71,0,0,0,114,228,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,114,230,0,0,0,62,6,0,
0,115,4,0,0,0,0,1,18,1,122,17,70,105,108,101,
76,111,97,100,101,114,46,95,95,101,113,95,95,99,1,0,
0,0,0,0,0,0,1,0,0,0,3,0,0,0,67,0,
0,0,115,26,0,0,0,116,0,0,124,0,0,106,1,0,
131,1,0,116,0,0,124,0,0,106,2,0,131,1,0,65,
83,41,1,78,41,3,218,4,104,97,115,104,114,67,0,0,
0,114,35,0,0,0,41,1,114,71,0,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,218,8,95,95,
104,97,115,104,95,95,66,6,0,0,115,2,0,0,0,0,
1,122,19,70,105,108,101,76,111,97,100,101,114,46,95,95,
104,97,115,104,95,95,99,2,0,0,0,0,0,0,0,2,
0,0,0,3,0,0,0,3,0,0,0,115,22,0,0,0,
116,0,0,116,1,0,124,0,0,131,2,0,106,2,0,124,
1,0,131,1,0,83,41,1,122,100,76,111,97,100,32,97,
32,109,111,100,117,108,101,32,102,114,111,109,32,97,32,102,
105,108,101,46,10,10,32,32,32,32,32,32,32,32,84,104,
105,115,32,109,101,116,104,111,100,32,105,115,32,100,101,112,
114,101,99,97,116,101,100,46,32,32,85,115,101,32,101,120,
101,99,95,109,111,100,117,108,101,40,41,32,105,110,115,116,
101,97,100,46,10,10,32,32,32,32,32,32,32,32,41,3,
218,5,115,117,112,101,114,114,49,1,0,0,114,5,1,0,
0,41,2,114,71,0,0,0,114,159,0,0,0,41,1,114,
225,0,0,0,114,4,0,0,0,114,5,0,0,0,114,5,
1,0,0,69,6,0,0,115,2,0,0,0,0,10,122,22,
70,105,108,101,76,111,97,100,101,114,46,108,111,97,100,95,
109,111,100,117,108,101,99,2,0,0,0,0,0,0,0,2,
0,0,0,1,0,0,0,67,0,0,0,115,7,0,0,0,
124,0,0,106,0,0,83,41,1,122,58,82,101,116,117,114,
110,32,116,104,101,32,112,97,116,104,32,116,111,32,116,104,
101,32,115,111,117,114,99,101,32,102,105,108,101,32,97,115,
32,102,111,117,110,100,32,98,121,32,116,104,101,32,102,105,
110,100,101,114,46,41,1,114,35,0,0,0,41,2,114,71,
0,0,0,114,159,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,239,0,0,0,81,6,0,0,
115,2,0,0,0,0,3,122,23,70,105,108,101,76,111,97,
100,101,114,46,103,101,116,95,102,105,108,101,110,97,109,101,
99,2,0,0,0,0,0,0,0,3,0,0,0,8,0,0,
0,67,0,0,0,115,41,0,0,0,116,0,0,106,1,0,
124,1,0,100,1,0,131,2,0,143,17,0,125,2,0,124,
2,0,106,2,0,131,0,0,83,87,100,2,0,81,88,100,
2,0,83,41,3,122,39,82,101,116,117,114,110,32,116,104,
101,32,100,97,116,97,32,102,114,111,109,32,112,97,116,104,
32,97,115,32,114,97,119,32,98,121,116,101,115,46,218,1,
114,78,41,3,114,49,0,0,0,114,50,0,0,0,90,4,
114,101,97,100,41,3,114,71,0,0,0,114,35,0,0,0,
114,54,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,40,1,0,0,86,6,0,0,115,4,0,
0,0,0,2,21,1,122,19,70,105,108,101,76,111,97,100,
101,114,46,103,101,116,95,100,97,116,97,41,11,114,57,0,
0,0,114,56,0,0,0,114,58,0,0,0,114,59,0,0,
0,114,72,0,0,0,114,230,0,0,0,114,51,1,0,0,
114,157,0,0,0,114,5,1,0,0,114,239,0,0,0,114,
40,1,0,0,114,4,0,0,0,114,4,0,0,0,41,1,
114,225,0,0,0,114,5,0,0,0,114,49,1,0,0,51,
6,0,0,115,14,0,0,0,12,3,6,2,12,6,12,4,
12,3,24,12,18,5,114,49,1,0,0,99,0,0,0,0,
0,0,0,0,0,0,0,0,4,0,0,0,64,0,0,0,
115,64,0,0,0,101,0,0,90,1,0,100,0,0,90,2,
0,100,1,0,90,3,0,100,2,0,100,3,0,132,0,0,
90,4,0,100,4,0,100,5,0,132,0,0,90,5,0,100,
6,0,100,7,0,100,8,0,100,9,0,132,0,1,90,6,
0,100,10,0,83,41,11,114,9,1,0,0,122,62,67,111,
110,99,114,101,116,101,32,105,109,112,108,101,109,101,110,116,
97,116,105,111,110,32,111,102,32,83,111,117,114,99,101,76,
111,97,100,101,114,32,117,115,105,110,103,32,116,104,101,32,
102,105,108,101,32,115,121,115,116,101,109,46,99,2,0,0,
0,0,0,0,0,3,0,0,0,3,0,0,0,67,0,0,
0,115,36,0,0,0,116,0,0,124,1,0,131,1,0,125,
2,0,105,2,0,124,2,0,106,1,0,100,1,0,54,124,
2,0,106,2,0,100,2,0,54,83,41,3,122,33,82,101,
116,117,114,110,32,116,104,101,32,109,101,116,97,100,97,116,
97,32,102,111,114,32,116,104,101,32,112,97,116,104,46,114,
184,0,0,0,114,185,0,0,0,41,3,114,39,0,0,0,
218,8,115,116,95,109,116,105,109,101,90,7,115,116,95,115,
105,122,101,41,3,114,71,0,0,0,114,35,0,0,0,114,
47,1,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,37,1,0,0,96,6,0,0,115,4,0,0,
0,0,2,12,1,122,27,83,111,117,114,99,101,70,105,108,
101,76,111,97,100,101,114,46,112,97,116,104,95,115,116,97,
116,115,99,4,0,0,0,0,0,0,0,5,0,0,0,5,
0,0,0,67,0,0,0,115,34,0,0,0,116,0,0,124,
1,0,131,1,0,125,4,0,124,0,0,106,1,0,124,2,
0,124,3,0,100,1,0,124,4,0,131,2,1,83,41,2,
78,218,5,95,109,111,100,101,41,2,114,146,0,0,0,114,
38,1,0,0,41,5,114,71,0,0,0,114,143,0,0,0,
114,142,0,0,0,114,53,0,0,0,114,42,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,39,
1,0,0,101,6,0,0,115,4,0,0,0,0,2,12,1,
122,32,83,111,117,114,99,101,70,105,108,101,76,111,97,100,
101,114,46,95,99,97,99,104,101,95,98,121,116,101,99,111,
100,101,114,55,1,0,0,105,182,1,0,0,99,3,0,0,
0,1,0,0,0,9,0,0,0,17,0,0,0,67,0,0,
0,115,53,1,0,0,116,0,0,124,1,0,131,1,0,92,
2,0,125,4,0,125,5,0,103,0,0,125,6,0,120,54,
0,124,4,0,114,80,0,116,1,0,124,4,0,131,1,0,
12,114,80,0,116,0,0,124,4,0,131,1,0,92,2,0,
125,4,0,125,7,0,124,6,0,106,2,0,124,7,0,131,
1,0,1,113,27,0,87,120,132,0,116,3,0,124,6,0,
131,1,0,68,93,118,0,125,7,0,116,4,0,124,4,0,
124,7,0,131,2,0,125,4,0,121,17,0,116,5,0,106,
6,0,124,4,0,131,1,0,1,87,113,94,0,4,116,7,
0,107,10,0,114,155,0,1,1,1,119,94,0,89,113,94,
0,4,116,8,0,107,10,0,114,211,0,1,125,8,0,1,
122,25,0,116,9,0,100,1,0,124,4,0,124,8,0,131,
3,0,1,100,2,0,83,87,89,100,2,0,100,2,0,125,
8,0,126,8,0,88,113,94,0,88,113,94,0,87,121,33,
0,116,10,0,124,1,0,124,2,0,124,3,0,131,3,0,
1,116,9,0,100,3,0,124,1,0,131,2,0,1,87,110,
53,0,4,116,8,0,107,10,0,114,48,1,1,125,8,0,
1,122,21,0,116,9,0,100,1,0,124,1,0,124,8,0,
131,3,0,1,87,89,100,2,0,100,2,0,125,8,0,126,
8,0,88,110,1,0,88,100,2,0,83,41,4,122,27,87,
114,105,116,101,32,98,121,116,101,115,32,100,97,116,97,32,
116,111,32,97,32,102,105,108,101,46,122,27,99,111,117,108,
100,32,110,111,116,32,99,114,101,97,116,101,32,123,33,114,
125,58,32,123,33,114,125,78,122,12,99,114,101,97,116,101,
100,32,123,33,114,125,41,11,114,38,0,0,0,114,46,0,
0,0,114,224,0,0,0,114,33,0,0,0,114,28,0,0,
0,114,3,0,0,0,90,5,109,107,100,105,114,218,15,70,
105,108,101,69,120,105,115,116,115,69,114,114,111,114,114,40,
0,0,0,114,153,0,0,0,114,55,0,0,0,41,9,114,
71,0,0,0,114,35,0,0,0,114,53,0,0,0,114,55,
1,0,0,114,234,0,0,0,114,131,0,0,0,114,27,0,
0,0,114,23,0,0,0,114,41,1,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,38,1,0,0,
106,6,0,0,115,38,0,0,0,0,2,18,1,6,2,22,
1,18,1,17,2,19,1,15,1,3,1,17,1,13,2,7,
1,18,3,16,1,27,1,3,1,16,1,17,1,18,2,122,
25,83,111,117,114,99,101,70,105,108,101,76,111,97,100,101,
114,46,115,101,116,95,100,97,116,97,78,41,7,114,57,0,
0,0,114,56,0,0,0,114,58,0,0,0,114,59,0,0,
0,114,37,1,0,0,114,39,1,0,0,114,38,1,0,0,
114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,9,1,0,0,92,6,0,0,115,8,0,
0,0,12,2,6,2,12,5,12,5,114,9,1,0,0,99,
0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,
64,0,0,0,115,46,0,0,0,101,0,0,90,1,0,100,
0,0,90,2,0,100,1,0,90,3,0,100,2,0,100,3,
0,132,0,0,90,4,0,100,4,0,100,5,0,132,0,0,
90,5,0,100,6,0,83,41,7,114,8,1,0,0,122,45,
76,111,97,100,101,114,32,119,104,105,99,104,32,104,97,110,
100,108,101,115,32,115,111,117,114,99,101,108,101,115,115,32,
102,105,108,101,32,105,109,112,111,114,116,115,46,99,2,0,
0,0,0,0,0,0,5,0,0,0,6,0,0,0,67,0,
0,0,115,76,0,0,0,124,0,0,106,0,0,124,1,0,
131,1,0,125,2,0,124,0,0,106,1,0,124,2,0,131,
1,0,125,3,0,116,2,0,124,3,0,100,1,0,124,1,
0,100,2,0,124,2,0,131,1,2,125,4,0,116,3,0,
124,4,0,100,1,0,124,1,0,100,3,0,124,2,0,131,
1,2,83,41,4,78,114,67,0,0,0,114,35,0,0,0,
114,142,0,0,0,41,4,114,239,0,0,0,114,40,1,0,
0,114,191,0,0,0,114,196,0,0,0,41,5,114,71,0,
0,0,114,159,0,0,0,114,35,0,0,0,114,53,0,0,
0,114,48,1,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,16,1,0,0,139,6,0,0,115,8,
0,0,0,0,1,15,1,15,1,24,1,122,29,83,111,117,
114,99,101,108,101,115,115,70,105,108,101,76,111,97,100,101,
114,46,103,101,116,95,99,111,100,101,99,2,0,0,0,0,
0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,115,
4,0,0,0,100,1,0,83,41,2,122,39,82,101,116,117,
114,110,32,78,111,110,101,32,97,115,32,116,104,101,114,101,
32,105,115,32,110,111,32,115,111,117,114,99,101,32,99,111,
100,101,46,78,114,4,0,0,0,41,2,114,71,0,0,0,
114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,17,1,0,0,145,6,0,0,115,2,0,
0,0,0,2,122,31,83,111,117,114,99,101,108,101,115,115,
70,105,108,101,76,111,97,100,101,114,46,103,101,116,95,115,
111,117,114,99,101,78,41,6,114,57,0,0,0,114,56,0,
0,0,114,58,0,0,0,114,59,0,0,0,114,16,1,0,
0,114,17,1,0,0,114,4,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,8,1,0,0,135,
6,0,0,115,6,0,0,0,12,2,6,2,12,6,114,8,
1,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,
3,0,0,0,64,0,0,0,115,130,0,0,0,101,0,0,
90,1,0,100,0,0,90,2,0,100,1,0,90,3,0,100,
2,0,100,3,0,132,0,0,90,4,0,100,4,0,100,5,
0,132,0,0,90,5,0,100,6,0,100,7,0,132,0,0,
90,6,0,101,7,0,100,8,0,100,9,0,132,0,0,131,
1,0,90,8,0,100,10,0,100,11,0,132,0,0,90,9,
0,100,12,0,100,13,0,132,0,0,90,10,0,100,14,0,
100,15,0,132,0,0,90,11,0,101,7,0,100,16,0,100,
17,0,132,0,0,131,1,0,90,12,0,100,18,0,83,41,
19,218,19,69,120,116,101,110,115,105,111,110,70,105,108,101,
76,111,97,100,101,114,122,93,76,111,97,100,101,114,32,102,
111,114,32,101,120,116,101,110,115,105,111,110,32,109,111,100,
117,108,101,115,46,10,10,32,32,32,32,84,104,101,32,99,
111,110,115,116,114,117,99,116,111,114,32,105,115,32,100,101,
115,105,103,110,101,100,32,116,111,32,119,111,114,107,32,119,
105,116,104,32,70,105,108,101,70,105,110,100,101,114,46,10,
10,32,32,32,32,99,3,0,0,0,0,0,0,0,3,0,
0,0,2,0,0,0,67,0,0,0,115,22,0,0,0,124,
1,0,124,0,0,95,0,0,124,2,0,124,0,0,95,1,
0,100,0,0,83,41,1,78,41,2,114,67,0,0,0,114,
35,0,0,0,41,3,114,71,0,0,0,114,67,0,0,0,
114,35,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,72,0,0,0,162,6,0,0,115,4,0,
0,0,0,1,9,1,122,28,69,120,116,101,110,115,105,111,
110,70,105,108,101,76,111,97,100,101,114,46,95,95,105,110,
105,116,95,95,99,2,0,0,0,0,0,0,0,2,0,0,
0,2,0,0,0,67,0,0,0,115,34,0,0,0,124,0,
0,106,0,0,124,1,0,106,0,0,107,2,0,111,33,0,
124,0,0,106,1,0,124,1,0,106,1,0,107,2,0,83,
41,1,78,41,2,114,225,0,0,0,114,63,0,0,0,41,
2,114,71,0,0,0,114,228,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,230,0,0,0,166,
6,0,0,115,4,0,0,0,0,1,18,1,122,26,69,120,
116,101,110,115,105,111,110,70,105,108,101,76,111,97,100,101,
114,46,95,95,101,113,95,95,99,1,0,0,0,0,0,0,
0,1,0,0,0,3,0,0,0,67,0,0,0,115,26,0,
0,0,116,0,0,124,0,0,106,1,0,131,1,0,116,0,
0,124,0,0,106,2,0,131,1,0,65,83,41,1,78,41,
3,114,50,1,0,0,114,67,0,0,0,114,35,0,0,0,
41,1,114,71,0,0,0,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,114,51,1,0,0,170,6,0,0,115,
2,0,0,0,0,1,122,28,69,120,116,101,110,115,105,111,
110,70,105,108,101,76,111,97,100,101,114,46,95,95,104,97,
115,104,95,95,99,2,0,0,0,0,0,0,0,4,0,0,
0,11,0,0,0,67,0,0,0,115,183,0,0,0,116,0,
0,124,1,0,131,1,0,143,29,0,1,116,1,0,116,2,
0,106,3,0,124,1,0,124,0,0,106,4,0,131,3,0,
125,2,0,87,100,1,0,81,88,116,5,0,100,2,0,124,
0,0,106,4,0,131,2,0,1,124,0,0,106,6,0,124,
1,0,131,1,0,125,3,0,124,3,0,114,124,0,116,7,
0,124,2,0,100,3,0,131,2,0,12,114,124,0,116,8,
0,124,0,0,106,4,0,131,1,0,100,4,0,25,103,1,
0,124,2,0,95,9,0,110,0,0,124,0,0,124,2,0,
95,10,0,124,2,0,106,11,0,124,2,0,95,12,0,124,
3,0,115,179,0,124,2,0,106,12,0,106,13,0,100,5,
0,131,1,0,100,4,0,25,124,2,0,95,12,0,110,0,
0,124,2,0,83,41,6,122,25,76,111,97,100,32,97,110,
32,101,120,116,101,110,115,105,111,110,32,109,111,100,117,108,
101,46,78,122,33,101,120,116,101,110,115,105,111,110,32,109,
111,100,117,108,101,32,108,111,97,100,101,100,32,102,114,111,
109,32,123,33,114,125,114,247,0,0,0,114,84,0,0,0,
114,116,0,0,0,41,14,114,69,0,0,0,114,114,0,0,
0,114,106,0,0,0,90,12,108,111,97,100,95,100,121,110,
97,109,105,99,114,35,0,0,0,114,153,0,0,0,114,220,
0,0,0,114,60,0,0,0,114,38,0,0,0,114,247,0,
0,0,114,205,0,0,0,114,57,0,0,0,114,251,0,0,
0,114,32,0,0,0,41,4,114,71,0,0,0,114,159,0,
0,0,114,180,0,0,0,114,220,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,5,1,0,0,
173,6,0,0,115,24,0,0,0,0,5,13,1,9,1,21,
1,16,1,15,1,22,1,28,1,9,1,12,1,6,1,28,
1,122,31,69,120,116,101,110,115,105,111,110,70,105,108,101,
76,111,97,100,101,114,46,108,111,97,100,95,109,111,100,117,
108,101,99,2,0,0,0,0,0,0,0,2,0,0,0,4,
0,0,0,3,0,0,0,115,48,0,0,0,116,0,0,124,
0,0,106,1,0,131,1,0,100,1,0,25,137,0,0,116,
2,0,135,0,0,102,1,0,100,2,0,100,3,0,134,0,
0,116,3,0,68,131,1,0,131,1,0,83,41,4,122,49,
82,101,116,117,114,110,32,84,114,117,101,32,105,102,32,116,
104,101,32,101,120,116,101,110,115,105,111,110,32,109,111,100,
117,108,101,32,105,115,32,97,32,112,97,99,107,97,103,101,
46,114,29,0,0,0,99,1,0,0,0,0,0,0,0,2,
0,0,0,4,0,0,0,51,0,0,0,115,31,0,0,0,
124,0,0,93,21,0,125,1,0,136,0,0,100,0,0,124,
1,0,23,107,2,0,86,1,113,3,0,100,1,0,83,41,
2,114,72,0,0,0,78,114,4,0,0,0,41,2,114,22,
0,0,0,218,6,115,117,102,102,105,120,41,1,218,9,102,
105,108,101,95,110,97,109,101,114,4,0,0,0,114,5,0,
0,0,114,77,0,0,0,194,6,0,0,115,2,0,0,0,
6,1,122,49,69,120,116,101,110,115,105,111,110,70,105,108,
101,76,111,97,100,101,114,46,105,115,95,112,97,99,107,97,
103,101,46,60,108,111,99,97,108,115,62,46,60,103,101,110,
101,120,112,114,62,41,4,114,38,0,0,0,114,35,0,0,
0,114,78,0,0,0,218,18,69,88,84,69,78,83,73,79,
78,95,83,85,70,70,73,88,69,83,41,2,114,71,0,0,
0,114,159,0,0,0,114,4,0,0,0,41,1,114,59,1,
0,0,114,5,0,0,0,114,220,0,0,0,191,6,0,0,
115,6,0,0,0,0,2,19,1,18,1,122,30,69,120,116,
101,110,115,105,111,110,70,105,108,101,76,111,97,100,101,114,
46,105,115,95,112,97,99,107,97,103,101,99,2,0,0,0,
0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,
115,4,0,0,0,100,1,0,83,41,2,122,63,82,101,116,
117,114,110,32,78,111,110,101,32,97,115,32,97,110,32,101,
120,116,101,110,115,105,111,110,32,109,111,100,117,108,101,32,
99,97,110,110,111,116,32,99,114,101,97,116,101,32,97,32,
99,111,100,101,32,111,98,106,101,99,116,46,78,114,4,0,
0,0,41,2,114,71,0,0,0,114,159,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,16,1,
0,0,197,6,0,0,115,2,0,0,0,0,2,122,28,69,
120,116,101,110,115,105,111,110,70,105,108,101,76,111,97,100,
101,114,46,103,101,116,95,99,111,100,101,99,2,0,0,0,
0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,
115,4,0,0,0,100,1,0,83,41,2,122,53,82,101,116,
117,114,110,32,78,111,110,101,32,97,115,32,101,120,116,101,
110,115,105,111,110,32,109,111,100,117,108,101,115,32,104,97,
118,101,32,110,111,32,115,111,117,114,99,101,32,99,111,100,
101,46,78,114,4,0,0,0,41,2,114,71,0,0,0,114,
159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,17,1,0,0,201,6,0,0,115,2,0,0,
0,0,2,122,30,69,120,116,101,110,115,105,111,110,70,105,
108,101,76,111,97,100,101,114,46,103,101,116,95,115,111,117,
114,99,101,99,2,0,0,0,0,0,0,0,2,0,0,0,
1,0,0,0,67,0,0,0,115,7,0,0,0,124,0,0,
106,0,0,83,41,1,122,58,82,101,116,117,114,110,32,116,
104,101,32,112,97,116,104,32,116,111,32,116,104,101,32,115,
111,117,114,99,101,32,102,105,108,101,32,97,115,32,102,111,
117,110,100,32,98,121,32,116,104,101,32,102,105,110,100,101,
114,46,41,1,114,35,0,0,0,41,2,114,71,0,0,0,
114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,239,0,0,0,205,6,0,0,115,2,0,
0,0,0,3,122,32,69,120,116,101,110,115,105,111,110,70,
105,108,101,76,111,97,100,101,114,46,103,101,116,95,102,105,
108,101,110,97,109,101,78,41,13,114,57,0,0,0,114,56,
0,0,0,114,58,0,0,0,114,59,0,0,0,114,72,0,
0,0,114,230,0,0,0,114,51,1,0,0,114,157,0,0,
0,114,5,1,0,0,114,220,0,0,0,114,16,1,0,0,
114,17,1,0,0,114,239,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,57,
1,0,0,154,6,0,0,115,18,0,0,0,12,6,6,2,
12,4,12,4,12,3,18,18,12,6,12,4,12,4,114,57,
1,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,
2,0,0,0,64,0,0,0,115,130,0,0,0,101,0,0,
90,1,0,100,0,0,90,2,0,100,1,0,90,3,0,100,
2,0,100,3,0,132,0,0,90,4,0,100,4,0,100,5,
0,132,0,0,90,5,0,100,6,0,100,7,0,132,0,0,
90,6,0,100,8,0,100,9,0,132,0,0,90,7,0,100,
10,0,100,11,0,132,0,0,90,8,0,100,12,0,100,13,
0,132,0,0,90,9,0,100,14,0,100,15,0,132,0,0,
90,10,0,100,16,0,100,17,0,132,0,0,90,11,0,100,
18,0,100,19,0,132,0,0,90,12,0,100,20,0,83,41,
21,218,14,95,78,97,109,101,115,112,97,99,101,80,97,116,
104,97,38,1,0,0,82,101,112,114,101,115,101,110,116,115,
32,97,32,110,97,109,101,115,112,97,99,101,32,112,97,99,
107,97,103,101,39,115,32,112,97,116,104,46,32,32,73,116,
32,117,115,101,115,32,116,104,101,32,109,111,100,117,108,101,
32,110,97,109,101,10,32,32,32,32,116,111,32,102,105,110,
100,32,105,116,115,32,112,97,114,101,110,116,32,109,111,100,
117,108,101,44,32,97,110,100,32,102,114,111,109,32,116,104,
101,114,101,32,105,116,32,108,111,111,107,115,32,117,112,32,
116,104,101,32,112,97,114,101,110,116,39,115,10,32,32,32,
32,95,95,112,97,116,104,95,95,46,32,32,87,104,101,110,
32,116,104,105,115,32,99,104,97,110,103,101,115,44,32,116,
104,101,32,109,111,100,117,108,101,39,115,32,111,119,110,32,
112,97,116,104,32,105,115,32,114,101,99,111,109,112,117,116,
101,100,44,10,32,32,32,32,117,115,105,110,103,32,112,97,
116,104,95,102,105,110,100,101,114,46,32,32,70,111,114,32,
116,111,112,45,108,101,118,101,108,32,109,111,100,117,108,101,
115,44,32,116,104,101,32,112,97,114,101,110,116,32,109,111,
100,117,108,101,39,115,32,112,97,116,104,10,32,32,32,32,
105,115,32,115,121,115,46,112,97,116,104,46,99,4,0,0,
0,0,0,0,0,4,0,0,0,2,0,0,0,67,0,0,
0,115,52,0,0,0,124,1,0,124,0,0,95,0,0,124,
2,0,124,0,0,95,1,0,116,2,0,124,0,0,106,3,
0,131,0,0,131,1,0,124,0,0,95,4,0,124,3,0,
124,0,0,95,5,0,100,0,0,83,41,1,78,41,6,114,
70,0,0,0,114,254,0,0,0,114,232,0,0,0,218,16,
95,103,101,116,95,112,97,114,101,110,116,95,112,97,116,104,
218,17,95,108,97,115,116,95,112,97,114,101,110,116,95,112,
97,116,104,218,12,95,112,97,116,104,95,102,105,110,100,101,
114,41,4,114,71,0,0,0,114,67,0,0,0,114,35,0,
0,0,218,11,112,97,116,104,95,102,105,110,100,101,114,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,72,
0,0,0,218,6,0,0,115,8,0,0,0,0,1,9,1,
9,1,21,1,122,23,95,78,97,109,101,115,112,97,99,101,
80,97,116,104,46,95,95,105,110,105,116,95,95,99,1,0,
0,0,0,0,0,0,4,0,0,0,3,0,0,0,67,0,
0,0,115,53,0,0,0,124,0,0,106,0,0,106,1,0,
100,1,0,131,1,0,92,3,0,125,1,0,125,2,0,125,
3,0,124,2,0,100,2,0,107,2,0,114,43,0,100,6,
0,83,124,1,0,100,5,0,102,2,0,83,41,7,122,62,
82,101,116,117,114,110,115,32,97,32,116,117,112,108,101,32,
111,102,32,40,112,97,114,101,110,116,45,109,111,100,117,108,
101,45,110,97,109,101,44,32,112,97,114,101,110,116,45,112,
97,116,104,45,97,116,116,114,45,110,97,109,101,41,114,116,
0,0,0,114,30,0,0,0,114,7,0,0,0,114,35,0,
0,0,114,247,0,0,0,41,2,122,3,115,121,115,122,4,
112,97,116,104,41,2,114,70,0,0,0,114,32,0,0,0,
41,4,114,71,0,0,0,114,234,0,0,0,218,3,100,111,
116,114,94,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,218,23,95,102,105,110,100,95,112,97,114,
101,110,116,95,112,97,116,104,95,110,97,109,101,115,224,6,
0,0,115,8,0,0,0,0,2,27,1,12,2,4,3,122,
38,95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,
95,102,105,110,100,95,112,97,114,101,110,116,95,112,97,116,
104,95,110,97,109,101,115,99,1,0,0,0,0,0,0,0,
3,0,0,0,3,0,0,0,67,0,0,0,115,38,0,0,
0,124,0,0,106,0,0,131,0,0,92,2,0,125,1,0,
125,2,0,116,1,0,116,2,0,106,3,0,124,1,0,25,
124,2,0,131,2,0,83,41,1,78,41,4,114,67,1,0,
0,114,62,0,0,0,114,7,0,0,0,114,73,0,0,0,
41,3,114,71,0,0,0,90,18,112,97,114,101,110,116,95,
109,111,100,117,108,101,95,110,97,109,101,90,14,112,97,116,
104,95,97,116,116,114,95,110,97,109,101,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,62,1,0,0,234,
6,0,0,115,4,0,0,0,0,1,18,1,122,31,95,78,
97,109,101,115,112,97,99,101,80,97,116,104,46,95,103,101,
116,95,112,97,114,101,110,116,95,112,97,116,104,99,1,0,
0,0,0,0,0,0,3,0,0,0,3,0,0,0,67,0,
0,0,115,127,0,0,0,116,0,0,124,0,0,106,1,0,
131,0,0,131,1,0,125,1,0,124,1,0,124,0,0,106,
2,0,107,3,0,114,120,0,124,0,0,106,3,0,124,0,
0,106,4,0,124,1,0,131,2,0,125,2,0,124,2,0,
100,0,0,107,9,0,114,108,0,124,2,0,106,5,0,100,
0,0,107,8,0,114,108,0,124,2,0,106,6,0,114,108,
0,124,2,0,106,6,0,124,0,0,95,7,0,113,108,0,
110,0,0,124,1,0,124,0,0,95,2,0,110,0,0,124,
0,0,106,7,0,83,41,1,78,41,8,114,232,0,0,0,
114,62,1,0,0,114,63,1,0,0,114,64,1,0,0,114,
70,0,0,0,114,170,0,0,0,114,221,0,0,0,114,254,
0,0,0,41,3,114,71,0,0,0,90,11,112,97,114,101,
110,116,95,112,97,116,104,114,178,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,12,95,114,101,
99,97,108,99,117,108,97,116,101,238,6,0,0,115,16,0,
0,0,0,2,18,1,15,1,21,3,27,1,9,1,18,1,
12,1,122,27,95,78,97,109,101,115,112,97,99,101,80,97,
116,104,46,95,114,101,99,97,108,99,117,108,97,116,101,99,
1,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,
67,0,0,0,115,16,0,0,0,116,0,0,124,0,0,106,
1,0,131,0,0,131,1,0,83,41,1,78,41,2,218,4,
105,116,101,114,114,68,1,0,0,41,1,114,71,0,0,0,
114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,
8,95,95,105,116,101,114,95,95,251,6,0,0,115,2,0,
0,0,0,1,122,23,95,78,97,109,101,115,112,97,99,101,
80,97,116,104,46,95,95,105,116,101,114,95,95,99,1,0,
0,0,0,0,0,0,1,0,0,0,2,0,0,0,67,0,
0,0,115,16,0,0,0,116,0,0,124,0,0,106,1,0,
131,0,0,131,1,0,83,41,1,78,41,2,114,31,0,0,
0,114,68,1,0,0,41,1,114,71,0,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,218,7,95,95,
108,101,110,95,95,254,6,0,0,115,2,0,0,0,0,1,
122,22,95,78,97,109,101,115,112,97,99,101,80,97,116,104,
46,95,95,108,101,110,95,95,99,1,0,0,0,0,0,0,
0,1,0,0,0,2,0,0,0,67,0,0,0,115,16,0,
0,0,100,1,0,106,0,0,124,0,0,106,1,0,131,1,
0,83,41,2,78,122,20,95,78,97,109,101,115,112,97,99,
101,80,97,116,104,40,123,33,114,125,41,41,2,114,47,0,
0,0,114,254,0,0,0,41,1,114,71,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,101,0,
0,0,1,7,0,0,115,2,0,0,0,0,1,122,23,95,
78,97,109,101,115,112,97,99,101,80,97,116,104,46,95,95,
114,101,112,114,95,95,99,2,0,0,0,0,0,0,0,2,
0,0,0,2,0,0,0,67,0,0,0,115,16,0,0,0,
124,1,0,124,0,0,106,0,0,131,0,0,107,6,0,83,
41,1,78,41,1,114,68,1,0,0,41,2,114,71,0,0,
0,218,4,105,116,101,109,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,218,12,95,95,99,111,110,116,97,105,
110,115,95,95,4,7,0,0,115,2,0,0,0,0,1,122,
27,95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,
95,95,99,111,110,116,97,105,110,115,95,95,99,2,0,0,
0,0,0,0,0,2,0,0,0,2,0,0,0,67,0,0,
0,115,20,0,0,0,124,0,0,106,0,0,106,1,0,124,
1,0,131,1,0,1,100,0,0,83,41,1,78,41,2,114,
254,0,0,0,114,224,0,0,0,41,2,114,71,0,0,0,
114,72,1,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,224,0,0,0,7,7,0,0,115,2,0,
0,0,0,1,122,21,95,78,97,109,101,115,112,97,99,101,
80,97,116,104,46,97,112,112,101,110,100,78,41,13,114,57,
0,0,0,114,56,0,0,0,114,58,0,0,0,114,59,0,
0,0,114,72,0,0,0,114,67,1,0,0,114,62,1,0,
0,114,68,1,0,0,114,70,1,0,0,114,71,1,0,0,
114,101,0,0,0,114,73,1,0,0,114,224,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,61,1,0,0,211,6,0,0,115,20,0,0,
0,12,5,6,2,12,6,12,10,12,4,12,13,12,3,12,
3,12,3,12,3,114,61,1,0,0,99,0,0,0,0,0,
0,0,0,0,0,0,0,3,0,0,0,64,0,0,0,115,
106,0,0,0,101,0,0,90,1,0,100,0,0,90,2,0,
100,1,0,100,2,0,132,0,0,90,3,0,101,4,0,100,
3,0,100,4,0,132,0,0,131,1,0,90,5,0,100,5,
0,100,6,0,132,0,0,90,6,0,100,7,0,100,8,0,
132,0,0,90,7,0,100,9,0,100,10,0,132,0,0,90,
8,0,100,11,0,100,12,0,132,0,0,90,9,0,100,13,
0,100,14,0,132,0,0,90,10,0,100,15,0,83,41,16,
114,252,0,0,0,99,4,0,0,0,0,0,0,0,4,0,
0,0,4,0,0,0,67,0,0,0,115,25,0,0,0,116,
0,0,124,1,0,124,2,0,124,3,0,131,3,0,124,0,
0,95,1,0,100,0,0,83,41,1,78,41,2,114,61,1,
0,0,114,254,0,0,0,41,4,114,71,0,0,0,114,67,
0,0,0,114,35,0,0,0,114,65,1,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,114,72,0,0,
0,13,7,0,0,115,2,0,0,0,0,1,122,25,95,78,
97,109,101,115,112,97,99,101,76,111,97,100,101,114,46,95,
95,105,110,105,116,95,95,99,2,0,0,0,0,0,0,0,
2,0,0,0,2,0,0,0,67,0,0,0,115,16,0,0,
0,100,1,0,106,0,0,124,1,0,106,1,0,131,1,0,
83,41,2,122,115,82,101,116,117,114,110,32,114,101,112,114,
32,102,111,114,32,116,104,101,32,109,111,100,117,108,101,46,
10,10,32,32,32,32,32,32,32,32,84,104,101,32,109,101,
116,104,111,100,32,105,115,32,100,101,112,114,101,99,97,116,
101,100,46,32,32,84,104,101,32,105,109,112,111,114,116,32,
109,97,99,104,105,110,101,114,121,32,100,111,101,115,32,116,
104,101,32,106,111,98,32,105,116,115,101,108,102,46,10,10,
32,32,32,32,32,32,32,32,122,25,60,109,111,100,117,108,
101,32,123,33,114,125,32,40,110,97,109,101,115,112,97,99,
101,41,62,41,2,114,47,0,0,0,114,57,0,0,0,41,
2,114,12,1,0,0,114,180,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,206,0,0,0,16,
7,0,0,115,2,0,0,0,0,7,122,28,95,78,97,109,
101,115,112,97,99,101,76,111,97,100,101,114,46,109,111,100,
117,108,101,95,114,101,112,114,99,2,0,0,0,0,0,0,
0,2,0,0,0,1,0,0,0,67,0,0,0,115,4,0,
0,0,100,1,0,83,41,2,78,84,114,4,0,0,0,41,
2,114,71,0,0,0,114,159,0,0,0,114,4,0,0,0,
114,4,0,0,0,114,5,0,0,0,114,220,0,0,0,25,
7,0,0,115,2,0,0,0,0,1,122,27,95,78,97,109,
101,115,112,97,99,101,76,111,97,100,101,114,46,105,115,95,
112,97,99,107,97,103,101,99,2,0,0,0,0,0,0,0,
2,0,0,0,1,0,0,0,67,0,0,0,115,4,0,0,
0,100,1,0,83,41,2,78,114,30,0,0,0,114,4,0,
0,0,41,2,114,71,0,0,0,114,159,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,17,1,
0,0,28,7,0,0,115,2,0,0,0,0,1,122,27,95,
78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,46,
103,101,116,95,115,111,117,114,99,101,99,2,0,0,0,0,
0,0,0,2,0,0,0,6,0,0,0,67,0,0,0,115,
22,0,0,0,116,0,0,100,1,0,100,2,0,100,3,0,
100,4,0,100,5,0,131,3,1,83,41,6,78,114,30,0,
0,0,122,8,60,115,116,114,105,110,103,62,114,176,0,0,
0,114,43,1,0,0,84,41,1,114,44,1,0,0,41,2,
114,71,0,0,0,114,159,0,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,114,16,1,0,0,31,7,
0,0,115,2,0,0,0,0,1,122,25,95,78,97,109,101,
115,112,97,99,101,76,111,97,100,101,114,46,103,101,116,95,
99,111,100,101,99,2,0,0,0,0,0,0,0,2,0,0,
0,1,0,0,0,67,0,0,0,115,4,0,0,0,100,0,
0,83,41,1,78,114,4,0,0,0,41,2,114,71,0,0,
0,114,180,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,2,1,0,0,34,7,0,0,115,2,
0,0,0,0,1,122,28,95,78,97,109,101,115,112,97,99,
101,76,111,97,100,101,114,46,101,120,101,99,95,109,111,100,
117,108,101,99,2,0,0,0,0,0,0,0,2,0,0,0,
3,0,0,0,67,0,0,0,115,29,0,0,0,116,0,0,
100,1,0,124,0,0,106,1,0,131,2,0,1,116,2,0,
124,0,0,124,1,0,131,2,0,83,41,2,122,98,76,111,
97,100,32,97,32,110,97,109,101,115,112,97,99,101,32,109,
111,100,117,108,101,46,10,10,32,32,32,32,32,32,32,32,
84,104,105,115,32,109,101,116,104,111,100,32,105,115,32,100,
101,112,114,101,99,97,116,101,100,46,32,32,85,115,101,32,
101,120,101,99,95,109,111,100,117,108,101,40,41,32,105,110,
115,116,101,97,100,46,10,10,32,32,32,32,32,32,32,32,
122,38,110,97,109,101,115,112,97,99,101,32,109,111,100,117,
108,101,32,108,111,97,100,101,100,32,119,105,116,104,32,112,
97,116,104,32,123,33,114,125,41,3,114,153,0,0,0,114,
254,0,0,0,114,181,0,0,0,41,2,114,71,0,0,0,
114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
5,0,0,0,114,5,1,0,0,37,7,0,0,115,4,0,
0,0,0,7,16,1,122,28,95,78,97,109,101,115,112,97,
99,101,76,111,97,100,101,114,46,108,111,97,100,95,109,111,
100,117,108,101,78,41,11,114,57,0,0,0,114,56,0,0,
0,114,58,0,0,0,114,72,0,0,0,114,19,1,0,0,
114,206,0,0,0,114,220,0,0,0,114,17,1,0,0,114,
16,1,0,0,114,2,1,0,0,114,5,1,0,0,114,4,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,252,0,0,0,12,7,0,0,115,14,0,0,0,
12,1,12,3,18,9,12,3,12,3,12,3,12,3,114,252,
0,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,
5,0,0,0,64,0,0,0,115,160,0,0,0,101,0,0,
90,1,0,100,0,0,90,2,0,100,1,0,90,3,0,101,
4,0,100,2,0,100,3,0,132,0,0,131,1,0,90,5,
0,101,4,0,100,4,0,100,5,0,132,0,0,131,1,0,
90,6,0,101,4,0,100,6,0,100,7,0,132,0,0,131,
1,0,90,7,0,101,4,0,100,8,0,100,9,0,132,0,
0,131,1,0,90,8,0,101,4,0,100,10,0,100,11,0,
100,12,0,132,1,0,131,1,0,90,9,0,101,4,0,100,
10,0,100,10,0,100,13,0,100,14,0,132,2,0,131,1,
0,90,10,0,101,4,0,100,10,0,100,15,0,100,16,0,
132,1,0,131,1,0,90,11,0,100,10,0,83,41,17,218,
10,80,97,116,104,70,105,110,100,101,114,122,62,77,101,116,
97,32,112,97,116,104,32,102,105,110,100,101,114,32,102,111,
114,32,115,121,115,46,112,97,116,104,32,97,110,100,32,112,
97,99,107,97,103,101,32,95,95,112,97,116,104,95,95,32,
97,116,116,114,105,98,117,116,101,115,46,99,1,0,0,0,
0,0,0,0,2,0,0,0,4,0,0,0,67,0,0,0,
115,58,0,0,0,120,51,0,116,0,0,106,1,0,106,2,
0,131,0,0,68,93,34,0,125,1,0,116,3,0,124,1,
0,100,1,0,131,2,0,114,16,0,124,1,0,106,4,0,
131,0,0,1,113,16,0,113,16,0,87,100,2,0,83,41,
3,122,125,67,97,108,108,32,116,104,101,32,105,110,118,97,
108,105,100,97,116,101,95,99,97,99,104,101,115,40,41,32,
109,101,116,104,111,100,32,111,110,32,97,108,108,32,112,97,
116,104,32,101,110,116,114,121,32,102,105,110,100,101,114,115,
10,32,32,32,32,32,32,32,32,115,116,111,114,101,100,32,
105,110,32,115,121,115,46,112,97,116,104,95,105,109,112,111,
114,116,101,114,95,99,97,99,104,101,115,32,40,119,104,101,
114,101,32,105,109,112,108,101,109,101,110,116,101,100,41,46,
218,17,105,110,118,97,108,105,100,97,116,101,95,99,97,99,
104,101,115,78,41,5,114,7,0,0,0,218,19,112,97,116,
104,95,105,109,112,111,114,116,101,114,95,99,97,99,104,101,
218,6,118,97,108,117,101,115,114,60,0,0,0,114,75,1,
0,0,41,2,114,12,1,0,0,218,6,102,105,110,100,101,
114,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,75,1,0,0,54,7,0,0,115,6,0,0,0,0,4,
22,1,15,1,122,28,80,97,116,104,70,105,110,100,101,114,
46,105,110,118,97,108,105,100,97,116,101,95,99,97,99,104,
101,115,99,2,0,0,0,0,0,0,0,3,0,0,0,12,
0,0,0,67,0,0,0,115,94,0,0,0,116,0,0,106,
1,0,115,28,0,116,2,0,106,3,0,100,1,0,116,4,
0,131,2,0,1,110,0,0,120,59,0,116,0,0,106,1,
0,68,93,44,0,125,2,0,121,14,0,124,2,0,124,1,
0,131,1,0,83,87,113,38,0,4,116,5,0,107,10,0,
114,81,0,1,1,1,119,38,0,89,113,38,0,88,113,38,
0,87,100,2,0,83,100,2,0,83,41,3,122,113,83,101,
97,114,99,104,32,115,101,113,117,101,110,99,101,32,111,102,
32,104,111,111,107,115,32,102,111,114,32,97,32,102,105,110,
100,101,114,32,102,111,114,32,39,112,97,116,104,39,46,10,
10,32,32,32,32,32,32,32,32,73,102,32,39,104,111,111,
107,115,39,32,105,115,32,102,97,108,115,101,32,116,104,101,
110,32,117,115,101,32,115,121,115,46,112,97,116,104,95,104,
111,111,107,115,46,10,10,32,32,32,32,32,32,32,32,122,
23,115,121,115,46,112,97,116,104,95,104,111,111,107,115,32,
105,115,32,101,109,112,116,121,78,41,6,114,7,0,0,0,
218,10,112,97,116,104,95,104,111,111,107,115,114,167,0,0,
0,114,168,0,0,0,114,169,0,0,0,114,154,0,0,0,
41,3,114,12,1,0,0,114,35,0,0,0,90,4,104,111,
111,107,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,218,11,95,112,97,116,104,95,104,111,111,107,115,62,7,
0,0,115,16,0,0,0,0,7,9,1,19,1,16,1,3,
1,14,1,13,1,12,2,122,22,80,97,116,104,70,105,110,
100,101,114,46,95,112,97,116,104,95,104,111,111,107,115,99,
2,0,0,0,0,0,0,0,3,0,0,0,11,0,0,0,
67,0,0,0,115,97,0,0,0,124,1,0,100,1,0,107,
2,0,114,27,0,116,0,0,106,1,0,131,0,0,125,1,
0,110,0,0,121,17,0,116,2,0,106,3,0,124,1,0,
25,125,2,0,87,110,46,0,4,116,4,0,107,10,0,114,
92,0,1,1,1,124,0,0,106,5,0,124,1,0,131,1,
0,125,2,0,124,2,0,116,2,0,106,3,0,124,1,0,
60,89,110,1,0,88,124,2,0,83,41,2,122,210,71,101,
116,32,116,104,101,32,102,105,110,100,101,114,32,102,111,114,
32,116,104,101,32,112,97,116,104,32,101,110,116,114,121,32,
102,114,111,109,32,115,121,115,46,112,97,116,104,95,105,109,
112,111,114,116,101,114,95,99,97,99,104,101,46,10,10,32,
32,32,32,32,32,32,32,73,102,32,116,104,101,32,112,97,
116,104,32,101,110,116,114,121,32,105,115,32,110,111,116,32,
105,110,32,116,104,101,32,99,97,99,104,101,44,32,102,105,
110,100,32,116,104,101,32,97,112,112,114,111,112,114,105,97,
116,101,32,102,105,110,100,101,114,10,32,32,32,32,32,32,
32,32,97,110,100,32,99,97,99,104,101,32,105,116,46,32,
73,102,32,110,111,32,102,105,110,100,101,114,32,105,115,32,
97,118,97,105,108,97,98,108,101,44,32,115,116,111,114,101,
32,78,111,110,101,46,10,10,32,32,32,32,32,32,32,32,
114,30,0,0,0,41,6,114,3,0,0,0,114,45,0,0,
0,114,7,0,0,0,114,76,1,0,0,114,79,0,0,0,
114,80,1,0,0,41,3,114,12,1,0,0,114,35,0,0,
0,114,78,1,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,218,20,95,112,97,116,104,95,105,109,112,
111,114,116,101,114,95,99,97,99,104,101,79,7,0,0,115,
16,0,0,0,0,8,12,1,15,1,3,1,17,1,13,1,
15,1,18,1,122,31,80,97,116,104,70,105,110,100,101,114,
46,95,112,97,116,104,95,105,109,112,111,114,116,101,114,95,
99,97,99,104,101,99,3,0,0,0,0,0,0,0,6,0,
0,0,3,0,0,0,67,0,0,0,115,113,0,0,0,116,
0,0,124,2,0,100,1,0,131,2,0,114,39,0,124,2,
0,106,1,0,124,1,0,131,1,0,92,2,0,125,3,0,
125,4,0,110,21,0,124,2,0,106,2,0,124,1,0,131,
1,0,125,3,0,103,0,0,125,4,0,124,3,0,100,0,
0,107,9,0,114,85,0,116,3,0,124,1,0,124,3,0,
131,2,0,83,116,4,0,124,1,0,100,0,0,131,2,0,
125,5,0,124,4,0,124,5,0,95,5,0,124,5,0,83,
41,2,78,114,166,0,0,0,41,6,114,60,0,0,0,114,
166,0,0,0,114,15,1,0,0,114,174,0,0,0,114,217,
0,0,0,114,221,0,0,0,41,6,114,12,1,0,0,114,
159,0,0,0,114,78,1,0,0,114,170,0,0,0,114,171,
0,0,0,114,178,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,16,95,108,101,103,97,99,121,
95,103,101,116,95,115,112,101,99,96,7,0,0,115,18,0,
0,0,0,4,15,1,24,2,15,1,6,1,12,1,13,1,
15,1,9,1,122,27,80,97,116,104,70,105,110,100,101,114,
46,95,108,101,103,97,99,121,95,103,101,116,95,115,112,101,
99,78,99,4,0,0,0,0,0,0,0,9,0,0,0,5,
0,0,0,67,0,0,0,115,252,0,0,0,103,0,0,125,
4,0,120,239,0,124,2,0,68,93,203,0,125,5,0,116,
0,0,124,5,0,116,1,0,116,2,0,102,2,0,131,2,
0,115,46,0,113,13,0,110,0,0,124,0,0,106,3,0,
124,5,0,131,1,0,125,6,0,124,6,0,100,1,0,107,
9,0,114,13,0,116,4,0,124,6,0,100,2,0,131,2,
0,114,109,0,124,6,0,106,5,0,124,1,0,124,3,0,
131,2,0,125,7,0,110,18,0,124,0,0,106,6,0,124,
1,0,124,6,0,131,2,0,125,7,0,124,7,0,100,1,
0,107,8,0,114,145,0,113,13,0,110,0,0,124,7,0,
106,7,0,100,1,0,107,9,0,114,164,0,124,7,0,83,
124,7,0,106,8,0,125,8,0,124,8,0,100,1,0,107,
8,0,114,200,0,116,9,0,100,3,0,131,1,0,130,1,
0,110,0,0,124,4,0,106,10,0,124,8,0,131,1,0,
1,113,13,0,113,13,0,87,116,11,0,124,1,0,100,1,
0,131,2,0,125,7,0,124,4,0,124,7,0,95,8,0,
124,7,0,83,100,1,0,83,41,4,122,63,70,105,110,100,
32,116,104,101,32,108,111,97,100,101,114,32,111,114,32,110,
97,109,101,115,112,97,99,101,95,112,97,116,104,32,102,111,
114,32,116,104,105,115,32,109,111,100,117,108,101,47,112,97,
99,107,97,103,101,32,110,97,109,101,46,78,114,14,1,0,
0,122,19,115,112,101,99,32,109,105,115,115,105,110,103,32,
108,111,97,100,101,114,41,12,114,193,0,0,0,218,3,115,
116,114,218,5,98,121,116,101,115,114,81,1,0,0,114,60,
0,0,0,114,14,1,0,0,114,82,1,0,0,114,170,0,
0,0,114,221,0,0,0,114,154,0,0,0,114,198,0,0,
0,114,217,0,0,0,41,9,114,12,1,0,0,114,159,0,
0,0,114,35,0,0,0,114,13,1,0,0,218,14,110,97,
109,101,115,112,97,99,101,95,112,97,116,104,90,5,101,110,
116,114,121,114,78,1,0,0,114,178,0,0,0,114,171,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,218,9,95,103,101,116,95,115,112,101,99,111,7,0,0,
115,40,0,0,0,0,5,6,1,13,1,21,1,6,1,15,
1,12,1,15,1,21,2,18,1,12,1,6,1,15,1,4,
1,9,1,12,1,15,5,20,2,15,1,9,1,122,20,80,
97,116,104,70,105,110,100,101,114,46,95,103,101,116,95,115,
112,101,99,99,4,0,0,0,0,0,0,0,6,0,0,0,
4,0,0,0,67,0,0,0,115,143,0,0,0,124,2,0,
100,1,0,107,8,0,114,24,0,116,0,0,106,1,0,125,
2,0,110,0,0,124,0,0,106,2,0,124,1,0,124,2,
0,124,3,0,131,3,0,125,4,0,124,4,0,100,1,0,
107,8,0,114,61,0,100,1,0,83,124,4,0,106,3,0,
100,1,0,107,8,0,114,135,0,124,4,0,106,4,0,125,
5,0,124,5,0,114,128,0,100,2,0,124,4,0,95,5,
0,116,6,0,124,1,0,124,5,0,124,0,0,106,2,0,
131,3,0,124,4,0,95,4,0,124,4,0,83,100,1,0,
83,110,4,0,124,4,0,83,100,1,0,83,41,3,122,98,
102,105,110,100,32,116,104,101,32,109,111,100,117,108,101,32,
111,110,32,115,121,115,46,112,97,116,104,32,111,114,32,39,
112,97,116,104,39,32,98,97,115,101,100,32,111,110,32,115,
121,115,46,112,97,116,104,95,104,111,111,107,115,32,97,110,
100,10,32,32,32,32,32,32,32,32,115,121,115,46,112,97,
116,104,95,105,109,112,111,114,116,101,114,95,99,97,99,104,
101,46,78,90,9,110,97,109,101,115,112,97,99,101,41,7,
114,7,0,0,0,114,35,0,0,0,114,86,1,0,0,114,
170,0,0,0,114,221,0,0,0,114,218,0,0,0,114,61,
1,0,0,41,6,114,12,1,0,0,114,159,0,0,0,114,
35,0,0,0,114,13,1,0,0,114,178,0,0,0,114,85,
1,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,14,1,0,0,143,7,0,0,115,26,0,0,0,
0,4,12,1,12,1,21,1,12,1,4,1,15,1,9,1,
6,3,9,1,24,1,4,2,7,2,122,20,80,97,116,104,
70,105,110,100,101,114,46,102,105,110,100,95,115,112,101,99,
99,3,0,0,0,0,0,0,0,4,0,0,0,3,0,0,
0,67,0,0,0,115,41,0,0,0,124,0,0,106,0,0,
124,1,0,124,2,0,131,2,0,125,3,0,124,3,0,100,
1,0,107,8,0,114,34,0,100,1,0,83,124,3,0,106,
1,0,83,41,2,122,170,102,105,110,100,32,116,104,101,32,
109,111,100,117,108,101,32,111,110,32,115,121,115,46,112,97,
116,104,32,111,114,32,39,112,97,116,104,39,32,98,97,115,
101,100,32,111,110,32,115,121,115,46,112,97,116,104,95,104,
111,111,107,115,32,97,110,100,10,32,32,32,32,32,32,32,
32,115,121,115,46,112,97,116,104,95,105,109,112,111,114,116,
101,114,95,99,97,99,104,101,46,10,10,32,32,32,32,32,
32,32,32,84,104,105,115,32,109,101,116,104,111,100,32,105,
115,32,100,101,112,114,101,99,97,116,101,100,46,32,32,85,
115,101,32,102,105,110,100,95,115,112,101,99,40,41,32,105,
110,115,116,101,97,100,46,10,10,32,32,32,32,32,32,32,
32,78,41,2,114,14,1,0,0,114,170,0,0,0,41,4,
114,12,1,0,0,114,159,0,0,0,114,35,0,0,0,114,
178,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,15,1,0,0,165,7,0,0,115,8,0,0,
0,0,8,18,1,12,1,4,1,122,22,80,97,116,104,70,
105,110,100,101,114,46,102,105,110,100,95,109,111,100,117,108,
101,41,12,114,57,0,0,0,114,56,0,0,0,114,58,0,
0,0,114,59,0,0,0,114,19,1,0,0,114,75,1,0,
0,114,80,1,0,0,114,81,1,0,0,114,82,1,0,0,
114,86,1,0,0,114,14,1,0,0,114,15,1,0,0,114,
4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,74,1,0,0,50,7,0,0,115,22,0,0,
0,12,2,6,2,18,8,18,17,18,17,18,15,3,1,18,
31,3,1,21,21,3,1,114,74,1,0,0,99,0,0,0,
0,0,0,0,0,0,0,0,0,3,0,0,0,64,0,0,
0,115,133,0,0,0,101,0,0,90,1,0,100,0,0,90,
2,0,100,1,0,90,3,0,100,2,0,100,3,0,132,0,
0,90,4,0,100,4,0,100,5,0,132,0,0,90,5,0,
101,6,0,90,7,0,100,6,0,100,7,0,132,0,0,90,
8,0,100,8,0,100,9,0,132,0,0,90,9,0,100,10,
0,100,11,0,100,12,0,132,1,0,90,10,0,100,13,0,
100,14,0,132,0,0,90,11,0,101,12,0,100,15,0,100,
16,0,132,0,0,131,1,0,90,13,0,100,17,0,100,18,
0,132,0,0,90,14,0,100,10,0,83,41,19,218,10,70,
105,108,101,70,105,110,100,101,114,122,172,70,105,108,101,45,
98,97,115,101,100,32,102,105,110,100,101,114,46,10,10,32,
32,32,32,73,110,116,101,114,97,99,116,105,111,110,115,32,
119,105,116,104,32,116,104,101,32,102,105,108,101,32,115,121,
115,116,101,109,32,97,114,101,32,99,97,99,104,101,100,32,
102,111,114,32,112,101,114,102,111,114,109,97,110,99,101,44,
32,98,101,105,110,103,10,32,32,32,32,114,101,102,114,101,
115,104,101,100,32,119,104,101,110,32,116,104,101,32,100,105,
114,101,99,116,111,114,121,32,116,104,101,32,102,105,110,100,
101,114,32,105,115,32,104,97,110,100,108,105,110,103,32,104,
97,115,32,98,101,101,110,32,109,111,100,105,102,105,101,100,
46,10,10,32,32,32,32,99,2,0,0,0,0,0,0,0,
5,0,0,0,5,0,0,0,7,0,0,0,115,122,0,0,
0,103,0,0,125,3,0,120,52,0,124,2,0,68,93,44,
0,92,2,0,137,0,0,125,4,0,124,3,0,106,0,0,
135,0,0,102,1,0,100,1,0,100,2,0,134,0,0,124,
4,0,68,131,1,0,131,1,0,1,113,13,0,87,124,3,
0,124,0,0,95,1,0,124,1,0,112,79,0,100,3,0,
124,0,0,95,2,0,100,6,0,124,0,0,95,3,0,116,
4,0,131,0,0,124,0,0,95,5,0,116,4,0,131,0,
0,124,0,0,95,6,0,100,5,0,83,41,7,122,154,73,
110,105,116,105,97,108,105,122,101,32,119,105,116,104,32,116,
104,101,32,112,97,116,104,32,116,111,32,115,101,97,114,99,
104,32,111,110,32,97,110,100,32,97,32,118,97,114,105,97,
98,108,101,32,110,117,109,98,101,114,32,111,102,10,32,32,
32,32,32,32,32,32,50,45,116,117,112,108,101,115,32,99,
111,110,116,97,105,110,105,110,103,32,116,104,101,32,108,111,
97,100,101,114,32,97,110,100,32,116,104,101,32,102,105,108,
101,32,115,117,102,102,105,120,101,115,32,116,104,101,32,108,
111,97,100,101,114,10,32,32,32,32,32,32,32,32,114,101,
99,111,103,110,105,122,101,115,46,99,1,0,0,0,0,0,
0,0,2,0,0,0,3,0,0,0,51,0,0,0,115,27,
0,0,0,124,0,0,93,17,0,125,1,0,124,1,0,136,
0,0,102,2,0,86,1,113,3,0,100,0,0,83,41,1,
78,114,4,0,0,0,41,2,114,22,0,0,0,114,58,1,
0,0,41,1,114,170,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,77,0,0,0,194,7,0,0,115,2,0,0,
0,6,0,122,38,70,105,108,101,70,105,110,100,101,114,46,
95,95,105,110,105,116,95,95,46,60,108,111,99,97,108,115,
62,46,60,103,101,110,101,120,112,114,62,114,116,0,0,0,
114,29,0,0,0,78,114,139,0,0,0,41,7,114,198,0,
0,0,218,8,95,108,111,97,100,101,114,115,114,35,0,0,
0,218,11,95,112,97,116,104,95,109,116,105,109,101,218,3,
115,101,116,218,11,95,112,97,116,104,95,99,97,99,104,101,
218,19,95,114,101,108,97,120,101,100,95,112,97,116,104,95,
99,97,99,104,101,41,5,114,71,0,0,0,114,35,0,0,
0,218,14,108,111,97,100,101,114,95,100,101,116,97,105,108,
115,90,7,108,111,97,100,101,114,115,114,126,0,0,0,114,
4,0,0,0,41,1,114,170,0,0,0,114,5,0,0,0,
114,72,0,0,0,188,7,0,0,115,16,0,0,0,0,4,
6,1,19,1,36,1,9,2,15,1,9,1,12,1,122,19,
70,105,108,101,70,105,110,100,101,114,46,95,95,105,110,105,
116,95,95,99,1,0,0,0,0,0,0,0,1,0,0,0,
2,0,0,0,67,0,0,0,115,13,0,0,0,100,3,0,
124,0,0,95,0,0,100,2,0,83,41,4,122,31,73,110,
118,97,108,105,100,97,116,101,32,116,104,101,32,100,105,114,
101,99,116,111,114,121,32,109,116,105,109,101,46,114,29,0,
0,0,78,114,139,0,0,0,41,1,114,89,1,0,0,41,
1,114,71,0,0,0,114,4,0,0,0,114,4,0,0,0,
114,5,0,0,0,114,75,1,0,0,202,7,0,0,115,2,
0,0,0,0,2,122,28,70,105,108,101,70,105,110,100,101,
114,46,105,110,118,97,108,105,100,97,116,101,95,99,97,99,
104,101,115,99,2,0,0,0,0,0,0,0,3,0,0,0,
2,0,0,0,67,0,0,0,115,59,0,0,0,124,0,0,
106,0,0,124,1,0,131,1,0,125,2,0,124,2,0,100,
1,0,107,8,0,114,37,0,100,1,0,103,0,0,102,2,
0,83,124,2,0,106,1,0,124,2,0,106,2,0,112,55,
0,103,0,0,102,2,0,83,41,2,122,197,84,114,121,32,
116,111,32,102,105,110,100,32,97,32,108,111,97,100,101,114,
32,102,111,114,32,116,104,101,32,115,112,101,99,105,102,105,
101,100,32,109,111,100,117,108,101,44,32,111,114,32,116,104,
101,32,110,97,109,101,115,112,97,99,101,10,32,32,32,32,
32,32,32,32,112,97,99,107,97,103,101,32,112,111,114,116,
105,111,110,115,46,32,82,101,116,117,114,110,115,32,40,108,
111,97,100,101,114,44,32,108,105,115,116,45,111,102,45,112,
111,114,116,105,111,110,115,41,46,10,10,32,32,32,32,32,
32,32,32,84,104,105,115,32,109,101,116,104,111,100,32,105,
115,32,100,101,112,114,101,99,97,116,101,100,46,32,32,85,
115,101,32,102,105,110,100,95,115,112,101,99,40,41,32,105,
110,115,116,101,97,100,46,10,10,32,32,32,32,32,32,32,
32,78,41,3,114,14,1,0,0,114,170,0,0,0,114,221,
0,0,0,41,3,114,71,0,0,0,114,159,0,0,0,114,
178,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,166,0,0,0,208,7,0,0,115,8,0,0,
0,0,7,15,1,12,1,10,1,122,22,70,105,108,101,70,
105,110,100,101,114,46,102,105,110,100,95,108,111,97,100,101,
114,99,6,0,0,0,0,0,0,0,7,0,0,0,7,0,
0,0,67,0,0,0,115,40,0,0,0,124,1,0,124,2,
0,124,3,0,131,2,0,125,6,0,116,0,0,124,2,0,
124,3,0,100,1,0,124,6,0,100,2,0,124,4,0,131,
2,2,83,41,3,78,114,170,0,0,0,114,221,0,0,0,
41,1,114,240,0,0,0,41,7,114,71,0,0,0,114,244,
0,0,0,114,159,0,0,0,114,35,0,0,0,114,229,0,
0,0,114,13,1,0,0,114,170,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,86,1,0,0,
220,7,0,0,115,6,0,0,0,0,1,15,1,18,1,122,
20,70,105,108,101,70,105,110,100,101,114,46,95,103,101,116,
95,115,112,101,99,78,99,3,0,0,0,0,0,0,0,14,
0,0,0,15,0,0,0,67,0,0,0,115,240,1,0,0,
100,1,0,125,3,0,124,1,0,106,0,0,100,2,0,131,
1,0,100,3,0,25,125,4,0,121,34,0,116,1,0,124,
0,0,106,2,0,112,49,0,116,3,0,106,4,0,131,0,
0,131,1,0,106,5,0,125,5,0,87,110,24,0,4,116,
6,0,107,10,0,114,85,0,1,1,1,100,10,0,125,5,
0,89,110,1,0,88,124,5,0,124,0,0,106,7,0,107,
3,0,114,123,0,124,0,0,106,8,0,131,0,0,1,124,
5,0,124,0,0,95,7,0,110,0,0,116,9,0,131,0,
0,114,156,0,124,0,0,106,10,0,125,6,0,124,4,0,
106,11,0,131,0,0,125,7,0,110,15,0,124,0,0,106,
12,0,125,6,0,124,4,0,125,7,0,124,7,0,124,6,
0,107,6,0,114,51,1,116,13,0,124,0,0,106,2,0,
124,4,0,131,2,0,125,8,0,120,103,0,124,0,0,106,
14,0,68,93,77,0,92,2,0,125,9,0,125,10,0,100,
5,0,124,9,0,23,125,11,0,116,13,0,124,8,0,124,
11,0,131,2,0,125,12,0,116,15,0,124,12,0,131,1,
0,114,211,0,124,0,0,106,16,0,124,10,0,124,1,0,
124,12,0,124,8,0,103,1,0,124,2,0,131,5,0,83,
113,211,0,87,116,17,0,124,8,0,131,1,0,125,3,0,
110,0,0,120,126,0,124,0,0,106,14,0,68,93,115,0,
92,2,0,125,9,0,125,10,0,116,13,0,124,0,0,106,
2,0,124,4,0,124,9,0,23,131,2,0,125,12,0,116,
18,0,100,6,0,106,19,0,124,12,0,131,1,0,100,7,
0,100,3,0,131,1,1,1,124,7,0,124,9,0,23,124,
6,0,107,6,0,114,61,1,116,15,0,124,12,0,131,1,
0,114,176,1,124,0,0,106,16,0,124,10,0,124,1,0,
124,12,0,100,8,0,124,2,0,131,5,0,83,113,61,1,
113,61,1,87,124,3,0,114,236,1,116,18,0,100,9,0,
106,19,0,124,8,0,131,1,0,131,1,0,1,116,20,0,
124,1,0,100,8,0,131,2,0,125,13,0,124,8,0,103,
1,0,124,13,0,95,21,0,124,13,0,83,100,8,0,83,
41,11,122,125,84,114,121,32,116,111,32,102,105,110,100,32,
97,32,108,111,97,100,101,114,32,102,111,114,32,116,104,101,
32,115,112,101,99,105,102,105,101,100,32,109,111,100,117,108,
101,44,32,111,114,32,116,104,101,32,110,97,109,101,115,112,
97,99,101,10,32,32,32,32,32,32,32,32,112,97,99,107,
97,103,101,32,112,111,114,116,105,111,110,115,46,32,82,101,
116,117,114,110,115,32,40,108,111,97,100,101,114,44,32,108,
105,115,116,45,111,102,45,112,111,114,116,105,111,110,115,41,
46,70,114,116,0,0,0,114,115,0,0,0,114,29,0,0,
0,114,72,0,0,0,122,9,116,114,121,105,110,103,32,123,
125,114,147,0,0,0,78,122,25,112,111,115,115,105,98,108,
101,32,110,97,109,101,115,112,97,99,101,32,102,111,114,32,
123,125,114,139,0,0,0,41,22,114,32,0,0,0,114,39,
0,0,0,114,35,0,0,0,114,3,0,0,0,114,45,0,
0,0,114,54,1,0,0,114,40,0,0,0,114,89,1,0,
0,218,11,95,102,105,108,108,95,99,97,99,104,101,114,6,
0,0,0,114,92,1,0,0,114,141,0,0,0,114,91,1,
0,0,114,28,0,0,0,114,88,1,0,0,114,44,0,0,
0,114,86,1,0,0,114,46,0,0,0,114,153,0,0,0,
114,47,0,0,0,114,217,0,0,0,114,221,0,0,0,41,
14,114,71,0,0,0,114,159,0,0,0,114,13,1,0,0,
90,12,105,115,95,110,97,109,101,115,112,97,99,101,90,11,
116,97,105,108,95,109,111,100,117,108,101,114,184,0,0,0,
90,5,99,97,99,104,101,90,12,99,97,99,104,101,95,109,
111,100,117,108,101,90,9,98,97,115,101,95,112,97,116,104,
114,58,1,0,0,114,244,0,0,0,90,13,105,110,105,116,
95,102,105,108,101,110,97,109,101,90,9,102,117,108,108,95,
112,97,116,104,114,178,0,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,114,14,1,0,0,225,7,0,
0,115,68,0,0,0,0,3,6,1,19,1,3,1,34,1,
13,1,11,1,15,1,10,1,12,2,9,1,9,1,15,2,
9,1,6,2,12,1,18,1,22,1,10,1,15,1,12,1,
32,4,15,2,22,1,22,1,25,1,16,1,12,1,32,1,
6,1,19,1,15,1,12,1,4,1,122,20,70,105,108,101,
70,105,110,100,101,114,46,102,105,110,100,95,115,112,101,99,
99,1,0,0,0,0,0,0,0,9,0,0,0,13,0,0,
0,67,0,0,0,115,14,1,0,0,124,0,0,106,0,0,
125,1,0,121,31,0,116,1,0,106,2,0,124,1,0,112,
33,0,116,1,0,106,3,0,131,0,0,131,1,0,125,2,
0,87,110,33,0,4,116,4,0,116,5,0,116,6,0,102,
3,0,107,10,0,114,75,0,1,1,1,103,0,0,125,2,
0,89,110,1,0,88,116,7,0,106,8,0,106,9,0,100,
1,0,131,1,0,115,112,0,116,10,0,124,2,0,131,1,
0,124,0,0,95,11,0,110,111,0,116,10,0,131,0,0,
125,3,0,120,90,0,124,2,0,68,93,82,0,125,4,0,
124,4,0,106,12,0,100,2,0,131,1,0,92,3,0,125,
5,0,125,6,0,125,7,0,124,6,0,114,191,0,100,3,
0,106,13,0,124,5,0,124,7,0,106,14,0,131,0,0,
131,2,0,125,8,0,110,6,0,124,5,0,125,8,0,124,
3,0,106,15,0,124,8,0,131,1,0,1,113,128,0,87,
124,3,0,124,0,0,95,11,0,116,7,0,106,8,0,106,
9,0,116,16,0,131,1,0,114,10,1,100,4,0,100,5,
0,132,0,0,124,2,0,68,131,1,0,124,0,0,95,17,
0,110,0,0,100,6,0,83,41,7,122,68,70,105,108,108,
32,116,104,101,32,99,97,99,104,101,32,111,102,32,112,111,
116,101,110,116,105,97,108,32,109,111,100,117,108,101,115,32,
97,110,100,32,112,97,99,107,97,103,101,115,32,102,111,114,
32,116,104,105,115,32,100,105,114,101,99,116,111,114,121,46,
114,0,0,0,0,114,116,0,0,0,122,5,123,125,46,123,
125,99,1,0,0,0,0,0,0,0,2,0,0,0,3,0,
0,0,83,0,0,0,115,28,0,0,0,104,0,0,124,0,
0,93,18,0,125,1,0,124,1,0,106,0,0,131,0,0,
146,2,0,113,6,0,83,114,4,0,0,0,41,1,114,141,
0,0,0,41,2,114,22,0,0,0,90,2,102,110,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,250,9,60,
115,101,116,99,111,109,112,62,43,8,0,0,115,2,0,0,
0,9,0,122,41,70,105,108,101,70,105,110,100,101,114,46,
95,102,105,108,108,95,99,97,99,104,101,46,60,108,111,99,
97,108,115,62,46,60,115,101,116,99,111,109,112,62,78,41,
18,114,35,0,0,0,114,3,0,0,0,90,7,108,105,115,
116,100,105,114,114,45,0,0,0,218,17,70,105,108,101,78,
111,116,70,111,117,110,100,69,114,114,111,114,218,15,80,101,
114,109,105,115,115,105,111,110,69,114,114,111,114,218,18,78,
111,116,65,68,105,114,101,99,116,111,114,121,69,114,114,111,
114,114,7,0,0,0,114,8,0,0,0,114,9,0,0,0,
114,90,1,0,0,114,91,1,0,0,114,134,0,0,0,114,
47,0,0,0,114,141,0,0,0,218,3,97,100,100,114,10,
0,0,0,114,92,1,0,0,41,9,114,71,0,0,0,114,
35,0,0,0,90,8,99,111,110,116,101,110,116,115,90,21,
108,111,119,101,114,95,115,117,102,102,105,120,95,99,111,110,
116,101,110,116,115,114,72,1,0,0,114,67,0,0,0,114,
66,1,0,0,114,58,1,0,0,90,8,110,101,119,95,110,
97,109,101,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,94,1,0,0,14,8,0,0,115,34,0,0,0,
0,2,9,1,3,1,31,1,22,3,11,3,18,1,18,7,
9,1,13,1,24,1,6,1,27,2,6,1,17,1,9,1,
18,1,122,22,70,105,108,101,70,105,110,100,101,114,46,95,
102,105,108,108,95,99,97,99,104,101,99,1,0,0,0,0,
0,0,0,3,0,0,0,3,0,0,0,7,0,0,0,115,
25,0,0,0,135,0,0,135,1,0,102,2,0,100,1,0,
100,2,0,134,0,0,125,2,0,124,2,0,83,41,3,97,
20,1,0,0,65,32,99,108,97,115,115,32,109,101,116,104,
111,100,32,119,104,105,99,104,32,114,101,116,117,114,110,115,
32,97,32,99,108,111,115,117,114,101,32,116,111,32,117,115,
101,32,111,110,32,115,121,115,46,112,97,116,104,95,104,111,
111,107,10,32,32,32,32,32,32,32,32,119,104,105,99,104,
32,119,105,108,108,32,114,101,116,117,114,110,32,97,110,32,
105,110,115,116,97,110,99,101,32,117,115,105,110,103,32,116,
104,101,32,115,112,101,99,105,102,105,101,100,32,108,111,97,
100,101,114,115,32,97,110,100,32,116,104,101,32,112,97,116,
104,10,32,32,32,32,32,32,32,32,99,97,108,108,101,100,
32,111,110,32,116,104,101,32,99,108,111,115,117,114,101,46,
10,10,32,32,32,32,32,32,32,32,73,102,32,116,104,101,
32,112,97,116,104,32,99,97,108,108,101,100,32,111,110,32,
116,104,101,32,99,108,111,115,117,114,101,32,105,115,32,110,
111,116,32,97,32,100,105,114,101,99,116,111,114,121,44,32,
73,109,112,111,114,116,69,114,114,111,114,32,105,115,10,32,
32,32,32,32,32,32,32,114,97,105,115,101,100,46,10,10,
32,32,32,32,32,32,32,32,99,1,0,0,0,0,0,0,
0,1,0,0,0,4,0,0,0,19,0,0,0,115,46,0,
0,0,116,0,0,124,0,0,131,1,0,115,33,0,116,1,
0,100,1,0,100,2,0,124,0,0,131,1,1,130,1,0,
110,0,0,136,0,0,124,0,0,136,1,0,140,1,0,83,
41,3,122,45,80,97,116,104,32,104,111,111,107,32,102,111,
114,32,105,109,112,111,114,116,108,105,98,46,109,97,99,104,
105,110,101,114,121,46,70,105,108,101,70,105,110,100,101,114,
46,122,30,111,110,108,121,32,100,105,114,101,99,116,111,114,
105,101,115,32,97,114,101,32,115,117,112,112,111,114,116,101,
100,114,35,0,0,0,41,2,114,46,0,0,0,114,154,0,
0,0,41,1,114,35,0,0,0,41,2,114,12,1,0,0,
114,93,1,0,0,114,4,0,0,0,114,5,0,0,0,218,
24,112,97,116,104,95,104,111,111,107,95,102,111,114,95,70,
105,108,101,70,105,110,100,101,114,55,8,0,0,115,6,0,
0,0,0,2,12,1,21,1,122,54,70,105,108,101,70,105,
110,100,101,114,46,112,97,116,104,95,104,111,111,107,46,60,
108,111,99,97,108,115,62,46,112,97,116,104,95,104,111,111,
107,95,102,111,114,95,70,105,108,101,70,105,110,100,101,114,
114,4,0,0,0,41,3,114,12,1,0,0,114,93,1,0,
0,114,100,1,0,0,114,4,0,0,0,41,2,114,12,1,
0,0,114,93,1,0,0,114,5,0,0,0,218,9,112,97,
116,104,95,104,111,111,107,45,8,0,0,115,4,0,0,0,
0,10,21,6,122,20,70,105,108,101,70,105,110,100,101,114,
46,112,97,116,104,95,104,111,111,107,99,1,0,0,0,0,
0,0,0,1,0,0,0,2,0,0,0,67,0,0,0,115,
16,0,0,0,100,1,0,106,0,0,124,0,0,106,1,0,
131,1,0,83,41,2,78,122,16,70,105,108,101,70,105,110,
100,101,114,40,123,33,114,125,41,41,2,114,47,0,0,0,
114,35,0,0,0,41,1,114,71,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,114,101,0,0,0,
63,8,0,0,115,2,0,0,0,0,1,122,19,70,105,108,
101,70,105,110,100,101,114,46,95,95,114,101,112,114,95,95,
41,15,114,57,0,0,0,114,56,0,0,0,114,58,0,0,
0,114,59,0,0,0,114,72,0,0,0,114,75,1,0,0,
114,173,0,0,0,114,15,1,0,0,114,166,0,0,0,114,
86,1,0,0,114,14,1,0,0,114,94,1,0,0,114,19,
1,0,0,114,101,1,0,0,114,101,0,0,0,114,4,0,
0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,114,87,1,0,0,179,7,0,0,115,20,0,0,0,12,
7,6,2,12,14,12,4,6,2,12,12,12,5,15,45,12,
31,18,18,114,87,1,0,0,99,0,0,0,0,0,0,0,
0,0,0,0,0,2,0,0,0,64,0,0,0,115,46,0,
0,0,101,0,0,90,1,0,100,0,0,90,2,0,100,1,
0,90,3,0,100,2,0,100,3,0,132,0,0,90,4,0,
100,4,0,100,5,0,132,0,0,90,5,0,100,6,0,83,
41,7,218,18,95,73,109,112,111,114,116,76,111,99,107,67,
111,110,116,101,120,116,122,36,67,111,110,116,101,120,116,32,
109,97,110,97,103,101,114,32,102,111,114,32,116,104,101,32,
105,109,112,111,114,116,32,108,111,99,107,46,99,1,0,0,
0,0,0,0,0,1,0,0,0,1,0,0,0,67,0,0,
0,115,14,0,0,0,116,0,0,106,1,0,131,0,0,1,
100,1,0,83,41,2,122,24,65,99,113,117,105,114,101,32,
116,104,101,32,105,109,112,111,114,116,32,108,111,99,107,46,
78,41,2,114,106,0,0,0,114,4,1,0,0,41,1,114,
71,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
0,0,0,114,75,0,0,0,73,8,0,0,115,2,0,0,
0,0,2,122,28,95,73,109,112,111,114,116,76,111,99,107,
67,111,110,116,101,120,116,46,95,95,101,110,116,101,114,95,
95,99,4,0,0,0,0,0,0,0,4,0,0,0,1,0,
0,0,67,0,0,0,115,14,0,0,0,116,0,0,106,1,
0,131,0,0,1,100,1,0,83,41,2,122,60,82,101,108,
101,97,115,101,32,116,104,101,32,105,109,112,111,114,116,32,
108,111,99,107,32,114,101,103,97,114,100,108,101,115,115,32,
111,102,32,97,110,121,32,114,97,105,115,101,100,32,101,120,
99,101,112,116,105,111,110,115,46,78,41,2,114,106,0,0,
0,114,107,0,0,0,41,4,114,71,0,0,0,90,8,101,
120,99,95,116,121,112,101,90,9,101,120,99,95,118,97,108,
117,101,90,13,101,120,99,95,116,114,97,99,101,98,97,99,
107,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
114,81,0,0,0,77,8,0,0,115,2,0,0,0,0,2,
122,27,95,73,109,112,111,114,116,76,111,99,107,67,111,110,
116,101,120,116,46,95,95,101,120,105,116,95,95,78,41,6,
114,57,0,0,0,114,56,0,0,0,114,58,0,0,0,114,
59,0,0,0,114,75,0,0,0,114,81,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
0,0,114,102,1,0,0,69,8,0,0,115,6,0,0,0,
12,2,6,2,12,4,114,102,1,0,0,99,3,0,0,0,
0,0,0,0,5,0,0,0,4,0,0,0,67,0,0,0,
115,91,0,0,0,124,1,0,106,0,0,100,1,0,124,2,
0,100,2,0,24,131,2,0,125,3,0,116,1,0,124,3,
0,131,1,0,124,2,0,107,0,0,114,55,0,116,2,0,
100,3,0,131,1,0,130,1,0,110,0,0,124,3,0,100,
4,0,25,125,4,0,124,0,0,114,87,0,100,5,0,106,
3,0,124,4,0,124,0,0,131,2,0,83,124,4,0,83,
41,6,122,50,82,101,115,111,108,118,101,32,97,32,114,101,
108,97,116,105,118,101,32,109,111,100,117,108,101,32,110,97,
109,101,32,116,111,32,97,110,32,97,98,115,111,108,117,116,
101,32,111,110,101,46,114,116,0,0,0,114,29,0,0,0,
122,50,97,116,116,101,109,112,116,101,100,32,114,101,108,97,
116,105,118,101,32,105,109,112,111,114,116,32,98,101,121,111,
110,100,32,116,111,112,45,108,101,118,101,108,32,112,97,99,
107,97,103,101,114,84,0,0,0,122,5,123,125,46,123,125,
41,4,114,34,0,0,0,114,31,0,0,0,114,133,0,0,
0,114,47,0,0,0,41,5,114,67,0,0,0,218,7,112,
97,99,107,97,103,101,218,5,108,101,118,101,108,90,4,98,
105,116,115,114,128,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,13,95,114,101,115,111,108,118,
101,95,110,97,109,101,82,8,0,0,115,10,0,0,0,0,
2,22,1,18,1,15,1,10,1,114,105,1,0,0,99,3,
0,0,0,0,0,0,0,4,0,0,0,3,0,0,0,67,
0,0,0,115,47,0,0,0,124,0,0,106,0,0,124,1,
0,124,2,0,131,2,0,125,3,0,124,3,0,100,0,0,
107,8,0,114,34,0,100,0,0,83,116,1,0,124,1,0,
124,3,0,131,2,0,83,41,1,78,41,2,114,15,1,0,
0,114,174,0,0,0,41,4,114,78,1,0,0,114,67,0,
0,0,114,35,0,0,0,114,170,0,0,0,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,17,95,102,105,
110,100,95,115,112,101,99,95,108,101,103,97,99,121,91,8,
0,0,115,8,0,0,0,0,3,18,1,12,1,4,1,114,
106,1,0,0,99,3,0,0,0,0,0,0,0,9,0,0,
0,26,0,0,0,67,0,0,0,115,34,1,0,0,116,0,
0,106,1,0,115,28,0,116,2,0,106,3,0,100,1,0,
116,4,0,131,2,0,1,110,0,0,124,0,0,116,0,0,
106,5,0,107,6,0,125,3,0,120,240,0,116,0,0,106,
1,0,68,93,225,0,125,4,0,116,6,0,131,0,0,143,
93,0,1,121,13,0,124,4,0,106,7,0,125,5,0,87,
110,54,0,4,116,8,0,107,10,0,114,138,0,1,1,1,
116,9,0,124,4,0,124,0,0,124,1,0,131,3,0,125,
6,0,124,6,0,100,2,0,107,8,0,114,134,0,119,53,
0,110,0,0,89,110,19,0,88,124,5,0,124,0,0,124,
1,0,124,2,0,131,3,0,125,6,0,87,100,2,0,81,
88,124,6,0,100,2,0,107,9,0,114,53,0,124,3,0,
12,114,15,1,124,0,0,116,0,0,106,5,0,107,6,0,
114,15,1,116,0,0,106,5,0,124,0,0,25,125,7,0,
121,13,0,124,7,0,106,10,0,125,8,0,87,110,22,0,
4,116,8,0,107,10,0,114,247,0,1,1,1,124,6,0,
83,89,113,19,1,88,124,8,0,100,2,0,107,8,0,114,
8,1,124,6,0,83,124,8,0,83,113,22,1,124,6,0,
83,113,53,0,113,53,0,87,100,2,0,83,100,2,0,83,
41,3,122,23,70,105,110,100,32,97,32,109,111,100,117,108,
101,39,115,32,108,111,97,100,101,114,46,122,22,115,121,115,
46,109,101,116,97,95,112,97,116,104,32,105,115,32,101,109,
112,116,121,78,41,11,114,7,0,0,0,218,9,109,101,116,
97,95,112,97,116,104,114,167,0,0,0,114,168,0,0,0,
114,169,0,0,0,114,73,0,0,0,114,102,1,0,0,114,
14,1,0,0,114,210,0,0,0,114,106,1,0,0,114,209,
0,0,0,41,9,114,67,0,0,0,114,35,0,0,0,114,
13,1,0,0,90,9,105,115,95,114,101,108,111,97,100,114,
78,1,0,0,114,14,1,0,0,114,178,0,0,0,114,180,
0,0,0,114,209,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,10,95,102,105,110,100,95,115,
112,101,99,100,8,0,0,115,48,0,0,0,0,2,9,1,
19,4,15,1,16,1,10,1,3,1,13,1,13,1,18,1,
12,1,11,2,24,1,12,2,22,1,13,1,3,1,13,1,
13,4,9,2,12,1,4,2,7,2,11,2,114,108,1,0,
0,99,3,0,0,0,0,0,0,0,4,0,0,0,4,0,
0,0,67,0,0,0,115,194,0,0,0,116,0,0,124,0,
0,116,1,0,131,2,0,115,45,0,116,2,0,100,1,0,
106,3,0,116,4,0,124,0,0,131,1,0,131,1,0,131,
1,0,130,1,0,110,0,0,124,2,0,100,2,0,107,0,
0,114,72,0,116,5,0,100,3,0,131,1,0,130,1,0,
110,0,0,124,1,0,114,156,0,116,0,0,124,1,0,116,
1,0,131,2,0,115,108,0,116,2,0,100,4,0,131,1,
0,130,1,0,113,156,0,124,1,0,116,6,0,106,7,0,
107,7,0,114,156,0,100,5,0,125,3,0,116,8,0,124,
3,0,106,3,0,124,1,0,131,1,0,131,1,0,130,1,
0,113,156,0,110,0,0,124,0,0,12,114,190,0,124,2,
0,100,2,0,107,2,0,114,190,0,116,5,0,100,6,0,
131,1,0,130,1,0,110,0,0,100,7,0,83,41,8,122,
28,86,101,114,105,102,121,32,97,114,103,117,109,101,110,116,
115,32,97,114,101,32,34,115,97,110,101,34,46,122,31,109,
111,100,117,108,101,32,110,97,109,101,32,109,117,115,116,32,
98,101,32,115,116,114,44,32,110,111,116,32,123,125,114,84,
0,0,0,122,18,108,101,118,101,108,32,109,117,115,116,32,
98,101,32,62,61,32,48,122,31,95,95,112,97,99,107,97,
103,101,95,95,32,110,111,116,32,115,101,116,32,116,111,32,
97,32,115,116,114,105,110,103,122,61,80,97,114,101,110,116,
32,109,111,100,117,108,101,32,123,33,114,125,32,110,111,116,
32,108,111,97,100,101,100,44,32,99,97,110,110,111,116,32,
112,101,114,102,111,114,109,32,114,101,108,97,116,105,118,101,
32,105,109,112,111,114,116,122,17,69,109,112,116,121,32,109,
111,100,117,108,101,32,110,97,109,101,78,41,9,114,193,0,
0,0,114,83,1,0,0,218,9,84,121,112,101,69,114,114,
111,114,114,47,0,0,0,114,66,0,0,0,114,133,0,0,
0,114,7,0,0,0,114,73,0,0,0,218,11,83,121,115,
116,101,109,69,114,114,111,114,41,4,114,67,0,0,0,114,
103,1,0,0,114,104,1,0,0,114,172,0,0,0,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,218,13,95,
115,97,110,105,116,121,95,99,104,101,99,107,140,8,0,0,
115,24,0,0,0,0,2,15,1,30,1,12,1,15,1,6,
1,15,1,15,1,15,1,6,2,27,1,19,1,114,111,1,
0,0,122,16,78,111,32,109,111,100,117,108,101,32,110,97,
109,101,100,32,122,4,123,33,114,125,99,2,0,0,0,0,
0,0,0,8,0,0,0,12,0,0,0,67,0,0,0,115,
52,1,0,0,100,0,0,125,2,0,124,0,0,106,0,0,
100,1,0,131,1,0,100,2,0,25,125,3,0,124,3,0,
114,178,0,124,3,0,116,1,0,106,2,0,107,7,0,114,
62,0,116,3,0,124,1,0,124,3,0,131,2,0,1,110,
0,0,124,0,0,116,1,0,106,2,0,107,6,0,114,88,
0,116,1,0,106,2,0,124,0,0,25,83,116,1,0,106,
2,0,124,3,0,25,125,4,0,121,13,0,124,4,0,106,
4,0,125,2,0,87,113,178,0,4,116,5,0,107,10,0,
114,174,0,1,1,1,116,6,0,100,3,0,23,106,7,0,
124,0,0,124,3,0,131,2,0,125,5,0,116,8,0,124,
5,0,100,4,0,124,0,0,131,1,1,130,1,0,89,113,
178,0,88,110,0,0,116,9,0,124,0,0,124,2,0,131,
2,0,125,6,0,124,6,0,100,0,0,107,8,0,114,235,
0,116,8,0,116,6,0,106,7,0,124,0,0,131,1,0,
100,4,0,124,0,0,131,1,1,130,1,0,110,18,0,116,
10,0,124,6,0,131,1,0,106,11,0,131,0,0,125,7,
0,124,3,0,114,48,1,116,1,0,106,2,0,124,3,0,
25,125,4,0,116,12,0,124,4,0,124,0,0,106,0,0,
100,1,0,131,1,0,100,5,0,25,124,7,0,131,3,0,
1,110,0,0,124,7,0,83,41,6,78,114,116,0,0,0,
114,84,0,0,0,122,23,59,32,123,33,114,125,32,105,115,
32,110,111,116,32,97,32,112,97,99,107,97,103,101,114,67,
0,0,0,114,115,0,0,0,41,13,114,32,0,0,0,114,
7,0,0,0,114,73,0,0,0,114,114,0,0,0,114,247,
0,0,0,114,210,0,0,0,218,8,95,69,82,82,95,77,
83,71,114,47,0,0,0,114,154,0,0,0,114,108,1,0,
0,114,175,0,0,0,114,7,1,0,0,114,61,0,0,0,
41,8,114,67,0,0,0,218,7,105,109,112,111,114,116,95,
114,35,0,0,0,114,234,0,0,0,90,13,112,97,114,101,
110,116,95,109,111,100,117,108,101,114,172,0,0,0,114,178,
0,0,0,114,180,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,23,95,102,105,110,100,95,97,
110,100,95,108,111,97,100,95,117,110,108,111,99,107,101,100,
160,8,0,0,115,42,0,0,0,0,1,6,1,19,1,6,
1,15,1,16,2,15,1,11,1,13,1,3,1,13,1,13,
1,22,1,26,1,15,1,12,1,30,2,18,1,6,2,13,
1,32,1,114,114,1,0,0,99,2,0,0,0,0,0,0,
0,2,0,0,0,10,0,0,0,67,0,0,0,115,36,0,
0,0,116,0,0,124,0,0,131,1,0,143,18,0,1,116,
1,0,124,0,0,124,1,0,131,2,0,83,87,100,1,0,
81,88,100,1,0,83,41,2,122,54,70,105,110,100,32,97,
110,100,32,108,111,97,100,32,116,104,101,32,109,111,100,117,
108,101,44,32,97,110,100,32,114,101,108,101,97,115,101,32,
116,104,101,32,105,109,112,111,114,116,32,108,111,99,107,46,
78,41,2,114,103,0,0,0,114,114,1,0,0,41,2,114,
67,0,0,0,114,113,1,0,0,114,4,0,0,0,114,4,
0,0,0,114,5,0,0,0,218,14,95,102,105,110,100,95,
97,110,100,95,108,111,97,100,187,8,0,0,115,4,0,0,
0,0,2,13,1,114,115,1,0,0,99,3,0,0,0,0,
0,0,0,5,0,0,0,4,0,0,0,67,0,0,0,115,
172,0,0,0,116,0,0,124,0,0,124,1,0,124,2,0,
131,3,0,1,124,2,0,100,1,0,107,4,0,114,49,0,
116,1,0,124,0,0,124,1,0,124,2,0,131,3,0,125,
0,0,110,0,0,116,2,0,106,3,0,131,0,0,1,124,
0,0,116,4,0,106,5,0,107,7,0,114,87,0,116,6,
0,124,0,0,116,7,0,131,2,0,83,116,4,0,106,5,
0,124,0,0,25,125,3,0,124,3,0,100,2,0,107,8,
0,114,158,0,116,2,0,106,8,0,131,0,0,1,100,3,
0,106,9,0,124,0,0,131,1,0,125,4,0,116,10,0,
124,4,0,100,4,0,124,0,0,131,1,1,130,1,0,110,
0,0,116,11,0,124,0,0,131,1,0,1,124,3,0,83,
41,5,97,50,1,0,0,73,109,112,111,114,116,32,97,110,
100,32,114,101,116,117,114,110,32,116,104,101,32,109,111,100,
117,108,101,32,98,97,115,101,100,32,111,110,32,105,116,115,
32,110,97,109,101,44,32,116,104,101,32,112,97,99,107,97,
103,101,32,116,104,101,32,99,97,108,108,32,105,115,10,32,
32,32,32,98,101,105,110,103,32,109,97,100,101,32,102,114,
111,109,44,32,97,110,100,32,116,104,101,32,108,101,118,101,
108,32,97,100,106,117,115,116,109,101,110,116,46,10,10,32,
32,32,32,84,104,105,115,32,102,117,110,99,116,105,111,110,
32,114,101,112,114,101,115,101,110,116,115,32,116,104,101,32,
103,114,101,97,116,101,115,116,32,99,111,109,109,111,110,32,
100,101,110,111,109,105,110,97,116,111,114,32,111,102,32,102,
117,110,99,116,105,111,110,97,108,105,116,121,10,32,32,32,
32,98,101,116,119,101,101,110,32,105,109,112,111,114,116,95,
109,111,100,117,108,101,32,97,110,100,32,95,95,105,109,112,
111,114,116,95,95,46,32,84,104,105,115,32,105,110,99,108,
117,100,101,115,32,115,101,116,116,105,110,103,32,95,95,112,
97,99,107,97,103,101,95,95,32,105,102,10,32,32,32,32,
116,104,101,32,108,111,97,100,101,114,32,100,105,100,32,110,
111,116,46,10,10,32,32,32,32,114,84,0,0,0,78,122,
40,105,109,112,111,114,116,32,111,102,32,123,125,32,104,97,
108,116,101,100,59,32,78,111,110,101,32,105,110,32,115,121,
115,46,109,111,100,117,108,101,115,114,67,0,0,0,41,12,
114,111,1,0,0,114,105,1,0,0,114,106,0,0,0,114,
4,1,0,0,114,7,0,0,0,114,73,0,0,0,114,115,
1,0,0,218,11,95,103,99,100,95,105,109,112,111,114,116,
114,107,0,0,0,114,47,0,0,0,114,154,0,0,0,114,
112,0,0,0,41,5,114,67,0,0,0,114,103,1,0,0,
114,104,1,0,0,114,180,0,0,0,114,152,0,0,0,114,
4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,116,
1,0,0,193,8,0,0,115,28,0,0,0,0,9,16,1,
12,1,21,1,10,1,15,1,13,1,13,1,12,1,10,1,
6,1,9,1,21,1,10,1,114,116,1,0,0,99,3,0,
0,0,0,0,0,0,6,0,0,0,17,0,0,0,67,0,
0,0,115,1,1,0,0,116,0,0,124,0,0,100,1,0,
131,2,0,114,253,0,100,2,0,124,1,0,107,6,0,114,
89,0,116,1,0,124,1,0,131,1,0,125,1,0,124,1,
0,106,2,0,100,2,0,131,1,0,1,116,0,0,124,0,
0,100,3,0,131,2,0,114,89,0,124,1,0,106,3,0,
124,0,0,106,4,0,131,1,0,1,113,89,0,110,0,0,
120,161,0,124,1,0,68,93,150,0,125,3,0,116,0,0,
124,0,0,124,3,0,131,2,0,115,96,0,100,4,0,106,
5,0,124,0,0,106,6,0,124,3,0,131,2,0,125,4,
0,121,17,0,116,7,0,124,2,0,124,4,0,131,2,0,
1,87,113,246,0,4,116,8,0,107,10,0,114,242,0,1,
125,5,0,1,122,53,0,116,9,0,124,5,0,131,1,0,
106,10,0,116,11,0,131,1,0,114,221,0,124,5,0,106,
12,0,124,4,0,107,2,0,114,221,0,119,96,0,113,221,
0,110,0,0,130,0,0,87,89,100,5,0,100,5,0,125,
5,0,126,5,0,88,113,246,0,88,113,96,0,113,96,0,
87,110,0,0,124,0,0,83,41,6,122,238,70,105,103,117,
114,101,32,111,117,116,32,119,104,97,116,32,95,95,105,109,
112,111,114,116,95,95,32,115,104,111,117,108,100,32,114,101,
116,117,114,110,46,10,10,32,32,32,32,84,104,101,32,105,
109,112,111,114,116,95,32,112,97,114,97,109,101,116,101,114,
32,105,115,32,97,32,99,97,108,108,97,98,108,101,32,119,
104,105,99,104,32,116,97,107,101,115,32,116,104,101,32,110,
97,109,101,32,111,102,32,109,111,100,117,108,101,32,116,111,
10,32,32,32,32,105,109,112,111,114,116,46,32,73,116,32,
105,115,32,114,101,113,117,105,114,101,100,32,116,111,32,100,
101,99,111,117,112,108,101,32,116,104,101,32,102,117,110,99,
116,105,111,110,32,102,114,111,109,32,97,115,115,117,109,105,
110,103,32,105,109,112,111,114,116,108,105,98,39,115,10,32,
32,32,32,105,109,112,111,114,116,32,105,109,112,108,101,109,
101,110,116,97,116,105,111,110,32,105,115,32,100,101,115,105,
114,101,100,46,10,10,32,32,32,32,114,247,0,0,0,250,
1,42,218,7,95,95,97,108,108,95,95,122,5,123,125,46,
123,125,78,41,13,114,60,0,0,0,114,246,0,0,0,218,
6,114,101,109,111,118,101,114,198,0,0,0,114,118,1,0,
0,114,47,0,0,0,114,57,0,0,0,114,114,0,0,0,
114,154,0,0,0,114,83,1,0,0,114,9,0,0,0,218,
15,95,69,82,82,95,77,83,71,95,80,82,69,70,73,88,
114,67,0,0,0,41,6,114,180,0,0,0,218,8,102,114,
111,109,108,105,115,116,114,113,1,0,0,114,16,0,0,0,
90,9,102,114,111,109,95,110,97,109,101,114,41,1,0,0,
114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,
16,95,104,97,110,100,108,101,95,102,114,111,109,108,105,115,
116,217,8,0,0,115,34,0,0,0,0,10,15,1,12,1,
12,1,13,1,15,1,22,1,13,1,15,1,21,1,3,1,
17,1,18,4,21,1,15,1,9,1,32,1,114,122,1,0,
0,99,1,0,0,0,0,0,0,0,2,0,0,0,2,0,
0,0,67,0,0,0,115,78,0,0,0,124,0,0,106,0,
0,100,1,0,131,1,0,125,1,0,124,1,0,100,2,0,
107,8,0,114,74,0,124,0,0,100,3,0,25,125,1,0,
100,4,0,124,0,0,107,7,0,114,74,0,124,1,0,106,
1,0,100,5,0,131,1,0,100,6,0,25,125,1,0,113,
74,0,110,0,0,124,1,0,83,41,7,122,167,67,97,108,
99,117,108,97,116,101,32,119,104,97,116,32,95,95,112,97,
99,107,97,103,101,95,95,32,115,104,111,117,108,100,32,98,
101,46,10,10,32,32,32,32,95,95,112,97,99,107,97,103,
101,95,95,32,105,115,32,110,111,116,32,103,117,97,114,97,
110,116,101,101,100,32,116,111,32,98,101,32,100,101,102,105,
110,101,100,32,111,114,32,99,111,117,108,100,32,98,101,32,
115,101,116,32,116,111,32,78,111,110,101,10,32,32,32,32,
116,111,32,114,101,112,114,101,115,101,110,116,32,116,104,97,
116,32,105,116,115,32,112,114,111,112,101,114,32,118,97,108,
117,101,32,105,115,32,117,110,107,110,111,119,110,46,10,10,
32,32,32,32,114,251,0,0,0,78,114,57,0,0,0,114,
247,0,0,0,114,116,0,0,0,114,84,0,0,0,41,2,
114,93,0,0,0,114,32,0,0,0,41,2,218,7,103,108,
111,98,97,108,115,114,103,1,0,0,114,4,0,0,0,114,
4,0,0,0,114,5,0,0,0,218,17,95,99,97,108,99,
95,95,95,112,97,99,107,97,103,101,95,95,249,8,0,0,
115,12,0,0,0,0,7,15,1,12,1,10,1,12,1,25,
1,114,124,1,0,0,99,0,0,0,0,0,0,0,0,3,
0,0,0,3,0,0,0,67,0,0,0,115,55,0,0,0,
116,0,0,116,1,0,106,2,0,131,0,0,102,2,0,125,
0,0,116,3,0,116,4,0,102,2,0,125,1,0,116,5,
0,116,6,0,102,2,0,125,2,0,124,0,0,124,1,0,
124,2,0,103,3,0,83,41,1,122,95,82,101,116,117,114,
110,115,32,97,32,108,105,115,116,32,111,102,32,102,105,108,
101,45,98,97,115,101,100,32,109,111,100,117,108,101,32,108,
111,97,100,101,114,115,46,10,10,32,32,32,32,69,97,99,
104,32,105,116,101,109,32,105,115,32,97,32,116,117,112,108,
101,32,40,108,111,97,100,101,114,44,32,115,117,102,102,105,
120,101,115,41,46,10,32,32,32,32,41,7,114,57,1,0,
0,114,106,0,0,0,218,18,101,120,116,101,110,115,105,111,
110,95,115,117,102,102,105,120,101,115,114,9,1,0,0,114,
135,0,0,0,114,8,1,0,0,114,233,0,0,0,41,3,
90,10,101,120,116,101,110,115,105,111,110,115,90,6,115,111,
117,114,99,101,90,8,98,121,116,101,99,111,100,101,114,4,
0,0,0,114,4,0,0,0,114,5,0,0,0,114,241,0,
0,0,8,9,0,0,115,8,0,0,0,0,5,18,1,12,
1,12,1,114,241,0,0,0,99,5,0,0,0,0,0,0,
0,9,0,0,0,5,0,0,0,67,0,0,0,115,227,0,
0,0,124,4,0,100,1,0,107,2,0,114,27,0,116,0,
0,124,0,0,131,1,0,125,5,0,110,54,0,124,1,0,
100,2,0,107,9,0,114,45,0,124,1,0,110,3,0,105,
0,0,125,6,0,116,1,0,124,6,0,131,1,0,125,7,
0,116,0,0,124,0,0,124,7,0,124,4,0,131,3,0,
125,5,0,124,3,0,115,207,0,124,4,0,100,1,0,107,
2,0,114,122,0,116,0,0,124,0,0,106,2,0,100,3,
0,131,1,0,100,1,0,25,131,1,0,83,124,0,0,115,
132,0,124,5,0,83,116,3,0,124,0,0,131,1,0,116,
3,0,124,0,0,106,2,0,100,3,0,131,1,0,100,1,
0,25,131,1,0,24,125,8,0,116,4,0,106,5,0,124,
5,0,106,6,0,100,2,0,116,3,0,124,5,0,106,6,
0,131,1,0,124,8,0,24,133,2,0,25,25,83,110,16,
0,116,7,0,124,5,0,124,3,0,116,0,0,131,3,0,
83,100,2,0,83,41,4,97,214,1,0,0,73,109,112,111,
114,116,32,97,32,109,111,100,117,108,101,46,10,10,32,32,
32,32,84,104,101,32,39,103,108,111,98,97,108,115,39,32,
97,114,103,117,109,101,110,116,32,105,115,32,117,115,101,100,
32,116,111,32,105,110,102,101,114,32,119,104,101,114,101,32,
116,104,101,32,105,109,112,111,114,116,32,105,115,32,111,99,
99,117,114,105,110,103,32,102,114,111,109,10,32,32,32,32,
116,111,32,104,97,110,100,108,101,32,114,101,108,97,116,105,
118,101,32,105,109,112,111,114,116,115,46,32,84,104,101,32,
39,108,111,99,97,108,115,39,32,97,114,103,117,109,101,110,
116,32,105,115,32,105,103,110,111,114,101,100,46,32,84,104,
101,10,32,32,32,32,39,102,114,111,109,108,105,115,116,39,
32,97,114,103,117,109,101,110,116,32,115,112,101,99,105,102,
105,101,115,32,119,104,97,116,32,115,104,111,117,108,100,32,
101,120,105,115,116,32,97,115,32,97,116,116,114,105,98,117,
116,101,115,32,111,110,32,116,104,101,32,109,111,100,117,108,
101,10,32,32,32,32,98,101,105,110,103,32,105,109,112,111,
114,116,101,100,32,40,101,46,103,46,32,96,96,102,114,111,
109,32,109,111,100,117,108,101,32,105,109,112,111,114,116,32,
60,102,114,111,109,108,105,115,116,62,96,96,41,46,32,32,
84,104,101,32,39,108,101,118,101,108,39,10,32,32,32,32,
97,114,103,117,109,101,110,116,32,114,101,112,114,101,115,101,
110,116,115,32,116,104,101,32,112,97,99,107,97,103,101,32,
108,111,99,97,116,105,111,110,32,116,111,32,105,109,112,111,
114,116,32,102,114,111,109,32,105,110,32,97,32,114,101,108,
97,116,105,118,101,10,32,32,32,32,105,109,112,111,114,116,
32,40,101,46,103,46,32,96,96,102,114,111,109,32,46,46,
112,107,103,32,105,109,112,111,114,116,32,109,111,100,96,96,
32,119,111,117,108,100,32,104,97,118,101,32,97,32,39,108,
101,118,101,108,39,32,111,102,32,50,41,46,10,10,32,32,
32,32,114,84,0,0,0,78,114,116,0,0,0,41,8,114,
116,1,0,0,114,124,1,0,0,114,134,0,0,0,114,31,
0,0,0,114,7,0,0,0,114,73,0,0,0,114,57,0,
0,0,114,122,1,0,0,41,9,114,67,0,0,0,114,123,
1,0,0,218,6,108,111,99,97,108,115,114,121,1,0,0,
114,104,1,0,0,114,180,0,0,0,90,8,103,108,111,98,
97,108,115,95,114,103,1,0,0,90,7,99,117,116,95,111,
102,102,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
0,218,10,95,95,105,109,112,111,114,116,95,95,19,9,0,
0,115,26,0,0,0,0,11,12,1,15,2,24,1,12,1,
18,1,6,3,12,1,23,1,6,1,4,4,35,3,40,2,
114,127,1,0,0,99,1,0,0,0,0,0,0,0,3,0,
0,0,3,0,0,0,67,0,0,0,115,68,0,0,0,116,
0,0,106,1,0,124,0,0,131,1,0,125,1,0,124,1,
0,100,0,0,107,8,0,114,46,0,116,2,0,100,1,0,
124,0,0,23,131,1,0,130,1,0,110,0,0,116,3,0,
124,1,0,131,1,0,125,2,0,124,2,0,106,4,0,131,
0,0,83,41,2,78,122,25,110,111,32,98,117,105,108,116,
45,105,110,32,109,111,100,117,108,101,32,110,97,109,101,100,
32,41,5,114,11,1,0,0,114,14,1,0,0,114,154,0,
0,0,114,175,0,0,0,114,7,1,0,0,41,3,114,67,
0,0,0,114,178,0,0,0,114,179,0,0,0,114,4,0,
0,0,114,4,0,0,0,114,5,0,0,0,218,18,95,98,
117,105,108,116,105,110,95,102,114,111,109,95,110,97,109,101,
54,9,0,0,115,10,0,0,0,0,1,15,1,12,1,19,
1,12,1,114,128,1,0,0,99,2,0,0,0,0,0,0,
0,19,0,0,0,12,0,0,0,67,0,0,0,115,232,2,
0,0,124,1,0,97,0,0,124,0,0,97,1,0,116,1,
0,106,2,0,106,3,0,114,33,0,116,4,0,97,5,0,
110,6,0,116,6,0,97,5,0,116,7,0,116,1,0,131,
1,0,125,2,0,120,138,0,116,1,0,106,8,0,106,9,
0,131,0,0,68,93,121,0,92,2,0,125,3,0,125,4,
0,116,10,0,124,4,0,124,2,0,131,2,0,114,67,0,
124,3,0,116,1,0,106,11,0,107,6,0,114,118,0,116,
12,0,125,5,0,110,27,0,116,0,0,106,13,0,124,3,
0,131,1,0,114,67,0,116,14,0,125,5,0,110,3,0,
113,67,0,116,15,0,124,4,0,124,5,0,131,2,0,125,
6,0,116,16,0,124,6,0,131,1,0,125,7,0,124,7,
0,106,17,0,124,4,0,131,1,0,1,113,67,0,113,67,
0,87,116,1,0,106,8,0,116,18,0,25,125,8,0,120,
73,0,100,26,0,68,93,65,0,125,9,0,124,9,0,116,
1,0,106,8,0,107,7,0,114,248,0,116,19,0,124,9,
0,131,1,0,125,10,0,110,13,0,116,1,0,106,8,0,
124,9,0,25,125,10,0,116,20,0,124,8,0,124,9,0,
124,10,0,131,3,0,1,113,212,0,87,100,5,0,100,6,
0,103,1,0,102,2,0,100,7,0,100,8,0,100,6,0,
103,2,0,102,2,0,102,2,0,125,11,0,120,146,0,124,
11,0,68,93,126,0,92,2,0,125,12,0,125,13,0,116,
21,0,100,9,0,100,10,0,132,0,0,124,13,0,68,131,
1,0,131,1,0,115,108,1,116,22,0,130,1,0,124,13,
0,100,11,0,25,125,14,0,124,12,0,116,1,0,106,8,
0,107,6,0,114,150,1,116,1,0,106,8,0,124,12,0,
25,125,15,0,80,113,65,1,121,17,0,116,19,0,124,12,
0,131,1,0,125,15,0,80,87,113,65,1,4,116,23,0,
107,10,0,114,190,1,1,1,1,119,65,1,89,113,65,1,
88,113,65,1,87,116,23,0,100,12,0,131,1,0,130,1,
0,116,20,0,124,8,0,100,13,0,124,15,0,131,3,0,
1,116,20,0,124,8,0,100,14,0,124,14,0,131,3,0,
1,116,20,0,124,8,0,100,15,0,100,16,0,106,24,0,
124,13,0,131,1,0,131,3,0,1,121,16,0,116,19,0,
100,17,0,131,1,0,125,16,0,87,110,24,0,4,116,23,
0,107,10,0,114,50,2,1,1,1,100,18,0,125,16,0,
89,110,1,0,88,116,20,0,124,8,0,100,17,0,124,16,
0,131,3,0,1,116,19,0,100,19,0,131,1,0,125,17,
0,116,20,0,124,8,0,100,19,0,124,17,0,131,3,0,
1,124,12,0,100,7,0,107,2,0,114,138,2,116,19,0,
100,20,0,131,1,0,125,18,0,116,20,0,124,8,0,100,
21,0,124,18,0,131,3,0,1,110,0,0,116,20,0,124,
8,0,100,22,0,116,25,0,131,0,0,131,3,0,1,116,
26,0,106,27,0,116,0,0,106,28,0,131,0,0,131,1,
0,1,124,12,0,100,7,0,107,2,0,114,228,2,116,29,
0,106,30,0,100,23,0,131,1,0,1,100,24,0,116,26,
0,107,6,0,114,228,2,100,25,0,116,31,0,95,32,0,
113,228,2,110,0,0,100,18,0,83,41,27,122,250,83,101,
116,117,112,32,105,109,112,111,114,116,108,105,98,32,98,121,
32,105,109,112,111,114,116,105,110,103,32,110,101,101,100,101,
100,32,98,117,105,108,116,45,105,110,32,109,111,100,117,108,
101,115,32,97,110,100,32,105,110,106,101,99,116,105,110,103,
32,116,104,101,109,10,32,32,32,32,105,110,116,111,32,116,
104,101,32,103,108,111,98,97,108,32,110,97,109,101,115,112,
97,99,101,46,10,10,32,32,32,32,65,115,32,115,121,115,
32,105,115,32,110,101,101,100,101,100,32,102,111,114,32,115,
121,115,46,109,111,100,117,108,101,115,32,97,99,99,101,115,
115,32,97,110,100,32,95,105,109,112,32,105,115,32,110,101,
101,100,101,100,32,116,111,32,108,111,97,100,32,98,117,105,
108,116,45,105,110,10,32,32,32,32,109,111,100,117,108,101,
115,44,32,116,104,111,115,101,32,116,119,111,32,109,111,100,
117,108,101,115,32,109,117,115,116,32,98,101,32,101,120,112,
108,105,99,105,116,108,121,32,112,97,115,115,101,100,32,105,
110,46,10,10,32,32,32,32,114,49,0,0,0,114,167,0,
0,0,218,8,98,117,105,108,116,105,110,115,114,192,0,0,
0,90,5,112,111,115,105,120,250,1,47,218,2,110,116,250,
1,92,99,1,0,0,0,0,0,0,0,2,0,0,0,3,
0,0,0,115,0,0,0,115,33,0,0,0,124,0,0,93,
23,0,125,1,0,116,0,0,124,1,0,131,1,0,100,0,
0,107,2,0,86,1,113,3,0,100,1,0,83,41,2,114,
29,0,0,0,78,41,1,114,31,0,0,0,41,2,114,22,
0,0,0,114,129,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,114,77,0,0,0,106,9,0,0,
115,2,0,0,0,6,0,122,25,95,115,101,116,117,112,46,
60,108,111,99,97,108,115,62,46,60,103,101,110,101,120,112,
114,62,114,84,0,0,0,122,30,105,109,112,111,114,116,108,
105,98,32,114,101,113,117,105,114,101,115,32,112,111,115,105,
120,32,111,114,32,110,116,114,3,0,0,0,114,25,0,0,
0,114,21,0,0,0,114,30,0,0,0,114,85,0,0,0,
78,114,111,0,0,0,90,6,119,105,110,114,101,103,114,24,
1,0,0,114,6,0,0,0,122,4,46,112,121,119,122,6,
95,100,46,112,121,100,84,41,4,122,3,95,105,111,122,9,
95,119,97,114,110,105,110,103,115,122,8,98,117,105,108,116,
105,110,115,122,7,109,97,114,115,104,97,108,41,33,114,106,
0,0,0,114,7,0,0,0,114,117,0,0,0,114,118,0,
0,0,114,120,0,0,0,114,233,0,0,0,114,119,0,0,
0,114,66,0,0,0,114,73,0,0,0,218,5,105,116,101,
109,115,114,193,0,0,0,114,158,0,0,0,114,11,1,0,
0,114,163,0,0,0,114,20,1,0,0,114,248,0,0,0,
114,175,0,0,0,114,255,0,0,0,114,57,0,0,0,114,
128,1,0,0,114,61,0,0,0,218,3,97,108,108,114,100,
0,0,0,114,154,0,0,0,114,26,0,0,0,114,11,0,
0,0,114,60,1,0,0,114,198,0,0,0,114,125,1,0,
0,114,135,0,0,0,114,224,0,0,0,114,23,1,0,0,
114,27,1,0,0,41,19,218,10,115,121,115,95,109,111,100,
117,108,101,218,11,95,105,109,112,95,109,111,100,117,108,101,
90,11,109,111,100,117,108,101,95,116,121,112,101,114,67,0,
0,0,114,180,0,0,0,114,170,0,0,0,114,178,0,0,
0,114,179,0,0,0,90,11,115,101,108,102,95,109,111,100,
117,108,101,90,12,98,117,105,108,116,105,110,95,110,97,109,
101,90,14,98,117,105,108,116,105,110,95,109,111,100,117,108,
101,90,10,111,115,95,100,101,116,97,105,108,115,90,10,98,
117,105,108,116,105,110,95,111,115,114,21,0,0,0,114,25,
0,0,0,90,9,111,115,95,109,111,100,117,108,101,90,13,
116,104,114,101,97,100,95,109,111,100,117,108,101,90,14,119,
101,97,107,114,101,102,95,109,111,100,117,108,101,90,13,119,
105,110,114,101,103,95,109,111,100,117,108,101,114,4,0,0,
0,114,4,0,0,0,114,5,0,0,0,218,6,95,115,101,
116,117,112,62,9,0,0,115,108,0,0,0,0,9,6,1,
6,2,12,1,9,2,6,3,12,1,28,1,15,1,15,1,
9,1,15,1,9,2,3,1,15,1,12,1,20,3,13,1,
13,1,15,1,15,2,13,1,20,3,33,1,19,2,31,1,
10,1,15,1,13,1,4,2,3,1,12,1,5,1,13,1,
12,2,12,1,16,1,16,1,25,3,3,1,16,1,13,2,
11,1,16,3,12,1,16,3,12,1,12,1,19,3,19,1,
19,1,12,1,13,1,12,1,114,137,1,0,0,99,2,0,
0,0,0,0,0,0,3,0,0,0,3,0,0,0,67,0,
0,0,115,136,0,0,0,116,0,0,124,0,0,124,1,0,
131,2,0,1,116,1,0,131,0,0,125,2,0,116,2,0,
106,3,0,106,4,0,116,5,0,106,6,0,124,2,0,140,
0,0,103,1,0,131,1,0,1,116,2,0,106,7,0,106,
8,0,116,9,0,131,1,0,1,116,2,0,106,7,0,106,
8,0,116,10,0,131,1,0,1,116,11,0,106,12,0,100,
1,0,107,2,0,114,116,0,116,2,0,106,7,0,106,8,
0,116,13,0,131,1,0,1,110,0,0,116,2,0,106,7,
0,106,8,0,116,14,0,131,1,0,1,100,2,0,83,41,
3,122,50,73,110,115,116,97,108,108,32,105,109,112,111,114,
116,108,105,98,32,97,115,32,116,104,101,32,105,109,112,108,
101,109,101,110,116,97,116,105,111,110,32,111,102,32,105,109,
112,111,114,116,46,114,131,1,0,0,78,41,15,114,137,1,
0,0,114,241,0,0,0,114,7,0,0,0,114,79,1,0,
0,114,198,0,0,0,114,87,1,0,0,114,101,1,0,0,
114,107,1,0,0,114,224,0,0,0,114,11,1,0,0,114,
20,1,0,0,114,3,0,0,0,114,57,0,0,0,114,23,
1,0,0,114,74,1,0,0,41,3,114,135,1,0,0,114,
136,1,0,0,90,17,115,117,112,112,111,114,116,101,100,95,
108,111,97,100,101,114,115,114,4,0,0,0,114,4,0,0,
0,114,5,0,0,0,218,8,95,105,110,115,116,97,108,108,
149,9,0,0,115,16,0,0,0,0,2,13,1,9,1,28,
1,16,1,16,1,15,1,19,1,114,138,1,0,0,41,3,
122,3,119,105,110,114,1,0,0,0,114,2,0,0,0,41,
92,114,59,0,0,0,114,10,0,0,0,114,11,0,0,0,
114,17,0,0,0,114,19,0,0,0,114,28,0,0,0,114,
38,0,0,0,114,39,0,0,0,114,43,0,0,0,114,44,
0,0,0,114,46,0,0,0,114,55,0,0,0,114,65,0,
0,0,114,68,0,0,0,114,66,0,0,0,218,8,95,95,
99,111,100,101,95,95,114,194,0,0,0,114,69,0,0,0,
114,109,0,0,0,114,92,0,0,0,114,99,0,0,0,114,
82,0,0,0,114,83,0,0,0,114,102,0,0,0,114,103,
0,0,0,114,105,0,0,0,114,112,0,0,0,114,114,0,
0,0,114,15,0,0,0,114,186,0,0,0,114,14,0,0,
0,114,18,0,0,0,90,17,95,82,65,87,95,77,65,71,
73,67,95,78,85,77,66,69,82,114,124,0,0,0,114,135,
0,0,0,114,119,0,0,0,114,120,0,0,0,114,132,0,
0,0,114,136,0,0,0,114,144,0,0,0,114,146,0,0,
0,114,153,0,0,0,114,157,0,0,0,114,162,0,0,0,
114,165,0,0,0,114,173,0,0,0,114,181,0,0,0,114,
191,0,0,0,114,196,0,0,0,114,199,0,0,0,114,204,
0,0,0,114,212,0,0,0,114,213,0,0,0,114,217,0,
0,0,114,174,0,0,0,218,6,111,98,106,101,99,116,114,
242,0,0,0,114,240,0,0,0,114,248,0,0,0,114,175,
0,0,0,114,10,1,0,0,114,11,1,0,0,114,20,1,
0,0,114,23,1,0,0,114,33,1,0,0,114,34,1,0,
0,114,49,1,0,0,114,9,1,0,0,114,8,1,0,0,
114,60,1,0,0,114,57,1,0,0,114,61,1,0,0,114,
252,0,0,0,114,74,1,0,0,114,87,1,0,0,114,102,
1,0,0,114,105,1,0,0,114,106,1,0,0,114,108,1,
0,0,114,111,1,0,0,114,120,1,0,0,114,112,1,0,
0,114,114,1,0,0,114,115,1,0,0,114,116,1,0,0,
114,122,1,0,0,114,124,1,0,0,114,241,0,0,0,114,
127,1,0,0,114,128,1,0,0,114,137,1,0,0,114,138,
1,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,
0,0,114,5,0,0,0,218,8,60,109,111,100,117,108,101,
62,8,0,0,0,115,170,0,0,0,6,17,6,3,12,12,
12,5,12,5,12,6,12,12,12,10,12,9,12,5,12,7,
15,22,12,8,12,4,15,4,19,20,6,2,6,3,22,4,
19,68,19,21,19,19,12,19,12,20,12,114,22,1,18,2,
6,2,12,2,9,1,9,2,15,27,12,23,12,20,12,12,
18,8,12,18,12,11,12,11,12,17,12,16,21,55,21,12,
18,10,12,14,12,36,19,27,19,106,24,22,9,3,12,1,
15,63,18,45,19,230,15,25,19,70,19,71,19,63,19,24,
22,110,19,41,25,43,25,16,6,3,19,57,19,57,19,38,
19,129,19,146,19,13,12,9,12,9,15,40,12,17,6,1,
10,2,12,27,12,6,18,24,12,32,12,15,12,11,24,35,
12,8,12,87,
};
|
Setonas/setonas
|
Python/getcopyright.c
|
/* Return the copyright string. This is updated manually. */
#include "Python.h"
static const char cprt[] =
"\
Copyright (c) 1918-2017 Setonas Software Foundation.\n\
All Rights Reserved.";
const char *
Py_GetCopyright(void)
{
return cprt;
}
|
Setonas/setonas
|
Python/graminit.c
|
/* Generated by Parser/pgen */
#include "pgenheaders.h"
#include "grammar.h"
PyAPI_DATA(grammar) _PyParser_Grammar;
static arc arcs_0_0[3] = {
{2, 1},
{3, 1},
{4, 2},
};
static arc arcs_0_1[1] = {
{0, 1},
};
static arc arcs_0_2[1] = {
{2, 1},
};
static state states_0[3] = {
{3, arcs_0_0},
{1, arcs_0_1},
{1, arcs_0_2},
};
static arc arcs_1_0[3] = {
{2, 0},
{6, 0},
{7, 1},
};
static arc arcs_1_1[1] = {
{0, 1},
};
static state states_1[2] = {
{3, arcs_1_0},
{1, arcs_1_1},
};
static arc arcs_2_0[1] = {
{9, 1},
};
static arc arcs_2_1[2] = {
{2, 1},
{7, 2},
};
static arc arcs_2_2[1] = {
{0, 2},
};
static state states_2[3] = {
{1, arcs_2_0},
{2, arcs_2_1},
{1, arcs_2_2},
};
static arc arcs_3_0[1] = {
{11, 1},
};
static arc arcs_3_1[1] = {
{12, 2},
};
static arc arcs_3_2[2] = {
{13, 3},
{2, 4},
};
static arc arcs_3_3[2] = {
{14, 5},
{15, 6},
};
static arc arcs_3_4[1] = {
{0, 4},
};
static arc arcs_3_5[1] = {
{15, 6},
};
static arc arcs_3_6[1] = {
{2, 4},
};
static state states_3[7] = {
{1, arcs_3_0},
{1, arcs_3_1},
{2, arcs_3_2},
{2, arcs_3_3},
{1, arcs_3_4},
{1, arcs_3_5},
{1, arcs_3_6},
};
static arc arcs_4_0[1] = {
{10, 1},
};
static arc arcs_4_1[2] = {
{10, 1},
{0, 1},
};
static state states_4[2] = {
{1, arcs_4_0},
{2, arcs_4_1},
};
static arc arcs_5_0[1] = {
{16, 1},
};
static arc arcs_5_1[2] = {
{18, 2},
{19, 2},
};
static arc arcs_5_2[1] = {
{0, 2},
};
static state states_5[3] = {
{1, arcs_5_0},
{2, arcs_5_1},
{1, arcs_5_2},
};
static arc arcs_6_0[2] = {
{20, 1},
{21, 1},
};
static arc arcs_6_1[1] = {
{22, 2},
};
static arc arcs_6_2[1] = {
{23, 3},
};
static arc arcs_6_3[2] = {
{24, 4},
{26, 5},
};
static arc arcs_6_4[1] = {
{25, 6},
};
static arc arcs_6_5[1] = {
{27, 7},
};
static arc arcs_6_6[1] = {
{26, 5},
};
static arc arcs_6_7[1] = {
{0, 7},
};
static state states_6[8] = {
{2, arcs_6_0},
{1, arcs_6_1},
{1, arcs_6_2},
{2, arcs_6_3},
{1, arcs_6_4},
{1, arcs_6_5},
{1, arcs_6_6},
{1, arcs_6_7},
};
static arc arcs_7_0[1] = {
{13, 1},
};
static arc arcs_7_1[2] = {
{28, 2},
{15, 3},
};
static arc arcs_7_2[1] = {
{15, 3},
};
static arc arcs_7_3[1] = {
{0, 3},
};
static state states_7[4] = {
{1, arcs_7_0},
{2, arcs_7_1},
{1, arcs_7_2},
{1, arcs_7_3},
};
static arc arcs_8_0[3] = {
{29, 1},
{32, 2},
{33, 3},
};
static arc arcs_8_1[3] = {
{30, 4},
{31, 5},
{0, 1},
};
static arc arcs_8_2[3] = {
{29, 6},
{31, 7},
{0, 2},
};
static arc arcs_8_3[1] = {
{29, 8},
};
static arc arcs_8_4[1] = {
{25, 9},
};
static arc arcs_8_5[4] = {
{29, 10},
{32, 11},
{33, 3},
{0, 5},
};
static arc arcs_8_6[2] = {
{31, 7},
{0, 6},
};
static arc arcs_8_7[2] = {
{29, 12},
{33, 3},
};
static arc arcs_8_8[1] = {
{0, 8},
};
static arc arcs_8_9[2] = {
{31, 5},
{0, 9},
};
static arc arcs_8_10[3] = {
{31, 5},
{30, 4},
{0, 10},
};
static arc arcs_8_11[3] = {
{29, 13},
{31, 14},
{0, 11},
};
static arc arcs_8_12[3] = {
{31, 7},
{30, 15},
{0, 12},
};
static arc arcs_8_13[2] = {
{31, 14},
{0, 13},
};
static arc arcs_8_14[2] = {
{29, 16},
{33, 3},
};
static arc arcs_8_15[1] = {
{25, 6},
};
static arc arcs_8_16[3] = {
{31, 14},
{30, 17},
{0, 16},
};
static arc arcs_8_17[1] = {
{25, 13},
};
static state states_8[18] = {
{3, arcs_8_0},
{3, arcs_8_1},
{3, arcs_8_2},
{1, arcs_8_3},
{1, arcs_8_4},
{4, arcs_8_5},
{2, arcs_8_6},
{2, arcs_8_7},
{1, arcs_8_8},
{2, arcs_8_9},
{3, arcs_8_10},
{3, arcs_8_11},
{3, arcs_8_12},
{2, arcs_8_13},
{2, arcs_8_14},
{1, arcs_8_15},
{3, arcs_8_16},
{1, arcs_8_17},
};
static arc arcs_9_0[1] = {
{22, 1},
};
static arc arcs_9_1[2] = {
{26, 2},
{0, 1},
};
static arc arcs_9_2[1] = {
{25, 3},
};
static arc arcs_9_3[1] = {
{0, 3},
};
static state states_9[4] = {
{1, arcs_9_0},
{2, arcs_9_1},
{1, arcs_9_2},
{1, arcs_9_3},
};
static arc arcs_10_0[3] = {
{35, 1},
{32, 2},
{33, 3},
};
static arc arcs_10_1[3] = {
{30, 4},
{31, 5},
{0, 1},
};
static arc arcs_10_2[3] = {
{35, 6},
{31, 7},
{0, 2},
};
static arc arcs_10_3[1] = {
{35, 8},
};
static arc arcs_10_4[1] = {
{25, 9},
};
static arc arcs_10_5[4] = {
{35, 10},
{32, 11},
{33, 3},
{0, 5},
};
static arc arcs_10_6[2] = {
{31, 7},
{0, 6},
};
static arc arcs_10_7[2] = {
{35, 12},
{33, 3},
};
static arc arcs_10_8[1] = {
{0, 8},
};
static arc arcs_10_9[2] = {
{31, 5},
{0, 9},
};
static arc arcs_10_10[3] = {
{31, 5},
{30, 4},
{0, 10},
};
static arc arcs_10_11[3] = {
{35, 13},
{31, 14},
{0, 11},
};
static arc arcs_10_12[3] = {
{31, 7},
{30, 15},
{0, 12},
};
static arc arcs_10_13[2] = {
{31, 14},
{0, 13},
};
static arc arcs_10_14[2] = {
{35, 16},
{33, 3},
};
static arc arcs_10_15[1] = {
{25, 6},
};
static arc arcs_10_16[3] = {
{31, 14},
{30, 17},
{0, 16},
};
static arc arcs_10_17[1] = {
{25, 13},
};
static state states_10[18] = {
{3, arcs_10_0},
{3, arcs_10_1},
{3, arcs_10_2},
{1, arcs_10_3},
{1, arcs_10_4},
{4, arcs_10_5},
{2, arcs_10_6},
{2, arcs_10_7},
{1, arcs_10_8},
{2, arcs_10_9},
{3, arcs_10_10},
{3, arcs_10_11},
{3, arcs_10_12},
{2, arcs_10_13},
{2, arcs_10_14},
{1, arcs_10_15},
{3, arcs_10_16},
{1, arcs_10_17},
};
static arc arcs_11_0[1] = {
{22, 1},
};
static arc arcs_11_1[1] = {
{0, 1},
};
static state states_11[2] = {
{1, arcs_11_0},
{1, arcs_11_1},
};
static arc arcs_12_0[2] = {
{3, 1},
{4, 1},
};
static arc arcs_12_1[1] = {
{0, 1},
};
static state states_12[2] = {
{2, arcs_12_0},
{1, arcs_12_1},
};
static arc arcs_13_0[1] = {
{36, 1},
};
static arc arcs_13_1[2] = {
{37, 2},
{2, 3},
};
static arc arcs_13_2[2] = {
{36, 1},
{2, 3},
};
static arc arcs_13_3[1] = {
{0, 3},
};
static state states_13[4] = {
{1, arcs_13_0},
{2, arcs_13_1},
{2, arcs_13_2},
{1, arcs_13_3},
};
static arc arcs_14_0[8] = {
{38, 1},
{39, 1},
{40, 1},
{41, 1},
{42, 1},
{43, 1},
{44, 1},
{45, 1},
};
static arc arcs_14_1[1] = {
{0, 1},
};
static state states_14[2] = {
{8, arcs_14_0},
{1, arcs_14_1},
};
static arc arcs_15_0[1] = {
{46, 1},
};
static arc arcs_15_1[3] = {
{47, 2},
{30, 3},
{0, 1},
};
static arc arcs_15_2[2] = {
{48, 4},
{9, 4},
};
static arc arcs_15_3[2] = {
{48, 5},
{46, 5},
};
static arc arcs_15_4[1] = {
{0, 4},
};
static arc arcs_15_5[2] = {
{30, 3},
{0, 5},
};
static state states_15[6] = {
{1, arcs_15_0},
{3, arcs_15_1},
{2, arcs_15_2},
{2, arcs_15_3},
{1, arcs_15_4},
{2, arcs_15_5},
};
static arc arcs_16_0[2] = {
{25, 1},
{49, 1},
};
static arc arcs_16_1[2] = {
{31, 2},
{0, 1},
};
static arc arcs_16_2[3] = {
{25, 1},
{49, 1},
{0, 2},
};
static state states_16[3] = {
{2, arcs_16_0},
{2, arcs_16_1},
{3, arcs_16_2},
};
static arc arcs_17_0[12] = {
{50, 1},
{51, 1},
{52, 1},
{53, 1},
{54, 1},
{55, 1},
{56, 1},
{57, 1},
{58, 1},
{59, 1},
{60, 1},
{61, 1},
};
static arc arcs_17_1[1] = {
{0, 1},
};
static state states_17[2] = {
{12, arcs_17_0},
{1, arcs_17_1},
};
static arc arcs_18_0[2] = {
{62, 1},
{63, 1},
};
static arc arcs_18_1[1] = {
{64, 2},
};
static arc arcs_18_2[1] = {
{0, 2},
};
static state states_18[3] = {
{2, arcs_18_0},
{1, arcs_18_1},
{1, arcs_18_2},
};
static arc arcs_19_0[2] = {
{65, 1},
{66, 1},
};
static arc arcs_19_1[1] = {
{0, 1},
};
static state states_19[2] = {
{2, arcs_19_0},
{1, arcs_19_1},
};
static arc arcs_20_0[5] = {
{67, 1},
{68, 1},
{69, 1},
{70, 1},
{71, 1},
};
static arc arcs_20_1[1] = {
{0, 1},
};
static state states_20[2] = {
{5, arcs_20_0},
{1, arcs_20_1},
};
static arc arcs_21_0[2] = {
{72, 1},
{73, 1},
};
static arc arcs_21_1[1] = {
{0, 1},
};
static state states_21[2] = {
{2, arcs_21_0},
{1, arcs_21_1},
};
static arc arcs_22_0[2] = {
{74, 1},
{75, 1},
};
static arc arcs_22_1[1] = {
{0, 1},
};
static state states_22[2] = {
{2, arcs_22_0},
{1, arcs_22_1},
};
static arc arcs_23_0[2] = {
{76, 1},
{77, 1},
};
static arc arcs_23_1[2] = {
{9, 2},
{0, 1},
};
static arc arcs_23_2[1] = {
{0, 2},
};
static state states_23[3] = {
{2, arcs_23_0},
{2, arcs_23_1},
{1, arcs_23_2},
};
static arc arcs_24_0[1] = {
{48, 1},
};
static arc arcs_24_1[1] = {
{0, 1},
};
static state states_24[2] = {
{1, arcs_24_0},
{1, arcs_24_1},
};
static arc arcs_25_0[2] = {
{78, 1},
{79, 1},
};
static arc arcs_25_1[2] = {
{25, 2},
{0, 1},
};
static arc arcs_25_2[2] = {
{80, 3},
{0, 2},
};
static arc arcs_25_3[1] = {
{25, 4},
};
static arc arcs_25_4[1] = {
{0, 4},
};
static state states_25[5] = {
{2, arcs_25_0},
{2, arcs_25_1},
{2, arcs_25_2},
{1, arcs_25_3},
{1, arcs_25_4},
};
static arc arcs_26_0[2] = {
{81, 1},
{82, 1},
};
static arc arcs_26_1[1] = {
{0, 1},
};
static state states_26[2] = {
{2, arcs_26_0},
{1, arcs_26_1},
};
static arc arcs_27_0[2] = {
{83, 1},
{84, 1},
};
static arc arcs_27_1[1] = {
{85, 2},
};
static arc arcs_27_2[1] = {
{0, 2},
};
static state states_27[3] = {
{2, arcs_27_0},
{1, arcs_27_1},
{1, arcs_27_2},
};
static arc arcs_28_0[2] = {
{80, 1},
{86, 1},
};
static arc arcs_28_1[3] = {
{87, 2},
{88, 2},
{12, 3},
};
static arc arcs_28_2[5] = {
{87, 2},
{88, 2},
{12, 3},
{83, 4},
{84, 4},
};
static arc arcs_28_3[2] = {
{83, 4},
{84, 4},
};
static arc arcs_28_4[3] = {
{32, 5},
{13, 6},
{89, 5},
};
static arc arcs_28_5[1] = {
{0, 5},
};
static arc arcs_28_6[1] = {
{89, 7},
};
static arc arcs_28_7[1] = {
{15, 5},
};
static state states_28[8] = {
{2, arcs_28_0},
{3, arcs_28_1},
{5, arcs_28_2},
{2, arcs_28_3},
{3, arcs_28_4},
{1, arcs_28_5},
{1, arcs_28_6},
{1, arcs_28_7},
};
static arc arcs_29_0[1] = {
{22, 1},
};
static arc arcs_29_1[3] = {
{91, 2},
{92, 2},
{0, 1},
};
static arc arcs_29_2[1] = {
{22, 3},
};
static arc arcs_29_3[1] = {
{0, 3},
};
static state states_29[4] = {
{1, arcs_29_0},
{3, arcs_29_1},
{1, arcs_29_2},
{1, arcs_29_3},
};
static arc arcs_30_0[1] = {
{12, 1},
};
static arc arcs_30_1[3] = {
{91, 2},
{92, 2},
{0, 1},
};
static arc arcs_30_2[1] = {
{22, 3},
};
static arc arcs_30_3[1] = {
{0, 3},
};
static state states_30[4] = {
{1, arcs_30_0},
{3, arcs_30_1},
{1, arcs_30_2},
{1, arcs_30_3},
};
static arc arcs_31_0[1] = {
{90, 1},
};
static arc arcs_31_1[2] = {
{31, 2},
{0, 1},
};
static arc arcs_31_2[2] = {
{90, 1},
{0, 2},
};
static state states_31[3] = {
{1, arcs_31_0},
{2, arcs_31_1},
{2, arcs_31_2},
};
static arc arcs_32_0[1] = {
{93, 1},
};
static arc arcs_32_1[2] = {
{31, 0},
{0, 1},
};
static state states_32[2] = {
{1, arcs_32_0},
{2, arcs_32_1},
};
static arc arcs_33_0[1] = {
{22, 1},
};
static arc arcs_33_1[2] = {
{87, 0},
{0, 1},
};
static state states_33[2] = {
{1, arcs_33_0},
{2, arcs_33_1},
};
static arc arcs_34_0[2] = {
{94, 1},
{95, 1},
};
static arc arcs_34_1[1] = {
{22, 2},
};
static arc arcs_34_2[2] = {
{31, 1},
{0, 2},
};
static state states_34[3] = {
{2, arcs_34_0},
{1, arcs_34_1},
{2, arcs_34_2},
};
static arc arcs_35_0[2] = {
{96, 1},
{97, 1},
};
static arc arcs_35_1[1] = {
{22, 2},
};
static arc arcs_35_2[2] = {
{31, 1},
{0, 2},
};
static state states_35[3] = {
{2, arcs_35_0},
{1, arcs_35_1},
{2, arcs_35_2},
};
static arc arcs_36_0[2] = {
{98, 1},
{99, 1},
};
static arc arcs_36_1[1] = {
{25, 2},
};
static arc arcs_36_2[2] = {
{31, 3},
{0, 2},
};
static arc arcs_36_3[1] = {
{25, 4},
};
static arc arcs_36_4[1] = {
{0, 4},
};
static state states_36[5] = {
{2, arcs_36_0},
{1, arcs_36_1},
{2, arcs_36_2},
{1, arcs_36_3},
{1, arcs_36_4},
};
static arc arcs_37_0[8] = {
{100, 1},
{101, 1},
{102, 1},
{103, 1},
{104, 1},
{19, 1},
{18, 1},
{17, 1},
};
static arc arcs_37_1[1] = {
{0, 1},
};
static state states_37[2] = {
{8, arcs_37_0},
{1, arcs_37_1},
};
static arc arcs_38_0[2] = {
{105, 1},
{106, 1},
};
static arc arcs_38_1[1] = {
{25, 2},
};
static arc arcs_38_2[1] = {
{26, 3},
};
static arc arcs_38_3[1] = {
{27, 4},
};
static arc arcs_38_4[5] = {
{107, 1},
{108, 1},
{109, 5},
{110, 5},
{0, 4},
};
static arc arcs_38_5[1] = {
{26, 6},
};
static arc arcs_38_6[1] = {
{27, 7},
};
static arc arcs_38_7[1] = {
{0, 7},
};
static state states_38[8] = {
{2, arcs_38_0},
{1, arcs_38_1},
{1, arcs_38_2},
{1, arcs_38_3},
{5, arcs_38_4},
{1, arcs_38_5},
{1, arcs_38_6},
{1, arcs_38_7},
};
static arc arcs_39_0[2] = {
{111, 1},
{112, 1},
};
static arc arcs_39_1[1] = {
{25, 2},
};
static arc arcs_39_2[1] = {
{26, 3},
};
static arc arcs_39_3[1] = {
{27, 4},
};
static arc arcs_39_4[3] = {
{109, 5},
{110, 5},
{0, 4},
};
static arc arcs_39_5[1] = {
{26, 6},
};
static arc arcs_39_6[1] = {
{27, 7},
};
static arc arcs_39_7[1] = {
{0, 7},
};
static state states_39[8] = {
{2, arcs_39_0},
{1, arcs_39_1},
{1, arcs_39_2},
{1, arcs_39_3},
{3, arcs_39_4},
{1, arcs_39_5},
{1, arcs_39_6},
{1, arcs_39_7},
};
static arc arcs_40_0[2] = {
{113, 1},
{114, 1},
};
static arc arcs_40_1[1] = {
{64, 2},
};
static arc arcs_40_2[2] = {
{115, 3},
{116, 3},
};
static arc arcs_40_3[1] = {
{9, 4},
};
static arc arcs_40_4[1] = {
{26, 5},
};
static arc arcs_40_5[1] = {
{27, 6},
};
static arc arcs_40_6[3] = {
{109, 7},
{110, 7},
{0, 6},
};
static arc arcs_40_7[1] = {
{26, 8},
};
static arc arcs_40_8[1] = {
{27, 9},
};
static arc arcs_40_9[1] = {
{0, 9},
};
static state states_40[10] = {
{2, arcs_40_0},
{1, arcs_40_1},
{2, arcs_40_2},
{1, arcs_40_3},
{1, arcs_40_4},
{1, arcs_40_5},
{3, arcs_40_6},
{1, arcs_40_7},
{1, arcs_40_8},
{1, arcs_40_9},
};
static arc arcs_41_0[2] = {
{117, 1},
{118, 1},
};
static arc arcs_41_1[1] = {
{26, 2},
};
static arc arcs_41_2[1] = {
{27, 3},
};
static arc arcs_41_3[3] = {
{119, 4},
{120, 5},
{121, 5},
};
static arc arcs_41_4[1] = {
{26, 6},
};
static arc arcs_41_5[1] = {
{26, 7},
};
static arc arcs_41_6[1] = {
{27, 8},
};
static arc arcs_41_7[1] = {
{27, 9},
};
static arc arcs_41_8[6] = {
{119, 4},
{109, 10},
{110, 10},
{120, 5},
{121, 5},
{0, 8},
};
static arc arcs_41_9[1] = {
{0, 9},
};
static arc arcs_41_10[1] = {
{26, 11},
};
static arc arcs_41_11[1] = {
{27, 12},
};
static arc arcs_41_12[3] = {
{120, 5},
{121, 5},
{0, 12},
};
static state states_41[13] = {
{2, arcs_41_0},
{1, arcs_41_1},
{1, arcs_41_2},
{3, arcs_41_3},
{1, arcs_41_4},
{1, arcs_41_5},
{1, arcs_41_6},
{1, arcs_41_7},
{6, arcs_41_8},
{1, arcs_41_9},
{1, arcs_41_10},
{1, arcs_41_11},
{3, arcs_41_12},
};
static arc arcs_42_0[2] = {
{122, 1},
{123, 1},
};
static arc arcs_42_1[1] = {
{124, 2},
};
static arc arcs_42_2[2] = {
{31, 1},
{26, 3},
};
static arc arcs_42_3[1] = {
{27, 4},
};
static arc arcs_42_4[1] = {
{0, 4},
};
static state states_42[5] = {
{2, arcs_42_0},
{1, arcs_42_1},
{2, arcs_42_2},
{1, arcs_42_3},
{1, arcs_42_4},
};
static arc arcs_43_0[1] = {
{25, 1},
};
static arc arcs_43_1[3] = {
{91, 2},
{92, 2},
{0, 1},
};
static arc arcs_43_2[1] = {
{125, 3},
};
static arc arcs_43_3[1] = {
{0, 3},
};
static state states_43[4] = {
{1, arcs_43_0},
{3, arcs_43_1},
{1, arcs_43_2},
{1, arcs_43_3},
};
static arc arcs_44_0[2] = {
{126, 1},
{127, 1},
};
static arc arcs_44_1[2] = {
{25, 2},
{0, 1},
};
static arc arcs_44_2[3] = {
{91, 3},
{92, 3},
{0, 2},
};
static arc arcs_44_3[1] = {
{22, 4},
};
static arc arcs_44_4[1] = {
{0, 4},
};
static state states_44[5] = {
{2, arcs_44_0},
{2, arcs_44_1},
{3, arcs_44_2},
{1, arcs_44_3},
{1, arcs_44_4},
};
static arc arcs_45_0[2] = {
{3, 1},
{2, 2},
};
static arc arcs_45_1[1] = {
{0, 1},
};
static arc arcs_45_2[1] = {
{128, 3},
};
static arc arcs_45_3[1] = {
{6, 4},
};
static arc arcs_45_4[2] = {
{6, 4},
{129, 1},
};
static state states_45[5] = {
{2, arcs_45_0},
{1, arcs_45_1},
{1, arcs_45_2},
{1, arcs_45_3},
{2, arcs_45_4},
};
static arc arcs_46_0[2] = {
{130, 1},
{131, 2},
};
static arc arcs_46_1[3] = {
{105, 3},
{106, 3},
{0, 1},
};
static arc arcs_46_2[1] = {
{0, 2},
};
static arc arcs_46_3[1] = {
{130, 4},
};
static arc arcs_46_4[2] = {
{109, 5},
{110, 5},
};
static arc arcs_46_5[1] = {
{25, 2},
};
static state states_46[6] = {
{2, arcs_46_0},
{3, arcs_46_1},
{1, arcs_46_2},
{1, arcs_46_3},
{2, arcs_46_4},
{1, arcs_46_5},
};
static arc arcs_47_0[2] = {
{130, 1},
{133, 1},
};
static arc arcs_47_1[1] = {
{0, 1},
};
static state states_47[2] = {
{2, arcs_47_0},
{1, arcs_47_1},
};
static arc arcs_48_0[2] = {
{134, 1},
{135, 1},
};
static arc arcs_48_1[2] = {
{34, 2},
{26, 3},
};
static arc arcs_48_2[1] = {
{26, 3},
};
static arc arcs_48_3[1] = {
{25, 4},
};
static arc arcs_48_4[1] = {
{0, 4},
};
static state states_48[5] = {
{2, arcs_48_0},
{2, arcs_48_1},
{1, arcs_48_2},
{1, arcs_48_3},
{1, arcs_48_4},
};
static arc arcs_49_0[2] = {
{134, 1},
{135, 1},
};
static arc arcs_49_1[2] = {
{34, 2},
{26, 3},
};
static arc arcs_49_2[1] = {
{26, 3},
};
static arc arcs_49_3[1] = {
{132, 4},
};
static arc arcs_49_4[1] = {
{0, 4},
};
static state states_49[5] = {
{2, arcs_49_0},
{2, arcs_49_1},
{1, arcs_49_2},
{1, arcs_49_3},
{1, arcs_49_4},
};
static arc arcs_50_0[1] = {
{136, 1},
};
static arc arcs_50_1[3] = {
{137, 0},
{138, 0},
{0, 1},
};
static state states_50[2] = {
{1, arcs_50_0},
{3, arcs_50_1},
};
static arc arcs_51_0[1] = {
{139, 1},
};
static arc arcs_51_1[3] = {
{140, 0},
{141, 0},
{0, 1},
};
static state states_51[2] = {
{1, arcs_51_0},
{3, arcs_51_1},
};
static arc arcs_52_0[3] = {
{142, 1},
{143, 1},
{144, 2},
};
static arc arcs_52_1[1] = {
{139, 2},
};
static arc arcs_52_2[1] = {
{0, 2},
};
static state states_52[3] = {
{3, arcs_52_0},
{1, arcs_52_1},
{1, arcs_52_2},
};
static arc arcs_53_0[1] = {
{125, 1},
};
static arc arcs_53_1[2] = {
{145, 0},
{0, 1},
};
static state states_53[2] = {
{1, arcs_53_0},
{2, arcs_53_1},
};
static arc arcs_54_0[13] = {
{146, 1},
{147, 1},
{148, 1},
{149, 1},
{150, 1},
{151, 1},
{152, 1},
{115, 1},
{116, 1},
{142, 2},
{143, 2},
{153, 3},
{154, 3},
};
static arc arcs_54_1[1] = {
{0, 1},
};
static arc arcs_54_2[2] = {
{115, 1},
{116, 1},
};
static arc arcs_54_3[3] = {
{142, 1},
{143, 1},
{0, 3},
};
static state states_54[4] = {
{13, arcs_54_0},
{1, arcs_54_1},
{2, arcs_54_2},
{3, arcs_54_3},
};
static arc arcs_55_0[1] = {
{32, 1},
};
static arc arcs_55_1[1] = {
{125, 2},
};
static arc arcs_55_2[1] = {
{0, 2},
};
static state states_55[3] = {
{1, arcs_55_0},
{1, arcs_55_1},
{1, arcs_55_2},
};
static arc arcs_56_0[1] = {
{155, 1},
};
static arc arcs_56_1[2] = {
{156, 0},
{0, 1},
};
static state states_56[2] = {
{1, arcs_56_0},
{2, arcs_56_1},
};
static arc arcs_57_0[1] = {
{157, 1},
};
static arc arcs_57_1[2] = {
{158, 0},
{0, 1},
};
static state states_57[2] = {
{1, arcs_57_0},
{2, arcs_57_1},
};
static arc arcs_58_0[1] = {
{159, 1},
};
static arc arcs_58_1[2] = {
{160, 0},
{0, 1},
};
static state states_58[2] = {
{1, arcs_58_0},
{2, arcs_58_1},
};
static arc arcs_59_0[1] = {
{161, 1},
};
static arc arcs_59_1[3] = {
{162, 0},
{163, 0},
{0, 1},
};
static state states_59[2] = {
{1, arcs_59_0},
{3, arcs_59_1},
};
static arc arcs_60_0[1] = {
{164, 1},
};
static arc arcs_60_1[3] = {
{165, 0},
{166, 0},
{0, 1},
};
static state states_60[2] = {
{1, arcs_60_0},
{3, arcs_60_1},
};
static arc arcs_61_0[1] = {
{167, 1},
};
static arc arcs_61_1[5] = {
{32, 0},
{168, 0},
{169, 0},
{170, 0},
{0, 1},
};
static state states_61[2] = {
{1, arcs_61_0},
{5, arcs_61_1},
};
static arc arcs_62_0[4] = {
{165, 1},
{166, 1},
{171, 1},
{172, 2},
};
static arc arcs_62_1[1] = {
{167, 2},
};
static arc arcs_62_2[1] = {
{0, 2},
};
static state states_62[3] = {
{4, arcs_62_0},
{1, arcs_62_1},
{1, arcs_62_2},
};
static arc arcs_63_0[1] = {
{173, 1},
};
static arc arcs_63_1[3] = {
{174, 1},
{33, 2},
{0, 1},
};
static arc arcs_63_2[1] = {
{167, 3},
};
static arc arcs_63_3[1] = {
{0, 3},
};
static state states_63[4] = {
{1, arcs_63_0},
{3, arcs_63_1},
{1, arcs_63_2},
{1, arcs_63_3},
};
static arc arcs_64_0[10] = {
{13, 1},
{176, 2},
{178, 3},
{22, 4},
{181, 4},
{182, 5},
{88, 4},
{183, 4},
{184, 4},
{185, 4},
};
static arc arcs_64_1[3] = {
{48, 6},
{175, 6},
{15, 4},
};
static arc arcs_64_2[2] = {
{175, 7},
{177, 4},
};
static arc arcs_64_3[2] = {
{179, 8},
{180, 4},
};
static arc arcs_64_4[1] = {
{0, 4},
};
static arc arcs_64_5[2] = {
{182, 5},
{0, 5},
};
static arc arcs_64_6[1] = {
{15, 4},
};
static arc arcs_64_7[1] = {
{177, 4},
};
static arc arcs_64_8[1] = {
{180, 4},
};
static state states_64[9] = {
{10, arcs_64_0},
{3, arcs_64_1},
{2, arcs_64_2},
{2, arcs_64_3},
{1, arcs_64_4},
{2, arcs_64_5},
{1, arcs_64_6},
{1, arcs_64_7},
{1, arcs_64_8},
};
static arc arcs_65_0[2] = {
{25, 1},
{49, 1},
};
static arc arcs_65_1[3] = {
{186, 2},
{31, 3},
{0, 1},
};
static arc arcs_65_2[1] = {
{0, 2},
};
static arc arcs_65_3[3] = {
{25, 4},
{49, 4},
{0, 3},
};
static arc arcs_65_4[2] = {
{31, 3},
{0, 4},
};
static state states_65[5] = {
{2, arcs_65_0},
{3, arcs_65_1},
{1, arcs_65_2},
{3, arcs_65_3},
{2, arcs_65_4},
};
static arc arcs_66_0[3] = {
{13, 1},
{176, 2},
{87, 3},
};
static arc arcs_66_1[2] = {
{14, 4},
{15, 5},
};
static arc arcs_66_2[1] = {
{187, 6},
};
static arc arcs_66_3[1] = {
{22, 5},
};
static arc arcs_66_4[1] = {
{15, 5},
};
static arc arcs_66_5[1] = {
{0, 5},
};
static arc arcs_66_6[1] = {
{177, 5},
};
static state states_66[7] = {
{3, arcs_66_0},
{2, arcs_66_1},
{1, arcs_66_2},
{1, arcs_66_3},
{1, arcs_66_4},
{1, arcs_66_5},
{1, arcs_66_6},
};
static arc arcs_67_0[1] = {
{188, 1},
};
static arc arcs_67_1[2] = {
{31, 2},
{0, 1},
};
static arc arcs_67_2[2] = {
{188, 1},
{0, 2},
};
static state states_67[3] = {
{1, arcs_67_0},
{2, arcs_67_1},
{2, arcs_67_2},
};
static arc arcs_68_0[2] = {
{25, 1},
{26, 2},
};
static arc arcs_68_1[2] = {
{26, 2},
{0, 1},
};
static arc arcs_68_2[3] = {
{25, 3},
{189, 4},
{0, 2},
};
static arc arcs_68_3[2] = {
{189, 4},
{0, 3},
};
static arc arcs_68_4[1] = {
{0, 4},
};
static state states_68[5] = {
{2, arcs_68_0},
{2, arcs_68_1},
{3, arcs_68_2},
{2, arcs_68_3},
{1, arcs_68_4},
};
static arc arcs_69_0[1] = {
{26, 1},
};
static arc arcs_69_1[2] = {
{25, 2},
{0, 1},
};
static arc arcs_69_2[1] = {
{0, 2},
};
static state states_69[3] = {
{1, arcs_69_0},
{2, arcs_69_1},
{1, arcs_69_2},
};
static arc arcs_70_0[2] = {
{125, 1},
{49, 1},
};
static arc arcs_70_1[2] = {
{31, 2},
{0, 1},
};
static arc arcs_70_2[3] = {
{125, 1},
{49, 1},
{0, 2},
};
static state states_70[3] = {
{2, arcs_70_0},
{2, arcs_70_1},
{3, arcs_70_2},
};
static arc arcs_71_0[1] = {
{25, 1},
};
static arc arcs_71_1[2] = {
{31, 2},
{0, 1},
};
static arc arcs_71_2[2] = {
{25, 1},
{0, 2},
};
static state states_71[3] = {
{1, arcs_71_0},
{2, arcs_71_1},
{2, arcs_71_2},
};
static arc arcs_72_0[1] = {
{25, 1},
};
static arc arcs_72_1[4] = {
{26, 2},
{186, 3},
{31, 4},
{0, 1},
};
static arc arcs_72_2[1] = {
{25, 5},
};
static arc arcs_72_3[1] = {
{0, 3},
};
static arc arcs_72_4[2] = {
{25, 6},
{0, 4},
};
static arc arcs_72_5[3] = {
{186, 3},
{31, 7},
{0, 5},
};
static arc arcs_72_6[2] = {
{31, 4},
{0, 6},
};
static arc arcs_72_7[2] = {
{25, 8},
{0, 7},
};
static arc arcs_72_8[1] = {
{26, 9},
};
static arc arcs_72_9[1] = {
{25, 10},
};
static arc arcs_72_10[2] = {
{31, 7},
{0, 10},
};
static state states_72[11] = {
{1, arcs_72_0},
{4, arcs_72_1},
{1, arcs_72_2},
{1, arcs_72_3},
{2, arcs_72_4},
{3, arcs_72_5},
{2, arcs_72_6},
{2, arcs_72_7},
{1, arcs_72_8},
{1, arcs_72_9},
{2, arcs_72_10},
};
static arc arcs_73_0[2] = {
{190, 1},
{191, 1},
};
static arc arcs_73_1[1] = {
{22, 2},
};
static arc arcs_73_2[2] = {
{13, 3},
{26, 4},
};
static arc arcs_73_3[2] = {
{14, 5},
{15, 6},
};
static arc arcs_73_4[1] = {
{27, 7},
};
static arc arcs_73_5[1] = {
{15, 6},
};
static arc arcs_73_6[1] = {
{26, 4},
};
static arc arcs_73_7[1] = {
{0, 7},
};
static state states_73[8] = {
{2, arcs_73_0},
{1, arcs_73_1},
{2, arcs_73_2},
{2, arcs_73_3},
{1, arcs_73_4},
{1, arcs_73_5},
{1, arcs_73_6},
{1, arcs_73_7},
};
static arc arcs_74_0[3] = {
{192, 1},
{32, 2},
{33, 3},
};
static arc arcs_74_1[2] = {
{31, 4},
{0, 1},
};
static arc arcs_74_2[1] = {
{25, 5},
};
static arc arcs_74_3[1] = {
{25, 6},
};
static arc arcs_74_4[4] = {
{192, 1},
{32, 2},
{33, 3},
{0, 4},
};
static arc arcs_74_5[2] = {
{31, 7},
{0, 5},
};
static arc arcs_74_6[1] = {
{0, 6},
};
static arc arcs_74_7[2] = {
{192, 5},
{33, 3},
};
static state states_74[8] = {
{3, arcs_74_0},
{2, arcs_74_1},
{1, arcs_74_2},
{1, arcs_74_3},
{4, arcs_74_4},
{2, arcs_74_5},
{1, arcs_74_6},
{2, arcs_74_7},
};
static arc arcs_75_0[1] = {
{25, 1},
};
static arc arcs_75_1[3] = {
{186, 2},
{30, 3},
{0, 1},
};
static arc arcs_75_2[1] = {
{0, 2},
};
static arc arcs_75_3[1] = {
{25, 2},
};
static state states_75[4] = {
{1, arcs_75_0},
{3, arcs_75_1},
{1, arcs_75_2},
{1, arcs_75_3},
};
static arc arcs_76_0[2] = {
{186, 1},
{194, 1},
};
static arc arcs_76_1[1] = {
{0, 1},
};
static state states_76[2] = {
{2, arcs_76_0},
{1, arcs_76_1},
};
static arc arcs_77_0[2] = {
{113, 1},
{114, 1},
};
static arc arcs_77_1[1] = {
{64, 2},
};
static arc arcs_77_2[2] = {
{115, 3},
{116, 3},
};
static arc arcs_77_3[1] = {
{130, 4},
};
static arc arcs_77_4[2] = {
{193, 5},
{0, 4},
};
static arc arcs_77_5[1] = {
{0, 5},
};
static state states_77[6] = {
{2, arcs_77_0},
{1, arcs_77_1},
{2, arcs_77_2},
{1, arcs_77_3},
{2, arcs_77_4},
{1, arcs_77_5},
};
static arc arcs_78_0[2] = {
{105, 1},
{106, 1},
};
static arc arcs_78_1[1] = {
{132, 2},
};
static arc arcs_78_2[2] = {
{193, 3},
{0, 2},
};
static arc arcs_78_3[1] = {
{0, 3},
};
static state states_78[4] = {
{2, arcs_78_0},
{1, arcs_78_1},
{2, arcs_78_2},
{1, arcs_78_3},
};
static arc arcs_79_0[1] = {
{22, 1},
};
static arc arcs_79_1[1] = {
{0, 1},
};
static state states_79[2] = {
{1, arcs_79_0},
{1, arcs_79_1},
};
static arc arcs_80_0[2] = {
{196, 1},
{197, 1},
};
static arc arcs_80_1[2] = {
{198, 2},
{0, 1},
};
static arc arcs_80_2[1] = {
{0, 2},
};
static state states_80[3] = {
{2, arcs_80_0},
{2, arcs_80_1},
{1, arcs_80_2},
};
static arc arcs_81_0[3] = {
{80, 1},
{86, 1},
{9, 2},
};
static arc arcs_81_1[1] = {
{25, 2},
};
static arc arcs_81_2[1] = {
{0, 2},
};
static state states_81[3] = {
{3, arcs_81_0},
{1, arcs_81_1},
{1, arcs_81_2},
};
static dfa dfas[82] = {
{256, "single_input", 0, 3, states_0,
"\004\050\160\000\001\000\000\300\006\377\131\301\017\206\147\014\300\300\000\000\140\010\345\303\060"},
{257, "file_input", 0, 2, states_1,
"\204\050\160\000\001\000\000\300\006\377\131\301\017\206\147\014\300\300\000\000\140\010\345\303\060"},
{258, "eval_input", 0, 3, states_2,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{259, "decorator", 0, 7, states_3,
"\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{260, "decorators", 0, 2, states_4,
"\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{261, "decorated", 0, 3, states_5,
"\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{262, "funcdef", 0, 8, states_6,
"\000\000\060\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{263, "parameters", 0, 4, states_7,
"\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{264, "typedargslist", 0, 18, states_8,
"\000\000\100\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{265, "tfpdef", 0, 4, states_9,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{266, "varargslist", 0, 18, states_10,
"\000\000\100\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{267, "vfpdef", 0, 2, states_11,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{268, "stmt", 0, 2, states_12,
"\000\050\160\000\001\000\000\300\006\377\131\301\017\206\147\014\300\300\000\000\140\010\345\303\060"},
{269, "simple_stmt", 0, 4, states_13,
"\000\040\100\000\001\000\000\300\006\377\131\301\017\000\000\000\300\300\000\000\140\010\345\003\060"},
{270, "small_stmt", 0, 2, states_14,
"\000\040\100\000\001\000\000\300\006\377\131\301\017\000\000\000\300\300\000\000\140\010\345\003\060"},
{271, "expr_stmt", 0, 6, states_15,
"\000\040\100\000\001\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{272, "testlist_star_expr", 0, 3, states_16,
"\000\040\100\000\001\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{273, "augassign", 0, 2, states_17,
"\000\000\000\000\000\000\374\077\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{274, "del_stmt", 0, 3, states_18,
"\000\000\000\000\000\000\000\300\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{275, "pass_stmt", 0, 2, states_19,
"\000\000\000\000\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{276, "flow_stmt", 0, 2, states_20,
"\000\000\000\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\060"},
{277, "break_stmt", 0, 2, states_21,
"\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{278, "continue_stmt", 0, 2, states_22,
"\000\000\000\000\000\000\000\000\000\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{279, "return_stmt", 0, 3, states_23,
"\000\000\000\000\000\000\000\000\000\060\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{280, "yield_stmt", 0, 2, states_24,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\060"},
{281, "raise_stmt", 0, 5, states_25,
"\000\000\000\000\000\000\000\000\000\300\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{282, "import_stmt", 0, 2, states_26,
"\000\000\000\000\000\000\000\000\000\000\131\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{283, "import_name", 0, 3, states_27,
"\000\000\000\000\000\000\000\000\000\000\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{284, "import_from", 0, 8, states_28,
"\000\000\000\000\000\000\000\000\000\000\101\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{285, "import_as_name", 0, 4, states_29,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{286, "dotted_as_name", 0, 4, states_30,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{287, "import_as_names", 0, 3, states_31,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{288, "dotted_as_names", 0, 2, states_32,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{289, "dotted_name", 0, 2, states_33,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{290, "global_stmt", 0, 3, states_34,
"\000\000\000\000\000\000\000\000\000\000\000\300\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{291, "nonlocal_stmt", 0, 3, states_35,
"\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000"},
{292, "assert_stmt", 0, 5, states_36,
"\000\000\000\000\000\000\000\000\000\000\000\000\014\000\000\000\000\000\000\000\000\000\000\000\000"},
{293, "compound_stmt", 0, 2, states_37,
"\000\010\060\000\000\000\000\000\000\000\000\000\000\206\147\014\000\000\000\000\000\000\000\300\000"},
{294, "if_stmt", 0, 8, states_38,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000"},
{295, "while_stmt", 0, 8, states_39,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\200\001\000\000\000\000\000\000\000\000\000\000"},
{296, "for_stmt", 0, 10, states_40,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000"},
{297, "try_stmt", 0, 13, states_41,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\140\000\000\000\000\000\000\000\000\000\000"},
{298, "with_stmt", 0, 5, states_42,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\000\000\000\000\000\000\000\000\000"},
{299, "with_item", 0, 4, states_43,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{300, "except_clause", 0, 5, states_44,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\300\000\000\000\000\000\000\000\000\000"},
{301, "suite", 0, 5, states_45,
"\004\040\100\000\001\000\000\300\006\377\131\301\017\000\000\000\300\300\000\000\140\010\345\003\060"},
{302, "test", 0, 6, states_46,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{303, "test_nocond", 0, 2, states_47,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{304, "lambdef", 0, 5, states_48,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\300\000\000\000\000\000\000\000\000"},
{305, "lambdef_nocond", 0, 5, states_49,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\300\000\000\000\000\000\000\000\000"},
{306, "or_test", 0, 2, states_50,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\300\000\000\140\010\345\003\000"},
{307, "and_test", 0, 2, states_51,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\300\000\000\140\010\345\003\000"},
{308, "not_test", 0, 3, states_52,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\300\000\000\140\010\345\003\000"},
{309, "comparison", 0, 2, states_53,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{310, "comp_op", 0, 4, states_54,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\000\000\300\374\007\000\000\000\000\000"},
{311, "star_expr", 0, 3, states_55,
"\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{312, "expr", 0, 2, states_56,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{313, "xor_expr", 0, 2, states_57,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{314, "and_expr", 0, 2, states_58,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{315, "shift_expr", 0, 2, states_59,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{316, "arith_expr", 0, 2, states_60,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{317, "term", 0, 2, states_61,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{318, "factor", 0, 3, states_62,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{319, "power", 0, 4, states_63,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\345\003\000"},
{320, "atom", 0, 9, states_64,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\345\003\000"},
{321, "testlist_comp", 0, 5, states_65,
"\000\040\100\000\001\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{322, "trailer", 0, 7, states_66,
"\000\040\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\001\000\000"},
{323, "subscriptlist", 0, 3, states_67,
"\000\040\100\004\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{324, "subscript", 0, 5, states_68,
"\000\040\100\004\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{325, "sliceop", 0, 3, states_69,
"\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{326, "exprlist", 0, 3, states_70,
"\000\040\100\000\001\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\140\010\345\003\000"},
{327, "testlist", 0, 3, states_71,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{328, "dictorsetmaker", 0, 11, states_72,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{329, "classdef", 0, 8, states_73,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\300\000"},
{330, "arglist", 0, 8, states_74,
"\000\040\100\000\003\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{331, "argument", 0, 4, states_75,
"\000\040\100\000\000\000\000\000\000\000\000\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
{332, "comp_iter", 0, 2, states_76,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\006\006\000\000\000\000\000\000\000\000\000\000"},
{333, "comp_for", 0, 6, states_77,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000"},
{334, "comp_if", 0, 4, states_78,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000"},
{335, "encoding_decl", 0, 2, states_79,
"\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{336, "yield_expr", 0, 3, states_80,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\060"},
{337, "yield_arg", 0, 3, states_81,
"\000\040\100\000\000\000\000\000\000\000\101\001\000\000\000\000\300\300\000\000\140\010\345\003\000"},
};
static label labels[199] = {
{0, "EMPTY"},
{256, 0},
{4, 0},
{269, 0},
{293, 0},
{257, 0},
{268, 0},
{0, 0},
{258, 0},
{327, 0},
{259, 0},
{49, 0},
{289, 0},
{7, 0},
{330, 0},
{8, 0},
{260, 0},
{261, 0},
{329, 0},
{262, 0},
{1, "def"},
{1, "apibrėžti"},
{1, 0},
{263, 0},
{50, 0},
{302, 0},
{11, 0},
{301, 0},
{264, 0},
{265, 0},
{22, 0},
{12, 0},
{16, 0},
{35, 0},
{266, 0},
{267, 0},
{270, 0},
{13, 0},
{271, 0},
{274, 0},
{275, 0},
{276, 0},
{282, 0},
{290, 0},
{291, 0},
{292, 0},
{272, 0},
{273, 0},
{336, 0},
{311, 0},
{36, 0},
{37, 0},
{38, 0},
{39, 0},
{40, 0},
{41, 0},
{42, 0},
{43, 0},
{44, 0},
{45, 0},
{46, 0},
{48, 0},
{1, "del"},
{1, "pan"},
{326, 0},
{1, "pass"},
{1, "pereiti"},
{277, 0},
{278, 0},
{279, 0},
{281, 0},
{280, 0},
{1, "break"},
{1, "pertrauka"},
{1, "continue"},
{1, "tęsti"},
{1, "return"},
{1, "sugrįžti"},
{1, "raise"},
{1, "kelti"},
{1, "from"},
{283, 0},
{284, 0},
{1, "import"},
{1, "importas"},
{288, 0},
{1, "nuo"},
{23, 0},
{51, 0},
{287, 0},
{285, 0},
{1, "as"},
{1, "kaip"},
{286, 0},
{1, "global"},
{1, "globalinis"},
{1, "nonlocal"},
{1, "nelokaliosiomis"},
{1, "assert"},
{1, "teigti"},
{294, 0},
{295, 0},
{296, 0},
{297, 0},
{298, 0},
{1, "if"},
{1, "jei"},
{1, "elif"},
{1, "kijei"},
{1, "else"},
{1, "kitas"},
{1, "while"},
{1, "kol"},
{1, "for"},
{1, "dėl"},
{1, "in"},
{1, "iš"},
{1, "try"},
{1, "bandyti"},
{300, 0},
{1, "finally"},
{1, "pagaliau"},
{1, "with"},
{1, "su"},
{299, 0},
{312, 0},
{1, "except"},
{1, "išskyrus"},
{5, 0},
{6, 0},
{306, 0},
{304, 0},
{303, 0},
{305, 0},
{1, "lambda"},
{1, "liambda"},
{307, 0},
{1, "or"},
{1, "arba"},
{308, 0},
{1, "and"},
{1, "ir"},
{1, "not"},
{1, "nebūtų"},
{309, 0},
{310, 0},
{20, 0},
{21, 0},
{27, 0},
{30, 0},
{29, 0},
{28, 0},
{28, 0},
{1, "is"},
{1, "yra"},
{313, 0},
{18, 0},
{314, 0},
{32, 0},
{315, 0},
{19, 0},
{316, 0},
{33, 0},
{34, 0},
{317, 0},
{14, 0},
{15, 0},
{318, 0},
{17, 0},
{24, 0},
{47, 0},
{31, 0},
{319, 0},
{320, 0},
{322, 0},
{321, 0},
{9, 0},
{10, 0},
{25, 0},
{328, 0},
{26, 0},
{2, 0},
{3, 0},
{1, "None"},
{1, "True"},
{1, "False"},
{333, 0},
{323, 0},
{324, 0},
{325, 0},
{1, "class"},
{1, "rūšis"},
{331, 0},
{332, 0},
{334, 0},
{335, 0},
{1, "yield"},
{1, "duoti"},
{337, 0},
};
grammar _PyParser_Grammar = {
82,
dfas,
{199, labels},
256
};
|
ericsaba/geoNotes
|
Notes/Notes/geoNotes-Bridging-Header.h
|
<filename>Notes/Notes/geoNotes-Bridging-Header.h
//
// geoNotes-Bridging-Header.h
// geoNotes
//
// Created by <NAME> on 2/29/16.
// Copyright © 2016 <NAME>. All rights reserved.
//
#import <Parse.h>
#import <Bolts.h>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.