hexsha stringlengths 40 40 | size int64 5 1.05M | ext stringclasses 588
values | lang stringclasses 305
values | max_stars_repo_path stringlengths 3 363 | max_stars_repo_name stringlengths 5 118 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 10 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringdate 2015-01-01 00:00:35 2022-03-31 23:43:49 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 12:37:38 2022-03-31 23:59:52 ⌀ | max_issues_repo_path stringlengths 3 363 | max_issues_repo_name stringlengths 5 118 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 10 | max_issues_count float64 1 134k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 363 | max_forks_repo_name stringlengths 5 135 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 10 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringdate 2015-01-01 00:01:02 2022-03-31 23:27:27 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 08:55:07 2022-03-31 23:59:24 ⌀ | content stringlengths 5 1.05M | avg_line_length float64 1.13 1.04M | max_line_length int64 1 1.05M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
57543853b05dc6257b78a72068c9b16766e20acc | 5,196 | h | C | MdePkg/Include/Register/Intel/SmramSaveStateMap.h | ray-linn/myedk2 | b6a8574cb6ba49044fe43a748b98f31d417ece07 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
] | null | null | null | MdePkg/Include/Register/Intel/SmramSaveStateMap.h | ray-linn/myedk2 | b6a8574cb6ba49044fe43a748b98f31d417ece07 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
] | null | null | null | MdePkg/Include/Register/Intel/SmramSaveStateMap.h | ray-linn/myedk2 | b6a8574cb6ba49044fe43a748b98f31d417ece07 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
] | null | null | null | /** @file
SMRAM Save State Map Definitions.
SMRAM Save State Map definitions based on contents of the
Intel(R) 64 and IA-32 Architectures Software Developer's Manual
Volume 3C, Section 34.4 SMRAM
Volume 3C, Section 34.5 SMI Handler Execution Environment
Volume 3C, Section 34.7 Managing Synchronous and Asynchronous SMIs
Copyright (c) 2015 - 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef __INTEL_SMRAM_SAVE_STATE_MAP_H__
#define __INTEL_SMRAM_SAVE_STATE_MAP_H__
///
/// Default SMBASE address
///
#define SMM_DEFAULT_SMBASE 0x30000
///
/// Offset of SMM handler from SMBASE
///
#define SMM_HANDLER_OFFSET 0x8000
///
/// Offset of SMRAM Save State Map from SMBASE
///
#define SMRAM_SAVE_STATE_MAP_OFFSET 0xfc00
#pragma pack (1)
///
/// 32-bit SMRAM Save State Map
///
typedef struct {
UINT8 Reserved[0x200]; // 7c00h
// Padded an extra 0x200 bytes so 32-bit and 64-bit
// SMRAM Save State Maps are the same size
UINT8 Reserved1[0xf8]; // 7e00h
UINT32 SMBASE; // 7ef8h
UINT32 SMMRevId; // 7efch
UINT16 IORestart; // 7f00h
UINT16 AutoHALTRestart; // 7f02h
UINT8 Reserved2[0x9C]; // 7f08h
UINT32 IOMemAddr; // 7fa0h
UINT32 IOMisc; // 7fa4h
UINT32 _ES; // 7fa8h
UINT32 _CS; // 7fach
UINT32 _SS; // 7fb0h
UINT32 _DS; // 7fb4h
UINT32 _FS; // 7fb8h
UINT32 _GS; // 7fbch
UINT32 Reserved3; // 7fc0h
UINT32 _TR; // 7fc4h
UINT32 _DR7; // 7fc8h
UINT32 _DR6; // 7fcch
UINT32 _EAX; // 7fd0h
UINT32 _ECX; // 7fd4h
UINT32 _EDX; // 7fd8h
UINT32 _EBX; // 7fdch
UINT32 _ESP; // 7fe0h
UINT32 _EBP; // 7fe4h
UINT32 _ESI; // 7fe8h
UINT32 _EDI; // 7fech
UINT32 _EIP; // 7ff0h
UINT32 _EFLAGS; // 7ff4h
UINT32 _CR3; // 7ff8h
UINT32 _CR0; // 7ffch
} SMRAM_SAVE_STATE_MAP32;
///
/// 64-bit SMRAM Save State Map
///
typedef struct {
UINT8 Reserved1[0x1d0]; // 7c00h
UINT32 GdtBaseHiDword; // 7dd0h
UINT32 LdtBaseHiDword; // 7dd4h
UINT32 IdtBaseHiDword; // 7dd8h
UINT8 Reserved2[0xc]; // 7ddch
UINT64 IO_EIP; // 7de8h
UINT8 Reserved3[0x50]; // 7df0h
UINT32 _CR4; // 7e40h
UINT8 Reserved4[0x48]; // 7e44h
UINT32 GdtBaseLoDword; // 7e8ch
UINT32 Reserved5; // 7e90h
UINT32 IdtBaseLoDword; // 7e94h
UINT32 Reserved6; // 7e98h
UINT32 LdtBaseLoDword; // 7e9ch
UINT8 Reserved7[0x38]; // 7ea0h
UINT64 EptVmxControl; // 7ed8h
UINT32 EnEptVmxControl; // 7ee0h
UINT8 Reserved8[0x14]; // 7ee4h
UINT32 SMBASE; // 7ef8h
UINT32 SMMRevId; // 7efch
UINT16 IORestart; // 7f00h
UINT16 AutoHALTRestart; // 7f02h
UINT8 Reserved9[0x18]; // 7f04h
UINT64 _R15; // 7f1ch
UINT64 _R14;
UINT64 _R13;
UINT64 _R12;
UINT64 _R11;
UINT64 _R10;
UINT64 _R9;
UINT64 _R8;
UINT64 _RAX; // 7f5ch
UINT64 _RCX;
UINT64 _RDX;
UINT64 _RBX;
UINT64 _RSP;
UINT64 _RBP;
UINT64 _RSI;
UINT64 _RDI;
UINT64 IOMemAddr; // 7f9ch
UINT32 IOMisc; // 7fa4h
UINT32 _ES; // 7fa8h
UINT32 _CS;
UINT32 _SS;
UINT32 _DS;
UINT32 _FS;
UINT32 _GS;
UINT32 _LDTR; // 7fc0h
UINT32 _TR;
UINT64 _DR7; // 7fc8h
UINT64 _DR6;
UINT64 _RIP; // 7fd8h
UINT64 IA32_EFER; // 7fe0h
UINT64 _RFLAGS; // 7fe8h
UINT64 _CR3; // 7ff0h
UINT64 _CR0; // 7ff8h
} SMRAM_SAVE_STATE_MAP64;
///
/// Union of 32-bit and 64-bit SMRAM Save State Maps
///
typedef union {
SMRAM_SAVE_STATE_MAP32 x86;
SMRAM_SAVE_STATE_MAP64 x64;
} SMRAM_SAVE_STATE_MAP;
///
/// Minimum SMM Revision ID that supports IOMisc field in SMRAM Save State Map
///
#define SMRAM_SAVE_STATE_MIN_REV_ID_IOMISC 0x30004
///
/// SMRAM Save State Map IOMisc I/O Length Values
///
#define SMM_IO_LENGTH_BYTE 0x01
#define SMM_IO_LENGTH_WORD 0x02
#define SMM_IO_LENGTH_DWORD 0x04
///
/// SMRAM Save State Map IOMisc I/O Instruction Type Values
///
#define SMM_IO_TYPE_IN_IMMEDIATE 0x9
#define SMM_IO_TYPE_IN_DX 0x1
#define SMM_IO_TYPE_OUT_IMMEDIATE 0x8
#define SMM_IO_TYPE_OUT_DX 0x0
#define SMM_IO_TYPE_INS 0x3
#define SMM_IO_TYPE_OUTS 0x2
#define SMM_IO_TYPE_REP_INS 0x7
#define SMM_IO_TYPE_REP_OUTS 0x6
///
/// SMRAM Save State Map IOMisc structure
///
typedef union {
struct {
UINT32 SmiFlag : 1;
UINT32 Length : 3;
UINT32 Type : 4;
UINT32 Reserved1 : 8;
UINT32 Port : 16;
} Bits;
UINT32 Uint32;
} SMRAM_SAVE_STATE_IOMISC;
#pragma pack ()
#endif
| 28.086486 | 80 | 0.582564 |
70c3c3201376cd3b475b04bf8cf0f990e30831f8 | 90 | h | C | lib/PaxHeaders.2308045/conntrack-private.h | cuijianming/ovs-2.13.6 | e7fdf06d6c26d280b25bdf235146ae007cd2208c | [
"Apache-2.0"
] | null | null | null | lib/PaxHeaders.2308045/conntrack-private.h | cuijianming/ovs-2.13.6 | e7fdf06d6c26d280b25bdf235146ae007cd2208c | [
"Apache-2.0"
] | null | null | null | lib/PaxHeaders.2308045/conntrack-private.h | cuijianming/ovs-2.13.6 | e7fdf06d6c26d280b25bdf235146ae007cd2208c | [
"Apache-2.0"
] | null | null | null | 30 mtime=1639777086.550355983
30 atime=1639777086.550355983
30 ctime=1639777127.860355983
| 22.5 | 29 | 0.866667 |
02dd482f9a3f1e9839bddc04f788b3cc13a76acc | 3,134 | h | C | index.h | maxlor/psearch | ab0b69780990bbc808b75cf5152d986e45f0ddfd | [
"BSD-2-Clause"
] | 1 | 2021-05-16T16:57:01.000Z | 2021-05-16T16:57:01.000Z | index.h | maxlor/psearch | ab0b69780990bbc808b75cf5152d986e45f0ddfd | [
"BSD-2-Clause"
] | 1 | 2021-06-20T16:07:55.000Z | 2021-07-02T20:01:52.000Z | index.h | maxlor/psearch | ab0b69780990bbc808b75cf5152d986e45f0ddfd | [
"BSD-2-Clause"
] | null | null | null | #ifndef INDEX_H
#define INDEX_H
#include <fstream>
#include <set>
#include <string>
class Index {
public:
enum Fieldname {
Pkgname = 0, Origin, Prefix, Desc, Descpath, Maintainer, Categories
};
/**
* Opens the index file named in filename, so that it can be parsed
* through parse_line() calls later.
*
* @param filename file to be opened as index file.
* @param unique_origin If true, a row which has the same origin as
* a previous row will be skipped.
* @param need_descpath Whether the path to the description file needs
* to be parsed from the index file later.
* @param need_maintainer Whether the maintainer field needs to be
* parsed from the index file later. Implies
* need_descpath.
* @param need_categories Whether the categories field needs to be
* parsed from the index file later. Implies
* need_maintainer and need_descpath.
*/
Index(const std::string filename, bool unique_origin,
bool need_descpath, bool need_maintainer, bool need_categories);
~Index();
/**
* Is the index file readable? Use this after creating the object to
* check whether opening the file in the constructor worked.
*/
bool readable();
/**
* Read a line from the index file.
*
* @return true if the line could be read, false otherwise.
*/
bool read_line();
/**
* Parse a line from the index file.
*
* @return true if the line could be parsed, false otherwise.
*/
bool parse_line();
///@{
/**
* Return a fieldname. The fields maintainer() and categories() are only
* available if need_categories was true in the constructor. descpath()
* is only available if need_descpath or need_categories were true in the
* constructor.
*/
std::string pkgname() const;
std::string origin() const;
std::string prefix() const;
std::string desc() const;
std::string descpath() const;
std::string maintainer() const;
///@}
/**
* Categories this entry belongs to.
*/
std::set<std::string> categories();
/**
* Prints the entry for the currently parsed line.
*
* @param flag_name If true, print package name instead of path.
* @param flag_maintainer If true, print the maintainer's email
* address instead of the package description.
* @param flag_long If true, print pkg-descr file too.
*/
void print_line(bool flag_name, bool flag_maintainer, bool flag_long);
private:
std::ifstream _file;
std::string _line;
bool _unique_origin;
unsigned int _fields_num;
std::string _fields[7];
std::set<std::string> _origins;
};
inline std::string Index::pkgname() const { return _fields[Pkgname]; }
inline std::string Index::origin() const { return _fields[Origin]; }
inline std::string Index::prefix() const { return _fields[Prefix]; }
inline std::string Index::desc() const { return _fields[Desc]; }
inline std::string Index::descpath() const { return _fields[Descpath]; }
inline std::string Index::maintainer() const { return _fields[Maintainer]; }
#endif
| 30.427184 | 76 | 0.668794 |
f1cf42caa6333c08846ab17e6a7aabe631794513 | 816 | h | C | src/Framework/Project/ProjectManager.h | xcasadio/casaengine | 19e34c0457265435c28667df7f2e5c137d954b98 | [
"MIT"
] | null | null | null | src/Framework/Project/ProjectManager.h | xcasadio/casaengine | 19e34c0457265435c28667df7f2e5c137d954b98 | [
"MIT"
] | null | null | null | src/Framework/Project/ProjectManager.h | xcasadio/casaengine | 19e34c0457265435c28667df7f2e5c137d954b98 | [
"MIT"
] | null | null | null |
#ifndef PROJECTMANAGER_H_
#define PROJECTMANAGER_H_
#include "CA_Export.h"
#include <string>
#include "Parsers\Xml\tinyxml2.h"
namespace CasaEngine
{
/**
*
*/
class CA_EXPORT ProjectManager
{
public:
ProjectManager();
~ProjectManager();
void LoadProject(const char *fileName_);
void SaveProject(const char *fileName_);
std::string ProjectPath() const;
private:
void LoadConfig(const tinyxml2::XMLElement* node_);
void LoadEngineSettings(const tinyxml2::XMLElement* node_);
std::string m_ProjectPath;
};
// #ifdef EDITOR
//
// //Used by the C++/Cli Wrapper
// extern "C" __declspec(dllexport) ProjectManager* ProjectManager_New();
// extern "C" __declspec(dllexport) void ProjectManager_Delete(ProjectManager* package_);
//
// #endif // EDITOR
}
#endif // PROJECTMANAGER_H_
| 18.545455 | 90 | 0.723039 |
ccbd114ea0fc6943f0958caacdc4d4d91cd0f77f | 368 | h | C | Interpreter.h | KalbinVV/PyDesert | a17c410ac68d4b83ae0a2a4ab17787cbfd39a483 | [
"Zlib"
] | null | null | null | Interpreter.h | KalbinVV/PyDesert | a17c410ac68d4b83ae0a2a4ab17787cbfd39a483 | [
"Zlib"
] | null | null | null | Interpreter.h | KalbinVV/PyDesert | a17c410ac68d4b83ae0a2a4ab17787cbfd39a483 | [
"Zlib"
] | null | null | null | #ifndef INTERPRETER_H_INCLUDED
#define INTERPRETER_H_INCLUDED
#include <sstream>
#include <vector>
#include <string>
class Interpreter{
public:
Interpreter();
void run(std::string);
void clean();
std::string getOutput();
private:
std::stringstream output;
const std::vector<std::string> prohibitedWords;
};
#endif // INTERPRETER_H_INCLUDED
| 17.52381 | 51 | 0.720109 |
2f17d09b916e7f06526dacbc1b363faf7215230a | 9,330 | c | C | src/linux_xlib.c | burito/dpb | 04b44570962d17f6d332c58eac2edcfa0e388c86 | [
"Zlib"
] | null | null | null | src/linux_xlib.c | burito/dpb | 04b44570962d17f6d332c58eac2edcfa0e388c86 | [
"Zlib"
] | null | null | null | src/linux_xlib.c | burito/dpb | 04b44570962d17f6d332c58eac2edcfa0e388c86 | [
"Zlib"
] | null | null | null | /*
Copyright (c) 2012 Daniel Burke
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
*/
#include <X11/Xutil.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/extensions/XInput2.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <unistd.h>
#include "log.h"
#include "global.h"
///////////////////////////////////////////////////////////////////////////////
//////// Public Interface to the rest of the program
///////////////////////////////////////////////////////////////////////////////
int win_width = 0; /* used for switching from fullscreen back to window */
int win_height = 0;
int win_x = 0;
int win_y = 0;
int fullscreen=0;
int fullscreen_toggle=0;
///////////////////////////////////////////////////////////////////////////////
//////// X11 OpenGL window setup
///////////////////////////////////////////////////////////////////////////////
extern unsigned char _binary_lin_icon_head_start[];
Display *display;
Window window;
static int screen;
XSetWindowAttributes xwin_attr;
Cursor cursor_none;
int opcode; // for XInput
int oldx=20, oldy=20;
void gfx_resize(void);
//char* x11_error(unsigned long result);
//char* x11_opcode(unsigned long opcode);
#include "x11_helper.c"
int x11_error_handler(Display * dpy, XErrorEvent * error)
{
log_error("X11: %s() = %s",
x11_opcode(error->request_code),
x11_error(error->error_code)
);
return 1;
}
static Atom atom_net_wm_state;
static Atom atom_net_wm_state_fullscreen;
static XEvent xevent_fullscreen;
void x11_fullscreen_init(void)
{
atom_net_wm_state = XInternAtom(display, "_NET_WM_STATE", True);
if(atom_net_wm_state == None)
{
log_warning("_NET_WM_STATE");
return;
}
atom_net_wm_state_fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", True);
if(atom_net_wm_state_fullscreen == None)
{
log_debug("_NET_WM_STATE_FULLSCREEN");
return;
}
xevent_fullscreen.type = ClientMessage;
xevent_fullscreen.xclient.window = window;
xevent_fullscreen.xclient.message_type = atom_net_wm_state;
xevent_fullscreen.xclient.format = 32;
xevent_fullscreen.xclient.data.l[0] = 1;
xevent_fullscreen.xclient.data.l[1] = atom_net_wm_state_fullscreen;
xevent_fullscreen.xclient.data.l[2] = 0;
xevent_fullscreen.xclient.data.l[3] = 0;
xevent_fullscreen.xclient.data.l[4] = 0;
}
static void x11_window(void)
{
XSetErrorHandler(x11_error_handler);
int result;
xwin_attr.override_redirect = False;
int screen = DefaultScreen(display);
window = XCreateWindow(display, RootWindow(display, screen),
0, 0, vid_width, vid_height, 0,
DefaultDepth(display, screen), InputOutput, DefaultVisual(display, screen),
CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect,
&xwin_attr);
// Set the icon
Atom net_wm_icon = XInternAtom(display, "_NET_WM_ICON", False);
Atom cardinal = XInternAtom(display, "CARDINAL", False);
int icon_length = 2 + 256 * 256;
result = XChangeProperty(display, window, net_wm_icon, cardinal, 32,
PropModeReplace, _binary_lin_icon_head_start, icon_length);
if(result != 1)log_error("XChangeProperty() = %s", x11_error(result));
// I will handle quit messages
Atom delwm = XInternAtom(display, "WM_DELETE_WINDOW", False);
result = XSetWMProtocols(display, window, &delwm, 1);
if(result != 1)log_error("XSetWMProtocols() = %s", x11_error(result));
// My window shall be named...
XSetStandardProperties(display, window, binary_name, binary_name, None, NULL, 0, NULL);
// XSetWMProperties(display, window, binary_name, binary_name, NULL, 0, NULL, NULL, NULL);
XMapRaised(display, window);
gfx_resize();
}
int ignore_mouse = 0;
static void x11_init(void)
{
memset(keys, 0, KEYMAX);
memset(mouse, 0, 3);
display = XOpenDisplay(0);
if(display == NULL)
{
log_error("XOpenDisplay(), if debugging ensure the DISPLAY "
"environment variable is passed to the program");
exit(1);
}
Screen *screen_ptr = DefaultScreenOfDisplay(display);
sys_width = XWidthOfScreen(screen_ptr);
sys_height = XHeightOfScreen(screen_ptr);
memset(&xwin_attr, 0, sizeof(XSetWindowAttributes));
screen = DefaultScreen(display);
xwin_attr.colormap = XCreateColormap(display,
RootWindow(display, screen), DefaultVisual(display, screen), AllocNone);
xwin_attr.event_mask = ExposureMask | StructureNotifyMask |
ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
KeyPressMask | KeyReleaseMask;
x11_window();
static char buf[] = { 0,0,0,0,0,0,0,0 };
XColor black = { .red=0, .green=0, .blue=0 };
Pixmap bitmap = XCreateBitmapFromData(display, window, buf, 2, 2);
cursor_none = XCreatePixmapCursor(display, bitmap, bitmap,
&black, &black, 0, 0);
int event, error;
if(!XQueryExtension(display,"XInputExtension", &opcode, &event, &error))
{
log_warning("X Input extension not available");
return;
}
x11_fullscreen_init();
}
static void handle_events(void)
{
int deltax;
int deltay;
XEvent event;
XIDeviceEvent *e;
double value;
struct sys_event received_event;
mickey_x = mickey_y = 0;
float x=0, y=0;
int pos=0;
while(XPending(display) > 0)
{
int bit = 0;
XNextEvent(display, &event);
if(XGetEventData(display, &event.xcookie))
{
XGenericEventCookie *c = &event.xcookie;
e = c->data;
if(c->extension == opcode && c->type == GenericEvent)
switch(c->evtype) {
// case XI_RawMotion:
// print_rawmotion(e);
// break;
// case XI_ButtonPress:
case XI_Motion:
// case XI_KeyPress:
pos = 0;
for(int i=0; i < e->valuators.mask_len * 8; i++)
if(XIMaskIsSet(e->valuators.mask, i))
{
value = e->valuators.values[pos];
log_debug("%d -- %f --",pos, value);
switch(i){
case 0:
if(value > 1.0)
{
x=value;
pos++;
log_debug("%#+f",x);
}
break;
case 1:
if(value > 1.0)
{
y=value;
pos++;
log_debug("\t\t%f",y);
}
break;
default:
log_debug("%d -- %f --",pos, value);
break;
}
}
log_debug("%f\t%f\t--",x, y);
break;
default:
break;
}
XFreeEventData(display, &event.xcookie);
}
else
switch(event.type) {
case ConfigureNotify:
vid_width = event.xconfigure.width;
vid_height = event.xconfigure.height;
gfx_resize();
break;
case ClientMessage:
killme=1;
break;
/* Mouse */
case ButtonPress:
switch(event.xbutton.button) {
case 1: mouse[0]=1; break;
case 2: mouse[1]=1; break;
case 3: mouse[2]=1; break;
}
// log_debug("mouse[] %d, @ %d", foo, (int)event.xbutton.time);
break;
case ButtonRelease:
switch(event.xbutton.button) {
case 1: mouse[0]=0; break;
case 2: mouse[1]=0; break;
case 3: mouse[2]=0; break;
}
break;
case MotionNotify:
// log_debug("x=%d, y=%d", event.xmotion.x_root,
// event.xmotion.y_root);
if(ignore_mouse)
if(event.xmotion.x == vid_width/2)
{
ignore_mouse = 0;
break;
}
deltax = mouse_x - event.xmotion.x;
mouse_x = event.xmotion.x;
mickey_x += deltax;
deltay = mouse_y - event.xmotion.y;
mouse_y = event.xmotion.y;
mickey_y += deltay;
break;
/* keyboard */
case KeyPress:
// log_debug("keyd[%d] @ %d", event.xkey.keycode, (int)event.xkey.time);
if(event.xkey.keycode == KEY_F11)
{
fullscreen_toggle=1;
return;
}
bit = 1;
__attribute__((fallthrough));
case KeyRelease:
{
int code = event.xkey.keycode;
if( code < KEYMAX )
keys[code] = bit;
received_event.type = bit ? EVENT_KEY_DOWN : EVENT_KEY_UP;
received_event.keycode = code;
sys_event_write(received_event);
}
break;
}
}
if(fullscreen_toggle)
{
fullscreen_toggle = 0;
fullscreen = !fullscreen;
if( fullscreen )
{
xevent_fullscreen.xclient.data.l[0] = 1;
XSendEvent(display, RootWindow(display, screen), False, SubstructureNotifyMask | SubstructureRedirectMask, &xevent_fullscreen);
}
else
{
xevent_fullscreen.xclient.data.l[0] = 0;
XSendEvent(display, RootWindow(display, screen), False, SubstructureNotifyMask | SubstructureRedirectMask, &xevent_fullscreen);
}
}
}
static void x11_end(void)
{
XDestroyWindow(display, window);
XCloseDisplay(display);
}
int main(int argc, char* argv[])
{
log_init();
sys_event_init();
log_info("Platform : Xlib");
x11_init();
int ret = main_init(argc, argv);
if(ret)
{
log_info("Shutdown on : Init Failed");
x11_end();
return ret;
}
while(!killme)
{
handle_events();
main_loop();
sys_event_init();
}
main_end();
x11_end();
return 0;
}
| 23.923077 | 130 | 0.667203 |
a374dd35688dc7d4d8b53d822770672d08d212d4 | 1,244 | h | C | Headers/Final Cut Pro/PEProviderSettingsWindow.h | CommandPost/FinalCutProFrameworks | d98b00ff0c84af80942d71514e9238d624aca50a | [
"MIT"
] | 3 | 2020-11-19T10:04:02.000Z | 2021-10-02T17:25:21.000Z | Headers/Final Cut Pro/PEProviderSettingsWindow.h | CommandPost/FinalCutProFrameworks | d98b00ff0c84af80942d71514e9238d624aca50a | [
"MIT"
] | null | null | null | Headers/Final Cut Pro/PEProviderSettingsWindow.h | CommandPost/FinalCutProFrameworks | d98b00ff0c84af80942d71514e9238d624aca50a | [
"MIT"
] | null | null | null | //
// Generated by class-dump 3.5 (64 bit) (Debug version compiled Mar 11 2021 20:53:35).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#import <AppKit/NSWindowController.h>
#import "NSAnimationDelegate-Protocol.h"
@class FFSettingsModule, NSButton, NSString, NSView;
@interface PEProviderSettingsWindow : NSWindowController <NSAnimationDelegate>
{
FFSettingsModule *module;
NSView *settingsView;
NSButton *automaticCustomSettingsButtons;
BOOL _undoSetup;
BOOL _ignoreModuleFrameChanges;
}
- (void)changeAutomaticCustomSettings:(id)arg1;
- (void)didEndSheet:(id)arg1 returnCode:(int)arg2 contextInfo:(void *)arg3;
- (void)cancelSettings:(id)arg1;
- (void)acceptSettings:(id)arg1;
- (BOOL)presentError:(id)arg1;
- (void)runSheetForWindow:(id)arg1;
- (void)moduleViewFrameChanged:(id)arg1;
- (void)animationDidEnd:(id)arg1;
@property(retain) FFSettingsModule *module;
- (void)_resizeToFitModule;
- (void)_setupAutomaticCustomSettingsButton;
- (void)dealloc;
- (id)initWithSettingsModule:(id)arg1;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
| 28.272727 | 90 | 0.763666 |
2b0d89644575cc2e6ed51d46281e06ff7107201b | 1,276 | c | C | _archive/BASS/bass-1.0.7/innd.c | indraai/IndraMind | b1110b75b4e41891b32c0100729c0ee97ba019a1 | [
"MIT"
] | 7 | 2021-01-15T23:46:24.000Z | 2021-10-16T00:48:00.000Z | _archive/BASS/bass-1.0.7/innd.c | indraai/IndraMind | b1110b75b4e41891b32c0100729c0ee97ba019a1 | [
"MIT"
] | 2 | 2021-02-03T06:02:59.000Z | 2021-11-07T07:10:48.000Z | _archive/BASS/bass-1.0.7/innd.c | indraai/IndraMind | b1110b75b4e41891b32c0100729c0ee97ba019a1 | [
"MIT"
] | 3 | 2021-01-22T16:38:16.000Z | 2021-02-09T06:19:22.000Z | /*
innd.c
Author: Liraz Siri <liraz@bigfoot.com>
Copyright (c) Liraz Siri <liraz@bigfoot.com>, Ariel, Israel
All rights reserved.
Created: Sat Sep 26 09:17:42 GMT 1998
Code for the innd vulnerability 'hook'.
*/
#include "BASS.h"
#include "network.h"
#include "innd.h"
#include "log.h"
/* We only check the innd version. If smaller then the lowest known
immune version, then we declare vulnerability. */
int innd_handlehost(struct sockaddr_in *addr, char *host, int timer)
{
int tcpfd;
char *serverid, *version;
struct sockaddr_in raddr;
memcpy(&raddr, addr, sizeof(raddr));
raddr.sin_port = htons(INN_PORT);
if((tcpfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0 ||
tconnect(tcpfd, (struct sockaddr *)&raddr, sizeof(struct sockaddr),
timer) < 0) return -1;
serverid = (char *)alloca(INN_ID_LEN);
if(network_gets(tcpfd, serverid, INN_ID_LEN - 1, timer) < 0) return -1;
close(tcpfd);
if((version = strstr(serverid, "INN"))) {
version += 4; *(version + 3) = 0;
if(strlen(version) && atof(version) < atof(INN_IMMUNE_VERSION) )
log("innd - [%s] vulnerable version (%s).", network_getname(host),
version);
else
log("innd - [%s] immune version (%s).", host, version);
return 0;
}
return (errno = -1);
}
| 23.62963 | 72 | 0.665361 |
d1a2918cc87671d0d51e47a80db0777a9114c34a | 3,658 | h | C | auto/impl_glm.h | Csabix/imgui | d0eec238d8f3975c4b464707ab6dbf39a24392ce | [
"MIT"
] | 53 | 2017-11-21T23:25:01.000Z | 2022-03-27T18:28:59.000Z | auto/impl_glm.h | Csabix/imgui | d0eec238d8f3975c4b464707ab6dbf39a24392ce | [
"MIT"
] | null | null | null | auto/impl_glm.h | Csabix/imgui | d0eec238d8f3975c4b464707ab6dbf39a24392ce | [
"MIT"
] | 2 | 2018-12-28T15:39:29.000Z | 2022-03-10T13:09:21.000Z | #pragma once
#ifndef _IMGUI_AUTO_GLM_
#define _IMGUI_AUTO_GLM_
#include "../auto.h"
#include "core.h"
#include "impl_base.h"
#include <glm/glm.hpp>
// SPECIALIZATIONS
// ===============
#pragma region [I]VECN
IMGUI_AUTO_DEFINE_INLINE(template<>, glm::vec2, IMGUI_AUTO_INPUT_FLOAT2(name.c_str(), &var.x);)
IMGUI_AUTO_DEFINE_INLINE(template<>, glm::vec3, IMGUI_AUTO_INPUT_FLOAT3(name.c_str(), &var.x);)
IMGUI_AUTO_DEFINE_INLINE(template<>, glm::vec4, IMGUI_AUTO_INPUT_FLOAT4(name.c_str(), &var.x);)
IMGUI_AUTO_DEFINE_INLINE(template<>, const glm::vec2, ImGui::Text("%s=(%f,%f)", name.c_str(), var.x, var.y);)
IMGUI_AUTO_DEFINE_INLINE(template<>, const glm::vec3, ImGui::Text("%s=(%f,%f,%f)", name.c_str(), var.x, var.y, var.z);)
IMGUI_AUTO_DEFINE_INLINE(template<>, const glm::vec4, ImGui::Text("%s=(%f,%f,%f,%f)", name.c_str(), var.x, var.y, var.z, var.w);)
IMGUI_AUTO_DEFINE_INLINE(template<>, glm::ivec2, IMGUI_AUTO_INPUT_INT2(name.c_str(), &var.x);)
IMGUI_AUTO_DEFINE_INLINE(template<>, glm::ivec3, IMGUI_AUTO_INPUT_INT3(name.c_str(), &var.x);)
IMGUI_AUTO_DEFINE_INLINE(template<>, glm::ivec4, IMGUI_AUTO_INPUT_INT4(name.c_str(), &var.x);)
IMGUI_AUTO_DEFINE_INLINE(template<>, const glm::ivec2, ImGui::Text("%s=(%d,%d)", name.c_str(), var.x, var.y);)
IMGUI_AUTO_DEFINE_INLINE(template<>, const glm::ivec3, ImGui::Text("%s=(%d,%d,%d)", name.c_str(), var.x, var.y, var.z);)
IMGUI_AUTO_DEFINE_INLINE(template<>, const glm::ivec4, ImGui::Text("%s=(%d,%d,%d,%d)", name.c_str(), var.x, var.y, var.z, var.w);)
#pragma endregion
#pragma region MATNxN
IMGUI_AUTO_DEFINE_BEGIN(template<>, glm::mat2)
var = glm::transpose(var);
ImGui::TextUnformatted(("Matrix 2x2 "+name).c_str());
ImGui::PushID(name.c_str());
IMGUI_AUTO_INPUT_FLOAT2("row 0", &var[0].x);
IMGUI_AUTO_INPUT_FLOAT2("row 1", &var[1].x);
ImGui::PopID();
var = glm::transpose(var);
IMGUI_AUTO_DEFINE_END
IMGUI_AUTO_DEFINE_BEGIN(template<>, glm::mat3)
var = glm::transpose(var);
ImGui::TextUnformatted(("Matrix 3x3 "+name).c_str());
ImGui::PushID(name.c_str());
IMGUI_AUTO_INPUT_FLOAT3("row 0", &var[0].x);
IMGUI_AUTO_INPUT_FLOAT3("row 1", &var[1].x);
IMGUI_AUTO_INPUT_FLOAT3("row 2", &var[2].x);
ImGui::PopID();
var = glm::transpose(var);
IMGUI_AUTO_DEFINE_END
IMGUI_AUTO_DEFINE_BEGIN(template<>, glm::mat4)
var = glm::transpose(var);
ImGui::TextUnformatted(("Matrix "+name).c_str());
ImGui::PushID(name.c_str());
IMGUI_AUTO_INPUT_FLOAT4("row 0", &var[0].x);
IMGUI_AUTO_INPUT_FLOAT4("row 1", &var[1].x);
IMGUI_AUTO_INPUT_FLOAT4("row 2", &var[2].x);
IMGUI_AUTO_INPUT_FLOAT4("row 3", &var[3].x);
ImGui::PopID();
var = glm::transpose(var);
IMGUI_AUTO_DEFINE_END
IMGUI_AUTO_DEFINE_BEGIN(template<>, const glm::mat2)
ImGui::TextUnformatted(("Matrix "+name).c_str());
ImGui::Text("%f\t%f", var[0][0], var[1][0]);
ImGui::Text("%f\t%f", var[0][1], var[1][1]);
IMGUI_AUTO_DEFINE_END
IMGUI_AUTO_DEFINE_BEGIN(template<>, const glm::mat3)
ImGui::TextUnformatted(("Matrix "+name).c_str());
ImGui::Text("%f\t%f\t%f", var[0][0], var[1][0], var[2][0]);
ImGui::Text("%f\t%f\t%f", var[0][1], var[1][1], var[2][1]);
ImGui::Text("%f\t%f\t%f", var[0][2], var[1][2], var[2][2]);
IMGUI_AUTO_DEFINE_END
IMGUI_AUTO_DEFINE_BEGIN(template<>, const glm::mat4)
ImGui::TextUnformatted(("Matrix "+name).c_str());
ImGui::Text("%f\t%f\t%f\t%f", var[0][0], var[1][0], var[2][0], var[3][0]);
ImGui::Text("%f\t%f\t%f\t%f", var[0][1], var[1][1], var[2][1], var[3][1]);
ImGui::Text("%f\t%f\t%f\t%f", var[0][2], var[1][2], var[2][2], var[3][2]);
ImGui::Text("%f\t%f\t%f\t%f", var[0][3], var[1][3], var[2][3], var[3][3]);
IMGUI_AUTO_DEFINE_END
#pragma endregion
#endif // !_IMGUI_AUTO_GLM_ | 39.76087 | 130 | 0.676873 |
9e96c05cb031939b791ae5361a7c3423932450ae | 4,596 | h | C | include/egt/themes/ultraviolet.h | mattwood-microchip/egt | 6cf491008684feb200585ad1e323a9a02085d9bf | [
"Apache-2.0"
] | 36 | 2019-08-06T06:29:18.000Z | 2022-03-31T09:26:28.000Z | include/egt/themes/ultraviolet.h | mattwood-microchip/egt | 6cf491008684feb200585ad1e323a9a02085d9bf | [
"Apache-2.0"
] | 19 | 2019-12-06T00:25:35.000Z | 2022-03-28T00:22:27.000Z | include/egt/themes/ultraviolet.h | mattwood-microchip/egt | 6cf491008684feb200585ad1e323a9a02085d9bf | [
"Apache-2.0"
] | 14 | 2019-08-09T07:23:25.000Z | 2021-09-22T20:08:12.000Z | /*
* Copyright (C) 2018 Microchip Technology Inc. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef EGT_THEMES_ULTRAVIOLET_H
#define EGT_THEMES_ULTRAVIOLET_H
#include <egt/detail/meta.h>
#include <egt/theme.h>
namespace egt
{
inline namespace v1
{
/**
* Ultra Violet Theme.
*/
class EGT_API UltraVioletTheme : public Theme
{
protected:
void init_palette() override
{
m_palette.clear();
m_palette.set(Palette::ColorId::cursor, Palette::GroupId::normal, Palette::red);
const auto pattern = [](const Color & color)
{
const Pattern patt(Pattern::Type::linear,
{
{0, color.tint(0.20)},
{0.5, color},
{1.0, color.tint(.20)},
});
return patt;
};
// colors light to dark
std::vector<Color> colors =
{
Color::css("#f6f5f9"),
Color::css("#e1ddea"),
Color::css("#c3bcd6"),
Color::css("#a59ac1"),
Color::css("#8879ad"),
Color::css("#6b5b95"),
Color::css("#615286"),
Color::css("#564977"),
Color::css("#4b4068"),
Color::css("#403759"),
Color::css("#362e4a"),
};
m_palette.set(Palette::ColorId::bg, Palette::GroupId::normal, colors[0]);
m_palette.set(Palette::ColorId::text, Palette::GroupId::normal, colors[5]);
m_palette.set(Palette::ColorId::text_highlight, Palette::GroupId::normal, Palette::hotpink);
m_palette.set(Palette::ColorId::border, Palette::GroupId::normal, colors[7]);
m_palette.set(Palette::ColorId::button_bg, Palette::GroupId::normal, pattern(colors[7]));
m_palette.set(Palette::ColorId::button_fg, Palette::GroupId::normal, colors[7]);
m_palette.set(Palette::ColorId::button_text, Palette::GroupId::normal, Palette::white);
m_palette.set(Palette::ColorId::label_bg, Palette::GroupId::normal, colors[0]);
m_palette.set(Palette::ColorId::label_text, Palette::GroupId::normal, colors[5]);
m_palette.set(Palette::ColorId::bg, Palette::GroupId::disabled, colors[0]);
m_palette.set(Palette::ColorId::text, Palette::GroupId::disabled, colors[2]);
m_palette.set(Palette::ColorId::text_highlight, Palette::GroupId::disabled, Palette::hotpink);
m_palette.set(Palette::ColorId::border, Palette::GroupId::disabled, colors[2]);
m_palette.set(Palette::ColorId::button_bg, Palette::GroupId::disabled, pattern(colors[4]));
m_palette.set(Palette::ColorId::button_fg, Palette::GroupId::disabled, colors[2]);
m_palette.set(Palette::ColorId::button_text, Palette::GroupId::disabled, colors[2]);
m_palette.set(Palette::ColorId::label_bg, Palette::GroupId::disabled, colors[0]);
m_palette.set(Palette::ColorId::label_text, Palette::GroupId::disabled, colors[2]);
m_palette.set(Palette::ColorId::bg, Palette::GroupId::active, colors[0]);
m_palette.set(Palette::ColorId::text, Palette::GroupId::active, colors[5]);
m_palette.set(Palette::ColorId::text_highlight, Palette::GroupId::active, Palette::hotpink);
m_palette.set(Palette::ColorId::border, Palette::GroupId::active, colors[5]);
m_palette.set(Palette::ColorId::button_bg, Palette::GroupId::active, pattern(colors[10]));
m_palette.set(Palette::ColorId::button_fg, Palette::GroupId::active, colors[7]);
m_palette.set(Palette::ColorId::button_text, Palette::GroupId::active, colors[0]);
m_palette.set(Palette::ColorId::label_bg, Palette::GroupId::active, colors[0]);
m_palette.set(Palette::ColorId::label_text, Palette::GroupId::active, colors[10]);
m_palette.set(Palette::ColorId::bg, Palette::GroupId::checked, colors[0]);
m_palette.set(Palette::ColorId::text, Palette::GroupId::checked, colors[5]);
m_palette.set(Palette::ColorId::text_highlight, Palette::GroupId::checked, Palette::hotpink);
m_palette.set(Palette::ColorId::border, Palette::GroupId::checked, colors[7]);
m_palette.set(Palette::ColorId::button_bg, Palette::GroupId::checked, pattern(colors[7]));
m_palette.set(Palette::ColorId::button_fg, Palette::GroupId::checked, colors[7]);
m_palette.set(Palette::ColorId::button_text, Palette::GroupId::checked, Palette::white);
m_palette.set(Palette::ColorId::label_bg, Palette::GroupId::checked, colors[10]);
m_palette.set(Palette::ColorId::label_text, Palette::GroupId::checked, colors[8]);
}
};
}
}
#endif
| 44.192308 | 102 | 0.646432 |
b1134d1218f4493f62e2a127d7f0a6785b428185 | 2,232 | h | C | include/freerdp/codecs.h | zouhirzz/FreeRDP | d51958205298123ce83a5c349c08fc1859be7de9 | [
"Apache-2.0"
] | 5,941 | 2015-01-01T13:25:03.000Z | 2022-03-30T11:31:00.000Z | include/freerdp/codecs.h | zouhirzz/FreeRDP | d51958205298123ce83a5c349c08fc1859be7de9 | [
"Apache-2.0"
] | 5,801 | 2015-01-01T22:35:16.000Z | 2022-03-31T13:54:50.000Z | include/freerdp/codecs.h | zouhirzz/FreeRDP | d51958205298123ce83a5c349c08fc1859be7de9 | [
"Apache-2.0"
] | 12,644 | 2015-01-01T14:59:26.000Z | 2022-03-31T22:31:34.000Z | /**
* FreeRDP: A Remote Desktop Protocol Implementation
* RDP Codecs
*
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CODECS_H
#define FREERDP_CODECS_H
#include <freerdp/api.h>
#include <freerdp/codec/color.h>
#include <freerdp/codec/rfx.h>
#include <freerdp/codec/nsc.h>
#include <freerdp/codec/h264.h>
#include <freerdp/codec/clear.h>
#include <freerdp/codec/planar.h>
#include <freerdp/codec/interleaved.h>
#include <freerdp/codec/progressive.h>
#define FREERDP_CODEC_INTERLEAVED 0x00000001
#define FREERDP_CODEC_PLANAR 0x00000002
#define FREERDP_CODEC_NSCODEC 0x00000004
#define FREERDP_CODEC_REMOTEFX 0x00000008
#define FREERDP_CODEC_CLEARCODEC 0x00000010
#define FREERDP_CODEC_ALPHACODEC 0x00000020
#define FREERDP_CODEC_PROGRESSIVE 0x00000040
#define FREERDP_CODEC_AVC420 0x00000080
#define FREERDP_CODEC_AVC444 0x00000100
#define FREERDP_CODEC_ALL 0xFFFFFFFF
struct rdp_codecs
{
rdpContext* context;
RFX_CONTEXT* rfx;
NSC_CONTEXT* nsc;
H264_CONTEXT* h264;
CLEAR_CONTEXT* clear;
PROGRESSIVE_CONTEXT* progressive;
BITMAP_PLANAR_CONTEXT* planar;
BITMAP_INTERLEAVED_CONTEXT* interleaved;
};
#ifdef __cplusplus
extern "C"
{
#endif
FREERDP_API BOOL freerdp_client_codecs_prepare(rdpCodecs* codecs, UINT32 flags, UINT32 width,
UINT32 height);
FREERDP_API BOOL freerdp_client_codecs_reset(rdpCodecs* codecs, UINT32 flags, UINT32 width,
UINT32 height);
FREERDP_API rdpCodecs* codecs_new(rdpContext* context);
FREERDP_API void codecs_free(rdpCodecs* codecs);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CODECS_H */
| 28.987013 | 94 | 0.760753 |
36f1fe0706eb87154ebfe1f9c4c45386439e0455 | 1,143 | h | C | common/warnings.h | ozyb/aom | 8d335b714326a38dd6d20403082f1c8eb2c3f7e5 | [
"BSD-2-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | common/warnings.h | ozyb/aom | 8d335b714326a38dd6d20403082f1c8eb2c3f7e5 | [
"BSD-2-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | common/warnings.h | ozyb/aom | 8d335b714326a38dd6d20403082f1c8eb2c3f7e5 | [
"BSD-2-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | /*
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef AOM_COMMON_WARNINGS_H_
#define AOM_COMMON_WARNINGS_H_
#ifdef __cplusplus
extern "C" {
#endif
struct aom_codec_enc_cfg;
struct AvxEncoderConfig;
/*
* Checks config for improperly used settings. Warns user upon encountering
* settings that will lead to poor output quality. Prompts user to continue
* when warnings are issued.
*/
void check_encoder_config(int disable_prompt,
const struct AvxEncoderConfig *global_config,
const struct aom_codec_enc_cfg *stream_config);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // AOM_COMMON_WARNINGS_H_
| 32.657143 | 78 | 0.740157 |
829192fb6b2af7e7d2c5ed21bad743554745a681 | 2,699 | c | C | src/test/ioctl_tty.c | bokand/rr | 580a45aa22b39ee735a88f84d6474c1f882e14d3 | [
"BSD-1-Clause"
] | 1 | 2020-04-03T05:10:20.000Z | 2020-04-03T05:10:20.000Z | src/test/ioctl_tty.c | SaberMaster/rr | 29a59e412ad3e6600fcb37e9a5017f6eafce3b3d | [
"BSD-1-Clause"
] | null | null | null | src/test/ioctl_tty.c | SaberMaster/rr | 29a59e412ad3e6600fcb37e9a5017f6eafce3b3d | [
"BSD-1-Clause"
] | null | null | null | /* -*- Mode: C; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */
#include "util.h"
int main(void) {
int fd;
int ret;
struct termios* tc;
struct termio* tio;
pid_t* pgrp;
int* navail;
int* outq;
struct winsize* w;
pid_t* sid;
signal(SIGTTOU, SIG_IGN);
fd = open("/dev/tty", O_RDWR);
if (fd < 0) {
atomic_puts("Can't open tty, aborting test");
atomic_puts("EXIT-SUCCESS");
return 0;
}
ALLOCATE_GUARD(tc, 'a');
test_assert(0 == ioctl(fd, TCGETS, tc));
VERIFY_GUARD(tc);
atomic_printf("TCGETS returned { iflag=0x%x, oflag=0x%x, cflag=0x%x, "
"lflag=0x%x }\n",
tc->c_iflag, tc->c_oflag, tc->c_cflag, tc->c_lflag);
test_assert(0 == ioctl(fd, TCSETS, tc));
test_assert(0 == ioctl(fd, TCSETSW, tc));
test_assert(0 == ioctl(fd, TCSETSF, tc));
ALLOCATE_GUARD(tio, 'b');
test_assert(0 == ioctl(fd, TCGETA, tio));
VERIFY_GUARD(tio);
atomic_printf("TCGETA returned { iflag=0x%x, oflag=0x%x, cflag=0x%x, "
"lflag=0x%x }\n",
tio->c_iflag, tio->c_oflag, tio->c_cflag, tio->c_lflag);
test_assert(0 == ioctl(fd, TCSETA, tio));
test_assert(0 == ioctl(fd, TCSETAW, tio));
test_assert(0 == ioctl(fd, TCSETAF, tio));
test_assert(0 == ioctl(fd, TIOCGLCKTRMIOS, tc));
VERIFY_GUARD(tc);
atomic_printf("TIOCGLCKTRMIOS returned { iflag=0x%x, oflag=0x%x, cflag=0x%x, "
"lflag=0x%x }\n",
tio->c_iflag, tio->c_oflag, tio->c_cflag, tio->c_lflag);
ret = ioctl(fd, TIOCSLCKTRMIOS, tc);
test_assert(ret >= 0 || errno == EPERM);
test_assert(0 == ioctl(fd, TCSBRK, 0));
test_assert(0 == ioctl(fd, TCSBRKP, 0));
test_assert(0 == ioctl(fd, TIOCSBRK, 0));
test_assert(0 == ioctl(fd, TIOCCBRK, 0));
ALLOCATE_GUARD(pgrp, 'c');
test_assert(0 == ioctl(fd, TIOCGPGRP, pgrp));
VERIFY_GUARD(pgrp);
atomic_printf("TIOCGPGRP returned process group %d\n", *pgrp);
test_assert(0 == ioctl(fd, TIOCSPGRP, pgrp));
ALLOCATE_GUARD(navail, 'd');
test_assert(0 == ioctl(fd, TIOCINQ, navail));
VERIFY_GUARD(navail);
atomic_printf("TIOCINQ returned navail=%d\n", *navail);
ALLOCATE_GUARD(outq, 'e');
test_assert(0 == ioctl(fd, TIOCOUTQ, outq));
VERIFY_GUARD(outq);
atomic_printf("TIOCOUTQ returned outq=%d\n", *outq);
ALLOCATE_GUARD(w, 'f');
test_assert(0 == ioctl(fd, TIOCGWINSZ, w));
VERIFY_GUARD(w);
atomic_printf("TIOCGWINSZ returned {row:%d col:%d}\n", w->ws_row, w->ws_col);
test_assert(0 == ioctl(fd, TIOCSWINSZ, w));
ALLOCATE_GUARD(sid, 'g');
test_assert(0 == ioctl(fd, TIOCGSID, sid));
VERIFY_GUARD(sid);
atomic_printf("TIOCGSID returned %d\n", *sid);
atomic_puts("EXIT-SUCCESS");
return 0;
}
| 30.670455 | 80 | 0.628381 |
89e5c8c3fba089b6b73fead5ba7b60888f2e7280 | 5,138 | h | C | avt/IVP/avtLCSIC.h | ahota/visit_ospray | d80b2e18ff5654d04bfb56ae4d6f42e45f87c9b9 | [
"BSD-3-Clause"
] | null | null | null | avt/IVP/avtLCSIC.h | ahota/visit_ospray | d80b2e18ff5654d04bfb56ae4d6f42e45f87c9b9 | [
"BSD-3-Clause"
] | null | null | null | avt/IVP/avtLCSIC.h | ahota/visit_ospray | d80b2e18ff5654d04bfb56ae4d6f42e45f87c9b9 | [
"BSD-3-Clause"
] | null | null | null | /*****************************************************************************
*
* Copyright (c) 2000 - 2014, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-442911
* All rights reserved.
*
* This file is part of VisIt. For details, see https://visit.llnl.gov/. The
* full copyright notice is contained in the file COPYRIGHT located at the root
* of the VisIt distribution or at http://www.llnl.gov/visit/copyright.html.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the disclaimer below.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the disclaimer (as noted below) in the
* documentation and/or other materials provided with the distribution.
* - Neither the name of the LLNS/LLNL nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
* LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*****************************************************************************/
// ************************************************************************* //
// avtLCSIC.h //
// ************************************************************************* //
#ifndef AVT_LCS_IC_H
#define AVT_LCS_IC_H
#include <avtIntegralCurve.h>
// ****************************************************************************
// Class: avtLCSIC
//
// Purpose:
// A derived type of avtIntegralCurve. This class
// decides how to terminate a LCS.
//
// Programmer: Allen Sanderson
// Creation: August 14, 2013
//
// Modifications:
//
// ****************************************************************************
class IVP_API avtLCSIC : public avtIntegralCurve
{
public:
avtLCSIC(int maxSteps, bool doDistance, double maxDistance,
bool doTime, double maxTime,
const avtIVPSolver* model,
Direction dir, const double& t_start,
const avtVector &p_start, const avtVector &v_start,
int ID);
avtLCSIC();
virtual ~avtLCSIC();
virtual void Serialize(MemStream::Mode mode, MemStream &buff,
avtIVPSolver *solver, SerializeFlags serializeFlags);
virtual bool UseFixedTerminationTime(void) { return doTime; };
virtual double FixedTerminationTime(void) { return maxTime; };
virtual bool UseFixedTerminationDistance(void) { return doDistance; };
virtual double FixedTerminationDistance(void) { return maxDistance; };
bool TerminatedBecauseOfMaxSteps(void)
{ return terminatedBecauseOfMaxSteps; };
protected:
avtLCSIC( const avtLCSIC& );
avtLCSIC& operator=( const avtLCSIC& );
public:
virtual bool CheckForTermination(avtIVPStep& step, avtIVPField *);
virtual int GetNumSteps() { return numSteps; }
virtual double GetTime() { return time; }
virtual double GetArcLength() { return arcLength; }
virtual double GetDistance() { return distance; }
virtual double GetSummation0() { return summation0; }
virtual double GetSummation1() { return summation1; }
virtual void AnalyzeStep( avtIVPStep &step, avtIVPField *field);
bool LessThan(const avtIntegralCurve *ic) const;
avtIntegralCurve* MergeIntegralCurveSequence(std::vector<avtIntegralCurve *> &v);
avtVector GetStartPoint() { return p_start; }
avtVector GetEndPoint() { return p_end; }
public:
unsigned int maxSteps;
protected:
unsigned int numSteps;
bool doDistance;
double maxDistance;
bool doTime;
double maxTime;
bool terminatedBecauseOfMaxSteps;
double time;
double arcLength;
double distance;
double summation0;
double summation1;
avtVector p_start, p_end;
};
#endif
| 39.829457 | 85 | 0.613079 |
191a634efd07e2eeb3e1fa782527ab7f28d85330 | 1,465 | h | C | cc/test/fake_content_layer.h | kurli/chromium-crosswalk | f4c5d15d49d02b74eb834325e4dff50b16b53243 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2 | 2017-03-21T23:19:25.000Z | 2019-02-03T05:32:47.000Z | cc/test/fake_content_layer.h | carlosavignano/android_external_chromium_org | 2b5652f7889ccad0fbdb1d52b04bad4c23769547 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | cc/test/fake_content_layer.h | carlosavignano/android_external_chromium_org | 2b5652f7889ccad0fbdb1d52b04bad4c23769547 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 3 | 2017-07-31T19:09:52.000Z | 2019-01-04T18:48:50.000Z | // Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_TEST_FAKE_CONTENT_LAYER_H_
#define CC_TEST_FAKE_CONTENT_LAYER_H_
#include "base/memory/scoped_ptr.h"
#include "cc/layers/content_layer.h"
namespace cc {
class FakeContentLayer : public ContentLayer {
public:
static scoped_refptr<FakeContentLayer> Create(ContentLayerClient* client) {
return make_scoped_refptr(new FakeContentLayer(client));
}
virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
OVERRIDE;
size_t update_count() const { return update_count_; }
void reset_update_count() { update_count_ = 0; }
size_t push_properties_count() const { return push_properties_count_; }
void reset_push_properties_count() { push_properties_count_ = 0; }
virtual bool Update(
ResourceUpdateQueue* queue,
const OcclusionTracker* occlusion) OVERRIDE;
void set_always_update_resources(bool always_update_resources) {
always_update_resources_ = always_update_resources;
}
virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
bool HaveBackingAt(int i, int j);
private:
explicit FakeContentLayer(ContentLayerClient* client);
virtual ~FakeContentLayer();
size_t update_count_;
size_t push_properties_count_;
bool always_update_resources_;
};
} // namespace cc
#endif // CC_TEST_FAKE_CONTENT_LAYER_H_
| 28.173077 | 77 | 0.77884 |
308fee546e58a214e9939b78cdab4361be246f1c | 1,731 | h | C | source/pacman/main.h | iamstevendao/pacman_cpp | 3dbe686d6b96f64d29538d4b449fe52e117ea3bc | [
"BSD-3-Clause"
] | 3 | 2017-08-29T14:30:54.000Z | 2018-08-31T00:05:45.000Z | source/pacman/main.h | iamstevendao/pacman_cpp | 3dbe686d6b96f64d29538d4b449fe52e117ea3bc | [
"BSD-3-Clause"
] | null | null | null | source/pacman/main.h | iamstevendao/pacman_cpp | 3dbe686d6b96f64d29538d4b449fe52e117ea3bc | [
"BSD-3-Clause"
] | 3 | 2019-12-15T00:40:38.000Z | 2021-12-02T05:02:42.000Z | #include "Pacman.h"
#include "Element.h"
#include "Constant.h"
#include <cstdlib>
#include <Windows.h>
#include <iostream>
#include <math.h>
#include <cmath>
using namespace std;
using namespace sf;
//setup game
void showMenu();
void clearVectors();
void initialize();
void reset();
//generate elements of the game
void generate();
void generateFood();
void generateGhost();
void generatePacman();
void generateMap();
void generateCherries();
int generateTarget();
//drawing
void drawMenu(RenderWindow &, int, Font &);
void draw(RenderWindow &, Font &);
void drawMaps(RenderWindow &);
void drawFoods(RenderWindow &);
void drawPacman(RenderWindow &);
void drawGhosts(RenderWindow &);
void drawCherries(RenderWindow &);
void drawPath(RenderWindow &);
//control game
void controlGame();
void controlObject(Character &, bool);
void controlScore();
void crashGhost();
void eatCherry();
void eatFood();
void controlPath(int);
//functionality
void pushToMap(int,int);
void pushMultipleToMap(int,int);
bool isContained(vector<Element>, Element);
bool isContained(vector<Character>, Character);
bool isContained(vector<Constant::Direction>, Constant::Direction);
bool isCrashed(float, float); //check if a character is gonna hit the map
Constant::Direction opositeOf(Constant::Direction); //return the oposite direction
vector<Constant::Direction> whereCanGo(float,float); //check all the directions that a ghost can go into
//new
Path* findPath(int, Path *, Point);
vector<Point> getAdjacences(int, vector<Path*>, Point);
vector<Point> shuffle(int, vector<Point>);
bool reachTarget(Point, int);
bool isInQueue(vector<Path*>, Point);
bool isInMap(Point);
bool isInteger(float);
void setPath();
int round(float);
Point round(Point); | 25.835821 | 104 | 0.75621 |
cf25698bd1ecae1a260aa0fe64253c724f298874 | 155,439 | c | C | src/C/libpqcrypto/crypto_sign/gui448/pclmulqdq/gfext_iso_448.c | GaloisInc/hacrypto | 5c99d7ac73360e9b05452ac9380c1c7dc6784849 | [
"BSD-3-Clause"
] | 34 | 2015-02-04T18:03:14.000Z | 2020-11-10T06:45:28.000Z | src/C/libpqcrypto/crypto_sign/gui448/pclmulqdq/gfext_iso_448.c | GaloisInc/hacrypto | 5c99d7ac73360e9b05452ac9380c1c7dc6784849 | [
"BSD-3-Clause"
] | 5 | 2015-06-30T21:17:00.000Z | 2016-06-14T22:31:51.000Z | src/C/libpqcrypto/crypto_sign/gui312/pclmulqdq/gfext_iso_448.c | GaloisInc/hacrypto | 5c99d7ac73360e9b05452ac9380c1c7dc6784849 | [
"BSD-3-Clause"
] | 15 | 2015-10-29T14:21:58.000Z | 2022-01-19T07:33:14.000Z |
#include "stdint.h"
const uint64_t gf2448to25656[8*448] __attribute__((aligned(32))) = {
0x1ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL,
0x9EC5FDD621AE97EFULL, 0xCC6F8B7B97D0A069ULL, 0x2B0F6CF023FFAA08ULL, 0xD0952B994087D5F0ULL, 0x195B21B5FFAEC5FEULL,
0xF4F083F85F9C7B15ULL, 0x7BE87DA9E71FFCULL, 0x0ULL,
0xE384DC347446CAE2ULL, 0xEF9B357458C66FE1ULL, 0x849A6ADE6F8E11FDULL, 0x30AD454C61DA37ACULL, 0x7993F15930FA0318ULL,
0x28B1AB14F6507FE0ULL, 0x886784D1022B3ACEULL, 0x0ULL,
0xBAEAE0B2DA3726ECULL, 0x3BCC938C34C2D05CULL, 0x3EB717F0067ACB34ULL, 0x7D79B149C1E8A7C8ULL, 0x955FAD13C4D092D8ULL,
0xF1FAF3C985520441ULL, 0x16BDFB912CE450B8ULL, 0x0ULL,
0x5CA1503AD4B11B29ULL, 0xC16398FD288A2162ULL, 0xF492C3A058F47C3ULL, 0x511FC4684400410ULL, 0x68FE8914C2A3FE67ULL,
0x1EE8084CF051AF00ULL, 0x7ABC3B8C2876A140ULL, 0x0ULL,
0x1638DC016D15BD22ULL, 0xD46CE7B3293E54D9ULL, 0x3B10191222038F95ULL, 0x2230ECB8BAD6990ULL, 0x57457B726831C0DULL,
0xADE2E4B1894BC448ULL, 0xE57E17AA5A7284AULL, 0x0ULL,
0xC8F416284ED52751ULL, 0x4DB5EB32311B2E90ULL, 0x5AFC06A5CF4BCFCCULL, 0x4D6D770DBDA424D2ULL, 0x79D072604D53DBC3ULL,
0xF2E01ECB2A931797ULL, 0x417017F2D3DBD202ULL, 0x0ULL,
0x24F602886C49E662ULL, 0x6A4A183941349539ULL, 0x5C0DE81D9DD02703ULL, 0x78D93BB3A69D28E0ULL, 0x97F937220822C60EULL,
0x2C63995CE722E679ULL, 0x9E3EBFF827505FCAULL, 0x0ULL,
0x29D7FEB42DE84F7FULL, 0xC66D0E81343A5E01ULL, 0xB88AFE95F5CBC1A8ULL, 0x27D0FCEE311A79FULL, 0xD01F865AB9B3861CULL,
0xBEAD33C052654735ULL, 0x1BC3C805491ACB96ULL, 0x0ULL,
0x38824ED6C2692BEAULL, 0xC680306F603EA28AULL, 0xADAC717F3D8DB147ULL, 0x89520E09C4E92FA7ULL, 0x8B172F429FB61A4FULL,
0x317D42D70EBB7AAFULL, 0x99078E08F84555DBULL, 0x0ULL,
0x18693A4FD37476EEULL, 0x5539FD3F1C820BA1ULL, 0x8148D0BF20B6E43FULL, 0x6E59BDBF00C06337ULL, 0x27DD436FDAEA9003ULL,
0x9A19F01287B019ECULL, 0x9551BF2F061233DDULL, 0x0ULL,
0xB2E8E20CAC6B4C9FULL, 0x463AE9B480C94D8FULL, 0x6FE4722BF3E9607FULL, 0xE0FB649D5B86B9B4ULL, 0x5D2E15152318907BULL,
0xD5271C91835E7448ULL, 0x2616081FDB7E87FCULL, 0x0ULL,
0xC3D8DCB8403003DEULL, 0xFB038A3C735C0D30ULL, 0xB5162DA6E9F7E5A5ULL, 0x72F9E0735F5A4BC9ULL, 0x5045AD35CBA8A96BULL,
0x54E05DDFA384E8DDULL, 0xEBFF6F17F7EA6757ULL, 0x0ULL,
0x772EDF9C0E3105E3ULL, 0xAA97A139E7F7A783ULL, 0xE22BC67153A19382ULL, 0xC8E6D2D36EBA1516ULL, 0x69AEA77CA8CCCDA9ULL,
0x73F27F91ED249516ULL, 0xB231531DC0A11F44ULL, 0x0ULL,
0xB0739C9373D3CBA2ULL, 0x14E2E3D4B07A8353ULL, 0x2C80A52F316D3164ULL, 0x9040FB2D0118041BULL, 0x9D081EE25256BA3DULL,
0xA540E485AF9FA2DBULL, 0xF6C979A0177B8898ULL, 0x0ULL,
0x856BEDA5E01A20A9ULL, 0x14BF5170C203B94CULL, 0x10807C5CFA95BABULL, 0x2127CF1F292878B0ULL, 0xD9451D08326C1E17ULL,
0x88B6D6CFD90F57A2ULL, 0x39B7FEF2AF461956ULL, 0x0ULL,
0x810E4FE5DBD70DEBULL, 0xAE2A9D57FAF312DCULL, 0x839B7C2A4919266EULL, 0xD403E54A5E5FD943ULL, 0x8AC0D75CF0742DCEULL,
0x4028CDA8F7449C37ULL, 0xCAE76310BD17BABFULL, 0x0ULL,
0x467668C7D0A0B74EULL, 0x3BAAFF416C395EF0ULL, 0x65F0D5AC65E4B13FULL, 0xEF0738FD3B4C0A01ULL, 0x35E26CB536FC489BULL,
0x85B82FD659941A2EULL, 0x5E07F52F2A7FCDE4ULL, 0x0ULL,
0x464470650CF4B743ULL, 0x9617DC5FA1170D23ULL, 0xF59D0AFC850D21F7ULL, 0x5E3C77FC34378180ULL, 0xAFDAF98F9ED4A992ULL,
0x28F5FC868FB59803ULL, 0xC2D96FC1D083E13EULL, 0x0ULL,
0xDA43B1E80F28764CULL, 0x13C973D0A6AC094FULL, 0xF37FB4AFE9CBB76EULL, 0xCBD61FEE08510575ULL, 0x97D51C94AD0F2F53ULL,
0xA880D8B45D2695BDULL, 0xD5767C61F552AB9BULL, 0x0ULL,
0xCA402F81A57E90C7ULL, 0x6E44C8E2C584AF4EULL, 0xCD2711CCCA38AF18ULL, 0x8906DAF2DFC796C8ULL, 0xE072FEAFB84E748DULL,
0x288F2CC2D36DE7EAULL, 0x56D62326ED1337CCULL, 0x0ULL,
0xAE00AD47BCAFBCDBULL, 0x6ACDC19F0EE32059ULL, 0x20973D1F9AFDAD99ULL, 0x27BBA0821A54D5D7ULL, 0xEBC1FEA714BA4F09ULL,
0xA0B0FE1D5C150C84ULL, 0xBC029D34590FD3F7ULL, 0x0ULL,
0x62BC304A117DF4C9ULL, 0x1CA55EC84E288200ULL, 0x61F119413A85043FULL, 0x457CF12DF21AF033ULL, 0xB65611B55A7BA3F4ULL,
0x2F1B2CF03D36654EULL, 0x17541B132F2EE6FCULL, 0x0ULL,
0x3F8D2CBF9D17CEA3ULL, 0x28695ACF0013A7C3ULL, 0x6AD791BA0420FB8EULL, 0x44C0342189E725B3ULL, 0xFB7C810A579494D4ULL,
0x21EE81845CD1DE9BULL, 0x839BAC7F68E0E2D1ULL, 0x0ULL,
0xA6AC5F68039CBF72ULL, 0xCF629C364220D06CULL, 0xCFC61013DDE0F0B0ULL, 0x84F0185C7D5D3E36ULL, 0xBF6E17CC89A5D4CCULL,
0x50702AA0CA1DE520ULL, 0x66DB33247E9BFE6DULL, 0x0ULL,
0xD3142C2ECF7767A0ULL, 0x80F0971A9F2295B0ULL, 0x2BD5B8F04E7799FEULL, 0xA78F0E7733BBA31AULL, 0x1B4C8A54369609AEULL,
0x3E7B179D544A32F5ULL, 0xAFB3A06621C8C38CULL, 0x0ULL,
0x78F17B8353D4D01EULL, 0x34D563A5C8213E47ULL, 0x2C2A955B6EE43997ULL, 0x941970D6E73DB8E8ULL, 0xA2A6151E0BAF0E6BULL,
0xC4A7C961A3B4EF3DULL, 0xC7B9BB005EB0CC25ULL, 0x0ULL,
0x2FFBEBC7B6829254ULL, 0xB4F5C8102FD04F14ULL, 0x4E03D900B9474187ULL, 0x2DFB7725DF3F4047ULL, 0xAABCE344409B1E11ULL,
0xA7CFEE3EF8B2942DULL, 0x136A267FD18FF4C4ULL, 0x0ULL,
0x7FEF88C48D63D43DULL, 0xE34D2E96C7FF6D88ULL, 0xCAF42D95D7C41A10ULL, 0xA6C4B1B81EF5EAE6ULL, 0x5417AA4EE510A81BULL,
0x94E725D59E03BD4BULL, 0x4A943CFC383DCE5DULL, 0x0ULL,
0xDB454B63B338F5E5ULL, 0x5AD95C0780C1311ULL, 0x91E7A638DB008CDAULL, 0x8C73DEB6B81D9F94ULL, 0xBFB5A9A8C4871D9AULL,
0x12839C3BE47EB63FULL, 0x75A1E126EAFEFB95ULL, 0x0ULL,
0x25E9E03292BD25EEULL, 0x8305788F349F0635ULL, 0x1DCB436514C638BCULL, 0xA36F946B05B11F31ULL, 0x8A5E0F647491465CULL,
0x50DB4A4A8B5C1B61ULL, 0x7B1410AB7603E707ULL, 0x0ULL,
0x9EC0F9D55590BDDFULL, 0xCAE9665FC782E6F5ULL, 0x13ADE83766B8C29AULL, 0x37EB5D5E9E9DADAFULL, 0xF36F80F2F0B9689DULL,
0xD4BE3520306E09AFULL, 0xF65083E1A3396873ULL, 0x0ULL,
0xA47FCDEB34FE2775ULL, 0x131A5A93ECBA4823ULL, 0xE4543BE3DEA9E95ULL, 0x2367274DF1DA48D7ULL, 0x797CE8B0CAB805C1ULL,
0xDCAE4811A1724278ULL, 0x79BE2B6B7DEE44FDULL, 0x0ULL,
0x1CFE2F551DC3ED99ULL, 0xB5A728ACB10472EDULL, 0xD2F4FB40957713C3ULL, 0x179C316AC301F189ULL, 0x1F94E7FC444B7AC8ULL,
0xA904B9FA1D708521ULL, 0xA303BACC22EE89DBULL, 0x0ULL,
0x8C6C3644C4539A0AULL, 0xCEDE213B249901EBULL, 0xECC4224D02A4CB37ULL, 0x336CEB2202E40192ULL, 0x8C1AE989C51735C4ULL,
0xB9C093FE7E2FE5DCULL, 0x7F2CE72C84BB22E5ULL, 0x0ULL,
0x7CEC4C9593D719E2ULL, 0xE1746F816CE8DF62ULL, 0xCACD0FD8657A4F99ULL, 0x7FEF759A7433D4C2ULL, 0x3A4E9BEDDA59141ULL,
0x74B3BEF6CACF4FC1ULL, 0xC33393C2A9B7A7EULL, 0x0ULL,
0x4E04A2AAA892B010ULL, 0x3744DCB0ACC15CC2ULL, 0x1631414DF00F9098ULL, 0x8D6DB8BEC8DC7356ULL, 0xDA7D75BFF340B2FFULL,
0xC52318D2B4433AF2ULL, 0x4C330259862C4AE7ULL, 0x0ULL,
0x5FE53B45C223C696ULL, 0x9C77B783F5457A3EULL, 0x40D72A7A47D81569ULL, 0xD74B50F48AF7FC30ULL, 0x3767102EFEB1AF70ULL,
0x8E896B1D3B8547BAULL, 0xDFE9AF65B43018AAULL, 0x0ULL,
0x4ED08685DBBDC7B1ULL, 0xEE451FF5AB17A62FULL, 0x390987205324B0A8ULL, 0x673573919D9FBBD3ULL, 0x801B2A88F4976EE9ULL,
0x62206FDAB4EB0B5ULL, 0x21CCCED5E34CB13FULL, 0x0ULL,
0xB2FDD0F9F9458CB6ULL, 0x5AD937F9D5CC56F0ULL, 0xFBA7080DE835CC4CULL, 0x1C37303AEB490BF5ULL, 0x20F9351C2C9F85B7ULL,
0x211EF32A3BCF590BULL, 0xF63B7BEE561BF6E8ULL, 0x0ULL,
0xD813F0F64408F348ULL, 0x4AB5E9F025A6B741ULL, 0x1E3AE13ECA6B6B5ULL, 0xDCA97A248A94533ULL, 0x5013C28FE0274B0CULL,
0xA84E2688FBB5AC2BULL, 0x8277BF5C2497F890ULL, 0x0ULL,
0xAAF2BDF8E97F0E64ULL, 0x5B2D60871C3DAEBEULL, 0x7A4FB11177B5C390ULL, 0x31DB475852099885ULL, 0x49DE980B49072F83ULL,
0xE754B0E6F2A7998CULL, 0xBADD9CBC251B2D3CULL, 0x0ULL,
0x66CD82668CED6EA0ULL, 0x4A1A4B326A671CA3ULL, 0x5EA55EB6EA71C979ULL, 0x5162125B67081B91ULL, 0xB982144DBEA58AF2ULL,
0x7D7BF85241B7EE94ULL, 0xF8744749F3A0BB29ULL, 0x0ULL,
0x17E605586FD7EF65ULL, 0x9CEB5A6B4CE973BFULL, 0x9D5EC455C8C854C4ULL, 0x195A6447E1FDDE89ULL, 0x8AF8E3A75A7B95ECULL,
0x2C5925FCD24BF2B0ULL, 0x4082046123CD6E69ULL, 0x0ULL,
0xE07EA83283625261ULL, 0xF93F38F2094623CCULL, 0x68ED54E6435567A2ULL, 0x185F8151E1643623ULL, 0x14C602B1D5C2AEE0ULL,
0x29B6F0606F198813ULL, 0x824E50F938FD0C96ULL, 0x0ULL,
0xA5A0FF715F4D35DULL, 0xB003E2BEE781D645ULL, 0x21256EE4F3E5B4B0ULL, 0x53E474C499A6C288ULL, 0x96F76F2D60EA3459ULL,
0x3AFA8E556A002984ULL, 0x6742C4C43F9D5441ULL, 0x0ULL,
0xBFBB868D3059128CULL, 0x3BEA801239F9152AULL, 0x1A352551D8C0935BULL, 0x84065EFEE74026E6ULL, 0xFF62E0E9B3B44088ULL,
0x98EE4AF87EAABA5DULL, 0x92CCBBDF62C9E59BULL, 0x0ULL,
0xB99F918F5096EFA8ULL, 0x92F4F3E6B785AA8CULL, 0x34E83777AAD0612BULL, 0x732E96B51C35D125ULL, 0xD0C73799DA274DBAULL,
0xDFDDF53A84639806ULL, 0x499211C2E92D07B9ULL, 0x0ULL,
0x325CBFF58D186577ULL, 0xA41114DB74A7DEC7ULL, 0x56267FD7CF79D1C1ULL, 0x9479DD6892E0695DULL, 0xF2245476450133B8ULL,
0xDCB2FEA335DCCD9ULL, 0xA17299343DE8B33DULL, 0x0ULL,
0x61402E38AAB781B5ULL, 0x50F77C7A4CF99C0EULL, 0xC08696C8BB533B38ULL, 0x78D15181872FBBD1ULL, 0xD91CEBBED6EC5E1DULL,
0x41EC88913DFED158ULL, 0x3C850C5B22D37B97ULL, 0x0ULL,
0x87BADB738DA62051ULL, 0x681FC7E87FFF95F6ULL, 0xA3A70C904E1F471DULL, 0xC7315C62CC1EBBA3ULL, 0xAC0360445812529BULL,
0xED5F695FD1F6ED1BULL, 0xB3F48F0F41A24C25ULL, 0x0ULL,
0x847FBFC01E082E9CULL, 0xB6615099542D8F9DULL, 0x9924415737F53C4FULL, 0x6090B88C1D00CACEULL, 0xD64AEF7DFA9F15F0ULL,
0xE2646AB9920859A4ULL, 0x6633397A3CFAC4D6ULL, 0x0ULL,
0xE8BB9994B38C1AF1ULL, 0x7EB6EF4EACC41C4FULL, 0x9CCECA2F3FCC157BULL, 0xB0403C14BF9C58A1ULL, 0xC812348116C92EB1ULL,
0x243021E8A358E674ULL, 0xEAE0A834FDDD9980ULL, 0x0ULL,
0x7BA80F602CDFB8B3ULL, 0xA99169532CF7B9D1ULL, 0xE339393D6F235888ULL, 0x711F5304EEAEC5D8ULL, 0xEEBD61A3D38454C5ULL,
0xA68B3A74C4E0B56DULL, 0x95A842AA2DAE7019ULL, 0x0ULL,
0xD1231FDD5E51EF7DULL, 0x292AE9CC3E9A0E35ULL, 0xBA973CC33D13D869ULL, 0xCAE1B170D77246CCULL, 0x3EF47ADABDBBC8B6ULL,
0xC9CE36AC4608C849ULL, 0xBC104FA6B243B208ULL, 0x0ULL,
0xD0F00CBF4A3728C4ULL, 0xC42FD8D326AF3661ULL, 0xA37B4E1C72B84F83ULL, 0x5B5B35FA18B76EA6ULL, 0x4E000ECB988562C5ULL,
0xBB4E5B7A65A0C7ACULL, 0x70C70F804D71D9E4ULL, 0x0ULL,
0x3ACEEECFA6DBA624ULL, 0xA66F611CCE4962D7ULL, 0x5D52644451F3A044ULL, 0xCDA95E4D444EF624ULL, 0xE6398A2C812E1D9ULL,
0x1A8BF4DF2B9735EEULL, 0x29E7F954C0DFACFDULL, 0x0ULL,
0xFBBB70C0529D2664ULL, 0xBACA984D6B85E78AULL, 0xFF0F84299CB947A0ULL, 0x1F063E9C9E511177ULL, 0xEF0F05D57011566ULL,
0xD23B7D83DF7FE850ULL, 0xB3FE5155F2D8F79AULL, 0x0ULL,
0x5B7EB732F0273A08ULL, 0xD0E7F91E5E50A217ULL, 0xA1048EA99F903283ULL, 0xA3A1A9BCD4378C5ULL, 0x7F069A1EFCC3EEB3ULL,
0x657A72CCD8DAECF7ULL, 0x31742F489E82F0E4ULL, 0x0ULL,
0x63BDB4A23BAE8268ULL, 0xB3967516802F6BULL, 0x71770BF5A697654AULL, 0xDDDA5EDBA45984D5ULL, 0x8A4B4C4875D93E2AULL,
0x8508A70E71B38378ULL, 0x62F2F53C9E100101ULL, 0x0ULL,
0x47AF1AC7647D5116ULL, 0x4A87437FACA0810ULL, 0x49F479C0A395D328ULL, 0x49125D38B42E32A4ULL, 0x889110FDD7D60B0EULL,
0x4DB9CC9681789114ULL, 0x630C320B62896297ULL, 0x0ULL,
0x37127A60B57DE509ULL, 0xFD9F79EC5D1FE20BULL, 0xE538E07777C63B12ULL, 0xFD0B2E65E23E1BDULL, 0x6E08ABE43C5853A0ULL,
0xC9E2206E7F1BEC8ULL, 0xBEE362006EAF467AULL, 0x0ULL,
0xEBD4181BEC379DA7ULL, 0xC20B59AB1A2AF0A0ULL, 0x38583D2E35B67C67ULL, 0x815B5F627D960AACULL, 0xF887C7AD332600BCULL,
0xD87087CCD033B0F3ULL, 0x55B1B4318FEF0AEULL, 0x0ULL,
0x94038A2854060564ULL, 0xCC99C9C381929499ULL, 0x67F2C171E2FF616AULL, 0xC24CB35D36ED01EAULL, 0x501FD311CCC62C3CULL,
0xD8D7DE78F798E7A9ULL, 0xB76A9305B736E02BULL, 0x0ULL,
0x9F7E4770868D70FBULL, 0xE225F640DBC3A3BBULL, 0xC7BD80B7D3E72BE4ULL, 0x6740F0DDEF56CFEFULL, 0xD9275D4944096449ULL,
0x8B5337BD8412609FULL, 0x18AFE7FD9FEEDE36ULL, 0x0ULL,
0x245C6BCBE5B3ABA1ULL, 0x224F89999C795E28ULL, 0x7FB8332A205914A1ULL, 0x5F4DACBF95ADA051ULL, 0xB87EA30883AFB04CULL,
0x7026F215457F5D2AULL, 0xA5B3948F298FFD97ULL, 0x0ULL,
0x5ACAFB398B07E249ULL, 0xDD64E27A9D269081ULL, 0x51FB0EC06E552CF2ULL, 0x9FCD2515C3771785ULL, 0xED4B512F1308B89EULL,
0xFDE6E64E2564D526ULL, 0xEBD156212FA6AB4BULL, 0x0ULL,
0x671165D53F9F9DB4ULL, 0x5C193C1151E25177ULL, 0x4083293D55AFC540ULL, 0x4609EA4956F8C9C5ULL, 0xE6F1B3982BB77C2BULL,
0x119D93266C3EC706ULL, 0x1BC7CB0C465A788DULL, 0x0ULL,
0x82739B6F9BE68A4AULL, 0x9A8C2180FEB58828ULL, 0xFEBCD4B2E29C057CULL, 0x55CAF24D7518C022ULL, 0x2011F1C522301C6DULL,
0x8ED8E49DF873DD40ULL, 0x5768F14F9C1C5301ULL, 0x0ULL,
0xB8FD2B2AEA225BDFULL, 0x7087C87E11B4671DULL, 0x5F97C366C6912264ULL, 0x738BD05AFF09451DULL, 0x624EA1F590B2A80FULL,
0x619724271A6FDA1FULL, 0x89BA540828C15981ULL, 0x0ULL,
0x8AAF006E009218C8ULL, 0xDD51A4BC7CDAE5C6ULL, 0x76782EAADE350702ULL, 0x674507F4B2DDBBE6ULL, 0x1DCFAFB71A3C495FULL,
0x742343E5C412C5D7ULL, 0x3CFD1EE2198B38E6ULL, 0x0ULL,
0xC43AAA6A57344695ULL, 0x84FFA34D8B6FAEFDULL, 0xF6C19ECC311A305CULL, 0x9E5E8624655BF495ULL, 0xB42BF1B2692AD438ULL,
0xFD3A26F729D41AAULL, 0xCDA1B982A359B4CBULL, 0x0ULL,
0x7A790CDEA044034AULL, 0x2E8A3511150BF4B1ULL, 0x2DB0C5E311FF12F8ULL, 0x4E9A5656C9A66307ULL, 0xA5CC1C5DE68EFA4AULL,
0xCE7381E9A7915E70ULL, 0x5B132F6692791E35ULL, 0x0ULL,
0xF7367841A78FCE65ULL, 0xE45517D33502279CULL, 0x2001CF5CD40ABE86ULL, 0x5BFD57518FF6A039ULL, 0xB90A7C60D5041758ULL,
0xF9C3B68F911FB035ULL, 0xA62F55456FDCBB29ULL, 0x0ULL,
0x194BFD859ECFA166ULL, 0xCC3382486EF9B19BULL, 0x813E7B430CDDDAD0ULL, 0x4DD1680137A1C0EEULL, 0xB5DD76527F8C2367ULL,
0xC0D506496D728FEFULL, 0x6AF1F00C4B440C3FULL, 0x0ULL,
0xACC083C527278B20ULL, 0xEF94A824EEA3DB10ULL, 0xA0CD1B5651DAEAD8ULL, 0x7A759FB0E207B509ULL, 0x921DC075618D99EAULL,
0x73890D45306C4890ULL, 0x92A2A7EA319D9E89ULL, 0x0ULL,
0x6A8DA54B007C7F45ULL, 0xD0CA6F4799382844ULL, 0xF7DB08745B7B32D3ULL, 0x503F3CF7A8C39230ULL, 0x1C2D3D76E0A2E582ULL,
0x3B5D3DABC9182F48ULL, 0xE6A860564A546362ULL, 0x0ULL,
0x876432C0B5F3B7C0ULL, 0x90D62C901A32EF62ULL, 0x98508EAEFA3BA657ULL, 0x504F5225E82A6EC5ULL, 0xBB1CE845358937A2ULL,
0xF736463C104BA5BBULL, 0x22990B548A03E71BULL, 0x0ULL,
0x2FB11CBC1FD9C8FBULL, 0x7A35A1A982EFD70BULL, 0xDAD2A4B70AE606BDULL, 0xF36D211476671769ULL, 0x15E4F93388570BF8ULL,
0x5345F78650989A87ULL, 0xA117AB778E041A4FULL, 0x0ULL,
0xFB3E9597F0E6212BULL, 0xD625E56CE9A46F49ULL, 0x866343E26F3F39DAULL, 0xFF176F2834C26EBBULL, 0x68F7071920A26DD8ULL,
0x788D83A28CDF5287ULL, 0x6D6EF42AE53D10DFULL, 0x0ULL,
0xD3C1F47FBC17EE10ULL, 0x9DF18C2E65720420ULL, 0x50BCC557D3EF11C8ULL, 0xC05C8757FC7BAE11ULL, 0x521C7D7850D33C1BULL,
0x71152E69D3F7BFBCULL, 0x5864125D63226711ULL, 0x0ULL,
0x2E57D41D3B0BF3FEULL, 0xEBA465FAFA83B103ULL, 0x9519DB9B0EAEF662ULL, 0x93411947B4A4A172ULL, 0x9960F1B19EE97CULL,
0xF999137D13762D13ULL, 0xDCB2749E20C8A252ULL, 0x0ULL,
0xDA7D1FABF00B610AULL, 0x633312D6591CEA86ULL, 0x95C4E417CE94B20AULL, 0xE185A134A0356854ULL, 0x17522A1A3E6963CBULL,
0x1A4100060727E945ULL, 0x14EED1D93DDE8BBULL, 0x0ULL,
0x3DA4BCA32552F335ULL, 0x38933CAD695FABA5ULL, 0xEC42FE4B58FE86C2ULL, 0x7F01A6CAC9CCC493ULL, 0xC4FAC77E53AA70BDULL,
0xA407303926FFCEC8ULL, 0x5FD50889126FBD47ULL, 0x0ULL,
0xDE4A7DA08B1F5A95ULL, 0x8C048D893B0301A3ULL, 0x984FFA59A8EB325FULL, 0x3D6E3C84C5B597E9ULL, 0xC9D8A8410CA0C7F8ULL,
0xE892BCA7E155BA43ULL, 0x1E42FC96DE408210ULL, 0x0ULL,
0xE71483F437C39310ULL, 0xA703FE328CC80563ULL, 0x4DC7405FC0D449FDULL, 0xFAFCD81C2788D600ULL, 0x46EC8E41C93F4AA3ULL,
0x465CD459FEF36376ULL, 0x1EB3226EFD864072ULL, 0x0ULL,
0x8602DB14E43E4A03ULL, 0xF97306830AD1AE9FULL, 0x3CB25D94F8347CF1ULL, 0x1E4C8365C584928EULL, 0xAE7062FBD47D6DCAULL,
0xE7981EFEFE5C4ADBULL, 0x19BD691A5C949A1ULL, 0x0ULL,
0xA06392578271BF67ULL, 0xD3B1D523AFBB49B7ULL, 0x82F0CFAEC00B00D7ULL, 0x1CD361BCEC0AF5A6ULL, 0x61B4AEE4018A36F4ULL,
0x2830EEEAB65EFD44ULL, 0x67801CCB84EED7E7ULL, 0x0ULL,
0x8E9413F4483479CDULL, 0x794CC95A242DA772ULL, 0xCAF4BD1B52060870ULL, 0x726A757DFCCF3D2EULL, 0x61D11DFA3492FC8AULL,
0xC46292E24AC9DF7EULL, 0x6882FAC291A6AB33ULL, 0x0ULL,
0x8141D6A3F1B3ADF6ULL, 0xC9C84505AD4E39DAULL, 0xBD6DD276F13A1F93ULL, 0x7A435D7B71C5ED7ULL, 0x72EFD4028500664FULL,
0x828F6A2BE7E0CA9AULL, 0x7B2B062BE4B7EC0FULL, 0x0ULL,
0xB0B00D5098918E3CULL, 0x926DBCCCBB85E5DEULL, 0x217F3E5A4D579FB4ULL, 0x5D711C02543A99A4ULL, 0xCF9BF0AF4A4ADE0DULL,
0x61495235C2B4558CULL, 0xEFE9B1C86AF3859AULL, 0x0ULL,
0xE126CF5C27CAAF83ULL, 0x8E6F43D6D928669DULL, 0xE557498AD79F799EULL, 0xA7300A7688E63844ULL, 0x6E2C5B7EA3CF13F6ULL,
0xEF7897B0DF7A998BULL, 0xC3BB71166E00D871ULL, 0x0ULL,
0xD2729CAC915E7690ULL, 0xA8094D4F06CCBF3AULL, 0x3C7596CA4F42D1A7ULL, 0x3B58B02966EC9134ULL, 0x1DA3B6485331965ULL,
0x8A457AC2C41E8428ULL, 0x161FE4FE011308A9ULL, 0x0ULL,
0x88B96FC5C91FBADULL, 0x3AFE17A72232E086ULL, 0x3A8AD5370C096355ULL, 0x1FE0663E535EF87EULL, 0xC8D9EA48C3F920C6ULL,
0x8BB57F6D67369733ULL, 0x153C116B102A8DACULL, 0x0ULL,
0x5DA47DE199CF9C45ULL, 0xBFAF86FB397072E5ULL, 0x774781B067483FB3ULL, 0x7A9B1CD0C1E1F7D8ULL, 0x55C548B0A1E74E37ULL,
0x96B736545368025DULL, 0x21C4EBBDC628782AULL, 0x0ULL,
0x6851D7F48215A935ULL, 0x24527EE51A44F61FULL, 0xE7F3598F5B4B6CE4ULL, 0x67B58A9A71980819ULL, 0xF8E62238DD352982ULL,
0xDC3E56D711AF6D97ULL, 0x56942C6CA0EA9117ULL, 0x0ULL,
0x4912BAB80C38F1FCULL, 0x624836647B37BF90ULL, 0x85B8ACFAFE46FE16ULL, 0xB420A636448746DFULL, 0xD110A09EFC44B405ULL,
0xE636D0BCCBB029E9ULL, 0x679F0746F53911F9ULL, 0x0ULL,
0xE6EC49B36FCE26C6ULL, 0xC951A4F8AB094236ULL, 0xA1E2D7060AF86BEULL, 0x6E6E28FDD413FDF9ULL, 0x58EA59F37F1AFD8CULL,
0xE232F3611F96F676ULL, 0x9FEF8E762D459FBAULL, 0x0ULL,
0xB6CF37491B797BDBULL, 0x6FB31F8A54339919ULL, 0x8C1DD0B1DD60025AULL, 0xC0336DD433E1841AULL, 0xADFAE7909ACDFC97ULL,
0xC6FD2B4A07C87952ULL, 0x4986D4739B4D69DFULL, 0x0ULL,
0x7DE4639ED267084BULL, 0xF0B4763F75F9CDBEULL, 0x8EBDBE014630A11EULL, 0x72554F1B344060DBULL, 0x381A986F27B98BC7ULL,
0xE7FBA281FA1C34BFULL, 0xFA3F77403BFDF5AULL, 0x0ULL,
0x8BBDB5B3D45B032DULL, 0x5F858F5432111F1FULL, 0xE2B8A3BCE1A2F2E7ULL, 0x40FF5984AE4065E8ULL, 0x1C92D30EC4C0860DULL,
0x18EF5D947DACFAC2ULL, 0x1140FAB5D953B278ULL, 0x0ULL,
0x78097FE50CAB3758ULL, 0xE2F3065184EB5B0EULL, 0x7281562058AC549ULL, 0x7648A6E1EB1A29D9ULL, 0xBB1283F3B93B4EB2ULL,
0x727224ACFD7652C6ULL, 0x6280319BA3CE6266ULL, 0x0ULL,
0x187393569595C443ULL, 0xDEFDEA74F513347CULL, 0x1A98A1C9061AAC97ULL, 0xC3619C82073014E0ULL, 0x2445F3910AA4B47CULL,
0xCA964E17472F639AULL, 0x61211ECCAA9B7CAAULL, 0x0ULL,
0xB56201B4D3B05E59ULL, 0x700270031C48B2EULL, 0x886FFA7AA11DC0C3ULL, 0x59AE670C6E72E79AULL, 0x93025808CAA1D179ULL,
0xAEA1789F54CC6389ULL, 0xC81997C5DBD92E4CULL, 0x0ULL,
0x4B225E80008BC86CULL, 0xC748A1146D3EA002ULL, 0x991824174F9FF940ULL, 0x7B29BEA80E8995F4ULL, 0x631365EF57BFCC9ULL,
0x62A8E4A0ADD1CD03ULL, 0x4546F490D8E8CF67ULL, 0x0ULL,
0x30EBC1998987D809ULL, 0x87BCF6B240D7329AULL, 0x1E5925B58BA77AEAULL, 0x799E92A2E0393502ULL, 0x763424A598ADA37EULL,
0x1BB5942A52865F00ULL, 0xBF3388E6877CF56DULL, 0x0ULL,
0x68D4872376126D90ULL, 0xCFD546B9AEE6310AULL, 0xD9E25BE32E8D19CAULL, 0x79AFD79A5BFD93BEULL, 0x8D40E2F8A47E9848ULL,
0x4D5B6FEA63DB617EULL, 0xB8535F781C99F306ULL, 0x0ULL,
0x6680A2928DC31DFEULL, 0xCFD6A89C581CA2F7ULL, 0xA37106F26EAEE015ULL, 0xAE347CCF255388FEULL, 0x15D5ACDD2AEC6B59ULL,
0x39E1B9BB50F70B56ULL, 0x796E320AF4E8920ULL, 0x0ULL,
0x73BEDD947E18F8BAULL, 0xAED22514EDE82E29ULL, 0xC548196DB013F37AULL, 0x647FD5EA09785365ULL, 0x67CF8FB35B1052A5ULL,
0x4B1E37F5F7C5D76BULL, 0xD5C7AFD01BE5BDA8ULL, 0x0ULL,
0x55123E8E6ED46991ULL, 0xA3DBB7E6FDDD31C1ULL, 0xCA2FC2F757D4716FULL, 0x80D61D3D2675C9E0ULL, 0x10F7850275409F6CULL,
0x5428A1916FA27A0ULL, 0x59E2E2F52D76BD40ULL, 0x0ULL,
0xE0164D91C628C69AULL, 0xA5D779DB87582EA2ULL, 0x6FA60CE3D3A9FB8BULL, 0x2BAC3C77CFC55459ULL, 0x486AFF68FA11EDC7ULL,
0xE25FBCAF601EDD2EULL, 0x9DEEB39F6ECB68D1ULL, 0x0ULL,
0xFB33BAEC097180C4ULL, 0x470697BC85E56592ULL, 0xB323C99F702EA950ULL, 0x8A7DB102ACB0F7C7ULL, 0x16E412C31B93A8A6ULL,
0x7948125B9AAF4CFCULL, 0x661B13143E37BF85ULL, 0x0ULL,
0xC8667F00C1FCB585ULL, 0x99DBDF197AC87CC1ULL, 0xAA311C28B52631DFULL, 0x786BFFBCE1CE89CEULL, 0x740630596F4FB540ULL,
0x455CDA5D04AFB404ULL, 0xF6D567720795A7DDULL, 0x0ULL,
0xDCD3BF0BC0C88056ULL, 0xF38F4D0AF8B48483ULL, 0xE399210F77BCC559ULL, 0x9B9E30F7385EBC6DULL, 0x9F575C881F09F0A4ULL,
0xA7AAB529B96E4A5CULL, 0xE762769D5CDFC43CULL, 0x0ULL,
0x1B743D3C620D9E43ULL, 0x795524EDB4A3748AULL, 0xE2DC7F1C0F4CE8FFULL, 0x2BDD82DC154673E2ULL, 0x934CA1E2253820F4ULL,
0x62694E68DD5D3B7EULL, 0x163C0A3BE28693B0ULL, 0x0ULL,
0x53A73AF6E8CA86E0ULL, 0x6B616218F269A324ULL, 0xAFA5E76BB7E17DCBULL, 0xBA7B280CDA1848D9ULL, 0xF2D5096997D9DDE1ULL,
0xA9F9B9BE942EF985ULL, 0x57F1159E4E6EE02EULL, 0x0ULL,
0x3D750927586C9D5BULL, 0x4305714AD52BF7DDULL, 0x481C492FE8AFF704ULL, 0x59C064D864741295ULL, 0xDEDCC9DD9BE44645ULL,
0xA8CD3708581323DBULL, 0xAB4F5BFE82A22D79ULL, 0x0ULL,
0xF130AAAA96AD58CCULL, 0xAD7DE44F6D3A41F0ULL, 0x9C2C50FA787D28F4ULL, 0xC6DE1E50BE2D5E7FULL, 0x96EFC29A527CB8F7ULL,
0xA2706D10924C59F8ULL, 0x300230DFDB32E677ULL, 0x0ULL,
0x5E32364380720F1FULL, 0xBADA95893B98C77DULL, 0x6CC3DC39D39AEE9BULL, 0x1AEB940257DD2667ULL, 0xDFA17A12E25E87E9ULL,
0xE26C1AD7031F6F82ULL, 0xBBBF7586AB6D60FAULL, 0x0ULL,
0x48E76F5B4043AF34ULL, 0x1849831B611ED0BCULL, 0xF39B10036A764783ULL, 0x3C04C9A8CA9C7568ULL, 0xBC551F432C41F27AULL,
0xF3AB019C9B0446B1ULL, 0x102B09B7288F1213ULL, 0x0ULL,
0x4682811A47F3A021ULL, 0x5D92A10203E6B53DULL, 0x9A75EB01FD95657DULL, 0x54280FCCE0FB7FD0ULL, 0x3A5F2DD3F33AA6CFULL,
0x3338726D1314745FULL, 0x5CB73E8C2AF3AF1CULL, 0x0ULL,
0x86DE26EFF0F67A5ULL, 0xB6C2B539670EEE8ULL, 0x8726FCA9731CA2B7ULL, 0xE705B1C5BFD68B68ULL, 0x253EA17F7D91F22ULL,
0xC642B40749B3C52FULL, 0x6B14D49BA6E40A87ULL, 0x0ULL,
0xFB65F3553D372B01ULL, 0xB474E44402EAE419ULL, 0x5D9677C12834B232ULL, 0x6182CB1A2215197FULL, 0x4CFFD79A3D67CB4BULL,
0x2A6950FBE8CA4854ULL, 0x3F252F4B50DFADF8ULL, 0x0ULL,
0x429EED0A83A84168ULL, 0xCF7C04A10A3A5C32ULL, 0x1C1CB91D70BCCA32ULL, 0x7ED77CC8310DFB6AULL, 0x2FD3D398AB8876DULL,
0x920C5281A1B4CEF9ULL, 0x2A711356302F2A65ULL, 0x0ULL,
0x4FA8EB59D6DAC0BDULL, 0x3C4E31835E159C75ULL, 0xF7030C44CDFCD700ULL, 0x960B7DC31BA17B00ULL, 0x214A240C093E40CEULL,
0xF3697737E6E316F6ULL, 0x973159BCAD664FD6ULL, 0x0ULL,
0xB14E39ED17047C2ULL, 0x118612AF4AA302A9ULL, 0xB51B504E71302472ULL, 0xCDCB739535A9D060ULL, 0xE25F409EEDD59311ULL,
0x7F336C191C94450AULL, 0xD9C8B84827514835ULL, 0x0ULL,
0xE603C0F6AAE967AULL, 0x6659A97B0614F865ULL, 0x5D50E0CD8D51CA42ULL, 0xDC3705BCF2A87331ULL, 0x56EF5B6D2263A476ULL,
0xC8C5EF2A90E5CFCEULL, 0x50BB1504CD875CF3ULL, 0x0ULL,
0x27B56ED572B3C6E5ULL, 0x431192A8103170C8ULL, 0x12FBCE38CD1A12BDULL, 0xDD3E1F6AD11A56D9ULL, 0xB73D4C04CA2B4A62ULL,
0xC1B527C8F3A1EAC9ULL, 0x3CCDFE89107322E1ULL, 0x0ULL,
0xEEF88DFC68A4278BULL, 0x65B8A683E860C29CULL, 0xBDDFAA8FC8C7D92AULL, 0xF5D0BA9B16F33951ULL, 0x476D4126749794F9ULL,
0x58B7B2597EF4B4AULL, 0x64CC2DA06CADDAE1ULL, 0x0ULL,
0xA0B3E9213F488AA0ULL, 0x6A65F82183D8680AULL, 0x362CD78F0C4A8B92ULL, 0xB4766320FC61C7A0ULL, 0xAF34FF879FAB35D4ULL,
0x9B4381C17ED5A176ULL, 0xB59C6017990B76CDULL, 0x0ULL,
0xC0951FDCBC69E4A9ULL, 0xAD2CB0AE468EF711ULL, 0x7ECF3F3CEE1D69E9ULL, 0xE350D8056AFD6F5EULL, 0x59CFDA57B3EBAF03ULL,
0x51F63251DC4B4FDCULL, 0xBDFBB012A92CCBD0ULL, 0x0ULL,
0x975B0C4D01A743D4ULL, 0xC3CC330731A924B4ULL, 0xD6AEEF116764E6C8ULL, 0x952311156602B5D4ULL, 0x97B8FA7B488BB1D0ULL,
0xBAEF3A92CCD0C555ULL, 0x2DE4D450C9EF1E3AULL, 0x0ULL,
0x1EE7A2CC1649E983ULL, 0x1CC95867B8988B06ULL, 0x3B31FFD66859123BULL, 0x99AFAE56B44FF861ULL, 0x533E44753D327E01ULL,
0x489A958059B28D5EULL, 0x72163FEE60C323BDULL, 0x0ULL,
0xB67A4B0F04F2F9B6ULL, 0xE875BBB398E6B8B0ULL, 0x90D42E58250F9F05ULL, 0xA7A3EBEF5C3E6500ULL, 0xFF0B19582E7BDA3EULL,
0x7A5ECF695766FD4BULL, 0x4FDD9B3C5589B40ULL, 0x0ULL,
0x6662CD313E58D723ULL, 0x60D3768B5D1F8822ULL, 0x6073C45BBD8CD639ULL, 0x60A7F278B74EC949ULL, 0x5DF084E5D6389D43ULL,
0xF020FAB32E13FAB8ULL, 0xC11266F1BB6CB80EULL, 0x0ULL,
0xE9E6055B4BF9B487ULL, 0xD6DB1331ECB1FB9FULL, 0x25795222CA34E4A5ULL, 0x4B76F6D790DD01E2ULL, 0x1C9F67FD7208FF97ULL,
0x5EEED99710259854ULL, 0xD1523D0BAF36CF6ULL, 0x0ULL,
0xA1365CA720B828DEULL, 0x3990DA5BDE1C599ULL, 0x1AE9F17D4306A760ULL, 0x16DDB40E12247FC9ULL, 0x223061ACCF3A2046ULL,
0xEC8B85D17F086AE1ULL, 0xDC83B6A6236C28B0ULL, 0x0ULL,
0xB1481F908BDEE7BFULL, 0x7850C8E049D3F2E1ULL, 0x6C378962914358AEULL, 0x1558FC78C10E3567ULL, 0xAC3D0F4DD2F47645ULL,
0x8F81493D50CCC38DULL, 0xDC4F9347D917E92EULL, 0x0ULL,
0x2B58234833A226C7ULL, 0x9459887DE9A187AAULL, 0xE54A1263080DD9A7ULL, 0xB933AF298DE5B14BULL, 0x11CFD12122231B61ULL,
0xE5D229FB16F47C78ULL, 0x8662623E7F8F13C2ULL, 0x0ULL,
0xD6813A8169CCB19EULL, 0x300E6871138511B3ULL, 0x2FC5119BABFD8638ULL, 0xC8E5CE9BA1C4EB82ULL, 0xF76BF9457FCA9F47ULL,
0x936DF612606629A6ULL, 0xFAB64C79FFAFB831ULL, 0x0ULL,
0xE72368BCE56C3711ULL, 0x2FA89ABFF0D7DF44ULL, 0xC278C116B850DD2EULL, 0x92E2CCD644B58608ULL, 0x56328C7FAA335F2EULL,
0x7616E388ED000EE9ULL, 0xC2ADBFCED7E5A6E5ULL, 0x0ULL,
0x5D2FD244EAA438FULL, 0x938501771E865331ULL, 0xD4DEFFB1DC6CF39FULL, 0xDDE46F6188A6B058ULL, 0x98CC95BD9654F6FBULL,
0xFABE15623132D2FEULL, 0xF1717E75E8AA8AC3ULL, 0x0ULL,
0x575D1A47C8DDFCD5ULL, 0x401CC3B695356661ULL, 0xE963D3DEC637547DULL, 0xC13779A1EEFBCC7ULL, 0xF8BDDD874656D687ULL,
0x79FA2BF72F7CB86BULL, 0xCEDDBC2A9881A1CFULL, 0x0ULL,
0x72E60B3F358503E9ULL, 0x9F366612D11385B2ULL, 0xBCB5A993E279AF6BULL, 0x867D097119FF8EB7ULL, 0x6C07D3E6C668BB1FULL,
0x644EF8404B42508EULL, 0xA3097E5C1FA5203DULL, 0x0ULL,
0x237D57C7E54DEFB6ULL, 0xE3483BF9252EDC5EULL, 0x3E25939689BBB9DCULL, 0xA7365E66FA243DE2ULL, 0x3FB02C471D35F605ULL,
0x4CA867C92DA6F913ULL, 0x5FCA0C5796B51C37ULL, 0x0ULL,
0x8E9A92E4D2BD33D3ULL, 0xD8E0608C819A82BULL, 0xB1B9048A10CA13E0ULL, 0xF4A56DE7D51EC5C8ULL, 0x1064AF24DD62F2ECULL,
0xC59696DB7EE23E8DULL, 0xCFD363F64CCA16E8ULL, 0x0ULL,
0x95910228EC0B51CBULL, 0xAD5022498F9EE239ULL, 0xF9398EE3E17BA8AEULL, 0xE53D4270CFCE7C3FULL, 0x44A2E2079E789E75ULL,
0xA5C7FC00E192D6C0ULL, 0xF9CDA174C815CF47ULL, 0x0ULL,
0xEFB5EBFE4A2E6226ULL, 0x17FBE88D79BCE8A5ULL, 0x4C422C6FDD02F2A8ULL, 0xAB69ABC060C432BFULL, 0x254740FE3A8D682EULL,
0xBE3EABD0812F5147ULL, 0xC0FF5C134D963EA9ULL, 0x0ULL,
0x9D7907EA5CFEC046ULL, 0x287FCEE69FCBE1FAULL, 0x8F92C88DA58FF76ULL, 0xD57121E51F73DEA7ULL, 0x4222AC6AB8FFC576ULL,
0xDA386C5331F4FB19ULL, 0xB5AB7E3E987CB735ULL, 0x0ULL,
0x842524D85CEA0290ULL, 0xDFA19047BE0EB8F9ULL, 0xF48755E03E9365FAULL, 0x1A6E0C1429696CB0ULL, 0xAF5454E28F056FE9ULL,
0x8A880274292BCA8EULL, 0xEFCA4746C22F2157ULL, 0x0ULL,
0xC12B09349CAD19E6ULL, 0x3A929B270BBA0903ULL, 0xE613CCD03D87EF93ULL, 0x8068E71321208C94ULL, 0x2AA5DD51BA2354CBULL,
0x69168BB5AD315C84ULL, 0xBB189E7E2FFFB5B1ULL, 0x0ULL,
0x2507A31ECD1960FEULL, 0xA8AC7DEE5E51D021ULL, 0x5D06BD423062C4F8ULL, 0xE0B3847C7D6DEBE9ULL, 0x53A71B736A5FD355ULL,
0xB0AB593F6C072E9BULL, 0xBBC69262F58764FFULL, 0x0ULL,
0x458F1C78C5D297E5ULL, 0xF30026AEECC04866ULL, 0x4E205F5A17588CAULL, 0x9F4803FF82BE4BA4ULL, 0xB96C4E6B5C633F19ULL,
0xF766DB41F14E611EULL, 0xF1EA4621CCA6C4F3ULL, 0x0ULL,
0xF59527E3723C8380ULL, 0xC829C2E332FA057AULL, 0x4DFA42C65589231CULL, 0x1C2A628EE55F0BC9ULL, 0x4E1C8F9083B01D0FULL,
0xBCF464D1908D5146ULL, 0x17CCCC2DBEB8569BULL, 0x0ULL,
0xC87AFA3E6D50BBBDULL, 0x4846EEAB56837CC3ULL, 0xDC34D30730095D37ULL, 0xA45E1E43BB05ABE4ULL, 0xAF1E9A9F5BA80B27ULL,
0xD315CC5FA0CBF58AULL, 0x78C4CF5C91AB1951ULL, 0x0ULL,
0xDB7442D89B21C2ECULL, 0xF2DB0E6A6AFF64FBULL, 0xE4FD72B49E242B72ULL, 0xF0FB199D8B50CCF5ULL, 0x4D506B75BFED3D01ULL,
0xE7E754ED33FA3E75ULL, 0xC5D6609274A4C54EULL, 0x0ULL,
0x39F443F812ADB162ULL, 0x4ED37E3CE3E371ECULL, 0xD23565B9AEA04FC3ULL, 0x32CA875DA7ADFF98ULL, 0xCDA182EFFC804E96ULL,
0xDD112DC2A194F871ULL, 0xCF14668F60A624E4ULL, 0x0ULL,
0x2DE67226B79C4204ULL, 0xFF2ED2ED2A7648DBULL, 0xC82923B8157B8ABEULL, 0x3A9FF18EC01017C7ULL, 0xB7BC94D410F02F16ULL,
0x31FAA54A13EDB609ULL, 0x723F30FADEEE5AB4ULL, 0x0ULL,
0xB8C0B3A74468789FULL, 0x4AEE475EAD0248A3ULL, 0xBC3299692C1A0C33ULL, 0x292A3C1213357D26ULL, 0x2E71B0BBA23E83D5ULL,
0xB1F60A1DE4FD23AFULL, 0xF4E9BA598CFEF569ULL, 0x0ULL,
0x3E9D7B9053F26FD2ULL, 0x97E96DDE6BA1C7C2ULL, 0xFE5B886DB4842CDULL, 0x31BF5BA0D6E1CF3ULL, 0x2069257B5F1572F4ULL,
0xA894C057FEE1EF07ULL, 0x703737D26BE391ACULL, 0x0ULL,
0x21D01BC24768DED7ULL, 0x8E2C9A290ECFC92AULL, 0x5DEB9160CA5DD31FULL, 0x415DCC11A5976D5EULL, 0x6F480B6C99EDAE17ULL,
0x483C9EBD799D96F3ULL, 0xD8C17847814AD736ULL, 0x0ULL,
0xE15E57C30D44A1C8ULL, 0x3883773B3679EDAFULL, 0x9DA08E3401146079ULL, 0x1178FB96C9B4D3B8ULL, 0x1E6A1ED19EDBB881ULL,
0x2141C1DBFC363CA3ULL, 0x722FDA0858C1ECAULL, 0x0ULL,
0x7FA54E5DA53061CAULL, 0xB4FE0C5D013A0859ULL, 0x4F9B6BBABB90C5D7ULL, 0x9D3A594711801A23ULL, 0xD60DE58498286E0BULL,
0xECB5CAED7DD49276ULL, 0xF8F5770E0A70D66EULL, 0x0ULL,
0x3FDAC1162AD6EACEULL, 0xA4074FEE02C5C458ULL, 0x946240001EDA8C62ULL, 0x54A033B553B66C40ULL, 0xF334360EC5E2BCAFULL,
0xDE13F6BA3D6CD945ULL, 0xED5DF550B9E150AULL, 0x0ULL,
0xE2D8A442D40A0A82ULL, 0x81C3FDE28A52723CULL, 0x88AB63AC11172EA3ULL, 0x1411F21A318644C3ULL, 0xADC966C70AF10D5EULL,
0x39476BAED606D63EULL, 0xB4FAA6BCA4A35A41ULL, 0x0ULL,
0xD4C7195E97F7CB34ULL, 0xCF3A86F73086B523ULL, 0x30135346CE9D587CULL, 0x8DF2EE04CBB1437BULL, 0xEA2305C93F6FBE71ULL,
0x9E5941492425C4AEULL, 0x4DA32F56A1B6BE97ULL, 0x0ULL,
0x40587481361692E2ULL, 0x589694617027B9AULL, 0x52164D533C8CD596ULL, 0xD5054E91698E6119ULL, 0xE45830DD1C373296ULL,
0xB42E069749EF173FULL, 0x8DAAA0736E6FFF3AULL, 0x0ULL,
0xDA5C9E587AE6032BULL, 0x858F0CCA32052AF2ULL, 0xB1ACAC89D8B98B0EULL, 0xDE5F511CD44160FEULL, 0xF5444741930A90E4ULL,
0x8DD37929228CCAE3ULL, 0xA90F6042183E1848ULL, 0x0ULL,
0x8B9D62C24B0DF49FULL, 0x74193C235128A3FFULL, 0x41CAD5635C9B6BEFULL, 0x10982CF946E6BFE5ULL, 0xCA6A9B148E4D2A7CULL,
0x10FA0179F195D8EBULL, 0xA8A683D2DFB73D77ULL, 0x0ULL,
0x8786B2AAF489E453ULL, 0x33B6C08E3E6FD053ULL, 0xCE260B3EAD16E57BULL, 0x694F427F49D59EE0ULL, 0x97D97D161AA84DBDULL,
0x92E58F84CCAB9644ULL, 0xA55A9F861A055F05ULL, 0x0ULL,
0x7C0D6AFE8D853F30ULL, 0x8F609B62152B05F9ULL, 0xA992ED596DB9BC56ULL, 0x74AB35E7D6DEFD84ULL, 0xFAFE8D9836BA95D0ULL,
0xF20862D3EB70FBBDULL, 0x4028E9219AE0BEE3ULL, 0x0ULL,
0xBB2E3FDE3765BACEULL, 0x965B8C0C1077D2CBULL, 0xDAA67A5EA1BAC705ULL, 0x1AC73DE6803CCD86ULL, 0x387173C30DA33D04ULL,
0x2EF0FAE4716D66CEULL, 0xB9A9A5558D962D38ULL, 0x0ULL,
0xA493088074757411ULL, 0x250AEF58806D97D7ULL, 0x6FC4EB5BBFB163FAULL, 0x5DCCA769EF2DD9DULL, 0xC485EB5CF6587BD1ULL,
0x371D081816A2259AULL, 0x4FAE318EED24B160ULL, 0x0ULL,
0x71AC0107B1161AE2ULL, 0xA1A463CA9705F23BULL, 0x334319A0C8320DB5ULL, 0x61E96D30D6EC8736ULL, 0xFE643B787086E659ULL,
0x52E9526E7C77C170ULL, 0xF46948FAC2E1103DULL, 0x0ULL,
0xE2F500250C21C835ULL, 0x61FAEE8FC879B2DEULL, 0xA90874F2FA189CBULL, 0x6E2192FC2DC3C241ULL, 0xD1DE6E344DDDA18ULL,
0x12837F486B4197FFULL, 0x30A5FF30C8BADA36ULL, 0x0ULL,
0xAC9996C61A4B2900ULL, 0x1A74257B73A70F75ULL, 0xE9069BB198E3E9D6ULL, 0x29D3703DC13A71B2ULL, 0xEBA27746CB75BD52ULL,
0x8E98CED7F65097FULL, 0xD6F0BD1F081C7E45ULL, 0x0ULL,
0xEEA1D950CE6B90E8ULL, 0x605A2256FE6F5C4DULL, 0xA241839FFFD6A46DULL, 0xB3B049852994E00AULL, 0x1F351A56029B3026ULL,
0xB2019589D242FBDBULL, 0x382D30BE4403F325ULL, 0x0ULL,
0xF6D0723A3101F084ULL, 0x47EE732365DE215CULL, 0x2E4984A6BD1200CBULL, 0xB9733608C77B86C0ULL, 0x9D98F4AB0FACBF8ULL,
0x27AFC31F4F7434F2ULL, 0xF39AA6032A4804E7ULL, 0x0ULL,
0x70D4D116D1F4A861ULL, 0xD991AB66E197666FULL, 0x802B7DA2A6F16D9FULL, 0x4FA854E9FBA94441ULL, 0xB49A718C4092F540ULL,
0xD0C53DCB884F6FDEULL, 0x59FD31971827F621ULL, 0x0ULL,
0xDBF8389C17FCAD58ULL, 0x72A7810308217F90ULL, 0x923F7734406DC95CULL, 0x69323334D547E815ULL, 0x3856C6C1B29417FEULL,
0x5C19B709F1294249ULL, 0x61E13FA703220453ULL, 0x0ULL,
0xFAE46B6012364517ULL, 0xD7059705A63B90DFULL, 0xFE44238FE44F5D73ULL, 0xE2DC68EB1206053CULL, 0xEF1EFFAC4170F468ULL,
0xB4B6F9A7956A6B37ULL, 0x46B4D0BF2B081215ULL, 0x0ULL,
0x417584E03448F10BULL, 0x4ECCFFEECCC61ACDULL, 0xD568DFE96DF9C77CULL, 0xA0E0774FA00C76C2ULL, 0xFCCF3B5512EBED8EULL,
0x57D2AEC68474F70CULL, 0x7E31D589299C214BULL, 0x0ULL,
0xDA3A2B3D89DE4077ULL, 0x38E69F88FA08E7E1ULL, 0x4E4EAFFDF1293FB7ULL, 0x22F70A41A8037C6AULL, 0xF6805E491A10E1CULL,
0x5B69F47B230A823BULL, 0xEDDA72AA6CCAB0A9ULL, 0x0ULL,
0x26C1E132B97F0E9CULL, 0x8A784A57BEE15CB1ULL, 0xAB0BEE1C38EC0EA9ULL, 0xF2DAD1932687EA49ULL, 0x6D1336BA0B2202EAULL,
0x89742CF55C450CC2ULL, 0x674E1A0D82F91DF3ULL, 0x0ULL,
0xB0DB2113EEBA7472ULL, 0xEEEC0684BC9565F2ULL, 0xF4159EE389E73B21ULL, 0x9FAE7C14C6333BCAULL, 0x60B0EA039ABB6FF7ULL,
0x2E371CF47613863DULL, 0x3F9EDC8E6DFA9F6FULL, 0x0ULL,
0x5E925FFAD42F6936ULL, 0xDE768B01EF556817ULL, 0xFB67CCB78646FAF3ULL, 0x2DC874822726F8EEULL, 0x188F99FC358AC52AULL,
0xB824C7BA5ED95D30ULL, 0xF845815185BC3C2EULL, 0x0ULL,
0xD77C26A06E8C588CULL, 0x550481D4E0B79EE7ULL, 0x42CE6C5E3C30B71CULL, 0x69016A21F5FAF622ULL, 0x8BC576AEEC3AF0BBULL,
0x7BA5244A63883D2ULL, 0x2695092BBD1070D0ULL, 0x0ULL,
0x585B13706D76E37EULL, 0xE9F9FF79DC65DDEFULL, 0x684D76A606EA6955ULL, 0x29B5170F7152E3E1ULL, 0xCA3942A2A7CBC42CULL,
0xA266C745DB02578AULL, 0xCFA783389E8E956EULL, 0x0ULL,
0xBD1E8C9E1FF19D1ULL, 0x252F3CF153D6A220ULL, 0xAFDF0112398F8F58ULL, 0xDA545F5099EBE9B5ULL, 0x98A1C8F8B799EF1FULL,
0xA236B2C759F47B66ULL, 0xE0DC7CC5DE3C2CDEULL, 0x0ULL,
0x16ADE031875C73BCULL, 0xE8A9B7B5C739EAE3ULL, 0x1D9E92F8D2E6DCC0ULL, 0x5457A0C111C55ECEULL, 0xEBCE3D442B92F2D3ULL,
0xBF4DA326B83E1401ULL, 0x2F983F88D38F09B6ULL, 0x0ULL,
0xDFE95589CA7AD6DULL, 0x964F37E25E11749DULL, 0x5403916C05D4DC2DULL, 0x68BA4DA61A802E6CULL, 0x9271BB0480878B7AULL,
0x2BC3CA2AE3C5E30FULL, 0x3A95D50D93C927C7ULL, 0x0ULL,
0xE76D09A795A6CDE7ULL, 0x62738D669A8BDE0EULL, 0x935FCB11FE4E7DD3ULL, 0xFA15B019255228A1ULL, 0xF903E5F7A8E62798ULL,
0x41A3F9D17FAF49F9ULL, 0x3A1415BABC8706DBULL, 0x0ULL,
0xECB941ABD1271822ULL, 0x2C1E396CFD4E5F8FULL, 0x8CE567B0ADB129E0ULL, 0xE589EEB8FA9D71C8ULL, 0xB690DBDEFF2C227FULL,
0xA26C0ED3F769559EULL, 0x1242C7ECB72281EFULL, 0x0ULL,
0xDDE00E37A806EDB4ULL, 0x49B924C59C6757B8ULL, 0xD2750CEFDB6C06D3ULL, 0x93AC614ED3AC2D0BULL, 0x84CC797906099374ULL,
0xD3C13B21F286A9F9ULL, 0x36881AFC351FA517ULL, 0x0ULL,
0xF6B945D8DCD084D9ULL, 0x69E3F3FEF50E787EULL, 0xB3BA12B19A2B14CCULL, 0x50BD23881779DD33ULL, 0xBB3EC63F343E7089ULL,
0x8EDA25779B083B79ULL, 0x791EFD751215932ULL, 0x0ULL,
0xCCE8534E23C6E392ULL, 0x309BB21EBAF0D1EEULL, 0xE7FF3A6BD616F33EULL, 0x76010BED5EBAF1EDULL, 0x47142814380C3980ULL,
0x4A7D45B5E34E7F55ULL, 0x63F9D2778FA44F3EULL, 0x0ULL,
0x8E3E805DA03ACE7FULL, 0x19B15439DD5D1C8DULL, 0xD93550BC2D78AB2ULL, 0xDC1A3D09D32A0C6FULL, 0x59D2823685876186ULL,
0x7F83C8A5A3027CD2ULL, 0x6F922E2290907CDULL, 0x0ULL,
0x4F744A4428CA2A83ULL, 0xD1B4AB17F50EAA4CULL, 0x8CBB1DA079162DECULL, 0x913C417DDC812A53ULL, 0x2818DF26194D1D8FULL,
0xACF02DAD8383CCA3ULL, 0xE99F90C9B15ED7D1ULL, 0x0ULL,
0xD469CFAF4784F700ULL, 0x67759C99079F31A7ULL, 0xA705BE164C54A09ULL, 0xBAB02CDC77C2C967ULL, 0x667FE4198C91323EULL,
0x5FF607BA3ADBBF6EULL, 0x75BA0A0D17D64E35ULL, 0x0ULL,
0xDC4F72A04237E687ULL, 0x166BD1B972E712A5ULL, 0xA99BED9115C01BA8ULL, 0x7947D268B7906993ULL, 0xF9EB50FA2F4E1575ULL,
0xA8B7C948B2A436F8ULL, 0xB88DAACD301D3F61ULL, 0x0ULL,
0x83B00D121F631460ULL, 0x6198D4D1D49BB350ULL, 0x5907348FAF80DD91ULL, 0x332D0C2344F29B60ULL, 0xDDC41E2435B9424FULL,
0x3BFF2F507A0A6CD2ULL, 0xA06A8A70C1710322ULL, 0x0ULL,
0x4D592007B9C85430ULL, 0x4F0C547AA075368EULL, 0x10E5A4EEEFAFA81FULL, 0xEB55D9A0CB81283AULL, 0xA1164550823B9D1FULL,
0xEF5469BF388D9B47ULL, 0xFB687A71DADB9C2AULL, 0x0ULL,
0xF1A01FD22B922D3FULL, 0xCF5496103DD57668ULL, 0xD0FA7F2A356EC0EDULL, 0x18EBDA3CA8BAEA07ULL, 0xC4CC5B1B40AA0491ULL,
0x3A6E1190FB4CDA63ULL, 0x37D1E82863C4B5FBULL, 0x0ULL,
0x3C15453DBAFCD0AFULL, 0x8E7979ECBDFAC063ULL, 0x99EC734E275B0D04ULL, 0xA05CD773B97BFB95ULL, 0x2CEB5360A9E616FAULL,
0x5C390ECEBE5A7CCULL, 0x6184138CE45DDD28ULL, 0x0ULL,
0x18C81443AB0A4C6BULL, 0x7AF5B46374769D31ULL, 0x8286897DDECFC0F6ULL, 0x75FE9F7B1DC0DB0BULL, 0xF6CC76E04B76AD1AULL,
0xAABC499D38A03D1FULL, 0x48771548C306CA14ULL, 0x0ULL,
0x5D827FD2264298CFULL, 0xE6C4C687D785012AULL, 0x9A8B87989E60709ULL, 0x995159AD201A5EC3ULL, 0x40BEDC7148A6B63BULL,
0x23910CC9BA1F10BULL, 0xCD27B3F89C71ACEEULL, 0x0ULL,
0xEC4B545A8C55C3ULL, 0xCA3C1B0A29A0D6CFULL, 0xC5AB908F748ED4ECULL, 0xAAEB109932739AFEULL, 0x9F2160480392518DULL,
0x5892B92B886F1FE2ULL, 0x9CA25710156F4991ULL, 0x0ULL,
0x85F716EE305B5C7EULL, 0x7A630FF063C7BE66ULL, 0x1D4904A27F30035DULL, 0x375374E28C8FE159ULL, 0x34073A441A1660E7ULL,
0xB905191A998C4E36ULL, 0x3A00F818A1B0EB31ULL, 0x0ULL,
0x580B67B583565EC2ULL, 0x1ADDA33C44023D37ULL, 0x330913D8B056940CULL, 0x105771CBB062083EULL, 0x293D2A55F4A49A2DULL,
0x6CAB5098198BF73FULL, 0xD36F8395D8643235ULL, 0x0ULL,
0x5645231F1ADAAC03ULL, 0xB1B16FB38E768354ULL, 0xD1CB5ABABCF104AULL, 0x3478DD85F11D65C5ULL, 0xFC16225C6EB2C402ULL,
0x7FF6385A09AF2CEULL, 0xBCB962351BF9F50FULL, 0x0ULL,
0xE9845ABB676A76ULL, 0xBB5A9C6869D2CAB1ULL, 0x71CC3929443BA0F2ULL, 0x11654097768F87F1ULL, 0x4DB9B54CDF83AE17ULL,
0x5A6EA3383C867036ULL, 0xCCCF4FEC1FC5E70EULL, 0x0ULL,
0x3C0E9402405968FCULL, 0x678ADDA7E9A77B2BULL, 0xA5CC63E8718C5A64ULL, 0xB0666AA0B1272DB0ULL, 0xD635CB0BCDE1A662ULL,
0x83141F029C171D63ULL, 0xF3F45694FBF9B9BCULL, 0x0ULL,
0x3675196BE9FDCB80ULL, 0x6D740EDC74ACE3F1ULL, 0x6D7CA09F6240EC1BULL, 0xA6F30DE7D3112B85ULL, 0xFD8BDFAB9BE7210AULL,
0x5C8523E89D95B3DFULL, 0x6972E630FDDB67D1ULL, 0x0ULL,
0x28A334407FE48146ULL, 0xB5272C7DDB1BA3D4ULL, 0xD35488B83B92AB8CULL, 0xEA28F5197D7FA78AULL, 0x49E3D3739DB05310ULL,
0x4E622C4E89BEBE9AULL, 0x5733DCDDD4B28BDEULL, 0x0ULL,
0xDD1EAA3B90513024ULL, 0xF1C22233CD7A008AULL, 0xE49AD4D21C13B480ULL, 0x9D3F942190175F12ULL, 0xE477DBAFA89F683DULL,
0x56320CDDCAFB04E2ULL, 0x4573068B97AE45E9ULL, 0x0ULL,
0xA0089B7EB28238CEULL, 0x529608FE642E88F6ULL, 0xA3539CCEDD2557B6ULL, 0x72CE18356FB2EF3AULL, 0x2EA14B8BCC76EE83ULL,
0xDCD6CF2D8FBF719FULL, 0x8380A57576954C43ULL, 0x0ULL,
0xD640B92367A2C141ULL, 0x5C368C620A1447FAULL, 0x87A4D939879260CAULL, 0x466744FB01C2F58DULL, 0x48152C02CB3B70F0ULL,
0xD8D6D64781665BC3ULL, 0x70CDCC2F11A788E5ULL, 0x0ULL,
0x443BE4A30D4B6A07ULL, 0xA2421F5A07A5177EULL, 0x3C46AA892A188850ULL, 0xDBBF1B6B38710878ULL, 0xD2F9D624DE665C4ULL,
0x32858D01E9521A13ULL, 0x5CBB14BD325F9145ULL, 0x0ULL,
0x266587A429F6A38BULL, 0xF5F3220C63123F05ULL, 0xFA07FF2ED8638788ULL, 0xF0208B8B4FC2C6C2ULL, 0xBF0B0480F8943202ULL,
0xB963129641C86E86ULL, 0xB47E49216DD88538ULL, 0x0ULL,
0x9B9A55183B4C9561ULL, 0x1A3070D6D516E214ULL, 0xA40481B7DE32CC64ULL, 0x3C188D29A04E2569ULL, 0x42EC99DD39E2E5EULL,
0xB0836CB7FA801CF3ULL, 0x98CD7A89ED6BC3CDULL, 0x0ULL,
0x4938D84BA2A44473ULL, 0xB5A8D0955190A0AEULL, 0xCC1DB9F13B69B35AULL, 0x738EEDBDBF56835AULL, 0x15CE28F988F8420BULL,
0x80B91136AEB8672EULL, 0x6B6D563B58B6245ULL, 0x0ULL,
0x28824D48FA8E4438ULL, 0x3928D4F2059C617BULL, 0x518DC400DA013930ULL, 0x2EB664048F561C46ULL, 0xB84123987B5C3739ULL,
0x805EC81DD9A7A417ULL, 0x6FD7299FDE933EAFULL, 0x0ULL,
0x52D210ECF2B7128FULL, 0x5FF2BDA892668F9CULL, 0xD011A6B7C6FC92CCULL, 0xB92557DF8B65B88CULL, 0xF87047FB8B4E3C00ULL,
0x189C759A95F75081ULL, 0x7FD2389A3D292645ULL, 0x0ULL,
0x105E209CE53EB9C9ULL, 0xBDD1C9CABB86149AULL, 0x8B31254053362710ULL, 0x68060B214470578ULL, 0x88BA7AAF2317EDEEULL,
0xAEC7A930166EBB42ULL, 0x8D4F598B3DA78A1ULL, 0x0ULL,
0xE293B87DC24013BBULL, 0xED4734D14CE0EC17ULL, 0x47DE31E4BDACDCF7ULL, 0x77AABB74FF1A8074ULL, 0xF892810E357C7E87ULL,
0x46A4B6FB13191B28ULL, 0x6B190F70DBF1407AULL, 0x0ULL,
0x3AE0A0E61428ED7BULL, 0x474BE32A788B0FADULL, 0x2344FD18629E0564ULL, 0x6A1E2120D69503F7ULL, 0x170AE76DCA6CCDD7ULL,
0x4427A6F4A6831B6AULL, 0xD82F9F9A61165631ULL, 0x0ULL,
0x8EEFFAD5CEFCB7FFULL, 0x15A2E663E13EA225ULL, 0x52AEE33B15E7F132ULL, 0x5385E534F19A3131ULL, 0x9645BE53E91C6FC7ULL,
0x88B07DEB867C5055ULL, 0x293CD7240A52545FULL, 0x0ULL,
0xE29E316EF99FA4A0ULL, 0x4CD7EAFC27F3BB7EULL, 0xF5ACC678E4491588ULL, 0x4E8EA7362FABB305ULL, 0xE2E482B5BF0D8CECULL,
0x82F844B7A38D67D6ULL, 0x5543CFE5865D79C8ULL, 0x0ULL,
0xC6D4CD2022E6E664ULL, 0x1133971D5528E82ULL, 0x7072114F2C179FBDULL, 0x31564457A22E0BFCULL, 0xF55AEACFC817A32FULL,
0xE3E393C497C452C1ULL, 0x24D7203E3FA9E492ULL, 0x0ULL,
0x871CB9302CE02A49ULL, 0x9F6B506CFCCDBBB1ULL, 0x33890E086DED36F2ULL, 0x8B0F1BEDCFA8AD26ULL, 0x6BE9E47A0E334ED4ULL,
0x989D897C93467A6ULL, 0x9B5270F17FB93BE3ULL, 0x0ULL,
0x74B25A5A34E24E3DULL, 0x349B509F6F33D8DDULL, 0x6D63A29EA9281C91ULL, 0xD49AD2A6F755325BULL, 0x87CCE89A153BAE4ULL,
0xC2749D0E99D447A8ULL, 0x9360B1C058827B8BULL, 0x0ULL,
0x266BF1130FBD9D67ULL, 0x4DDC4C611DC1C3B3ULL, 0xFA6EC2B20CC6767BULL, 0xF9C1872BDCA6C463ULL, 0x34E001F0078C3F06ULL,
0x547BD72F1A0DFFC0ULL, 0x812FBD098C5061C3ULL, 0x0ULL,
0xAD3D13EEA1B57311ULL, 0x4703871D24BF157ULL, 0x5697703A4878E5BAULL, 0x5D3A01BFC11E5028ULL, 0x361A8F6A2E3D9ED6ULL,
0xA364FE69B7BF3E06ULL, 0x52EFFECA9664FB84ULL, 0x0ULL,
0x21E71DD5E23B6003ULL, 0xDCE5846D4DAC198ULL, 0xD76B79E3502F153FULL, 0x53CDAF4E3D256327ULL, 0xC675B5B34E917ED6ULL,
0x5DA9AEA139A0F45ULL, 0x47AD162AD63042B1ULL, 0x0ULL,
0x42BA89C9855E0B3DULL, 0xFC2B15671DE64561ULL, 0xBAF5BEFF67F5CD3ULL, 0x7176FDE69FC4D97BULL, 0x643CE5BA75FA520BULL,
0x9B8CE3E30D723120ULL, 0x2D16370ED09B5F63ULL, 0x0ULL,
0xF7A7EAAE00EBF686ULL, 0x9F48728085656BEAULL, 0xEF4EF3732AA67FFDULL, 0x7CCB115A862FB042ULL, 0xF2F6EC1D785B233FULL,
0xD602CFC9E0C076ACULL, 0xF6FB85E65B948CEDULL, 0x0ULL,
0xD5A6C24EC1993021ULL, 0x171A18201857AAF8ULL, 0xD502619168A6DCE9ULL, 0x20DCBEA73C3221DCULL, 0x22CE731BECFDA638ULL,
0x4BE2F878BEC95C05ULL, 0xA0597FE921BAA139ULL, 0x0ULL,
0x9F426C6A52491F45ULL, 0x47D6FD1B06E2DC7DULL, 0xFB7A9B313146E9F4ULL, 0xBA48B822EFA776BULL, 0x8FA36AC8D0716B8FULL,
0x340BAF05F16745A8ULL, 0x4A4815831DA1BF75ULL, 0x0ULL,
0x2C3BDC31CC260BB0ULL, 0x84AE8D8E1CAF7C6BULL, 0x65305AEFABA970CEULL, 0xC243B50B339BADD5ULL, 0xEDB8E7F4477383CAULL,
0x5033FA6734B0F3BAULL, 0x52F3F49578CE8CCULL, 0x0ULL,
0xD1DEEF7822995B79ULL, 0xA4ADFF69C4B2250CULL, 0x2886B32D399BB242ULL, 0xA5C2D47993C42C07ULL, 0x7AF7869EF003D3A7ULL,
0x59140F2C0C0A9506ULL, 0x74943924B45A72D1ULL, 0x0ULL,
0x678C37DFDAE2A7ACULL, 0xA48757D13FC52EAFULL, 0xB90E6197CF214AB7ULL, 0x3DCD983DD670451CULL, 0x1C53ADFDE69F7682ULL,
0xD35CE6A9C2582429ULL, 0x2FB2CE084E2ECA2FULL, 0x0ULL,
0x40C59493DE0C507DULL, 0x7C1FC91AEAF24D74ULL, 0x6D99A2AA37CFD482ULL, 0x707C098F2157E066ULL, 0x708AB5579E479B4ULL,
0x2443857C6CA9F4DBULL, 0xC93099F87DAE9EBFULL, 0x0ULL,
0x8081568124315FB4ULL, 0x67888F280886F91FULL, 0x95F3BCE4A738FE58ULL, 0x3BD827AAA8623C99ULL, 0x4303C34FC5BB9B6ULL,
0x22C08C0C617E0E98ULL, 0x7B68E75CE900BC08ULL, 0x0ULL,
0x9AB480D1EDB6E032ULL, 0xD8E7340520C67F88ULL, 0xCAFCD139746F3FC9ULL, 0x4812B4A4FC7595E9ULL, 0x59CCC0624BD3E0C0ULL,
0x9CD3902A23A59AB3ULL, 0x3DF6D765479600B7ULL, 0x0ULL,
0x345506399DD88279ULL, 0x8FD68C770A4ECB9FULL, 0x88A466D6E97AF352ULL, 0x59790884F44CCD8EULL, 0x9FADCA89907E5A1AULL,
0x83FAD8E20CA587ADULL, 0x344B251B81F0FDA5ULL, 0x0ULL,
0xDE23BF941CED34AULL, 0x19D4C1978A1A81EDULL, 0xCB601E30B5E6C205ULL, 0x71609921B929A325ULL, 0x973DE028F0879D7AULL,
0x554E186027691CADULL, 0xE0A75F1A8445CD39ULL, 0x0ULL,
0xB9A7253398325CA7ULL, 0x85BA90CC74F9D8CDULL, 0xE63EA44716384003ULL, 0xB3EA26F25FAF98EEULL, 0xC8DD9F491908A201ULL,
0x3AFF22F7926A1E01ULL, 0xB5B965E185224E82ULL, 0x0ULL,
0xFA61AA65D19F1873ULL, 0xD84649144854E31BULL, 0x37C1286685F41CEAULL, 0xA3A352C6BA6A9DB6ULL, 0xFEEF375A1A6D99E6ULL,
0x441C6300365123D5ULL, 0x12BA1639DACE8119ULL, 0x0ULL,
0xC6528DDE9CA1C0F1ULL, 0x34AE9D8BB595F0DAULL, 0x8B137AE83FD90FFCULL, 0x4D2AA912FDE58A49ULL, 0x3256DA3D731EE4ACULL,
0x4B7BE131968C4D80ULL, 0xF4F1BC172D0B8962ULL, 0x0ULL,
0x4509B82CCDDC9D94ULL, 0x572957724DCE1625ULL, 0x475AE9199FB67ACULL, 0xBD2F2482BA584494ULL, 0x8AF0554E4E766ACDULL,
0xBC0C437ACE3C6D50ULL, 0xC70FA1A7C5AF7E05ULL, 0x0ULL,
0x682938C90B4E536CULL, 0x7CF2EEDFEA09C846ULL, 0x1504CFF7201407C0ULL, 0x5331701D677CC903ULL, 0x752182E070E13510ULL,
0xA7C1C18857B8A8F3ULL, 0x755AE11F40A37A94ULL, 0x0ULL,
0x35C81EEADC143457ULL, 0x4BCA9D2A46C4DCE8ULL, 0x297B147591DDC661ULL, 0xE550765DD2CAB6C6ULL, 0x6EA5BA955A8FCD35ULL,
0xF3389BBC9C0C101FULL, 0x8B218C3DAA059931ULL, 0x0ULL,
0x965C21A459263C27ULL, 0x954C25106B0DB1A2ULL, 0xB2DA14D3DEE74097ULL, 0x9F05A5E625F2EEDULL, 0x632D76279B7A71F0ULL,
0xDCFC42019DB24F56ULL, 0x2919D8C514A1D74DULL, 0x0ULL,
0xB24CF0FDB13CA3FDULL, 0x64F9B694839E5DDAULL, 0x1777342864F6C407ULL, 0x773409ADAEA596B8ULL, 0x9DF490AB3119D4B6ULL,
0x3967EAF14A3C5A7BULL, 0x7045032F09B4EBBCULL, 0x0ULL,
0x93590682B78DF909ULL, 0xAAF98571C9ACADF5ULL, 0xCD8A926167ECDFD4ULL, 0xEA802A435978EE0EULL, 0xE28AE5B4E82F5D01ULL,
0x96835041F3F5506CULL, 0xF6FC559FFE3FFE53ULL, 0x0ULL,
0xEA89D363D6F44071ULL, 0x3A205168CF208C8CULL, 0x1273DB39A1E13D3CULL, 0x20F426F671BE6C84ULL, 0xB83B91DF1EF563CDULL,
0xD5BB762679BAF6DDULL, 0xD188AC0FB3BCF0C5ULL, 0x0ULL,
0x60EBF5A2B2A8C887ULL, 0xE1E827E2E127A9BULL, 0xCDD7E29074BDB7E9ULL, 0xAB23832D608D82BULL, 0x65C4597355A6703EULL,
0x282B15426BB5859AULL, 0x861EA50E41F44634ULL, 0x0ULL,
0xD2F6A2F4CDC1D5D6ULL, 0x2131907B68B29BEFULL, 0xA6447FB22C2442E4ULL, 0x23FB0307335C49D1ULL, 0x9F5629919F9FC60EULL,
0xF0183118588F0829ULL, 0x8443835AFC0FAA09ULL, 0x0ULL,
0x7397EC6E49C9C79EULL, 0xB5DCD84AD21DFFE4ULL, 0xDC06CE20F30B9F70ULL, 0xB826DB956CC23F9EULL, 0x735D005E03FF39FCULL,
0xCF4F88CF9F0EFD5EULL, 0xB33C6C4477DE5332ULL, 0x0ULL,
0x5C6777B1A175066DULL, 0x3727E175BC7DC30DULL, 0x9F511432EF8D6DD8ULL, 0x2F07371DB9E62D3DULL, 0x6B5446C075F12ED7ULL,
0xDA38458BD647E891ULL, 0xF270AED99FEF49C6ULL, 0x0ULL,
0x1A848B74A5B69496ULL, 0x334BF36CE0CBC78AULL, 0xA32D456F32C02BD6ULL, 0x16E1DFD891753BE3ULL, 0x9E1AA587B883811EULL,
0xF3C9E47444FC3696ULL, 0x172FC9AADF8860DFULL, 0x0ULL,
0x6B96526C4C2CCBCCULL, 0x60ECF55F961AF1ABULL, 0xB1F27957153B3C99ULL, 0x9CEB4E5B0F2B37E1ULL, 0x8ADB872948604628ULL,
0xC6CC71D4CA8173EFULL, 0xB896AE1F3BDD4720ULL, 0x0ULL,
0xDAD718933CFA774FULL, 0x80580BE01C9E3DCULL, 0x97CB12E41317FBFFULL, 0x4022760322773BFBULL, 0x3465B79868841622ULL,
0x7D4DA42F239C7615ULL, 0xF382723E3224A528ULL, 0x0ULL,
0xDB7677C5FDCDF840ULL, 0x5D0851B74A9B595ULL, 0x8A9EFDA772A5D8CCULL, 0xFC9AC6E0149E99ABULL, 0x7E8D306EE2A2AF95ULL,
0xE2BDA0145E4601AFULL, 0x4A0E014564A5EBE4ULL, 0x0ULL,
0xBB7B90757DC73703ULL, 0x135CAE5541924EA2ULL, 0x455096A7E5A6778EULL, 0x215C99574DECE158ULL, 0x26998A35A6CD4F1DULL,
0x8E40A0246AC847D6ULL, 0x6E3F27A6EFE4248FULL, 0x0ULL,
0x4C0D255AD12977E7ULL, 0xF2B80A05F81699C4ULL, 0x8EB8B7E0FD68038AULL, 0x6923932A0D4E308DULL, 0x700721B5BEB109F0ULL,
0xB0C564DEABE02AFEULL, 0xF7704C22871DF614ULL, 0x0ULL,
0x920C2BF14A3F343AULL, 0xB403B14E97395365ULL, 0x999E277887A766ADULL, 0xD04FB37F23988C17ULL, 0xDC28A7061576C2A4ULL,
0x2D9F3CF8706AED65ULL, 0xE3146941FD2527F2ULL, 0x0ULL,
0xA1E356D0A01CC968ULL, 0x11572B7C9C7A7C1BULL, 0xC0E60135B3608BF0ULL, 0x3CED520C63F654BULL, 0x227DCDA20A884762ULL,
0x8CABF4CA58988CEULL, 0xA15FFB418473403ULL, 0x0ULL,
0x2447051C1D8C581DULL, 0x96B7656C76B5C41AULL, 0x9F5AF9D4178D721AULL, 0x13A7F71BCE6B65D3ULL, 0x8D3DD9A1CB81E4D2ULL,
0x51710D9AF3BDE2F0ULL, 0x95CFB0C7BE86C2BEULL, 0x0ULL,
0xF3591DEC3355D522ULL, 0x10E987033C200232ULL, 0x17E13019466E2D87ULL, 0x8789310E7D1A4339ULL, 0xE632680ED1D0231CULL,
0x666998E1D3671D2DULL, 0x27301C1D832ED65CULL, 0x0ULL,
0xEF8FAE376A6E552BULL, 0x4E4AE958DF527E96ULL, 0x56AE66C5B2B913AAULL, 0x93C7EAA556C58C2ULL, 0xBDB873F7EEFAEE0BULL,
0x15013BA2B8AF09A2ULL, 0x2F660443C455F53FULL, 0x0ULL,
0xB0744CDBB8437BC9ULL, 0x8A2F33D083F210BEULL, 0x43036037886D93C9ULL, 0x4F1348B8CE627D5DULL, 0xF58760300C8B6422ULL,
0x8311BAC9781F0A46ULL, 0xDDBC055B53052D5ULL, 0x0ULL,
0xE0FCF3BBF8740A29ULL, 0x83523A25870044A9ULL, 0x3BC8F6020CD3130ULL, 0x4469AB1A998995A0ULL, 0xE488BFCB29A023F2ULL,
0x9A4246526A303993ULL, 0xCE1A852C82C0F4AFULL, 0x0ULL,
0xDAF1F72A8ECB6DCBULL, 0x33B88A46F64FF549ULL, 0x19AABE60A6381D83ULL, 0x4741EF7BE5D65EA2ULL, 0x6841A2DF78EE19ACULL,
0x9705345070BC01DEULL, 0x489CCC699627E89CULL, 0x0ULL,
0x8C3995A3150344D0ULL, 0x437214CFFEBA45A1ULL, 0xDA9128EFBF069E3BULL, 0xACC96FE6D3BDA613ULL, 0xB269624B50A5B3AEULL,
0x8929DEF0954F55A4ULL, 0x1DB9268F75AD9500ULL, 0x0ULL,
0xD6464832F59C3BEFULL, 0x6490F24888728E90ULL, 0x77450BE0C70A3409ULL, 0x86F577E0CD9CCA77ULL, 0x91F0647CFC614D4AULL,
0x5163A9AB8B9EEF32ULL, 0x9AFC2CD38F5D135ULL, 0x0ULL,
0xC93C5F93FF868F09ULL, 0x2C7F1F26B45E0519ULL, 0xC9094052BA7B2C80ULL, 0xFC0813D6CB98686AULL, 0x7920BE8BD719BCDBULL,
0x2BE1F8C7C5A37548ULL, 0x7BBAF0D968A0A704ULL, 0x0ULL,
0xE3C8D0CEC3370F7DULL, 0xF89FF8CCF8A4B0FAULL, 0x2A1B764A90BD669DULL, 0xFB2428B3426B6FD8ULL, 0xDC976A94E6B77E0AULL,
0x45B76F11D40063A2ULL, 0xF74061A40E33FCBEULL, 0x0ULL,
0x7BA658E9FFB7F398ULL, 0x9BCFF2167E14BB88ULL, 0x359FB24A291CE397ULL, 0xF84F4A3B4DEA0D50ULL, 0x6A63B95CBD4EBA89ULL,
0xED68B664C91B6535ULL, 0xC2CE433DE525A3E6ULL, 0x0ULL,
0x499806EED16329CFULL, 0x78C702FDE6C2F6D5ULL, 0x9DBA92C2AD959D7FULL, 0xA97F79257E8AB41ULL, 0x6C6F617FD1CFD479ULL,
0xEBC79D6A45DCFADFULL, 0xECA98E52F7D6FA57ULL, 0x0ULL,
0x21C5D504A6E8AF8ULL, 0xD323B5FA6241760DULL, 0x4F4A457956263A0AULL, 0x87C00CE7CA481E66ULL, 0x6854D8B7EED61AD2ULL,
0x6A4BFF6B20A20D30ULL, 0xCA78BD1F29994BA4ULL, 0x0ULL,
0xAFCBB5456B654B1DULL, 0xC2756A1DDB51A78ULL, 0x2F3BF3228E82D42FULL, 0xF1BFC018CB0EE772ULL, 0xC1531A97DE51D088ULL,
0x8280D5AEBB7BB32BULL, 0x4613CC103E5FE498ULL, 0x0ULL,
0x667E24A5F97E38A4ULL, 0x5DF1994D7F0A6707ULL, 0x1866F0429DABB95FULL, 0x1838DC054480D00AULL, 0xC48FDF0ABF7F669CULL,
0xF82A84030D4256FAULL, 0x1B06CB04C7898CF9ULL, 0x0ULL,
0x1742B5570F9061DCULL, 0xBCF0B17E02C09D8FULL, 0x9335E5446C11972BULL, 0x79FD33A8E90100D0ULL, 0xB8AB452E919611DAULL,
0x12B3FC1FD1CBB4C9ULL, 0xDCF0731B2BF21727ULL, 0x0ULL,
0x24049F7003F736E0ULL, 0xFD3C82AACBF7D71DULL, 0xC4D40559C447692CULL, 0xBD8315585BB9B064ULL, 0xAA87860DD9FD87C4ULL,
0xAEF7A27F3BF93910ULL, 0x4CB9F595E69B7729ULL, 0x0ULL,
0x37F14BE20ECEC2DDULL, 0xF70F70E9785D8398ULL, 0x2A2CC30548EC3166ULL, 0x4DB74DAD7082EE6FULL, 0x592CFA97CF82CA30ULL,
0x9904BFB83768F795ULL, 0xE314B78DA5CA4E8AULL, 0x0ULL,
0x5945451683BEF56AULL, 0x1B31083BDF2D7C2DULL, 0x5073F55A6F485CFCULL, 0xD028F10E14D97AA5ULL, 0xE08D83D021F6DB4BULL,
0x67F1F5CF0F928C88ULL, 0xEC7E8D5CDBAD56C9ULL, 0x0ULL,
0xC9DCF31048AA3464ULL, 0x48DF2A773FFD7135ULL, 0x4F184B739F6BAC6AULL, 0xF233115727D07419ULL, 0x66420AF228C7AC89ULL,
0xF92FF4717806D5F9ULL, 0xC16E4AD826D9A0C6ULL, 0x0ULL,
0xD080B03CDC1073C4ULL, 0x2F0ECBDD99EE70CDULL, 0x764FE7EE8E6E4020ULL, 0x4B5B0170B6262021ULL, 0x15754E678DDDA243ULL,
0x99D2D4912FEC9C6FULL, 0xAF84BAFB96963A41ULL, 0x0ULL,
0x1208D40167FB4E95ULL, 0x43C5E8FC4C4FDAA2ULL, 0x7B628E310E0C93F0ULL, 0x6B06179A2E305776ULL, 0x7E485F3A6CE5A4ACULL,
0xD26B51D0CF1D3E2ULL, 0x21F922F5C1D768F7ULL, 0x0ULL,
0xE50743A2973D57BEULL, 0xBC7BB9B5D306766ULL, 0xB22C2417F03DCF2FULL, 0x8471B6BB4C69F893ULL, 0xFF41824134EC2FCCULL,
0xB5549137DDCE575DULL, 0x411F0181B1FD2421ULL, 0x0ULL,
0x1DC67CF309E49B3ULL, 0xBB4936516610D842ULL, 0x53C7E977E507A797ULL, 0x79EDFA21832AC784ULL, 0xAAF8C86BCA5F17B1ULL,
0x5FCBF458EC91AE1FULL, 0x4C1E031A9BC79677ULL, 0x0ULL,
0xB1AB9E34E9B7414DULL, 0x45E701EC4A2583B2ULL, 0x1FA02EB486E34360ULL, 0xC6AD3DE97AD60B42ULL, 0x3BB65A2D9E92C4E2ULL,
0x9160CFC8016F15D8ULL, 0x48B5CE386D1A95BEULL, 0x0ULL,
0x2D5A524FE78F359FULL, 0x91C55CC86749EA50ULL, 0xFBDDE69F636A1E3AULL, 0xDCEF47C6DFAED1FFULL, 0x2D1B9F51881B68C4ULL,
0x8E701FB2C1393440ULL, 0xDD4B8CBCB195B716ULL, 0x0ULL,
0x40D325F83B348718ULL, 0x4A88736B4A314669ULL, 0x8243DAAE8197AEA8ULL, 0xC932AA7ECF1F7283ULL, 0xC2F95E6F172CC456ULL,
0x2CDBFB925F53B9D0ULL, 0x5D7A04EA5B10AC43ULL, 0x0ULL,
0xEE8EE10902409C85ULL, 0xD8AE3333DA0AC395ULL, 0x6126D73D63BAAD09ULL, 0x13281A2433F68515ULL, 0x370D403FFFB9B5E3ULL,
0xCD64DD089CE0106FULL, 0xB9A575914B057BAFULL, 0x0ULL,
0x29B550D9FA87794FULL, 0x1BCE4B12395DB528ULL, 0x7DE845F247760818ULL, 0xCCC57CE7B284ACD0ULL, 0x9DFE8D4ECE4F4BE1ULL,
0x4B7B1BD2CBADDE4FULL, 0x8FB364F37BD26982ULL, 0x0ULL,
0x9B246CDB97C9F9A2ULL, 0xBF66D7E68FC87944ULL, 0x43C8407EB1AE504ULL, 0x91B5B63E5D173C89ULL, 0x5B7F7427060BB933ULL,
0x18782CE31C9F6024ULL, 0x72DFD1BB1D7D81A7ULL, 0x0ULL,
0xBB0C562C2C7B583EULL, 0xDE76A84398C1AA31ULL, 0x7D20E7E7BE10E7F4ULL, 0x251CE26FDC0FA7DDULL, 0xB1FAD22A85645100ULL,
0xAC8A273EA81C1B42ULL, 0x5DF50696D00FBDB5ULL, 0x0ULL,
0x772B5C3AFAE0771ULL, 0x197CE3FC4EB742EAULL, 0xF517829EC4A1217FULL, 0xA5636735370BA4AAULL, 0x2B83C4E43A825B46ULL,
0x105B055326BD7BD0ULL, 0x79C4309283D56F2FULL, 0x0ULL,
0x79F390F8A65F2930ULL, 0xE78AA86FA2E3D1F3ULL, 0x4C9B10C63C1D2A9DULL, 0xD6C8B53918F6C76EULL, 0x79857F128B4A8566ULL,
0xD96CC64FA4105663ULL, 0xD717527C4FF355BBULL, 0x0ULL,
0xD3088A5268526DA0ULL, 0xABC0C76C2F331B3ULL, 0xF44EA257F2666FFDULL, 0xFB1C9E29FC694C7DULL, 0xF3A0CFE435333B9AULL,
0x4B6EBD103D473C10ULL, 0xE8E0835985C0D9B6ULL, 0x0ULL,
0xDDEE9C4D585B73D6ULL, 0xC6B0871B3F79BEEFULL, 0xAD8C77499C9EFEEULL, 0x503410A172B55FD3ULL, 0x88FE74EA49F089E4ULL,
0xFDC0707BB1FBCF31ULL, 0x2963F6206514B3D2ULL, 0x0ULL,
0x34424987E4BC2D6FULL, 0x3D2EE8FB3B2D1538ULL, 0x9B3E62AA8D7D495FULL, 0xE38941AD8F210DA1ULL, 0xC5574EA123E908AULL,
0xE925940ADB58DDBFULL, 0x8493A3E8EADB7493ULL, 0x0ULL,
0x70886919E60AF6DFULL, 0xD65F6B940D6F511EULL, 0x5294ED6ACBFDC4C5ULL, 0x2142CC97724247FAULL, 0x3A6EA17F15928EB0ULL,
0xC79F3A94564E7577ULL, 0x55083047782FE688ULL, 0x0ULL,
0x961E878E29AE22C9ULL, 0xA3EF438E353A2B1ULL, 0x26AACA46B6492DC6ULL, 0xBAB96217891F38ULL, 0x2CA081E20A13C76ULL, 0xF17FE747B15080EAULL,
0x59D20388B62D113BULL, 0x0ULL,
0xC609A8B3BABBA60ULL, 0x8F8CD1131C08281FULL, 0x4EB87AB39CA9A2E3ULL, 0xAE1243A6CD25D7C8ULL, 0x181A3977A535EBB2ULL,
0xAF3F609934BB97EAULL, 0xCF5261EFA5966161ULL, 0x0ULL,
0x4B08553D6049FBB6ULL, 0xF4853218A8CDE956ULL, 0x4E80B722D815982AULL, 0x51754BF0BEFC7E88ULL, 0xA3A6D08DD4BF21C2ULL,
0x376E930A2C5535E4ULL, 0x2243C3E359ECE128ULL, 0x0ULL,
0x757357BDAA6E58CFULL, 0x9CBE2DF1F6B4410ULL, 0xC3A05CC48D065F8DULL, 0x312055BBF230A13BULL, 0x86BDCCE429EC0937ULL,
0xBD1CCD9083FB8F9BULL, 0x93D66F4E285C3DB4ULL, 0x0ULL,
0xF59630012FB684ACULL, 0xD40FED07F745C87FULL, 0x1F0EE43FA7F06A8FULL, 0x6899986B106CB069ULL, 0x7DA88AE8382F5A6EULL,
0x4E947FE413D8F01EULL, 0x1DDFC1FC1C408700ULL, 0x0ULL,
0x7A0CB26950356280ULL, 0x32ECBCB02428EBBCULL, 0xF8EADB13D8C61111ULL, 0xC35AA38BA064FAD6ULL, 0x47D3172FB0D4B0B5ULL,
0x39103BB50B11A163ULL, 0x4688059E19D14304ULL, 0x0ULL,
0xF21CA82F6279ED21ULL, 0x7D8BB97047CE4171ULL, 0xB91C610245378765ULL, 0xE85B4D8459353FC0ULL, 0x4F139910BBBC5809ULL,
0xB75775B5CBBA029BULL, 0x3D5FE120EECA4385ULL, 0x0ULL,
0xF6C7D849405DAB7FULL, 0xF9556BAD2EF2F66EULL, 0xCE068DD51544634BULL, 0xAB352C6517569BCCULL, 0x85F30E62E1BAC7A2ULL,
0x26C1FC31FF4076C3ULL, 0x9757B5183FAF7665ULL, 0x0ULL,
0xDDBB7C6950B67024ULL, 0x82AAB178E46B9CD6ULL, 0x7EDCB23DD2ABC9B0ULL, 0x623C72B73A06935DULL, 0x8F8BC3CB7A8F92FDULL,
0xE7BAF51137C8B327ULL, 0x75BE148773279FA7ULL, 0x0ULL,
0x67FA273FFF3D9BB8ULL, 0xF2A6834D1BAC2EF9ULL, 0xA8A8B92C39AC8B7FULL, 0xD324DEC1F3205747ULL, 0xC0E3ED6153EA460DULL,
0x638517E52959C24DULL, 0x72721164C1F06598ULL, 0x0ULL,
0xD5F370CEADD8152ULL, 0x78FD2EC8A7119EA5ULL, 0x996C7A26F4B6AB87ULL, 0xA29D9ADCE9A7CC8AULL, 0x570CA2DCBB607B2FULL,
0x96289C58274C464AULL, 0xA4005D02DFA0D284ULL, 0x0ULL,
0x27D503B80AFBE167ULL, 0xD18540D527EEBA2FULL, 0xB31419E8A4B883CAULL, 0x6E5484E04737F7ADULL, 0x13FD97832DEBDF16ULL,
0x33777E6A377F0EFCULL, 0x51BFD5B66D73197EULL, 0x0ULL,
0x75B80299EF03C5CAULL, 0x90E56B53C0545F69ULL, 0xFADC05AB86902566ULL, 0x4A52E81BE19A1D39ULL, 0x5F58CB967C8190F0ULL,
0x5784A34D487296B2ULL, 0x23F30A6B70F1C258ULL, 0x0ULL,
0x2B5DF438C662A190ULL, 0x533B9324A98F9063ULL, 0x91284E48BBB9DFB1ULL, 0x598744CC8C941CE9ULL, 0xA7341EAC244D9D7CULL,
0x999AC6F7B5499821ULL, 0x77F114F7DBBF0616ULL, 0x0ULL,
0xE345BBAEC86D0CF1ULL, 0x77FA58AE91C9D46DULL, 0x5A772E8BD9AB7E8AULL, 0x9F74EC4C77C90BE6ULL, 0xAA31F7C57632FB2AULL,
0xB47C8D42066CD209ULL, 0x4BD503A318146C9FULL, 0x0ULL,
0xFC64A6299CC4AB2DULL, 0x353F45CC6DDA762ULL, 0xE5FB6F77A34517E9ULL, 0x3ED8D392A3E38DDULL, 0x5370602992857163ULL,
0x615B93759B3696EFULL, 0x708C33FBF7720620ULL, 0x0ULL,
0x228F4E6DE848310EULL, 0xEE6B916C38F1B7ECULL, 0xD92271FBC35F0C85ULL, 0x3AB3F7A8363C1064ULL, 0xEA0191AA6DE05CA3ULL,
0xEFAD7AE6362994CCULL, 0xD2A387F9DDF9DE63ULL, 0x0ULL,
0x9282A946DBD64342ULL, 0x39AAFB369A79F195ULL, 0xB6317DC4E09FE742ULL, 0xA05410605B13C849ULL, 0x8E65BA194F6A4906ULL,
0xB382F564C9CEADE3ULL, 0x1DF5D2B0E0C684B5ULL, 0x0ULL,
0x2E451E044F668203ULL, 0xF5259493D6BCDA82ULL, 0x1EABA5C0AAD19B26ULL, 0xCB37FBE62C4B913DULL, 0x112192AB27C07284ULL,
0x848025E368CAA12ULL, 0xF21D629ECB00CF97ULL, 0x0ULL,
0xFFEBB354C2F149E0ULL, 0xD53494495E8C4B85ULL, 0xABE0C582E620952DULL, 0xB8AFED4C429DB6DEULL, 0xDC102C647E770558ULL,
0x838EB33209BD901FULL, 0x7B0C176B43AD0FB6ULL, 0x0ULL,
0x6BAC1E24A4A7EAB1ULL, 0xE143C11FF143F78ULL, 0xC25519F8CB1AB866ULL, 0x19AEF195AC626353ULL, 0x91916553493C4236ULL,
0x1D33688C34A79029ULL, 0x7EF22C6CC1E603F2ULL, 0x0ULL,
0x6D5DDEA74433513ULL, 0x797CD0C288DA7DC7ULL, 0xA8E614322503DFF2ULL, 0x8AA0AED71D1F89E2ULL, 0x8621FA17C440C762ULL,
0x4830EB76188FF0E0ULL, 0xF3FD5A3634797D98ULL, 0x0ULL,
0xAAC99D37855586E4ULL, 0xD87877776C92D438ULL, 0x8473D78A50A9C64ULL, 0x5C85D0FE128D217AULL, 0xB407F6D363B698AEULL,
0x117E74B763522AD2ULL, 0x45D5C4B66CDF44A8ULL, 0x0ULL,
0x305FF22ABDA3C5A5ULL, 0xE66E9B79934C506BULL, 0x3A3A1E95807BBA4EULL, 0xAE3EFDEB9C7E54E2ULL, 0x9135C74B2FAF1A22ULL,
0x90F97A8FCA3E56E6ULL, 0x199FEEFEB17B8DD9ULL, 0x0ULL,
0x1EFB2566661799E8ULL, 0xC45863A9A3518570ULL, 0x6DD9C4FB7FC3DD23ULL, 0x22279AEE72F0A1F9ULL, 0x6AF383185E2C4C09ULL,
0xA3C705DB59212118ULL, 0x8C496744D0B1254FULL, 0x0ULL,
0x3F5C5CBF8EDDDF4AULL, 0x8ADB054E7546229CULL, 0x98913F8FDD858FDFULL, 0x23A4E626CC92235BULL, 0x5F97C883DB757897ULL,
0xB276A898B92F8584ULL, 0x1101FE99A281079BULL, 0x0ULL,
0xA0EF9581495B29ADULL, 0x5EDD2126F58C6588ULL, 0x24AD700CE868D355ULL, 0x617B1006BC1D1C0FULL, 0x2181E9F84D4CB777ULL,
0xCE244D2483367C79ULL, 0x1038FDA6EC467F7DULL, 0x0ULL,
0xAFE8B2D1263A2038ULL, 0x2F4F1DDE6E913829ULL, 0x1821465CD1A88AD9ULL, 0xA3D0A01F2687E81EULL, 0xE095362146F67F25ULL,
0xF49FBEEEAF387A71ULL, 0xACC19B7C6418E4CFULL, 0x0ULL,
0xFC649F1EA153A74DULL, 0x17C4019CCB49E6BCULL, 0xBE7B9306203AA22CULL, 0x191A520FDB981199ULL, 0xFE7D4969F798AB7FULL,
0x5AC309F52092001ULL, 0x108C38EFB84CC365ULL, 0x0ULL,
0x3274E10A5FE6DC13ULL, 0xC32945940B68754FULL, 0x209AD070D86D2E91ULL, 0x5D9D0C5972C26CCAULL, 0x25322A6F5BEA21BCULL,
0x2DBB0E8DAAA90215ULL, 0xE82DA8F6EB304EBAULL, 0x0ULL,
0x48A2231841DB1B4DULL, 0xD657B718B3C11582ULL, 0x9131952E1835CACEULL, 0xAA773227667FB410ULL, 0xB13B7AEA9C479CBULL,
0xF55D7283DE5FF71FULL, 0x51B834BCC261C7AFULL, 0x0ULL,
0x55F0DEE2D12E76CAULL, 0x606F727BBAC46CF1ULL, 0x11B713BAEEBE7564ULL, 0xD69835C26F465B9BULL, 0xF5EC99EC884CAFBFULL,
0xF347CD25A3EA63EAULL, 0x92F88B922FE55E0BULL, 0x0ULL,
0xA1D3C3E3C965BC97ULL, 0xE1692F7D75FAD937ULL, 0xDCC7021FC49C29D8ULL, 0x37529DC4C92E7E96ULL, 0x5B1CD90E13FDBA5AULL,
0xDD6852894B94AF5ULL, 0x88276E24F48B3382ULL, 0x0ULL,
0xE830D6CEE7DA5D16ULL, 0x6FA2514131465D96ULL, 0x34C22F2B67FA36B5ULL, 0xC8B7A44D714F22A1ULL, 0xA76E330BB240B1AULL,
0x1FC99C417F104D54ULL, 0x7F5134C9A2F8F0E3ULL, 0x0ULL,
0x94ADD8503FF9D915ULL, 0x7357135D58EC053AULL, 0x703487761C746303ULL, 0xB910978B6837FA09ULL, 0x983E4B3006295A74ULL,
0xC7BD87E0E4B9FD61ULL, 0xCB606EC4251189D2ULL, 0x0ULL,
0x374FD8BDE500A031ULL, 0x7DFCBE38338B272CULL, 0x7D3AF57E9999F5EFULL, 0xF7AA4A8C6FC1522ULL, 0x90ACAD2EA1AA60EBULL,
0xEA0D2983FD5640EULL, 0x79B3FB0D9B0279BCULL, 0x0ULL,
0xFB88BF3F229A837EULL, 0x964BDCD071CB8DBBULL, 0x4EE0FCBB158863D8ULL, 0xC406778F33A06038ULL, 0xB4D391E4D8BD46B0ULL,
0xC3F768CA029B8FCBULL, 0xB57A76378626DA40ULL, 0x0ULL,
0xC0508694EAE7ABBCULL, 0x765DD3562D692DC9ULL, 0xAE24C4A49479B4BFULL, 0xE428F2B384E683A2ULL, 0xD61F78395698043AULL,
0x9531D4190C91354BULL, 0x85CC90AD71891024ULL, 0x0ULL,
0xE5009055CFAB9C52ULL, 0x31EB23B98DA6EA6BULL, 0xA79A1963497394D0ULL, 0xF875C0D4C2C93F36ULL, 0x3B08FC66415525B4ULL,
0xC47F48DAFC242925ULL, 0x815DAC6F51384B51ULL, 0x0ULL,
0xF83D7394303387B2ULL, 0x379FA9BB406A97FULL, 0xD1971A171A6F949AULL, 0x63FBF8747F801D34ULL, 0xB5714CB278133D3ULL,
0x94A763AB52406F13ULL, 0x1D49D45C46571F72ULL, 0x0ULL,
0x265696DB23ABFE99ULL, 0xF4464A498E7B5777ULL, 0x1FC2EF3C286D2229ULL, 0x57E1CFE658DC8D38ULL, 0x7F9615F9861EBD02ULL,
0x7DD3932C27736FF6ULL, 0xAC11BB78A9CFDE79ULL, 0x0ULL,
0x90802FF26D34D662ULL, 0x26B1178F190CD04BULL, 0x37876404A88ACB08ULL, 0xC5A093573568AD4CULL, 0xBE0B15B2D1B5DB16ULL,
0x7E37A028238CB2A6ULL, 0x3601E025871D440CULL, 0x0ULL,
0x6CFDDF971B7FE393ULL, 0x637F116FDDAA13B2ULL, 0xE965439E5F517AE2ULL, 0x9A2BDD09B96154C6ULL, 0x70055C252872C52BULL,
0xE3A8BEE371EF1E24ULL, 0x4F82EC074EE54311ULL, 0x0ULL,
0x41E87F492216EA5EULL, 0x9CF95E838551B87BULL, 0x2914DE7F4DFC3DD4ULL, 0xE7C1259C26639382ULL, 0x7F955FF5FDB9CE71ULL,
0xE0F709F4918B04D2ULL, 0x5AD20981A8EFF48AULL, 0x0ULL,
0xE3EEF6871F77EC5BULL, 0x8176C92F023F405BULL, 0xC019C5451A914BE7ULL, 0x823F411B6908825AULL, 0x406D7C39033627BDULL,
0xC3DA53E7F4B9CE02ULL, 0x86BA4B756D65189EULL, 0x0ULL,
0xC9A22EA5703B544CULL, 0x323810416CB16003ULL, 0xFCE46C94FCB2B90BULL, 0xEA7D505E8FF3812FULL, 0xCF1BEB121C0F0459ULL,
0x2C51922DF3B26694ULL, 0x4E59C9E7DA3817F9ULL, 0x0ULL,
0x903E93DFE38132E7ULL, 0x3854831D7FFE4D70ULL, 0x9B9202186CE4FD10ULL, 0xEBFC088862A6AC7FULL, 0x8974F4694102B47FULL,
0xB7A34BA4BB325528ULL, 0x7890CA14B18525ADULL, 0x0ULL,
0xA3434F9D0523CDCEULL, 0x4DB5FDBD3E41615BULL, 0x2C9500C6890C7BB2ULL, 0x1AD28B566D028C3BULL, 0xF37E43B4A23A21A7ULL,
0x629EEB46863961CBULL, 0x36040A147361485CULL, 0x0ULL,
0x5D7776E15D31BC4AULL, 0x8B5E9511D3ED011AULL, 0xB3B7B0698F016FEULL, 0x3C8D66FE8917F3EAULL, 0x4E38780F60922E2CULL,
0x139E92019912AC19ULL, 0x76290E9205CEE699ULL, 0x0ULL,
0x703F77A42FC07708ULL, 0x1F4240845A91CF37ULL, 0xFA94C4D8699B3A83ULL, 0xE8E4721EC1C592C3ULL, 0x41CC3EC19909A6BEULL,
0x85A861ACC8B899F2ULL, 0xDB58BD02ECC11D99ULL, 0x0ULL,
0xDB0994EFCC09C885ULL, 0xB80E0A404248AF9BULL, 0xFE670797EE2C2855ULL, 0xF4A217B84CCE6B28ULL, 0x8AE96B15B36C88BDULL,
0xC2E854E2AA429939ULL, 0xF6EEF42C74927C6ULL, 0x0ULL,
0x172779EBBB9904CFULL, 0x2D5C26312B15D00AULL, 0xB83E478420BD6CD4ULL, 0x6443C140A416F167ULL, 0x765E85CDFD15D716ULL,
0x596D00F8AD4C78DULL, 0x96D5A9836E9DE880ULL, 0x0ULL,
0x54218E6D407BE553ULL, 0x2F1983688902F24EULL, 0xD892AFA5CACA040FULL, 0x5B459CDA21034E9EULL, 0xB268052C8AFF6FCULL,
0x889D8E97BA40EC8DULL, 0x55970D1280E3585AULL, 0x0ULL,
0x6ABF18B3118FBBFEULL, 0xB14CE45EFAF93888ULL, 0xBE31AEEA603BEAFFULL, 0x889D805AD9F859D5ULL, 0x5C584F01F227E4B4ULL,
0x1BE53C61902FE585ULL, 0x96D5B62E52FCED15ULL, 0x0ULL,
0x924C4EFFE938515FULL, 0xB8069F0CA914F16CULL, 0x1100D7C35661A9BCULL, 0x29BAB7ED282ED822ULL, 0xD38DC7881E3B83DFULL,
0xF9B9DFBF6F7E9144ULL, 0x5032FC0CB5AD4704ULL, 0x0ULL,
0x71760DF99D600BB1ULL, 0xEB9CAA7034F999E0ULL, 0xA422F43BEE935A52ULL, 0x6773F9846051E0ABULL, 0xAD3919ECEE70AC43ULL,
0x3D1920B13E9E473FULL, 0x3A5C06B7FCB6E665ULL, 0x0ULL,
0x27E2CC64DC8E798CULL, 0xA7BCD85B4A0400C1ULL, 0xBC32E85563A2B7EEULL, 0xB7E4AB790450EF3AULL, 0x2E7D72C5E8D6D3BAULL,
0x8C3E5B63E7288B4ULL, 0xDEB39CD0CECE084AULL, 0x0ULL,
0x2C6008F5F8AEF388ULL, 0xD8CE4BE1EC25A933ULL, 0x4EC78105BF0A554CULL, 0x5E31AF299C19EC35ULL, 0x8896D1183677D039ULL,
0x7E12D74889CCF566ULL, 0x7591D6F7C58FCE44ULL, 0x0ULL,
0x4635DE118828D9D3ULL, 0xD9169442253A4044ULL, 0xA4E2B63B3C75C890ULL, 0x5AF4D47E89634DD3ULL, 0xB502CDD54C368A2EULL,
0x7C6A9C6054CB5AF6ULL, 0xF6D75CE5B0752D76ULL, 0x0ULL,
0xD5969662B54E3048ULL, 0xBA19E77829BB0A0EULL, 0xAE0B57BECAF9C2B1ULL, 0x31756868ECC12DCFULL, 0xD5EBBE9B1B805FFDULL,
0x81BCE4A689317615ULL, 0x721A2353308B48F7ULL, 0x0ULL,
0xD660917FDC2E9F6CULL, 0x6BFA1772E1690E6CULL, 0x2B398AE46D00E5B0ULL, 0xCDF3FA11ACBF41FULL, 0x7AC54278E1EC14A2ULL,
0xAC11842EE1128D6AULL, 0x23731568A6469945ULL, 0x0ULL,
0x630B5FEDE800F54BULL, 0x16C136FCC2BC6892ULL, 0x763924347DC8F9C1ULL, 0xC4EF6D21D4D91462ULL, 0x54DF581DDCCC0A53ULL,
0x33EBBA0AFBBDF4F6ULL, 0xE212444D19FB6CCBULL, 0x0ULL,
0x4AE24A6BB0B795B8ULL, 0x71BCB46C17CF55D1ULL, 0xCF5AA21D3198B93ULL, 0x8E75239B6B2FF86AULL, 0x20AEB882179234A3ULL,
0xD0B24DCB3DDB95BFULL, 0xF81873BCD63AE6BAULL, 0x0ULL,
0xBCB36229673C8AB0ULL, 0x9EB4528CB8C6D49FULL, 0x9A331380E94EB6ULL, 0x612E773EE06B8794ULL, 0x260925F20B1490ULL, 0xB450DE3A60F84E7CULL,
0x62C03108C1227809ULL, 0x0ULL,
0x7337469BF79446DBULL, 0x8A5A5A9E79218EFAULL, 0x774FA82656674B1CULL, 0x835BB9ED30F8658CULL, 0x59E9FF7C30C0EFF2ULL,
0xE7E76B5B3DD28D55ULL, 0xEFE0854033A1625AULL, 0x0ULL,
0xE67332B02B28F727ULL, 0x4BEB071BA12F2D0FULL, 0x7CCC98D62D38A369ULL, 0x81A6373F41FE06EDULL, 0xECD9E476E9F265A5ULL,
0x87D4C03533EE6902ULL, 0x2825055648B6101AULL, 0x0ULL,
0xD67706D644A07572ULL, 0xB1623CF79E9E59FAULL, 0xB5D6CF6EAEE8FD70ULL, 0xFF02AEBE74AA601DULL, 0x37758C5BAC226CAULL,
0x6337BB65B02B94DBULL, 0xA97A9619B7A243BCULL, 0x0ULL,
0x5DF8A7E647E30DB1ULL, 0xB548C84CC3F458C8ULL, 0x64339AF3D652943ULL, 0xDD62453A2FC1C026ULL, 0x5067681ECE491464ULL,
0xD4169529B9A3A9C6ULL, 0x73B6C54D115067B3ULL, 0x0ULL,
0x3BFE59833FD47B4EULL, 0x535E55EB6FEC2D14ULL, 0x25FE4E33A5A8AF63ULL, 0x48DEED0D3142D48ULL, 0x6E1B12ED6D5FF472ULL,
0x62FAD3F5B499F29DULL, 0x6AEC0A12DFAE497EULL, 0x0ULL,
0x62EDD18C1287D7D3ULL, 0x357863A9AA53238FULL, 0x876398781A8C9EFEULL, 0xAFC09EA91B530999ULL, 0x427F80B00D36971FULL,
0xA57894D36C98250CULL, 0xC7F38A76EE9166B0ULL, 0x0ULL,
0x14DD1FD724E09400ULL, 0x122B497FF7868F8EULL, 0x15B9A3840946221CULL, 0x2947F9AB28FDA609ULL, 0xDBE597E3CA012D6CULL,
0xBF70DA5DC0BE0DA2ULL, 0x850E6D26ACDF7921ULL, 0x0ULL,
0x31DDE238E3CDD92FULL, 0xB99D02C6A64DE4BDULL, 0xB60B33FE5810C321ULL, 0x927C1B98EF2C1BA7ULL, 0xD75A7B6B27352C1BULL,
0x90D232F4C1C5D72AULL, 0x72972A8397CA40ACULL, 0x0ULL,
0xD3CED6DD95597C3EULL, 0xA38A25B86F6FB26CULL, 0x8E6C0F9679F41886ULL, 0x5462ECB5A0CBE417ULL, 0x99802EE39EB15E09ULL,
0x643B25D98783E781ULL, 0x17B0E4543528B361ULL, 0x0ULL,
0xE43504903615C0C0ULL, 0x71992E7667783DBCULL, 0x50108A8994CF7CF8ULL, 0xC782038A1C0EC2E5ULL, 0x4DE0113FFAC0649DULL,
0xCA83D3605505AA1AULL, 0x70FDF1C8440B225FULL, 0x0ULL,
0xC36BF785CA70DE2FULL, 0x78A0EF898BF23B04ULL, 0x458EBDEF70A379D6ULL, 0xAF6EBE94C7216FFDULL, 0xC8330EBD9C54CA15ULL,
0x47FEEB3589F5EBD8ULL, 0xE0C1B5E7BB689D91ULL, 0x0ULL,
0xA7E4ACD1864EB43ULL, 0xB134B8E35B0FE269ULL, 0x4AE11CF2F66F61ACULL, 0x58BE7B378155431EULL, 0xE68362AEA863FFAAULL,
0x1EFFA5EBE6F3A031ULL, 0x601A3A08A9FD42F8ULL, 0x0ULL,
0x61FC589E1422989FULL, 0xBC07B4CD30B52CB6ULL, 0x583DB63E700AEEB6ULL, 0x830315F58796BA5AULL, 0xDEB596A880686C6BULL,
0xC3CFA8C9749C1E7BULL, 0x604932FA594D536DULL, 0x0ULL,
0xBEE44C16DA5210D1ULL, 0x2B1398547D382698ULL, 0x9ACDCDF16884E88DULL, 0x333B5E9385037753ULL, 0x1A9A060569442302ULL,
0x96A6D008F2E61558ULL, 0x53F3B844BD1A2D9ULL, 0x0ULL,
0xAC31FB7EAC194066ULL, 0x68DAA81B51F0AF7DULL, 0xBD68FF6D466EEB8BULL, 0x38034FF8E8532F90ULL, 0x7EB248DC6E815D5ULL,
0xB3F638CBA0D67C04ULL, 0x22AEC063E2345D6AULL, 0x0ULL,
0xE98D18F8D0E50335ULL, 0x89D3263AB4228D8EULL, 0xBC1D31C950374DE6ULL, 0x34BAC3B33FDF977EULL, 0x459A5420F9B8411CULL,
0xEF4752CE1779FA3FULL, 0xA333B2EB7623DD59ULL, 0x0ULL,
0xADB4342ECAE842CEULL, 0xFEDCA8C42FDF5EC8ULL, 0x1094E39A2FABDA34ULL, 0xF617A1EAD9B5AFD8ULL, 0xD54C1E1F9F93B073ULL,
0x3A40234FAE2DC7A6ULL, 0x4893C6BB8F004C43ULL, 0x0ULL,
0xB66142E8E7CABB63ULL, 0x1FB444D428E05B3ULL, 0xB933BCECE404DC4ULL, 0xFB9EA09008B8F5BBULL, 0x7F3F89613919DEC7ULL,
0x93E6744C931ED5CULL, 0x481FF80FF146A37AULL, 0x0ULL,
0xAD0846A3DB88DA12ULL, 0x3274E6E390EFCDDBULL, 0xC58495F10208BB8CULL, 0x1FB567546A8DDEE0ULL, 0x2BE0564E1B719E35ULL,
0x507D5164620C8277ULL, 0x6D11D30085CBDB98ULL, 0x0ULL,
0x2325E3DF57845343ULL, 0x121CA992289B4752ULL, 0xC5B0F064863F1A3FULL, 0xCF093C5FAA8B11A6ULL, 0x2376BE6AB61A0109ULL,
0x646FA4984654442FULL, 0x4D5C0FF17E6632DFULL, 0x0ULL,
0x529CD1D811346277ULL, 0x454702C58DD61E5EULL, 0xB6388B84332743F6ULL, 0x335E0ACFE1569262ULL, 0x61026DAF7902E258ULL,
0x3E27EB059154E781ULL, 0xBD83AE96B6880E6CULL, 0x0ULL,
0x4C9D045FC6DD0638ULL, 0x2C8E3B3047515951ULL, 0x44AB006D1E042C7DULL, 0x3A51EC5EDE9AC9EFULL, 0xEB53F1463AF03086ULL,
0xA3275BB656A59A30ULL, 0xBF346AF92715263CULL, 0x0ULL,
0x7831767C2CAFD732ULL, 0x75028425CEE0DA38ULL, 0x2C6E5C6BBC876E7BULL, 0xE3E7E13BF8A30A3EULL, 0xE18E97BC4961C68AULL,
0xD680C6DABF8AA21ULL, 0xDFB75199920C3612ULL, 0x0ULL,
0x81EB2D5522F7AC82ULL, 0xB698795A3FAD241BULL, 0x80E4C4F4E31D4768ULL, 0xE97E83C3B33233A1ULL, 0x26D104BBC22991CBULL,
0x3CBE0404D5383086ULL, 0xEBF3803FF04F9237ULL, 0x0ULL,
0x2159443E4E67C117ULL, 0x8A257746EEEB043FULL, 0x9F7AF3E1E2CB3BFEULL, 0x8DD258BA80F6DEA2ULL, 0xD64EA9D6083F6C0BULL,
0x9DAD6D064C1753FCULL, 0x94CB7BAC33CF5EF7ULL, 0x0ULL,
0xFE8F9CA8E4FFA787ULL, 0xA2364EFA7B519ECFULL, 0x1336E940BAC51948ULL, 0xB8BE0FEACE7CF676ULL, 0xBBD82D84EEA846CULL,
0x6A178DF255E3D24BULL, 0xC43784E91C9CE494ULL, 0x0ULL,
0xF9F1DF6BD1C5512ULL, 0xC2BA1D2C8F8BA11DULL, 0x494C4E0FCE2194B7ULL, 0x6098F9E3A54B522ULL, 0xE0D2AF656C2B516FULL,
0x3A0F9FE93810CEDBULL, 0x504CC6747F8A4042ULL, 0x0ULL,
0xAF51E7C2C0D16701ULL, 0x9C29F2E9176C708FULL, 0xD5378FA4A3107EB6ULL, 0xD55BF30D568FF029ULL, 0x964A982B5029CF3EULL,
0xE4D611AA52E7B010ULL, 0x18C4FB8801552EF7ULL, 0x0ULL,
0x7DF5B17F4DB47FAAULL, 0x6D262B4E999A3C7FULL, 0x4995FB385BE036C6ULL, 0x3194BC35AEA975ULL, 0xE63F9935E1316607ULL,
0x2D4F343E7BCAA2DBULL, 0xB5BEB8CCE7BD91B3ULL, 0x0ULL,
0xF65F90D5055C5D69ULL, 0x884E4AF99BA0C561ULL, 0x5A4D172492948DC8ULL, 0x85FFD276C51C76EBULL, 0xBC852C2B0AFE3820ULL,
0xF0A28F186FB2BB4ULL, 0x97F4AC5835F5874DULL, 0x0ULL,
0xB69A8ED6AE31F653ULL, 0xEFB90759284E0DA0ULL, 0xE0810FBC8112CE28ULL, 0x605F0E7FB99E2964ULL, 0xB9D4C120D9CD0125ULL,
0xD2273224F420AD14ULL, 0x78ED2C3EDC3EA4C8ULL, 0x0ULL,
0x39DD331010D1B907ULL, 0x7C4046E0D32D599CULL, 0x7EB69F8003E80F6BULL, 0x4249A22BAB745F21ULL, 0xC7FF8A8BA84FF548ULL,
0x374A49EF1B0A0693ULL, 0x4C2B3D155D1797A8ULL, 0x0ULL,
0x5185589AE7095877ULL, 0x6118A198B522D2B2ULL, 0x6B9038AC8E7CC1EULL, 0xD19ACE96963498B7ULL, 0x8BB4912550E6E78DULL,
0x127472F66158EA38ULL, 0xE87C7188C1B5E647ULL, 0x0ULL,
0x1E538E3ED2E7F066ULL, 0xEC63676FEE32D20CULL, 0xCDB0AD84F54E1959ULL, 0x49529A95782F1E12ULL, 0x1A49DC0C0244C953ULL,
0x5849E8CBD2FAF211ULL, 0x3D83D46CCA22BFC9ULL, 0x0ULL,
0xBD66CEAFBF59DD3CULL, 0x776DAFFF0A7FA557ULL, 0x13AF4B764BC7EC88ULL, 0xF32D626C1CD2093DULL, 0x663B102391B36DDAULL,
0xFA03AA78581F76DFULL, 0x3BD3277F3D6A8EABULL, 0x0ULL,
0xD673777C9653D379ULL, 0x1F83EF404F71ED14ULL, 0x6C6F223F5931AE36ULL, 0x2E8599DE0D92845BULL, 0x8F2775B852312921ULL,
0x84E2E5D21AE0A90FULL, 0xD84B605D9E0E9BA0ULL, 0x0ULL,
0x3AD6F89ABABCF37FULL, 0xB5A771BEA87FA993ULL, 0x91926D4556C7A956ULL, 0x299851945E352F19ULL, 0xD38169481CDBE403ULL,
0xA1F4608353C54774ULL, 0xFD9B5FCA9451B8FDULL, 0x0ULL,
0x72B68E502BF3D838ULL, 0x2AADAE12F0A8E403ULL, 0xFC3C1436DC162832ULL, 0x4D7BFD6A3D4DA71FULL, 0xDA40F0790DAC45EBULL,
0x11F788A9B55830CBULL, 0x3E8DF71A7022184FULL, 0x0ULL,
0x3B4CC3DAD8819FB6ULL, 0x2EFA67C623ECC9D8ULL, 0xE403B3B014CA2597ULL, 0xCB25153310D693D1ULL, 0x803A75EA73F7EACFULL,
0x77EB7D88501DE087ULL, 0xCC319D0A8B3379C7ULL, 0x0ULL,
0xAA6ED89E47E50D57ULL, 0xEFF23E1FCBF4921DULL, 0x43D835D788673170ULL, 0x5E79D1D804B8F159ULL, 0xBA0344D22F6EFE96ULL,
0xB1D4DC8B901B66B9ULL, 0xEFD56A02A046B7C8ULL, 0x0ULL,
0x12F696BF61AB218EULL, 0xCC7CE402FB2F36D7ULL, 0x3F95C5294037A0F9ULL, 0xCB586A6ED94A0BD7ULL, 0xE0E7B2115CBF85FEULL,
0x17E7110683BBF041ULL, 0x5121DFB6815B5785ULL, 0x0ULL,
0x5D57EF9903552E5AULL, 0x1FB2B6C7C6C06CBEULL, 0x38B2058B2500F5D1ULL, 0xB4DE03E59169B62AULL, 0x33E20CA4CB9CFC95ULL,
0x421A380C2B05849AULL, 0xA3BD60221C85DEAEULL, 0x0ULL,
0xF6730D6E0E9F115FULL, 0xF248C4711FF16897ULL, 0xE0DA312C78779170ULL, 0x23D1F92C3C862B90ULL, 0x91320664D537227BULL,
0xF7E0CDF44CF9B4DFULL, 0x9353991E8FEF51DFULL, 0x0ULL,
0x27DBAEF357A6E1DDULL, 0x4820521016F7ACE7ULL, 0xD50E948EECC76977ULL, 0x7C5978D4D61FCB63ULL, 0x38129240E3B55A02ULL,
0xB056E71622115461ULL, 0xB339743357073D05ULL, 0x0ULL,
0x97EE15491F140F79ULL, 0xE413F415DADFA499ULL, 0xEFF6719C03A7BB56ULL, 0x48B58ABB656625E2ULL, 0xBE7141A6E39BAEFAULL,
0xC907C3B6746C77F4ULL, 0x1402E2294284E445ULL, 0x0ULL,
0xBE80FBCE8ADC8A2EULL, 0x30A1BC599D7EB598ULL, 0x22DD37FD90F64A21ULL, 0xA02360DF519E1629ULL, 0xF7502F5C3F5A590DULL,
0xB84831B9B4AB7A15ULL, 0x22D9ECD7B299683BULL, 0x0ULL,
0x598FBDC2AC346D22ULL, 0x8C3E07624672BD51ULL, 0x1C9B4F80D964DBD3ULL, 0xCA09407A3068102FULL, 0xC3DA50514C9CA9BEULL,
0x385476219FF38235ULL, 0x8065540595FDF5F5ULL, 0x0ULL,
0x8544F4E7916D5463ULL, 0xE7D7A025DF111221ULL, 0x3D5394FA6B299D7ULL, 0x764E3365AB6D395BULL, 0x222170C0324FE37DULL,
0x64F600F12C68730ULL, 0xC633EA39E1335F2ULL, 0x0ULL,
0x12963E9BAA6A3BCFULL, 0xA3972E1933405244ULL, 0x943D76969A166999ULL, 0xCA815EAC4F50E15FULL, 0xA98F3E2AB9A9EA03ULL,
0x1F60B7DFEE7921EULL, 0x9773B39923BBFB32ULL, 0x0ULL,
0xA19ABB23C5AE6A4CULL, 0x9992482BE7F3C21ULL, 0xB8A30486AF98D946ULL, 0xA6B923B544AF5659ULL, 0xE0A53EE53F5BA627ULL,
0xF9627A169C400175ULL, 0xAEF65E006D070222ULL, 0x0ULL,
0x74E106A3628F856DULL, 0x813D402C41ACB2ADULL, 0x7893C19E2715DD3FULL, 0xA8762472F64A5AE0ULL, 0x368842BA2D1DBE02ULL,
0x3736EA4528CA52B3ULL, 0xC5BE5924FAFF7B57ULL, 0x0ULL,
0xB175ED2524992CA8ULL, 0xCC21AF9FC61232A9ULL, 0x3AE8A4B041159054ULL, 0x4AA1561F75369FE2ULL, 0xDC0E27C0DA8018AAULL,
0xC64270EB853D9AB8ULL, 0x62D7076EA55DA479ULL, 0x0ULL,
0x2EB0FD44C733422FULL, 0xFED6E9AC82A088EDULL, 0x9A3817F0C99C28E2ULL, 0x95DF173CB9CF657FULL, 0x38264FDBAD4E2EE5ULL,
0x10FA83626104A36FULL, 0x956F84065F21DAE8ULL, 0x0ULL,
0x59B5F03E223490D4ULL, 0x77AEF9454FDA0350ULL, 0x9960F072B39DDECBULL, 0xE9413F08B093A9ADULL, 0xFB543C2D10794565ULL,
0x74D8CEB7A0439DE2ULL, 0x76160C953AE12F34ULL, 0x0ULL,
0x10B7FC89426E48C0ULL, 0x10DA7942A7AA2DBFULL, 0x4C312A32C1B8329BULL, 0xE0D91F799E85B9BULL, 0xDFE371D54CC564FFULL,
0xF7E723906CC36C5DULL, 0xB535802E97F268A9ULL, 0x0ULL,
0x69B9880C4B378C3ULL, 0x77F935132707BBCULL, 0xFD282D2FD2AEAB2EULL, 0x8E5F919B0CFA4D8BULL, 0x1A6FC229F6D2C49AULL,
0x683C0701A7C9386EULL, 0xD30084D2BC36C935ULL, 0x0ULL,
0x6DCDEB1E506A6C16ULL, 0x47829F31390CA5B7ULL, 0x3B59F41B2DF3FF6CULL, 0xF73EDEE3A27B4663ULL, 0x48A18E6BFB2EF14EULL,
0x3DC9956FA4FB9221ULL, 0x42C2FF164F8BB405ULL, 0x0ULL,
0x9DFFDAC9BAF7513AULL, 0x9F3F643A5185D9FFULL, 0xAE797E6A2D790D7CULL, 0x8D0BA562B66D7507ULL, 0xCFB445968A210C42ULL,
0xF572939B2F1D1CCEULL, 0x4C8ED18E57EF52C1ULL, 0x0ULL,
0xA3942595CA7C6EAULL, 0xF9DE932731B5BD02ULL, 0x83107E02AFC5A0D2ULL, 0xFDC5783D00728A2ULL, 0xB19D86592C34C8A7ULL,
0x97BC4CFBC641B3C8ULL, 0x27521556F3BD78D2ULL, 0x0ULL,
0xF6C065D2DA5A8C56ULL, 0xA23168266557626FULL, 0xE8EB8FEDF419A0AULL, 0x585D918FC1574343ULL, 0x4FCC22C6F64472CFULL,
0xB16D5202A2C01E3FULL, 0xEEA143C7672692D5ULL, 0x0ULL,
0x92BF36EA9EBB2AE7ULL, 0xDCC055BFB2ACF426ULL, 0x362A8F1DDD3CB1B4ULL, 0xFB7D862964678DDEULL, 0x96B44AA3D7AE88BULL,
0x5DBF81C066A58BC3ULL, 0x3B26E67711610167ULL, 0x0ULL,
0x9A3A9BCC280D0C2DULL, 0x357384A6E114505DULL, 0x41A157660A34025EULL, 0x8AD274810FE6DBABULL, 0x52AA74D2A7C25723ULL,
0xC4375ABD66A9A86ULL, 0xBB44A8CF69BECBA9ULL, 0x0ULL,
0x4D80BA75DFDDDF50ULL, 0xE2D49A81D2EAE566ULL, 0xC3E660F33FA5A43CULL, 0xDEA9516F81994676ULL, 0x5159CAB589CF0D08ULL,
0x856192ABDA0DB27ULL, 0xDEF9A91C2FBD47F9ULL, 0x0ULL,
0xCB10E50C8E42C753ULL, 0x877DAE7BA10526F3ULL, 0x4FC90AF63EA7D8ABULL, 0x745AC61AADAA0459ULL, 0x54BB5C2415B206E0ULL,
0x6E528FE61C437E0DULL, 0x9AFA6033A40B1330ULL, 0x0ULL,
0xD1B60C39126F1F88ULL, 0x5CD44AFA0D0BC0E3ULL, 0xA613102F0DE81CC9ULL, 0x75BB47A664F9841BULL, 0xD9B787631D05ABE7ULL,
0xD3EC24C3D5E55CA7ULL, 0xAC3C79386DEFA6DCULL, 0x0ULL,
0xF34BD2C6B3AD4997ULL, 0xA1D6202E819848A1ULL, 0x1CA479096C1AE610ULL, 0x157457DB396915C9ULL, 0x41E6B15BD64DC36FULL,
0xB4FB3F7D775255B5ULL, 0x221EDA6842F5CD34ULL, 0x0ULL,
0x921D67B4003100D0ULL, 0xF15E9B13B8E6BC4ULL, 0x2E085C6CA40BD6E0ULL, 0xA8CF574E88895D32ULL, 0xD9F33B394DF6E220ULL,
0x27F985BE6A4C8DEFULL, 0xED39A65804203102ULL, 0x0ULL,
0x8DFD5648B37E021FULL, 0xD824F5922E06E9DCULL, 0xFE1304EB61453239ULL, 0xBE95196E36D48665ULL, 0x5CBE7C125A727825ULL,
0xAD58C265EBD27600ULL, 0x75DCFEC1716B9BDEULL, 0x0ULL,
0xC3BB54A3C7B75C49ULL, 0x7E559ECC60B2CC22ULL, 0xFDE4401ABC5D2138ULL, 0xDEBBB6F8878E90A7ULL, 0xAFB157849D6AB393ULL,
0x8F75BB71122EF888ULL, 0xBE64B6DD940F02BBULL, 0x0ULL,
0xD7F7DA2C812A3E6ULL, 0xE458DAEEA58C4E1AULL, 0x12C6E6E9F1673D18ULL, 0xFC33FF12FA639C41ULL, 0x967B703103611BC7ULL,
0x231181956AD6E07FULL, 0x1A9C39E626281BA1ULL, 0x0ULL,
0x283CE8C6FC224F4CULL, 0x34CCD8BEF5D9C894ULL, 0x8F3E8B8B3CC08626ULL, 0x54B7812A4064AEAFULL, 0xD1E26A27FC628091ULL,
0xFAAE5BCAC2B24459ULL, 0x903FBC78E01EE55DULL, 0x0ULL,
0x22321F5DDB96583BULL, 0x3F852034618B8198ULL, 0xCD96AF6FD74EF8E7ULL, 0xB73F56E543821935ULL, 0x891DD04D27785ACDULL,
0x971071DCE0AD07F3ULL, 0x5CAB0CF8041D0B32ULL, 0x0ULL,
0xBBB4F7688B39113BULL, 0x7BE95A198777BD81ULL, 0x67CD26D8DE6CF090ULL, 0x78818661903ABE58ULL, 0x36E6DE0442EF5182ULL,
0x5C4F39727AF65BCEULL, 0x21A740C2D94AE6C6ULL, 0x0ULL,
0x656F5DA15ECD5741ULL, 0xDC3248E218C13446ULL, 0x44057DCA7B064332ULL, 0xDA519A33C88D494EULL, 0x4791AF0E97D9E414ULL,
0xE14FFC5255D384DAULL, 0xA024B98B7DA73154ULL, 0x0ULL,
0x91E19A028A3061FULL, 0x786EEDC434E7B858ULL, 0xE3F256304A30CA92ULL, 0x50FA786C725F0D39ULL, 0x9FD5E1CFCAF608ACULL,
0x898288996A503343ULL, 0x7B8D52A5F673DB77ULL, 0x0ULL,
0xEF84AE33875715F6ULL, 0x64B2563527445786ULL, 0x15D0FAAD8C80F8F8ULL, 0x23A004131A7733C9ULL, 0x53F44988004E8AF4ULL,
0x3AED2AAD81CB4A91ULL, 0xB1BA90D56DC3F393ULL, 0x0ULL,
0x6A3EC1970475EE7AULL, 0x53AD936010928A0DULL, 0x2B7626EC95C1D504ULL, 0x71E3851D07425FD3ULL, 0x45538C9BA7809093ULL,
0x9E9903BDE435274CULL, 0x907ADE1A7A1E116CULL, 0x0ULL,
0x62DA7F11019B9157ULL, 0x124CD5AF4DC98F10ULL, 0x871376E93405F812ULL, 0xB0300D4345970590ULL, 0x34B7C640D2BA0AF4ULL,
0x523247C3B18983DULL, 0xF4CE44B2DFB29B30ULL, 0x0ULL,
0x8277D56B07F4ABC1ULL, 0x19424F084B475886ULL, 0xC8587610F5958F8EULL, 0x6BAC3D9CC4E860C5ULL, 0xAC27C3BC97952960ULL,
0xDF757EAF65AE2AD1ULL, 0x1161E64A59C0B9AULL
};
const uint64_t gf25656to2448[8*448] __attribute__((aligned(32))) = {
0x1ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL,
0x99DE49710B0F0ABAULL, 0xFEBEA5EBE6BC87D8ULL, 0x7030DE362FC5C324ULL, 0xC730DE8460ACE045ULL, 0x60C552C3A497F919ULL,
0x8C02FAFDC3A9BA7BULL, 0x5FFFBBA47024AFC8ULL, 0x0ULL,
0x7E7E66FDDE0FB007ULL, 0x167A292406A1497DULL, 0x56D00AA7828DD48AULL, 0x796476C96450C9E1ULL, 0xD4C1A6B491AA96A9ULL,
0x96CD5664C8106CBCULL, 0x66EDEAAF69FC6919ULL, 0x0ULL,
0x71DC8E7C2E75AFE6ULL, 0x41A25E1229BC7AD9ULL, 0x7F2CD493BACB5C74ULL, 0x694ACD328AF9ECE5ULL, 0xD11E0B47EF0E3EB9ULL,
0xEC4A3FA6DBFFFFD6ULL, 0xB8FD9133F518243ULL, 0x0ULL,
0x22E1A468DC3EA0EBULL, 0xB819F551025A9164ULL, 0x3468556A62E7DA92ULL, 0x6E65A33346CE2F1BULL, 0x5EC11D194A483F92ULL,
0x7283203658881D42ULL, 0xA690744EA9DF754FULL, 0x0ULL,
0x60A40F3A56646FA3ULL, 0xFAFA08DA6B77F070ULL, 0xC266259125F15BAEULL, 0x6647EDBEBBFAB79AULL, 0xA1E5C1ECEC77E466ULL,
0xD2080F6B0D8B70DBULL, 0xE3787DEC383D1D80ULL, 0x0ULL,
0x1DCC555595DFEAB3ULL, 0x3EFFDF0C01AB09ABULL, 0xC0872CD758459A21ULL, 0xF2BA348913CAB36EULL, 0xD6C74118D1B31F63ULL,
0x98E187C164BBFC66ULL, 0xDB6F7E73DB8D5468ULL, 0x0ULL,
0xDCE7B2E95068E14CULL, 0x7E427C07548DCCF9ULL, 0x437AA0EE59578CD5ULL, 0x3A23A27E3ACA8247ULL, 0x25C6D62FDAF7447BULL,
0x473B288C3A37FA9EULL, 0x9ABFFD9EE9DDAEE2ULL, 0x0ULL,
0x1E7B2CC670F8C834ULL, 0x83BFDB439A649379ULL, 0x9ABBBC941D2A078AULL, 0x5FAEFA8289CCBBD7ULL, 0xEC5032FA01E149F2ULL,
0x961D4D99002AE6DFULL, 0xB7888D6FF9C7331EULL, 0x0ULL,
0x3F2737C5EB023C1DULL, 0x803CD46CA72A5AD3ULL, 0x54E96816F2B3FB5DULL, 0xA5B21D0A00386B3ULL, 0xB19435EC2DF1F13ULL,
0x8E614BED7892E44DULL, 0x76A73C5BDA1B6552ULL, 0x0ULL,
0x515A795612E51059ULL, 0xF4F05E37700661D4ULL, 0x39C2571F71A2F1AEULL, 0xC9B7478BA5F5096ULL, 0x47062B318B189A0AULL,
0x840F71EA6980A665ULL, 0x5B5C21BCCA5398A2ULL, 0x0ULL,
0x3AD9157BBCA357F2ULL, 0x2FA8093A48C6F36CULL, 0xD75524941C56123FULL, 0xB7A8485ED9E86F7BULL, 0xEC1923AF1DCA85E9ULL,
0x4EEDEDECC36CE482ULL, 0xE3ED8F080E8D9A20ULL, 0x0ULL,
0xBABAF8BB5C00A226ULL, 0x53E9B0D1E5AB6795ULL, 0xBEBBEFB1F2883F31ULL, 0x4F28BA7D1A52D055ULL, 0x83D8F9E7B5D20F6BULL,
0x6D50A0FBA2CC8168ULL, 0x9E016043E730122AULL, 0x0ULL,
0x70A0695824D8CD2DULL, 0xB31CE04BCE54A369ULL, 0xBB7A3319C6C571C0ULL, 0xD62423EBE27A5DEEULL, 0x5BEC99D26DFF8D66ULL,
0x48AD1B29A0E2807AULL, 0x332E48E6D18ECE0DULL, 0x0ULL,
0x22860A4ADEE93D5BULL, 0xAEC445190E204EE1ULL, 0x9D787F163A459FEULL, 0x5491F05315339B37ULL, 0x62A733B920C68E0CULL,
0xBBFB5B46B875D877ULL, 0x4145A25835ACAF54ULL, 0x0ULL,
0x27020919EE381FD3ULL, 0xA95D1FB64D1767C5ULL, 0x4CCC9E880DE6F6A2ULL, 0x8EFC8DC974F8EDE8ULL, 0x66E82D9140E94B4FULL,
0x372F2F86DE3CD38DULL, 0xC50EF0EBC53B458CULL, 0x0ULL,
0x5EF4C702A4DB57E5ULL, 0x1CF71F3FB8B8BEBULL, 0x1DF79120AD7E1F5ULL, 0x40079CC73C451BFAULL, 0xF5759D62F41792B9ULL,
0xB79DDCDE0E19DA5BULL, 0x40F73F3F216153EAULL, 0x0ULL,
0x270E870D55127EE1ULL, 0x964A7E3F654764B3ULL, 0x68C3EFA0C9D1FBB0ULL, 0xB6686645028EFB87ULL, 0xC61CFCD15C7DC3CCULL,
0xA639189F353FB494ULL, 0x94FE82A10CEE56C2ULL, 0x0ULL,
0x2B5031CC6CBDDCFULL, 0xEA42FD14A0B25813ULL, 0xA45AE69204DBE332ULL, 0xE8AA7368AEF7D1F4ULL, 0x98CD9E0590E7CE25ULL,
0x1EC727FDF647031AULL, 0x91B8DA66E97E3A62ULL, 0x0ULL,
0x19A51B508C4E8064ULL, 0x77C0603D11638D6DULL, 0xF5555D6BAD6D844EULL, 0x3EB8AB59FD0C8D98ULL, 0x9AAA527825FF197DULL,
0xDE048E302CF86C5AULL, 0xE661F11BBA93538DULL, 0x0ULL,
0xFE2EC03DECF72826ULL, 0x30CD0A8D62F3C12AULL, 0xE3291B484FA3A8EBULL, 0x996D4BA7F8B8D7F6ULL, 0xCF887F15948CE858ULL,
0xF6CB8275C75BF0E6ULL, 0x3C41E0ABCF9890F3ULL, 0x0ULL,
0xDCAD6DB38C02B9CBULL, 0xCF844C6FB224A579ULL, 0x5708AC75DDA47065ULL, 0x80E45F444246A2F8ULL, 0xF83C212C8161ADADULL,
0x80DBD68C827DD69BULL, 0xB2B6FDE6C8D193C5ULL, 0x0ULL,
0x9049877A675A3723ULL, 0x426367A8EA7A26EDULL, 0xBCC365CE4149FBECULL, 0xFC3C14F7C02202A0ULL, 0x63B26E88E8AFBEA0ULL,
0xCDB9F4989DDB88B2ULL, 0x26A0445BFB9AEBD8ULL, 0x0ULL,
0x606F20F9F166C7E3ULL, 0xAD55C5C1A15CA1BDULL, 0x5B756088AA9A626CULL, 0x4A0C9DC147DC538DULL, 0x288BA7FE12A44F68ULL,
0xD6B7F3ED2F168752ULL, 0x77BB7E2EE676596BULL, 0x0ULL,
0x580CA2D953EEB3A0ULL, 0x7D63C62A18F7A61CULL, 0xC056D1037731B2FAULL, 0x3FE00FC884DED41EULL, 0x947C307F8D5A4C21ULL,
0x9C02015FBD560952ULL, 0xC5F8E688776BE800ULL, 0x0ULL,
0x7D7E297B3A7CA3E1ULL, 0xF564CF91164C8ED5ULL, 0x212D126C84136B2CULL, 0xADF9720FA913D49AULL, 0xF163A4CAE3049D7DULL,
0xE43C4D05AA7D7B68ULL, 0x9E63B28A66EEFB51ULL, 0x0ULL,
0xF4FCDCBE08C9A5FEULL, 0x256B280E38C60221ULL, 0xB97B887C6C5D3B2DULL, 0x3A677F604703FE33ULL, 0x362CB44DD81F2CB5ULL,
0x534BC334D15A9693ULL, 0x45099383798E37C6ULL, 0x0ULL,
0x75C6B3C37A77C456ULL, 0x1B7CAB39B222C49BULL, 0xFC4233507EF2B03FULL, 0xC312F14C463EC074ULL, 0x2C1983D3F3A3AB4CULL,
0xEBD5BD33B9D28057ULL, 0x73038E72469C1685ULL, 0x0ULL,
0x4AED075F594A6479ULL, 0x46DFD49DCCFA6B72ULL, 0x4445D92E11E4C040ULL, 0x8A9DFABF84CE8974ULL, 0x2CE3E22333BE5435ULL,
0xF7FC0C1796284AF2ULL, 0x915719B22AF518B7ULL, 0x0ULL,
0xFB38B2265C30E9A9ULL, 0x9EB4705C81F42E9BULL, 0x7DE9FA0F9FEFD210ULL, 0x4B8FE2FFF7CCC5F5ULL, 0x10DFC771F4976BFCULL,
0x80F14D99BC29F2DEULL, 0xDF58A02179C426BDULL, 0x0ULL,
0x1915BDE740EC929EULL, 0x410A35F37F1E12ADULL, 0xC2D35B6768C2C00DULL, 0x96B5DAF77C90B1A6ULL, 0x3B3A32D3B2516998ULL,
0xB48334D5614DF7BDULL, 0x331945237B294C3BULL, 0x0ULL,
0x88663D39E45E5DAULL, 0x460F842CD0A9204BULL, 0xBC410FFA3B68E86DULL, 0xAEB7E3FB1B285146ULL, 0x95F844B0ABCC75D0ULL,
0xA1D6FB4B07DCB078ULL, 0x377E4B019C64FC9CULL, 0x0ULL,
0x941058F3C8A1C9A7ULL, 0xC384E1A6AFCC26F2ULL, 0x8721D20799617297ULL, 0x2665C28C15BE152AULL, 0xF2881C5DB55E75ULL,
0xF4B575E37A2E489DULL, 0xD576C08A6E9E3A9FULL, 0x0ULL,
0x852C52BEF0DA57B0ULL, 0x8E085CFB7DB4921EULL, 0xA145BA470C51A24ULL, 0x251EBD3C0215E68BULL, 0xED95BFE09A9FC0AEULL,
0xC44367894A7B9E44ULL, 0x23847F957902CE37ULL, 0x0ULL,
0x9E559B463ACB1DDEULL, 0x732A7457CBD76C05ULL, 0x9C70AAA2BAE11063ULL, 0xA17574A1550D7700ULL, 0x76C5773E332538A1ULL,
0xCBA7C9AB7AD2F9B4ULL, 0x9A400CE428BEB625ULL, 0x0ULL,
0x255CF58C2B6896BAULL, 0x4EA42E39F7AAE6D8ULL, 0xCAC9F51F0C2CC0E7ULL, 0x42B31064542827E0ULL, 0x3902E08C48E63F82ULL,
0x4E98521B7ECBC165ULL, 0x774AE8A5DFCC5DDEULL, 0x0ULL,
0xA3F8A0BFD20C2E4DULL, 0xED0F4EDBECE1A1E6ULL, 0x683BCF53E3F472E1ULL, 0xDE21001A8D4A0AB1ULL, 0xF95719AF4E5BF98EULL,
0xAC6B843582A80A4AULL, 0x4F917D7EEAF491E7ULL, 0x0ULL,
0x3DDB5426E654A807ULL, 0x8FC15A4DA36718E4ULL, 0x470D0C73E9BBA77CULL, 0x6DFC89A2EC1CB9CBULL, 0x9EE72AAC4C75B181ULL,
0xC9BD604C43477DADULL, 0xCE0C618C7B451F82ULL, 0x0ULL,
0x5B35B9F95707FE28ULL, 0xBB0A11F2D594616FULL, 0x246831CBBCA1E49BULL, 0x6FF9690D5C272D7ULL, 0xA1445CF43FC091C4ULL,
0x839A3B1A54FC00F0ULL, 0xFB762789FB85920ULL, 0x0ULL,
0x6E5D1599ED6ECD5CULL, 0x4E5AF2328A6C8640ULL, 0x8F9086F560E3E6EFULL, 0x888EEA69423BF1FAULL, 0x9A0C2CF25FACFBB8ULL,
0x12E5C628CEC2E542ULL, 0xE09F182555F7F18ULL, 0x0ULL,
0x5D1516A9B881A65FULL, 0x1B22C219A00F5EF7ULL, 0x9305018BB8327B1FULL, 0xFCAC5FABC5A136D7ULL, 0x4DF4923B44A75E2CULL,
0x7B37BCA4388BD78DULL, 0x69C793393A9EDC16ULL, 0x0ULL,
0x245233327550816BULL, 0x4CC59AC15E414FECULL, 0xD11491C3E3814F00ULL, 0xFB13316DAA088B2BULL, 0x780DC929EF760F6BULL,
0xA39C0E57CCEAD1A7ULL, 0x4BCFBC3343EADB82ULL, 0x0ULL,
0x6B8EC1B273469F65ULL, 0x1E5FCAF430A89C3FULL, 0xA8C46DC04D08481ULL, 0xC4ED65FAC8B663CFULL, 0x650BED76B74D6B1FULL,
0x7853D027DD233D97ULL, 0x226634FEA37E81A1ULL, 0x0ULL,
0xC05BB6859E430ABULL, 0xA18DEEA8381F48D4ULL, 0x53FE9410AB7AEFFAULL, 0xF46FB0CA7E917C2ULL, 0x583F7DADC02545D8ULL,
0x8AA6EDF094B6A289ULL, 0xB290CA74E453A896ULL, 0x0ULL,
0x6CE3A33033F53B7AULL, 0x5F80CB590219C3F1ULL, 0x8F679A320F6307E7ULL, 0x22E6F4BD4823061AULL, 0xEC0A26936C1219B4ULL,
0xD37ACAE8F9BA07AULL, 0x4EB04D18F85A38C0ULL, 0x0ULL,
0xFADB25A1E5A97135ULL, 0xD9B588D26A1F9B5BULL, 0x5E72AA926B223959ULL, 0xE998EA380C4D0DCFULL, 0x7216BBCD0D5EC765ULL,
0xBB9936BDED124456ULL, 0xD0C43DE2C451955FULL, 0x0ULL,
0x2CDC28B8D5FD696BULL, 0x64A98CE0892A802EULL, 0x2521020681EC7FE6ULL, 0x7116B03734F0E67BULL, 0x173075165425DA26ULL,
0x366C90709526BADBULL, 0x153C2C6656365F54ULL, 0x0ULL,
0xA851E1A437BE8AFULL, 0x85DDC08938673053ULL, 0xAB9EBC240F4FCDFBULL, 0xD60054C4D8364A68ULL, 0xD300E3E20F92331ULL,
0xA79EDF762A608E62ULL, 0x9056BFED6940CD58ULL, 0x0ULL,
0x7EFA305463F8EE14ULL, 0x756640EFB096A5FEULL, 0xF799E8870D1DBEA6ULL, 0x387770217FE26B9FULL, 0xCC8507F545B21EB0ULL,
0xC090183B1A41002AULL, 0xDB5BA7323C1B6E1DULL, 0x0ULL,
0xEBB5D3F0BC098DB7ULL, 0x67E5E446DF30DBBULL, 0x2F39DEB3F2BD5225ULL, 0xF4DBD9159BB721F8ULL, 0xE3476B6BA5DA11A0ULL,
0xE9935E28EF4779E1ULL, 0x4477805366D042E4ULL, 0x0ULL,
0x8F48AE2147C8F8CCULL, 0x512E90CFEC1E4A80ULL, 0x6A5F5E1AF062A22DULL, 0xDD7C8DCB6BFCDEE7ULL, 0x9855871732D45705ULL,
0x1A002D0BEFBAF59EULL, 0x8F0FAF84CCE205A1ULL, 0x0ULL,
0x76BF34B2AD96F609ULL, 0xEA3D3650808F4BCFULL, 0x852204BEF0272A1ULL, 0xC297C7611050D4A2ULL, 0x8A9F3A61F490784ULL,
0x56CBFCA444F5AFFFULL, 0xDF090F84C694E553ULL, 0x0ULL,
0xA65FDFD4D1FDDEAULL, 0xB11D4D6EE64818D8ULL, 0x88B413609DB191EEULL, 0x26A54D7FBCD24E05ULL, 0xD9175A266BD9A332ULL,
0x9F493ED887D9AB14ULL, 0x62AF3B491405FBB5ULL, 0x0ULL,
0x695B302338448BEAULL, 0x67892C71467DABD7ULL, 0x1FCE1397F017EB1DULL, 0x971F5E7F19FE8AD6ULL, 0x403150D2FC0B27E7ULL,
0x26C1DC40C02E73DDULL, 0xB36786F03CF45FB1ULL, 0x0ULL,
0x97552BBFE1EB8032ULL, 0x4F01CEB03985CF68ULL, 0xDC6F1E5BB501CE86ULL, 0xB2788ECF43F2667CULL, 0xE119A9143C4359C7ULL,
0xF1CD3DAB3F458FB9ULL, 0xFD5DDDE334B3C4BDULL, 0x0ULL,
0x5C6F8F8FC8DD7A9DULL, 0xDA1C8F8858E3A76CULL, 0xBEA41FD31A90C4A9ULL, 0x664459E75622B1FBULL, 0xFA69DCAA7F9F528CULL,
0x5715B303017E8BD4ULL, 0xCA567DD6A0188D98ULL, 0x0ULL,
0xA142043AF97CE432ULL, 0xEE65036A47DE207EULL, 0xBC229A790ECF63A2ULL, 0xA8E3F1BFBBB76065ULL, 0xC5A60DF89EF367B6ULL,
0x3C2A9DDEEC978B3ULL, 0xF2DB99EADFE33215ULL, 0x0ULL,
0x9BBC130C1FA4C1ULL, 0x171CBEF14920BBB2ULL, 0x735A78C467285D6CULL, 0x35FFC4B5962D2A9EULL, 0xF87E855941E6B62FULL,
0x3A433DEF2949340AULL, 0xBDBA2FCA626C7BB8ULL, 0x0ULL,
0x61CF03E73F99C738ULL, 0xB593FB60296241D2ULL, 0xD06883021D5AD318ULL, 0x4A356043477A354AULL, 0x7ED6AA1FEF57C86AULL,
0x65D020B52802BF45ULL, 0x73FE06674E411306ULL, 0x0ULL,
0x1CF1BFB959A44F7CULL, 0x47599D893F7E5A90ULL, 0x2C00CDC89C4851FFULL, 0x62980AA4F4C434BCULL, 0xFAC9A7E5A4A4CCBFULL,
0x51E2CBEB4FD9691ULL, 0xCAD5250BB7B4C372ULL, 0x0ULL,
0xCC2A2D881AC15950ULL, 0x413F469D5351B32ULL, 0xC203AE8639831CDFULL, 0xC21FF7F697F4CE85ULL, 0x98EAD1CC7849B905ULL,
0xD3AB4860089F2EEDULL, 0xAD7D4C85496615D0ULL, 0x0ULL,
0x794ABE718FE75C8EULL, 0x313D8C322CE9B67DULL, 0x75662DB49E2CAB08ULL, 0x11F80D86C368A7F9ULL, 0x2C99599E143A310BULL,
0xDF1E5D5D141B110BULL, 0x1A64303C88D99C33ULL, 0x0ULL,
0xE0285A81FC190427ULL, 0x37A6E357CBFCFB7BULL, 0x4300E278D40EDEBCULL, 0x686205E438722EDBULL, 0x5FACD2936CA9D590ULL,
0xB8513024099DC06DULL, 0x776B8087EDAE5D7BULL, 0x0ULL,
0xC8579A0F05E8047CULL, 0xB379818FA8CBF881ULL, 0x8126AFA167037005ULL, 0xD6222FDABD620110ULL, 0xFF4EF4CA73E92712ULL,
0x96B53A3B519C2ADAULL, 0x54F3CC02389F61BCULL, 0x0ULL,
0xAD6D6B48C29A35D1ULL, 0x81003665A2DC76AULL, 0x44738B8B6B54CC9FULL, 0xE4B3927FAB6E9D39ULL, 0x93BC1665874F2755ULL,
0x425EDF67359FDBEAULL, 0x2775D554913E69F9ULL, 0x0ULL,
0x700A145FEA01C3BULL, 0x989ADCCBDB041058ULL, 0x112038DB05AFA9E4ULL, 0x595A26196151138AULL, 0x1D679434ABBD4CB3ULL,
0xF4E7DCA792BCDF47ULL, 0xD1179F9C7ADCDFD8ULL, 0x0ULL,
0xB6F063646D0CE8A9ULL, 0x928532B5FC2CB4DCULL, 0xD165F2AA8164C693ULL, 0xF8CF0D8F82910046ULL, 0xE5077D88156DC1B6ULL,
0x6EDAE6EED6DE640AULL, 0x10B94FCD4B7FB00AULL, 0x0ULL,
0xCD011725538BB2B9ULL, 0x61E24DA59CE67119ULL, 0xA6FE3FB7DA0B3FD7ULL, 0xB36866CDBD1FB751ULL, 0x80A0BDF6ADD622F6ULL,
0x773DDD53FF59B5DAULL, 0xB64E634B953932BAULL, 0x0ULL,
0x9763E3C857DF3673ULL, 0xD38858CA2E34520CULL, 0x4580F2F0CDAF911ULL, 0xA5E0FDD880F41B86ULL, 0x443CE1C0F30034B5ULL,
0x2AEF0AE95297C96BULL, 0xE98EBB2859C8F9ULL, 0x0ULL,
0x758C6C0311437D6FULL, 0xB0C5A97ACA9AA270ULL, 0x4A7A840B5567FB09ULL, 0xCF3879C6AE219B93ULL, 0x4AAAF429867314C8ULL,
0xE022373B1FEFFAB4ULL, 0xF264E4BF02F54C2FULL, 0x0ULL,
0x71063A89E12A456CULL, 0xCC72D15C0F470F0FULL, 0x2BEB5F3AE74F9E66ULL, 0xA9AD3DFBE7A8994FULL, 0x26409F478FF56F62ULL,
0xE7A5E01E29EC3E79ULL, 0x635AB12E9191AD7EULL, 0x0ULL,
0xA1AA7E536F3E2F99ULL, 0x2BA7ABAA6F88EFB0ULL, 0xD9F8951125F7FC28ULL, 0xB8A40EEE03E1F18BULL, 0xB16E1181A2C17B15ULL,
0x679073D3F8D3ED4ULL, 0x2233A61191C12F54ULL, 0x0ULL,
0x325DB6A38051A9DEULL, 0xBA4BE38B013E85F4ULL, 0x99A658C7D445CEEBULL, 0x639FC52C7EF0ABA9ULL, 0xAF21C3491C33981FULL,
0x538A08BDE44E759CULL, 0x10FE0CCC990225E1ULL, 0x0ULL,
0x859D5B1424B71AE4ULL, 0xDB4BD647AC33469DULL, 0x8D86A610763959B2ULL, 0x6D6EBED24E4B1CD2ULL, 0x3EF273B2453E9AB4ULL,
0xA5FC74DFCBD7A9F5ULL, 0xF25B4F703096C7E7ULL, 0x0ULL,
0xE6B3B57CC16EF48EULL, 0xD20225454E13287EULL, 0xA6D651AC3E0F9918ULL, 0x11637D15AC1CD59DULL, 0xE79FB34E32648C42ULL,
0x82DAD9450E63D6FULL, 0x409BBFA43BC368ADULL, 0x0ULL,
0x683BB2A49C154DCFULL, 0x6CA2EEE9B4443560ULL, 0x68AA6F90B96F072FULL, 0x4595F4B232D6AC8FULL, 0xCDA0D9F4EE4115CAULL,
0xA5144ADDBF84DE8CULL, 0x28F035193B1808C8ULL, 0x0ULL,
0x6C3F0CD34D2B132AULL, 0x21F41C70B3414CC0ULL, 0x390C18191EEB773EULL, 0x3A5DDE6B04556ED7ULL, 0x88C41C03321F8025ULL,
0xDDC710CB64169AF7ULL, 0x407C2E96DA89BA0FULL, 0x0ULL,
0x8B14286029B2091EULL, 0xDAB6FF15D82E96B9ULL, 0x10DA405354EEB8FCULL, 0x795D0EB4750DCC50ULL, 0xD6DC21B19CC50564ULL,
0x73788541CEA81374ULL, 0xBD90F14307F1D1C4ULL, 0x0ULL,
0x1BA643544996CEDULL, 0xD9549E4445FAF365ULL, 0xE14167FBC817B867ULL, 0x30E33A516E3EAFC0ULL, 0xE2DC60006799C9B1ULL,
0xABBF62EC3A036C2AULL, 0xC15931B4405F4F0FULL, 0x0ULL,
0xCFB4636E6FD7B590ULL, 0xE4338B1B93963F93ULL, 0x246CD1947991C046ULL, 0x3BB9E29166590D7CULL, 0x15AEE1A249C7A3ECULL,
0x597BCD7CACC6DFB3ULL, 0x451B5ADD096CA6B6ULL, 0x0ULL,
0xB8FDD09A0FE08D09ULL, 0xCAACBC834A7294F7ULL, 0xB00BD2AAEEA23117ULL, 0x672A692974B26567ULL, 0xF14B45B038F8BE87ULL,
0x259EDB510991F468ULL, 0x5BC8DDB7FA5F37EAULL, 0x0ULL,
0x59E57ED106559D4EULL, 0x8C6C3DA369A798DCULL, 0x171FE6A24108BE9CULL, 0xC3CC70A8186688F6ULL, 0x1328DC210EC2DA3AULL,
0xA6F093D148B6E6B4ULL, 0xE2A16B03978878EDULL, 0x0ULL,
0xD7162EE1684B7C91ULL, 0x98BB89D330AF4625ULL, 0x3D728FCD407C2BC0ULL, 0xCBB797B625202976ULL, 0xA573E24C63D06786ULL,
0x10F46CCA18320350ULL, 0x441C0331C17BD7F1ULL, 0x0ULL,
0x5878736996A2814CULL, 0xC245CA27E4D1C4D2ULL, 0xCA7B33E2039EDBCEULL, 0x1E61BEC7B31D67A7ULL, 0x7DE40FBA4F76556AULL,
0x4BB48DABCBDC0233ULL, 0x501A77E3878C22E9ULL, 0x0ULL,
0xABAF4B7A411ABD0AULL, 0xD68521D63204C300ULL, 0x8AEF1F15AE90718FULL, 0x69C22EE35751C274ULL, 0x599E5B0BDFDE9334ULL,
0xFDAAD908ECFC9737ULL, 0xB6137AED73B5B1CBULL, 0x0ULL,
0x637AF3BC75E6B79EULL, 0x3F5CB2009F2AEE6FULL, 0x382D25848B84FF27ULL, 0xB31943BBE9EADE2BULL, 0xCC8E6FBCF946C8F8ULL,
0x67D1CD5446EC9E97ULL, 0xDF7BF25FDF9450BFULL, 0x0ULL,
0x9DD8924E095B8F94ULL, 0x83A514EA88A61C0CULL, 0x5691D30CB63FEB17ULL, 0x3E3774C4C4DE4EC5ULL, 0x8BB2408E44F006F8ULL,
0x947CAD30542FE9DDULL, 0x91717F48F7B5F023ULL, 0x0ULL,
0xD4DDEF2382499CF3ULL, 0x77D0FD85F0648DFAULL, 0x1D07CB813923AA69ULL, 0xD84376802BB92C23ULL, 0xA470E147E2CBB879ULL,
0xDBD597F8D2FDDF40ULL, 0x7D8E7B696AC49879ULL, 0x0ULL,
0x68B6083A796804AEULL, 0x5564CE5FC00027B1ULL, 0x2ED541473E3CB2EFULL, 0x153391FFAF02C4B1ULL, 0xA325CB968BEA1F3FULL,
0xD72610020B3AFFD5ULL, 0x94DBDE25D63C554AULL, 0x0ULL,
0x490A95C8FECD6E07ULL, 0x204D0801131CDC07ULL, 0x2A2EBFC7692DDE92ULL, 0x2098D29540C77226ULL, 0x4CD5D01E209D41FCULL,
0x6B7D805DA13C6107ULL, 0xFC0780D957EAE076ULL, 0x0ULL,
0x66A614E6F6638D6BULL, 0xC63E332A448E2162ULL, 0xCC7401CC765C9462ULL, 0x60EC904FC30FE329ULL, 0xCA97AF3B55A14E24ULL,
0x755EFE8A6B5C5AE3ULL, 0x455C0C9CDD0FCB6AULL, 0x0ULL,
0x66D213CE74560EEDULL, 0x95845E6BCBDF4FA4ULL, 0x72B606365D6AD23EULL, 0xE36368F92FF4B8C5ULL, 0x9ECCCFDAFC4BE65DULL,
0x23CAB79BACFD73B5ULL, 0x5082A075C7D0DC8EULL, 0x0ULL,
0x414C7AF145F4144CULL, 0xAF1E17E06A2D7DF8ULL, 0x8002E685BA05CB30ULL, 0x218CE815C545A5DULL, 0xF695B308C609F098ULL,
0x5582E926A05279D5ULL, 0xA630A36A06902B36ULL, 0x0ULL,
0x31084A4BE3964A10ULL, 0x8CD5AC4CCFDF3D2BULL, 0xFC4B16A26EE4D052ULL, 0x49FEF9B83FF589C9ULL, 0xFE5EC56B1153086BULL,
0x3F8238E0209B416CULL, 0xB9E991AD886A581DULL, 0x0ULL,
0xB618BC2BF6E210B6ULL, 0x2F72448C563F8FC1ULL, 0x11270C0AF66E06DFULL, 0x91CF260C526F80C1ULL, 0x542D50BD694AC024ULL,
0x2EA221DC0BE2CC4AULL, 0xDA74619AE60D48A6ULL, 0x0ULL,
0x7290887CCB468CEDULL, 0xAA970FED1C23D054ULL, 0xCD703331AE8AD3ECULL, 0x9DE3F9C1CD2FDE8EULL, 0x44ACF0C53B8B8F7EULL,
0x2E3B9A1578B46BAEULL, 0xE71E4136858AACBULL, 0x0ULL,
0x724CC5D0CD56E0F9ULL, 0xCE145EB09E491812ULL, 0xF1BF0A794DAE8732ULL, 0x85AEC4A910028DC5ULL, 0x907EFC51D716201DULL,
0x3885D1415624D91CULL, 0x15571420A9DE0AA3ULL, 0x0ULL,
0xE5E8C5BC8FFA17AEULL, 0x25181B1572DCF934ULL, 0x83AC86EC44FFCB53ULL, 0xC768086DB78DF94EULL, 0x8EA846428D74FF6AULL,
0x11D0F90BD5A2F3EFULL, 0x8FCBC183EDD430A3ULL, 0x0ULL,
0xFCD92843BEB3EB8CULL, 0x2E9D2D8E5211F67CULL, 0x5B7E1FA1D223FC8ULL, 0x949D28AB24CF7250ULL, 0x4B1C5244195DD614ULL,
0xB1228EAACFB64616ULL, 0xFD57B2272E762F42ULL, 0x0ULL,
0x581F583ABF613ADDULL, 0x6E4FC996C0FEE09EULL, 0x9B65300D9BAD558BULL, 0x9E813B13A326114CULL, 0xEB37133E26F20DD3ULL,
0x10ECB819F2F4E00DULL, 0xE2D998FAF04E2A11ULL, 0x0ULL,
0xB547E6091A14D415ULL, 0x6726DF5723E4FE39ULL, 0xCD8C94DFDA5BF9E6ULL, 0x923D38922A7EB3ECULL, 0x71B4A9C008B35BE8ULL,
0xE67CF64207D5F64FULL, 0x81505B258418D5FDULL, 0x0ULL,
0xB8474588AF8FC405ULL, 0xA06ACE97894A61F6ULL, 0x82D29C2EE18B8E9ULL, 0x82B78215918CDD9BULL, 0x92A86A084C305C89ULL,
0x3BBDFA678292F8F3ULL, 0x760691E0A32872A9ULL, 0x0ULL,
0x8CC68F8D75D07F2DULL, 0x497565EF7152AA4DULL, 0x1E75966C31C369D2ULL, 0x2B6BBD39246CB89BULL, 0x5BEA3671325B8CF5ULL,
0xB06743BF540BA858ULL, 0xFCEEEA69D44B14F0ULL, 0x0ULL,
0x5C056CBB673545BULL, 0xE53F8A329D0B9F6EULL, 0x2B7A0A746440BCC9ULL, 0x25D22065130EF793ULL, 0x61006FC9D36AB5B8ULL,
0x1751AC3ADE6988ADULL, 0x41503A3B9BB785B1ULL, 0x0ULL,
0xB2603EF48644620AULL, 0x6D731D28CF8694D3ULL, 0xCB86063B01019372ULL, 0x24A7574F549CCECEULL, 0x1B76875E6B25A7CEULL,
0x3E51287CAA58A4AEULL, 0x32CAFD5BBB3100D2ULL, 0x0ULL,
0x961FDA6DC50731DCULL, 0x186F480234177A63ULL, 0xD2750FC9AE9AB3C0ULL, 0xA096B1ACCF137183ULL, 0x211307CDE73C798AULL,
0x2662EC162D15CD9DULL, 0x77BA2BC5DFD27DADULL, 0x0ULL,
0x61194A41D188FEAULL, 0x8468AF033F2AD8BCULL, 0xE28ADDCF50AAC914ULL, 0xFABE5735709435FDULL, 0x1625D71689F2D83DULL,
0xC05E16E834BF1FB8ULL, 0x1E9628B12DEB071FULL, 0x0ULL,
0xC14E2191EAE52B9CULL, 0x20A0AC63021C7241ULL, 0x77B82BB0CE3E2428ULL, 0x3F79C458C875B688ULL, 0xDFF47FA78FF064C5ULL,
0x15B3B118F171E18ULL, 0xEC0C8ABF4C2A2809ULL, 0x0ULL,
0xAB82406B4C9C37AFULL, 0x379F86B8FDFC86CAULL, 0xCCBA870261B53FC4ULL, 0xC0FB1B1115C2A948ULL, 0x233FBB9CEC149914ULL,
0x470A143A781D713AULL, 0x8E35D274B6620F4DULL, 0x0ULL,
0x17B2564925F036B8ULL, 0x3ADBD103B627FB5DULL, 0xBD8DA9B466D96080ULL, 0xE432CD03FB91BD2EULL, 0x7038DA0EAC08C4C3ULL,
0x70F762566DE77742ULL, 0x62B0A14FB7CEE679ULL, 0x0ULL,
0x7C2ECA6A1A87E6DDULL, 0x2004A4FB47E04FF6ULL, 0x282486433B50A968ULL, 0x4D9BFB3C3105F8C8ULL, 0x827177F8C0561691ULL,
0x2F9693624FE896DULL, 0x376086F3045B3701ULL, 0x0ULL,
0xA9C4C0672F9E09CAULL, 0xC96B2696CA36C045ULL, 0xF6C0E2AC85A3F82EULL, 0x688EAF8B474410AFULL, 0x625333F6662CA06DULL,
0x58B19260AEE1EA32ULL, 0x5FFED3CECA0F5518ULL, 0x0ULL,
0xCE27733F8D803EF3ULL, 0x9F43CB442DA4054DULL, 0x8B55EC70200BE33BULL, 0x1614ABE5B6681F29ULL, 0x239C28C8FDC4D0FULL,
0x4EAF624F0AB0A32CULL, 0x9E954533C6DB5D81ULL, 0x0ULL,
0x8C3C8D97526D7C9EULL, 0x4FD8E70868D2D693ULL, 0x6D5D573B2E28E4C9ULL, 0xCCF7554AB1EC67BAULL, 0x72931487F3861B84ULL,
0x7D577392ABD4D57EULL, 0xF28165D41062A168ULL, 0x0ULL,
0x74DF8EB22673AEC2ULL, 0x190BD3E0D79E8B39ULL, 0xD65C6736A79D2E32ULL, 0x52A61696CB7BA8DEULL, 0x5C8B28C156AE18ABULL,
0xDA38B76F5498DC57ULL, 0x79FB8FF41C5E9CBEULL, 0x0ULL,
0x8D626BDD963F2FE5ULL, 0x38E5F2510BD2E4E5ULL, 0xACCC21C22B6DE349ULL, 0x56515130C8490A2DULL, 0x148F616B18CE2FB8ULL,
0x9073D7D49C39B4CFULL, 0xFEEBCB820F8A94BULL, 0x0ULL,
0x1ED2A02357C1FEC0ULL, 0xDEFE09C5297EAFECULL, 0x2FBB6D4307B152D4ULL, 0x792E8BEE4F1B5E6EULL, 0x3EAAB86CE6D75AEDULL,
0x3F83FAF56E24D9FFULL, 0xDEDF548E8413A23CULL, 0x0ULL,
0x97C38CC444E05972ULL, 0x6466AED7F2091CDDULL, 0x2D088CC2A7EAB2D3ULL, 0x98590820798DDEBFULL, 0x28AC0F92BD1A0B2BULL,
0x9FCE5B5CE77F0BD5ULL, 0x679CE0E8955A067CULL, 0x0ULL,
0xFF1EDB6BB625DB4DULL, 0xF94BCEE257E7F932ULL, 0x6ED955B74CA7116ULL, 0x3ADB7D04717E1FC1ULL, 0x73D69CB38FB8FF8BULL,
0x260B6F810FA300B4ULL, 0xE7A353D91BC67ED1ULL, 0x0ULL,
0xB07AB106D128C9FFULL, 0x82AC5B7476DA5014ULL, 0x85094FD05617F7CCULL, 0xA36228D5152AC421ULL, 0x97F77B98A53FEDE2ULL,
0x8FA599962370D13ULL, 0x9E4F9EA607804B86ULL, 0x0ULL,
0x4D87526AD089E0ACULL, 0x9F257AB4E811BCEAULL, 0xBABD9B646F952BDDULL, 0xB89381F1A5F7CC11ULL, 0x1918939C39F95DEBULL,
0x6BD4BADF6A681AE4ULL, 0xDA6667D321ECBE68ULL, 0x0ULL,
0xD4C485AF0FF9D55DULL, 0x473D7B20BB8FBBABULL, 0xBD85EB0CE9ACD02FULL, 0xFAE13CAD2C8F0D27ULL, 0x1FF785182FFE044FULL,
0x6BAD7B3300545E4EULL, 0x1F15CC7A0027103BULL, 0x0ULL,
0xDDA9748E3D43AEDDULL, 0x97FC6B913CD70BEAULL, 0x7F7E62FFE376D36FULL, 0x71A4EA7757094C59ULL, 0x41B73AE9821A30A8ULL,
0x1B5D2F40A07C850BULL, 0x4F2C0D7AA9944400ULL, 0x0ULL,
0x497F63D34EAEBA0CULL, 0x3B32DA7F761812E1ULL, 0x6E45335A0FC6398EULL, 0x3A770C6737F172AULL, 0x9127D467F59F9125ULL,
0x7DB60597E892A7FDULL, 0x9A6B87ECE0010C1EULL, 0x0ULL,
0xBBFF304E76843557ULL, 0xD372CFDDC62FD2AULL, 0xAE3AEEE818B0B5D9ULL, 0xE5CB18FC9E5CB2F4ULL, 0x502FC880705F6F77ULL,
0xAA26A259F26C86DEULL, 0xC55A630D0FCD9853ULL, 0x0ULL,
0x455C74DAA3166C8FULL, 0x5CE22027B0276610ULL, 0xF84CD76DD2C6DEF0ULL, 0xBAEC037F6A425542ULL, 0xDA27ECC19C375F3DULL,
0xB883F3684CB781D7ULL, 0x54A77724B3F3856ULL, 0x0ULL,
0x1C0E1ECD3FCD7AB1ULL, 0xA18CD737C753DDCDULL, 0xFC7863C1B2596FA8ULL, 0x66A271C1715DB3EULL, 0x2E4E72F91241163BULL,
0x4CF0697BFD69D45AULL, 0x78948B6CA09EA2F6ULL, 0x0ULL,
0x76238E365D5BBAEULL, 0xE4158DEAAD22B6E5ULL, 0x282B05E438450549ULL, 0x85AD8398F48C0073ULL, 0xE3A1F3A60C2EC211ULL,
0x3925E49D54E80A5BULL, 0xE21D6CD3F473108AULL, 0x0ULL,
0x3FF94A22FAECEFA2ULL, 0xDC3E28AE9D7760BULL, 0xEE2029C1E4383B06ULL, 0x4202DAFD002A5D8FULL, 0xC6BA5A505B806CCEULL,
0xEDAF7A684B9EB6B3ULL, 0xB9D5861D673763BEULL, 0x0ULL,
0x285B4E9406986D4EULL, 0x94F2CFAC596B6D58ULL, 0x2641046713EA68BBULL, 0xFC9BB60D5AA8D453ULL, 0x145D73B8167C8568ULL,
0x583E77DC4523E590ULL, 0x806923AABDC4FA63ULL, 0x0ULL,
0xCA6EF81D76DA4FD6ULL, 0x67829AA5DDFE794AULL, 0x1C7C09A7EBF856ABULL, 0x999FFD71707CBCD0ULL, 0x561C673A2B6A862DULL,
0xF43FDC3919278C69ULL, 0x7D40445D4B395E51ULL, 0x0ULL,
0xEFD2F933E4324119ULL, 0xAA195C08C3EEDB59ULL, 0xF321C05F37CABCE5ULL, 0x304E3158624EA5D5ULL, 0x517950267C99D499ULL,
0xABEB95FA1C355B72ULL, 0x81EB35784F59D1C8ULL, 0x0ULL,
0x418CCC401C2F565CULL, 0x3045480FD5168959ULL, 0x2CA7A8F942572C93ULL, 0xE9085A5CCFAFC93ULL, 0x88BB43BB044A9E6EULL,
0x70B0C663A306A9D8ULL, 0xC1CD2BBA2855B5D7ULL, 0x0ULL,
0x3C384211C97D80D5ULL, 0xBFB09B3AA4C4F72ULL, 0x9D0679883F79B4EAULL, 0x49F06A3A0C5E57DCULL, 0xABB4C6623AFE7C0BULL,
0x9619DD780EA3F70BULL, 0x232444104DD4855AULL, 0x0ULL,
0x2E252AD13EC9A8E3ULL, 0x86B66C40C09A4BF3ULL, 0xB4619DB3F8D4681FULL, 0xE57DAE2D18CCC57FULL, 0x16EE27AE793C9CF2ULL,
0x2E60A52098489247ULL, 0x158FA12394E080C8ULL, 0x0ULL,
0x507613AF94819F61ULL, 0x1D4BF9BEF3AAAAA4ULL, 0x4C3BBAF19C9CC3E9ULL, 0xD5147196B7A99603ULL, 0x8051C3596032BC2FULL,
0xF5E298A3E8BC6EC5ULL, 0x5E73C773ED34BD32ULL, 0x0ULL,
0x964F9023A9403138ULL, 0x4E03AF04DC14F9EBULL, 0x6C6425924D2864C4ULL, 0x53E1C3C49D1866DBULL, 0xE6EBB652482CE53AULL,
0xE510614398D2C3E8ULL, 0x46B6D959718B5C7ULL, 0x0ULL,
0x911373B06BBF492ULL, 0x7EF4D3544725F70FULL, 0x614DE2CC2983ED47ULL, 0xB8AC86E9DDAE78D7ULL, 0x4D23E96DBCCDBF88ULL,
0xEEF0CD7BA3AA7F4EULL, 0x904C747647F3CD0CULL, 0x0ULL,
0xFD661797F4FC9382ULL, 0xF7DFBB75FDA7DF6ULL, 0x9E5D7F71882A918EULL, 0x4FF3DC3259A2DBB7ULL, 0xDE8793F43C33BB7DULL,
0xD5B4B0EAA2A14E86ULL, 0xDFE958C255EB7D65ULL, 0x0ULL,
0x9BC4C1E841DF1359ULL, 0xF4A11A7ECFA5B59CULL, 0x3DD272171B0CE959ULL, 0x737D2CC7909185E1ULL, 0xF3955E3E453EF6ABULL,
0x81A93BC681F31E5FULL, 0xCB16D4D72275318FULL, 0x0ULL,
0x4B7E8FDAACCEE0CDULL, 0xD1E4B3B35710698ULL, 0xF7A5195BF348270BULL, 0x5C04B5E88749376DULL, 0xA89C98A0383285B4ULL,
0x5CD7180A0875E86ULL, 0xC19D26170ED2917EULL, 0x0ULL,
0xBC66CBB597BED7FBULL, 0x479455123343E971ULL, 0x85F41725DB4AC24CULL, 0xD822ACBAE3628931ULL, 0x7CA506E86356C252ULL,
0xEC4A863EFE9E36D4ULL, 0xA3AF501871AAA442ULL, 0x0ULL,
0xEDA1F81DF1B78B2DULL, 0xB9D2007C8D2A1C56ULL, 0xF9E2E43C66E963A8ULL, 0x8946FDB4CCA878F9ULL, 0xAE34D009834C3F29ULL,
0x96259DA1E5233FC9ULL, 0x238448A0C6515ABAULL, 0x0ULL,
0x28E69CCAEE86C88AULL, 0x8B1F16EB729FC8CBULL, 0x4A1C541F9F58F4FBULL, 0x83D060D90438638DULL, 0x6C9640D1E3F8B1C5ULL,
0x8F1A069FBEC1AB17ULL, 0x22176B87D13FD7F9ULL, 0x0ULL,
0x6666CAFCDF2E81C4ULL, 0x9C965A379754DFD5ULL, 0x92DAF1CDD253AAEDULL, 0x2A9FE628C64799F8ULL, 0x3E767DA57F39794EULL,
0x93BC46E2EE0B34A3ULL, 0xA872AA6460F1F0FEULL, 0x0ULL,
0x62528DA0F12AEE0EULL, 0x7E8742D5688DC1CULL, 0xB9C82F355923E043ULL, 0xC6F7D2D90C885B82ULL, 0x9429857DFC8C37B7ULL,
0x9AC2F2F633A05817ULL, 0x63D9FA23977138F8ULL, 0x0ULL,
0x8FE7BFB419171C18ULL, 0x18011ED777021BB8ULL, 0xC42AF5C456210371ULL, 0xFAD5BFFB65BD496CULL, 0xBE3F55282DCFC02CULL,
0xBAFB31A229CC8C6AULL, 0xF7A62B57E994C67BULL, 0x0ULL,
0x739382120495C707ULL, 0xD2B89118131B3DC2ULL, 0xA7E0A03D83B86F6AULL, 0xEBEC5623FCE5E061ULL, 0x7A658A03AF73B437ULL,
0x590EA144FCF646A4ULL, 0x81B609258F58E42FULL, 0x0ULL,
0x77DCF5E0EFDCE65ULL, 0x8D1C0FBB534993A8ULL, 0x8D812BEC0A783D21ULL, 0xC03DB7382D2725D7ULL, 0x723847DF07420C63ULL,
0x5CD4CEC4D9026118ULL, 0x51AFA5A64947413AULL, 0x0ULL,
0x3A2D7CC331E2C1F8ULL, 0xCEC8B112B6FB3C9ULL, 0x3CEBD3EEE9DD7283ULL, 0xDDE5D697A28FFF5EULL, 0x4657F0CC24AB4986ULL,
0xEE9077BBCD5767AEULL, 0x9E1A738629354408ULL, 0x0ULL,
0xE8C8A321761E9E92ULL, 0xA2242C413671A716ULL, 0xA512A40F45892F44ULL, 0xFEAD4ECD4C3BBDCAULL, 0x9B5373F9E94393D4ULL,
0xD91FA9DEDBFCF4C1ULL, 0x26F54F3D3AE418AEULL, 0x0ULL,
0x1E2ABB7B781DD74ULL, 0x4DE504BCF5C39A1EULL, 0x5D42679A28E69C7ULL, 0x2DFA5EF1BF7D609EULL, 0xEEAD9B5C741571B2ULL,
0xD71811E7086C463FULL, 0xADEAB389C2DF5F45ULL, 0x0ULL,
0xCB5B60E5F62258CULL, 0xA4829B4B3FF76DC0ULL, 0xEA680EAAD42FAE42ULL, 0xFE4D0979C99E8F8EULL, 0xFB2515A50BEE48A5ULL,
0xD025D48A232F520DULL, 0x36FA062C0A99699CULL, 0x0ULL,
0xD1D91AAFF4BAF8E8ULL, 0xE7206E79138C76BEULL, 0x86BAEC6D26C59608ULL, 0x7DA6EB80D63F5ED1ULL, 0x156F1223775665B3ULL,
0x93924FF9CF4EBD95ULL, 0x69A14A6C9765A5F0ULL, 0x0ULL,
0x67CCE81DCE2DA91FULL, 0xC14E16E97C5C0603ULL, 0xCB0CDEB949D6FA7ULL, 0x322D8EA261FE773DULL, 0xAEE7BD609E1CAD7FULL,
0xF97FA8FC2671DDB0ULL, 0x67D2E57175368302ULL, 0x0ULL,
0xD196ED0FDD1C8AC8ULL, 0xBA6EB9C437B4F1A5ULL, 0xFF16DBD3C1554E65ULL, 0x7FCBA318FD65CCC3ULL, 0x376EC506E4B23048ULL,
0x47543A56430018A9ULL, 0xE98D1AB80E2A88A0ULL, 0x0ULL,
0x5B0FADF7721C3D3ULL, 0x194BA4825431D2E2ULL, 0xD4A2CD2DCF266D69ULL, 0x2810DE1D76BEB52BULL, 0xE32F499B53AF0AE7ULL,
0x33EC2AFE2871D032ULL, 0x4536975E5C7BB3D8ULL, 0x0ULL,
0x2236ECE9155F5981ULL, 0x77C854FB4F4C5653ULL, 0xD1BBA0B850B5D96AULL, 0xB1FFC9500B187E7AULL, 0x9BD2E55D18EB784FULL,
0x62DDC2C741DB3CULL, 0x19E131D2BC0414CULL, 0x0ULL,
0x7B71B63A0BD508DDULL, 0x97058EFA5FA77646ULL, 0x32A2C384A87A2C87ULL, 0xF3CE43DA7B053110ULL, 0x52653EEF5AA81ED3ULL,
0x2B4DD2DD7B6C0054ULL, 0xBD1CFE8F5030C6EFULL, 0x0ULL,
0x8EAFEE380796713BULL, 0xFF1AEB80F04C8FC4ULL, 0xF6063053F064D5E3ULL, 0x93944CAE843ADB61ULL, 0xF8570912A44CB8FCULL,
0xA3507F83036DBFD5ULL, 0x7C94EA78914CC5FCULL, 0x0ULL,
0x2DCE8DBD4BAEDF93ULL, 0x2326A33C7E4B08D4ULL, 0xC9F2E8069A505C17ULL, 0x7F96B9CB97894B63ULL, 0xAB169F4405036CA8ULL,
0xB1BF4B9E11BB0DF2ULL, 0x553DFA601D1114AAULL, 0x0ULL,
0xBFB7283593D240A9ULL, 0x142765FD6BA93D45ULL, 0x62F87777D282F9FAULL, 0xC0ABAD99FFD10DB6ULL, 0x615462BBF3A004EULL,
0x441C2582F3C909F6ULL, 0x32A45AC0545843D8ULL, 0x0ULL,
0x16D338C6723605A3ULL, 0x635F49E0424B2044ULL, 0xD89CA84DA4690972ULL, 0x13A9A328BDD2319EULL, 0xAB3381A2BBCBEDFAULL,
0xD1F984AB9723801AULL, 0xED65C75052521F55ULL, 0x0ULL,
0xE164D5EF56D957D6ULL, 0xA7E96FB34F613565ULL, 0xF8757E9A48DD20DEULL, 0x8116036278E935A8ULL, 0xFD045D4D8B8D482BULL,
0x79B4BEE2754F921AULL, 0x905DACDCCBE9298CULL, 0x0ULL,
0xFABC465DC1CA21DAULL, 0xE85120ADA06F62F8ULL, 0xBFA3A5E558D10DF3ULL, 0x90B4BECC8873242EULL, 0x445085DD9C712718ULL,
0xA294E8F77D832E24ULL, 0x816C029D2F7F7CB8ULL, 0x0ULL,
0xF237B879248D5470ULL, 0x69FDA5090847F181ULL, 0x92D56F81AA183D62ULL, 0x5F4A4C0BABEEE10DULL, 0x829B69F6C6C9A82CULL,
0x7DDB9ED6839CC1FEULL, 0x339825A6F7862C55ULL, 0x0ULL,
0x19BA74E25C660552ULL, 0xA704A26817E80242ULL, 0xCC27175697DCF7C2ULL, 0xD5096D9F34ADCB00ULL, 0x376689D30351612EULL,
0x9821372B7ECAB3D6ULL, 0x14C08AB6431BCB05ULL, 0x0ULL,
0xE94935A2FBCA2604ULL, 0xA8042D1EA318FA02ULL, 0xDB4C9E25D5DCA69CULL, 0x2D6E7289D8B77692ULL, 0x2678B48DA0A7018CULL,
0xDE255BFD90E070DCULL, 0x63779A4B11D7CD4DULL, 0x0ULL,
0x99F687757A26319EULL, 0x36FBB131FFD3E438ULL, 0x609741D7933FC38ULL, 0x2B85521AA004CAD9ULL, 0x61BBC5E32A34AE09ULL,
0xD72DCCB0E14CCA6ULL, 0x632ADB07CDBD3ACBULL, 0x0ULL,
0xFE9914560EF729C7ULL, 0x45B1E10FC111E9B2ULL, 0xB0C0A70C65F94DA5ULL, 0xF03618495C138879ULL, 0xF6C627FAAD9A7A26ULL,
0x2A4E454616DB3316ULL, 0x39A05E1554F6EDBFULL, 0x0ULL,
0xE058C6966FAF6B3FULL, 0xC70319D4DC79638AULL, 0x37CFCF1F805C4E6CULL, 0xF2C28DAADE0F376CULL, 0x2E44FB5BF1EBF6BCULL,
0x43B97C1A5086DC60ULL, 0x3C438823F9A14CBBULL, 0x0ULL,
0xD479E6308DCF298DULL, 0xECCB3992E76D88FFULL, 0x19EBE3AA0B1F20A4ULL, 0xAA1ACE5E6562E72FULL, 0x7918F77A691811FAULL,
0xC928B62C6ECF450CULL, 0x8FFC26EFCF5CC7B5ULL, 0x0ULL,
0x8F67073176AF86AAULL, 0xB3941EBF5D983713ULL, 0x5CC1214D87BF41C2ULL, 0xFD308CE0D385D267ULL, 0xB78C42308CF2BA61ULL,
0x303CBDE1A5695F16ULL, 0xAB40016E22936F1ULL, 0x0ULL,
0x135E9BDF209BCED0ULL, 0xC756292D678E5D46ULL, 0x56CD5A84138E2BE3ULL, 0x26F6DDDA4B662FFEULL, 0xFB8926D66B983B68ULL,
0x1511C4A0B1D8CFA1ULL, 0x90DEF91518720471ULL, 0x0ULL,
0xC408D52466E3731EULL, 0x8D67D001CEF28A82ULL, 0x115EAFA85C45E4A5ULL, 0xFA05CA429B65B4E3ULL, 0xA0B864D2EB715BBULL,
0x72CEB352695D4D25ULL, 0xA3854510F8B969ADULL, 0x0ULL,
0x78EBAC1646474660ULL, 0x19141A9C1B07F963ULL, 0x48A66758A8C681DULL, 0x3EDEF64F100A207ULL, 0xAD1EA3BD64EFC01AULL,
0xD19DD6974F3C63ABULL, 0x3613AD4E15314017ULL, 0x0ULL,
0xA32E5F26FD8BAAF6ULL, 0x796F0CA09B9B6A9DULL, 0xE64BFF49B933B10AULL, 0x3C1A7082AFA93715ULL, 0x21CFF874F80456A1ULL,
0x20723C8A7667ED85ULL, 0xB2A100295B76BA48ULL, 0x0ULL,
0x255DD13C60448A0ULL, 0x9D01D5C20A11C74FULL, 0x13FAD850C5632A79ULL, 0x8CA50D4A8B543E86ULL, 0x3C8E4127E95B5EA5ULL,
0x4089714C573B2DBDULL, 0x5F31598A0E56BCAAULL, 0x0ULL,
0x736789A97B5EAE13ULL, 0xEF552560FD676C82ULL, 0xBE716CB053B95A7FULL, 0xD5B34185CEC35CAFULL, 0xBBFC1B355700271CULL,
0x19F442A1EA3A7450ULL, 0xD452104F7EEC615FULL, 0x0ULL,
0xA319E1DB8DE7A266ULL, 0x7FB585EB0AD61F40ULL, 0xD33F76184C22AFF7ULL, 0x380E8C33EB5A7DBDULL, 0x7D0F4A9CFEB6A4CDULL,
0xB53F161B95F6FAA7ULL, 0xF8907AFD4D3194FULL, 0x0ULL,
0xB1FC26AF3ABCE28AULL, 0xF690BA60C6BD9801ULL, 0x17708409523AD5D3ULL, 0xC850E29A5C960FF6ULL, 0x5E09085FE50C5CC4ULL,
0xFC34EB1D18E9FA99ULL, 0xA3FF5F9273D701AAULL, 0x0ULL,
0x69451150A7767BD8ULL, 0xA172F00904D7EDC4ULL, 0x63BF2AC9FB682E0ULL, 0xA99C220C06B143BFULL, 0x9E57058C856A0EDEULL,
0xDFD9B046B18753E2ULL, 0x5423511EB0EAA0B6ULL, 0x0ULL,
0x13D4F8131B83434DULL, 0xE4ABF0DBBD68D72EULL, 0x3A3D6C769D273EC9ULL, 0xE5EA6D954804AB6CULL, 0xBFB7054837B87903ULL,
0xCAF39F1285DC5AE8ULL, 0x7C589E7EFFB44798ULL, 0x0ULL,
0xF94D1DA6A70B21FEULL, 0x6EF813D4A0E551B9ULL, 0x8954BE349DC1BE94ULL, 0xBE8B0C3FB32E7D30ULL, 0x8DF139FB13E81A87ULL,
0x819F06942957BB31ULL, 0x2D711248168E7D9CULL, 0x0ULL,
0x7DEF49BE1ADE201ULL, 0xD49401F1FAA153A4ULL, 0x933F282FDDF55A98ULL, 0x243235E2B7A1E0CCULL, 0xE5D01B135CFB477CULL,
0x57253A692224F1FBULL, 0x14F0BFA51B7791F9ULL, 0x0ULL,
0x6CF0D51F11296575ULL, 0xAC270DD8B6BC8958ULL, 0x417E7B6B90BE6907ULL, 0x9246B088F16922AAULL, 0xD7364AC27B199F90ULL,
0x513BE0ECAF76C1BULL, 0x5B194EFFE599322CULL, 0x0ULL,
0x994E0CF9F8E56CD5ULL, 0xA386796B483FFC88ULL, 0xFE3017E85408814ULL, 0x1553D8E8743FD834ULL, 0xC29C11BAA7ABD510ULL,
0x175E1456584B4AC1ULL, 0x9448C9245279FFBAULL, 0x0ULL,
0x627376BCB3D1FB1BULL, 0x75142898555336E1ULL, 0x5393093C1CC1DE64ULL, 0xE11D3B2107F690D4ULL, 0x105812AD309BA85EULL,
0x85C559955BCADA7DULL, 0xF74CB979182BAE9CULL, 0x0ULL,
0x86DD994277ABA49DULL, 0x915BC5B36AF0B091ULL, 0xAD38971801A2F327ULL, 0x61B565250C371996ULL, 0xBD68C7F4B56EAB40ULL,
0x8A3533FDF753CFD2ULL, 0xCA3CE30412A8A9FDULL, 0x0ULL,
0x11657F12F4E80C30ULL, 0x7FEFDDBFC91EC193ULL, 0xCEF3B47FF3018ABDULL, 0x576DCE854F648D0CULL, 0x2344CEB60D610800ULL,
0x3332065C68D50CBULL, 0xDF3937D3A8562458ULL, 0x0ULL,
0x68254A7AE649F707ULL, 0xA7A4F530EA222A2AULL, 0xD7C93A266CF74EB5ULL, 0x389BE1E01BA3461AULL, 0xD4E1C4063DB4087CULL,
0x38FCA29849D643D3ULL, 0xB9BAAF26A8655022ULL, 0x0ULL,
0x5BB7D55841794D65ULL, 0x824A5401A172EF98ULL, 0x736B34B5F7613C32ULL, 0xF29D418D14F9E4A3ULL, 0xE3EEB29EFCDA0A91ULL,
0x9E37E18A6308B5EDULL, 0xD135E604B86A5863ULL, 0x0ULL,
0x1B118354CFFDCEBCULL, 0x319DA476A411C802ULL, 0xBC5DAF03FCDB6C9DULL, 0x3472FEE413A9DCBFULL, 0x763E0F1D6DA3D5B2ULL,
0xCED84E312DDDA30AULL, 0xB766649DF683A43CULL, 0x0ULL,
0xC2D4DD50E1A19BBEULL, 0x1A862C00BD084C2ULL, 0xCF10651870B5BB56ULL, 0x16234976C9839F58ULL, 0xDBB7776ECB1BE99AULL,
0xCED42CB324E44113ULL, 0x948E99E13350F607ULL, 0x0ULL,
0x717F417A6E8956C9ULL, 0xC60E7A882BB42238ULL, 0x231DFD824A5E75D6ULL, 0xA483080814F66B23ULL, 0xD35985B1A807204AULL,
0x1CA8F980A237C68EULL, 0x6DB8AD002DA21A9CULL, 0x0ULL,
0xF4709690C0396243ULL, 0x1BD1045FBAECC018ULL, 0x864B474C5DCE3779ULL, 0x5F77344F331ED283ULL, 0x59048E40F2F52766ULL,
0x4A3E55C6535ED868ULL, 0xF80BCF5B08465A62ULL, 0x0ULL,
0xAC2FAAFF7468DDDULL, 0x71AD1F08AED78B36ULL, 0x1BDE11A19343A238ULL, 0x42DF1610B2643546ULL, 0x656D22B3779BA186ULL,
0x51BF87F234057436ULL, 0xBCF9B7040D48F170ULL, 0x0ULL,
0x7D31FB368B2B683DULL, 0x6713C9EDCCD869CULL, 0x875B672EC4A8ADB1ULL, 0xE087F58E00A0C416ULL, 0x86448B496E61F83BULL,
0xFB1CA16A09AA7943ULL, 0x64535F8C20CE84ULL, 0x0ULL,
0x199ABC6CF3841D74ULL, 0xFBE590927C5B7A5AULL, 0x8225080506F18642ULL, 0x10C472214126FACCULL, 0xF49C0B1CA6FB9A8FULL,
0xC037D270554690A9ULL, 0xB792553168ACCCBFULL, 0x0ULL,
0xEEDE768AAECA059AULL, 0x796ECA145B50E189ULL, 0x9651C63EB13F760EULL, 0xE0B01F8732007C52ULL, 0x609928A0954BE16EULL,
0xDDABC085FFCAA7C7ULL, 0xDBE574D942F3AE15ULL, 0x0ULL,
0x947639376A471464ULL, 0xC22716BDBD3B4AC9ULL, 0x3AA5D5F0061D34D7ULL, 0x144B8BB3793B6E0EULL, 0xD446FF9F9A977C7BULL,
0x1ADB9D210A25034AULL, 0x513C47CA6536136CULL, 0x0ULL,
0x8C79C63C4BEBF06DULL, 0x50462D9DB4039BE1ULL, 0xC89E4749F664A519ULL, 0xC7789FE7AD5A63F9ULL, 0x69452A946E8F4CC7ULL,
0x9F4122519B90F49DULL, 0x66EC64966829F936ULL, 0x0ULL,
0xD22A86917D2888A7ULL, 0xD1627189924B0C82ULL, 0xDBBC63B20DCF5E31ULL, 0x4A8DEA54636B4F3ULL, 0x783E40598DD1848ULL,
0x46997D01CC9DFDF1ULL, 0x4EEFAA9E81491659ULL, 0x0ULL,
0x226DF09DEC8324EBULL, 0xA307DDCA4CB50BA6ULL, 0x8A4BF0F466A57C17ULL, 0xBBE7FB323D8831AULL, 0xE6A06927B90D271ULL,
0x5C3662CF9E2ADC1FULL, 0xD5B6344EFF0E2958ULL, 0x0ULL,
0xA4BFA2A842FA7C36ULL, 0xBAF6E3F67BA37AFBULL, 0x6E7A226CD172FDB8ULL, 0x8E7017C2A38BC02AULL, 0xAFD5E7EF5D60A48CULL,
0xB60B999443215552ULL, 0x5FD7F327EA87C82BULL, 0x0ULL,
0xE833F787CD58B73AULL, 0xA31D6B65C4142AF1ULL, 0x2F1379729D17B843ULL, 0x771B4C42C0A88756ULL, 0xDE1DE5CA0C4CB255ULL,
0xBBF28C1BD2BFC3AEULL, 0x28436E29680DAF85ULL, 0x0ULL,
0xD31D309166EFDC12ULL, 0xD99C02261A6CF321ULL, 0x9F783B93EB9D10CDULL, 0xDF96CB5D38FC2E61ULL, 0x4B35F9584877FF76ULL,
0x7359F6FE6F204AE8ULL, 0xE18F6DF544589FAULL, 0x0ULL,
0x979FA8BAEE389275ULL, 0x9F6F7828D29511B9ULL, 0xD290D8FBBF57E0D2ULL, 0x2DB1071F4D0929A9ULL, 0x7030DFF956011D61ULL,
0xB02A95B2C6580338ULL, 0x91AD30FF7D8A5F42ULL, 0x0ULL,
0xBFE9AD827096F7E7ULL, 0x4C0FEB40B8E9E376ULL, 0xC055D01F08821A68ULL, 0x8DEE5768BEAC9624ULL, 0x6F6E6DBE9A4CA8B9ULL,
0x744E09A900302AB3ULL, 0x5AC0FCC2AD721070ULL, 0x0ULL,
0x5BD7599E7C073372ULL, 0x6080878C5F7F9ABEULL, 0x31F86E43147BBA66ULL, 0x5C83F5741AEE4F0FULL, 0xD6170A289FD94C9FULL,
0x2EB73345BD65EADDULL, 0x9A21D971615ECB3CULL, 0x0ULL,
0xAE1F77B158C9255BULL, 0xF4F5D5D1C2DB3A5ULL, 0x808B954E61A24B3DULL, 0x5E6ECEEDC54F694AULL, 0x571C05087B9A06CDULL,
0xAAB83A08E5AD2175ULL, 0x146A6C47BF2297D2ULL, 0x0ULL,
0x2A6238FBB7C1C582ULL, 0x75BE7F408F318ABDULL, 0x4B2596D8C3D0FCE2ULL, 0xB159691CA4D7790FULL, 0x68902DE981CF17A6ULL,
0x3F71AF573A98613BULL, 0x5E7AA12B3ADDE830ULL, 0x0ULL,
0xAA148DA222DD2D11ULL, 0x716B89BB4DCC280CULL, 0xE83FAC7CA7E27510ULL, 0x20CB16D7D7C58F9ULL, 0xA508454C3248230BULL,
0x6F0CCCE75C5F9519ULL, 0x390DB36651616A8DULL, 0x0ULL,
0x6FC8E4C3CB2D4A16ULL, 0xEFA1BE86DB011987ULL, 0xB4A25B4393B10935ULL, 0x592D435579A0E34BULL, 0x7F26C1957B2D01EBULL,
0x805800FC909E4788ULL, 0x5EFB970D1FA40FFFULL, 0x0ULL,
0xD0AFF7543F6A9663ULL, 0x493AEF67C4F53A18ULL, 0x976CBDE56E004176ULL, 0x2DD8D0FF3349066DULL, 0x96D444FF4A9CB766ULL,
0x7F824403C8EBB62BULL, 0xCFE1FAC770E8C868ULL, 0x0ULL,
0xAA2B4B3F1C0F51BBULL, 0x4B4743E0A153A583ULL, 0xF3BE16136484F9E3ULL, 0x5E6343C978E10B37ULL, 0xD83B6EEDB7E5E9E0ULL,
0x4350582CC48D5FBAULL, 0x7D37B2ECEB45E42EULL, 0x0ULL,
0x1C86F5A999BB86EFULL, 0x29C4CBBADA69A443ULL, 0xEC5AA005CE5155DDULL, 0x9A33298C15E096DBULL, 0x7A1B238F021337E6ULL,
0xD1EAFA63D2637E7AULL, 0xFCD347170F547DD3ULL, 0x0ULL,
0xAD7375A73C4105EBULL, 0xB746DCB05651493EULL, 0xCE1FB6D3AB4AB87DULL, 0x3018B5F108893E7EULL, 0x5F9A9C9EE625AB26ULL,
0x64C2FDC033306C61ULL, 0x455442CE90C5FCFULL, 0x0ULL,
0x706AF7A2878C395AULL, 0x4DF48AC169DDCD3CULL, 0x25FB882AB8992725ULL, 0xA8D7A5794BB04112ULL, 0x9D9DF749B61343CFULL,
0xC20F3B88B2C25E34ULL, 0x85DA0445F073D112ULL, 0x0ULL,
0xD94C46C40232568DULL, 0x972B0DA18E6B58DBULL, 0xAD3E645F17E14DA3ULL, 0x7D077E6A00B2BD04ULL, 0x62F7C070A3521BA9ULL,
0x30F6B77C5515399BULL, 0xA89C92887E8D276ULL, 0x0ULL,
0x31972AF749F0B152ULL, 0x7B31D7D8816D971EULL, 0x5228252BF131A8F3ULL, 0x3E79702799E8D1A4ULL, 0x6CDF46D85FF1B52DULL,
0x414EE2125BC55E7EULL, 0x85229FDEE67E6466ULL, 0x0ULL,
0x3485C66F62097545ULL, 0xD0B085F81018241DULL, 0x1CB999EC08E067DULL, 0x2ABF0EE92C28580AULL, 0x9067EDDAB2EFB96ULL,
0x7C2158D6F9C117B0ULL, 0x5073CFD9F3F16053ULL, 0x0ULL,
0xDF8D1DADE6863860ULL, 0x5DED57A78A1BA292ULL, 0xAE5F534723DD1A3AULL, 0xAAA961631A74A9ULL, 0x4778388ED6AD6629ULL,
0x416FEAC194B2CFC2ULL, 0xF6F79AD76BFAA35ULL, 0x0ULL,
0x1C3E5CD659207A3FULL, 0xCB2571A8A712195FULL, 0x967F38E469FE143AULL, 0xA4B594E87E2F9260ULL, 0x32E6822248E316F8ULL,
0x1D7432BB1A4E1C24ULL, 0xB66F184A23F345E9ULL, 0x0ULL,
0xF475F6FD9C7B2B13ULL, 0x36A90D8EE128238CULL, 0x6A722C992CA74EEULL, 0x6CCC1928E60EC080ULL, 0xF249929572FAF39CULL,
0xD94511131D5255B6ULL, 0x9E5FE226DA3A4F2CULL, 0x0ULL,
0x51C7323EEF4D83DDULL, 0xAD9F41FA315F296DULL, 0x893C8C8475217C54ULL, 0xE5B46E9C947F7FADULL, 0x4B3BF245BD8C5C04ULL,
0x701D269BB8F35BBAULL, 0x85F6C2E1662CB8ULL, 0x0ULL,
0x3A0A9A1F1F1222A8ULL, 0xDC8682CBE366F56BULL, 0x9196A0DBEE00E9A3ULL, 0x820ABCBDCCE14F3FULL, 0xF98D579B9485BD2ULL,
0xB8927C80755B71EEULL, 0xE61B17A1C3D9AF3CULL, 0x0ULL,
0xEB440401EA8314AAULL, 0x381A2D27C4FFA1FDULL, 0x218BB5C60C6EC055ULL, 0x321497547D1F2867ULL, 0x49DC8D0BB0A9EF0ULL,
0xD1A1CBAEF7FE897AULL, 0xEFBA78F341AC203ULL, 0x0ULL,
0x4CAE864BD2F8139AULL, 0x544E58B1C06DE5DCULL, 0x4A83390B6E7294B3ULL, 0x61263DF47F8587ADULL, 0x6B7ECFBE5E9C1D84ULL,
0x9E24318F5559F4EDULL, 0x15EEAD1843B1B01CULL, 0x0ULL,
0xB4FF0AA9F3E9D563ULL, 0xE4F01ACB4E509981ULL, 0x557C0901A7D4D398ULL, 0x9AAC2A84DA1DBFE8ULL, 0xFB0EF8ECE2D25EE5ULL,
0xD4810DFB697F68B8ULL, 0xCB02235EB51A111AULL, 0x0ULL,
0xAC3506473A550AAULL, 0x90E1F346D3F21F45ULL, 0xC109778922C33CE3ULL, 0xE26B478134F41927ULL, 0xA5D03001831BEB06ULL,
0x55728B8F47D42BA0ULL, 0xCB76830D23A78F4EULL, 0x0ULL,
0x21A558B930A494ACULL, 0x77C33F5A0053E1AFULL, 0x530056CF7ED82E8FULL, 0xB0153BC95B982C09ULL, 0xB0E2E5F9758EED00ULL,
0x9BDF6BFFC5A86447ULL, 0xEC839A4BFDEAC7F0ULL, 0x0ULL,
0x1A608B39C6DA506BULL, 0x635021DD224D8D75ULL, 0xCF6C05B5B2610E6CULL, 0xF56C286924BCAC77ULL, 0xF884735B6D3556D1ULL,
0x391822135C56F52AULL, 0x78FEC878C6C67950ULL, 0x0ULL,
0x1968D3C0D4673CB3ULL, 0xDD4E4816E6588773ULL, 0xD4433ED5E651CEDFULL, 0xB20C178F96149C7FULL, 0xC33AAB5350AB6558ULL,
0x33315372D50F3435ULL, 0x4A45502BBB16E42FULL, 0x0ULL,
0x6C7B27ECA058295DULL, 0x781EC42E2673EB88ULL, 0x75B8AEF773636305ULL, 0x20C131C5A4CDB34DULL, 0x55594080A43E7AD9ULL,
0xD8ABD784FF5960CULL, 0xC4D1FB047DCE36EEULL, 0x0ULL,
0x7F0FB0129E51662FULL, 0xACF694E8537D8858ULL, 0x4A83353671BA0D8DULL, 0x478731DA996B7832ULL, 0x5E788FF59ECAAD20ULL,
0x6FF71B23C3822B2DULL, 0xA37D3F1602E0A1B1ULL, 0x0ULL,
0x93DC792792CF4E23ULL, 0xE1087DE3AB847512ULL, 0xECBC2519E7CD4972ULL, 0x57363CB6206C5B3AULL, 0xCE97228AC1D044B1ULL,
0x38C0DCA743B59450ULL, 0xDFD38BD048B78468ULL, 0x0ULL,
0xE9DAB9A032DDC679ULL, 0x85C42636A8979996ULL, 0xAAAFF750E503BCF2ULL, 0xACDD4F5C741B3C0EULL, 0x179B2C5BB60D7775ULL,
0x62577208C45FDFB6ULL, 0x4465D5E834B672ACULL, 0x0ULL,
0xEAF1FAF1E05A8E46ULL, 0x7F6ADAB779131B61ULL, 0xABD11A3B9E228399ULL, 0x6524AE0EF6FD789CULL, 0x55707099F454B085ULL,
0x28669CD2DD03635DULL, 0xB354487A584297E2ULL, 0x0ULL,
0x5F5B254CCAA0DCD3ULL, 0x65E447826E239CB4ULL, 0xD596C3D0C1554005ULL, 0xBD0189AF36A9EB89ULL, 0xFA119893C4684383ULL,
0x93DBE9619BC0D3BBULL, 0x1B35F635427671DDULL, 0x0ULL,
0x776FBF27149B88B9ULL, 0x768AB6E3580F5D60ULL, 0xC6BD936EBA368DD6ULL, 0x48E80F5185D62AC0ULL, 0x1D7867EC20D55A81ULL,
0xB1DF05EC6E281F59ULL, 0x44AC78387DED2E4AULL, 0x0ULL,
0x83A88ED9283709C5ULL, 0xF565199713C5EFCAULL, 0x1807038DB41E5BD1ULL, 0x58F66CDBDBFCD8A4ULL, 0x401DB398C5DE159DULL,
0xF48CB864876F7B09ULL, 0xDB258E24C9259EEBULL, 0x0ULL,
0x1F69212A25DECC22ULL, 0xE6C0CD604FF834D7ULL, 0xCDC75203D0C94447ULL, 0xADEA843484D4B4A7ULL, 0x841AEFA34609D1E5ULL,
0x7A0B5BEB48BB2E5CULL, 0x3CEB5EF5FD513B33ULL, 0x0ULL,
0x7A3667C9ED25CC94ULL, 0x5249B520FE4DC7DFULL, 0xE3D13D904D22B02FULL, 0xAB2871B8EDF97630ULL, 0x2437D87F68DF3F8FULL,
0xBB804EAB0706BB2CULL, 0xBDFF3ABEC816518BULL, 0x0ULL,
0x6B9AD07A523545ULL, 0x8E07ABA5F99D4734ULL, 0xDF83FB69A71CF462ULL, 0x70847412A0A9280EULL, 0xBCC160769B312C15ULL,
0xD929FFED81198008ULL, 0x67CD6B53AB5B20B6ULL, 0x0ULL,
0x7F95FA7E499C06EBULL, 0xA1443707E8AE4FA7ULL, 0x57F250C0237521B7ULL, 0x3883A49460E4BC01ULL, 0x4FB09DAE572CA3BBULL,
0xB69DB8DFEFCDE0CULL, 0x4404D81FD78B907EULL, 0x0ULL,
0x9843B34DB8339271ULL, 0x7AC485FA59EEFD82ULL, 0xC6F575483717155BULL, 0x3C5208A3CDD4BF61ULL, 0x277D6E31EB8FCD2DULL,
0xD54EF3E7FDD7142EULL, 0x501C8718A2571E05ULL, 0x0ULL,
0x218E20B4258E2C7DULL, 0x91A889CC95B74FE3ULL, 0xD5252A0278EA7B5ULL, 0x2004AFB7B2429937ULL, 0x18336559F458D3A8ULL,
0xEFF93E22092243F9ULL, 0x5E04DF50F5DAF08AULL, 0x0ULL,
0xE799A5DE9BE18A3DULL, 0xFB0C01EAA408DBE1ULL, 0xED71E774A18926FEULL, 0x3FF99AD5A8492633ULL, 0x4B65CD9240F03165ULL,
0x558D16DE15035D39ULL, 0xE4AFE058B944F53ULL, 0x0ULL,
0xB4CAC14523560A08ULL, 0x2EF80295D43E8252ULL, 0x9D5F06FD0217E8EDULL, 0x4C9800A577B73DD9ULL, 0xC17F1B72F788497DULL,
0xDF36B7AB5E78F83AULL, 0x1EEEDD1DC2E58D17ULL, 0x0ULL,
0x7DDD233A07A601A2ULL, 0x5CA9C475F4920DE8ULL, 0x80DB1CDF638E017AULL, 0xECC899F49AA484CDULL, 0x30630D52AFBD6F8AULL,
0x3F929CD801C84627ULL, 0x53694EBC4A853D7ULL, 0x0ULL,
0xFC93CF115A257B5CULL, 0x3145977FD97D1CB9ULL, 0x13FCCDBEDB40D62DULL, 0xE5DF697B5291CC8AULL, 0x2D614C488CF2E1D6ULL,
0x6948F32A69F46EBBULL, 0x11AD27C9231CB7BFULL, 0x0ULL,
0x426C0ED51A2063DBULL, 0x25E3E701B5F87032ULL, 0x235EE372171138E1ULL, 0x979304A3F742C78CULL, 0x5F8C68EB157C9588ULL,
0xCD86AEE8B327D58DULL, 0xACE89E167554B242ULL, 0x0ULL,
0xBCB4EF71ED8A7A20ULL, 0x746DFB68F75AD00EULL, 0x13A4778C0E52EC6BULL, 0x2463CA79235E9627ULL, 0xEFB857B436DF4ECFULL,
0x5243188467A126F8ULL, 0x4C9FF30822A3DD5ULL, 0x0ULL,
0xCCEDDE7EE4D3EBDAULL, 0x755624EC4C28A4DAULL, 0xABAF613A5FBBC8C5ULL, 0x524ABE75F52EA8EDULL, 0xFF3FA340EC29DE66ULL,
0x8F1FA1FD43B89141ULL, 0x94DF0F26984262FCULL, 0x0ULL,
0x19C94FC175CB686AULL, 0x86521A05EC835B00ULL, 0x27BA0193D337E9D9ULL, 0xED0A27497C7A206ULL, 0xEE11901E7EF9622BULL,
0xCA66A264D12D21BBULL, 0x409143ACAA8A8B4AULL, 0x0ULL,
0x87B0568054C7A928ULL, 0x4573154810F0B26BULL, 0xCD4875AA55AB6D4EULL, 0xFD778B4C540D4B29ULL, 0x14109790B1F80B5FULL,
0x79CF449022257F43ULL, 0x26D922065875D971ULL, 0x0ULL,
0x7A1BC7E440B28C2AULL, 0xF51EB9B24BC0F81DULL, 0x6AD228CBDA9E5A4EULL, 0x670828276B1AF279ULL, 0x5757ACB935054781ULL,
0x50D2CF67D6884D14ULL, 0x77946DB9FF0151EDULL, 0x0ULL,
0xBDDD4D5FADC341D6ULL, 0x7C5AA47D57A6294EULL, 0x5FA7E406E2442EBCULL, 0xE1E295954EC7BD9EULL, 0xD1C096042D836539ULL,
0xAC89BCC19DA6649AULL, 0xDFB2A8E2618A49CBULL, 0x0ULL,
0x2776E8BDA0B3BA84ULL, 0xD0C332E834E84CDFULL, 0xAF5E730E8BA8AF9EULL, 0xC1435DFE4B9A6D08ULL, 0x59EA18F62F60CEC3ULL,
0x7691BE89C21AB5E1ULL, 0xADF4D3BB3F8A77E0ULL, 0x0ULL,
0x6D11C7FAE701EDULL, 0xCB198F23BFD55EBBULL, 0x91225618198D9AD6ULL, 0x720A44E6C0036F32ULL, 0xD0C300C7B21DA9A2ULL,
0xA98A9CDC8413C430ULL, 0x6D3D32D0B3FE1253ULL, 0x0ULL,
0x122A90C01E9274E4ULL, 0xD681D17345E75BF6ULL, 0x13E5A0BA72B18798ULL, 0xB5E432595E1CBA8DULL, 0xF072115BD3AA2E9FULL,
0xB05B06F64792A071ULL, 0x449474BD18B1B7C3ULL, 0x0ULL,
0x386CA1BA71029418ULL, 0xA81DB05A9483B21DULL, 0xFDA1AFFF231594CULL, 0x5C26BEDCC46377DAULL, 0xE5D8C94BD1FBF202ULL,
0x862941EE2FEC0CFBULL, 0x7D69A5443AE195A7ULL, 0x0ULL,
0xBFCC24A31EE00687ULL, 0xF814E932F4FE782ULL, 0x11DDDAF98EC81E12ULL, 0x23B927AA3D26E411ULL, 0x797DCC4CD66855F5ULL,
0xF51657A54AA04A77ULL, 0x1BFE5E58F09A7358ULL, 0x0ULL,
0xFDC6DB072808D5FULL, 0xB9BA50D24250DC66ULL, 0x3D97D1DC0F343995ULL, 0x36F0A61DFEEAF481ULL, 0x385A88E172944344ULL,
0x44AECEA1AB84D5B8ULL, 0xF308466A56A996ULL, 0x0ULL,
0x3516308948445612ULL, 0xC36C3E02404B7AF5ULL, 0xDF5CF3F3B2FBC5E5ULL, 0xE869BB03F5AF2661ULL, 0xE7F5380CFAEA17B5ULL,
0x6190CF22C43D0156ULL, 0x38881981EBA64854ULL, 0x0ULL,
0xAC052191C49AA179ULL, 0xCC7F0290CCB59055ULL, 0xC7D8A6F0CCB4364ULL, 0x3BE1AA15F8EFDAB0ULL, 0xA26403E85E3AA742ULL,
0xD7FE28E5D58326EBULL, 0x5062872214C77D2ULL, 0x0ULL,
0xB274BFAFD057E9D6ULL, 0x9AF529EBB11B589AULL, 0xB6800ED30E59D2E2ULL, 0x338F1043A7248776ULL, 0x61AE294990AA324BULL,
0x781BE08803955B09ULL, 0xF9B3ADFAAC6D1320ULL, 0x0ULL,
0x78633C6A8EEF87E7ULL, 0x81FA09F7F9D3CAA1ULL, 0x77800C4653A86AC8ULL, 0x1BDD4E8A064E42D7ULL, 0x2F069E9A99C706FCULL,
0x81244E5ABE5F93B6ULL, 0x90551CE1C8C308B9ULL, 0x0ULL,
0x82528A659D9EFA74ULL, 0xA10F27E18FE8B399ULL, 0x31BDB8577ACE6570ULL, 0x13B722D46204F447ULL, 0xC33EA8C436A78495ULL,
0x76F34CE17F4ED5DAULL, 0x77C33831591AC993ULL, 0x0ULL,
0x920936B667C69B6AULL, 0x3DA4388FBFE51FE0ULL, 0x454D538C8B697F4EULL, 0xBE0AD3673EB91619ULL, 0xE94CCD7E2CFA3893ULL,
0x607E45E3466F3E8FULL, 0xE7489B2E2351F72BULL, 0x0ULL,
0x6DC9099A8EE7EE54ULL, 0x865353F800B7118AULL, 0x5D84DF235DF3E8FCULL, 0x2824276F1FA30F2CULL, 0xFA7ED7D4AA69AA3BULL,
0x3E6ABA3B941D883CULL, 0xB36D58FDA057D3FAULL, 0x0ULL,
0x2B2E7499976C9E90ULL, 0xBE56C0E32E6F60BAULL, 0x3C524834556E3BBAULL, 0xC2302FD5D63A4B76ULL, 0x7F3CB94930A68276ULL,
0xE0C9867D0658D8BBULL, 0x4A8808401416A707ULL, 0x0ULL,
0xD57A1638B7E8512ULL, 0x93A375E2048C0A92ULL, 0xD868BA4A4B8F3BEFULL, 0x6100E37838EDAC09ULL, 0x393F2068D0D32647ULL,
0x2D774D41E671AC5DULL, 0xE6D2B88D938F663DULL, 0x0ULL,
0xAEB82F5EC3E99BB6ULL, 0xAB602A922199F6A1ULL, 0xC276A2B8A1B1BC29ULL, 0xD78C429F9BE3A01CULL, 0x5F3F26D198F42F8AULL,
0xA6815104E009615ULL, 0xFC6CB77F80AEB1D7ULL, 0x0ULL,
0xED7B7BD853498AAULL, 0x8F1CD5238FFE5B5BULL, 0x751758FBFAA8A9ACULL, 0x37F202D7F2B5C1ULL, 0x61D60437983E25B6ULL,
0x190D500614CE294DULL, 0x4AED4A3EF25D664AULL, 0x0ULL,
0x317EC14D37F96EFULL, 0xF91B8BAC84EB08C4ULL, 0xEB69944528D15CEEULL, 0xB449BAC48CFCF98DULL, 0x3F9AA05305B965DEULL,
0x6A583BCCE83B876CULL, 0x9A6A83500A6CC682ULL, 0x0ULL,
0xEEF870C7D13E6CA9ULL, 0x3169D12A67C8D4A4ULL, 0x91A79995D423BE8FULL, 0x8C9B622D460E7E4CULL, 0x717B6B5D846F3546ULL,
0xB9B1E25518F5C7BAULL, 0x8467B2F9A783E01DULL, 0x0ULL,
0x5CCE1674B380EB66ULL, 0xA1EFFE2A562992AEULL, 0x65DC8FE347233C35ULL, 0xD2094B505CC793AFULL, 0x88757FAE31EB4E26ULL,
0xB20905CBA2550482ULL, 0x7267BAD04A997195ULL, 0x0ULL,
0xE4D8AEFDD938B844ULL, 0x8D045DAC30E0F604ULL, 0xF407EED5FF00336FULL, 0xBFFE33B43CDA3323ULL, 0x97B55C87B8508932ULL,
0xDBB858FDC37E676CULL, 0x4EBACD9CBCAA0F5BULL, 0x0ULL,
0xC8E16140D2FEDB2FULL, 0x6578D07F88EE15ABULL, 0x3DED549FB9CAB7B7ULL, 0x681B9A24A9BA6B9DULL, 0xA05A5A2DE520C320ULL,
0xBF7462273DAA3824ULL, 0x9A03F876A4F014FDULL, 0x0ULL,
0x158468A0EEA99528ULL, 0xAC8EA09DAC8E214FULL, 0xB01269FB88FB3C4DULL, 0x9865BB787C65D982ULL, 0xA4D3E88D1875A6AULL,
0xA358B7907A103955ULL, 0x8B384F2400DB5200ULL, 0x0ULL,
0xC3EF4A52134D9483ULL, 0xB95E74C48D13C66EULL, 0x1594A462E989189FULL, 0x564088536D8BB398ULL, 0x7160F87B2A5938FFULL,
0x63C09D04CF37832ULL, 0x1E25ACD758A3788FULL, 0x0ULL,
0x5647A2A85043BC6EULL, 0x2D2C14B7BCE036AAULL, 0x183C24A4C55F00A7ULL, 0xE77F613E5950EC9CULL, 0x11CCD967F889238AULL,
0x9A31D996F0720997ULL, 0x4F86CE1BB860D671ULL, 0x0ULL,
0xD36AE6BE0FC493B9ULL, 0x72E571606F6619E2ULL, 0xDEB0FD1A08DD60EBULL, 0xDF3A5E1A5E3599D6ULL, 0x964161BAA494B0C1ULL,
0xBD69A7D72AE5B22ULL, 0xCE85043DAAA8D863ULL, 0x0ULL,
0x1BF739E53A3EE912ULL, 0xDA47FF1C7C31A1C5ULL, 0x1E2EC374EC8B95F4ULL, 0x20D82F996D5F3C00ULL, 0xD66295C63B2B2079ULL,
0x27C49A1B2A1AE6BFULL, 0x7919F5B4415D7CF0ULL, 0x0ULL,
0xB126E1ABD0804B70ULL, 0xCD6F2D3090D79FD2ULL, 0x6E5740203A4A361DULL, 0x14404A823631CAA7ULL, 0x3384DFBFA999ACE5ULL,
0xDD2EE2F606C35DCFULL, 0xCFDA8E1B6575DC90ULL, 0x0ULL,
0x8CA7CF3E051FB628ULL, 0xE1177F3A9CC7E537ULL, 0xFA4A6E220F8AB7C7ULL, 0x64824756BB666C25ULL, 0x8A9DC01A4E5F03CAULL,
0x47C211088EEEF485ULL, 0x623D07A77A9F5317ULL, 0x0ULL,
0x88CEDFAB2D279B51ULL, 0xABCF72E0E6B2A336ULL, 0x2E78813DEC55EE75ULL, 0x3346C1F53B9B35EULL, 0xAE603C9E9D463283ULL,
0x652288DF8C27AF1AULL, 0xCB5D8BCCD8FC7A99ULL, 0x0ULL,
0x44CD0B5256A39CADULL, 0x42740776E657E78BULL, 0xC9BE1AAFF661522EULL, 0x48458C5404E903B9ULL, 0x6FB1AA491294F2A0ULL,
0xD4F34120EE145C64ULL, 0xED60C9573D0FCCFBULL, 0x0ULL,
0xB11C2C07780C7DCAULL, 0xD228E59E3300722DULL, 0xF3CD7579914BCC2CULL, 0x92DC38EA61245B35ULL, 0x5A375A435B015157ULL,
0xCF31B3902228B850ULL, 0x29C53120F44CBC14ULL, 0x0ULL,
0x70EDF226611801BCULL, 0xFE324D1F976490A0ULL, 0x680DDA4315FB7039ULL, 0x3D5AC19AAA9556F2ULL, 0xF6AF05D466A4AC66ULL,
0x88D42D2985DDC0C9ULL, 0xF758EED9574F2DCEULL, 0x0ULL,
0xE0BBCA7731D777C2ULL, 0xF7B58ABAE3A8A799ULL, 0xE2FEAC498D433FA0ULL, 0x7FF6C2378E7D81FEULL, 0xBF5F3660D5B53393ULL,
0x3773B4BA5127F026ULL, 0x9E997838EC1EC1F4ULL, 0x0ULL,
0x5DADDD3D3DD1BAAAULL, 0xDF24F2773A2ACCB1ULL, 0xCC59A9DA8029175FULL, 0x595CCA1D82A849A5ULL, 0xF362C07B0B0406ECULL,
0x26ED1109F9DA3344ULL, 0x283C99F0D6612592ULL, 0x0ULL,
0xCAEFB4B1894D34CFULL, 0xFB01E059B2A7D8D6ULL, 0xD443D70D42C90E7ULL, 0xC4DAEB1A627822E4ULL, 0x7A68D75A405B8CC8ULL,
0x788E05B26FBCEA7FULL, 0xCA963D687454128FULL, 0x0ULL,
0x3A761F0BED3E7F7AULL, 0xF00B2774CEE934AAULL, 0xAA9CE4ABBAF809B1ULL, 0x63F70883FA6B87CBULL, 0x6683C6F013058D46ULL,
0x4E2A345338BCF0ACULL, 0xB2AC0F361920A0D7ULL, 0x0ULL,
0x1058C4F11D826397ULL, 0xF2C937AABA41AD36ULL, 0x4869D881405474D6ULL, 0x4DBD85187182FBF4ULL, 0xC3C3249F508C9134ULL,
0x528C163FA8231138ULL, 0x84CA83C07933115BULL, 0x0ULL,
0x86C66F296D98D7D1ULL, 0x901B62D20B91BD40ULL, 0x95970A152B5C59E3ULL, 0x51F07FA33699E73BULL, 0x29646672CCACA445ULL,
0xC9E0E0C24CF6BB1BULL, 0x4F6D5622CAC99561ULL, 0x0ULL,
0x798163F73459ED01ULL, 0xEB6DC0F19983085DULL, 0x34E54288DE67DEB0ULL, 0xF4EB40D3B7ECDBBBULL, 0xFC0F070DB54E7E16ULL,
0x9CBDA8185D3D76C4ULL, 0xB93B22D2CE341C07ULL, 0x0ULL,
0xC6E22711164EE2C2ULL, 0x6D680FF4BE04C496ULL, 0x7385196E0F7D191AULL, 0x8515A3C69045857EULL, 0x22F046793F124AA4ULL,
0xA7DEA3A3156E0662ULL, 0xF8F67F7ED31B2C9ULL, 0x0ULL,
0x6BFEDFF0679430F8ULL, 0x837D78B4DFE98AE6ULL, 0xEB2CCF8330AF9C81ULL, 0x75B340802AF5F737ULL, 0xBCAB916A5C9E29FBULL,
0xC57A46E552876D38ULL, 0x4E760B33513B1D12ULL, 0x0ULL,
0xC35DC57192A2B963ULL, 0xD9853158B9C4DF0FULL, 0xE3D344AA06513325ULL, 0x96356D3A953B4DULL, 0x2AC5B946C58F7ACCULL,
0x6ABBF43816B2B1A3ULL, 0x7C177133A3604C22ULL, 0x0ULL,
0xC793888EEF850C7ULL, 0x5D3A20D7A464901FULL, 0x372123CE635ACC9FULL, 0xC366169F62FA2E9BULL, 0xCCF456DDF215AA06ULL,
0xB4891D44E74A618CULL, 0x7D8FBCEB85CF5683ULL, 0x0ULL,
0x6EEAE7420BD1452EULL, 0xBBA322565DC15D05ULL, 0xF3521B2AEF8078F3ULL, 0x8C97B5C055C8A09EULL, 0x2A25862C5F1E229CULL,
0xA6B7F368029C658AULL, 0x27F061A368D91DD5ULL, 0x0ULL,
0xEE3AE0292BE5F7D7ULL, 0x2D7F077EBA79BF1FULL, 0xF15EAA78A211EF6DULL, 0xB25B92D62EB1344EULL, 0x7C12FB1C62AB7DB2ULL,
0x79DFC6B40B869DF0ULL, 0x1043B5E0497390C4ULL, 0x0ULL,
0x62A186F3783E6C2ULL, 0xECEC3212947DF00AULL, 0x463FE8F108F35C79ULL, 0x509C609F17E7D762ULL, 0x876054F2D5408B2BULL,
0xCD5BACB0E09D508EULL, 0x4A870403A59AC17AULL, 0x0ULL,
0x1D88CC3C158B5436ULL, 0x239DFBFF50194E80ULL, 0xC12D941525C37853ULL, 0xFDB0E9521FF38A0EULL, 0x3084AA575A7332ACULL,
0x5F64A9BBF2850619ULL, 0x733B7E85DFEB5D9FULL, 0x0ULL,
0x1D1E9061C86375CFULL, 0x301EB663F73A0E83ULL, 0x75F6793D49BEDA2DULL, 0xD8E66FD0E66E75AFULL, 0xC50526884C333F20ULL,
0x5588B780C72B7EE7ULL, 0x7DFBBB595651BB1EULL, 0x0ULL,
0xD34B29449302B9C8ULL, 0x5F6B61BA8FEC324DULL, 0x2ADAEEEE7685E2BULL, 0x2EEE60C8F7C7E79ULL, 0xDE3F620E81F0D407ULL,
0x4D0147A09C1778F4ULL, 0xB380BE06E7D2F434ULL, 0x0ULL,
0xC6490BD0283EC0FFULL, 0xEA94D6513DEEDE78ULL, 0x3F80579BCD97E50ULL, 0x73D98F878194CC8DULL, 0xFFB2AB9883CB603FULL,
0x9A493B55FA24CF3DULL, 0xC06C1AA7922425C0ULL, 0x0ULL,
0xE8F9D8D4F3FEC438ULL, 0x5D4696839DA7F5C6ULL, 0xB1CB89F49AEE7D1ULL, 0x99BB941DE76E9630ULL, 0xA9064F6C45D3ED3BULL,
0x19AFF5CA2ABD0691ULL, 0xD1FB4C665B6C4E33ULL, 0x0ULL,
0xC27D026D6B2B28BFULL, 0x2CD385F53278F7DULL, 0x581E6761A5E0A834ULL, 0xB98A9548FDD0A6C1ULL, 0xE69A8C56E9C4A9D7ULL,
0x3BBBF441FDD2BAADULL, 0xDB93C00D88663F92ULL, 0x0ULL,
0x60AB564A74E10B0CULL, 0xAD12207D39E066B4ULL, 0x4CB97E800B69B7F4ULL, 0xD336AC971FE704A9ULL, 0x31A53C88382EAB36ULL,
0xF46718B53E87351CULL, 0x41416C660DA3A07FULL, 0x0ULL,
0x4C4873DA1703384EULL, 0xD3721AE3A425614EULL, 0xA88E895101FAA50EULL, 0xD4D303056037DD55ULL, 0x112019ED2637D5CCULL,
0xD4947022AF9E8C16ULL, 0x907DDCDA08030462ULL, 0x0ULL,
0x6F8C8B301A4F965AULL, 0x5537DDB616ECD3AFULL, 0x3453EF257BD1FFA8ULL, 0x7B08F021BBEE1C63ULL, 0x4999A21532F34C1ULL,
0x18F0CCA9B4868B2AULL, 0xEDDFDFFC9F314BDBULL, 0x0ULL,
0x7FE5947AB2A519BULL, 0x426C534FFCC2C1E3ULL, 0xED53C572D2E69FD8ULL, 0x7C06689D43862F67ULL, 0xBD6F102324DBDFB6ULL,
0x571511B7C1DB1CA2ULL, 0xCBAED4B693E8C28EULL, 0x0ULL,
0x7A40F4E7685D83EULL, 0x69EF14E6E75BF7AULL, 0x8E08D8BEA7E5AC89ULL, 0xB54CF1D7A0EB492BULL, 0x9DBD67542FEEEAE6ULL,
0x7626622A78C193B9ULL, 0x5E7A1022B8B52AB1ULL, 0x0ULL,
0x1A44FEE9E1103DC9ULL, 0x9098228667E6581CULL, 0xE674EE06E57AE5B7ULL, 0x8D246711EB5982E1ULL, 0x6994382072C6954ULL,
0x50488A87CF793F20ULL, 0x6C85488141E50EF3ULL, 0x0ULL,
0x4F2BDEA87D14735DULL, 0xFEA4CD1AAC92A469ULL, 0x86C90FCC00671D85ULL, 0x770074F435B41739ULL, 0x489627AFB0D6379BULL,
0xD7F62172495A4DB0ULL, 0xECBC1AEA814609ADULL, 0x0ULL,
0x450B23BA84B38CC3ULL, 0xA68E680C6F472158ULL, 0xC7B45BB59F5F0F7DULL, 0x7040AC3801FE7849ULL, 0x22FDB35BA760FA15ULL,
0x45F0ADCC4E72B3AFULL, 0x14AD88E6656DE1B0ULL, 0x0ULL,
0xAFB3B05D778CF823ULL, 0xF3C521440ECDE18ULL, 0x8C5DA44EDB928AC0ULL, 0xB995201D600EDE89ULL, 0x48D43ED2EC76DA71ULL,
0xC96CE8B9E2BD998DULL, 0x277A2D4AE4F83005ULL, 0x0ULL,
0x7E9B787DF78E6FE5ULL, 0x65B273B544A72D49ULL, 0x913C566907E543F5ULL, 0x63E89BF55BC45BFCULL, 0xC200E7444675CDE7ULL,
0xBBB3FFB225C58ED3ULL, 0x39F6C390A439E51AULL, 0x0ULL,
0xD4FBE6B941D4E48EULL, 0x408B9F9F01EC89E9ULL, 0x18330D4A4375E53CULL, 0x83767CC60B859F65ULL, 0xAB8B05D70DC941C5ULL,
0x850CD116FA57F8CBULL, 0x3C83BDDD38AAC945ULL, 0x0ULL,
0x2AE1B381250D7A36ULL, 0x7690BDBDEF53DA82ULL, 0x7916B6DED4D08FEFULL, 0xEC90FE6C802A947BULL, 0x45CF68A9CAFDAC1DULL,
0xA40F6741D66C449BULL, 0xF3B28DD649F7B4B4ULL, 0x0ULL,
0x87CDE1380E4C8E99ULL, 0xFA4D615202DE59BCULL, 0xE6CDCFA48B9DD3ADULL, 0x5D2AD26564C2FF1ULL, 0xE254CF5E81CA2988ULL,
0x338A9C942FC036E7ULL, 0xF34698434F3C69CFULL, 0x0ULL,
0x1CF4BA6FAA185364ULL, 0x76C24408DD30158FULL, 0xBC6502FB9632A690ULL, 0xD0835D0589434F9EULL, 0xB092CBEF52125842ULL,
0x273455B51159E849ULL, 0xC0E6A388DCD71DD9ULL, 0x0ULL,
0x2E1AAF166BDDEAF1ULL, 0x5FC4D2C6E938E973ULL, 0xF8B284DD66EDB5D4ULL, 0x72DD27A2F66565E8ULL, 0x29AB241E0568715ULL,
0x52FE0790906A1D8AULL, 0x510D24F1996001ACULL, 0x0ULL,
0xAC3731426909FF8DULL, 0x164C4FDB447DEE7BULL, 0x574E11A92A8B2B5BULL, 0xC267F7C2ED37123DULL, 0x96FD5913E4E632F0ULL,
0x1718E60C4326E9F6ULL, 0x238C9A8AC6934C85ULL, 0x0ULL,
0xFF1F780D43E4090DULL, 0x3FE11DC680ED665CULL, 0x6B184F26F2E0AAF1ULL, 0x7FFF3EC368CD5337ULL, 0x1B8FC4FEF7B357DEULL,
0x30AAD7BA08F3FF03ULL, 0x72969623AAE15E28ULL, 0x0ULL,
0xBD1FF3D510A6D00BULL, 0x2829400230CFFA26ULL, 0x30E67E563A11487BULL, 0x530EF2CDDF4B94DDULL, 0xCCCDCE7263013CB7ULL,
0xB5319B916D58BDC8ULL, 0x1448BE888E113AD7ULL, 0x0ULL,
0xB5BB9C1DF6EED05FULL, 0xDA67AD060628C759ULL, 0x5CF9172EBFA8C14EULL, 0x850BC393DDD48156ULL, 0xC7431FDE04122361ULL,
0x54B742C7C705598ULL, 0x40295D8C0AA7AEBCULL, 0x0ULL,
0x1EDB337543D3248FULL, 0x508F54CF8481CCEAULL, 0xB41F8570B90698A7ULL, 0x6D408AEE461DC878ULL, 0xB1C46BDED6A1F724ULL,
0x1176515C7C79E936ULL, 0xE29EBA9268EB7E2EULL, 0x0ULL,
0x2C40B76B73107BB1ULL, 0x99187434789C91BEULL, 0xA8BFC2D7BFB74793ULL, 0xBCB28190A5C71DEULL, 0xBE36ECB522074D62ULL,
0x35628D180C2957CDULL, 0x154FC9560FFFA149ULL, 0x0ULL,
0x7C0CB261A7EC9B43ULL, 0xE5F3144B06A8062FULL, 0x8E89FC49F25E91DDULL, 0x8F5289008DC09CDCULL, 0xC5C8D7A538CCB365ULL,
0xD5CEBA0FF63FA108ULL, 0x9B03E4C543CC60FDULL, 0x0ULL,
0xCB73B172D8D5E3F5ULL, 0x5DEC195C14A5C39FULL, 0x1FDD22CB7D1D3E9CULL, 0x440ACEDD2EEA0405ULL, 0xEA37BC9AE847761ULL,
0x67EE0FEA37979F56ULL, 0x775A5E81843C1123ULL, 0x0ULL,
0x7DAE4E9FCE51F401ULL, 0x6B141C2B5A8FB108ULL, 0x829B60F54954FC79ULL, 0x9B27DBBB932C6A1AULL, 0x97A3D6AB0BBC5736ULL,
0xCEBAAC430B8AD098ULL, 0x5A7C48862F59E137ULL, 0x0ULL,
0xCC624F726AF5D4B5ULL, 0x98F717E9D2713AEEULL, 0x71C57528CF5B630BULL, 0x2370E3B1F1BCB82CULL, 0x31659ED55CE4B849ULL,
0xB4142D6E7180BC58ULL, 0x624BD980504D58FCULL, 0x0ULL,
0x15345A43FCFF7A27ULL, 0x5DA1861567D7D6F8ULL, 0xF1C4ED0F66A5D296ULL, 0x8761A6BBEEF40C7BULL, 0xFCCB3DFB97D3257CULL,
0x97E2AD6C759593D3ULL, 0x15CB6C8E5B69FBDBULL, 0x0ULL,
0xDAB18CCD8CBAE7BCULL, 0xD03ADE7AE7CABA5AULL, 0x72FB23B886A2D2FDULL, 0xBA5BEFBEE62C7969ULL, 0x6EAF0A5F3A17A193ULL,
0x6427498FD17DB684ULL, 0x2904BEBD313E19E4ULL, 0x0ULL,
0xCF36037A54612947ULL, 0x12204E92DC34712DULL, 0xE1D6D0A7D929501EULL, 0xCF3BEA98C9BCA4D8ULL, 0xE0704EB262D58D53ULL,
0x67A079106D4C4CD1ULL, 0x39A18EABC86407B0ULL, 0x0ULL,
0x270D0E0070C30903ULL, 0x36C3815EF89C50B7ULL, 0xF031F57C0ECA1834ULL, 0x355AA07E83315584ULL, 0xE967665A5FDFB9C7ULL,
0x1006F2EE294F853FULL, 0x453DCC6A9960A7A7ULL, 0x0ULL,
0x4BE1388A524AE70ULL, 0xEEDA9C323A13B0FAULL, 0x62F9F96F6439FEF0ULL, 0xD68D5CB0D7A89C27ULL, 0x30A091C8FA70F87CULL,
0xF77C70C4E2AFEA16ULL, 0x81586D815AF65D7AULL, 0x0ULL,
0xE7F9D538172E24FFULL, 0x79EFD36D8F2EC689ULL, 0xEDE33AD2420E29BBULL, 0x8360AB378BE3AE75ULL, 0x19219EE15402EF36ULL,
0x47C18EE97842A77DULL, 0x28FF3945FE910E9AULL, 0x0ULL,
0xD23C5ED2110DA38AULL, 0xEA215276FFCB1A11ULL, 0xEE534AE296CF58DBULL, 0xB3A1C45DEE96F24FULL, 0xEF8418F4F487AA8EULL,
0x75DDE8065CBDEA68ULL, 0x7D8916D311E0BAC3ULL, 0x0ULL,
0x1AA6B4A842FE90AULL, 0x5EFE8ABFC54589F6ULL, 0xC40DC139CD3F3297ULL, 0xC204279052FB421BULL, 0xA7FFFBEE78F6B1F8ULL,
0x801A608415B77DE6ULL, 0xEDF19E6210D5B62BULL, 0x0ULL,
0x1AEAB76AB7A7AA28ULL, 0xA25E7CE0FD013DA5ULL, 0xFF882D9817700B0AULL, 0x8E0ACA647B94610DULL, 0x1AA90AE35873381DULL,
0xED79DCCCEAFC96BEULL, 0xD446E945EB69733FULL, 0x0ULL,
0x8AF8A5DAC409C727ULL, 0x3F658461D5660B6ULL, 0xBC6CE12110D41890ULL, 0x9531E47C7977FB64ULL, 0xF1D82E79078E3919ULL,
0x62D04B5287509024ULL, 0xF312B315D4F83A24ULL, 0x0ULL,
0x91CF6ABBA25E4DFFULL, 0xC079A9B82D994AF4ULL, 0xEDDDC87F8EBE1C4FULL, 0xD8EC102ABD265FDEULL, 0x102EB78CCAAA0C76ULL,
0xF670EF0B2A104EF1ULL, 0x45F330402275D1AULL, 0x0ULL,
0xD7EC349BE2966C42ULL, 0xCE31B17D6E560ACULL, 0x25EB102123EA0ADAULL, 0xD05D52522B50EC22ULL, 0xF22E511192C907AAULL,
0x22BF55FA18B355E1ULL, 0x15A9ECD09703FCE4ULL, 0x0ULL,
0xD897AA9A3EB883CBULL, 0x53F80AEB22A62465ULL, 0x8811EA40B6A2CF5FULL, 0x7AF9818446954549ULL, 0x95583726FBE67C7EULL,
0xF27C17D87F6CE29EULL, 0x1F3E3A58E0B04EB1ULL, 0x0ULL,
0x4D3FB9A52092FA6EULL, 0x9D4845BAE506295AULL, 0xEB03B4374ACF6515ULL, 0x1EF613C5D0EFC66BULL, 0x81381CAC222CB487ULL,
0x1A3ADD51EC069E80ULL, 0xA76A999CBEB22345ULL, 0x0ULL,
0x9FA97A8B0D96A665ULL, 0x8ED79E3CF78A7E21ULL, 0xCB131F9A9D1B931ULL, 0xCB7254A0C2CBF5BBULL, 0x401BF0901B35162EULL,
0x18FFFD407614CF9CULL, 0x94653C726EAB0F31ULL, 0x0ULL,
0x38C1D0F8DD6B07E1ULL, 0xB2450F8F755CB0ABULL, 0xB5DCF7BAE20DD3A7ULL, 0x856C39EA40520F6FULL, 0xB1489EF328BE6DF9ULL,
0x1414804C71EAEF03ULL, 0x4F8CF0FC0517DAE7ULL, 0x0ULL,
0xC686F85E90DBA7AULL, 0xF9B75E9C6F440EECULL, 0xD82790D462A73E4DULL, 0xA0A65DE0C1437244ULL, 0x3176E502B54C8C23ULL,
0x337EB1010D1767BCULL, 0x4412A85A4291F747ULL, 0x0ULL,
0x3F6D75937DCBE546ULL, 0x882B4A8BD29CD319ULL, 0xA9597951E6FC3C2FULL, 0xBD45284C57890B69ULL, 0xB2A8729876D12DEDULL,
0xC968E4993DF16965ULL, 0x329D97ABEECA45C2ULL, 0x0ULL,
0x21BDD7358036BDFAULL, 0x8122444C4C3586D8ULL, 0xA1ECF92DF83F263EULL, 0xDB3784B5A353EDD3ULL, 0x11DF87B6AE1E8527ULL,
0xAA8D4EC9CBF971D2ULL, 0xFA219EEF7384889ULL, 0x0ULL,
0x9BB2FF43B2E93D0BULL, 0xAB4E358701955979ULL, 0xBA9C938196346DC0ULL, 0x1C458E6E128C2B25ULL, 0xFD49C004B6064D0FULL,
0x30F57F508B79E801ULL, 0xA89DA728BC9BE260ULL, 0x0ULL,
0x7B1846562C93A9B2ULL, 0x7C4066A9F4489029ULL, 0xC8BADF5C2FDB6540ULL, 0xEC93FAB47F6A46D6ULL, 0x549F55889D8EDEBULL,
0xF0AFD71557A1C534ULL, 0xFCC683C02FE979BEULL, 0x0ULL,
0x1ED2850075391206ULL, 0xFE280A68DF71FE1DULL, 0x66BDD5BA13FE4F93ULL, 0x6B45FB2CBC602ABCULL, 0xCB1C2342BC76CE46ULL,
0xE41D054BDB4BE39EULL, 0x681E0EB2198DBACEULL, 0x0ULL,
0xFC86DA2CF3B3F63CULL, 0x4FF634A5BEC3F1E9ULL, 0x2CB8DB3D8E74B747ULL, 0x7E76B5AFBE7B8DE5ULL, 0xA59778B22BAC1062ULL,
0x70391637537BA83BULL, 0x2C8F126C54DB58E2ULL, 0x0ULL,
0xBF613A6026E49463ULL, 0xE661D2521D56B3ABULL, 0xFF2209AD8C33150AULL, 0x30CE66A8AA028FBFULL, 0xEEF2934FEBD002CDULL,
0x94C6BD6FF15EEF3BULL, 0xDED00DB5EAA670EDULL, 0x0ULL,
0xB26F4032A85CBA92ULL, 0xF5D49C7B85F563EAULL, 0x285D67429D4CD8DCULL, 0x8C375419C1366976ULL, 0x25CBAAEB15DC5037ULL,
0x5573A1079B67D245ULL, 0x44B6578D1DDEDEECULL, 0x0ULL,
0xD57B6FDCC3D5A34FULL, 0xC1A3E718EC72B83ULL, 0x1B4CB1F14AACB8AULL, 0x3BAAA69A5DCE6E68ULL, 0xC980182EF27ADFD7ULL,
0xE8C2CBD56A589D05ULL, 0xA3B1FFC7AE5C0A65ULL, 0x0ULL,
0xEF7BC057421AF8E4ULL, 0x557CA9D5EFA12BE3ULL, 0xDE394AAB5F84CC6FULL, 0xB0410CEA8156914AULL, 0x12D14C08B2BEC666ULL,
0xC2BAECC7AC5CCDBULL, 0x9EDEFC1E61C6DCD7ULL, 0x0ULL,
0x2196CE07C0EBA924ULL, 0xC09468C1A405AC5ULL, 0xB8E6785033B34C68ULL, 0x5B3AD6D332B42C10ULL, 0xDD970FB4932A63ABULL,
0xC84B0EB659188ABFULL, 0x41C998EE6745F95FULL, 0x0ULL,
0xC6162FDEA9551B70ULL, 0x8D4AE70D0F1BB810ULL, 0xB8922DD04B099F39ULL, 0x4A2B6014FAA3B635ULL, 0xAC3D3D055002E52BULL,
0xB95D7F93D6F2119BULL, 0xD031D1ADE3578567ULL, 0x0ULL,
0x801994630590D08DULL, 0x307D1ACEDCEC2C3FULL, 0xBC19908D3ABE5DADULL, 0xBE43E68FCF478679ULL, 0x1628B252D4C1A10AULL,
0x805A3166386812B2ULL, 0x7DB31E432016F387ULL, 0x0ULL,
0x6F17CE38BA18438FULL, 0xBA526979AE46563EULL, 0x1530FF5517862DA0ULL, 0xE89CC032E7548F1AULL, 0xC51ACD6D6C782E1FULL,
0x26EE0527E2B5C680ULL, 0xF792027FC5503D4CULL, 0x0ULL,
0xABD30FA7164F66F5ULL, 0x49A3A5568C80FCD7ULL, 0x3A0D6901810CFB52ULL, 0xA7E6BEE6D99AA12EULL, 0x35CAAA7E75F94ABFULL,
0xD10595E3F9DBF2A3ULL, 0xF3E39D2C7BF4EF3DULL, 0x0ULL,
0x552DD2EF0B71188BULL, 0xE9FA6284066700ADULL, 0x5B826C7E3CDD78EFULL, 0x5E246A63D95B6043ULL, 0x7FA7504E4EDC6CEAULL,
0xAE465248A7683676ULL, 0xE6EB1B9B89B25486ULL, 0x0ULL,
0xB60BE9931D4713A1ULL, 0x150FEBFD205AE8ECULL, 0xD919B0BBD41D1C36ULL, 0x586AD775318AE49FULL, 0x8B240B2AB84709D5ULL,
0xC1EEB096589D0796ULL, 0x520E1AA670DAE4DULL, 0x0ULL,
0x3C602E1A3A469482ULL, 0x1878B8A22851A29ULL, 0x4F0E8AFFEFDC234AULL, 0xAAB0D513ECEDB9DCULL, 0xF4F76A33DE38A11CULL,
0x93ACBD54334C29DAULL, 0x2644DD2F7B0DA69DULL, 0x0ULL,
0xDE5683B51393FEAULL, 0x43F7D892FAC6DA24ULL, 0x766ED49B3363B0B6ULL, 0x3B23AB3B0A01D300ULL, 0x99406C58C0525802ULL,
0x68242379E982D598ULL, 0x9BA2B58C1C05EC59ULL, 0x0ULL,
0x8A6ED5E1FA657772ULL, 0x73DD03C3E08933C7ULL, 0x974BE800136EDA1ULL, 0xEF174C3D07FECFC1ULL, 0x452A2C38CC583BCFULL,
0x62D5A2CC0BD4851BULL, 0x850C26C97BE46D20ULL, 0x0ULL,
0xF0E02154CB926EB9ULL, 0xBFCB292D75398F87ULL, 0xC3506BD9F76E7F48ULL, 0xF5732FF2B1C9C05EULL, 0xF655758AE9B58315ULL,
0x1624AAD665BCB4BAULL, 0xB2B121486C60849BULL, 0x0ULL,
0xE999906E7618AB93ULL, 0xEDBFB6EDF7CD4B10ULL, 0x5AC5BE359C9F126FULL, 0x4E3D3E5ACAF6E54ULL, 0xE1127C3B6086778DULL,
0xB148CBDF07DE1A6FULL, 0xC033A4D0DCE37B6CULL, 0x0ULL,
0x941F65D2B0F813B9ULL, 0xC2BE20DAD2DFAC74ULL, 0x3F66E5A23788921EULL, 0x324723624C9F8A9BULL, 0xBF93C37A1EDAC2FFULL,
0xD59A1F342F4B5F7EULL, 0x22BCBBBF06F772A0ULL, 0x0ULL,
0x8D83CBE161480F69ULL, 0xB9C974F7D2749EULL, 0xFDD180BC5FB2E927ULL, 0x2FE5C5358ACD19A5ULL, 0x9E58CF461641489CULL,
0x43DC9AB067C5CD0ULL, 0xC02E44E41819C9CCULL, 0x0ULL,
0x407F0B4E54916ED5ULL, 0x21573324E1881EA1ULL, 0x3051814A3352AULL, 0x37F5986E7DF3C358ULL, 0xBF09924B39A9D547ULL,
0xBA83FB4DB6A5EA76ULL, 0x4BAF3564453E2EE0ULL, 0x0ULL,
0x1DFCCB1FA2D134AAULL, 0x2E69E815F0B09DA4ULL, 0x8C9455FB456CB165ULL, 0xA786BDF1DA03367AULL, 0x26B13C05314796DBULL,
0xB52EED28BA23D751ULL, 0x44A37B67610BDA9EULL, 0x0ULL,
0x25634B400F298C10ULL, 0xE9B734FE37D257B7ULL, 0xD2756C991C707A44ULL, 0xF3207E02A50E7F3FULL, 0xD3AE72C35816D02CULL,
0x88B02DDAC76CE15FULL, 0x27030E67C2274AE5ULL, 0x0ULL,
0x5404BBD5E6D9EC96ULL, 0xEB0A93CF46C19324ULL, 0xC89EE91838770089ULL, 0x4C1CCDAC2AA0A2ECULL, 0xC48630F5F74D9C52ULL,
0x66DBAF628C2C051AULL, 0xFC62A00F9EAAC608ULL, 0x0ULL,
0x42841EB3191E1B7FULL, 0x25C7CB4088FF3218ULL, 0x6AA0FB50EF934522ULL, 0xFCC38C652A3C8CC1ULL, 0x243615C6772F7642ULL,
0x51C81406AED29D33ULL, 0xE2B7E436B42E2398ULL, 0x0ULL,
0xD09A624476356E89ULL, 0x3F5C167D8CED7D28ULL, 0xEF84F4C7BA5DD150ULL, 0x3F61A2EFCA0F7508ULL, 0xA866EE0A21179972ULL,
0xC34725CED9E0D6C6ULL, 0xCB9226030680C5C1ULL, 0x0ULL,
0x128CCE83AF163A81ULL, 0x145B76C66451AE6ULL, 0xD4366E6576999920ULL, 0xD5084851F25938A9ULL, 0xE310530EE23608EEULL,
0x955B5335FB876DB1ULL, 0x195696C7EAF9C5EULL, 0x0ULL,
0xF2AB7CC011A7FE8AULL, 0xEC4876537CC6DB52ULL, 0xD4573FF5A619CB64ULL, 0x2AFF63CA36E0D7C4ULL, 0x405030CD77CE12B1ULL,
0x8E4C3F133FB2654CULL, 0xA72B4F22ED21E9A1ULL, 0x0ULL,
0x59007EC82FF384DEULL, 0x62096A9D98CC338FULL, 0xFF503837E95DC7B4ULL, 0xCC1D2323BAAFF1C4ULL, 0xC9A9BAFF940D0388ULL,
0x5A4988B6FA78FCD8ULL, 0xA63B3C5B6949EDA6ULL, 0x0ULL,
0x505C2591D63A4CADULL, 0xED8E1A9E420D4546ULL, 0x2CDF09FDA9AB8FF2ULL, 0x771271334AAFD373ULL, 0xC65ED6CA15678708ULL,
0xA04D12E95157A7C6ULL, 0x54EB794EF03071F4ULL, 0x0ULL,
0xD7993E5C224FB0FDULL, 0x7D7C9ABEA3DB483CULL, 0x47EF58C71F3781A6ULL, 0x20C33E06D928931EULL, 0xEACBE93918DC59BEULL,
0x852EBCDB89E27ACCULL, 0x3C599B8EF5B86A30ULL, 0x0ULL,
0xAAF30D6ECBBE5716ULL, 0x849D1B998101A88ULL, 0xA0C0EB5EDB7CF8B6ULL, 0xC31A9199D021F1E8ULL, 0x877B8E3B7C341683ULL,
0xFBE0D10CD1C4C9B6ULL, 0x9A6BCC0EA3A3CD74ULL, 0x0ULL,
0xFBF51A2CC05BE66FULL, 0x3B0ECF798F949A3AULL, 0x985E4A2CDAECE5BFULL, 0xC3D3143B121A359EULL, 0x7D8442BB1228865BULL,
0xF1D7A1395B74127FULL, 0x8A592DF06A4F4CC9ULL, 0x0ULL,
0xF7E25AAD919D7DE2ULL, 0x878FFFECFBE83D9BULL, 0xED03DF2BAC581355ULL, 0x985CB22AE02BCB73ULL, 0x94E96B02796B02CBULL,
0x937772CB847BE5FCULL, 0xE6D0D32D6C0B40F8ULL, 0x0ULL,
0xAE39B13EAD1FF286ULL, 0xE291C9D67BDB7AA4ULL, 0xF8F05ABBA5D6E1D1ULL, 0xF70D07B25FB72A62ULL, 0xB0D832789CAF267FULL,
0x658E8FB065195A64ULL, 0x9081AD28C08E79E4ULL, 0x0ULL,
0x416BDAD97825C407ULL, 0xAF5830916066D655ULL, 0x72DAF9A1D3B89359ULL, 0x7424773BB8068FA8ULL, 0x35268A9EF4661479ULL,
0x4541BFF2F3542FBBULL, 0xE34519DE04431A08ULL, 0x0ULL,
0xEE73238C929B22F3ULL, 0x1560D2BF32083FBULL, 0xAD0F58364DFE8440ULL, 0x9BBEDD8C50F2A9B0ULL, 0xC10808AD0DAB63C1ULL,
0x68684BC2EE4F7A9FULL, 0x1E915DD0A29EF913ULL, 0x0ULL,
0x5203459201380D8EULL, 0x4A55D671A2DC83B9ULL, 0xCD7B2F0C14614119ULL, 0xE5B3FECDCAFF1862ULL, 0xDF7637DDF79DE2D4ULL,
0x1761A64EBC481026ULL, 0x116C02B545BE80BBULL, 0x0ULL,
0xA4E9B2E7C6EAE8AEULL, 0x432DEE2BC2495EBBULL, 0xC8DD5E79708ED3AFULL, 0x9B9C6A7980C222F8ULL, 0xDAB34B2918DFDE27ULL,
0xE24940BDC16F8027ULL, 0xA7DCFDCA45AF4B8AULL, 0x0ULL,
0xCE090A4F73F8250EULL, 0xB87A3A3F785C3080ULL, 0xA45AF6641FBBE677ULL, 0x5AD79A067B15EB8DULL, 0x52BC34DAD6CF1447ULL,
0x220A9A905EEC1EFAULL, 0xF863FCDB224B4C69ULL, 0x0ULL,
0x933C97BC3DBCC416ULL, 0xCAE032D2800FE63FULL, 0x4D3DB0165CC3C81CULL, 0x263C8C0CA95B5725ULL, 0xC3FAFFF4281C8114ULL,
0x33332376C8F17D70ULL, 0x68B26B393E3B7AE0ULL, 0x0ULL,
0x8B4FC8AEAAEB38C1ULL, 0xCF04CCB5B90F1564ULL, 0xF744A66A0832372FULL, 0x4AA7B300CB99590BULL, 0xB372E5A59F4402F8ULL,
0x4505470BFA395B49ULL, 0xDA231BDD89C48A26ULL, 0x0ULL,
0xA29FED336C341B76ULL, 0x918BE184B8D8B11CULL, 0x638ADC47EFB28BB7ULL, 0x7DB2FB780356B8C1ULL, 0x90840177DC3FA5A8ULL,
0x2A2B0435EE515590ULL, 0x78FE68DECDE9BDE9ULL, 0x0ULL,
0x2B4A0F19E2CB67EBULL, 0xD39092171C782DF1ULL, 0x2D6C072D776C296FULL, 0xBC94164AD5F820B4ULL, 0x1E42C5D86ED1C97BULL,
0x71299EBA08BB05DAULL, 0x11AD3903F6131C85ULL, 0x0ULL,
0x35E6903DA9C298BCULL, 0x50F09F7ECE2793B0ULL, 0x65DE550718EC6229ULL, 0x592ADB453DF2B948ULL, 0xC7184779C2A8CCE3ULL,
0x60DA2417A8910228ULL, 0xF7FB7EE32A9892CBULL, 0x0ULL,
0xEE0D12667E12C992ULL, 0x7159978F0C02FA40ULL, 0x3069C5E5FE105277ULL, 0xBBFBF9B86665CA14ULL, 0xA1A42322D17DEA8ULL,
0xF56C1601C83640E3ULL, 0xAD40475BE5AFD824ULL, 0x0ULL,
0x9864DE22DFFF5A5DULL, 0x7C6DF6F7F7F9DABFULL, 0xB7D1A7AB86EB45E0ULL, 0x2CF4581A5406F0D9ULL, 0x5B3F7A10AA946D33ULL,
0xA8A34AF873708D97ULL, 0xA2B823A16EE421DFULL, 0x0ULL,
0x6D4ACF5DC7B3142BULL, 0x5C46983167346F7EULL, 0x897B6AB7F50ACF7CULL, 0x1E02ADF3EFD5CFC0ULL, 0xF959E7A749EC21F8ULL,
0xC76C4BEA5C56D1FBULL, 0xDE08CB42060F79F4ULL, 0x0ULL,
0xCE9B1D1F0CDCB823ULL, 0xE0E1E532F763B122ULL, 0x5E0CB2C1D6CB49C7ULL, 0xD5942EDFF91FA1A2ULL, 0x7F8067FBE8A82EF4ULL,
0xDB3A3B7078B33621ULL, 0x6384234AC3395580ULL, 0x0ULL,
0x220A4282AEA54B08ULL, 0x4B84C8CB03A34E67ULL, 0x59008A90CB4EA6A1ULL, 0x7F5F1467347D609AULL, 0xBBA815F66112C223ULL,
0x7B00F19B794D7B3BULL, 0x67EB903ED99E99A4ULL, 0x0ULL,
0x1DD89CE391BE0CBFULL, 0xC88219AFE051B5BBULL, 0xB8D8D25E511135FEULL, 0xAAC3AA10D4F47B6BULL, 0x899C7597BEC7064DULL,
0xD9610929BDA549C3ULL, 0xB334B21A112FE1CDULL, 0x0ULL,
0xC1AAA08C61E333A6ULL, 0x58A7A5D2BEF10AF0ULL, 0x1191D708AED81561ULL, 0xD64F422210D4A593ULL, 0xDB0124AFECA501DFULL,
0xDD08C64409EF9B21ULL, 0xE7C0FC0212AA93DDULL, 0x0ULL,
0xF08D7C259BD00197ULL, 0xDA89B3D653E224DULL, 0x8F5A80E154CE3D99ULL, 0x855E40B5BAC840CCULL, 0x579C9EE613A4644BULL,
0x9CF2C01757FAD03CULL, 0x1F76F2CACA117A14ULL, 0x0ULL,
0xEA51B109ED7B019BULL, 0x7EA0E906D2F76138ULL, 0xFE8D1436F0D5C9D1ULL, 0xEAC37B7EA54B0C2ULL, 0x2F37A19C631B518DULL,
0x6F24F05AEA55A61ULL, 0xE6C151D53D937B86ULL, 0x0ULL,
0x39E5BFF03F1CE70ULL, 0x53B6AEF82B58EDA3ULL, 0xB6EF504A5F4D62E4ULL, 0x748801A36ED6A524ULL, 0x908668671E709B0CULL,
0xD665080620751B59ULL, 0x9132AA76E5CEA7A0ULL, 0x0ULL,
0x2D1F8AC32863BF2CULL, 0xE4E95B75FE83B8FFULL, 0x5AAB69C2388009BFULL, 0x6F51589FE152D149ULL, 0xD301B678A0A1FE2AULL,
0xB12EBB07444CD706ULL, 0x280F60998A5A320AULL, 0x0ULL,
0x3E71CA2FF41D1FDCULL, 0xD069F37873912EBULL, 0xC74B5A79EF29D27FULL, 0x822B70AA756E9902ULL, 0x3651B8F48257F709ULL,
0x627CC6F2C6D08D64ULL, 0xD027432666E3FE4AULL, 0x0ULL,
0x203D8DA23C936D9EULL, 0x9EE1AF2251E9921EULL, 0x96AFF6C952E748F0ULL, 0xE200E7445F336BEFULL, 0x5F38855BDF9FA830ULL,
0x817812B5422D3725ULL, 0xF96BF77B49A9BEC8ULL, 0x0ULL,
0x710B037B31855B7AULL, 0x95EAA0FCDF3C66D6ULL, 0x4790562C54053A5FULL, 0x105249578DDC1B40ULL, 0x929BB6602E948FBDULL,
0xC0248AE5EC09985CULL, 0x5C4D476BCA096C9ULL, 0x0ULL,
0x2DE44101E6E4CDD5ULL, 0x5F52F31F3AC2FC50ULL, 0x72E1F7E038F7A464ULL, 0x2976261C84595219ULL, 0x41C2A3BE209240E9ULL,
0xE19394E54556E5CBULL, 0xD43674BBAE010F28ULL, 0x0ULL,
0x77C9130054B79CBDULL, 0xAF2022FE26D70D77ULL, 0x17286A21769FCF3CULL, 0x4663A66661BCD12EULL, 0xCC5AC1F854636ADEULL,
0x8E48227BF0FADA46ULL, 0x32FE6D53BADBC6D8ULL, 0x0ULL,
0x4A61028E3EDE1A7CULL, 0x7E1720DF481F83EDULL, 0x1B82C40EB2D5FBE0ULL, 0x27BB782CDD8ABE6EULL, 0x6114BF08BD75D5FCULL,
0x3AB9A58416A55A58ULL, 0x38475CA9A785894FULL, 0x0ULL,
0x4C917762333B1A2AULL, 0x71ACDE8DFE07EAE0ULL, 0xB4BEBB156DF30F22ULL, 0x7B21279F6BA669FBULL, 0x27D8CFB81CD2B96EULL,
0x34D84655B6E2B2CULL, 0x4BEB6DF9BD85F121ULL, 0x0ULL,
0x29E2B015A58AE5C1ULL, 0x7ED27C1E8C5BFE90ULL, 0x4D082C358ABF766FULL, 0x94381E9796F89788ULL, 0xEA8C090148D62B1EULL,
0x53E15DCA9C2E1E99ULL, 0x2716B08CA7C20391ULL, 0x0ULL,
0xD798F74F4A6E115BULL, 0xB7D190EB1AF75557ULL, 0xCB4194124E60D9FAULL, 0x44589BDAAAB2C2CCULL, 0x5E2D9FD8D96299EDULL,
0x242D3E853F93E610ULL, 0x77E009C8FB3CD169ULL, 0x0ULL,
0xC178F6B536B4BF88ULL, 0xCE3D456EB64AC23ULL, 0x47F703CD997D4665ULL, 0xFC6D3020A28AE6FEULL, 0x532BA0351B375BF9ULL,
0x6E0537E5A9327B83ULL, 0x4AEB35C5FE712554ULL, 0x0ULL,
0x4729BBD8A5E400D0ULL, 0x719236453D20C9C6ULL, 0x29359B66CAA17218ULL, 0xAE0D9E1357D158B4ULL, 0x9EEF7122EBF15A19ULL,
0xE8C37230F82B584DULL, 0x857E1F8EC0C66578ULL, 0x0ULL,
0x53C932D39525A9D0ULL, 0xEDD532AF1259AC94ULL, 0xD11A33251E04D6D8ULL, 0x65746A0CC7AD6FA1ULL, 0xC983D9C69AA12318ULL,
0xE5A7DFEDA0F46626ULL, 0x4BFD7FDEF57DE342ULL, 0x0ULL,
0x2ED97DA4D19B4897ULL, 0x7E6519445CCBE004ULL, 0xC2EE54903B7F94E2ULL, 0x9C1DD4E9DDAFC22EULL, 0xB041D3F56D67EB9DULL,
0x8EA1C0AA09D7B751ULL, 0x7368702B8840CE10ULL, 0x0ULL,
0xE875FAC372B3884ULL, 0x719F3BF838960EA1ULL, 0xA9C8A700761DD8F7ULL, 0x697345012D79C1A8ULL, 0x3E24333DFE28DE29ULL,
0x6F875F64855B6E83ULL, 0x41A8C98CE1309EF5ULL, 0x0ULL,
0x14390215D8390FBDULL, 0xF4BA36B46322E626ULL, 0xD67C1FE0311412B5ULL, 0xB3839A4416AF6DCFULL, 0xC4D26CE246110B34ULL,
0x7A71A98673C727CBULL, 0x9FD5AF3FA61BC80BULL, 0x0ULL,
0xC7D4011FD798E8C5ULL, 0xBC68740D48A54F4AULL, 0x720D74CB05ED34FDULL, 0xA967CEE68AE3B40AULL, 0x6AE59C67926382B1ULL,
0xFB4EF0D27E4257A5ULL, 0xF7C9D4D56572D33DULL, 0x0ULL,
0xBE892A54A3B39152ULL, 0x2D9B3C7524089FEULL, 0x575BE73A793B9F2BULL, 0x47732A24C1F557B4ULL, 0x2D2AFE3AD0D084AAULL,
0x67491614A72D52D7ULL, 0xFE5CB3F35536B062ULL, 0x0ULL,
0x1C1095A34AE805D4ULL, 0x3A4BDB72BED20454ULL, 0xC2BD01154D15FEB4ULL, 0xC055E00899BF33CCULL, 0xC49F70B68D3818F4ULL,
0xA9B3A3A371CEE250ULL, 0x8C1E22B6A24EA8D5ULL, 0x0ULL,
0x91F70E0E9BC624EBULL, 0x3A4FF5F15AE294AULL, 0xE5F0844AB27676DCULL, 0x2BBC7650EF28F1F9ULL, 0x7DCF5893E5AC773CULL,
0x7282779DF9092F7CULL, 0xFCA57B42988DE5DCULL, 0x0ULL,
0xDDA78C62999CA913ULL, 0x2AD3151A99B49079ULL, 0xBF1245D07B88A8CAULL, 0x25E22F4DBEE1904FULL, 0x167EDA055DE5F26FULL,
0x692B5253F7E0C8A9ULL, 0xF73E5D65460B203EULL, 0x0ULL,
0x6D6E88623B91FD1ULL, 0x3FF7BE1C1ECC6289ULL, 0x7251CD8AFB4B524AULL, 0x3E63E8A2B5C382B1ULL, 0xC1CABD9F3DD69913ULL,
0xB4339C7B9A1D733DULL, 0xAC3218D15DD1FA71ULL, 0x0ULL,
0x2A08EA1C160672DFULL, 0xDB503EE78B528027ULL, 0xF1278D38C874ECFEULL, 0x32A72CD83C68E749ULL, 0xF4366104C8BB17B1ULL,
0xCB5FA5D658F9DD32ULL, 0x7D0C494E3FF2C4D2ULL, 0x0ULL,
0x552409E8CA058F39ULL, 0x95AEA6628D79051DULL, 0xB19292BB5061EFE1ULL, 0x67CFB2BF26100964ULL, 0x71819247EA0FFD4BULL,
0xB7761EFB7331F458ULL, 0x7722EBD5B50E8B80ULL, 0x0ULL,
0x9E6FCEF6DAEFCF2BULL, 0x36428A2D378787E7ULL, 0xED3E575C107AB5FAULL, 0xFE758FA06776D795ULL, 0x5DD99B3A95A9550BULL,
0xD82B0B718C66A971ULL, 0xB2496C294F62736EULL, 0x0ULL,
0x80D07D9165B86DBFULL, 0x559E0E018926C3F1ULL, 0x5C59EC4B00A41EE2ULL, 0x29E4619E2494E278ULL, 0x2313F79D58E2DC9DULL,
0xA3EC8C6590216FEAULL, 0x2735514B6FF59898ULL, 0x0ULL,
0x8A31FCC3E02C788FULL, 0xF0725E9FAD271342ULL, 0xDE68179D5BC500D7ULL, 0xA7F7CA63B95DA539ULL, 0xFC75A4C250AC7C56ULL,
0xB5A63777081FE2F9ULL, 0x636EB0E82D9CE433ULL, 0x0ULL,
0xCF9969DA30E3B7EDULL, 0x8B638D27C68867FDULL, 0xF4F5C533725DC3AAULL, 0xF09BF836D35E53DFULL, 0x8482F71F0EEBD45AULL,
0xC1B9587D7B8C35B3ULL, 0x37B1864B27D84BB9ULL, 0x0ULL,
0x93D9B13702E03791ULL, 0x2E7F2D4453E84EE0ULL, 0x2193D2F5E17C9211ULL, 0x23D4D263BBF29D83ULL, 0x67E8E97372816B2CULL,
0x6DF0C75E8C1C6ABCULL, 0x677DC9539C4013C3ULL, 0x0ULL,
0xE412E3F0CBE5A5EBULL, 0x21A087C4E5F172F8ULL, 0xC91FC7E0B8EC3340ULL, 0xA880B624731094BFULL, 0xB0FED6283FA10E80ULL,
0x178E7860EED1770CULL, 0x1E5E0E5526DDC565ULL, 0x0ULL,
0xB442B3EED3616255ULL, 0x92B21262CBE33115ULL, 0xD116259D4B83278EULL, 0x2FA7DDCC90FB5ACEULL, 0x799ED9A5D2856162ULL,
0xEC8EDFB159E2AF25ULL, 0xED2CE258483BCF67ULL, 0x0ULL,
0x227D286FB3921FF3ULL, 0x49ED6BAC4EA4C16ULL, 0xDE4A31F20BA8CA21ULL, 0x25F1643E3CF83153ULL, 0x3B89AE01DA84AEEFULL,
0xBB58A0B7DFCC72E9ULL, 0xC051BA97093565A7ULL, 0x0ULL,
0xF09F381B874B6094ULL, 0x6DCA9001D5BDC704ULL, 0x56B573980DD3B4C5ULL, 0x277AD6F15A540530ULL, 0x37E104F2209A2D95ULL,
0xFE6B207889749EFEULL, 0x80C779F984D03396ULL, 0x0ULL,
0x117AED2A8E9BD04DULL, 0x6B033F819205E7EAULL, 0x8D5FC27ED54254D7ULL, 0x25FDAEA98AC14EE7ULL, 0x3C29E116AC56B192ULL,
0x713E9C6A13E7C410ULL, 0x8B8C4B9B30D4319EULL, 0x0ULL,
0x42201925C204BDACULL, 0x3A449BDA54AB7B27ULL, 0x926406655B84D336ULL, 0x8CB2085322F893CCULL, 0xDF2282345B8EC567ULL,
0xC8DBF7AF7845B41CULL, 0x7F19733143F4BFC2ULL
};
| 86.259156 | 134 | 0.878705 |
65b296154ee49c387087f64c7650c1eb7b4e2c2e | 3,111 | h | C | android/art/tools/veridex/resolver.h | Solotov/deoptfuscator | 8a54119e81517bcef73d2d6dfefba910ae2446e7 | [
"MIT"
] | 206 | 2020-04-13T03:19:33.000Z | 2022-03-27T13:52:25.000Z | android/art/tools/veridex/resolver.h | Solotov/deoptfuscator | 8a54119e81517bcef73d2d6dfefba910ae2446e7 | [
"MIT"
] | 9 | 2020-06-07T12:51:09.000Z | 2022-03-28T23:55:09.000Z | android/art/tools/veridex/resolver.h | Solotov/deoptfuscator | 8a54119e81517bcef73d2d6dfefba910ae2446e7 | [
"MIT"
] | 42 | 2020-04-13T03:37:58.000Z | 2022-03-23T15:08:12.000Z | /*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_TOOLS_VERIDEX_RESOLVER_H_
#define ART_TOOLS_VERIDEX_RESOLVER_H_
#include "dex/dex_file.h"
#include "veridex.h"
namespace art {
class HiddenApi;
class VeridexResolver;
/**
* Map from the start of a dex file (ie DexFile::Begin()), to
* its corresponding resolver.
*/
using DexResolverMap = std::map<uintptr_t, VeridexResolver*>;
class VeridexResolver {
public:
VeridexResolver(const DexFile& dex_file,
const DexResolverMap& dex_resolvers,
TypeMap& type_map)
: dex_file_(dex_file),
type_map_(type_map),
dex_resolvers_(dex_resolvers),
type_infos_(dex_file.NumTypeIds(), VeriClass()),
method_infos_(dex_file.NumMethodIds(), nullptr),
field_infos_(dex_file.NumFieldIds(), nullptr) {}
// Run on the defined classes of that dex file and populate our
// local type cache.
void Run();
// Return the class declared at `index`.
VeriClass* GetVeriClass(dex::TypeIndex index);
// Return the method declared at `method_index`.
VeriMethod GetMethod(uint32_t method_index);
// Return the field declared at `field_index`.
VeriField GetField(uint32_t field_index);
// Do a JLS lookup in `kls` to find a method.
VeriMethod LookupMethodIn(const VeriClass& kls,
const char* method_name,
const Signature& method_signature);
// Do a JLS lookup in `kls` to find a field.
VeriField LookupFieldIn(const VeriClass& kls,
const char* field_name,
const char* field_type);
// Lookup a method declared in `kls`.
VeriMethod LookupDeclaredMethodIn(const VeriClass& kls,
const char* method_name,
const char* signature) const;
// Resolve all type_id/method_id/field_id.
void ResolveAll();
// The dex file this resolver is associated to.
const DexFile& GetDexFile() const {
return dex_file_;
}
const DexFile& GetDexFileOf(const VeriClass& kls) {
return GetResolverOf(kls)->dex_file_;
}
private:
// Return the resolver where `kls` is from.
VeridexResolver* GetResolverOf(const VeriClass& kls) const;
const DexFile& dex_file_;
TypeMap& type_map_;
const DexResolverMap& dex_resolvers_;
std::vector<VeriClass> type_infos_;
std::vector<VeriMethod> method_infos_;
std::vector<VeriField> field_infos_;
};
} // namespace art
#endif // ART_TOOLS_VERIDEX_RESOLVER_H_
| 30.80198 | 75 | 0.684024 |
04f7eec99da83006386f709b62c42d9fa8129ff2 | 221 | c | C | cap-6/exercicio-01.c | ppfon/uC | fab74ca93a2de4560abe7aee3daa7a19b8970175 | [
"MIT"
] | null | null | null | cap-6/exercicio-01.c | ppfon/uC | fab74ca93a2de4560abe7aee3daa7a19b8970175 | [
"MIT"
] | null | null | null | cap-6/exercicio-01.c | ppfon/uC | fab74ca93a2de4560abe7aee3daa7a19b8970175 | [
"MIT"
] | null | null | null | /* |6.1|
* Seja w um vetor contendo 9 elementos inteiros. Supondo que i seja uma variável
* inteira armazenando o valor 5, quais valores estarão armazenados em w depois
* das seguintes atribuições?
*
* R:
*
| 27.625 | 81 | 0.696833 |
aa3112e7d737081aa4840966f37a74e99d0709d0 | 2,941 | c | C | stage23/lib/libc.s2.c | Killaship/limine | 294382e3bf39cbb3470318243a3141b904d667d3 | [
"BSD-2-Clause"
] | 658 | 2020-08-30T15:44:33.000Z | 2022-03-31T12:17:51.000Z | stage23/lib/libc.s2.c | Killaship/limine | 294382e3bf39cbb3470318243a3141b904d667d3 | [
"BSD-2-Clause"
] | 82 | 2020-09-06T01:33:52.000Z | 2022-03-21T01:30:59.000Z | stage23/lib/libc.s2.c | Killaship/limine | 294382e3bf39cbb3470318243a3141b904d667d3 | [
"BSD-2-Clause"
] | 109 | 2020-08-30T20:07:08.000Z | 2022-03-21T00:29:23.000Z | #include <stddef.h>
#include <stdint.h>
#include <lib/libc.h>
#include <stdbool.h>
#include <lib/blib.h>
int toupper(int c) {
if (c >= 'a' && c <= 'z') {
return c - 0x20;
}
return c;
}
int tolower(int c) {
if (c >= 'A' && c <= 'Z') {
return c + 0x20;
}
return c;
}
void *memcpy(void *dest, const void *src, size_t n) {
uint8_t *pdest = dest;
const uint8_t *psrc = src;
for (size_t i = 0; i < n; i++) {
pdest[i] = psrc[i];
}
return dest;
}
void *memset(void *s, int c, size_t n) {
uint8_t *p = s;
for (size_t i = 0; i < n; i++) {
p[i] = (uint8_t)c;
}
return s;
}
void *memmove(void *dest, const void *src, size_t n) {
uint8_t *pdest = dest;
const uint8_t *psrc = src;
if (src > dest) {
for (size_t i = 0; i < n; i++) {
pdest[i] = psrc[i];
}
} else if (src < dest) {
for (size_t i = n; i > 0; i--) {
pdest[i-1] = psrc[i-1];
}
}
return dest;
}
int memcmp(const void *s1, const void *s2, size_t n) {
const uint8_t *p1 = s1;
const uint8_t *p2 = s2;
for (size_t i = 0; i < n; i++) {
if (p1[i] != p2[i])
return p1[i] < p2[i] ? -1 : 1;
}
return 0;
}
char *strcpy(char *dest, const char *src) {
size_t i;
for (i = 0; src[i]; i++)
dest[i] = src[i];
dest[i] = 0;
return dest;
}
char *strncpy(char *dest, const char *src, size_t n) {
size_t i;
for (i = 0; i < n && src[i]; i++)
dest[i] = src[i];
for ( ; i < n; i++)
dest[i] = 0;
return dest;
}
int strcmp(const char *s1, const char *s2) {
for (size_t i = 0; ; i++) {
char c1 = s1[i], c2 = s2[i];
if (c1 != c2)
return c1 < c2 ? -1 : 1;
if (!c1)
return 0;
}
}
int strcasecmp(const char *s1, const char *s2) {
for (size_t i = 0; ; i++) {
char c1 = s1[i], c2 = s2[i];
if (tolower(c1) != tolower(c2))
return c1 < c2 ? -1 : 1;
if (!c1)
return 0;
}
}
int strncmp(const char *s1, const char *s2, size_t n) {
for (size_t i = 0; i < n; i++) {
char c1 = s1[i], c2 = s2[i];
if (c1 != c2)
return c1 < c2 ? -1 : 1;
if (!c1)
return 0;
}
return 0;
}
size_t strlen(const char *str) {
size_t len;
for (len = 0; str[len]; len++);
return len;
}
int inet_pton(const char *src, void *dst) {
uint8_t array[4];
const char *current = src;
for (int i = 0; i < 4; i++) {
const char *newcur;
uint64_t value = strtoui(current, &newcur, 10);
if (current == newcur)
return -1;
current = newcur;
if (*current == 0 && i < 3)
return -1;
if (value > 255)
return -1;
current++;
array[i] = value;
}
memcpy(dst, array, 4);
return 0;
}
| 19.222222 | 55 | 0.454947 |
aa8ff04d3921ee11119c664a5d6446c5758e43d8 | 770 | h | C | ext/stub/interfaces/implementint.zep.h | nawawi/zephir | cc7ecd35745594710913edab1afe5c6d82f52932 | [
"MIT"
] | 2,508 | 2015-01-02T09:48:45.000Z | 2021-02-13T14:58:39.000Z | ext/stub/interfaces/implementint.zep.h | nawawi/zephir | cc7ecd35745594710913edab1afe5c6d82f52932 | [
"MIT"
] | 1,321 | 2015-01-03T09:31:20.000Z | 2021-02-16T06:39:07.000Z | ext/stub/interfaces/implementint.zep.h | nawawi/zephir | cc7ecd35745594710913edab1afe5c6d82f52932 | [
"MIT"
] | 507 | 2015-01-02T09:51:11.000Z | 2021-02-15T08:13:53.000Z |
extern zend_class_entry *stub_interfaces_implementint_ce;
ZEPHIR_INIT_CLASS(Stub_Interfaces_ImplementInt);
PHP_METHOD(Stub_Interfaces_ImplementInt, set);
PHP_METHOD(Stub_Interfaces_ImplementInt, get);
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_implementint_set, 0, 1, IS_VOID, 0)
ZEND_ARG_TYPE_INFO(0, val, IS_LONG, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_implementint_get, 0, 0, IS_LONG, 0)
ZEND_END_ARG_INFO()
ZEPHIR_INIT_FUNCS(stub_interfaces_implementint_method_entry) {
PHP_ME(Stub_Interfaces_ImplementInt, set, arginfo_stub_interfaces_implementint_set, ZEND_ACC_PUBLIC)
PHP_ME(Stub_Interfaces_ImplementInt, get, arginfo_stub_interfaces_implementint_get, ZEND_ACC_PUBLIC)
PHP_FE_END
};
| 35 | 101 | 0.875325 |
107dca3f9259f6c86837ed50283a6d3babef56db | 7,193 | c | C | devicemodel/vmcfg/apl-mrb/vm1/vm1.c | JiangMaox/acrn-hypervisor | 536bc5bd1262290c5c85929c350e5fa69c02fbe1 | [
"BSD-3-Clause"
] | 1 | 2019-03-25T02:54:23.000Z | 2019-03-25T02:54:23.000Z | devicemodel/vmcfg/apl-mrb/vm1/vm1.c | JiangMaox/acrn-hypervisor | 536bc5bd1262290c5c85929c350e5fa69c02fbe1 | [
"BSD-3-Clause"
] | 2 | 2018-11-14T09:21:15.000Z | 2018-11-23T01:42:03.000Z | devicemodel/vmcfg/apl-mrb/vm1/vm1.c | JiangMaox/acrn-hypervisor | 536bc5bd1262290c5c85929c350e5fa69c02fbe1 | [
"BSD-3-Clause"
] | 1 | 2021-07-01T11:49:30.000Z | 2021-07-01T11:49:30.000Z | /*
* Copyright (C)2018 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <vmcfg_config.h>
#include <vmcfg.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#define TOSTR(X) #X
#define STR(X) TOSTR(X)
#ifdef CONFIG_MRB_VM1
static char cmdline_fmt[] = "maxcpus=" STR(CONFIG_MRB_VM1_CPU) " "
"nohpet tsc=reliable intel_iommu=off "
"androidboot.serialno=%s%s "
"i915.enable_rc6=1 "
"i915.enable_fbc=1 "
"i915.enable_guc_loading=0 "
"i915.avail_planes_per_pipe=0x070F00 "
"i915.enable_hangcheck=0 "
"use_nuclear_flip=1 "
"i915.enable_guc_submission=0 "
"i915.enable_guc=0 ";
static char kernel_cmdline[sizeof(cmdline_fmt) + 256];
static char *mrb_vm1_options[] = {
NULL, /*Reserved for program name*/
#ifdef CONFIG_MRB_VM1_UUID
"-U", CONFIG_MRB_VM1_UUID_VAL,
#endif /*CONFIG_MRB_VM1_UUID*/
#ifdef CONFIG_MRB_VM1_ACPI
"-A",
#endif /*CONFIG_MRB_VM1_ACPI*/
#ifdef CONFIG_MRB_VM1_MEM
"-m", STR(CONFIG_MRB_VM1_MEM) "M",
#endif /*CONFIG_MRB_VM1_MEN*/
#ifdef CONFIG_MRB_VM1_CPU
"-c", STR(CONFIG_MRB_VM1_CPU),
#endif /*CONFIG_MRB_VM1_CPU*/
#ifdef CONFIG_MRB_VM1_GVT
"-s", CONFIG_MRB_VM1_GVT_DEV,
"-G", CONFIG_MRB_VM1_GVT_ARG,
#endif /*CONFIG_MRB_VM1_GVT*/
#ifdef CONFIG_MRB_VM1_HOSTBRIDGE
"-s", CONFIG_MRB_VM1_HOSTBRIDGE_OPT,
#ifdef CONFIG_MRB_VM1_USB_XHCI
"-s", CONFIG_MRB_VM1_USB_XHCI_OPT,
#endif /*CONFIG_MRB_VM1_USB_XHCI*/
#ifdef CONFIG_MRB_VM1_PTDEV_USB
"-s", CONFIG_MRB_VM1_PTDEV_USB_OPT_1,
#endif /*CONFIG_MRB_VM1_PTDEV_USB*/
#ifdef CONFIG_MRB_VM1_VIRTIO_RPMB
"-s", CONFIG_MRB_VM1_VIRTIO_RPMB_OPT,
#endif /*CONFIG_MRB_VM1_VIRTIO_RPMB*/
#ifdef CONFIG_MRB_VM1_VIRTIO_HYPER_DMABUF
"-s", CONFIG_MRB_VM1_VIRTIO_HYPER_DMABUF_OPT,
#endif /*CONFIG_MRB_VM1_VIRTIO_HYPER_DMABUF*/
#ifdef CONFIG_MRB_VM1_WDT_I6300ESB
"-s", CONFIG_MRB_VM1_WDT_I6300ESB_OPT,
#endif /*CONFIG_MRB_VM1_WDT_I6300ESB*/
#ifdef CONFIG_MRB_VM1_VIRTIO_BLK
"-s", CONFIG_MRB_VM1_VIRTIO_BLK_OPT,
#endif /*CONFIG_MRB_VM1_VIRTIO_BLK*/
#ifdef CONFIG_MRB_VM1_VIRTIO_NET
"-s", CONFIG_MRB_VM1_VIRTIO_NET_OPT,
#endif /*CONFIG_MRB_VM1_VIRTIO_NET*/
#ifdef CONFIG_MRB_VM1_PTDEV_AUDIO
"-s", CONFIG_MRB_VM1_PTDEV_AUDIO_OPT,
#endif /*CONFIG_MRB_VM1_PTDEV_AUDIO*/
#ifdef CONFIG_MRB_VM1_PTDEV_AUDIO_CODEC
"-s", CONFIG_MRB_VM1_PTDEV_AUDIO_CODEC_OPT,
#endif /*CONFIG_MRB_VM1_PTDEV_AUDIO_CODEC*/
#ifdef CONFIG_MRB_VM1_PTDEV_CSME
"-s", CONFIG_MRB_VM1_PTDEV_CSME_OPT,
#endif /*CONFIG_MRB_VM1_PTDEV_CSME */
#ifdef CONFIG_MRB_VM1_PTDEV_IPU
"-s", CONFIG_MRB_VM1_PTDEV_IPU_OPT, /*ipu device*/
"-s", CONFIG_MRB_VM1_PTDEV_IPU_I2C, /*ipu related i2c*/
#endif /*CONFIG_MRB_VM1_PTDEV_IPU*/
#ifdef CONFIG_MRB_VM1_PTDEV_SD
"-s", CONFIG_MRB_VM1_PTDEV_SD_OPT,
#endif /*CONFIG_MRB_VM1_PTDEV_SD*/
#ifdef CONFIG_MRB_VM1_PTDEV_WIFI
"-s", CONFIG_MRB_VM1_PTDEV_WIFI_OPT,
#endif /*CONFIG_MRB_VM1_PTDEV_WIFI*/
#ifdef CONFIG_MRB_VM1_PTDEV_BLUETOOTH
"-s", CONFIG_MRB_VM1_PTDEV_BLUETOOTH_OPT,
#endif /*CONFIG_MRB_VM1_PTDEV_BLUETOOTH*/
#endif /*CONFIG_MRB_VM1_HOSTBRIDGE */
#ifdef CONFIG_MRB_VM1_LPC
"-s", CONFIG_MRB_VM1_LPC_OPT,
#ifdef CONFIG_MRB_VM1_IOC
"-i", CONFIG_MRB_VM1_IOC_UART CONFIG_MRB_VM1_NAME ","
CONFIG_MRB_VM1_IOC_REASON,
#endif /*CONFIG_MRB_VM1_IOC */
#ifdef CONFIG_MRB_VM1_LPC_COM1
"-l", CONFIG_MRB_VM1_LPC_COM1_OPT,
#endif /*CONFIG_MRB_VM1_LPC_COM1 */
#ifdef CONFIG_MRB_VM1_LPC_COM2
"-l", CONFIG_MRB_VM1_LPC_COM2_OPT CONFIG_MRB_VM1_NAME,
#endif /*CONFIG_MRB_VM1_LPC_COM2 */
#endif /*CONFIG_MRB_VM1_LPC */
#ifdef CONFIG_MRB_VM1_VSBL_IMAGE
"--vsbl", CONFIG_MRB_VM1_VSBL_IMAGE,
#endif /*CONFIG_MRB_VM1_VSBL_IMAGE */
"--enable_trusty",
/*command line */
"-B",
kernel_cmdline,
/* VM name */
CONFIG_MRB_VM1_NAME,
};
#ifdef CONFIG_MRB_VM1_PTDEV
#define PCI_UNBIND_PATH(X) \
"/sys/bus/pci/devices/" X "/driver/unbind"
static int pci_dev_unbind(char *path, char *bdf)
{
int fd = -1;
int ret = -1;
fd = open(path, O_WRONLY);
if (fd < 0) {
perror(path);
return -1;
}
ret = write(fd, bdf, strnlen(bdf, 64));
if (ret != strnlen(bdf, 64)) {
perror(bdf);
ret = -1;
}
close(fd);
return ret;
}
static int pci_dev_newid(char *id)
{
int fd = -1;
int ret = -1;
fd = open("/sys/bus/pci/drivers/pci-stub/new_id", O_WRONLY);
if (fd < 0) {
perror("/sys/bus/pci/drivers/pci-stub/new_id");
return -1;
}
ret = write(fd, id, strnlen(id, 64));
if (ret != strnlen(id, 64)) {
perror(id);
ret = -1;
}
close(fd);
return ret;
}
#define PTDEV_SETUP(ID, DEVINFO) \
do { \
pci_dev_newid(ID); \
pci_dev_unbind(PCI_UNBIND_PATH(DEVINFO), DEVINFO); \
} while(0)
#endif /*CONFIG_MRB_VM1_PTDEV*/
static void check_str(char *str, int len)
{
int i = 0;
for (i = 0; i < len; i++)
if (str[i] < 0x20 || str[i] > 0x7e)
str[i] = 0;
}
static int mrb_vm1_setup(void)
{
char mmc_name[64] = {};
char mmc_serial[64] = {};
int ret = 0;
int fd = -1;
#ifdef CONFIG_MRB_VM1_PTDEV_USB
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_USB_ID_1,
CONFIG_MRB_VM1_PTDEV_USB_DEVINFO_1);
#endif /*CONFIG_MRB_VM1_PTDEV_USB*/
#ifdef CONFIG_MRB_VM1_PTDEV_AUDIO
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_AUDIO_ID,
CONFIG_MRB_VM1_PTDEV_AUDIO_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_AUDIO*/
#ifdef CONFIG_MRB_VM1_PTDEV_AUDIO_CODEC
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_AUDIO_CODEC_ID,
CONFIG_MRB_VM1_PTDEV_AUDIO_CODEC_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_AUDIO*/
#ifdef CONFIG_MRB_VM1_PTDEV_CSME
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_CSME_ID,
CONFIG_MRB_VM1_PTDEV_CSME_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_CSME*/
#ifdef CONFIG_MRB_VM1_PTDEV_IPU
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_IPU_ID,
CONFIG_MRB_VM1_PTDEV_IPU_DEVINFO);
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_IPU_I2C_ID,
CONFIG_MRB_VM1_PTDEV_IPU_I2C_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_IPU*/
#ifdef CONFIG_MRB_VM1_PTDEV_SD
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_SD_ID,
CONFIG_MRB_VM1_PTDEV_SD_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_SD*/
#ifdef CONFIG_MRB_VM1_PTDEV_WIFI
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_WIFI_ID,
CONFIG_MRB_VM1_PTDEV_WIFI_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_WIFI*/
#ifdef CONFIG_MRB_VM1_PTDEV_BLUETOOTH
PTDEV_SETUP(CONFIG_MRB_VM1_PTDEV_BLUETOOTH_ID,
CONFIG_MRB_VM1_PTDEV_BLUETOOTH_DEVINFO);
#endif /*CONFIG_MRB_VM1_PTDEV_BLUETOOTH*/
memset(kernel_cmdline, 0, sizeof(kernel_cmdline));
fd = open("/sys/block/mmcblk1/device/name", O_RDONLY);
if (fd >= 0) {
ret = read(fd, mmc_name, sizeof(mmc_name));
if (ret >= sizeof(mmc_name))
mmc_name[sizeof(mmc_name) - 1] = 0;
check_str(mmc_name, sizeof(mmc_name));
close(fd);
}
fd = open("/sys/block/mmcblk1/device/serial", O_RDONLY);
if (fd >= 0) {
ret = read(fd, mmc_serial, sizeof(mmc_serial));
if (ret >= sizeof(mmc_serial))
mmc_name[sizeof(mmc_serial) - 1] = 0;
check_str(mmc_serial, sizeof(mmc_serial));
close(fd);
}
snprintf(kernel_cmdline, sizeof(kernel_cmdline) - 1, cmdline_fmt,
mmc_name, mmc_serial);
return 0;
}
struct vmcfg_arg mrb_vm1_args = {
.argv = mrb_vm1_options,
.argc = sizeof(mrb_vm1_options) / sizeof(char *),
.setup = mrb_vm1_setup,
};
#endif /*CONFIG_MRB_VM1 */
| 24.383051 | 67 | 0.74072 |
109137544daadc28ee3d26a50a3953c7f67c5b40 | 14,082 | h | C | public/internal/windows/inc/duser/duivalue.h | npocmaka/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 17 | 2020-11-13T13:42:52.000Z | 2021-09-16T09:13:13.000Z | windows/advcore/duser/directui/engine/core/value.w | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 2 | 2020-10-19T08:02:06.000Z | 2020-10-19T08:23:18.000Z | windows/advcore/duser/directui/engine/core/value.w | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 14 | 2020-11-14T09:43:20.000Z | 2021-08-28T08:59:57.000Z | /*
* Value
*/
#ifndef DUI_CORE_VALUE_H_INCLUDED
#define DUI_CORE_VALUE_H_INCLUDED
#pragma once
namespace DirectUI
{
////////////////////////////////////////////////////////
// Value
/*
* Value Multithreading
*
* Values are immutable and are a process-wide resource. A value created in one thread can be
* used in any thread. Access to them are synchronized (thread-safe) and they do not have
* thread-affinity.
*
* TODO: Impl thread-safety for Values
*/
// Forward declarations
class Element;
class Layout;
class PropertySheet;
class Expression;
typedef DynamicArray<Element*> ElementList;
// Value will maintain the lifetime of ElementLists, Layouts, PropertySheets, and Expressions after
// a new Value is created with a pointer to the object (these objects are created externally). When
// the reference count goes to zero, these objects will be deleted.
#define DUIV_UNAVAILABLE -2
#define DUIV_UNSET -1
#define DUIV_NULL 0
#define DUIV_INT 1
#define DUIV_BOOL 2
#define DUIV_ELEMENTREF 3
#define DUIV_ELLIST 4 // List deleted on Value destruction and made immutable on create (Value only object holding external created ElementList)
#define DUIV_STRING 5 // String duplicated on creation and freed on destruction (Value creates new internal instance)
#define DUIV_POINT 6
#define DUIV_SIZE 7
#define DUIV_RECT 8
#define DUIV_FILL 9
#define DUIV_LAYOUT 10 // Layout object destroyed on Value destruction (Value only object holding external created Layout)
#define DUIV_GRAPHIC 11 // Bitmap handle freed on Value destruction (Value creates new internal instance)
#define DUIV_SHEET 12 // PropertySheet object destroyed on Value destruction and made immutable on create (Value only object holding external created PropertySheet)
#define DUIV_EXPR 13 // Expression object destroyed on Value destruction (Value only object holding external created Expression)
#define DUIV_ATOM 14
#define DUIV_CURSOR 15 // Will not destroy cursor handle upon value destruction
// Value structures and macros
#define FILLTYPE_HGradient ((BYTE)0)
#define FILLTYPE_VGradient ((BYTE)1)
#define FILLTYPE_Solid ((BYTE)2)
#define FILLTYPE_TriHGradient ((BYTE)3)
#define FILLTYPE_TriVGradient ((BYTE)4)
#define FILLTYPE_DrawFrameControl ((BYTE)5) // DrawFrameControl fill
#define FILLTYPE_DrawThemeBackground ((BYTE)6) // DrawThemeBackground fill
struct Fill // Solid colors and fills
{
BYTE dType;
union
{
struct
{
COLORREF cr;
COLORREF cr2;
COLORREF cr3;
} ref;
struct
{
UINT uType;
UINT uState;
} fillDFC;
struct
{
HTHEME hTheme;
int iPartId;
int iStateId;
} fillDTB;
};
};
// Graphic
// Graphic objects may either have an Alpha channel applied to the entire bitmap,
// may have full alpha transparency of a particular color in the bitmap (with the
// option of an auto-color pick (upper left corner)), or neither
#define GRAPHICTYPE_Bitmap ((BYTE)0)
#define GRAPHICTYPE_Icon ((BYTE)1)
#define GRAPHICTYPE_EnhMetaFile ((BYTE)2)
#ifdef GADGET_ENABLE_GDIPLUS
#define GRAPHICTYPE_GpBitmap ((BYTE)3)
#endif
// Valid modes for Bitmaps (Alpha or RGB used depending on mode), meaning based on context of use
#define GRAPHIC_NoBlend ((BYTE)0)
#define GRAPHIC_AlphaConst ((BYTE)1)
#define GRAPHIC_AlphaConstPerPix ((BYTE)2)
#define GRAPHIC_TransColor ((BYTE)3)
#define GRAPHIC_Stretch ((BYTE)4)
#define GRAPHIC_NineGrid ((BYTE)5)
#define GRAPHIC_NineGridTransColor ((BYTE)6)
#define GRAPHIC_NineGridAlphaConstPerPix ((BYTE)7)
struct Graphic
{
HANDLE hImage; // Will hold hBitmap, hIcon, hEnhMetaFile or Gdiplus::Bitmap
HANDLE hAltImage;
USHORT cx;
USHORT cy;
struct
{
BYTE dImgType : 2;
BYTE dMode : 3;
bool bFlip : 1;
bool bRTLGraphic: 1;
bool bFreehImage: 1;
union
{
BYTE dAlpha;
struct
{
BYTE r: 8;
BYTE g: 8;
BYTE b: 8;
} rgbTrans;
};
} BlendMode;
};
struct Cursor
{
HCURSOR hCursor;
};
// Compile-time static version of the Value class
struct _StaticValue
{
BYTE _fReserved0;
BYTE _fReserved1;
short _dType;
int _cRef;
int _val0;
int _val1;
int _val2;
int _val3;
};
struct _StaticValueColor
{
BYTE _fReserved0;
BYTE _fReserved1;
short _dType;
int _cRef;
BYTE dType;
COLORREF cr;
COLORREF crSec;
USHORT x;
USHORT y;
};
struct _StaticValuePtr
{
BYTE _fReserved0;
BYTE _fReserved1;
short _dType;
int _cRef;
void* _ptr;
};
// Value class (24-bytes)
class Value
{
private:
BYTE _fReserved0; // Reserved for small block allocator
BYTE _fReserved1; // Data alignment padding
short _dType;
int _cRef;
union
{
int _intVal;
bool _boolVal;
Element* _peVal;
ElementList* _peListVal;
LPWSTR _pszVal;
POINT _ptVal;
SIZE _sizeVal;
RECT _rectVal;
Fill _fillVal;
Layout* _plVal;
Graphic _graphicVal;
PropertySheet* _ppsVal;
Expression* _pexVal;
ATOM _atomVal;
Cursor _cursorVal;
};
void _ZeroRelease();
public:
#if DBG
bool IsZeroRef() { return !_cRef; }
#endif
// Value creation methods
static Value* CreateInt(int dValue);
static Value* CreateBool(bool bValue);
static Value* CreateElementRef(Element* peValue);
static Value* CreateElementList(ElementList* peListValue);
static Value* CreateString(LPCWSTR pszValue, HINSTANCE hResLoad = NULL);
static Value* CreatePoint(int x, int y);
static Value* CreateSize(int cx, int cy);
static Value* CreateRect(int left, int top, int right, int bottom);
static Value* CreateColor(COLORREF cr);
static Value* CreateColor(COLORREF cr0, COLORREF cr1, BYTE dType = FILLTYPE_HGradient);
static Value* CreateColor(COLORREF cr0, COLORREF cr1, COLORREF cr2, BYTE dType = FILLTYPE_TriHGradient);
static Value* CreateFill(const Fill & clrSrc);
static Value* CreateDFCFill(UINT uType, UINT uState);
static Value* CreateDTBFill(HTHEME hTheme, int iPartId, int iStateId);
static Value* CreateLayout(Layout* plValue);
static Value* CreateGraphic(HBITMAP hBitmap, BYTE dBlendMode = GRAPHIC_TransColor, UINT dBlendValue = (UINT)-1, bool bFlip = false, bool bRTL = false);
#ifdef GADGET_ENABLE_GDIPLUS
static Value* CreateGraphic(Gdiplus::Bitmap * pgpbmp, BYTE dBlendMode = GRAPHIC_TransColor, UINT dBlendValue = (UINT)-1, bool bFlip = false, bool bRTL = false);
#endif
static Value* CreateGraphic(HICON hIcon, bool bFlip = false, bool bRTL = false);
static Value* CreateGraphic(LPCWSTR pszBMP, BYTE dBlendMode = GRAPHIC_TransColor, UINT dBlendValue = (UINT)-1, USHORT cx = 0, USHORT cy = 0, HINSTANCE hResLoad = NULL,
bool bFlip = false, bool bRTL = false);
static Value* CreateGraphic(LPCWSTR pszICO, USHORT cxDesired, USHORT cyDesired, HINSTANCE hResLoad = NULL, bool bFlip = false, bool bRTL = false);
static Value* CreateGraphic(HENHMETAFILE hEnhMetaFile, HENHMETAFILE hAltEnhMetaFile = NULL);
static Value* CreatePropertySheet(PropertySheet* ppsValue);
static Value* CreateExpression(Expression* pexValue);
static Value* CreateAtom(LPCWSTR pszValue);
static Value* CreateCursor(LPCWSTR pszValue);
static Value* CreateCursor(HCURSOR hValue);
// Reference count methods
void AddRef() { if (_cRef != -1) _cRef++; } // -1 is static value
void Release() { if (_cRef != -1 && !--_cRef) _ZeroRelease(); } // -1 is static value
int GetRefCount() { return _cRef; }
// Accessors
int GetType();
LPVOID GetImage(bool bGetRTL);
int GetInt();
bool GetBool();
Element* GetElement();
ElementList* GetElementList(); // Invalid if released (object referred to destroyed)
const LPWSTR GetString(); // Invalid if released (object referred to destroyed)
const POINT* GetPoint(); // Invalid if released
const SIZE* GetSize(); // Invalid if released
const RECT* GetRect(); // Invalid if released
const Fill* GetFill(); // Invalid if released
Layout* GetLayout(); // Invalid if released (object referred to destroyed)
Graphic* GetGraphic(); // Invalid if released (object indirectly referred to destroyed)
PropertySheet* GetPropertySheet(); // Invalid if released (object referred to destroyed)
Expression* GetExpression(); // Invalid if released (object referred to destroyed)
ATOM GetAtom(); // Invalid if released
Cursor* GetCursor(); // Invalid if released
// Equality
bool IsEqual(Value* pv);
// Conversion
LPWSTR ToString(LPWSTR psz, UINT c);
// Common values
static Value* pvUnavailable;
static Value* pvNull;
static Value* pvUnset;
static Value* pvElementNull;
static Value* pvElListNull;
static Value* pvBoolTrue;
static Value* pvBoolFalse;
static Value* pvStringNull;
static Value* pvPointZero;
static Value* pvSizeZero;
static Value* pvRectZero;
static Value* pvIntZero;
static Value* pvLayoutNull;
static Value* pvGraphicNull;
static Value* pvSheetNull;
static Value* pvExprNull;
static Value* pvAtomZero;
static Value* pvCursorNull;
static Value* pvColorTrans;
};
//LPVOID GetImage(Graphic *pg, bool bGetRTL);
#define GethBitmap(pv, bGetRTL) ((HBITMAP)pv->GetImage(bGetRTL))
#define GethIcon(pv, bGetRTL) ((HICON)pv->GetImage(bGetRTL))
#define GethEnhMetaFile(pv, bGetRTL) ((HENHMETAFILE)pv->GetImage(bGetRTL))
#define GetGpBitmap(pv, bGetRTL) ((Gdiplus::Bitmap *)pv->GetImage(bGetRTL))
#define StaticValue(name, type, val0) static _StaticValue name = { 0, 0, type, -1, val0, 0, 0, 0 }
#define StaticValue2(name, type, val0, val1) static _StaticValue name = { 0, 0, type, -1, val0, val1, 0, 0 }
#define StaticValue4(name, type, val0, val1, val2, val3) static _StaticValue name = { 0, 0, type, -1, val0, val1, val2, val3 }
#define StaticValueColorSolid(name, cr) static _StaticValueColor name = { 0, 0, DUIV_FILL, -1, FILLTYPE_Solid, cr, 0, 0, 0 }
#define StaticValuePtr(name, type, ptr) static _StaticValuePtr name = { 0, 0, type, -1, ptr }
// Accessors
inline int
Value::GetType()
{
return _dType;
}
inline int
Value::GetInt() // Copy passed out
{
DUIAssert(_dType == DUIV_INT, "Invalid value type");
return _intVal;
}
inline bool
Value::GetBool() // Copy passed out
{
DUIAssert(_dType == DUIV_BOOL, "Invalid value type");
return _boolVal;
}
inline Element *
Value::GetElement() // Copy passed out
{
DUIAssert(_dType == DUIV_ELEMENTREF, "Invalid value type");
return _peVal;
}
inline ElementList *
Value::GetElementList() // Copy passed out, invalid (destroyed) if value released
{
DUIAssert(_dType == DUIV_ELLIST, "Invalid value type");
return _peListVal;
}
inline const LPWSTR
Value::GetString() // Copy passed out, invalid (destroyed) if value released
{
DUIAssert(_dType == DUIV_STRING, "Invalid value type");
return _pszVal;
}
inline const POINT *
Value::GetPoint() // Pointer to internal structure, invalid if value released
{
DUIAssert(_dType == DUIV_POINT, "Invalid value type");
return &_ptVal;
}
inline const SIZE *
Value::GetSize() // Pointer to internal structure, invalid if value released
{
DUIAssert(_dType == DUIV_SIZE, "Invalid value type");
return &_sizeVal;
}
inline const RECT *
Value::GetRect() // Pointer to internal structure, invalid if value released
{
DUIAssert(_dType == DUIV_RECT, "Invalid value type");
return &_rectVal;
}
inline const Fill *
Value::GetFill() // Pointer to internal structure, invalid if value released
{
DUIAssert(_dType == DUIV_FILL, "Invalid value type");
return &_fillVal;
}
inline Layout *
Value::GetLayout() // Copy passed out, invalid (destroyed) if value released
{
DUIAssert(_dType == DUIV_LAYOUT, "Invalid value type");
return _plVal;
}
inline Graphic *
Value::GetGraphic() // Pointer to internal structure, invalid if value released
{
DUIAssert(_dType == DUIV_GRAPHIC, "Invalid value type");
return &_graphicVal;
}
inline PropertySheet * Value::GetPropertySheet() // Copy passed out, invalid (destroyed) if value released
{
DUIAssert(_dType == DUIV_SHEET, "Invalid value type");
return _ppsVal;
}
inline Expression *
Value::GetExpression() // Copy passed out, invalid (destroyed) if value released
{
DUIAssert(_dType == DUIV_EXPR, "Invalid value type");
return _pexVal;
}
inline ATOM
Value::GetAtom() // Copy passed out
{
DUIAssert(_dType == DUIV_ATOM, "Invalid value type");
return _atomVal;
}
inline Cursor *
Value::GetCursor() // Pointer to internal structure, invalid if value released
{
DUIAssert(_dType == DUIV_CURSOR, "Invalid value type");
return &_cursorVal;
}
} // namespace DirectUI
#endif // DUI_CORE_VALUE_H_INCLUDED
| 31.716216 | 173 | 0.641528 |
43fd639902cdaaa2dc55bae1e687b17cb3a3bf89 | 136 | h | C | 1/untitled/tests/unit_tests.h | PetrIlya/operating-systems | 55261903b824c7052198507793da1893347bb334 | [
"MIT"
] | null | null | null | 1/untitled/tests/unit_tests.h | PetrIlya/operating-systems | 55261903b824c7052198507793da1893347bb334 | [
"MIT"
] | null | null | null | 1/untitled/tests/unit_tests.h | PetrIlya/operating-systems | 55261903b824c7052198507793da1893347bb334 | [
"MIT"
] | null | null | null | #ifndef UNIT_TESTS_H
#define UNIT_TESTS_H
#include "../header/memory_model.h"
void init_test_memory (memory_nodel *new_mem);
#endif
| 13.6 | 46 | 0.779412 |
b74b48ad6c0ec999dc6f9255be9bc3553d4c5821 | 6,432 | c | C | contrib/dtka/kauth/karecv.c | yanhc519/ion-3.5.0 | b8aad9b75929297e0f0c9ec802094d03c048cef9 | [
"Unlicense"
] | 1 | 2018-09-04T02:50:14.000Z | 2018-09-04T02:50:14.000Z | contrib/dtka/kauth/karecv.c | yanhc519/ion-3.5.0 | b8aad9b75929297e0f0c9ec802094d03c048cef9 | [
"Unlicense"
] | null | null | null | contrib/dtka/kauth/karecv.c | yanhc519/ion-3.5.0 | b8aad9b75929297e0f0c9ec802094d03c048cef9 | [
"Unlicense"
] | null | null | null | /*
karecv.c: Key authority daemon for reception of key
records asserted by nodes.
Author: Scott Burleigh, JPL
Copyright (c) 2013, California Institute of Technology.
ALL RIGHTS RESERVED. U.S. Government Sponsorship
acknowledged.
*/
#include "kauth.h"
#include "bpP.h"
typedef struct
{
BpSAP sap;
int running;
} KarecvState;
static KarecvState *_karecvState(KarecvState *newState)
{
void *value;
KarecvState *state;
if (newState) /* Add task variable. */
{
value = (void *) (newState);
state = (KarecvState *) sm_TaskVar(&value);
}
else /* Retrieve task variable. */
{
state = (KarecvState *) sm_TaskVar(NULL);
}
return state;
}
static void shutDown() /* Commands karecv termination. */
{
KarecvState *state;
isignal(SIGTERM, shutDown);
PUTS("DTKA receiver daemon interrupted.");
state = _karecvState(NULL);
bp_interrupt(state->sap);
state->running = 0;
}
static unsigned short fetchRecord(Object recordsList, uvast nodeNbr,
BpTimestamp *effectiveTime, Object *recordElt,
Object *nextRecordElt)
{
Sdr sdr = getIonsdr();
Object elt;
DtkaRecord record;
CHKERR(recordsList);
CHKERR(nodeNbr);
CHKERR(effectiveTime);
CHKERR(recordElt);
*recordElt = 0; /* Not found. (Default) */
if (nextRecordElt)
{
*nextRecordElt = 0; /* None. (Default) */
}
for (elt = sdr_list_first(sdr, recordsList); elt;
elt = sdr_list_next(sdr, elt))
{
sdr_read(sdr, (char *) &record, sdr_list_data(sdr, elt),
DTKA_HDR_LEN);
if (record.nodeNbr < nodeNbr)
{
continue;
}
if (record.nodeNbr > nodeNbr)
{
break;
}
if (record.effectiveTime.seconds < effectiveTime->seconds)
{
continue;
}
if (record.effectiveTime.seconds > effectiveTime->seconds)
{
break;
}
if (record.effectiveTime.count < effectiveTime->count)
{
continue;
}
if (record.effectiveTime.count > effectiveTime->count)
{
break;
}
/* Found it. */
*recordElt = elt;
return record.datLength;
}
if (nextRecordElt)
{
*nextRecordElt = elt;
}
return 0; /* Not found. */
}
static int acquireRecord(Sdr sdr, DtkaAuthDB *db, char *src, Object adu)
{
int parsedOkay;
MetaEid metaEid;
VScheme *vscheme;
PsmAddress schemeElt;
vast recordLength;
ZcoReader reader;
int len;
char buffer[DTKA_MAX_REC];
unsigned char *cursor = (unsigned char *) buffer;
DtkaRecord record;
Object recordElt;
Object nextRecordElt;
Object obj;
parsedOkay = parseEidString(src, &metaEid, &vscheme, &schemeElt);
if (!parsedOkay)
{
restoreEidString(&metaEid);
writeMemoNote("[?] Can't parse source of DTKA record", src);
return 0;
}
recordLength = zco_source_data_length(sdr, adu);
len = recordLength;
if (len > DTKA_MAX_REC)
{
restoreEidString(&metaEid);
writeMemoNote("[?] DTKA record length error", itoa(len));
return 0;
}
#if DTKA_DEBUG
printf("Got pubkey record from " UVAST_FIELDSPEC " in karecv.\n",
metaEid.nodeNbr);
fflush(stdout);
#endif
memset(&record, 0, sizeof record);
zco_start_receiving(adu, &reader);
recordLength = zco_receive_source(sdr, &reader, DTKA_MAX_REC, buffer);
len = recordLength;
if (dtka_deserialize(&cursor, &len, DTKA_MAX_DATLEN,
&(record.nodeNbr), &(record.effectiveTime),
&(record.assertionTime), &(record.datLength),
record.datValue) < 0)
{
#if DTKA_DEBUG
puts("Deserialize failed.");
fflush(stdout);
#endif
restoreEidString(&metaEid);
return 0;
}
if (record.nodeNbr != metaEid.nodeNbr)
{
restoreEidString(&metaEid);
writeMemoNote("[?] DTKA record posted from unauthorized EID",
src);
return 0;
}
restoreEidString(&metaEid);
if (fetchRecord(db->pendingRecords, record.nodeNbr,
&record.effectiveTime, &recordElt, &nextRecordElt))
{
#if DTKA_DEBUG
puts("Record already pending; ignored.");
fflush(stdout);
#endif
return 0; /* Record already pending; ignore. */
}
/* Record not previously submitted in this cycle. Was
* it submitted in an earlier cycle? */
if (fetchRecord(db->currentRecords, record.nodeNbr,
&record.effectiveTime, &recordElt, NULL))
{
return 0; /* Record already posted; ignore. */
}
/* Record not previously submitted. Okay to add it. */
obj = sdr_malloc(sdr, sizeof(DtkaRecord));
if (obj == 0)
{
return -1;
}
record.acknowledged[db->ownAuthIdx] = 1;
sdr_write(sdr, obj, (char *) &record, sizeof(DtkaRecord));
if (nextRecordElt)
{
recordElt = sdr_list_insert_before(sdr, nextRecordElt, obj);
}
else
{
recordElt = sdr_list_insert_last(sdr, db->pendingRecords, obj);
}
if (recordElt == 0)
{
return -1;
}
return record.datLength;
}
#if defined (VXWORKS) || defined (RTEMS) || defined (bionic)
int karecv(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
#else
int main(int argc, char *argv[])
{
#endif
char ownEid[32];
KarecvState state = { NULL, 1 };
Sdr sdr;
Object dbobj;
DtkaAuthDB db;
BpDelivery dlv;
if (kauthAttach() < 0)
{
putErrmsg("karecv can't attach to dtka.", NULL);
return 1;
}
isprintf(ownEid, sizeof ownEid, "imc:%d.0", DTKA_DECLARE);
if (bp_open(ownEid, &state.sap) < 0)
{
putErrmsg("Can't open own endpoint.", ownEid);
ionDetach();
return 1;
}
sdr = getIonsdr();
dbobj = getKauthDbObject();
if (dbobj == 0)
{
putErrmsg("No DTKA authority database.", NULL);
ionDetach();
return 1;
}
sdr_read(sdr, (char *) &db, dbobj, sizeof(DtkaAuthDB));
/* Main loop: receive record, insert into list. */
oK(_karecvState(&state));
isignal(SIGTERM, shutDown);
writeMemo("[i] karecv is running.");
while (state.running)
{
if (bp_receive(state.sap, &dlv, BP_BLOCKING) < 0)
{
putErrmsg("karecv bundle reception failed.", NULL);
state.running = 0;
continue;
}
if (dlv.result == BpReceptionInterrupted)
{
bp_release_delivery(&dlv, 1);
continue;
}
if (dlv.result == BpEndpointStopped)
{
bp_release_delivery(&dlv, 1);
state.running = 0;
continue;
}
if (dlv.result == BpPayloadPresent)
{
CHKZERO(sdr_begin_xn(sdr));
if (acquireRecord(sdr, &db, dlv.bundleSourceEid,
dlv.adu) < 0)
{
putErrmsg("Can't acquire record.", NULL);
sdr_cancel_xn(sdr);
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't handle DTKA record.", NULL);
state.running = 0;
continue;
}
}
bp_release_delivery(&dlv, 1);
}
bp_close(state.sap);
writeErrmsgMemos();
writeMemo("[i] karecv has ended.");
ionDetach();
return 0;
}
| 20.1 | 72 | 0.670398 |
b7bddcc3b631c94f560243bf16293c5d40e68a42 | 7,607 | h | C | src/components/sde/sde_internal.h | cothan/PAPI_ARMv8_Cortex_A72 | 2f9d855f1d202b744984f8f24ab5f3f18e15988d | [
"BSD-3-Clause"
] | 4 | 2020-09-18T05:38:40.000Z | 2021-07-16T06:21:51.000Z | src/components/sde/sde_internal.h | cothan/PAPI_ARMv8_Cortex_A72 | 2f9d855f1d202b744984f8f24ab5f3f18e15988d | [
"BSD-3-Clause"
] | null | null | null | src/components/sde/sde_internal.h | cothan/PAPI_ARMv8_Cortex_A72 | 2f9d855f1d202b744984f8f24ab5f3f18e15988d | [
"BSD-3-Clause"
] | null | null | null | #ifndef SDE_H
#define SDE_H
// Enable the following line if you want to use PAPI_overflow()
#define SDE_HAVE_OVERFLOW
#define PAPI_SDE_THREAD_SAFE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#if defined(SDE_HAVE_OVERFLOW)
#include <ucontext.h>
#endif //defined(SDE_HAVE_OVERFLOW)
#define is_readonly(_X_) (PAPI_SDE_RO == ((_X_)&0x0F))
#define is_readwrite(_X_) (PAPI_SDE_RW == ((_X_)&0x0F))
#define is_delta(_X_) (PAPI_SDE_DELTA == ((_X_)&0xF0))
#define is_instant(_X_) (PAPI_SDE_INSTANT == ((_X_)&0xF0))
#define EXP_CONTAINER_ENTRIES 52
#define EXP_CONTAINER_MIN_SIZE 2048
#ifndef SDE_MAX_SIMULTANEOUS_COUNTERS
#define SDE_MAX_SIMULTANEOUS_COUNTERS 40
#endif
#define PAPISDE_HT_SIZE 512
#define REGISTERED_EVENT_MASK 0x2;
/* Headers required by PAPI */
#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"
#include "extras.h"
#include "interface/papi_sde_interface.h"
#if defined(PAPI_SDE_THREAD_SAFE)
#define papi_sde_lock() _papi_hwi_lock(COMPONENT_LOCK);
#define papi_sde_unlock() _papi_hwi_unlock(COMPONENT_LOCK);
#else
#warning "Thread safe locking is _NOT_ activated"
#define papi_sde_lock()
#define papi_sde_unlock()
#endif
papi_vector_t _sde_vector;
/* We do not use this structure, but the framework needs its size */
typedef struct sde_register
{
int junk;
} sde_register_t;
/* We do not use this structure, but the framework needs its size */
typedef struct sde_reg_alloc
{
sde_register_t junk;
} sde_reg_alloc_t;
/**
* There's one of these per event-set to hold data specific to the EventSet, like
* counter start values, number of events in a set and counter uniq ids.
*/
typedef struct sde_control_state
{
int num_events;
unsigned int which_counter[SDE_MAX_SIMULTANEOUS_COUNTERS];
long long counter[SDE_MAX_SIMULTANEOUS_COUNTERS];
long long previous_value[SDE_MAX_SIMULTANEOUS_COUNTERS];
#if defined(SDE_HAVE_OVERFLOW)
timer_t timerid;
int has_timer;
#endif //defined(SDE_HAVE_OVERFLOW)
} sde_control_state_t;
typedef struct sde_context {
long long junk;
} sde_context_t;
typedef struct sde_counter_s sde_counter_t;
typedef struct sde_sorting_params_s sde_sorting_params_t;
typedef struct papisde_list_entry_s papisde_list_entry_t;
typedef struct papisde_library_desc_s papisde_library_desc_t;
typedef struct papisde_control_s papisde_control_t;
typedef struct recorder_data_s recorder_data_t;
/* Hash table entry */
struct papisde_list_entry_s {
sde_counter_t *item;
papisde_list_entry_t *next;
};
struct recorder_data_s{
void *exp_container[EXP_CONTAINER_ENTRIES];
long long total_entries;
long long used_entries;
size_t typesize;
void *sorted_buffer;
long long sorted_entries;
};
/* The following type describes a counter, or a counter group, or a recording. */
struct sde_counter_s {
unsigned int glb_uniq_id;
char *name;
char *description;
void *data;
long long int previous_data;
recorder_data_t *recorder_data;
int is_created;
int overflow;
papi_sde_fptr_t func_ptr;
void *param;
int cntr_type;
int cntr_mode;
papisde_library_desc_t *which_lib;
papisde_list_entry_t *counter_group_head;
uint32_t counter_group_flags;
};
struct sde_sorting_params_s{
sde_counter_t *recording;
int (*cmpr_func_ptr)(const void *p1, const void *p2);
};
/* This type describes one library. This is the type of the handle returned by papi_sde_init(). */
struct papisde_library_desc_s {
char* libraryName;
papisde_list_entry_t lib_counters[PAPISDE_HT_SIZE];
papisde_library_desc_t *next;
};
/* One global variable of this type holds pointers to all other SDE meta-data */
struct papisde_control_s {
unsigned int num_reg_events; /* This number only increases, so it can be used as a uniq id */
unsigned int num_live_events; /* This number decreases at unregister() */
papisde_library_desc_t *lib_list_head;
unsigned int activeLibCount;
papisde_list_entry_t all_reg_counters[PAPISDE_HT_SIZE];
};
/** This global variable points to the head of the control state list **/
static papisde_control_t *_papisde_global_control = NULL;
/* All of the following functions are for internal use only. */
static int _sde_reset( hwd_context_t *ctx, hwd_control_state_t *ctl );
static int _sde_write( hwd_context_t *ctx, hwd_control_state_t *ctl, long long *events );
static int _sde_read( hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags );
static int _sde_stop( hwd_context_t *ctx, hwd_control_state_t *ctl );
static int _sde_start( hwd_context_t *ctx, hwd_control_state_t *ctl );
static int _sde_update_control_state( hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx );
static int _sde_init_control_state( hwd_control_state_t * ctl );
static int _sde_init_thread( hwd_context_t *ctx );
static int _sde_init_component( int cidx );
static int _sde_shutdown_component(void);
static int _sde_shutdown_thread( hwd_context_t *ctx );
static int _sde_ctl( hwd_context_t *ctx, int code, _papi_int_option_t *option );
static int _sde_set_domain( hwd_control_state_t * cntrl, int domain );
static int _sde_ntv_enum_events( unsigned int *EventCode, int modifier );
static int _sde_ntv_code_to_name( unsigned int EventCode, char *name, int len );
static int _sde_ntv_code_to_descr( unsigned int EventCode, char *descr, int len );
static int _sde_ntv_name_to_code(const char *name, unsigned int *event_code );
#if defined(SDE_HAVE_OVERFLOW)
static int _sde_set_overflow( EventSetInfo_t *ESI, int EventIndex, int threshold );
static void _sde_dispatch_timer( int n, hwd_siginfo_t *info, void *uc);
static void invoke_user_handler(sde_counter_t *cntr_handle);
static int set_timer_for_overflow( sde_control_state_t *sde_ctl );
#endif // defined(SDE_HAVE_OVERFLOW)
static papi_handle_t do_sde_init(const char *name_of_library);
static int sde_cast_and_store(void *data, long long int previous_value, void *rslt, int type);
static int sde_hardware_read_and_store( sde_counter_t *counter, long long int previous_value, long long int *rslt );
static int sde_read_counter_group( sde_counter_t *counter, long long int *rslt );
static int sde_setup_counter_internals( papi_handle_t handle, const char *event_name, int cntr_mode, int cntr_type, void *counter, papi_sde_fptr_t fp_counter, void *param, sde_counter_t **placeholder );
int aggregate_value_in_group(long long int *data, long long int *rslt, int cntr_type, int group_flags);
static inline int sde_do_register( papi_handle_t handle, const char *event_name, int cntr_mode, int cntr_type, void *counter, papi_sde_fptr_t fp_counter, void *param );
static sde_counter_t *allocate_and_insert(papisde_library_desc_t* lib_handle, const char *name, unsigned int uniq_id, int cntr_mode, int cntr_type, void *data, papi_sde_fptr_t func_ptr, void *param);
static int delete_counter(papisde_library_desc_t* lib_handle, const char *name);
static inline void free_counter(sde_counter_t *counter);
static unsigned int ht_hash_id(unsigned int uniq_id);
static unsigned long ht_hash_name(const char *str);
static void ht_insert(papisde_list_entry_t *hash_table, int key, sde_counter_t *sde_counter);
static sde_counter_t *ht_delete(papisde_list_entry_t *hash_table, int key, unsigned int uniq_id);
static sde_counter_t *ht_lookup_by_name(papisde_list_entry_t *hash_table, const char *name);
static sde_counter_t *ht_lookup_by_id(papisde_list_entry_t *hash_table, unsigned int uniq_id);
#endif
| 38.226131 | 202 | 0.787696 |
2ee522a2c9d26d6ca04b5eebef1b22a0f946f8f6 | 47,354 | c | C | src/winscard_scf.c | ystk/debian-pcsc-lite | 6ee555c6874e92321d95c2f5b167e789db84a7fe | [
"BSD-3-Clause"
] | null | null | null | src/winscard_scf.c | ystk/debian-pcsc-lite | 6ee555c6874e92321d95c2f5b167e789db84a7fe | [
"BSD-3-Clause"
] | null | null | null | src/winscard_scf.c | ystk/debian-pcsc-lite | 6ee555c6874e92321d95c2f5b167e789db84a7fe | [
"BSD-3-Clause"
] | null | null | null | /*
* MUSCLE SmartCard Development ( http://www.linuxnet.com )
*
* Copyright (C) 2002
* David Corcoran <corcoran@linuxnet.com>
* Najam Siddiqui
* Copyright (C) 2005
* Ludovic Rousseau <ludovic.rousseau@free.fr>
*
* $Id: winscard_scf.c 2896 2008-04-22 09:20:00Z rousseau $
*/
/**
* @file
* @brief This provides PC/SC to SCF shimming.
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/un.h>
#include <smartcard/scf.h>
#include <time.h>
#include "pcsclite.h"
#include "winscard.h"
#include "debug.h"
#include "thread_generic.h"
#include "readerfactory.h"
#include "eventhandler.h"
#include "sys_generic.h"
#define TRUE 1
#define FALSE 0
#undef PCSCLITE_MAX_READERS_CONTEXTS
#define PCSCLITE_MAX_READERS_CONTEXTS 2
/** Global session to manage Readers, Card events. */
static SCF_Session_t g_hSession = NULL;
/** Have to define this because they are defined in pcsclite.h as externs */
SCARD_IO_REQUEST g_rgSCardT0Pci, g_rgSCardT1Pci, g_rgSCardRawPci;
static struct _psTransmitMap
{
BYTE Buffer[266];
int isResponseCached;
LONG bufferLength;
} psTransmitMap[PCSCLITE_MAX_APPLICATION_CONTEXTS];
/** Channel Map to manage Card Connections. */
static struct _psChannelMap
{
SCARDHANDLE PCSC_hCard;
SCARDCONTEXT hContext;
SCF_Session_t hSession;
SCF_Terminal_t hTerminal;
SCF_Card_t SCF_hCard;
short haveLock;
short isReset;
int ReaderIndice;
} psChannelMap[PCSCLITE_MAX_APPLICATION_CONTEXTS];
/** Context Map to manage contexts and sessions. */
static struct _psContextMap
{
SCARDCONTEXT hContext;
SCF_Session_t hSession;
DWORD contextBlockStatus;
} psContextMap[PCSCLITE_MAX_APPLICATION_CONTEXTS];
/** Reader Map to handle Status and GetStatusChange. */
static struct _psReaderMap
{
SCF_Terminal_t hTerminal;
LPSTR ReaderName;
short SharedRefCount;
DWORD dwCurrentState;
BYTE bAtr[MAX_ATR_SIZE];
DWORD dwAtrLength;
SCF_ListenerHandle_t lHandle;
} psReaderMap[PCSCLITE_MAX_READERS_CONTEXTS];
static PCSCLITE_MUTEX clientMutex = PTHREAD_MUTEX_INITIALIZER;
/**
* Mutex for the Smardcard Event Handling, different from client Mutex
* because event reporting from the ocfserver is done using a single thread,
* so to get lock on the clientMutex may affect the performance of the ocf server.
*/
static PCSCLITE_MUTEX EventMutex = PTHREAD_MUTEX_INITIALIZER;
static PCSCLITE_MUTEX SCFInitMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t EventCondition = PTHREAD_COND_INITIALIZER;
static char PCSC_Initialized = 0;
static LONG isOCFServerRunning(void);
LONG SCardLockThread(void);
LONG SCardUnlockThread(void);
LONG SCardEventLock(void);
LONG SCardEventUnlock(void);
static LONG PCSC_SCF_Initialize(void);
static void EventCallback(SCF_Event_t eventType, SCF_Terminal_t hTerm,
void *cbdata);
static LONG PCSC_SCF_getATR(SCF_Card_t hCard, LPBYTE pcbAtr,
LPDWORD pcbAtrLen);
static LONG ConvertStatus(SCF_Status_t status);
static LONG SCardGetReaderIndice(LPCSTR ReaderName);
static LONG getNewContext(SCARDCONTEXT * phContext);
static LONG SCardAddContext(SCARDCONTEXT hContext, SCF_Session_t hSession);
static SCF_Session_t getSessionForContext(SCARDCONTEXT hContext);
static LONG SCardRemoveContext(SCARDCONTEXT hContext);
static LONG SCardGetContextIndice(SCARDCONTEXT hContext);
static LONG getNewHandle(SCARDCONTEXT hContext, LPCSTR szReader,
SCARDHANDLE * phCard, DWORD);
static LONG getCardForHandle(SCARDHANDLE PSCS_hCard, SCF_Card_t * SCF_hCard);
static LONG SCardRemoveHandle(SCARDHANDLE hCard);
static LONG SCardAddHandle(SCARDHANDLE PCSC_hCard, SCARDCONTEXT hContext,
SCF_Session_t hSession, SCF_Terminal_t hTerminal,
SCF_Card_t SCF_hCard, int, DWORD);
static LONG SCardGetHandleIndice(SCARDHANDLE hCard);
static LONG isActiveContextPresent(void);
static LONG SCardEstablishContextTH(DWORD dwScope, LPCVOID pvReserved1,
LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
LONG rv = 0;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
rv = PCSC_SCF_Initialize();
if (SCARD_S_SUCCESS != rv)
return rv;
if (NULL == phContext)
return SCARD_E_INVALID_PARAMETER;
else
*phContext = 0;
if (dwScope != SCARD_SCOPE_USER && dwScope != SCARD_SCOPE_TERMINAL &&
dwScope != SCARD_SCOPE_SYSTEM && dwScope != SCARD_SCOPE_GLOBAL)
{
*phContext = 0;
return SCARD_E_INVALID_VALUE;
}
rv = getNewContext(phContext);
return rv;
}
LONG SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1,
LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
long rv;
SCardLockThread();
rv = SCardEstablishContextTH(dwScope, pvReserved1,
pvReserved2, phContext);
SCardUnlockThread();
return rv;
}
static LONG SCardReleaseContextTH(SCARDCONTEXT hContext)
{
LONG rv;
/* Zero out everything */
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
rv = 0;
/* Remove the local context from the stack */
rv = SCardRemoveContext(hContext);
return rv;
}
LONG SCardReleaseContext(SCARDCONTEXT hContext)
{
long rv;
SCardLockThread();
rv = SCardReleaseContextTH(hContext);
SCardUnlockThread();
return rv;
}
static LONG SCardListReadersTH(SCARDCONTEXT hContext, LPCSTR mszGroups,
LPSTR mszReaders, LPDWORD pcchReaders)
{
static int first_time = 1;
int i = 0;
static DWORD dwReadersLen = 0;
LONG retIndice = 0;
char *tempPtr;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* Check for NULL parameters */
if (pcchReaders == NULL)
{
return SCARD_E_INVALID_PARAMETER;
}
/*Check for Context validity */
retIndice = SCardGetContextIndice(hContext);
if (0 > retIndice)
return SCARD_E_INVALID_HANDLE;
/*Calculate the the buffer length reuired only once.
*/
if (first_time)
{
for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
{
if (NULL != psReaderMap[i].ReaderName)
dwReadersLen += strlen(psReaderMap[i].ReaderName) + 1;
}
dwReadersLen++;
first_time = 0;
}
/*There are no readers available */
if (1 >= dwReadersLen)
return SCARD_E_READER_UNAVAILABLE;
if (mszReaders == NULL)
{
*pcchReaders = dwReadersLen;
return SCARD_S_SUCCESS;
}
else if (*pcchReaders == 0)
{
*pcchReaders = dwReadersLen;
return SCARD_S_SUCCESS;
}
else if (*pcchReaders < dwReadersLen)
{
*pcchReaders = dwReadersLen;
return SCARD_E_INSUFFICIENT_BUFFER;
}
tempPtr = mszReaders;
for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
{
if (NULL != psReaderMap[i].ReaderName)
{
memcpy(tempPtr, psReaderMap[i].ReaderName,
strlen(psReaderMap[i].ReaderName) + 1);
tempPtr += (strlen(psReaderMap[i].ReaderName) + 1);
}
}
/*the extra NULL character as per the PCSC specs. */
tempPtr[0] = '\0';
*pcchReaders = dwReadersLen;
return SCARD_S_SUCCESS;
}
LONG SCardListReaders(SCARDCONTEXT hContext, LPCSTR mszGroups,
LPSTR mszReaders, LPDWORD pcchReaders)
{
long rv;
SCardLockThread();
rv = SCardListReadersTH(hContext, mszGroups, mszReaders, pcchReaders);
SCardUnlockThread();
return rv;
}
/* by najam */
static LONG SCardConnectTH(SCARDCONTEXT hContext, LPCSTR szReader,
DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
LPDWORD pdwActiveProtocol)
{
LONG rv;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* Zero out everything */
rv = 0;
/* Check for NULL parameters */
if (phCard == NULL || pdwActiveProtocol == NULL)
return SCARD_E_INVALID_PARAMETER;
else
*phCard = 0;
/* Make sure this context has been opened */
if (SCardGetContextIndice(hContext) == -1)
return SCARD_E_INVALID_HANDLE;
if (szReader == NULL)
return SCARD_E_UNKNOWN_READER;
/* Check for uninitialized strings */
if (strlen(szReader) > MAX_READERNAME)
return SCARD_E_INVALID_VALUE;
if (!(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
!(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
!(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
!(dwPreferredProtocols & SCARD_PROTOCOL_ANY))
{
return SCARD_E_INVALID_VALUE;
}
if ((SCARD_SHARE_SHARED != dwShareMode) &&
(SCARD_SHARE_EXCLUSIVE != dwShareMode) &&
(SCARD_SHARE_DIRECT != dwShareMode))
{
return SCARD_E_INVALID_VALUE;
}
/* TODO Which Protocols have to be supported */
/* Ignoring protocols for now */
/* Make sure this handle has been opened */
rv = getNewHandle(hContext, szReader, phCard, dwShareMode);
if (SCARD_S_SUCCESS != rv)
return rv;
*pdwActiveProtocol = SCARD_PROTOCOL_T0;
return SCARD_S_SUCCESS;
}
LONG SCardConnect(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode,
DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
LPDWORD pdwActiveProtocol)
{
long rv;
SCardLockThread();
rv = SCardConnectTH(hContext, szReader, dwShareMode,
dwPreferredProtocols, phCard, pdwActiveProtocol);
SCardUnlockThread();
return rv;
}
static LONG SCardDisconnectTH(SCARDHANDLE hCard, DWORD dwDisposition)
{
long rv;
LONG retIndice = 0;
SCF_Status_t status;
/*check ocfserver availibility */
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
if (dwDisposition != SCARD_LEAVE_CARD &&
dwDisposition != SCARD_RESET_CARD &&
dwDisposition != SCARD_UNPOWER_CARD &&
dwDisposition != SCARD_EJECT_CARD)
{
return SCARD_E_INVALID_VALUE;
}
/*CHECK HANDLE VALIDITY */
retIndice = SCardGetHandleIndice(hCard);
if ((retIndice == -1) || (NULL == psChannelMap[retIndice].SCF_hCard))
return SCARD_E_INVALID_HANDLE;
/* TODO Take Care of the Disposition... */
/* Resetting the card for SCARD_RESET_CARD |
SCARD_UNPOWER_CARD | SCARD_EJECT_CARD */
if (SCARD_LEAVE_CARD != dwDisposition)
{
/*must acquire the lock to reset card */
status = SCF_Card_lock(psChannelMap[retIndice].SCF_hCard, 0);
if ((SCF_STATUS_SUCCESS == status)
|| (SCF_STATUS_DOUBLELOCK == status))
{
status = SCF_Card_reset(psChannelMap[retIndice].SCF_hCard);
SCF_Card_unlock(psChannelMap[retIndice].SCF_hCard);
/*a usleep here will allow the RESET_EVENT to be reported and
the Maps to be updated */
SYS_USleep(10);
}
}
rv = SCardRemoveHandle(hCard);
return rv;
}
static LONG SCardReconnectTH(SCARDHANDLE hCard, DWORD dwShareMode,
DWORD dwPreferredProtocols, DWORD dwInitialization,
LPDWORD pdwActiveProtocol)
{
SCARDCONTEXT hContext;
LPSTR ReaderName;
SCARDHANDLE tempHandle;
LONG rv;
int retIndice = 0;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
if (pdwActiveProtocol == NULL)
return SCARD_E_INVALID_PARAMETER;
if (dwInitialization != SCARD_LEAVE_CARD &&
dwInitialization != SCARD_RESET_CARD &&
dwInitialization != SCARD_UNPOWER_CARD &&
dwInitialization != SCARD_EJECT_CARD)
{
return SCARD_E_INVALID_VALUE;
}
retIndice = SCardGetHandleIndice(hCard);
if (-1 == retIndice)
return SCARD_E_INVALID_HANDLE;
hContext = psChannelMap[retIndice].hContext;
ReaderName = psReaderMap[psChannelMap[retIndice].ReaderIndice].ReaderName;
SCardDisconnectTH(hCard, dwInitialization);
/* get a new handle */
rv = SCardConnectTH(hContext, ReaderName, dwShareMode,
dwPreferredProtocols, &tempHandle, pdwActiveProtocol);
if (SCARD_S_SUCCESS != rv)
return rv;
retIndice = SCardGetHandleIndice(tempHandle);
if (-1 == retIndice)
return SCARD_E_NO_MEMORY;
/*set PCSC hCard to old Handle */
SCardEventLock();
psChannelMap[retIndice].PCSC_hCard = hCard;
SCardEventUnlock();
return SCARD_S_SUCCESS;
}
LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
DWORD dwPreferredProtocols, DWORD dwInitialization,
LPDWORD pdwActiveProtocol)
{
long rv;
SCardLockThread();
rv = SCardReconnectTH(hCard, dwShareMode, dwPreferredProtocols,
dwInitialization, pdwActiveProtocol);
SCardUnlockThread();
return rv;
}
LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
{
long rv;
SCardLockThread();
rv = SCardDisconnectTH(hCard, dwDisposition);
SCardUnlockThread();
return rv;
}
LONG SCardBeginTransaction(SCARDHANDLE hCard)
{
LONG rv;
SCF_Card_t SCF_hCard;
SCF_Status_t status;
/* Zero out everything */
rv = 0;
SCardLockThread();
if (SCARD_S_SUCCESS != isOCFServerRunning())
{
SCardUnlockThread();
return SCARD_E_NO_SERVICE;
}
rv = getCardForHandle(hCard, &SCF_hCard);
if (SCARD_S_SUCCESS != rv)
{
SCardUnlockThread();
return rv;
}
SCardUnlockThread();
status = SCF_Card_lock(SCF_hCard, SCF_TIMEOUT_MAX);
if (SCF_STATUS_DOUBLELOCK == status)
return SCARD_S_SUCCESS;
rv = ConvertStatus(status);
return rv;
}
static LONG SCardEndTransactionTH(SCARDHANDLE hCard, DWORD dwDisposition)
{
LONG rv;
LONG retIndice = 0;
SCF_Card_t SCF_hCard;
SCF_Status_t status;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* Zero out everything */
rv = 0;
if (dwDisposition != SCARD_LEAVE_CARD &&
dwDisposition != SCARD_RESET_CARD &&
dwDisposition != SCARD_UNPOWER_CARD &&
dwDisposition != SCARD_EJECT_CARD)
{
return SCARD_E_INVALID_VALUE;
}
retIndice = SCardGetHandleIndice(hCard);
if (retIndice == -1)
return SCARD_E_INVALID_HANDLE;
rv = getCardForHandle(hCard, &SCF_hCard);
if (rv != SCARD_S_SUCCESS)
return rv;
/* TODO Take Care of the Disposition... */
if (SCARD_LEAVE_CARD != dwDisposition)
{
status = SCF_Card_reset(psChannelMap[retIndice].SCF_hCard);
if (SCF_STATUS_SUCCESS == status)
{
/* reset the isReset for this card */
SYS_USleep(10);
SCardEventLock();
psChannelMap[retIndice].isReset = 0;
SCardEventUnlock();
}
}
status = SCF_Card_unlock(SCF_hCard);
return ConvertStatus(status);
}
LONG SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
{
long rv;
SCardLockThread();
rv = SCardEndTransactionTH(hCard, dwDisposition);
SCardUnlockThread();
return rv;
}
static LONG SCardCancelTransactionTH(SCARDHANDLE hCard)
{
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* TODO */
return SCARD_S_SUCCESS;
}
LONG SCardCancelTransaction(SCARDHANDLE hCard)
{
long rv;
SCardLockThread();
rv = SCardCancelTransactionTH(hCard);
SCardUnlockThread();
return rv;
}
static LONG SCardStatusTH(SCARDHANDLE hCard, LPSTR mszReaderNames,
LPDWORD pcchReaderLen, LPDWORD pdwState,
LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
LONG retIndice, rv;
int i;
DWORD dwReaderLen;
SCF_Card_t SCF_hCard;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* Zero out everything */
retIndice = 0;
dwReaderLen = 0;
rv = 0;
i = 0;
/* Check for NULL parameters */
if (pcchReaderLen == NULL || pdwState == NULL ||
pdwProtocol == NULL || pcbAtrLen == NULL)
{
return SCARD_E_INVALID_PARAMETER;
}
retIndice = SCardGetHandleIndice(hCard);
rv = getCardForHandle(hCard, &SCF_hCard);
if (SCARD_S_SUCCESS != rv)
return rv;
dwReaderLen =
strlen(psReaderMap[psChannelMap[retIndice].ReaderIndice].ReaderName);
if (mszReaderNames == NULL)
{
*pcchReaderLen = dwReaderLen;
*pcbAtrLen = 0;
*pdwState = 0;
*pdwProtocol = 0;
return SCARD_S_SUCCESS;
}
if (*pcchReaderLen == 0)
{
*pcchReaderLen = dwReaderLen;
*pcbAtrLen = 0;
*pdwState = 0;
*pdwProtocol = 0;
return SCARD_S_SUCCESS;
}
if (*pcchReaderLen < dwReaderLen)
{
*pcchReaderLen = dwReaderLen;
*pcbAtrLen = 0;
*pdwState = 0;
*pdwProtocol = 0;
return SCARD_E_INSUFFICIENT_BUFFER;
}
*pcchReaderLen = dwReaderLen;
strcpy(mszReaderNames,
psReaderMap[psChannelMap[retIndice].ReaderIndice].ReaderName);
*pdwProtocol = SCARD_PROTOCOL_T0;
SCardEventLock();
if (!(psReaderMap[psChannelMap[retIndice].ReaderIndice].
dwCurrentState & SCARD_STATE_PRESENT))
{
*pdwState = SCARD_ABSENT;
SCardEventUnlock();
return SCARD_S_SUCCESS;
}
*pdwState = SCARD_NEGOTIABLE | SCARD_POWERED | SCARD_PRESENT;
rv = PCSC_SCF_getATR(SCF_hCard, pbAtr, pcbAtrLen);
if (SCARD_S_SUCCESS == rv)
{
/*referesh the Atr in the reader Map */
psReaderMap[psChannelMap[retIndice].ReaderIndice].dwAtrLength =
*pcbAtrLen;
memcpy(psReaderMap[psChannelMap[retIndice].ReaderIndice].bAtr, pbAtr,
*pcbAtrLen);
}
SCardEventUnlock();
return SCARD_S_SUCCESS;
}
LONG SCardStatus(SCARDHANDLE hCard, LPSTR mszReaderNames,
LPDWORD pcchReaderLen, LPDWORD pdwState,
LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
long rv;
SCardLockThread();
rv = SCardStatusTH(hCard, mszReaderNames, pcchReaderLen, pdwState,
pdwProtocol, pbAtr, pcbAtrLen);
SCardUnlockThread();
return rv;
}
LONG SCardGetStatusChange(SCARDCONTEXT hContext, DWORD dwTimeout,
LPSCARD_READERSTATE_A rgReaderStates, DWORD cReaders)
{
LONG rv, retIndice, readerIndice;
PSCARD_READERSTATE_A currReader;
PREADER_STATE rContext;
LPSTR lpcReaderName;
DWORD dwTime;
DWORD dwState;
DWORD dwBreakFlag;
int i, j;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* Zero out everything */
rv = 0;
rContext = 0;
lpcReaderName = 0;
dwTime = 0;
j = 0;
dwState = 0;
i = 0;
currReader = 0;
retIndice = 0;
readerIndice = 0;
dwBreakFlag = 0;
if (rgReaderStates == NULL && cReaders > 0)
return SCARD_E_INVALID_PARAMETER;
if (cReaders < 0)
return SCARD_E_INVALID_VALUE;
/* change by najam */
SCardLockThread();
retIndice = SCardGetContextIndice(hContext);
/* change by najam */
SCardUnlockThread();
if (retIndice == -1)
return SCARD_E_INVALID_HANDLE;
/* Application is waiting for a reader -
return the first available reader
*/
if (cReaders == 0)
{
for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
{
if (psReaderMap[i].ReaderName)
return SCARD_S_SUCCESS;
}
return SCARD_E_READER_UNAVAILABLE;
}
else if (cReaders > PCSCLITE_MAX_READERS_CONTEXTS)
{
return SCARD_E_INVALID_VALUE;
}
/* Check the integrity of the reader states structures */
for (j = 0; j < cReaders; j++)
{
currReader = &rgReaderStates[j];
if (currReader->szReader == NULL)
{
return SCARD_E_INVALID_VALUE;
}
}
/* End of search for readers */
/* Clear the event state for all readers */
for (j = 0; j < cReaders; j++)
{
currReader = &rgReaderStates[j];
currReader->dwEventState = 0;
}
/* Now is where we start our event checking loop */
psContextMap[retIndice].contextBlockStatus = BLOCK_STATUS_BLOCKING;
j = 0;
do
{
SYS_USleep(10);
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
currReader = &rgReaderStates[j];
/************ Look for IGNORED readers ****************************/
if (currReader->dwCurrentState & SCARD_STATE_IGNORE)
{
currReader->dwEventState = SCARD_STATE_IGNORE;
}
else
{
/************ Looks for correct readernames *********************/
lpcReaderName = (char *) currReader->szReader;
readerIndice = SCardGetReaderIndice(lpcReaderName);
/* The requested reader name is not recognized */
if (0 > readerIndice)
{
if (currReader->dwCurrentState & SCARD_STATE_UNKNOWN)
{
currReader->dwEventState = SCARD_STATE_UNKNOWN;
}
else
{
currReader->dwEventState =
SCARD_STATE_UNKNOWN | SCARD_STATE_CHANGED;
/* Spec says use SCARD_STATE_IGNORE but a removed USB reader
with eventState fed into currentState will be ignored forever */
dwBreakFlag = 1;
}
}
else
{
/* The reader has come back after being away */
if (currReader->dwCurrentState & SCARD_STATE_UNKNOWN)
{
currReader->dwEventState |= SCARD_STATE_CHANGED;
currReader->dwEventState &= ~SCARD_STATE_UNKNOWN;
dwBreakFlag = 1;
}
/*****************************************************************/
SCardEventLock();
/* Now we check all the Reader States */
dwState = psReaderMap[readerIndice].dwCurrentState;
/*********** Check if the reader is in the correct state ********/
if (dwState & SCARD_STATE_UNKNOWN)
{
/* App thinks reader is in bad state and it is */
if (currReader->dwCurrentState & SCARD_STATE_UNAVAILABLE)
{
currReader->dwEventState = SCARD_STATE_UNAVAILABLE;
}
else
{
/* App thinks reader is in good state and it is not */
currReader->dwEventState = SCARD_STATE_CHANGED |
SCARD_STATE_UNAVAILABLE;
dwBreakFlag = 1;
}
}
else
{
/* App thinks reader in bad state but it is not */
if (currReader->dwCurrentState & SCARD_STATE_UNAVAILABLE)
{
currReader->dwEventState &= ~SCARD_STATE_UNAVAILABLE;
currReader->dwEventState |= SCARD_STATE_CHANGED;
dwBreakFlag = 1;
}
}
/********** Check for card presence in the reader **************/
if (dwState & SCARD_STATE_PRESENT)
{
currReader->cbAtr = psReaderMap[readerIndice].dwAtrLength;
memcpy(currReader->rgbAtr, psReaderMap[readerIndice].bAtr,
currReader->cbAtr);
}
else
{
currReader->cbAtr = 0;
}
/* Card is now absent */
if (dwState & SCARD_STATE_EMPTY)
{
currReader->dwEventState |= SCARD_STATE_EMPTY;
currReader->dwEventState &= ~SCARD_STATE_PRESENT;
currReader->dwEventState &= ~SCARD_STATE_UNAWARE;
currReader->dwEventState &= ~SCARD_STATE_IGNORE;
currReader->dwEventState &= ~SCARD_STATE_UNKNOWN;
currReader->dwEventState &= ~SCARD_STATE_UNAVAILABLE;
currReader->dwEventState &= ~SCARD_STATE_ATRMATCH;
currReader->dwEventState &= ~SCARD_STATE_MUTE;
currReader->dwEventState &= ~SCARD_STATE_INUSE;
/* After present the rest are assumed */
if (currReader->dwCurrentState & SCARD_STATE_PRESENT ||
currReader->dwCurrentState & SCARD_STATE_ATRMATCH ||
currReader->dwCurrentState & SCARD_STATE_EXCLUSIVE ||
currReader->dwCurrentState & SCARD_STATE_INUSE)
{
currReader->dwEventState |= SCARD_STATE_CHANGED;
dwBreakFlag = 1;
}
/* Card is now present */
}
else if (dwState & SCARD_STATE_PRESENT)
{
currReader->dwEventState |= SCARD_STATE_PRESENT;
currReader->dwEventState &= ~SCARD_STATE_EMPTY;
currReader->dwEventState &= ~SCARD_STATE_UNAWARE;
currReader->dwEventState &= ~SCARD_STATE_IGNORE;
currReader->dwEventState &= ~SCARD_STATE_UNKNOWN;
currReader->dwEventState &= ~SCARD_STATE_UNAVAILABLE;
currReader->dwEventState &= ~SCARD_STATE_MUTE;
if (currReader->dwCurrentState & SCARD_STATE_EMPTY)
{
currReader->dwEventState |= SCARD_STATE_CHANGED;
dwBreakFlag = 1;
}
/* TODO */
if (0 && dwState & SCARD_SWALLOWED)
{
if (currReader->dwCurrentState & SCARD_STATE_MUTE)
{
currReader->dwEventState |= SCARD_STATE_MUTE;
}
else
{
currReader->dwEventState |= SCARD_STATE_MUTE;
if (currReader->dwCurrentState !=
SCARD_STATE_UNAWARE)
{
currReader->dwEventState |=
SCARD_STATE_CHANGED;
}
dwBreakFlag = 1;
}
}
else
{
/* App thinks card is mute but it is not */
if (currReader->dwCurrentState & SCARD_STATE_MUTE)
{
currReader->dwEventState |= SCARD_STATE_CHANGED;
dwBreakFlag = 1;
}
}
}
if (-1 == psReaderMap[readerIndice].SharedRefCount)
{
currReader->dwEventState |= SCARD_STATE_EXCLUSIVE;
currReader->dwEventState &= ~SCARD_STATE_INUSE;
if (!currReader->dwCurrentState & SCARD_STATE_EXCLUSIVE)
{
currReader->dwEventState |= SCARD_STATE_CHANGED;
dwBreakFlag = 1;
}
}
else if (psReaderMap[readerIndice].SharedRefCount >= 1)
{
/* A card must be inserted for it to be INUSE */
if (dwState & SCARD_STATE_PRESENT)
{
currReader->dwEventState |= SCARD_STATE_INUSE;
currReader->dwEventState &= ~SCARD_STATE_EXCLUSIVE;
if (!currReader->dwCurrentState & SCARD_STATE_INUSE)
{
currReader->dwEventState |= SCARD_STATE_CHANGED;
dwBreakFlag = 1;
}
}
}
SCardEventUnlock();
if (currReader->dwCurrentState == SCARD_STATE_UNAWARE)
{
/* Break out of the while .. loop and return status
once all the status's for all readers is met */
dwBreakFlag = 1;
}
SYS_USleep(PCSCLITE_STATUS_WAIT);
} /* End of SCARD_STATE_UNKNOWN */
} /* End of SCARD_STATE_IGNORE */
/* Counter and resetter */
j = j + 1;
if (j == cReaders)
j = 0;
if (dwTimeout != INFINITE && dwTimeout != 0)
{
dwTime += PCSCLITE_STATUS_WAIT;
/* If time is greater than timeout and all readers have been
checked
*/
if ((dwTime >= (dwTimeout * 1000)) && (j == 0))
{
return SCARD_E_TIMEOUT;
}
}
/* Declare all the break conditions */
/* TODO think about this */
if (psContextMap[retIndice].contextBlockStatus == BLOCK_STATUS_RESUME)
break;
/* Break if UNAWARE is set and all readers have been checked */
if ((dwBreakFlag == 1) && (j == 0))
break;
/*
* Solve the problem of never exiting the loop when a smartcard is
* already inserted in the reader, thus blocking the application
* (patch proposed by Serge Koganovitsch)
*/
if ((dwTimeout == 0) && (j == 0))
break;
}
while (1); /* end of do */
if (psContextMap[retIndice].contextBlockStatus == BLOCK_STATUS_RESUME)
{
return SCARD_E_CANCELLED;
}
return SCARD_S_SUCCESS;
}
LONG SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID pbSendBuffer,
DWORD cbSendLength, LPVOID pbRecvBuffer, DWORD cbRecvLength,
LPDWORD lpBytesReturned)
{
/* TODO */
return SCARD_S_SUCCESS;
}
static LONG SCardTransmitTH(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci,
LPCBYTE pbSendBuffer, DWORD cbSendLength,
LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength)
{
BYTE Buffer[MAX_BUFFER_SIZE];
LONG rv = 0;
SCF_Card_t SCF_hCard;
SCF_Status_t status;
LONG retIndice;
LONG localRecvLen = MAX_BUFFER_SIZE;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
if (pbSendBuffer == NULL || pbRecvBuffer == NULL ||
pcbRecvLength == NULL || pioSendPci == NULL)
{
return SCARD_E_INVALID_PARAMETER;
}
rv = getCardForHandle(hCard, &SCF_hCard);
if (rv != SCARD_S_SUCCESS)
return rv;
if ((cbSendLength > MAX_BUFFER_SIZE) || (*pcbRecvLength < 2))
return SCARD_E_INSUFFICIENT_BUFFER;
/* TODO which protocols to support */
/* if(pioSendPci && pioSendPci->dwProtocol) { */
retIndice = SCardGetHandleIndice(hCard);
if ((pbSendBuffer[1] == 0xC0) &&
psTransmitMap[retIndice].isResponseCached)
{
if (*pcbRecvLength < psTransmitMap[retIndice].bufferLength)
{
*pcbRecvLength = psTransmitMap[retIndice].bufferLength;
return SCARD_E_INSUFFICIENT_BUFFER;
}
*pcbRecvLength = psTransmitMap[retIndice].bufferLength;
memcpy(pbRecvBuffer, psTransmitMap[retIndice].Buffer,
psTransmitMap[retIndice].bufferLength);
if (pioRecvPci && pioSendPci)
pioRecvPci->dwProtocol = pioSendPci->dwProtocol;
return SCARD_S_SUCCESS;
}
else
{
psTransmitMap[retIndice].isResponseCached = 0;
}
status = SCF_Card_exchangeAPDU(SCF_hCard,
(const uint8_t *) pbSendBuffer, (size_t) cbSendLength,
(uint8_t *) Buffer, (size_t *) & localRecvLen);
if ((cbSendLength > 5) && (localRecvLen > 2))
{
if (SCF_STATUS_SUCCESS == status)
{
*pcbRecvLength = 2;
pbRecvBuffer[0] = 0x61;
pbRecvBuffer[1] = localRecvLen - 2;
psTransmitMap[retIndice].isResponseCached = TRUE;
psTransmitMap[retIndice].bufferLength = localRecvLen;
memcpy(psTransmitMap[retIndice].Buffer, Buffer,
psTransmitMap[retIndice].bufferLength);
if (pioRecvPci && pioSendPci)
pioRecvPci->dwProtocol = pioSendPci->dwProtocol;
return SCARD_S_SUCCESS;
}
}
else
{
if (SCF_STATUS_SUCCESS == status)
{
if (*pcbRecvLength < localRecvLen)
{
*pcbRecvLength = localRecvLen;
return SCARD_E_INSUFFICIENT_BUFFER;
}
*pcbRecvLength = localRecvLen;
memcpy(pbRecvBuffer, Buffer, *pcbRecvLength);
}
}
/* TODO fill the received Pci ... */
/* For now just filling the send pci protocol. */
if (pioRecvPci && pioSendPci)
pioRecvPci->dwProtocol = pioSendPci->dwProtocol;
rv = ConvertStatus(status);
return rv;
}
LONG SCardTransmit(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci,
LPCBYTE pbSendBuffer, DWORD cbSendLength,
LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength)
{
long rv;
SCardLockThread();
rv = SCardTransmitTH(hCard, pioSendPci, pbSendBuffer, cbSendLength,
pioRecvPci, pbRecvBuffer, pcbRecvLength);
SCardUnlockThread();
return rv;
}
static LONG SCardListReaderGroupsTH(SCARDCONTEXT hContext, LPSTR mszGroups,
LPDWORD pcchGroups)
{
LONG rv = SCARD_S_SUCCESS;
const char ReaderGroup[] = "SCard$DefaultReaders";
const int dwGroups = strlen(ReaderGroup) + 2;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
/* Make sure this context has been opened */
if (SCardGetContextIndice(hContext) == -1)
{
return SCARD_E_INVALID_HANDLE;
}
if (mszGroups)
{
if (*pcchGroups < dwGroups)
rv = SCARD_E_INSUFFICIENT_BUFFER;
else
{
memset(mszGroups, 0, dwGroups);
memcpy(mszGroups, ReaderGroup, strlen(ReaderGroup));
}
}
*pcchGroups = dwGroups;
return rv;
}
LONG SCardListReaderGroups(SCARDCONTEXT hContext, LPSTR mszGroups,
LPDWORD pcchGroups)
{
long rv;
SCardLockThread();
rv = SCardListReaderGroupsTH(hContext, mszGroups, pcchGroups);
SCardUnlockThread();
return rv;
}
static LONG SCardCancelTH(SCARDCONTEXT hContext)
{
LONG hContextIndice;
if (SCARD_S_SUCCESS != isOCFServerRunning())
return SCARD_E_NO_SERVICE;
hContextIndice = SCardGetContextIndice(hContext);
if (hContextIndice == -1)
return SCARD_E_INVALID_HANDLE;
/* Set the block status for this Context so blocking calls will complete */
psContextMap[hContextIndice].contextBlockStatus = BLOCK_STATUS_RESUME;
return SCARD_S_SUCCESS;
}
LONG SCardCancel(SCARDCONTEXT hContext)
{
long rv;
SCardLockThread();
rv = SCardCancelTH(hContext);
SCardUnlockThread();
return rv;
}
LONG SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,
LPDWORD pcbAttrLen)
{
return SCARD_E_NOT_TRANSACTED;
}
LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr,
DWORD cbAttrLen)
{
return SCARD_E_NOT_TRANSACTED;
}
static LONG SCardGetHandleIndice(SCARDHANDLE hCard)
{
int i = 0;
static int LastIndex = 0;
if (hCard == 0)
return -1;
if (psChannelMap[LastIndex].PCSC_hCard == hCard)
return LastIndex;
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if (hCard == psChannelMap[i].PCSC_hCard)
return i;
}
return -1;
}
static LONG SCardGetReaderIndice(LPCSTR ReaderName)
{
int i = 0;
if (NULL == ReaderName)
return -1;
for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
{
if ((NULL != psReaderMap[i].ReaderName) &&
(strncmp(psReaderMap[i].ReaderName, ReaderName,
strlen(psReaderMap[i].ReaderName)) == 0))
{
return i;
}
}
return -1;
}
static LONG SCardAddHandle(SCARDHANDLE PCSC_hCard, SCARDCONTEXT hContext,
SCF_Session_t hSession, SCF_Terminal_t hTerminal,
SCF_Card_t SCF_hCard, int ReaderIndice, DWORD dwShareMode)
{
int i = 0;
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if (psChannelMap[i].PCSC_hCard == 0)
{
psChannelMap[i].PCSC_hCard = PCSC_hCard;
psChannelMap[i].hContext = hContext;
psChannelMap[i].hSession = hSession;
psChannelMap[i].hTerminal = hTerminal;
psChannelMap[i].SCF_hCard = SCF_hCard;
psChannelMap[i].ReaderIndice = ReaderIndice;
SCardEventLock();
if (SCARD_SHARE_EXCLUSIVE == dwShareMode)
{
psChannelMap[i].haveLock = TRUE;
psReaderMap[ReaderIndice].SharedRefCount = -1;
}
else
{
psReaderMap[ReaderIndice].SharedRefCount++;
psReaderMap[ReaderIndice].dwCurrentState |= SCARD_STATE_INUSE;
}
PCSC_SCF_getATR(SCF_hCard, psReaderMap[ReaderIndice].bAtr,
&psReaderMap[ReaderIndice].dwAtrLength);
SCardEventUnlock();
return SCARD_S_SUCCESS;
}
}
return SCARD_E_NO_MEMORY;
}
static LONG PCSC_SCF_getATR(SCF_Card_t hCard, LPBYTE pcbAtr,
LPDWORD pcbAtrLen)
{
SCF_Status_t status;
struct SCF_BinaryData_t *pAtr;
status = SCF_Card_getInfo(hCard, "atr", &pAtr);
if (SCF_STATUS_SUCCESS != status)
return SCARD_F_COMM_ERROR;
if ((NULL == pcbAtr) || (NULL == pcbAtrLen) ||
(MAX_ATR_SIZE < pAtr->length))
{
if (NULL != pcbAtrLen)
*pcbAtrLen = pAtr->length;
SCF_Card_freeInfo(hCard, pAtr);
return SCARD_E_INSUFFICIENT_BUFFER;
}
*pcbAtrLen = pAtr->length;
memcpy(pcbAtr, pAtr->data, pAtr->length);
SCF_Card_freeInfo(hCard, pAtr);
return SCARD_S_SUCCESS;
}
static LONG SCardRemoveHandle(SCARDHANDLE hCard)
{
LONG retIndice = 0;
retIndice = SCardGetHandleIndice(hCard);
if (retIndice == -1)
{
return SCARD_E_INVALID_HANDLE;
}
SCardEventLock();
SCF_Session_close(psChannelMap[retIndice].hSession);
psChannelMap[retIndice].PCSC_hCard = 0;
psChannelMap[retIndice].hContext = 0;
psChannelMap[retIndice].hSession = NULL;
psChannelMap[retIndice].hTerminal = NULL;
psChannelMap[retIndice].SCF_hCard = NULL;
psChannelMap[retIndice].isReset = 0;
if (psChannelMap[retIndice].haveLock)
{
psChannelMap[retIndice].haveLock = FALSE;
psReaderMap[psChannelMap[retIndice].ReaderIndice].SharedRefCount = 0;
}
else
{
psReaderMap[psChannelMap[retIndice].ReaderIndice].SharedRefCount--;
if (0 >=
psReaderMap[psChannelMap[retIndice].ReaderIndice].SharedRefCount)
{
psReaderMap[psChannelMap[retIndice].ReaderIndice].SharedRefCount =
0;
psReaderMap[psChannelMap[retIndice].ReaderIndice].
dwCurrentState &=
(~(SCARD_STATE_EXCLUSIVE | SCARD_STATE_INUSE));
}
}
psChannelMap[retIndice].ReaderIndice = 0;
SCardEventUnlock();
return SCARD_S_SUCCESS;
}
static LONG getCardForHandle(SCARDHANDLE PCSC_hCard, SCF_Card_t * SCF_hCard)
{
int retIndice = 0;
retIndice = SCardGetHandleIndice(PCSC_hCard);
if (0 > retIndice)
return SCARD_E_INVALID_HANDLE;
*SCF_hCard = psChannelMap[retIndice].SCF_hCard;
if (NULL == *SCF_hCard)
return SCARD_E_INVALID_HANDLE;
SCardEventLock();
if (psChannelMap[retIndice].isReset)
{
SCardEventUnlock();
return SCARD_W_RESET_CARD;
}
SCardEventUnlock();
return SCARD_S_SUCCESS;
}
static LONG getNewHandle(SCARDCONTEXT hContext, LPCSTR szReader,
SCARDHANDLE * phCard, DWORD dwShareMode)
{
long rv = 0, ReaderIndice;
SCF_Status_t status;
SCF_Session_t hSession;
SCF_Terminal_t hTerminal;
SCF_Card_t SCF_hCard;
ReaderIndice = SCardGetReaderIndice(szReader);
if (-1 == ReaderIndice)
return SCARD_E_UNKNOWN_READER;
SCardEventLock();
if ((psReaderMap[ReaderIndice].SharedRefCount == -1) ||
((SCARD_SHARE_EXCLUSIVE == dwShareMode) &&
psReaderMap[ReaderIndice].SharedRefCount))
{
SCardEventUnlock();
return SCARD_E_SHARING_VIOLATION;
}
SCardEventUnlock();
status = SCF_Session_getSession(&hSession);
if (SCF_STATUS_SUCCESS != status)
{
return ConvertStatus(status);
}
status = SCF_Session_getTerminal(hSession, szReader, &hTerminal);
if (SCF_STATUS_SUCCESS != status)
{
SCF_Session_close(hSession);
return ConvertStatus(status);
}
status = SCF_Terminal_getCard(hTerminal, &SCF_hCard);
if (SCF_STATUS_SUCCESS != status)
{
SCF_Session_close(hSession);
return ConvertStatus(status);
}
if (SCARD_SHARE_EXCLUSIVE == dwShareMode)
{
status = SCF_Card_lock(SCF_hCard, 0);
if (status != SCF_STATUS_SUCCESS)
{
SCF_Session_close(hSession);
return SCARD_E_SHARING_VIOLATION;
}
}
while (1)
{
*phCard = (PCSCLITE_SVC_IDENTITY + SYS_RandomInt(1, 65535));
if (SCardGetHandleIndice(*phCard) == -1)
break;
}
rv = SCardAddHandle(*phCard, hContext, hSession,
hTerminal, SCF_hCard, ReaderIndice, dwShareMode);
if (SCARD_S_SUCCESS != rv)
{
SCF_Session_close(hSession);
return rv;
}
return SCARD_S_SUCCESS;
}
/*
Function Managing Terminals for Sessions
*/
/*
Functions for managing instances of SCardEstablishContext
These functions keep track of Context handles and associate
the blocking variable contextBlockStatus to an hContext
*/
static LONG getNewContext(SCARDCONTEXT * phContext)
{
LONG rv;
SCF_Session_t hSession = NULL;
SCF_Status_t status;
status = SCF_Session_getSession(&hSession);
if (status != SCF_STATUS_SUCCESS)
return SCARD_E_NO_SERVICE;
while (1)
{
*phContext = (PCSCLITE_SVC_IDENTITY + SYS_RandomInt(1, 65535));
if (-1 == SCardGetContextIndice(*phContext))
break;
}
rv = SCardAddContext(*phContext, hSession);
if (SCARD_S_SUCCESS != rv)
{
SCF_Session_close(hSession);
}
return rv;
}
static LONG SCardAddContext(SCARDCONTEXT hContext, SCF_Session_t hSession)
{
int i;
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if (psContextMap[i].hContext == 0)
{
psContextMap[i].hContext = hContext;
psContextMap[i].hSession = hSession;
psContextMap[i].contextBlockStatus = BLOCK_STATUS_RESUME;
return SCARD_S_SUCCESS;
}
}
return SCARD_E_NO_MEMORY;
}
static LONG SCardGetContextIndice(SCARDCONTEXT hContext)
{
int i;
/* Find this context and return it's spot in the array */
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if ((hContext == psContextMap[i].hContext) && (hContext != 0))
{
return i;
}
}
return -1;
}
static LONG SCardRemoveContext(SCARDCONTEXT hContext)
{
LONG retIndice;
int i = 0;
retIndice = 0;
retIndice = SCardGetContextIndice(hContext);
if (retIndice == -1)
{
return SCARD_E_INVALID_HANDLE;
}
else
{
/* Free all handles for this context. */
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if (psChannelMap[i].hContext == hContext)
{
SCardRemoveHandle(psChannelMap[i].PCSC_hCard);
}
}
SCF_Session_close(psContextMap[retIndice].hSession);
psContextMap[retIndice].hContext = 0;
psContextMap[retIndice].hSession = NULL;
psContextMap[retIndice].contextBlockStatus = BLOCK_STATUS_RESUME;
}
return SCARD_S_SUCCESS;
}
static SCF_Session_t getSessionForContext(SCARDCONTEXT hContext)
{
LONG retIndice;
retIndice = 0;
retIndice = SCardGetContextIndice(hContext);
if (retIndice == -1)
return NULL;
return (psContextMap[retIndice].hSession);
}
/* This function locks a mutex so another thread
must wait to use this function
*/
LONG SCardLockThread(void)
{
return SYS_MutexLock(&clientMutex);
}
LONG SCardEventLock(void)
{
return SYS_MutexLock(&EventMutex);
}
/* This function unlocks a mutex so another thread
may use the client library
*/
LONG SCardUnlockThread(void)
{
return SYS_MutexUnLock(&clientMutex);
}
LONG SCardEventUnlock(void)
{
return SYS_MutexUnLock(&EventMutex);
}
static LONG isActiveContextPresent(void)
{
long fActiveContext = FALSE;
int i;
for (i=0; i<PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if (psContextMap[i].hContext != 0)
{
fActiveContext = TRUE;
break;
}
}
return fActiveContext;
}
static void EventCallback(SCF_Event_t eventType, SCF_Terminal_t hTerm,
void *cbdata)
{
static char bInitialized = 0;
int i = 0;
int ReaderIndice = 0;
SCF_Card_t hCard;
SCF_Status_t status;
#if 0
struct _psReaderMap *readerMap;
readerMap = (struct _psReaderMap *) cbdata;
#endif
ReaderIndice = (int) cbdata;
SCardEventLock();
switch (eventType)
{
case SCF_EVENT_CARDINSERTED:
case SCF_EVENT_CARDPRESENT:
#if 0
printf("card present dwState = %x\n",
psReaderMap[ReaderIndice].dwCurrentState);
#endif
psReaderMap[ReaderIndice].dwCurrentState &=
(~(SCARD_STATE_UNKNOWN | SCARD_STATE_UNAVAILABLE |
SCARD_STATE_EMPTY));
psReaderMap[ReaderIndice].dwCurrentState |= SCARD_STATE_PRESENT;
#if 0
printf("card present post dwState = %x\n",
psReaderMap[ReaderIndice].dwCurrentState);
#endif
/* TODO get the ATR... filled */
status = SCF_Terminal_getCard(psReaderMap[ReaderIndice].hTerminal,
&hCard);
if (SCF_STATUS_SUCCESS == status)
{
#if 0
printf("Setting ATR...\n");
#endif
PCSC_SCF_getATR(hCard, psReaderMap[ReaderIndice].bAtr,
&psReaderMap[ReaderIndice].dwAtrLength);
#if 0
printf("Atrlen = %d\n", psReaderMap[ReaderIndice].dwAtrLength);
#endif
}
SCF_Card_close(hCard);
break;
case SCF_EVENT_CARDREMOVED:
case SCF_EVENT_CARDABSENT:
#if 0
printf("card absent dwState = %x\n",
psReaderMap[ReaderIndice].dwCurrentState);
#endif
psReaderMap[ReaderIndice].dwCurrentState &= (~(SCARD_STATE_PRESENT |
SCARD_STATE_EXCLUSIVE |
SCARD_STATE_INUSE |
SCARD_STATE_MUTE | SCARD_STATE_UNAVAILABLE));
psReaderMap[ReaderIndice].dwCurrentState |= SCARD_STATE_EMPTY;
psReaderMap[ReaderIndice].SharedRefCount = 0;
psReaderMap[ReaderIndice].dwAtrLength = 0;
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if ((0 != psChannelMap[i].PCSC_hCard) &&
(psChannelMap[i].ReaderIndice == ReaderIndice))
{
psChannelMap[i].haveLock = FALSE;
}
}
#if 0
printf("card absent dwState = %x\n",
psReaderMap[ReaderIndice].dwCurrentState);
#endif
break;
case SCF_EVENT_TERMINALCLOSED:
/* TODO .... */
break;
case SCF_EVENT_CARDRESET:
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if ((0 != psChannelMap[i].PCSC_hCard) &&
(psChannelMap[i].ReaderIndice == ReaderIndice))
{
psChannelMap[i].isReset = TRUE;
}
}
break;
default:
break;
} /* switch */
/*
* The OCF Server always calls the registered callback function
* immediately after the callback function is registered,
* but always with the state of SCF_EVENT_CARDABSENT even if
* there is a card present in the reader, the OCF server then
* calls the callback the second time with the correct state,
* that is the reason for the check if (bInitialized == 2).
* If there is no card present in the reader the PCSC_SCF_Initialize's
* pthread_cond_timedwait times out after 2 secs.
*/
if (bInitialized < 2)
{
bInitialized++;
if (2 == bInitialized)
pthread_cond_signal(&EventCondition);
}
SCardEventUnlock();
}
static LONG isOCFServerRunning(void)
{
static int isRunning = TRUE;
SCF_Status_t status;
SCF_Session_t hSession;
if (FALSE == isRunning)
return SCARD_E_NO_SERVICE;
status = SCF_Session_getSession(&hSession);
if (SCF_STATUS_SUCCESS != status)
{
isRunning = FALSE;
return SCARD_E_NO_SERVICE;
}
SCF_Session_close(hSession);
return SCARD_S_SUCCESS;
}
static LONG PCSC_SCF_Initialize(void)
{
SCF_Status_t status;
char **tList = NULL;
int i;
if (PCSC_Initialized)
return SCARD_S_SUCCESS;
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
psContextMap[i].hContext = 0;
psContextMap[i].hSession = 0;
psContextMap[i].contextBlockStatus = BLOCK_STATUS_RESUME;
psChannelMap[i].PCSC_hCard = 0;
psChannelMap[i].SCF_hCard = 0;
psChannelMap[i].hTerminal = 0;
psChannelMap[i].hContext = 0;
psChannelMap[i].hSession = 0;
psChannelMap[i].haveLock = 0;
psChannelMap[i].isReset = 0;
psChannelMap[i].ReaderIndice = 0;
psTransmitMap[i].isResponseCached = 0;
psTransmitMap[i].bufferLength = 0;
}
for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
{
psReaderMap[i].ReaderName = NULL;
psReaderMap[i].hTerminal = 0;
psReaderMap[i].SharedRefCount = 0;
psReaderMap[i].dwCurrentState |= SCARD_STATE_UNAVAILABLE;
psReaderMap[i].dwAtrLength = 0;
memset(psReaderMap[i].bAtr, 0, MAX_ATR_SIZE);
psReaderMap[i].lHandle = NULL;
}
status = SCF_Session_getSession(&g_hSession);
if (status != SCF_STATUS_SUCCESS)
return SCARD_E_NO_SERVICE;
status = SCF_Session_getInfo(g_hSession, "terminalnames", &tList);
if (status != SCF_STATUS_SUCCESS)
return SCARD_E_NO_SERVICE;
for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)
{
if (NULL == tList[i])
break;
psReaderMap[i].ReaderName = strdup(tList[i]);
status =
SCF_Session_getTerminal(g_hSession, psReaderMap[i].ReaderName,
&psReaderMap[i].hTerminal);
if (status != SCF_STATUS_SUCCESS)
continue;
status =
SCF_Terminal_addEventListener(psReaderMap[i].hTerminal,
SCF_EVENT_ALL, EventCallback, (void *) i,
&psReaderMap[i].lHandle);
if (status != SCF_STATUS_SUCCESS)
{
SCF_Terminal_close(psReaderMap[i].hTerminal);
psReaderMap[i].hTerminal = NULL;
}
}
SCF_Session_freeInfo(g_hSession, tList);
SYS_MutexLock(&SCFInitMutex);
/* wait for ocfserver to initialize... or 2 secs whichever is earlier */
{
struct timeval currTime;
struct timespec absTime;
gettimeofday(&currTime, NULL);
/* Calculate absolute time to time out */
absTime.tv_sec = currTime.tv_sec + 2;
absTime.tv_nsec = currTime.tv_usec*1000;
pthread_cond_timedwait(&EventCondition, &SCFInitMutex, &absTime);
}
SYS_MutexUnLock(&SCFInitMutex);
PCSC_Initialized = 1;
return SCARD_S_SUCCESS;
}
static LONG ConvertStatus(SCF_Status_t status)
{
switch (status)
{
case SCF_STATUS_COMMERROR:
return SCARD_F_COMM_ERROR;
case SCF_STATUS_FAILED:
return SCARD_F_INTERNAL_ERROR;
case SCF_STATUS_BADHANDLE:
return SCARD_E_INVALID_HANDLE;
case SCF_STATUS_UNKNOWNPROPERTY:
return SCARD_F_UNKNOWN_ERROR;
case SCF_STATUS_BADARGS:
return SCARD_E_INVALID_VALUE;
case SCF_STATUS_BADTERMINAL:
return SCARD_E_READER_UNAVAILABLE;
case SCF_STATUS_NOCARD:
return SCARD_E_NO_SMARTCARD;
case SCF_STATUS_CARDREMOVED:
return SCARD_W_REMOVED_CARD;
case SCF_STATUS_TIMEOUT:
return SCARD_E_TIMEOUT;
#if 0
case SCF_STATUS_DOUBLELOCK:
/* TODO */
break;
#endif
case SCF_STATUS_CARDLOCKED:
return SCARD_E_SHARING_VIOLATION;
case SCF_STATUS_NOSPACE:
return SCARD_E_NO_MEMORY;
case SCF_STATUS_SUCCESS:
return SCARD_S_SUCCESS;
}
return SCARD_F_UNKNOWN_ERROR;
}
/*
* Note that this function is not used
*/
LONG SCardCheckReaderAvailability(LPSTR readerName, LONG errorCode)
{
#if 0
LONG retIndice;
int i;
retIndice = 0;
i = 0;
if (errorCode != SCARD_S_SUCCESS)
{
for (i = 0; i < PCSCLITE_MAX_APPLICATION_CONTEXTS; i++)
{
if (strcmp(psChannelMap[i].readerName, readerName) == 0)
{
return errorCode;
}
}
return SCARD_E_READER_UNAVAILABLE;
}
else
{
return SCARD_S_SUCCESS;
}
#endif
return 0;
}
/*
* free resources allocated by the library
* You _shall_ call this function if you use dlopen/dlclose to load/unload the
* library. Otherwise you will exhaust the ressources available.
*/
void SCardUnload(void)
{
int i=0;
#if 0
if (!isExecuted)
return;
SHMClientCloseSession();
SYS_CloseFile(mapAddr);
isExecuted = 0;
#endif
/*
* Cleanup only if PCSC has been initialized and there are no active
* context. Checking for active context is critical when libpcsclite is
* linked with multiple modules. for eg. an application links with
* pcsclite and a PAM module also links with pcsclite, when the PAM is
* unloaded from memory and if it calls SCardUnload, pcsclite will
* un-initialize even though there are active references from the
* application. Now, why dont we add SCardUnload to the array of functions
* to be called on unload (-zfiniarray=SCUnload), well, that does not seem
* to solve the problem, SCardUnload is called when PAM is unloaded from
* memory having the same impact that PCSC is uninitialized enen though
* there are active references.
*/
if((!PCSC_Initialized) || isActiveContextPresent())
return;
for(i=0; i<PCSCLITE_MAX_READERS_CONTEXTS; i++)
if (psReaderMap[i].hTerminal)
{
SCF_Terminal_removeEventListener(psReaderMap[i].hTerminal,
psReaderMap[i].lHandle);
SCF_Terminal_close(psReaderMap[i].hTerminal);
if (psReaderMap[i].ReaderName)
free(psReaderMap[i].ReaderName);
}
SCF_Session_close(g_hSession);
PCSC_Initialized = 0;
}
/*
* Note that this function is not used
*/
LONG SCardCheckDaemonAvailability(void)
{
LONG rv = 1; /* assume it exists */
if (rv == 0)
return SCARD_E_NO_SERVICE;
else
return SCARD_S_SUCCESS;
}
| 24.2468 | 82 | 0.725092 |
082099d016db269ec830e55a2658fd9b8c92c0ce | 892 | h | C | Applications/WebSheet/WebSheetRemoteAlertPresentationViewController.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 2 | 2021-11-02T09:23:27.000Z | 2022-03-28T08:21:57.000Z | Applications/WebSheet/WebSheetRemoteAlertPresentationViewController.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | null | null | null | Applications/WebSheet/WebSheetRemoteAlertPresentationViewController.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 1 | 2022-03-28T08:21:59.000Z | 2022-03-28T08:21:59.000Z | //
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#import <SpringBoardUIServices/SBUIRemoteAlertServiceViewController.h>
@interface WebSheetRemoteAlertPresentationViewController : SBUIRemoteAlertServiceViewController
{
}
- (void)viewDidAppear:(_Bool)arg1; // IMP=0x0000000100008f74
- (void)_willAppearInRemoteViewController; // IMP=0x0000000100008e84
- (_Bool)_shouldRemoveViewFromHierarchyOnDisappear; // IMP=0x0000000100008e7c
- (unsigned long long)supportedInterfaceOrientations; // IMP=0x0000000100008e74
- (void)handleHomeButtonPressed; // IMP=0x0000000100008e04
- (_Bool)shouldPresentInFullscreen; // IMP=0x0000000100008dfc
- (_Bool)shouldAutorotate; // IMP=0x0000000100008df4
- (void)dismissPresentationController:(_Bool)arg1; // IMP=0x0000000100008cc0
@end
| 37.166667 | 120 | 0.802691 |
0c39989ac5a8577aa595fd0cfb6e820766a2ca0b | 2,092 | h | C | System/Library/PrivateFrameworks/SiriActivation.framework/SASBoardServicesConfiguration.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 2 | 2021-11-02T09:23:27.000Z | 2022-03-28T08:21:57.000Z | System/Library/PrivateFrameworks/SiriActivation.framework/SASBoardServicesConfiguration.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/SiriActivation.framework/SASBoardServicesConfiguration.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 1 | 2022-03-28T08:21:59.000Z | 2022-03-28T08:21:59.000Z | /*
* This header is generated by classdump-dyld 1.5
* on Wednesday, October 27, 2021 at 3:17:42 PM Mountain Standard Time
* Operating System: Version 13.5.1 (Build 17F80)
* Image Source: /System/Library/PrivateFrameworks/SiriActivation.framework/SiriActivation
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
@class NSString;
@interface SASBoardServicesConfiguration : NSObject {
NSString* _machServiceIdentifier;
NSString* _presentationDomain;
NSString* _presentationIdentifier;
NSString* _signalDomain;
NSString* _signalIdentifier;
}
@property (nonatomic,retain) NSString * machServiceIdentifier; //@synthesize machServiceIdentifier=_machServiceIdentifier - In the implementation block
@property (nonatomic,retain) NSString * presentationDomain; //@synthesize presentationDomain=_presentationDomain - In the implementation block
@property (nonatomic,retain) NSString * presentationIdentifier; //@synthesize presentationIdentifier=_presentationIdentifier - In the implementation block
@property (nonatomic,retain) NSString * signalDomain; //@synthesize signalDomain=_signalDomain - In the implementation block
@property (nonatomic,retain) NSString * signalIdentifier; //@synthesize signalIdentifier=_signalIdentifier - In the implementation block
+(id)new;
+(id)configuration;
-(id)init;
-(id)_init;
-(NSString *)machServiceIdentifier;
-(id)identifierForService:(long long)arg1 ;
-(void)setPresentationIdentifier:(NSString *)arg1 ;
-(NSString *)presentationIdentifier;
-(void)setMachServiceIdentifier:(NSString *)arg1 ;
-(void)setPresentationDomain:(NSString *)arg1 ;
-(void)setSignalDomain:(NSString *)arg1 ;
-(void)setSignalIdentifier:(NSString *)arg1 ;
-(NSString *)presentationDomain;
-(NSString *)signalDomain;
-(NSString *)signalIdentifier;
-(id)domainForService:(long long)arg1 ;
@end
| 46.488889 | 167 | 0.713671 |
08de9be82779cf16f160852e4d123aff6ed8d75a | 2,241 | h | C | QtnProperty/Auxiliary/PropertyDelegateInfo.h | koala999cn/QtnProperty | e67ecf7fc8d36b1d976197f725a8897b0857d930 | [
"Apache-2.0"
] | 193 | 2019-05-30T13:43:31.000Z | 2022-03-30T04:47:51.000Z | QtnProperty/Auxiliary/PropertyDelegateInfo.h | koala999cn/QtnProperty | e67ecf7fc8d36b1d976197f725a8897b0857d930 | [
"Apache-2.0"
] | 32 | 2015-02-05T13:45:11.000Z | 2019-04-19T06:11:12.000Z | QtnProperty/Auxiliary/PropertyDelegateInfo.h | koala999cn/QtnProperty | e67ecf7fc8d36b1d976197f725a8897b0857d930 | [
"Apache-2.0"
] | 63 | 2015-02-05T15:38:00.000Z | 2019-05-23T07:32:15.000Z | /*******************************************************************************
Copyright (c) 2012-2016 Alex Zhondin <lexxmark.dev@gmail.com>
Copyright (c) 2015-2019 Alexandra Cherdantseva <neluhus.vagus@gmail.com>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*******************************************************************************/
#ifndef QTN_PROPERTY_DELEGATE_INFO_H
#define QTN_PROPERTY_DELEGATE_INFO_H
#include "QtnProperty/Config.h"
#include <QMap>
#include <QVariant>
struct QTN_IMPORT_EXPORT QtnPropertyDelegateInfo
{
QByteArray name;
using Attributes = QMap<QByteArray, QVariant>;
Attributes attributes;
QtnPropertyDelegateInfo() = default;
QtnPropertyDelegateInfo(const QtnPropertyDelegateInfo &other);
QtnPropertyDelegateInfo(
const QByteArray &name, const Attributes &attributes = Attributes());
template <typename T>
inline T getAttribute(
const QByteArray &attributeName, const T &defaultValue = T()) const
{
auto it = attributes.find(attributeName);
if (it == attributes.end())
return defaultValue;
return it.value().value<T>();
}
template <typename T>
inline bool loadAttribute(const QByteArray &name, T &to) const
{
auto it = attributes.find(name);
if (it == attributes.end())
return false;
to = it.value().value<T>();
return true;
}
template <typename OBJ_T, typename ATTR_T_RET, typename ATTR_T_ARG>
inline void storeAttributeValue(const QByteArray &name, OBJ_T *to,
ATTR_T_RET (OBJ_T::*get)() const, void (OBJ_T::*set)(ATTR_T_ARG)) const
{
Q_ASSERT(to);
(to->*set)(getAttribute(name, (to->*get)()));
}
};
struct QTN_IMPORT_EXPORT QtnSubPropertyInfo
{
int id;
QString key;
QByteArray displayNameAttr;
QByteArray descriptionAttr;
};
#endif // QTN_PROPERTY_DELEGATE_INFO_H
| 28.730769 | 80 | 0.70415 |
648c4df1ed537f7c73af76f95f7d02636e5154c0 | 14,547 | c | C | build_gnu/binutils/sim/ppc/hw_com.c | jed-frey/e200-gcc | df1421b421a8ec8729d70791129f5283dee5f9ea | [
"BSD-3-Clause"
] | 1 | 2017-05-31T21:42:12.000Z | 2017-05-31T21:42:12.000Z | build_gnu/binutils/sim/ppc/hw_com.c | jed-frey/e200-gcc | df1421b421a8ec8729d70791129f5283dee5f9ea | [
"BSD-3-Clause"
] | null | null | null | build_gnu/binutils/sim/ppc/hw_com.c | jed-frey/e200-gcc | df1421b421a8ec8729d70791129f5283dee5f9ea | [
"BSD-3-Clause"
] | 1 | 2019-12-17T22:04:07.000Z | 2019-12-17T22:04:07.000Z | /* This file is part of the program psim.
Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _HW_COM_C_
#define _HW_COM_C_
#ifndef STATIC_INLINE_HW_COM
#define STATIC_INLINE_HW_COM STATIC_INLINE
#endif
#include "device_table.h"
#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
/* DEVICE
com - '550 compatible serial device
DESCRIPTION
Models the basics of the 8 register '550 serial device. The model
includes an interrupt line, input and output fifos, and status
information.
Independent configuration of the devices input and output streams is
allowed: use either the console or a file (buffered or unbuffered) as
the data source/sink; specify the real-time delay between each character
transfer.
When the devices input stream is being taken from a file, the end of
file is signaled by a loss of carrier (the loss of carrier may be
incorrectly proceeded by a single null character).
PROPERTIES
reg = <address> <size> ... (optional - note 1)
List of <address> <size> pairs. Each pair specifies an address for
the devices 8 registers. The address should be 8 byte aligned.
alternate-reg = <address> <size> ... (optional - note 1)
Alternative addreses for the registers.
assigned-addresses = <address> <size> ... (optional - note 1)
On a PCI bus, this property specifies the addresses assigned to the
device. The values reflect the devices configuration base registers.
Note 1: At least one of "assigned-addresses", "reg" or "alternative-reg"
must be specified. If "assigned-addresses" is specified the other
address specifications are ignored.
input-file = <file-name> (optional)
File to take all serial port input from (instead of the simulation
console).
output-file = <file-name> (optional)
File to send all output to (instead of the simulation console).
input-buffering = "unbuffered" (optional)
Specifying "unbuffered" buffering disables buffering on the serial
devices input stream (all data is immediatly read). In the future,
this option may be used to provide input buffering alternatives.
output-buffering = "unbuffered" (optional)
Specifying "unbuffered" buffering disables buffering on the serial
devices output stream (all data is immediatly written). In the future,
this option may be extended to include other buffering alternatives.
input-delay = <integer-delay> (optional)
Specify the number of ticks after the current character has been
read from the serial port that the next character becomes
available.
output-delay = <integer-delay> (optional)
Specify the number of ticks after a character has been written to
the empty output fifo that the fifo finishes draining. Any
characters written to the output fifo before it has drained will
not be lost and will still be displayed.
EXAMPLES
| /iobus@0xf0000000/com@0x3000/reg 0x3000 8
Create a simple console device at address <<0x3000>> within
<<iobus>>. Since iobus starts at address <<0xf0000000>> the
absolute address of the serial port will be <<0xf0003000>>.
The device will always be ready for I/O (no delay properties specified)
and both the input and output streams will use the simulation console
(no file properties).
| $ psim \
| -o '/cpus/cpu@0' \
| -o '/iobus@0xf0000000/com@0x4000/reg 0x4000 8' \
| -o '/iobus@0xf0000000/com@0x4000/input-file /etc/passwd' \
| -o '/iobus@0xf0000000/com@0x4000/input-delay 1000' \
| -o '/iobus@0xf0000000/com@0x4000 > 0 int /cpus/cpu@0x0' \
| psim-test/hw-com/cat.be 0xf0004000
The serial port (at address <<0xf0004000>> is configured so that it
takes its input from the file <</etc/passwd>> while its output is
allowed to appear on the simulation console.
The node <</cpus/cpu@0>> was explicitly specified to ensure that it had
been created before any interrupts were attached to it.
The program <<psim-test/hw-com/cat>> copies any characters on the serial
port's input (<</etc/passwd>>) to its output (the console).
Consequently, the aove program will display the contents of the file
<</etc/passwd>> on the screen.
BUGS
IEEE 1275 requires that a device on a PCI bus have, as its first reg
entry, the address of its configuration space registers. Currently,
this device does not even implement configuration registers.
This model does not attempt to model the '550's input and output fifos.
Instead, the input fifo is limited to a single character at a time,
while the output fifo is effectivly infinite. Consequently, unlike the
'550, this device will not discard output characters once a stream of 16
have been written to the data output register.
The input and output can only be taken from a file (or the current
terminal device). In the future, the <<com>> device should allow the
specification of other data streams (such as an xterm or TK window).
The input blocks if no data is available.
Interrupts have not been tested.
*/
enum {
max_hw_com_registers = 8,
};
typedef struct _com_port {
int ready;
int delay;
int interrupting;
FILE *file;
} com_port;
typedef struct _com_modem {
int carrier;
int carrier_changed;
int interrupting;
} com_modem;
typedef struct _hw_com_device {
com_port input;
com_port output;
com_modem modem;
char dlab[2];
char reg[max_hw_com_registers];
int interrupting;
} hw_com_device;
static void
hw_com_device_init_data(device *me)
{
hw_com_device *com = (hw_com_device*)device_data(me);
/* clean up */
if (com->output.file != NULL)
fclose(com->output.file);
if (com->input.file != NULL)
fclose(com->input.file);
memset(com, 0, sizeof(hw_com_device));
/* the fifo speed */
com->output.delay = (device_find_property(me, "output-delay") != NULL
? device_find_integer_property(me, "output-delay")
: 0);
com->input.delay = (device_find_property(me, "input-delay") != NULL
? device_find_integer_property(me, "input-delay")
: 0);
/* the data source/sink */
if (device_find_property(me, "input-file") != NULL) {
const char *input_file = device_find_string_property(me, "input-file");
com->input.file = fopen(input_file, "r");
if (com->input.file == NULL)
device_error(me, "Problem opening input file %s\n", input_file);
if (device_find_property(me, "input-buffering") != NULL) {
const char *buffering = device_find_string_property(me, "input-buffering");
if (strcmp(buffering, "unbuffered") == 0)
setbuf(com->input.file, NULL);
}
}
if (device_find_property(me, "output-file") != NULL) {
const char *output_file = device_find_string_property(me, "output-file");
com->output.file = fopen(output_file, "w");
if (com->output.file == NULL)
device_error(me, "Problem opening output file %s\n", output_file);
if (device_find_property(me, "output-buffering") != NULL) {
const char *buffering = device_find_string_property(me, "output-buffering");
if (strcmp(buffering, "unbuffered") == 0)
setbuf(com->output.file, NULL);
}
}
/* ready from the start */
com->input.ready = 1;
com->modem.carrier = 1;
com->output.ready = 1;
}
static void
update_com_interrupts(device *me,
hw_com_device *com)
{
int interrupting;
com->modem.interrupting = (com->modem.carrier_changed && (com->reg[1] & 0x80));
com->input.interrupting = (com->input.ready && (com->reg[1] & 0x1));
com->output.interrupting = (com->output.ready && (com->reg[1] & 0x2));
interrupting = (com->input.interrupting
|| com->output.interrupting
|| com->modem.interrupting);
if (interrupting) {
if (!com->interrupting) {
device_interrupt_event(me, 0 /*port*/, 1 /*value*/, NULL, 0);
}
}
else /*!interrupting*/ {
if (com->interrupting)
device_interrupt_event(me, 0 /*port*/, 0 /*value*/, NULL, 0);
}
com->interrupting = interrupting;
}
static void
make_read_ready(void *data)
{
device *me = (device*)data;
hw_com_device *com = (hw_com_device*)device_data(me);
com->input.ready = 1;
update_com_interrupts(me, com);
}
static void
read_com(device *me,
hw_com_device *com,
unsigned_word a,
char val[1])
{
unsigned_word addr = a % 8;
/* the divisor latch is special */
if (com->reg[3] & 0x8 && addr < 2) {
*val = com->dlab[addr];
return;
}
switch (addr) {
case 0:
/* fifo */
if (!com->modem.carrier)
*val = '\0';
if (com->input.ready) {
/* read the char in */
if (com->input.file == NULL) {
if (sim_io_read_stdin(val, 1) < 0)
com->modem.carrier_changed = 1;
}
else {
if (fread(val, 1, 1, com->input.file) == 0)
com->modem.carrier_changed = 1;
}
/* setup for next read */
if (com->modem.carrier_changed) {
/* once lost carrier, never ready */
com->modem.carrier = 0;
com->input.ready = 0;
*val = '\0';
}
else if (com->input.delay > 0) {
com->input.ready = 0;
device_event_queue_schedule(me, com->input.delay, make_read_ready, me);
}
}
else {
/* discard it? */
/* overflow input fifo? */
*val = '\0';
}
break;
case 2:
/* interrupt ident */
if (com->interrupting) {
if (com->input.interrupting)
*val = 0x4;
else if (com->output.interrupting)
*val = 0x2;
else if (com->modem.interrupting == 0)
*val = 0;
else
device_error(me, "bad elif for interrupts\n");
}
else
*val = 0x1;
break;
case 5:
/* line status */
*val = ((com->input.ready ? 0x1 : 0)
| (com->output.ready ? 0x60 : 0)
);
break;
case 6:
/* modem status */
*val = ((com->modem.carrier_changed ? 0x08 : 0)
| (com->modem.carrier ? 0x80 : 0)
);
com->modem.carrier_changed = 0;
break;
default:
*val = com->reg[addr];
break;
}
update_com_interrupts(me, com);
}
static unsigned
hw_com_io_read_buffer_callback(device *me,
void *dest,
int space,
unsigned_word addr,
unsigned nr_bytes,
cpu *processor,
unsigned_word cia)
{
hw_com_device *com = device_data(me);
int i;
for (i = 0; i < nr_bytes; i++) {
read_com(me, com, addr + i, &((char*)dest)[i]);
}
return nr_bytes;
}
static void
make_write_ready(void *data)
{
device *me = (device*)data;
hw_com_device *com = (hw_com_device*)device_data(me);
com->output.ready = 1;
update_com_interrupts(me, com);
}
static void
write_com(device *me,
hw_com_device *com,
unsigned_word a,
char val)
{
unsigned_word addr = a % 8;
/* the divisor latch is special */
if (com->reg[3] & 0x8 && addr < 2) {
com->dlab[addr] = val;
return;
}
switch (addr) {
case 0:
/* fifo */
if (com->output.file == NULL) {
sim_io_write_stdout(&val, 1);
}
else {
fwrite(&val, 1, 1, com->output.file);
}
/* setup for next write */
if (com->output.ready && com->output.delay > 0) {
com->output.ready = 0;
device_event_queue_schedule(me, com->output.delay, make_write_ready, me);
}
break;
default:
com->reg[addr] = val;
break;
}
update_com_interrupts(me, com);
}
static unsigned
hw_com_io_write_buffer_callback(device *me,
const void *source,
int space,
unsigned_word addr,
unsigned nr_bytes,
cpu *processor,
unsigned_word cia)
{
hw_com_device *com = device_data(me);
int i;
for (i = 0; i < nr_bytes; i++) {
write_com(me, com, addr + i, ((char*)source)[i]);
}
return nr_bytes;
}
/* instances of the hw_com device */
static void
hw_com_instance_delete(device_instance *instance)
{
/* nothing to delete, the hw_com is attached to the device */
return;
}
static int
hw_com_instance_read(device_instance *instance,
void *buf,
unsigned_word len)
{
device *me = device_instance_device(instance);
hw_com_device *com = device_data(me);
if (com->input.file == NULL)
return sim_io_read_stdin(buf, len);
else {
return fread(buf, 1, len, com->input.file);
}
}
static int
hw_com_instance_write(device_instance *instance,
const void *buf,
unsigned_word len)
{
device *me = device_instance_device(instance);
hw_com_device *com = device_data(me);
if (com->output.file == NULL)
return sim_io_write_stdout(buf, len);
else {
return fwrite(buf, 1, len, com->output.file);
}
}
static const device_instance_callbacks hw_com_instance_callbacks = {
hw_com_instance_delete,
hw_com_instance_read,
hw_com_instance_write,
};
static device_instance *
hw_com_create_instance(device *me,
const char *path,
const char *args)
{
/* point an instance directly at the device */
return device_create_instance_from(me, NULL,
device_data(me),
path, args,
&hw_com_instance_callbacks);
}
static device_callbacks const hw_com_callbacks = {
{ generic_device_init_address,
hw_com_device_init_data },
{ NULL, }, /* address */
{ hw_com_io_read_buffer_callback,
hw_com_io_write_buffer_callback, },
{ NULL, }, /* DMA */
{ NULL, }, /* interrupt */
{ NULL, }, /* unit */
hw_com_create_instance,
};
static void *
hw_com_create(const char *name,
const device_unit *unit_address,
const char *args)
{
/* create the descriptor */
hw_com_device *hw_com = ZALLOC(hw_com_device);
return hw_com;
}
const device_descriptor hw_com_device_descriptor[] = {
{ "com", hw_com_create, &hw_com_callbacks },
{ NULL },
};
#endif /* _HW_COM_C_ */
| 26.023256 | 82 | 0.665223 |
6411d1034a8012e5eac41f2af9cd6441b4fd4895 | 3,366 | c | C | nitan/kungfu/class/misc/goldtiger.c | cantona/NT6 | 073f4d491b3cfe6bfbe02fbad12db8983c1b9201 | [
"MIT"
] | 1 | 2019-03-27T07:25:16.000Z | 2019-03-27T07:25:16.000Z | nitan/kungfu/class/misc/goldtiger.c | cantona/NT6 | 073f4d491b3cfe6bfbe02fbad12db8983c1b9201 | [
"MIT"
] | null | null | null | nitan/kungfu/class/misc/goldtiger.c | cantona/NT6 | 073f4d491b3cfe6bfbe02fbad12db8983c1b9201 | [
"MIT"
] | null | null | null | // nanhai.c
#include <ansi.h>
inherit NPC;
void create()
{
set_name(NOR + YEL "黃金" + HIW "白玉" + HIY "虎" NOR, ({ "gold tiger" }) );
set("title", HIM "萬獸之王" NOR);
set("gender", "男性");
set("age", 2000);
set("long", @LONG
這是一隻巨大的老虎，渾身金黃色，頭為白色，猶如白玉。
LONG );
set("combat_exp", 1000000000);
set("shen_type", 0);
set("attitude", "heroism");
set("max_neili", 300000);
set("neili", 300000);
set("max_jing", 300000);
set("jing", 300000);
set("max_qi", 1200000);
set("qi", 1200000);
set("jingli", 1200000);
set("max_jingli", 1200000);
set("str", 200);
set("int", 100);
set("con", 100);
set("dex", 100);
set_skill("unarmed", 2000);
set_skill("sword", 1200);
set_skill("parry", 1000);
set_skill("dodge", 1000);
set_skill("force", 1000);
set_skill("martial-cognize", 1000);
set("jiali", 300);
set_temp("apply/attack", 1000);
set_temp("apply/unarmed_damage", 1000);
set_temp("apply/armor", 2000);
if (clonep(this_object()))
{
set("chat_chance", 30);
set("chat_msg", ({ (: random_move :) }));
set("born_time", time());
keep_heart_beat();
}
setup();
}
void fight_ob(object ob)
{
if (is_fighting(ob))
return;
message_vision(HIW "$N一聲長嘯，張牙舞爪，面目猙獰。\n" NOR, this_object(), ob);
::fight_ob(ob);
if( !is_killing(query("id", ob)) )
kill_ob(ob);
}
int accept_fight(object ob)
{
message_vision(HIW "$N" HIW "一聲長嘯，撲向$n" HIW "上來。\n" NOR,
this_object(), ob);
kill_ob(ob);
return -1;
}
int accept_kill(object ob)
{
return 1;
}
int accept_hit(object ob)
{
return 1;
}
mixed hit_ob(object me, object ob, int damage_bouns)
{
ob->receive_wound("qi", 1000 + random(1000), me);
set("neili",query("max_neili", me), me);
return HIW "$N" HIW "周圍紫氣大盛，面目猙獰，狂嘯一聲，登時令$n"
HIW "迷惑不已，難以自拔。\n" NOR;
}
varargs void unconcious(object defeater)
{
object ob;
//if( query("end_boss") || query("fight_boss") )
if( objectp(ob = previous_object(0)) && sscanf(base_name(ob), "/kungfu/skill/%*s") ) {
full_self();
return;
}
die(defeater);
return;
}
varargs void die(object killer)
{
object ob;
if( objectp(ob = previous_object(0)) && sscanf(base_name(ob), "/kungfu/skill/%*s") )
{
full_self();
return;
}
if (! objectp(killer))
killer = query_last_damage_from();
if (! objectp(killer))return;
if( query("lunhui-sword_quest/chushengdao/give_quest", killer) )
{
tell_object(killer, BLINK + HIG "你已經殺死了黃金白玉虎，任務完成。\n" NOR);
set("lunhui-sword_quest/chushengdao/killed", 1, killer);
killer->save();
}
destruct(this_object());
}
void random_move()
{
if (time() - query("born_time") > 1800)
{
message_vision("$N竄入叢林，消失了。\n", this_object());
destruct(this_object());
return;
}
}
| 23.87234 | 94 | 0.500297 |
d9b3fc2c82202ef872c3c0676c2361b74d9baca6 | 412 | h | C | Prism-master/PrismDemo/Prism/Record/LogRecord/TYLogDateRecord.h | feng562925462/YJAPMDemo | 3269b586d84bfc139c51374172c4140a933fc645 | [
"MIT"
] | 1 | 2018-10-16T06:28:59.000Z | 2018-10-16T06:28:59.000Z | Prism-master/PrismDemo/Prism/Record/LogRecord/TYLogDateRecord.h | feng562925462/YJAPMDemo | 3269b586d84bfc139c51374172c4140a933fc645 | [
"MIT"
] | null | null | null | Prism-master/PrismDemo/Prism/Record/LogRecord/TYLogDateRecord.h | feng562925462/YJAPMDemo | 3269b586d84bfc139c51374172c4140a933fc645 | [
"MIT"
] | null | null | null | //
// TYLogDateRecord.h
// PrismMonitorDemo
//
// Created by tany on 17/3/23.
// Copyright © 2017年 tany. All rights reserved.
//
#import <CoreData/CoreData.h>
#import "TYLogMsgRecord.h"
@interface TYLogDateRecord : NSManagedObject
@property (nullable, nonatomic, copy) NSString *date;
@property (nullable, nonatomic, copy) NSNumber *id;
+ (NSFetchRequest<TYLogDateRecord *> *_Nonnull)fetchRequest;
@end
| 20.6 | 60 | 0.73301 |
26cd69a0e21069565f472349682d4031ae1bc24d | 1,653 | c | C | src/jsonlexer/t/t_jsonlexer_parse.c | koji-hirono/pms | 64ad78d067305a349a9e053a2ff9e316de851a22 | [
"MIT"
] | null | null | null | src/jsonlexer/t/t_jsonlexer_parse.c | koji-hirono/pms | 64ad78d067305a349a9e053a2ff9e316de851a22 | [
"MIT"
] | null | null | null | src/jsonlexer/t/t_jsonlexer_parse.c | koji-hirono/pms | 64ad78d067305a349a9e053a2ff9e316de851a22 | [
"MIT"
] | null | null | null | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "buf.h"
#include "stream.h"
#include "jsonlexer.h"
#include "memstat.h"
static void
print_memstat(void)
{
Memstat m;
memstat_get(&m);
printf("vsize: %zu, rssize: %zu\n", m.vs, m.rs);
}
int
parse(Stream *s)
{
JSONLexer lexer;
Buf token;
int type;
jsonlexer_init(&lexer, s);
buf_init(&token, 64);
print_memstat();
while ((type = jsonlexer_token(&lexer, &token)) != -1) {
print_memstat();
switch (type) {
case JSON_OBJECT_START:
/* { */
printf("object start = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_OBJECT_END:
/* } */
printf("object end = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_ARRAY_START:
/* [ */
printf("array start = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_ARRAY_END:
/* ] */
printf("array end = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_NULL:
/* null */
printf("null = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_BOOLEAN:
/* true | false */
printf("boolean = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_STRING:
/* "string" */
printf("string = '%.*s'\n",
(int)token.len, token.data);
break;
case JSON_NUMBER:
/* number */
printf("number = '%.*s'\n",
(int)token.len, token.data);
break;
default:
break;
}
}
buf_free(&token);
return 0;
}
static void
test1(void)
{
Stream s;
print_memstat();
stream_open(&s, 0);
print_memstat();
parse(&s);
stream_close(&s);
print_memstat();
}
int
main(void)
{
test1();
return 0;
}
| 15.448598 | 57 | 0.581972 |
6cac6a3889732e58083bb179dd384c90e570de88 | 4,625 | h | C | archive_files/libraries/Maker_LED_Matrix_32-master/Maker_LED_Matrix_32.h | marctheshark3/Basking-Shark | f3aa39d51219c521fd538afd99a96f8341d45309 | [
"MIT"
] | null | null | null | archive_files/libraries/Maker_LED_Matrix_32-master/Maker_LED_Matrix_32.h | marctheshark3/Basking-Shark | f3aa39d51219c521fd538afd99a96f8341d45309 | [
"MIT"
] | null | null | null | archive_files/libraries/Maker_LED_Matrix_32-master/Maker_LED_Matrix_32.h | marctheshark3/Basking-Shark | f3aa39d51219c521fd538afd99a96f8341d45309 | [
"MIT"
] | null | null | null | /*
This library should be used with arduino IDE on e-radionica Social Display Module.
Used librarys:
Adafruit IS31FL3731 Library: https://github.com/adafruit/Adafruit_IS31FL3731
Adafruit GFX Library: https://github.com/adafruit/Adafruit-GFX-Library
Ticker Library for timer: https://github.com/esp8266/Arduino/tree/master/libraries/Ticker
*/
#ifndef _MAKER_LED_MATRIX_32_H_
#define _MAKER_LED_MATRIX_32_H_
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#define _BUFFERSIZE 800 //Size of buffer for displying messages.
#define _GAMMA 2.2
static uint8_t _brightness; //Variables for font and background brightness and also for delay between shifts and shift (scroll) step.
static uint8_t _backBrightness;
static uint8_t _pause;
static uint8_t _step;
static char msgBuffer[_BUFFERSIZE]; //Buffer for user defined message, max size of 799 characters.
static int _msgSize; //Variable that holds a size of user message.
static int _scroll; //Variable for scrolling text on display (defines maximal scroll steps for the whole message to be scrolled).
static int _position; //Variable that moves position of text on screen.
static uint8_t wlanSuccess = 0; //Variable that holds information of WiFi connectivity.
static uint8_t* pictBuffer; //Pointer to user-defined picture (bitmap).
static int _repeats = 0; //Variable that keep number that says how many more times message have to be displayed.
static uint16_t _messageRepeats = 0; //Variable that keeps track how many times message has been displayed (repeated).
static uint8_t** picTxtBuffer; //Variable for pointing on addresses of pictures
static uint16_t *posBufferX; //Variable for pointing on x cooridinates of each picture
static uint16_t *posBufferY; //Variable for pointing on y cooridinates of each picture
static uint8_t noOfPics; //Variable that keep number of pictures on screen.
static uint8_t _frameCount; //Variable that keeps track on what frame buffer is displayed on screen.
static void writeMessage(); //Function that makes scrolling text on screen (called from timer).
static void writePicture(); //Same as previous function, only for picture
static void writeTextAndPic();
class Maker_LED_Matrix_32 {
public:
Maker_LED_Matrix_32();
int begin(); //Init function.
int initLEDMatrix(); //Function sets up everything e-radionica Social Dispaly board.
void brightness(uint8_t _fontLight, uint8_t _backingLight); //Sets up font brightness and background brightness.
void message(char* msg, int _ms, int _stp, int _rep); //Writes user defined message/text on display.
void stopScroll(); //Calling this function scrolling will stop.
void resumeScroll(); //Calling this function scrolling will continue.
void deleteScroll(); //Function removes everything from screen and clears buffer.
void picture(uint8_t* p, int posX, int posY); //Function writes picture on screen (without scrolling).
void scrollPicture(uint8_t* p, int _ms, int _stp); //Function writes picture on screen with scrolling.
void scrollTxtAndPics(char* txt, uint8_t** p, uint16_t* picsPos_x, uint16_t* picsPos_y, uint8_t n, int _ms, int _stp, int _rep);
int repeatCount(); //Function return how much times message has been displayed
void picture8Bit(uint8_t* p, int xSize, int ySize, int x0, int y0, uint8_t bright); //Function that removes everything from screen and displays a 8bit gray scale image.
int wifiNetwork(const char* _ssid, const char* _pass); //Funcion connects to WLAN network.
int webPage(char* url, int _ms, int _stp, int _rep); //Function opens web page and displays text on LED matrix.
int webPageText(char* url, char* webText, int _n); //Function opens a web and saves data into a string without displayig on matrix.
int _dispMode;
};
#endif
| 67.028986 | 184 | 0.637838 |
e79e9823cb7c8030d89bed6ea7cd8c83cafa22ed | 301 | c | C | code30/linux/day5/fp_fd/fopen_open.c | stdbilly/CS_Note | a8a87e135a525d53c283a4c70fb942c9ca59a758 | [
"MIT"
] | 2 | 2020-12-09T09:55:51.000Z | 2021-01-08T11:38:22.000Z | code30/linux/day5/fp_fd/fopen_open.c | stdbilly/CS_Note | a8a87e135a525d53c283a4c70fb942c9ca59a758 | [
"MIT"
] | null | null | null | code30/linux/day5/fp_fd/fopen_open.c | stdbilly/CS_Note | a8a87e135a525d53c283a4c70fb942c9ca59a758 | [
"MIT"
] | null | null | null | #include <func.h>
int main(int argc,char* argv[])
{
ARGS_CHECK(argc,2);
FILE *fp;
fp=fopen(argv[1],"rb+");
ERROR_CHECK(fp,NULL,"fopen");
int fd=fileno(fp);
printf("fd=%d\n",fd);
char buf[128]={0};
read(fd,buf,sizeof(buf));
printf("buf=%s\n",buf);
return 0;
}
| 17.705882 | 33 | 0.551495 |
f048de3a49bd890bfaa1da1d99f044be415e1d85 | 3,684 | h | C | xdk-asf-3.51.0/avr32/components/touch/at42qt1060/module_config/conf_at42qt1060.h | j3270/SAMD_Experiments | 5c242aff44fc8d7092322d7baf2dda450a78a9b7 | [
"MIT"
] | null | null | null | xdk-asf-3.51.0/avr32/components/touch/at42qt1060/module_config/conf_at42qt1060.h | j3270/SAMD_Experiments | 5c242aff44fc8d7092322d7baf2dda450a78a9b7 | [
"MIT"
] | null | null | null | xdk-asf-3.51.0/avr32/components/touch/at42qt1060/module_config/conf_at42qt1060.h | j3270/SAMD_Experiments | 5c242aff44fc8d7092322d7baf2dda450a78a9b7 | [
"MIT"
] | null | null | null | /*****************************************************************************
*
* \file
*
* \brief AT42QT1060 template configuration file.
*
* Copyright (c) 2009-2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*
*****************************************************************************/
/*
* Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
*/
#ifndef _CONF_AT42QT1060_H_
#define _CONF_AT42QT1060_H_
#include "board.h"
#define AT42QT1060_DETECT_PIN AVR32_PIN_PA22
#define AT42QT1060_EIC_EXTINT_FUNCTION AVR32_EIC_EXTINT_1_FUNCTION
#define AT42QT1060_EIC_EXTINT_IRQ AVR32_EIC_IRQ_GROUP0 // IRQ line for INTC
#define AT42QT1060_EIC_LINE AVR32_EIC_INT1 // EIC line (0-7)
/*! Priority group level of the EIC IRQ channel */
#define AT42QT1060_EIC_EXTINT_LEVEL 0
#if !defined(AT42QT1060_TWI)
#warning "Using a default AT42QT1060 mapping. Verify all AT42QT1060_TWI* defines according to the current board."
#if (UC3A3 || UC3A4 || UC3C || UC3L)
#define AT42QT1060_TWI (&AVR32_TWIM0)
#define AT42QT1060_TWI_SCL_PIN AVR32_TWIMS0_TWCK_0_0_PIN
#define AT42QT1060_TWI_SCL_FUNCTION AVR32_TWIMS0_TWCK_0_0_FUNCTION
#define AT42QT1060_TWI_SDA_PIN AVR32_TWIMS0_TWD_0_0_PIN
#define AT42QT1060_TWI_SDA_FUNCTION AVR32_TWIMS0_TWD_0_0_FUNCTION
#else
#define AT42QT1060_TWI (&AVR32_TWI)
#define AT42QT1060_TWI_SCL_PIN AVR32_TWI_SCL_0_0_PIN
#define AT42QT1060_TWI_SCL_FUNCTION AVR32_TWI_SCL_0_0_FUNCTION
#define AT42QT1060_TWI_SDA_PIN AVR32_TWI_SDA_0_0_PIN
#define AT42QT1060_TWI_SDA_FUNCTION AVR32_TWI_SDA_0_0_FUNCTION
#endif
#endif // #if !defined(AT42QT1060_TWI)
/*! The AT42QT1060 can do max 100kHz on the TWI. */
#define AT42QT1060_TWI_MASTER_SPEED 100000
#define AT42QT1060_KEY_MASK_VALUE 0x3F
/*! Threshold value for touch sensors.
* A measured value above this value will count as a detect
*/
#define AT42QT1060_KEY_0_NTHR_VALUE 15
#define AT42QT1060_KEY_1_NTHR_VALUE 15
#define AT42QT1060_KEY_2_NTHR_VALUE 15
#define AT42QT1060_KEY_3_NTHR_VALUE 15
#define AT42QT1060_KEY_4_NTHR_VALUE 15
#define AT42QT1060_KEY_5_NTHR_VALUE 10
/*! Number of consecutive measurements that must be confirmed as having
* passed the key threshold before that key is registered as being in detect.
*/
#define AT42QT1060_DETECT_INTEGRATOR_VALUE 3
/*! The I2C address is fixed for the AT42QT1060 device. */
#define AT42QT1060_TWI_ADDRESS 0x12
#endif /* _CONF_AT42QT1060_H_ */
| 40.043478 | 113 | 0.748914 |
5357c7ebfa5e5d802b6b4e1e0fa84c71354c80aa | 1,624 | h | C | src/include/catalog/pg_inheritproc.h | emotionbug/incubator-age-pg | 676e3c735dec32ba0448fdd0faf9ace37c1fa792 | [
"BSD-4-Clause-UC"
] | null | null | null | src/include/catalog/pg_inheritproc.h | emotionbug/incubator-age-pg | 676e3c735dec32ba0448fdd0faf9ace37c1fa792 | [
"BSD-4-Clause-UC"
] | null | null | null | src/include/catalog/pg_inheritproc.h | emotionbug/incubator-age-pg | 676e3c735dec32ba0448fdd0faf9ace37c1fa792 | [
"BSD-4-Clause-UC"
] | null | null | null | /*-------------------------------------------------------------------------
*
* pg_inheritproc.h--
* definition of the system "inheritproc" relation (pg_inheritproc)
* along with the relation's initial contents.
*
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: pg_inheritproc.h,v 1.2 1996/10/31 09:47:33 scrappy Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
* information from the DATA() statements.
*
*-------------------------------------------------------------------------
*/
#ifndef PG_INHERITPROC_H
#define PG_INHERITPROC_H
/* ----------------
* postgres.h contains the system type definintions and the
* CATALOG(), BOOTSTRAP and DATA() sugar words so this file
* can be read by both genbki.sh and the C compiler.
* ----------------
*/
/* ----------------
* pg_inheritproc definition. cpp turns this into
* typedef struct FormData_pg_inheritproc
* ----------------
*/
CATALOG(pg_inheritproc) {
NameData inhproname;
Oid inhargrel;
Oid inhdefrel;
Oid inhproc;
} FormData_pg_inheritproc;
/* ----------------
* Form_pg_inheritproc corresponds to a pointer to a tuple with
* the format of pg_inheritproc relation.
* ----------------
*/
typedef FormData_pg_inheritproc *Form_pg_inheritproc;
/* ----------------
* compiler constants for pg_inheritproc
* ----------------
*/
#define Natts_pg_inheritproc 4
#define Anum_pg_inheritproc_inhproname 1
#define Anum_pg_inheritproc_inhargrel 2
#define Anum_pg_inheritproc_inhdefrel 3
#define Anum_pg_inheritproc_inhproc 4
#endif /* PG_INHERITPROC_H */
| 27.525424 | 75 | 0.605296 |
1878d910961e401e4ac4ceae45a613c705f305d8 | 3,219 | h | C | SimpleIoc/SimpleIoc.h | wangrenzhu/SimpleIoc-For-Objective-c | ad5321f5a7a0ab965f5123440fd048bf4a30c5a5 | [
"Apache-2.0"
] | 2 | 2016-02-19T09:16:58.000Z | 2016-02-19T09:21:32.000Z | SimpleIoc/SimpleIoc.h | wangrenzhu/SimpleIoc-For-Objective-c | ad5321f5a7a0ab965f5123440fd048bf4a30c5a5 | [
"Apache-2.0"
] | null | null | null | SimpleIoc/SimpleIoc.h | wangrenzhu/SimpleIoc-For-Objective-c | ad5321f5a7a0ab965f5123440fd048bf4a30c5a5 | [
"Apache-2.0"
] | null | null | null | //
// SimpleIoc.h
// YFIOCLibrary
// IOCContainers from mvvmLight toolkit
// 从C# 移植
// Created by ghostZephyr on 14-9-19.
// Copyright (c) 2014年 YF. All rights reserved.
//
#import "ISimpleIoc.h"
#import "IConstructorProvider.h"
#import "ConstructorInfo.h"
#import "SimpleIocLibrary.h"
#define simpleIoc_WEAK_SELF __typeof(&*self) __weak weakSelf = self
#define simpleIoc_STRONG_SELF __typeof(&*self) __strong strongSelf = weakSelf
#define simpleIoc_register(value) \
if (![[SimpleIoc defaultInstance] isRegistered:value]) { \
Class cls = NSClassFromString(value); \
if([[cls description] isEqualToString:value]) { \
[[SimpleIoc defaultInstance] registerInstance:cls]; \
} \
}
#define simpleIoc_registerCreate(value) \
if (![[SimpleIoc defaultInstance] isRegistered:value]) { \
Class cls = NSClassFromString(value); \
if([[cls description] isEqualToString:value]) { \
[[SimpleIoc defaultInstance] registerInstance:cls createInstanceImmediately:YES]; \
} \
}
#define simpleIoc_registerInterface(interface,implementation) \
if (![[SimpleIoc defaultInstance] isRegistered:interface]) { \
Class cls = NSClassFromString(implementation); \
if([[cls description] isEqualToString:implementation]) { \
[[SimpleIoc defaultInstance] registerInstance:NSProtocolFromString(interface) tClassName:NSClassFromString(implementation)]; \
} \
}
#define simpleIoc_registerInterfaceCreate(interface,implementation) \
if (![[SimpleIoc defaultInstance] isRegistered:interface]) { \
Class cls = NSClassFromString(implementation); \
if([[cls description] isEqualToString:implementation]) { \
[[SimpleIoc defaultInstance] registerInstance:NSProtocolFromString(interface) tClassName:NSClassFromString(implementation) createInstanceImmediately:YES]; \
} \
}
#define simpleIoc_required() \
[[SimpleIoc defaultInstance] simpleIocRequiresInjection:self];
#define simpleIoc_getInstanceClass(value) do { \
if (![[SimpleIoc defaultInstance] isRegistered:NSStringFromClass(value)]) { \
return [[SimpleIoc defaultInstance] getInstance:value]; \
} else { \
return nil; \
}}while(0)
//第一个参数为需要构造的selector 一般指定到增加了零件对应参数的init方法上 第二个参数 是需要构造的零件 的协议 或者是Class 该零件与init的参数一一对应
#define simpleIoc_ctorInfoWithSelector(buildSelector, args...) \
-(ConstructorInfo *)getConstructorInfo { \
ConstructorInfo *ctor = [[ConstructorInfo alloc] init]; \
ctor.buildSelectorString = NSStringFromSelector(buildSelector); \
id objs[] = {args}; \
ctor.parameterTypes = [NSMutableArray arrayWithObjects: objs count:sizeof(objs)/sizeof(id)]; \
return ctor; \
}
//第一个参数为需要构造的selector 一般指定到非init方法上 第二个selector 指定到 自定义构造函数上 第三个参数 是需要构造的零件 的协议 或者是Class
#define simpleIoc_ctorInfoWithSelectorCustomInit(buildSelector,initSelector, args...) \
-(ConstructorInfo *)getConstructorInfo { \
ConstructorInfo *ctor = [[ConstructorInfo alloc] init]; \
ctor.buildSelectorString = NSStringFromSelector(buildSelector); \
ctor.initializerSelectorString = NSStringFromSelector(initSelector); \
id objs[] = {args}; \
ctor.parameterTypes = [NSMutableArray arrayWithObjects: objs count:sizeof(objs)/sizeof(id)]; \
return ctor; \
}
@interface SimpleIoc : NSObject <ISimpleIoc>
/**
* 工厂单例
*
* @return 工厂
*/
+ (instancetype)defaultInstance;
@end
| 33.884211 | 156 | 0.768562 |
17cc1e31de7f7ea25d5cf1e3907f78acadbcaf9c | 583 | h | C | Programs/ResourceEditor/Classes/SceneTree/Private/CreateEntitySupportDefault.h | stinvi/dava.engine | 2b396ca49cdf10cdc98ad8a9ffcf7768a05e285e | [
"BSD-3-Clause"
] | 26 | 2018-09-03T08:48:22.000Z | 2022-02-14T05:14:50.000Z | Programs/ResourceEditor/Classes/SceneTree/Private/CreateEntitySupportDefault.h | ANHELL-blitz/dava.engine | ed83624326f000866e29166c7f4cccfed1bb41d4 | [
"BSD-3-Clause"
] | null | null | null | Programs/ResourceEditor/Classes/SceneTree/Private/CreateEntitySupportDefault.h | ANHELL-blitz/dava.engine | ed83624326f000866e29166c7f4cccfed1bb41d4 | [
"BSD-3-Clause"
] | 45 | 2018-05-11T06:47:17.000Z | 2022-02-03T11:30:55.000Z | #pragma once
#include <REPlatform/Global/SceneTree/CreateEntitySupport.h>
namespace DAVA
{
class Entity;
} // namespace DAVA
template <typename T>
class SimpleCreatorHelper : public DAVA::SimpleEntityCreator
{
public:
SimpleCreatorHelper(DAVA::BaseEntityCreator::eMenuPointOrder order, const QIcon& icon, const QString& text)
: SimpleEntityCreator(order, icon, text, DAVA::MakeFunction(&T::CreateEntity))
{
}
DAVA_VIRTUAL_REFLECTION(SimpleCreatorHelper, DAVA::SimpleEntityCreator);
};
std::unique_ptr<DAVA::BaseEntityCreator> CreateEntityCreationTree();
| 25.347826 | 111 | 0.770154 |
eb8ad9304bba44c4f61b3ae062d97ae66cb92fa9 | 1,309 | h | C | Libraries/UtilLib/Include/ExUtilFileWriterStream.h | tom-weatherhead/exeter-asset-processor | e19c777427afe66684f308cb7b07448b3481c25e | [
"MIT"
] | null | null | null | Libraries/UtilLib/Include/ExUtilFileWriterStream.h | tom-weatherhead/exeter-asset-processor | e19c777427afe66684f308cb7b07448b3481c25e | [
"MIT"
] | null | null | null | Libraries/UtilLib/Include/ExUtilFileWriterStream.h | tom-weatherhead/exeter-asset-processor | e19c777427afe66684f308cb7b07448b3481c25e | [
"MIT"
] | null | null | null | /*
* ExUtilFileWriterStream.h
* Exeter Utility Library
*
* Created by Tom Weatherhead on Tue May 24 2005.
* Copyright (c) 2003-2005 by Tom Weatherhead. All rights reserved.
*
*/
#ifndef _EXUTILFILEWRITERSTREAM_H_
#define _EXUTILFILEWRITERSTREAM_H_
#include <fstream>
#include "ExUtilFileWriterBaseInterface.h"
class ExUtilFileWriterStream : public ExUtilFileWriterBaseInterface
{
private:
ExAPAutoPtr<std::basic_ofstream<unsigned char> > m_pStream;
public:
explicit ExUtilFileWriterStream( const std::string & filename, bool littleEndian = true, bool binary = true ) throw( ExAPException );
virtual ~ExUtilFileWriterStream( void );
virtual void SetOffset( long offset ); // Throws an exception if it fails.
virtual unsigned int GetOffset( void ) const;
virtual void Align( unsigned int alignment );
virtual void WriteByte( int c );
virtual void WriteBytes( unsigned char * p, size_t n );
virtual void WriteWord( unsigned short w );
virtual void WriteDoubleWord( unsigned int dw );
#if 0
// Remove this as soon as the JPEG code no longer needs it.
inline FILE * GetFilePointer( void ) const
{
return( m_fp );
}
#endif
}; // class ExUtilFileReaderStream
#endif // #ifndef _EXUTILFILEWRITERSTREAM_H_
// **** End of File ****
| 26.714286 | 135 | 0.718869 |
5b63db0365c39300f2dbf1be0e8decaba8504220 | 6,737 | h | C | trace_event/trace_event_memory.h | chinmaygarde/flutter_base | 40e46434df6711b5c219823d3a01ffa1f2fb10d6 | [
"BSD-3-Clause"
] | 1 | 2021-06-12T00:47:11.000Z | 2021-06-12T00:47:11.000Z | trace_event/trace_event_memory.h | chinmaygarde/flutter_base | 40e46434df6711b5c219823d3a01ffa1f2fb10d6 | [
"BSD-3-Clause"
] | null | null | null | trace_event/trace_event_memory.h | chinmaygarde/flutter_base | 40e46434df6711b5c219823d3a01ffa1f2fb10d6 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_H_
#define BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_H_
#include "base/base_export.h"
#include "base/gtest_prod_util.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "base/trace_event/trace_event_impl.h"
// TODO(jamescook): Windows support for memory tracing.
#if !defined(NO_TCMALLOC) && !defined(OS_NACL) && \
(defined(OS_LINUX) || defined(OS_ANDROID))
#define TCMALLOC_TRACE_MEMORY_SUPPORTED 1
#endif
namespace base {
class SingleThreadTaskRunner;
namespace trace_event {
// Watches for chrome://tracing to be enabled or disabled. When tracing is
// enabled, also enables tcmalloc heap profiling. This class is the preferred
// way to turn trace-base heap memory profiling on and off.
class BASE_EXPORT TraceMemoryController
: public TraceLog::EnabledStateObserver {
public:
typedef int (*StackGeneratorFunction)(int skip_count, void** stack);
typedef void (*HeapProfilerStartFunction)(StackGeneratorFunction callback);
typedef void (*HeapProfilerStopFunction)();
typedef char* (*GetHeapProfileFunction)();
// |task_runner| must be a task runner for the primary thread for the client
// process, e.g. the UI thread in a browser. The function pointers must be
// pointers to tcmalloc heap profiling functions; by avoiding direct calls to
// these functions we avoid a dependency on third_party/tcmalloc from base.
TraceMemoryController(scoped_refptr<SingleThreadTaskRunner> task_runner,
HeapProfilerStartFunction heap_profiler_start_function,
HeapProfilerStopFunction heap_profiler_stop_function,
GetHeapProfileFunction get_heap_profile_function);
~TraceMemoryController() override;
// base::trace_event::TraceLog::EnabledStateChangedObserver overrides:
void OnTraceLogEnabled() override;
void OnTraceLogDisabled() override;
// Starts heap memory profiling.
void StartProfiling();
// Captures a heap profile.
void DumpMemoryProfile();
// If memory tracing is enabled, dumps a memory profile to the tracing system.
void StopProfiling();
private:
FRIEND_TEST_ALL_PREFIXES(TraceMemoryTest, TraceMemoryController);
bool IsTimerRunningForTest() const;
// Ensures the observer starts and stops tracing on the primary thread.
scoped_refptr<SingleThreadTaskRunner> task_runner_;
// Pointers to tcmalloc heap profiling functions. Allows this class to use
// tcmalloc functions without introducing a dependency from base to tcmalloc.
HeapProfilerStartFunction heap_profiler_start_function_;
HeapProfilerStopFunction heap_profiler_stop_function_;
GetHeapProfileFunction get_heap_profile_function_;
// Timer to schedule memory profile dumps.
RepeatingTimer<TraceMemoryController> dump_timer_;
WeakPtrFactory<TraceMemoryController> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(TraceMemoryController);
};
//////////////////////////////////////////////////////////////////////////////
// A scoped context for memory tracing. Pushes the name onto a stack for
// recording by tcmalloc heap profiling.
class BASE_EXPORT ScopedTraceMemory {
public:
struct ScopeData {
const char* category;
const char* name;
};
// Memory for |category| and |name| must be static, for example, literal
// strings in a TRACE_EVENT macro.
ScopedTraceMemory(const char* category, const char* name) {
if (!enabled_)
return;
Initialize(category, name);
}
~ScopedTraceMemory() {
if (!enabled_)
return;
Destroy();
}
// Enables the storing of trace names on a per-thread stack.
static void set_enabled(bool enabled) { enabled_ = enabled; }
// Testing interface:
static void InitForTest();
static void CleanupForTest();
static int GetStackDepthForTest();
static ScopeData GetScopeDataForTest(int stack_index);
private:
void Initialize(const char* category, const char* name);
void Destroy();
static bool enabled_;
DISALLOW_COPY_AND_ASSIGN(ScopedTraceMemory);
};
//////////////////////////////////////////////////////////////////////////////
// Converts tcmalloc's heap profiler data with pseudo-stacks in |input| to
// trace event compatible JSON and appends to |output|. Visible for testing.
BASE_EXPORT void AppendHeapProfileAsTraceFormat(const char* input,
std::string* output);
// Converts the first |line| of heap profiler data, which contains totals for
// all allocations in a special format, into trace event compatible JSON and
// appends to |output|. Visible for testing.
BASE_EXPORT void AppendHeapProfileTotalsAsTraceFormat(const std::string& line,
std::string* output);
// Converts a single |line| of heap profiler data into trace event compatible
// JSON and appends to |output|. Returns true if the line was valid and has a
// non-zero number of current allocations. Visible for testing.
BASE_EXPORT bool AppendHeapProfileLineAsTraceFormat(const std::string& line,
std::string* output);
// Returns a pointer to a string given its hexadecimal address in |hex_address|.
// Handles both 32-bit and 64-bit addresses. Returns "null" for null pointers
// and "error" if |address| could not be parsed. Visible for testing.
BASE_EXPORT const char* StringFromHexAddress(const std::string& hex_address);
} // namespace trace_event
} // namespace base
// Make local variables with unique names based on the line number. Note that
// the extra level of redirection is needed.
#define INTERNAL_TRACE_MEMORY_ID3(line) trace_memory_unique_##line
#define INTERNAL_TRACE_MEMORY_ID2(line) INTERNAL_TRACE_MEMORY_ID3(line)
#define INTERNAL_TRACE_MEMORY_ID INTERNAL_TRACE_MEMORY_ID2(__LINE__)
// This is the core macro that adds a scope to each TRACE_EVENT location.
// It generates a unique local variable name using the macros above.
#if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
#define INTERNAL_TRACE_MEMORY(category, name) \
base::trace_event::ScopedTraceMemory INTERNAL_TRACE_MEMORY_ID(category, name);
#else
#define INTERNAL_TRACE_MEMORY(category, name)
#endif // defined(TRACE_MEMORY_SUPPORTED)
// A special trace name that allows us to ignore memory allocations inside
// the memory dump system itself. The allocations are recorded, but the
// visualizer skips them. Must match the value in heap.js.
#define TRACE_MEMORY_IGNORE "trace-memory-ignore"
#endif // BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_H_
| 39.168605 | 80 | 0.738162 |
6ffa90f0cf96c9d4cf5f103617be640f64f69f44 | 831 | h | C | System/Library/PrivateFrameworks/AutoLoop.framework/VideoAccessIndexNorm.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 2 | 2021-11-02T09:23:27.000Z | 2022-03-28T08:21:57.000Z | System/Library/PrivateFrameworks/AutoLoop.framework/VideoAccessIndexNorm.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/AutoLoop.framework/VideoAccessIndexNorm.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 1 | 2022-03-28T08:21:59.000Z | 2022-03-28T08:21:59.000Z | /*
* This header is generated by classdump-dyld 1.5
* on Wednesday, October 27, 2021 at 3:18:36 PM Mountain Standard Time
* Operating System: Version 13.5.1 (Build 17F80)
* Image Source: /System/Library/PrivateFrameworks/AutoLoop.framework/AutoLoop
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
#import <AutoLoop/AutoLoop-Structs.h>
#import <AutoLoop/VideoAccessIndex.h>
@interface VideoAccessIndexNorm : VideoAccessIndex {
FrameTimeNormalizer* mNormalizer;
}
-(id)initFromFile:(id)arg1 pixelFormat:(unsigned)arg2 normalizer:(FrameTimeNormalizer*)arg3 ;
-(int)getFrameAtIndex:(unsigned)arg1 pixBuf:(_CVBuffer*)arg2 ;
@end
| 39.571429 | 130 | 0.652226 |
cb7042bf44a2c9dc6687a73bf846b5756255694c | 579 | c | C | GUI/Shaders/vertex_shader.c | pracedru/PracedruDesign | e6e313ee3efb377a8e393e5276eb9daa172e1c58 | [
"BSD-3-Clause"
] | 3 | 2019-01-09T09:32:56.000Z | 2019-02-14T18:27:33.000Z | GUI/Shaders/vertex_shader.c | pracedru/PracedruDesign | e6e313ee3efb377a8e393e5276eb9daa172e1c58 | [
"BSD-3-Clause"
] | null | null | null | GUI/Shaders/vertex_shader.c | pracedru/PracedruDesign | e6e313ee3efb377a8e393e5276eb9daa172e1c58 | [
"BSD-3-Clause"
] | null | null | null | #version 130
in highp vec4 vertex;
in highp vec4 normal;
out highp vec3 position;
out highp vec3 eye_norm;
out highp vec3 globe_norm;
out highp vec3 eye_up;
out highp vec3 eye_vector;
uniform mediump mat3 normal_matrix;
uniform mediump mat4 model_view_matrix;
uniform mediump mat4 mvp;
void main(void)
{
gl_Position = mvp * vertex;
position = vec3(mvp * vertex);
eye_norm = normalize(normal_matrix * normal.xyz);
eye_up = normalize(normal_matrix * vec3(0.0,1.0,0.0));
eye_vector = vec3(normalize(model_view_matrix * vertex));
globe_norm = normal.xyz;
} | 25.173913 | 61 | 0.739206 |
9913e6ec6489867b0e341ebfc486f30a11e13e2b | 6,606 | c | C | app/serials/server/config.c | arinichevN/aind | d4f6c19db0cf7e1e764d3563842c0797156d6dfb | [
"Unlicense"
] | null | null | null | app/serials/server/config.c | arinichevN/aind | d4f6c19db0cf7e1e764d3563842c0797156d6dfb | [
"Unlicense"
] | null | null | null | app/serials/server/config.c | arinichevN/aind | d4f6c19db0cf7e1e764d3563842c0797156d6dfb | [
"Unlicense"
] | null | null | null | #include "config.h"
int srvc_forThisApp(Acpls *server){
int id;
if(acp_packGetCellI(server->acpl->buf, ACP_REQUEST_IND_ID, &id)){
if(id == app_id){
return 1;
}else{
printdln("\tnot for this app");
return 0;
}
}
printdln("\tfailed to get app_id");
return 0;
}
#ifdef USE_AOIDS
Aoid *srvc_getAoid(Acpls *server){
int id;
if(acp_packGetCellI(server->acpl->buf, AOID_ACP_REQUEST_IND_ID, &id)){
FOREACH_APP_AOID{
if(id == oid->id){
return oid;
}
}
printdln("\tAOID not found");
return NULL;
}
printdln("\tfailed to get oid_id");
return NULL;
}
void acnf_aoidGetFirst(Acpls *server, int command){
if(!srvc_forThisApp(server)) {acpls_reset(server); return;}
int oid_id = AOID_ID_UNKNOWN;
int oid_parent_id = AOID_ID_UNKNOWN;
int oid_kind = AOID_KIND_UNKNOWN;
int oid_description = AOID_DESCRIPTION_UNKNOWN;
Aoid *oid = &aoid;
if(oid != NULL){
oid_id = oid->id;
oid_kind = oid->kind;
oid_description = oid->description;
if(oid->parent != NULL){
oid_parent_id = oid->parent->id;
}
}
if(acp_buildPack5I(server->acpl->buf, ACP_BUF_MAX_LENGTH, ACP_SIGN_RESPONSE, app_id, oid_id, oid_parent_id, oid_kind, oid_description)){
acpls_beginWrite(server);
return;
}
acpls_reset(server);
}
void acnf_aoidGetNext(Acpls *server, int command){
if(!srvc_forThisApp(server)) {acpls_reset(server); return;}
int oid_id = AOID_ID_UNKNOWN;
int oid_parent_id = AOID_ID_UNKNOWN;
int oid_kind = AOID_KIND_UNKNOWN;
int oid_description = AOID_DESCRIPTION_UNKNOWN;
Aoid *prev_oid = srvc_getAoid(server);
if(prev_oid != NULL){
if(prev_oid->next != NULL){
Aoid *oid = prev_oid->next;
oid_id = oid->id;
oid_kind = oid->kind;
oid_description = oid->description;
if(oid->parent != NULL){
oid_parent_id = oid->parent->id;
}
}
}
if(acp_buildPack5I(server->acpl->buf, ACP_BUF_MAX_LENGTH, ACP_SIGN_RESPONSE, app_id, oid_id, oid_parent_id, oid_kind, oid_description)){
acpls_beginWrite(server);
return;
}
acpls_reset(server);
}
void acnf_aoidServeRequest(Acpls *server, int command){
if(!srvc_forThisApp(server)) {acpls_reset(server); return;}
Aoid *oid = srvc_getAoid(server);
if(oid != NULL){
if(oid->serveRequest != NULL){
oid->serveRequest(oid->data, oid, server, command);
return;
}
}
acpls_reset(server);
}
#endif
#ifdef USE_NOIDS
Noid *srvc_getNoid(Acpls *server){
int id;
if(acp_packGetCellI(server->acpl->buf, NOID_ACP_REQUEST_IND_ID, &id)){
FOREACH_APP_NOID{
if(id == *oid->id){
return oid;
}
}
printdln("\tNOID not found");
return NULL;
}
printdln("\tfailed to get oid_id");
return NULL;
}
void acnf_noidServeRequest(Acpls *server, int command){
Noid *oid = srvc_getNoid(server);
if(oid != NULL){
if(oid->serveRequest != NULL){
oid->serveRequest(oid->data, oid, server, command);
return;
}
}
acpls_reset(server);
}
void acnf_noidExists(Acpls *server, int command){
int id;
if(acp_packGetCellI(server->acpl->buf, NOID_ACP_REQUEST_IND_ID, &id)){
if(id == NOID_ID_BROADCAST){
goto found;
}
FOREACH_APP_NOID{
if(id == *oid->id && oid->kind != NOID_KIND_EXTERN){
goto found;
}
}
printd(id); printdln(" NOID not found");
acpls_reset(server);
return;
}
printdln("\tfailed to get oid_id");
acpls_reset(server);
return;
found:
if(acp_buildPackII(server->acpl->buf, ACP_BUF_MAX_LENGTH, ACP_SIGN_RESPONSE, id, 1)){
acpls_beginWrite(server);
return;
}
printdln("\tfailed to build package");
acpls_reset(server);
}
void acnf_noidGetFirst(Acpls *server, int command){
if(noid_top == NULL){
acpls_reset(server);
return;
}
if(noid_top->kind != NOID_KIND_FIRST){
acpls_reset(server);
return;
}
int next_id = NOID_ID_UNKNOWN;
if(noid_top->next != NULL){
next_id = *noid_top->next->id;
}
if(acp_buildPackII(server->acpl->buf, ACP_BUF_MAX_LENGTH, ACP_SIGN_RESPONSE, *noid_top->id, next_id)){
acpls_beginWrite(server);
return;
}
acpls_reset(server);
}
void acnf_noidGetNext(Acpls *server, int command){
Noid *noid = srvc_getNoid(server);
if(noid != NULL){
if(noid->kind != NOID_KIND_EXTERN){
int next_id = NOID_ID_UNKNOWN;
if(noid->next != NULL){
next_id = *noid->next->id;
}
if(acp_buildPackII(server->acpl->buf, ACP_BUF_MAX_LENGTH, ACP_SIGN_RESPONSE, *noid->id, next_id)){
acpls_beginWrite(server);
return;
}
}
}
acpls_reset(server);
}
void acnf_getAppId(Acpls *server, int command){
int id;
if(acp_packGetCellI(server->acpl->buf, NOID_ACP_REQUEST_IND_ID, &id)){
if(id == NOID_ID_BROADCAST){
if(acp_buildPackI(server->acpl->buf, ACP_BUF_MAX_LENGTH, ACP_SIGN_RESPONSE, app_id)){
acpls_beginWrite(server);
return;
}
printdln("\tfailed to build package");
acpls_reset(server);
return;
}
printdln("\tbroadcast id expected");
acpls_reset(server);
return;
}
printdln("\tfailed to get oid_id");
acpls_reset(server);
}
#endif
AcplsCommandNode acnodes[] = {
#ifdef USE_NOIDS
{CMD_NOID_GET_FTS, acnf_noidServeRequest},
{CMD_NOID_GET_STATE, acnf_noidServeRequest},
{CMD_NOID_GET_ERROR, acnf_noidServeRequest},
{CMD_NOID_GET_DEVICE_KIND, acnf_noidServeRequest},
{CMD_NOID_SET_GOAL, acnf_noidServeRequest},
{CMD_NOID_SET_TEXT, acnf_noidServeRequest},
{CMD_NOID_SET_TEXT_BLINK, acnf_noidServeRequest},
{CMD_NOID_START, acnf_noidServeRequest},
{CMD_NOID_STOP, acnf_noidServeRequest},
{CMD_NOID_RESET, acnf_noidServeRequest},
{CMD_NOID_GET_EXISTS, acnf_noidExists},
{CMD_NOID_GET_ACP_COMMAND_SUPPORTED_NEXT, acnf_noidServeRequest},
{CMD_NOID_GET_ACP_COMMAND_SUPPORTED_FIRST, acnf_noidServeRequest},
{CMD_NOID_GET_NEXT, acnf_noidGetNext},
{CMD_NOID_GET_FIRST, acnf_noidGetFirst},
{CMD_APP_GET_ID, acnf_getAppId},
#endif
#ifdef USE_AOIDS
{CMD_AOID_GET_ACP_COMMAND_SUPPORTED_NEXT, acnf_aoidServeRequest},
{CMD_AOID_GET_ACP_COMMAND_SUPPORTED_FIRST, acnf_aoidServeRequest},
{CMD_AOID_GET_NEXT, acnf_aoidGetNext},
{CMD_AOID_GET_FIRST, acnf_aoidGetFirst},
{CMD_AOID_START, acnf_aoidServeRequest},
{CMD_AOID_STOP, acnf_aoidServeRequest},
{CMD_AOID_RESET, acnf_aoidServeRequest},
{CMD_AOID_SET_NVRAM_VALUE, acnf_aoidServeRequest},
{CMD_AOID_GET_RAM_VALUE, acnf_aoidServeRequest},
{CMD_AOID_GET_NVRAM_VALUE, acnf_aoidServeRequest},
{CMD_AOID_DELETE, acnf_aoidServeRequest},
{CMD_AOID_ADD, acnf_aoidServeRequest},
#endif
};
#define ACPL_CNODE_COUNT (sizeof acnodes / sizeof acnodes[0])
AcplsCommandNodeList server_nodes = {.items = acnodes, .length = ACPL_CNODE_COUNT, .max_length = ACPL_CNODE_COUNT};
| 26.53012 | 137 | 0.716318 |
4108afecc29578d860b9c8ab5994f3cd5e3cccc2 | 7,258 | h | C | node_modules/pixel-change/src/engine.h | laitrungdung2000/motion-pam | 58c7a88182f230b254def4386b6f06244ac70776 | [
"MIT"
] | null | null | null | node_modules/pixel-change/src/engine.h | laitrungdung2000/motion-pam | 58c7a88182f230b254def4386b6f06244ac70776 | [
"MIT"
] | null | null | null | node_modules/pixel-change/src/engine.h | laitrungdung2000/motion-pam | 58c7a88182f230b254def4386b6f06244ac70776 | [
"MIT"
] | null | null | null | #ifndef SRC_ENGINE_H_
#define SRC_ENGINE_H_
#include "napi.h"
#include <cstdint>
#include <string>
#include <vector>
#include <memory>
enum Engines {// ordered by depth -> target -> response
GRAY_ALL_PERCENT = 0,
GRAY_ALL_BOUNDS = 1,
GRAY_ALL_BLOBS = 2,
GRAY_REGION_PERCENT = 10,
GRAY_REGION_BOUNDS = 11,
GRAY_REGION_BLOBS = 12,
GRAY_REGIONS_PERCENT = 20,
GRAY_REGIONS_BOUNDS = 21,
GRAY_REGIONS_BLOBS = 22,
RGB_ALL_PERCENT = 100,
RGB_ALL_BOUNDS = 101,
RGB_ALL_BLOBS = 102,
RGB_REGION_PERCENT = 110,
RGB_REGION_BOUNDS = 111,
RGB_REGION_BLOBS = 112,
RGB_REGIONS_PERCENT = 120,
RGB_REGIONS_BOUNDS = 121,
RGB_REGIONS_BLOBS = 122,
};
struct Config {
uint32_t width;
uint32_t height;
uint32_t depth;
uint32_t pixelCount;
uint32_t byteLength;
bool draw;
Config() = default;
Config(uint32_t _width, uint32_t _height, uint32_t _depth, bool _draw) : width(_width), height(_height), depth(_depth), pixelCount(_width * _height), byteLength(_width * _height * _depth), draw(_draw) {}
};
struct All {
std::string name;
uint32_t difference;
uint32_t percent;
};
struct Bounds {
uint32_t minX;
uint32_t maxX;
uint32_t minY;
uint32_t maxY;
void expandTo(uint32_t x, uint32_t y) {
if (x < minX) minX = x;
if (x > maxX) maxX = x;
if (y < minY) minY = y;
if (y > maxY) maxY = y;
}
};
struct Region {
std::string name;// 24
std::vector<bool> bitset;// 24
uint32_t bitsetCount;// 4
uint32_t difference;// 4
uint32_t percent;// 4
Bounds bounds;
};
struct Blob {
uint32_t label;
Bounds bounds;
uint32_t percent;
bool flagged;
Blob() = default;
explicit Blob(Bounds _bounds) : label(0), bounds(_bounds), percent(0), flagged(false) {}
};
struct Pixels {
std::unique_ptr<uint8_t[]> ptr;
//uint8_t *ptr;
uint32_t size;
Pixels() : ptr(nullptr), size(0) {}
//Pixels(uint8_t *_ptr, uint32_t _size) : ptr(_ptr), size(_size) {}
};
struct Result {
const char *name;
uint32_t percent;
Bounds bounds;
std::vector<Blob> blobs;
bool flagged;
Result() : name(nullptr), percent(0), bounds(Bounds{0, 0, 0, 0}), blobs(std::vector<Blob>()), flagged(false) {}
explicit Result(const char *_name) : name(_name), percent(0), bounds(Bounds{0, 0, 0, 0}), blobs(std::vector<Blob>()), flagged(false) {}
Result(const char *_name, Bounds _bounds) : name(_name), percent(0), bounds(_bounds), blobs(std::vector<Blob>()), flagged(false) {}
};
// placeholder for CPP results that will be converted to JS values
struct CallbackData {
std::vector<Result> results;
Pixels pixels;
};
typedef std::function<void(const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData)> ExecuteFunc;
typedef std::function<void(const Napi::Env &env, const Napi::Function &cb, CallbackData &callbackData)> CallbackFunc;
// absolute value
inline uint32_t
AbsInt(int32_t n) {
return static_cast<uint32_t>(n < 0 ? -n : n);
}
// measure difference of gray bytes
inline uint32_t
GrayDiff(const uint8_t *buf0, const uint8_t *buf1, const uint32_t i) {
//return static_cast<uint32_t>(std::abs(buf0[i] - buf1[i]));
return AbsInt(buf0[i] - buf1[i]);
}
// measure difference of rgb(a) bytes using average
inline uint32_t
RgbDiff(const uint8_t *buf0, const uint8_t *buf1, uint32_t i) {
//return std::abs(buf0[i] + buf0[i + 1] + buf0[i + 2] - buf1[i] - buf1[i + 1] - buf1[i + 2]) / 3u;
return AbsInt(buf0[i] + buf0[i + 1] + buf0[i + 2] - buf1[i] - buf1[i + 1] - buf1[i + 2]) / 3u;
}
// convert js bitset to cpp
std::vector<bool>
BitsetJsToCpp(const Napi::Buffer<bool> &bitsetJs);
// convert js region to cpp
Region
RegionJsToCpp(const Napi::Object ®ionJs);
// convert js regions to cpp
std::vector<Region>
RegionsJsToCpp(const Napi::Array ®ionsJs);
// gray all percent
void
GrayAllPercentExecute(const Config &config, const All &all, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray single region percent
void
GrayRegionPercentExecute(const Config &config, const Region ®ion, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray multi regions bounds
void
GrayRegionsPercentExecute(const Config &config, const std::vector<Region> ®ions, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray all bounds
void
GrayAllBoundsExecute(const Config &config, const All &all, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray single region bounds
void
GrayRegionBoundsExecute(const Config &config, const Region ®ion, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray multi regions bounds
void
GrayRegionsBoundsExecute(const Config &config, const std::vector<Region> ®ions, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray all blobs
void
GrayAllBlobsExecute(const Config &config, const All &all, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray single region blobs
void
GrayRegionBlobsExecute(const Config &config, const Region ®ion, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// gray multi regions blobs
void
GrayRegionsBlobsExecute(const Config &config, const std::vector<Region> ®ions, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb all percent
void
RgbAllPercentExecute(const Config &config, const All &all, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb single region percent
void
RgbRegionPercentExecute(const Config &config, const Region ®ion, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb multi regions bounds
void
RgbRegionsPercentExecute(const Config &config, const std::vector<Region> ®ions, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb all bounds
void
RgbAllBoundsExecute(const Config &config, const All &all, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb single region bounds
void
RgbRegionBoundsExecute(const Config &config, const Region ®ion, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb multi regions bounds
void
RgbRegionsBoundsExecute(const Config &config, const std::vector<Region> ®ions, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb all blobs
void
RgbAllBlobsExecute(const Config &config, const All &all, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb single region blobs
void
RgbRegionBlobsExecute(const Config &config, const Region ®ion, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// rgb multi regions blobs
void
RgbRegionsBlobsExecute(const Config &config, const std::vector<Region> ®ions, const uint8_t *buf0, const uint8_t *buf1, CallbackData &callbackData);
// determine engine type
uint32_t
EngineType(uint32_t depth, uint32_t regionsLength, const std::string &response);
// set execute and callback functions
void
SetFunctions(const Napi::Object &config, ExecuteFunc &executeFunc, CallbackFunc &callbackFunc);
#endif | 30.885106 | 207 | 0.720033 |
85ff292b3200f77ee1169820247f4d3480cdf7d7 | 2,390 | h | C | third_party/webrtc/include/chromium/src/blimp/client/core/compositor/blimp_compositor_frame_sink.h | ssaroha/node-webrtc | 74335bd07cbc52484a88c8eeb336c9bd001928a8 | [
"BSD-2-Clause"
] | 3 | 2018-02-22T18:06:56.000Z | 2021-08-28T12:49:27.000Z | third_party/webrtc/include/chromium/src/blimp/client/core/compositor/blimp_compositor_frame_sink.h | ssaroha/node-webrtc | 74335bd07cbc52484a88c8eeb336c9bd001928a8 | [
"BSD-2-Clause"
] | null | null | null | third_party/webrtc/include/chromium/src/blimp/client/core/compositor/blimp_compositor_frame_sink.h | ssaroha/node-webrtc | 74335bd07cbc52484a88c8eeb336c9bd001928a8 | [
"BSD-2-Clause"
] | 2 | 2017-08-16T08:15:01.000Z | 2018-03-27T00:07:30.000Z | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_FRAME_SINK_H_
#define BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_FRAME_SINK_H_
#include <memory>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "blimp/client/core/compositor/blimp_compositor_frame_sink_proxy.h"
#include "cc/output/compositor_frame_sink.h"
namespace base {
class SingleThreadTaskRunner;
} // namespace base
namespace cc {
class BeginFrameSource;
class ContextProvider;
} // namespace cc
namespace blimp {
namespace client {
// This class is created on the main thread, but then becomes bound to the
// compositor thread and will be destroyed there (soon, crbug.com/640730).
class BlimpCompositorFrameSink : public cc::CompositorFrameSink,
public BlimpCompositorFrameSinkProxyClient {
public:
BlimpCompositorFrameSink(
scoped_refptr<cc::ContextProvider> compositor_context_provider,
scoped_refptr<cc::ContextProvider> worker_context_provider,
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
base::WeakPtr<BlimpCompositorFrameSinkProxy> main_thread_proxy);
~BlimpCompositorFrameSink() override;
// cc::CompositorFrameSink implementation.
bool BindToClient(cc::CompositorFrameSinkClient* client) override;
void DetachFromClient() override;
void SubmitCompositorFrame(cc::CompositorFrame frame) override;
// BlimpCompositorFrameSinkProxyClient implementation.
void ReclaimCompositorResources(
const cc::ReturnedResourceArray& resources) override;
void SubmitCompositorFrameAck() override;
private:
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
base::WeakPtr<BlimpCompositorFrameSinkProxy> main_thread_proxy_;
// This CompositorFrameSink is responsible for providing the BeginFrameSource
// to drive frame creation. This will be built on the compositor impl thread
// at BindToClient call time.
std::unique_ptr<cc::BeginFrameSource> begin_frame_source_;
base::WeakPtrFactory<BlimpCompositorFrameSink> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(BlimpCompositorFrameSink);
};
} // namespace client
} // namespace blimp
#endif // BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_FRAME_SINK_H_
| 35.147059 | 79 | 0.79749 |
3e2c0fddd1b9ff367efe19ed23a6151c59a7085c | 6,739 | h | C | pywinrt/winsdk/src/py.Windows.Web.UI.h | pywinrt/python-winsdk | 1e2958a712949579f5e84d38220062b2cec12511 | [
"MIT"
] | 3 | 2022-02-14T14:53:08.000Z | 2022-03-29T20:48:54.000Z | pywinrt/winsdk/src/py.Windows.Web.UI.h | pywinrt/python-winsdk | 1e2958a712949579f5e84d38220062b2cec12511 | [
"MIT"
] | 4 | 2022-01-28T02:53:52.000Z | 2022-02-26T18:10:05.000Z | pywinrt/winsdk/src/py.Windows.Web.UI.h | pywinrt/python-winsdk | 1e2958a712949579f5e84d38220062b2cec12511 | [
"MIT"
] | null | null | null | // WARNING: Please don't edit this file. It was generated by Python/WinRT v1.0.0-beta.4
#pragma once
#include "pybase.h"
#if __has_include("py.Windows.ApplicationModel.DataTransfer.h")
#include "py.Windows.ApplicationModel.DataTransfer.h"
#endif
#if __has_include("py.Windows.Foundation.h")
#include "py.Windows.Foundation.h"
#endif
#if __has_include("py.Windows.Foundation.Collections.h")
#include "py.Windows.Foundation.Collections.h"
#endif
#if __has_include("py.Windows.Storage.Streams.h")
#include "py.Windows.Storage.Streams.h"
#endif
#if __has_include("py.Windows.UI.h")
#include "py.Windows.UI.h"
#endif
#if __has_include("py.Windows.Web.h")
#include "py.Windows.Web.h"
#endif
#if __has_include("py.Windows.Web.Http.h")
#include "py.Windows.Web.Http.h"
#endif
#include <winrt/Windows.Web.UI.h>
namespace py::proj::Windows::Web::UI
{}
namespace py::impl::Windows::Web::UI
{}
namespace py::wrapper::Windows::Web::UI
{
using WebViewControlContentLoadingEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlContentLoadingEventArgs>;
using WebViewControlDOMContentLoadedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlDOMContentLoadedEventArgs>;
using WebViewControlDeferredPermissionRequest = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlDeferredPermissionRequest>;
using WebViewControlLongRunningScriptDetectedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlLongRunningScriptDetectedEventArgs>;
using WebViewControlNavigationCompletedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlNavigationCompletedEventArgs>;
using WebViewControlNavigationStartingEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlNavigationStartingEventArgs>;
using WebViewControlNewWindowRequestedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlNewWindowRequestedEventArgs>;
using WebViewControlPermissionRequest = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlPermissionRequest>;
using WebViewControlPermissionRequestedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlPermissionRequestedEventArgs>;
using WebViewControlScriptNotifyEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlScriptNotifyEventArgs>;
using WebViewControlSettings = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlSettings>;
using WebViewControlUnsupportedUriSchemeIdentifiedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlUnsupportedUriSchemeIdentifiedEventArgs>;
using WebViewControlUnviewableContentIdentifiedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlUnviewableContentIdentifiedEventArgs>;
using WebViewControlWebResourceRequestedEventArgs = py::winrt_wrapper<winrt::Windows::Web::UI::WebViewControlWebResourceRequestedEventArgs>;
using IWebViewControl = py::winrt_wrapper<winrt::Windows::Web::UI::IWebViewControl>;
using IWebViewControl2 = py::winrt_wrapper<winrt::Windows::Web::UI::IWebViewControl2>;
}
namespace py
{
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlContentLoadingEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlDOMContentLoadedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlDeferredPermissionRequest>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlLongRunningScriptDetectedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlNavigationCompletedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlNavigationStartingEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlNewWindowRequestedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlPermissionRequest>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlPermissionRequestedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlScriptNotifyEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlSettings>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlUnsupportedUriSchemeIdentifiedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlUnviewableContentIdentifiedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::WebViewControlWebResourceRequestedEventArgs>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::IWebViewControl>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
template<>
struct winrt_type<winrt::Windows::Web::UI::IWebViewControl2>
{
static PyTypeObject* python_type;
static PyTypeObject* get_python_type() { return python_type; }
};
}
| 37.859551 | 164 | 0.742247 |
8f5e7de49cb4ea93df5ec1d62e27ea842cfd69bd | 3,759 | h | C | tensorflow/core/common_runtime/dml/dml_pooled_heap.h | BenjaminWegener/tensorflow-directml | ecdbdbd2691e17dcc462fc49138fc7cc1536b7d5 | [
"Apache-2.0"
] | 351 | 2020-09-01T08:36:28.000Z | 2022-03-29T06:54:29.000Z | tensorflow/core/common_runtime/dml/dml_pooled_heap.h | BenjaminWegener/tensorflow-directml | ecdbdbd2691e17dcc462fc49138fc7cc1536b7d5 | [
"Apache-2.0"
] | 80 | 2020-09-02T01:57:33.000Z | 2022-03-28T08:51:57.000Z | tensorflow/core/common_runtime/dml/dml_pooled_heap.h | BenjaminWegener/tensorflow-directml | ecdbdbd2691e17dcc462fc49138fc7cc1536b7d5 | [
"Apache-2.0"
] | 29 | 2020-09-14T06:29:58.000Z | 2022-03-01T09:21:17.000Z | /* Copyright (c) Microsoft 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 "dml_common.h"
#include "dml_gpu_event.h"
#include "tensorflow/core/lib/core/status.h"
namespace tensorflow {
// Base class for implementing a non-blocking, ring-buffer style D3D12 heap
// allocator where allocations are automatically freed once usage has completed
// on the GPU.
class DmlPooledHeap {
public:
// Releases unused capacity.
void Trim();
uint64_t Capacity() const { return total_capacity_; }
protected:
static constexpr uint64_t kMinChunkSize = 1024 * 1024; // 1MB
// In bytes; as per D3D12 requirement for buffers
static constexpr uint64_t kAllocationAlignment = 512;
// A suballoction from a chunk
struct Allocation {
uint64_t size_in_bytes;
// The offset, in bytes, from the beginning of the chunk to the beginning of
// this allocation
uint64_t offset_in_chunk;
// The event that will be signaled to when the GPU is done executing work
// that uses this allocation
DmlGpuEvent done_event;
};
// Represents a single contiguous heap from which we carve out suballocations.
// Ranges are suballocated from the heap in a ring-buffer fashion.
struct Chunk {
uint64_t capacity_in_bytes; // The total size of the heap, in bytes
Microsoft::WRL::ComPtr<ID3D12Resource> resource;
// Allocations are sorted by ascending fence value - that is, least to most
// recently allocated
std::list<Allocation> allocations;
};
// Calls AssertInvariants on construction and again on destruction
class InvariantChecker {
public:
InvariantChecker(DmlPooledHeap* parent) : parent_(parent) {
parent_->AssertInvariants();
}
~InvariantChecker() { parent_->AssertInvariants(); }
private:
DmlPooledHeap* parent_;
};
DmlPooledHeap(ID3D12Device* device, const D3D12_HEAP_PROPERTIES& heap_props,
D3D12_RESOURCE_STATES barrier_state);
// Finds or creates a chunk with enough space to accommodate an allocation of
// the given size, and returns a pointer to the chunk and allocation offset.
Status Reserve(uint64_t size_in_bytes,
/*out*/ DmlPooledHeap::Chunk** chunk_ptr,
/*out*/ uint64_t* offset_in_chunk);
void ReclaimAllocations(); // Frees all allocations which are no longer being
// used by the GPU.
private:
// Attempts to find enough unused space in the supplied chunk to accommodate
// the given allocation size. Returns the offset of that memory if successful,
// null if there wasn't enough space.
static absl::optional<uint64_t> FindOffsetForAllocation(
const Chunk& chunk, uint64_t size_in_bytes);
Status CreateChunk(ID3D12Device* device, uint64_t size_in_bytes,
/*out*/ DmlPooledHeap::Chunk* chunk);
void AssertInvariants();
Microsoft::WRL::ComPtr<ID3D12Device> device_;
D3D12_HEAP_PROPERTIES heap_props_;
D3D12_RESOURCE_STATES barrier_state_;
// sorted ascending by capacity (heap size)
std::vector<Chunk> chunks_;
uint64_t total_capacity_ = 0; // Total size of all chunks, in bytes
};
} // namespace tensorflow
| 34.172727 | 80 | 0.712157 |
f5e83e9bd10a87ba424961622465b427fc4f469e | 1,839 | h | C | include/mimick/va.h | devnexen/Mimick | 93b10bfe7f81d10fc9969062f498f64b1563346c | [
"MIT"
] | 99 | 2016-02-27T01:05:07.000Z | 2022-03-10T01:15:41.000Z | include/mimick/va.h | devnexen/Mimick | 93b10bfe7f81d10fc9969062f498f64b1563346c | [
"MIT"
] | 21 | 2016-05-18T13:56:53.000Z | 2021-11-12T12:37:48.000Z | include/mimick/va.h | devnexen/Mimick | 93b10bfe7f81d10fc9969062f498f64b1563346c | [
"MIT"
] | 16 | 2016-10-25T02:44:57.000Z | 2021-06-11T03:12:04.000Z | /*
* The MIT License (MIT)
*
* Copyright © 2016 Franklin "Snaipe" Mathieu <http://snai.pe/>
*
* 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 MMK_VA_H_
# define MMK_VA_H_
# include "string.h"
# include "../mimick.h"
/* mmk_va_args is actually just a preprocessed token without any real
definition -- we just reserve it anyway in mimick.h. */
# undef mmk_va_args
# define mmk_make_va_param(vd, vl, type) do { \
(vd) = mmk_malloc(sizeof (struct mmk_va_param) + sizeof (type)); \
(vd)->size = sizeof (type); \
type val = va_arg(vl, type); \
mmk_memcpy((vd)->data, &val, sizeof (type)); \
} while (0)
#endif /* !MMK_VA_H_ */
| 43.785714 | 80 | 0.663404 |
acb2a165546837ffd7c807a2222fd5ed081743fe | 9,267 | h | C | src/MeshDataNonConformingHexaElement.h | yoshiya-usui/makeCutawayForGMT | 7bfc010c3e08eeba79e2217e78ee20bb0653545e | [
"MIT"
] | 1 | 2020-11-18T22:36:20.000Z | 2020-11-18T22:36:20.000Z | src/MeshDataNonConformingHexaElement.h | yoshiya-usui/makeCutawayForGMT | 7bfc010c3e08eeba79e2217e78ee20bb0653545e | [
"MIT"
] | null | null | null | src/MeshDataNonConformingHexaElement.h | yoshiya-usui/makeCutawayForGMT | 7bfc010c3e08eeba79e2217e78ee20bb0653545e | [
"MIT"
] | null | null | null | //--------------------------------------------------------------------------
// MIT License
//
// Copyright (c) 2021 Yoshiya Usui
//
// 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 DBLDEF_MESHDATA_NONCONFORMING_HEXA_ELEMENT
#define DBLDEF_MESHDATA_NONCONFORMING_HEXA_ELEMENT
#include <vector>
#include "MeshData.h"
// Class of FEM mesh for brick element
class MeshDataNonConformingHexaElement : public MeshData {
public:
// Constructer
MeshDataNonConformingHexaElement();
// Destructer
virtual ~MeshDataNonConformingHexaElement();
// Input mesh data from "mesh.dat"
virtual void inputMeshData();
// Find element including a point
int findElementIncludingPoint( const double locX, const double locY, const double locZ, double& xi, double& eta, double& zeta ) const;
// Find elements including point on the surface of the earth
int findElementIncludingPointOnSurface( const double locX, const double locY, int& faceID, double& xi, double& eta, double& zeta,
const bool useUpperElem, const bool modLoc, double& locXMod, double& locYMod ) const;
// Find element including a point on the Y-Z plane and return element ID of 2D mesh
int findElementIncludingPointOnYZPlaneAndReturnElemID2D( const int iPlane, const double locY, const double locZ, double& xi, double& eta ) const;
// Find element including a point on the Z-X plane and return element ID of 2D mesh
int findElementIncludingPointOnZXPlaneAndReturnElemID2D( const int iPlane, const double locX, const double locZ, double& xi, double& eta ) const;
// Get mesh type
int getMeshType() const;
// Get ID of a neighbor element
int getIDOfNeighborElement( const int iElem, const int iFace, const int num ) const;
// Get number of neighbor elements for an element-face
int getNumNeighborElement( const int iElem, const int iFace ) const;
// Get flag specifing whether an element face has slave faces
bool faceSlaveElements( const int iElem, const int iFace ) const;
// Get flag specifing whether an element face is outer boundary
bool isOuterBoundary( const int iElem, const int iFace ) const;
// Get local face ID of elements belonging to the boundary planes
int getFaceIDLocalFromElementBoundaryPlanes( const int iPlane, const int iElem ) const;
// Get global node ID of specified element and edge
int getNodeIDGlobalFromElementAndEdge( const int iElem, const int iEdge, const int num ) const;
// Get global node ID of specified element and face
int getNodeIDGlobalFromElementAndFace( const int iElem, const int iFace, const int num ) const;
// Get global node ID of specified element belonging to the boundary planes
int getNodeIDGlobalFromElementBoundaryPlanes( const int iPlane, const int iElem, const int num ) const;
// Get global node ID from ID of element belonging to the boundary planes and its edge index
int getNodeIDGlobalFromElementAndEdgeBoundaryPlanes( const int iPlane, const int iElem, const int iEdge, const int num ) const;
// Get X coordinate of node of specified element belonging to the boundary planes
double getCoordXFromElementBoundaryPlanes( const int iPlane, const int iElem, const int num ) const;
// Get Y coordinate of node of specified element belonging to the boundary planes
double getCoordYFromElementBoundaryPlanes( const int iPlane, const int iElem, const int num ) const;
// Get Z coordinate of node of specified element belonging to the boundary planes
double getCoordZFromElementBoundaryPlanes( const int iPlane, const int iElem, const int num ) const;
// Get local edge ID from local face ID
int getEdgeIDLocalFromFaceIDLocal( const int iFace, const int num ) const;
// Decide whether specified elements share same edges
virtual bool shareSameEdges( const int elemID1, const int elemID2 ) const;
// Calculate volume of a specified element
virtual double calcVolume( const int elemID ) const;
// Get ID of the nodes of elements belonging to the boundary planes
virtual int getNodesOfElementsBoundaryPlanes( const int iPlane, const int iElem, const int iNode ) const;
// Calculate horizontal coordinate differences of edges of the elements on boundary planes
double calcHorizontalCoordDifferenceBoundaryPlanes( const int iPlane, const int iElem, const int iEdge ) const;
// Interpolate x coordinate on top or bottom face from local coordinate of horizontal plane
double calcXCoordOfPointOnFace( const int iElem, const int iFace, const double xi, const double eta ) const;
// Interpolate y coordinate on top or bottom face from local coordinate of horizontal plane
double calcYCoordOfPointOnFace( const int iElem, const int iFace, const double xi, const double eta ) const;
// Interpolate z coordinate on top or bottom face from local coordinate of horizontal plane
double calcZCoordOfPointOnFace( const int iElem, const int iFace, const double xi, const double eta ) const;
// Calculate length of edges of elements
double calcEdgeLengthFromElementAndEdge( const int iElem, const int iEdge ) const;
// Calculate length of edges of elements on boundary planes
double calcEdgeLengthFromElementAndEdgeBoundaryPlanes( const int iPlane, const int iElem, const int iEdge ) const;
// Get face index of neighbor element
int getFaceIndexOfNeighborElement( const int iFace ) const;
// Calculate area of face
double calcAreaOfFace( const int iElem, const int iFace ) const;
// Calculate area of face at bottom of mesh
double calcAreaOfFaceAtBottomOfMesh( const int iElem ) const;
private:
// Copy constructer
MeshDataNonConformingHexaElement(const MeshDataNonConformingHexaElement& rhs);
// Copy assignment operator
MeshDataNonConformingHexaElement& operator=(const MeshDataNonConformingHexaElement& rhs);
// Array of IDs of neighbor Elements
std::vector<int>* m_neighborElementsForNonConformingHexa;
// Array of faces of elements belonging to the boundary planes
// m_facesOfElementsBoundaryPlanes[0] : Y-Z Plane ( Minus Side )
// m_facesOfElementsBoundaryPlanes[1] : Y-Z Plane ( Plus Side )
// m_facesOfElementsBoundaryPlanes[2] : Z-X Plane ( Minus Side )
// m_facesOfElementsBoundaryPlanes[3] : Z-X Plane ( Plus Side )
// m_facesOfElementsBoundaryPlanes[4] : X-Y Plane ( Minus Side )
// m_facesOfElementsBoundaryPlanes[5] : X-Y Plane ( Plus Side )
int* m_facesOfElementsBoundaryPlanes[6];
// Number of elements belonging to the land surface
int m_numElemOnLandSurface;
// Array of elements belonging to the land surface
int* m_elemOnLandSurface;
// Array of faces belonging to the land surface
int* m_faceLandSurface;
// Array converting from face ID to node ID
int m_faceID2NodeID[6][4];
// Array converting from face ID to edge ID
int m_faceID2EdgeID[6][4];
// Array converting from edge ID to node ID
int m_edgeID2NodeID[12][2];
const static int m_numGauss = 2;
const static int m_numIntegralPoints = m_numGauss * m_numGauss * m_numGauss;
double m_integralPointXi[m_numIntegralPoints];
double m_integralPointEta[m_numIntegralPoints];
double m_integralPointZeta[m_numIntegralPoints];
double m_weights[m_numIntegralPoints];
// Array of reference coord xi values for each node
double m_xiAtNode[8];
// Array of reference coord eta values for each node
double m_etaAtNode[8];
// Array of reference coord zeta values for each node
double m_zetaAtNode[8];
// Check whether side element-faces are parallel to Z-X or Y-Z plane
void checkWhetherSideFaceIsParallelToZXOrYZPlane() const;
// Check whether the specified point is located in the specified element
bool isLocatedInTheElement( const double x, const double y, const double z, const int iElem ) const;
// Calculate local coordinates
void calcLocalCoordinates( const int iElem, const double x, const double y, const double z, double& xi, double& eta, double& zeta ) const;
// Calculate horizontal local coordinates
void calcHorizontalLocalCoordinates( const int iElem, const double x, const double y, double& xi, double& eta ) const;
// Calculate determinant of jacobian matrix of the elements
double calcDeterminantOfJacobianMatrix( const int iElem, const double xi, const double eta, const double zeta ) const;
};
#endif
| 43.712264 | 146 | 0.765944 |
3a42ea2b728eb86e4713c69146e946b15935420e | 6,156 | h | C | Engine/gapi/vulkan/vdevice.h | swick/MoltenTempest | 22f22b38d4d786aee9280b314a1032e8b667e4d6 | [
"MIT"
] | null | null | null | Engine/gapi/vulkan/vdevice.h | swick/MoltenTempest | 22f22b38d4d786aee9280b314a1032e8b667e4d6 | [
"MIT"
] | null | null | null | Engine/gapi/vulkan/vdevice.h | swick/MoltenTempest | 22f22b38d4d786aee9280b314a1032e8b667e4d6 | [
"MIT"
] | null | null | null | #pragma once
#include <Tempest/AbstractGraphicsApi>
#include <stdexcept>
#include <vulkan/vulkan.hpp>
#include "vallocator.h"
#include "vcommandbuffer.h"
#include "vcommandpool.h"
#include "vfence.h"
#include "vulkanapi_impl.h"
#include "exceptions/exception.h"
namespace Tempest {
namespace Detail{
class VSwapchain;
class VCommandBuffer;
class VFence;
class VSemaphore;
class VTexture;
inline void vkAssert(VkResult code){
switch( code ) {
case VkResult::VK_SUCCESS:
return;
case VkResult::VK_ERROR_OUT_OF_DEVICE_MEMORY:
throw std::system_error(Tempest::GraphicsErrc::OutOfVideoMemory);
case VkResult::VK_ERROR_OUT_OF_HOST_MEMORY:
//throw std::system_error(Tempest::GraphicsErrc::OutOfHostMemory);
throw std::bad_alloc();
case VkResult::VK_ERROR_DEVICE_LOST:
throw DeviceLostException();
default:
throw std::runtime_error("engine internal error"); //TODO
}
}
inline VkFormat nativeFormat(TextureFormat f){
static const VkFormat vfrm[]={
VK_FORMAT_UNDEFINED,
VK_FORMAT_R8_UNORM,
VK_FORMAT_R8G8B8_UNORM,
VK_FORMAT_R8G8B8A8_UNORM,
VK_FORMAT_R16G16_UNORM,
VK_FORMAT_D16_UNORM,
VK_FORMAT_X8_D24_UNORM_PACK32,
VK_FORMAT_D24_UNORM_S8_UINT,
VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
VK_FORMAT_BC2_UNORM_BLOCK,
VK_FORMAT_BC3_UNORM_BLOCK,
};
return vfrm[f];
}
inline bool nativeIsDepthFormat(VkFormat f){
return f==VK_FORMAT_D16_UNORM ||
f==VK_FORMAT_X8_D24_UNORM_PACK32 ||
f==VK_FORMAT_D32_SFLOAT ||
f==VK_FORMAT_S8_UINT ||
f==VK_FORMAT_D16_UNORM_S8_UINT ||
f==VK_FORMAT_D24_UNORM_S8_UINT ||
f==VK_FORMAT_D32_SFLOAT_S8_UINT;
}
inline VkSamplerAddressMode nativeFormat(ClampMode f){
static const VkSamplerAddressMode vfrm[]={
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
VK_SAMPLER_ADDRESS_MODE_REPEAT,
VK_SAMPLER_ADDRESS_MODE_REPEAT,
};
return vfrm[int(f)];
}
class VDevice : public AbstractGraphicsApi::Device {
public:
struct QueueFamilyIndices {
uint32_t graphicsFamily=uint32_t(-1);
uint32_t presentFamily =uint32_t(-1);
bool isComplete() {
return graphicsFamily!=std::numeric_limits<uint32_t>::max() &&
presentFamily !=std::numeric_limits<uint32_t>::max();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities={};
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
using ResPtr = Detail::DSharedPtr<AbstractGraphicsApi::Shared*>;
using BufPtr = Detail::DSharedPtr<VBuffer*>;
using TexPtr = Detail::DSharedPtr<VTexture*>;
VDevice(VulkanApi& api,void* hwnd);
~VDevice();
VkSurfaceKHR surface =VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice =nullptr;
VkDevice device =nullptr;
size_t nonCoherentAtomSize=1;
std::mutex graphicsSync;
VkQueue graphicsQueue =nullptr;
VkQueue presentQueue =nullptr;
VAllocator allocator;
AbstractGraphicsApi::Caps caps;
std::mutex allocSync;
VkResult nextImg(VSwapchain& sw,uint32_t& imageId,VSemaphore& onReady);
VkResult present(VSwapchain& sw,const VSemaphore *wait,size_t wSize,uint32_t imageId);
void waitData();
const char* renderer() const override;
SwapChainSupportDetails querySwapChainSupport() { return querySwapChainSupport(physicalDevice); }
QueueFamilyIndices findQueueFamilies () { return findQueueFamilies(physicalDevice); }
uint32_t memoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags props) const;
void getCaps(AbstractGraphicsApi::Caps& c);
void submitQueue(VkQueue q, VkSubmitInfo& info, VkFence fence, bool waitData);
class Data final {
public:
Data(VDevice& dev);
~Data();
void start();
void flush(const Detail::VBuffer& src, size_t size);
void copy(Detail::VBuffer& dest, const Detail::VBuffer& src, size_t size);
void copy(Detail::VTexture& dest, uint32_t w, uint32_t h, uint32_t mip, const Detail::VBuffer& src, size_t offset);
void changeLayout(Detail::VTexture& dest, VkImageLayout oldLayout, VkImageLayout newLayout, uint32_t mipCount);
void generateMipmap(VTexture& image, VkFormat frm, uint32_t texWidth, uint32_t texHeight, uint32_t mipLevels);
void hold(BufPtr& b);
void hold(TexPtr& b);
void commit();
private:
VDevice& dev;
std::lock_guard<std::mutex> sync;
bool commited=true;
};
private:
class DataHelper {
public:
DataHelper(VDevice &owner);
~DataHelper();
void begin();
void end();
void wait();
VDevice& owner;
VCommandPool cmdPool;
VCommandBuffer cmdBuffer;
std::vector<ResPtr> hold;
private:
VFence fence;
VkQueue graphicsQueue=nullptr;
std::mutex waitSync;
bool hasToWait=false;
};
VkInstance instance;
VkPhysicalDeviceMemoryProperties memoryProperties;
std::unique_ptr<DataHelper> data;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]={};
void pickPhysicalDevice();
bool isDeviceSuitable(VkPhysicalDevice device);
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device);
bool checkDeviceExtensionSupport(VkPhysicalDevice device);
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device);
void createSurface(VulkanApi &api,void* hwnd);
void createLogicalDevice(VulkanApi &api);
};
}}
| 31.896373 | 123 | 0.648798 |
b14f97377dd4a278a68ce6e491e5069b2a597a44 | 5,958 | c | C | src/add-ons/kernel/drivers/network/wlan/realtekwifi/dev/rtwn/if_rtwn_efuse.c | Kirishikesan/haiku | 835565c55830f2dab01e6e332cc7e2d9c015b51e | [
"MIT"
] | 1,338 | 2015-01-03T20:06:56.000Z | 2022-03-26T13:49:54.000Z | src/add-ons/kernel/drivers/network/wlan/realtekwifi/dev/rtwn/if_rtwn_efuse.c | Kirishikesan/haiku | 835565c55830f2dab01e6e332cc7e2d9c015b51e | [
"MIT"
] | 15 | 2015-01-17T22:19:32.000Z | 2021-12-20T12:35:00.000Z | src/add-ons/kernel/drivers/network/wlan/realtekwifi/dev/rtwn/if_rtwn_efuse.c | Kirishikesan/haiku | 835565c55830f2dab01e6e332cc7e2d9c015b51e | [
"MIT"
] | 350 | 2015-01-08T14:15:27.000Z | 2022-03-21T18:14:35.000Z | /* $OpenBSD: if_urtwn.c,v 1.16 2011/02/10 17:26:40 jakemsr Exp $ */
/*-
* Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr>
* Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org>
* Copyright (c) 2015-2016 Andriy Voskoboinyk <avos@FreeBSD.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_wlan.h"
#include <sys/param.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/mbuf.h>
#include <sys/kernel.h>
#include <sys/socket.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/queue.h>
#include <sys/taskqueue.h>
#include <sys/bus.h>
#include <sys/endian.h>
#include <net/if.h>
#include <net/ethernet.h>
#include <net/if_media.h>
#include <net80211/ieee80211_var.h>
#include <net80211/ieee80211_radiotap.h>
#include <dev/rtwn/if_rtwnreg.h>
#include <dev/rtwn/if_rtwnvar.h>
#include <dev/rtwn/if_rtwn_debug.h>
#include <dev/rtwn/if_rtwn_efuse.h>
#include <dev/rtwn/rtl8192c/r92c_reg.h>
static int
rtwn_efuse_switch_power(struct rtwn_softc *sc)
{
uint32_t reg;
int error;
error = rtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_ON);
if (error != 0)
return (error);
reg = rtwn_read_2(sc, R92C_SYS_FUNC_EN);
if (!(reg & R92C_SYS_FUNC_EN_ELDR)) {
error = rtwn_write_2(sc, R92C_SYS_FUNC_EN,
reg | R92C_SYS_FUNC_EN_ELDR);
if (error != 0)
return (error);
}
reg = rtwn_read_2(sc, R92C_SYS_CLKR);
if ((reg & (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) !=
(R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) {
error = rtwn_write_2(sc, R92C_SYS_CLKR,
reg | R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M);
if (error != 0)
return (error);
}
return (0);
}
int
rtwn_efuse_read_next(struct rtwn_softc *sc, uint8_t *val)
{
uint32_t reg;
int ntries, error;
if (sc->next_rom_addr >= sc->efuse_maxlen)
return (EFAULT);
reg = rtwn_read_4(sc, R92C_EFUSE_CTRL);
reg = RW(reg, R92C_EFUSE_CTRL_ADDR, sc->next_rom_addr);
reg &= ~R92C_EFUSE_CTRL_VALID;
error = rtwn_write_4(sc, R92C_EFUSE_CTRL, reg);
if (error != 0)
return (error);
/* Wait for read operation to complete. */
for (ntries = 0; ntries < 100; ntries++) {
reg = rtwn_read_4(sc, R92C_EFUSE_CTRL);
if (reg & R92C_EFUSE_CTRL_VALID)
break;
rtwn_delay(sc, 10);
}
if (ntries == 100) {
device_printf(sc->sc_dev,
"could not read efuse byte at address 0x%x\n",
sc->next_rom_addr);
return (ETIMEDOUT);
}
*val = MS(reg, R92C_EFUSE_CTRL_DATA);
sc->next_rom_addr++;
return (0);
}
static int
rtwn_efuse_read_data(struct rtwn_softc *sc, uint8_t *rom, uint8_t off,
uint8_t msk)
{
uint8_t reg;
int addr, i, error;
for (i = 0; i < 4; i++) {
if (msk & (1 << i))
continue;
addr = off * 8 + i * 2;
if (addr + 1 >= sc->efuse_maplen)
return (EFAULT);
error = rtwn_efuse_read_next(sc, ®);
if (error != 0)
return (error);
RTWN_DPRINTF(sc, RTWN_DEBUG_ROM, "rom[0x%03X] == 0x%02X\n",
addr, reg);
rom[addr] = reg;
error = rtwn_efuse_read_next(sc, ®);
if (error != 0)
return (error);
RTWN_DPRINTF(sc, RTWN_DEBUG_ROM, "rom[0x%03X] == 0x%02X\n",
addr + 1, reg);
rom[addr + 1] = reg;
}
return (0);
}
#ifdef RTWN_DEBUG
static void
rtwn_dump_rom_contents(struct rtwn_softc *sc, uint8_t *rom, uint16_t size)
{
int i;
/* Dump ROM contents. */
device_printf(sc->sc_dev, "%s:", __func__);
for (i = 0; i < size; i++) {
if (i % 32 == 0)
printf("\n%03X: ", i);
else if (i % 4 == 0)
printf(" ");
printf("%02X", rom[i]);
}
printf("\n");
}
#endif
static int
rtwn_efuse_read(struct rtwn_softc *sc, uint8_t *rom, uint16_t size)
{
#define RTWN_CHK(res) do { \
if ((error = res) != 0) \
goto end; \
} while(0)
uint8_t msk, off, reg;
int error;
/* Read full ROM image. */
sc->next_rom_addr = 0;
memset(rom, 0xff, size);
RTWN_CHK(rtwn_efuse_read_next(sc, ®));
while (reg != 0xff) {
/* check for extended header */
if ((sc->sc_flags & RTWN_FLAG_EXT_HDR) &&
(reg & 0x1f) == 0x0f) {
off = reg >> 5;
RTWN_CHK(rtwn_efuse_read_next(sc, ®));
if ((reg & 0x0f) != 0x0f)
off = ((reg & 0xf0) >> 1) | off;
else
continue;
} else
off = reg >> 4;
msk = reg & 0xf;
RTWN_CHK(rtwn_efuse_read_data(sc, rom, off, msk));
RTWN_CHK(rtwn_efuse_read_next(sc, ®));
}
end:
#ifdef RTWN_DEBUG
if (sc->sc_debug & RTWN_DEBUG_ROM)
rtwn_dump_rom_contents(sc, rom, size);
#endif
/* Device-specific. */
rtwn_efuse_postread(sc);
if (error != 0) {
device_printf(sc->sc_dev, "%s: error while reading ROM\n",
__func__);
}
return (error);
#undef RTWN_CHK
}
static int
rtwn_efuse_read_prepare(struct rtwn_softc *sc, uint8_t *rom, uint16_t size)
{
int error;
error = rtwn_efuse_switch_power(sc);
if (error != 0)
goto fail;
error = rtwn_efuse_read(sc, rom, size);
fail:
rtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_OFF);
return (error);
}
int
rtwn_read_rom(struct rtwn_softc *sc)
{
uint8_t *rom;
int error;
rom = malloc(sc->efuse_maplen, M_TEMP, M_WAITOK);
/* Read full ROM image. */
RTWN_LOCK(sc);
error = rtwn_efuse_read_prepare(sc, rom, sc->efuse_maplen);
RTWN_UNLOCK(sc);
if (error != 0)
goto fail;
/* Parse & save data in softc. */
rtwn_parse_rom(sc, rom);
fail:
free(rom, M_TEMP);
return (error);
}
| 22.398496 | 75 | 0.675059 |
16a6d4aa15683b55af64eb21900de46198109b32 | 635 | h | C | apiwzsk/VecWzskVPvwmode.h | mpsitech/wzsk-Whiznium-StarterK | 94a0a8a05a0fac06c4360b8f835556a299b9425a | [
"MIT"
] | 1 | 2020-09-20T16:25:07.000Z | 2020-09-20T16:25:07.000Z | apiwzsk/VecWzskVPvwmode.h | mpsitech/wzsk-Whiznium-StarterKit | 94a0a8a05a0fac06c4360b8f835556a299b9425a | [
"MIT"
] | null | null | null | apiwzsk/VecWzskVPvwmode.h | mpsitech/wzsk-Whiznium-StarterKit | 94a0a8a05a0fac06c4360b8f835556a299b9425a | [
"MIT"
] | null | null | null | /**
* \file VecWzskVPvwmode.h
* vector VecWzskVPvwmode (declarations)
* \copyright (C) 2016-2020 MPSI Technologies GmbH
* \author Emily Johnson (auto-generation)
* \date created: 5 Dec 2020
*/
// IP header --- ABOVE
#ifndef VECWZSKVPVWMODE_H
#define VECWZSKVPVWMODE_H
#include <sbecore/Xmlio.h>
/**
* VecWzskVPvwmode
*/
namespace VecWzskVPvwmode {
const Sbecore::uint BINGRAY = 1;
const Sbecore::uint BINREDDOM = 2;
const Sbecore::uint BINRGB = 3;
const Sbecore::uint RAWGRAY = 4;
const Sbecore::uint RAWRGB = 5;
Sbecore::uint getIx(const std::string& sref);
std::string getSref(const Sbecore::uint ix);
};
#endif
| 21.166667 | 50 | 0.713386 |
55d085e29428484d64d18a4cfc1f3809b3c1c5d2 | 4,355 | h | C | Libs/Db/include/Visus/LogicBox.h | n8vm/OpenVisus | dab633f6ecf13ffcf9ac2ad47d51e48902d4aaef | [
"Unlicense"
] | 1 | 2019-04-30T12:11:24.000Z | 2019-04-30T12:11:24.000Z | Libs/Db/include/Visus/LogicBox.h | tjhei/OpenVisus | f0c3bf21cb0c02f303025a8efb68b8c36701a9fd | [
"Unlicense"
] | null | null | null | Libs/Db/include/Visus/LogicBox.h | tjhei/OpenVisus | f0c3bf21cb0c02f303025a8efb68b8c36701a9fd | [
"Unlicense"
] | null | null | null | /*-----------------------------------------------------------------------------
Copyright(c) 2010 - 2018 ViSUS L.L.C.,
Scientific Computing and Imaging Institute of the University of Utah
ViSUS L.L.C., 50 W.Broadway, Ste. 300, 84101 - 2044 Salt Lake City, UT
University of Utah, 72 S Central Campus Dr, Room 3750, 84112 Salt Lake City, UT
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met :
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
For additional information about this project contact : pascucci@acm.org
For support : support@visus.net
-----------------------------------------------------------------------------*/
#ifndef __VISUS_LOGIC_BOX_H
#define __VISUS_LOGIC_BOX_H
#include <Visus/Db.h>
#include <Visus/Array.h>
namespace Visus {
////////////////////////////////////////////////////////
class VISUS_DB_API LogicBox : public NdBox
{
public:
VISUS_CLASS(LogicBox)
NdPoint nsamples;
NdPoint delta;
NdPoint shift;
//default constructor
LogicBox() : NdBox(0) {
}
//constructor
LogicBox(NdBox box_, NdPoint delta_)
: NdBox(box_),delta(delta_),shift(delta_.getLog2())
{
int pdim = getPointDim();
//a zero delta will cause problems. you can have an endless loop
// for (pos=;pos<=;pos+=delta)
VisusAssert(delta.innerProduct()>0);
//calculate how many samples I will get
this->nsamples = NdPoint::one(pdim);
for (int D=0;D<pdim;D++)
this->nsamples[D]=(this->p2[D]-this->p1[D])/this->delta[D];
//probably overflow
if (this->nsamples.innerProduct()<=0 || !NdBox::isFullDim()) {
*this=LogicBox();
return;
}
//check alignment
VisusAssert(
((NdPoint::one(pdim).leftShift(this->shift))==this->delta) &&
(this->pixelToLogic(NdPoint(pdim))==this->p1) &&
(this->pixelToLogic(nsamples)==this->p2) &&
(this->logicToPixel(this->p1)==NdPoint(pdim)) &&
(this->logicToPixel(this->p2)==nsamples));
}
//valid
bool valid() const {
return nsamples[0]>0;
}
//pixelToLogic
inline NdPoint pixelToLogic(const NdPoint& value) const {
return p1 + value.leftShift(shift);
}
//logicToPixel
inline NdPoint logicToPixel(const NdPoint& value) const {
return (value-p1).rightShift(shift);
}
//alignBox
NdBox alignBox(NdBox value) const
{
int pdim = nsamples.getPointDim();
if (!this->valid())
return NdBox::invalid(pdim);
value= value.getIntersection(*this);
if (!value.isFullDim())
return NdBox::invalid(pdim);
//NOTE: i can move P2 to the right, since p2 is not included it it's aligned it wont' be moved
// if it's not aligned will be moved to the right, but all the extra samples wont't be "good" due to the delta
for (int D = 0; D < pdim; D++)
{
value.p1[D] = Utils::alignRight(value.p1[D], this->p1[D], this->delta[D]);
value.p2[D] = Utils::alignRight(value.p2[D], this->p1[D], this->delta[D]);
}
return value;
}
};
} //namespace Visus
#endif //__VISUS_LOGIC_BOX_H
| 31.788321 | 119 | 0.675086 |
df580868fc473e34064b071fae783f94b02a7717 | 335 | h | C | AS3/demo/AS3_rcContext.h | dvdjg/recastnavigation | 08b706dcf507a9211e6918cca5fe960833ad500b | [
"Zlib"
] | null | null | null | AS3/demo/AS3_rcContext.h | dvdjg/recastnavigation | 08b706dcf507a9211e6918cca5fe960833ad500b | [
"Zlib"
] | null | null | null | AS3/demo/AS3_rcContext.h | dvdjg/recastnavigation | 08b706dcf507a9211e6918cca5fe960833ad500b | [
"Zlib"
] | null | null | null |
#include "DetourNavMesh.h"
#include "Recast.h"
#include "AS3/AS3.h"
class AS3_rcContext : public rcContext
{
protected:
//override base log
virtual void doLog(const rcLogCategory category, const char* msg, const int len)
{
AS3_DeclareVar(message, String);
AS3_CopyCStringToVar(message, msg, len);
AS3_Trace(message);
}
}; | 19.705882 | 82 | 0.737313 |
3d4a298c0d768a42d80b92809d06f3340a4c2263 | 3,153 | h | C | Plugins/CapabilityDetect/Source/ThirdParty/CapabilityDetectLibrary/StatsCollector.h | GameTechDev/UnrealCapabilityDetec | f9c622171abf9c4eb62bfd960b74c8e9ad8e0411 | [
"MIT"
] | 3 | 2019-01-08T00:51:38.000Z | 2020-06-30T00:04:54.000Z | Plugins/CapabilityDetect/Source/ThirdParty/CapabilityDetectLibrary/StatsCollector.h | DragonFire9408/UnrealCapabilityDetect | f9c622171abf9c4eb62bfd960b74c8e9ad8e0411 | [
"MIT"
] | null | null | null | Plugins/CapabilityDetect/Source/ThirdParty/CapabilityDetectLibrary/StatsCollector.h | DragonFire9408/UnrealCapabilityDetect | f9c622171abf9c4eb62bfd960b74c8e9ad8e0411 | [
"MIT"
] | 2 | 2020-06-30T00:05:02.000Z | 2021-09-03T00:51:08.000Z | /////////////////////////////////////////////////////////////////////////////////////////////
// Copyright 2017 Intel 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 imlied.
// See the License for the specific language governing permissions and
// limitations under the License.
/////////////////////////////////////////////////////////////////////////////////////////////
#ifndef STATS_COLLECTOR_H
#define STATS_COLLECTOR_H
#include <string>
#include <vector>
#include <memory>
#include <d3d11.h>
#ifdef _WIN32
#include <Pdh.h>
#pragma comment(lib, "pdh.lib")
#endif
static const std::string METRIC_URI_PREFIX = "CapabilityDetect";
enum METRIC {
RSS_MEMORY_SIZE, // App resident memory
AVAILABLE_MEMORY, // Total available memory
CPU_FREQ, // Current Frequency of the 0th core
CPU_PERCENT_MAX_FREQ_PER_CORE, // The Max Frequency Capable of the CPU - Matches ark.intel.com
CPU_PREDEFINED_COUNT
};
class Metric
{
public:
std::string mMetricName;
#ifdef _WIN32
std::wstring mPDHPath; // PDH Path to this metric's data source
HCOUNTER mPDHCounter; // Handle for this counter
DWORD mCounterType;
#endif
double mCurrentValue; // Current value of metric
double GetCurrentValue();
void SetCurrentValue(double currentValue);
Metric();
Metric(std::string metricName);
};
class InfoCollector {
public:
InfoCollector();
~InfoCollector();
void CollectPDHData(); // Refresh all metric data
double CollectDataForMetric(METRIC metric); // Allows metric classes to pull their own data
bool IsIntelCPU(); // Determine if Intel CPU
unsigned int GetLogicalCoreCount();
unsigned int GetPhysicalCoreCount();
float GetUsablePhysMemoryGB();
double GetCacheSize();
std::string GetFullProcessorNameString();
std::string GetProcessorName();
std::unique_ptr<Metric>* GetMetric(METRIC varMetric);
private:
std::string mFullProcessorName; // CPU Brand Information
std::string mProcessorName; // CPU Name
unsigned int mCPUCoresNumber; // Number of LOGICAL cores
unsigned int mCPUPhysicalCoresNumber; // Number of PHYSICAL cores
unsigned int mResidentMemory; // App resident Memory
unsigned int mAvailableMemory; // App resident Memory
double mCacheSize; // CPU cache size
float mUsablePhysicalMemoryGB = 0;
bool mIsIntelCPU = false;
std::vector<std::unique_ptr<Metric>> mMetricsVec; // stores single metrics
void GetCoreCounts();
void ConstructMetricDataStructure();
void InitializeData();
void SetCPUBrandString();
void SetIsIntelCPU();
#ifdef _WINDOWS
HQUERY mQueryHandle; // Handle for metrics query to PDH
#endif
};
#endif // STATS_COLLECTOR_H | 33.903226 | 101 | 0.678402 |
3d62e75548e486746db3ad7a485430afc721e4d1 | 590 | h | C | Source/Libraries/XcodeFrameworks/IDEKit/IDESpeechAlert.h | yndj/ShowInGitHub | eb088c999aa725630f0e881b5a701d503c6b4aba | [
"BSD-2-Clause"
] | 92 | 2015-01-19T10:22:08.000Z | 2021-12-16T14:22:50.000Z | Source/Libraries/XcodeFrameworks/IDEKit/IDESpeechAlert.h | yndj/ShowInGitHub | eb088c999aa725630f0e881b5a701d503c6b4aba | [
"BSD-2-Clause"
] | 15 | 2015-02-09T16:19:41.000Z | 2016-05-11T06:47:31.000Z | Source/Libraries/XcodeFrameworks/IDEKit/IDESpeechAlert.h | yndj/ShowInGitHub | eb088c999aa725630f0e881b5a701d503c6b4aba | [
"BSD-2-Clause"
] | 28 | 2015-01-06T13:21:37.000Z | 2021-05-24T04:30:09.000Z | /*
* Generated by class-dump 3.3.4 (64 bit).
*
* class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2011 by Steve Nygard.
*/
#import "IDEAlert.h"
@class NSSpeechSynthesizer, NSString;
@interface IDESpeechAlert : IDEAlert
{
NSString *_voice;
NSSpeechSynthesizer *_speech;
}
- (int)alertPropertyListVersion;
- (id)availableVoices;
- (id)init;
- (id)initWithPropertyList:(id)arg1;
- (id)propertyList;
- (void)runForEvent:(id)arg1 inWorkspace:(id)arg2 context:(id)arg3 completionBlock:(id)arg4;
@property(retain) NSString *voice; // @synthesize voice=_voice;
@end
| 21.851852 | 92 | 0.710169 |
3ddb806092856a8571dec08da51d26b75157e4e8 | 2,420 | h | C | cc/subtle/stateful_cmac_boringssl.h | fax001/tink | 9f30c97cb84b10bbba6978bc9c12c86478024050 | [
"Apache-2.0"
] | 1 | 2022-03-02T19:43:24.000Z | 2022-03-02T19:43:24.000Z | cc/subtle/stateful_cmac_boringssl.h | fax001/tink | 9f30c97cb84b10bbba6978bc9c12c86478024050 | [
"Apache-2.0"
] | 1 | 2022-03-02T13:25:38.000Z | 2022-03-02T13:25:38.000Z | cc/subtle/stateful_cmac_boringssl.h | fax001/tink | 9f30c97cb84b10bbba6978bc9c12c86478024050 | [
"Apache-2.0"
] | null | null | null | // Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef TINK_SUBTLE_STATEFUL_CMAC_BORINGSSL_H_
#define TINK_SUBTLE_STATEFUL_CMAC_BORINGSSL_H_
#include <memory>
#include <string>
#include <utility>
#include "openssl/cmac.h"
#include "openssl/evp.h"
#include "tink/internal/ssl_unique_ptr.h"
#include "tink/subtle/common_enums.h"
#include "tink/subtle/mac/stateful_mac.h"
#include "tink/util/secret_data.h"
#include "tink/util/status.h"
#include "tink/util/statusor.h"
namespace crypto {
namespace tink {
namespace subtle {
// A BoringSSL CMAC implementation of Stateful Mac interface.
class StatefulCmacBoringSsl : public subtle::StatefulMac {
public:
// Key must be 16 or 32 bytes, all other sizes will be rejected.
static util::StatusOr<std::unique_ptr<StatefulMac>> New(
uint32_t tag_size, const util::SecretData& key_value);
util::Status Update(absl::string_view data) override;
util::StatusOr<std::string> Finalize() override;
private:
static constexpr size_t kSmallKeySize = 16;
static constexpr size_t kBigKeySize = 32;
static constexpr size_t kMaxTagSize = 16;
StatefulCmacBoringSsl(uint32_t tag_size, internal::SslUniquePtr<CMAC_CTX> ctx)
: cmac_context_(std::move(ctx)), tag_size_(tag_size) {}
const internal::SslUniquePtr<CMAC_CTX> cmac_context_;
const uint32_t tag_size_;
};
class StatefulCmacBoringSslFactory : public subtle::StatefulMacFactory {
public:
StatefulCmacBoringSslFactory(uint32_t tag_size,
const util::SecretData& key_value);
util::StatusOr<std::unique_ptr<StatefulMac>> Create() const override;
private:
const uint32_t tag_size_;
const util::SecretData key_value_;
};
} // namespace subtle
} // namespace tink
} // namespace crypto
#endif // TINK_SUBTLE_STATEFUL_CMAC_BORINGSSL_H_
| 32.702703 | 80 | 0.728926 |
e1fd3ceb54c06e200671663873fd8cccdbba6e27 | 636 | h | C | ios/Classes/splash/BdSplashAd.h | gstory0404/flutter_baiduad | fc562406e60e4acbf16f2a7b542beb080e309e0b | [
"Apache-2.0"
] | 1 | 2021-11-22T17:44:50.000Z | 2021-11-22T17:44:50.000Z | ios/Classes/splash/BdSplashAd.h | gstory0404/flutter_baiduad | fc562406e60e4acbf16f2a7b542beb080e309e0b | [
"Apache-2.0"
] | null | null | null | ios/Classes/splash/BdSplashAd.h | gstory0404/flutter_baiduad | fc562406e60e4acbf16f2a7b542beb080e309e0b | [
"Apache-2.0"
] | 3 | 2021-11-30T06:24:04.000Z | 2022-02-18T01:50:33.000Z | //
// SplashAd.h
// flutter_baiduad
//
// Created by 郭维佳 on 2021/11/29.
//
#import <Foundation/Foundation.h>
#import <Flutter/Flutter.h>
NS_ASSUME_NONNULL_BEGIN
@interface BdSplashAdFactory : NSObject<FlutterPlatformViewFactory>
- (instancetype)initWithMessenger:(NSObject<FlutterBinaryMessenger>*)messager;
@end
@interface BdSplashAd : NSObject<FlutterPlatformView>
- (instancetype)initWithWithFrame:(CGRect)frame
viewIdentifier:(int64_t)viewId
arguments:(id _Nullable)args
binaryMessenger:(NSObject<FlutterBinaryMessenger>*)messenger;
@end
NS_ASSUME_NONNULL_END
| 22.714286 | 79 | 0.726415 |
cd82c5433d1c93c1ff3c10cffeeac08b7a367c85 | 686 | h | C | xnlib/QuWidgets/include/QuMenubar.h | manaskamal/aurora-xeneva | fe277f7ac155a40465c70f1db3c27046e4d0f7b5 | [
"BSD-2-Clause"
] | 8 | 2021-07-19T04:46:35.000Z | 2022-03-12T17:56:00.000Z | xnlib/QuWidgets/include/QuMenubar.h | manaskamal/aurora-xeneva | fe277f7ac155a40465c70f1db3c27046e4d0f7b5 | [
"BSD-2-Clause"
] | null | null | null | xnlib/QuWidgets/include/QuMenubar.h | manaskamal/aurora-xeneva | fe277f7ac155a40465c70f1db3c27046e4d0f7b5 | [
"BSD-2-Clause"
] | null | null | null | ///! Copyright (C) Manas Kamal Choudhury 2021
///!
///! QuMenubar.h -- Quince Menubar Widget
///!
///! /PROJECT - Aurora's Xeneva
///! /AUTHOR - Manas Kamal Choudhury
///!
///!===============================================
#ifndef __QU_MENUBAR_H__
#define __QU_MENUBAR_H__
#include <QuWindow.h>
#include <QuBase.h>
#include <QuUtils\QuList.h>
#include <QuContextMenu.h>
typedef struct _qu_menubar_h_ {
QuWidget wid;
QuList *CtxMenus;
QuContextMenu *focused;
QuContextMenu *last_focused;
bool update_required;
bool popup_enable;
int m_x;
int m_y;
}QuMenubar;
extern QuMenubar *QuCreateMenubar ();
extern void QuMenubarAddMenu(QuMenubar *mb, QuContextMenu *menu);
#endif | 22.129032 | 65 | 0.677843 |
ef37dc827ea57d2442a46f7a83ff0ab17dc555eb | 459 | h | C | expms/common/helper.h | arjunramaswami/FPGA_expms | 511accc5b4903196cded25eb0742e1237be5e7c3 | [
"MIT"
] | null | null | null | expms/common/helper.h | arjunramaswami/FPGA_expms | 511accc5b4903196cded25eb0742e1237be5e7c3 | [
"MIT"
] | null | null | null | expms/common/helper.h | arjunramaswami/FPGA_expms | 511accc5b4903196cded25eb0742e1237be5e7c3 | [
"MIT"
] | null | null | null | // Author: Arjun Ramaswami
#ifndef HELPER_H
#define HELPER_H
#include <stdbool.h>
#include "bare.h"
bool create_data(float2 *inp, unsigned N);
void print_config(unsigned N, unsigned iter, bool interleaving, unsigned batch);
void display_measures(double total_api_time, double pcie_rd, double pcie_wr, double exec, unsigned N, unsigned iter);
bool verify_output(float2 *inp, float2 *out, unsigned N);
double getTimeinMilliseconds();
#endif // HELPER_H
| 24.157895 | 117 | 0.77342 |
ef5d86dc1dca03732e40bcad114a73b6d477ea86 | 74 | h | C | NorthstarDedicatedTest/main.h | MindSwipe/NorthstarLauncher | ce6127ae96022ce6e803a876a2e39eed7bd754ea | [
"MIT"
] | 3 | 2021-12-27T22:24:08.000Z | 2022-01-16T03:58:59.000Z | NorthstarDedicatedTest/main.h | MindSwipe/NorthstarLauncher | ce6127ae96022ce6e803a876a2e39eed7bd754ea | [
"MIT"
] | null | null | null | NorthstarDedicatedTest/main.h | MindSwipe/NorthstarLauncher | ce6127ae96022ce6e803a876a2e39eed7bd754ea | [
"MIT"
] | null | null | null | #pragma once
extern "C" __declspec(dllexport) void InitialiseNorthstar(); | 24.666667 | 60 | 0.797297 |
721a2453153538320009a751922c5aaefd41c36b | 1,957 | h | C | apps/examples/multi_window_example/multi_window_example_app/multi_window_example_app.h | sp0lsh/island | dbb3165f66abdfe6b44d07baeba115e9dac6b61a | [
"MIT"
] | null | null | null | apps/examples/multi_window_example/multi_window_example_app/multi_window_example_app.h | sp0lsh/island | dbb3165f66abdfe6b44d07baeba115e9dac6b61a | [
"MIT"
] | null | null | null | apps/examples/multi_window_example/multi_window_example_app/multi_window_example_app.h | sp0lsh/island | dbb3165f66abdfe6b44d07baeba115e9dac6b61a | [
"MIT"
] | null | null | null | #ifndef GUARD_multi_window_example_app_H
#define GUARD_multi_window_example_app_H
#endif
#include <stdint.h>
#include "le_core/le_core.h"
// depends on le_backend_vk. le_backend_vk must be loaded before this class is used.
void register_multi_window_example_app_api( void *api );
struct multi_window_example_app_o;
// clang-format off
struct multi_window_example_app_api {
static constexpr auto id = "multi_window_example_app";
static constexpr auto pRegFun = register_multi_window_example_app_api;
struct multi_window_example_app_interface_t {
multi_window_example_app_o * ( *create )();
void ( *destroy )( multi_window_example_app_o *self );
bool ( *update )( multi_window_example_app_o *self );
void ( *initialize )(); // static methods
void ( *terminate )(); // static methods
};
multi_window_example_app_interface_t multi_window_example_app_i;
};
// clang-format on
LE_MODULE( multi_window_example_app );
LE_MODULE_LOAD_DEFAULT( multi_window_example_app );
#ifdef __cplusplus
namespace multi_window_example_app {
static const auto &api = multi_window_example_app_api_i;
static const auto &multi_window_example_app_i = api -> multi_window_example_app_i;
} // namespace multi_window_example_app
class MultiWindowExampleApp : NoCopy, NoMove {
multi_window_example_app_o *self;
public:
MultiWindowExampleApp()
: self( multi_window_example_app::multi_window_example_app_i.create() ) {
}
bool update() {
return multi_window_example_app::multi_window_example_app_i.update( self );
}
~MultiWindowExampleApp() {
multi_window_example_app::multi_window_example_app_i.destroy( self );
}
static void initialize() {
multi_window_example_app::multi_window_example_app_i.initialize();
}
static void terminate() {
multi_window_example_app::multi_window_example_app_i.terminate();
}
};
#endif
| 27.180556 | 84 | 0.745529 |
075062a6e923e76dce43b1c535ac29405c97394b | 3,328 | h | C | modules/canbus/vehicle/wey/protocol/ads_shifter_115.h | zhulianhai/apollo | ab47e53dff2a9fe836ac69fdf783a654a0220802 | [
"Apache-2.0"
] | 2 | 2019-02-21T05:52:59.000Z | 2019-07-27T03:24:16.000Z | modules/canbus/vehicle/wey/protocol/ads_shifter_115.h | zhulianhai/apollo | ab47e53dff2a9fe836ac69fdf783a654a0220802 | [
"Apache-2.0"
] | null | null | null | modules/canbus/vehicle/wey/protocol/ads_shifter_115.h | zhulianhai/apollo | ab47e53dff2a9fe836ac69fdf783a654a0220802 | [
"Apache-2.0"
] | 1 | 2021-12-03T23:30:00.000Z | 2021-12-03T23:30:00.000Z | /******************************************************************************
* Copyright 2019 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include "modules/drivers/canbus/can_comm/protocol_data.h"
#include "modules/canbus/proto/chassis_detail.pb.h"
namespace apollo {
namespace canbus {
namespace wey {
class Adsshifter115 : public ::apollo::drivers::canbus::ProtocolData<
::apollo::canbus::ChassisDetail> {
public:
static const int32_t ID;
Adsshifter115();
uint32_t GetPeriod() const override;
void UpdateData(uint8_t* data) override;
void Reset() override;
// config detail: {'description': 'ADS Shift Mode', 'enum': {0:
// 'ADS_SHIFTMODE_INVALID', 1: 'ADS_SHIFTMODE_VALID'}, 'precision': 1.0,
// 'len': 4, 'name': 'ADS_ShiftMode', 'is_signed_var': False, 'offset': 0.0,
// 'physical_range': '[0|1]', 'bit': 31, 'type': 'enum', 'order': 'motorola',
// 'physical_unit': ''}
Adsshifter115* set_ads_shiftmode(Ads_shifter_115::
Ads_shiftmodeType ads_shiftmode);
// config detail: {'description': 'ADS Target Gear', 'enum': {0:
// 'ADS_TARGETGEAR_N', 1: 'ADS_TARGETGEAR_R', 2: 'ADS_TARGETGEAR_P', 3:
// 'ADS_TARGETGEAR_D'}, 'precision': 1.0, 'len': 2, 'name': 'ADS_TargetGear',
// 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|0]',
// 'bit': 38, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Adsshifter115* set_ads_targetgear(Ads_shifter_115::
Ads_targetgearType ads_targetgear);
private:
// config detail: {'description': 'ADS Shift Mode', 'enum': {0:
// 'ADS_SHIFTMODE_INVALID', 1: 'ADS_SHIFTMODE_VALID'}, 'precision': 1.0,
// 'len': 4, 'name': 'ADS_ShiftMode', 'is_signed_var': False, 'offset': 0.0,
// 'physical_range': '[0|1]', 'bit': 31, 'type': 'enum', 'order': 'motorola',
// 'physical_unit': ''}
void set_p_ads_shiftmode(uint8_t* data, Ads_shifter_115::
Ads_shiftmodeType ads_shiftmode);
// config detail: {'description': 'ADS Target Gear', 'enum': {0:
// 'ADS_TARGETGEAR_N', 1: 'ADS_TARGETGEAR_R', 2: 'ADS_TARGETGEAR_P', 3:
// 'ADS_TARGETGEAR_D'}, 'precision': 1.0, 'len': 2, 'name': 'ADS_TargetGear',
// 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|0]',
// 'bit': 38, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
void set_p_ads_targetgear(uint8_t* data, Ads_shifter_115::
Ads_targetgearType ads_targetgear);
private:
Ads_shifter_115::Ads_shiftmodeType ads_shiftmode_;
Ads_shifter_115::Ads_targetgearType ads_targetgear_;
};
} // namespace wey
} // namespace canbus
} // namespace apollo
| 41.08642 | 79 | 0.63101 |
b0ce43beeaef5e832ca76acd61d936c38fb297ba | 3,713 | h | C | akumulid/server.h | adulau/Akumuli | 7fd0e5934ef018575299517eea02702778ee6e6c | [
"Apache-2.0"
] | null | null | null | akumulid/server.h | adulau/Akumuli | 7fd0e5934ef018575299517eea02702778ee6e6c | [
"Apache-2.0"
] | null | null | null | akumulid/server.h | adulau/Akumuli | 7fd0e5934ef018575299517eea02702778ee6e6c | [
"Apache-2.0"
] | 1 | 2019-08-26T06:51:59.000Z | 2019-08-26T06:51:59.000Z | #pragma once
#include "akumuli.h"
#include "storage_api.h"
#include "signal_handler.h"
#include <map>
#include <string>
#include <tuple>
#include <tuple>
namespace Akumuli {
struct ProtocolSettings {
std::string name;
int port;
};
struct ServerSettings {
std::string name;
std::vector<ProtocolSettings> protocols;
int nworkers;
};
struct WALSettings {
std::string path;
int volume_size_bytes;
int nvolumes;
};
/** Interface to query data.
*/
struct ReadOperation {
virtual ~ReadOperation() = default;
/** Start query execution
*/
virtual void start() = 0;
/** Append query data to cursor
*/
virtual void append(const char* data, size_t data_size) = 0;
/** Return error code or AKU_SUCCESS.
* This error code represent result of the query parsing and initial processing. It can indicate
* error in the query. Result of the call to this function shouldn't change while reading data.
* If error occurs during reading `read_some` method should throw an error.
*/
virtual aku_Status get_error() = 0;
/**
* Return error message (if any). Should be called only if previous call to get_error returned
* non-zero value.
*/
virtual const char* get_error_message() = 0;
/** Read some data from cursor. This method should be called only if `get_error` have returned
* AKU_SUCCESS. If some error occured during read operation this method should throw.
* Method returns tuple (num_elements, is_done). If there is no more results, method returns
* (any, true) otherwise it returns (any, false). Number of elements can be 0, in this case
* if second tuple element is false client should call this method again.
*/
virtual std::tuple<size_t, bool> read_some(char* buf, size_t buf_size) = 0;
/** Close cursor.
* Should be called after read operation was completed or interrupted.
*/
virtual void close() = 0;
};
/**
* API endpoint from which the query originated from.
*/
enum class ApiEndpoint {
QUERY,
SUGGEST,
SEARCH,
UNKNOWN,
};
//! Interface that can be used to create read operations
struct ReadOperationBuilder {
virtual ~ReadOperationBuilder() = default;
virtual ReadOperation* create(ApiEndpoint ep) = 0;
virtual std::string get_all_stats() = 0;
virtual std::string get_resource(std::string name) = 0;
};
//! Server interface
struct Server {
virtual ~Server() = default;
virtual void start(SignalHandler* sig_handler, int id) = 0;
};
struct ServerFactory {
typedef std::function<std::shared_ptr<Server>(std::shared_ptr<AkumuliConnection>,
std::shared_ptr<ReadOperationBuilder>,
const ServerSettings&)>
Generator;
std::map<std::string, Generator> gen_;
std::shared_ptr<Server> create(std::shared_ptr<AkumuliConnection> connection,
std::shared_ptr<ReadOperationBuilder> qproc,
const ServerSettings& settings) {
auto it = gen_.find(settings.name);
if (it == gen_.end()) {
return std::shared_ptr<Server>();
}
return it->second(connection, qproc, settings);
}
void register_type(std::string name, Generator gen) { gen_[name] = gen; }
static ServerFactory& instance() {
static ServerFactory factory;
return factory;
}
};
} // namespace
| 30.434426 | 101 | 0.612173 |
90888bce013d1b10f9c5eef6e7e589b8fb42a129 | 1,555 | c | C | testdata/K-and-R-exercises-and-examples/06.02-structures_and_functions/ex-structs.c | Konstantin8105/c2go-rating | edba6b8aa1ce2a69a17b076596764fec656cb2f9 | [
"MIT"
] | null | null | null | testdata/K-and-R-exercises-and-examples/06.02-structures_and_functions/ex-structs.c | Konstantin8105/c2go-rating | edba6b8aa1ce2a69a17b076596764fec656cb2f9 | [
"MIT"
] | null | null | null | testdata/K-and-R-exercises-and-examples/06.02-structures_and_functions/ex-structs.c | Konstantin8105/c2go-rating | edba6b8aa1ce2a69a17b076596764fec656cb2f9 | [
"MIT"
] | null | null | null | #include <stdio.h>
#define XMAX 100
#define YMAX 100
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))
struct point
{
int x;
int y;
};
struct rect
{
struct point pt1;
struct point pt2;
};
struct point makepoint(int x, int y);
struct point addpoint(struct point p1, struct point p2);
int ptinrect(struct point p, struct rect r);
int main(void)
{
struct rect screen;
struct point middle;
struct point origin;
struct point *pp;
screen.pt1 = makepoint(0, 0);
screen.pt2 = makepoint(XMAX, YMAX);
middle = makepoint((screen.pt1.x + screen.pt2.x)/2,
(screen.pt1.y + screen.pt2.y)/2);
origin = screen.pt1;
pp = &origin;
printf("origin is (%d,%d)\n", (*pp).x, (*pp).y);
printf("origin is (%d,%d)\n", pp->x, pp->.y)
return 0;
}
/* makepint: make a point from x and y components */
struct point makepoint(int x, int y)
{
struct point temp;
temp.x = x;
temp.y = y;
return temp;
}
/* addpoint: add two points*/
struct point addpoint(struct point p1, struct point p2)
{
p1.x += p2.x;
p1.y += p2.y;
return p1;
}
/* ptinrect: return 1 if p in r, 0 if not */
int ptinrect(struct point p, struct rect r)
{
return p.x >= r.pt1.x && p.x < r.pt2.x
&& p.y >= r.pt1.y && p.y < r.pt2.y;
}
/* canonrect: canonicalize coordinates of rectanglw */
struct rect canonrect(struct rect r)
{
struct rect temp;
temp.pt1.x = min(r.pt1.x, r.pt2.x);
temp.pt1.y = min(r.pt1.y, r.pt2.y);
temp.pt2.x = max(r.pt1.x, r.pt2.x);
temp.pt2.y = max(r.pt1.y, r.pt2.y);
return temp;
}
| 19.935897 | 56 | 0.610289 |
fc529bb5f2bf169b5cd220cab83cc713f5b89257 | 3,364 | c | C | app/src/main/jni/LoadingProcess.c | ucanchangetheworld/template | 9b98dd0da8bdd92958d8e661791332be0ef178f2 | [
"Apache-2.0"
] | null | null | null | app/src/main/jni/LoadingProcess.c | ucanchangetheworld/template | 9b98dd0da8bdd92958d8e661791332be0ef178f2 | [
"Apache-2.0"
] | null | null | null | app/src/main/jni/LoadingProcess.c | ucanchangetheworld/template | 9b98dd0da8bdd92958d8e661791332be0ef178f2 | [
"Apache-2.0"
] | null | null | null | #include <jni.h>
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
/*
* Piracy Check
*
* Change this value to JNI_TRUE if you would like to enable anti piracy
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_getAPStatus(JNIEnv *env) {
return JNI_FALSE;
}
/*
* Base 64 License Key
*
* Insert your base 64 license key obtained from Play Store in the quotations below!
* ATTENTION: On line 23, do you see the "000"? You MUST count the amount of characters of your key
* and input the proper number! This is so that you get your own specialized set of variables!
*/
JNIEXPORT jstring JNICALL
Java_substratum_theme_template_SubstratumLauncher_getBase64Key(JNIEnv *env) {
// TODO: This must be done!
char BASE_64_LICENSE_KEY[000] = "";
return (*env)->NewStringUTF(env, BASE_64_LICENSE_KEY);
}
/*
* APK Signature Production
*
* Insert your release APK's signature in the quotations below!
* ATTENTION: On line 34, do you see the "28"? If you're disabling antipiracy, change that to 0!
* All release production signature prefixes have the length of 28!
*/
JNIEXPORT jstring JNICALL
Java_substratum_theme_template_SubstratumLauncher_getAPKSignatureProduction(JNIEnv *env) {
char APK_SIGNATURE_PRODUCTION[28] = "";
return (*env)->NewStringUTF(env, APK_SIGNATURE_PRODUCTION);
}
/*
* Enforce Internet Check
*
* Change this value to JNI_TRUE if you would like to enable internet check
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_getInternetCheck(JNIEnv *env) {
return JNI_FALSE;
}
/*
* Enforce Google Play Install
*
* Change this value to JNI_TRUE if you would like to enable this check
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_getGooglePlayRequirement(JNIEnv *env) {
return JNI_FALSE;
}
/*
* Enforce Amazon App Store Install
*
* Change this value to JNI_TRUE if you would like to enable this check
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_getAmazonAppStoreRequirement(JNIEnv *env) {
return JNI_FALSE;
}
/*
* Enable check for Blacklisted APKs
*
* Change this value to JNI_TRUE if you would like to enable blacklist check
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_getBlacklistedApplications(JNIEnv *env) {
return JNI_FALSE;
}
/*
* Allow Third Party Substratum Builds
*
* Change this value to JNI_FALSE if you would like to ban your theme to work on external, non-team
* built compilations of substratum
*
* WARNING: Having this enabled may or may not cause a bunch of issues due to the system not built
* and distributed by an official team member. You will take charge of handling bug reports
* if there are specific bugs unreproducible on the main stream of APKs.
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_allowThirdPartySubstratumBuilds(JNIEnv *env) {
return JNI_TRUE;
}
/*
* Enable Samsung theming
*
* Change Line 94 to JNI_FALSE for official Samsung support!
*/
JNIEXPORT jboolean JNICALL
Java_substratum_theme_template_SubstratumLauncher_getSamsungSupport(JNIEnv *env) {
return Java_substratum_theme_template_SubstratumLauncher_allowThirdPartySubstratumBuilds(env);
}
#pragma clang diagnostic pop | 31.439252 | 100 | 0.778835 |
e63a9e4ee1fdafdfa6d648df60f112817148b7f1 | 15,739 | h | C | cast/streaming/receiver.h | gtalis/openscreen | 9b28b9695df98d310c2271eaa65d20cc6d224203 | [
"BSD-3-Clause"
] | 1 | 2020-09-22T05:59:36.000Z | 2020-09-22T05:59:36.000Z | cast/streaming/receiver.h | gtalis/openscreen | 9b28b9695df98d310c2271eaa65d20cc6d224203 | [
"BSD-3-Clause"
] | null | null | null | cast/streaming/receiver.h | gtalis/openscreen | 9b28b9695df98d310c2271eaa65d20cc6d224203 | [
"BSD-3-Clause"
] | 1 | 2022-02-03T11:05:44.000Z | 2022-02-03T11:05:44.000Z | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CAST_STREAMING_RECEIVER_H_
#define CAST_STREAMING_RECEIVER_H_
#include <stdint.h>
#include <array>
#include <chrono> // NOLINT
#include <memory>
#include <vector>
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "cast/streaming/clock_drift_smoother.h"
#include "cast/streaming/compound_rtcp_builder.h"
#include "cast/streaming/environment.h"
#include "cast/streaming/frame_collector.h"
#include "cast/streaming/frame_id.h"
#include "cast/streaming/packet_receive_stats_tracker.h"
#include "cast/streaming/rtcp_common.h"
#include "cast/streaming/rtcp_session.h"
#include "cast/streaming/rtp_packet_parser.h"
#include "cast/streaming/sender_report_parser.h"
#include "cast/streaming/ssrc.h"
#include "platform/api/time.h"
#include "util/alarm.h"
namespace openscreen {
namespace cast {
struct EncodedFrame;
class ReceiverPacketRouter;
struct SessionConfig;
// The Cast Streaming Receiver, a peer corresponding to some Cast Streaming
// Sender at the other end of a network link.
//
// Cast Streaming is a transport protocol which divides up the frames for one
// media stream (e.g., audio or video) into multiple RTP packets containing an
// encrypted payload. The Receiver is the peer responsible for collecting the
// RTP packets, decrypting the payload, and re-assembling a frame that can be
// passed to a decoder and played out.
//
// A Sender ↔ Receiver pair is used to transport each media stream. Typically,
// there are two pairs in a normal system, one for the audio stream and one for
// video stream. A local player is responsible for synchronizing the playout of
// the frames of each stream to achieve lip-sync. See the discussion in
// encoded_frame.h for how the |reference_time| and |rtp_timestamp| of the
// EncodedFrames are used to achieve this.
//
// See the Receiver Demo app for a reference implementation that both shows and
// explains how Receivers are properly configured and started, integrated with a
// decoder, and the resulting decoded media is played out. Also, here is a
// general usage example:
//
// class MyPlayer : public openscreen::cast::Receiver::Consumer {
// public:
// explicit MyPlayer(Receiver* receiver) : receiver_(receiver) {
// recevier_->SetPlayerProcessingTime(std::chrono::milliseconds(10));
// receiver_->SetConsumer(this);
// }
//
// ~MyPlayer() override {
// receiver_->SetConsumer(nullptr);
// }
//
// private:
// // Receiver::Consumer implementation.
// void OnFramesReady(int next_frame_buffer_size) override {
// std::vector<uint8_t> buffer;
// buffer.resize(next_frame_buffer_size);
// openscreen::cast::EncodedFrame encoded_frame =
// receiver_->ConsumeNextFrame(absl::Span<uint8_t>(buffer));
//
// display_.RenderFrame(decoder_.DecodeFrame(encoded_frame.data));
//
// // Note: An implementation could call receiver_->AdvanceToNextFrame()
// // and receiver_->ConsumeNextFrame() in a loop here, to consume all the
// // remaining frames that are ready.
// }
//
// Receiver* const receiver_;
// MyDecoder decoder_;
// MyDisplay display_;
// };
//
// Internally, a queue of complete and partially-received frames is maintained.
// The queue is a circular queue of FrameCollectors that each maintain the
// individual receive state of each in-flight frame. There are three conceptual
// "pointers" that indicate what assumptions and operations are made on certain
// ranges of frames in the queue:
//
// 1. Latest Frame Expected: The FrameId of the latest frame whose existence
// is known to this Receiver. This is the highest FrameId seen in any
// successfully-parsed RTP packet.
// 2. Checkpoint Frame: Indicates that all of the RTP packets for all frames
// up to and including the one having this FrameId have been successfully
// received and processed.
// 3. Last Frame Consumed: The FrameId of last frame consumed (see
// ConsumeNextFrame()). Once a frame is consumed, all internal resources
// related to the frame can be freed and/or re-used for later frames.
class Receiver {
public:
class Consumer {
public:
virtual ~Consumer();
// Called whenever one or more frames have become ready for consumption. The
// |next_frame_buffer_size| argument is identical to the result of calling
// AdvanceToNextFrame(), and so the Consumer only needs to prepare a buffer
// and call ConsumeNextFrame(). It may then call AdvanceToNextFrame() to
// check whether there are any more frames ready, but this is not mandatory.
// See usage example in class-level comments.
virtual void OnFramesReady(int next_frame_buffer_size) = 0;
};
// Constructs a Receiver that attaches to the given |environment| and
// |packet_router|. The config contains the settings that were
// agreed-upon by both sides from the OFFER/ANSWER exchange (i.e., the part of
// the overall end-to-end connection process that occurs before Cast Streaming
// is started).
Receiver(Environment* environment,
ReceiverPacketRouter* packet_router,
const SessionConfig& config);
~Receiver();
Ssrc ssrc() const { return rtcp_session_.receiver_ssrc(); }
int rtp_timebase() const { return rtp_timebase_; }
// Set the Consumer receiving notifications when new frames are ready for
// consumption. Frames received before this method is called will remain in
// the queue indefinitely.
void SetConsumer(Consumer* consumer);
// Sets how much time the consumer will need to decode/buffer/render/etc., and
// otherwise fully process a frame for on-time playback. This information is
// used by the Receiver to decide whether to skip past frames that have
// arrived too late. This method can be called repeatedly to make adjustments
// based on changing environmental conditions.
//
// Default setting: kDefaultPlayerProcessingTime
void SetPlayerProcessingTime(Clock::duration needed_time);
// Propagates a "picture loss indicator" notification to the Sender,
// requesting a key frame so that decode/playout can recover. It is safe to
// call this redundantly. The Receiver will clear the picture loss condition
// automatically, once a key frame is received (i.e., before
// ConsumeNextFrame() is called to access it).
void RequestKeyFrame();
// Advances to the next frame ready for consumption. This may skip-over
// incomplete frames that will not play out on-time; but only if there are
// completed frames further down the queue that have no dependency
// relationship with them (e.g., key frames).
//
// This method returns kNoFramesReady if there is not currently a frame ready
// for consumption. The caller should wait for a Consumer::OnFramesReady()
// notification before trying again. Otherwise, the number of bytes of encoded
// data is returned, and the caller should use this to ensure the buffer it
// passes to ConsumeNextFrame() is large enough.
int AdvanceToNextFrame();
// Returns the next frame, both metadata and payload data. The Consumer calls
// this method after being notified via OnFramesReady(), and it can also call
// this whenever AdvanceToNextFrame() indicates another frame is ready.
// |buffer| must point to a sufficiently-sized buffer that will be populated
// with the frame's payload data. Upon return |frame->data| will be set to the
// portion of the buffer that was populated.
EncodedFrame ConsumeNextFrame(absl::Span<uint8_t> buffer);
// The default "player processing time" amount. See SetPlayerProcessingTime().
static constexpr std::chrono::milliseconds kDefaultPlayerProcessingTime{5};
// Returned by AdvanceToNextFrame() when there are no frames currently ready
// for consumption.
static constexpr int kNoFramesReady = -1;
protected:
friend class ReceiverPacketRouter;
// Called by ReceiverPacketRouter to provide this Receiver with what looks
// like a RTP/RTCP packet meant for it specifically (among other Receivers).
void OnReceivedRtpPacket(Clock::time_point arrival_time,
std::vector<uint8_t> packet);
void OnReceivedRtcpPacket(Clock::time_point arrival_time,
std::vector<uint8_t> packet);
private:
// An entry in the circular queue (see |pending_frames_|).
struct PendingFrame {
FrameCollector collector;
// The Receiver's [local] Clock time when this frame was originally captured
// at the Sender. This is computed and assigned when the RTP packet with ID
// 0 is processed. Add the target playout delay to this to get the target
// playout time.
absl::optional<Clock::time_point> estimated_capture_time;
PendingFrame();
~PendingFrame();
// Reset this entry to its initial state, freeing resources.
void Reset();
};
// Get/Set the checkpoint FrameId. This indicates that all of the packets for
// all frames up to and including this FrameId have been successfully received
// (or otherwise do not need to be re-transmitted).
FrameId checkpoint_frame() const { return rtcp_builder_.checkpoint_frame(); }
void set_checkpoint_frame(FrameId frame_id) {
rtcp_builder_.SetCheckpointFrame(frame_id);
}
// Send an RTCP packet to the Sender immediately, to acknowledge the complete
// reception of one or more additional frames, to reply to a Sender Report, or
// to request re-transmits. Calling this also schedules additional RTCP
// packets to be sent periodically for the life of this Receiver.
void SendRtcp();
// Helpers to map the given |frame_id| to the element in the |pending_frames_|
// circular queue. There are both const and non-const versions, but neither
// mutate any state (i.e., they are just look-ups).
const PendingFrame& GetQueueEntry(FrameId frame_id) const;
PendingFrame& GetQueueEntry(FrameId frame_id);
// Record that the target playout delay has changed starting with the given
// FrameId.
void RecordNewTargetPlayoutDelay(FrameId as_of_frame,
std::chrono::milliseconds delay);
// Examine the known target playout delay changes to determine what setting is
// in-effect for the given frame.
std::chrono::milliseconds ResolveTargetPlayoutDelay(FrameId frame_id) const;
// Called to move the checkpoint forward. This scans the queue, starting from
// |new_checkpoint|, to find the latest in a contiguous sequence of completed
// frames. Then, it records that frame as the new checkpoint, and immediately
// sends a feedback RTCP packet to the Sender.
void AdvanceCheckpoint(FrameId new_checkpoint);
// Helper to force-drop all frames before |first_kept_frame|, even if they
// were never consumed. This will also auto-cancel frames that were never
// completely received, artificially moving the checkpoint forward, and
// notifying the Sender of that. The caller of this method is responsible for
// making sure that frame data dependencies will not be broken by dropping the
// frames.
void DropAllFramesBefore(FrameId first_kept_frame);
// Sets the |consumption_alarm_| to check whether any frames are ready,
// including possibly skipping over late frames in order to make not-yet-late
// frames become ready. The default argument value means "without delay."
void ScheduleFrameReadyCheck(Clock::time_point when = Alarm::kImmediately);
const ClockNowFunctionPtr now_;
ReceiverPacketRouter* const packet_router_;
RtcpSession rtcp_session_;
SenderReportParser rtcp_parser_;
CompoundRtcpBuilder rtcp_builder_;
PacketReceiveStatsTracker stats_tracker_; // Tracks transmission stats.
RtpPacketParser rtp_parser_;
const int rtp_timebase_; // RTP timestamp ticks per second.
const FrameCrypto crypto_; // Decrypts assembled frames.
// Buffer for serializing/sending RTCP packets.
const int rtcp_buffer_capacity_;
const std::unique_ptr<uint8_t[]> rtcp_buffer_;
// Schedules tasks to ensure RTCP reports are sent within a bounded interval.
// Not scheduled until after this Receiver has processed the first packet from
// the Sender.
Alarm rtcp_alarm_;
Clock::time_point last_rtcp_send_time_ = Clock::time_point::min();
// The last Sender Report received and when the packet containing it had
// arrived. This contains lip-sync timestamps used as part of the calculation
// of playout times for the received frames, as well as ping-pong data bounced
// back to the Sender in the Receiver Reports. It is nullopt until the first
// parseable Sender Report is received.
absl::optional<SenderReportParser::SenderReportWithId> last_sender_report_;
Clock::time_point last_sender_report_arrival_time_;
// Tracks the offset between the Receiver's [local] clock and the Sender's
// clock. This is invalid until the first Sender Report has been successfully
// processed (i.e., |last_sender_report_| is not nullopt).
ClockDriftSmoother smoothed_clock_offset_;
// The ID of the latest frame whose existence is known to this Receiver. This
// value must always be greater than or equal to |checkpoint_frame()|.
FrameId latest_frame_expected_ = FrameId::leader();
// The ID of the last frame consumed. This value must always be less than or
// equal to |checkpoint_frame()|, since it's impossible to consume incomplete
// frames!
FrameId last_frame_consumed_ = FrameId::leader();
// The ID of the latest key frame known to be in-flight. This is used by
// RequestKeyFrame() to ensure the PLI condition doesn't get set again until
// after the consumer has seen a key frame that would clear the condition.
FrameId last_key_frame_received_;
// The frame queue (circular), which tracks which frames are in-flight, stores
// data for partially-received frames, and holds onto completed frames until
// the consumer consumes them.
//
// Use GetQueueEntry() to access a slot. The currently-active slots are those
// for the frames after |last_frame_consumed_| and up-to/including
// |latest_frame_expected_|.
std::array<PendingFrame, kMaxUnackedFrames> pending_frames_{};
// Tracks the recent changes to the target playout delay, which is controlled
// by the Sender. The FrameId indicates the first frame where a new delay
// setting takes effect. This vector is never empty, is kept sorted, and is
// pruned to remain as small as possible.
//
// The target playout delay is the amount of time between a frame's
// capture/recording on the Sender and when it should be played-out at the
// Receiver.
std::vector<std::pair<FrameId, std::chrono::milliseconds>>
playout_delay_changes_;
// The consumer to notify when there are one or more frames completed and
// ready to be consumed.
Consumer* consumer_ = nullptr;
// The additional time needed to decode/play-out each frame after being
// consumed from this Receiver.
Clock::duration player_processing_time_ = kDefaultPlayerProcessingTime;
// Scheduled to check whether there are frames ready and, if there are, to
// notify the Consumer via OnFramesReady().
Alarm consumption_alarm_;
// The interval between sending ACK/NACK feedback RTCP messages while
// incomplete frames exist in the queue.
//
// TODO(miu): This should be a function of the current target playout delay,
// similar to the Sender's kickstart interval logic.
static constexpr std::chrono::milliseconds kNackFeedbackInterval{30};
};
} // namespace cast
} // namespace openscreen
#endif // CAST_STREAMING_RECEIVER_H_
| 45.227011 | 80 | 0.744012 |
f7eff3bfe0da9732929c80a2492a86498b7d4053 | 287 | c | C | C语言程序设计基础/35. 【字符】删除重复字符.c | xiabee/BIT-CS | 5d8d8331e6b9588773991a872c259e430ef1eae1 | [
"Apache-2.0"
] | 63 | 2021-01-10T02:32:17.000Z | 2022-03-30T04:08:38.000Z | C语言程序设计基础/35. 【字符】删除重复字符.c | xiabee/BIT-CS | 5d8d8331e6b9588773991a872c259e430ef1eae1 | [
"Apache-2.0"
] | 2 | 2021-06-09T05:38:58.000Z | 2021-12-14T13:53:54.000Z | C语言程序设计基础/35. 【字符】删除重复字符.c | xiabee/BIT-CS | 5d8d8331e6b9588773991a872c259e430ef1eae1 | [
"Apache-2.0"
] | 20 | 2021-01-12T11:49:36.000Z | 2022-03-26T11:04:58.000Z | #include<stdio.h>
#include<string.h>
#define N 100
int main(int argc, char *argv[])
{
static char a[N],b[N];
int i,j,k=0,p;
gets(a);
for(i=0;i<N;i++)
{
for(j=0,p=0;j<N;j++)
{
if(b[j]==a[i])
p=1;
}
if(p==0)
{
b[k]=a[i];
k++;
}
}
puts(b);
return 0;
}
| 11.48 | 32 | 0.463415 |
07641c6df06c406336f6e9134e9273af24359beb | 3,197 | h | C | deps/libgeos/geos/include/geos/noding/snap/SnappingIntersectionAdder.h | khrushjing/node-gdal-async | 6546b0c8690f2db677d5385b40b407523503b314 | [
"Apache-2.0"
] | 42 | 2021-03-26T17:34:52.000Z | 2022-03-18T14:15:31.000Z | deps/libgeos/geos/include/geos/noding/snap/SnappingIntersectionAdder.h | khrushjing/node-gdal-async | 6546b0c8690f2db677d5385b40b407523503b314 | [
"Apache-2.0"
] | 29 | 2021-06-03T14:24:01.000Z | 2022-03-23T15:43:58.000Z | deps/libgeos/geos/include/geos/noding/snap/SnappingIntersectionAdder.h | khrushjing/node-gdal-async | 6546b0c8690f2db677d5385b40b407523503b314 | [
"Apache-2.0"
] | 8 | 2021-05-14T19:26:37.000Z | 2022-03-21T13:44:42.000Z | /**********************************************************************
*
* GEOS - Geometry Engine Open Source
* http://geos.osgeo.org
*
* Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
*
* This is free software; you can redistribute and/or modify it under
* the terms of the GNU Lesser General Public Licence as published
* by the Free Software Foundation.
* See the COPYING file for more information.
*
**********************************************************************/
#pragma once
#include <geos/export.h>
#include <vector>
#include <geos/algorithm/LineIntersector.h> // for composition
#include <geos/geom/Coordinate.h> // for use in vector
#include <geos/geom/PrecisionModel.h> // for inlines (should drop)
#include <geos/noding/SegmentIntersector.h>
// Forward declarations
namespace geos {
namespace geom {
class PrecisionModel;
}
namespace noding {
class SegmentString;
class NodedSegmentString;
namespace snap {
class SnappingPointIndex;
}
}
}
namespace geos {
namespace noding { // geos::noding
namespace snap { // geos::noding::snap
class GEOS_DLL SnappingIntersectionAdder: public SegmentIntersector { // implements SegmentIntersector
private:
algorithm::LineIntersector li;
double snapTolerance;
SnappingPointIndex& snapPointIndex;
/**
* If an endpoint of one segment is near
* the <i>interior</i> of the other segment, add it as an intersection.
* EXCEPT if the endpoint is also close to a segment endpoint
* (since this can introduce "zigs" in the linework).
* <p>
* This resolves situations where
* a segment A endpoint is extremely close to another segment B,
* but is not quite crossing. Due to robustness issues
* in orientation detection, this can
* result in the snapped segment A crossing segment B
* without a node being introduced.
*/
void processNearVertex(
SegmentString* srcSS,
std::size_t srcIndex,
const geom::Coordinate& p,
SegmentString* ss,
std::size_t segIndex,
const geom::Coordinate& p0,
const geom::Coordinate& p1);
/**
* Tests if segments are adjacent on the same SegmentString.
* Closed segStrings require a check for the point shared by the beginning
* and end segments.
*/
static bool isAdjacent(SegmentString* ss0, std::size_t segIndex0, SegmentString* ss1, std::size_t segIndex1);
public:
SnappingIntersectionAdder(double p_snapTolerance, SnappingPointIndex& p_snapPointIndex);
/**
* This method is called by clients
* of the {@link SegmentIntersector} class to process
* intersections for two segments of the {@link SegmentString}s being intersected.
* Note that some clients (such as <code>MonotoneChain</code>s) may optimize away
* this call for segment pairs which they have determined do not intersect
* (e.g. by an disjoint envelope test).
*/
void processIntersections(SegmentString* e0, std::size_t segIndex0, SegmentString* e1, std::size_t segIndex1) override;
bool isDone() const override { return false; };
};
} // namespace geos::noding::snapround
} // namespace geos::noding
} // namespace geos
| 29.063636 | 123 | 0.680951 |
e00e939bd06d99f7c9ef3a6d9723a2cf563d15d2 | 604 | h | C | ports/www/chromium-legacy/newport/files/patch-content_public_common_common__param__traits__macros.h | liweitianux/DeltaPorts | b907de0ceb9c0e46ae8961896e97b361aa7c62c0 | [
"BSD-2-Clause-FreeBSD"
] | 31 | 2015-02-06T17:06:37.000Z | 2022-03-08T19:53:28.000Z | ports/www/chromium-legacy/newport/files/patch-content_public_common_common__param__traits__macros.h | liweitianux/DeltaPorts | b907de0ceb9c0e46ae8961896e97b361aa7c62c0 | [
"BSD-2-Clause-FreeBSD"
] | 236 | 2015-06-29T19:51:17.000Z | 2021-12-16T22:46:38.000Z | ports/www/chromium-legacy/newport/files/patch-content_public_common_common__param__traits__macros.h | liweitianux/DeltaPorts | b907de0ceb9c0e46ae8961896e97b361aa7c62c0 | [
"BSD-2-Clause-FreeBSD"
] | 52 | 2015-02-06T17:05:36.000Z | 2021-10-21T12:13:06.000Z | --- content/public/common/common_param_traits_macros.h.orig 2021-01-18 21:28:57 UTC
+++ content/public/common/common_param_traits_macros.h
@@ -134,7 +134,7 @@ IPC_STRUCT_TRAITS_BEGIN(blink::RendererPreferences)
IPC_STRUCT_TRAITS_MEMBER(accept_languages)
IPC_STRUCT_TRAITS_MEMBER(plugin_fullscreen_allowed)
IPC_STRUCT_TRAITS_MEMBER(caret_browsing_enabled)
-#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_BSD)
IPC_STRUCT_TRAITS_MEMBER(system_font_family_name)
IPC_STRUCT_TRAITS_MEMBER(selection_clipboard_buffer_available)
#endif
| 50.333333 | 83 | 0.824503 |
d4376b0c00fa77d04d4bcd533a8af8bb90fded72 | 866 | h | C | src/debugging/Inspector/Inspector/NativeScript Inspector/InspectorFrontendHost.h | NathanWalker/ios-runtime | 233a15210cbc2ac568722683e919cdbac9864550 | [
"Apache-2.0"
] | 319 | 2015-03-05T16:19:10.000Z | 2021-12-03T15:46:17.000Z | src/debugging/Inspector/Inspector/NativeScript Inspector/InspectorFrontendHost.h | NathanWalker/ios-runtime | 233a15210cbc2ac568722683e919cdbac9864550 | [
"Apache-2.0"
] | 1,032 | 2015-03-06T12:40:36.000Z | 2022-03-31T08:23:49.000Z | src/debugging/Inspector/Inspector/NativeScript Inspector/InspectorFrontendHost.h | NathanWalker/ios-runtime | 233a15210cbc2ac568722683e919cdbac9864550 | [
"Apache-2.0"
] | 75 | 2015-03-05T21:44:00.000Z | 2022-03-23T16:34:35.000Z | #import "Communication.h"
#import "InspectorFrontendHostProtocol.h"
#import <Foundation/Foundation.h>
@import AppKit;
@interface InspectorFrontendHost : NSObject <InspectorFrontendHostProtocol> {
TNSCommunicationChannel* communication_channel;
}
- (NSString*)platform;
- (NSString*)localizedStringsURL;
- (NSString*)debuggableType;
- (NSString*)backendCommandsURL;
- (NSString*)zoomFactor;
- (unsigned)inspectionLevel;
- (void)connect:(NSString*)socketPath
readHandler:(InspectorReadHandler)read_handler
errorHandler:(InspectorErrorHandler)errorHandler;
- (void)disconnect;
- (void)loaded;
- (void)bringToFront;
- (void)sendMessageToBackend:(NSString*)message;
- (void)inspectedURLChanged;
- (void)startWindowDrag;
- (void)setZoomFactor:(NSString*)factor;
- (void)showContextMenu;
- (void)openInNewTab;
- (NSString*)userInterfaceLayoutDirection;
@end
| 28.866667 | 77 | 0.786374 |
b4923eeefdc5cd2f0dece34ffe30d8ac54fd07fd | 5,248 | c | C | glib-2.64.0/gio/tests/giomodule.c | BeanGreen247/surf | a56d1b0ceb43c578c6a3258e4ffb2903dc691fe2 | [
"MIT"
] | null | null | null | glib-2.64.0/gio/tests/giomodule.c | BeanGreen247/surf | a56d1b0ceb43c578c6a3258e4ffb2903dc691fe2 | [
"MIT"
] | null | null | null | glib-2.64.0/gio/tests/giomodule.c | BeanGreen247/surf | a56d1b0ceb43c578c6a3258e4ffb2903dc691fe2 | [
"MIT"
] | null | null | null | /* Unit tests for GIOModule
* Copyright (C) 2013 Red Hat, Inc
* Author: Matthias Clasen
*
* This work is provided "as is"; redistribution and modification
* in whole or in part, in any medium, physical or electronic is
* permitted without restriction.
*
* This work is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* In no event shall the authors or contributors be liable for any
* direct, indirect, incidental, special, exemplary, or consequential
* damages (including, but not limited to, procurement of substitute
* goods or services; loss of use, data, or profits; or business
* interruption) however caused and on any theory of liability, whether
* in contract, strict liability, or tort (including negligence or
* otherwise) arising in any way out of the use of this software, even
* if advised of the possibility of such damage.
*/
#include <gio/gio.h>
#include <glibconfig.h>
#ifdef _MSC_VER
# define MODULE_FILENAME_PREFIX ""
#else
# define MODULE_FILENAME_PREFIX "lib"
#endif
static void
test_extension_point (void)
{
GIOExtensionPoint *ep, *ep2;
GIOExtension *ext;
GList *list;
GType req;
GTypeClass *class;
ep = g_io_extension_point_lookup ("test-extension-point");
g_assert_null (ep);
ep = g_io_extension_point_register ("test-extension-point");
ep2 = g_io_extension_point_lookup ("test-extension-point");
g_assert (ep2 == ep);
req = g_io_extension_point_get_required_type (ep);
g_assert (req == G_TYPE_INVALID);
g_io_extension_point_set_required_type (ep, G_TYPE_OBJECT);
req = g_io_extension_point_get_required_type (ep);
g_assert (req == G_TYPE_OBJECT);
list = g_io_extension_point_get_extensions (ep);
g_assert_null (list);
g_io_extension_point_implement ("test-extension-point",
G_TYPE_VFS,
"extension1",
10);
g_io_extension_point_implement ("test-extension-point",
G_TYPE_OBJECT,
"extension2",
20);
list = g_io_extension_point_get_extensions (ep);
g_assert_cmpint (g_list_length (list), ==, 2);
ext = list->data;
g_assert_cmpstr (g_io_extension_get_name (ext), ==, "extension2");
g_assert (g_io_extension_get_type (ext) == G_TYPE_OBJECT);
g_assert (g_io_extension_get_priority (ext) == 20);
class = g_io_extension_ref_class (ext);
g_assert (class == g_type_class_peek (G_TYPE_OBJECT));
g_type_class_unref (class);
ext = list->next->data;
g_assert_cmpstr (g_io_extension_get_name (ext), ==, "extension1");
g_assert (g_io_extension_get_type (ext) == G_TYPE_VFS);
g_assert (g_io_extension_get_priority (ext) == 10);
}
static void
test_module_scan_all (void)
{
#ifdef GLIB_STATIC_COMPILATION
/* The plugin module is statically linked with a separate copy
* of GLib so g_io_extension_point_implement won't work. */
g_test_skip ("GIOExtensionPoint with dynamic modules isn't supported in static builds.");
return;
#endif
if (g_test_subprocess ())
{
GIOExtensionPoint *ep;
GIOExtension *ext;
GList *list;
ep = g_io_extension_point_register ("test-extension-point");
g_io_modules_scan_all_in_directory (g_test_get_filename (G_TEST_BUILT, "modules", NULL));
list = g_io_extension_point_get_extensions (ep);
g_assert_cmpint (g_list_length (list), ==, 2);
ext = list->data;
g_assert_cmpstr (g_io_extension_get_name (ext), ==, "test-b");
ext = list->next->data;
g_assert_cmpstr (g_io_extension_get_name (ext), ==, "test-a");
return;
}
g_test_trap_subprocess (NULL, 0, 7);
g_test_trap_assert_passed ();
}
static void
test_module_scan_all_with_scope (void)
{
#ifdef GLIB_STATIC_COMPILATION
/* Disabled for the same reason as test_module_scan_all. */
g_test_skip ("GIOExtensionPoint with dynamic modules isn't supported in static builds.");
return;
#endif
if (g_test_subprocess ())
{
GIOExtensionPoint *ep;
GIOModuleScope *scope;
GIOExtension *ext;
GList *list;
ep = g_io_extension_point_register ("test-extension-point");
scope = g_io_module_scope_new (G_IO_MODULE_SCOPE_BLOCK_DUPLICATES);
g_io_module_scope_block (scope, MODULE_FILENAME_PREFIX "testmoduleb." G_MODULE_SUFFIX);
g_io_modules_scan_all_in_directory_with_scope (g_test_get_filename (G_TEST_BUILT, "modules", NULL), scope);
list = g_io_extension_point_get_extensions (ep);
g_assert_cmpint (g_list_length (list), ==, 1);
ext = list->data;
g_assert_cmpstr (g_io_extension_get_name (ext), ==, "test-a");
g_io_module_scope_free (scope);
return;
}
g_test_trap_subprocess (NULL, 0, 7);
g_test_trap_assert_passed ();
}
int
main (int argc, char *argv[])
{
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/giomodule/extension-point", test_extension_point);
g_test_add_func ("/giomodule/module-scan-all", test_module_scan_all);
g_test_add_func ("/giomodule/module-scan-all-with-scope", test_module_scan_all_with_scope);
return g_test_run ();
}
| 34.077922 | 113 | 0.705221 |
98609dae4149dcd4ff96e9629195167dc523c6d3 | 5,033 | h | C | isode++/code/iso/itu/osi/fsmc/cmp/Parser.h | Kampbell/ISODE | 37f161e65f11348ef6fca2925d399d611df9f31b | [
"Apache-2.0"
] | 3 | 2016-01-18T17:00:00.000Z | 2021-06-25T03:18:13.000Z | isode++/code/iso/itu/osi/fsmc/cmp/Parser.h | Kampbell/ISODE | 37f161e65f11348ef6fca2925d399d611df9f31b | [
"Apache-2.0"
] | null | null | null | isode++/code/iso/itu/osi/fsmc/cmp/Parser.h | Kampbell/ISODE | 37f161e65f11348ef6fca2925d399d611df9f31b | [
"Apache-2.0"
] | null | null | null | /*
* Parser.h
*
* Created on: 16 janv. 2016
* Author: FrancisANDRE
*/
#ifndef ALS_SMC_PARSER_H_
#define ALS_SMC_PARSER_H_
#include <stack>
using std::stack;
#include "Poco/Path.h"
#include "Poco/File.h"
#include "Poco/Logger.h"
#include "Poco/Token.h"
#include "Poco/CountingStream.h"
using Poco::Logger;
using Poco::Token;
using Poco::Path;
using Poco::File;
using Poco::CountingInputStream;
#include "fsmc/cmp/Tokenizer.h"
#include "fsmc/smc/smc.h"
using ALS::SMC::MODEL::StatePtr;
using ALS::SMC::MODEL::EntryPtr;
using ALS::SMC::MODEL::ExitPtr;
using ALS::SMC::MODEL::GuardPtr;
using ALS::SMC::MODEL::MapPtr;
using ALS::SMC::MODEL::ActionPtr;
using ALS::SMC::MODEL::TransitionPtr;
using ALS::SMC::MODEL::ParameterPtr;
using ALS::SMC::MODEL::FSMPtr;
using ALS::SMC::MODEL::ExpressionPtr;
using ALS::SMC::MODEL::ArgumentPtr;
using ALS::SMC::MODEL::ReferencePtr;
namespace ALS {
namespace SMC {
namespace PARSER {
class Parser {
public:
Parser(Logger& logger, const File& smfile, istream& istr);
virtual ~Parser();
FSMPtr parse(const Path& out);
protected:
const Poco::Token* parseAccess(const Poco::Token* next);
const Poco::Token* parseAction(const Poco::Token* next);
const Poco::Token* parseActions(const Poco::Token* next, List<const ActionPtr>& actions);
const Poco::Token* parseArgument(const Poco::Token* next, List<ArgumentPtr>& list);
const Poco::Token* parseArguments(const Poco::Token* next, List<ArgumentPtr>& list);
const Poco::Token* parseClass(const Poco::Token* next);
const Poco::Token* parseDeclare(const Poco::Token* next);
const Poco::Token* parseEntry(const Poco::Token* next);
const Poco::Token* parseExit(const Poco::Token* next);
const Poco::Token* parseExpression(const Poco::Token* next, ExpressionPtr& expression);
const Poco::Token* parseFSM(const Poco::Token* next);
const Poco::Token* parseFSMClass(const Poco::Token* next);
const Poco::Token* parseFSMFile(const Poco::Token* next);
const Poco::Token* parseFile(const Poco::Token* next, const Path& out);
const Poco::Token* parseGuard(const Poco::Token* next);
const Poco::Token* parseHeader(const Poco::Token* next);
const Poco::Token* parseImport(const Poco::Token* next);
const Poco::Token* parseInclude(const Poco::Token* next);
const Poco::Token* parseIncludes(const Poco::Token* next);
const Poco::Token* parseMap(const Poco::Token* next);
const Poco::Token* parseNext(const Poco::Token* next);
const Poco::Token* parsePackage(const Poco::Token* next);
const Poco::Token* parseParameter(const Poco::Token* next);
const Poco::Token* parseParameters(const Poco::Token* next);
const Poco::Token* parsePopArguments(const Poco::Token* next);
const Poco::Token* parsePopTransition(const Poco::Token* next);
const Poco::Token* parsePushTransition(const Poco::Token* next);
const Poco::Token* parseRawCode(const Poco::Token* next);
const Poco::Token* parseSource(const Poco::Token* next);
const Poco::Token* parseStart(const Poco::Token* next);
const Poco::Token* parseState(const Poco::Token* next);
const Poco::Token* parseStates(const Poco::Token* next);
const Poco::Token* parseTransition(const Poco::Token* next);
const Poco::Token* parseTransitionArgs(const Poco::Token* next);
const Poco::Token* parseTransitions(const Poco::Token* next);
const Poco::Token* parseTerminal(const Poco::Token* next, ReferencePtr& reference);
static bool isString(const Poco::Token* token);
static bool isCharacter(const Poco::Token* token);
static bool isNumber(const Poco::Token* token);
static bool isIdentifier(const Poco::Token* token);
static bool isOperator(const Poco::Token* token);
static bool isOperator(const Poco::Token* token, int kind);
static bool isKeyword(const Poco::Token* token, int kind);
static bool isEOF(const Poco::Token* token);
static void expectOperator(const Poco::Token* token, int kind, const string& msg);
static void syntaxError(const string& msg);
static void append(string& decl, const string& token);
static void append(string& decl, const Poco::Token* token);
const Poco::Token* nextToken();
const Poco::Token* nextPreprocessed();
const Poco::Token* nextParserToken();
void reduce();
public:
const File& file() const { return _file; }
private:
CountingInputStream _istr;
Tokenizer _tokenizer;
File _file;
Path _path;
string _currentPath;
bool _inFile;
string _package;
string _library;
string _doc;
string _attrs;
FSMPtr fsm = nullptr;
StatePtr state= nullptr;
GuardPtr guard= nullptr;
MapPtr map= nullptr;
ActionPtr action= nullptr;
TransitionPtr transition= nullptr;
ParameterPtr parameter= nullptr;
List<ParameterPtr> parameters;
EntryPtr entry = nullptr;
ExitPtr exit = nullptr;
Logger& _logger;
stack<ExpressionPtr> stack;
};
}
}
}
#endif
| 35.695035 | 93 | 0.702364 |
54d5b61d715a306b40c6162d538842424059a66c | 2,639 | h | C | chainerx_cc/chainerx/reduction_kernel_arg.h | zaltoprofen/chainer | 3b03f9afc80fd67f65d5e0395ef199e9506b6ee1 | [
"MIT"
] | 3,705 | 2017-06-01T07:36:12.000Z | 2022-03-30T10:46:15.000Z | chainerx_cc/chainerx/reduction_kernel_arg.h | nolfwin/chainer | 8d776fcc1e848cb9d3800a6aab356eb91ae9d088 | [
"MIT"
] | 5,998 | 2017-06-01T06:40:17.000Z | 2022-03-08T01:42:44.000Z | chainerx_cc/chainerx/reduction_kernel_arg.h | nolfwin/chainer | 8d776fcc1e848cb9d3800a6aab356eb91ae9d088 | [
"MIT"
] | 1,150 | 2017-06-02T03:39:46.000Z | 2022-03-29T02:29:32.000Z | #pragma once
#include <algorithm>
#include <cstdint>
#include "chainerx/array.h"
#include "chainerx/indexable_array.h"
#include "chainerx/indexer.h"
#include "chainerx/shape.h"
#include "chainerx/strides.h"
namespace chainerx {
// Argument to reduction kernels.
//
// It contains five data:
//
// - Input indexable array
// - Output indexable array
// - Input indexer (using the input shape)
// - Output indexer (using the output shape)
//
// Input and output arrays are transposed so that the reduction axes come last. Axes of length 1 are also removed.
//
// Any instance of this struct can be passed directly to a kernel function (including CUDA __global__ function).
template <typename In, typename Out, int8_t InNdim = kDynamicNdim, int8_t OutNdim = kDynamicNdim>
struct ReductionKernelArg {
IndexableArray<const In, InNdim> in;
IndexableArray<Out, OutNdim> out;
Indexer<InNdim> in_indexer;
Indexer<OutNdim> out_indexer;
};
// A structure to represent argument of Reduce function.
//
// This structure is used to make a reduction kernel argument having indexers with dynamic ndim or statically optmized ndim.
//
// Strides and shapes are permuted so that the reduction axes come last. Axes of length 1 are also removed.
// Contiguous dimensions of strides and shapes are squashed.
class ReductionArg {
public:
ReductionArg(const Array& in, const Axes& axis, const Array& out);
const Array& in() const { return in_; }
const Array& out() const { return out_; }
const Strides& in_strides() const { return in_strides_; }
const Strides& out_strides() const { return out_strides_; }
const Shape& in_shape() const { return in_shape_; }
const Shape& out_shape() const { return out_shape_; }
private:
void Permute(const Axes& axis);
void Squash();
const Array& in_;
const Array& out_;
Strides in_strides_{};
Strides out_strides_{};
Shape in_shape_{};
Shape out_shape_{};
};
// Creates ReductionKernelArg from ReductionArg
template <typename In, typename Out, int8_t InNdim = kDynamicNdim, int8_t OutNdim = kDynamicNdim>
ReductionKernelArg<In, Out, InNdim, OutNdim> MakeReductionKernelArg(const ReductionArg& arg) {
return ReductionKernelArg<In, Out, InNdim, OutNdim>{IndexableArray<const In, InNdim>{arg.in(), arg.in_strides()},
IndexableArray<Out, OutNdim>{arg.out(), arg.out_strides()},
Indexer<InNdim>{arg.in_shape()},
Indexer<OutNdim>{arg.out_shape()}};
}
} // namespace chainerx
| 36.150685 | 124 | 0.686245 |
8eb23b28dbe13fe79dd9fecae2132f4b34a674cb | 504 | h | C | H/Lexer/Lexer.h | lehtojo/Evie | f41b3872f6a1a7da1778c241c7b01823b36ac78d | [
"MIT"
] | 12 | 2020-07-12T06:22:11.000Z | 2022-02-27T13:19:19.000Z | H/Lexer/Lexer.h | lehtojo/Evie | f41b3872f6a1a7da1778c241c7b01823b36ac78d | [
"MIT"
] | 2 | 2020-07-12T06:22:48.000Z | 2021-11-28T01:23:25.000Z | H/Lexer/Lexer.h | lehtojo/Evie | f41b3872f6a1a7da1778c241c7b01823b36ac78d | [
"MIT"
] | 3 | 2021-09-16T19:02:19.000Z | 2021-11-28T00:50:15.000Z | #ifndef _LEXER_H_
#define _LEXER_H_
#include "Component.h"
#include "..//Flags.h"
namespace Lexer
{
extern char SingleLineCommentIdentifier;
extern char StringIdentifier;
extern char DecimalSeparator;
extern char ExponentSeparator;
extern vector<string> Operators;
extern vector<string> Keywords;
extern vector<Component> GetComponentsFromFile(string file);
extern vector<Component> GetComponents(string text);
extern Component GetComponent(string text);
}
#endif | 22.909091 | 64 | 0.755952 |
c2c3d5597dd898433050ddc1d8952e8e572621ae | 1,608 | h | C | include/bluetooth/driver.h | piroux/zephyr | 21594aa1fd1fd22928364540561701db17f69dfb | [
"Apache-2.0"
] | 6 | 2016-06-07T00:06:31.000Z | 2021-03-20T19:48:54.000Z | include/bluetooth/driver.h | piroux/zephyr | 21594aa1fd1fd22928364540561701db17f69dfb | [
"Apache-2.0"
] | 2 | 2016-08-30T01:28:57.000Z | 2017-09-27T01:50:28.000Z | include/bluetooth/driver.h | piroux/zephyr | 21594aa1fd1fd22928364540561701db17f69dfb | [
"Apache-2.0"
] | 5 | 2016-06-11T07:44:20.000Z | 2021-06-12T17:41:37.000Z | /** @file
* @brief Bluetooth HCI driver API.
*/
/*
* Copyright (c) 2015 Intel 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.
*/
#ifndef __BT_DRIVER_H
#define __BT_DRIVER_H
#include <net/buf.h>
enum bt_buf_type {
BT_CMD, /** HCI command */
BT_EVT, /** HCI event */
BT_ACL_OUT, /** Outgoing ACL data */
BT_ACL_IN, /** Incoming ACL data */
};
/* Allocate a buffer for an HCI event */
struct net_buf *bt_buf_get_evt(void);
/* Allocate a buffer for incoming ACL data */
struct net_buf *bt_buf_get_acl(void);
#ifdef __cplusplus
extern "C" {
#endif
/* Receive data from the controller/HCI driver */
void bt_recv(struct net_buf *buf);
struct bt_driver {
/* Open the HCI transport */
int (*open)(void);
/* Send buffer command to controller */
int (*send)(enum bt_buf_type type, struct net_buf *buf);
};
/* Register a new HCI driver to the Bluetooth stack */
int bt_driver_register(struct bt_driver *drv);
/* Unregister a previously registered HCI driver */
void bt_driver_unregister(struct bt_driver *drv);
#ifdef __cplusplus
}
#endif
#endif /* __BT_DRIVER_H */
| 25.125 | 75 | 0.71704 |
fc3a9e2035ca4a8fd99117f87d3241fe5ccbb526 | 3,822 | c | C | old/s_output.c | Shadorain/ShadoEditor_TestZone | 29829db2e2dc213bb29b82c22949db3527a1b1a8 | [
"BSD-3-Clause"
] | 8 | 2021-02-28T22:39:36.000Z | 2021-12-24T16:57:09.000Z | s_output.c | Shadorain/ShadoEditor | 4161a17bf6839629e9fa1110351598db49b2b9b4 | [
"BSD-3-Clause"
] | null | null | null | s_output.c | Shadorain/ShadoEditor | 4161a17bf6839629e9fa1110351598db49b2b9b4 | [
"BSD-3-Clause"
] | null | null | null | /* ------------------------------- s_output.c ------------------------------- */
#include "shado.h"
void scroll () {
E.rx = 0;
if (E.cy < E.numrows)
E.rx = row_cx_to_rx(&E.row[E.cy], E.cx);
if (E.cy < E.rowoff)
E.rowoff = E.cy;
if (E.cy >= E.rowoff + E.screenrows)
E.rowoff = E.cy - E.screenrows + 1;
if (E.rx < E.coloff)
E.coloff = E.rx;
if (E.rx >= E.coloff + E.screencols)
E.coloff = E.rx - E.screencols + 1;
}
void draw_rows (struct abuf *ab) {
int y;
for (y = 0; y < E.screenrows; y++) {
int filerow = y + E.rowoff;
if (filerow >= E.numrows) {
if (E.numrows == 0 && y == E.screenrows / 3) {
char welcome[80];
int welcomelen = snprintf(welcome, sizeof(welcome),
"Shado editor -- version %s", SHADO_VERSION);
if (welcomelen > E.screencols) welcomelen = E.screencols;
int padding = (E.screencols - welcomelen) / 2;
if (padding) {
ab_append(ab, "~", 1);
padding--;
}
while (padding--) ab_append(ab, " ", 1);
ab_append(ab, welcome, welcomelen);
} else
ab_append(ab, "~", 1);
} else {
int len = E.row[filerow].rsize - E.coloff;
if (len < 0) len = 0;
if (len > E.screencols) len = E.screencols;
char *c = &E.row[filerow].render[E.coloff];
unsigned char *hl = &E.row[filerow].hl[E.coloff];
int cur_col = -1;
int i;
for (i = 0; i < len; i++)
if (iscntrl(c[i])) {
char sym = (c[i] <= 26) ? '@' + c[i] : '?';
ab_append(ab, "\x1b[7m", 4);
ab_append(ab, &sym, 1);
ab_append(ab, "\x1b[m", 3);
if (cur_col != -1) {
char buf[16];
int clen = snprintf(buf, sizeof(buf), "\x1b[%dm", cur_col);
ab_append(ab, buf, clen);
}
} else if (hl[i] == HL_NORMAL) {
if (cur_col != -1) {
ab_append(ab, "\x1b[39m", 5);
cur_col = -1;
}
ab_append(ab, &c[i], 1);
} else {
int color = syntax_to_color(hl[i]);
if (color != cur_col) {
cur_col = color;
char buf[16];
int clen = snprintf(buf, sizeof(buf), "\x1b[%dm", color);
ab_append(ab, buf, clen);
}
ab_append(ab, &c[i], 1);
}
ab_append(ab, "\x1b[39m", 5);
}
ab_append(ab, "\x1b[K", 3);
/* if (y < E.screenrows - 1) */
ab_append(ab, "\r\n", 2);
}
}
void refresh_screen () {
scroll();
struct abuf ab = ABUF_INIT;
ab_append(&ab, "\x1b[?25l", 6); /* Hide Cursor */
ab_append(&ab, "\x1b[H", 3); /* Reposition Cursor */
draw_rows(&ab);
draw_sts_bar(&ab);
draw_msg_bar(&ab);
char buf[32];
snprintf(buf, sizeof(buf), "\x1b[%d;%dH", (E.cy - E.rowoff) + 1,
(E.rx - E.coloff) + 1);
ab_append(&ab, buf, strlen(buf));
ab_append(&ab, "\x1b[?25h", 6); /* Unhide Cursor */
write(STDOUT_FILENO, ab.b, ab.len);
ab_free(&ab);
}
void set_cursor_type () {
if(E.mode == 1) write(STDOUT_FILENO, "\x1b[6 q", 5);
else if(E.mode == 10) write(STDOUT_FILENO, "\x1b[4 q", 5);
else write(STDOUT_FILENO, "\x1b[2 q", 5);
}
/* -------------------------------------------------------------------------- */
| 35.388889 | 83 | 0.405808 |
504165167070d662475f9f8c88df5308e46be631 | 80 | h | C | src/cpp/KnnAlgorithm.h | biovault/nptsne | 9f70726d26ae49a0c5f8c6fe3f081234dbfa69ab | [
"Apache-2.0"
] | 30 | 2019-10-25T06:09:38.000Z | 2022-03-12T08:29:17.000Z | src/cpp/KnnAlgorithm.h | biovault/nptsne | 9f70726d26ae49a0c5f8c6fe3f081234dbfa69ab | [
"Apache-2.0"
] | 13 | 2019-08-07T16:57:19.000Z | 2022-03-13T10:26:18.000Z | src/cpp/KnnAlgorithm.h | biovault/nptsne | 9f70726d26ae49a0c5f8c6fe3f081234dbfa69ab | [
"Apache-2.0"
] | 2 | 2019-11-11T13:07:30.000Z | 2020-03-11T06:00:16.000Z | #pragma once
enum class KnnAlgorithm {
Flann = -1,
HNSW = 0,
Annoy = 1
}; | 11.428571 | 25 | 0.6 |
da192065a814f38d5e14fcc999a442ce8d70b0ec | 1,058 | h | C | src/groups/misc.h | Abde5/GBT-Emulator | 5c4ea9a350dfc9710997506caaa6f5f8fd319270 | [
"MIT"
] | 5 | 2021-04-01T11:14:04.000Z | 2021-10-01T22:57:05.000Z | src/groups/misc.h | Abde5/GBT-Emulator | 5c4ea9a350dfc9710997506caaa6f5f8fd319270 | [
"MIT"
] | 2 | 2021-04-01T16:31:31.000Z | 2021-04-01T18:24:36.000Z | src/groups/misc.h | Abde5/GBT-Emulator | 5c4ea9a350dfc9710997506caaa6f5f8fd319270 | [
"MIT"
] | 1 | 2021-04-01T11:16:28.000Z | 2021-04-01T11:16:28.000Z | #ifndef MISC_H
#define MISC_H
#include "../cpu.h"
#include "../mmu.h"
/*
* NOP operation.
*/
void Nop00(struct CPU* cpu, struct MMU* mmu);
/*
* Rotate register A left by adding carry flag.
*/
void Rlca07(struct CPU* cpu, struct MMU* mmu);
/*
* Rotate register A right by adding carry flag.
*/
void Rrca0F(struct CPU* cpu, struct MMU* mmu);
/*
* STOP command -> halts gameboy proc + screen until button pressed.
*/
void Stop10(struct CPU* cpu, struct MMU* mmu);
/*
* Rotate register A left to carry flag.
*/
void Rla17(struct CPU* cpu, struct MMU* mmu);
/*
* Rotate register A right to carry flag.
*/
void Rra1F(struct CPU* cpu, struct MMU* mmu);
/*
* Stops CPU until interrupts occurs.
*/
void Halt76(struct CPU* cpu, struct MMU* mmu);
/*
* Disable interrupts after next operation.
*/
void DiF3(struct CPU* cpu, struct MMU* mmu);
/*
* Enable interrupts after next operation.
*/
void EiFB(struct CPU* cpu, struct MMU* mmu);
/*
* Next instruction is prefixed.
*/
void PrefCB(struct CPU* cpu, struct MMU* mmu);
#endif // MISC_H
| 17.932203 | 68 | 0.671078 |
fbadfe78289befec3a54026dfcf3de53e2b610b2 | 825 | h | C | TXKomlinIM/Classes/TXKomlinIMConfiguration.h | xtzPioneer/TXKomlinIM | 08415e86f7c5b2e8371802ccf1dbe8eaf86798d5 | [
"MIT"
] | null | null | null | TXKomlinIM/Classes/TXKomlinIMConfiguration.h | xtzPioneer/TXKomlinIM | 08415e86f7c5b2e8371802ccf1dbe8eaf86798d5 | [
"MIT"
] | null | null | null | TXKomlinIM/Classes/TXKomlinIMConfiguration.h | xtzPioneer/TXKomlinIM | 08415e86f7c5b2e8371802ccf1dbe8eaf86798d5 | [
"MIT"
] | null | null | null | //
// TXKomlinIMConfiguration.h
// TXXMPP
//
// Created by xtz_pioneer on 2019/4/1.
// Copyright © 2019 zhangxiong. All rights reserved.
//
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
/**
* 空灵即时通讯配置文件
*/
@interface TXKomlinIMConfiguration : NSObject
/** 空灵即时通讯服务器地址 */
@property (nonatomic,copy)NSString *komlinIMServerAddress;
/** 空灵即时通讯服务器端口 */
@property (nonatomic,assign)UInt16 komlinIMServerPort;
/** 空灵即时通讯域名 */
@property (nonatomic,copy)NSString *komlinIMDomain;
/** 空灵即时通讯源 */
@property (nonatomic,copy)NSString *komlinIMResource;
/** 心跳包间隔 */
@property (nonatomic,assign)NSTimeInterval pingInterval;
/** 重连时间间隔 */
@property (nonatomic,assign)NSTimeInterval reconnectTimerInterval;
/** 重新连接延迟时间 */
@property (nonatomic,assign)NSTimeInterval reconnectDelay;
@end
NS_ASSUME_NONNULL_END
| 19.642857 | 66 | 0.753939 |
7418ee7c9a881bd9d7f56727db6d7b074dd630e0 | 1,200 | h | C | include/h5geo/misc/h5seiscontainerimpl.h | kerim371/h5geo | a023d8c667ff002de361e8184165e6d72e510bde | [
"MIT"
] | 1 | 2021-06-17T23:40:52.000Z | 2021-06-17T23:40:52.000Z | include/h5geo/misc/h5seiscontainerimpl.h | tierra-colada/h5geo | 1d577f4194c0f7826a3e584742fc9714831ec368 | [
"MIT"
] | null | null | null | include/h5geo/misc/h5seiscontainerimpl.h | tierra-colada/h5geo | 1d577f4194c0f7826a3e584742fc9714831ec368 | [
"MIT"
] | null | null | null | #ifndef H5SEISCONTAINERIMPL_H
#define H5SEISCONTAINERIMPL_H
#include "../h5seiscontainer.h"
#include "h5basecontainerimpl.h"
class H5SeisContainerImpl : public H5BaseContainerImpl<H5SeisContainer>
{
protected:
explicit H5SeisContainerImpl(const h5gt::File &h5File);
virtual ~H5SeisContainerImpl() = default;
public:
virtual H5Seis* getSeis(
const std::string& name) override;
virtual H5Seis* getSeis(
h5gt::Group group) override;
virtual H5Seis* createSeis(
std::string& name,
SeisParam& p,
h5geo::CreationType createFlag) override;
virtual H5Seis* createSeis(
h5gt::Group group,
SeisParam& p,
h5geo::CreationType createFlag) override;
virtual std::vector<H5Seis*> getSeisList() override;
//----------- FRIEND CLASSES -----------
friend class H5BaseContainerImpl<H5SeisContainer>;
friend H5SeisContainer* h5geo::createSeisContainer(
h5gt::File h5File, h5geo::CreationType createFlag);
friend H5SeisContainer* h5geo::createSeisContainerByName(
std::string& fileName, h5geo::CreationType createFlag);
friend H5SeisContainer* h5geo::openSeisContainer(
h5gt::File h5File);
};
#endif // H5SEISCONTAINERIMPL_H
| 30 | 71 | 0.73 |
749c345490c2c6c1a25c2e8631e6dd8d5693f69c | 2,676 | c | C | syslinux/gpxe/src/net/icmp.c | TooDumbForAName/modern-boot-floppy | c0f4352ee356aab3f31d214af73d2462bde28198 | [
"BSD-2-Clause"
] | 11 | 2021-12-21T01:32:59.000Z | 2022-03-30T14:37:45.000Z | grub-extras/disabled/gpxe/src/net/icmp.c | GalliumOS/grub2 | a90b0bf25dd265d43b75d40030985594c578ea44 | [
"MIT"
] | 15 | 2022-01-12T00:40:59.000Z | 2022-03-31T17:03:42.000Z | grub-extras/disabled/gpxe/src/net/icmp.c | GalliumOS/grub2 | a90b0bf25dd265d43b75d40030985594c578ea44 | [
"MIT"
] | 7 | 2021-12-20T11:45:46.000Z | 2022-03-15T06:22:52.000Z | /*
* Copyright (C) 2009 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
FILE_LICENCE ( GPL2_OR_LATER );
#include <string.h>
#include <errno.h>
#include <gpxe/iobuf.h>
#include <gpxe/in.h>
#include <gpxe/tcpip.h>
#include <gpxe/icmp.h>
/** @file
*
* ICMP protocol
*
*/
struct tcpip_protocol icmp_protocol __tcpip_protocol;
/**
* Process a received packet
*
* @v iobuf I/O buffer
* @v st_src Partially-filled source address
* @v st_dest Partially-filled destination address
* @v pshdr_csum Pseudo-header checksum
* @ret rc Return status code
*/
static int icmp_rx ( struct io_buffer *iobuf, struct sockaddr_tcpip *st_src,
struct sockaddr_tcpip *st_dest,
uint16_t pshdr_csum __unused ) {
struct icmp_header *icmp = iobuf->data;
size_t len = iob_len ( iobuf );
unsigned int csum;
int rc;
/* Sanity check */
if ( len < sizeof ( *icmp ) ) {
DBG ( "ICMP packet too short at %zd bytes (min %zd bytes)\n",
len, sizeof ( *icmp ) );
rc = -EINVAL;
goto done;
}
/* Verify checksum */
csum = tcpip_chksum ( icmp, len );
if ( csum != 0 ) {
DBG ( "ICMP checksum incorrect (is %04x, should be 0000)\n",
csum );
DBG_HD ( icmp, len );
rc = -EINVAL;
goto done;
}
/* We respond only to pings */
if ( icmp->type != ICMP_ECHO_REQUEST ) {
DBG ( "ICMP ignoring type %d\n", icmp->type );
rc = 0;
goto done;
}
DBG ( "ICMP responding to ping\n" );
/* Change type to response and recalculate checksum */
icmp->type = ICMP_ECHO_RESPONSE;
icmp->chksum = 0;
icmp->chksum = tcpip_chksum ( icmp, len );
/* Transmit the response */
if ( ( rc = tcpip_tx ( iob_disown ( iobuf ), &icmp_protocol, st_dest,
st_src, NULL, NULL ) ) != 0 ) {
DBG ( "ICMP could not transmit ping response: %s\n",
strerror ( rc ) );
goto done;
}
done:
free_iob ( iobuf );
return rc;
}
/** ICMP TCP/IP protocol */
struct tcpip_protocol icmp_protocol __tcpip_protocol = {
.name = "ICMP",
.rx = icmp_rx,
.tcpip_proto = IP_ICMP,
};
| 25.730769 | 76 | 0.667788 |
929200e581b12da47ab0661b2a0f3deef61b4897 | 230 | h | C | XYW8IndicatorViewExample/ViewController.h | levinXiao/AnimationIndicatorView | c236452d459062e23461e2bebab747ff51e53659 | [
"MIT"
] | 4 | 2016-04-07T08:40:14.000Z | 2016-08-15T10:21:21.000Z | XYW8IndicatorViewExample/ViewController.h | levinXiao/AnimationIndicatorView | c236452d459062e23461e2bebab747ff51e53659 | [
"MIT"
] | null | null | null | XYW8IndicatorViewExample/ViewController.h | levinXiao/AnimationIndicatorView | c236452d459062e23461e2bebab747ff51e53659 | [
"MIT"
] | 1 | 2015-12-03T08:03:45.000Z | 2015-12-03T08:03:45.000Z | //
// ViewController.h
// XYW8IndicatorViewExample
//
// Created by xiaoyu on 15/12/2.
// Copyright © 2015年 _companyname_. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface ViewController : UIViewController
@end
| 14.375 | 57 | 0.713043 |
a184751c73cb23b8e127f3b5f568a2df3a691bba | 178 | h | C | vivi/vivi64/CTabBar.h | vivisuke/openViVi | d3e57727393bfc48625945f09ca743e81bf14817 | [
"MIT"
] | 54 | 2020-02-15T23:17:25.000Z | 2021-11-14T17:13:22.000Z | vivi/vivi64/CTabBar.h | vivisuke/openViVi | d3e57727393bfc48625945f09ca743e81bf14817 | [
"MIT"
] | 11 | 2020-06-01T08:04:40.000Z | 2020-11-22T02:18:41.000Z | vivi/vivi64/CTabBar.h | vivisuke/openViVi | d3e57727393bfc48625945f09ca743e81bf14817 | [
"MIT"
] | 1 | 2020-06-01T07:51:47.000Z | 2020-06-01T07:51:47.000Z | #pragma once
#include <QTabBar>
class CTabBar : public QTabBar
{
public:
CTabBar(QWidget *parent = nullptr);
~CTabBar();
protected:
void paintEvent(QPaintEvent *event);
};
| 13.692308 | 37 | 0.719101 |
59752b046067329a4d2bca9b6b0c2f5da8cbbbd5 | 2,446 | c | C | recovery_ui.c | thenameisnigel/miui_recovery | 169c371b0d9a1b5750c94e7c909aaa477643d76e | [
"BSD-2-Clause"
] | null | null | null | recovery_ui.c | thenameisnigel/miui_recovery | 169c371b0d9a1b5750c94e7c909aaa477643d76e | [
"BSD-2-Clause"
] | null | null | null | recovery_ui.c | thenameisnigel/miui_recovery | 169c371b0d9a1b5750c94e7c909aaa477643d76e | [
"BSD-2-Clause"
] | null | null | null | /*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <linux/input.h>
#include "recovery_ui.h"
#include "common.h"
#include "miui/src/miui.h"
//init ui
void device_ui_init() {
main_ui_init();
}
//start ui?
int device_recovery_start() {
return 0;
}
int device_main_ui_show()
{
return main_ui_show();
}
int device_main_ui_release()
{
return main_ui_release();
}
int device_toggle_display(volatile char* key_pressed, int key_code) {
return key_code == KEY_HOME;
}
int device_reboot_now(volatile char* key_pressed, int key_code) {
return 0;
}
int device_handle_key(int key_code, int visible) {
if (visible) {
switch (key_code) {
case KEY_DOWN:
case KEY_VOLUMEDOWN:
return HIGHLIGHT_DOWN;
case KEY_UP:
case KEY_VOLUMEUP:
return HIGHLIGHT_UP;
case KEY_ENTER:
return SELECT_ITEM;
}
}
return NO_ACTION;
}
int device_perform_action(int which) {
return which;
}
int device_wipe_data() {
return 0;
}
void ui_set_background(int icon)
{
//TODO
}
// Show a progress bar and define the scope of the next operation:
// portion - fraction of the progress bar the next operation will use
// seconds - expected time interval (progress bar moves at this minimum rate)
void ui_show_progress(float portion, int seconds)
{
//TODO
miuiInstall_show_progress(portion, seconds);
}
void ui_set_progress(float fraction) // 0.0 - 1.0 within the defined scope
{
miuiInstall_set_progress(fraction); // 0.0 - 1.0 within the defined scope
//TODO
}
void ui_set_text(char *str)
{
miuiInstall_set_text(str);
}
// Show a rotating "barberpole" for ongoing operations. Updates automatically.
void ui_show_indeterminate_progress()
{
}
// Hide and reset the progress bar.
void ui_reset_progress()
{
}
| 22.859813 | 79 | 0.690515 |
5acd38127898abfdab5f065c1302400457400e73 | 3,187 | c | C | hoc_lai_mang.c | khimne/code_nhieu_nhi | bfb49b000f8d195bc47d50426c96ff50c00eab08 | [
"Apache-2.0"
] | null | null | null | hoc_lai_mang.c | khimne/code_nhieu_nhi | bfb49b000f8d195bc47d50426c96ff50c00eab08 | [
"Apache-2.0"
] | null | null | null | hoc_lai_mang.c | khimne/code_nhieu_nhi | bfb49b000f8d195bc47d50426c96ff50c00eab08 | [
"Apache-2.0"
] | null | null | null | #include<stdio.h>
#include<stdlib.h>
#define MAX 100
//Mảng- array
void nhapmang (int a[], int n) // ( mảng và số liệu ptu)
{
for (int i=0; i<n;i++)
scanf("%d",a[i]);
}
void xuatmang (int a[], int n) // ( mảng và số liệu ptu)
{
for (int i=0; i<n;i++)
printf("%4d",a[i]);
}
int main ()
{
int n; scanf("%d",&n);
// <KDL> tên_mảng[tổng_số_pt];
int arr[MAX];
nhapmang(arr,n);
xuatmang(arr,n);
}
// Kiểm tra xem pt có tồn tại trong mảng k?
//IN: gia tri, mảng và số lg pt
//OUT: 1/0
int laTonTai (int k, int a[], int n)
{
for(int i=0 ; i<n)
{
if(a[i]==k){
return 1;
}
}
}
int main ()
{
int n=0; scanf("%d",&n);
// <KDL> tên_mảng[tổng_số_pt];
int arr[MAX];
nhapmang(arr,n);
xuatmang(arr,n);
printf
while(1){
int x,scanf("")
if (laTonTai(x,arr,n))
}
}
//Hàm tìm gtln của mảng
//In
//Out
int getMax(int a[],int n)
{
int i_max=0;
for (int i=0; i<n;i++)
{
if (a[i_max]<a[i])
{
i_max=i;
}
}
return a[i_max];
}
//Hàm để đếm số lần xh trong mảng
// in:
//out:
int contValue (int k, int a[], int n)
{
int dem=0;
for (int i=0;i<n;i++)
{
if(a[i]==k)
dem++;
}
return dem;
}
//Hàm tìm pt xh nhiều nhất trong mảng
void Lietkeptxh (int a[],int n)
{
int dem=0;
for (int i=0; i<n;i++)
{
if(countValue(a[i],a,n)>dem_max)
dem_max=countValue(a[i],a,n);
}
for (int i=0;i<n;i++)
{
if(countValue(a[i],a,n)==dem_max && !laTonTai(a[i],a,i))
printf("%d",a[i]);
}
}
2/6/2020
//Hàm tìm vị trí của 1 pt có gtnn
//Từ vị trí l đến vị trí r mảng đó
//In: mảng đó, a ,b
//OUT: min của mảng
int getMinPos(int a[],int l, int r)
{
int minPos=l;
for (int i=l+1;i<=r,i++)
{
if (a[i]<[minPos])
min =i;
}
return minPos;
}
//Selection Sort - sắp xếp chọn
//In: mảng đó, số pt
//Out: k có
void selectionSortAscending( int a[], int n)
{
for (int i=0,i<n-1;i++)
{
//Vị trí phần tử có gtnn
int minPos=getMinPos(a,i,n-1)
//Đổi vtri pt thứ i và phần tử thứ minpos có gt nhỏ nhất
int tmp=a[i];
a[i]=a[minPos];
a[minPos]=tmp;
}
}
//Kiểm tra xem 1 mảng có tăng dần hay k
int inAscending (int a[],int n)
{
for (int i=1;i<n;i++)
{
if (a[i-1]>a[i])
return 0;
}
return 1;
}
//Bubble Sort - sắp xếp nổi bật
void bubbleSortAscending(int a[],int n)
{
while (!IsAscending(a,n))
{
for (int i=1;i<n;i++)
{
if (a[i-1]>a[i])
{
int tmp =a[i-1];
a[i-1]=a[i];
a[i]=tmp;
}
}
}
}
//Insertion Sort - sắp xếp chọn
int main ()
{
int n=0; scanf("%d",&n);
// <KDL> tên_mảng[tổng_số_pt];
int arr[MAX];
nhapmang(arr,n);
selectionSortAscending(a,n);
xuatmang(arr,n);
}
| 17.320652 | 65 | 0.449325 |
ee4f3b1fbc5adf6275e0fbe9e02fa0cc0b7a4949 | 1,805 | h | C | division-tables.h | cedricpinson/detex | b8c2cc968a094ebb6d9052582d4c079741f98fa4 | [
"ISC"
] | null | null | null | division-tables.h | cedricpinson/detex | b8c2cc968a094ebb6d9052582d4c079741f98fa4 | [
"ISC"
] | 1 | 2020-04-30T11:59:07.000Z | 2020-04-30T11:59:07.000Z | division-tables.h | cedricpinson/detex | b8c2cc968a094ebb6d9052582d4c079741f98fa4 | [
"ISC"
] | 2 | 2016-10-11T15:35:33.000Z | 2020-04-29T13:36:29.000Z | /*
Copyright (c) 2015 Harm Hanemaaijer <fgenfb@yahoo.com>
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.
*/
// Integer division using look-up tables, used by BC1/2/3 and RGTC (BC4/5)
// decompression.
#include <stdlib.h>
extern const uint8_t detex_division_by_3_table[768];
static DETEX_INLINE_ONLY uint32_t detexDivide0To767By3(uint32_t value) {
return detex_division_by_3_table[value];
}
extern const uint8_t detex_division_by_7_table[1792];
static DETEX_INLINE_ONLY uint32_t detexDivide0To1791By7(uint32_t value) {
return detex_division_by_7_table[value];
}
static DETEX_INLINE_ONLY int8_t detexSignInt32(int v) {
return (int8_t)((v >> 31) | - (- v >> 31));
}
static DETEX_INLINE_ONLY int detexDivideMinus895To895By7(int value) {
return (int8_t)detex_division_by_7_table[abs(value)] * detexSignInt32(value);
}
extern const uint8_t detex_division_by_5_table[1280];
static DETEX_INLINE_ONLY uint32_t detexDivide0To1279By5(uint32_t value) {
return detex_division_by_5_table[value];
}
static DETEX_INLINE_ONLY int detexDivideMinus639To639By5(int value) {
return (int8_t)detex_division_by_5_table[abs(value)] * detexSignInt32(value);
}
| 33.425926 | 78 | 0.80277 |
205ec3f140097363614abd5c502251bf215102ac | 4,571 | h | C | sm64ex-nightly/src/game/object_list_processor.h | alex-free/sm64ex-creator | e7089df69fb43f266b2165078d94245b33b8e72a | [
"Intel",
"X11",
"Unlicense"
] | 2 | 2022-03-12T08:27:53.000Z | 2022-03-12T18:26:06.000Z | sm64ex-nightly/src/game/object_list_processor.h | alex-free/sm64ex-creator | e7089df69fb43f266b2165078d94245b33b8e72a | [
"Intel",
"X11",
"Unlicense"
] | null | null | null | sm64ex-nightly/src/game/object_list_processor.h | alex-free/sm64ex-creator | e7089df69fb43f266b2165078d94245b33b8e72a | [
"Intel",
"X11",
"Unlicense"
] | null | null | null | #ifndef OBJECT_LIST_PROCESSOR_H
#define OBJECT_LIST_PROCESSOR_H
#include <PR/ultratypes.h>
#include "area.h"
#include "macros.h"
#include "types.h"
/**
* Flags for gTimeStopState. These control which objects are processed each frame
* and also track some miscellaneous info.
*/
#define TIME_STOP_UNKNOWN_0 (1 << 0)
#define TIME_STOP_ENABLED (1 << 1)
#define TIME_STOP_DIALOG (1 << 2)
#define TIME_STOP_MARIO_AND_DOORS (1 << 3)
#define TIME_STOP_ALL_OBJECTS (1 << 4)
#define TIME_STOP_MARIO_OPENED_DOOR (1 << 5)
#define TIME_STOP_ACTIVE (1 << 6)
/**
* The maximum number of objects that can be loaded at once.
*/
#ifdef NODRAWINGDISTANCE
#define OBJECT_POOL_CAPACITY 960
#else
#define OBJECT_POOL_CAPACITY 240
#endif
/**
* Every object is categorized into an object list, which controls the order
* they are processed and which objects they can collide with.
*/
enum ObjectList
{
OBJ_LIST_PLAYER, // (0) Mario
OBJ_LIST_UNUSED_1, // (1) (unused)
OBJ_LIST_DESTRUCTIVE, // (2) things that can be used to destroy other objects, like
// bob-ombs and corkboxes
OBJ_LIST_UNUSED_3, // (3) (unused)
OBJ_LIST_GENACTOR, // (4) general actors. most normal 'enemies' or actors are
// on this list. (MIPS, bullet bill, bully, etc)
OBJ_LIST_PUSHABLE, // (5) pushable actors. This is a group of objects which
// can push each other around as well as their parent
// objects. (goombas, koopas, spinies)
OBJ_LIST_LEVEL, // (6) level objects. general level objects such as heart, star
OBJ_LIST_UNUSED_7, // (7) (unused)
OBJ_LIST_DEFAULT, // (8) default objects. objects that didnt start with a 00
// command are put here, so this is treated as a default.
OBJ_LIST_SURFACE, // (9) surface objects. objects that specifically have surface
// collision and not object collision. (thwomp, whomp, etc)
OBJ_LIST_POLELIKE, // (10) polelike objects. objects that attract or otherwise
// "cling" Mario similar to a pole action. (hoot,
// whirlpool, trees/poles, etc)
OBJ_LIST_SPAWNER, // (11) spawners
OBJ_LIST_UNIMPORTANT, // (12) unimportant objects. objects that will not load
// if there are not enough object slots: they will also
// be manually unloaded to make room for slots if the list
// gets exhausted.
NUM_OBJ_LISTS
};
extern struct ObjectNode gObjectListArray[];
extern s32 gDebugInfoFlags;
extern s32 gNumFindFloorMisses;
extern UNUSED s32 unused_8033BEF8;
extern s32 gUnknownWallCount;
extern u32 gObjectCounter;
struct NumTimesCalled {
/*0x00*/ s16 floor;
/*0x02*/ s16 ceil;
/*0x04*/ s16 wall;
};
extern struct NumTimesCalled gNumCalls;
extern s16 gDebugInfo[][8];
extern s16 gDebugInfoOverwrite[][8];
extern u32 gTimeStopState;
extern struct Object gObjectPool[];
extern struct Object gMacroObjectDefaultParent;
extern struct ObjectNode *gObjectLists;
extern struct ObjectNode gFreeObjectList;
extern struct Object *gMarioObject;
extern struct Object *gLuigiObject;
extern struct Object *gCurrentObject;
extern const BehaviorScript *gCurBhvCommand;
extern s16 gPrevFrameObjectCount;
extern s32 gSurfaceNodesAllocated;
extern s32 gSurfacesAllocated;
extern s32 gNumStaticSurfaceNodes;
extern s32 gNumStaticSurfaces;
extern struct MemoryPool *gObjectMemoryPool;
extern s16 gCheckingSurfaceCollisionsForCamera;
extern s16 gFindFloorIncludeSurfaceIntangible;
extern s16 *gEnvironmentRegions;
extern s32 gEnvironmentLevels[20];
extern s8 gDoorAdjacentRooms[60][2];
extern s16 gMarioCurrentRoom;
extern s16 D_8035FEE2;
extern s16 D_8035FEE4;
extern s16 gTHIWaterDrained;
extern s16 gTTCSpeedSetting;
extern s16 gMarioShotFromCannon;
extern s16 gCCMEnteredSlide;
extern s16 gNumRoomedObjectsInMarioRoom;
extern s16 gNumRoomedObjectsNotInMarioRoom;
extern s16 gWDWWaterLevelChanging;
extern s16 gMarioOnMerryGoRound;
void bhv_mario_update(void);
void set_object_respawn_info_bits(struct Object *obj, u8 bits);
void unload_objects_from_area(UNUSED s32 unused, s32 areaIndex);
void spawn_objects_from_info(UNUSED s32 unused, struct SpawnInfo *spawnInfo);
void clear_objects(void);
void update_objects(UNUSED s32 unused);
#endif // OBJECT_LIST_PROCESSOR_H
| 34.368421 | 90 | 0.701159 |
6e28489aab4a0b2490963740441ea0ff2351179c | 6,619 | c | C | src/draw/sdl/lv_draw_sdl_img.c | gagarinlg/lvgl | 9dc084429642a2fac6e4086bae375feccf7dd1f6 | [
"MIT"
] | 2 | 2020-06-10T01:07:02.000Z | 2020-06-10T01:21:45.000Z | src/draw/sdl/lv_draw_sdl_img.c | gagarinlg/lvgl | 9dc084429642a2fac6e4086bae375feccf7dd1f6 | [
"MIT"
] | 1 | 2021-09-02T03:34:24.000Z | 2021-09-02T03:34:24.000Z | src/draw/sdl/lv_draw_sdl_img.c | gagarinlg/lvgl | 9dc084429642a2fac6e4086bae375feccf7dd1f6 | [
"MIT"
] | 1 | 2021-09-01T14:43:35.000Z | 2021-09-01T14:43:35.000Z | /**
* @file lv_draw_sdl_img.c
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lv_conf_internal.h"
#if LV_USE_GPU_SDL
#include "../lv_draw_img.h"
#include "../lv_img_cache.h"
#include "../lv_draw_mask.h"
#include "../../misc/lv_lru.h"
#include "lv_draw_sdl_utils.h"
#include "lv_draw_sdl_texture_cache.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static SDL_Texture * upload_img_texture(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc);
static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
lv_res_t lv_draw_sdl_img_core(lv_draw_ctx_t * draw_ctx, const lv_draw_img_dsc_t * draw_dsc,
const lv_area_t * coords, const void * src)
{
const lv_area_t * clip = draw_ctx->clip_area;
lv_draw_sdl_ctx_t * ctx = (lv_draw_sdl_ctx_t *) draw_ctx;
SDL_Renderer * renderer = ctx->renderer;
size_t key_size;
lv_draw_sdl_cache_key_head_img_t * key = lv_draw_sdl_texture_img_key_create(src, draw_dsc->frame_id, &key_size);
bool texture_found = false;
SDL_Texture * texture = lv_draw_sdl_texture_cache_get(ctx, key, key_size, &texture_found);
if(!texture_found) {
_lv_img_cache_entry_t * cdsc = _lv_img_cache_open(src, draw_dsc->recolor, draw_dsc->frame_id);
lv_draw_sdl_cache_flag_t tex_flags = 0;
if(cdsc) {
lv_img_decoder_dsc_t * dsc = &cdsc->dec_dsc;
if(dsc->user_data && SDL_memcmp(dsc->user_data, LV_DRAW_SDL_DEC_DSC_TEXTURE_HEAD, 8) == 0) {
lv_draw_sdl_dec_dsc_userdata_t * ptr = (lv_draw_sdl_dec_dsc_userdata_t *) dsc->user_data;
texture = ptr->texture;
if(ptr->texture_managed) {
tex_flags |= LV_DRAW_SDL_CACHE_FLAG_MANAGED;
}
ptr->texture_referenced = true;
}
else {
texture = upload_img_texture(renderer, dsc);
}
#if LV_IMG_CACHE_DEF_SIZE == 0
lv_img_decoder_close(dsc);
#endif
}
if(texture && cdsc) {
lv_img_header_t * header = SDL_malloc(sizeof(lv_img_header_t));
SDL_memcpy(header, &cdsc->dec_dsc.header, sizeof(lv_img_header_t));
lv_draw_sdl_texture_cache_put_advanced(ctx, key, key_size, texture, header, SDL_free, tex_flags);
}
else {
lv_draw_sdl_texture_cache_put(ctx, key, key_size, NULL);
}
}
SDL_free(key);
if(!texture) {
return LV_RES_INV;
}
SDL_Rect clip_rect, coords_rect;
lv_area_to_sdl_rect(clip, &clip_rect);
lv_area_to_sdl_rect(coords, &coords_rect);
lv_area_zoom_to_sdl_rect(coords, &coords_rect, draw_dsc->zoom, &draw_dsc->pivot);
SDL_Point pivot = {.x = draw_dsc->pivot.x, .y = draw_dsc->pivot.y};
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
SDL_RenderSetClipRect(renderer, &clip_rect);
SDL_Color recolor;
lv_color_to_sdl_color(&draw_dsc->recolor, &recolor);
if(draw_dsc->recolor_opa == LV_OPA_COVER) {
/* Draw fully recolored image*/
SDL_SetTextureColorMod(texture, draw_dsc->recolor.ch.red, recolor.g, recolor.b);
SDL_SetTextureAlphaMod(texture, draw_dsc->opa);
SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
}
else if(draw_dsc->recolor_opa > LV_OPA_TRANSP) {
/* Draw blended. src: origA, dst: origA * recolorA */
SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF);
SDL_SetTextureAlphaMod(texture, draw_dsc->opa);
SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
SDL_SetTextureColorMod(texture, recolor.r, recolor.g, recolor.b);
SDL_SetTextureAlphaMod(texture, draw_dsc->opa * draw_dsc->recolor_opa / 255);
SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
}
else {
/* Draw with no recolor */
SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF);
SDL_SetTextureAlphaMod(texture, draw_dsc->opa);
SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
}
SDL_RenderSetClipRect(renderer, NULL);
return LV_RES_OK;
}
/**********************
* STATIC FUNCTIONS
**********************/
static SDL_Texture * upload_img_texture(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc)
{
if(!dsc->img_data) {
return upload_img_texture_fallback(renderer, dsc);
}
bool chroma_keyed = dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED;
uint32_t h = dsc->header.h;
uint32_t w = dsc->header.w;
void * data = (void *) dsc->img_data;
Uint32 rmask = 0x00FF0000;
Uint32 gmask = 0x0000FF00;
Uint32 bmask = 0x000000FF;
Uint32 amask = 0xFF000000;
if(chroma_keyed) {
amask = 0x00;
}
SDL_Surface * surface = SDL_CreateRGBSurfaceFrom(data, w, h, LV_COLOR_DEPTH, w * LV_COLOR_DEPTH / 8,
rmask, gmask, bmask, amask);
SDL_SetColorKey(surface, chroma_keyed, lv_color_to32(LV_COLOR_CHROMA_KEY));
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_FreeSurface(surface);
return texture;
}
static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc)
{
lv_coord_t h = dsc->header.h;
lv_coord_t w = dsc->header.w;
uint8_t * data = lv_mem_buf_get(w * h * sizeof(lv_color_t));
for(lv_coord_t y = 0; y < h; y++) {
lv_img_decoder_read_line(dsc, 0, y, w, &data[y * w * sizeof(lv_color_t)]);
}
Uint32 rmask = 0x00FF0000;
Uint32 gmask = 0x0000FF00;
Uint32 bmask = 0x000000FF;
Uint32 amask = 0xFF000000;
SDL_Surface * surface = SDL_CreateRGBSurfaceFrom(data, w, h, LV_COLOR_DEPTH, w * LV_COLOR_DEPTH / 8,
rmask, gmask, bmask, amask);
SDL_SetColorKey(surface, SDL_TRUE, lv_color_to32(LV_COLOR_CHROMA_KEY));
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_FreeSurface(surface);
lv_mem_buf_release(data);
return texture;
}
#endif /*LV_USE_GPU_SDL*/
| 36.169399 | 116 | 0.627889 |
0ca217e5f70ba761a1bc10b2a9d9617b7e0c91e7 | 882 | h | C | main/MainWindow.h | scottaronbloom/TestFlowWidget | 1c0e73c61833b55a81f5f986bf8a529925185bcf | [
"MIT"
] | null | null | null | main/MainWindow.h | scottaronbloom/TestFlowWidget | 1c0e73c61833b55a81f5f986bf8a529925185bcf | [
"MIT"
] | null | null | null | main/MainWindow.h | scottaronbloom/TestFlowWidget | 1c0e73c61833b55a81f5f986bf8a529925185bcf | [
"MIT"
] | null | null | null | #ifndef _MAINWINDOW_H
#define _MAINWINDOW_H
#include <QDialog>
#include <memory>
class CFlowWidgetItem;
class QStandardItemModel;
class QListWidgetItem;
struct SRegisteredStatusInfo;
namespace Ui{ class CMainWindow; }
class CMainWindow : public QDialog
{
Q_OBJECT
public:
CMainWindow( QWidget *parent = 0);
~CMainWindow();
void mLoadFromXML( const QString & xFileName );
public Q_SLOTS:
void slotStatusItemSelected( QListWidgetItem* /*xListWidgetItem*/ );
void slotFlowWidgetItemSelected( CFlowWidgetItem* xItem, bool xSelected );
private:
void mLoadStatuses();
void mLoadStatus( const SRegisteredStatusInfo& ii );
void mDemoFlowWidget();
void mLoadFromXML();
void mDumpFlowWidget();
void mCollapseWidgetType( const QModelIndex& index );
QStandardItemModel * fModel;
std::unique_ptr< Ui::CMainWindow > fImpl;
};
#endif
| 23.837838 | 78 | 0.74263 |
11ee2ffd71c697eadf180b74659ab48400f605d9 | 4,017 | h | C | src/point_w.h | dickoa/euclid | 6588a6f56c73779152ff99eb06f41b3ec61170bc | [
"MIT"
] | 68 | 2020-09-17T13:17:03.000Z | 2022-02-20T09:14:54.000Z | src/point_w.h | dickoa/euclid | 6588a6f56c73779152ff99eb06f41b3ec61170bc | [
"MIT"
] | 27 | 2020-09-17T13:35:53.000Z | 2022-01-20T09:12:48.000Z | src/point_w.h | dickoa/euclid | 6588a6f56c73779152ff99eb06f41b3ec61170bc | [
"MIT"
] | 11 | 2020-09-17T11:43:37.000Z | 2022-01-10T13:08:27.000Z | #pragma once
#include <cpp11/strings.hpp>
#include "cgal_types.h"
#include "geometry_vector.h"
#include "exact_numeric.h"
#include "intersection.h"
#include "distance.h"
#include <vector>
class point_w2 : public geometry_vector<Weighted_point_2, 2> {
public:
using geometry_vector::geometry_vector;
~point_w2() = default;
Primitive geometry_type() const { return WPOINT; }
cpp11::writable::strings def_names() const {
return {"x", "y", "w"};
}
Exact_number get_single_definition(size_t i, int which, int element) const {
switch(which) {
case 0: return _storage[i].x();
case 1: return _storage[i].y();
case 2: return _storage[i].weight();
}
return _storage[i].x();
}
std::vector<double> get_row(size_t i, size_t j) const {
return {
CGAL::to_double(_storage[i].x().exact()),
CGAL::to_double(_storage[i].y().exact()),
CGAL::to_double(_storage[i].weight().exact())
};
}
cpp11::writable::list intersection(const geometry_vector_base& other) const {
cpp11::stop("Don't know how to calculate the intersection of these geometries");
}
cpp11::writable::logicals do_intersect(const geometry_vector_base& other) const {
if (other.dimensions() != dimensions()) {
cpp11::stop("Only geometries of the same dimensionality can intersect");
}
return unknown_intersect_impl(std::max(size(), other.size()));
}
std::vector<Exact_number> squared_distance(const geometry_vector_base& other) const {
if (other.dimensions() != dimensions()) {
cpp11::stop("Only geometries of the same dimensionality can intersect");
}
return unknown_squared_distance_impl(std::max(size(), other.size()));
}
cpp11::writable::doubles_matrix distance_matrix(const geometry_vector_base& other) const {
if (other.dimensions() != dimensions()) {
cpp11::stop("Only geometries of the same dimensionality can intersect");
}
return unknown_distance_matrix_impl(size(), other.size());
}
};
typedef cpp11::external_pointer<point_w2> point_w2_p;
class point_w3 : public geometry_vector<Weighted_point_3, 3, Weighted_point_2> {
public:
using geometry_vector::geometry_vector;
~point_w3() = default;
Primitive geometry_type() const { return WPOINT; }
cpp11::writable::strings def_names() const {
return {"x", "y", "z", "w"};
}
Exact_number get_single_definition(size_t i, int which, int element) const {
switch(which) {
case 0: return _storage[i].x();
case 1: return _storage[i].y();
case 2: return _storage[i].z();
case 3: return _storage[i].weight();
}
return _storage[i].x();
}
std::vector<double> get_row(size_t i, size_t j) const {
return {
CGAL::to_double(_storage[i].x().exact()),
CGAL::to_double(_storage[i].y().exact()),
CGAL::to_double(_storage[i].z().exact()),
CGAL::to_double(_storage[i].weight().exact())
};
}
cpp11::writable::list intersection(const geometry_vector_base& other) const {
cpp11::stop("Don't know how to calculate the intersection of these geometries");
}
cpp11::writable::logicals do_intersect(const geometry_vector_base& other) const {
if (other.dimensions() != dimensions()) {
cpp11::stop("Only geometries of the same dimensionality can intersect");
}
return unknown_intersect_impl(std::max(size(), other.size()));
}
std::vector<Exact_number> squared_distance(const geometry_vector_base& other) const {
if (other.dimensions() != dimensions()) {
cpp11::stop("Only geometries of the same dimensionality can intersect");
}
return unknown_squared_distance_impl(std::max(size(), other.size()));
}
cpp11::writable::doubles_matrix distance_matrix(const geometry_vector_base& other) const {
if (other.dimensions() != dimensions()) {
cpp11::stop("Only geometries of the same dimensionality can intersect");
}
return unknown_distance_matrix_impl(size(), other.size());
}
};
typedef cpp11::external_pointer<point_w3> point_w3_p;
| 32.136 | 92 | 0.687329 |
bcd8f237a5add22eec35d3c5069dac9c9092a5ba | 2,661 | c | C | actividades/prog/files/java/mil-ejemplos/darwin/network/RemCat.c | oritelad/libro-de-actividades | d6cd3a1f7e45947d4ad9c9084d36482f1986545e | [
"CC0-1.0"
] | null | null | null | actividades/prog/files/java/mil-ejemplos/darwin/network/RemCat.c | oritelad/libro-de-actividades | d6cd3a1f7e45947d4ad9c9084d36482f1986545e | [
"CC0-1.0"
] | null | null | null | actividades/prog/files/java/mil-ejemplos/darwin/network/RemCat.c | oritelad/libro-de-actividades | d6cd3a1f7e45947d4ad9c9084d36482f1986545e | [
"CC0-1.0"
] | null | null | null | /* Remote cat client using TFTP server (UDP socket implementation).
UNIX Version -- Solution
Usage: rcat hostname filename
*/
#include <sys/types.h>
#include <sys/fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#define TFTP_PORT 69 /* tftps well-known port number */
#define BSIZE 600 /* size of our data buffer */
#define MODE "octet"
#define OP_RRQ 1 /* TFTP op-codes */
#define OP_DATA 3
#define OP_ACK 4
#define OP_ERROR 5
main(int argc, char *argv[])
{
int sock; /* Socket descriptor */
struct sockaddr_in server; /* Servers address */
struct sockaddr_in client; /* Clients address */
struct hostent *host; /* Server host info */
char buffer[BSIZE], *p;
int count, server_len;
if (argc != 3) {
fprintf(stderr, "usage: %s hostname filename\n", argv[0]);
exit(1);
}
/* Create a datagram socket */
sock = socket(AF_INET, SOCK_DGRAM, 0);
/* Get the servers address */
host = gethostbyname(argv[1]);
if (host == NULL) {
fprintf(stderr, "unknown host: %s\n", argv[1]);
exit(2);
}
server.sin_family = AF_INET;
memcpy(&server.sin_addr.s_addr, host->h_addr, host->h_length);
server.sin_port = htons(TFTP_PORT);
/* Build a tftp Read Request packet. This is messy because the
fields have variable length, so we cant use a structure.
*/
*(short *)buffer = htons(OP_RRQ); /* The op-code */
p = buffer + 2;
strcpy(p, argv[2]); /* The file name */
p += strlen(argv[2]) + 1; /* Keep the nul */
strcpy(p, MODE); /* The Mode */
p += strlen(MODE) + 1;
/* Send Read Request to tftp server */
count = sendto(sock, buffer, p-buffer, 0,
(struct sockaddr *)&server, sizeof server);
/* Loop, collecting data packets from the server, until a short
packet arrives. This indicates the end of the file.
*/
do {
server_len = sizeof server;
count = recvfrom(sock, buffer, BSIZE, 0,
(struct sockaddr *)&server, &server_len);
if (ntohs(*(short *)buffer) == OP_ERROR) {
fprintf(stderr, "rcat: %s\n", buffer+4);
}
else {
write(1, buffer+4, count-4);
/* Send an ack packet. The block number we want to ack is
already in the buffer so we just need to change the
opcode. Note that the ACK is sent to the port number
which the server just sent the data from, NOT to port
69
*/
*(short *)buffer = htons(OP_ACK);
sendto(sock, buffer, 4, 0, (struct sockaddr *)&server,
sizeof server);
}
} while (count == 516);
}
| 30.238636 | 67 | 0.605411 |
bce9f28a3e1c16c4783c3e9e102094fcd4219c1e | 19,972 | c | C | src/crntk.c | jasondark/crntk | 27bdb4c5aef542b58e12fc015d766ec85314a9bb | [
"BSD-2-Clause"
] | null | null | null | src/crntk.c | jasondark/crntk | 27bdb4c5aef542b58e12fc015d766ec85314a9bb | [
"BSD-2-Clause"
] | null | null | null | src/crntk.c | jasondark/crntk | 27bdb4c5aef542b58e12fc015d766ec85314a9bb | [
"BSD-2-Clause"
] | null | null | null | /*******************************************************************************
* CRNTK: The Chemical Reaction Network Toolkit *
* Copyright (C) 2018 Jason Dark, email@jkdark.com *
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted provided that the following conditions are met: *
* *
* 1. Redistributions of source code must retain the above copyright notice, *
* this list of conditions and the following disclaimer. *
* *
* 2. Redistributions in binary form must reproduce the above copyright notice,*
* this list of conditions and the following disclaimer in the documentation*
* and/or other materials provided with the distribution. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE *
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE *
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE *
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF *
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN *
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) *
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE *
* POSSIBILITY OF SUCH DAMAGE. *
******************************************************************************/
#include <stdlib.h> // calloc
#include <string.h> // memset, memcpy
#include "../include/crntk.h"
// internal struct: a reactant object
typedef struct {
double (*affinity)(size_t,size_t,const double*);
double *data;
} crntk_reactant;
// internal struct: a reaction object
typedef struct {
double rate; // the rate constant for the reaction
size_t* lhs; // a pointer to the source complex
size_t* rhs; // a pointer to the destination complex
bool conservative; // does the reaction satisfy the conservation laws?
} crntk_reaction;
/// implementation of crntk struct
struct crntk_crn {
// the "dimensions" of the CRN
size_t n_reactants;
size_t n_complexes;
size_t n_reactions;
size_t n_states;
size_t n_constraints;
crntk_reactant *reactants;
size_t *complexes;
crntk_reaction *reactions;
size_t *states;
size_t *constraints;
size_t *constraint_values;
// a representation of the lattice
size_t **table;
// internal builder quantities
size_t _i_reactant;
size_t _i_complex;
size_t _i_reaction;
size_t _i_constraint;
};
// the next 5 functions are internal helper functions
static inline void react(
// input parameters
const crntk crn, const size_t rxn_index, const size_t *n0,
// output parameters
size_t *n1, double *propensity, bool *bounded)
{
// copy the reaction
crntk_reaction rxn = crn->reactions[rxn_index];
// iterate through each species
for (size_t k = 0; k < crn->n_reactants; k++) {
// check for sufficient copy number
rxn.conservative = rxn.conservative && (n0[k] >= rxn.lhs[k]);
// compute the propensity regardless -- this permits non-physical kinetics like FSP or non-conservative reactions
rxn.rate *= crn->reactants[k].affinity(n0[k], rxn.lhs[k], crn->reactants[k].data);
}
// update the output parameters
for (size_t k = 0; k < crn->n_reactants; k++) {
n1[k] = n0[k] + rxn.rhs[k] - rxn.lhs[k];
}
*propensity = rxn.rate;
*bounded = rxn.conservative;
}
static inline size_t tensor_offset(size_t *index, const size_t rank, size_t *bound) {
size_t offset = 0;
for (size_t i = 0; i < rank; i++) {
offset = *index + offset * (1 + *bound);
bound += 1;
index += 1;
}
return offset;
}
static inline size_t tensor_delta(size_t *b, size_t *c, size_t *n, const size_t rank) {
size_t i = 0, min, temp;
for (; i < rank && n[i] == 0; i++);
min = (b[i] - c[i]) / n[i];
for (i++; i < rank; i++) {
if (n[i] == 0) continue;
temp = (b[i] - c[i]) / n[i];
if (temp < min) min = temp;
}
return min;
}
static bool init_lattice_table(crntk lattice) {
const size_t m = lattice->n_constraints, n = lattice->n_reactants;
size_t *A = lattice->constraints, *b = lattice->constraint_values;
size_t** table = calloc(n, sizeof(size_t*));
if (table == NULL)
return false;
size_t numel = 1;
for (size_t i = 0; i < m; i++)
numel *= b[i]+1;
for (size_t i = 0; i < n; i++) {
table[i] = calloc(numel, sizeof(size_t));
if (table[i] == NULL) {
for (size_t j = 0; j < i; j++)
free(table[j]);
free(table);
return false;
}
}
size_t index[m];
for (size_t i = 0; i < m; i++)
index[i] = 0;
// start with last variable
A += m*(n-1);
size_t delta = tensor_offset(A, m, b);
size_t inc = tensor_delta(b, index, A, m);
for (size_t j = 0; j <= inc; j++)
table[0][j*delta] = 1;
// and then the remaining variables
for (size_t k = 1; k < n; k++) {
A -= m;
delta = tensor_offset(A, m, b);
memcpy(index, b, m * sizeof(size_t));
for (size_t i = 0; i < numel; i++) {
for (size_t j = m; j-- > 0; ) {
if (index[j] < b[j]) {
index[j] += 1;
break;
}
index[j] = 0;
}
inc = tensor_delta(b, index, A, m);
for (size_t j = 0; j <= inc; j++)
table[k][i+j*delta] += table[k-1][i];
}
}
lattice->table = table;
return true;
}
static bool init_lattice_states(crntk lattice) {
const size_t m = lattice->n_constraints, n = lattice->n_reactants;
const size_t dim = lattice->table[n-1][tensor_offset(lattice->constraint_values, m, lattice->constraint_values)];
lattice->n_states = dim;
lattice->states = calloc(n * dim, sizeof(size_t));
if (lattice->states == NULL)
return false;
size_t b[m], x[n];
for (size_t i = 0; i < m; i++)
b[i] = lattice->constraint_values[i];
for (size_t i = 0; i < n; i++)
x[i] = 0;
size_t i = 0;
size_t j = n-1;
size_t k;
bool flag, finished = false;
while (!finished) {
// Special case 1: first column
if (j == 0) {
for (k = 0; k < m; k++) {
// if no more increments are possible we are done
if (lattice->constraints[k] > b[k]) {
finished = true;
break;
}
else {
b[k] -= lattice->constraints[k];
}
}
if (!finished) {
x[0] += 1;
j = n-1;
}
continue;
}
// we can easily check if there are solutions. if not, let's not waste time
if (lattice->table[n-1-j][tensor_offset(b, m, lattice->constraint_values)] == 0) {
if (x[j] != 0) {
for (k = 0; k < m; k++)
b[k] += x[j] * lattice->constraints[k+j*m];
x[j] = 0;
}
j -= 1;
continue;
}
// Special case 2: last column
if (j == n-1) {
// we know there is a solution, so we record it
for (k = 0; k < m; k++) {
if (b[k] == 0 && lattice->constraints[k+j*m] == 0)
continue;
else
break;
}
x[j] = b[k] / lattice->constraints[k+j*m];
memcpy(lattice->states + n*i, x, n * sizeof(size_t));
i += 1;
x[j] = 0;
j -= 1;
continue;
}
// general case: if we can increment, great, otherwise we back-track
flag = true;
for (k = 0; k < m; k++) {
if (lattice->constraints[k+j*m] > b[k]) {
flag = false;
break;
}
}
if (flag) {
x[j] += 1;
for (k = 0; k < m; k++)
b[k] -= lattice->constraints[k+j*m];
j = n-1;
}
else {
if (x[j] != 0) {
for (k = 0; k < m; k++)
b[k] += x[j] * lattice->constraints[k+j*m];
x[j] = 0;
}
j -= 1;
}
}
return true;
}
double crntk_kinetics_mass_action(size_t x, size_t n, const double *data) {
if (x < n) {
return 0.0;
}
double response = 1.0;
for (size_t i = 0; i < n; i++) {
response *= (double) (x-i) / (double) (i+1);
}
return response;
}
double crntk_kinetics_heaviside(size_t x, size_t n, const double *data) {
return (x < n)? 0.0 : 1.0;
}
double crntk_kinetics_fsp(size_t x, size_t n, const double *data) {
return 1.0;
}
double crntk_kinetics_hill(size_t x, size_t n, const double *data) {
const double temp = crntk_kinetics_mass_action(x, n, NULL);
return temp / (data[0] + temp);
}
size_t crntk_index_of(const crntk lattice, const size_t *index) {
const size_t m = lattice->n_constraints, n = lattice->n_reactants;
const size_t nullity = n-m;
size_t *A = lattice->constraints;
size_t offset = 0;
size_t b[m];
memcpy(b, lattice->constraint_values, m*sizeof(size_t));
for (size_t i = 0; i < nullity; i++) {
for (size_t j = 0; j < index[i]; j++) {
offset += lattice->table[n-i-2][tensor_offset(b, m, lattice->constraint_values)];
for (size_t k = 0; k < m; k++)
b[k] -= A[k];
}
A += m;
}
return offset;
}
size_t crntk_dim(const crntk crn) {
return crn->n_states;
}
const size_t* crntk_state(const crntk crn, const size_t i) {
return crn->states + crn->n_reactants*i;
}
void crntk_diag(const crntk crn, double* d) {
#pragma omp parallel
{
size_t n1[crn->n_reactants];
double propensity;
bool valid;
#pragma omp for
for (size_t i = 0; i < crn->n_states; i++) {
// n0 is the current state, n1 is a temporary variable for neighboring states
const size_t *n0 = crn->states + crn->n_reactants * i;
// a temporary variable for the reaction propensity and neighbors
double flux = 0.0;
for (size_t k = 0; k < crn->n_reactions; k++) {
react(crn, k, n0, n1, &propensity, &valid);
flux -= propensity;
}
d[i] = flux;
}
}
}
// y = id(A)x
void crntk_id_apply(const crntk crn, const double *x, double *y) {
// init y to zero vector
memset(y, 0, crn->n_states * sizeof(double));
#pragma omp parallel
{
// thread-local scratch variables
size_t n1[crn->n_reactants];
double propensity;
bool valid;
#pragma omp for
for (size_t i = 0; i < crn->n_states; i++) {
// n0 is the current state, n1 is a temporary variable for neighboring states
const size_t *n0 = crn->states + crn->n_reactants * i;
for (size_t k = 0; k < crn->n_reactions; k++) {
react(crn, k, n0, n1, &propensity, &valid);
propensity *= x[i];
#pragma omp atomic
y[i] -= propensity;
if (valid) {
const size_t j = crntk_index_of(crn, n1);
#pragma omp atomic
y[j] += propensity;
}
}
}
}
}
// y = tr(A)x
void crntk_tr_apply(const crntk crn, const double *x, double *y) {
// init y to zero vector
memset(y, 0, crn->n_states * sizeof(double));
#pragma omp parallel
{
// thread-local scratch variables
size_t n1[crn->n_reactants];
double propensity;
bool valid;
#pragma omp for
for (size_t i = 0; i < crn->n_states; i++) {
// n0 is the current state, n1 is a temporary variable for neighboring states
const size_t *n0 = crn->states + crn->n_reactants * i;
for (size_t k = 0; k < crn->n_reactions; k++) {
react(crn, k, n0, n1, &propensity, &valid);
y[i] += propensity * ((valid? x[crntk_index_of(crn, n1)] : 0.0) - x[i]);
}
}
}
}
// Given, tr(A) = L+U-D...
// (1) compute x <- inv(w*L-D) x
void crntk_tr_sor_forward(const crntk crn, double omega, double *x) {
size_t n1[crn->n_reactants];
for (size_t i = 0; i < crn->n_states; i++) {
// n0 is the current state, n1 is a temporary variable for neighboring states
const size_t *n0 = crn->states + crn->n_reactants * i;
// a temporary variable for the reaction propensity and neighbors
double flux = 0.0;
double propensity;
bool nbrd;
size_t j;
for (size_t k = 0; k < crn->n_reactions; k++) {
react(crn, k, n0, n1, &propensity, &nbrd);
flux -= propensity;
j = nbrd? crntk_index_of(crn, n1) : i+1;
if (j < i) {
x[i] -= omega * propensity * x[j];
}
}
x[i] /= flux;
}
}
// (2) compute x <- inv(w*U-D) x
void crntk_tr_sor_backward(const crntk crn, double omega, double *x) {
size_t n1[crn->n_reactants];
for (size_t i = crn->n_states; i-- > 0;) {
// n0 is the current state, n1 is a temporary variable for neighboring states
const size_t *n0 = crn->states + crn->n_reactants * i;
// a temporary variable for the reaction propensity and neighbors
double flux = 0.0;
double propensity;
bool nbrd;
size_t j;
for (size_t k = 0; k < crn->n_reactions; k++) {
react(crn, k, n0, n1, &propensity, &nbrd);
flux -= propensity;
j = nbrd? crntk_index_of(crn, n1) : i-1;
if (j > i) {
x[i] -= omega * propensity * x[j];
}
}
x[i] /= flux;
}
}
static inline void jacobi(const crntk crn, double *x) {
#pragma omp parallel
{
size_t n1[crn->n_reactants];
double propensity;
bool valid;
#pragma omp for
for (size_t i = 0; i < crn->n_states; i++) {
// n0 is the current state, n1 is a temporary variable for neighboring states
const size_t *n0 = crn->states + crn->n_reactants * i;
// a temporary variable for the reaction propensity and neighbors
double flux = 0.0;
for (size_t k = 0; k < crn->n_reactions; k++) {
react(crn, k, n0, n1, &propensity, &valid);
flux -= propensity;
}
x[i] *= flux;
}
}
}
// and now for the lattice stuff
// version 1 (now): brute force enumerate the states (with some clever shortcuts)
// version 2 (later): it is possible to construct these efficiently on the fly
// by reducing A to column Hermite Normal form...
// This is a possible memory/speed trade-off to be considered later.
bool crntk_init(crntk *out, const size_t n_reactants, const size_t n_complexes, const size_t n_reactions, const size_t n_constraints) {
crntk crn = calloc(1, sizeof(**out));
crn->n_reactants = n_reactants;
crn->n_complexes = n_complexes;
crn->n_reactions = n_reactions;
crn->n_constraints = n_constraints;
crn->reactants = calloc(n_reactants, sizeof(crntk_reactant));
if (crn->reactants == NULL) {
return false;
}
crn->complexes = calloc(n_complexes*n_reactants, sizeof(size_t));
if (crn->complexes == NULL) {
free(crn->reactants);
return false;
}
crn->reactions = calloc(n_reactions, sizeof(crntk_reaction));
if (crn->reactions == NULL) {
free(crn->reactants);
free(crn->complexes);
return false;
}
crn->constraints = calloc(n_constraints*n_reactants, sizeof(size_t));
if (crn->constraints == NULL) {
free(crn->reactants);
free(crn->complexes);
free(crn->reactions);
return false;
}
crn->constraint_values = calloc(n_constraints, sizeof(size_t));
if (crn->constraint_values == NULL) {
free(crn->reactants);
free(crn->complexes);
free(crn->reactions);
free(crn->constraints);
return false;
}
crn->_i_reactant = 0;
crn->_i_complex = 0;
crn->_i_reaction = 0;
crn->_i_constraint = 0;
*out = crn;
return true;
}
size_t crntk_add_reactant(crntk crn, double (*affinity)(size_t,size_t,const double*), double *data) {
crntk_reactant* ptr = &crn->reactants[crn->_i_reactant];
ptr->affinity = affinity;
ptr->data = data;
return crn->_i_reactant++;
}
size_t crntk_add_complex(crntk crn, const size_t* cplx) {
size_t* ptr = &crn->complexes[crn->n_reactants * crn->_i_complex];
for (size_t i = 0; i < crn->n_reactants; i++) {
*ptr = cplx[i];
ptr++;
}
return crn->_i_complex++;
}
size_t crntk_add_reaction(crntk crn, double rate, size_t lhs, size_t rhs) {
crntk_reaction* ptr = &crn->reactions[crn->_i_reaction];
ptr->rate = rate;
ptr->lhs = crn->complexes + crn->n_reactants * lhs;
ptr->rhs = crn->complexes + crn->n_reactants * rhs;
return crn->_i_reaction++;
}
void crntk_set_reaction_rate(crntk crn, size_t rxn, double rate) {
crn->reactions[rxn].rate = rate;
}
size_t crntk_add_constraint(crntk crn, size_t value, const size_t* law) {
size_t* ptr = &crn->constraints[crn->_i_constraint];
crn->constraint_values[crn->_i_constraint] = value;
for (size_t i = 0; i < crn->n_reactants; i++) {
*ptr = law[i];
ptr += crn->n_constraints;
}
return crn->_i_constraint++;
}
bool crntk_finalize(crntk crn) {
// check the conservation of each reaction
for (size_t i = 0; i < crn->n_reactions; i++) {
crn->reactions[i].conservative = true;
const size_t *lhs = crn->reactions[i].lhs;
const size_t *rhs = crn->reactions[i].rhs;
const size_t *constraint = crn->constraints;
size_t value_lhs, value_rhs;
for (size_t j = 0; j < crn->n_constraints; j++) {
value_lhs = 0;
value_rhs = 0;
for (size_t k = 0; k < crn->n_reactants; k++) {
value_lhs += lhs[k] * constraint[k * crn->n_constraints];
value_rhs += rhs[k] * constraint[k * crn->n_constraints];
}
constraint++;
if (value_lhs != value_rhs) {
crn->reactions[i].conservative = false;
break;
}
}
}
if (!init_lattice_table(crn))
return false;
if (!init_lattice_states(crn))
return false;
return true;
}
void crntk_destroy(crntk crn) {
free(crn->reactants);
free(crn->complexes);
free(crn->reactions);
free(crn->constraints);
free(crn->constraint_values);
for (size_t i = 0; i < crn->n_reactants; i++)
free(crn->table[i]);
free(crn->table);
free(crn->states);
free(crn);
}
| 30.868624 | 135 | 0.534649 |
a7462660725ec1e04494a40bf872c2f71dc974e1 | 2,194 | h | C | cpp/perspective/src/include/perspective/expression_tables.h | vishalbelsare/perspective | a0f2ad988c5cec40258e1549f2986fa7c9d938da | [
"Apache-2.0"
] | 1,821 | 2017-12-08T22:38:48.000Z | 2019-04-29T19:29:31.000Z | cpp/perspective/src/include/perspective/expression_tables.h | vishalbelsare/perspective | a0f2ad988c5cec40258e1549f2986fa7c9d938da | [
"Apache-2.0"
] | 278 | 2018-01-19T22:27:09.000Z | 2019-04-27T00:16:00.000Z | cpp/perspective/src/include/perspective/expression_tables.h | vishalbelsare/perspective | a0f2ad988c5cec40258e1549f2986fa7c9d938da | [
"Apache-2.0"
] | 125 | 2017-12-08T20:57:50.000Z | 2019-04-23T07:57:05.000Z | /******************************************************************************
*
* Copyright (c) 2019, the Perspective Authors.
*
* This file is part of the Perspective library, distributed under the terms of
* the Apache License 2.0. The full license can be found in the LICENSE file.
*
*/
#pragma once
#include <perspective/first.h>
#include <perspective/base.h>
#include <perspective/computed_expression.h>
#include <perspective/data_table.h>
#ifdef PSP_PARALLEL_FOR
#include <perspective/parallel_for.h>
#endif
namespace perspective {
/**
* @brief Store expression tables for each context - by separating expression
* columns from the main tables managed by the context, we ensure that cleaning
* up a context will also clean up its expression columns and not leak memory
* after the lifetime of a context.
*/
struct t_expression_tables {
PSP_NON_COPYABLE(t_expression_tables);
t_expression_tables(
const std::vector<std::shared_ptr<t_computed_expression>>& expressions);
/**
* @brief Reserve space on each transitional table - reserve is important
* because it also reserves space on each underlying column, whereas
* `set_capacity` only affects the table, and can lead to a situation where
* the table's capacity and the capacity of underlying columns grow out
* of sync, which causes memory errors.
*
* @param size
*/
void reserve_transitional_table_size(t_uindex size);
void set_transitional_table_size(t_uindex size);
void clear_transitional_tables();
// Calculate the `t_transitions` value for each row.
void calculate_transitions(std::shared_ptr<t_data_table> existed);
void reset();
// master table is calculated from t_gstate's master table
std::shared_ptr<t_data_table> m_master;
// flattened, prev, current, delta, transitions calculated from the
// tables stored on the gnode's output ports.
std::shared_ptr<t_data_table> m_flattened;
std::shared_ptr<t_data_table> m_prev;
std::shared_ptr<t_data_table> m_current;
std::shared_ptr<t_data_table> m_delta;
std::shared_ptr<t_data_table> m_transitions;
};
} // end namespace perspective | 33.242424 | 80 | 0.710574 |
7357286452b96aa4de05bab2a2a15b10a678f73a | 130 | h | C | Vendor/spdlog/include/spdlog/logger.h | wdrDarx/DEngine3 | 27e2de3b56b6d4c8705e8a0e36f5911d8651caa2 | [
"MIT"
] | 2 | 2022-01-11T21:15:31.000Z | 2022-02-22T21:14:33.000Z | Vendor/spdlog/include/spdlog/logger.h | wdrDarx/DEngine3 | 27e2de3b56b6d4c8705e8a0e36f5911d8651caa2 | [
"MIT"
] | null | null | null | Vendor/spdlog/include/spdlog/logger.h | wdrDarx/DEngine3 | 27e2de3b56b6d4c8705e8a0e36f5911d8651caa2 | [
"MIT"
] | null | null | null | version https://git-lfs.github.com/spec/v1
oid sha256:dc8843d8da2a389812ef67991d513e91b2a482cb10d9a1e8dab0757e7af1db17
size 15311
| 32.5 | 75 | 0.884615 |
56afbed2d7198fc61705bc5f310ffd9cbc82d600 | 56,576 | c | C | src/accel.c | terminele/armio | 34b9c75ed6b8a8157c01ccd91ba18c3f59def8fb | [
"MIT"
] | 7 | 2020-03-23T18:12:12.000Z | 2021-09-02T13:56:48.000Z | src/accel.c | terminele/armio | 34b9c75ed6b8a8157c01ccd91ba18c3f59def8fb | [
"MIT"
] | 1 | 2020-08-30T14:41:13.000Z | 2020-08-30T14:53:15.000Z | src/accel.c | terminele/armio | 34b9c75ed6b8a8157c01ccd91ba18c3f59def8fb | [
"MIT"
] | 1 | 2020-07-08T14:39:18.000Z | 2020-07-08T14:39:18.000Z | /** file: accel.c
* modified: 2014-11-03 11:50:33
*/
//___ I N C L U D E S ________________________________________________________
#include "accel.h"
#include "lis2dh12.h"
#include "main.h"
#include "leds.h"
#include "aclock.h"
// TODO : on super Y, turn off when y low / z high
//___ M A C R O S ( P R I V A T E ) ________________________________________
#define ACCEL_ERROR_TIMEOUT ((uint32_t) 1)
#define ACCEL_ERROR_SELF_TEST(test) (((uint32_t) 2) \
| (((uint32_t) test)<<8))
#define ACCEL_ERROR_READ_ID ((uint32_t) 3)
#define ACCEL_ERROR_WRONG_ID(id) (((uint32_t) 4) \
| (((uint32_t) id)<<8) )
#define ACCEL_ERROR_CONFIG(reg, val) \
main_terminate_in_error( error_group_accel, \
((uint32_t) 5) | (((uint32_t) reg)<<8) | (((uint32_t) val)<<16) )
#ifndef ABS
#define ABS(a) ( a < 0 ? -1 * a : a )
#endif
#ifndef LENGTH
#define LENGTH(a) (sizeof(a)/sizeof(a[0]))
#endif
#ifndef USE_SELF_TEST
# define USE_SELF_TEST false
#endif
/* for easier debugging of interrupt levels */
/* flash led to indicate isr triggering */
#ifndef DEBUG_AX_ISR
# define DEBUG_AX_ISR false
#endif
#ifndef REJECT_ALL_GESTURES
#define REJECT_ALL_GESTURES false
#endif
#ifndef SKIP_WAIT_FOR_DOWN
#define SKIP_WAIT_FOR_DOWN false
#endif
#ifndef GESTURE_FILTERS
# define GESTURE_FILTERS true
#endif
/* filter gestures based on intentional 'views' */
#ifndef SHOW_ACCEL_ERRORS_ON_LED
#define SHOW_ACCEL_ERRORS_ON_LED false
#endif
/* show / disable accel related errors showing on LED's */
//#define SHOW_LED_FOR_FILTER_INFO true
#ifndef SHOW_LED_FOR_FILTER_INFO
#define SHOW_LED_FOR_FILTER_INFO false
#endif
/* show a debug led indicating the gesture filter result */
#ifndef SHOW_LED_ON_DCLICK_FAIL
#define SHOW_LED_ON_DCLICK_FAIL false
#endif
/* Do we flash an LED if double-click was triggerd but filtered out
* because of the watch orientation */
#ifndef USE_PCA_LDA_FILTERS
#define USE_PCA_LDA_FILTERS false
#endif
/* Do we use new filters created from PCA / LDA analysis */
#ifndef WAKE_ON_SUPER_Y
#define WAKE_ON_SUPER_Y true
#endif
/* Do we allow a 'down' event to trigger with y or z high? */
#ifndef LOG_ACCEL_GESTURE_FIFO
#define LOG_ACCEL_GESTURE_FIFO false
#endif
#ifndef LOG_UNCONFIRMED_GESTURES
#define LOG_UNCONFIRMED_GESTURES true
#endif
#if ( SHOW_LED_FOR_FILTER_INFO )
#define _DISP_FILTER_INFO( i ) do { \
_led_on_full( i ); \
delay_ms(20); \
_led_off_full( i ); \
delay_ms(5); \
_led_on_full( i ); \
delay_ms(20); \
_led_off_full( i ); \
delay_ms(5); \
} while(0);
#else /* SHOW_LED_FOR_FILTER_INFO */
#define _DISP_FILTER_INFO( i )
#endif /* SHOW_LED_FOR_FILTER_INFO */
#if ( SHOW_ACCEL_ERRORS_ON_LED )
#define _DISP_ERROR( i ) do { \
_led_on_full( i ); \
delay_ms(1000); \
_led_off_full( i ); \
delay_ms(100); \
_led_on_full( i ); \
delay_ms(1000); \
_led_off_full( i ); \
delay_ms(100); \
} while(0);
#else /* SHOW_ACCEL_ERRORS_ON_LED */
#define _DISP_ERROR( i )
#endif
#define DISP_ERR_FIFO_READ() _DISP_ERROR( 30 )
#define DISP_ERR_CONSEC_READ_1() _DISP_ERROR( 57 )
#define DISP_ERR_CONSEC_READ_2() _DISP_ERROR( 58 )
#define DISP_ERR_CONSEC_READ_3() _DISP_ERROR( 59 )
#define DISP_ERR_WAKE_1() _DISP_ERROR( 19 )
#define DISP_ERR_WAKE_2() _DISP_ERROR( 56 )
//#define DISP_ERR_WAKE_3() _DISP_ERROR( 54 )
//#define DISP_ERR_WAKE_4() _DISP_ERROR( 53 )
//#define DISP_ERR_WAKE_GEST( state ) _DISP_ERROR( state + 40 )
#define DISP_ERR_ISR_RELEASE() _DISP_ERROR( 10 )
#define MS_TO_ODRS(t, sample_int) (t/sample_int)
#define BITS_PER_ACCEL_VAL 8
#define FIFO_MAX_SIZE 32
/* Click configuration constants */
#define ACTIVE_ODR ODR_400HZ
#define ACTIVE_SAMPLE_INT SAMPLE_INT_400HZ
#define SLEEP_ODR ODR_100HZ
#define SLEEP_SAMPLE_INT SAMPLE_INT_100HZ
/* parameters for ST sleep-to-wake/return-to-sleep functionality */
#define DEEP_SLEEP_THS 4
#define DEEP_SLEEP_DUR MS_TO_ODRS(1000, SLEEP_SAMPLE_INT)
#define ACTIVE_CLICK_THS 70 /* assumes 4g scale */
#define ACTIVE_CLICK_TIME_LIM MS_TO_ODRS(20, ACTIVE_SAMPLE_INT)
#define ACTIVE_CLICK_TIME_LAT MS_TO_ODRS(100, ACTIVE_SAMPLE_INT) /* ms */
#define SLEEP_CLICK_THS 47 /* assumes 4g scale */
#define SLEEP_CLICK_TIME_LIM MS_TO_ODRS(30, SLEEP_SAMPLE_INT)
#define SLEEP_CLICK_TIME_LAT MS_TO_ODRS(100, SLEEP_SAMPLE_INT) /* ms */
#define FAST_CLICK_WINDOW_MS 400
#define SLOW_CLICK_WINDOW_MS 1800
/* manual multi-click settings for ACTIVE mode */
#define DCLICK_TIME_WIN MS_TO_ODRS(400, SLEEP_SAMPLE_INT)
/* automated double click settings for SLEEP mode
* threshold : click checking starts when threshold is exceeded
* limit : value must be back below threshold by 'limit'
* latency : ignore from start of click through latency for a second click
* window : starts at end of latency, 2nd click must start before end of win
* details in AN3308 */
//___ T Y P E D E F S ( P R I V A T E ) ____________________________________
typedef enum { reject=-1, punt=0, accept=1 } fltr_result_t;
typedef enum {
WAIT_FOR_DOWN = 0,
WAIT_FOR_UP,
} wake_gesture_state_t;
typedef union {
struct {
bool xl : 1;
bool xh : 1;
bool yl : 1;
bool yh : 1;
bool zl : 1;
bool zh : 1;
bool ia : 1;
bool super : 1;
};
uint8_t b8;
} int_reg_flags_t;
typedef union {
struct {
bool x : 1;
bool y : 1;
bool z : 1;
bool sign : 1;
bool sclick : 1;
bool dclick : 1;
bool ia : 1;
bool : 1;
};
uint8_t b8;
} click_flags_t;
typedef struct {
union {
struct {
short int : 16 - BITS_PER_ACCEL_VAL;
short int x_l : BITS_PER_ACCEL_VAL;
};
short int x : 16;
};
union {
struct {
short int : 16 - BITS_PER_ACCEL_VAL;
short int y_l : BITS_PER_ACCEL_VAL;
};
short int y : 16;
};
union {
struct {
short int : 16 - BITS_PER_ACCEL_VAL;
short int z_l : BITS_PER_ACCEL_VAL;
};
short int z : 16;
};
} accel_xyz_t;
typedef struct {
union {
accel_xyz_t values[ FIFO_MAX_SIZE ];
uint8_t bytes[ FIFO_MAX_SIZE * sizeof( accel_xyz_t ) ];
};
uint8_t depth;
} accel_fifo_t;
/* Multiple Accumulate Compare Filter Def */
typedef struct {
/* Filter action (accept, punt, reject) if lower than this threshold */
const int32_t lower_ths;
const fltr_result_t lt_action;
/* Filter action (accept, punt, reject) if greater than this threshold */
const int32_t upper_ths;
const fltr_result_t gt_action;
/* weights for x,y,z fifo values for multiply accumulate */
const int32_t x_ws[32];
const int32_t y_ws[32];
const int32_t z_ws[32];
} macc_fltr_t;
//___ P R O T O T Y P E S ( P R I V A T E ) ________________________________
static void wait_state_conf( wake_gesture_state_t wait_state );
/* @brief configure the interrupts to detect movement into orientations of
* interest, used for gesture wake
* @param the state that we want to wait for
* @retrn None
*/
static bool wake_check( void );
static inline bool gesture_filter_check( void );
/* @brief read the accel fifo and filter turn to wake gestures
* @param None
* @retrn true if the watch should wake up
*/
static inline bool dclick_filter_check( void );
/* @brief read the accel current position and filter double click
* @param None
* @retrn true if the watch should wake up
*/
#if ( LOG_ACCEL_GESTURE_FIFO )
static inline void log_accel_gesture_fifo( void );
/* @brief log the fifo for an accel gesture
* @param None
* @retrn None
*/
#endif /* LOG_ACCEL_GESTURE_FIFO */
static void accel_isr(void);
static void configure_i2c(void);
/* @brief setup the i2c module to communicate with accelerometer
* accelerometer
* @param
* @retrn none
*/
static inline bool fltr_y_not_deliberate_fail( int16_t y_last, accel_xyz_t* sums );
/* @brief Highest priority filter is to check if the latest y
* is facing outward and the y-movement was not deliberate enough
* when turning wrist up from horizontal position, the sum of the
* first N y-values should exceed a certain threshold in the
* negative direction (i.e. 12 oclock facing downward)
* @param y_last : the last (most recent) y value
* @param sums : the sum history pointer
* @retrn true on fail
*/
static inline bool fltr_z_sum_slope_accept( accel_xyz_t* sums );
/* @brief the difference between the sum of the first N z-values and
* the sum of the last N z-values should exced a threshold
* (i.e. face moves from vertical to horizontal)
* @param the sum history pointer
* @retrn true on pass
*/
static inline bool fltr_y_turn_arm_accept( accel_xyz_t* sums );
static inline bool fltr_x_turn_arm_accept( accel_xyz_t* sums );
static inline bool fltr_xy_turn_arm_accept( accel_xyz_t* sums );
/* @brief if the sum after a certain number of values is high enough
* @param the sum history pointer
* @retrn true on pass
*/
static inline bool fltr_y_overshoot_accept( accel_xyz_t* sums );
/* @brief edge case test for when watch gets into a position closer to
* looking at you, then falls back into more of a flat position
* @param the sum history pointer
* @retrn true on pass
*/
static inline bool fltr_y_facing_inwards_accept( int16_t y_last );
/* @brief for when the watch is really facing inwards, this is a farily
* 'uncomfortable' position that indicates you are looking at the
* watch
* @param the last y value in the fifo
* @retrn true on pass
*/
static bool accel_register_consecutive_read (uint8_t start_reg,
uint8_t count, uint8_t *data_ptr);
/* @brief reads a series of data from consecutive registers from the
* accelerometer
* @param start_reg - address of first register to read
* count - # of consecutive registers to read
* data - pointer to array of data to be filled with reg values
* @retrn true on success, false on failure
*/
static bool accel_register_write (uint8_t reg, uint8_t val);
#if ( USE_SELF_TEST )
static void run_self_test( void );
/* @brief run the self test on the acceleration module
* expect an output change of between 17 and 360, defined by
* OUTPUT[LSb](self-test enabled) - OUTPUT[LSb](self-test disabled)
* where 1LSB=4mg at 10bit representation and +/- 2g full scale
* sign is defined in CTRL_REG4 (0x23)
* @param None
* @retrn None
*/
#endif
#if ( GESTURE_FILTERS || LOG_ACCEL_GESTURE_FIFO )
static void read_accel_fifo( void );
#endif
static bool check_tilt_down( int16_t x, int16_t y, int16_t z );
/* @brief check if the watch it tilted away from the user and should be sent
* to sleep. this can be used while awake and before waking
* @param current accel values
* @retrn true when tilted down
*/
static bool check_tilt_not_viewable( int16_t x, int16_t y, int16_t z );
/* @brief check if the watch is oriented in a postion that is not viewable
* @param current accel values
* @retrn true when tilted down
*/
//___ V A R I A B L E S ______________________________________________________
uint8_t accel_slow_click_cnt = 0;
uint8_t accel_fast_click_cnt = 0;
static accel_fifo_t accel_fifo = { .bytes = { 0 }, .depth = 0 };
static bool accel_wakeup_gesture_enabled = true;
#if (LOG_ACCEL_GESTURE_FIFO)
bool accel_confirmed = false;
#endif
static uint8_t slow_click_counter = 0;
static uint8_t fast_click_counter = 0;
static uint16_t i2c_addr = AX_ADDRESS0;
static uint32_t last_click_time_ms;
static struct i2c_master_module i2c_master_instance;
static click_flags_t click_flags;
static int_reg_flags_t int1_flags = { .super = false };
static int_reg_flags_t int2_flags = { .super = false };
static wake_gesture_state_t wake_gesture_state;
/* Gesture filter constants -- AUTO GENERATED by accel analysis script */
const macc_fltr_t zh_fltrs[] =
{
{
/*** Z-FILTER 1 - Fix Weight no PCA (60%) ***/
.lower_ths = 0,
.lt_action = punt,
.upper_ths = -446706,
.gt_action = reject,
.x_ws = {
54012, 0, 0, 4167, -2165, 0, 0, -8856,
0, 0, 0, 0, 1958, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 1041, 0, 1789, 0, 0, 0, 0,
},
.y_ws = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, -4167, 586,
0, 2083, 0, 0, 533, 0, -65536, 0,
},
.z_ws = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 520, 0,
0, 31893, 0, 0, 0, 0, 0, 0,
0, 0, 0, -48610, 0, 54752, -60013, -2083,
},
},
{
/*** Z-FILTER 2 - Round 2 Fix Weight no PCA (54%) ***/
.lower_ths = 0,
.lt_action = punt,
.upper_ths = 5230486,
.gt_action = reject,
.x_ws = {
0, 0, 0, 0, -512, 0, 0, 0,
0, 256, 0, 0, 0, 2048, 0, 0,
0, 0, 0, -42998, 0, -65536, 0, 18353,
0, 0, 29418, 0, -16658, 0, -28211, 0,
},
.y_ws = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, -58982, 0, 0, 0, 0,
},
.z_ws = {
0, 0, 0, 0, 38698, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, -4503,
0, -13493, 0, 18038, 0, 0, 2882, 3602,
0, 0, 0, 0, 0, 34828, 62634, -4096,
},
},
{
/*** Z-FILTER 3 - Round 3 Y-turn accepts ***/
.lower_ths = 0,
.lt_action = punt,
.upper_ths = -1749158,
.gt_action = accept,
.x_ws = {
26156, 23497, 19475, 15669, 9098, 5498, 17, -4861,
-7906, -9712, -9168, -7490, -8205, -8986, -10649, -9484,
-8574, -8183, -6794, -6422, -5725, -4599, -3422, -604,
-337, -284, 167, 328, 212, 769, 783, 1146,
},
.y_ws = {
-62271, -61932, -54030, -51469, -48088, -48552, -42286, -32404,
-29369, -18587, -9111, 3161, 12415, 17938, 30386, 36638,
41782, 47074, 47740, 49115, 49536, 50535, 52156, 52696,
52346, 51421, 50717, 48475, 46952, 45137, 44108, 45227,
},
.z_ws = {
-65536, -62615, -58106, -48842, -38389, -28383, -17732, -4534,
7378, 20030, 23182, 25973, 22934, 21008, 16182, 12977,
8315, 4880, 2105, 721, -628, -1429, -2729, -4981,
-6127, -7392, -7990, -8102, -7017, -5446, -3947, -3245,
},
},
{
/*** Z-FILTER 4 - Round 4 X-turn accepts ***/
.lower_ths = 0,
.lt_action = punt,
.upper_ths = -17284718,
.gt_action = accept,
.x_ws = {
23200, 16683, 9066, 9580, 4141, -3962, -12810, -31655,
-36521, -38897, -35085, -35851, -36346, -39118, -37378, -39760,
-34636, -36256, -31652, -27804, -25864, -19212, -12286, -7157,
-4164, -1562, 2518, 3528, 4049, 4963, 4682, 6877,
},
.y_ws = {
-29583, -21903, 4622, -17452, -36467, -41474, -26352, -10512,
-12657, -13850, 11788, 30983, 57374, 61410, 57328, 49723,
54519, 65536, 60635, 60511, 62393, 62598, 61109, 60332,
60468, 60394, 60987, 58525, 56137, 55249, 54650, 54682,
},
.z_ws = {
-49395, -55834, -43578, -26345, -12388, -14322, -41967, -44087,
-36964, -25421, -53619, -60921, -63159, -45876, -43926, -22894,
-18644, -9957, -12400, -13712, -14677, -16324, -17469, -19462,
-19038, -16246, -14383, -13155, -10381, -7032, -4119, -3944,
},
},
{
/*** Z-FILTER 5 - Round 5, final ***/
.lower_ths = 0,
.lt_action = accept,
.upper_ths = 0,
.gt_action = reject,
.x_ws = {
-3955, 4483, 8721, 4478, -2022, -2327, 5260, 9801,
12839, 13467, 16849, 19960, 21789, 24624, 27936, 31324,
32231, 35895, 36346, 35233, 35162, 35665, 35846, 35786,
35141, 34534, 33063, 32611, 31205, 30463, 29131, 28826,
},
.y_ws = {
-12697, -1905, -2646, -13055, -23760, -36802, -46602, -54816,
-54527, -53567, -60140, -61642, -65536, -61325, -62674, -60174,
-60386, -56689, -46092, -39149, -35981, -34129, -31283, -29238,
-28368, -28082, -28091, -28353, -26563, -24307, -23030, -22227,
},
.z_ws = {
-8696, -19425, -22185, -17831, -11460, 792, 9893, 14622,
9644, 12360, 13187, 15867, 10914, 6411, 8049, 6711,
7309, 7154, 6138, 6932, 6753, 6420, 5155, 4056,
3422, 2294, 2685, 3483, 3449, 3483, 2636, 1561,
},
},
};
const macc_fltr_t yh_fltrs[] =
{
{
/*** Y-FILTER 1 - PCA8, Reject Test 1 (45%) ***/
.lower_ths = 2733591,
.lt_action = reject,
.upper_ths = 34764674,
.gt_action = reject,
.x_ws = {
-28247, -26720, -25102, -23099, -20643, -19454, -16719, -16150,
-16157, -16853, -16253, -15324, -14883, -13047, -12133, -10941,
-10783, -10014, -9170, -8288, -7870, -7449, -6238, -5228,
-4938, -4839, -5351, -4902, -4428, -3490, -3509, -3143,
},
.y_ws = {
18514, 18540, 18072, 15983, 12543, 6023, -1134, -9280,
-14424, -15368, -17980, -18404, -20052, -15961, -8334, 451,
6143, 9584, 10472, 9282, 8543, 5502, 2296, 1415,
-451, -2813, -5286, -7808, -10275, -13854, -16315, -16679,
},
.z_ws = {
572, 425, 1331, -877, -1846, -6950, -9807, -13554,
-17902, -19724, -20019, -20088, -19714, -17269, -14184, -10445,
-3591, 4126, 13228, 23469, 31653, 38310, 45687, 49847,
54996, 59684, 64015, 65536, 65057, 63945, 62580, 59360,
},
},
{
/*** Y-FILTER 2 - PCA8, Reject Test 2 (22%) ***/
.lower_ths = -89832048,
.lt_action = reject,
.upper_ths = 29154581,
.gt_action = reject,
.x_ws = {
57961, 61043, 63047, 63874, 64606, 65536, 65195, 64894,
61653, 59486, 57407, 58174, 55736, 53252, 49559, 45092,
42341, 37142, 33296, 30578, 27535, 24511, 17972, 15209,
13356, 10583, 8208, 5450, 3449, 3012, 2127, 2375,
},
.y_ws = {
42129, 45340, 44132, 43850, 48841, 47395, 50848, 51593,
53497, 52777, 47470, 41659, 30621, 17853, 2120, -14609,
-25616, -29882, -27270, -25170, -25434, -24403, -25020, -29960,
-33557, -36306, -35631, -32567, -30214, -25485, -24595, -23653,
},
.z_ws = {
59988, 61252, 61520, 60255, 58120, 54404, 48918, 42721,
39579, 35189, 29771, 25172, 21581, 16288, 9839, 4090,
1298, -272, 641, 1223, 2904, 5322, 6212, 8401,
8260, 9118, 9555, 10099, 11304, 11484, 10890, 11501,
},
},
{
/*** Y-FILTER 3 - Y-trig X-turn Accept (PCA8, FP 16%) ***/
.lower_ths = 3269748,
.lt_action = accept,
.upper_ths = 0,
.gt_action = punt,
.x_ws = {
65536, 53201, 43038, 34966, 25535, 17619, 9357, 1228,
-4127, -8943, -11623, -15508, -18465, -20734, -21103, -19894,
-20036, -15790, -11932, -11583, -8788, -8774, -2441, -1155,
-12, 1443, 3094, 4335, 4473, 2330, 2197, 2702,
},
.y_ws = {
15181, 8550, 3726, -2067, -6330, -9336, -11567, -12808,
-16538, -18098, -16700, -19178, -19090, -15092, -10560, 368,
7159, 11027, 11345, 13255, 20641, 29159, 38235, 48710,
54367, 59128, 61376, 58651, 57409, 52008, 47989, 41592,
},
.z_ws = {
15238, 13208, 11740, 8631, 7531, 10410, 9895, 8488,
5775, 2729, -18, -917, -3356, -5132, -7232, -9073,
-6991, -6219, -3191, -4992, -8170, -9965, -9885, -12373,
-12158, -11830, -11633, -12837, -14729, -16347, -16449, -20403,
},
},
{
/*** Y-FILTER 4 - Y-trig Y-turn Accept (PCA8, FP 14%) ***/
.lower_ths = -13211549,
.lt_action = accept,
.upper_ths = 0,
.gt_action = punt,
.x_ws = {
-6274, -6995, -6853, -5462, -3768, -3804, -1949, -627,
2644, 4716, 6570, 6000, 5023, 4181, 4146, 7215,
7001, 6894, 5917, 3448, 3488, 3478, 1460, 24,
-700, -534, -1482, -1274, -1889, -1462, -1165, 498,
},
.y_ws = {
47530, 45827, 47329, 46543, 47500, 39233, 36210, 30622,
7527, -1956, -3861, -6565, -8850, -2663, 17811, 30337,
32955, 35625, 36183, 34297, 31111, 22736, 11936, 11390,
11127, 8611, 7075, 5431, 4133, 1025, -230, -3173,
},
.z_ws = {
65536, 60579, 57180, 50562, 42620, 33835, 27760, 17647,
-441, -17623, -30836, -44245, -52466, -57851, -58433, -57739,
-49391, -43390, -33711, -25982, -20303, -14384, -2741, -1191,
4131, 8108, 9231, 8688, 7429, 7087, 3718, 1772,
},
},
{
/*** Y-FILTER 5 - Y-Trig, last ditch ***/
.lower_ths = -12426520,
.lt_action = accept,
.upper_ths = -12426520,
.gt_action = reject,
.x_ws = {
875, 1455, 2967, 3329, 4117, 4681, 4213, 5223,
11094, 9426, 10778, 11242, 8419, 6770, 4561, 181,
-3241, -2474, -1254, -589, 58, -1959, -1772, -898,
-1634, -2112, -3274, -4059, -6223, -4204, -5376, -4537,
},
.y_ws = {
65536, 61232, 56366, 51409, 51652, 46910, 42081, 44920,
32305, 33810, 31785, 27682, 13671, -2106, -4544, -20085,
-32984, -34875, -24709, -20044, -17095, -15706, -14056, -16639,
-21309, -24412, -27448, -26347, -27058, -22404, -26025, -26796,
},
.z_ws = {
49577, 47392, 44007, 38492, 30898, 26335, 27750, 19467,
8738, -5727, -15988, -23553, -24545, -27792, -31910, -36103,
-34737, -30514, -25906, -27430, -25064, -22688, -16886, -15474,
-13882, -11034, -10079, -10972, -9973, -11085, -18889, -20353,
},
},
};
const macc_fltr_t syh_fltrs[] =
{
{
/*** SUPER Y-FILTER 1 - LD 2axis, from 16 samples ***/
.lower_ths = 32641288,
.lt_action = reject,
.upper_ths = 44881771,
.gt_action = reject,
.x_ws = {
-8210, -8060, -8955, -8971, -9368, -9104, -10555, -9811,
-10049, -10429, -10590, -11387, -12805, -10727, -11444, -12130,
-12990, -13794, -17153, -16694, -15913, -16785, -17062, -17802,
-18755, -18824, -18977, -18345, -17704, -17354, -17663, -16980,
},
.y_ws = {
24225, 26623, 27654, 28450, 29231, 30294, 32617, 32675,
34207, 33634, 34097, 34245, 34645, 36627, 37661, 37829,
38961, 39407, 41753, 42194, 48230, 51651, 54675, 58717,
61467, 64221, 65536, 65514, 64524, 63357, 63046, 59882,
},
.z_ws = {
7585, 6706, 5865, 5378, 5563, 4845, 6663, 6186,
6431, 5698, 4814, 4903, 6510, 3455, 3700, 2270,
2088, 1274, 1300, 740, 1613, 1415, 1265, 1533,
1315, 1900, 2425, 2983, 2239, 2168, 2888, 2996,
},
},
};
//___ I N T E R R U P T S ___________________________________________________
static void accel_isr(void) {
if (!accel_register_consecutive_read(AX_REG_CLICK_SRC, 1, &click_flags.b8)) {
DISP_ERR_CONSEC_READ_1();
}
if (!accel_register_consecutive_read(AX_REG_INT1_SRC, 1, &int1_flags.b8)) {
DISP_ERR_CONSEC_READ_2();
}
if (!accel_register_consecutive_read(AX_REG_INT2_SRC, 1, &int2_flags.b8)) {
DISP_ERR_CONSEC_READ_3();
}
#if ( DEBUG_AX_ISR )
if ( click_flags.ia ) _led_on_full( 56 );
if ( int1_flags.xl ) _led_on_full( 14 ); // y
if ( int1_flags.xh ) _led_on_full( 44 ); // ^
if ( int1_flags.yl ) _led_on_full( 59 ); // |
if ( int1_flags.yh ) _led_on_full( 29 ); // |
if ( int1_flags.zl ) _led_on_full( 7 ); // .---> x
if ( int1_flags.zh ) _led_on_full( 36 ); // /
if ( int2_flags.xl ) _led_on_full( 16 ); // /
if ( int2_flags.xh ) _led_on_full( 46 ); // z'
if ( int2_flags.yl ) _led_on_full( 1 );
if ( int2_flags.yh ) _led_on_full( 31 );
if ( int2_flags.zl ) _led_on_full( 9 );
if ( int2_flags.zh ) _led_on_full( 38 );
delay_ms(100);
if ( click_flags.ia ) _led_off_full( 56 );
if ( int1_flags.xl ) _led_off_full( 14 );
if ( int1_flags.xh ) _led_off_full( 44 );
if ( int1_flags.yl ) _led_off_full( 59 );
if ( int1_flags.yh ) _led_off_full( 29 );
if ( int1_flags.zl ) _led_off_full( 7 );
if ( int1_flags.zh ) _led_off_full( 36 );
if ( int2_flags.xl ) _led_off_full( 16 );
if ( int2_flags.xh ) _led_off_full( 46 );
if ( int2_flags.yl ) _led_off_full( 1 );
if ( int2_flags.yh ) _led_off_full( 31 );
if ( int2_flags.zl ) _led_off_full( 9 );
if ( int2_flags.zh ) _led_off_full( 38 );
#endif /* DEBUG_AX_ISR */
extint_chan_clear_detected(AX_INT_CHAN);
/* FIXME : as soon as the interrupt is cleared, the fifo is free to 'stream' again,
* so we should read the fifo before the interrupt gets cleared!!! (or
* right afterwareds before another sample is taken)
* */
/* Wait for accelerometer to release interrupt */
uint8_t i = 0;
while( extint_chan_is_detected(AX_INT_CHAN) ) {
uint8_t dummy;
extint_chan_clear_detected(AX_INT_CHAN);
accel_register_consecutive_read(AX_REG_CLICK_SRC, 1, &dummy);
accel_register_consecutive_read(AX_REG_INT1_SRC, 1, &dummy);
accel_register_consecutive_read(AX_REG_INT2_SRC, 1, &dummy);
if (i > 250) { /* 'i' is expected to roll over */
/* ### HACK to guard against unreleased AX interrupt */
accel_register_write (AX_REG_CTL3, 0);
accel_register_write (AX_REG_CTL3, I1_CLICK_EN);
accel_register_write (AX_REG_CLICK_CFG, X_DCLICK );
accel_register_write (AX_REG_CLICK_THS, SLEEP_CLICK_THS);
accel_register_write (AX_REG_TIME_LIM, SLEEP_CLICK_TIME_LIM);
accel_register_write (AX_REG_TIME_LAT, SLEEP_CLICK_TIME_LAT);
DISP_ERR_ISR_RELEASE()
}
i++;
};
}
//___ F U N C T I O N S ______________________________________________________
static void wait_state_conf( wake_gesture_state_t wait_state ) {
/* 1 LSb = 32 mg @ FS = 4g
* NOTE: if we are checking for 'z' high, then this filter will pass
* when z is positive and the magnitude of 'x' and 'y' is below the
* threshold value.. In other words, this threshold doesn't check that
* 'z' is greater than some value, it checks that 'x' & 'y' are below
* some value (or for 'y' it would check that 'z' & 'x' are below value) */
/* with threshold at 12 and ZH enabled
* POS: triggers when z > 12 and mag(xy) < 12
* AND: triggers when abs(z) > 12
* OR : triggers when abs(z) > ? (something below 12)
* */
/* NOTE: changing DURATION_ODR | THRESHOLD changes wake events signature */
/* NOTE: for duration -- tested 20-70, #samples is ms/10 + 2
* .. seems like there are n+1 samples checked, the very last sample
* doesn't matter (could be above/ could be below)*/
/* NOTE for 6D (ctrlreg5 AOI_POS): 0 and 1 do not work
* 5 -- uses 'xymag' <= value
* 2, 3, 4, 10, 15, 20, 21, 23 -- uses 'xymag' < value
* 24, 25, 26, 30 -- uses 'z' >= value (50, 6 samples, last is not counted)
* */
int16_t x, y, z;
accel_data_read(&x, &y, &z);
#if (SKIP_WAIT_FOR_DOWN)
wait_state = WAIT_FOR_UP;
#endif /* SKIP_WAIT_FOR_DOWN */
/* Configure interrupt to detect orientation status */
wake_gesture_state = wait_state;
/* Write bypass to clear FIFO, must be called before changing settings (p.21) */
accel_register_write (AX_REG_FIFO_CTL, FIFO_BYPASS);
if( wait_state == WAIT_FOR_DOWN ) {
accel_register_write (AX_REG_INT1_THS, 20);
accel_register_write (AX_REG_INT1_DUR, MS_TO_ODRS(70, SLEEP_SAMPLE_INT));
if ( z < 0 && y > 0 ) { /* don't allow 'down' event on z-low */
accel_register_write (AX_REG_INT1_CFG, AOI_POS | XLIE | XHIE | YLIE);
} else {
accel_register_write (AX_REG_INT1_CFG, AOI_POS | XLIE | XHIE | YLIE | ZLIE);
}
#if (WAKE_ON_SUPER_Y)
if (y < 10) {
accel_register_write (AX_REG_INT2_THS, 28);
accel_register_write (AX_REG_INT2_DUR, MS_TO_ODRS(100, SLEEP_SAMPLE_INT));
accel_register_write (AX_REG_INT2_CFG, AOI_POS | YHIE );
accel_register_write (AX_REG_CTL3, I1_CLICK_EN | I1_AOI1_EN | I1_AOI2_EN);
} else {
accel_register_write (AX_REG_INT2_THS, 0);
accel_register_write (AX_REG_INT2_DUR, 0);
accel_register_write (AX_REG_INT2_CFG, 0);
accel_register_write (AX_REG_CTL3, I1_CLICK_EN | I1_AOI1_EN);
}
#else
accel_register_write (AX_REG_CTL3, I1_CLICK_EN | I1_AOI1_EN);
#endif
} else { /* WAIT_FOR_UP */
accel_register_write (AX_REG_INT1_THS, 26);
accel_register_write (AX_REG_INT1_DUR, MS_TO_ODRS(120, SLEEP_SAMPLE_INT));
accel_register_write (AX_REG_INT1_CFG, AOI_POS | ZHIE);
accel_register_write (AX_REG_INT2_THS, 10);
accel_register_write (AX_REG_INT2_DUR, MS_TO_ODRS(80, SLEEP_SAMPLE_INT));
accel_register_write (AX_REG_INT2_CFG, AOI_POS | YHIE );
accel_register_write (AX_REG_CTL3, I1_CLICK_EN | I1_AOI1_EN | I1_AOI2_EN);
}
/* Enable stream to FIFO buffer mode */
accel_register_write (AX_REG_FIFO_CTL, STREAM_TO_FIFO);
}
static bool wake_check( void ) {
if (click_flags.ia) {
if (dclick_filter_check()) {
return true;
} else {
/* This DCLICK has been filtered out. Ensure
* we our configured correctly for sleep based on
* current wake gesture state */
if (accel_wakeup_gesture_enabled) {
wait_state_conf(wake_gesture_state);
}
return false;
}
}
/* dclick interrupt flag was not set but only a dclick
* interrupt could have occurred */
if (!accel_wakeup_gesture_enabled) {
DISP_ERR_WAKE_1();
return dclick_filter_check();
}
/* we got here bc of an interrupt, check that at least one flag exists */
if (!(int1_flags.ia || int2_flags.ia)) {
DISP_ERR_WAKE_2();
/* The accelerometer is in an error state (probably a timing
* error between interrupt trigger and register read) so just
* assume the interrupt was for what we expect based on state */
if (wake_gesture_state == WAIT_FOR_DOWN) {
wait_state_conf( WAIT_FOR_UP );
return false;
} else {
return true;
}
}
/* if our state was 'down', go forward to 'up' */
if (wake_gesture_state == WAIT_FOR_DOWN) {
#if (WAKE_ON_SUPER_Y)
if ( int2_flags.ia ) {
/* we just got a super y-high isr flag, skip to check gesture */
int2_flags.super = true;
if (gesture_filter_check()) {
return true;
}
main_nvm_data.filtered_gestures++;
wait_state_conf(WAIT_FOR_DOWN);
return false;
}
int2_flags.super = false;
#endif /* WAKE_ON_SUPER_Y */
wait_state_conf(WAIT_FOR_UP);
return false;
}
/* we are in WAIT_FOR_UP, run gesture filters to determine wake status */
if (gesture_filter_check()) {
return true;
}
/* gesture has been filtered out, wait for down again */
main_nvm_data.filtered_gestures++;
wait_state_conf(WAIT_FOR_DOWN);
return false;
}
static bool check_tilt_down( int16_t x, int16_t y, int16_t z ) {
const int16_t MAX_TILT = 20;
const int16_t ALMOST_VERT = 28;
const int16_t DOWN_FACING = -2;
return (ABS(x) > MAX_TILT || // x-tilted
(z <= ALMOST_VERT && y <= DOWN_FACING) || // turned out
(z <= DOWN_FACING && y <= ALMOST_VERT));
}
static inline fltr_result_t calc_macc_fltr_action( const macc_fltr_t *macc_fltr ) {
uint8_t i;
int32_t result = 0;
for( i = 0; i < accel_fifo.depth; i++ ) {
result += ((int32_t) accel_fifo.values[i].x_l) * macc_fltr->x_ws[i];
result += ((int32_t) accel_fifo.values[i].y_l) * macc_fltr->y_ws[i];
result += ((int32_t) accel_fifo.values[i].z_l) * macc_fltr->z_ws[i];
}
if (macc_fltr->lt_action != punt) {
if (result < macc_fltr->lower_ths ) {
return macc_fltr->lt_action;
}
}
if (macc_fltr->gt_action != punt) {
if (result > macc_fltr->upper_ths ) {
return macc_fltr->gt_action;
}
}
return punt;
}
static bool check_tilt_not_viewable( int16_t x, int16_t y, int16_t z ) {
const int16_t SLIGHTLY_VERT = 5;
const int16_t DOWN_FACING = -15;
return ((z <= SLIGHTLY_VERT && y <= DOWN_FACING) || // turned out
(z <= DOWN_FACING && y <= SLIGHTLY_VERT));
}
static inline bool gesture_filter_check( void ) {
/* Read FIFO to determine if a turn-up gesture occurred */
#if (LOG_ACCEL_GESTURE_FIFO || GESTURE_FILTERS)
read_accel_fifo();
#endif /* LOG_ACCEL_GESTURE_FIFO || GESTURE_FILTERS */
#if (REJECT_ALL_GESTURES)
#if (LOG_ACCEL_GESTURE_FIFO)
log_accel_gesture_fifo();
#endif /* LOG_ACCEL_GESTURE_FIFO */
return false;
#endif /* REJECT_ALL_GESTURES */
#if (!(GESTURE_FILTERS))
return true;
#endif
uint8_t i;
fltr_result_t result;
if( accel_fifo.depth == 0 ) {
/* there was some error reading the fifo */
return true;
}
if (check_tilt_down(accel_fifo.values[accel_fifo.depth-1].x_l,
accel_fifo.values[accel_fifo.depth-1].y_l,
accel_fifo.values[accel_fifo.depth-1].z_l)) {
/* current orientation would put us to sleep immediately anyway */
return false;
}
if (int1_flags.ia && int2_flags.ia) {
/* Both z-high and y-high interrupts are active (rare) */
/* Usually a true positive so accept always */
return true;
}
if (int2_flags.super) {
/* A "super Y" event has occurred */
/* run filters for wakeup due to z-high */
for (i=0; i < LENGTH(syh_fltrs); i++) {
result = calc_macc_fltr_action(syh_fltrs + i);
if (result == accept) {
_DISP_FILTER_INFO((i+1)*5);
return true;
} else if (result == reject) {
_DISP_FILTER_INFO(60-(i+1)*5);
return false;
}
}
/* ###FIXME accept any punted super-y for now */
return true;
}
if (int1_flags.ia) {
/* run filters for wakeup due to z-high */
for (i=0; i < LENGTH(zh_fltrs); i++) {
result = calc_macc_fltr_action(zh_fltrs + i);
if (result == accept) {
_DISP_FILTER_INFO((i+1)*5);
return true;
} else if (result == reject) {
_DISP_FILTER_INFO(60-(i+1)*5);
return false;
}
}
}
/* run filters for y-high (int2 active) */
if (int2_flags.ia) {
/* run filters for wakeup due to z-high */
for (i=0; i < LENGTH(yh_fltrs); i++) {
result = calc_macc_fltr_action(yh_fltrs + i);
if (result == accept) {
_DISP_FILTER_INFO(2 + (i+1)*5);
return true;
} else if (result == reject) {
_DISP_FILTER_INFO(60-2-(i+1)*5);
return false;
}
}
}
/* ###FIXME accept anything that is punted by all filters for now */
return true;
}
static inline bool dclick_filter_check( void ) {
int16_t x, y, z;
accel_register_write (AX_REG_FIFO_CTL, FIFO_BYPASS);
accel_data_read(&x, &y, &z);
if (check_tilt_down(x, y, z)) {
return false;
}
if (z >= 12 || y >= 12) {
return true;
} else if (z > 0 && y > 0 && (z*z + y*y) >= 144) {
return true;
} else {
main_nvm_data.filtered_dclicks++;
#if ( SHOW_LED_ON_DCLICK_FAIL )
_led_on_full(31);
delay_ms(10);
_led_off_full(31);
#endif /* SHOW_LED_ON_DCLICK_FAIL */
}
return false;
}
static void configure_interrupt ( void ) {
/* Configure our accel interrupt 1 to wake us up */
struct port_config pin_conf;
port_get_config_defaults(&pin_conf);
pin_conf.direction = PORT_PIN_DIR_INPUT;
pin_conf.input_pull = PORT_PIN_PULL_NONE;
port_pin_set_config(AX_INT_PIN, &pin_conf);
struct extint_chan_conf eint_chan_conf;
extint_chan_get_config_defaults(&eint_chan_conf);
eint_chan_conf.gpio_pin = AX_INT_EIC;
eint_chan_conf.gpio_pin_mux = AX_INT_EIC_MUX;
eint_chan_conf.gpio_pin_pull = EXTINT_PULL_NONE;
/* NOTE: cannot wake from standby with filter or edge detection ... */
eint_chan_conf.detection_criteria = EXTINT_DETECT_HIGH;
eint_chan_conf.filter_input_signal = false;
eint_chan_conf.wake_if_sleeping = true;
extint_chan_set_config(AX_INT_CHAN, &eint_chan_conf);
}
static void configure_i2c(void) {
/* Initialize config structure and software module */
struct i2c_master_config config_i2c_master;
i2c_master_get_config_defaults(&config_i2c_master);
/* Change buffer timeout to something longer */
config_i2c_master.baud_rate = I2C_MASTER_BAUD_RATE_400KHZ;
config_i2c_master.buffer_timeout = 65535;
config_i2c_master.pinmux_pad0 = AX_SDA_PAD;
config_i2c_master.pinmux_pad1 = AX_SCL_PAD;
config_i2c_master.start_hold_time = I2C_MASTER_START_HOLD_TIME_400NS_800NS;
config_i2c_master.run_in_standby = false;
/* Initialize and enable device with config */
while(i2c_master_init(&i2c_master_instance, SERCOM0, &config_i2c_master) != STATUS_OK);
i2c_master_enable(&i2c_master_instance);
}
static bool accel_register_consecutive_read (uint8_t start_reg, uint8_t count,
uint8_t *data_ptr) {
/* register address is 7 LSBs, MSB indicates consecutive or single read */
uint8_t write = start_reg | (count > 1 ? 1 << 7 : 0);
/* Write the register address (SUB) to the accelerometer */
struct i2c_master_packet packet = {
.address = i2c_addr,
.data_length = 1,
.data = &write,
.ten_bit_address = false,
.high_speed = false,
.hs_master_code = 0x0,
};
if ( STATUS_OK != i2c_master_write_packet_wait_no_stop (
&i2c_master_instance, &packet ) ) {
return false;
}
packet.data = data_ptr;
packet.data_length = count;
if (STATUS_OK != i2c_master_read_packet_wait ( &i2c_master_instance, &packet )) {
return false;
}
return true;
}
static inline bool fltr_y_not_deliberate_fail( int16_t y_last,
accel_xyz_t* sums ) {
bool y_test = y_last < -5;
return y_test;
}
static inline bool fltr_y_turn_arm_accept( accel_xyz_t* sums ) {
/* "Turn Arm Up" filter */
bool ytest = ABS( sums[9].y ) >= 240;
return ytest;
}
static inline bool fltr_x_turn_arm_accept( accel_xyz_t* sums ) {
/* "Turn Arm Up" filter */
/* when turning arm up from 3 or 9 o'clock down the absolute value
* sum of the first N x-values should exceed a certain threshold */
bool xtest = ABS( sums[5].x ) >= 120;
/* for xtest, check if sum of first N x-values are large enough in
* the negative (or positive for lefties) direction
* (3 or 9 o'clock facing down)
* */
return xtest;
}
static inline bool fltr_xy_turn_arm_accept( accel_xyz_t* sums ) {
/* "Turn Arm Up" filter */
bool xytest = ABS( sums[9].y ) + ABS( sums[5].x ) > 140;
return xytest;
}
static inline bool fltr_y_overshoot_accept( accel_xyz_t* sums ) {
bool test1 = sums[31].y - sums[26].y > 20;
bool test2 = sums[31].y - sums[22].y > 40;
return test1 || test2;
}
static inline bool fltr_y_facing_inwards_accept( int16_t y_last ) {
/* Filter #3 - if the y-value is greater than a certain threshold
* in positive direction (6 o'clock down, wrist turned in towards body)
* then we should wakeup */
bool test = y_last >= 4;
return test;
}
static bool accel_register_write (uint8_t reg, uint8_t val) {
uint8_t data[2] = {reg, val};
/* Write the register address (SUB) to the accelerometer */
struct i2c_master_packet packet = {
.address = i2c_addr,
.data_length = 2,
.data = data,
.ten_bit_address = false,
.high_speed = false,
.hs_master_code = 0x0,
};
if (STATUS_OK != i2c_master_write_packet_wait ( &i2c_master_instance, &packet)) {
return false;
}
return true;
}
#if ( USE_SELF_TEST )
static void run_self_test( void ) {
int16_t x0, y0, z0;
int16_t x1, y1, z1;
uint8_t reg4_default;
uint8_t status_reg;
int16_t stest_low = 17;
int16_t stest_high = 360;
uint32_t timeout;
const uint32_t default_to = 0x10;
uint8_t st_failure;
accel_register_consecutive_read( AX_REG_CTL4, 1, ®4_default );
/* set acceleration resoultion to +/- 2g */
accel_register_write( AX_REG_CTL4, FS_2G | STEST_NORMAL );
/* clear fifo data, then read xyz0 */
accel_data_read( &x0, &y0, &z0 ); /* clear existing data */
timeout = default_to;
do {
accel_register_consecutive_read( AX_STATUS_REG, 1, &status_reg );
} while( !(status_reg & ZYXDA) && --timeout );
if( timeout == 0 ) {
main_terminate_in_error( error_group_accel, ACCEL_ERROR_TIMEOUT );
}
accel_data_read( &x0, &y0, &z0 );
accel_register_write( AX_REG_CTL4, FS_2G | STEST_TEST1 );
/* test data is obtained after 2 samples in low power and normal mode
* or 8 samples in high resolution mode */
/* clear fifo data, then read xyz1 */
accel_data_read( &x1, &y1, &z1 );
timeout = default_to;
do {
accel_register_consecutive_read( AX_STATUS_REG, 1, &status_reg );
} while( !(status_reg & ZYXDA) && --timeout );
if( timeout == 0 ) {
main_terminate_in_error( error_group_accel, ACCEL_ERROR_TIMEOUT );
}
accel_data_read( &x1, &y1, &z1 );
timeout = default_to;
do {
accel_register_consecutive_read( AX_STATUS_REG, 1, &status_reg );
} while( !(status_reg & ZYXDA) && --timeout );
if( timeout == 0 ) {
main_terminate_in_error( error_group_accel, ACCEL_ERROR_TIMEOUT );
}
accel_data_read( &x1, &y1, &z1 );
x1 <<= 10 - BITS_PER_ACCEL_VAL;
x0 <<= 10 - BITS_PER_ACCEL_VAL;
y1 <<= 10 - BITS_PER_ACCEL_VAL;
y0 <<= 10 - BITS_PER_ACCEL_VAL;
z0 <<= 10 - BITS_PER_ACCEL_VAL;
z1 <<= 10 - BITS_PER_ACCEL_VAL;
/* check for failure modes on self test */
st_failure = 0;
if ( ABS(x1 - x0) < stest_low ) { /* fail x self test low */
st_failure |= (1<<0);
} else if ( ABS(x1 - x0) > stest_high ) { /* fail x self test high */
st_failure |= (1<<1);
}
if ( ABS(y1 - y0) < stest_low ) { /* fail y self test low */
st_failure |= (1<<2);
} else if ( ABS(y1 - y0) > stest_high ) { /* fail y self test high */
st_failure |= (1<<3);
}
if ( ABS(z1 - z0) < stest_low ) { /* fail z self test low */
st_failure |= (1<<4);
} else if ( ABS(z1 - z0) > stest_high ) { /* fail z self test high */
st_failure |= (1<<5);
}
accel_register_write( AX_REG_CTL4, reg4_default );
if( st_failure ) {
main_terminate_in_error( error_group_accel,
ACCEL_ERROR_SELF_TEST( st_failure ) );
}
}
#endif /* USE_SELF_TEST */
#if ( GESTURE_FILTERS || LOG_ACCEL_GESTURE_FIFO )
static void read_accel_fifo( void ) {
/* Read fifo depth first (should be 0x1f usually ) */
accel_register_consecutive_read( AX_REG_FIFO_SRC, 1, &accel_fifo.depth );
/* Note: STM's FSS FIFO Size register reports the size off-by-1
* (i.e. as an index instead of actual size). So a value of 31 means
* there the depth is 32 and so on */
accel_fifo.depth = 1 + (accel_fifo.depth & FIFO_SIZE);
if ( !accel_register_consecutive_read( AX_REG_OUT_X_L,
sizeof(accel_xyz_t) * accel_fifo.depth, accel_fifo.bytes ) ) {
accel_fifo.depth = 0;
DISP_ERR_FIFO_READ();
}
}
#endif /* GESTURE_FILTERS || LOG_ACCEL_GESTURE_FIFO */
//___ F U N C T I O N S ______________________________________________________
bool accel_wakeup_check( void ) {
bool wakeup = false;
#ifdef NO_ACCEL
return true;
#endif
/* Callback enable is only active when sleeping */
extint_chan_disable_callback(AX_INT_CHAN, EXTINT_CALLBACK_TYPE_DETECT);
wakeup = wake_check();
extint_chan_enable_callback(AX_INT_CHAN, EXTINT_CALLBACK_TYPE_DETECT);
return wakeup;
}
bool accel_data_read (int16_t *x_ptr, int16_t *y_ptr, int16_t *z_ptr) {
uint8_t reg_data[6] = {0};
/* Read the 6 8-bit registers starting with lower 8-bits of X value */
if (!accel_register_consecutive_read (AX_REG_OUT_X_L, 6, reg_data)) {
return false; //failure
}
*x_ptr = (int16_t)reg_data[0] | (((int16_t)reg_data[1]) << 8);
*x_ptr = *x_ptr >> (16 - BITS_PER_ACCEL_VAL);
*y_ptr = (int16_t)reg_data[2] | (((int16_t)reg_data[3]) << 8);
*y_ptr = *y_ptr >> (16 - BITS_PER_ACCEL_VAL);
*z_ptr = (int16_t)reg_data[4] | (((int16_t)reg_data[5]) << 8);
*z_ptr = *z_ptr >> (16 - BITS_PER_ACCEL_VAL);
return true;
}
void accel_enable ( void ) {
//i2c_master_enable(&i2c_master_instance);
#ifdef NO_ACCEL
return;
#endif
/* Callback enabled only when sleeping */
extint_chan_disable_callback(AX_INT_CHAN, EXTINT_CALLBACK_TYPE_DETECT);
accel_register_write (AX_REG_CTL1, (ACTIVE_ODR | X_EN | Y_EN | Z_EN |
(BITS_PER_ACCEL_VAL == 8 ? LOW_PWR_EN : 0)));
accel_register_write (AX_REG_CLICK_CFG, X_SCLICK);
accel_register_write (AX_REG_CLICK_THS, ACTIVE_CLICK_THS);
accel_register_write (AX_REG_TIME_LIM, ACTIVE_CLICK_TIME_LIM);
accel_register_write (AX_REG_TIME_LAT, ACTIVE_CLICK_TIME_LAT);
/* Enable single and double click detection */
accel_register_write (AX_REG_CTL3, I1_CLICK_EN);
/* Disable FIFO mode */
accel_register_write (AX_REG_FIFO_CTL, FIFO_BYPASS);
}
#if ( LOG_ACCEL_GESTURE_FIFO )
static inline void log_accel_gesture_fifo( void ) {
if ((LOG_UNCONFIRMED_GESTURES || accel_confirmed) && accel_fifo.depth) {
uint8_t START_CODE[3] = { 0x77, 0x77, 0x77 };
uint8_t END_CODE[3] = { 0x7F, 0x7F, 0x7F };
uint8_t flags[3];
uint8_t vbatt_relative;
uint32_t waketicks;
int32_t timestamp;
uint8_t values[3*FIFO_MAX_SIZE];
uint8_t i;
flags[0] = accel_confirmed ? 0xCC : 0xEE;
flags[1] = int1_flags.b8;
flags[2] = int2_flags.b8;
vbatt_relative = main_get_vbatt_relative();
waketicks = main_get_waketicks();
timestamp = aclock_get_timestamp();
for(i=0; i<accel_fifo.depth; i++) {
values[3*i+0] = (uint8_t) (accel_fifo.values[i].x_l & 0xFF);
values[3*i+1] = (uint8_t) (accel_fifo.values[i].y_l & 0xFF);
values[3*i+2] = (uint8_t) (accel_fifo.values[i].z_l & 0xFF);
}
main_log_data (START_CODE, 3, false);
main_log_data (flags, 3, false);
main_log_data ((uint8_t *) ×tamp, 4, false);
main_log_data ((uint8_t *) &waketicks, 4, false);
main_log_data (&vbatt_relative, 1, false);
main_log_data (values, 3*accel_fifo.depth, false);
main_log_data (END_CODE, 3, true);
}
}
#endif
void accel_sleep ( void ) {
#ifdef NO_ACCEL
return;
#endif
/* Reset click counters */
accel_register_write (AX_REG_CTL1,
(SLEEP_ODR | X_EN | Y_EN | Z_EN |
(BITS_PER_ACCEL_VAL == 8 ? LOW_PWR_EN : 0)));
/* Configure click parameters */
/* Only x-axis double clicks should wake us up */
accel_register_write (AX_REG_CTL3, I1_CLICK_EN);
accel_register_write (AX_REG_CLICK_CFG, X_DCLICK);
accel_register_write (AX_REG_CLICK_THS, SLEEP_CLICK_THS);
accel_register_write (AX_REG_TIME_LIM, SLEEP_CLICK_TIME_LIM);
accel_register_write (AX_REG_TIME_LAT, SLEEP_CLICK_TIME_LAT);
if (accel_wakeup_gesture_enabled) {
/* Configure interrupt to detect orientation down */
wait_state_conf( WAIT_FOR_DOWN );
#if (LOG_ACCEL_GESTURE_FIFO)
log_accel_gesture_fifo();
#endif /* LOG_ACCEL_GESTURE_FIFO */
}
int1_flags.b8 = 0;
int2_flags.b8 = 0;
click_flags.b8 = 0;
accel_slow_click_cnt = slow_click_counter = 0;
accel_fast_click_cnt = fast_click_counter = 0;
accel_fifo.depth = 0;
extint_chan_enable_callback(AX_INT_CHAN, EXTINT_CALLBACK_TYPE_DETECT);
}
static event_flags_t click_timeout_event_check( void ) {
/* Check for click timeouts */
if (fast_click_counter > 0 &&
(main_get_waketime_ms() > last_click_time_ms + FAST_CLICK_WINDOW_MS)) {
fast_click_counter = 0;
return EV_FLAG_ACCEL_FAST_CLICK_END;
}
if (slow_click_counter > 0 &&
(main_get_waketime_ms() > last_click_time_ms + SLOW_CLICK_WINDOW_MS)) {
slow_click_counter = 0;
return EV_FLAG_ACCEL_SLOW_CLICK_END;
}
return EV_FLAG_NONE;
}
void accel_events_clear( void ) {
fast_click_counter = 0;
slow_click_counter = 0;
accel_fast_click_cnt = 0;
accel_slow_click_cnt = 0;
}
event_flags_t accel_event_flags( void ) {
event_flags_t ev_flags = EV_FLAG_NONE;
int16_t x = 0, y = 0, z = 0;
static bool int_state = false;//keep track of prev interrupt state
/* these values assume a 4g scale */
const uint32_t SLEEP_DOWN_DUR_MS = 200;
const uint32_t SLEEP_NOT_VIEWABLE_DUR_MS = 200;
/* timestamp (based on main tic count) of most recent
* y down interrupt for entering sleep on z-low
*/
static bool tilt_down = false;
static bool tilt_not_viewable = false;
static uint32_t tilt_down_timeout_ms = 0;
static uint32_t tilt_not_viewable_timeout_ms = 0;
#ifdef NO_ACCEL
return ev_flags;
#endif
ev_flags |= click_timeout_event_check();
/* Check for turn down event */
accel_data_read(&x, &y, &z);
if (check_tilt_down(x, y, z)) {
if (!tilt_down) {
tilt_down = true;
tilt_down_timeout_ms = main_get_waketime_ms() + SLEEP_DOWN_DUR_MS;
} else if (main_get_waketime_ms() > tilt_down_timeout_ms) {
/* Check for accel low-z timeout */
ev_flags |= EV_FLAG_ACCEL_DOWN;
}
if (check_tilt_not_viewable(x, y, z)) {
if (!tilt_not_viewable) {
tilt_not_viewable = true;
tilt_not_viewable_timeout_ms = main_get_waketime_ms() + SLEEP_NOT_VIEWABLE_DUR_MS;
} else if (main_get_waketime_ms() > tilt_not_viewable_timeout_ms) {
ev_flags |= EV_FLAG_ACCEL_NOT_VIEWABLE;
}
} else {
tilt_not_viewable = false;
}
} else {
tilt_down = false;
}
if (port_pin_get_input_level(AX_INT_PIN)) {
accel_register_consecutive_read(AX_REG_CLICK_SRC, 1, &click_flags.b8);
if (int_state) return ev_flags; //we've already handled this interrupt
int_state = true;
if (!click_flags.ia) return ev_flags;
if (click_flags.sclick) {
if (click_flags.x) {
fast_click_counter++;
slow_click_counter++;
accel_fast_click_cnt = fast_click_counter;
accel_slow_click_cnt = slow_click_counter;
ev_flags |= EV_FLAG_ACCEL_CLICK;
last_click_time_ms = main_get_waketime_ms();
}
}
click_flags.b8 = 0;
} else {
int_state = false;
}
return ev_flags;
}
void accel_init ( void ) {
uint8_t who_it_be;
uint8_t write_byte, reg_read;
#ifdef NO_ACCEL
return;
#endif
configure_i2c();
delay_ms(5); /* accel takes 5ms to power up */
if (!accel_register_consecutive_read (AX_REG_WHO_AM_I, 1, &who_it_be)) {
/* ID read at first address failed. try other i2c address */
i2c_addr = AX_ADDRESS1;
if (!accel_register_consecutive_read (AX_REG_WHO_AM_I, 1, &who_it_be))
main_terminate_in_error( error_group_accel, ACCEL_ERROR_READ_ID );
}
if (who_it_be != WHO_IS_IT) {
main_terminate_in_error( error_group_accel,
ACCEL_ERROR_WRONG_ID( who_it_be ) );
}
accel_register_write(AX_REG_CTL5, BOOT);
delay_ms(5); /* this is a guess.. 5ms is required from full power
off to configure, if it wasn't ready then these
registers probably shouldn't validate */
/* Latch interrupts and enable FIFO */
write_byte = FIFO_EN | LIR_INT1 | LIR_INT2 | D4D_INT2;
/* Use 4D for interrupt 2 so that Y-HIGH events can be detected at low
* thresholds (i.e. slightly turned in). 4D allows since the AOI_POS
* interrupts are only triggered if the axis of interest exceeds the
* configured threshold AND all other axes are below that threshold. If
* 6D is enabled, then the z-axis is included in that check; with 4D the
* z-axis is not included -- so we have more freedom with the y-high
* interrupt */
accel_register_write (AX_REG_CTL5, write_byte);
accel_register_consecutive_read(AX_REG_CTL5, 1, ®_read);
if(reg_read != write_byte) {ACCEL_ERROR_CONFIG(AX_REG_CTL5, reg_read);}
/* Using 4g mode */
accel_register_write (AX_REG_CTL4, FS_4G);
accel_register_consecutive_read(AX_REG_CTL4, 1, ®_read);
if(reg_read != FS_4G) {ACCEL_ERROR_CONFIG(AX_REG_CTL4, reg_read);}
accel_register_write (AX_REG_TIME_WIN, DCLICK_TIME_WIN);
accel_register_consecutive_read(AX_REG_TIME_WIN, 1, ®_read);
if(reg_read != DCLICK_TIME_WIN) {ACCEL_ERROR_CONFIG(AX_REG_TIME_WIN, reg_read);}
/* Enable High Pass filter for Clicks, not for AOI function */
write_byte = HPCLICK | HPCF | HPMS_NORM;
accel_register_write (AX_REG_CTL2, write_byte);
accel_register_consecutive_read(AX_REG_CTL2, 1, ®_read);
if(reg_read != write_byte) {ACCEL_ERROR_CONFIG(AX_REG_CTL2, reg_read);}
/* Enable sleep-to-wake by setting activity threshold and duration */
accel_register_write (AX_REG_ACT_THS, DEEP_SLEEP_THS);
accel_register_consecutive_read(AX_REG_ACT_THS, 1, ®_read);
if(reg_read != DEEP_SLEEP_THS) {ACCEL_ERROR_CONFIG(AX_REG_ACT_THS, reg_read);}
accel_register_write (AX_REG_ACT_DUR, DEEP_SLEEP_DUR);
accel_register_consecutive_read(AX_REG_ACT_DUR, 1, ®_read);
if(reg_read != DEEP_SLEEP_DUR) {ACCEL_ERROR_CONFIG(AX_REG_ACT_DUR, reg_read);}
accel_enable();
#if ( USE_SELF_TEST )
run_self_test( );
#endif /* USE_SELF_TEST */
configure_interrupt();
extint_register_callback(accel_isr, AX_INT_CHAN, EXTINT_CALLBACK_TYPE_DETECT);
}
void accel_set_gesture_enabled( bool enabled ) {
#if (LOG_ACCEL_GESTURE_FIFO)
if (main_user_data.wake_gestures) {
accel_confirmed = !(enabled);
accel_wakeup_gesture_enabled = true;
} else {
/* respect main_user_data.wake_gestures setting */
accel_wakeup_gesture_enabled = false;
}
#else
accel_wakeup_gesture_enabled = enabled;
#endif
}
| 34.837438 | 98 | 0.611019 |
8270af11b2ca562ba22d06a2f891ee9503cf8dc7 | 7,625 | c | C | src/pbkdf2.c | Zontec/embedCrypto | 229242db4f18a429ddb01ce86a3c0be28b35d46a | [
"MIT"
] | 3 | 2021-07-26T17:07:34.000Z | 2021-10-04T12:00:20.000Z | src/pbkdf2.c | polina-krukovich/mbedCrypto | 229242db4f18a429ddb01ce86a3c0be28b35d46a | [
"MIT"
] | 9 | 2021-09-21T14:15:27.000Z | 2021-09-21T15:42:41.000Z | src/pbkdf2.c | polina-krukovich/mbedCrypto | 229242db4f18a429ddb01ce86a3c0be28b35d46a | [
"MIT"
] | 2 | 2021-09-01T15:48:30.000Z | 2021-09-01T16:51:43.000Z | /****************************INFORMATION***********************************
* Copyright (c) 2021 Zontec
* Email: dehibeo@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
**************************************************************************/
/*!
* @file pbkdf2.c
* @brief File contains PBKDF2 implementation.
* @author Zontec
* @version 1.1
* @date 2021.07.04
*/
#include "pbkdf2.h"
#define PBKDF2_HMAC_SHA1_BUFFER_SIZE (32)
#define PBKDF2_HMAC_SHA256_BUFFER_SIZE (64)
#define PBKDF2_HMAC_SHA512_BUFFER_SIZE (128)
#define PBKDF2_HMAC_MAX_BUFFER_SIZE (PBKDF2_HMAC_SHA512_BUFFER_SIZE)
static security_status_e _pbkdf2_hmac(void *ctx, hmac_init_t hmac_init,
hmac_update_t hmac_update,
hmac_final_t hmac_finish,
uint32_t hmac_size, const uint8_t *password,
uint32_t pass_len, const uint8_t *salt,
uint32_t salt_len, uint32_t iters,
uint8_t *out, uint32_t out_len)
{
SECURITY_FUNCTION_BEGIN;
uint8_t U[PBKDF2_HMAC_MAX_BUFFER_SIZE];
uint8_t T[PBKDF2_HMAC_MAX_BUFFER_SIZE];
uint32_t U_len = hmac_size;
uint8_t *out_p = out;
uint8_t ctr[4];
uint32_t use_len;
uint32_t ctr_len = sizeof(ctr) / sizeof(uint8_t);
/* check input params */
SECURITY_CHECK_VALID_NOT_NULL(password);
SECURITY_CHECK_VALID_NOT_NULL(salt);
SECURITY_CHECK_VALID_NOT_NULL(out);
if (!pass_len || !salt_len || !out_len || !iters)
{
SECURITY_FUNCTION_RET_VAR = SECURITY_STATUS_FAIL_INCORRECT_FUNCTION_PARAM;
goto SECURITY_FUNCTION_EXIT;
}
SECURITY_CHECK_VALID_NOT_NULL(memset(ctr, 0x00, ctr_len));
/* by default ctr = 1 */
/* LE is used */
ctr[3] = 1;
while (out_len != 0)
{
/* salt||ctr */
SECURITY_CHECK_RES(hmac_init(ctx, password, pass_len));
SECURITY_CHECK_RES(hmac_update(ctx, salt, salt_len));
SECURITY_CHECK_RES(hmac_update(ctx, ctr, ctr_len));
SECURITY_CHECK_RES(hmac_finish(ctx, T));
SECURITY_CHECK_VALID_NOT_NULL(memcpy(U, T, U_len));
SECURITY_CHECK_RES(hmac_init(ctx, password, pass_len));
for(uint32_t i = 1; i < iters; ++i)
{
/* Uj= HMAC(P, Uj-1) */
SECURITY_CHECK_RES(hmac_update(ctx, U, U_len));
SECURITY_CHECK_RES(hmac_finish(ctx, U));
SECURITY_CHECK_RES(hmac_init(ctx, password, pass_len));
/* Ti = Ti xor Uj */
#if (PBKDF2_MIN_SIZE == ENABLED)
/* If mem_xor if defined */
#ifdef mem_xor
mem_xor(T, U, U_len);
#else /* mem_xor */
for(uint32_t j = 0; j < U_len; ++j)
{
T[j] ^= U[j];
}
#endif /* mem_xor */
#else /* PBKDF2_MIN_SIZE */
for(uint32_t j = 0; j < U_len;)
{
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
T[j] ^= U[j], ++j;
}
#endif /* PBKDF2_MIN_SIZE */
}
use_len = (out_len < U_len) ? out_len : U_len;
/* mk = T1 || T2 || … || Tlen<0…r-1> */
SECURITY_CHECK_VALID_NOT_NULL(memcpy(out_p, T, use_len));
/* next counter for new iter */
out_len -= U32(use_len);
out_p += use_len;
/* if overflow happens then next byte + 1*/
for(uint32_t i = 3; i > 0; --i)
{
++ctr[i];
if(ctr[i] != 0)
{
break;
}
}
}
SECURITY_FUNCTION_EXIT:
#if (SECURITY_LEVEL == MAX_SECURITY_LEVEL) \
|| defined(SECURED_PBKDF2_HMAC_SHA1) \
|| defined(SECURED_PBKDF2_HMAC_SHA256) \
|| defined(SECURED_PBKDF2_HMAC_SHA512) \
/* Clean local data*/
memset_safe(U, MAX_BYTE_VALUE, sizeof(U));
memset_safe(T, MAX_BYTE_VALUE, sizeof(T));
out_p = MAX_WORD_VALUE;
memset_safe(ctr, MAX_BYTE_VALUE, sizeof(ctr));
#endif /* SECURITY_LEVEL == MAX_SECURITY_LEVEL */
SECURITY_FUNCTION_RETURN;
}
/*=============================== PBKDF2_HMAC_SHA1 ===============================*/
#if (PBKDF2_HMAC_SHA1 == ENABLED)
#include "hmac_sha1.h"
security_status_e pbkdf2_hmac_sha1(const uint8_t *password, uint32_t pass_len,
const uint8_t *salt, uint32_t salt_len,
uint32_t iters, uint8_t *out, uint32_t out_len)
{
SECURITY_FUNCTION_BEGIN;
hmac_sha1_t hmac;
SECURITY_CHECK_RES(
_pbkdf2_hmac(&hmac, hmac_sha1_init, hmac_sha1_update, hmac_sha1_finish,
HMAC_SHA1_HASH_SIZE, password, pass_len, salt, salt_len, iters,
out, out_len)
);
SECURITY_FUNCTION_EXIT:
#if (SECURITY_LEVEL == MAX_SECURITY_LEVEL) || defined(SECURED_PBKDF2_HMAC_SHA1)
memset_safe(&hmac, MAX_BYTE_VALUE, sizeof(hmac));
#endif /* SECURITY_LEVEL == MAX_SECURITY_LEVEL */
SECURITY_FUNCTION_RETURN;
}
#endif /* (PBKDF2_HMAC_SHA1 == ENABLED) */
/*=============================== PBKDF2_HMAC_SHA256 ===============================*/
#if (PBKDF2_HMAC_SHA256 == ENABLED)
#include "hmac_sha256.h"
security_status_e pbkdf2_hmac_sha256(const uint8_t *password, uint32_t pass_len,
const uint8_t *salt, uint32_t salt_len,
uint32_t iters, uint8_t *out, uint32_t out_len)
{
SECURITY_FUNCTION_BEGIN;
hmac_sha256_t hmac;
SECURITY_CHECK_RES(
_pbkdf2_hmac(&hmac, hmac_sha256_init, hmac_sha256_update, hmac_sha256_finish,
HMAC_SHA256_HASH_SIZE, password, pass_len, salt, salt_len, iters,
out, out_len)
);
SECURITY_FUNCTION_EXIT:
#if (SECURITY_LEVEL == MAX_SECURITY_LEVEL) || defined(SECURED_PBKDF2_HMAC_SHA256)
memset_safe(&hmac, MAX_BYTE_VALUE, sizeof(hmac));
#endif /* SECURITY_LEVEL == MAX_SECURITY_LEVEL */
SECURITY_FUNCTION_RETURN;
}
#endif /* (PBKDF2_HMAC_SHA256 == ENABLED) */
/*=============================== PBKDF2_HMAC_SHA512 ===============================*/
#if (PBKDF2_HMAC_SHA512 == ENABLED)
#include "hmac_sha512.h"
security_status_e pbkdf2_hmac_sha512(const uint8_t *password, uint32_t pass_len,
const uint8_t *salt, uint32_t salt_len,
uint32_t iters, uint8_t *out, uint32_t out_len)
{
SECURITY_FUNCTION_BEGIN;
hmac_sha512_t hmac;
SECURITY_CHECK_RES(
_pbkdf2_hmac(&hmac, hmac_sha512_init, hmac_sha512_update, hmac_sha512_finish,
HMAC_SHA512_HASH_SIZE, password, pass_len, salt, salt_len, iters,
out, out_len)
);
SECURITY_FUNCTION_EXIT:
#if (SECURITY_LEVEL == MAX_SECURITY_LEVEL) || defined(SECURED_PBKDF2_HMAC_SHA512)
memset_safe(&hmac, MAX_BYTE_VALUE, sizeof(hmac));
#endif /* SECURITY_LEVEL == MAX_SECURITY_LEVEL */
SECURITY_FUNCTION_RETURN;
}
#endif /* (PBKDF2_HMAC_SHA512 == ENABLED) */
| 30.5 | 86 | 0.580984 |
069a88caeec70b31be4a1a720adf7ea1a81aefcf | 889 | c | C | ch07-composition-and-aggregation/ExtremeC_examples_chapter7_1_engine.c | Grahame-student/Extreme-C | b5fa8c6575147e095d8e72b829f08d04b9d4e2e2 | [
"MIT"
] | 162 | 2019-07-02T21:58:08.000Z | 2022-03-27T20:53:31.000Z | ch07-composition-and-aggregation/ExtremeC_examples_chapter7_1_engine.c | Grahame-student/Extreme-C | b5fa8c6575147e095d8e72b829f08d04b9d4e2e2 | [
"MIT"
] | 2 | 2020-09-01T22:00:49.000Z | 2021-09-05T13:57:14.000Z | ch07-composition-and-aggregation/ExtremeC_examples_chapter7_1_engine.c | Grahame-student/Extreme-C | b5fa8c6575147e095d8e72b829f08d04b9d4e2e2 | [
"MIT"
] | 80 | 2019-01-26T09:51:33.000Z | 2022-03-30T13:53:23.000Z | // File name: ExtremeC_examples_chapter4_4_engine.c
// Description: Implementation of the class Engine
#include <stdlib.h>
typedef enum {
ON,
OFF
} state_t;
typedef struct {
state_t state;
double temperature;
} engine_t;
// Memory allocator
engine_t* engine_new() {
return (engine_t*)malloc(sizeof(engine_t));
}
// Constructor
void engine_ctor(engine_t* engine) {
engine->state = OFF;
engine->temperature = 15;
}
// Destructor
void engine_dtor(engine_t* engine) {
// Nothing to do
}
// Behavior functions
void engine_turn_on(engine_t* engine) {
if (engine->state == ON) {
return;
}
engine->state = ON;
engine->temperature = 75;
}
void engine_turn_off(engine_t* engine) {
if (engine->state == OFF) {
return;
}
engine->state = OFF;
engine->temperature = 15;
}
double engine_get_temperature(engine_t* engine) {
return engine->temperature;
}
| 17.096154 | 51 | 0.694038 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.