text
stringlengths 8
6.88M
|
|---|
#ifndef __DRIVER_GPIO_H
#define __DRIVER_GPIO_H
#include "gpiod.h"
using namespace std;
class gpio {
private:
struct gpiod_chip * chip;
struct gpiod_line * line;
public:
gpio(int no, int dir);
~gpio();
int set_value(int val);
int get_value();
};
#endif
|
#include "CHud.h"
char (*CHud::m_BigMessage)[128] = (char (*)[128])0xBAACC0;
Bool &CHud::bScriptForceDisplayWithCounters = *(Bool *)0xBAA3FA;
|
#include "glib.h"
#include "iostream"
#include "sstream"
int main(int argc , char *argv[])
{
GLIB obj("file://myconnections.xml");
int val=obj.HexStringToInt(argv[1]);
obj.writeTest("test_REG",val);
return 0;
}
|
//Jumping on clouds
#include <iostream>
#include<vector>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> clouds(n);
for(int i = 0;i < n;i++){
cin >> clouds[i];
}
vector<int>counts(n , 100);
counts[0] = 0;
for (int i = 0; i < n; ++i) {
if (clouds[i] == 1) continue;
if (i + 1 < n && clouds[i + 1] == 0) {
counts[i + 1] = min(counts[i + 1], counts[i] + 1);
}
if (i + 2 < n && clouds[i + 2] == 0) {
counts[i + 2] = min(counts[i + 2], counts[i] + 1);
}
}
cout << counts[n - 1] << endl;
return 0;
}
|
#include "knight.h"
Knight::Knight(int x, int y, bool pieceColor)
: Piece(x, y, 'N', pieceColor){}
bool Knight::Move(int i, int j, Location** board)
{
// down
if ( i == mX + 2 ) {
if ( ( ( j == mY - 1 ) || ( j == mY + 1 ) )&&( ( board[i][j].GetPiece() == NULL)
|| ( board[i][j].GetPiece()->GetColor() != board[mX][mY].GetPiece()->GetColor() ) ) )
{
return true;
}
// up
} else if ( i == mX - 2 ) {
if ( ( ( j == mY - 1 ) || ( j == mY + 1 ) )&&( ( board[i][j].GetPiece() == NULL )
|| ( board[i][j].GetPiece()->GetColor() != board[mX][mY].GetPiece()->GetColor() ) ) )
{
return true;
}
// right
} else if ( j == mY + 2 ) {
if ( ( ( i == mX - 1 ) || ( i == mX + 1 ) )&&( ( board[i][j].GetPiece() == NULL )
|| ( board[i][j].GetPiece()->GetColor() != board[mX][mY].GetPiece()->GetColor() ) ) )
{
return true;
}
// left
} else if ( j == mY - 2 ) {
if ( ( ( i == mX - 1 ) || ( i == mX + 1 ) )&&( ( board[i][j].GetPiece() == NULL )
|| ( board[i][j].GetPiece()->GetColor() != board[mX][mY].GetPiece()->GetColor() ) ) )
{
return true;
}
}
return false;
}
|
/*
* Copyright 2016 Freeman Zhang <zhanggyb@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.
*/
#include <skland/gui/surface.hpp>
#include <skland/gui/abstract-event-handler.hpp>
#include <skland/gui/buffer.hpp>
#include <skland/gui/shell-surface.hpp>
#include <skland/gui/sub-surface.hpp>
#include <skland/gui/egl-surface.hpp>
#include "internal/display-registry.hpp"
#include "internal/surface-commit-task.hpp"
namespace skland {
Surface *Surface::kTop = nullptr;
Surface *Surface::kBottom = nullptr;
int Surface::kShellSurfaceCount = 0;
Task Surface::kCommitTaskHead;
Task Surface::kCommitTaskTail;
Surface::Surface(AbstractEventHandler *event_handler, const Margin &margin)
: mode_(kSynchronized),
parent_(nullptr),
above_(nullptr),
below_(nullptr),
up_(nullptr),
down_(nullptr),
event_handler_(event_handler),
margin_(margin),
buffer_transform_(WL_OUTPUT_TRANSFORM_NORMAL),
buffer_scale_(1),
is_user_data_set_(false),
egl_surface_role_(nullptr) {
DBG_ASSERT(nullptr != event_handler_);
role_.placeholder = nullptr;
wl_surface_.enter().Set(this, &Surface::OnEnter);
wl_surface_.leave().Set(this, &Surface::OnLeave);
wl_surface_.Setup(Display::Registry().wl_compositor());
commit_task_.reset(new CommitTask(this));
}
Surface::~Surface() {
if (egl_surface_role_)
delete egl_surface_role_;
if (nullptr == parent_)
delete role_.shell_surface; // deleting a shell surface will break the links to up_ and down_
else
delete role_.sub_surface; // deleting all sub surfaces and break the links to above_ and below_
}
void Surface::Attach(Buffer *buffer, int32_t x, int32_t y) {
if (nullptr != egl_surface_role_) return;
if (nullptr == buffer) {
wl_surface_.Attach(NULL, x, y);
} else {
buffer->SetPosition(x, y);
wl_surface_.Attach(buffer->wl_buffer(), x, y);
}
}
void Surface::Commit() {
if (nullptr != egl_surface_role_) {
// EGL surface does not use commit
if (mode_ == kSynchronized) {
// Synchronized mode need to commit the main surface
Surface *main_surface = GetShellSurface();
main_surface->Commit();
}
return;
}
if (commit_task_->IsLinked())
return;
if (nullptr == parent_) {
kCommitTaskTail.PushFront(commit_task_.get());
return;
}
if (mode_ == kSynchronized) {
// Synchronized mode need to commit the main surface too
Surface *main_surface = GetShellSurface();
main_surface->Commit();
main_surface->commit_task_->PushFront(commit_task_.get());
} else {
kCommitTaskTail.PushFront(commit_task_.get());
}
}
Surface *Surface::GetShellSurface() {
Surface *shell_surface = this;
Surface *parent = parent_;
while (parent) {
shell_surface = parent;
parent = parent->parent_;
}
return shell_surface;
}
Point Surface::GetWindowPosition() const {
Point position = relative_position_;
const Surface *parent = parent_;
const Surface *shell_surface = this;
while (parent) {
position += parent->relative_position();
if (nullptr == parent->parent_) shell_surface = parent;
parent = parent->parent();
}
return position - Point(shell_surface->margin().l, shell_surface->margin().t);
}
void Surface::OnEnter(struct wl_output *wl_output) {
if (!is_user_data_set_) {
wl_surface_.SetUserData(this);
is_user_data_set_ = true;
}
// TODO: call function in view_
}
void Surface::OnLeave(struct wl_output *wl_output) {
// TODO: call function in view_
}
void Surface::Clear() {
while (kShellSurfaceCount > 0) {
AbstractEventHandler *event_handler = kTop->event_handler();
delete event_handler;
}
}
void Surface::InitializeCommitTaskList() {
kCommitTaskHead.PushBack(&kCommitTaskTail);
}
void Surface::ClearCommitTaskList() {
Task *task = kCommitTaskHead.next();
Task *next_task = nullptr;
while (task != &kCommitTaskTail) {
next_task = task->next();
task->Unlink();
task = next_task;
}
}
}
|
//
// nehe10.h
// NeheGL
//
// Created by Andong Li on 9/7/13.
// Copyright (c) 2013 Andong Li. All rights reserved.
//
#ifndef __NeheGL__nehe10__
#define __NeheGL__nehe10__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <GLUT/glut.h>
#include "utils.h"
#include "SOIL.h"
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <cmath>
#include <ctime>
struct Vertex{
GLfloat x,y,z,u,v;
};
struct Triangle{
Vertex vertex[3];
};
struct Sector{
int numTriangles;
Triangle* triangles;
};
class NEHE10{
public:
static GLvoid ReSizeGLScene(GLsizei width, GLsizei height);
static GLvoid InitGL();
static GLvoid DrawGLScene();
static GLvoid UpdateScene(int flag);
static GLvoid KeyboardFuction(unsigned char key, int x, int y);
static GLvoid KeyboardUpFuction(unsigned char key, int x, int y);
static GLvoid KeySpecialFuction(int key, int x, int y);
static GLvoid KeySpecialUpFuction(int key, int x, int y);
static const char* TITLE;
const static int EXPECT_FPS = 60; // expect FPS during rendering
const static int FPS_UPDATE_CAP = 100; // time period for updating FPS
private:
static GLfloat sleepTime; //delay time for limiting FPS
static void computeFPS();
static bool LoadGLTextures(const char* dir);
static int frameCounter;
static int currentTime;
static int lastTime;
static char FPSstr[15];
static GLuint filter; // Which Filter To Use
static GLuint texture[3]; // Storage For Three Texture
static bool setupWorld(const char* fileDir);
static void readstr(FILE *f,char *string); //helper function read one line
static bool keys[256];
static bool specialKeys[256];
static bool bp;
static bool blend;
static bool fp;
static Sector sector;
static const GLfloat piover180;
static GLfloat walkbias;
static GLfloat walkbiasangle;
static GLfloat heading;
static GLfloat xpos;
static GLfloat zpos;
static GLfloat yrot;
static GLfloat lookupdown;
static GLfloat z;
};
#endif /* defined(__NeheGL__nehe10__) */
|
#include "ESObject.h"
ESObject::ESObject(string _name)
{
className = _name;
}
|
/*
* Program: Matching.h
* Usage: Match all the images with key points
*/
#ifndef MATCHING_H
#define MATCHING_H
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include "CImg.h"
#include "Warping.h"
extern "C"{
#include <vl/generic.h>
#include <vl/sift.h>
#include <vl/kdtree.h>
}
#define NUM_OF_PAIR 4
#define CONFIDENCE 0.99
#define INLINER_RATIO 0.5
#define RANSAC_THRESHOLD 4.0
using namespace std;
using namespace cimg_library;
struct keyPointPair{
VlSiftKeypoint p1;
VlSiftKeypoint p2;
keyPointPair(VlSiftKeypoint _p1, VlSiftKeypoint _p2){
p1 = _p1;
p2 = _p2;
}
};
struct keyPointPairs{
vector<keyPointPair> pairs;
int src, dst;
point_pairs(vector<keyPointPair> _pairs, int s, int d) {
pairs = _pairs;
src = s;
dst = d;
}
};
class Matcher{
public:
Macther(){
this->wr = Warper();
}
vector<keyPointPair> scanPointPairs(map<vector<float>, VlSiftKeypoint>& f1, map<vector<float>, VlSiftKeypoint> f2);
vector<int> getInlinerIndexs(vector<keyPointPair>& pairs, Axis H, set<int> indexes);
Axis Homography(vector<keyPointPair>& pairs);
Axis RANSAC(vector<keyPointPair>& pairs);
Axis leastSquares(vector<keyPointPair> pairs, vector<int> inliner_indexs);
inline int random(int min, int max) {
return rand() % (max - min + 1) + min;
}
private:
Warper wr;
};
#endif
|
/** @file
* Base class for an host-guest service.
*/
/*
* Copyright (C) 2011-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
#ifndef ___VBox_HostService_Service_h
#define ___VBox_HostService_Service_h
#include <VBox/log.h>
#include <VBox/hgcmsvc.h>
#include <iprt/assert.h>
#include <iprt/alloc.h>
#include <iprt/cpp/utils.h>
#include <memory> /* for auto_ptr */
namespace HGCM
{
class Message
{
public:
Message(uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM aParms[])
: m_uMsg(0)
, m_cParms(0)
, m_paParms(0)
{
setData(uMsg, cParms, aParms);
}
~Message()
{
cleanup();
}
uint32_t message() const { return m_uMsg; }
uint32_t paramsCount() const { return m_cParms; }
int getData(uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM aParms[]) const
{
if (m_uMsg != uMsg)
{
LogFlowFunc(("Message type does not match (%u (buffer), %u (guest))\n",
m_uMsg, uMsg));
return VERR_INVALID_PARAMETER;
}
if (m_cParms != cParms)
{
LogFlowFunc(("Parameter count does not match (%u (buffer), %u (guest))\n",
m_cParms, cParms));
return VERR_INVALID_PARAMETER;
}
int rc = copyParms(cParms, m_paParms, &aParms[0], false /* fCreatePtrs */);
// if (RT_FAILURE(rc))
// cleanup(aParms);
return rc;
}
int setData(uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM aParms[])
{
AssertReturn(cParms < 256, VERR_INVALID_PARAMETER);
AssertPtrNullReturn(aParms, VERR_INVALID_PARAMETER);
/* Cleanup old messages. */
cleanup();
m_uMsg = uMsg;
m_cParms = cParms;
if (cParms > 0)
{
m_paParms = (VBOXHGCMSVCPARM*)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * m_cParms);
if (!m_paParms)
return VERR_NO_MEMORY;
}
int rc = copyParms(cParms, &aParms[0], m_paParms, true /* fCreatePtrs */);
if (RT_FAILURE(rc))
cleanup();
return rc;
}
int getParmU32Info(uint32_t iParm, uint32_t *pu32Info) const
{
AssertPtrNullReturn(pu32Info, VERR_INVALID_PARAMETER);
AssertReturn(iParm < m_cParms, VERR_INVALID_PARAMETER);
AssertReturn(m_paParms[iParm].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_INVALID_PARAMETER);
*pu32Info = m_paParms[iParm].u.uint32;
return VINF_SUCCESS;
}
int getParmU64Info(uint32_t iParm, uint64_t *pu64Info) const
{
AssertPtrNullReturn(pu64Info, VERR_INVALID_PARAMETER);
AssertReturn(iParm < m_cParms, VERR_INVALID_PARAMETER);
AssertReturn(m_paParms[iParm].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_INVALID_PARAMETER);
*pu64Info = m_paParms[iParm].u.uint64;
return VINF_SUCCESS;
}
int getParmPtrInfo(uint32_t iParm, void **ppvAddr, uint32_t *pcSize) const
{
AssertPtrNullReturn(ppvAddr, VERR_INVALID_PARAMETER);
AssertPtrNullReturn(pcSize, VERR_INVALID_PARAMETER);
AssertReturn(iParm < m_cParms, VERR_INVALID_PARAMETER);
AssertReturn(m_paParms[iParm].type == VBOX_HGCM_SVC_PARM_PTR, VERR_INVALID_PARAMETER);
*ppvAddr = m_paParms[iParm].u.pointer.addr;
*pcSize = m_paParms[iParm].u.pointer.size;
return VINF_SUCCESS;
}
int copyParms(uint32_t cParms, PVBOXHGCMSVCPARM paParmsSrc, PVBOXHGCMSVCPARM paParmsDst, bool fCreatePtrs) const
{
int rc = VINF_SUCCESS;
for (uint32_t i = 0; i < cParms; ++i)
{
paParmsDst[i].type = paParmsSrc[i].type;
switch (paParmsSrc[i].type)
{
case VBOX_HGCM_SVC_PARM_32BIT:
{
paParmsDst[i].u.uint32 = paParmsSrc[i].u.uint32;
break;
}
case VBOX_HGCM_SVC_PARM_64BIT:
{
paParmsDst[i].u.uint64 = paParmsSrc[i].u.uint64;
break;
}
case VBOX_HGCM_SVC_PARM_PTR:
{
/* Do we have to recreate the memory? */
if (fCreatePtrs)
{
/* Yes, do so. */
paParmsDst[i].u.pointer.size = paParmsSrc[i].u.pointer.size;
if (paParmsDst[i].u.pointer.size > 0)
{
paParmsDst[i].u.pointer.addr = RTMemAlloc(paParmsDst[i].u.pointer.size);
if (!paParmsDst[i].u.pointer.addr)
{
rc = VERR_NO_MEMORY;
break;
}
}
}
else
{
/* No, but we have to check if there is enough room. */
if (paParmsDst[i].u.pointer.size < paParmsSrc[i].u.pointer.size)
rc = VERR_BUFFER_OVERFLOW;
}
if ( paParmsDst[i].u.pointer.addr
&& paParmsSrc[i].u.pointer.size > 0
&& paParmsDst[i].u.pointer.size > 0)
memcpy(paParmsDst[i].u.pointer.addr,
paParmsSrc[i].u.pointer.addr,
RT_MIN(paParmsDst[i].u.pointer.size, paParmsSrc[i].u.pointer.size));
break;
}
default:
{
AssertMsgFailed(("Unknown HGCM type %u\n", paParmsSrc[i].type));
rc = VERR_INVALID_PARAMETER;
break;
}
}
if (RT_FAILURE(rc))
break;
}
return rc;
}
void cleanup()
{
if (m_paParms)
{
for (uint32_t i = 0; i < m_cParms; ++i)
{
switch (m_paParms[i].type)
{
case VBOX_HGCM_SVC_PARM_PTR:
if (m_paParms[i].u.pointer.size)
RTMemFree(m_paParms[i].u.pointer.addr);
break;
}
}
RTMemFree(m_paParms);
m_paParms = 0;
}
m_cParms = 0;
m_uMsg = 0;
}
protected:
uint32_t m_uMsg;
uint32_t m_cParms;
PVBOXHGCMSVCPARM m_paParms;
};
class Client
{
public:
Client(uint32_t uClientId, VBOXHGCMCALLHANDLE hHandle, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM aParms[])
: m_uClientId(uClientId)
, m_hHandle(hHandle)
, m_uMsg(uMsg)
, m_cParms(cParms)
, m_paParms(aParms) {}
VBOXHGCMCALLHANDLE handle() const { return m_hHandle; }
uint32_t message() const { return m_uMsg; }
uint32_t clientId() const { return m_uClientId; }
int addMessageInfo(uint32_t uMsg, uint32_t cParms)
{
if (m_cParms != 3)
return VERR_INVALID_PARAMETER;
m_paParms[0].setUInt32(uMsg);
m_paParms[1].setUInt32(cParms);
return VINF_SUCCESS;
}
int addMessageInfo(const Message *pMessage)
{
if (m_cParms != 3)
return VERR_INVALID_PARAMETER;
m_paParms[0].setUInt32(pMessage->message());
m_paParms[1].setUInt32(pMessage->paramsCount());
return VINF_SUCCESS;
}
int addMessage(const Message *pMessage)
{
return pMessage->getData(m_uMsg, m_cParms, m_paParms);
}
private:
uint32_t m_uClientId;
VBOXHGCMCALLHANDLE m_hHandle;
uint32_t m_uMsg;
uint32_t m_cParms;
PVBOXHGCMSVCPARM m_paParms;
};
template <class T>
class AbstractService: public RTCNonCopyable
{
public:
/**
* @copydoc VBOXHGCMSVCLOAD
*/
static DECLCALLBACK(int) svcLoad(VBOXHGCMSVCFNTABLE *pTable)
{
LogFlowFunc(("ptable = %p\n", pTable));
int rc = VINF_SUCCESS;
if (!VALID_PTR(pTable))
rc = VERR_INVALID_PARAMETER;
else
{
LogFlowFunc(("ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", pTable->cbSize, pTable->u32Version));
if ( pTable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
|| pTable->u32Version != VBOX_HGCM_SVC_VERSION)
rc = VERR_VERSION_MISMATCH;
else
{
std::auto_ptr<AbstractService> apService;
/* No exceptions may propagate outside. */
try
{
apService = std::auto_ptr<AbstractService>(new T(pTable->pHelpers));
} catch (int rcThrown)
{
rc = rcThrown;
} catch (...)
{
rc = VERR_UNRESOLVED_ERROR;
}
if (RT_SUCCESS(rc))
{
/*
* We don't need an additional client data area on the host,
* because we're a class which can have members for that :-).
*/
pTable->cbClient = 0;
/* These functions are mandatory */
pTable->pfnUnload = svcUnload;
pTable->pfnConnect = svcConnect;
pTable->pfnDisconnect = svcDisconnect;
pTable->pfnCall = svcCall;
/* Clear obligatory functions. */
pTable->pfnHostCall = NULL;
pTable->pfnSaveState = NULL;
pTable->pfnLoadState = NULL;
pTable->pfnRegisterExtension = NULL;
/* Let the service itself initialize. */
rc = apService->init(pTable);
/* Only on success stop the auto release of the auto_ptr. */
if (RT_SUCCESS(rc))
pTable->pvService = apService.release();
}
}
}
LogFlowFunc(("returning %Rrc\n", rc));
return rc;
}
virtual ~AbstractService() {};
protected:
explicit AbstractService(PVBOXHGCMSVCHELPERS pHelpers)
: m_pHelpers(pHelpers)
, m_pfnHostCallback(NULL)
, m_pvHostData(NULL)
{}
virtual int init(VBOXHGCMSVCFNTABLE *ptable) { return VINF_SUCCESS; }
virtual int uninit() { return VINF_SUCCESS; }
virtual int clientConnect(uint32_t u32ClientID, void *pvClient) = 0;
virtual int clientDisconnect(uint32_t u32ClientID, void *pvClient) = 0;
virtual void guestCall(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void *pvClient, uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) = 0;
virtual int hostCall(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { return VINF_SUCCESS; }
/** Type definition for use in callback functions. */
typedef AbstractService SELF;
/** HGCM helper functions. */
PVBOXHGCMSVCHELPERS m_pHelpers;
/*
* Callback function supplied by the host for notification of updates
* to properties.
*/
PFNHGCMSVCEXT m_pfnHostCallback;
/** User data pointer to be supplied to the host callback function. */
void *m_pvHostData;
/**
* @copydoc VBOXHGCMSVCHELPERS::pfnUnload
* Simply deletes the service object
*/
static DECLCALLBACK(int) svcUnload(void *pvService)
{
AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
SELF *pSelf = reinterpret_cast<SELF *>(pvService);
int rc = pSelf->uninit();
AssertRC(rc);
if (RT_SUCCESS(rc))
delete pSelf;
return rc;
}
/**
* @copydoc VBOXHGCMSVCHELPERS::pfnConnect
* Stub implementation of pfnConnect and pfnDisconnect.
*/
static DECLCALLBACK(int) svcConnect(void *pvService,
uint32_t u32ClientID,
void *pvClient)
{
AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
LogFlowFunc(("pvService=%p, u32ClientID=%u, pvClient=%p\n", pvService, u32ClientID, pvClient));
SELF *pSelf = reinterpret_cast<SELF *>(pvService);
int rc = pSelf->clientConnect(u32ClientID, pvClient);
LogFlowFunc(("rc=%Rrc\n", rc));
return rc;
}
/**
* @copydoc VBOXHGCMSVCHELPERS::pfnConnect
* Stub implementation of pfnConnect and pfnDisconnect.
*/
static DECLCALLBACK(int) svcDisconnect(void *pvService,
uint32_t u32ClientID,
void *pvClient)
{
AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
LogFlowFunc(("pvService=%p, u32ClientID=%u, pvClient=%p\n", pvService, u32ClientID, pvClient));
SELF *pSelf = reinterpret_cast<SELF *>(pvService);
int rc = pSelf->clientDisconnect(u32ClientID, pvClient);
LogFlowFunc(("rc=%Rrc\n", rc));
return rc;
}
/**
* @copydoc VBOXHGCMSVCHELPERS::pfnCall
* Wraps to the call member function
*/
static DECLCALLBACK(void) svcCall(void * pvService,
VBOXHGCMCALLHANDLE callHandle,
uint32_t u32ClientID,
void *pvClient,
uint32_t u32Function,
uint32_t cParms,
VBOXHGCMSVCPARM paParms[])
{
AssertLogRelReturnVoid(VALID_PTR(pvService));
LogFlowFunc(("pvService=%p, callHandle=%p, u32ClientID=%u, pvClient=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, callHandle, u32ClientID, pvClient, u32Function, cParms, paParms));
SELF *pSelf = reinterpret_cast<SELF *>(pvService);
pSelf->guestCall(callHandle, u32ClientID, pvClient, u32Function, cParms, paParms);
LogFlowFunc(("returning\n"));
}
/**
* @copydoc VBOXHGCMSVCHELPERS::pfnHostCall
* Wraps to the hostCall member function
*/
static DECLCALLBACK(int) svcHostCall(void *pvService,
uint32_t u32Function,
uint32_t cParms,
VBOXHGCMSVCPARM paParms[])
{
AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
LogFlowFunc(("pvService=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, u32Function, cParms, paParms));
SELF *pSelf = reinterpret_cast<SELF *>(pvService);
int rc = pSelf->hostCall(u32Function, cParms, paParms);
LogFlowFunc(("rc=%Rrc\n", rc));
return rc;
}
/**
* @copydoc VBOXHGCMSVCHELPERS::pfnRegisterExtension
* Installs a host callback for notifications of property changes.
*/
static DECLCALLBACK(int) svcRegisterExtension(void *pvService,
PFNHGCMSVCEXT pfnExtension,
void *pvExtension)
{
AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
LogFlowFunc(("pvService=%p, pfnExtension=%p, pvExtention=%p\n", pvService, pfnExtension, pvExtension));
SELF *pSelf = reinterpret_cast<SELF *>(pvService);
pSelf->m_pfnHostCallback = pfnExtension;
pSelf->m_pvHostData = pvExtension;
return VINF_SUCCESS;
}
};
}
#endif /* !___VBox_HostService_Service_h */
|
#include <stdio.h>
int main () {
int n;
double sed = 0.464102, result = 0;
scanf("%d", &n);
if (n % 2 == 0) {
result = n;
}
else if (n == 1) {
result = 2;
}
else if (n == 3) {
result = 3.732051;
}
else {
result = n + sed;
}
printf("%lf\n", result);
}
|
//#include <iostream>
//
//using namespace std;
//
//int main()
//{
// int n=9,m=19;
// if(n<10&&m<20)
// {
// while(n>=1)
// {
// while(m>=1)
// {
// cout<<m<<" ";
// m--;
// }
// cout<<"\n n: "<<n<<"\n";
// n--;
// }
//
// }
// cout<<"\n";
// for(int i=1,j=2;i+j<10;i++,j+=2)
// {
// cout<<i+j<<" ";
// }
// cout<<"\n";
// int s;
// s=1>=2;
// cout<<s<<endl;
// int a=1;
// if(a==0)
// cout<<"\n a =0";
// if(a==0)
// {
// cout<<"a ==0 !";
//
// }
// else
// cout<<"a !=0";
// cout<<"\n";
// for(int i=0;i<10;i+=2)
// {
// cout<<i<<" ";
// }
// int b=2;
// int c=1;
// switch(b)
// {
// case 1:
// {
// cout<<"\n 1";
// break;
// }
// case 2:
// {
// switch(c)
// {
// case 1:
// {
// cout<<"\n b =1";
// break;
// }
// case 2:
// {
// cout<<"\n b=2!";
// break;
// }
// }
// break;
// }
// case 3:
// {
// cout<<"\n 3";
// }
// }
// int loidungswitch;
// cout<<"\n Nhap lua chon:\t";
// cin>>loidungswitch;
// switch(loidungswitch)
// {
// case 1:
// case 5:
// case 7:
// case 9:
// case 3:
// cout<<"\n so le !";
// break;
// case 2:
// case 6:
// case 8:
//
//
//
// case 4:
// cout<<"\n so chan !";
// break;
//
// }
// return 0;
//}
#include<iostream>
#include<string>
using namespace std;
class TenLop
{
private:
string name;//trong private nen rieng cho class minz
public:
//ham constructor (Ham dung)
//Chuc nang: Khoi tao mac dinh
// kieu khong gia tri tra ve
///Co The Co Tham so Hoac khong!
//CU-PHAP:
/*
->KHONG CO THAM SO
<ten_lop>()
{
name=" Tu Hoc Lap Trinh!";
cac cau lenh( );
}
*/
/*
=>CO THAM SO TRUYEN VAO
<ten_lop>( string ten)
{
name=ten;
}
*/
TenLop()
{
name=" Hay ";
//cout<<" Hay ";
}
TenLop(string ten)
{
name=ten;
}
void setter(string ten)
{
name=ten;
//cout<<name;
}
//tra ve cai ten do = kieu du lieu cua ten do da duoc thay doi
string getter()
{
return name+" co Len! ";//cong them 1 chuoi!
}
};
int main()
{
TenLop Ten;//khi chay den day la no da chay ngay vao ham constructor
//string x=" vuong min normal";
//Ten.setter(x);
cout<<Ten.getter()<<endl;//xuat ra Ten
TenLop Ten2("vuongmin normal");
cout<<Ten2.getter();
return 0;
}
|
int Solution::solve(vector<int> &A, int B) {
int n = A.size();
int light, dark = 0;
int ans = 0;
while (dark < n)
{
light = dark + B - 1 < n ? dark + B - 1 : n - 1;
while (light >= 0 && light >= dark - B + 1 && A[light] != 1)
light--;
if (light < 0 || light < dark - B + 1)
return -1;
dark = light + B;
ans++;
}
return ans;
}
|
#include "CModifyIdMessage.h"
#include "Markup.h"
#include "CMessageEventMediator.h"
#include "NetClass.h"
CModifyIdMessage::CModifyIdMessage(CMessageEventMediator* pMessageEventMediator, QObject *parent)
: CMessage(pMessageEventMediator, parent)
{
}
CModifyIdMessage::~CModifyIdMessage()
{
}
bool CModifyIdMessage::packedSendMessage(NetMessage& netMessage)
{
CMarkup xml;
xml.SetDoc("<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n");
xml.AddElem("Message");
xml.AddChildElem("Header");
xml.IntoElem();
xml.AddAttrib("MsgType", "EMSG_MODIFYID_REQ");
xml.OutOfElem();
xml.AddChildElem("Info");
xml.IntoElem();
xml.AddAttrib("OldId", MessageDataMediator->m_strOldId.toStdString().c_str());
xml.AddAttrib("NewId", MessageDataMediator->m_strNewId.toStdString().c_str());
xml.OutOfElem();
netMessage.msgBuffer = packXml(&xml);
netMessage.msgLen = xml.GetDoc().length();
return true;
}
bool CModifyIdMessage::treatMessage(const NetMessage& netMessage, CNetClt* pNet)
{
CMarkup xml;
if(xml.SetDoc(netMessage.msgBuffer))
{
int errCode = 0;
QString errorInfo = "";
if(checkError(&xml, errCode, errorInfo))
{
if(0 != errCode)
{
ClientLogger->AddLog(QString::fromLocal8Bit("ModifyId [%1] : \r\n[%2]").arg(errorInfo).arg(netMessage.msgBuffer));
emit NetClass->m_pMessageEventMediator->sigError(netMessage.msgHead, errorInfo);
return true;
}
}
emit NetClass->m_pMessageEventMediator->sigModifySuccess();
}
else
{
ClientLogger->AddLog(QString::fromLocal8Bit("ModifyId收到的消息错误， 无法被正确解析 : [%1]").arg(netMessage.msgBuffer));
emit NetClass->m_pMessageEventMediator->sigError(netMessage.msgHead, QString::fromLocal8Bit("收到的消息错误， 无法被正确解析"));
}
return true;
}
|
#include "deleteworker.h"
#include "JlCompress.h"
#include<QFile>
#include<QDir>
#include <boost/filesystem.hpp>
void DeleteWorker::init(QFileInfo& f1)
{
QString path = f1.filePath();
this->qfi1_= path + "/blk0001.dat";
this->qfi2_= path + "/txleveldb";
std::cout << "file " << (this->qfi1_).toStdString() << std::endl;
std::cout << "dir " << (this->qfi2_).toStdString() << std::endl;
}
void DeleteWorker::removeFiles()
{
QFile::remove(this->qfi1_);
//QDir txdbDir((this->qfi2_).toStdString().c_str());
//txdbDir.removeRecursively();
boost::filesystem::remove_all((this->qfi2_).toStdString().c_str());
emit completed();
}
|
#pragma once
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
class CourseData
{
public:
struct Course
{
float grade;
int points;
std::string name;
std::string gradeName;
int id;
};
private:
float CalculateCredential();
std::vector<Course*> courses;
std::string GradeToName(int i);
public:
CourseData();
~CourseData();
bool DeleteCourse(int i);
bool NewCourse(int _grade, int _points, std::string _name);
int count = 0;
Course* GetCourse(int i = -1);
float cred;
char* GetAsSaveData();
bool FromSaveData(std::string dataString);
int GetAmount();
};
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: Bibliotheque.cpp
* Author: emmadevaud
*
* Created on 22 mai 2020, 14:17
*/
#include "Bibliotheque.h"
using namespace std;
//----------------------- Classe Musique ---------------------------------
//Constructeur
Musique :: Musique(){
int i ;
int j ;
for(i=0; i<10; i++){
for(j = 0; j<1024 ; j++)
valeurs[i][j]='\0';
}
BPM=0;
}
// Destructeur
Musique :: ~Musique() {
}
// Assesseurs
void Musique :: set_values(char val[10][UART_BUFFER_SIZE]) {
int i ;
int j ;
for(i=0; i<10; i++){
for(j = 0; j<1024 ; j++)
valeurs[i][j]=val[i][j];
}
}
void Musique :: set_BPM (int bpm){
BPM=bpm ;
}
char* Musique::get_Note(int index){
return valeurs[index];
}
//Redefinition de l'opérateur <<
ostream & operator<<(ostream &os, const Musique& ma_musique){
os << "BPM: " << ma_musique.BPM << endl;
os << "Note: ";
for(int i=0; i<10; i++)
os << ma_musique.valeurs[i] << " ";
os << endl;
return os;
}
// ---------------------- Classe Bibliothèque ----------------------------
// Constructeur
Bibliotheque::Bibliotheque() {
//maBibliotheque["K-Maro-Femme Like U"]="130;
//maBibliotheque["Pascal Obispo-Tombe pour elle"]="120";
//maBibliotheque ["Marc Lavoine-Elle a les yeux revolver"]="80";
}
Bibliotheque :: Exception_biblio :: Exception_biblio(string ch): code(ch){}
string Bibliotheque :: Exception_biblio :: getException_biblio(){
return code;
}
// Fonction qui recherche si la musique reçue est déjà dans la bibliothèque
void Bibliotheque :: MiseAJourBiblio(char musique[UART_BUFFER_SIZE],int bpm,char val[10][UART_BUFFER_SIZE]){
map <string,Musique>::iterator iter_biblio=maBibliotheque.begin();
//Si la bibliothèque est vide j'ajoute la musique directement
if (maBibliotheque.begin()==maBibliotheque.end()){
Musique maMusique=Musique() ;
maMusique.set_values(val);
maMusique.set_BPM(bpm);
maBibliotheque[musique]=maMusique;
cout << "---screen : Ajout de la musique à la bibliothèque -> " << musique << endl;
cout << maMusique;
}else{
// Vérification si la musique est dans la bibliothèque
while ((iter_biblio->first != musique) && (iter_biblio!=maBibliotheque.end())){
iter_biblio++ ;
}
if(iter_biblio->first == musique) //Si elle y est
cout << "---screen : La musique est déjà dans la bibliothèque "<< endl ;
else{ // Si elle n'y est pas après le parcours , je l'ajoute
Musique maMusique=Musique() ;
maMusique.set_values(val);
maMusique.set_BPM(bpm);
maBibliotheque[musique]=maMusique;
cout << "---screen : Ajout de la musique à la bibliothèque -> " << musique << endl;
cout << maMusique;
}
}
}
Musique& Bibliotheque::get_Musique(char* index){
return maBibliotheque[index];
}
//Destructeur
Bibliotheque::~Bibliotheque() {
}
|
#ifndef TEXT_MANAGER_HPP_
#define TEXT_MANAGER_HPP_
#include "TextRendererInterface.h"
#include <unordered_map>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <FTGL/ftgl.h>
class FTGLTextRenderer : public TextRendererInterface {
private:
typedef std::unordered_map<int, FTGLPixmapFont *> FontContainerType;
enum {
MAX_PRINT_SIZE = 1024,
};
public:
FTGLTextRenderer() {}
~FTGLTextRenderer() {
for (auto f : fonts_) {
delete f.second;
}
delete default_font_;
}
void Init() {
default_font_ = new FTGLPixmapFont("ubuntu_mono.ttf");
if (default_font_->Error()) {
throw std::string("Unable to load default font!");
}
default_font_->FaceSize(24);
font_ = default_font_;
}
void Print(int x, int y, const char * fmt, ...) {
glRasterPos2i(x, y);
va_list args;
va_start(args, fmt);
// BUG : Does not working...
Print(fmt, args);
va_end(args);
}
void Print(const char * fmt, ...) {
memset(print_buffer_, 0, MAX_PRINT_SIZE);
va_list args;
va_start(args, fmt);
vsnprintf(print_buffer_, MAX_PRINT_SIZE, fmt, args);
va_end(args);
font_->Render(print_buffer_);
}
void Print(std::string message) {
font_->Render(message.c_str());
}
void UseFont(int index, int size) {
FontContainerType::const_iterator it;
it = fonts_.find(index);
if (it != fonts_.end()) {
font_ = fonts_[index];
}
else {
font_ = default_font_;
}
font_->FaceSize(size);
}
void AddFont(int index, std::string path) {
font_ = new FTGLPixmapFont(path.c_str());
if (font_->Error()) {
throw std::string("Unable to find given font!");
}
fonts_[index] = font_;
}
void AddFont(int index, int font_id) {
// Will not be implemented.
(void)index;
(void)font_id;
}
private:
char print_buffer_[MAX_PRINT_SIZE];
FTGLPixmapFont * font_;
FTGLPixmapFont * default_font_;
FontContainerType fonts_;
};
#endif // TEXT_MANAGER_HPP_
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Robot_part {
protected:
string name;
int model_number;
double cost;
string description;
string image_filename;
public:
Robot_part(string _name, int _model_number, double _cost, string _description) : name{_name}, model_number{_model_number}, cost{_cost},
description{_description} {}
};
//
// ROBOT PARTS
//
class Head : public Robot_part {
private:
double power;
public:
Head(string _name, int _model_number, double _cost, string _description, double _power) : Robot_part(_name,_model_number,_cost,_description), power{_power} {}
};
class Locomotor : public Robot_part {
private:
double max_power;
public:
Locomotor(string _name, int _model_number, double _cost, string _description, double _max_power) : Robot_part(_name,_model_number,_cost,_description), max_power{_max_power} {}
};
class Torso : public Robot_part {
private:
int battery_compartments;
int max_arms;
public:
Torso(string _name, int _model_number, double _cost, string _description, int bat_comp, int _max_arms) : Robot_part(_name,_model_number,_cost,_description), battery_compartments{bat_comp}, max_arms{_max_arms} {}
};
class Battery : public Robot_part {
private:
double power_available;
double max_energy;
public:
Battery(string _name, int _model_number, double _cost, string _description ,double pow_avail, double max_ener) : Robot_part(_name,_model_number,_cost,_description), power_available{pow_avail}, max_energy{max_ener} {}
};
class Arm : public Robot_part {
private:
double max_power;
public:
Arm(string _name, int _model_number, double _cost, string _description, double max_pow) : Robot_part(_name,_model_number,_cost,_description), max_power{max_pow} {}
};
///
/// Robot Model
///
class Robot_model {
private:
string name;
int model_number;
Robot_part torso;
Robot_part head;
Robot_part locomotor;
Robot_part arm;
Robot_part battery;
public:
Robot_model(Robot_part _head, Robot_part _torso, Robot_part _battery, Robot_part _locomotor, Robot_part _arm, string _name, int mod_num) : head{_head}, torso{_torso}, battery{_battery}, locomotor{_locomotor}, arm{_arm}, name{_name}, model_number{mod_num} {}
void robot_info();
double cost();
double max_speed();
double max_battery_life();
};
class Customer {
private:
string name;
int customer_number;
string phone_number;
string email_address;
public:
Customer(string nam, int cust_num, string pho_num, string em_add): name{nam}, customer_number{cust_num}, phone_number{pho_num}, email_address{em_add} {}
};
class Sales_associate {
private:
string name;
int employee_number;
public:
Sales_associate(string nam, int cust_num): name{nam}, employee_number{cust_num} {}
};
class Order {
private:
int order_number;
string date;
Customer customer;
Sales_associate sales_associate;
public:
Order(int o_num, string dat, Customer cust, Sales_associate sales): order_number{o_num}, date{dat}, customer{cust}, sales_associate{sales} {}
double robot_cost();
};
///
/// shop
///
class Shop {
public:
void create_new_robot_part(Robot_part part) { parts.push_back(part);}
void create_new_robot_model(Robot_model model) {models.push_back(model);}
void create_new_customer(Customer cust) {cus.push_back(cust);}
void choose_new_sales_associate(Sales_associate sales) {sale.push_back(sales);}
void create_new_order(Order ord) {ordo.push_back(ord);}
private:
//Order order;
//Customer customer;
//Sales_associate sales_associate;
vector<Robot_part> parts;
vector<Robot_model> models;
vector<Order> ordo;
vector<Sales_associate> sale;
vector<Customer> cus;
};
class Controller {
private:
Shop shop;
public:
void execute(); //kind of like a view class
void create_new_robot_model();
void create_new_robot_parts();
void pre_defined_models();
void create_order();
void choose_sales_assoc();
void create_customer();
};
void Controller::execute() {
int choice;
cout << "\nWhat would you like to do?\n\n"<<"(0) Create new robot parts\n" << "(1) Create new robot model\n" << "(2) Choose pre-made bots\n" << "(3) Create new customer\n" << "(4) Create new Sales associate\n" << "(5) Create new Order\n" << "(#) insert any other number to quit\n" << "Option: ";
cin >> choice;
if (choice == 0) {
create_new_robot_parts();
}
else if(choice == 1) {
create_new_robot_model();
}
else if(choice == 2) {
pre_defined_models();
}
else if(choice == 3) {
create_customer();
}
else if(choice == 4) {
choose_sales_assoc();
}
else if(choice == 5) {
create_order();
}
else {
cout << "Exiting Program...\n";
exit(0);
}
execute(); //recursion, loop won't repeat print statement
}
void Controller::create_customer() {
string name, phone_number, email_address;
int customer_number = rand() % 100;
cout << "Your customer number is " << customer_number <<".\n\n";
cout << "What is your full name?";
getline(cin,name);
cout << "What is your phone number?";
getline(cin,phone_number);
cout << "What is your email address?";
getline(cin,email_address);
shop.create_new_customer(Customer(name,customer_number,phone_number,email_address));
}
void Controller::choose_sales_assoc() {
int mavs;
Sales_associate employ1("Dirk Nowitzki",1);
Sales_associate employ2("Jason Terry",2);
Sales_associate employ3("Jason Kidd",3);
Sales_associate employ4("Steve Nash",4);
cout << "(1) Dirk Nowitzki\n(2) Jason Terry\n(3) Jason Kidd\n(4) Steve Nash\n";
cout << "Which sales associate would you like to help you? ";
cin >> mavs;
switch(mavs) {
case(1):
shop.choose_new_sales_associate(employ1);
cout << "Successfully Choosen.\n";
break;
case(2):
shop.choose_new_sales_associate(employ2);
cout << "Successfully Choosen.\n";
break;
case(3):
shop.choose_new_sales_associate(employ3);
cout << "Successfully Choosen.\n";
break;
case(4):
shop.choose_new_sales_associate(employ4);
cout << "Successfully Choosen.\n";
break;
default:
cout << "Invalid input.\n";
break;
}
}
void Controller::create_order() {
int choice;
string date,name,phone_number,email_address;
int order_number = rand() % 1000;
int customer_number = rand() % 100;
Customer custom("a",0,"a","a"); //Initializing to change later
Sales_associate employ("h",0); //Initializing to change later
cout << "Your order number is " << order_number <<'\n';
cout << "Enter the current date: ";
getline(cin,date);
cout << "Your customer number is " << customer_number <<".\n\n";
cout << "What is your full name?";
getline(cin,name);
cout << "What is your phone number?"; //////CREATES CUSTOMER FOR ORDER
getline(cin,phone_number);
cout << "What is your email address?";
getline(cin,email_address);
custom = Customer(name,customer_number,phone_number,email_address);
cout << "(1) Dirk Nowitzki\n(2) Jason Terry\n(3) Jason Kidd\n(4) Steve Nash\n";
cout << "Which sales associate would you like to help you? "; ///CHOOSE SALE ASSOCIATE
cin >> choice;
switch(choice) {
case(1):
employ = Sales_associate("Dik Nowitzki",1);
cout << "Successfully Choosen.\n";
break;
case(2):
employ = Sales_associate("Jason Terry",2);
cout << "Successfully Choosen.\n";
break;
case(3):
employ = Sales_associate("Jason Kidd",3);
cout << "Successfully Choosen.\n";
break;
case(4):
employ = Sales_associate("Steve Nash",4);
cout << "Successfully Choosen.\n";
break;
default:
cout << "Invalid input.\n";
break;
}
Order _order(order_number,date,custom,employ);
}
void Controller::pre_defined_models() {
int choice;
Head head1("Basic Head",100,100.00,"basic bot",50.0);
Torso torso1("Basic Torso",100,100.00,"basicbot",2,1);
Battery battery1("Basic Battery",100,100.00,"basic bot",50.0,100.0);
Locomotor locomotor1("Basic Locomotor",100,100.00,"basic bot",50.0);
Arm arm1("Basic Arm",100,100.00,"basic bot",50.0);
Head head2("Advanced Head",200,1000.00,"advanced bot",250.0);
Torso torso2("Advanced Torso",200,1000.00,"advanced bot",5,2);
Battery battery2("Advanced Battery",200,1000.00,"advanced bot",250.0,450.0);
Locomotor locomotor2("Advanced Locomotor",200,1000.00,"advanced bot",250.0);
Arm arm2("Advanced Arm",200,1000.00,"advanced bot",250.0);
Head head3("Deluxe Head",300,10000.00,"Deluxe bot",500.0);
Torso torso3("Deluxe Torso",300,10000.00,"Deluxe bot",10,4);
Battery battery3("Deluxe Battery",300,10000.00,"Deluxe bot",500.0,750.0);
Locomotor locomotor3("Deluxe Locomotor",300,10000.00,"Deluxe bot",500.0);
Arm arm3("Deluxe Arm",300,10000.00,"Deluxe bot",500.0);
cout << "Which robot would you like?\n(0)Basic Bot\n(1)Advanced Bot\n(2)Deluxe Bot\n";
cin >> choice;
if(choice == 0) {
Robot_model bbot(head1, torso1, battery1, locomotor1, arm1,"Basic bot",1);
cout << "Successfully Chosen Basic bot.\n";
}
else if(choice == 1) {
Robot_model abot(head2, torso2, battery2, locomotor2, arm2,"Advanced bot",2);
cout << "Successfully Chosen Advanced bot.\n";
}
else if(choice == 2) {
Robot_model dbot(head3, torso3, battery3, locomotor3, arm3,"Deluxe bot",3);
cout << "Successfully Chosen Deluxe bot.\n";
}
}
void Controller::create_new_robot_parts() {
string name, input;
int model_number, bat_compart, num_arms, get_out; //get_out is to break the loop
double cost, power,max_energy;
string description;
cout << "\n\n(0) quit\n(1) head\n(2) torso\n(3) battery\n(4) locomotor\n(5) arm\nEnter one of the choices: ";
cin >> get_out;
while(get_out != 0) {
cin.ignore(); //consumes \n
switch(get_out) {
case(1): {
cout << "Enter the name of the head: ";
getline(cin,name);
cout << "Enter the desired model number: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the part: ";
getline(cin,description);
cout << "How much power do you want your head to have?\n";
cin >> power;
cin.ignore();
cost = 1000;
cout << "Cost for all custom heads is $" << cost << " NON-NEGOTIABLE\n";
shop.create_new_robot_part(Head(name,model_number,cost,description,power));
cout << "Successfully created " << name <<'\n';
break;
}
case(2): {
cout << "Enter the name of the torso: ";
getline(cin,name);
cout << "Enter the desired model number: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the part: ";
getline(cin,description);
cout << "How many arms do you want your robot to have?\n";
cin >> num_arms;
cin.ignore();
cout << "How many battery compartments do you want your robot to have?\n";
cin >> bat_compart;
cin.ignore();
cost = 2000;
cout << "Cost for all custom torsos is $" << cost << " NON-NEGOTIABLE\n";
shop.create_new_robot_part(Torso(name,model_number,cost,description,bat_compart,num_arms));
cout << "Successfully created " << name <<'\n';
break;
}
case(3): {
cout << "Enter the name of the battery: ";
getline(cin,name);
cout << "Enter the desired model number: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the part: ";
getline(cin,description);
cout << "How much power do you want your battery to have?\n";
cin >> power;
cin.ignore();
cout << "What is the max energy you want to put on your battery?\n";
cin >> max_energy;
cin.ignore();
cost = 1000;
cout << "Cost for all custom batteries is $" << cost << " NON-NEGOTIABLE\n";
shop.create_new_robot_part(Battery(name,model_number,cost,description,power,max_energy));
cout << "Successfully created " << name <<'\n';
break;
}
case(4): {
cout << "Enter the name of the locomotor: ";
getline(cin,name);
cout << "Enter the desired model number: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the part: ";
getline(cin,description);
cout << "What is the max power you want to put on your locomotor?\n";
cin >> power;
cin.ignore();
cost = 3000;
cout << "Cost for all custom locomotors is $" << cost << " NON-NEGOTIABLE\n";
shop.create_new_robot_part(Locomotor(name,model_number,cost,description,power));
cout << "Successfully created " << name <<'\n';
break;
}
case(5): {
cout << "Enter the name of the arms: ";
getline(cin,name);
cout << "Enter the desired model number: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the part: ";
getline(cin,description);
cout << "What is the max power you want to put on your arms?\n";
cin >> power;
cin.ignore();
cost = 1000;
cout << "Cost for all custom arms is $" << cost << "each NON-NEGOTIABLE\n";
shop.create_new_robot_part(Arm(name,model_number,cost,description,power));
cout << "Successfully created " << name <<'\n';
break;
}
default: {
cout<<"\nWould you like to continue adding parts?\n\n(0) quit\n(1) head\n(2) torso\n(3) battery\n(4) locomotor\n(5) arm\nEnter one of the choices: ";
cin >> get_out;
}
}
cout<<"\nWould you like to continue adding parts?\n\n(0) quit\n(1) head\n(2) torso\n(3) battery\n(4) locomotor\n(5) arm\nEnter one of the choices: ";
cin >> get_out;
}
//end of loop
}
void Controller::create_new_robot_model() {
string name, input;
int model_number, bat_compart, num_arms, get_out = 1;
double cost, power,max_energy;
string description;
Head head("Head",1,1.00,"Head",1.0);
Torso torso("Torso",1,1.00,"Torso",1,1);
Battery battery("Battery",1,1.00,"Battery",1.0,1.0);
Locomotor locomotor("Locomotor",1,1.00,"Locomotor",1.0);
Arm arm("Arm",1,1.00,"Arm",1.0);
while(get_out != 0) {
switch(get_out) {
case(1): {
cout << "Enter the desired model number for the head: ";
cin >> model_number;
cin.ignore();
cout << "Enter the name of the head: ";
getline(cin,name);
cout << "Enter a description of the head: ";
getline(cin,description);
cout << "How much power do you want your head to have?\n";
cin >> power;
cin.ignore();
cost = 1000;
cout << "Cost for all custom heads is $" << cost << " NON-NEGOTIABLE\n";
head = Head(name,model_number,cost,description,power);
cout << "Successfully created " << name <<'\n';
}
case(2): {
cout << "\nEnter the name of the torso: ";
getline(cin,name);
cout << "Enter the desired model number for the torso: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the torso: ";
getline(cin,description);
cout << "How many arms do you want your robot to have?\n";
cin >> num_arms;
cin.ignore();
cout << "How many battery compartments do you want your robot to have?\n";
cin >> bat_compart;
cin.ignore();
cost = 2000;
cout << "Cost for all custom torsos is $" << cost << " NON-NEGOTIABLE\n";
torso = Torso(name,model_number,cost,description,bat_compart,num_arms);
cout << "Successfully created " << name <<'\n';
}
case(3): {
cout << "\nEnter the name of the battery: ";
getline(cin,name);
cout << "Enter the desired model number for your battery: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the battery: ";
getline(cin,description);
cout << "How much power do you want your battery to have?\n";
cin >> power;
cin.ignore();
cout << "What is the max energy you want to put on your battery?\n";
cin >> max_energy;
cin.ignore();
cost = 1000;
cout << "Cost for all custom batteries is $" << cost << " NON-NEGOTIABLE\n";
battery = Battery(name,model_number,cost,description,power,max_energy);
cout << "Successfully created " << name <<'\n';
}
case(4): {
cout << "\nEnter the name of the locomotor: ";
getline(cin,name);
cout << "Enter the desired model number for the locomotor: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the locomotor: ";
getline(cin,description);
cout << "What is the max power you want to put on your locomotor?\n";
cin >> power;
cin.ignore();
cost = 3000;
cout << "Cost for all custom locomotors is $" << cost << " NON-NEGOTIABLE\n";
locomotor = Locomotor(name,model_number,cost,description,power);
cout << "Successfully created " << name <<'\n';
}
case(5): {
cout << "\nEnter the name of the arms: ";
getline(cin,name);
cout << "Enter the desired model numbe for the arms: ";
cin >> model_number;
cin.ignore();
cout << "Enter a description of the arms: ";
getline(cin,description);
cout << "What is the max power you want to put on your arms?\n";
cin >> power;
cin.ignore();
cost = 1000;
cout << "Cost for all custom arms is $" << cost << "each NON-NEGOTIABLE\n";
arm = Arm(name,model_number,cost,description,power);
cout << "Successfully created " << name <<'\n';
}
default: {
cout << "\nWhat is the model_number of this robot?";
cin >> model_number;
cin.ignore();
cout << "What is the name of this robot?";
getline(cin,name);
Robot_model robot_model(head, torso, battery, locomotor, arm,name,model_number);
shop.create_new_robot_model(robot_model);
cout << "Successfully created robot.\n";
cout<<"\nWould you like to continue adding models?\n\n(0) quit\n(1) continue\n";
cin >> get_out;
}
}
}
}
int main() {
Controller controller;
controller.execute();
}
|
#include "libretro.h"
#include <windows.h>
static HMODULE h;
static void (*pretro_set_environment)(retro_environment_t);
void retro_set_environment(retro_environment_t p)
{
pretro_set_environment(p);
}
static void (*pretro_set_video_refresh)(retro_video_refresh_t);
void retro_set_video_refresh(retro_video_refresh_t p)
{
pretro_set_video_refresh(p);
}
static void (*pretro_set_audio_sample)(retro_audio_sample_t);
void retro_set_audio_sample(retro_audio_sample_t p)
{
pretro_set_audio_sample(p);
}
static void (*pretro_set_audio_sample_batch)(retro_audio_sample_batch_t);
void retro_set_audio_sample_batch(retro_audio_sample_batch_t p)
{
pretro_set_audio_sample_batch(p);
}
static void (*pretro_set_input_poll)(retro_input_poll_t);
void retro_set_input_poll(retro_input_poll_t p)
{
pretro_set_input_poll(p);
}
static void (*pretro_set_input_state)(retro_input_state_t);
void retro_set_input_state(retro_input_state_t p)
{
pretro_set_input_state(p);
}
static void (*pretro_init)(void);
void retro_init(void)
{
pretro_init();
}
static void (*pretro_deinit)(void);
void retro_deinit(void)
{
pretro_deinit();
FreeLibrary(h);
}
static unsigned (*pretro_api_version)(void);
unsigned retro_api_version(void)
{
return pretro_api_version();
}
static void (*pretro_get_system_info)(struct retro_system_info *info);
void retro_get_system_info(struct retro_system_info *info)
{
pretro_get_system_info(info);
}
static void (*pretro_get_system_av_info)(struct retro_system_av_info *info);
void retro_get_system_av_info(struct retro_system_av_info *info)
{
pretro_get_system_av_info(info);
}
static void (*pretro_set_controller_port_device)(unsigned port, unsigned device);
void retro_set_controller_port_device(unsigned port, unsigned device)
{
pretro_set_controller_port_device(port, device);
}
static void (*pretro_reset)(void);
void retro_reset(void)
{
pretro_reset();
}
static void (*pretro_run)(void);
void retro_run(void)
{
pretro_run();
}
static size_t (*pretro_serialize_size)(void);
size_t retro_serialize_size(void)
{
return pretro_serialize_size();
}
static bool (*pretro_serialize)(void *data, size_t size);
bool retro_serialize(void *data, size_t size)
{
return pretro_serialize(data, size);
}
static bool (*pretro_unserialize)(const void *data, size_t size);
bool retro_unserialize(const void *data, size_t size)
{
return pretro_unserialize(data, size);
}
static void (*pretro_cheat_reset)(void);
void retro_cheat_reset(void)
{
pretro_cheat_reset();
}
static void (*pretro_cheat_set)(unsigned index, bool enabled, const char *code);
void retro_cheat_set(unsigned index, bool enabled, const char *code)
{
pretro_cheat_set(index, enabled, code);
}
static bool (*pretro_load_game)(const struct retro_game_info *game);
bool retro_load_game(const struct retro_game_info *game)
{
return pretro_load_game(game);
}
static bool (*pretro_load_game_special)(unsigned game_type, const struct retro_game_info *info, size_t num_info);
bool retro_load_game_special(unsigned game_type, const struct retro_game_info *info, size_t num_info)
{
return pretro_load_game_special(game_type, info, num_info);
}
static void (*pretro_unload_game)(void);
void retro_unload_game(void)
{
pretro_unload_game();
}
static unsigned (*pretro_get_region)(void);
unsigned retro_get_region(void)
{
return pretro_get_region();
}
static void* (*pretro_get_memory_data)(unsigned id);
void* retro_get_memory_data(unsigned id)
{
return pretro_get_memory_data(id);
}
static size_t (*pretro_get_memory_size)(unsigned id);
size_t retro_get_memory_size(unsigned id)
{
return pretro_get_memory_size(id);
}
bool retro_load()
{
h=LoadLibraryW(L"retro.dll");
if (!h) return false;
#define die() do { FreeLibrary(h); return false; } while(0)
#define libload(name) GetProcAddress(h, name)
#ifdef __GNUC__
#define load(name) if (!(p##name=(__typeof(p##name))libload(#name))) die()//shut up about that damn type punning
#else
#define load(name) if (!(*(void**)(&p##name)=(void*)libload(#name))) die()
#endif
load(retro_set_environment);
load(retro_set_video_refresh);
load(retro_set_audio_sample);
load(retro_set_audio_sample_batch);
load(retro_set_input_poll);
load(retro_set_input_state);
load(retro_init);
load(retro_deinit);
load(retro_api_version);
load(retro_get_system_info);
load(retro_get_system_av_info);
load(retro_set_controller_port_device);
load(retro_reset);
load(retro_run);
load(retro_serialize_size);
load(retro_serialize);
load(retro_unserialize);
load(retro_cheat_reset);
load(retro_cheat_set);
load(retro_load_game);
load(retro_load_game_special);
load(retro_unload_game);
load(retro_get_region);
load(retro_get_memory_data);
load(retro_get_memory_size);
if (retro_api_version()!=RETRO_API_VERSION) die();
return true;
}
|
class CommonAmerica : CommonBlufor {
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "" };
backpack[] = { "" };
primary[] = { "" };
secondary[] = { "" };
launcher[] = { "" };
magazines[] = { "" };
items[] = { "ACE_EarPlugs",1 };
binoculars[] = { "" };
compass[] = { "ItemCompass" };
goggles[] = { "" };
gps[] = { "" };
headgear[] = { "" };
map[] = { "" };
nvgs[] = { "rhsusf_ANPVS_14" };
watch[] = { "" };
};
class US_ARMY_PL : CommonAmerica {
};
class US_NAVY_ADM : CommonAmerica { // Admiral
uniform[] = { "FUTARM_U_BASIC_MT" };
vest[] = { "usm_vest_safety" };
backpack[] = { "" };
primary[] = { "" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",4,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2};
lrradios[] = {"ACRE_PRC148", "ACRE_PRC148"};
binoculars[] = { "rhs_pdu4" };
compass[] = { "ItemCompass" };
goggles[] = { "" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "FUTARM_H_MILCAP_MT" };
map[] = { "ItemMap" };
nvgs[] = { "" };
watch[] = { "ACE_Altimeter" };
};
class US_NAVY_RADM : US_NAVY_ADM { // Rear Admiral
gps[] = {"B_EasyTrack_Tablet"};
};
class US_MARINES_PL : CommonAmerica { // Marines [Platoon Leader]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "TFA_PlateCarrierH_fol" };
backpack[] = { "" };
primary[] = { "rhs_weap_m4a1_d_mstock","rhsusf_acc_anpeq15side","rhsusf_acc_eotech_552_d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk262_Stanag",8,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",5,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2,"rhs_mag_m18_green",3,"rhs_mag_m18_purple",3,"rhs_mag_m18_red",3};
lrradios[] = {"ACRE_PRC148", "ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_mich_helmet_marpatwd_norotos_arc_headset" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_JTAC : CommonAmerica { // Marines [Joint Terminal Attack Controller]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "rhsusf_spc_patchless_radio" };
backpack[] = { "B_Carryall_cbr" };
primary[] = { "rhs_weap_m4a1_m203s_d","rhsusf_acc_anpeq15side","optic_ERCO_snd_F" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk262_Stanag",8,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",6,"ACE_fieldDressing",6,"ACE_packingBandage",6,"ACE_tourniquet",2,"rhs_mag_m18_green",5,"rhs_mag_m18_purple",5,"rhs_mag_m18_red",5,"rhs_mag_m661_green",8,"rhs_mag_m662_red",8,"rhs_mag_m713_Red",5,"rhs_mag_m714_White",5,"rhs_mag_m715_Green",5,"rhs_mag_m716_yellow",5,"Laserdesignator_03",1,"Laserbatteries",3 };
lrradios[] = {"ACRE_PRC148", "ACRE_PRC148"};
binoculars[] = { "ACE_Vector" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_mich_helmet_marpatwd_norotos_arc_headset" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_SQL : CommonAmerica { // Marines [Squad Leader]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "rhsusf_spc_squadleader" };
backpack[] = { "" };
primary[] = { "rhs_weap_m4a1_d_mstock","rhsusf_acc_anpeq15side","rhsusf_acc_eotech_552_d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk262_Stanag",8,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot", 3, "ACE_fieldDressing", 4, "ACE_packingBandage", 4, "ACE_tourniquet", 2, "rhs_mag_m18_green", 1, "rhs_mag_m18_red", 1 };
lrradios[] = {"ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_mich_helmet_marpatwd_norotos_arc_headset" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_FTL : CommonAmerica { // Marines [Fire Team Leader]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "rhsusf_spc_squadleader" };
backpack[] = { "" };
primary[] = { "rhs_weap_mk18_KAC_wd","optic_ACO_grn" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk262_Stanag",8,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",3,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2,"rhs_mag_m18_green",1,"rhs_mag_m18_red",1};
binoculars[] = { "" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Bandanna_sport" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_opscore_ut_pelt_nsw_cam" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_ARM : CommonAmerica { // Marines [Automatic Rifleman]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "rhsusf_spc_iar" };
backpack[] = { "" };
primary[] = { "rhs_weap_m249_pip_L_vfg","rhsusf_acc_eotech_552" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhsusf_200Rnd_556x45_soft_pouch",3,"rhsusf_mag_7x45acp_MHP",2 };
items[] += { "ACE_quikclot",3,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2,"rhs_mag_m18_green",1};
binoculars[] = { "" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Bandanna_sport" };
gps[] = { "" };
headgear[] = { "rhsusf_opscore_ut_pelt_nsw_cam" };
map[] = { "" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_GND : CommonAmerica { // Marines [Grenadier]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "rhsusf_spc_teamleader" };
backpack[] = { "" };
primary[] = { "rhs_weap_m32" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhsusf_mag_6Rnd_M397_HET",6,"rhsusf_mag_7x45acp_MHP",2 };
items[] += { "ACE_quikclot", 3,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2,"rhs_mag_m18_green",1};
binoculars[] = { "" };
compass[] = { "ItemCompass" };
goggles[] = { "" };
gps[] = { "" };
headgear[] = { "rhsusf_opscore_ut_pelt_nsw_cam" };
map[] = { "" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_RFL : CommonAmerica { // Marines [Rifleman]
uniform[] = { "rhs_uniform_FROG01_wd" };
vest[] = { "rhsusf_spc_light" };
backpack[] = { "B_Carryall_oli" };
primary[] = { "rhs_weap_hk416d10_LMT","rhsusf_acc_anpeq15side","rhsusf_acc_eotech_552_d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk262_Stanag",8,"rhsusf_mag_7x45acp_MHP",2, "rhsusf_200Rnd_556x45_soft_pouch", 4 };
items[] += { "ACE_quikclot",3,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2,"rhs_mag_m18_green",1};
binoculars[] = { "" };
compass[] = { "ItemCompass" };
goggles[] = { "" };
gps[] = { "" };
headgear[] = { "rhsusf_opscore_ut_pelt_nsw_cam" };
map[] = { "" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_WSL : CommonAmerica { // Marines [Weapon Squad Leader]
uniform[] = { "rhs_uniform_g3_m81" };
vest[] = { "V_PlateCarrierSpec_rgr" };
backpack[] = { "B_TacticalPack_oli" };
primary[] = { "rhs_weap_hk416d145","rhsusf_acc_anpeq15side","optic_ERCO_blk_F","rhs_acc_grip_ffg2" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk318_Stanag",22,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",3,"ACE_fieldDressing",4,"ACE_packingBandage",4,"ACE_tourniquet",2,"rhs_mag_m18_green",1,"rhs_mag_m18_red",1 };
lrradios[] = {"ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_ach_bare_semi_headset" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_MG : CommonAmerica { // Marines [Heavy Machine Gunner]
uniform[] = { "rhs_uniform_g3_m81" };
vest[] = { "V_PlateCarrierSpec_tna_F" };
backpack[] = { "rhssaf_kitbag_smb" };
primary[] = { "MMG_01_tan_F","rhsusf_acc_EOTECH","bipod_01_F_snd" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "150Rnd_93x64_Mag",4,"rhsusf_mag_7x45acp_MHP",2 };
items[] += { "ACE_quikclot", 3,"ACE_fieldDressing",3,"ACE_packingBandage",3,"ACE_tourniquet",2,"rhs_mag_m18_green",1 };
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "ffaa_Glasses" };
gps[] = { "" };
headgear[] = { "ffaa_moe_casco_02_2_b" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_AMG : CommonAmerica { // Marines [Assistant Heavy Machine Gunner]
uniform[] = { "rhs_uniform_g3_m81" };
vest[] = { "V_PlateCarrierSpec_tna_F" };
backpack[] = { "rhssaf_kitbag_smb" };
primary[] = { "rhs_weap_mk18_KAC_wd","optic_ERCO_khk_F" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk318_Stanag",12,"rhsusf_mag_7x45acp_MHP",3,"150Rnd_93x64_Mag",3 };
items[] += { "ACE_quikclot",3,"ACE_fieldDressing",3,"ACE_packingBandage",3,"ACE_tourniquet",2,"rhs_mag_m18_green",1 };
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "ffaa_Glasses" };
gps[] = { "" };
headgear[] = { "ffaa_moe_casco_02_2_b" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_SPEC_AT : CommonAmerica { // Marines [AT Specialist]
uniform[] = { "rhs_uniform_g3_m81" };
vest[] = { "V_PlateCarrierSpec_tna_F" };
backpack[] = { "rhssaf_kitbag_smb" };
primary[] = { "rhs_weap_mk18_KAC_wd","optic_ERCO_khk_F" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "launch_O_Titan_short_ghex_F" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk318_Stanag",7,"rhsusf_mag_7x45acp_MHP",3,"Titan_AT",3 };
items[] += { "ACE_quikclot",3,"ACE_fieldDressing",3,"ACE_packingBandage",3,"ACE_tourniquet",2,"rhs_mag_m18_green",1 };
binoculars[] = { "" };
compass[] = { "ItemCompass" };
goggles[] = { "ffaa_Glasses" };
gps[] = { "" };
headgear[] = { "ffaa_moe_casco_02_2_b" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_MARINES_SPEC_AT_ASS : CommonAmerica { // Marines [Assistant AT Specialist]
uniform[] = { "rhs_uniform_g3_m81" };
vest[] = { "V_PlateCarrierSpec_tna_F" };
backpack[] = { "rhssaf_kitbag_smb" };
primary[] = { "rhs_weap_mk18_KAC_wd","optic_ERCO_khk_F" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk318_Stanag",6,"rhsusf_mag_7x45acp_MHP",3,"Titan_AT",2 };
items[] += { "ACE_quikclot",3,"ACE_fieldDressing",3,"ACE_packingBandage",3,"ACE_tourniquet",2,"rhs_mag_m18_green",1 };
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "ffaa_Glasses" };
gps[] = { "" };
headgear[] = { "ffaa_moe_casco_02_2_b" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
class US_NAVY_JPLT : CommonAmerica { // Navy [Jet Pilot]
uniform[] = { "U_B_PilotCoveralls" };
vest[] = { "TFA_PlateCarrierH_fol" };
backpack[] = { "ACE_NonSteerableParachute" };
primary[] = { "" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",6,"ACE_fieldDressing",6,"ACE_packingBandage",6,"ACE_tourniquet",2,"rhs_mag_m18_purple",4,"ACE_microDAGR" };
lrradios[] = {"ACRE_PRC148", "ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "H_PilotHelmetFighter_B" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
preLoadout = "(_this select 0) setVariable [""ACE_GForceCoef"", 0]";
};
class US_ARMY_PLT : CommonAmerica { // Army Pilot with HGU-56P (AH-64D Apache ready)
uniform[] = { "rhs_uniform_g3_tan" };
vest[] = { "V_TacVest_khk" };
backpack[] = { "" };
primary[] = { "rhs_weap_m4a1_blockII_d", "rhsusf_acc_eotech_552_d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_M855A1_Stanag",5,"rhsusf_mag_7x45acp_MHP",3 };
items[] = { "ACE_packingBandage",6,"ACE_quikclot",6, "ACE_tourniquet",2,"rhs_mag_m18_purple",4 };
lrradios[] = {"ACRE_PRC148", "ACRE_PRC148"};
binoculars[] = { "lerca_1200_tan" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "b_EasyTrack_PDA" };
headgear[] = { "rhsusf_hgu56p" };
map[] = { "ItemMap" };
nvgs[] = { "rhsusf_ANPVS_14" };
watch[] = { "ACE_Altimeter" };
preLoadout = "(_this select 0) setVariable [""ACE_GForceCoef"", 0]";
};
class US_NAVY_MPLT : CommonAmerica { // Air Medavac Pilot
uniform[] = { "rhs_uniform_g3_tan" };
vest[] = { "V_PlateCarrier1_rgr" };
backpack[] = { "ACE_NonSteerableParachute" };
primary[] = { "rhsusf_weap_MP7A2_desert", "optic_Aco" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhsusf_mag_40Rnd_46x30_AP",10,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"ACE_quikclot",6,"ACE_fieldDressing",6,"ACE_packingBandage",6,"ACE_tourniquet",2,"ACE_microDAGR"};
lrradios[] = {"ACRE_PRC148", "ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_hgu56p" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
preLoadout = "(_this select 0) setVariable [""ACE_GForceCoef"", 0]";
};
class US_NAVY_MEDIC : CommonAmerica { // Navy Medic
uniform[] = { "rhs_uniform_g3_rgr" };
vest[] = { "V_PlateCarrier2_rgr" };
backpack[] = { "B_Carryall_oli" };
primary[] = { "rhs_weap_m4a1_blockII_KAC_wd", "rhsusf_acc_anpeq15side", "rhsusf_acc_eotech_552_d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk318_Stanag",8,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {"W_Defibrillator",1, "ACE_surgicalKit","ACE_fieldDressing",24,"ACE_elasticBandage",24,"ACE_quikclot",24,"ACE_packingBandage",24, "ACE_bloodIV",12, "ACE_epinephrine",22, "ACE_morphine", 22, "ACE_tourniquet", 8, "rhs_mag_m18_green", 4 };
lrradios[] = {"ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_mich_bare_alt_semi" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
preLoadout = "(_this select 0) setVariable [""ACE_medical_medicClass"", 2, true]";
};
class US_NAVY_PARAM : CommonAmerica { // Navy Paramedic
uniform[] = { "rhs_uniform_g3_rgr" };
vest[] = { "V_PlateCarrier1_rgr" };
backpack[] = { "" };
primary[] = { "rhs_weap_m4a1_blockII_KAC_wd", "rhsusf_acc_anpeq15side", "rhsusf_acc_eotech_552_d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhs_mag_30Rnd_556x45_Mk318_Stanag",8,"rhsusf_mag_7x45acp_MHP",2 };
items[] += { "ACE_fieldDressing", 6, "ACE_elasticBandage", 6, "ACE_quikclot", 6, "ACE_packingBandage", 6, "ACE_bloodIV", 2, "ACE_epinephrine", 8, "ACE_morphine", 8, "ACE_tourniquet", 4, "rhs_mag_m18_green", 3};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_mich_bare_alt_semi" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
preLoadout = "(_this select 0) setVariable [""ACE_medical_medicClass"", 1, true]";
};
class US_NAVY_AMCQSEC : CommonAmerica { // Air Medevac Perimeter Security
uniform[] = { "rhs_uniform_g3_tan" };
vest[] = { "V_PlateCarrier1_rgr" };
backpack[] = { "ACE_NonSteerableParachute" };
primary[] = { "rhs_weap_m240G", "rhsusf_acc_ACOG2_3d" };
secondary[] = { "rhsusf_weap_m1911a1" };
launcher[] = { "" };
magazines[] = { "rhsusf_100Rnd_762x51_m80a1epr",4,"rhsusf_mag_7x45acp_MHP",2 };
items[] += {};
lrradios[] = {"ACRE_PRC148"};
binoculars[] = { "Binocular" };
compass[] = { "ItemCompass" };
goggles[] = { "G_Aviator" };
gps[] = { "B_EasyTrack_PDA" };
headgear[] = { "rhsusf_hgu56p_mask" };
map[] = { "ItemMap" };
watch[] = { "ACE_Altimeter" };
};
|
/*
Petar 'PetarV' Velickovic
Algorithm: Merge Sort
*/
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <complex>
#define MAX_N 1000001
using namespace std;
typedef long long lld;
int n;
int niz[MAX_N], tmp[MAX_N];
//Merge sort algoritam za sortiranje niza
//Slozenost: O(n log n)
inline void merge(int left, int mid, int right)
{
int h,i,j,k;
h = left;
i = left;
j = mid+1;
while (h <= mid && j <= right)
{
if (niz[h] <= niz[j])
{
tmp[i] = niz[h];
h++;
}
else
{
tmp[i] = niz[j];
j++;
}
i++;
}
if (h > mid)
{
for(k=j;k<=right;k++)
{
tmp[i] = niz[k];
i++;
}
}
else
{
for(k=h;k<=mid;k++)
{
tmp[i] = niz[k];
i++;
}
}
for(k=left;k<=right;k++) niz[k] = tmp[k];
}
void mergeSort(int left, int right)
{
if (left == right) return;
int MID = (left+right)/2;
mergeSort(left, MID);
mergeSort(MID+1, right);
merge(left, MID, right);
}
int main()
{
n = 5;
niz[0] = 4;
niz[1] = 2;
niz[2] = 5;
niz[3] = 1;
niz[4] = 3;
mergeSort(0, n-1);
for (int i=0;i<n;i++) printf("%d ",niz[i]);
printf("\n");
return 0;
}
|
#ifndef _ICOSAHEDRON_H_
#define _ICOSAHEDRON_H_
#include <vector>
#define _USE_MATH_DEFINES
#include <cmath>
#include "g_Vector.h"
#define ICOSAHEDRON_EPSILON 1e-5
class Icosahedron {
protected:
int d_q; // frequency of tesselation
// offset for coordinates
g_Vector d_offset;
double d_radius;
int d_maxLevels, d_maxVert;
g_Vector d_rot[3];
bool d_rotate;
public:
inline Icosahedron( int q, g_Vector offset=g_Vector(), double radius=1.0 );
inline void setRotation( g_Vector orientation );
inline int generateTesselation(std::vector<g_Vector>& vertices, std::vector<g_Vector>& normals, double z_min=-1e9 );
};
Icosahedron::Icosahedron( int q, g_Vector offset, double radius ) :
d_q(q), d_offset(offset), d_radius(radius), d_rotate(false) {
d_maxLevels = 1 << q;
// maximum number of points per horizontal circle
d_maxVert = 5 * d_maxLevels;
// Correct maxLevels by one
d_maxLevels++;
// number of points
int n = 10 * ( 1 << q ) * ( 1 << q ) + 2;
}
/*
* Expects the direction, i.e., orientation of the probe
*/
void Icosahedron::setRotation( g_Vector orientation ) {
// new z-axis
orientation.Normalize();
// calculate rotation axis
g_Vector r(-orientation.y(), orientation.x(), 0.0 );
if ( r.Length() < ICOSAHEDRON_EPSILON ) {
if ( orientation.z() <= -1.0 + ICOSAHEDRON_EPSILON ) {
// flip the z and x-axis
d_rot[0] = g_Vector( -1.0, 0.0, 0.0 );
d_rot[1] = g_Vector( 0.0, 1.0, 0.0 );
d_rot[2] = g_Vector( 0.0, 0.0, -1.0 );
d_rotate = true;
return;
} else {
d_rotate = false;
return;
}
}
r.Normalize();
g_Vector ry = orientation.Cross(r);
d_rot[0].Set( r.x(), ry.x(), orientation.x() );
d_rot[1].Set( r.y(), ry.y(), orientation.y() );
d_rot[2].Set( r.z(), ry.z(), orientation.z() );
d_rotate = true;
}
int Icosahedron::generateTesselation(std::vector<g_Vector>& vertices, std::vector<g_Vector>& normals, double depth ) {
int totalLevels = d_maxLevels + 2 * (d_maxVert/5);
int noVert = 1;
double elevationStep = M_PI / ( totalLevels - 1 );
double elevation = M_PI/2;
double orientOffset = 0;
for ( int level = 0; level < totalLevels; level++ ) {
double z = d_radius * sin(elevation);
if ( d_radius - depth > z ) return vertices.size();
double cosE = d_radius * cos(elevation);
// Generate vertices for the current level
for ( int i=0; i<noVert; ++i ) {
// elevation
double azimuth = 2.0*M_PI *((double)i+orientOffset)/((double)noVert);
double y = cosE * sin(azimuth);
double x = cosE * cos(azimuth);
if ( d_rotate ) {
g_Vector pos(x,y,z);
vertices.push_back(g_Vector(d_offset.x()+pos.Dot( d_rot[0] ),d_offset.y()+pos.Dot( d_rot[1] ),d_offset.z()+pos.Dot( d_rot[2] )));
g_Vector norm(-x,-y, -z);
norm.Normalize();
normals.push_back(g_Vector(norm.Dot( d_rot[0] ), norm.Dot( d_rot[1] ), norm.Dot( d_rot[2] )));
} else {
vertices.push_back(g_Vector( x+d_offset.x(),y+d_offset.y(),z+d_offset.z()));
normals.push_back(g_Vector(-x, -y, -z ));
}
}
// Calculate elevation angle for next level
elevation -= elevationStep;
// Adjust orientation offset
if ( orientOffset > 0 + ICOSAHEDRON_EPSILON ) {
orientOffset = 0;
} else {
orientOffset = 0.5;
}
// Calculate the number of vertices on the next level
if ( level+1 < ( d_maxVert/5 )) {
// increasing
if ( noVert == 1 ) noVert = 0;
noVert += 5;
} else {
if ( level+1 < d_maxLevels + ( d_maxVert/5 )) {
// maximum
noVert = d_maxVert;
} else {
// decreasing
noVert -= 5;
if ( noVert == 0 ) { noVert = 1; orientOffset = 0;}
}
}
}
return vertices.size();
}
#endif
|
#ifndef AWS_NODES_VARIABLEDECLARATION_H
#define AWS_NODES_VARIABLEDECLARATION_H
/*
* aws/nodes/variabledeclaration.h
* AwesomeScript Variable Declaration
* Author: Dominykas Djacenka
* Email: Chaosteil@gmail.com
*/
#include <list>
#include "assignment.h"
#include "statement.h"
namespace AwS{
namespace Nodes{
class VariableDeclaration : public Statement{
public:
VariableDeclaration(std::list<Assignment*>* content)
: Statement(), _content(content){
}
virtual ~VariableDeclaration(){
if(_content){
for(std::list<Assignment*>::iterator i = _content->begin(); i != _content->end(); ++i){
if(*i)delete *i;
}
delete _content;
}
}
const std::list<Assignment*>& getContent() const{ return *_content; }
void translatePhp(std::ostream& output, TranslateSettings& settings) const throw(NodeException){
bool ignore = settings.isIgnoreSemicolon();
settings.setIgnoreSemicolon(true);
bool begin = true;
for(std::list<Assignment*>::iterator i = _content->begin(); i != _content->end(); ++i){
if(begin == false)
if(ignore)
output << ", ";
else
output << "; ";
if(*i)
(*i)->translatePhp(output, settings);
begin = false;
}
settings.setIgnoreSemicolon(ignore);
if(!settings.isIgnoreSemicolon())
output << ";" << std::endl;
}
private:
std::list<Assignment*>* _content;
};
};
};
#endif
|
#include <stdlib.h>
#include <string.h>
#include <list>
#include <set>
#include <memory>
#include <stdexcept>
#include "socks6msg.h"
#include "socks6msg.hh"
#include "sanity.hh"
using namespace std;
using namespace S6M;
#define S6M_CATCH(err) \
catch (EndOfBufferException &) \
{ \
(err) = S6M_ERR_BUFFER; \
} \
catch (BadVersionException &) \
{ \
(err) = S6M_ERR_OTHERVER; \
} \
catch (BadAddressTypeException &) \
{ \
(err) = S6M_ERR_ADDRTYPE; \
} \
catch (invalid_argument &) \
{ \
(err) = S6M_ERR_INVALID; \
} \
catch (logic_error &) \
{ \
(err) = S6M_ERR_INVALID; \
} \
catch (bad_alloc &) \
{ \
(err) = S6M_ERR_ALLOC; \
} \
catch (...) \
{ \
(err) = S6M_ERR_UNSPEC; \
}
struct S6M_PrivateClutter
{
string domain;
vector<S6M_StackOption> stackOpts;
SessionID sessionID;
vector<SOCKS6Method> knownMethods;
string username;
string password;
};
/*
* S6m_Addr
*/
static void S6M_Addr_Fill(S6M_Address *cAddr, const Address &cppAddr, S6M_PrivateClutter *clutter)
{
cAddr->type = cppAddr.getType();
switch (cppAddr.getType())
{
case SOCKS6_ADDR_IPV4:
cAddr->ipv4 = cppAddr.getIPv4();
break;
case SOCKS6_ADDR_IPV6:
cAddr->ipv6 = cppAddr.getIPv6();
break;
case SOCKS6_ADDR_DOMAIN:
clutter->domain = cppAddr.getDomain();
cAddr->domain = clutter->domain.c_str();
break;
}
}
static Address S6M_Addr_Flush(const S6M_Address *cAddr)
{
switch (cAddr->type)
{
case SOCKS6_ADDR_IPV4:
return Address(cAddr->ipv4);
case SOCKS6_ADDR_IPV6:
return Address(cAddr->ipv6);
case SOCKS6_ADDR_DOMAIN:
return Address(cAddr->domain);
}
throw invalid_argument("Bad address type");
}
template <typename SET>
static void fillStackOptions(const SET *set, list<S6M_StackOption> *stackOpts)
{
static const vector<SOCKS6StackLeg> LEGS = { SOCKS6_STACK_LEG_CLIENT_PROXY, SOCKS6_STACK_LEG_PROXY_REMOTE };
for (SOCKS6StackLeg leg: LEGS)
{
auto value = set->get(leg);
if (!value)
continue;
S6M_StackOption opt { leg, SET::Option::LEVEL, SET::Option::CODE, value.value() };
stackOpts->push_back(opt);
}
}
/*
* S6m_OptionSet
*/
static void S6M_OptionSet_Fill(S6M_OptionSet *cSet, const OptionSet *cppSet, S6M_PrivateClutter *clutter)
{
list<S6M_StackOption> stackOpts;
fillStackOptions(&cppSet->stack.tos, &stackOpts);
fillStackOptions(&cppSet->stack.tfo, &stackOpts);
fillStackOptions(&cppSet->stack.mp, &stackOpts);
fillStackOptions(&cppSet->stack.backlog, &stackOpts);
if (!stackOpts.empty())
{
clutter->stackOpts.reserve(stackOpts.size());
int i = 0;
for (const S6M_StackOption &opt: stackOpts)
clutter->stackOpts[i++] = opt;
cSet->stack.options = clutter->stackOpts.data();
}
else
{
cSet = nullptr;
}
if (cppSet->session.requested())
cSet->session.request = 1;
if (cppSet->session.tornDown())
cSet->session.tearDown = 1;
if (cppSet->session.getID())
{
clutter->sessionID = *(cppSet->session.getID());
cSet->session.id = clutter->sessionID.data();
cSet->session.idLength = clutter->sessionID.size();
}
if (cppSet->session.isOK())
cSet->session.ok = 1;
if (cppSet->session.rejected())
cSet->session.rejected = 1;
if (cppSet->session.isUntrusted())
cSet->session.untrusted = 1;
cSet->idempotence.request = cppSet->idempotence.requestedSize();
cSet->idempotence.spend = (bool)cppSet->idempotence.getToken();
cSet->idempotence.token = cppSet->idempotence.getToken().value_or(0);
cSet->idempotence.windowBase = cppSet->idempotence.getAdvertised().first;
cSet->idempotence.windowSize = cppSet->idempotence.getAdvertised().second;
cSet->idempotence.reply = cppSet->idempotence.getReply().has_value();
cSet->idempotence.accepted = cppSet->idempotence.getReply().value_or(false);
if (!cppSet->authMethods.getAdvertised()->empty())
{
clutter->knownMethods.reserve(cppSet->authMethods.getAdvertised()->size());
for (SOCKS6Method method: *(cppSet->authMethods.getAdvertised()))
clutter->knownMethods.push_back(method);
cSet->authMethods.known.methods = clutter->knownMethods.data();
}
cSet->authMethods.initialDataLen = cppSet->authMethods.getInitialDataLen();
cSet->authMethods.selected = cppSet->authMethods.getSelected();
auto [user, passwd] = cppSet->userPassword.getCredentials();
if (user.length() > 0)
{
clutter->username = user;
clutter->password = passwd;
cSet->userPassword.username = clutter->username.c_str();
cSet->userPassword.passwd = clutter->password.c_str();
}
if (cppSet->userPassword.getReply().has_value())
{
cSet->userPassword.replied = 1;
cSet->userPassword.success = cppSet->userPassword.getReply().value();
}
}
static void S6M_OptionSet_Flush(OptionSet *cppSet, const S6M_OptionSet *cSet)
{
for (int i = 0; i < cSet->stack.count; i++)
{
S6M_StackOption *option = &cSet->stack.options[i];
if (option->level == SOCKS6_STACK_LEVEL_IP)
{
if (option->code == SOCKS6_STACK_CODE_TOS)
cppSet->stack.tos.set(option->leg, option->value);
else
throw logic_error("Invalid option");
}
else if (option->level == SOCKS6_STACK_LEVEL_TCP)
{
if (option->code == SOCKS6_STACK_CODE_TFO)
cppSet->stack.tfo.set(option->leg, option->value);
else if (option->code == SOCKS6_STACK_CODE_MP)
cppSet->stack.mp.set(option->leg, option->value);
else if (option->code == SOCKS6_STACK_CODE_BACKLOG)
cppSet->stack.backlog.set(option->leg, option->value);
else
throw logic_error("Invalid option");
}
else
{
throw logic_error("Invalid option");
}
}
if (cSet->session.request)
cppSet->session.request();
if (cSet->session.tearDown)
cppSet->session.tearDown();
if (cSet->session.idLength)
cppSet->session.setID(SessionID(cSet->session.id, cSet->session.id + cSet->session.idLength));
if (cSet->session.ok)
cppSet->session.signalOK();
if (cSet->session.rejected)
cppSet->session.signalReject();
if (cSet->session.untrusted)
cppSet->session.setUntrusted();
if (cSet->idempotence.request > 0)
cppSet->idempotence.request(cSet->idempotence.request);
if (cSet->idempotence.spend)
cppSet->idempotence.setToken(cSet->idempotence.token);
if (cSet->idempotence.windowSize > 0)
cppSet->idempotence.advertise({ cSet->idempotence.windowBase, cSet->idempotence.windowSize });
if (cSet->idempotence.reply)
cppSet->idempotence.setReply(cSet->idempotence.accepted);
if (cSet->authMethods.known.methods)
{
set<SOCKS6Method> methods;
for (int i = 0; i < cSet->authMethods.known.count; i++)
methods.insert((SOCKS6Method)cSet->authMethods.known.methods[i]);
cppSet->authMethods.advertise(methods, cSet->authMethods.initialDataLen);
}
if (cSet->authMethods.selected != SOCKS6_METHOD_NOAUTH)
cppSet->authMethods.select(cSet->authMethods.selected);
if (cSet->userPassword.username || cSet->userPassword.passwd)
cppSet->userPassword.setCredentials({ cSet->userPassword.username, cSet->userPassword.passwd });
if (cSet->userPassword.replied)
cppSet->userPassword.setReply(cSet->userPassword.success);
}
/*
* S6M_Request_*
*/
struct S6M_RequestExtended: public S6M_Request
{
S6M_PrivateClutter clutter;
};
ssize_t S6M_Request_packedSize(const S6M_Request *req)
{
S6M_Error err;
try
{
Address addr = S6M_Addr_Flush(&req->addr);
Request cppReq(req->code, addr, req->port);
S6M_OptionSet_Flush(&cppReq.options, &req->optionSet);
return cppReq.packedSize();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_Request_pack(const S6M_Request *req, uint8_t *buf, size_t size)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
Address addr = S6M_Addr_Flush(&req->addr);
Request cppReq(req->code, addr, req->port);
S6M_OptionSet_Flush(&cppReq.options, &req->optionSet);
cppReq.pack(&bb);
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_Request_parse(uint8_t *buf, size_t size, S6M_Request **preq)
{
S6M_Error err;
S6M_RequestExtended *req = nullptr;
try
{
ByteBuffer bb(buf, size);
Request cppReq(&bb);
req = new S6M_RequestExtended();
memset((S6M_Request *)req, 0, sizeof(S6M_Request));
req->code = cppReq.code;
S6M_Addr_Fill(&req->addr, cppReq.address, &req->clutter);
req->port = cppReq.port;
S6M_OptionSet_Fill(&req->optionSet, &cppReq.options, &req->clutter);
*preq = req;
return bb.getUsed();
}
S6M_CATCH(err);
if (req)
S6M_Request_free(req);
return err;
}
void S6M_Request_free(S6M_Request *req)
{
delete (S6M_RequestExtended * )req;
}
/*
* S6M_AuthReply_*
*/
struct S6M_AuthReplyExtended: public S6M_AuthReply
{
S6M_PrivateClutter clutter;
};
ssize_t S6M_AuthReply_packedSize(const S6M_AuthReply *authReply)
{
S6M_Error err;
try
{
AuthenticationReply cppAuthReply(authReply->code);
S6M_OptionSet_Flush(&cppAuthReply.options, &authReply->optionSet);
return cppAuthReply.packedSize();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_AuthReply_pack(const S6M_AuthReply *authReply, uint8_t *buf, size_t size)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
AuthenticationReply cppAuthReply(authReply->code);
S6M_OptionSet_Flush(&cppAuthReply.options, &authReply->optionSet);
cppAuthReply.pack(&bb);
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_AuthReply_parse(uint8_t *buf, size_t size, S6M_AuthReply **pauthReply)
{
S6M_Error err;
S6M_AuthReplyExtended *authReply = nullptr;
try
{
ByteBuffer bb(buf, size);
AuthenticationReply cppAuthReply(&bb);
authReply = new S6M_AuthReplyExtended();
memset((S6M_AuthReply *)authReply, 0, sizeof(S6M_AuthReply));
authReply->code = cppAuthReply.code;
S6M_OptionSet_Fill(&authReply->optionSet, &cppAuthReply.options, &authReply->clutter);
*pauthReply = authReply;
return bb.getUsed();
}
S6M_CATCH(err);
if (authReply)
S6M_AuthReply_free(authReply);
return err;
}
void S6M_AuthReply_free(S6M_AuthReply *authReply)
{
delete (S6M_AuthReplyExtended *)authReply;
}
/*
* S6M_OpReply_*
*/
struct S6M_OpReplyExtended: public S6M_OpReply
{
S6M_PrivateClutter clutter;
};
ssize_t S6M_OpReply_packedSize(const S6M_OpReply *opReply)
{
S6M_Error err;
try
{
Address addr = S6M_Addr_Flush(&opReply->addr);
OperationReply cppOpReply(opReply->code, addr, opReply->port);
S6M_OptionSet_Flush(&cppOpReply.options, &opReply->optionSet);
return cppOpReply.packedSize();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_OpReply_pack(const S6M_OpReply *opReply, uint8_t *buf, size_t size)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
Address addr = S6M_Addr_Flush(&opReply->addr);
OperationReply cppOpReply(opReply->code, addr, opReply->port);
S6M_OptionSet_Flush(&cppOpReply.options, &opReply->optionSet);
cppOpReply.pack(&bb);
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_OpReply_parse(uint8_t *buf, size_t size, S6M_OpReply **popReply)
{
S6M_Error err;
S6M_OpReplyExtended *opReply = nullptr;
try
{
ByteBuffer bb(buf, size);
OperationReply cppOpReply(&bb);
opReply = new S6M_OpReplyExtended();
memset((S6M_OpReply *)opReply, 0, sizeof(S6M_OpReply));
opReply->code = cppOpReply.code;
S6M_Addr_Fill(&opReply->addr, cppOpReply.address, &opReply->clutter);
opReply->port = cppOpReply.port;
S6M_OptionSet_Fill(&opReply->optionSet, &cppOpReply.options, &opReply->clutter);
*popReply = opReply;
return bb.getUsed();
}
S6M_CATCH(err);
if (opReply)
S6M_OpReply_free(opReply);
return err;
}
void S6M_OpReply_free(S6M_OpReply *opReply)
{
delete (S6M_OpReplyExtended *)opReply;
}
/*
* S6M_PasswdReq_*
*/
struct S6M_PasswdReqExtended: public S6M_PasswdReq
{
struct
{
string username;
string passwd;
} clutter;
};
ssize_t S6M_PasswdReq_packedSize(const S6M_PasswdReq *pwReq)
{
S6M_Error err;
try
{
UserPasswordRequest req({ pwReq->username, pwReq->passwd });
return req.packedSize();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_PasswdReq_pack(const S6M_PasswdReq *pwReq, uint8_t *buf, size_t size)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
UserPasswordRequest req({ pwReq->username, pwReq->passwd });
req.pack(&bb);
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_PasswdReq_parse(uint8_t *buf, size_t size, S6M_PasswdReq **ppwReq)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
UserPasswordRequest cppReq(&bb);
S6M_PasswdReqExtended *pwReq = new S6M_PasswdReqExtended();
try
{
auto [user, passwd] = cppReq.getCredentials();
pwReq->clutter.username = user;
pwReq->clutter.passwd = passwd;
}
catch (...)
{
delete pwReq;
throw;
}
pwReq->username = pwReq->clutter.username.c_str();
pwReq->passwd = pwReq->clutter.passwd.c_str();
*ppwReq = pwReq;
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
void S6M_PasswdReq_free(S6M_PasswdReq *pwReq)
{
delete (S6M_PasswdReqExtended *)pwReq;
}
/*
* S6M_PasswdReply_*
*/
ssize_t S6M_PasswdReply_packedSize(const S6M_PasswdReply *pwReply)
{
(void)pwReply;
return UserPasswordReply::packedSize();
}
ssize_t S6M_PasswdReply_pack(const S6M_PasswdReply *pwReply, uint8_t *buf, size_t size)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
UserPasswordReply rep(pwReply->success);
rep.pack(&bb);
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
ssize_t S6M_PasswdReply_parse(uint8_t *buf, size_t size, S6M_PasswdReply **ppwReply)
{
S6M_Error err;
try
{
ByteBuffer bb(buf, size);
UserPasswordReply rep(&bb);
S6M_PasswdReply *pwReply = new S6M_PasswdReply();
pwReply->success = rep.success;
*ppwReply = pwReply;
return bb.getUsed();
}
S6M_CATCH(err);
return err;
}
void S6M_PasswdReply_free(S6M_PasswdReply *pwReply)
{
delete pwReply;
}
/*
* S6M_Error_*
*/
const char *S6M_Error_msg(S6M_Error err)
{
switch (err)
{
case S6M_ERR_SUCCESS:
return "Success";
case S6M_ERR_INVALID:
return "Invalid field";
case S6M_ERR_ALLOC:
return "Memory allocation failure";
case S6M_ERR_BUFFER:
return "End of buffer";
case S6M_ERR_OTHERVER:
return "Unsupported protocol version";
case S6M_ERR_UNSPEC:
return "Unspecified error";
default:
return "Not my problem!";
}
}
|
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//============================================================================
//======================================================= IntAna2d_Outils.hxx
//============================================================================
#ifndef IntAna2d_Outils_HeaderFile
#define IntAna2d_Outils_HeaderFile
#include <math_TrigonometricFunctionRoots.hxx>
#include <IntAna2d_IntPoint.hxx>
class MyDirectPolynomialRoots {
public:
MyDirectPolynomialRoots(const Standard_Real A4,
const Standard_Real A3,
const Standard_Real A2,
const Standard_Real A1,
const Standard_Real A0);
MyDirectPolynomialRoots(const Standard_Real A2,
const Standard_Real A1,
const Standard_Real A0);
Standard_Integer NbSolutions() const { return(nbsol); }
Standard_Real Value(const Standard_Integer i) const { return(sol[i-1]); }
Standard_Real IsDone() const { return(nbsol>-1); }
Standard_Boolean InfiniteRoots() const { return(same); }
private:
Standard_Real sol[16];
Standard_Real val[16];
Standard_Integer nbsol;
Standard_Boolean same;
};
Standard_Boolean Points_Confondus(const Standard_Real xa,const Standard_Real ya,
const Standard_Real xb,const Standard_Real yb);
void Traitement_Points_Confondus(Standard_Integer& nb_pts
,IntAna2d_IntPoint *pts);
void Coord_Ancien_Repere(Standard_Real& Ancien_X,
Standard_Real& Ancien_Y,
const gp_Ax2d& Axe_Nouveau_Repere);
#endif
|
#include "abstractshapeinfo.h"
namespace sbg {
template<int n>
AbstractShapeInfo<n>::~AbstractShapeInfo()
{
}
template struct AbstractShapeInfo<2>;
template struct AbstractShapeInfo<3>;
}
|
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018-2020 SChernykh <https://github.com/SChernykh>
* Copyright 2016-2020 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* 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/>.
*/
#include <cassert>
#include <memory>
#include "base/kernel/Base.h"
#include "base/io/json/Json.h"
#include "base/io/json/JsonChain.h"
#include "base/io/log/backends/ConsoleLog.h"
#include "base/io/log/backends/FileLog.h"
#include "base/io/log/Log.h"
#include "base/io/log/Tags.h"
#include "base/io/Watcher.h"
#include "base/kernel/interfaces/IBaseListener.h"
#include "base/kernel/Platform.h"
#include "base/kernel/Process.h"
#include "base/net/tools/NetBuffer.h"
#include "core/config/Config.h"
#include "core/config/ConfigTransform.h"
#include "version.h"
#ifdef HAVE_SYSLOG_H
# include "base/io/log/backends/SysLog.h"
#endif
#ifdef XMRIG_FEATURE_API
# include "base/api/Api.h"
# include "base/api/interfaces/IApiRequest.h"
namespace xmrig {
static const char *kConfigPathV1 = "/1/config";
static const char *kConfigPathV2 = "/2/config";
} // namespace xmrig
#endif
#ifdef XMRIG_FEATURE_EMBEDDED_CONFIG
# include "core/config/Config_default.h"
#endif
namespace xmrig {
class BasePrivate
{
public:
XMRIG_DISABLE_COPY_MOVE_DEFAULT(BasePrivate)
inline BasePrivate(Process *process)
{
Log::init();
config = load(process);
}
inline ~BasePrivate()
{
# ifdef XMRIG_FEATURE_API
delete api;
# endif
delete config;
delete watcher;
NetBuffer::destroy();
}
inline bool read(const JsonChain &chain, std::unique_ptr<Config> &config)
{
config = std::unique_ptr<Config>(new Config());
return config->read(chain, chain.fileName());
}
inline void replace(Config *newConfig)
{
Config *previousConfig = config;
config = newConfig;
for (IBaseListener *listener : listeners) {
listener->onConfigChanged(config, previousConfig);
}
delete previousConfig;
}
Api *api = nullptr;
Config *config = nullptr;
std::vector<IBaseListener *> listeners;
Watcher *watcher = nullptr;
private:
inline Config *load(Process *process)
{
JsonChain chain;
ConfigTransform transform;
std::unique_ptr<Config> config;
ConfigTransform::load(chain, process, transform);
if (read(chain, config)) {
return config.release();
}
chain.addFile(Process::location(Process::DataLocation, "config.json"));
if (read(chain, config)) {
return config.release();
}
chain.addFile(Process::location(Process::HomeLocation, "." APP_ID ".json"));
if (read(chain, config)) {
return config.release();
}
chain.addFile(Process::location(Process::HomeLocation, ".config" XMRIG_DIR_SEPARATOR APP_ID ".json"));
if (read(chain, config)) {
return config.release();
}
# ifdef XMRIG_FEATURE_EMBEDDED_CONFIG
chain.addRaw(default_config);
if (read(chain, config)) {
return config.release();
}
# endif
return nullptr;
}
};
} // namespace xmrig
xmrig::Base::Base(Process *process)
: d_ptr(new BasePrivate(process))
{
}
xmrig::Base::~Base()
{
delete d_ptr;
}
bool xmrig::Base::isReady() const
{
return d_ptr->config != nullptr;
}
int xmrig::Base::init()
{
# ifdef XMRIG_FEATURE_API
d_ptr->api = new Api(this);
d_ptr->api->addListener(this);
# endif
Platform::init(config()->userAgent());
if (isBackground()) {
Log::setBackground(true);
}
else {
Log::add(new ConsoleLog(config()->title()));
}
if (config()->logFile()) {
Log::add(new FileLog(config()->logFile()));
}
# ifdef HAVE_SYSLOG_H
if (config()->isSyslog()) {
Log::add(new SysLog());
}
# endif
return 0;
}
void xmrig::Base::start()
{
# ifdef XMRIG_FEATURE_API
api()->start();
# endif
if (config()->isShouldSave()) {
config()->save();
}
if (config()->isWatch()) {
d_ptr->watcher = new Watcher(config()->fileName(), this);
}
}
void xmrig::Base::stop()
{
# ifdef XMRIG_FEATURE_API
api()->stop();
# endif
delete d_ptr->watcher;
d_ptr->watcher = nullptr;
}
xmrig::Api *xmrig::Base::api() const
{
assert(d_ptr->api != nullptr);
return d_ptr->api;
}
bool xmrig::Base::isBackground() const
{
return d_ptr->config && d_ptr->config->isBackground();
}
bool xmrig::Base::reload(const rapidjson::Value &json)
{
JsonReader reader(json);
if (reader.isEmpty()) {
return false;
}
auto config = new Config();
if (!config->read(reader, d_ptr->config->fileName())) {
delete config;
return false;
}
const bool saved = config->save();
if (config->isWatch() && d_ptr->watcher && saved) {
delete config;
return true;
}
d_ptr->replace(config);
return true;
}
xmrig::Config *xmrig::Base::config() const
{
assert(d_ptr->config != nullptr);
return d_ptr->config;
}
void xmrig::Base::addListener(IBaseListener *listener)
{
d_ptr->listeners.push_back(listener);
}
void xmrig::Base::onFileChanged(const String &fileName)
{
LOG_WARN("%s " YELLOW("\"%s\" was changed, reloading configuration"), Tags::config(), fileName.data());
JsonChain chain;
chain.addFile(fileName);
auto config = new Config();
if (!config->read(chain, chain.fileName())) {
LOG_ERR("%s " RED("reloading failed"), Tags::config());
delete config;
return;
}
d_ptr->replace(config);
}
#ifdef XMRIG_FEATURE_API
void xmrig::Base::onRequest(IApiRequest &request)
{
if (request.method() == IApiRequest::METHOD_GET) {
if (request.url() == kConfigPathV1 || request.url() == kConfigPathV2) {
if (request.isRestricted()) {
return request.done(403);
}
request.accept();
config()->getJSON(request.doc());
}
}
else if (request.method() == IApiRequest::METHOD_PUT || request.method() == IApiRequest::METHOD_POST) {
if (request.url() == kConfigPathV1 || request.url() == kConfigPathV2) {
request.accept();
if (!reload(request.json())) {
return request.done(400);
}
request.done(204);
}
}
}
#endif
|
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define pr pair<int,int>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--) {
int n,m;
cin>>n>>m;
vector<string> s(n);
vector<int> row(n,0),col(m,0);
for(int i=0;i<n;i++)
cin>>s[i];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++) {
if(s[i][j]=='1') {
row[i]++;
col[j]++;
}
}
}
string d;
cin>>d;
//int l=0,r=0,u=0,e=0;
for(int i=0;i<d.size();i++) {
if(d[i]=='L') {
// l++;
// if(r=!0) {
// r=0;
//cout<<d[i]<<" ";
for(int i=0;i<n;i++) {
int k=0;
for(int j=0;j<m;j++) {
if(k<row[i]) {
if(s[i][j]=='0')
col[j]++;
s[i][j]='1';
k++;
} else {
if(s[i][j]=='1')
col[j]--;
s[i][j]='0';
}
}
}
//}
} else if(d[i]=='R') {
// r++;
// if(l!=0) {
// l=0;
//cout<<d[i]<<" ";
for(int i=n-1;i>=0;i--) {
int k=0;
for(int j=m-1;j>=0;j--) {
if(k<row[i]) {
if(s[i][j]=='0')
col[j]++;
s[i][j]='1';
k++;
} else {
if(s[i][j]=='1')
col[j]--;
s[i][j]='0';
}
}
}
// }
} else if(d[i]=='D') {
// d++;
// if(u=!0) {
// u=0;
//cout<<d[i]<<" ";
for(int i=m-1;i>=0;i--) {
int k=0;
for(int j=n-1;j>=0;j--) {
if(k<col[i]) {
if(s[j][i]=='0')
row[j]++;
s[j][i]='1';
k++;
} else {
if(s[j][i]=='1')
row[j]--;
s[j][i]='0';
}
}
}
// }
} else if(d[i]=='U') {
// u++;
// if(=!0) {
// d=0;
//cout<<d[i]<<" ";
for(int i=0;i<m;i++) {
int k=0;
for(int j=0;j<n;j++) {
if(k<col[i]) {
if(s[j][i]=='0')
row[j]++;
s[j][i]='1';
k++;
} else {
if(s[j][i]=='1')
row[j]--;
s[j][i]='0';
}
}
}
//}
}
}
for(int i=0;i<n;i++)
cout<<s[i]<<"\n";
}
return 0;
}
|
#ifndef UTILS_H_
#define UTILS_H_
#include "Room.h"
#include <vector>
#include "../rapidxml/rapidxml.hpp"
#include "../rapidxml/rapidxml_utils.hpp"
#include "../rapidxml/rapidxml_print.hpp"
using namespace std;
using namespace rapidxml;
Room makeRoom(int, xml_node<> *);
Item makeItem(xml_node<> *);
Container makeContainer(xml_node<> *, vector<Item>);
Creature makeCreature(xml_node<> *);
#endif
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <cmath>
#include <string>
#include <algorithm>
//#include "camadafisica.h"
#define TAMANHO_VETOR 8
using namespace std;
int CamadaDeAplicacaoTransmissoraBipolar(){
// Deve ser feita a conversão para binário
//CamadaFisicaTrasnmissoraCodificacaoBinaria();
// A mensagem é codificada por desnível entre 0 e 1
// 0 -> 0 = 0
// 0 -> 1 = 1
// 1 -> 1 = -1/0
string mensagem;
cout << "Digite uma mensagem:" << endl;
cin >> mensagem;
cout << "A mensagem digitada em bipolar eh :";
int i;
int nivelnegativo = -1;
int aux0, aux1,aux2;
int nivelneutro = 0;
int nivelpositivo = 1;
/*for (i =0; i < mensagem.length(); i++){
// mensagem[i] = 0;
}*/
//for (i = 0; i < mensagem.length(); i++)
//mensagem[i] > mensagem[nivelneutro]
if (mensagem[i] > mensagem[nivelneutro]){
nivelneutro = nivelpositivo;
// cout << " ";
cout << "1";
nivelneutro = 1;
//else if (mensagem[i] == mensagem[i] || mensagem[i] == 0 || mensagem[i] == 1)
} else if ( mensagem[i] == mensagem[i]){
nivelneutro = nivelnegativo;
mensagem[i] >= (1 << i);
mensagem[i] = mensagem[i] - (1 << i);
//cout << " ";
cout << "0";
nivelneutro = 0;
//mensagem[i] == mensagem[i] && mensagem[i] == 1
}
if (mensagem[i] == mensagem[i] && mensagem[i] == 1 ){
//nivelnegativo = nivelneutro;
cout << " ";
cout << "-1";
}
cout << " ";
cout << "\n";
cout << "\nO valor tamanho da mensagem eh: " << mensagem.size() << endl;
}
int CamadaDeAplicacaoReceptoraDecodificacaoBipolar(){
// 0 -> 0 = 0
// 0 -> 1 = 1
// 1 -> 1 = -1/0
string mensagem;
cout << "Digite uma mensagem:" << endl;
cin >> mensagem;
int i;
int nivelnegativo = -1;
int aux0, aux1,aux2;
int nivelneutro = 0;
int nivelpositivo = 1;
// Inicializar
for (i = 0; i < mensagem.length(); i++){
mensagem[i] = 0;
mensagem[i+1] = 1;
}
cout << "A mensagem decodifica eh: ";
if (mensagem[i] < mensagem[nivelneutro]){
nivelneutro = nivelpositivo;
// cout << " ";
cout << "0";
nivelneutro = 1;
//else if (mensagem[i] == mensagem[i] || mensagem[i] == 0 || mensagem[i] == 1)
} else if ( mensagem[i] != mensagem[i]){
nivelneutro = nivelnegativo;
mensagem[i] >= (1 << i);
mensagem[i] = mensagem[i] - (1 << i);
//cout << " ";
cout << "1";
nivelneutro = 0;
//mensagem[i] == mensagem[i] && mensagem[i] == 1
}
if (mensagem[i] == mensagem[i] && mensagem[i] == 1 ){
//nivelnegativo = nivelneutro;
cout << " ";
cout << "1";
}
cout << " ";
cout << "\n";
cout << "\nO valor tamanho da mensagem eh: " << mensagem.size() << endl;
}
int main (){
//CamadaFisicaTrasnmissoraCodificacaoBinaria();
CamadaDeAplicacaoTransmissoraBipolar();
CamadaDeAplicacaoReceptoraDecodificacaoBipolar();
}
|
#include "Application.h"
#include "MenuScene.h"
int main()
{
try
{
// Create an application object.
FW::Application app("Resources/Configuration.xml");
// Add the menu scene to the scene manager.
app.getSceneManager().addScene<MenuScene>();
// Run the game.
app.run();
}
// If there was an error, catch it and display it on the console.
catch (const FW::ApplicationException& error)
{
OUTPUT_ERROR(error.what());
std::cin.get();
}
return 0;
}
|
//-----------------------------------------------------------------------------
// Module D
//
// Description - Contains functions used to calculate the repulsive energy
//-----------------------------------------------------------------------------
#ifndef MODULEDNEW_HPP
#define MODULEDNEW_HPP
#include "../atom/atom.h"
#include "armadillo"
#include <cmath>
#include "../atom/vect3.h"
#include "../sim/unitcell.h"
#include "../sim/simulation.hpp"
using namespace moldycat;
using namespace arma;
//Define parameters as taken from Xu 1992 paper
const double phi0=8.18555;
const double d0=1.64;
const double d1=2.57;
const double m=3.30304;
const double mc=8.6655;
const double dc=2.1052;
const double c0r=2.2504290109E-8;
const double c1r=-1.4408640561E-6;
const double c2r=2.1043303374E-5;
const double c3r=6.6024390226E-5;
const double f0=-2.5909765118191;
const double f1=0.5721151498619;
const double f2=-1.7896349903996E-3;
const double f3=2.3539221516757E-5;
const double f4=-1.24251169551587E-7;
//-------------------------------------------------------------
// Function phi
//-------------------------------------------------------------
// Returns: phi(r) (from Xu et al.)
//
// Params: r - Distance between atoms
//
// Operation: Calculates phi(r) used to calculate the repulsive
// energy and the repulsive force
//-------------------------------------------------------------
double phi(double r) {
if (r>d1) {
double r_2=r-d1;
return c0r + r_2*(c1r + r_2*(c2r + r_2*(c3r)));
}
else {
return phi0*pow((d0/r),m)*exp(m*(pow(d0/dc,mc)-pow(r/dc,mc)));
}
}
//------------------------------------------------------------------------------
// Function phiDeriv
//------------------------------------------------------------------------------
// Returns: Phi'(r)
//
// Params: r - Distance between atoms
//
// Operation: Calculates the derivative of Phi(r) at r, used to
// calcaulte the repulsive forces
//------------------------------------------------------------------------------
double phiDeriv(double r) {
if (r>d1) {
double r_2=r-d1;
return r_2*c1r*1.0+r_2*(c2r*2.0+r_2*(c3r*3.0));
}
else {
return -m*phi(r)*((1.0/r)+(mc/r)*pow((r/dc),mc));
}
}
//------------------------------------------------------------------------------
// Function repulsiveEnergy
//------------------------------------------------------------------------------
// Returns: E_rep - Total repulsive energy
//
// Params: atoms(atom_list) - Positions of atoms
// cell(unitcell) - Unit cell
//
// Operation: works out displacement betweens atoms and returns total repulsive
// energy accordingly.
//------------------------------------------------------------------------------
double repulsiveEnergy(const atom_list& atoms, unitcell cell) {
int n=atoms.count(),i,j;
double x,R,E_rep=0.0,dif;
vec E=zeros<vec>(n);
vect3 r;
for (i=0;i<n;i++) {
x=0.0;
for (j=0;j<n;j++) {
if(j==i) {
continue;
}
else {
r=atoms[j].pos.diff_bc(atoms[i].pos,cell);
R=r.norm();
if (R<r_m) {
x+=phi(R);
}
}
}
dif=f0+x*(f1+x*(f2+x*(f3+x*f4)));
E(i)=dif;
E_rep+=dif;
}
return E_rep;
}
#endif
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep1(i, n) for(int i = 1; i <= (int)(n); i++)
#define showmap(is, js, x) {rep(i, is){rep(j, js){cout << x[i][j] << " ";}cout << endl;}}
#define show(x) {for(auto i: x){cout << i << " ";} cout<<endl;}
#define showm(m) {for(auto i: m){cout << m.x << " ";} cout<<endl;}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
ll gcd(int x, int y){ return y?gcd(y, x%y):x;}
ll lcm(ll x, ll y){ return (x*y)/gcd(x,y);}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return true;} return false;}
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return true;} return false;}
int main()
{
int n, m;
cin >> n >> m;
vector<int> a(m);
rep(i, m){ cin >> a[i]; }
sort(a.begin(), a.end());
//show(a);
int st = 1;
vector<int> sp;
rep(i, m){
int tsp = a[i] - st;
if (tsp != 0) sp.push_back(tsp);
st = a[i]+1;
}
if (n+1-st != 0) sp.push_back(n+1-st);
//show(sp);
int minl = MOD;
//not care
if (sp.size() == 0) {cout << 0 << endl; return 0;}
rep(i, sp.size()){
chmin(minl, sp[i]);
}
int ans = 0;
rep(i, sp.size()){
ans += (sp[i] + minl - 1) / minl;
}
cout << ans << endl;
}
|
#ifndef _ZORK_ROOM_
#define _ZORK_ROOM_
#include "Object.hpp"
#include "Container.hpp"
#include "Item.hpp"
#include "Creature.hpp"
#include <functional>
#include <list>
using namespace std;
class Room:public Object
{
public:
Room(const string& n,const string& desc,const string& status, const string& type);
void addBorder(string& rm,int dir){border[dir] = rm;}
void removeBorder(int dir){border[dir].clear();}
static int Border(char c){
switch(c){
case 'n':
return 0;
case 'e':
return 1;
case 's':
return 2;
case 'w':
return 3;
}
return -1;
}
void Add(Item& c);
void Add(Container& c);
void Add(Creature& c);
void Delete();
bool Has(const Object& c) {return c.getowner()==*this;}
void Remove(Item& c);
void Remove(Container& c);
void Remove(Creature& c);
private:
string type;
string border[4];//NESW
list< reference_wrapper<Container> > cont;
list< reference_wrapper<Item> > item;
list< reference_wrapper<Creature> > being;
};
#endif
|
#ifndef WAVEGUIDE_SYSTEM_H_
#define WAVEGUIDE_SYSTEM_H_
#include "linear_system.h"
#include "waveguide.h"
#include "wave.h"
#include "complex"
namespace KFU
{
class WaveguideSystem: public LinearSystem
{
public:
WaveguideSystem(Waveguide guide, Wave w);
void solve_all();
Wave* getSolutions();
private:
Waveguide waveguide;
Wave wave;
Wave* solutions;
void init_matrix();
void init_vector();
Complex exp_i(Complex x);
};
}
#endif
|
//
#pragma once
#ifndef _CONTRH_
#define _CONTRH_
/*
定义等值线绘制中使用到的基本数据类型
读取网格点信息 contr::access_contour
*/
#include "comn.h"
#include "string-trans.h"
namespace contr{
template <typename T>
class pointxy //点
{
public:
T x;
T y;
pointxy()
:x(0),y(0)
{}
pointxy(T a,T b)
{
set(a,b);
}
void set(T a,T b)
{
x=a;
y=b;
}
bool operator ==(const pointxy & right)const
{
if(beql(right.x,this->x) && beql(right.y,this->y))
{
return true;
}
return false;
}
bool operator !=(const pointxy & right)const
{
if(*this == right)
return false;
return true;
}
//for CPoint Class
operator CPoint()const
{
return CPoint(int(x+0.5),int(y+0.5));
}
};
template <typename T>
std::istream & operator >>(std::istream & in,pointxy<T> &pt)
{
in>>pt.x>>pt.y;
return in;
}
template <typename T>
std::ostream & operator <<(std::ostream & out,const pointxy<T> &pt)
{
out<<pt.x<<" "<<pt.y;
return out;
}
//仿函数
//按照坐标轴排序
template <typename T>
class sort_by_axes
{
public:
typedef pointxy<T> point_type;
typedef std::vector<point_type> line_type;
private:
char c;
public:
sort_by_axes(char m):c(m){}
//比较两个点
bool operator ()(const point_type &left,const point_type &right)const
{
switch(c)
{
case 'x':
if(left.x < right.x)
{
return true;
}
break;
case 'y':
if(left.y < right.y)
{
return true;
}
break;
default:
break;
}
return false;
}
//重载 比较两条线的起点
bool operator ()(const line_type &left,const line_type &right)const
{
return this->operator () (left[0],right[0]);
}
};
//网格点数据结构
struct grid_point
{
pointxy<double> xy;
double value;
};
class grid_point_sort
{
public:
grid_point_sort(char m):c(m){}
bool operator ()(const grid_point & left, const grid_point &right)const
{
switch(c)
{
case 'x':
if(left.xy.x < right.xy.x)
{
return true;
}
break;
case 'y':
if(left.xy.y < right.xy.y)
{
return true;
}
break;
case 'v':
if(left.value < right.value)
{
return true;
}
default:
break;
}
return false;
}
private:
char c;
};
//网格的一些基本信息
//网格的行数，列数，X，Y, Z轴的最大最小值
struct grid_info
{
int rows,cols;
double xmin,xmax;
double ymin,ymax;
double zmin,zmax;
grid_info()
{
xmin = xmax = 0;
ymin = ymax = 0;
zmin = zmax = 0;
}
};
class access_contour
{
private:
grid_info gridinfo; //网格信息
std::vector<grid_point> gridpoints;
public:
access_contour()
{
}
void get_grid_data(std::string filename)
{
std::string text_content;
std::vector<std::string> text_lines;
filetostr(filename,text_content);
str_split(str_trim(text_content),"\n",text_lines,true);
double x0=0,x1=0;
string_to(text_lines[0],x0);
string_to(text_lines[1],x1);
if(beql(x0,x1))//行优先
{
get_col_first(text_lines);
}
else
{
get_row_first(text_lines);
}
}
const grid_info& gd_info()const
{
return gridinfo;
}
const std::vector<grid_point>& gdpts()const
{
return gridpoints;
}
private:
void get_row_first(std::vector<std::string> &text_lines)
{
gridpoints.resize(text_lines.size());
for(size_t it=0;
it != text_lines.size(); it++)
{
std::vector<std::string> aline;
str_split(text_lines[it]," ",aline);
if(aline.size()<3) continue;
string_to(aline[0],gridpoints[it].xy.x);
string_to(aline[1],gridpoints[it].xy.y);
string_to(aline[2],gridpoints[it].value);
}
set_grid_info();
}
void get_col_first(std::vector<std::string> &text_lines)
{
}
void set_grid_info()
{
std::vector<grid_point>::iterator it;
it = std::min_element(gridpoints.begin(), gridpoints.end(), grid_point_sort('x'));
gridinfo.xmin = it->xy.x;
it = std::max_element(gridpoints.begin(), gridpoints.end(), grid_point_sort('x'));
gridinfo.xmax = it->xy.x;
it = std::min_element(gridpoints.begin(), gridpoints.end(), grid_point_sort('y'));
gridinfo.ymin = it->xy.y;
it = std::max_element(gridpoints.begin(), gridpoints.end(), grid_point_sort('y'));
gridinfo.ymax = it->xy.y;
it = std::min_element(gridpoints.begin(), gridpoints.end(), grid_point_sort('v'));
gridinfo.zmin = it->value;
it = std::max_element(gridpoints.begin(), gridpoints.end(), grid_point_sort('v'));
gridinfo.zmax = it->value;
gridinfo.cols = int((gridinfo.xmax - gridinfo.xmin)/(gridpoints[1].xy.x - gridpoints[0].xy.x)+1.5);
gridinfo.rows = (gridpoints.size()/gridinfo.cols);
}
};
}
#endif /* _CONTRH_ END */
|
#ifndef QTestParameterNames_H
#define QTestParameterNames_H
/** \class QTestParameterNames
* *
* Defines name and number of parameters that must be specified in the
* xml configuration file for each quality test besides error and warning thresholds.
* It's used by QTestConfigurationPerser
* to check that all necessary parameters are defined.
*
* \author Ilaria Segoni
*/
#include <map>
#include <string>
#include <vector>
class QTestParameterNames {
public:
///Constructor
QTestParameterNames();
///Destructor
~QTestParameterNames() {}
///returns the list of parameters used by the test of a given type (the string theTestType
///must be one of the names defined in DQMServices/ClientConfig/interface/DQMQualityTestsConfiguration.h
std::vector<std::string> getTestParamNames(std::string theTestType);
private:
void constructMap(std::string testType,
std::string param1 = "undefined",
std::string param2 = "undefined",
std::string param3 = "undefined",
std::string param4 = "undefined",
std::string param5 = "undefined",
std::string param6 = "undefined",
std::string param7 = "undefined",
std::string param8 = "undefined");
private:
std::map<std::string, std::vector<std::string> > configurationMap;
};
#endif
|
// Created on: 2013-02-05
// Created by: Julia GERASIMOVA
// Copyright (c) 2001-2013 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _GeomFill_DiscreteTrihedron_HeaderFile
#define _GeomFill_DiscreteTrihedron_HeaderFile
#include <Standard.hxx>
#include <GeomFill_HSequenceOfAx2.hxx>
#include <TColStd_HSequenceOfReal.hxx>
#include <GeomFill_TrihedronLaw.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <GeomAbs_Shape.hxx>
#include <TColStd_Array1OfReal.hxx>
class GeomFill_Frenet;
class gp_Vec;
class GeomFill_DiscreteTrihedron;
DEFINE_STANDARD_HANDLE(GeomFill_DiscreteTrihedron, GeomFill_TrihedronLaw)
//! Defined Discrete Trihedron Law.
//! The requirement for path curve is only G1.
//! The result is C0-continuous surface
//! that can be later approximated to C1.
class GeomFill_DiscreteTrihedron : public GeomFill_TrihedronLaw
{
public:
Standard_EXPORT GeomFill_DiscreteTrihedron();
Standard_EXPORT virtual Handle(GeomFill_TrihedronLaw) Copy() const Standard_OVERRIDE;
Standard_EXPORT void Init();
//! initialize curve of trihedron law
//! @return Standard_True in case if execution end correctly
Standard_EXPORT virtual Standard_Boolean SetCurve (const Handle(Adaptor3d_Curve)& C) Standard_OVERRIDE;
//! compute Trihedron on curve at parameter <Param>
Standard_EXPORT virtual Standard_Boolean D0 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& Normal, gp_Vec& BiNormal) Standard_OVERRIDE;
//! compute Trihedron and derivative Trihedron on curve
//! at parameter <Param>
//! Warning : It used only for C1 or C2 approximation
//! For the moment it returns null values for DTangent, DNormal
//! and DBiNormal.
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& BiNormal, gp_Vec& DBiNormal) Standard_OVERRIDE;
//! compute Trihedron on curve
//! first and seconde derivatives.
//! Warning : It used only for C2 approximation
//! For the moment it returns null values for DTangent, DNormal
//! DBiNormal, D2Tangent, D2Normal, D2BiNormal.
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, gp_Vec& Tangent, gp_Vec& DTangent, gp_Vec& D2Tangent, gp_Vec& Normal, gp_Vec& DNormal, gp_Vec& D2Normal, gp_Vec& BiNormal, gp_Vec& DBiNormal, gp_Vec& D2BiNormal) Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Get average value of Tangent(t) and Normal(t) it is usful to
//! make fast approximation of rational surfaces.
Standard_EXPORT virtual void GetAverageLaw (gp_Vec& ATangent, gp_Vec& ANormal, gp_Vec& ABiNormal) Standard_OVERRIDE;
//! Say if the law is Constant.
Standard_EXPORT virtual Standard_Boolean IsConstant() const Standard_OVERRIDE;
//! Return True.
Standard_EXPORT virtual Standard_Boolean IsOnlyBy3dCurve() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(GeomFill_DiscreteTrihedron,GeomFill_TrihedronLaw)
protected:
private:
gp_Pnt myPoint;
Handle(GeomFill_HSequenceOfAx2) myTrihedrons;
Handle(TColStd_HSequenceOfReal) myKnots;
Handle(GeomFill_Frenet) myFrenet;
Standard_Boolean myUseFrenet;
};
#endif // _GeomFill_DiscreteTrihedron_HeaderFile
|
/**********************************************************************
axasm Copyright 2006, 2007, 2008, 2009
by Al Williams (alw@al-williams.com).
This file is part of axasm.
axasm is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public Licenses as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
axasm 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 axasm (see LICENSE.TXT).
If not, see http://www.gnu.org/licenses/.
If a non-GPL license is desired, contact the author.
This is the One-Der definition file
***********************************************************************/
#ifndef __SOLO_ASM_INC
#define __SOLO_ASM_INC
#include <stdio.h> // needed for XSYM
#include <stdlib.h>
#include <soloasm.h>
/* Define _SOLO_XSYM to get symbol xref dumped to stderr */
// Define this to override to a different memory size (in words, not bytes!)
#ifndef MAXMEM
#define MAXMEM 99
#endif
static void __setary(unsigned int a, unsigned int v)
{
if (a>=MAXMEM)
{
fprintf(stderr,"Memory overflow, program too large.\n");
_solo_info.err=1;
}
else _solo_info.ary[a]=v;
}
// note ORG is only for first address, use REORG to start over
#define ORG(n) unsigned int genasm(int _solo_pass) { \
unsigned _solo_add=n;\
_solo_info.psize=16; \
_solo_info.begin=n; \
_solo_info.end=n; \
_solo_info.memsize=MAXMEM; \
_solo_info.ary=malloc(_solo_info.memsize*_solo_info.psize); \
_solo_info.err=(_solo_info.ary==NULL)
#define REORG(n) _solo_info.end=((_solo_add)-1)>_solo_info.end?((_solo_add)-1):_solo_info.end; _solo_add=n; _solo_info.begin=(n)<_solo_info.begin?(n):_solo_info.begin
// Assume end is at the highest address
#define END _solo_info.end=_solo_info.end<_solo_add-1?_solo_add-1:_solo_info.end; return _solo_info.end; }
// Note this requires a compiler like gcc that supports var
// declarations inthe middle of a block
#define DEFLABEL(l) static unsigned l
#ifdef _SOLO_XSYM
#define LABEL(l) l=_solo_add; if (_solo_pass==2) fprintf(stderr,"%-32s:\t%08X\n",#l,_solo_add)
#else
#define LABEL(l) l=_solo_add
#endif
#define bcd(n) ((((n)/100)<<8)+((((n)/10)%10)<<4)+((n)%10))
#define DATA(d) __setary(_solo_add++,(bcd(d)))
#define NEGDATA(d) __setary(_solo_add++,0x1000 + bcd(d))
#define INP(r) __setary(_solo_add++,bcd(r))
#define LOD(r) __setary(_solo_add++,bcd(100+(r)))
#define ADD(r) __setary(_solo_add++,bcd(200+(r)))
#define TAC(r) __setary(_solo_add++,bcd(300+(r)))
#define SFT(r,l) __setary(_solo_add++,bcd(400+((r)*10)+(l)))
#define OUT(r) __setary(_solo_add++,bcd(500+(r)))
#define STO(r) __setary(_solo_add++,bcd(600+(r)))
#define SUB(r) __setary(_solo_add++,bcd(700+(r)))
#define JMP(r) __setary(_solo_add++,bcd(800+(r)))
#define HLT __setary(_solo_add++,bcd(900))
#endif
|
// Created on: 1993-05-04
// Created by: Modelistation
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _HLRBRep_ShapeToHLR_HeaderFile
#define _HLRBRep_ShapeToHLR_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BRepTopAdaptor_MapOfShapeTool.hxx>
#include <Standard_Integer.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
class HLRBRep_Data;
class HLRTopoBRep_OutLiner;
class HLRAlgo_Projector;
class TopoDS_Face;
//! compute the OutLinedShape of a Shape with an
//! OutLiner, a Projector and create the Data
//! Structure of a Shape.
class HLRBRep_ShapeToHLR
{
public:
DEFINE_STANDARD_ALLOC
//! Creates a DataStructure containing the OutLiner
//! <S> depending on the projector <P> and nbIso.
Standard_EXPORT static Handle(HLRBRep_Data) Load (const Handle(HLRTopoBRep_OutLiner)& S, const HLRAlgo_Projector& P, BRepTopAdaptor_MapOfShapeTool& MST, const Standard_Integer nbIso = 0);
protected:
private:
Standard_EXPORT static void ExploreFace (const Handle(HLRTopoBRep_OutLiner)& S, const Handle(HLRBRep_Data)& DS, const TopTools_IndexedMapOfShape& FM, const TopTools_IndexedMapOfShape& EM, Standard_Integer& i, const TopoDS_Face& F, const Standard_Boolean closed);
Standard_EXPORT static void ExploreShape (const Handle(HLRTopoBRep_OutLiner)& S, const Handle(HLRBRep_Data)& DS, const TopTools_IndexedMapOfShape& FM, const TopTools_IndexedMapOfShape& EM);
};
#endif // _HLRBRep_ShapeToHLR_HeaderFile
|
#ifndef DFILEDIALOG_H
#define DFILEDIALOG_H
#include <QQuickItem>
#include <xcb/xcb.h>
#include <xcb/xproto.h>
class QWindow;
class QFileDialog;
class DFileDialog : public QQuickItem
{
Q_OBJECT
public:
explicit DFileDialog(QQuickItem *parent = 0);
~DFileDialog();
Q_PROPERTY(QUrl fileUrl READ fileUrl)
Q_PROPERTY(QList<QUrl> fileUrls READ fileUrls)
Q_PROPERTY(QUrl folder READ folder WRITE setFolder)
Q_PROPERTY(Qt::WindowModality modality READ modality WRITE setModality)
Q_PROPERTY(QList<QString> nameFilters READ nameFilters WRITE setNameFilters)
Q_PROPERTY(bool selectExisting READ selectExisting WRITE setSelectExisting)
Q_PROPERTY(bool selectFolder READ selectFolder WRITE setSelectFolder)
Q_PROPERTY(bool selectMultiple READ selectMultiple WRITE setSelectMultiple)
Q_PROPERTY(QString selectedNameFilter READ selectedNameFilter WRITE selectNameFilter)
Q_PROPERTY(QString title READ title WRITE setTitle)
Q_PROPERTY(bool visible READ isVisible WRITE setVisible)
Q_PROPERTY(bool saveMode READ isSaveMode WRITE setSaveMode)
Q_PROPERTY(QString defaultFileName READ defaultFileName WRITE setDefaultFileName)
Q_PROPERTY(QWindow* transientParent READ transientParent WRITE setTransientParent)
QUrl fileUrl();
QList<QUrl> fileUrls();
QUrl folder();
void setFolder(QUrl folder);
Qt::WindowModality modality();
void setModality(Qt::WindowModality modality);
QStringList nameFilters();
void setNameFilters(QStringList nameFilters);
QString selectedNameFilter();
void selectNameFilter(QString nameFilter);
bool selectExisting();
void setSelectExisting(bool selectExisting);
bool selectFolder();
void setSelectFolder(bool selectFolder);
bool selectMultiple();
void setSelectMultiple(bool selectMultiple);
QString title();
void setTitle(QString title);
bool isVisible();
void setVisible(bool visible);
bool isSaveMode();
void setSaveMode(bool saveMode);
QString defaultFileName();
void setDefaultFileName(QString defaultFileName);
QWindow* transientParent();
void setTransientParent(QWindow*);
Q_INVOKABLE void open();
Q_INVOKABLE void close();
signals:
void accepted();
void rejected();
private:
xcb_connection_t *m_conn;
QFileDialog *m_fileDialog;
bool m_selectMultiple;
bool m_selectExisting;
bool m_selectFolder;
QString m_defaultFileName;
QWindow *m_transientParent;
QString m_domain;
void setFileModeInternal();
void checkFileNameDuplication();
void setTransientParentInternal();
QString tr(const char*, bool flag);
private slots:
void directoryEnteredSlot(const QString&);
};
#endif // DFILEDIALOG_H
|
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) Triad National Security, LLC. This file is part of the
// Tusas code (LA-CC-17-001) and is subject to the revised BSD license terms
// in the LICENSE file found in the top-level directory of this distribution.
//
//////////////////////////////////////////////////////////////////////////////
#include "timestep.hpp"
//timestep::timestep(){}
//timestep::~timestep(){}
//void timestep::initialize(){}
//void timestep::advance(){}
//void timestep::finalize(){}
//int timestep::get_elapsedSteps{return elapsedSteps;};
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 1995-2007 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
*/
#ifndef VEGA_BACKENDS_MODULE_H
#define VEGA_BACKENDS_MODULE_H
#include "modules/hardcore/opera/module.h"
#ifdef VEGA_BACKENDS_BLOCKLIST_FETCH
#include "modules/hardcore/mh/messobj.h"
#include "modules/url/url2.h"
#include "modules/util/OpHashTable.h"
#include "platforms/vega_backends/vega_blocklist_device.h"
/// helper struct for url loading - these are stored in a hash table with url.Id() as key
struct BlocklistUrlObj
{
URL url; ///< the URL of the blocklist file
VEGABlocklistDevice::BlocklistType type; ///< the type of the blocklist file
};
/**
a hash of blocklist files currently being downloaded
*/
class AutoBlocklistUrlHashTable : public OpHashTable
{
public:
~AutoBlocklistUrlHashTable() { DeleteAll(); }
/// get BlocklistUrlObj associated with id
BlocklistUrlObj* Get(URL_ID id)
{
BlocklistUrlObj* o;
if (OpStatus::IsError(GetData((void*)id, (void**)&o)))
return 0;
return o;
}
/// add a BlocklistUrlObj to the hash
OP_STATUS Add(BlocklistUrlObj* o) { return OpHashTable::Add((void*)o->url.Id(), o); }
/// remove a BlocklistUrlObj from the hash
OP_STATUS Remove(BlocklistUrlObj* o) { return OpHashTable::Remove((void*)o->url.Id(), (void**)&o); }
/// delete a BlocklistUrlObj
void Delete(void* d) { OP_DELETE(static_cast<BlocklistUrlObj*>(d)); }
};
#endif // VEGA_BACKENDS_BLOCKLIST_FETCH
class VegaBackendsModule : public OperaModule
#ifdef VEGA_BACKENDS_BLOCKLIST_FETCH
, public MessageObject
#endif // VEGA_BACKENDS_BLOCKLIST_FETCH
{
public:
VegaBackendsModule()
#ifdef SELFTEST
: m_selftest_blocklist_url(0)
#endif // SELFTEST
{}
virtual void InitL(const OperaInitInfo& info) {}
virtual void Destroy()
{
#ifdef VEGA_BACKENDS_BLOCKLIST_FETCH
m_blocklist_url_hash.DeleteAll();
#endif // VEGA_BACKENDS_BLOCKLIST_FETCH
}
#ifdef VEGA_BACKENDS_BLOCKLIST_FETCH
void HandleCallback(OpMessage msg, MH_PARAM_1 par1, MH_PARAM_2 par2);
/// trigger download of the blocklist file associated with type in delay ms
void FetchBlocklist(VEGABlocklistDevice::BlocklistType type, unsigned long delay);
#endif // VEGA_BACKENDS_BLOCKLIST_FETCH
OpStringC GetCreationStatus() { return creation_status; }
void SetCreationStatus(const OpStringC& status) { creation_status = status; }
private:
#ifdef VEGA_BACKENDS_BLOCKLIST_FETCH
/// download the blocklist file associated with type
OP_STATUS FetchBlocklist(VEGABlocklistDevice::BlocklistType type);
/// list of currently loading blocklist files
AutoBlocklistUrlHashTable m_blocklist_url_hash;
#endif // VEGA_BACKENDS_BLOCKLIST_FETCH
/// status of last failed attempt to create a 3d backend
OpStringC creation_status;
#ifdef SELFTEST
public:
const uni_char* m_selftest_blocklist_url;
#endif // SELFTEST
};
#define g_vega_backends_module g_opera->vega_backends_module
#define VEGA_BACKENDS_MODULE_REQUIRED
#endif // !VEGA_BACKENDS_MODULE_H
|
#ifndef SRC_DISPLAY_STRING_TRIE_NODE_H
#define SRC_DISPLAY_STRING_TRIE_NODE_H
/**
* HIGH-LEVEL OVERVIEW:
* Return the number of characters to print below the current node so as to
* separate its value from those of its children. Eg.,
* hello
* =========== -> This function determines the number of these characters.
* ab bc cd de
*
* DETAILS:
* Given [parent = "hello", children = {"ab", "bc", "cd", "de"}],
* this helper function would return len("ab") + len("bc") + len("cd")
* + len("de") + 4 - 1 = 2(4) + 3 = 11. We add 4 to the sum of the children
* lengths since there is 1 whitespace after each child. But we subtract 1
* since the last child's value will not be followed by a whitespace.
*/
static size_t getNumSeparators(TrieNode<std::string> &tn)
{
size_t numSeparators = 0;
for (int i = 0; i < tn.getNumChildren(); i++) {
TrieNode<std::string> *child = tn.getChildAtIndex(i);
std::string val = child->getValue();
numSeparators += val.size() + 1;
}
numSeparators--;
return numSeparators;
}
/**
* Write the current node's value and a line of separator chars to the given stringstream.
* Eg.,
* hello
* =========== -> Used to separate current node from children
*/
static void handleCurrentNode(TrieNode<std::string> &tn, std::stringstream &strStream)
{
const char SEPARATOR = '=';
size_t parentNodeLen = tn.getValue().size();
size_t numSeparators = getNumSeparators(tn);
// Center parent based on number of separators if the latter is longer.
if (numSeparators > parentNodeLen) {
strStream << std::string(numSeparators / 2 - 2, ' ');
}
// Otherwise, set the number of separators to the parent's length and
// don't indent the parent. In displayNode below, we will indent the
// children instead.
else {
numSeparators = parentNodeLen;
}
strStream << tn.getValue() << std::endl;
strStream << std::string(numSeparators, SEPARATOR) << std::endl;
}
/**
* Template specialization / overloaded version of displayNode in trieNode.h
* Specifies how a single TrieNode<string> should be displayed.
*/
inline std::string displayNode(TrieNode<std::string> &tn)
{
std::stringstream strStream;
size_t parentLen = tn.getValue().size();
size_t numSeparators = getNumSeparators(tn);
// parent node + separators
handleCurrentNode(tn, strStream);
// child nodes
TrieNode<std::string> *firstChild = tn.getChildAtIndex(0);
if (firstChild != NULL && numSeparators < parentLen) {
strStream << std::string(parentLen / 2 - 2, ' ');
}
int nc = tn.getNumChildren();
for (int i = 0; i < nc; i++) {
TrieNode<std::string> *child = tn.getChildAtIndex(i);
strStream << child->getValue();
if (i != nc-1) {
strStream << "|";
}
}
return strStream.str();
}
#endif // SRC_DISPLAY_STRING_TRIE_NODE_H
|
#ifndef SOAP_SRC_EDLPROVIDERSERVERTHREAD_H
#define SOAP_SRC_EDLPROVIDERSERVERTHREAD_H
#include <QThread>
namespace edlprovider
{
namespace soap
{
/*!
* \brief The EdlProviderServerThread class is simply a helper to launch the Edl provider soap server in a separate thread.
*/
class EdlProviderServerThread : public QThread
{
public:
/*!
* \brief EdlProviderServerThread constructor.
*/
EdlProviderServerThread();
};
}
}
#endif // SOAP_SRC_EDLPROVIDERSERVERTHREAD_H
|
#ifndef TENSORPRODDENSE_H
#define TENSORPRODDENSE_H
#include <vector>
#include <complex>
#include <Eigen/SparseCore>
//#include "sparseMat.h"
using namespace Eigen;
using namespace std;
typedef std::complex<double> Complex;
typedef Eigen::Triplet<Complex> T;
typedef Eigen::SparseMatrix<Complex,RowMajor> SpMat;
//typedef struct { Complex* q; int dim; } QReg;
//typedef struct { Complex* val; int* row; int* col; int nVal; int nRows; int nCols; } sparseCSR;
/*
QReg tensorProdDense(QReg a, QReg b) {
// Computes the tensor product between two quantum registers.
// A single qubit is defined as a quantum register of dimension 2.
// Example usage:
// QReg prod = tensorProd(&qbitA, &qbitB);
// --> qbitA and qbitB are both of type QReg
// Initialize output Qreg. It has a dimension of the a.dim * b.dim.
QReg prod;
prod.dim = a.dim * b.dim;
prod.q = new Complex[prod.dim];
// Store Complex array pointers and size because openACC does not handle struct objects well.
Complex* aq = a.q;
int aN = a.dim;
Complex* bq = b.q;
int bN = b.dim;
Complex* prodq = prod.q;
int prodN = prod.dim;
// Perform tensor product to populate prod
#pragma acc data copy(prodq[0:prodN]) copyin(aq[0:aN]) copyin(bq[0:bN])
#pragma acc parallel loop
for (int i = 0; i < aN; i++) {
for (int j = 0; j < bN; j++) {
prodq[i * bN + j] = aq[i] * bq[j];
}
}
return prod;
}
*/
SpMat tensorProdSparse(SpMat A, SpMat B) {
std::vector<T> tripletList;
tripletList.reserve(A.nonZeros() * B.nonZeros());
for (int r_A = 0; r_A < A.outerSize(); ++r_A) {
for (int r_B = 0; r_B < B.outerSize(); ++r_B) {
for (SpMat::InnerIterator it_A(A, r_A); it_A; ++it_A) {
for (SpMat::InnerIterator it_B(B, r_B); it_B; ++it_B) {
tripletList.push_back(T(it_A.row() * B.outerSize() + it_B.row(), it_A.col() * B.innerSize() + it_B.col(), it_A.value() * it_B.value()));
}
}
}
}
SpMat prod(A.rows() * B.rows(), A.cols() * B.cols());
prod.setFromTriplets(tripletList.begin(), tripletList.end());
return prod;
}
/*
sparseCSR* tensorProdSparse(sparseCSR* a, sparseCSR* b) {
int a_nVal = a->nVal;
int a_nRows = a->nRows;
int a_nCols = a->nCols;
Complex* a_val = a->val;
int* a_row = a->row;
int* a_col = a->col;
int b_nVal = b->nVal;
int b_nRows = b->nRows;
int b_nCols = b->nCols;
Complex* b_val = b->val;
int* b_row = b->row;
int* b_col = b->col;
int p_nVal = a_nVal * b_nVal;
int p_nRows = a_nRows * b_nRows;
int p_nCols = a_nCols * b_nCols;
sparseCSR* prod = new sparseCSR(p_nVal, p_nRows, p_nCols);
Complex* p_val = prod->val;
int* p_row = prod->row;
int* p_col = prod->col;
p_row[0] = 0;
int p_val_ind = 0;
#pragma acc data copyout(p_val[0:p_nVal], p_row[0:p_nRows+1], p_col[0:p_nVal]) copyin(a_val[0:a_nVal], a_row[0:a_nRows+1], a_col[0:a_nVal], b_val[0:b_nVal], b_row[0:b_nRows+1], b_col[0:b_nVal], p_val_ind, a_nRows, b_nRows, b_nCols)
#pragma acc region
{
#pragma acc loop independent seq
for (int r_a = 0; r_a < a_nRows; r_a++) {
#pragma acc loop independent seq
for (int r_b = 0; r_b < b_nRows; r_b++) {
#pragma acc loop independent seq
for (int i = a_row[r_a]; i < a_row[r_a + 1]; i++) {
#pragma acc loop independent seq
for (int j = b_row[r_b]; j < b_row[r_b + 1]; j++) {
p_val[p_val_ind] = a_val[i] * b_val[j];
p_col[p_val_ind] = a_col[i] * b_nCols + b_col[j];
p_val_ind++;
}
}
p_row[r_a * b_nRows + r_b + 1] = p_row[r_a * b_nRows + r_b] + (a_row[r_a + 1] - a_row[r_a]) * (b_row[r_b + 1] - b_row[r_b]);
}
}
}
return prod;
}
*/
#endif
|
#pragma once
template <typename TCollection>
class query_collection
{
private:
TCollection m_Collection;
public:
query_collection(TCollection && collection)
: m_Collection (std::forward<TCollection>(collection))
{
}
auto begin()
{
return m_Collection.begin();
}
auto end()
{
return m_Collection.end();
}
decltype(auto) to_vector()
{
if constexpr (std::is_reference_v<TCollection>)
{
return (m_Collection);
}
else
{
return std::move(m_Collection);
}
}
};
|
#ifndef __QUADRATIC__
#define __QUADRATIC__
#include <cassert>
#include <iostream>
#include "R_Tree.hpp"
using namespace std;
//this will be an R-Tree that does quadratic split
template<typename RTreeType>
class QuadR_Tree : public R_Tree<RTreeType>
{
private:
typename R_Tree<RTreeType>::Node** splitNode(const typename R_Tree<RTreeType>::Node*);
public:
QuadR_Tree(const int& min_records,const int& max_records) : R_Tree<RTreeType>(min_records, max_records){}
~QuadR_Tree(){}
};
// This function will do the Guttman Quadratic split of an R-Tree
template<typename RTreeType>
typename R_Tree<RTreeType>::Node** QuadR_Tree<RTreeType>::splitNode(const typename R_Tree<RTreeType>::Node* curr_node)
{
typename R_Tree<RTreeType>::Node** new_nodes = new typename R_Tree<RTreeType>::Node*[2];
new_nodes[0] = new typename R_Tree<RTreeType>::Node(R_Tree<RTreeType>::getMaxRecords());
new_nodes[1] = new typename R_Tree<RTreeType>::Node(R_Tree<RTreeType>::getMaxRecords());
int* inserted = new int[curr_node->curr_records_num];
for(int i = 0; i < curr_node->curr_records_num; i++){
inserted[i] = 0;
}
// Picking the first point of each group
typename R_Tree<RTreeType>::Node::Record* max_rec_1 = NULL;
typename R_Tree<RTreeType>::Node::Record* max_rec_2 = NULL;
int max_rec_1_index;
int max_rec_2_index;
float max_d;
for(int i = 0; i < curr_node->curr_records_num; i++){
typename R_Tree<RTreeType>::Node::Record* cand_rec_1 = curr_node->records[i];
for(int j = i + 1; j < curr_node->curr_records_num; j++){
typename R_Tree<RTreeType>::Node::Record* cand_rec_2 = curr_node->records[j];
float curr_d = new_bounding_box(cand_rec_1->bounding_box, cand_rec_2->bounding_box).getArea();
curr_d -= cand_rec_1->bounding_box.getArea();
curr_d -= cand_rec_2->bounding_box.getArea();
if(curr_d > max_d || (i == 0 && j == 1)){
max_rec_1 = cand_rec_1;
max_rec_2 = cand_rec_2;
max_rec_1_index = i;
max_rec_2_index = j;
max_d = curr_d;
}
}
}
assert(max_rec_2_index != max_rec_1_index);
assert(max_rec_1 != max_rec_2);
inserted[max_rec_1_index] = 1;
inserted[max_rec_2_index] = 1;
new_nodes[0]->addRecord(max_rec_1);
if(new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child != NULL){
new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child->parent_node = new_nodes[0];
new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child->parent_record = new_nodes[0]->records[new_nodes[0]->curr_records_num - 1];
}
new_nodes[1]->addRecord(max_rec_2);
if(new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child != NULL){
new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child->parent_node = new_nodes[1];
new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child->parent_record = new_nodes[1]->records[new_nodes[1]->curr_records_num - 1];
}
Rectangle group_1_bb = max_rec_1->bounding_box;
Rectangle group_2_bb = max_rec_2->bounding_box;
int insert_count = 2;
for(int i = 2; i < curr_node->curr_records_num;i++){
// The two cases below are the cases that we should give the rest records to
// a node because if not will be underfull
if((new_nodes[0]->curr_records_num < R_Tree<RTreeType>::getMinRecords()) &&
((new_nodes[0]->curr_records_num + (curr_node->curr_records_num - insert_count)) == R_Tree<RTreeType>::getMinRecords()) )
{
for(int j = 0; j < curr_node->curr_records_num;j++){
if(inserted[j]) continue;
new_nodes[0]->addRecord(curr_node->records[j]);
if(new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child != NULL)
{
new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child->parent_node = new_nodes[0];
new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child->parent_record = new_nodes[0]->records[new_nodes[0]->curr_records_num - 1];
}
inserted[j] = 1;
insert_count++;
}
break;
}
if((new_nodes[1]->curr_records_num < R_Tree<RTreeType>::getMinRecords()) &&
((new_nodes[1]->curr_records_num + (curr_node->curr_records_num - insert_count)) == R_Tree<RTreeType>::getMinRecords()) )
{
for(int j = 0; j < curr_node->curr_records_num;j++){
if(inserted[j]) continue;
new_nodes[1]->addRecord(curr_node->records[j]);
if(new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child != NULL)
{
new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child->parent_node = new_nodes[1];
new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child->parent_record = new_nodes[1]->records[new_nodes[1]->curr_records_num - 1];
}
inserted[j] = 1;
insert_count++;
}
break;
}
// Picking next
typename R_Tree<RTreeType>::Node::Record* next_rec;
int next_rec_index;
float max_enlargement_diff = -1.0;
float max_enlargement_group_1;
float max_enlargement_group_2;
for(int j = 0; j < curr_node->curr_records_num; j++){
if(inserted[j]) continue;
typename R_Tree<RTreeType>::Node::Record* curr_rec = curr_node->records[j];
float group_1_area = group_1_bb.getArea();
float group_2_area = group_2_bb.getArea();
float enlargement_group_1 = new_bounding_box(group_1_bb, curr_rec->bounding_box).getArea() - group_1_bb.getArea();
float enlargement_group_2 = new_bounding_box(group_2_bb, curr_rec->bounding_box).getArea() - group_2_bb.getArea();
float enlargement_diff = abs(enlargement_group_1 - enlargement_group_2);
if(enlargement_diff > max_enlargement_diff){
max_enlargement_diff = enlargement_diff;
next_rec = curr_rec;
next_rec_index = j;
max_enlargement_group_1 = enlargement_group_1;
max_enlargement_group_2 = enlargement_group_2;
}
}
assert(max_enlargement_diff >= 0.0);
//Resolving ties in advance
if(max_enlargement_group_1 == max_enlargement_group_2){
if(group_1_bb.getArea() < group_2_bb.getArea()){
max_enlargement_group_1 -= 1.0;
}else{
max_enlargement_group_2 -= 1.0;
}
}
// Inserting the max record into a group
if(max_enlargement_group_1 < max_enlargement_group_2){
new_nodes[0]->addRecord(next_rec);
if(new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child != NULL)
{
new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child->parent_node = new_nodes[0];
new_nodes[0]->records[new_nodes[0]->curr_records_num - 1]->child->parent_record = new_nodes[0]->records[new_nodes[0]->curr_records_num - 1];
}
assert(!inserted[next_rec_index]);
inserted[next_rec_index] = 1;
insert_count++;
group_1_bb = new_bounding_box(group_1_bb, next_rec->bounding_box);
}
else{
new_nodes[1]->addRecord(next_rec);
if(new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child != NULL)
{
new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child->parent_node = new_nodes[1];
new_nodes[1]->records[new_nodes[1]->curr_records_num - 1]->child->parent_record = new_nodes[1]->records[new_nodes[1]->curr_records_num - 1];
}
assert(!inserted[next_rec_index]);
inserted[next_rec_index] = 1;
insert_count++;
group_2_bb = new_bounding_box(group_2_bb, next_rec->bounding_box);
}
}
for(int i = 0; i < curr_node->curr_records_num;i++){
assert(inserted[i] == 1);
}
assert(insert_count == curr_node->curr_records_num);
assert((new_nodes[0]->curr_records_num + new_nodes[1]->curr_records_num) == curr_node->curr_records_num);
assert(new_nodes[0]->curr_records_num >= R_Tree<RTreeType>::getMinRecords());
assert(new_nodes[1]->curr_records_num >= R_Tree<RTreeType>::getMinRecords());
delete[] inserted;
return new_nodes;
}
#endif
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2009 Opera Software ASA. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*/
#include "core/pch.h"
#ifdef DOM_JIL_API_SUPPORT
#include "modules/dom/src/domjil/domjildatanetworkinfo.h"
#include "modules/doc/frm_doc.h"
#include "modules/ecmascript_utils/esasyncif.h"
#include "modules/pi/device_api/OpTelephonyNetworkInfo.h"
#include "modules/dom/src/domjil/utils/jilutils.h"
/* static */ OP_STATUS
DOM_JILDataNetworkInfo::Make(DOM_JILDataNetworkInfo*& data_network_info, DOM_Runtime* runtime)
{
data_network_info = OP_NEW(DOM_JILDataNetworkInfo, ());
RETURN_IF_ERROR(data_network_info->DOMSetObjectRuntime(data_network_info, runtime, runtime->GetPrototype(DOM_Runtime::JIL_DATANETWORKINFO_PROTOTYPE), "DataNetworkInfo"));
if (g_DOM_jilUtils->IsJILApiRequested(JILFeatures::JIL_API_DATANETWORKCONNECTIONTYPES, runtime))
{
ES_Value data_network_connection_types_value;
data_network_connection_types_value.type = VALUE_OBJECT;
RETURN_IF_ERROR(MakeDataNetworkConnectionTypes(data_network_connection_types_value.value.object, runtime));
RETURN_IF_ERROR(runtime->PutName(data_network_info->GetNativeObject(), UNI_L("DataNetworkConnectionTypes"), data_network_connection_types_value, PROP_READ_ONLY | PROP_DONT_DELETE));
}
return OpNetworkInterfaceManager::Create(&data_network_info->m_network_interface_manager, data_network_info);
}
DOM_JILDataNetworkInfo::DOM_JILDataNetworkInfo()
: m_on_network_connection_changed(NULL)
, m_network_interface_manager(NULL)
, m_http_connection(NULL)
{
}
DOM_JILDataNetworkInfo::~DOM_JILDataNetworkInfo()
{
OP_DELETE(m_network_interface_manager);
}
/* virtual */ void
DOM_JILDataNetworkInfo::GCTrace()
{
DOM_JILObject::GCTrace();
GCMark(m_on_network_connection_changed);
}
OpNetworkInterface* DOM_JILDataNetworkInfo::GetActiveNetworkInterface()
{
RETURN_VALUE_IF_ERROR(m_network_interface_manager->BeginEnumeration(), NULL);
OpNetworkInterface* current_interface = NULL;
OpNetworkInterface* retval = NULL;
while (current_interface = m_network_interface_manager->GetNextInterface())
{
if (current_interface->GetStatus() == NETWORK_LINK_UP)
{
retval = current_interface;
break;
}
}
m_network_interface_manager->EndEnumeration();
return retval;
}
BOOL DOM_JILDataNetworkInfo::IsDataNetworkConnected()
{
return GetActiveNetworkInterface() ? TRUE : FALSE;
}
const uni_char* DOM_JILDataNetworkInfo::GetConnectionTypeString(OpNetworkInterface* network_interface)
{
OpNetworkInterface::NetworkType type = network_interface->GetNetworkType();
switch (type)
{
case OpNetworkInterface::ETHERNET:
return UNI_L("ethernet");
case OpNetworkInterface::CELLULAR_RADIO:
{
OpTelephonyNetworkInfo::RadioDataBearer bearer;
if (OpStatus::IsError(g_op_telephony_network_info->GetRadioDataBearer(&bearer)))
break;
switch (bearer)
{
case OpTelephonyNetworkInfo::RADIO_DATA_CSD:
return UNI_L("csd");
case OpTelephonyNetworkInfo::RADIO_DATA_GPRS:
return UNI_L("gprs");
case OpTelephonyNetworkInfo::RADIO_DATA_EDGE:
return UNI_L("edge");
case OpTelephonyNetworkInfo::RADIO_DATA_HSCSD:
return UNI_L("hscsd");
case OpTelephonyNetworkInfo::RADIO_DATA_EVDO:
return UNI_L("evdo");
case OpTelephonyNetworkInfo::RADIO_DATA_LTE:
return UNI_L("lte");
case OpTelephonyNetworkInfo::RADIO_DATA_UMTS:
return UNI_L("umts");
case OpTelephonyNetworkInfo::RADIO_DATA_HSPA:
return UNI_L("hspa");
case OpTelephonyNetworkInfo::RADIO_DATA_ONEXRTT:
return UNI_L("onexrtt");
}
break;
}
case OpNetworkInterface::IRDA:
return UNI_L("irda");
case OpNetworkInterface::WIFI:
return UNI_L("wifi");
case OpNetworkInterface::DIRECT_PC_LINK:
return UNI_L("cable");
case OpNetworkInterface::BLUETOOTH:
return UNI_L("bluetooth");
}
return UNI_L("unknown");
}
ES_GetState
DOM_JILDataNetworkInfo::GetNetworkConnectonType(ES_Value* value, DOM_Object* this_object, DOM_Runtime* origining_runtime, ES_Value* restart_value)
{
ES_Object* es_result_array = NULL;
GET_FAILED_IF_ERROR(origining_runtime->CreateNativeArrayObject(&es_result_array));
GET_FAILED_IF_ERROR(m_network_interface_manager->BeginEnumeration());
OpNetworkInterface* current_interface = NULL;
int index = 0;
OP_STATUS error = OpStatus::OK;
OpINT32Set interfaces;
while (current_interface = m_network_interface_manager->GetNextInterface())
{
if (interfaces.Contains(current_interface->GetNetworkType())) // only one interface of a specific type allowed
continue;
ES_Value type_val;
DOMSetString(&type_val, GetConnectionTypeString(current_interface));
OP_STATUS error = origining_runtime->PutIndex(es_result_array, index, type_val);
if (OpStatus::IsError(error))
break;
error = interfaces.Add(current_interface->GetNetworkType());
if (OpStatus::IsError(error))
break;
++index;
}
m_network_interface_manager->EndEnumeration();
GET_FAILED_IF_ERROR(error);
DOMSetObject(value, es_result_array);
return GET_SUCCESS;
}
/* virtual */ ES_GetState
DOM_JILDataNetworkInfo::InternalGetName(OpAtom property_atom, ES_Value* value, DOM_Runtime* origining_runtime, ES_Value* restart_value)
{
switch (property_atom)
{
case OP_ATOM_onNetworkConnectionChanged:
{
DOMSetObject(value, m_on_network_connection_changed);
return GET_SUCCESS;
}
case OP_ATOM_isDataNetworkConnected:
{
if (value)
DOMSetBoolean(value, IsDataNetworkConnected());
return GET_SUCCESS;
}
case OP_ATOM_networkConnectionType:
{
if (value)
return GetNetworkConnectonType(value, this, origining_runtime, restart_value);
return GET_SUCCESS;
}
}
return GET_FAILED;
}
/* virtual */ ES_PutState
DOM_JILDataNetworkInfo::InternalPutName(OpAtom property_atom, ES_Value* value, DOM_Runtime* origining_runtime, ES_Value* restart_value)
{
switch (property_atom)
{
case OP_ATOM_onNetworkConnectionChanged:
{
OP_ASSERT(restart_value == NULL);
switch (value->type)
{
case VALUE_OBJECT:
m_on_network_connection_changed = value->value.object;
m_http_connection = GetActiveNetworkInterface(); //
return PUT_SUCCESS;
case VALUE_NULL:
m_on_network_connection_changed = NULL;
return PUT_SUCCESS;
}
return DOM_PUTNAME_DOMEXCEPTION(TYPE_MISMATCH_ERR);
}
case OP_ATOM_isDataNetworkConnected:
case OP_ATOM_networkConnectionType:
return PUT_SUCCESS;
}
return PUT_FAILED;
}
/* static */ int
DOM_JILDataNetworkInfo::getNetworkConnectionName(DOM_Object *this_object, ES_Value* argv, int argc, ES_Value* return_value, DOM_Runtime* origining_runtime)
{
DOM_THIS_OBJECT(this_, DOM_TYPE_JIL_DATANETWORKINFO, DOM_JILDataNetworkInfo);
DOM_CHECK_ARGUMENTS_JIL("s");
const uni_char* connection_type = argv[0].value.string;
CALL_FAILED_IF_ERROR_WITH_HANDLER(this_->m_network_interface_manager->BeginEnumeration(), HandleJILError);
OpNetworkInterface* current_interface = NULL;
while (current_interface = this_->m_network_interface_manager->GetNextInterface())
if (uni_str_eq(connection_type, GetConnectionTypeString(current_interface))) // should it be case sensitive?
break;
this_->m_network_interface_manager->EndEnumeration();
if (!current_interface)
return CallException(DOM_Object::JIL_INVALID_PARAMETER_ERR, return_value, origining_runtime, UNI_L("Unknown interface type"));
OpString interface_name;
switch (current_interface->GetNetworkType())
{
case OpNetworkInterface::CELLULAR_RADIO:
CALL_FAILED_IF_ERROR_WITH_HANDLER(current_interface->GetAPN(&interface_name), HandleJILError);
break;
case OpNetworkInterface::WIFI:
CALL_FAILED_IF_ERROR_WITH_HANDLER(current_interface->GetSSID(&interface_name), HandleJILError);
break;
default:
CALL_FAILED_IF_ERROR_WITH_HANDLER(current_interface->GetId(&interface_name), HandleJILError);
break;
}
TempBuffer* buffer = GetEmptyTempBuf();
CALL_FAILED_IF_ERROR(buffer->Append(interface_name.CStr()));
DOMSetString(return_value, buffer);
return ES_VALUE;
}
void DOM_JILDataNetworkInfo::CheckHTTPConnection()
{
if (!m_on_network_connection_changed)
return; // no need to do anything if there is no handler set
OpNetworkInterface *http_connection = GetActiveNetworkInterface();
if (http_connection == m_http_connection)
return; // nothing is changed - no need to report anything
m_http_connection = http_connection;
if (http_connection == NULL)
return; // only a new connection should cause a function call to onNetworkConnectionChanged
ES_AsyncInterface* async_if = GetFramesDocument()->GetESAsyncInterface();
if (async_if == NULL)
return; // no way of reporting error specified in JIL
OpString interface_name;
RETURN_VOID_IF_ERROR(http_connection->GetId(&interface_name));
ES_Value argv[1];
DOMSetString(&(argv[0]), interface_name.CStr());
RETURN_VOID_IF_ERROR(async_if->CallFunction(m_on_network_connection_changed, GetNativeObject(), 1, argv));
}
/* virtual */
void DOM_JILDataNetworkInfo::OnInterfaceAdded(OpNetworkInterface* network_interface)
{
CheckHTTPConnection();
}
/* virtual */
void DOM_JILDataNetworkInfo::OnInterfaceRemoved(OpNetworkInterface* network_interface)
{
CheckHTTPConnection();
}
/* virtual */
void DOM_JILDataNetworkInfo::OnInterfaceChanged(OpNetworkInterface* network_interface)
{
CheckHTTPConnection();
}
/* static */
OP_STATUS DOM_JILDataNetworkInfo::MakeDataNetworkConnectionTypes(ES_Object*& data_network_connection_types, DOM_Runtime* runtime)
{
RETURN_IF_ERROR(runtime->CreateNativeObjectObject(&data_network_connection_types));
ES_Value value;
DOMSetString(&value, UNI_L("bluetooth"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("BLUETOOTH"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("edge"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("EDGE"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("evdo"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("EVDO"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("gprs"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("GPRS"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("irda"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("IRDA"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("lte"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("LTE"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("onexrtt"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("ONEXRTT"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("umts"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("UMTS"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
DOMSetString(&value, UNI_L("wifi"));
RETURN_IF_ERROR(runtime->PutName(data_network_connection_types, UNI_L("WIFI"), value, PROP_READ_ONLY | PROP_DONT_DELETE));
return OpStatus::OK;
}
#include "modules/dom/src/domglobaldata.h"
DOM_FUNCTIONS_START(DOM_JILDataNetworkInfo)
DOM_FUNCTIONS_WITH_SECURITY_RULE(DOM_JILDataNetworkInfo, DOM_JILDataNetworkInfo::getNetworkConnectionName, "getNetworkConnectionName", "s-", "DataNetworkInfo.getNetworkConnectionName")
DOM_FUNCTIONS_END(DOM_JILDataNetworkInfo)
#endif // DOM_JIL_API_SUPPORT
|
#include <gtkmm.h>
#include "../../core/Process.h"
#include "../../core/CommandDescriptor.h"
class CommandPage : public Gtk::Box
{
public:
CommandPage(Gtk::Window *parent);
void loadCommandDescriptor(CommandDescriptor *descriptor);
void reset();
void render();
void monitorChildProcess();
void onClickBack();
void onFormChanged();
void onClickExecute();
void onProcessCompleted();
sigc::signal<void> signal_clicked_back;
private:
Gtk::Window *parent;
Gtk::Grid contentArea;
Gtk::TextView terminal;
Gtk::Button stopStartButton;
std::map<std::string*, VariableEntryWidgetGTK*> textEntries;
CommandDescriptor commandDescriptor;
std::string command;
std::string output;
bool commandRunning;
Process *process;
void generateCommand();
};
|
#pragma once
#include "../MonsterAction.h"
class Act_Ignite : public MonsterAction
{
public:
Act_Ignite();
bool Action(Monster* me) override;
private:
bool Chase(Monster* me);
bool Attack(Monster* me);
enum state
{
enSChase,
enSAttack,
};
state m_state = enSChase;
bool m_first = true;
float m_cost = 20.f;
float m_timer = 0;
int m_cooltime = 5;
float m_damage = 0.01f;
float m_SkillRange = 300;
CVector3 m_efs = CVector3::One() * 3.5;
};
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
int months[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int n, m;
struct Solution {
string solve() { // sliding
string s;
vector<int> times;
int start = 0;
getline(cin, s); // discard the \n
while (getline(cin, s)) {
int month = stoi(s.substr(5, 2));
int day = stoi(s.substr(8, 2));
int hour = stoi(s.substr(11, 2));
int min = stoi(s.substr(14, 2));
int second = stoi(s.substr(17, 2));
int sec = second + min * 60 + hour * 3600 + day * 24 * 3600;
for (int i = 0; i + 1 < month; i++) sec += months[i] * 24 * 3600;
while (start < times.size() && times[start] + n <= sec) start++;
times.push_back(sec);
if (times.size() - start >= m) {
return s.substr(0, 19);
}
}
return "-1";
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
Solution test;
cout << test.solve() << endl;
}
|
#ifndef __QUEUE_CPP
#define __QUEUE_CPP
#include "queue.h"
#include <iostream>
using namespace std;
template <class T>
Queue<T>::Queue()
{
vipCount = 0;
}
template <class T>
Queue<T>::Queue(const Queue<T>& otherQueue)
{
vipCount = otherQueue.vipCount;
int len = otherQueue.list.length();
ListItem<T> *ptr = otherQueue.list.getHead();
for (int i = 0; i < len; i++)
{
list.insertAtTail(ptr->value);
ptr = ptr->next;
}
}
template <class T>
Queue<T>::~Queue()
{
}
template <class T>
void Queue<T>::enqueue(T item)
{
list.insertAtTail(item);
}
template <class T>
T Queue<T>::front()
{
return list.getHead()->value;
}
template <class T>
T Queue<T>::dequeue()
{
if (vipCount > 0)
{
vipCount--;
}
T temp = list.getHead()->value;
list.deleteHead();
return temp;
}
template <class T>
int Queue<T>::length()
{
return list.length();
}
template <class T>
bool Queue<T>::isEmpty()
{
if (list.length() == 0)
{
return true;
}
return false;
}
template <class T>
void Queue<T>::AddVip(T item)
{
ListItem<T> *ptr = list.getHead();
if (vipCount == 0)
{
list.insertAtHead(item);
}
else
{
for (int i = 1; i < vipCount; i++)
{
ptr = ptr->next;
}
list.insertAfter(item, ptr->value);
}
vipCount++;
}
#endif
|
// ImageFilter2D.cpp
//
// This example demonstrates performing gaussian filtering on a 2D image using
// OpenCL
//
// Requires FreeImage library for image I/O:
// http://freeimage.sourceforge.net/
#include <iostream>
#include <fstream>
#include <sstream>
#include <string.h>
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
#include "FreeImage.h"
#include "../device.hpp"
///
// Load an image using the FreeImage library and create an OpenCL
// image out of it
//
cl_mem LoadImage(cl_context context, char *fileName, int &width, int &height)
{
FREE_IMAGE_FORMAT format = FreeImage_GetFileType(fileName, 0);
FIBITMAP* image = FreeImage_Load(format, fileName);
// Convert to 32-bit image
FIBITMAP* temp = image;
image = FreeImage_ConvertTo32Bits(image);
FreeImage_Unload(temp);
width = FreeImage_GetWidth(image);
height = FreeImage_GetHeight(image);
char *buffer = new char[width * height * 4];
memcpy(buffer, FreeImage_GetBits(image), width * height * 4);
FreeImage_Unload(image);
// Create OpenCL image
cl_image_format clImageFormat;
clImageFormat.image_channel_order = CL_RGBA;
clImageFormat.image_channel_data_type = CL_UNORM_INT8;
cl_int err;
cl_mem clImage;
clImage = clCreateImage2D(context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
&clImageFormat,
width,
height,
0,
buffer,
&err);
if (err != CL_SUCCESS)
{
std::cerr << "Error creating CL image object" << std::endl;
return 0;
}
return clImage;
}
///
// Save an image using the FreeImage library
//
bool SaveImage(char *fileName, char *buffer, int width, int height)
{
FREE_IMAGE_FORMAT format = FreeImage_GetFIFFromFilename(fileName);
FIBITMAP *image = FreeImage_ConvertFromRawBits((BYTE*)buffer, width,
height, width * 4, 32,
0xFF000000, 0x00FF0000, 0x0000FF00);
return (FreeImage_Save(format, image, fileName) == TRUE) ? true : false;
}
///
// Round up to the nearest multiple of the group size
//
size_t roundUp(int groupSize, int globalSize)
{
int r = globalSize % groupSize;
if(r == 0)
{
return globalSize;
}
else
{
return globalSize + groupSize - r;
}
}
///
// main() for HelloBinaryWorld example
//
int ImageFilter2D()
{
cl_kernel kernel = 0;
cl_mem imageObjects[2] = { 0, 0 };
cl_sampler sampler = 0;
cl_int err;
char *file_in = "image_Lena512rgb.bmp";
char *file_out = "image_Lena512rgb_out.bmp";
//! Setup device
Device clDevice;
clDevice.Init();
//! Make sure the device supports images, otherwise exit
cl_bool imageSupport = CL_FALSE;
clGetDeviceInfo(clDevice.DeviceIDs[0], CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool),
&imageSupport, NULL);
if (imageSupport != CL_TRUE)
{
std::cerr << "OpenCL device does not support images." << std::endl;
return 1;
}
//! Init data
int width, height;
imageObjects[0] = LoadImage(clDevice.Context, file_in, width, height);
if (imageObjects[0] == 0)
{
std::cerr << "Error loading: " << std::string(file_in) << std::endl;
return 1;
}
// Create ouput image object
cl_image_format clImageFormat;
clImageFormat.image_channel_order = CL_RGBA;
clImageFormat.image_channel_data_type = CL_UNORM_INT8;
imageObjects[1] = clCreateImage2D(clDevice.Context,
CL_MEM_WRITE_ONLY,
&clImageFormat,
width,
height,
0,
NULL,
&err);
if (err != CL_SUCCESS)
{
std::cerr << "Error creating CL output image object." << std::endl;
return 1;
}
//! Create sampler for sampling image object
sampler = clCreateSampler(clDevice.Context,
CL_FALSE, // Non-normalized coordinates
CL_ADDRESS_CLAMP_TO_EDGE, // Set the color outside edge to color on edge
CL_FILTER_NEAREST,
&err);
if (err != CL_SUCCESS)
{
std::cerr << "Error creating CL sampler object." << std::endl;
return 1;
}
//! Get kernel
std::string kernel_name = "gaussian_filter";
kernel = clDevice.GetKernel(kernel_name);
if (kernel == NULL)
{
std::cerr << "Failed to create kernel" << std::endl;
return 1;
}
//! Set the kernel arguments
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &imageObjects[0]);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &imageObjects[1]);
err |= clSetKernelArg(kernel, 2, sizeof(cl_sampler), &sampler);
err |= clSetKernelArg(kernel, 3, sizeof(cl_int), &width);
err |= clSetKernelArg(kernel, 4, sizeof(cl_int), &height);
if (err != CL_SUCCESS)
{
std::cerr << "Error setting kernel arguments." << std::endl;
return 1;
}
//! Set global and local work size
size_t localWorkSize[2] = { 16, 16 };
size_t globalWorkSize[2] = { roundUp(localWorkSize[0], width),
roundUp(localWorkSize[1], height) };
//! Excute kernel
err = clEnqueueNDRangeKernel(clDevice.CommandQueue, kernel, 2, NULL,
globalWorkSize, localWorkSize,
0, NULL, NULL);
if (err != CL_SUCCESS)
{
std::cerr << "Error queuing kernel for execution." << std::endl;
return 1;
}
//! Get outputs to host
char *buffer = new char [width * height * 4];
size_t origin[3] = { 0, 0, 0 };
size_t region[3] = { width, height, 1};
err = clEnqueueReadImage(clDevice.CommandQueue, imageObjects[1], CL_TRUE,
origin, region, 0, 0, buffer,
0, NULL, NULL);
if (err != CL_SUCCESS)
{
std::cerr << "Error reading result buffer." << std::endl;
return 1;
}
std::cout << std::endl;
std::cout << "Executed program succesfully." << std::endl;
//! Save the image out to disk
if (!SaveImage(file_out, buffer, width, height))
{
std::cerr << "Error writing output image: " << file_out << std::endl;
delete [] buffer;
return 1;
}
delete [] buffer;
return 0;
}
|
// In order to fix up a vehicle more wheels and glass are required, so they have higher weights.
Parts[] =
{
{Loot_MAGAZINE, 1, PartGeneric},
{Loot_MAGAZINE, 3, PartGlass},
{Loot_MAGAZINE, 1, PartFueltank},
{Loot_MAGAZINE, 3, PartWheel},
{Loot_MAGAZINE, 1, PartEngine}
};
|
/**
* Copyright (c) 2021, Timothy Stack
*
* 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 Timothy Stack 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 REGENTS 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 REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* @file logfmt.parser.hh
*/
#ifndef lnav_logfmt_parser_hh
#define lnav_logfmt_parser_hh
#include "base/intern_string.hh"
#include "base/result.h"
#include "mapbox/variant.hpp"
namespace logfmt {
class parser {
public:
explicit parser(string_fragment sf);
struct end_of_input {};
struct error {
int e_offset;
const std::string e_msg;
};
struct unquoted_value {
string_fragment uv_value;
};
struct quoted_value {
string_fragment qv_value;
};
struct bool_value {
bool bv_value{false};
string_fragment bv_str_value;
};
struct int_value {
int64_t iv_value{0};
string_fragment iv_str_value;
};
struct float_value {
double fv_value{0};
string_fragment fv_str_value;
};
using value_type = mapbox::util::variant<
bool_value,
int_value,
float_value,
unquoted_value,
quoted_value
>;
using kvpair = std::pair<string_fragment, value_type>;
using step_result = mapbox::util::variant<
end_of_input,
kvpair,
error
>;
step_result step();
private:
string_fragment p_next_input;
};
}
#endif
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2011 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*
* Edward Welbourne (based on unix/base/common/mt.cpp by Morten Stenshorne).
*/
#include "core/pch.h"
#ifdef POSIX_OK_THREAD
#include "platforms/posix/posix_thread_util.h"
#include "modules/pi/OpSystemInfo.h"
# ifdef __hpux__ // HP's almost-POSIX threads:
#define pthread_attr_init(a) pthread_attr_create(a)
#define pthread_attr_destroy(x) // no-op
#define pthread_create(h, a, e, a) pthread_create(h, *a, e, a)
# endif // __hpux__
# ifdef DEBUG_ENABLE_OPASSERT
// Expression is either zero (success) or an errno value:
#define ZERO_OR_ERRNO(e) int const res = e; OP_ASSERT(!res)
# else
#define ZERO_OR_ERRNO(e) e
# endif
THREAD_HANDLE PosixThread::CreateThread(void* (*entry)(void*), void* argument)
{
THREAD_HANDLE handle;
pthread_attr_t attr;
pthread_attr_init(&attr);
#ifdef OPERA_LNXJAVA_SVALBARD
pthread_attr_setstacksize(&attr, 128 * 1024);
#endif // OPERA_LNXJAVA_SVALBARD
if (pthread_create(&handle, &attr, entry, argument))
handle = THREAD_HANDLE_NULL;
pthread_attr_destroy(&attr);
return handle;
}
PosixCondition::PosixCondition()
: PosixMutex(MUTEX_RECURSIVE)
#ifdef DEBUG_ENABLE_OPASSERT
, m_locked(0)
#endif
{
ZERO_OR_ERRNO(pthread_cond_init(&m_cond, NULL));
}
PosixCondition::~PosixCondition()
{
ZERO_OR_ERRNO(pthread_cond_destroy(&m_cond));
OP_ASSERT(m_locked == 0);
}
#ifdef DEBUG_ENABLE_OPASSERT
# define POSIX_COND_WAIT_START(condition) \
{ \
PosixCondition::AssertOwner assert_owner(condition); \
POSIX_CLEANUP_PUSH(PosixCondition::AssertOwner::CleanupHandler, &assert_owner)
# define POSIX_COND_WAIT_END(condition) \
POSIX_CLEANUP_POP(); \
}
#else // !DEBUG_ENABLE_OPASSERT
# define POSIX_COND_WAIT_START(condition)
# define POSIX_COND_WAIT_END(condition)
#endif
void PosixCondition::WakeAll()
{
POSIX_CONDITION_GRAB(this);
ZERO_OR_ERRNO(pthread_cond_broadcast(&m_cond));
POSIX_CONDITION_GIVE(this);
}
void PosixCondition::Wake()
{
POSIX_CONDITION_GRAB(this);
ZERO_OR_ERRNO(pthread_cond_signal(&m_cond));
POSIX_CONDITION_GIVE(this);
}
void PosixCondition::Wait(bool grab)
{
if (grab)
{
POSIX_CONDITION_GRAB(this);
Wait(false);
POSIX_CONDITION_GIVE(this);
}
else
{
OP_ASSERT(m_locked > 0);
POSIX_COND_WAIT_START(this);
ZERO_OR_ERRNO(pthread_cond_wait(&m_cond, &m_mutex));
POSIX_COND_WAIT_END(this);
}
}
bool PosixCondition::TimedWait(int delay, bool grab)
{
double abs_msec = g_op_time_info->GetTimeUTC() + delay;
struct timespec ts;
ts.tv_sec = abs_msec / 1000;
ts.tv_nsec = (abs_msec - 1000. * ts.tv_sec) * 1000000;
int err;
if (grab)
{
POSIX_CONDITION_GRAB(this);
POSIX_COND_WAIT_START(this);
err = pthread_cond_timedwait(&m_cond, &m_mutex, &ts);
POSIX_COND_WAIT_END(this);
POSIX_CONDITION_GIVE(this);
}
else
{
OP_ASSERT(m_locked > 0);
POSIX_COND_WAIT_START(this);
err = pthread_cond_timedwait(&m_cond, &m_mutex, &ts);
POSIX_COND_WAIT_END(this);
}
OP_ASSERT(err == 0 || err == ETIMEDOUT); // *not* EINVAL or EPERM
return err == 0;
}
#endif // POSIX_OK_THREAD
|
#include <iostream>
#include <stdlib.h>
using namespace std;
template <typename T>
void sortTab(T* array,int numElem);
int main() {
int intTab[10] = {5,6,3,10,45,33,2,0,5,87};
float floatTab[10] = {1.2,5.1,20.6,5.1,1.1,0.3,0.7,12.3,3.2,20.1};
double doubleTab[10] = {1.20,0.20,12.36,25.36,2.15,3.14,25.3,14.25,1.21,5.21};
char charTab[10] = {'v','A','b','f','r','y','e','g','o','m'};
cout << "Before Sort : " << endl;
cout << "intTab : ";
for (auto item : intTab) {
cout << item << " ";
}
cout << endl;
cout << "floatTab : ";
for (auto item : floatTab) {
cout << item << " ";
}
cout << endl;
cout << "doubleTab : ";
for (auto item : doubleTab) {
cout << item << " ";
}
cout << endl;
cout << "charTab : ";
for (auto item : charTab) {
cout << item << " ";
}
sortTab(intTab,10);
sortTab(doubleTab,10);
sortTab(floatTab,10);
sortTab(charTab,10);
cout << endl << "After Sort : " << endl;
cout << "intTab : ";
for (auto item : intTab) {
cout << item << " ";
}
cout << endl;
cout << "floatTab : ";
for (auto item : floatTab) {
cout << item << " ";
}
cout << endl;
cout << "doubleTab : ";
for (auto item : doubleTab) {
cout << item << " ";
}
cout << endl;
cout << "charTab : ";
for (auto item : charTab) {
cout << item << " ";
}
cout << endl;
system("pause");
return 0;
}
template <typename T>
void sortTab(T* array,int numElem) {
T swap;
for (int i = 0; i < (numElem - 1); i++) {
for (int j = 0; j < numElem - i - 1; j++) {
if(array[j] < array[j+1]) {
swap = array[j];
array[j] = array[j+1];
array[j+1] = swap;
}
}
}
}
|
#include "inifile.h"
int main(int argc, char**argv)
{
std::string file_name = "test.ini";
if (argc == 2) //different ini file passed as command arg
file_name = argv[1];
IniFile ini(file_name);
bool quit;
std::string section,name;
do
{
std::cout << "\n\nSECTION>";
std::getline(std::cin,section, '\n');
if(section == "quit")
quit = true;
else{
std::cout << "NAME>";
std::getline(std::cin,name, '\n');
std::cout << ini.GetProfileString(section, name);
}
}while(!quit);
}
|
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <folly/Optional.h>
#include <quic/dsr/frontend/WriteCodec.h>
namespace quic {
uint32_t writeDSRStreamFrame(
DSRPacketBuilderBase& packetBuilder,
SendInstruction::Builder& instructionBuilder,
StreamId id,
uint64_t offset,
uint64_t writeBufferLen,
uint64_t flowControlLen,
bool fin,
uint64_t bufMetaStartingOffset) {
if (packetBuilder.remainingSpace() == 0) {
return 0;
}
if (writeBufferLen == 0 && !fin) {
throw QuicInternalException(
"No data or fin supplied when writing stream.",
LocalErrorCode::INTERNAL_ERROR);
}
QuicInteger idInt(id);
uint64_t headerSize = sizeof(uint8_t) + idInt.getSize();
if (packetBuilder.remainingSpace() < headerSize) {
VLOG(4) << "No space in packet for stream header. stream=" << id
<< " limit=" << packetBuilder.remainingSpace();
return 0;
}
QuicInteger offsetInt(offset);
if (offset != 0) {
headerSize += offsetInt.getSize();
}
instructionBuilder.setStreamOffset(offset);
uint64_t dataLen = std::min(writeBufferLen, flowControlLen);
dataLen = std::min(dataLen, packetBuilder.remainingSpace() - headerSize);
bool shouldSetFin = fin && dataLen == writeBufferLen;
if (dataLen == 0 && !shouldSetFin) {
return 0;
}
if (packetBuilder.remainingSpace() < headerSize) {
VLOG(4) << "No space in packet for stream header. stream=" << id
<< " limit=" << packetBuilder.remainingSpace();
return 0;
}
DCHECK(dataLen + headerSize <= packetBuilder.remainingSpace());
instructionBuilder.setLength(dataLen);
instructionBuilder.setFin(shouldSetFin);
instructionBuilder.setBufMetaStartingOffset(bufMetaStartingOffset);
return dataLen + headerSize;
}
} // namespace quic
|
#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <array>
#include <fstream>
#include <numeric>
#include <boost/lexical_cast.hpp>
using namespace std;
using namespace boost;
class Creature {
enum Abilities { str, agl, intl, count };
std::array<int, count> abilities;
public:
int get_strength() const { return abilities[str]; }
void set_strength(int value) { abilities[str] = value; }
int sum() const {
return std::accumulate(abilities.begin(), abilities.end(), 0);
}
double average() const {
return sum() / (double)count;
}
int max() const {
return *std::max_element(abilities.begin(), abilities.end() );
}
};
int main() {
Creature orc;
orc.set_strength(100);
std::cout << orc.sum() << " " << orc.average() << " " << orc.max() << std::endl;
return 0;
}
|
#include "dormitory.h"
#include "login.h"
#include "administrator.h"
#include "ui_login.h"
#include "mysql.h"
#include "QMessageBox.h"
QString login::id = "";
login::login(QWidget *parent) :
QDialog(parent),
ui(new Ui::login)
{
ui->setupUi(this);
MySqlInit();
ui->password->setEchoMode(QLineEdit::Password);
}
login::~login()
{
delete ui;
}
void login::on_user_textChanged(const QString &arg1)
{
if(!QString(ui->password->text()).isEmpty()){
ui->ok->setEnabled(!arg1.isEmpty());
}
else
{
ui->ok->setDisabled(true);
}
}
void login::on_password_textChanged(const QString &arg1)
{
if(!QString(ui->user->text()).isEmpty()){
ui->ok->setEnabled(!arg1.isEmpty());
}
else
{
ui->ok->setDisabled(true);
}
}
void login::on_pushButton_2_clicked()
{
close();
}
void login::on_ok_clicked()
{
// login *a=new login;
// a->show();
login::id = ui->user->text();
QString password = ui->password->text();
QString str = QString("id = " + id);
qDebug() << str;
QString pwd = SqlQuery("student", str, "password");
qDebug() << pwd;
if(pwd!=NULL && pwd==password || id == "000000" && password == "000000"){
// if (login::id == "000000")
// {
// administrator m;
// m.exec();//只能给模态（Qdialog，弹出就不能跳过，只能先选完）和application
// }
// else
// {
// dormitory w; //主界面
// w.exec();
// }
login::id = ui->user->text();
accept();
}
else{
QMessageBox::warning(this, tr("Warning"), tr("Incorrect username or password!"), QMessageBox::Yes, QMessageBox::Yes);
this->ui->user->clear();
this->ui->password->clear();
this->ui->user->setFocus();
}
}
|
#include <iostream>
#include <map>
#include <vector>
#include <set>
#include <string>
#include <cstdio>
#include <algorithm>
using namespace std;
int main ()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
map<string, vector<string> > report;
set<string> dishes;
int i;
while (cin >> i) {
cin.ignore();
for (int j=0; j<i; j++) {
string name, dish, line;
size_t index = -1;
getline(cin, name, ' ');
getline(cin, line);
do {
index++;
dish = line.substr(index, line.find(' ', index) - (index));
dishes.insert(dish);
report[dish].push_back(name);
index = line.find(' ', index + 1);
} while (index != string::npos);
}
for (auto dish_name : dishes) {
cout << dish_name << ' ';
sort(report[dish_name].begin(), report[dish_name].end());
for (auto item : report[dish_name]) {
cout << item << ' ';
}
cout << endl;
}
report.clear();
dishes.clear();
cout << endl;
}
return 0;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2007 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*
* @author Arjan van Leeuwen (arjanl)
*/
#ifndef STREAM_BUFFER_H
#define STREAM_BUFFER_H
/**
* @brief A generic stream buffer class
*
* Use this if you want to append data to a buffer multiple times.
*
* Example for a uni_char* buffer:
*
* Declaration: StreamBuffer<uni_char> buffer
* Append data: buffer.Append(string, uni_strlen(string))
*
*/
class GenericStreamBuffer
{
protected:
GenericStreamBuffer();
~GenericStreamBuffer();
OP_STATUS AppendInternal(const char* data, size_t datasize, size_t length);
OP_STATUS ReserveInternal(size_t capacity);
void* ReleaseInternal();
void ResetInternal();
void TakeOverInternal(GenericStreamBuffer& buffer);
void TakeOverInternal(char*& buffer, size_t length);
char* m_buffer;
size_t m_filled;
size_t m_capacity;
};
template<class T>
class StreamBuffer : public GenericStreamBuffer
{
public:
StreamBuffer() {}
/** Append data to the buffer - data will be terminated with 0 after appending
* @param data Data to append
* @param length Length of data to append
*/
OP_STATUS Append(const T* data, size_t length)
{ return AppendInternal(reinterpret_cast<const char*>(data), sizeof(T), length); }
/** Get the data that is in the buffer
*/
const T* GetData() const
{ return reinterpret_cast<T*>(m_buffer); }
/** Reserve a number of items in the buffer
* Call this if you expect the total length of your buffer to not exceed a certain size
* NB: There is no need to reserve an extra item for string terminators!
* @param capacity Number of items to reserve
*/
OP_STATUS Reserve(size_t capacity)
{ return ReserveInternal(sizeof(T) * (capacity + 1)); }
/** Release the data from the buffer (data no longer owned by this buffer)
* @return The released data
*/
T* Release()
{ return static_cast<T*>(ReleaseInternal()); }
/** Get the current capacity of the buffer
*/
size_t GetCapacity() const
{ return (m_capacity / sizeof(T)) - 1; }
/** Get the current fill-rate of the buffer
*/
size_t GetFilled() const
{ return m_filled / sizeof(T); }
/** Reset the buffer
*/
void Reset()
{ return ResetInternal(); }
/** Take over the data contained in another buffer
* @param buffer Buffer to steal data from. This buffer will be empty
* after execution of this function.
*/
void TakeOver(StreamBuffer<T>& buffer)
{ TakeOverInternal(buffer); }
/** Take over the data contained in another buffer
* @param buffer Buffer to steal data from. The buffer should be allocated
* using NEWA(). The 'buffer' pointer will be invalid and should not be
* dereferenced after this method returns. The variable will also be set
* to 0 by this method.
* @param length size of buffer in bytes
*/
void TakeOver(char*& buffer, size_t length)
{ TakeOverInternal(buffer, length); }
private:
StreamBuffer(const StreamBuffer<T>& nocopy);
StreamBuffer& operator=(const StreamBuffer<T>& nocopy);
};
/** Make an OpString from a string-based StreamBuffer
* Executes in constant time (ie. not dependent on string length)
* @param buffer Buffer to convert (will release its data)
* @param string Where to put the converted string
*/
void StreamBufferToOpString(StreamBuffer<uni_char>& buffer, OpString& string);
void StreamBufferToOpString8(StreamBuffer<char>& buffer, OpString8& string);
#endif // STREAM_BUFFER_H
|
//===========================================================================
//! @file AssetManager.h
//! @brief アセット全般管理用クラス
//===========================================================================
#pragma once
//===========================================================================
//! @class AssetManager
//===========================================================================
class AssetManager
{
public:
//-----------------------------------------------------------------------
//! @name シングルトン
//-----------------------------------------------------------------------
//@{
//-----------------------------------------------------------------------
//! @brief インスタンス取得
//! @return 参照インスタンス
//-----------------------------------------------------------------------
static AssetManager& getInstance();
//@}
//-----------------------------------------------------------------------
//! @name 初期化
//-----------------------------------------------------------------------
//@{
private:
//! @brief コンストラクタ
AssetManager();
public:
// @brief デストラクタ
~AssetManager() = default;
//@}
//-----------------------------------------------------------------------
//! @name 取得
//-----------------------------------------------------------------------
//@{
//-----------------------------------------------------------------------
//! @brief モデル取得
//! @param [in] filePath 取得したいモデルファイル名(ファイル名だけでOK)
//! @return モデルのポインタ(受け取る側は、weak_ptr)
//-----------------------------------------------------------------------
std::shared_ptr<AssetModel> getModel(const std::string& filePath) const;
//-----------------------------------------------------------------------
//! @brief システムテクスチャ取得
//! @param [in] type 取得したいシステムテクスチャタイプ
//! @return テクスチャのポインタ(受け取る側は、weak_ptr)
//-----------------------------------------------------------------------
std::shared_ptr<gpu::Texture> getSystemTexture(SYSTEM_TEXTURE type) const;
//-----------------------------------------------------------------------
//! @brief テクスチャ取得
//! @param [in] filePath 取得したいテクスチャファイル名(ファイル名だけでOK)
//! @param [in] isCubemap キューブマップかどうか(作成用に必要)
//! @return テクスチャのポインタ(受け取る側は、weak_ptr)
//-----------------------------------------------------------------------
std::shared_ptr<gpu::Texture> getTexture(const std::string& filePath, bool isCubemap = false) const;
//@}
private:
std::unique_ptr<AssetModelManager> assetModelManager_; //!< モデルマネージャー
std::unique_ptr<AssetTextureManager> assetTextureManager_; //!< テクスチャマネージャー
};
//===========================================================================
//! namespace Asset
//===========================================================================
namespace Asset {
//-----------------------------------------------------------------------
//! @brief モデルの取得
//! @param [in] filePath 取得したいテクスチャファイル名(ファイル名だけでOK)
//! @return モデルのポインタ(受け取る側は、weak_ptr)
//-----------------------------------------------------------------------
std::shared_ptr<AssetModel> getModel(const std::string& filePath);
//-----------------------------------------------------------------------
//! @brief システムテクスチャ取得
//! @param [in] type 取得したいシステムテクスチャタイプ
//! @return テクスチャのポインタ(受け取る側は、weak_ptr)
//-----------------------------------------------------------------------
std::shared_ptr<gpu::Texture> getSystemTexture(SYSTEM_TEXTURE type);
//-----------------------------------------------------------------------
//! @brief テクスチャの取得
//! @param [in] filePath 取得したいテクスチャファイル名(ファイル名だけでOK)
//! @param [in] isCubemap キューブマップかどうか(作成用に必要)
//! @return テクスチャのポインタ(受け取る側は、weak_ptr)
//-----------------------------------------------------------------------
std::shared_ptr<gpu::Texture> getTexture(const std::string& filePath, bool isCubemap = false);
} // namespace Asset
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
**
** Copyright (C) 2000-2008 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser.
** It may not be distributed under any circumstances.
**
** Yngve Pettersen
*/
#ifndef LIBSSL_PREMASTER_H
#define LIBSSL_PREMASTER_H
#if defined _NATIVE_SSL_SUPPORT_
#include "modules/libssl/base/sslprotver.h"
#include "modules/libssl/handshake/randfield.h"
#define SSL_PREMASTERLENGTH 48
#define SSL_PREMASTERRANDOMLENGTH 46
class SSL_PreMasterSecret: public SSL_Handshake_Message_Base
{
private:
SSL_ProtocolVersion client_version;
SSL_Random random;
friend class SSL_EncryptedPreMasterSecret;
public:
SSL_PreMasterSecret();
virtual ~SSL_PreMasterSecret();
void Generate(){random.Generate();};
//const byte *GetPremasterRandom(){return random.GetDirect();};
void SetVersion(const SSL_ProtocolVersion &ver){client_version = ver;};
#ifdef SSL_SERVER_SUPPORT
SSL_ProtocolVersion GetVersion() const{return client_version;};
virtual BOOL Valid(SSL_Alert *msg=NULL) const;
#endif
#ifdef _DATASTREAM_DEBUG_
protected:
virtual const char *Debug_ClassName(){return "SSL_PreMasterSecret";}
#endif
};
#endif
#endif // LIBSSL_PREMASTER_H
|
#include <cstdio>
#include <memory.h>
#include <algorithm>
using std::max;
using std::min;
int s[2222][2222], n, m;
inline int getsum(int x1, int y1, int x2, int y2) {
x1 = max(min(x1, n + m), 1);
y1 = max(min(y1, m + n), 1);
x2 = max(min(x2, n + m), 1);
y2 = max(min(y2, m + n), 1);
return s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
}
int main() {
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
int __it = 0;
while (1) {
int k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
if (n == 0) break;
int shx, shy;
memset(s, 0, sizeof(s[0]) * (n + m + 1));
for (int i = 0; i < k; ++i) {
scanf("%d%d", &shx, ­);
++s[shx + shy][shx - shy + m];
}
for (int i = 1; i <= n + m; ++i)
for (int j = 1; j <= n + m; ++j)
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + s[i][j];
++__it;
printf("Case %d:\n", __it);
while (q--) {
int r;
scanf("%d", &r);
int mx = -1;
int ansx = 0;
int ansy = 0;
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) {
int ss = getsum(i - r + j, i - r - j + m, i + r + j, i + r - j + m);
if (ss > mx) {
mx = ss;
ansx = i;
ansy = j;
}
}
}
printf("%d (%d,%d)\n", mx, ansx, ansy);
}
}
return 0;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 2005 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
*/
#ifndef SVGNUMBER_H
#define SVGNUMBER_H
#include "modules/libvega/vegafixpoint.h"
class SVGNumber
{
private:
#ifdef SVG_DOUBLE_PRECISION_FLOATS
typedef double number_t;
typedef float other_t;
#else
typedef float number_t;
typedef double other_t;
#endif // SVG_DOUBLE_PRECISION_FLOATS
#ifndef VEGA_SUPPORT
typedef number_t VEGA_FIX;
#endif // VEGA_SUPPORT
public:
enum Uninitialized
{
UNINITIALIZED_SVGNUMBER
};
SVGNumber(Uninitialized) {}
SVGNumber() : value(0) {}
SVGNumber(int intpart) : value((number_t)intpart) {}
SVGNumber(unsigned int intpart) : value((number_t)intpart) {}
SVGNumber(long intpart) : value((number_t)intpart) {}
SVGNumber(unsigned long intpart) : value((number_t)intpart) {}
// Don't use this
SVGNumber(int intpart, unsigned int millions) : value((number_t)intpart + (number_t)millions/(number_t)1000000) { OP_ASSERT(!"This constructor will do terrible things for fixed point"); }
SVGNumber(other_t val) : value((number_t)val) {}
SVGNumber(number_t val) : value(val) {}
void operator=(const SVGNumber& other) { value = other.value; }
SVGNumber operator*(const SVGNumber& other) const { return SVGNumber(value * other.value); }
SVGNumber operator/(const SVGNumber& other) const { return SVGNumber(value / other.value); }
SVGNumber operator%(const SVGNumber& other) const { return SVGNumber(::op_fmod(value, other.value)); }
void operator*=(const SVGNumber& other) { value *= other.value; }
void operator/=(const SVGNumber& other) { value /= other.value; }
SVGNumber operator+(const SVGNumber& other) const { return SVGNumber(value + other.value); }
SVGNumber operator-(const SVGNumber& other) const { return SVGNumber(value - other.value); }
void operator+=(const SVGNumber& other) { value += other.value; }
void operator-=(const SVGNumber& other) { value -= other.value; }
SVGNumber& operator++() { ++value; return *this; }
SVGNumber& operator--() { --value; return *this; }
SVGNumber operator++(int) { SVGNumber rv(value); ++value; return rv; }
SVGNumber operator--(int) { SVGNumber rv(value); --value; return rv; }
SVGNumber operator-() const { return SVGNumber(-value); }
BOOL operator>(const SVGNumber &other) const { return value > other.value; }
BOOL operator<(const SVGNumber &other) const { return value < other.value; }
BOOL operator>=(const SVGNumber &other) const { return value >= other.value; }
BOOL operator<=(const SVGNumber &other) const { return value <= other.value; }
BOOL Equal(const SVGNumber& other) const { return value == other.value; }
BOOL NotEqual(const SVGNumber& other) const { return value != other.value; }
BOOL Close(const SVGNumber& other) const { return ::op_fabs(value - other.value) < eps().value; }
BOOL Close(const SVGNumber& other, const SVGNumber& e) const { return ::op_fabs(value - other.value) < e.value; }
BOOL operator==(const SVGNumber &other) const { return Equal(other); }
BOOL operator!=(const SVGNumber &other) const { return NotEqual(other); }
SVGNumber sqrt() const { return SVGNumber(::op_sqrt(value)); }
SVGNumber abs() const { return SVGNumber(::op_fabs(value)); }
SVGNumber ceil() const { return SVGNumber(::op_ceil(value)); }
SVGNumber floor() const { return SVGNumber(::op_floor(value)); }
SVGNumber pow(const SVGNumber& other) { return SVGNumber(::op_pow(value, other.value)); }
static SVGNumber max_of(const SVGNumber &n1, const SVGNumber& n2) { return SVGNumber(MAX(n1.value, n2.value)); }
static SVGNumber min_of(const SVGNumber &n1, const SVGNumber& n2) { return SVGNumber(MIN(n1.value, n2.value)); }
float GetFloatValue() const { return (float)value; }
int GetIntegerValue() const { return (int)value; }
int GetRoundedIntegerValue() const { return (int)(value + 0.5); }
long GetFixedPointValue(unsigned int decbits) const { return (long)(value*(1<<decbits)); }
VEGA_FIX GetVegaNumber() const
{
#if defined(VEGA_USE_FLOATS) || !defined(VEGA_SUPPORT)
return (float)value; // same implementation as GetFloatValue()
#else
return (long)(value*(1<<VEGA_FIX_DECBITS));
#endif // VEGA_FIX_DECBITS
}
void SetFixedPointValue(unsigned int decbits, unsigned int new_value) { value = ((number_t)new_value) / (1<<decbits); }
void SetVegaNumber(VEGA_FIX vega_number)
{
#if defined(VEGA_USE_FLOATS) || !defined(VEGA_SUPPORT)
# ifdef SVG_DOUBLE_PRECISION_FLOATS
// go from float to double
value = (double)vega_number;
# else
// go from float to float
value = vega_number;
# endif
#else // !VEGA_USE_FLOATS
value = ((number_t)vega_number) / (1 << VEGA_FIX_DECBITS);
#endif // !VEGA_USE_FLOATS
}
SVGNumber atan2(const SVGNumber &other) const { return SVGNumber(::op_atan2(other.value, value)); }
SVGNumber sin() const { return SVGNumber(::op_sin(value)); }
SVGNumber cos() const { return SVGNumber(::op_cos(value)); }
SVGNumber tan() const { return SVGNumber(::op_tan(value)); }
SVGNumber acos() const { return SVGNumber(::op_acos(value)); }
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
static SVGNumber pi() { return SVGNumber((number_t)M_PI); }
#ifdef SVG_DOUBLE_PRECISION_FLOATS
// For ieee doubles
#ifndef DBL_EPSILON
# define DBL_EPSILON 2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */
#endif // DBL_EPSILON
#ifndef DBL_MAX
# define DBL_MAX 1.7976931348623158e+308 /* max value */
#endif // DBL_MAX
#ifndef DBL_MIN
# define DBL_MIN 2.2250738585072014e-308 /* min positive value */
#endif // DBL_MIN
static SVGNumber eps() { return SVGNumber(DBL_EPSILON*100000); } // arbitrary number, need tuning
static SVGNumber max_num() { return SVGNumber(DBL_MAX); }
static SVGNumber min_num() { return SVGNumber(-DBL_MAX); }
#else
// For ieee flots
#ifndef FLT_EPSILON
# define FLT_EPSILON 1.192092896e-07F /* smallest such that 1.0+FLT_EPSILON != 1.0 */
#endif // FLT_EPSILON
#ifndef FLT_MAX
# define FLT_MAX 3.402823466e+38F /* max value */
#endif // FLT_MAX
#ifndef FLT_MIN
# define FLT_MIN 1.175494351e-38F /* min positive value */
#endif // FLT_MIN
static SVGNumber eps() { return SVGNumber(FLT_EPSILON*100); } // arbitrary number, need tuning
static SVGNumber max_num() { return SVGNumber(FLT_MAX); }
static SVGNumber min_num() { return SVGNumber(-FLT_MAX); }
#endif // SVG_DOUBLE_PRECISION_FLOATS
private:
number_t value;
};
#endif // SVGNUMBER_H
|
#ifndef BINARYTREENODE_H
#define BINARYTREENODE_H
#include <string>
#include <iostream>
using namespace std;
class BinaryTreeNode
{
public:
BinaryTreeNode();
BinaryTreeNode(string);
virtual ~BinaryTreeNode();
//The three Order functions just print the data
void PreOrder ();
void PostOrder();
void InOrder();
BinaryTreeNode* SearchWord(string);
void returnWordByNumber(string& aWord, int& num); //Each node is numbered with the "Post Order" method taking note of freq
//BinaryTreeNode* NewNode( string &s );
void insertNode(string &s);
BinaryTreeNode* GetrightChild() { return rightChild; }
void SetrightChild(BinaryTreeNode* val) { rightChild = val; }
BinaryTreeNode* GetleftChild() { return leftChild; }
void SetleftChild(BinaryTreeNode* val) { leftChild = val; }
unsigned int Getfrequency() { return frequency; }
void Setfrequency(unsigned int val) { frequency = val; }
string Getword() { return word; }
void Setword(string val) { word = val; }
private:
BinaryTreeNode* rightChild;
BinaryTreeNode* leftChild;
unsigned int frequency;
string word;
};
ostream &operator<< (ostream &stream, BinaryTreeNode &node);
#endif // BINARYTREENODE_H
|
#ifndef _ENCRYPT_RC4_
#define _ENCRYPT_RC4_
#include <string.h>
#define BOX_LEN 256
#define ENCRYPT_PWD "rockifone_powerful_ileader"
class RC4Encrypt{
public:
static int GetKey(const unsigned char* pass, int pass_len, unsigned char *out);
static int RC4(const unsigned char* data, int data_len, const unsigned char* key, int key_len, unsigned char* out, int* out_len);
static void swap_byte(unsigned char* a, unsigned char* b);
static char* Encrypt(const char* szSource);
static char* Decrypt(const char* szSource);
static char* ByteToHex(const unsigned char* vByte, const int vLen);
static unsigned char* HexToByte(const char* szHex);
};
#endif // #ifndef _ENCRYPT_RC4_
|
class Solution {
public:
bool isValid(string s) {
stack<char> pare;
for (string::iterator it = s.begin(); it != s.end(); ++it) {
switch (*it) {
case '{': case '[': case '(': {
pare.push(*it);
break;
}
case '}': {
if (pare.empty() || pare.top() != '{') return false;
pare.pop();
break;
}
case ']': {
if (pare.empty() || pare.top() != '[') return false;
pare.pop();
break;
}
case ')': {
if (pare.empty() || pare.top() != '(') return false;
pare.pop();
break;
}
default:
break;
}
}
return pare.empty();
}
};
|
#include <iostream>
template<typename T> class Vector {
private:
T* elem;
unsigned long sz;
public:
Vector(std::initializer_list<T>);
~Vector() { delete[] elem; }
T& operator[](int i);
const T* begin() const;
const T* end() const;
const T& operator[](int i) const;
unsigned long size() const { return sz; }
};
|
#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main(int argc, char const *argv[])
{
int A0=0, A1=0, A2=0, A3=0, A4=-1;
float cnt = 0.0;
int flag0=0, flag1=0, flag2=0, flag3=0, flag4=0;
int num, input;
int sign = 1;
cin >> num;
while( num-- )
{
cin >> input;
switch(input % 5){
case 0:
if (input % 2 == 0)
{
A0 += input;
flag0++;
}
break;
case 1:
A1 += sign*input;
sign = -sign;
flag1++;
break;
case 2:
A2++;
flag2++;
break;
case 3:
A3 += input;
cnt++;
flag3++;
break;
case 4:
if (input > A4)
A4 = input;
flag4++;
}
}
if (flag0)
{
cout << A0 << " ";
}
else{
cout << "N" << " ";
}
if (flag1)
{
cout << A1 << " ";
}
else{
cout << "N" << " ";
}
if (flag2)
{
cout << A2 << " ";
}
else{
cout << "N" << " ";
}
if (flag3)
{
printf("%.1f ", A3/cnt);
}
else{
cout << "N" << " ";
}
if (flag4)
{
cout << A4;
}
else{
cout << "N";
}
return 0;
}
|
#include <ionir/construct/construct.h>
#include <ionir/construct/value.h>
#include <ionir/const/const.h>
namespace ionir {
Construct::Construct(
ConstructKind kind,
std::optional<ionshared::SourceLocation> sourceLocation,
ionshared::OptPtr<Construct> parent
) :
ionshared::BaseConstruct<Construct, ConstructKind>(kind, sourceLocation, std::move(parent)) {
//
}
bool Construct::equals(const ionshared::Ptr<Construct> &other) {
return other == this->shared_from_this();
}
bool Construct::verify() {
Ast children = this->getChildrenNodes();
/**
* Loop through the children and verify them. If the verification
* function returns false, this construct's verification fails.
* If all the children's verification functions return true,
* this construct's verification passes, and returns true.
*/
for (auto &child : children) {
// NOTE: The verification function is not constant.
if (!child->verify()) {
return false;
}
}
return true;
}
std::optional<std::string> Construct::findConstructKindName() {
return Const::getConstructKindName(this->constructKind);
}
}
|
#include "ScriptManager.h"
#include <regex>
ScriptManager::ScriptManager() {}
int ScriptManager::scriptChangeColor() {
duk_context* ctx = duk_create_heap_default();
if (!ctx) {
printf("Failed to create a Duktape heap.\n");
exit(1);
}
// Register objects and member functions inside our context
dukglue_register_constructor<scriptObject>(ctx, "scriptObject");
dukglue_register_method(ctx, &scriptObject::GetR, "get_r");
dukglue_register_method(ctx, &scriptObject::GetG, "get_g");
dukglue_register_method(ctx, &scriptObject::GetB, "get_b");
dukglue_register_method(ctx, &scriptObject::GetLenght, "get_length");
dukglue_register_method(ctx, &scriptObject::GetWidth, "get_width");
dukglue_register_method(ctx, &scriptObject::SetR, "set_r");
dukglue_register_method(ctx, &scriptObject::SetG, "set_g");
dukglue_register_method(ctx, &scriptObject::SetB, "set_b");
dukglue_register_method(ctx, &scriptObject::SetLength, "set_length");
dukglue_register_method(ctx, &scriptObject::SetWidth, "set_width");
// Can use the standard duktape API to register c_functions if necessary
duk_push_c_function(ctx, native_print, DUK_VARARGS);
duk_put_global_string(ctx, "print");
// Load script from file, evaluate script
load_script_from_file(ctx, "scriptingForSpaceInv.js");
if (duk_peval(ctx) != 0) {
printf("Error: %s\n", duk_safe_to_string(ctx, -1));
duk_destroy_heap(ctx);
return 1;
}
duk_pop(ctx); // Ignore return, clear stack
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "enableScript");
/* This demonstrates passing objects declared in C++ to scripts */
scriptObject newScriptObject;
dukglue_push(ctx, &newScriptObject);
if (duk_pcall(ctx, 1) != 0)
printf("Error: %s\n", duk_safe_to_string(ctx, -1));
else
printf("%s\n", duk_safe_to_string(ctx, -1));
// receive a string and then split them into integer
string s = duk_safe_to_string(ctx, -1);
//cout << s << endl;
std::regex regex(",");
std::vector<std::string> out(
std::sregex_token_iterator(s.begin(), s.end(), regex, -1),
std::sregex_token_iterator()
);
vector<int> buffer;
for (auto& s : out) {
//std::cout << s << '\n';
buffer.push_back(stoi(s)); // convert all strings to integers, and stored in a buffer
}
//cout << buffer[0] << endl;
r = buffer[0];
//cout << buffer[1] << endl;
g = buffer[1];
//cout << buffer[2] << endl;
b = buffer[2];
new_length = buffer[3];
new_width = buffer[4];
duk_pop(ctx);
duk_destroy_heap(ctx);
return 0;
}
int ScriptManager::getR_fromScript() {
return r;
}
int ScriptManager::getG_fromScript() {
return g;
}
int ScriptManager::getB_fromScript() {
return b;
}
float ScriptManager::getLength_fromScript() {
return new_length;
}
float ScriptManager::getWidth_fromScript() {
return new_width;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>
#include <cstring>
using namespace std;
class Rochambo {
public:
int wins(string opponentGame) {
string myGame = "RR";
string rochambo = "RPS";
string tmp;
register size_t it;
for (it = 1; it < opponentGame.size(); ++it) {
if (opponentGame[it] != opponentGame[it-1]) {
tmp = rochambo;
tmp.erase(tmp.find(opponentGame[it-1]), 1);
tmp.erase(tmp.find(opponentGame[it]), 1);
if (tmp.compare("R") == 0) {
myGame.push_back('P');
} else if (tmp.compare("S") == 0) {
myGame.push_back('R');
} else {
myGame.push_back('S');
}
} else {
if (opponentGame[it-1] == 'R') {
myGame.push_back('P');
} else if (opponentGame[it-1] == 'S') {
myGame.push_back('R');
} else {
myGame.push_back('S');
}
}
}
int count = 0;
for (it = 0; it != opponentGame.size(); ++it) {
if ((opponentGame[it] == 'R' && myGame[it] == 'P')
|| (opponentGame[it] == 'S' && myGame[it] == 'R')
|| (opponentGame[it] == 'P' && myGame[it] == 'S' )) {
count++;
}
}
return count;
}
};
|
#include <iostream>
#include <list>
using namespace std;
struct Animal {
virtual void talk() = 0;
};
struct Dog : Animal {
void talk() {
cout << "Bark!" << endl;
}
};
struct Cat : Animal {
void talk() {
cout << "Meow!" << endl;
}
};
class Shelter {
private:
list<Animal*> q {};
template <typename T>
T* dequeue() {
auto p = q.begin();
while (p != q.end()) {
T* result = dynamic_cast<T*>(*p);
if (result) {
q.erase(p);
return result;
}
p++;
}
}
public:
void enqueue(Animal* a) {
q.push_back(a);
}
Animal* dequeueAny() {
Animal* front = q.front();
q.pop_front();
return front;
}
Dog* dequeueDog() {
return dequeue<Dog>();
}
Cat* dequeueCat() {
return dequeue<Cat>();
}
bool empty() {
return q.empty();
}
};
int main() {
Shelter shelter {};
shelter.enqueue(new Dog());
shelter.enqueue(new Dog());
shelter.enqueue(new Cat());
shelter.enqueue(new Cat());
shelter.enqueue(new Cat());
shelter.enqueue(new Dog());
shelter.enqueue(new Cat());
shelter.enqueue(new Cat());
shelter.enqueue(new Dog());
shelter.dequeueCat()->talk();
shelter.dequeueDog()->talk();
cout << endl;
while (!shelter.empty()) {
Animal* a = shelter.dequeueAny();
a->talk();
}
}
|
//超类方法不同的访问级别
class Gregarious
{
public:
virtual void talk() {cout<<"Gregarious say hello ! "<<endl;}
} ;
class Shy : public Gregarious
{
protected:
virtual void talk() {cout<<"Shy reluctantly say hello ! "<<endl;}
};
Shy myShy;
myShy.talk();//Bug，直接访问protected
//正确的访问方法
Shy myShy;
Gregarious& ref=myShy;//一个Gregarious引用
ref.talk();
|
#include "Chess.h"
#include <qpainter.h>
Chess::Chess(QWidget *parent)
: QMainWindow(parent)
{
ui.setupUi(this);
}
void Chess::paintEvent(QPaintEvent*)
{
}
|
/*
* File: main.cpp
* Author: Daniel Canales
*
* Created on July 11, 2014, 4:25 PM
*/
#include <cstdlib>
#include <iostream>
using namespace std;
/*
*
*/
int main(int argc, char** argv) {
//create for random # gen
srand(static_cast<unsigned int>(time(0)));
//decalre variables
short menu;
int ans;
int realans; //real answer to num1 num2
char choice; // give option to redo
do
{
//inside loop to make random everytime
int num1 = rand()%100+1; //give them only numbers 1-100
int num2 = rand()%100+1;
//give options for menu
cout << "Choose what kind of problem you want?" << endl;
cout << "1 for Addition" << endl;
cout << "2 for Subtraction" << endl;
cout << "3 for Multiplication" << endl;
cout << "4 for Division" << endl;
cin >> menu;
//switch for the cases
switch(menu)
{
case 1: realans = num1+num2;
cout << num1 << "+" << num2 << endl;
cin >> ans; //enter answer
if(realans==ans) cout << "Your are correct" << endl;
else cout << "Sorry you are wrong" << endl;
break;
case 2: realans = num1-num2;
cout << num1 << "-" << num2 << endl;
cin >> ans; //enter answer
if(realans==ans) cout << "Your are correct" << endl;
else cout << "Sorry you are wrong" << endl;
break;
case 3: realans = num1*num2;
cout << num1 << "*" << num2 << endl;
cin >> ans; //enter answer
if(realans==ans) cout << "Your are correct" << endl;
else cout << "Sorry you are wrong" << endl;
break;
case 4: realans = num1/num2;
cout << num1 << "/" << num2 << endl;
cin >> ans; //enter answer
if(realans==ans) cout << "Your are correct" << endl;
else cout << "Sorry you are wrong" << endl;
break;
}
cout << "Would you like to go again?" << endl;
cin >> choice;
}while(choice == 'Y' || choice == 'y');
return 0;
}
|
#include "Mat4x4f.h"
namespace CGLA
{
Mat4x4f rotation_Mat4x4f(Axis axis, float angle)
{
Mat4x4f m(0.0f);
switch(axis)
{
case XAXIS:
m[0][0] = 1.0;
m[1][1] = cos(angle);
m[1][2] = sin(angle);
m[2][1] = -sin(angle);
m[2][2] = cos(angle);
m[3][3] = 1.0;
break;
case YAXIS:
m[0][0] = cos(angle);
m[0][2] = -sin(angle);
m[2][0] = sin(angle);
m[2][2] = cos(angle);
m[1][1] = 1.0;
m[3][3] = 1.0;
break;
case ZAXIS:
m[0][0] = cos(angle);
m[0][1] = sin(angle);
m[1][0] = -sin(angle);
m[1][1] = cos(angle);
m[2][2] = 1.0;
m[3][3] = 1.0;
break;
}
return m;
}
Mat4x4f translation_Mat4x4f(const Vec3f& v)
{
Mat4x4f m(0.0f);
m[0][0] = 1.0;
m[1][1] = 1.0;
m[2][2] = 1.0;
m[3][3] = 1.0;
m[0][3] = v[0];
m[1][3] = v[1];
m[2][3] = v[2];
return m;
}
Mat4x4f scaling_Mat4x4f(const Vec3f& v)
{
Mat4x4f m(0.0f);
m[0][0] = v[0];
m[1][1] = v[1];
m[2][2] = v[2];
m[3][3] = 1.0;
return m;
}
Mat4x4f lookat_Mat4x4f(const CGLA::Vec3f& pos, const CGLA::Vec3f& dir, const CGLA::Vec3f& up)
{
CGLA::Mat4x4f T = translation_Mat4x4f(-pos);
CGLA::Vec3f X,Y,Z;
Z = -normalize(dir);
X = normalize(cross(up, Z));
Y = cross(Z,X);
CGLA::Mat4x4f M(CGLA::Vec4f(X,0),
CGLA::Vec4f(Y,0),
CGLA::Vec4f(Z,0),
CGLA::Vec4f(0,0,0,1));
return M*T;
}
Mat4x4f perspective_Mat4x4f(float fovy, float A, float glnear, float glfar)
{
Mat4x4f P(0.0);
float f = 1.0/(tan(0.5 * fovy * (M_PI/180.0)));
P[0][0] = f/A;
P[1][1] = f;
P[2][2] = (glfar+glnear)/(glnear-glfar);
P[2][3] = 2*glnear*glfar/(glnear-glfar);
P[3][2] = -1;
return P;
}
Mat4x4f ortho_Mat4x4f(const CGLA::Vec3f& lbn,const CGLA::Vec3f& rtf)
{
Mat4x4f P(0.0);
P[0][0] = 2.0/(rtf[0]-lbn[0]);
P[0][3] = -(rtf[0]+lbn[0])/(rtf[0]-lbn[0]);
P[1][1] = 2.0/(rtf[1]-lbn[1]);
P[1][3] = -(rtf[1]+lbn[1])/(rtf[1]-lbn[1]);
P[2][2] = - 2.0/(rtf[2]-lbn[2]);
P[2][3] = -(rtf[2]+lbn[2])/(rtf[2]-lbn[2]);
P[3][3] = 1.0;
return P;
}
}
|
/* -*- Mode: c++; tab-width: 4; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2008 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*
* @author Patricia Aas (psmaas)
*/
#include "core/pch.h" // -*- Mode: c++; tab-width: 4; c-basic-offset: 4 -*-
#include "platforms/viewix/FileHandlerManager.h"
#include "platforms/viewix/src/input_files/InputFileManager.h"
#include "platforms/viewix/src/FileHandlerManagerUtilities.h"
#include "platforms/viewix/src/nodes/MimeTypeNode.h"
#include "platforms/viewix/src/nodes/ApplicationNode.h"
#include "platforms/viewix/src/input_files/AliasesFile.h"
#include "platforms/viewix/src/input_files/SubclassesFile.h"
#include "platforms/viewix/src/input_files/MailcapFile.h"
#include "platforms/viewix/src/input_files/DesktopFile.h"
#include "platforms/viewix/src/input_files/MimeXMLFile.h"
#include "platforms/viewix/src/input_files/IndexThemeFile.h"
#include "platforms/viewix/src/input_files/KDErcFile.h"
#include "modules/util/filefun.h"
#include "modules/util/opfile/opfile.h"
/***********************************************************************************
** GetDataDirs
**
** Fills the vector dirs with the directories in XDG_DATA_DIRS which by definition
** include the directories in XDG_DATA_HOME (if either is not set - it defaults
** according to the standard).
**
** @param vector to be filled
**
** @return OpStatus::OK or OpStatus::ERR_NO_MEMORY
**
** "$XDG_DATA_HOME defines the base directory relative to which user specific data
** files should be stored. If $XDG_DATA_HOME is either not set or empty, a default
** equal to $HOME/.local/share should be used.
**
** $XDG_DATA_DIRS defines the preference-ordered set of base directories to search
** for data files in addition to the $XDG_DATA_HOME base directory.
**
** The directories in $XDG_DATA_DIRS should be seperated with a colon ':'.
**
** If $XDG_DATA_DIRS is either not set or empty, a value equal to
** /usr/local/share/:/usr/share/ should be used."
**
** Ref: http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
***********************************************************************************/
OP_STATUS InputFileManager::InitDataDirs()
{
OpString data_home;
OpString data_dirs;
OpString dir_string;
// Get the XDG_DATA_HOME:
// ----------------------
data_home.Set(op_getenv("XDG_DATA_HOME"));
if( data_home.IsEmpty() ) //Fall back to default value
{
OpString home;
home.Set(op_getenv("HOME"));
if(home.HasContent())
{
data_home.AppendFormat(UNI_L("%s/.local/share/"), home.CStr());
}
}
// Get the XDG_DATA_DIRS:
// ----------------------
data_dirs.Set(op_getenv("XDG_DATA_DIRS"));
if( data_dirs.IsEmpty() ) //Fall back to default value
{
data_dirs.Set("/usr/local/share/:/usr/share/");
}
// Make the path :
// ---------------
if(data_home.HasContent())
dir_string.Append(data_home);
if(data_home.HasContent() && data_dirs.HasContent())
dir_string.Append(":");
if(data_dirs.HasContent())
dir_string.Append(data_dirs);
// Place the dirs in the vector :
// ------------------------------
FileHandlerManagerUtilities::SplitString(m_data_dirs, dir_string, ':');
return OpStatus::OK;
}
/***********************************************************************************
** GetIconSpecificDirs
**
** "Icons and themes are looked for in a set of directories. By default, apps should
** look in $HOME/.icons (for backwards compatibility), in $XDG_DATA_DIRS/icons and
** in /usr/share/pixmaps (in that order). Applications may further add their own
** icon directories to this list, and users may extend or change the list (in
** application/desktop specific ways).In each of these directories themes are stored
** as subdirectories. A theme can be spread across several base directories by having
** subdirectories of the same name. This way users can extend and override system
** themes."
**
** Ref: http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
***********************************************************************************/
OP_STATUS InputFileManager::InitIconSpecificDirs()
{
// Clean out the string :
m_home_icons_dir.Empty();
// Local copies :
OpString home_icons_dir;
OpString home;
home.Set(op_getenv("HOME"));
// Make $HOME/.icons
if( home.HasContent() )
{
home_icons_dir.AppendFormat(UNI_L("%s/.icons"), home.CStr());
}
// Set the .icon directory :
if(FileHandlerManagerUtilities::IsDirectory(home_icons_dir))
{
m_home_icons_dir.Set(home_icons_dir.CStr());
}
// Get the rest of the pixmap directories
GetDirs(m_data_dirs, m_pixmaps_dirs, UNI_L("pixmaps"));
return OpStatus::OK;
}
/***********************************************************************************
** GetSubclassesFiles
**
** Extracts the full path filenames of all files in the directories listed in dirs
** that are in subdirectory "mime/" and are called "subclasses" and places them in the
** vector files.
***********************************************************************************/
OP_STATUS InputFileManager::GetSubclassesFiles(OpVector<OpString>& files)
{
return GetFiles(m_data_dirs, files, UNI_L("mime/"), UNI_L("subclasses"));
}
/***********************************************************************************
** GetAliasesFiles
**
** Extracts the full path filenames of all files in the directories listed in dirs
** that are in subdirectory "mime/" and are called "aliases" and places them in the
** vector files.
***********************************************************************************/
OP_STATUS InputFileManager::GetAliasesFiles(OpVector<OpString>& files)
{
return GetFiles(m_data_dirs, files, UNI_L("mime/"), UNI_L("aliases"));
}
/***********************************************************************************
** GetGlobsFiles
**
** Extracts the full path filenames of all files in the directories listed in dirs
** that are in subdirectory "mime/" and are called "globs" and places them in the
** vector files.
***********************************************************************************/
OP_STATUS InputFileManager::GetGlobsFiles(OpVector<OpString>& files)
{
return GetFiles(m_data_dirs, files, UNI_L("mime/"), UNI_L("globs"));
}
/***********************************************************************************
** GetMimeInfoFiles
**
** Extracts the full path filenames of all files in the directories listed in dirs
** that are in subdirectory "applications/" and are called "mimeinfo.cache" and
** places them in the vector files.
***********************************************************************************/
OP_STATUS InputFileManager::GetMimeInfoFiles(OpVector<OpString>& files)
{
return GetFiles(m_data_dirs, files, UNI_L("applications/"), UNI_L("mimeinfo.cache"));
}
/***********************************************************************************
** GetGnomeVFSFiles
**
** Extracts the full path filenames of all files in the directories listed in dirs
** that are in subdirectory "application-registry/" and are called
** "gnome-vfs.applications" and places them in the vector files.
***********************************************************************************/
OP_STATUS InputFileManager::GetGnomeVFSFiles(OpVector<OpString>& files)
{
return GetFiles(m_data_dirs, files, UNI_L("application-registry/"), UNI_L("gnome-vfs.applications"));
}
/***********************************************************************************
** GetDefaultsFiles
**
** Extracts the full path filenames of all files in the directories listed in dirs
** that are in subdirectory "applications/" and are called "defaults.list" and
** places them in the vector files.
**
***********************************************************************************/
OP_STATUS InputFileManager::GetDefaultsFiles(OpVector<OpString>& profilerc_files,
OpVector<OpString>& files)
{
RETURN_IF_ERROR(GetProfilercFiles(profilerc_files));
return GetFiles(m_data_dirs, files, UNI_L("applications/"), UNI_L("defaults.list"));
}
/***********************************************************************************
** FindDesktopFile
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::FindDesktopFile(const OpStringC & input_filename,
OpVector<OpString>& files)
{
// Remove the full path if there :
// ----------------------
OpString filename;
FileHandlerManagerUtilities::StripPath(filename, input_filename);
// Look in the applications subdirectory :
// ----------------------
GetFiles(m_data_dirs, files, UNI_L("applications/"), filename.CStr());
if(files.GetCount())
return OpStatus::OK;
// Look in the applications/kde subdirectory :
// ----------------------
GetFiles(m_data_dirs, files, UNI_L("applications/kde/"), filename.CStr());
if(files.GetCount())
return OpStatus::OK;
// Look in the mimelnk/application subdirectory :
// ----------------------
OpString mimelnk_filename;
mimelnk_filename.AppendFormat(UNI_L("x-%s"), filename.CStr());
GetFiles(m_data_dirs, files, UNI_L("mimelnk/application/"), mimelnk_filename.CStr());
if(files.GetCount())
return OpStatus::OK;
// Look in the applnk subdirectory :
// ----------------------
GetFiles(m_data_dirs, files, UNI_L("applnk/"), filename.CStr());
if(files.GetCount())
return OpStatus::OK;
return OpStatus::OK;
}
/***********************************************************************************
** GetProfilercFiles
**
** "Configuration files are located in a number of places, largely based on which
** distribution is being used. When an application attempts to find its configuration,
** it scans according to a predefined search order. The list of directories that are
** searched for config files is seen by using the command kde-config --path config.
** The directories shown actually are searched in the reverse order in which they are
** listed. This search order is put together by the following set of rules:
**
** 1. /etc/kderc: a search path of directories can be specified within this file.
**
** 2. KDEDIRS: a standard environment variable that is set to point KDE applications
** to the installation directories of KDE libraries and applications. It most
** likely already is set at login time. The installation directory of KDE
** automatically is appended to this list if it is not already present.
**
** 3. KDEDIR: an older environment variable now considered deprecated in favor of
** KDEDIRS. If KDEDIRS is set, this variable is ignored for configuration.
**
** 4. The directory of the executable file being run
**
** 5. KDEHOME or KDEROOTHOME: usually set to ~/.kde. The former is for all users, and the latter is for root."
**
** http://developer.kde.org/documentation/tutorials/kiosk/index.html
***********************************************************************************/
OP_STATUS InputFileManager::GetProfilercFiles(OpVector<OpString>& profilerc_files)
{
OpString home;
home.Set(op_getenv("HOME"));
if( home.HasContent() )
{
OpString * user_profilerc = OP_NEW(OpString, ());
if(!user_profilerc)
return OpStatus::ERR_NO_MEMORY;
user_profilerc->AppendFormat(UNI_L("%s/.kde/share/config/profilerc"), home.CStr());
profilerc_files.Add(user_profilerc);
}
OpString kderc_filename;
kderc_filename.Set("/etc/kderc");
if(FileHandlerManagerUtilities::IsFile(kderc_filename))
{
KDErcFile kderc_file;
kderc_file.Parse(kderc_filename);
if(FileHandlerManagerUtilities::IsDirectory(kderc_file.GetDir()))
{
OpString * global_profilerc = OP_NEW(OpString, ());
if(!global_profilerc)
return OpStatus::ERR_NO_MEMORY;
global_profilerc->AppendFormat(UNI_L("%s/share/config/profilerc"), kderc_file.GetDir().CStr());
if(FileHandlerManagerUtilities::IsFile(*global_profilerc))
profilerc_files.Add(global_profilerc);
else
OP_DELETE(global_profilerc);
}
}
return OpStatus::OK;
}
/***********************************************************************************
** GetIndexThemeFiles
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::GetIndexThemeFiles(OpVector<OpString>& files)
{
return GetFilesFromSubdirs(m_data_dirs, files, UNI_L("icons/"), UNI_L("index.theme"));
}
/***********************************************************************************
** GetMimetypeIconDesktopDirs
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::InitMimetypeIconDesktopDirs()
{
return GetDirs(m_data_dirs, m_mimetype_desktop_dirs, UNI_L("mimelnk"));
}
/***********************************************************************************
** UseAliasesAndSubclasses
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::UseAliasesAndSubclasses(OpVector<OpString>&aliases_files,
OpVector<OpString>&subclasses_files)
{
UINT32 i = 0;
UINT32 aliases_left = 0;
UINT32 subclasses_left = 0;
UINT32 last_alias_count = 0;
UINT32 last_subclass_count = 0;
//TODO:
//This should be rewritten - the unmatched mimetypes
//should be put in a vector and reprossesed there
//it is not necessary to reread the file.
// TODO: while(true) and break when the set of unmatched
// nodes did not change in an iteration
for(INT32 c = 0; c < 2; c++)
{
last_alias_count = aliases_left;
last_subclass_count = subclasses_left;
aliases_left = 0;
subclasses_left = 0;
// Read aliases files:
// -------------------
for(i = 0; i < aliases_files.GetCount(); i++)
{
AliasesFile alias_file;
alias_file.Parse(*aliases_files.Get(i));
aliases_left = alias_file.GetItemsLeft();
}
// Read Subclasses files:
// ----------------------
for(i = 0; i < subclasses_files.GetCount(); i++)
{
SubclassesFile subclasses_file;
subclasses_file.Parse(*subclasses_files.Get(i));
subclasses_left = subclasses_file.GetItemsLeft();
}
if((aliases_left == 0 && subclasses_left == 0) ||
(aliases_left == last_alias_count && subclasses_left == last_subclass_count))
break;
}
return OpStatus::OK;
}
/***********************************************************************************
** ParseMailcapFiles
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::ParseMailcapFiles()
{
OpString etc_mailcap_string;
OpString home_mailcap_string;
// Get the global mailcap :
// ------------------------
etc_mailcap_string.Set("/etc/mailcap");
// Get the user specific mailcap :
// -------------------------------
OpString home;
home.Set(op_getenv("HOME"));
if( home.HasContent() )
{
home_mailcap_string.AppendFormat(UNI_L("%s/.mailcap"), home.CStr());
}
// Parse the user mailcap:
// -----------------------
if(FileHandlerManagerUtilities::IsFile(home_mailcap_string))
{
MailcapFile mailcap_file;
mailcap_file.Parse(home_mailcap_string);
}
// Parse the global mailcap:
// -------------------------
if(FileHandlerManagerUtilities::IsFile(etc_mailcap_string))
{
MailcapFile mailcap_file;
mailcap_file.Parse(etc_mailcap_string);
}
return OpStatus::OK;
}
/***********************************************************************************
** GetFilesFromSubdirs
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::GetFilesFromSubdirs(OpVector<OpString>& dirs,
OpVector<OpString>& files,
const OpStringC & subdir,
const OpStringC & filename)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//Subdirectory cannot be null
OP_ASSERT(subdir.HasContent());
if(subdir.IsEmpty())
return OpStatus::ERR;
//File name cannot be null
OP_ASSERT(filename.HasContent());
if(filename.IsEmpty())
return OpStatus::ERR;
//-----------------------------------------------------
OpAutoVector<OpString> subdirs;
UINT32 i = 0;
// Get the subdirectories :
// ----------------------
for(i = 0; i < dirs.GetCount(); i++)
{
OpString * dir_str = dirs.Get(i);
OpString dirName;
dirName.AppendFormat(UNI_L("%s/%s"), dir_str->CStr(), subdir.CStr());
if(FileHandlerManagerUtilities::IsDirectory(dirName))
{
GetSubfolders(dirName.CStr(), subdirs);
}
}
// Get the files :
// ----------------------
GetFiles(subdirs, files, UNI_L(""), filename);
return OpStatus::OK;
}
/***********************************************************************************
** GetSubfolders
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::GetSubfolders(const OpStringC & dir,
OpVector<OpString>& dirs)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
OP_ASSERT(dir.HasContent());
if(dir.IsEmpty())
return OpStatus::ERR;
//-----------------------------------------------------
OP_STATUS status = OpStatus::OK;
OpFolderLister* folder_lister = OpFile::GetFolderLister(OPFILE_ABSOLUTE_FOLDER, UNI_L("*"), dir.CStr());
while( folder_lister ) // We need a loop and a NULL pointer test
{
if( folder_lister->IsFolder() )
{
OpString * full_path = OP_NEW(OpString, ());
if(!full_path)
{
status = OpStatus::ERR_NO_MEMORY;
break;
}
full_path->AppendFormat(UNI_L("%s%s/"), dir.CStr(), folder_lister->GetFileName());
dirs.Add(full_path);
}
if(!folder_lister->Next())
break;
}
OP_DELETE(folder_lister);
return status;
}
/***********************************************************************************
** GetDirs
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::GetDirs(OpVector<OpString>& dirs,
OpVector<OpString>& subdirs,
const OpStringC & subdir)
{
OP_STATUS status = OpStatus::OK;
for(UINT32 i = 0; i < dirs.GetCount(); i++)
{
OpString * dir_str = dirs.Get(i);
OpString dirName;
dirName.Set(dir_str->CStr());
if(subdir.HasContent())
{
FileHandlerManagerUtilities::RemoveSuffix(dirName, UNI_L("/")); //Just in case
dirName.Append("/");
dirName.Append(subdir);
}
if(FileHandlerManagerUtilities::IsDirectory(dirName))
{
OpString * dir = OP_NEW(OpString, ());
if(!dir)
{
status = OpStatus::ERR_NO_MEMORY;
break;
}
dir->AppendFormat(UNI_L("%s/"), dirName.CStr());
subdirs.Add(dir);
}
}
return status;
}
/***********************************************************************************
** GetFiles
**
** Appends subdir and filename to all dirs in dirs and checks whether this is a
** regular file with stat. If so the filename is appended to files.
**
** NOTE: The strings returned in files are the caller's resposibility to delete
***********************************************************************************/
OP_STATUS InputFileManager::GetFiles(OpVector<OpString>& dirs,
OpVector<OpString>& files,
const OpStringC & subdir,
const OpStringC & filename)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//File name has to have content
OP_ASSERT(filename.HasContent());
if(filename.IsEmpty())
return OpStatus::ERR;
//-----------------------------------------------------
OP_STATUS status = OpStatus::OK;
for(UINT32 i = 0; i < dirs.GetCount(); i++)
{
OpString * dir_str = dirs.Get(i);
OpString dirName;
dirName.Set(dir_str->CStr());
if(subdir.HasContent())
{
dirName.Append("/");
dirName.Append(subdir);
}
if(FileHandlerManagerUtilities::IsDirectory(dirName))
{
OpString fileName;
fileName.Set(dirName);
fileName.Append(filename);
if(FileHandlerManagerUtilities::IsFile(fileName))
{
OpString * file = OP_NEW(OpString, ());
if(!file)
{
status = OpStatus::ERR_NO_MEMORY;
break;
}
file->Set(fileName.CStr());
files.Add(file);
}
}
}
return status;
}
/***********************************************************************************
** MakeIconPath
**
**
**
** client code must delete the returned string
***********************************************************************************/
OP_STATUS InputFileManager::MakeIconPath(FileHandlerNode * node,
OpString & icon_path,
UINT32 icon_size)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//Application must be set
OP_ASSERT(node);
if(!node)
return OpStatus::ERR;
// If it has one, just return that one
if(node->HasIcon(icon_size) == (BOOL3) TRUE)
return icon_path.Set(node->GetIconPath(icon_size));
// If it doesn't then don't try again
if(node->HasIcon(icon_size) != MAYBE)
return OpStatus::OK;
const uni_char * subdir = 0;
if(node->GetType() == APPLICATION_NODE_TYPE)
subdir = UNI_L("/apps/");
else if(node->GetType() == MIME_TYPE_NODE_TYPE)
subdir = UNI_L("/mimetypes/");
else
return OpStatus::ERR;
//-----------------------------------------------------
const OpStringC icon = node->GetIcon();
if(icon.IsEmpty())
{
return OpStatus::OK;
}
uni_char * iconfile = 0;
OpString iconfile_path;
if(!iconfile && GetIconThemePath().HasContent())
{
MakeIconPathSimple(icon, GetIconThemePath(), iconfile_path, icon_size, subdir);
if(FileHandlerManagerUtilities::IsFile(iconfile_path))
{
iconfile = iconfile_path.CStr();
}
}
if(!iconfile && GetIconThemeBackupPath().HasContent())
{
//TODO - search themes this theme inherits from
MakeIconPathSimple(icon, GetIconThemeBackupPath(), iconfile_path, icon_size, subdir);
if(FileHandlerManagerUtilities::IsFile(iconfile_path))
{
iconfile = iconfile_path.CStr();
}
}
//Maybe its a full path
if(!iconfile)
{
iconfile_path.Set(icon);
if(FileHandlerManagerUtilities::IsFile(iconfile_path))
{
iconfile = iconfile_path.CStr();
}
}
//Last ditch attempt - go look in pixmaps
if(!iconfile)
{
// Make filename
OpString iconfile_name;
iconfile_name.Append(icon);
FileHandlerManagerUtilities::RemoveSuffix(iconfile_name, UNI_L(".png")); //if it's already there take it away
iconfile_name.Append(".png");
// Go look for it in the pixmaps directories
OpAutoVector<OpString> files;
GetFiles(m_pixmaps_dirs, files, 0, iconfile_name.CStr());
if(files.GetCount())
return icon_path.Set(files.Get(0)->CStr());
node->SetHasIcon((BOOL3) FALSE);
}
return icon_path.Set(iconfile);
}
/***********************************************************************************
** MakeIconPathSimple
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::MakeIconPathSimple(const OpStringC & icon,
const OpString& path,
OpString & icon_path,
UINT32 icon_size,
const OpStringC & subdir)
{
//BUILD PATH TO ICON:
// 0. Get pixel string:
// -> Must have pixel string to obtain directory
//-----------------------------------------------------
OpString pixel_str;
RETURN_IF_ERROR(FileHandlerManagerUtilities::MakePixelString(icon_size, pixel_str));
//-----------------------------------------------------
// 5. Assemble the sting:
//-----------------------------------------------------
OpString iconfile_path;
iconfile_path.Set(path.CStr());
iconfile_path.Append(pixel_str.CStr());
iconfile_path.Append(subdir);
iconfile_path.Append(icon);
FileHandlerManagerUtilities::RemoveSuffix(iconfile_path, UNI_L(".png")); //if it's already there take it away
iconfile_path.Append(".png");
//-----------------------------------------------------
return icon_path.Set(iconfile_path.CStr());
}
/***********************************************************************************
** TryExec
**
**
**
**
***********************************************************************************/
BOOL InputFileManager::TryExec(const OpStringC & try_exec,
OpString & full_path)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//try_exec cannot be null
OP_ASSERT(try_exec.HasContent());
if(try_exec.IsEmpty())
return FALSE;
//-----------------------------------------------------
return FileHandlerManagerUtilities::ExpandPath( try_exec.CStr(), X_OK, full_path );
}
/***********************************************************************************
** LoadNode
**
**
**
**
***********************************************************************************/
void InputFileManager::LoadNode(FileHandlerNode* node)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//node pointer cannot be null
OP_ASSERT(node);
if(!node)
return;
//-----------------------------------------------------
if(node->GetType() == APPLICATION_NODE_TYPE)
LoadApplicationNode((ApplicationNode*) node);
else if(node->GetType() == MIME_TYPE_NODE_TYPE)
LoadMimeTypeNode((MimeTypeNode*) node);
}
/***********************************************************************************
** LoadMimeTypeNode
**
**
**
**
***********************************************************************************/
void InputFileManager::LoadMimeTypeNode(MimeTypeNode* node)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//node pointer cannot be null
OP_ASSERT(node);
if(!node)
return;
//-----------------------------------------------------
UINT32 i = 0;
if(node->HasDesktopFile() == MAYBE)
{
for(i = 0; i < m_mimetype_desktop_dirs.GetCount(); i++)
{
OpString * subdir = m_mimetype_desktop_dirs.Get(i);
// Try to find an icon for one of the mimetype names
for(unsigned int j = 0; j < node->GetMimeTypes().GetCount(); j++)
{
// Get the mimetype :
OpString * mime_type = node->GetMimeTypes().Get(j);
OpString path;
path.AppendFormat(UNI_L("%s%s.desktop"), subdir->CStr(), mime_type->CStr());
if(FileHandlerManagerUtilities::IsFile(path))
{
DesktopFile desktop_file = DesktopFile(node);
desktop_file.Parse(path);
node->SetHasDesktopFile((BOOL3) TRUE);
node->SetDesktopFileName(path);
break;
}
}
}
if(node->HasDesktopFile() == MAYBE)
node->SetHasDesktopFile((BOOL3) FALSE);
OpAutoVector<OpString> files;
// Try to find an icon for one of the mimetype names
for(i = 0; i < node->GetMimeTypes().GetCount(); i++)
{
// Get the mimetype :
OpString * mime_type = node->GetMimeTypes().Get(i);
OpString filename;
filename.AppendFormat(UNI_L("%s.xml"), mime_type->CStr());
GetFiles(m_data_dirs, files, UNI_L("mime/"), filename.CStr());
}
for(i = 0; i < files.GetCount(); i++)
{
MimeXMLFile mime_xml_file = MimeXMLFile(node);
mime_xml_file.Parse(*files.Get(i));
}
}
}
/***********************************************************************************
** LoadMimeTypeNodeIcon
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::LoadIcon(FileHandlerNode* node,
UINT32 icon_size)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//node pointer cannot be null
OP_ASSERT(node);
if(!node)
return OpStatus::ERR;
//-----------------------------------------------------
//The path to be returned :
OpString iconfile;
if(node && !node->GetIconPath(icon_size))
{
//Find the desktopfile and parse it if it exists:
if(node->HasDesktopFile() == MAYBE)
{
LoadNode(node);
}
OpString icon;
if(node->GetIcon().IsEmpty())
{
if(node->GetType() == APPLICATION_NODE_TYPE)
{
ApplicationNode * app_node = (ApplicationNode *) node;
app_node->GuessIconName(icon);
node->SetIcon(icon.CStr());
MakeIconPath(node, iconfile, icon_size);
}
else if(node->GetType() == MIME_TYPE_NODE_TYPE)
{
MimeTypeNode* mime_node = (MimeTypeNode*) node;
// Try to find an icon for one of the mimetype names
for(unsigned int i = 0; i < mime_node->GetMimeTypes().GetCount() && iconfile.IsEmpty(); i++)
{
// Get the mimetype :
OpString * mime_type = mime_node->GetMimeTypes().Get(i);
FileHandlerManagerUtilities::StripPath(icon, *mime_type);
node->SetIcon(icon.CStr());
MakeIconPath(node, iconfile, icon_size);
}
}
}
else
{
MakeIconPath(node, iconfile, icon_size);
}
if(iconfile.IsEmpty())
{
if(node->GetType() == MIME_TYPE_NODE_TYPE)
{
MimeTypeNode* mime_node = (MimeTypeNode*) node;
mime_node->GetDefaultIconName(icon);
node->SetIcon(icon.CStr());
MakeIconPath(node, iconfile, icon_size);
}
}
if(iconfile.HasContent())
{
node->SetIconPath(iconfile.CStr(), icon_size);
}
}
return OpStatus::OK;
}
/***********************************************************************************
** LoadApplicationNode
**
**
**
**
***********************************************************************************/
void InputFileManager::LoadApplicationNode(ApplicationNode* node)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//Application node pointer cannot be null
OP_ASSERT(node);
if(!node)
return;
//-----------------------------------------------------
if(node->HasDesktopFile() == FALSE || node->HasDesktopFile() == TRUE)
{
return; // The file (if it exists) has already been parsed
}
else if(node->HasDesktopFile() == MAYBE)
{
const OpStringC path = node->GetPath();
const OpStringC filename = node->GetDesktopFileName();
//Path and filename must be set - but if this is a mimecap node - there is no desktop file
if(path.IsEmpty() || filename.IsEmpty())
{
node->SetHasDesktopFile((BOOL3) FALSE);
return;
}
OpString full_name;
full_name.Set(path);
OpString file_name;
file_name.Set(filename);
//Note : This is a KDE specific hack
FileHandlerManagerUtilities::ReplacePrefix(file_name, UNI_L("kde-"), UNI_L("kde/"));
full_name.Append(file_name);
DesktopFile desktop_file = DesktopFile(node);
desktop_file.Parse(full_name);
node->SetHasDesktopFile((BOOL3) TRUE);
if(node->HasDesktopFile() == MAYBE)
node->SetHasDesktopFile((BOOL3) FALSE);
}
}
/***********************************************************************************
** SortThemes
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::SortThemes(OpVector<OpString>& theme_files)
{
// Try to guess good themes :
OpString fav_theme;
OpString back_theme;
if (FileHandlerManagerUtilities::isKDERunning())
fav_theme.Set(UNI_L("crystalsvg"));
else if (FileHandlerManagerUtilities::isGnomeRunning())
fav_theme.Set(UNI_L("gnome"));
back_theme.Set(UNI_L("hicolor"));
// See if those are among the ones you have found :
OpString* main_theme = 0;
OpString* backup_theme = 0;
for(unsigned int i = 0; i < theme_files.GetCount(); i++)
{
// If we don't have one already, check if this is our main choice
if(!main_theme && fav_theme.HasContent() && theme_files.Get(i)->Find(fav_theme.CStr()) != KNotFound)
main_theme = theme_files.Get(i);
// If we don't have one already, check if this is our backup choice
if(!backup_theme && back_theme.HasContent() && theme_files.Get(i)->Find(back_theme.CStr()) != KNotFound)
backup_theme = theme_files.Get(i);
}
// If you didn't find your main one, try the backup
if(!main_theme)
{
main_theme = backup_theme;
backup_theme = 0;
}
// If you found a backup insert it first
if(backup_theme)
{
theme_files.RemoveByItem(backup_theme);
theme_files.Insert(0, backup_theme);
}
// If you found the main one insert it first
if(main_theme)
{
theme_files.RemoveByItem(main_theme);
theme_files.Insert(0, main_theme);
}
return OpStatus::OK;
}
/***********************************************************************************
** ParseIndexThemeFile
**
**
**
**
***********************************************************************************/
OP_STATUS InputFileManager::InitTheme(OpVector<OpString>& theme_files)
{
if(theme_files.GetCount() == 0)
return OpStatus::OK;
RETURN_IF_ERROR(SortThemes(theme_files));
// Process the main theme file
// ----------------------
OpString * themefile = theme_files.Get(0);
IndexThemeFile index_theme_file(&m_theme_node);
RETURN_IF_ERROR(index_theme_file.Parse(*themefile));
// Set the path to the index.theme file
RETURN_IF_ERROR(m_theme_node.SetIndexThemeFile(themefile->CStr()));
if(theme_files.GetCount() == 1)
return OpStatus::OK;
// Process the backup theme file
// ----------------------
OpString * backup_themefile = theme_files.Get(1);
IndexThemeFile index_theme_backup(&m_backup_theme_node);
RETURN_IF_ERROR(index_theme_backup.Parse(*backup_themefile));
// Set the path to the index.theme file
RETURN_IF_ERROR(m_backup_theme_node.SetIndexThemeFile(backup_themefile->CStr()));
return OpStatus::OK;
}
|
#include "graphics.h"
#include "md2.h"
#include <iostream>
#include <fstream>
#include <utility>
using std::cout;
using std::cerr;
using std::endl;
extern int modelsRenderedThisFrame;
Vector Model_MD2::_kAnorms[] = {
#include "Anorms.h"
};
int Model_MD2::_kMd2Ident = 'I' + ('D'<<8) + ('P'<<16) + ('2'<<24);
int Model_MD2::_kMd2Version = 8;
Model_MD2::Model_MD2 (const string &filename) {
this->type = 1;
this->name = filename;
// Open the file
std::ifstream ifs (filename.c_str (), std::ios::binary);
if (ifs.fail ())
throw std::runtime_error ("Couldn't open file");
// Read header
ifs.read (reinterpret_cast<char *>(&_header), sizeof (Md2Header_t));
// Check if ident and version are valid
if (_header.ident != _kMd2Ident)
throw std::runtime_error ("Bad file ident");
if (_header.version != _kMd2Version)
throw std::runtime_error ("Bad file version");
// Memory allocation for model data
_skins = new Md2Skin_t[_header.num_skins];
_texCoords = new Md2TexCoord_t[_header.num_st];
_triangles = new Md2Triangle_t[_header.num_tris];
_frames = new Md2Frame_t[_header.num_frames];
_glcmds = new int[_header.num_glcmds];
// Read skin names
ifs.seekg (_header.offset_skins, std::ios::beg);
ifs.read (reinterpret_cast<char *>(_skins), sizeof (Md2Skin_t) * _header.num_skins);
// Read texture coords.
ifs.seekg (_header.offset_st, std::ios::beg);
ifs.read (reinterpret_cast<char *>(_texCoords), sizeof (Md2TexCoord_t) * _header.num_st);
// Read triangle data
ifs.seekg (_header.offset_tris, std::ios::beg);
ifs.read (reinterpret_cast<char *>(_triangles), sizeof(Md2Triangle_t) * _header.num_tris);
// Read frames
ifs.seekg (_header.offset_frames, std::ios::beg);
for (int i = 0; i < _header.num_frames; ++i)
{
// Memory allocation for the vertices of this frame
_frames[i].verts = new Md2Vertex_t[_header.num_vertices];
// Read frame data
ifs.read (reinterpret_cast<char *>(&_frames[i].scale), sizeof (Vector));
ifs.read (reinterpret_cast<char *>(&_frames[i].translate), sizeof (Vector));
ifs.read (reinterpret_cast<char *>(&_frames[i].name), sizeof (char) * 16);
ifs.read (reinterpret_cast<char *>(_frames[i].verts), sizeof (Md2Vertex_t) * _header.num_vertices);
}
// Read OpenGL commands
ifs.seekg (_header.offset_glcmds, std::ios::beg);
ifs.read (reinterpret_cast<char *>(_glcmds),
sizeof (int) * _header.num_glcmds);
// Close file
ifs.close();
// Setup animation infos
setupAnimations ();
}
// --------------------------------------------------------------------------
// Model_MD2::~Model_MD2
//
// Destructor. Free all memory allocated for the model.
// --------------------------------------------------------------------------
Model_MD2::~Model_MD2 ()
{
delete [] _skins;
delete [] _texCoords;
delete [] _triangles;
delete [] _frames;
delete [] _glcmds;
}
// --------------------------------------------------------------------------
// Model_MD2::loadTexture
//
// Load a texture from file.
// --------------------------------------------------------------------------
bool Model_MD2::loadTexture (const string &filename) {
return false;
}
// --------------------------------------------------------------------------
// Model_MD2::setTexture
//
// Set the current texture for the mesh.
// --------------------------------------------------------------------------
void Model_MD2::setTexture (const string &filename) {
SkinMap::iterator itor;
itor = _skinIds.find (filename);
if (itor != _skinIds.end ())
_tex = itor->second;
else
_tex = NULL;
}
// --------------------------------------------------------------------------
// Model_MD2::setupAnimations
//
// Setup animation infos.
// --------------------------------------------------------------------------
void
Model_MD2::setupAnimations ()
{
string currentAnim;
Md2Anim_t animInfo = { 0, 0 };
for (int i = 0; i < _header.num_frames; ++i)
{
string frameName = _frames[i].name;
string frameAnim;
// Extract animation name from frame name
string::size_type len = frameName.find_first_of ("0123456789");
if ((len == frameName.length () - 3) &&
(frameName[len] != '0'))
len++;
frameAnim.assign (frameName, 0, len);
if (currentAnim != frameAnim)
{
if (i > 0)
{
// Previous animation is finished, insert
// it and start new animation.
_anims.insert (AnimMap::value_type
(currentAnim, animInfo));
}
// Initialize new anim info
animInfo.start = i;
animInfo.end = i;
currentAnim = frameAnim;
}
else
{
animInfo.end = i;
}
}
// Insert last animation
_anims.insert (AnimMap::value_type (currentAnim, animInfo));
}
// --------------------------------------------------------------------------
// Model_MD2::renderFrameImmediate
//
// Render the model for the specified frame, using immediate mode.
// --------------------------------------------------------------------------
void
Model_MD2::renderFrameImmediate (int frame)
{
modelsRenderedThisFrame++;
// Compute max frame index
int maxFrame = _header.num_frames;
// Check if the frame index is valid
if ((frame < 0) || (frame >= maxFrame))
frame = 0;
// Bind to model's texture
glBegin (GL_TRIANGLES);
// Draw each triangle
for (int i = 0; i < _header.num_tris; ++i)
{
// Draw each vertex of this triangle
// for (int j = 0; j < 3; ++j)
// {
Md2Frame_t *pFrame = &_frames[frame];
Md2Vertex_t *pVert = &pFrame->verts[_triangles[i].vertex[0]];
Md2TexCoord_t *pTexCoords = &_texCoords[_triangles[i].st[0]];
glTexCoord2f ((float)(pTexCoords->s) / _header.skinwidth, 1.0f - ((float)(pTexCoords->t) / _header.skinheight));
// glNormal3f(_kAnorms[pVert->normalIndex].x,_kAnorms[pVert->normalIndex].y,_kAnorms[pVert->normalIndex].z);
Vector v = ((Vector((float)pVert->v[0],(float)pVert->v[1],(float)pVert->v[2]) * pFrame->scale) + pFrame->translate) * _scale;
glVertex3f(v.x,v.y,v.z);
pVert = &pFrame->verts[_triangles[i].vertex[1]];
pTexCoords = &_texCoords[_triangles[i].st[1]];
glTexCoord2f ((float)(pTexCoords->s) / _header.skinwidth, 1.0f - ((float)(pTexCoords->t) / _header.skinheight));
// glNormal3f(_kAnorms[pVert->normalIndex].x,_kAnorms[pVert->normalIndex].y,_kAnorms[pVert->normalIndex].z);
v = ((Vector((float)pVert->v[0],(float)pVert->v[1],(float)pVert->v[2]) * pFrame->scale) + pFrame->translate) * _scale;
glVertex3f(v.x,v.y,v.z);
pVert = &pFrame->verts[_triangles[i].vertex[2]];
pTexCoords = &_texCoords[_triangles[i].st[2]];
glTexCoord2f ((float)(pTexCoords->s) / _header.skinwidth, 1.0f - ((float)(pTexCoords->t) / _header.skinheight));
// glNormal3f(_kAnorms[pVert->normalIndex].x,_kAnorms[pVert->normalIndex].y,_kAnorms[pVert->normalIndex].z);
v = ((Vector((float)pVert->v[0],(float)pVert->v[1],(float)pVert->v[2]) * pFrame->scale) + pFrame->translate) * _scale;
glVertex3f(v.x,v.y,v.z);
// }
}
glEnd();
}
// --------------------------------------------------------------------------
// Model_MD2::drawModelItpImmediate
//
// Render the model with frame interpolation, using immediate mode.
// --------------------------------------------------------------------------
void
Model_MD2::drawModelItpImmediate (int frameA, int frameB, float interp)
{
modelsRenderedThisFrame++;
// Compute max frame index
int maxFrame = _header.num_frames - 1;
// Check if frames are valid
if ((frameA < 0) || (frameB < 0))
return;
if ((frameA > maxFrame) || (frameB > maxFrame))
return;
// Bind to model's texture
glBegin (GL_TRIANGLES);
// Draw each triangle
for (int i = 0; i < _header.num_tris; ++i)
{
// Draw each vertex of this triangle
for (int j = 0; j < 3; ++j)
{
Md2Frame_t *pFrameA = &_frames[frameA];
Md2Frame_t *pFrameB = &_frames[frameB];
Md2Vertex_t *pVertA = &pFrameA->verts[_triangles[i].vertex[j]];
Md2Vertex_t *pVertB = &pFrameB->verts[_triangles[i].vertex[j]];
Md2TexCoord_t *pTexCoords = &_texCoords[_triangles[i].st[j]];
// Compute final texture coords.
GLfloat s = static_cast<GLfloat>(pTexCoords->s) / _header.skinwidth;
GLfloat t = static_cast<GLfloat>(pTexCoords->t) / _header.skinheight;
glTexCoord2f (s, 1.0f - t);
// Compute interpolated normal vector
Vector normA = _kAnorms[pVertA->normalIndex];
Vector normB = _kAnorms[pVertB->normalIndex];
Vector n = normA + (normB - normA) * interp;
glNormal3f(n.x,n.y,n.z);
// Compute final vertex position
Vector vecA, vecB, v;
// First, uncompress vertex positions
vecA = Vector((float*)pVertA->v) * pFrameA->scale + pFrameA->translate;
vecB = Vector((float*)pVertB->v) * pFrameB->scale + pFrameB->translate;
// Linear interpolation and scaling
v = (vecA + (vecB - vecA) * interp) * _scale;
glVertex3f(v.x,v.y,v.z);
}
}
glEnd();
}
// --------------------------------------------------------------------------
// Model_MD2::renderFrameWithGLcmds
//
// Render the model for the specified frame, using OpenGL commands.
// --------------------------------------------------------------------------
void
Model_MD2::renderFrameWithGLcmds (int frame)
{
modelsRenderedThisFrame++;
// Compute max frame index
int maxFrame = _header.num_frames - 1;
// Check if the frame index is valid
if ((frame < 0) || (frame > maxFrame))
return;
// Bind to model's texture
// Pointer to OpenGL commands
int *pGlcmds = _glcmds;
int i;
while ((i = *(pGlcmds++)) != 0)
{
if (i < 0)
{
glBegin (GL_TRIANGLE_FAN);
i = -i;
}
else
{
glBegin (GL_TRIANGLE_STRIP);
}
// Parse all OpenGL commands of this group
for (/* nothing */; i > 0; --i, pGlcmds += 3)
{
// pGlcmds[0] : final S texture coord.
// pGlcmds[1] : final T texture coord.
// pGlcmds[2] : vertex index to draw
Md2Glcmd_t *pGLcmd = reinterpret_cast<Md2Glcmd_t *>(pGlcmds);
Md2Frame_t *pFrame = &_frames[frame];
Md2Vertex_t *pVert = &pFrame->verts[pGLcmd->index];
// Send texture coords. to OpenGL
glTexCoord2f (pGLcmd->s, 1.0f - pGLcmd->t);
// Send normal vector to OpenGL
glNormal3f(_kAnorms[pVert->normalIndex].x,_kAnorms[pVert->normalIndex].y,_kAnorms[pVert->normalIndex].z);
// Uncompress vertex position and scale it
Vector v = (Vector((float*)pVert->v) + pFrame->translate * pFrame->scale) * _scale;
glVertex3f(v.x,v.y,v.z);
}
glEnd();
}
}
// --------------------------------------------------------------------------
// Model_MD2::drawModelItpWithGLcmds
//
// Render the model with frame interpolation, using OpenGL commands.
// --------------------------------------------------------------------------
void
Model_MD2::drawModelItpWithGLcmds (int frameA, int frameB, float interp)
{
modelsRenderedThisFrame++;
// Compute max frame index
int maxFrame = _header.num_frames - 1;
// Check if frames are valid
if ((frameA < 0) || (frameB < 0))
return;
if ((frameA > maxFrame) || (frameB > maxFrame))
return;
// Bind to model's texture
// Pointer to OpenGL commands
int *pGlcmds = _glcmds;
int i;
while ((i = *(pGlcmds++)) != 0)
{
if (i < 0)
{
glBegin (GL_TRIANGLE_FAN);
i = -i;
}
else
{
glBegin (GL_TRIANGLE_STRIP);
}
// Parse all OpenGL commands of this group
for (/* nothing */; i > 0; --i, pGlcmds += 3)
{
// pGlcmds[0] : final S texture coord.
// pGlcmds[1] : final T texture coord.
// pGlcmds[2] : vertex index to draw
Md2Glcmd_t *pGLcmd = reinterpret_cast<Md2Glcmd_t *>(pGlcmds);
Md2Frame_t *pFrameA = &_frames[frameA];
Md2Frame_t *pFrameB = &_frames[frameB];
Md2Vertex_t *pVertA = &pFrameA->verts[pGLcmd->index];
Md2Vertex_t *pVertB = &pFrameB->verts[pGLcmd->index];
// Send texture coords. to OpenGL
glTexCoord2f (pGLcmd->s, 1.0f - pGLcmd->t);
// Compute interpolated normal vector
Vector normA = _kAnorms [pVertA->normalIndex];
Vector normB = _kAnorms [pVertB->normalIndex];
Vector n = normA + (normB - normA) * interp;
glNormal3f(n.x,n.y,n.z);
// Compute final vertex position
Vector vecA, vecB, v;
// First, uncompress vertiex positions
vecA = (Vector((float*)pVertA->v) * pFrameA->scale) + pFrameA->translate;
vecB = (Vector((float*)pVertB->v) * pFrameB->scale) + pFrameB->translate;
// Linear interpolation and scaling
v = (vecA + ((vecB - vecA)*interp)) * _scale;
glVertex3f(v.x,v.y,v.z);
}
glEnd();
}
}
Md2Object::Md2Object (Model_MD2 *model) {
setModel(model);
_scale = 0.02f;
}
Md2Object::Md2Object() {
_scale = 0.02f;
}
Md2Object::~Md2Object() {
}
void
Md2Object::drawObjectItp (bool animated, Md2RenderMode renderMode)
{
glPushMatrix ();
// Axis rotation
glRotatef (rotation.x, 1.0f, 0.0f, 0.0f);
glRotatef (rotation.y, 0.0f, 1.0f, 0.0f);
glRotatef (rotation.z, 0.0f, 0.0f, 1.0f);
glTranslatef(position.x,position.y,-position.z);
// Set model scale factor
_model->setScale (_scale);
glPushAttrib (GL_POLYGON_BIT);
glFrontFace (GL_CW);
// Render the model
switch (renderMode)
{
case kDrawImmediate:
_model->drawModelItpImmediate (_currFrame, _nextFrame, _interp);
break;
case kDrawGLcmds:
_model->drawModelItpWithGLcmds (_currFrame, _nextFrame, _interp);
break;
}
glFrontFace (GL_CCW);
// GL_POLYGON_BIT
glPopAttrib ();
glPopMatrix ();
if (animated)
{
// Increase interpolation percent
_interp += _percent;
}
}
// --------------------------------------------------------------------------
// Md2Object::drawObjectFrame
//
// Draw the MD2 object for the specified frame.
// --------------------------------------------------------------------------
void Md2Object::drawObjectFrame (float frame, Md2RenderMode renderMode)
{
glPushMatrix ();
glMatrixMode(GL_MODELVIEW_MATRIX);
glTranslatef(position.x,position.y,position.z);
glRotatef (rotation.x-90, 1.0f, 0.0f, 0.0f);
glRotatef (rotation.y, 0.0f, 1.0f, 0.0f);
glRotatef (rotation.z, 0.0f, 0.0f, 1.0f);
// glTranslatef(0,0,3.2);
// Set model scale factor
_model->setScale (_scale);
// glPushAttrib (GL_POLYGON_BIT);
// glFrontFace (GL_CW);
_model->renderFrameImmediate ((int)frame);
// GL_POLYGON_BIT
// glPopAttrib ();
glPopMatrix ();
}
// --------------------------------------------------------------------------
// Md2Object::Animate
//
// Animate the object. Compute current and next frames, and the
// interpolation percent.
// --------------------------------------------------------------------------
void
Md2Object::animate (int startFrame, int endFrame, float percent)
{
// _currFrame must range between startFrame and endFrame
if (_currFrame < startFrame)
_currFrame = startFrame;
if (_currFrame > endFrame)
_currFrame = startFrame;
_percent = percent;
// Compute current and next frames.
if (_interp >= 1.0)
{
_interp = 0.0f;
_currFrame++;
if (_currFrame >= endFrame)
_currFrame = startFrame;
_nextFrame = _currFrame + 1;
if (_nextFrame >= endFrame)
_nextFrame = startFrame;
}
}
void Md2Object::animate (float percent)
{
// Use the current animation
animate (_animInfo->start, _animInfo->end, percent);
}
// --------------------------------------------------------------------------
// Md2Object::setModel
//
// Attach mesh model to object.
// --------------------------------------------------------------------------
void Md2Object::setModel (Model_MD2 *model)
{
_model = model;
if (_model)
{
// Set first animation as default animation
_animInfo = (Md2Anim_t*)&_model->anims().begin ()->second;
_currentAnim = _model->anims ().begin ()->first;
}
}
// --------------------------------------------------------------------------
// Md2Object::setAnim
//
// Set current object animation.
// --------------------------------------------------------------------------
void Md2Object::setAnim (const string &name)
{
// Try to find the desired animation
Model_MD2::AnimMap::const_iterator itor;
itor = _model->anims ().find (name);
if (itor != _model->anims ().end ())
{
// _animInfo = &itor->second;
_currentAnim = name;
}
}
|
/* BEGIN LICENCE */
/*****************************************************************************
* SKCore : the SK core library
* Copyright (C) 1995-2005 IDM <skcontact @at@ idm .dot. fr>
* $Id: unicode.cpp.in,v 1.1.4.1 2005/02/21 15:02:20 krys Exp $
*
* Authors: Mathieu Poumeyrol <poumeyrol @at@ idm .dot. fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Alternatively you can contact IDM <skcontact @at@ idm> for other license
* contracts concerning parts of the code owned by IDM.
*
*****************************************************************************/
/* END LICENSE */
PRUint32 g_piUnicode[] = {
0x0041, 0x0061, 0x0041 /* LATIN CAPITAL LETTER A */
, 0x0042, 0x0062, 0x0042 /* LATIN CAPITAL LETTER B */
, 0x0043, 0x0063, 0x0043 /* LATIN CAPITAL LETTER C */
, 0x0044, 0x0064, 0x0044 /* LATIN CAPITAL LETTER D */
, 0x0045, 0x0065, 0x0045 /* LATIN CAPITAL LETTER E */
, 0x0046, 0x0066, 0x0046 /* LATIN CAPITAL LETTER F */
, 0x0047, 0x0067, 0x0047 /* LATIN CAPITAL LETTER G */
, 0x0048, 0x0068, 0x0048 /* LATIN CAPITAL LETTER H */
, 0x0049, 0x0069, 0x0049 /* LATIN CAPITAL LETTER I */
, 0x004A, 0x006A, 0x004A /* LATIN CAPITAL LETTER J */
, 0x004B, 0x006B, 0x004B /* LATIN CAPITAL LETTER K */
, 0x004C, 0x006C, 0x004C /* LATIN CAPITAL LETTER L */
, 0x004D, 0x006D, 0x004D /* LATIN CAPITAL LETTER M */
, 0x004E, 0x006E, 0x004E /* LATIN CAPITAL LETTER N */
, 0x004F, 0x006F, 0x004F /* LATIN CAPITAL LETTER O */
, 0x0050, 0x0070, 0x0050 /* LATIN CAPITAL LETTER P */
, 0x0051, 0x0071, 0x0051 /* LATIN CAPITAL LETTER Q */
, 0x0052, 0x0072, 0x0052 /* LATIN CAPITAL LETTER R */
, 0x0053, 0x0073, 0x0053 /* LATIN CAPITAL LETTER S */
, 0x0054, 0x0074, 0x0054 /* LATIN CAPITAL LETTER T */
, 0x0055, 0x0075, 0x0055 /* LATIN CAPITAL LETTER U */
, 0x0056, 0x0076, 0x0056 /* LATIN CAPITAL LETTER V */
, 0x0057, 0x0077, 0x0057 /* LATIN CAPITAL LETTER W */
, 0x0058, 0x0078, 0x0058 /* LATIN CAPITAL LETTER X */
, 0x0059, 0x0079, 0x0059 /* LATIN CAPITAL LETTER Y */
, 0x005A, 0x007A, 0x005A /* LATIN CAPITAL LETTER Z */
, 0x00C0, 0x00E0, 0x0041 /* LATIN CAPITAL LETTER A WITH GRAVE */
, 0x00C1, 0x00E1, 0x0041 /* LATIN CAPITAL LETTER A WITH ACUTE */
, 0x00C2, 0x00E2, 0x0041 /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
, 0x00C3, 0x00E3, 0x0041 /* LATIN CAPITAL LETTER A WITH TILDE */
, 0x00C4, 0x00E4, 0x0041 /* LATIN CAPITAL LETTER A WITH DIAERESIS */
, 0x00C5, 0x00E5, 0x0041 /* LATIN CAPITAL LETTER A WITH RING ABOVE */
, 0x00C6, 0x00E6, 0x00C6 /* LATIN CAPITAL LETTER AE */
, 0x00C7, 0x00E7, 0x0043 /* LATIN CAPITAL LETTER C WITH CEDILLA */
, 0x00C8, 0x00E8, 0x0045 /* LATIN CAPITAL LETTER E WITH GRAVE */
, 0x00C9, 0x00E9, 0x0045 /* LATIN CAPITAL LETTER E WITH ACUTE */
, 0x00CA, 0x00EA, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
, 0x00CB, 0x00EB, 0x0045 /* LATIN CAPITAL LETTER E WITH DIAERESIS */
, 0x00CC, 0x00EC, 0x0049 /* LATIN CAPITAL LETTER I WITH GRAVE */
, 0x00CD, 0x00ED, 0x0049 /* LATIN CAPITAL LETTER I WITH ACUTE */
, 0x00CE, 0x00EE, 0x0049 /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
, 0x00CF, 0x00EF, 0x0049 /* LATIN CAPITAL LETTER I WITH DIAERESIS */
, 0x00D0, 0x00F0, 0x00D0 /* LATIN CAPITAL LETTER ETH */
, 0x00D1, 0x00F1, 0x004E /* LATIN CAPITAL LETTER N WITH TILDE */
, 0x00D2, 0x00F2, 0x004F /* LATIN CAPITAL LETTER O WITH GRAVE */
, 0x00D3, 0x00F3, 0x004F /* LATIN CAPITAL LETTER O WITH ACUTE */
, 0x00D4, 0x00F4, 0x004F /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
, 0x00D5, 0x00F5, 0x004F /* LATIN CAPITAL LETTER O WITH TILDE */
, 0x00D6, 0x00F6, 0x004F /* LATIN CAPITAL LETTER O WITH DIAERESIS */
, 0x00D8, 0x00F8, 0x00D8 /* LATIN CAPITAL LETTER O WITH STROKE */
, 0x00D9, 0x00F9, 0x0055 /* LATIN CAPITAL LETTER U WITH GRAVE */
, 0x00DA, 0x00FA, 0x0055 /* LATIN CAPITAL LETTER U WITH ACUTE */
, 0x00DB, 0x00FB, 0x0055 /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
, 0x00DC, 0x00FC, 0x0055 /* LATIN CAPITAL LETTER U WITH DIAERESIS */
, 0x00DD, 0x00FD, 0x0059 /* LATIN CAPITAL LETTER Y WITH ACUTE */
, 0x00DE, 0x00FE, 0x00DE /* LATIN CAPITAL LETTER THORN */
, 0x00E0, 0x00E0, 0x0061 /* LATIN SMALL LETTER A WITH GRAVE */
, 0x00E1, 0x00E1, 0x0061 /* LATIN SMALL LETTER A WITH ACUTE */
, 0x00E2, 0x00E2, 0x0061 /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
, 0x00E3, 0x00E3, 0x0061 /* LATIN SMALL LETTER A WITH TILDE */
, 0x00E4, 0x00E4, 0x0061 /* LATIN SMALL LETTER A WITH DIAERESIS */
, 0x00E5, 0x00E5, 0x0061 /* LATIN SMALL LETTER A WITH RING ABOVE */
, 0x00E7, 0x00E7, 0x0063 /* LATIN SMALL LETTER C WITH CEDILLA */
, 0x00E8, 0x00E8, 0x0065 /* LATIN SMALL LETTER E WITH GRAVE */
, 0x00E9, 0x00E9, 0x0065 /* LATIN SMALL LETTER E WITH ACUTE */
, 0x00EA, 0x00EA, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
, 0x00EB, 0x00EB, 0x0065 /* LATIN SMALL LETTER E WITH DIAERESIS */
, 0x00EC, 0x00EC, 0x0069 /* LATIN SMALL LETTER I WITH GRAVE */
, 0x00ED, 0x00ED, 0x0069 /* LATIN SMALL LETTER I WITH ACUTE */
, 0x00EE, 0x00EE, 0x0069 /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
, 0x00EF, 0x00EF, 0x0069 /* LATIN SMALL LETTER I WITH DIAERESIS */
, 0x00F1, 0x00F1, 0x006E /* LATIN SMALL LETTER N WITH TILDE */
, 0x00F2, 0x00F2, 0x006F /* LATIN SMALL LETTER O WITH GRAVE */
, 0x00F3, 0x00F3, 0x006F /* LATIN SMALL LETTER O WITH ACUTE */
, 0x00F4, 0x00F4, 0x006F /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
, 0x00F5, 0x00F5, 0x006F /* LATIN SMALL LETTER O WITH TILDE */
, 0x00F6, 0x00F6, 0x006F /* LATIN SMALL LETTER O WITH DIAERESIS */
, 0x00F9, 0x00F9, 0x0075 /* LATIN SMALL LETTER U WITH GRAVE */
, 0x00FA, 0x00FA, 0x0075 /* LATIN SMALL LETTER U WITH ACUTE */
, 0x00FB, 0x00FB, 0x0075 /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
, 0x00FC, 0x00FC, 0x0075 /* LATIN SMALL LETTER U WITH DIAERESIS */
, 0x00FD, 0x00FD, 0x0079 /* LATIN SMALL LETTER Y WITH ACUTE */
, 0x00FF, 0x00FF, 0x0079 /* LATIN SMALL LETTER Y WITH DIAERESIS */
, 0x0100, 0x0101, 0x0041 /* LATIN CAPITAL LETTER A WITH MACRON */
, 0x0101, 0x0101, 0x0061 /* LATIN SMALL LETTER A WITH MACRON */
, 0x0102, 0x0103, 0x0041 /* LATIN CAPITAL LETTER A WITH BREVE */
, 0x0103, 0x0103, 0x0061 /* LATIN SMALL LETTER A WITH BREVE */
, 0x0104, 0x0105, 0x0041 /* LATIN CAPITAL LETTER A WITH OGONEK */
, 0x0105, 0x0105, 0x0061 /* LATIN SMALL LETTER A WITH OGONEK */
, 0x0106, 0x0107, 0x0043 /* LATIN CAPITAL LETTER C WITH ACUTE */
, 0x0107, 0x0107, 0x0063 /* LATIN SMALL LETTER C WITH ACUTE */
, 0x0108, 0x0109, 0x0043 /* LATIN CAPITAL LETTER C WITH CIRCUMFLEX */
, 0x0109, 0x0109, 0x0063 /* LATIN SMALL LETTER C WITH CIRCUMFLEX */
, 0x010A, 0x010B, 0x0043 /* LATIN CAPITAL LETTER C WITH DOT ABOVE */
, 0x010B, 0x010B, 0x0063 /* LATIN SMALL LETTER C WITH DOT ABOVE */
, 0x010C, 0x010D, 0x0043 /* LATIN CAPITAL LETTER C WITH CARON */
, 0x010D, 0x010D, 0x0063 /* LATIN SMALL LETTER C WITH CARON */
, 0x010E, 0x010F, 0x0044 /* LATIN CAPITAL LETTER D WITH CARON */
, 0x010F, 0x010F, 0x0064 /* LATIN SMALL LETTER D WITH CARON */
, 0x0110, 0x0111, 0x0110 /* LATIN CAPITAL LETTER D WITH STROKE */
, 0x0112, 0x0113, 0x0045 /* LATIN CAPITAL LETTER E WITH MACRON */
, 0x0113, 0x0113, 0x0065 /* LATIN SMALL LETTER E WITH MACRON */
, 0x0114, 0x0115, 0x0045 /* LATIN CAPITAL LETTER E WITH BREVE */
, 0x0115, 0x0115, 0x0065 /* LATIN SMALL LETTER E WITH BREVE */
, 0x0116, 0x0117, 0x0045 /* LATIN CAPITAL LETTER E WITH DOT ABOVE */
, 0x0117, 0x0117, 0x0065 /* LATIN SMALL LETTER E WITH DOT ABOVE */
, 0x0118, 0x0119, 0x0045 /* LATIN CAPITAL LETTER E WITH OGONEK */
, 0x0119, 0x0119, 0x0065 /* LATIN SMALL LETTER E WITH OGONEK */
, 0x011A, 0x011B, 0x0045 /* LATIN CAPITAL LETTER E WITH CARON */
, 0x011B, 0x011B, 0x0065 /* LATIN SMALL LETTER E WITH CARON */
, 0x011C, 0x011D, 0x0047 /* LATIN CAPITAL LETTER G WITH CIRCUMFLEX */
, 0x011D, 0x011D, 0x0067 /* LATIN SMALL LETTER G WITH CIRCUMFLEX */
, 0x011E, 0x011F, 0x0047 /* LATIN CAPITAL LETTER G WITH BREVE */
, 0x011F, 0x011F, 0x0067 /* LATIN SMALL LETTER G WITH BREVE */
, 0x0120, 0x0121, 0x0047 /* LATIN CAPITAL LETTER G WITH DOT ABOVE */
, 0x0121, 0x0121, 0x0067 /* LATIN SMALL LETTER G WITH DOT ABOVE */
, 0x0122, 0x0123, 0x0047 /* LATIN CAPITAL LETTER G WITH CEDILLA */
, 0x0123, 0x0123, 0x0067 /* LATIN SMALL LETTER G WITH CEDILLA */
, 0x0124, 0x0125, 0x0048 /* LATIN CAPITAL LETTER H WITH CIRCUMFLEX */
, 0x0125, 0x0125, 0x0068 /* LATIN SMALL LETTER H WITH CIRCUMFLEX */
, 0x0126, 0x0127, 0x0126 /* LATIN CAPITAL LETTER H WITH STROKE */
, 0x0128, 0x0129, 0x0049 /* LATIN CAPITAL LETTER I WITH TILDE */
, 0x0129, 0x0129, 0x0069 /* LATIN SMALL LETTER I WITH TILDE */
, 0x012A, 0x012B, 0x0049 /* LATIN CAPITAL LETTER I WITH MACRON */
, 0x012B, 0x012B, 0x0069 /* LATIN SMALL LETTER I WITH MACRON */
, 0x012C, 0x012D, 0x0049 /* LATIN CAPITAL LETTER I WITH BREVE */
, 0x012D, 0x012D, 0x0069 /* LATIN SMALL LETTER I WITH BREVE */
, 0x012E, 0x012F, 0x0049 /* LATIN CAPITAL LETTER I WITH OGONEK */
, 0x012F, 0x012F, 0x0069 /* LATIN SMALL LETTER I WITH OGONEK */
, 0x0130, 0x0069, 0x0049 /* LATIN CAPITAL LETTER I WITH DOT ABOVE */
, 0x0132, 0x0133, 0x0132 /* LATIN CAPITAL LIGATURE IJ */
, 0x0134, 0x0135, 0x004A /* LATIN CAPITAL LETTER J WITH CIRCUMFLEX */
, 0x0135, 0x0135, 0x006A /* LATIN SMALL LETTER J WITH CIRCUMFLEX */
, 0x0136, 0x0137, 0x004B /* LATIN CAPITAL LETTER K WITH CEDILLA */
, 0x0137, 0x0137, 0x006B /* LATIN SMALL LETTER K WITH CEDILLA */
, 0x0139, 0x013A, 0x004C /* LATIN CAPITAL LETTER L WITH ACUTE */
, 0x013A, 0x013A, 0x006C /* LATIN SMALL LETTER L WITH ACUTE */
, 0x013B, 0x013C, 0x004C /* LATIN CAPITAL LETTER L WITH CEDILLA */
, 0x013C, 0x013C, 0x006C /* LATIN SMALL LETTER L WITH CEDILLA */
, 0x013D, 0x013E, 0x004C /* LATIN CAPITAL LETTER L WITH CARON */
, 0x013E, 0x013E, 0x006C /* LATIN SMALL LETTER L WITH CARON */
, 0x013F, 0x0140, 0x013F /* LATIN CAPITAL LETTER L WITH MIDDLE DOT */
, 0x0141, 0x0142, 0x0141 /* LATIN CAPITAL LETTER L WITH STROKE */
, 0x0143, 0x0144, 0x004E /* LATIN CAPITAL LETTER N WITH ACUTE */
, 0x0144, 0x0144, 0x006E /* LATIN SMALL LETTER N WITH ACUTE */
, 0x0145, 0x0146, 0x004E /* LATIN CAPITAL LETTER N WITH CEDILLA */
, 0x0146, 0x0146, 0x006E /* LATIN SMALL LETTER N WITH CEDILLA */
, 0x0147, 0x0148, 0x004E /* LATIN CAPITAL LETTER N WITH CARON */
, 0x0148, 0x0148, 0x006E /* LATIN SMALL LETTER N WITH CARON */
, 0x014A, 0x014B, 0x014A /* LATIN CAPITAL LETTER ENG */
, 0x014C, 0x014D, 0x004F /* LATIN CAPITAL LETTER O WITH MACRON */
, 0x014D, 0x014D, 0x006F /* LATIN SMALL LETTER O WITH MACRON */
, 0x014E, 0x014F, 0x004F /* LATIN CAPITAL LETTER O WITH BREVE */
, 0x014F, 0x014F, 0x006F /* LATIN SMALL LETTER O WITH BREVE */
, 0x0150, 0x0151, 0x004F /* LATIN CAPITAL LETTER O WITH DOUBLE ACUTE */
, 0x0151, 0x0151, 0x006F /* LATIN SMALL LETTER O WITH DOUBLE ACUTE */
, 0x0152, 0x0153, 0x0152 /* LATIN CAPITAL LIGATURE OE */
, 0x0154, 0x0155, 0x0052 /* LATIN CAPITAL LETTER R WITH ACUTE */
, 0x0155, 0x0155, 0x0072 /* LATIN SMALL LETTER R WITH ACUTE */
, 0x0156, 0x0157, 0x0052 /* LATIN CAPITAL LETTER R WITH CEDILLA */
, 0x0157, 0x0157, 0x0072 /* LATIN SMALL LETTER R WITH CEDILLA */
, 0x0158, 0x0159, 0x0052 /* LATIN CAPITAL LETTER R WITH CARON */
, 0x0159, 0x0159, 0x0072 /* LATIN SMALL LETTER R WITH CARON */
, 0x015A, 0x015B, 0x0053 /* LATIN CAPITAL LETTER S WITH ACUTE */
, 0x015B, 0x015B, 0x0073 /* LATIN SMALL LETTER S WITH ACUTE */
, 0x015C, 0x015D, 0x0053 /* LATIN CAPITAL LETTER S WITH CIRCUMFLEX */
, 0x015D, 0x015D, 0x0073 /* LATIN SMALL LETTER S WITH CIRCUMFLEX */
, 0x015E, 0x015F, 0x0053 /* LATIN CAPITAL LETTER S WITH CEDILLA */
, 0x015F, 0x015F, 0x0073 /* LATIN SMALL LETTER S WITH CEDILLA */
, 0x0160, 0x0161, 0x0053 /* LATIN CAPITAL LETTER S WITH CARON */
, 0x0161, 0x0161, 0x0073 /* LATIN SMALL LETTER S WITH CARON */
, 0x0162, 0x0163, 0x0054 /* LATIN CAPITAL LETTER T WITH CEDILLA */
, 0x0163, 0x0163, 0x0074 /* LATIN SMALL LETTER T WITH CEDILLA */
, 0x0164, 0x0165, 0x0054 /* LATIN CAPITAL LETTER T WITH CARON */
, 0x0165, 0x0165, 0x0074 /* LATIN SMALL LETTER T WITH CARON */
, 0x0166, 0x0167, 0x0166 /* LATIN CAPITAL LETTER T WITH STROKE */
, 0x0168, 0x0169, 0x0055 /* LATIN CAPITAL LETTER U WITH TILDE */
, 0x0169, 0x0169, 0x0075 /* LATIN SMALL LETTER U WITH TILDE */
, 0x016A, 0x016B, 0x0055 /* LATIN CAPITAL LETTER U WITH MACRON */
, 0x016B, 0x016B, 0x0075 /* LATIN SMALL LETTER U WITH MACRON */
, 0x016C, 0x016D, 0x0055 /* LATIN CAPITAL LETTER U WITH BREVE */
, 0x016D, 0x016D, 0x0075 /* LATIN SMALL LETTER U WITH BREVE */
, 0x016E, 0x016F, 0x0055 /* LATIN CAPITAL LETTER U WITH RING ABOVE */
, 0x016F, 0x016F, 0x0075 /* LATIN SMALL LETTER U WITH RING ABOVE */
, 0x0170, 0x0171, 0x0055 /* LATIN CAPITAL LETTER U WITH DOUBLE ACUTE */
, 0x0171, 0x0171, 0x0075 /* LATIN SMALL LETTER U WITH DOUBLE ACUTE */
, 0x0172, 0x0173, 0x0055 /* LATIN CAPITAL LETTER U WITH OGONEK */
, 0x0173, 0x0173, 0x0075 /* LATIN SMALL LETTER U WITH OGONEK */
, 0x0174, 0x0175, 0x0057 /* LATIN CAPITAL LETTER W WITH CIRCUMFLEX */
, 0x0175, 0x0175, 0x0077 /* LATIN SMALL LETTER W WITH CIRCUMFLEX */
, 0x0176, 0x0177, 0x0059 /* LATIN CAPITAL LETTER Y WITH CIRCUMFLEX */
, 0x0177, 0x0177, 0x0079 /* LATIN SMALL LETTER Y WITH CIRCUMFLEX */
, 0x0178, 0x00FF, 0x0059 /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
, 0x0179, 0x017A, 0x005A /* LATIN CAPITAL LETTER Z WITH ACUTE */
, 0x017A, 0x017A, 0x007A /* LATIN SMALL LETTER Z WITH ACUTE */
, 0x017B, 0x017C, 0x005A /* LATIN CAPITAL LETTER Z WITH DOT ABOVE */
, 0x017C, 0x017C, 0x007A /* LATIN SMALL LETTER Z WITH DOT ABOVE */
, 0x017D, 0x017E, 0x005A /* LATIN CAPITAL LETTER Z WITH CARON */
, 0x017E, 0x017E, 0x007A /* LATIN SMALL LETTER Z WITH CARON */
, 0x0181, 0x0253, 0x0181 /* LATIN CAPITAL LETTER B WITH HOOK */
, 0x0182, 0x0183, 0x0182 /* LATIN CAPITAL LETTER B WITH TOPBAR */
, 0x0184, 0x0185, 0x0184 /* LATIN CAPITAL LETTER TONE SIX */
, 0x0186, 0x0254, 0x0186 /* LATIN CAPITAL LETTER OPEN O */
, 0x0187, 0x0188, 0x0187 /* LATIN CAPITAL LETTER C WITH HOOK */
, 0x0189, 0x0256, 0x0189 /* LATIN CAPITAL LETTER AFRICAN D */
, 0x018A, 0x0257, 0x018A /* LATIN CAPITAL LETTER D WITH HOOK */
, 0x018B, 0x018C, 0x018B /* LATIN CAPITAL LETTER D WITH TOPBAR */
, 0x018E, 0x01DD, 0x018E /* LATIN CAPITAL LETTER REVERSED E */
, 0x018F, 0x0259, 0x018F /* LATIN CAPITAL LETTER SCHWA */
, 0x0190, 0x025B, 0x0190 /* LATIN CAPITAL LETTER OPEN E */
, 0x0191, 0x0192, 0x0191 /* LATIN CAPITAL LETTER F WITH HOOK */
, 0x0193, 0x0260, 0x0193 /* LATIN CAPITAL LETTER G WITH HOOK */
, 0x0194, 0x0263, 0x0194 /* LATIN CAPITAL LETTER GAMMA */
, 0x0196, 0x0269, 0x0196 /* LATIN CAPITAL LETTER IOTA */
, 0x0197, 0x0268, 0x0197 /* LATIN CAPITAL LETTER I WITH STROKE */
, 0x0198, 0x0199, 0x0198 /* LATIN CAPITAL LETTER K WITH HOOK */
, 0x019C, 0x026F, 0x019C /* LATIN CAPITAL LETTER TURNED M */
, 0x019D, 0x0272, 0x019D /* LATIN CAPITAL LETTER N WITH LEFT HOOK */
, 0x019F, 0x0275, 0x019F /* LATIN CAPITAL LETTER O WITH MIDDLE TILDE */
, 0x01A0, 0x01A1, 0x004F /* LATIN CAPITAL LETTER O WITH HORN */
, 0x01A1, 0x01A1, 0x006F /* LATIN SMALL LETTER O WITH HORN */
, 0x01A2, 0x01A3, 0x01A2 /* LATIN CAPITAL LETTER OI */
, 0x01A4, 0x01A5, 0x01A4 /* LATIN CAPITAL LETTER P WITH HOOK */
, 0x01A6, 0x0280, 0x01A6 /* LATIN LETTER YR */
, 0x01A7, 0x01A8, 0x01A7 /* LATIN CAPITAL LETTER TONE TWO */
, 0x01A9, 0x0283, 0x01A9 /* LATIN CAPITAL LETTER ESH */
, 0x01AC, 0x01AD, 0x01AC /* LATIN CAPITAL LETTER T WITH HOOK */
, 0x01AE, 0x0288, 0x01AE /* LATIN CAPITAL LETTER T WITH RETROFLEX HOOK */
, 0x01AF, 0x01B0, 0x0055 /* LATIN CAPITAL LETTER U WITH HORN */
, 0x01B0, 0x01B0, 0x0075 /* LATIN SMALL LETTER U WITH HORN */
, 0x01B1, 0x028A, 0x01B1 /* LATIN CAPITAL LETTER UPSILON */
, 0x01B2, 0x028B, 0x01B2 /* LATIN CAPITAL LETTER V WITH HOOK */
, 0x01B3, 0x01B4, 0x01B3 /* LATIN CAPITAL LETTER Y WITH HOOK */
, 0x01B5, 0x01B6, 0x01B5 /* LATIN CAPITAL LETTER Z WITH STROKE */
, 0x01B7, 0x0292, 0x01B7 /* LATIN CAPITAL LETTER EZH */
, 0x01B8, 0x01B9, 0x01B8 /* LATIN CAPITAL LETTER EZH REVERSED */
, 0x01BC, 0x01BD, 0x01BC /* LATIN CAPITAL LETTER TONE FIVE */
, 0x01C4, 0x01C6, 0x01C4 /* LATIN CAPITAL LETTER DZ WITH CARON */
, 0x01C5, 0x01C6, 0x01C5 /* LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON */
, 0x01C7, 0x01C9, 0x01C7 /* LATIN CAPITAL LETTER LJ */
, 0x01C8, 0x01C9, 0x01C8 /* LATIN CAPITAL LETTER L WITH SMALL LETTER J */
, 0x01CA, 0x01CC, 0x01CA /* LATIN CAPITAL LETTER NJ */
, 0x01CB, 0x01CC, 0x01CB /* LATIN CAPITAL LETTER N WITH SMALL LETTER J */
, 0x01CD, 0x01CE, 0x0041 /* LATIN CAPITAL LETTER A WITH CARON */
, 0x01CE, 0x01CE, 0x0061 /* LATIN SMALL LETTER A WITH CARON */
, 0x01CF, 0x01D0, 0x0049 /* LATIN CAPITAL LETTER I WITH CARON */
, 0x01D0, 0x01D0, 0x0069 /* LATIN SMALL LETTER I WITH CARON */
, 0x01D1, 0x01D2, 0x004F /* LATIN CAPITAL LETTER O WITH CARON */
, 0x01D2, 0x01D2, 0x006F /* LATIN SMALL LETTER O WITH CARON */
, 0x01D3, 0x01D4, 0x0055 /* LATIN CAPITAL LETTER U WITH CARON */
, 0x01D4, 0x01D4, 0x0075 /* LATIN SMALL LETTER U WITH CARON */
, 0x01D5, 0x01D6, 0x0055 /* LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON */
, 0x01D6, 0x01D6, 0x0075 /* LATIN SMALL LETTER U WITH DIAERESIS AND MACRON */
, 0x01D7, 0x01D8, 0x0055 /* LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE */
, 0x01D8, 0x01D8, 0x0075 /* LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE */
, 0x01D9, 0x01DA, 0x0055 /* LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON */
, 0x01DA, 0x01DA, 0x0075 /* LATIN SMALL LETTER U WITH DIAERESIS AND CARON */
, 0x01DB, 0x01DC, 0x0055 /* LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE */
, 0x01DC, 0x01DC, 0x0075 /* LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE */
, 0x01DE, 0x01DF, 0x0041 /* LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON */
, 0x01DF, 0x01DF, 0x0061 /* LATIN SMALL LETTER A WITH DIAERESIS AND MACRON */
, 0x01E0, 0x01E1, 0x0041 /* LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON */
, 0x01E1, 0x01E1, 0x0061 /* LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON */
, 0x01E2, 0x01E3, 0x00C6 /* LATIN CAPITAL LETTER AE WITH MACRON */
, 0x01E3, 0x01E3, 0x00E6 /* LATIN SMALL LETTER AE WITH MACRON */
, 0x01E4, 0x01E5, 0x01E4 /* LATIN CAPITAL LETTER G WITH STROKE */
, 0x01E6, 0x01E7, 0x0047 /* LATIN CAPITAL LETTER G WITH CARON */
, 0x01E7, 0x01E7, 0x0067 /* LATIN SMALL LETTER G WITH CARON */
, 0x01E8, 0x01E9, 0x004B /* LATIN CAPITAL LETTER K WITH CARON */
, 0x01E9, 0x01E9, 0x006B /* LATIN SMALL LETTER K WITH CARON */
, 0x01EA, 0x01EB, 0x004F /* LATIN CAPITAL LETTER O WITH OGONEK */
, 0x01EB, 0x01EB, 0x006F /* LATIN SMALL LETTER O WITH OGONEK */
, 0x01EC, 0x01ED, 0x004F /* LATIN CAPITAL LETTER O WITH OGONEK AND MACRON */
, 0x01ED, 0x01ED, 0x006F /* LATIN SMALL LETTER O WITH OGONEK AND MACRON */
, 0x01EE, 0x01EF, 0x01B7 /* LATIN CAPITAL LETTER EZH WITH CARON */
, 0x01EF, 0x01EF, 0x0292 /* LATIN SMALL LETTER EZH WITH CARON */
, 0x01F0, 0x01F0, 0x006A /* LATIN SMALL LETTER J WITH CARON */
, 0x01F1, 0x01F3, 0x01F1 /* LATIN CAPITAL LETTER DZ */
, 0x01F2, 0x01F3, 0x01F2 /* LATIN CAPITAL LETTER D WITH SMALL LETTER Z */
, 0x01F4, 0x01F5, 0x0047 /* LATIN CAPITAL LETTER G WITH ACUTE */
, 0x01F5, 0x01F5, 0x0067 /* LATIN SMALL LETTER G WITH ACUTE */
, 0x01F6, 0x0195, 0x01F6 /* LATIN CAPITAL LETTER HWAIR */
, 0x01F7, 0x01BF, 0x01F7 /* LATIN CAPITAL LETTER WYNN */
, 0x01F8, 0x01F9, 0x004E /* LATIN CAPITAL LETTER N WITH GRAVE */
, 0x01F9, 0x01F9, 0x006E /* LATIN SMALL LETTER N WITH GRAVE */
, 0x01FA, 0x01FB, 0x0041 /* LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE */
, 0x01FB, 0x01FB, 0x0061 /* LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE */
, 0x01FC, 0x01FD, 0x00C6 /* LATIN CAPITAL LETTER AE WITH ACUTE */
, 0x01FD, 0x01FD, 0x00E6 /* LATIN SMALL LETTER AE WITH ACUTE */
, 0x01FE, 0x01FF, 0x00D8 /* LATIN CAPITAL LETTER O WITH STROKE AND ACUTE */
, 0x01FF, 0x01FF, 0x00F8 /* LATIN SMALL LETTER O WITH STROKE AND ACUTE */
, 0x0200, 0x0201, 0x0041 /* LATIN CAPITAL LETTER A WITH DOUBLE GRAVE */
, 0x0201, 0x0201, 0x0061 /* LATIN SMALL LETTER A WITH DOUBLE GRAVE */
, 0x0202, 0x0203, 0x0041 /* LATIN CAPITAL LETTER A WITH INVERTED BREVE */
, 0x0203, 0x0203, 0x0061 /* LATIN SMALL LETTER A WITH INVERTED BREVE */
, 0x0204, 0x0205, 0x0045 /* LATIN CAPITAL LETTER E WITH DOUBLE GRAVE */
, 0x0205, 0x0205, 0x0065 /* LATIN SMALL LETTER E WITH DOUBLE GRAVE */
, 0x0206, 0x0207, 0x0045 /* LATIN CAPITAL LETTER E WITH INVERTED BREVE */
, 0x0207, 0x0207, 0x0065 /* LATIN SMALL LETTER E WITH INVERTED BREVE */
, 0x0208, 0x0209, 0x0049 /* LATIN CAPITAL LETTER I WITH DOUBLE GRAVE */
, 0x0209, 0x0209, 0x0069 /* LATIN SMALL LETTER I WITH DOUBLE GRAVE */
, 0x020A, 0x020B, 0x0049 /* LATIN CAPITAL LETTER I WITH INVERTED BREVE */
, 0x020B, 0x020B, 0x0069 /* LATIN SMALL LETTER I WITH INVERTED BREVE */
, 0x020C, 0x020D, 0x004F /* LATIN CAPITAL LETTER O WITH DOUBLE GRAVE */
, 0x020D, 0x020D, 0x006F /* LATIN SMALL LETTER O WITH DOUBLE GRAVE */
, 0x020E, 0x020F, 0x004F /* LATIN CAPITAL LETTER O WITH INVERTED BREVE */
, 0x020F, 0x020F, 0x006F /* LATIN SMALL LETTER O WITH INVERTED BREVE */
, 0x0210, 0x0211, 0x0052 /* LATIN CAPITAL LETTER R WITH DOUBLE GRAVE */
, 0x0211, 0x0211, 0x0072 /* LATIN SMALL LETTER R WITH DOUBLE GRAVE */
, 0x0212, 0x0213, 0x0052 /* LATIN CAPITAL LETTER R WITH INVERTED BREVE */
, 0x0213, 0x0213, 0x0072 /* LATIN SMALL LETTER R WITH INVERTED BREVE */
, 0x0214, 0x0215, 0x0055 /* LATIN CAPITAL LETTER U WITH DOUBLE GRAVE */
, 0x0215, 0x0215, 0x0075 /* LATIN SMALL LETTER U WITH DOUBLE GRAVE */
, 0x0216, 0x0217, 0x0055 /* LATIN CAPITAL LETTER U WITH INVERTED BREVE */
, 0x0217, 0x0217, 0x0075 /* LATIN SMALL LETTER U WITH INVERTED BREVE */
, 0x0218, 0x0219, 0x0053 /* LATIN CAPITAL LETTER S WITH COMMA BELOW */
, 0x0219, 0x0219, 0x0073 /* LATIN SMALL LETTER S WITH COMMA BELOW */
, 0x021A, 0x021B, 0x0054 /* LATIN CAPITAL LETTER T WITH COMMA BELOW */
, 0x021B, 0x021B, 0x0074 /* LATIN SMALL LETTER T WITH COMMA BELOW */
, 0x021C, 0x021D, 0x021C /* LATIN CAPITAL LETTER YOGH */
, 0x021E, 0x021F, 0x0048 /* LATIN CAPITAL LETTER H WITH CARON */
, 0x021F, 0x021F, 0x0068 /* LATIN SMALL LETTER H WITH CARON */
, 0x0220, 0x019E, 0x0220 /* LATIN CAPITAL LETTER N WITH LONG RIGHT LEG */
, 0x0222, 0x0223, 0x0222 /* LATIN CAPITAL LETTER OU */
, 0x0224, 0x0225, 0x0224 /* LATIN CAPITAL LETTER Z WITH HOOK */
, 0x0226, 0x0227, 0x0041 /* LATIN CAPITAL LETTER A WITH DOT ABOVE */
, 0x0227, 0x0227, 0x0061 /* LATIN SMALL LETTER A WITH DOT ABOVE */
, 0x0228, 0x0229, 0x0045 /* LATIN CAPITAL LETTER E WITH CEDILLA */
, 0x0229, 0x0229, 0x0065 /* LATIN SMALL LETTER E WITH CEDILLA */
, 0x022A, 0x022B, 0x004F /* LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON */
, 0x022B, 0x022B, 0x006F /* LATIN SMALL LETTER O WITH DIAERESIS AND MACRON */
, 0x022C, 0x022D, 0x004F /* LATIN CAPITAL LETTER O WITH TILDE AND MACRON */
, 0x022D, 0x022D, 0x006F /* LATIN SMALL LETTER O WITH TILDE AND MACRON */
, 0x022E, 0x022F, 0x004F /* LATIN CAPITAL LETTER O WITH DOT ABOVE */
, 0x022F, 0x022F, 0x006F /* LATIN SMALL LETTER O WITH DOT ABOVE */
, 0x0230, 0x0231, 0x004F /* LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON */
, 0x0231, 0x0231, 0x006F /* LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON */
, 0x0232, 0x0233, 0x0059 /* LATIN CAPITAL LETTER Y WITH MACRON */
, 0x0233, 0x0233, 0x0079 /* LATIN SMALL LETTER Y WITH MACRON */
, 0x0374, 0x0374, 0x02B9 /* GREEK NUMERAL SIGN */
, 0x037E, 0x037E, 0x003B /* GREEK QUESTION MARK */
, 0x0385, 0x0385, 0x00A8 /* GREEK DIALYTIKA TONOS */
, 0x0386, 0x03AC, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH TONOS */
, 0x0387, 0x0387, 0x00B7 /* GREEK ANO TELEIA */
, 0x0388, 0x03AD, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH TONOS */
, 0x0389, 0x03AE, 0x0397 /* GREEK CAPITAL LETTER ETA WITH TONOS */
, 0x038A, 0x03AF, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH TONOS */
, 0x038C, 0x03CC, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH TONOS */
, 0x038E, 0x03CD, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH TONOS */
, 0x038F, 0x03CE, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH TONOS */
, 0x0390, 0x0390, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS */
, 0x0391, 0x03B1, 0x0391 /* GREEK CAPITAL LETTER ALPHA */
, 0x0392, 0x03B2, 0x0392 /* GREEK CAPITAL LETTER BETA */
, 0x0393, 0x03B3, 0x0393 /* GREEK CAPITAL LETTER GAMMA */
, 0x0394, 0x03B4, 0x0394 /* GREEK CAPITAL LETTER DELTA */
, 0x0395, 0x03B5, 0x0395 /* GREEK CAPITAL LETTER EPSILON */
, 0x0396, 0x03B6, 0x0396 /* GREEK CAPITAL LETTER ZETA */
, 0x0397, 0x03B7, 0x0397 /* GREEK CAPITAL LETTER ETA */
, 0x0398, 0x03B8, 0x0398 /* GREEK CAPITAL LETTER THETA */
, 0x0399, 0x03B9, 0x0399 /* GREEK CAPITAL LETTER IOTA */
, 0x039A, 0x03BA, 0x039A /* GREEK CAPITAL LETTER KAPPA */
, 0x039B, 0x03BB, 0x039B /* GREEK CAPITAL LETTER LAMDA */
, 0x039C, 0x03BC, 0x039C /* GREEK CAPITAL LETTER MU */
, 0x039D, 0x03BD, 0x039D /* GREEK CAPITAL LETTER NU */
, 0x039E, 0x03BE, 0x039E /* GREEK CAPITAL LETTER XI */
, 0x039F, 0x03BF, 0x039F /* GREEK CAPITAL LETTER OMICRON */
, 0x03A0, 0x03C0, 0x03A0 /* GREEK CAPITAL LETTER PI */
, 0x03A1, 0x03C1, 0x03A1 /* GREEK CAPITAL LETTER RHO */
, 0x03A3, 0x03C3, 0x03A3 /* GREEK CAPITAL LETTER SIGMA */
, 0x03A4, 0x03C4, 0x03A4 /* GREEK CAPITAL LETTER TAU */
, 0x03A5, 0x03C5, 0x03A5 /* GREEK CAPITAL LETTER UPSILON */
, 0x03A6, 0x03C6, 0x03A6 /* GREEK CAPITAL LETTER PHI */
, 0x03A7, 0x03C7, 0x03A7 /* GREEK CAPITAL LETTER CHI */
, 0x03A8, 0x03C8, 0x03A8 /* GREEK CAPITAL LETTER PSI */
, 0x03A9, 0x03C9, 0x03A9 /* GREEK CAPITAL LETTER OMEGA */
, 0x03AA, 0x03CA, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH DIALYTIKA */
, 0x03AB, 0x03CB, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA */
, 0x03AC, 0x03AC, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH TONOS */
, 0x03AD, 0x03AD, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH TONOS */
, 0x03AE, 0x03AE, 0x03B7 /* GREEK SMALL LETTER ETA WITH TONOS */
, 0x03AF, 0x03AF, 0x03B9 /* GREEK SMALL LETTER IOTA WITH TONOS */
, 0x03B0, 0x03B0, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS */
, 0x03CA, 0x03CA, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DIALYTIKA */
, 0x03CB, 0x03CB, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DIALYTIKA */
, 0x03CC, 0x03CC, 0x03BF /* GREEK SMALL LETTER OMICRON WITH TONOS */
, 0x03CD, 0x03CD, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH TONOS */
, 0x03CE, 0x03CE, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH TONOS */
, 0x03D3, 0x03D3, 0x03D2 /* GREEK UPSILON WITH ACUTE AND HOOK SYMBOL */
, 0x03D4, 0x03D4, 0x03D2 /* GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL */
, 0x03D8, 0x03D9, 0x03D8 /* GREEK LETTER ARCHAIC KOPPA */
, 0x03DA, 0x03DB, 0x03DA /* GREEK LETTER STIGMA */
, 0x03DC, 0x03DD, 0x03DC /* GREEK LETTER DIGAMMA */
, 0x03DE, 0x03DF, 0x03DE /* GREEK LETTER KOPPA */
, 0x03E0, 0x03E1, 0x03E0 /* GREEK LETTER SAMPI */
, 0x03E2, 0x03E3, 0x03E2 /* COPTIC CAPITAL LETTER SHEI */
, 0x03E4, 0x03E5, 0x03E4 /* COPTIC CAPITAL LETTER FEI */
, 0x03E6, 0x03E7, 0x03E6 /* COPTIC CAPITAL LETTER KHEI */
, 0x03E8, 0x03E9, 0x03E8 /* COPTIC CAPITAL LETTER HORI */
, 0x03EA, 0x03EB, 0x03EA /* COPTIC CAPITAL LETTER GANGIA */
, 0x03EC, 0x03ED, 0x03EC /* COPTIC CAPITAL LETTER SHIMA */
, 0x03EE, 0x03EF, 0x03EE /* COPTIC CAPITAL LETTER DEI */
, 0x03F4, 0x03B8, 0x03F4 /* GREEK CAPITAL THETA SYMBOL */
, 0x03F7, 0x03F8, 0x03F7 /* GREEK CAPITAL LETTER SHO */
, 0x03F9, 0x03F2, 0x03F9 /* GREEK CAPITAL LUNATE SIGMA SYMBOL */
, 0x03FA, 0x03FB, 0x03FA /* GREEK CAPITAL LETTER SAN */
, 0x0400, 0x0450, 0x0415 /* CYRILLIC CAPITAL LETTER IE WITH GRAVE */
, 0x0401, 0x0451, 0x0415 /* CYRILLIC CAPITAL LETTER IO */
, 0x0402, 0x0452, 0x0402 /* CYRILLIC CAPITAL LETTER DJE */
, 0x0403, 0x0453, 0x0413 /* CYRILLIC CAPITAL LETTER GJE */
, 0x0404, 0x0454, 0x0404 /* CYRILLIC CAPITAL LETTER UKRAINIAN IE */
, 0x0405, 0x0455, 0x0405 /* CYRILLIC CAPITAL LETTER DZE */
, 0x0406, 0x0456, 0x0406 /* CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I */
, 0x0407, 0x0457, 0x0406 /* CYRILLIC CAPITAL LETTER YI */
, 0x0408, 0x0458, 0x0408 /* CYRILLIC CAPITAL LETTER JE */
, 0x0409, 0x0459, 0x0409 /* CYRILLIC CAPITAL LETTER LJE */
, 0x040A, 0x045A, 0x040A /* CYRILLIC CAPITAL LETTER NJE */
, 0x040B, 0x045B, 0x040B /* CYRILLIC CAPITAL LETTER TSHE */
, 0x040C, 0x045C, 0x041A /* CYRILLIC CAPITAL LETTER KJE */
, 0x040D, 0x045D, 0x0418 /* CYRILLIC CAPITAL LETTER I WITH GRAVE */
, 0x040E, 0x045E, 0x0423 /* CYRILLIC CAPITAL LETTER SHORT U */
, 0x040F, 0x045F, 0x040F /* CYRILLIC CAPITAL LETTER DZHE */
, 0x0410, 0x0430, 0x0410 /* CYRILLIC CAPITAL LETTER A */
, 0x0411, 0x0431, 0x0411 /* CYRILLIC CAPITAL LETTER BE */
, 0x0412, 0x0432, 0x0412 /* CYRILLIC CAPITAL LETTER VE */
, 0x0413, 0x0433, 0x0413 /* CYRILLIC CAPITAL LETTER GHE */
, 0x0414, 0x0434, 0x0414 /* CYRILLIC CAPITAL LETTER DE */
, 0x0415, 0x0435, 0x0415 /* CYRILLIC CAPITAL LETTER IE */
, 0x0416, 0x0436, 0x0416 /* CYRILLIC CAPITAL LETTER ZHE */
, 0x0417, 0x0437, 0x0417 /* CYRILLIC CAPITAL LETTER ZE */
, 0x0418, 0x0438, 0x0418 /* CYRILLIC CAPITAL LETTER I */
, 0x0419, 0x0439, 0x0418 /* CYRILLIC CAPITAL LETTER SHORT I */
, 0x041A, 0x043A, 0x041A /* CYRILLIC CAPITAL LETTER KA */
, 0x041B, 0x043B, 0x041B /* CYRILLIC CAPITAL LETTER EL */
, 0x041C, 0x043C, 0x041C /* CYRILLIC CAPITAL LETTER EM */
, 0x041D, 0x043D, 0x041D /* CYRILLIC CAPITAL LETTER EN */
, 0x041E, 0x043E, 0x041E /* CYRILLIC CAPITAL LETTER O */
, 0x041F, 0x043F, 0x041F /* CYRILLIC CAPITAL LETTER PE */
, 0x0420, 0x0440, 0x0420 /* CYRILLIC CAPITAL LETTER ER */
, 0x0421, 0x0441, 0x0421 /* CYRILLIC CAPITAL LETTER ES */
, 0x0422, 0x0442, 0x0422 /* CYRILLIC CAPITAL LETTER TE */
, 0x0423, 0x0443, 0x0423 /* CYRILLIC CAPITAL LETTER U */
, 0x0424, 0x0444, 0x0424 /* CYRILLIC CAPITAL LETTER EF */
, 0x0425, 0x0445, 0x0425 /* CYRILLIC CAPITAL LETTER HA */
, 0x0426, 0x0446, 0x0426 /* CYRILLIC CAPITAL LETTER TSE */
, 0x0427, 0x0447, 0x0427 /* CYRILLIC CAPITAL LETTER CHE */
, 0x0428, 0x0448, 0x0428 /* CYRILLIC CAPITAL LETTER SHA */
, 0x0429, 0x0449, 0x0429 /* CYRILLIC CAPITAL LETTER SHCHA */
, 0x042A, 0x044A, 0x042A /* CYRILLIC CAPITAL LETTER HARD SIGN */
, 0x042B, 0x044B, 0x042B /* CYRILLIC CAPITAL LETTER YERU */
, 0x042C, 0x044C, 0x042C /* CYRILLIC CAPITAL LETTER SOFT SIGN */
, 0x042D, 0x044D, 0x042D /* CYRILLIC CAPITAL LETTER E */
, 0x042E, 0x044E, 0x042E /* CYRILLIC CAPITAL LETTER YU */
, 0x042F, 0x044F, 0x042F /* CYRILLIC CAPITAL LETTER YA */
, 0x0439, 0x0439, 0x0438 /* CYRILLIC SMALL LETTER SHORT I */
, 0x0450, 0x0450, 0x0435 /* CYRILLIC SMALL LETTER IE WITH GRAVE */
, 0x0451, 0x0451, 0x0435 /* CYRILLIC SMALL LETTER IO */
, 0x0453, 0x0453, 0x0433 /* CYRILLIC SMALL LETTER GJE */
, 0x0457, 0x0457, 0x0456 /* CYRILLIC SMALL LETTER YI */
, 0x045C, 0x045C, 0x043A /* CYRILLIC SMALL LETTER KJE */
, 0x045D, 0x045D, 0x0438 /* CYRILLIC SMALL LETTER I WITH GRAVE */
, 0x045E, 0x045E, 0x0443 /* CYRILLIC SMALL LETTER SHORT U */
, 0x0460, 0x0461, 0x0460 /* CYRILLIC CAPITAL LETTER OMEGA */
, 0x0462, 0x0463, 0x0462 /* CYRILLIC CAPITAL LETTER YAT */
, 0x0464, 0x0465, 0x0464 /* CYRILLIC CAPITAL LETTER IOTIFIED E */
, 0x0466, 0x0467, 0x0466 /* CYRILLIC CAPITAL LETTER LITTLE YUS */
, 0x0468, 0x0469, 0x0468 /* CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS */
, 0x046A, 0x046B, 0x046A /* CYRILLIC CAPITAL LETTER BIG YUS */
, 0x046C, 0x046D, 0x046C /* CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS */
, 0x046E, 0x046F, 0x046E /* CYRILLIC CAPITAL LETTER KSI */
, 0x0470, 0x0471, 0x0470 /* CYRILLIC CAPITAL LETTER PSI */
, 0x0472, 0x0473, 0x0472 /* CYRILLIC CAPITAL LETTER FITA */
, 0x0474, 0x0475, 0x0474 /* CYRILLIC CAPITAL LETTER IZHITSA */
, 0x0476, 0x0477, 0x0474 /* CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT */
, 0x0477, 0x0477, 0x0475 /* CYRILLIC SMALL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT */
, 0x0478, 0x0479, 0x0478 /* CYRILLIC CAPITAL LETTER UK */
, 0x047A, 0x047B, 0x047A /* CYRILLIC CAPITAL LETTER ROUND OMEGA */
, 0x047C, 0x047D, 0x047C /* CYRILLIC CAPITAL LETTER OMEGA WITH TITLO */
, 0x047E, 0x047F, 0x047E /* CYRILLIC CAPITAL LETTER OT */
, 0x0480, 0x0481, 0x0480 /* CYRILLIC CAPITAL LETTER KOPPA */
, 0x048A, 0x048B, 0x048A /* CYRILLIC CAPITAL LETTER SHORT I WITH TAIL */
, 0x048C, 0x048D, 0x048C /* CYRILLIC CAPITAL LETTER SEMISOFT SIGN */
, 0x048E, 0x048F, 0x048E /* CYRILLIC CAPITAL LETTER ER WITH TICK */
, 0x0490, 0x0491, 0x0490 /* CYRILLIC CAPITAL LETTER GHE WITH UPTURN */
, 0x0492, 0x0493, 0x0492 /* CYRILLIC CAPITAL LETTER GHE WITH STROKE */
, 0x0494, 0x0495, 0x0494 /* CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK */
, 0x0496, 0x0497, 0x0496 /* CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER */
, 0x0498, 0x0499, 0x0498 /* CYRILLIC CAPITAL LETTER ZE WITH DESCENDER */
, 0x049A, 0x049B, 0x049A /* CYRILLIC CAPITAL LETTER KA WITH DESCENDER */
, 0x049C, 0x049D, 0x049C /* CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE */
, 0x049E, 0x049F, 0x049E /* CYRILLIC CAPITAL LETTER KA WITH STROKE */
, 0x04A0, 0x04A1, 0x04A0 /* CYRILLIC CAPITAL LETTER BASHKIR KA */
, 0x04A2, 0x04A3, 0x04A2 /* CYRILLIC CAPITAL LETTER EN WITH DESCENDER */
, 0x04A4, 0x04A5, 0x04A4 /* CYRILLIC CAPITAL LIGATURE EN GHE */
, 0x04A6, 0x04A7, 0x04A6 /* CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK */
, 0x04A8, 0x04A9, 0x04A8 /* CYRILLIC CAPITAL LETTER ABKHASIAN HA */
, 0x04AA, 0x04AB, 0x04AA /* CYRILLIC CAPITAL LETTER ES WITH DESCENDER */
, 0x04AC, 0x04AD, 0x04AC /* CYRILLIC CAPITAL LETTER TE WITH DESCENDER */
, 0x04AE, 0x04AF, 0x04AE /* CYRILLIC CAPITAL LETTER STRAIGHT U */
, 0x04B0, 0x04B1, 0x04B0 /* CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE */
, 0x04B2, 0x04B3, 0x04B2 /* CYRILLIC CAPITAL LETTER HA WITH DESCENDER */
, 0x04B4, 0x04B5, 0x04B4 /* CYRILLIC CAPITAL LIGATURE TE TSE */
, 0x04B6, 0x04B7, 0x04B6 /* CYRILLIC CAPITAL LETTER CHE WITH DESCENDER */
, 0x04B8, 0x04B9, 0x04B8 /* CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE */
, 0x04BA, 0x04BB, 0x04BA /* CYRILLIC CAPITAL LETTER SHHA */
, 0x04BC, 0x04BD, 0x04BC /* CYRILLIC CAPITAL LETTER ABKHASIAN CHE */
, 0x04BE, 0x04BF, 0x04BE /* CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER */
, 0x04C1, 0x04C2, 0x0416 /* CYRILLIC CAPITAL LETTER ZHE WITH BREVE */
, 0x04C2, 0x04C2, 0x0436 /* CYRILLIC SMALL LETTER ZHE WITH BREVE */
, 0x04C3, 0x04C4, 0x04C3 /* CYRILLIC CAPITAL LETTER KA WITH HOOK */
, 0x04C5, 0x04C6, 0x04C5 /* CYRILLIC CAPITAL LETTER EL WITH TAIL */
, 0x04C7, 0x04C8, 0x04C7 /* CYRILLIC CAPITAL LETTER EN WITH HOOK */
, 0x04C9, 0x04CA, 0x04C9 /* CYRILLIC CAPITAL LETTER EN WITH TAIL */
, 0x04CB, 0x04CC, 0x04CB /* CYRILLIC CAPITAL LETTER KHAKASSIAN CHE */
, 0x04CD, 0x04CE, 0x04CD /* CYRILLIC CAPITAL LETTER EM WITH TAIL */
, 0x04D0, 0x04D1, 0x0410 /* CYRILLIC CAPITAL LETTER A WITH BREVE */
, 0x04D1, 0x04D1, 0x0430 /* CYRILLIC SMALL LETTER A WITH BREVE */
, 0x04D2, 0x04D3, 0x0410 /* CYRILLIC CAPITAL LETTER A WITH DIAERESIS */
, 0x04D3, 0x04D3, 0x0430 /* CYRILLIC SMALL LETTER A WITH DIAERESIS */
, 0x04D4, 0x04D5, 0x04D4 /* CYRILLIC CAPITAL LIGATURE A IE */
, 0x04D6, 0x04D7, 0x0415 /* CYRILLIC CAPITAL LETTER IE WITH BREVE */
, 0x04D7, 0x04D7, 0x0435 /* CYRILLIC SMALL LETTER IE WITH BREVE */
, 0x04D8, 0x04D9, 0x04D8 /* CYRILLIC CAPITAL LETTER SCHWA */
, 0x04DA, 0x04DB, 0x04D8 /* CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS */
, 0x04DB, 0x04DB, 0x04D9 /* CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS */
, 0x04DC, 0x04DD, 0x0416 /* CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS */
, 0x04DD, 0x04DD, 0x0436 /* CYRILLIC SMALL LETTER ZHE WITH DIAERESIS */
, 0x04DE, 0x04DF, 0x0417 /* CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS */
, 0x04DF, 0x04DF, 0x0437 /* CYRILLIC SMALL LETTER ZE WITH DIAERESIS */
, 0x04E0, 0x04E1, 0x04E0 /* CYRILLIC CAPITAL LETTER ABKHASIAN DZE */
, 0x04E2, 0x04E3, 0x0418 /* CYRILLIC CAPITAL LETTER I WITH MACRON */
, 0x04E3, 0x04E3, 0x0438 /* CYRILLIC SMALL LETTER I WITH MACRON */
, 0x04E4, 0x04E5, 0x0418 /* CYRILLIC CAPITAL LETTER I WITH DIAERESIS */
, 0x04E5, 0x04E5, 0x0438 /* CYRILLIC SMALL LETTER I WITH DIAERESIS */
, 0x04E6, 0x04E7, 0x041E /* CYRILLIC CAPITAL LETTER O WITH DIAERESIS */
, 0x04E7, 0x04E7, 0x043E /* CYRILLIC SMALL LETTER O WITH DIAERESIS */
, 0x04E8, 0x04E9, 0x04E8 /* CYRILLIC CAPITAL LETTER BARRED O */
, 0x04EA, 0x04EB, 0x04E8 /* CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS */
, 0x04EB, 0x04EB, 0x04E9 /* CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS */
, 0x04EC, 0x04ED, 0x042D /* CYRILLIC CAPITAL LETTER E WITH DIAERESIS */
, 0x04ED, 0x04ED, 0x044D /* CYRILLIC SMALL LETTER E WITH DIAERESIS */
, 0x04EE, 0x04EF, 0x0423 /* CYRILLIC CAPITAL LETTER U WITH MACRON */
, 0x04EF, 0x04EF, 0x0443 /* CYRILLIC SMALL LETTER U WITH MACRON */
, 0x04F0, 0x04F1, 0x0423 /* CYRILLIC CAPITAL LETTER U WITH DIAERESIS */
, 0x04F1, 0x04F1, 0x0443 /* CYRILLIC SMALL LETTER U WITH DIAERESIS */
, 0x04F2, 0x04F3, 0x0423 /* CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE */
, 0x04F3, 0x04F3, 0x0443 /* CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE */
, 0x04F4, 0x04F5, 0x0427 /* CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS */
, 0x04F5, 0x04F5, 0x0447 /* CYRILLIC SMALL LETTER CHE WITH DIAERESIS */
, 0x04F8, 0x04F9, 0x042B /* CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS */
, 0x04F9, 0x04F9, 0x044B /* CYRILLIC SMALL LETTER YERU WITH DIAERESIS */
, 0x0500, 0x0501, 0x0500 /* CYRILLIC CAPITAL LETTER KOMI DE */
, 0x0502, 0x0503, 0x0502 /* CYRILLIC CAPITAL LETTER KOMI DJE */
, 0x0504, 0x0505, 0x0504 /* CYRILLIC CAPITAL LETTER KOMI ZJE */
, 0x0506, 0x0507, 0x0506 /* CYRILLIC CAPITAL LETTER KOMI DZJE */
, 0x0508, 0x0509, 0x0508 /* CYRILLIC CAPITAL LETTER KOMI LJE */
, 0x050A, 0x050B, 0x050A /* CYRILLIC CAPITAL LETTER KOMI NJE */
, 0x050C, 0x050D, 0x050C /* CYRILLIC CAPITAL LETTER KOMI SJE */
, 0x050E, 0x050F, 0x050E /* CYRILLIC CAPITAL LETTER KOMI TJE */
, 0x0531, 0x0561, 0x0531 /* ARMENIAN CAPITAL LETTER AYB */
, 0x0532, 0x0562, 0x0532 /* ARMENIAN CAPITAL LETTER BEN */
, 0x0533, 0x0563, 0x0533 /* ARMENIAN CAPITAL LETTER GIM */
, 0x0534, 0x0564, 0x0534 /* ARMENIAN CAPITAL LETTER DA */
, 0x0535, 0x0565, 0x0535 /* ARMENIAN CAPITAL LETTER ECH */
, 0x0536, 0x0566, 0x0536 /* ARMENIAN CAPITAL LETTER ZA */
, 0x0537, 0x0567, 0x0537 /* ARMENIAN CAPITAL LETTER EH */
, 0x0538, 0x0568, 0x0538 /* ARMENIAN CAPITAL LETTER ET */
, 0x0539, 0x0569, 0x0539 /* ARMENIAN CAPITAL LETTER TO */
, 0x053A, 0x056A, 0x053A /* ARMENIAN CAPITAL LETTER ZHE */
, 0x053B, 0x056B, 0x053B /* ARMENIAN CAPITAL LETTER INI */
, 0x053C, 0x056C, 0x053C /* ARMENIAN CAPITAL LETTER LIWN */
, 0x053D, 0x056D, 0x053D /* ARMENIAN CAPITAL LETTER XEH */
, 0x053E, 0x056E, 0x053E /* ARMENIAN CAPITAL LETTER CA */
, 0x053F, 0x056F, 0x053F /* ARMENIAN CAPITAL LETTER KEN */
, 0x0540, 0x0570, 0x0540 /* ARMENIAN CAPITAL LETTER HO */
, 0x0541, 0x0571, 0x0541 /* ARMENIAN CAPITAL LETTER JA */
, 0x0542, 0x0572, 0x0542 /* ARMENIAN CAPITAL LETTER GHAD */
, 0x0543, 0x0573, 0x0543 /* ARMENIAN CAPITAL LETTER CHEH */
, 0x0544, 0x0574, 0x0544 /* ARMENIAN CAPITAL LETTER MEN */
, 0x0545, 0x0575, 0x0545 /* ARMENIAN CAPITAL LETTER YI */
, 0x0546, 0x0576, 0x0546 /* ARMENIAN CAPITAL LETTER NOW */
, 0x0547, 0x0577, 0x0547 /* ARMENIAN CAPITAL LETTER SHA */
, 0x0548, 0x0578, 0x0548 /* ARMENIAN CAPITAL LETTER VO */
, 0x0549, 0x0579, 0x0549 /* ARMENIAN CAPITAL LETTER CHA */
, 0x054A, 0x057A, 0x054A /* ARMENIAN CAPITAL LETTER PEH */
, 0x054B, 0x057B, 0x054B /* ARMENIAN CAPITAL LETTER JHEH */
, 0x054C, 0x057C, 0x054C /* ARMENIAN CAPITAL LETTER RA */
, 0x054D, 0x057D, 0x054D /* ARMENIAN CAPITAL LETTER SEH */
, 0x054E, 0x057E, 0x054E /* ARMENIAN CAPITAL LETTER VEW */
, 0x054F, 0x057F, 0x054F /* ARMENIAN CAPITAL LETTER TIWN */
, 0x0550, 0x0580, 0x0550 /* ARMENIAN CAPITAL LETTER REH */
, 0x0551, 0x0581, 0x0551 /* ARMENIAN CAPITAL LETTER CO */
, 0x0552, 0x0582, 0x0552 /* ARMENIAN CAPITAL LETTER YIWN */
, 0x0553, 0x0583, 0x0553 /* ARMENIAN CAPITAL LETTER PIWR */
, 0x0554, 0x0584, 0x0554 /* ARMENIAN CAPITAL LETTER KEH */
, 0x0555, 0x0585, 0x0555 /* ARMENIAN CAPITAL LETTER OH */
, 0x0556, 0x0586, 0x0556 /* ARMENIAN CAPITAL LETTER FEH */
, 0x0622, 0x0622, 0x0627 /* ARABIC LETTER ALEF WITH MADDA ABOVE */
, 0x0623, 0x0623, 0x0627 /* ARABIC LETTER ALEF WITH HAMZA ABOVE */
, 0x0624, 0x0624, 0x0648 /* ARABIC LETTER WAW WITH HAMZA ABOVE */
, 0x0625, 0x0625, 0x0627 /* ARABIC LETTER ALEF WITH HAMZA BELOW */
, 0x0626, 0x0626, 0x064A /* ARABIC LETTER YEH WITH HAMZA ABOVE */
, 0x06C0, 0x06C0, 0x06D5 /* ARABIC LETTER HEH WITH YEH ABOVE */
, 0x06C2, 0x06C2, 0x06C1 /* ARABIC LETTER HEH GOAL WITH HAMZA ABOVE */
, 0x06D3, 0x06D3, 0x06D2 /* ARABIC LETTER YEH BARREE WITH HAMZA ABOVE */
, 0x0929, 0x0929, 0x0928 /* DEVANAGARI LETTER NNNA */
, 0x0931, 0x0931, 0x0930 /* DEVANAGARI LETTER RRA */
, 0x0934, 0x0934, 0x0933 /* DEVANAGARI LETTER LLLA */
, 0x0958, 0x0958, 0x0915 /* DEVANAGARI LETTER QA */
, 0x0959, 0x0959, 0x0916 /* DEVANAGARI LETTER KHHA */
, 0x095A, 0x095A, 0x0917 /* DEVANAGARI LETTER GHHA */
, 0x095B, 0x095B, 0x091C /* DEVANAGARI LETTER ZA */
, 0x095C, 0x095C, 0x0921 /* DEVANAGARI LETTER DDDHA */
, 0x095D, 0x095D, 0x0922 /* DEVANAGARI LETTER RHA */
, 0x095E, 0x095E, 0x092B /* DEVANAGARI LETTER FA */
, 0x095F, 0x095F, 0x092F /* DEVANAGARI LETTER YYA */
, 0x09DC, 0x09DC, 0x09A1 /* BENGALI LETTER RRA */
, 0x09DD, 0x09DD, 0x09A2 /* BENGALI LETTER RHA */
, 0x09DF, 0x09DF, 0x09AF /* BENGALI LETTER YYA */
, 0x0A33, 0x0A33, 0x0A32 /* GURMUKHI LETTER LLA */
, 0x0A36, 0x0A36, 0x0A38 /* GURMUKHI LETTER SHA */
, 0x0A59, 0x0A59, 0x0A16 /* GURMUKHI LETTER KHHA */
, 0x0A5A, 0x0A5A, 0x0A17 /* GURMUKHI LETTER GHHA */
, 0x0A5B, 0x0A5B, 0x0A1C /* GURMUKHI LETTER ZA */
, 0x0A5E, 0x0A5E, 0x0A2B /* GURMUKHI LETTER FA */
, 0x0B48, 0x0B48, 0x0B47 /* ORIYA VOWEL SIGN AI */
, 0x0B5C, 0x0B5C, 0x0B21 /* ORIYA LETTER RRA */
, 0x0B5D, 0x0B5D, 0x0B22 /* ORIYA LETTER RHA */
, 0x0CC0, 0x0CC0, 0x0CD5 /* KANNADA VOWEL SIGN II */
, 0x0CC7, 0x0CC7, 0x0CD5 /* KANNADA VOWEL SIGN EE */
, 0x0CC8, 0x0CC8, 0x0CD6 /* KANNADA VOWEL SIGN AI */
, 0x0CCA, 0x0CCA, 0x0CC2 /* KANNADA VOWEL SIGN O */
, 0x0DDA, 0x0DDA, 0x0DD9 /* SINHALA VOWEL SIGN DIGA KOMBUVA */
, 0x0DDD, 0x0DDD, 0x0DDC /* SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA */
, 0x0F43, 0x0F43, 0x0F42 /* TIBETAN LETTER GHA */
, 0x0F4D, 0x0F4D, 0x0F4C /* TIBETAN LETTER DDHA */
, 0x0F52, 0x0F52, 0x0F51 /* TIBETAN LETTER DHA */
, 0x0F57, 0x0F57, 0x0F56 /* TIBETAN LETTER BHA */
, 0x0F5C, 0x0F5C, 0x0F5B /* TIBETAN LETTER DZHA */
, 0x0F69, 0x0F69, 0x0F40 /* TIBETAN LETTER KSSA */
, 0x1026, 0x1026, 0x1025 /* MYANMAR LETTER UU */
, 0x1E00, 0x1E01, 0x0041 /* LATIN CAPITAL LETTER A WITH RING BELOW */
, 0x1E01, 0x1E01, 0x0061 /* LATIN SMALL LETTER A WITH RING BELOW */
, 0x1E02, 0x1E03, 0x0042 /* LATIN CAPITAL LETTER B WITH DOT ABOVE */
, 0x1E03, 0x1E03, 0x0062 /* LATIN SMALL LETTER B WITH DOT ABOVE */
, 0x1E04, 0x1E05, 0x0042 /* LATIN CAPITAL LETTER B WITH DOT BELOW */
, 0x1E05, 0x1E05, 0x0062 /* LATIN SMALL LETTER B WITH DOT BELOW */
, 0x1E06, 0x1E07, 0x0042 /* LATIN CAPITAL LETTER B WITH LINE BELOW */
, 0x1E07, 0x1E07, 0x0062 /* LATIN SMALL LETTER B WITH LINE BELOW */
, 0x1E08, 0x1E09, 0x0043 /* LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE */
, 0x1E09, 0x1E09, 0x0063 /* LATIN SMALL LETTER C WITH CEDILLA AND ACUTE */
, 0x1E0A, 0x1E0B, 0x0044 /* LATIN CAPITAL LETTER D WITH DOT ABOVE */
, 0x1E0B, 0x1E0B, 0x0064 /* LATIN SMALL LETTER D WITH DOT ABOVE */
, 0x1E0C, 0x1E0D, 0x0044 /* LATIN CAPITAL LETTER D WITH DOT BELOW */
, 0x1E0D, 0x1E0D, 0x0064 /* LATIN SMALL LETTER D WITH DOT BELOW */
, 0x1E0E, 0x1E0F, 0x0044 /* LATIN CAPITAL LETTER D WITH LINE BELOW */
, 0x1E0F, 0x1E0F, 0x0064 /* LATIN SMALL LETTER D WITH LINE BELOW */
, 0x1E10, 0x1E11, 0x0044 /* LATIN CAPITAL LETTER D WITH CEDILLA */
, 0x1E11, 0x1E11, 0x0064 /* LATIN SMALL LETTER D WITH CEDILLA */
, 0x1E12, 0x1E13, 0x0044 /* LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW */
, 0x1E13, 0x1E13, 0x0064 /* LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW */
, 0x1E14, 0x1E15, 0x0045 /* LATIN CAPITAL LETTER E WITH MACRON AND GRAVE */
, 0x1E15, 0x1E15, 0x0065 /* LATIN SMALL LETTER E WITH MACRON AND GRAVE */
, 0x1E16, 0x1E17, 0x0045 /* LATIN CAPITAL LETTER E WITH MACRON AND ACUTE */
, 0x1E17, 0x1E17, 0x0065 /* LATIN SMALL LETTER E WITH MACRON AND ACUTE */
, 0x1E18, 0x1E19, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW */
, 0x1E19, 0x1E19, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX BELOW */
, 0x1E1A, 0x1E1B, 0x0045 /* LATIN CAPITAL LETTER E WITH TILDE BELOW */
, 0x1E1B, 0x1E1B, 0x0065 /* LATIN SMALL LETTER E WITH TILDE BELOW */
, 0x1E1C, 0x1E1D, 0x0045 /* LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE */
, 0x1E1D, 0x1E1D, 0x0065 /* LATIN SMALL LETTER E WITH CEDILLA AND BREVE */
, 0x1E1E, 0x1E1F, 0x0046 /* LATIN CAPITAL LETTER F WITH DOT ABOVE */
, 0x1E1F, 0x1E1F, 0x0066 /* LATIN SMALL LETTER F WITH DOT ABOVE */
, 0x1E20, 0x1E21, 0x0047 /* LATIN CAPITAL LETTER G WITH MACRON */
, 0x1E21, 0x1E21, 0x0067 /* LATIN SMALL LETTER G WITH MACRON */
, 0x1E22, 0x1E23, 0x0048 /* LATIN CAPITAL LETTER H WITH DOT ABOVE */
, 0x1E23, 0x1E23, 0x0068 /* LATIN SMALL LETTER H WITH DOT ABOVE */
, 0x1E24, 0x1E25, 0x0048 /* LATIN CAPITAL LETTER H WITH DOT BELOW */
, 0x1E25, 0x1E25, 0x0068 /* LATIN SMALL LETTER H WITH DOT BELOW */
, 0x1E26, 0x1E27, 0x0048 /* LATIN CAPITAL LETTER H WITH DIAERESIS */
, 0x1E27, 0x1E27, 0x0068 /* LATIN SMALL LETTER H WITH DIAERESIS */
, 0x1E28, 0x1E29, 0x0048 /* LATIN CAPITAL LETTER H WITH CEDILLA */
, 0x1E29, 0x1E29, 0x0068 /* LATIN SMALL LETTER H WITH CEDILLA */
, 0x1E2A, 0x1E2B, 0x0048 /* LATIN CAPITAL LETTER H WITH BREVE BELOW */
, 0x1E2B, 0x1E2B, 0x0068 /* LATIN SMALL LETTER H WITH BREVE BELOW */
, 0x1E2C, 0x1E2D, 0x0049 /* LATIN CAPITAL LETTER I WITH TILDE BELOW */
, 0x1E2D, 0x1E2D, 0x0069 /* LATIN SMALL LETTER I WITH TILDE BELOW */
, 0x1E2E, 0x1E2F, 0x0049 /* LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE */
, 0x1E2F, 0x1E2F, 0x0069 /* LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE */
, 0x1E30, 0x1E31, 0x004B /* LATIN CAPITAL LETTER K WITH ACUTE */
, 0x1E31, 0x1E31, 0x006B /* LATIN SMALL LETTER K WITH ACUTE */
, 0x1E32, 0x1E33, 0x004B /* LATIN CAPITAL LETTER K WITH DOT BELOW */
, 0x1E33, 0x1E33, 0x006B /* LATIN SMALL LETTER K WITH DOT BELOW */
, 0x1E34, 0x1E35, 0x004B /* LATIN CAPITAL LETTER K WITH LINE BELOW */
, 0x1E35, 0x1E35, 0x006B /* LATIN SMALL LETTER K WITH LINE BELOW */
, 0x1E36, 0x1E37, 0x004C /* LATIN CAPITAL LETTER L WITH DOT BELOW */
, 0x1E37, 0x1E37, 0x006C /* LATIN SMALL LETTER L WITH DOT BELOW */
, 0x1E38, 0x1E39, 0x004C /* LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON */
, 0x1E39, 0x1E39, 0x006C /* LATIN SMALL LETTER L WITH DOT BELOW AND MACRON */
, 0x1E3A, 0x1E3B, 0x004C /* LATIN CAPITAL LETTER L WITH LINE BELOW */
, 0x1E3B, 0x1E3B, 0x006C /* LATIN SMALL LETTER L WITH LINE BELOW */
, 0x1E3C, 0x1E3D, 0x004C /* LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW */
, 0x1E3D, 0x1E3D, 0x006C /* LATIN SMALL LETTER L WITH CIRCUMFLEX BELOW */
, 0x1E3E, 0x1E3F, 0x004D /* LATIN CAPITAL LETTER M WITH ACUTE */
, 0x1E3F, 0x1E3F, 0x006D /* LATIN SMALL LETTER M WITH ACUTE */
, 0x1E40, 0x1E41, 0x004D /* LATIN CAPITAL LETTER M WITH DOT ABOVE */
, 0x1E41, 0x1E41, 0x006D /* LATIN SMALL LETTER M WITH DOT ABOVE */
, 0x1E42, 0x1E43, 0x004D /* LATIN CAPITAL LETTER M WITH DOT BELOW */
, 0x1E43, 0x1E43, 0x006D /* LATIN SMALL LETTER M WITH DOT BELOW */
, 0x1E44, 0x1E45, 0x004E /* LATIN CAPITAL LETTER N WITH DOT ABOVE */
, 0x1E45, 0x1E45, 0x006E /* LATIN SMALL LETTER N WITH DOT ABOVE */
, 0x1E46, 0x1E47, 0x004E /* LATIN CAPITAL LETTER N WITH DOT BELOW */
, 0x1E47, 0x1E47, 0x006E /* LATIN SMALL LETTER N WITH DOT BELOW */
, 0x1E48, 0x1E49, 0x004E /* LATIN CAPITAL LETTER N WITH LINE BELOW */
, 0x1E49, 0x1E49, 0x006E /* LATIN SMALL LETTER N WITH LINE BELOW */
, 0x1E4A, 0x1E4B, 0x004E /* LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW */
, 0x1E4B, 0x1E4B, 0x006E /* LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW */
, 0x1E4C, 0x1E4D, 0x004F /* LATIN CAPITAL LETTER O WITH TILDE AND ACUTE */
, 0x1E4D, 0x1E4D, 0x006F /* LATIN SMALL LETTER O WITH TILDE AND ACUTE */
, 0x1E4E, 0x1E4F, 0x004F /* LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS */
, 0x1E4F, 0x1E4F, 0x006F /* LATIN SMALL LETTER O WITH TILDE AND DIAERESIS */
, 0x1E50, 0x1E51, 0x004F /* LATIN CAPITAL LETTER O WITH MACRON AND GRAVE */
, 0x1E51, 0x1E51, 0x006F /* LATIN SMALL LETTER O WITH MACRON AND GRAVE */
, 0x1E52, 0x1E53, 0x004F /* LATIN CAPITAL LETTER O WITH MACRON AND ACUTE */
, 0x1E53, 0x1E53, 0x006F /* LATIN SMALL LETTER O WITH MACRON AND ACUTE */
, 0x1E54, 0x1E55, 0x0050 /* LATIN CAPITAL LETTER P WITH ACUTE */
, 0x1E55, 0x1E55, 0x0070 /* LATIN SMALL LETTER P WITH ACUTE */
, 0x1E56, 0x1E57, 0x0050 /* LATIN CAPITAL LETTER P WITH DOT ABOVE */
, 0x1E57, 0x1E57, 0x0070 /* LATIN SMALL LETTER P WITH DOT ABOVE */
, 0x1E58, 0x1E59, 0x0052 /* LATIN CAPITAL LETTER R WITH DOT ABOVE */
, 0x1E59, 0x1E59, 0x0072 /* LATIN SMALL LETTER R WITH DOT ABOVE */
, 0x1E5A, 0x1E5B, 0x0052 /* LATIN CAPITAL LETTER R WITH DOT BELOW */
, 0x1E5B, 0x1E5B, 0x0072 /* LATIN SMALL LETTER R WITH DOT BELOW */
, 0x1E5C, 0x1E5D, 0x0052 /* LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON */
, 0x1E5D, 0x1E5D, 0x0072 /* LATIN SMALL LETTER R WITH DOT BELOW AND MACRON */
, 0x1E5E, 0x1E5F, 0x0052 /* LATIN CAPITAL LETTER R WITH LINE BELOW */
, 0x1E5F, 0x1E5F, 0x0072 /* LATIN SMALL LETTER R WITH LINE BELOW */
, 0x1E60, 0x1E61, 0x0053 /* LATIN CAPITAL LETTER S WITH DOT ABOVE */
, 0x1E61, 0x1E61, 0x0073 /* LATIN SMALL LETTER S WITH DOT ABOVE */
, 0x1E62, 0x1E63, 0x0053 /* LATIN CAPITAL LETTER S WITH DOT BELOW */
, 0x1E63, 0x1E63, 0x0073 /* LATIN SMALL LETTER S WITH DOT BELOW */
, 0x1E64, 0x1E65, 0x0053 /* LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE */
, 0x1E65, 0x1E65, 0x0073 /* LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE */
, 0x1E66, 0x1E67, 0x0053 /* LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE */
, 0x1E67, 0x1E67, 0x0073 /* LATIN SMALL LETTER S WITH CARON AND DOT ABOVE */
, 0x1E68, 0x1E69, 0x0053 /* LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE */
, 0x1E69, 0x1E69, 0x0073 /* LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE */
, 0x1E6A, 0x1E6B, 0x0054 /* LATIN CAPITAL LETTER T WITH DOT ABOVE */
, 0x1E6B, 0x1E6B, 0x0074 /* LATIN SMALL LETTER T WITH DOT ABOVE */
, 0x1E6C, 0x1E6D, 0x0054 /* LATIN CAPITAL LETTER T WITH DOT BELOW */
, 0x1E6D, 0x1E6D, 0x0074 /* LATIN SMALL LETTER T WITH DOT BELOW */
, 0x1E6E, 0x1E6F, 0x0054 /* LATIN CAPITAL LETTER T WITH LINE BELOW */
, 0x1E6F, 0x1E6F, 0x0074 /* LATIN SMALL LETTER T WITH LINE BELOW */
, 0x1E70, 0x1E71, 0x0054 /* LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW */
, 0x1E71, 0x1E71, 0x0074 /* LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW */
, 0x1E72, 0x1E73, 0x0055 /* LATIN CAPITAL LETTER U WITH DIAERESIS BELOW */
, 0x1E73, 0x1E73, 0x0075 /* LATIN SMALL LETTER U WITH DIAERESIS BELOW */
, 0x1E74, 0x1E75, 0x0055 /* LATIN CAPITAL LETTER U WITH TILDE BELOW */
, 0x1E75, 0x1E75, 0x0075 /* LATIN SMALL LETTER U WITH TILDE BELOW */
, 0x1E76, 0x1E77, 0x0055 /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW */
, 0x1E77, 0x1E77, 0x0075 /* LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW */
, 0x1E78, 0x1E79, 0x0055 /* LATIN CAPITAL LETTER U WITH TILDE AND ACUTE */
, 0x1E79, 0x1E79, 0x0075 /* LATIN SMALL LETTER U WITH TILDE AND ACUTE */
, 0x1E7A, 0x1E7B, 0x0055 /* LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS */
, 0x1E7B, 0x1E7B, 0x0075 /* LATIN SMALL LETTER U WITH MACRON AND DIAERESIS */
, 0x1E7C, 0x1E7D, 0x0056 /* LATIN CAPITAL LETTER V WITH TILDE */
, 0x1E7D, 0x1E7D, 0x0076 /* LATIN SMALL LETTER V WITH TILDE */
, 0x1E7E, 0x1E7F, 0x0056 /* LATIN CAPITAL LETTER V WITH DOT BELOW */
, 0x1E7F, 0x1E7F, 0x0076 /* LATIN SMALL LETTER V WITH DOT BELOW */
, 0x1E80, 0x1E81, 0x0057 /* LATIN CAPITAL LETTER W WITH GRAVE */
, 0x1E81, 0x1E81, 0x0077 /* LATIN SMALL LETTER W WITH GRAVE */
, 0x1E82, 0x1E83, 0x0057 /* LATIN CAPITAL LETTER W WITH ACUTE */
, 0x1E83, 0x1E83, 0x0077 /* LATIN SMALL LETTER W WITH ACUTE */
, 0x1E84, 0x1E85, 0x0057 /* LATIN CAPITAL LETTER W WITH DIAERESIS */
, 0x1E85, 0x1E85, 0x0077 /* LATIN SMALL LETTER W WITH DIAERESIS */
, 0x1E86, 0x1E87, 0x0057 /* LATIN CAPITAL LETTER W WITH DOT ABOVE */
, 0x1E87, 0x1E87, 0x0077 /* LATIN SMALL LETTER W WITH DOT ABOVE */
, 0x1E88, 0x1E89, 0x0057 /* LATIN CAPITAL LETTER W WITH DOT BELOW */
, 0x1E89, 0x1E89, 0x0077 /* LATIN SMALL LETTER W WITH DOT BELOW */
, 0x1E8A, 0x1E8B, 0x0058 /* LATIN CAPITAL LETTER X WITH DOT ABOVE */
, 0x1E8B, 0x1E8B, 0x0078 /* LATIN SMALL LETTER X WITH DOT ABOVE */
, 0x1E8C, 0x1E8D, 0x0058 /* LATIN CAPITAL LETTER X WITH DIAERESIS */
, 0x1E8D, 0x1E8D, 0x0078 /* LATIN SMALL LETTER X WITH DIAERESIS */
, 0x1E8E, 0x1E8F, 0x0059 /* LATIN CAPITAL LETTER Y WITH DOT ABOVE */
, 0x1E8F, 0x1E8F, 0x0079 /* LATIN SMALL LETTER Y WITH DOT ABOVE */
, 0x1E90, 0x1E91, 0x005A /* LATIN CAPITAL LETTER Z WITH CIRCUMFLEX */
, 0x1E91, 0x1E91, 0x007A /* LATIN SMALL LETTER Z WITH CIRCUMFLEX */
, 0x1E92, 0x1E93, 0x005A /* LATIN CAPITAL LETTER Z WITH DOT BELOW */
, 0x1E93, 0x1E93, 0x007A /* LATIN SMALL LETTER Z WITH DOT BELOW */
, 0x1E94, 0x1E95, 0x005A /* LATIN CAPITAL LETTER Z WITH LINE BELOW */
, 0x1E95, 0x1E95, 0x007A /* LATIN SMALL LETTER Z WITH LINE BELOW */
, 0x1E96, 0x1E96, 0x0068 /* LATIN SMALL LETTER H WITH LINE BELOW */
, 0x1E97, 0x1E97, 0x0074 /* LATIN SMALL LETTER T WITH DIAERESIS */
, 0x1E98, 0x1E98, 0x0077 /* LATIN SMALL LETTER W WITH RING ABOVE */
, 0x1E99, 0x1E99, 0x0079 /* LATIN SMALL LETTER Y WITH RING ABOVE */
, 0x1E9B, 0x1E9B, 0x017F /* LATIN SMALL LETTER LONG S WITH DOT ABOVE */
, 0x1EA0, 0x1EA1, 0x0041 /* LATIN CAPITAL LETTER A WITH DOT BELOW */
, 0x1EA1, 0x1EA1, 0x0061 /* LATIN SMALL LETTER A WITH DOT BELOW */
, 0x1EA2, 0x1EA3, 0x0041 /* LATIN CAPITAL LETTER A WITH HOOK ABOVE */
, 0x1EA3, 0x1EA3, 0x0061 /* LATIN SMALL LETTER A WITH HOOK ABOVE */
, 0x1EA4, 0x1EA5, 0x0041 /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE */
, 0x1EA5, 0x1EA5, 0x0061 /* LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE */
, 0x1EA6, 0x1EA7, 0x0041 /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE */
, 0x1EA7, 0x1EA7, 0x0061 /* LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE */
, 0x1EA8, 0x1EA9, 0x0041 /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */
, 0x1EA9, 0x1EA9, 0x0061 /* LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */
, 0x1EAA, 0x1EAB, 0x0041 /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE */
, 0x1EAB, 0x1EAB, 0x0061 /* LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE */
, 0x1EAC, 0x1EAD, 0x0041 /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW */
, 0x1EAD, 0x1EAD, 0x0061 /* LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW */
, 0x1EAE, 0x1EAF, 0x0041 /* LATIN CAPITAL LETTER A WITH BREVE AND ACUTE */
, 0x1EAF, 0x1EAF, 0x0061 /* LATIN SMALL LETTER A WITH BREVE AND ACUTE */
, 0x1EB0, 0x1EB1, 0x0041 /* LATIN CAPITAL LETTER A WITH BREVE AND GRAVE */
, 0x1EB1, 0x1EB1, 0x0061 /* LATIN SMALL LETTER A WITH BREVE AND GRAVE */
, 0x1EB2, 0x1EB3, 0x0041 /* LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE */
, 0x1EB3, 0x1EB3, 0x0061 /* LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE */
, 0x1EB4, 0x1EB5, 0x0041 /* LATIN CAPITAL LETTER A WITH BREVE AND TILDE */
, 0x1EB5, 0x1EB5, 0x0061 /* LATIN SMALL LETTER A WITH BREVE AND TILDE */
, 0x1EB6, 0x1EB7, 0x0041 /* LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW */
, 0x1EB7, 0x1EB7, 0x0061 /* LATIN SMALL LETTER A WITH BREVE AND DOT BELOW */
, 0x1EB8, 0x1EB9, 0x0045 /* LATIN CAPITAL LETTER E WITH DOT BELOW */
, 0x1EB9, 0x1EB9, 0x0065 /* LATIN SMALL LETTER E WITH DOT BELOW */
, 0x1EBA, 0x1EBB, 0x0045 /* LATIN CAPITAL LETTER E WITH HOOK ABOVE */
, 0x1EBB, 0x1EBB, 0x0065 /* LATIN SMALL LETTER E WITH HOOK ABOVE */
, 0x1EBC, 0x1EBD, 0x0045 /* LATIN CAPITAL LETTER E WITH TILDE */
, 0x1EBD, 0x1EBD, 0x0065 /* LATIN SMALL LETTER E WITH TILDE */
, 0x1EBE, 0x1EBF, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE */
, 0x1EBF, 0x1EBF, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE */
, 0x1EC0, 0x1EC1, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE */
, 0x1EC1, 0x1EC1, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE */
, 0x1EC2, 0x1EC3, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */
, 0x1EC3, 0x1EC3, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */
, 0x1EC4, 0x1EC5, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE */
, 0x1EC5, 0x1EC5, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE */
, 0x1EC6, 0x1EC7, 0x0045 /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW */
, 0x1EC7, 0x1EC7, 0x0065 /* LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW */
, 0x1EC8, 0x1EC9, 0x0049 /* LATIN CAPITAL LETTER I WITH HOOK ABOVE */
, 0x1EC9, 0x1EC9, 0x0069 /* LATIN SMALL LETTER I WITH HOOK ABOVE */
, 0x1ECA, 0x1ECB, 0x0049 /* LATIN CAPITAL LETTER I WITH DOT BELOW */
, 0x1ECB, 0x1ECB, 0x0069 /* LATIN SMALL LETTER I WITH DOT BELOW */
, 0x1ECC, 0x1ECD, 0x004F /* LATIN CAPITAL LETTER O WITH DOT BELOW */
, 0x1ECD, 0x1ECD, 0x006F /* LATIN SMALL LETTER O WITH DOT BELOW */
, 0x1ECE, 0x1ECF, 0x004F /* LATIN CAPITAL LETTER O WITH HOOK ABOVE */
, 0x1ECF, 0x1ECF, 0x006F /* LATIN SMALL LETTER O WITH HOOK ABOVE */
, 0x1ED0, 0x1ED1, 0x004F /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE */
, 0x1ED1, 0x1ED1, 0x006F /* LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE */
, 0x1ED2, 0x1ED3, 0x004F /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE */
, 0x1ED3, 0x1ED3, 0x006F /* LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE */
, 0x1ED4, 0x1ED5, 0x004F /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */
, 0x1ED5, 0x1ED5, 0x006F /* LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */
, 0x1ED6, 0x1ED7, 0x004F /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE */
, 0x1ED7, 0x1ED7, 0x006F /* LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE */
, 0x1ED8, 0x1ED9, 0x004F /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW */
, 0x1ED9, 0x1ED9, 0x006F /* LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW */
, 0x1EDA, 0x1EDB, 0x004F /* LATIN CAPITAL LETTER O WITH HORN AND ACUTE */
, 0x1EDB, 0x1EDB, 0x006F /* LATIN SMALL LETTER O WITH HORN AND ACUTE */
, 0x1EDC, 0x1EDD, 0x004F /* LATIN CAPITAL LETTER O WITH HORN AND GRAVE */
, 0x1EDD, 0x1EDD, 0x006F /* LATIN SMALL LETTER O WITH HORN AND GRAVE */
, 0x1EDE, 0x1EDF, 0x004F /* LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE */
, 0x1EDF, 0x1EDF, 0x006F /* LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE */
, 0x1EE0, 0x1EE1, 0x004F /* LATIN CAPITAL LETTER O WITH HORN AND TILDE */
, 0x1EE1, 0x1EE1, 0x006F /* LATIN SMALL LETTER O WITH HORN AND TILDE */
, 0x1EE2, 0x1EE3, 0x004F /* LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW */
, 0x1EE3, 0x1EE3, 0x006F /* LATIN SMALL LETTER O WITH HORN AND DOT BELOW */
, 0x1EE4, 0x1EE5, 0x0055 /* LATIN CAPITAL LETTER U WITH DOT BELOW */
, 0x1EE5, 0x1EE5, 0x0075 /* LATIN SMALL LETTER U WITH DOT BELOW */
, 0x1EE6, 0x1EE7, 0x0055 /* LATIN CAPITAL LETTER U WITH HOOK ABOVE */
, 0x1EE7, 0x1EE7, 0x0075 /* LATIN SMALL LETTER U WITH HOOK ABOVE */
, 0x1EE8, 0x1EE9, 0x0055 /* LATIN CAPITAL LETTER U WITH HORN AND ACUTE */
, 0x1EE9, 0x1EE9, 0x0075 /* LATIN SMALL LETTER U WITH HORN AND ACUTE */
, 0x1EEA, 0x1EEB, 0x0055 /* LATIN CAPITAL LETTER U WITH HORN AND GRAVE */
, 0x1EEB, 0x1EEB, 0x0075 /* LATIN SMALL LETTER U WITH HORN AND GRAVE */
, 0x1EEC, 0x1EED, 0x0055 /* LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE */
, 0x1EED, 0x1EED, 0x0075 /* LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE */
, 0x1EEE, 0x1EEF, 0x0055 /* LATIN CAPITAL LETTER U WITH HORN AND TILDE */
, 0x1EEF, 0x1EEF, 0x0075 /* LATIN SMALL LETTER U WITH HORN AND TILDE */
, 0x1EF0, 0x1EF1, 0x0055 /* LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW */
, 0x1EF1, 0x1EF1, 0x0075 /* LATIN SMALL LETTER U WITH HORN AND DOT BELOW */
, 0x1EF2, 0x1EF3, 0x0059 /* LATIN CAPITAL LETTER Y WITH GRAVE */
, 0x1EF3, 0x1EF3, 0x0079 /* LATIN SMALL LETTER Y WITH GRAVE */
, 0x1EF4, 0x1EF5, 0x0059 /* LATIN CAPITAL LETTER Y WITH DOT BELOW */
, 0x1EF5, 0x1EF5, 0x0079 /* LATIN SMALL LETTER Y WITH DOT BELOW */
, 0x1EF6, 0x1EF7, 0x0059 /* LATIN CAPITAL LETTER Y WITH HOOK ABOVE */
, 0x1EF7, 0x1EF7, 0x0079 /* LATIN SMALL LETTER Y WITH HOOK ABOVE */
, 0x1EF8, 0x1EF9, 0x0059 /* LATIN CAPITAL LETTER Y WITH TILDE */
, 0x1EF9, 0x1EF9, 0x0079 /* LATIN SMALL LETTER Y WITH TILDE */
, 0x1F00, 0x1F00, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI */
, 0x1F01, 0x1F01, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA */
, 0x1F02, 0x1F02, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA */
, 0x1F03, 0x1F03, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA */
, 0x1F04, 0x1F04, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA */
, 0x1F05, 0x1F05, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA */
, 0x1F06, 0x1F06, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI */
, 0x1F07, 0x1F07, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI */
, 0x1F08, 0x1F00, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI */
, 0x1F09, 0x1F01, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA */
, 0x1F0A, 0x1F02, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA */
, 0x1F0B, 0x1F03, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA */
, 0x1F0C, 0x1F04, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA */
, 0x1F0D, 0x1F05, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA */
, 0x1F0E, 0x1F06, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI */
, 0x1F0F, 0x1F07, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI */
, 0x1F10, 0x1F10, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH PSILI */
, 0x1F11, 0x1F11, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH DASIA */
, 0x1F12, 0x1F12, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA */
, 0x1F13, 0x1F13, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA */
, 0x1F14, 0x1F14, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA */
, 0x1F15, 0x1F15, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA */
, 0x1F18, 0x1F10, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH PSILI */
, 0x1F19, 0x1F11, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH DASIA */
, 0x1F1A, 0x1F12, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA */
, 0x1F1B, 0x1F13, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA */
, 0x1F1C, 0x1F14, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA */
, 0x1F1D, 0x1F15, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA */
, 0x1F20, 0x1F20, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI */
, 0x1F21, 0x1F21, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA */
, 0x1F22, 0x1F22, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND VARIA */
, 0x1F23, 0x1F23, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND VARIA */
, 0x1F24, 0x1F24, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND OXIA */
, 0x1F25, 0x1F25, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND OXIA */
, 0x1F26, 0x1F26, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI */
, 0x1F27, 0x1F27, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI */
, 0x1F28, 0x1F20, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI */
, 0x1F29, 0x1F21, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA */
, 0x1F2A, 0x1F22, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA */
, 0x1F2B, 0x1F23, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA */
, 0x1F2C, 0x1F24, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA */
, 0x1F2D, 0x1F25, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA */
, 0x1F2E, 0x1F26, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI */
, 0x1F2F, 0x1F27, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI */
, 0x1F30, 0x1F30, 0x03B9 /* GREEK SMALL LETTER IOTA WITH PSILI */
, 0x1F31, 0x1F31, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DASIA */
, 0x1F32, 0x1F32, 0x03B9 /* GREEK SMALL LETTER IOTA WITH PSILI AND VARIA */
, 0x1F33, 0x1F33, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DASIA AND VARIA */
, 0x1F34, 0x1F34, 0x03B9 /* GREEK SMALL LETTER IOTA WITH PSILI AND OXIA */
, 0x1F35, 0x1F35, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DASIA AND OXIA */
, 0x1F36, 0x1F36, 0x03B9 /* GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI */
, 0x1F37, 0x1F37, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI */
, 0x1F38, 0x1F30, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH PSILI */
, 0x1F39, 0x1F31, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH DASIA */
, 0x1F3A, 0x1F32, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA */
, 0x1F3B, 0x1F33, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA */
, 0x1F3C, 0x1F34, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA */
, 0x1F3D, 0x1F35, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA */
, 0x1F3E, 0x1F36, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI */
, 0x1F3F, 0x1F37, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI */
, 0x1F40, 0x1F40, 0x03BF /* GREEK SMALL LETTER OMICRON WITH PSILI */
, 0x1F41, 0x1F41, 0x03BF /* GREEK SMALL LETTER OMICRON WITH DASIA */
, 0x1F42, 0x1F42, 0x03BF /* GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA */
, 0x1F43, 0x1F43, 0x03BF /* GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA */
, 0x1F44, 0x1F44, 0x03BF /* GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA */
, 0x1F45, 0x1F45, 0x03BF /* GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA */
, 0x1F48, 0x1F40, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH PSILI */
, 0x1F49, 0x1F41, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH DASIA */
, 0x1F4A, 0x1F42, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA */
, 0x1F4B, 0x1F43, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA */
, 0x1F4C, 0x1F44, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA */
, 0x1F4D, 0x1F45, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA */
, 0x1F50, 0x1F50, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH PSILI */
, 0x1F51, 0x1F51, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DASIA */
, 0x1F52, 0x1F52, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA */
, 0x1F53, 0x1F53, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA */
, 0x1F54, 0x1F54, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA */
, 0x1F55, 0x1F55, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA */
, 0x1F56, 0x1F56, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI */
, 0x1F57, 0x1F57, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI */
, 0x1F59, 0x1F51, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH DASIA */
, 0x1F5B, 0x1F53, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA */
, 0x1F5D, 0x1F55, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA */
, 0x1F5F, 0x1F57, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI */
, 0x1F60, 0x1F60, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI */
, 0x1F61, 0x1F61, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA */
, 0x1F62, 0x1F62, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA */
, 0x1F63, 0x1F63, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA */
, 0x1F64, 0x1F64, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA */
, 0x1F65, 0x1F65, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA */
, 0x1F66, 0x1F66, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI */
, 0x1F67, 0x1F67, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI */
, 0x1F68, 0x1F60, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI */
, 0x1F69, 0x1F61, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA */
, 0x1F6A, 0x1F62, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA */
, 0x1F6B, 0x1F63, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA */
, 0x1F6C, 0x1F64, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA */
, 0x1F6D, 0x1F65, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA */
, 0x1F6E, 0x1F66, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI */
, 0x1F6F, 0x1F67, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI */
, 0x1F70, 0x1F70, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH VARIA */
, 0x1F71, 0x1F71, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH OXIA */
, 0x1F72, 0x1F72, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH VARIA */
, 0x1F73, 0x1F73, 0x03B5 /* GREEK SMALL LETTER EPSILON WITH OXIA */
, 0x1F74, 0x1F74, 0x03B7 /* GREEK SMALL LETTER ETA WITH VARIA */
, 0x1F75, 0x1F75, 0x03B7 /* GREEK SMALL LETTER ETA WITH OXIA */
, 0x1F76, 0x1F76, 0x03B9 /* GREEK SMALL LETTER IOTA WITH VARIA */
, 0x1F77, 0x1F77, 0x03B9 /* GREEK SMALL LETTER IOTA WITH OXIA */
, 0x1F78, 0x1F78, 0x03BF /* GREEK SMALL LETTER OMICRON WITH VARIA */
, 0x1F79, 0x1F79, 0x03BF /* GREEK SMALL LETTER OMICRON WITH OXIA */
, 0x1F7A, 0x1F7A, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH VARIA */
, 0x1F7B, 0x1F7B, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH OXIA */
, 0x1F7C, 0x1F7C, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH VARIA */
, 0x1F7D, 0x1F7D, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH OXIA */
, 0x1F80, 0x1F80, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI */
, 0x1F81, 0x1F81, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI */
, 0x1F82, 0x1F82, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI */
, 0x1F83, 0x1F83, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI */
, 0x1F84, 0x1F84, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI */
, 0x1F85, 0x1F85, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI */
, 0x1F86, 0x1F86, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI */
, 0x1F87, 0x1F87, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI */
, 0x1F88, 0x1F80, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI */
, 0x1F89, 0x1F81, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI */
, 0x1F8A, 0x1F82, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI */
, 0x1F8B, 0x1F83, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI */
, 0x1F8C, 0x1F84, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI */
, 0x1F8D, 0x1F85, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI */
, 0x1F8E, 0x1F86, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI */
, 0x1F8F, 0x1F87, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI */
, 0x1F90, 0x1F90, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI */
, 0x1F91, 0x1F91, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI */
, 0x1F92, 0x1F92, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI */
, 0x1F93, 0x1F93, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI */
, 0x1F94, 0x1F94, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI */
, 0x1F95, 0x1F95, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI */
, 0x1F96, 0x1F96, 0x03B7 /* GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI */
, 0x1F97, 0x1F97, 0x03B7 /* GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI */
, 0x1F98, 0x1F90, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI */
, 0x1F99, 0x1F91, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI */
, 0x1F9A, 0x1F92, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI */
, 0x1F9B, 0x1F93, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI */
, 0x1F9C, 0x1F94, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI */
, 0x1F9D, 0x1F95, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI */
, 0x1F9E, 0x1F96, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI */
, 0x1F9F, 0x1F97, 0x0397 /* GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI */
, 0x1FA0, 0x1FA0, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI */
, 0x1FA1, 0x1FA1, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI */
, 0x1FA2, 0x1FA2, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI */
, 0x1FA3, 0x1FA3, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI */
, 0x1FA4, 0x1FA4, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI */
, 0x1FA5, 0x1FA5, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI */
, 0x1FA6, 0x1FA6, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI */
, 0x1FA7, 0x1FA7, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI */
, 0x1FA8, 0x1FA0, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI */
, 0x1FA9, 0x1FA1, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI */
, 0x1FAA, 0x1FA2, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI */
, 0x1FAB, 0x1FA3, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI */
, 0x1FAC, 0x1FA4, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI */
, 0x1FAD, 0x1FA5, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI */
, 0x1FAE, 0x1FA6, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI */
, 0x1FAF, 0x1FA7, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI */
, 0x1FB0, 0x1FB0, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH VRACHY */
, 0x1FB1, 0x1FB1, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH MACRON */
, 0x1FB2, 0x1FB2, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI */
, 0x1FB3, 0x1FB3, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI */
, 0x1FB4, 0x1FB4, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI */
, 0x1FB6, 0x1FB6, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PERISPOMENI */
, 0x1FB7, 0x1FB7, 0x03B1 /* GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI */
, 0x1FB8, 0x1FB0, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH VRACHY */
, 0x1FB9, 0x1FB1, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH MACRON */
, 0x1FBA, 0x1F70, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH VARIA */
, 0x1FBB, 0x1F71, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH OXIA */
, 0x1FBC, 0x1FB3, 0x0391 /* GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI */
, 0x1FBE, 0x1FBE, 0x03B9 /* GREEK PROSGEGRAMMENI */
, 0x1FC1, 0x1FC1, 0x00A8 /* GREEK DIALYTIKA AND PERISPOMENI */
, 0x1FC2, 0x1FC2, 0x03B7 /* GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI */
, 0x1FC3, 0x1FC3, 0x03B7 /* GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI */
, 0x1FC4, 0x1FC4, 0x03B7 /* GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI */
, 0x1FC6, 0x1FC6, 0x03B7 /* GREEK SMALL LETTER ETA WITH PERISPOMENI */
, 0x1FC7, 0x1FC7, 0x03B7 /* GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI */
, 0x1FC8, 0x1F72, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH VARIA */
, 0x1FC9, 0x1F73, 0x0395 /* GREEK CAPITAL LETTER EPSILON WITH OXIA */
, 0x1FCA, 0x1F74, 0x0397 /* GREEK CAPITAL LETTER ETA WITH VARIA */
, 0x1FCB, 0x1F75, 0x0397 /* GREEK CAPITAL LETTER ETA WITH OXIA */
, 0x1FCC, 0x1FC3, 0x0397 /* GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI */
, 0x1FCD, 0x1FCD, 0x1FBF /* GREEK PSILI AND VARIA */
, 0x1FCE, 0x1FCE, 0x1FBF /* GREEK PSILI AND OXIA */
, 0x1FCF, 0x1FCF, 0x1FBF /* GREEK PSILI AND PERISPOMENI */
, 0x1FD0, 0x1FD0, 0x03B9 /* GREEK SMALL LETTER IOTA WITH VRACHY */
, 0x1FD1, 0x1FD1, 0x03B9 /* GREEK SMALL LETTER IOTA WITH MACRON */
, 0x1FD2, 0x1FD2, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA */
, 0x1FD3, 0x1FD3, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA */
, 0x1FD6, 0x1FD6, 0x03B9 /* GREEK SMALL LETTER IOTA WITH PERISPOMENI */
, 0x1FD7, 0x1FD7, 0x03B9 /* GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI */
, 0x1FD8, 0x1FD0, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH VRACHY */
, 0x1FD9, 0x1FD1, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH MACRON */
, 0x1FDA, 0x1F76, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH VARIA */
, 0x1FDB, 0x1F77, 0x0399 /* GREEK CAPITAL LETTER IOTA WITH OXIA */
, 0x1FDD, 0x1FDD, 0x1FFE /* GREEK DASIA AND VARIA */
, 0x1FDE, 0x1FDE, 0x1FFE /* GREEK DASIA AND OXIA */
, 0x1FDF, 0x1FDF, 0x1FFE /* GREEK DASIA AND PERISPOMENI */
, 0x1FE0, 0x1FE0, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH VRACHY */
, 0x1FE1, 0x1FE1, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH MACRON */
, 0x1FE2, 0x1FE2, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA */
, 0x1FE3, 0x1FE3, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA */
, 0x1FE4, 0x1FE4, 0x03C1 /* GREEK SMALL LETTER RHO WITH PSILI */
, 0x1FE5, 0x1FE5, 0x03C1 /* GREEK SMALL LETTER RHO WITH DASIA */
, 0x1FE6, 0x1FE6, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH PERISPOMENI */
, 0x1FE7, 0x1FE7, 0x03C5 /* GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI */
, 0x1FE8, 0x1FE0, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH VRACHY */
, 0x1FE9, 0x1FE1, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH MACRON */
, 0x1FEA, 0x1F7A, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH VARIA */
, 0x1FEB, 0x1F7B, 0x03A5 /* GREEK CAPITAL LETTER UPSILON WITH OXIA */
, 0x1FEC, 0x1FE5, 0x03A1 /* GREEK CAPITAL LETTER RHO WITH DASIA */
, 0x1FED, 0x1FED, 0x00A8 /* GREEK DIALYTIKA AND VARIA */
, 0x1FEE, 0x1FEE, 0x00A8 /* GREEK DIALYTIKA AND OXIA */
, 0x1FEF, 0x1FEF, 0x0060 /* GREEK VARIA */
, 0x1FF2, 0x1FF2, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI */
, 0x1FF3, 0x1FF3, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI */
, 0x1FF4, 0x1FF4, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI */
, 0x1FF6, 0x1FF6, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PERISPOMENI */
, 0x1FF7, 0x1FF7, 0x03C9 /* GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI */
, 0x1FF8, 0x1F78, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH VARIA */
, 0x1FF9, 0x1F79, 0x039F /* GREEK CAPITAL LETTER OMICRON WITH OXIA */
, 0x1FFA, 0x1F7C, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH VARIA */
, 0x1FFB, 0x1F7D, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH OXIA */
, 0x1FFC, 0x1FF3, 0x03A9 /* GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI */
, 0x1FFD, 0x1FFD, 0x00B4 /* GREEK OXIA */
, 0x2000, 0x2000, 0x2002 /* EN QUAD */
, 0x2001, 0x2001, 0x2003 /* EM QUAD */
, 0x2126, 0x03C9, 0x03A9 /* OHM SIGN */
, 0x212A, 0x006B, 0x004B /* KELVIN SIGN */
, 0x212B, 0x00E5, 0x0041 /* ANGSTROM SIGN */
, 0x2160, 0x2170, 0x2160 /* ROMAN NUMERAL ONE */
, 0x2161, 0x2171, 0x2161 /* ROMAN NUMERAL TWO */
, 0x2162, 0x2172, 0x2162 /* ROMAN NUMERAL THREE */
, 0x2163, 0x2173, 0x2163 /* ROMAN NUMERAL FOUR */
, 0x2164, 0x2174, 0x2164 /* ROMAN NUMERAL FIVE */
, 0x2165, 0x2175, 0x2165 /* ROMAN NUMERAL SIX */
, 0x2166, 0x2176, 0x2166 /* ROMAN NUMERAL SEVEN */
, 0x2167, 0x2177, 0x2167 /* ROMAN NUMERAL EIGHT */
, 0x2168, 0x2178, 0x2168 /* ROMAN NUMERAL NINE */
, 0x2169, 0x2179, 0x2169 /* ROMAN NUMERAL TEN */
, 0x216A, 0x217A, 0x216A /* ROMAN NUMERAL ELEVEN */
, 0x216B, 0x217B, 0x216B /* ROMAN NUMERAL TWELVE */
, 0x216C, 0x217C, 0x216C /* ROMAN NUMERAL FIFTY */
, 0x216D, 0x217D, 0x216D /* ROMAN NUMERAL ONE HUNDRED */
, 0x216E, 0x217E, 0x216E /* ROMAN NUMERAL FIVE HUNDRED */
, 0x216F, 0x217F, 0x216F /* ROMAN NUMERAL ONE THOUSAND */
, 0x219A, 0x219A, 0x2190 /* LEFTWARDS ARROW WITH STROKE */
, 0x219B, 0x219B, 0x2192 /* RIGHTWARDS ARROW WITH STROKE */
, 0x21AE, 0x21AE, 0x2194 /* LEFT RIGHT ARROW WITH STROKE */
, 0x21CD, 0x21CD, 0x21D0 /* LEFTWARDS DOUBLE ARROW WITH STROKE */
, 0x21CE, 0x21CE, 0x21D4 /* LEFT RIGHT DOUBLE ARROW WITH STROKE */
, 0x21CF, 0x21CF, 0x21D2 /* RIGHTWARDS DOUBLE ARROW WITH STROKE */
, 0x2204, 0x2204, 0x2203 /* THERE DOES NOT EXIST */
, 0x2209, 0x2209, 0x2208 /* NOT AN ELEMENT OF */
, 0x220C, 0x220C, 0x220B /* DOES NOT CONTAIN AS MEMBER */
, 0x2224, 0x2224, 0x2223 /* DOES NOT DIVIDE */
, 0x2226, 0x2226, 0x2225 /* NOT PARALLEL TO */
, 0x2241, 0x2241, 0x223C /* NOT TILDE */
, 0x2244, 0x2244, 0x2243 /* NOT ASYMPTOTICALLY EQUAL TO */
, 0x2247, 0x2247, 0x2245 /* NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO */
, 0x2249, 0x2249, 0x2248 /* NOT ALMOST EQUAL TO */
, 0x2260, 0x2260, 0x003D /* NOT EQUAL TO */
, 0x2262, 0x2262, 0x2261 /* NOT IDENTICAL TO */
, 0x226D, 0x226D, 0x224D /* NOT EQUIVALENT TO */
, 0x226E, 0x226E, 0x003C /* NOT LESS-THAN */
, 0x226F, 0x226F, 0x003E /* NOT GREATER-THAN */
, 0x2270, 0x2270, 0x2264 /* NEITHER LESS-THAN NOR EQUAL TO */
, 0x2271, 0x2271, 0x2265 /* NEITHER GREATER-THAN NOR EQUAL TO */
, 0x2274, 0x2274, 0x2272 /* NEITHER LESS-THAN NOR EQUIVALENT TO */
, 0x2275, 0x2275, 0x2273 /* NEITHER GREATER-THAN NOR EQUIVALENT TO */
, 0x2278, 0x2278, 0x2276 /* NEITHER LESS-THAN NOR GREATER-THAN */
, 0x2279, 0x2279, 0x2277 /* NEITHER GREATER-THAN NOR LESS-THAN */
, 0x2280, 0x2280, 0x227A /* DOES NOT PRECEDE */
, 0x2281, 0x2281, 0x227B /* DOES NOT SUCCEED */
, 0x2284, 0x2284, 0x2282 /* NOT A SUBSET OF */
, 0x2285, 0x2285, 0x2283 /* NOT A SUPERSET OF */
, 0x2288, 0x2288, 0x2286 /* NEITHER A SUBSET OF NOR EQUAL TO */
, 0x2289, 0x2289, 0x2287 /* NEITHER A SUPERSET OF NOR EQUAL TO */
, 0x22AC, 0x22AC, 0x22A2 /* DOES NOT PROVE */
, 0x22AD, 0x22AD, 0x22A8 /* NOT TRUE */
, 0x22AE, 0x22AE, 0x22A9 /* DOES NOT FORCE */
, 0x22AF, 0x22AF, 0x22AB /* NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE */
, 0x22E0, 0x22E0, 0x227C /* DOES NOT PRECEDE OR EQUAL */
, 0x22E1, 0x22E1, 0x227D /* DOES NOT SUCCEED OR EQUAL */
, 0x22E2, 0x22E2, 0x2291 /* NOT SQUARE IMAGE OF OR EQUAL TO */
, 0x22E3, 0x22E3, 0x2292 /* NOT SQUARE ORIGINAL OF OR EQUAL TO */
, 0x22EA, 0x22EA, 0x22B2 /* NOT NORMAL SUBGROUP OF */
, 0x22EB, 0x22EB, 0x22B3 /* DOES NOT CONTAIN AS NORMAL SUBGROUP */
, 0x22EC, 0x22EC, 0x22B4 /* NOT NORMAL SUBGROUP OF OR EQUAL TO */
, 0x22ED, 0x22ED, 0x22B5 /* DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL */
, 0x2329, 0x2329, 0x3008 /* LEFT-POINTING ANGLE BRACKET */
, 0x232A, 0x232A, 0x3009 /* RIGHT-POINTING ANGLE BRACKET */
, 0x24B6, 0x24D0, 0x24B6 /* CIRCLED LATIN CAPITAL LETTER A */
, 0x24B7, 0x24D1, 0x24B7 /* CIRCLED LATIN CAPITAL LETTER B */
, 0x24B8, 0x24D2, 0x24B8 /* CIRCLED LATIN CAPITAL LETTER C */
, 0x24B9, 0x24D3, 0x24B9 /* CIRCLED LATIN CAPITAL LETTER D */
, 0x24BA, 0x24D4, 0x24BA /* CIRCLED LATIN CAPITAL LETTER E */
, 0x24BB, 0x24D5, 0x24BB /* CIRCLED LATIN CAPITAL LETTER F */
, 0x24BC, 0x24D6, 0x24BC /* CIRCLED LATIN CAPITAL LETTER G */
, 0x24BD, 0x24D7, 0x24BD /* CIRCLED LATIN CAPITAL LETTER H */
, 0x24BE, 0x24D8, 0x24BE /* CIRCLED LATIN CAPITAL LETTER I */
, 0x24BF, 0x24D9, 0x24BF /* CIRCLED LATIN CAPITAL LETTER J */
, 0x24C0, 0x24DA, 0x24C0 /* CIRCLED LATIN CAPITAL LETTER K */
, 0x24C1, 0x24DB, 0x24C1 /* CIRCLED LATIN CAPITAL LETTER L */
, 0x24C2, 0x24DC, 0x24C2 /* CIRCLED LATIN CAPITAL LETTER M */
, 0x24C3, 0x24DD, 0x24C3 /* CIRCLED LATIN CAPITAL LETTER N */
, 0x24C4, 0x24DE, 0x24C4 /* CIRCLED LATIN CAPITAL LETTER O */
, 0x24C5, 0x24DF, 0x24C5 /* CIRCLED LATIN CAPITAL LETTER P */
, 0x24C6, 0x24E0, 0x24C6 /* CIRCLED LATIN CAPITAL LETTER Q */
, 0x24C7, 0x24E1, 0x24C7 /* CIRCLED LATIN CAPITAL LETTER R */
, 0x24C8, 0x24E2, 0x24C8 /* CIRCLED LATIN CAPITAL LETTER S */
, 0x24C9, 0x24E3, 0x24C9 /* CIRCLED LATIN CAPITAL LETTER T */
, 0x24CA, 0x24E4, 0x24CA /* CIRCLED LATIN CAPITAL LETTER U */
, 0x24CB, 0x24E5, 0x24CB /* CIRCLED LATIN CAPITAL LETTER V */
, 0x24CC, 0x24E6, 0x24CC /* CIRCLED LATIN CAPITAL LETTER W */
, 0x24CD, 0x24E7, 0x24CD /* CIRCLED LATIN CAPITAL LETTER X */
, 0x24CE, 0x24E8, 0x24CE /* CIRCLED LATIN CAPITAL LETTER Y */
, 0x24CF, 0x24E9, 0x24CF /* CIRCLED LATIN CAPITAL LETTER Z */
, 0x2ADC, 0x2ADC, 0x2ADD /* FORKING */
, 0x304C, 0x304C, 0x304B /* HIRAGANA LETTER GA */
, 0x304E, 0x304E, 0x304D /* HIRAGANA LETTER GI */
, 0x3050, 0x3050, 0x304F /* HIRAGANA LETTER GU */
, 0x3052, 0x3052, 0x3051 /* HIRAGANA LETTER GE */
, 0x3054, 0x3054, 0x3053 /* HIRAGANA LETTER GO */
, 0x3056, 0x3056, 0x3055 /* HIRAGANA LETTER ZA */
, 0x3058, 0x3058, 0x3057 /* HIRAGANA LETTER ZI */
, 0x305A, 0x305A, 0x3059 /* HIRAGANA LETTER ZU */
, 0x305C, 0x305C, 0x305B /* HIRAGANA LETTER ZE */
, 0x305E, 0x305E, 0x305D /* HIRAGANA LETTER ZO */
, 0x3060, 0x3060, 0x305F /* HIRAGANA LETTER DA */
, 0x3062, 0x3062, 0x3061 /* HIRAGANA LETTER DI */
, 0x3065, 0x3065, 0x3064 /* HIRAGANA LETTER DU */
, 0x3067, 0x3067, 0x3066 /* HIRAGANA LETTER DE */
, 0x3069, 0x3069, 0x3068 /* HIRAGANA LETTER DO */
, 0x3070, 0x3070, 0x306F /* HIRAGANA LETTER BA */
, 0x3071, 0x3071, 0x306F /* HIRAGANA LETTER PA */
, 0x3073, 0x3073, 0x3072 /* HIRAGANA LETTER BI */
, 0x3074, 0x3074, 0x3072 /* HIRAGANA LETTER PI */
, 0x3076, 0x3076, 0x3075 /* HIRAGANA LETTER BU */
, 0x3077, 0x3077, 0x3075 /* HIRAGANA LETTER PU */
, 0x3079, 0x3079, 0x3078 /* HIRAGANA LETTER BE */
, 0x307A, 0x307A, 0x3078 /* HIRAGANA LETTER PE */
, 0x307C, 0x307C, 0x307B /* HIRAGANA LETTER BO */
, 0x307D, 0x307D, 0x307B /* HIRAGANA LETTER PO */
, 0x3094, 0x3094, 0x3046 /* HIRAGANA LETTER VU */
, 0x309E, 0x309E, 0x309D /* HIRAGANA VOICED ITERATION MARK */
, 0x30AC, 0x30AC, 0x30AB /* KATAKANA LETTER GA */
, 0x30AE, 0x30AE, 0x30AD /* KATAKANA LETTER GI */
, 0x30B0, 0x30B0, 0x30AF /* KATAKANA LETTER GU */
, 0x30B2, 0x30B2, 0x30B1 /* KATAKANA LETTER GE */
, 0x30B4, 0x30B4, 0x30B3 /* KATAKANA LETTER GO */
, 0x30B6, 0x30B6, 0x30B5 /* KATAKANA LETTER ZA */
, 0x30B8, 0x30B8, 0x30B7 /* KATAKANA LETTER ZI */
, 0x30BA, 0x30BA, 0x30B9 /* KATAKANA LETTER ZU */
, 0x30BC, 0x30BC, 0x30BB /* KATAKANA LETTER ZE */
, 0x30BE, 0x30BE, 0x30BD /* KATAKANA LETTER ZO */
, 0x30C0, 0x30C0, 0x30BF /* KATAKANA LETTER DA */
, 0x30C2, 0x30C2, 0x30C1 /* KATAKANA LETTER DI */
, 0x30C5, 0x30C5, 0x30C4 /* KATAKANA LETTER DU */
, 0x30C7, 0x30C7, 0x30C6 /* KATAKANA LETTER DE */
, 0x30C9, 0x30C9, 0x30C8 /* KATAKANA LETTER DO */
, 0x30D0, 0x30D0, 0x30CF /* KATAKANA LETTER BA */
, 0x30D1, 0x30D1, 0x30CF /* KATAKANA LETTER PA */
, 0x30D3, 0x30D3, 0x30D2 /* KATAKANA LETTER BI */
, 0x30D4, 0x30D4, 0x30D2 /* KATAKANA LETTER PI */
, 0x30D6, 0x30D6, 0x30D5 /* KATAKANA LETTER BU */
, 0x30D7, 0x30D7, 0x30D5 /* KATAKANA LETTER PU */
, 0x30D9, 0x30D9, 0x30D8 /* KATAKANA LETTER BE */
, 0x30DA, 0x30DA, 0x30D8 /* KATAKANA LETTER PE */
, 0x30DC, 0x30DC, 0x30DB /* KATAKANA LETTER BO */
, 0x30DD, 0x30DD, 0x30DB /* KATAKANA LETTER PO */
, 0x30F4, 0x30F4, 0x30A6 /* KATAKANA LETTER VU */
, 0x30F7, 0x30F7, 0x30EF /* KATAKANA LETTER VA */
, 0x30F8, 0x30F8, 0x30F0 /* KATAKANA LETTER VI */
, 0x30F9, 0x30F9, 0x30F1 /* KATAKANA LETTER VE */
, 0x30FA, 0x30FA, 0x30F2 /* KATAKANA LETTER VO */
, 0x30FE, 0x30FE, 0x30FD /* KATAKANA VOICED ITERATION MARK */
, 0xF900, 0xF900, 0x8C48 /* CJK COMPATIBILITY IDEOGRAPH-F900 */
, 0xF901, 0xF901, 0x66F4 /* CJK COMPATIBILITY IDEOGRAPH-F901 */
, 0xF902, 0xF902, 0x8ECA /* CJK COMPATIBILITY IDEOGRAPH-F902 */
, 0xF903, 0xF903, 0x8CC8 /* CJK COMPATIBILITY IDEOGRAPH-F903 */
, 0xF904, 0xF904, 0x6ED1 /* CJK COMPATIBILITY IDEOGRAPH-F904 */
, 0xF905, 0xF905, 0x4E32 /* CJK COMPATIBILITY IDEOGRAPH-F905 */
, 0xF906, 0xF906, 0x53E5 /* CJK COMPATIBILITY IDEOGRAPH-F906 */
, 0xF907, 0xF907, 0x9F9C /* CJK COMPATIBILITY IDEOGRAPH-F907 */
, 0xF908, 0xF908, 0x9F9C /* CJK COMPATIBILITY IDEOGRAPH-F908 */
, 0xF909, 0xF909, 0x5951 /* CJK COMPATIBILITY IDEOGRAPH-F909 */
, 0xF90A, 0xF90A, 0x91D1 /* CJK COMPATIBILITY IDEOGRAPH-F90A */
, 0xF90B, 0xF90B, 0x5587 /* CJK COMPATIBILITY IDEOGRAPH-F90B */
, 0xF90C, 0xF90C, 0x5948 /* CJK COMPATIBILITY IDEOGRAPH-F90C */
, 0xF90D, 0xF90D, 0x61F6 /* CJK COMPATIBILITY IDEOGRAPH-F90D */
, 0xF90E, 0xF90E, 0x7669 /* CJK COMPATIBILITY IDEOGRAPH-F90E */
, 0xF90F, 0xF90F, 0x7F85 /* CJK COMPATIBILITY IDEOGRAPH-F90F */
, 0xF910, 0xF910, 0x863F /* CJK COMPATIBILITY IDEOGRAPH-F910 */
, 0xF911, 0xF911, 0x87BA /* CJK COMPATIBILITY IDEOGRAPH-F911 */
, 0xF912, 0xF912, 0x88F8 /* CJK COMPATIBILITY IDEOGRAPH-F912 */
, 0xF913, 0xF913, 0x908F /* CJK COMPATIBILITY IDEOGRAPH-F913 */
, 0xF914, 0xF914, 0x6A02 /* CJK COMPATIBILITY IDEOGRAPH-F914 */
, 0xF915, 0xF915, 0x6D1B /* CJK COMPATIBILITY IDEOGRAPH-F915 */
, 0xF916, 0xF916, 0x70D9 /* CJK COMPATIBILITY IDEOGRAPH-F916 */
, 0xF917, 0xF917, 0x73DE /* CJK COMPATIBILITY IDEOGRAPH-F917 */
, 0xF918, 0xF918, 0x843D /* CJK COMPATIBILITY IDEOGRAPH-F918 */
, 0xF919, 0xF919, 0x916A /* CJK COMPATIBILITY IDEOGRAPH-F919 */
, 0xF91A, 0xF91A, 0x99F1 /* CJK COMPATIBILITY IDEOGRAPH-F91A */
, 0xF91B, 0xF91B, 0x4E82 /* CJK COMPATIBILITY IDEOGRAPH-F91B */
, 0xF91C, 0xF91C, 0x5375 /* CJK COMPATIBILITY IDEOGRAPH-F91C */
, 0xF91D, 0xF91D, 0x6B04 /* CJK COMPATIBILITY IDEOGRAPH-F91D */
, 0xF91E, 0xF91E, 0x721B /* CJK COMPATIBILITY IDEOGRAPH-F91E */
, 0xF91F, 0xF91F, 0x862D /* CJK COMPATIBILITY IDEOGRAPH-F91F */
, 0xF920, 0xF920, 0x9E1E /* CJK COMPATIBILITY IDEOGRAPH-F920 */
, 0xF921, 0xF921, 0x5D50 /* CJK COMPATIBILITY IDEOGRAPH-F921 */
, 0xF922, 0xF922, 0x6FEB /* CJK COMPATIBILITY IDEOGRAPH-F922 */
, 0xF923, 0xF923, 0x85CD /* CJK COMPATIBILITY IDEOGRAPH-F923 */
, 0xF924, 0xF924, 0x8964 /* CJK COMPATIBILITY IDEOGRAPH-F924 */
, 0xF925, 0xF925, 0x62C9 /* CJK COMPATIBILITY IDEOGRAPH-F925 */
, 0xF926, 0xF926, 0x81D8 /* CJK COMPATIBILITY IDEOGRAPH-F926 */
, 0xF927, 0xF927, 0x881F /* CJK COMPATIBILITY IDEOGRAPH-F927 */
, 0xF928, 0xF928, 0x5ECA /* CJK COMPATIBILITY IDEOGRAPH-F928 */
, 0xF929, 0xF929, 0x6717 /* CJK COMPATIBILITY IDEOGRAPH-F929 */
, 0xF92A, 0xF92A, 0x6D6A /* CJK COMPATIBILITY IDEOGRAPH-F92A */
, 0xF92B, 0xF92B, 0x72FC /* CJK COMPATIBILITY IDEOGRAPH-F92B */
, 0xF92C, 0xF92C, 0x90CE /* CJK COMPATIBILITY IDEOGRAPH-F92C */
, 0xF92D, 0xF92D, 0x4F86 /* CJK COMPATIBILITY IDEOGRAPH-F92D */
, 0xF92E, 0xF92E, 0x51B7 /* CJK COMPATIBILITY IDEOGRAPH-F92E */
, 0xF92F, 0xF92F, 0x52DE /* CJK COMPATIBILITY IDEOGRAPH-F92F */
, 0xF930, 0xF930, 0x64C4 /* CJK COMPATIBILITY IDEOGRAPH-F930 */
, 0xF931, 0xF931, 0x6AD3 /* CJK COMPATIBILITY IDEOGRAPH-F931 */
, 0xF932, 0xF932, 0x7210 /* CJK COMPATIBILITY IDEOGRAPH-F932 */
, 0xF933, 0xF933, 0x76E7 /* CJK COMPATIBILITY IDEOGRAPH-F933 */
, 0xF934, 0xF934, 0x8001 /* CJK COMPATIBILITY IDEOGRAPH-F934 */
, 0xF935, 0xF935, 0x8606 /* CJK COMPATIBILITY IDEOGRAPH-F935 */
, 0xF936, 0xF936, 0x865C /* CJK COMPATIBILITY IDEOGRAPH-F936 */
, 0xF937, 0xF937, 0x8DEF /* CJK COMPATIBILITY IDEOGRAPH-F937 */
, 0xF938, 0xF938, 0x9732 /* CJK COMPATIBILITY IDEOGRAPH-F938 */
, 0xF939, 0xF939, 0x9B6F /* CJK COMPATIBILITY IDEOGRAPH-F939 */
, 0xF93A, 0xF93A, 0x9DFA /* CJK COMPATIBILITY IDEOGRAPH-F93A */
, 0xF93B, 0xF93B, 0x788C /* CJK COMPATIBILITY IDEOGRAPH-F93B */
, 0xF93C, 0xF93C, 0x797F /* CJK COMPATIBILITY IDEOGRAPH-F93C */
, 0xF93D, 0xF93D, 0x7DA0 /* CJK COMPATIBILITY IDEOGRAPH-F93D */
, 0xF93E, 0xF93E, 0x83C9 /* CJK COMPATIBILITY IDEOGRAPH-F93E */
, 0xF93F, 0xF93F, 0x9304 /* CJK COMPATIBILITY IDEOGRAPH-F93F */
, 0xF940, 0xF940, 0x9E7F /* CJK COMPATIBILITY IDEOGRAPH-F940 */
, 0xF941, 0xF941, 0x8AD6 /* CJK COMPATIBILITY IDEOGRAPH-F941 */
, 0xF942, 0xF942, 0x58DF /* CJK COMPATIBILITY IDEOGRAPH-F942 */
, 0xF943, 0xF943, 0x5F04 /* CJK COMPATIBILITY IDEOGRAPH-F943 */
, 0xF944, 0xF944, 0x7C60 /* CJK COMPATIBILITY IDEOGRAPH-F944 */
, 0xF945, 0xF945, 0x807E /* CJK COMPATIBILITY IDEOGRAPH-F945 */
, 0xF946, 0xF946, 0x7262 /* CJK COMPATIBILITY IDEOGRAPH-F946 */
, 0xF947, 0xF947, 0x78CA /* CJK COMPATIBILITY IDEOGRAPH-F947 */
, 0xF948, 0xF948, 0x8CC2 /* CJK COMPATIBILITY IDEOGRAPH-F948 */
, 0xF949, 0xF949, 0x96F7 /* CJK COMPATIBILITY IDEOGRAPH-F949 */
, 0xF94A, 0xF94A, 0x58D8 /* CJK COMPATIBILITY IDEOGRAPH-F94A */
, 0xF94B, 0xF94B, 0x5C62 /* CJK COMPATIBILITY IDEOGRAPH-F94B */
, 0xF94C, 0xF94C, 0x6A13 /* CJK COMPATIBILITY IDEOGRAPH-F94C */
, 0xF94D, 0xF94D, 0x6DDA /* CJK COMPATIBILITY IDEOGRAPH-F94D */
, 0xF94E, 0xF94E, 0x6F0F /* CJK COMPATIBILITY IDEOGRAPH-F94E */
, 0xF94F, 0xF94F, 0x7D2F /* CJK COMPATIBILITY IDEOGRAPH-F94F */
, 0xF950, 0xF950, 0x7E37 /* CJK COMPATIBILITY IDEOGRAPH-F950 */
, 0xF951, 0xF951, 0x964B /* CJK COMPATIBILITY IDEOGRAPH-F951 */
, 0xF952, 0xF952, 0x52D2 /* CJK COMPATIBILITY IDEOGRAPH-F952 */
, 0xF953, 0xF953, 0x808B /* CJK COMPATIBILITY IDEOGRAPH-F953 */
, 0xF954, 0xF954, 0x51DC /* CJK COMPATIBILITY IDEOGRAPH-F954 */
, 0xF955, 0xF955, 0x51CC /* CJK COMPATIBILITY IDEOGRAPH-F955 */
, 0xF956, 0xF956, 0x7A1C /* CJK COMPATIBILITY IDEOGRAPH-F956 */
, 0xF957, 0xF957, 0x7DBE /* CJK COMPATIBILITY IDEOGRAPH-F957 */
, 0xF958, 0xF958, 0x83F1 /* CJK COMPATIBILITY IDEOGRAPH-F958 */
, 0xF959, 0xF959, 0x9675 /* CJK COMPATIBILITY IDEOGRAPH-F959 */
, 0xF95A, 0xF95A, 0x8B80 /* CJK COMPATIBILITY IDEOGRAPH-F95A */
, 0xF95B, 0xF95B, 0x62CF /* CJK COMPATIBILITY IDEOGRAPH-F95B */
, 0xF95C, 0xF95C, 0x6A02 /* CJK COMPATIBILITY IDEOGRAPH-F95C */
, 0xF95D, 0xF95D, 0x8AFE /* CJK COMPATIBILITY IDEOGRAPH-F95D */
, 0xF95E, 0xF95E, 0x4E39 /* CJK COMPATIBILITY IDEOGRAPH-F95E */
, 0xF95F, 0xF95F, 0x5BE7 /* CJK COMPATIBILITY IDEOGRAPH-F95F */
, 0xF960, 0xF960, 0x6012 /* CJK COMPATIBILITY IDEOGRAPH-F960 */
, 0xF961, 0xF961, 0x7387 /* CJK COMPATIBILITY IDEOGRAPH-F961 */
, 0xF962, 0xF962, 0x7570 /* CJK COMPATIBILITY IDEOGRAPH-F962 */
, 0xF963, 0xF963, 0x5317 /* CJK COMPATIBILITY IDEOGRAPH-F963 */
, 0xF964, 0xF964, 0x78FB /* CJK COMPATIBILITY IDEOGRAPH-F964 */
, 0xF965, 0xF965, 0x4FBF /* CJK COMPATIBILITY IDEOGRAPH-F965 */
, 0xF966, 0xF966, 0x5FA9 /* CJK COMPATIBILITY IDEOGRAPH-F966 */
, 0xF967, 0xF967, 0x4E0D /* CJK COMPATIBILITY IDEOGRAPH-F967 */
, 0xF968, 0xF968, 0x6CCC /* CJK COMPATIBILITY IDEOGRAPH-F968 */
, 0xF969, 0xF969, 0x6578 /* CJK COMPATIBILITY IDEOGRAPH-F969 */
, 0xF96A, 0xF96A, 0x7D22 /* CJK COMPATIBILITY IDEOGRAPH-F96A */
, 0xF96B, 0xF96B, 0x53C3 /* CJK COMPATIBILITY IDEOGRAPH-F96B */
, 0xF96C, 0xF96C, 0x585E /* CJK COMPATIBILITY IDEOGRAPH-F96C */
, 0xF96D, 0xF96D, 0x7701 /* CJK COMPATIBILITY IDEOGRAPH-F96D */
, 0xF96E, 0xF96E, 0x8449 /* CJK COMPATIBILITY IDEOGRAPH-F96E */
, 0xF96F, 0xF96F, 0x8AAA /* CJK COMPATIBILITY IDEOGRAPH-F96F */
, 0xF970, 0xF970, 0x6BBA /* CJK COMPATIBILITY IDEOGRAPH-F970 */
, 0xF971, 0xF971, 0x8FB0 /* CJK COMPATIBILITY IDEOGRAPH-F971 */
, 0xF972, 0xF972, 0x6C88 /* CJK COMPATIBILITY IDEOGRAPH-F972 */
, 0xF973, 0xF973, 0x62FE /* CJK COMPATIBILITY IDEOGRAPH-F973 */
, 0xF974, 0xF974, 0x82E5 /* CJK COMPATIBILITY IDEOGRAPH-F974 */
, 0xF975, 0xF975, 0x63A0 /* CJK COMPATIBILITY IDEOGRAPH-F975 */
, 0xF976, 0xF976, 0x7565 /* CJK COMPATIBILITY IDEOGRAPH-F976 */
, 0xF977, 0xF977, 0x4EAE /* CJK COMPATIBILITY IDEOGRAPH-F977 */
, 0xF978, 0xF978, 0x5169 /* CJK COMPATIBILITY IDEOGRAPH-F978 */
, 0xF979, 0xF979, 0x51C9 /* CJK COMPATIBILITY IDEOGRAPH-F979 */
, 0xF97A, 0xF97A, 0x6881 /* CJK COMPATIBILITY IDEOGRAPH-F97A */
, 0xF97B, 0xF97B, 0x7CE7 /* CJK COMPATIBILITY IDEOGRAPH-F97B */
, 0xF97C, 0xF97C, 0x826F /* CJK COMPATIBILITY IDEOGRAPH-F97C */
, 0xF97D, 0xF97D, 0x8AD2 /* CJK COMPATIBILITY IDEOGRAPH-F97D */
, 0xF97E, 0xF97E, 0x91CF /* CJK COMPATIBILITY IDEOGRAPH-F97E */
, 0xF97F, 0xF97F, 0x52F5 /* CJK COMPATIBILITY IDEOGRAPH-F97F */
, 0xF980, 0xF980, 0x5442 /* CJK COMPATIBILITY IDEOGRAPH-F980 */
, 0xF981, 0xF981, 0x5973 /* CJK COMPATIBILITY IDEOGRAPH-F981 */
, 0xF982, 0xF982, 0x5EEC /* CJK COMPATIBILITY IDEOGRAPH-F982 */
, 0xF983, 0xF983, 0x65C5 /* CJK COMPATIBILITY IDEOGRAPH-F983 */
, 0xF984, 0xF984, 0x6FFE /* CJK COMPATIBILITY IDEOGRAPH-F984 */
, 0xF985, 0xF985, 0x792A /* CJK COMPATIBILITY IDEOGRAPH-F985 */
, 0xF986, 0xF986, 0x95AD /* CJK COMPATIBILITY IDEOGRAPH-F986 */
, 0xF987, 0xF987, 0x9A6A /* CJK COMPATIBILITY IDEOGRAPH-F987 */
, 0xF988, 0xF988, 0x9E97 /* CJK COMPATIBILITY IDEOGRAPH-F988 */
, 0xF989, 0xF989, 0x9ECE /* CJK COMPATIBILITY IDEOGRAPH-F989 */
, 0xF98A, 0xF98A, 0x529B /* CJK COMPATIBILITY IDEOGRAPH-F98A */
, 0xF98B, 0xF98B, 0x66C6 /* CJK COMPATIBILITY IDEOGRAPH-F98B */
, 0xF98C, 0xF98C, 0x6B77 /* CJK COMPATIBILITY IDEOGRAPH-F98C */
, 0xF98D, 0xF98D, 0x8F62 /* CJK COMPATIBILITY IDEOGRAPH-F98D */
, 0xF98E, 0xF98E, 0x5E74 /* CJK COMPATIBILITY IDEOGRAPH-F98E */
, 0xF98F, 0xF98F, 0x6190 /* CJK COMPATIBILITY IDEOGRAPH-F98F */
, 0xF990, 0xF990, 0x6200 /* CJK COMPATIBILITY IDEOGRAPH-F990 */
, 0xF991, 0xF991, 0x649A /* CJK COMPATIBILITY IDEOGRAPH-F991 */
, 0xF992, 0xF992, 0x6F23 /* CJK COMPATIBILITY IDEOGRAPH-F992 */
, 0xF993, 0xF993, 0x7149 /* CJK COMPATIBILITY IDEOGRAPH-F993 */
, 0xF994, 0xF994, 0x7489 /* CJK COMPATIBILITY IDEOGRAPH-F994 */
, 0xF995, 0xF995, 0x79CA /* CJK COMPATIBILITY IDEOGRAPH-F995 */
, 0xF996, 0xF996, 0x7DF4 /* CJK COMPATIBILITY IDEOGRAPH-F996 */
, 0xF997, 0xF997, 0x806F /* CJK COMPATIBILITY IDEOGRAPH-F997 */
, 0xF998, 0xF998, 0x8F26 /* CJK COMPATIBILITY IDEOGRAPH-F998 */
, 0xF999, 0xF999, 0x84EE /* CJK COMPATIBILITY IDEOGRAPH-F999 */
, 0xF99A, 0xF99A, 0x9023 /* CJK COMPATIBILITY IDEOGRAPH-F99A */
, 0xF99B, 0xF99B, 0x934A /* CJK COMPATIBILITY IDEOGRAPH-F99B */
, 0xF99C, 0xF99C, 0x5217 /* CJK COMPATIBILITY IDEOGRAPH-F99C */
, 0xF99D, 0xF99D, 0x52A3 /* CJK COMPATIBILITY IDEOGRAPH-F99D */
, 0xF99E, 0xF99E, 0x54BD /* CJK COMPATIBILITY IDEOGRAPH-F99E */
, 0xF99F, 0xF99F, 0x70C8 /* CJK COMPATIBILITY IDEOGRAPH-F99F */
, 0xF9A0, 0xF9A0, 0x88C2 /* CJK COMPATIBILITY IDEOGRAPH-F9A0 */
, 0xF9A1, 0xF9A1, 0x8AAA /* CJK COMPATIBILITY IDEOGRAPH-F9A1 */
, 0xF9A2, 0xF9A2, 0x5EC9 /* CJK COMPATIBILITY IDEOGRAPH-F9A2 */
, 0xF9A3, 0xF9A3, 0x5FF5 /* CJK COMPATIBILITY IDEOGRAPH-F9A3 */
, 0xF9A4, 0xF9A4, 0x637B /* CJK COMPATIBILITY IDEOGRAPH-F9A4 */
, 0xF9A5, 0xF9A5, 0x6BAE /* CJK COMPATIBILITY IDEOGRAPH-F9A5 */
, 0xF9A6, 0xF9A6, 0x7C3E /* CJK COMPATIBILITY IDEOGRAPH-F9A6 */
, 0xF9A7, 0xF9A7, 0x7375 /* CJK COMPATIBILITY IDEOGRAPH-F9A7 */
, 0xF9A8, 0xF9A8, 0x4EE4 /* CJK COMPATIBILITY IDEOGRAPH-F9A8 */
, 0xF9A9, 0xF9A9, 0x56F9 /* CJK COMPATIBILITY IDEOGRAPH-F9A9 */
, 0xF9AA, 0xF9AA, 0x5BE7 /* CJK COMPATIBILITY IDEOGRAPH-F9AA */
, 0xF9AB, 0xF9AB, 0x5DBA /* CJK COMPATIBILITY IDEOGRAPH-F9AB */
, 0xF9AC, 0xF9AC, 0x601C /* CJK COMPATIBILITY IDEOGRAPH-F9AC */
, 0xF9AD, 0xF9AD, 0x73B2 /* CJK COMPATIBILITY IDEOGRAPH-F9AD */
, 0xF9AE, 0xF9AE, 0x7469 /* CJK COMPATIBILITY IDEOGRAPH-F9AE */
, 0xF9AF, 0xF9AF, 0x7F9A /* CJK COMPATIBILITY IDEOGRAPH-F9AF */
, 0xF9B0, 0xF9B0, 0x8046 /* CJK COMPATIBILITY IDEOGRAPH-F9B0 */
, 0xF9B1, 0xF9B1, 0x9234 /* CJK COMPATIBILITY IDEOGRAPH-F9B1 */
, 0xF9B2, 0xF9B2, 0x96F6 /* CJK COMPATIBILITY IDEOGRAPH-F9B2 */
, 0xF9B3, 0xF9B3, 0x9748 /* CJK COMPATIBILITY IDEOGRAPH-F9B3 */
, 0xF9B4, 0xF9B4, 0x9818 /* CJK COMPATIBILITY IDEOGRAPH-F9B4 */
, 0xF9B5, 0xF9B5, 0x4F8B /* CJK COMPATIBILITY IDEOGRAPH-F9B5 */
, 0xF9B6, 0xF9B6, 0x79AE /* CJK COMPATIBILITY IDEOGRAPH-F9B6 */
, 0xF9B7, 0xF9B7, 0x91B4 /* CJK COMPATIBILITY IDEOGRAPH-F9B7 */
, 0xF9B8, 0xF9B8, 0x96B8 /* CJK COMPATIBILITY IDEOGRAPH-F9B8 */
, 0xF9B9, 0xF9B9, 0x60E1 /* CJK COMPATIBILITY IDEOGRAPH-F9B9 */
, 0xF9BA, 0xF9BA, 0x4E86 /* CJK COMPATIBILITY IDEOGRAPH-F9BA */
, 0xF9BB, 0xF9BB, 0x50DA /* CJK COMPATIBILITY IDEOGRAPH-F9BB */
, 0xF9BC, 0xF9BC, 0x5BEE /* CJK COMPATIBILITY IDEOGRAPH-F9BC */
, 0xF9BD, 0xF9BD, 0x5C3F /* CJK COMPATIBILITY IDEOGRAPH-F9BD */
, 0xF9BE, 0xF9BE, 0x6599 /* CJK COMPATIBILITY IDEOGRAPH-F9BE */
, 0xF9BF, 0xF9BF, 0x6A02 /* CJK COMPATIBILITY IDEOGRAPH-F9BF */
, 0xF9C0, 0xF9C0, 0x71CE /* CJK COMPATIBILITY IDEOGRAPH-F9C0 */
, 0xF9C1, 0xF9C1, 0x7642 /* CJK COMPATIBILITY IDEOGRAPH-F9C1 */
, 0xF9C2, 0xF9C2, 0x84FC /* CJK COMPATIBILITY IDEOGRAPH-F9C2 */
, 0xF9C3, 0xF9C3, 0x907C /* CJK COMPATIBILITY IDEOGRAPH-F9C3 */
, 0xF9C4, 0xF9C4, 0x9F8D /* CJK COMPATIBILITY IDEOGRAPH-F9C4 */
, 0xF9C5, 0xF9C5, 0x6688 /* CJK COMPATIBILITY IDEOGRAPH-F9C5 */
, 0xF9C6, 0xF9C6, 0x962E /* CJK COMPATIBILITY IDEOGRAPH-F9C6 */
, 0xF9C7, 0xF9C7, 0x5289 /* CJK COMPATIBILITY IDEOGRAPH-F9C7 */
, 0xF9C8, 0xF9C8, 0x677B /* CJK COMPATIBILITY IDEOGRAPH-F9C8 */
, 0xF9C9, 0xF9C9, 0x67F3 /* CJK COMPATIBILITY IDEOGRAPH-F9C9 */
, 0xF9CA, 0xF9CA, 0x6D41 /* CJK COMPATIBILITY IDEOGRAPH-F9CA */
, 0xF9CB, 0xF9CB, 0x6E9C /* CJK COMPATIBILITY IDEOGRAPH-F9CB */
, 0xF9CC, 0xF9CC, 0x7409 /* CJK COMPATIBILITY IDEOGRAPH-F9CC */
, 0xF9CD, 0xF9CD, 0x7559 /* CJK COMPATIBILITY IDEOGRAPH-F9CD */
, 0xF9CE, 0xF9CE, 0x786B /* CJK COMPATIBILITY IDEOGRAPH-F9CE */
, 0xF9CF, 0xF9CF, 0x7D10 /* CJK COMPATIBILITY IDEOGRAPH-F9CF */
, 0xF9D0, 0xF9D0, 0x985E /* CJK COMPATIBILITY IDEOGRAPH-F9D0 */
, 0xF9D1, 0xF9D1, 0x516D /* CJK COMPATIBILITY IDEOGRAPH-F9D1 */
, 0xF9D2, 0xF9D2, 0x622E /* CJK COMPATIBILITY IDEOGRAPH-F9D2 */
, 0xF9D3, 0xF9D3, 0x9678 /* CJK COMPATIBILITY IDEOGRAPH-F9D3 */
, 0xF9D4, 0xF9D4, 0x502B /* CJK COMPATIBILITY IDEOGRAPH-F9D4 */
, 0xF9D5, 0xF9D5, 0x5D19 /* CJK COMPATIBILITY IDEOGRAPH-F9D5 */
, 0xF9D6, 0xF9D6, 0x6DEA /* CJK COMPATIBILITY IDEOGRAPH-F9D6 */
, 0xF9D7, 0xF9D7, 0x8F2A /* CJK COMPATIBILITY IDEOGRAPH-F9D7 */
, 0xF9D8, 0xF9D8, 0x5F8B /* CJK COMPATIBILITY IDEOGRAPH-F9D8 */
, 0xF9D9, 0xF9D9, 0x6144 /* CJK COMPATIBILITY IDEOGRAPH-F9D9 */
, 0xF9DA, 0xF9DA, 0x6817 /* CJK COMPATIBILITY IDEOGRAPH-F9DA */
, 0xF9DB, 0xF9DB, 0x7387 /* CJK COMPATIBILITY IDEOGRAPH-F9DB */
, 0xF9DC, 0xF9DC, 0x9686 /* CJK COMPATIBILITY IDEOGRAPH-F9DC */
, 0xF9DD, 0xF9DD, 0x5229 /* CJK COMPATIBILITY IDEOGRAPH-F9DD */
, 0xF9DE, 0xF9DE, 0x540F /* CJK COMPATIBILITY IDEOGRAPH-F9DE */
, 0xF9DF, 0xF9DF, 0x5C65 /* CJK COMPATIBILITY IDEOGRAPH-F9DF */
, 0xF9E0, 0xF9E0, 0x6613 /* CJK COMPATIBILITY IDEOGRAPH-F9E0 */
, 0xF9E1, 0xF9E1, 0x674E /* CJK COMPATIBILITY IDEOGRAPH-F9E1 */
, 0xF9E2, 0xF9E2, 0x68A8 /* CJK COMPATIBILITY IDEOGRAPH-F9E2 */
, 0xF9E3, 0xF9E3, 0x6CE5 /* CJK COMPATIBILITY IDEOGRAPH-F9E3 */
, 0xF9E4, 0xF9E4, 0x7406 /* CJK COMPATIBILITY IDEOGRAPH-F9E4 */
, 0xF9E5, 0xF9E5, 0x75E2 /* CJK COMPATIBILITY IDEOGRAPH-F9E5 */
, 0xF9E6, 0xF9E6, 0x7F79 /* CJK COMPATIBILITY IDEOGRAPH-F9E6 */
, 0xF9E7, 0xF9E7, 0x88CF /* CJK COMPATIBILITY IDEOGRAPH-F9E7 */
, 0xF9E8, 0xF9E8, 0x88E1 /* CJK COMPATIBILITY IDEOGRAPH-F9E8 */
, 0xF9E9, 0xF9E9, 0x91CC /* CJK COMPATIBILITY IDEOGRAPH-F9E9 */
, 0xF9EA, 0xF9EA, 0x96E2 /* CJK COMPATIBILITY IDEOGRAPH-F9EA */
, 0xF9EB, 0xF9EB, 0x533F /* CJK COMPATIBILITY IDEOGRAPH-F9EB */
, 0xF9EC, 0xF9EC, 0x6EBA /* CJK COMPATIBILITY IDEOGRAPH-F9EC */
, 0xF9ED, 0xF9ED, 0x541D /* CJK COMPATIBILITY IDEOGRAPH-F9ED */
, 0xF9EE, 0xF9EE, 0x71D0 /* CJK COMPATIBILITY IDEOGRAPH-F9EE */
, 0xF9EF, 0xF9EF, 0x7498 /* CJK COMPATIBILITY IDEOGRAPH-F9EF */
, 0xF9F0, 0xF9F0, 0x85FA /* CJK COMPATIBILITY IDEOGRAPH-F9F0 */
, 0xF9F1, 0xF9F1, 0x96A3 /* CJK COMPATIBILITY IDEOGRAPH-F9F1 */
, 0xF9F2, 0xF9F2, 0x9C57 /* CJK COMPATIBILITY IDEOGRAPH-F9F2 */
, 0xF9F3, 0xF9F3, 0x9E9F /* CJK COMPATIBILITY IDEOGRAPH-F9F3 */
, 0xF9F4, 0xF9F4, 0x6797 /* CJK COMPATIBILITY IDEOGRAPH-F9F4 */
, 0xF9F5, 0xF9F5, 0x6DCB /* CJK COMPATIBILITY IDEOGRAPH-F9F5 */
, 0xF9F6, 0xF9F6, 0x81E8 /* CJK COMPATIBILITY IDEOGRAPH-F9F6 */
, 0xF9F7, 0xF9F7, 0x7ACB /* CJK COMPATIBILITY IDEOGRAPH-F9F7 */
, 0xF9F8, 0xF9F8, 0x7B20 /* CJK COMPATIBILITY IDEOGRAPH-F9F8 */
, 0xF9F9, 0xF9F9, 0x7C92 /* CJK COMPATIBILITY IDEOGRAPH-F9F9 */
, 0xF9FA, 0xF9FA, 0x72C0 /* CJK COMPATIBILITY IDEOGRAPH-F9FA */
, 0xF9FB, 0xF9FB, 0x7099 /* CJK COMPATIBILITY IDEOGRAPH-F9FB */
, 0xF9FC, 0xF9FC, 0x8B58 /* CJK COMPATIBILITY IDEOGRAPH-F9FC */
, 0xF9FD, 0xF9FD, 0x4EC0 /* CJK COMPATIBILITY IDEOGRAPH-F9FD */
, 0xF9FE, 0xF9FE, 0x8336 /* CJK COMPATIBILITY IDEOGRAPH-F9FE */
, 0xF9FF, 0xF9FF, 0x523A /* CJK COMPATIBILITY IDEOGRAPH-F9FF */
, 0xFA00, 0xFA00, 0x5207 /* CJK COMPATIBILITY IDEOGRAPH-FA00 */
, 0xFA01, 0xFA01, 0x5EA6 /* CJK COMPATIBILITY IDEOGRAPH-FA01 */
, 0xFA02, 0xFA02, 0x62D3 /* CJK COMPATIBILITY IDEOGRAPH-FA02 */
, 0xFA03, 0xFA03, 0x7CD6 /* CJK COMPATIBILITY IDEOGRAPH-FA03 */
, 0xFA04, 0xFA04, 0x5B85 /* CJK COMPATIBILITY IDEOGRAPH-FA04 */
, 0xFA05, 0xFA05, 0x6D1E /* CJK COMPATIBILITY IDEOGRAPH-FA05 */
, 0xFA06, 0xFA06, 0x66B4 /* CJK COMPATIBILITY IDEOGRAPH-FA06 */
, 0xFA07, 0xFA07, 0x8F3B /* CJK COMPATIBILITY IDEOGRAPH-FA07 */
, 0xFA08, 0xFA08, 0x884C /* CJK COMPATIBILITY IDEOGRAPH-FA08 */
, 0xFA09, 0xFA09, 0x964D /* CJK COMPATIBILITY IDEOGRAPH-FA09 */
, 0xFA0A, 0xFA0A, 0x898B /* CJK COMPATIBILITY IDEOGRAPH-FA0A */
, 0xFA0B, 0xFA0B, 0x5ED3 /* CJK COMPATIBILITY IDEOGRAPH-FA0B */
, 0xFA0C, 0xFA0C, 0x5140 /* CJK COMPATIBILITY IDEOGRAPH-FA0C */
, 0xFA0D, 0xFA0D, 0x55C0 /* CJK COMPATIBILITY IDEOGRAPH-FA0D */
, 0xFA10, 0xFA10, 0x585A /* CJK COMPATIBILITY IDEOGRAPH-FA10 */
, 0xFA12, 0xFA12, 0x6674 /* CJK COMPATIBILITY IDEOGRAPH-FA12 */
, 0xFA15, 0xFA15, 0x51DE /* CJK COMPATIBILITY IDEOGRAPH-FA15 */
, 0xFA16, 0xFA16, 0x732A /* CJK COMPATIBILITY IDEOGRAPH-FA16 */
, 0xFA17, 0xFA17, 0x76CA /* CJK COMPATIBILITY IDEOGRAPH-FA17 */
, 0xFA18, 0xFA18, 0x793C /* CJK COMPATIBILITY IDEOGRAPH-FA18 */
, 0xFA19, 0xFA19, 0x795E /* CJK COMPATIBILITY IDEOGRAPH-FA19 */
, 0xFA1A, 0xFA1A, 0x7965 /* CJK COMPATIBILITY IDEOGRAPH-FA1A */
, 0xFA1B, 0xFA1B, 0x798F /* CJK COMPATIBILITY IDEOGRAPH-FA1B */
, 0xFA1C, 0xFA1C, 0x9756 /* CJK COMPATIBILITY IDEOGRAPH-FA1C */
, 0xFA1D, 0xFA1D, 0x7CBE /* CJK COMPATIBILITY IDEOGRAPH-FA1D */
, 0xFA1E, 0xFA1E, 0x7FBD /* CJK COMPATIBILITY IDEOGRAPH-FA1E */
, 0xFA20, 0xFA20, 0x8612 /* CJK COMPATIBILITY IDEOGRAPH-FA20 */
, 0xFA22, 0xFA22, 0x8AF8 /* CJK COMPATIBILITY IDEOGRAPH-FA22 */
, 0xFA25, 0xFA25, 0x9038 /* CJK COMPATIBILITY IDEOGRAPH-FA25 */
, 0xFA26, 0xFA26, 0x90FD /* CJK COMPATIBILITY IDEOGRAPH-FA26 */
, 0xFA2A, 0xFA2A, 0x98EF /* CJK COMPATIBILITY IDEOGRAPH-FA2A */
, 0xFA2B, 0xFA2B, 0x98FC /* CJK COMPATIBILITY IDEOGRAPH-FA2B */
, 0xFA2C, 0xFA2C, 0x9928 /* CJK COMPATIBILITY IDEOGRAPH-FA2C */
, 0xFA2D, 0xFA2D, 0x9DB4 /* CJK COMPATIBILITY IDEOGRAPH-FA2D */
, 0xFA30, 0xFA30, 0x4FAE /* CJK COMPATIBILITY IDEOGRAPH-FA30 */
, 0xFA31, 0xFA31, 0x50E7 /* CJK COMPATIBILITY IDEOGRAPH-FA31 */
, 0xFA32, 0xFA32, 0x514D /* CJK COMPATIBILITY IDEOGRAPH-FA32 */
, 0xFA33, 0xFA33, 0x52C9 /* CJK COMPATIBILITY IDEOGRAPH-FA33 */
, 0xFA34, 0xFA34, 0x52E4 /* CJK COMPATIBILITY IDEOGRAPH-FA34 */
, 0xFA35, 0xFA35, 0x5351 /* CJK COMPATIBILITY IDEOGRAPH-FA35 */
, 0xFA36, 0xFA36, 0x559D /* CJK COMPATIBILITY IDEOGRAPH-FA36 */
, 0xFA37, 0xFA37, 0x5606 /* CJK COMPATIBILITY IDEOGRAPH-FA37 */
, 0xFA38, 0xFA38, 0x5668 /* CJK COMPATIBILITY IDEOGRAPH-FA38 */
, 0xFA39, 0xFA39, 0x5840 /* CJK COMPATIBILITY IDEOGRAPH-FA39 */
, 0xFA3A, 0xFA3A, 0x58A8 /* CJK COMPATIBILITY IDEOGRAPH-FA3A */
, 0xFA3B, 0xFA3B, 0x5C64 /* CJK COMPATIBILITY IDEOGRAPH-FA3B */
, 0xFA3C, 0xFA3C, 0x5C6E /* CJK COMPATIBILITY IDEOGRAPH-FA3C */
, 0xFA3D, 0xFA3D, 0x6094 /* CJK COMPATIBILITY IDEOGRAPH-FA3D */
, 0xFA3E, 0xFA3E, 0x6168 /* CJK COMPATIBILITY IDEOGRAPH-FA3E */
, 0xFA3F, 0xFA3F, 0x618E /* CJK COMPATIBILITY IDEOGRAPH-FA3F */
, 0xFA40, 0xFA40, 0x61F2 /* CJK COMPATIBILITY IDEOGRAPH-FA40 */
, 0xFA41, 0xFA41, 0x654F /* CJK COMPATIBILITY IDEOGRAPH-FA41 */
, 0xFA42, 0xFA42, 0x65E2 /* CJK COMPATIBILITY IDEOGRAPH-FA42 */
, 0xFA43, 0xFA43, 0x6691 /* CJK COMPATIBILITY IDEOGRAPH-FA43 */
, 0xFA44, 0xFA44, 0x6885 /* CJK COMPATIBILITY IDEOGRAPH-FA44 */
, 0xFA45, 0xFA45, 0x6D77 /* CJK COMPATIBILITY IDEOGRAPH-FA45 */
, 0xFA46, 0xFA46, 0x6E1A /* CJK COMPATIBILITY IDEOGRAPH-FA46 */
, 0xFA47, 0xFA47, 0x6F22 /* CJK COMPATIBILITY IDEOGRAPH-FA47 */
, 0xFA48, 0xFA48, 0x716E /* CJK COMPATIBILITY IDEOGRAPH-FA48 */
, 0xFA49, 0xFA49, 0x722B /* CJK COMPATIBILITY IDEOGRAPH-FA49 */
, 0xFA4A, 0xFA4A, 0x7422 /* CJK COMPATIBILITY IDEOGRAPH-FA4A */
, 0xFA4B, 0xFA4B, 0x7891 /* CJK COMPATIBILITY IDEOGRAPH-FA4B */
, 0xFA4C, 0xFA4C, 0x793E /* CJK COMPATIBILITY IDEOGRAPH-FA4C */
, 0xFA4D, 0xFA4D, 0x7949 /* CJK COMPATIBILITY IDEOGRAPH-FA4D */
, 0xFA4E, 0xFA4E, 0x7948 /* CJK COMPATIBILITY IDEOGRAPH-FA4E */
, 0xFA4F, 0xFA4F, 0x7950 /* CJK COMPATIBILITY IDEOGRAPH-FA4F */
, 0xFA50, 0xFA50, 0x7956 /* CJK COMPATIBILITY IDEOGRAPH-FA50 */
, 0xFA51, 0xFA51, 0x795D /* CJK COMPATIBILITY IDEOGRAPH-FA51 */
, 0xFA52, 0xFA52, 0x798D /* CJK COMPATIBILITY IDEOGRAPH-FA52 */
, 0xFA53, 0xFA53, 0x798E /* CJK COMPATIBILITY IDEOGRAPH-FA53 */
, 0xFA54, 0xFA54, 0x7A40 /* CJK COMPATIBILITY IDEOGRAPH-FA54 */
, 0xFA55, 0xFA55, 0x7A81 /* CJK COMPATIBILITY IDEOGRAPH-FA55 */
, 0xFA56, 0xFA56, 0x7BC0 /* CJK COMPATIBILITY IDEOGRAPH-FA56 */
, 0xFA57, 0xFA57, 0x7DF4 /* CJK COMPATIBILITY IDEOGRAPH-FA57 */
, 0xFA58, 0xFA58, 0x7E09 /* CJK COMPATIBILITY IDEOGRAPH-FA58 */
, 0xFA59, 0xFA59, 0x7E41 /* CJK COMPATIBILITY IDEOGRAPH-FA59 */
, 0xFA5A, 0xFA5A, 0x7F72 /* CJK COMPATIBILITY IDEOGRAPH-FA5A */
, 0xFA5B, 0xFA5B, 0x8005 /* CJK COMPATIBILITY IDEOGRAPH-FA5B */
, 0xFA5C, 0xFA5C, 0x81ED /* CJK COMPATIBILITY IDEOGRAPH-FA5C */
, 0xFA5D, 0xFA5D, 0x8279 /* CJK COMPATIBILITY IDEOGRAPH-FA5D */
, 0xFA5E, 0xFA5E, 0x8279 /* CJK COMPATIBILITY IDEOGRAPH-FA5E */
, 0xFA5F, 0xFA5F, 0x8457 /* CJK COMPATIBILITY IDEOGRAPH-FA5F */
, 0xFA60, 0xFA60, 0x8910 /* CJK COMPATIBILITY IDEOGRAPH-FA60 */
, 0xFA61, 0xFA61, 0x8996 /* CJK COMPATIBILITY IDEOGRAPH-FA61 */
, 0xFA62, 0xFA62, 0x8B01 /* CJK COMPATIBILITY IDEOGRAPH-FA62 */
, 0xFA63, 0xFA63, 0x8B39 /* CJK COMPATIBILITY IDEOGRAPH-FA63 */
, 0xFA64, 0xFA64, 0x8CD3 /* CJK COMPATIBILITY IDEOGRAPH-FA64 */
, 0xFA65, 0xFA65, 0x8D08 /* CJK COMPATIBILITY IDEOGRAPH-FA65 */
, 0xFA66, 0xFA66, 0x8FB6 /* CJK COMPATIBILITY IDEOGRAPH-FA66 */
, 0xFA67, 0xFA67, 0x9038 /* CJK COMPATIBILITY IDEOGRAPH-FA67 */
, 0xFA68, 0xFA68, 0x96E3 /* CJK COMPATIBILITY IDEOGRAPH-FA68 */
, 0xFA69, 0xFA69, 0x97FF /* CJK COMPATIBILITY IDEOGRAPH-FA69 */
, 0xFA6A, 0xFA6A, 0x983B /* CJK COMPATIBILITY IDEOGRAPH-FA6A */
, 0xFB1D, 0xFB1D, 0x05D9 /* HEBREW LETTER YOD WITH HIRIQ */
, 0xFB1F, 0xFB1F, 0x05F2 /* HEBREW LIGATURE YIDDISH YOD YOD PATAH */
, 0xFB2A, 0xFB2A, 0x05E9 /* HEBREW LETTER SHIN WITH SHIN DOT */
, 0xFB2B, 0xFB2B, 0x05E9 /* HEBREW LETTER SHIN WITH SIN DOT */
, 0xFB2C, 0xFB2C, 0x05E9 /* HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT */
, 0xFB2D, 0xFB2D, 0x05E9 /* HEBREW LETTER SHIN WITH DAGESH AND SIN DOT */
, 0xFB2E, 0xFB2E, 0x05D0 /* HEBREW LETTER ALEF WITH PATAH */
, 0xFB2F, 0xFB2F, 0x05D0 /* HEBREW LETTER ALEF WITH QAMATS */
, 0xFB30, 0xFB30, 0x05D0 /* HEBREW LETTER ALEF WITH MAPIQ */
, 0xFB31, 0xFB31, 0x05D1 /* HEBREW LETTER BET WITH DAGESH */
, 0xFB32, 0xFB32, 0x05D2 /* HEBREW LETTER GIMEL WITH DAGESH */
, 0xFB33, 0xFB33, 0x05D3 /* HEBREW LETTER DALET WITH DAGESH */
, 0xFB34, 0xFB34, 0x05D4 /* HEBREW LETTER HE WITH MAPIQ */
, 0xFB35, 0xFB35, 0x05D5 /* HEBREW LETTER VAV WITH DAGESH */
, 0xFB36, 0xFB36, 0x05D6 /* HEBREW LETTER ZAYIN WITH DAGESH */
, 0xFB38, 0xFB38, 0x05D8 /* HEBREW LETTER TET WITH DAGESH */
, 0xFB39, 0xFB39, 0x05D9 /* HEBREW LETTER YOD WITH DAGESH */
, 0xFB3A, 0xFB3A, 0x05DA /* HEBREW LETTER FINAL KAF WITH DAGESH */
, 0xFB3B, 0xFB3B, 0x05DB /* HEBREW LETTER KAF WITH DAGESH */
, 0xFB3C, 0xFB3C, 0x05DC /* HEBREW LETTER LAMED WITH DAGESH */
, 0xFB3E, 0xFB3E, 0x05DE /* HEBREW LETTER MEM WITH DAGESH */
, 0xFB40, 0xFB40, 0x05E0 /* HEBREW LETTER NUN WITH DAGESH */
, 0xFB41, 0xFB41, 0x05E1 /* HEBREW LETTER SAMEKH WITH DAGESH */
, 0xFB43, 0xFB43, 0x05E3 /* HEBREW LETTER FINAL PE WITH DAGESH */
, 0xFB44, 0xFB44, 0x05E4 /* HEBREW LETTER PE WITH DAGESH */
, 0xFB46, 0xFB46, 0x05E6 /* HEBREW LETTER TSADI WITH DAGESH */
, 0xFB47, 0xFB47, 0x05E7 /* HEBREW LETTER QOF WITH DAGESH */
, 0xFB48, 0xFB48, 0x05E8 /* HEBREW LETTER RESH WITH DAGESH */
, 0xFB49, 0xFB49, 0x05E9 /* HEBREW LETTER SHIN WITH DAGESH */
, 0xFB4A, 0xFB4A, 0x05EA /* HEBREW LETTER TAV WITH DAGESH */
, 0xFB4B, 0xFB4B, 0x05D5 /* HEBREW LETTER VAV WITH HOLAM */
, 0xFB4C, 0xFB4C, 0x05D1 /* HEBREW LETTER BET WITH RAFE */
, 0xFB4D, 0xFB4D, 0x05DB /* HEBREW LETTER KAF WITH RAFE */
, 0xFB4E, 0xFB4E, 0x05E4 /* HEBREW LETTER PE WITH RAFE */
, 0xFF21, 0xFF41, 0xFF21 /* FULLWIDTH LATIN CAPITAL LETTER A */
, 0xFF22, 0xFF42, 0xFF22 /* FULLWIDTH LATIN CAPITAL LETTER B */
, 0xFF23, 0xFF43, 0xFF23 /* FULLWIDTH LATIN CAPITAL LETTER C */
, 0xFF24, 0xFF44, 0xFF24 /* FULLWIDTH LATIN CAPITAL LETTER D */
, 0xFF25, 0xFF45, 0xFF25 /* FULLWIDTH LATIN CAPITAL LETTER E */
, 0xFF26, 0xFF46, 0xFF26 /* FULLWIDTH LATIN CAPITAL LETTER F */
, 0xFF27, 0xFF47, 0xFF27 /* FULLWIDTH LATIN CAPITAL LETTER G */
, 0xFF28, 0xFF48, 0xFF28 /* FULLWIDTH LATIN CAPITAL LETTER H */
, 0xFF29, 0xFF49, 0xFF29 /* FULLWIDTH LATIN CAPITAL LETTER I */
, 0xFF2A, 0xFF4A, 0xFF2A /* FULLWIDTH LATIN CAPITAL LETTER J */
, 0xFF2B, 0xFF4B, 0xFF2B /* FULLWIDTH LATIN CAPITAL LETTER K */
, 0xFF2C, 0xFF4C, 0xFF2C /* FULLWIDTH LATIN CAPITAL LETTER L */
, 0xFF2D, 0xFF4D, 0xFF2D /* FULLWIDTH LATIN CAPITAL LETTER M */
, 0xFF2E, 0xFF4E, 0xFF2E /* FULLWIDTH LATIN CAPITAL LETTER N */
, 0xFF2F, 0xFF4F, 0xFF2F /* FULLWIDTH LATIN CAPITAL LETTER O */
, 0xFF30, 0xFF50, 0xFF30 /* FULLWIDTH LATIN CAPITAL LETTER P */
, 0xFF31, 0xFF51, 0xFF31 /* FULLWIDTH LATIN CAPITAL LETTER Q */
, 0xFF32, 0xFF52, 0xFF32 /* FULLWIDTH LATIN CAPITAL LETTER R */
, 0xFF33, 0xFF53, 0xFF33 /* FULLWIDTH LATIN CAPITAL LETTER S */
, 0xFF34, 0xFF54, 0xFF34 /* FULLWIDTH LATIN CAPITAL LETTER T */
, 0xFF35, 0xFF55, 0xFF35 /* FULLWIDTH LATIN CAPITAL LETTER U */
, 0xFF36, 0xFF56, 0xFF36 /* FULLWIDTH LATIN CAPITAL LETTER V */
, 0xFF37, 0xFF57, 0xFF37 /* FULLWIDTH LATIN CAPITAL LETTER W */
, 0xFF38, 0xFF58, 0xFF38 /* FULLWIDTH LATIN CAPITAL LETTER X */
, 0xFF39, 0xFF59, 0xFF39 /* FULLWIDTH LATIN CAPITAL LETTER Y */
, 0xFF3A, 0xFF5A, 0xFF3A /* FULLWIDTH LATIN CAPITAL LETTER Z */
, 0x10400, 0x10428, 0x10400 /* DESERET CAPITAL LETTER LONG I */
, 0x10401, 0x10429, 0x10401 /* DESERET CAPITAL LETTER LONG E */
, 0x10402, 0x1042A, 0x10402 /* DESERET CAPITAL LETTER LONG A */
, 0x10403, 0x1042B, 0x10403 /* DESERET CAPITAL LETTER LONG AH */
, 0x10404, 0x1042C, 0x10404 /* DESERET CAPITAL LETTER LONG O */
, 0x10405, 0x1042D, 0x10405 /* DESERET CAPITAL LETTER LONG OO */
, 0x10406, 0x1042E, 0x10406 /* DESERET CAPITAL LETTER SHORT I */
, 0x10407, 0x1042F, 0x10407 /* DESERET CAPITAL LETTER SHORT E */
, 0x10408, 0x10430, 0x10408 /* DESERET CAPITAL LETTER SHORT A */
, 0x10409, 0x10431, 0x10409 /* DESERET CAPITAL LETTER SHORT AH */
, 0x1040A, 0x10432, 0x1040A /* DESERET CAPITAL LETTER SHORT O */
, 0x1040B, 0x10433, 0x1040B /* DESERET CAPITAL LETTER SHORT OO */
, 0x1040C, 0x10434, 0x1040C /* DESERET CAPITAL LETTER AY */
, 0x1040D, 0x10435, 0x1040D /* DESERET CAPITAL LETTER OW */
, 0x1040E, 0x10436, 0x1040E /* DESERET CAPITAL LETTER WU */
, 0x1040F, 0x10437, 0x1040F /* DESERET CAPITAL LETTER YEE */
, 0x10410, 0x10438, 0x10410 /* DESERET CAPITAL LETTER H */
, 0x10411, 0x10439, 0x10411 /* DESERET CAPITAL LETTER PEE */
, 0x10412, 0x1043A, 0x10412 /* DESERET CAPITAL LETTER BEE */
, 0x10413, 0x1043B, 0x10413 /* DESERET CAPITAL LETTER TEE */
, 0x10414, 0x1043C, 0x10414 /* DESERET CAPITAL LETTER DEE */
, 0x10415, 0x1043D, 0x10415 /* DESERET CAPITAL LETTER CHEE */
, 0x10416, 0x1043E, 0x10416 /* DESERET CAPITAL LETTER JEE */
, 0x10417, 0x1043F, 0x10417 /* DESERET CAPITAL LETTER KAY */
, 0x10418, 0x10440, 0x10418 /* DESERET CAPITAL LETTER GAY */
, 0x10419, 0x10441, 0x10419 /* DESERET CAPITAL LETTER EF */
, 0x1041A, 0x10442, 0x1041A /* DESERET CAPITAL LETTER VEE */
, 0x1041B, 0x10443, 0x1041B /* DESERET CAPITAL LETTER ETH */
, 0x1041C, 0x10444, 0x1041C /* DESERET CAPITAL LETTER THEE */
, 0x1041D, 0x10445, 0x1041D /* DESERET CAPITAL LETTER ES */
, 0x1041E, 0x10446, 0x1041E /* DESERET CAPITAL LETTER ZEE */
, 0x1041F, 0x10447, 0x1041F /* DESERET CAPITAL LETTER ESH */
, 0x10420, 0x10448, 0x10420 /* DESERET CAPITAL LETTER ZHEE */
, 0x10421, 0x10449, 0x10421 /* DESERET CAPITAL LETTER ER */
, 0x10422, 0x1044A, 0x10422 /* DESERET CAPITAL LETTER EL */
, 0x10423, 0x1044B, 0x10423 /* DESERET CAPITAL LETTER EM */
, 0x10424, 0x1044C, 0x10424 /* DESERET CAPITAL LETTER EN */
, 0x10425, 0x1044D, 0x10425 /* DESERET CAPITAL LETTER ENG */
, 0x10426, 0x1044E, 0x10426 /* DESERET CAPITAL LETTER OI */
, 0x10427, 0x1044F, 0x10427 /* DESERET CAPITAL LETTER EW */
, 0x2F800, 0x2F800, 0x4E3D /* CJK COMPATIBILITY IDEOGRAPH-2F800 */
, 0x2F801, 0x2F801, 0x4E38 /* CJK COMPATIBILITY IDEOGRAPH-2F801 */
, 0x2F802, 0x2F802, 0x4E41 /* CJK COMPATIBILITY IDEOGRAPH-2F802 */
, 0x2F803, 0x2F803, 0x20122 /* CJK COMPATIBILITY IDEOGRAPH-2F803 */
, 0x2F804, 0x2F804, 0x4F60 /* CJK COMPATIBILITY IDEOGRAPH-2F804 */
, 0x2F805, 0x2F805, 0x4FAE /* CJK COMPATIBILITY IDEOGRAPH-2F805 */
, 0x2F806, 0x2F806, 0x4FBB /* CJK COMPATIBILITY IDEOGRAPH-2F806 */
, 0x2F807, 0x2F807, 0x5002 /* CJK COMPATIBILITY IDEOGRAPH-2F807 */
, 0x2F808, 0x2F808, 0x507A /* CJK COMPATIBILITY IDEOGRAPH-2F808 */
, 0x2F809, 0x2F809, 0x5099 /* CJK COMPATIBILITY IDEOGRAPH-2F809 */
, 0x2F80A, 0x2F80A, 0x50E7 /* CJK COMPATIBILITY IDEOGRAPH-2F80A */
, 0x2F80B, 0x2F80B, 0x50CF /* CJK COMPATIBILITY IDEOGRAPH-2F80B */
, 0x2F80C, 0x2F80C, 0x349E /* CJK COMPATIBILITY IDEOGRAPH-2F80C */
, 0x2F80D, 0x2F80D, 0x2063A /* CJK COMPATIBILITY IDEOGRAPH-2F80D */
, 0x2F80E, 0x2F80E, 0x514D /* CJK COMPATIBILITY IDEOGRAPH-2F80E */
, 0x2F80F, 0x2F80F, 0x5154 /* CJK COMPATIBILITY IDEOGRAPH-2F80F */
, 0x2F810, 0x2F810, 0x5164 /* CJK COMPATIBILITY IDEOGRAPH-2F810 */
, 0x2F811, 0x2F811, 0x5177 /* CJK COMPATIBILITY IDEOGRAPH-2F811 */
, 0x2F812, 0x2F812, 0x2051C /* CJK COMPATIBILITY IDEOGRAPH-2F812 */
, 0x2F813, 0x2F813, 0x34B9 /* CJK COMPATIBILITY IDEOGRAPH-2F813 */
, 0x2F814, 0x2F814, 0x5167 /* CJK COMPATIBILITY IDEOGRAPH-2F814 */
, 0x2F815, 0x2F815, 0x518D /* CJK COMPATIBILITY IDEOGRAPH-2F815 */
, 0x2F816, 0x2F816, 0x2054B /* CJK COMPATIBILITY IDEOGRAPH-2F816 */
, 0x2F817, 0x2F817, 0x5197 /* CJK COMPATIBILITY IDEOGRAPH-2F817 */
, 0x2F818, 0x2F818, 0x51A4 /* CJK COMPATIBILITY IDEOGRAPH-2F818 */
, 0x2F819, 0x2F819, 0x4ECC /* CJK COMPATIBILITY IDEOGRAPH-2F819 */
, 0x2F81A, 0x2F81A, 0x51AC /* CJK COMPATIBILITY IDEOGRAPH-2F81A */
, 0x2F81B, 0x2F81B, 0x51B5 /* CJK COMPATIBILITY IDEOGRAPH-2F81B */
, 0x2F81C, 0x2F81C, 0x291DF /* CJK COMPATIBILITY IDEOGRAPH-2F81C */
, 0x2F81D, 0x2F81D, 0x51F5 /* CJK COMPATIBILITY IDEOGRAPH-2F81D */
, 0x2F81E, 0x2F81E, 0x5203 /* CJK COMPATIBILITY IDEOGRAPH-2F81E */
, 0x2F81F, 0x2F81F, 0x34DF /* CJK COMPATIBILITY IDEOGRAPH-2F81F */
, 0x2F820, 0x2F820, 0x523B /* CJK COMPATIBILITY IDEOGRAPH-2F820 */
, 0x2F821, 0x2F821, 0x5246 /* CJK COMPATIBILITY IDEOGRAPH-2F821 */
, 0x2F822, 0x2F822, 0x5272 /* CJK COMPATIBILITY IDEOGRAPH-2F822 */
, 0x2F823, 0x2F823, 0x5277 /* CJK COMPATIBILITY IDEOGRAPH-2F823 */
, 0x2F824, 0x2F824, 0x3515 /* CJK COMPATIBILITY IDEOGRAPH-2F824 */
, 0x2F825, 0x2F825, 0x52C7 /* CJK COMPATIBILITY IDEOGRAPH-2F825 */
, 0x2F826, 0x2F826, 0x52C9 /* CJK COMPATIBILITY IDEOGRAPH-2F826 */
, 0x2F827, 0x2F827, 0x52E4 /* CJK COMPATIBILITY IDEOGRAPH-2F827 */
, 0x2F828, 0x2F828, 0x52FA /* CJK COMPATIBILITY IDEOGRAPH-2F828 */
, 0x2F829, 0x2F829, 0x5305 /* CJK COMPATIBILITY IDEOGRAPH-2F829 */
, 0x2F82A, 0x2F82A, 0x5306 /* CJK COMPATIBILITY IDEOGRAPH-2F82A */
, 0x2F82B, 0x2F82B, 0x5317 /* CJK COMPATIBILITY IDEOGRAPH-2F82B */
, 0x2F82C, 0x2F82C, 0x5349 /* CJK COMPATIBILITY IDEOGRAPH-2F82C */
, 0x2F82D, 0x2F82D, 0x5351 /* CJK COMPATIBILITY IDEOGRAPH-2F82D */
, 0x2F82E, 0x2F82E, 0x535A /* CJK COMPATIBILITY IDEOGRAPH-2F82E */
, 0x2F82F, 0x2F82F, 0x5373 /* CJK COMPATIBILITY IDEOGRAPH-2F82F */
, 0x2F830, 0x2F830, 0x537D /* CJK COMPATIBILITY IDEOGRAPH-2F830 */
, 0x2F831, 0x2F831, 0x537F /* CJK COMPATIBILITY IDEOGRAPH-2F831 */
, 0x2F832, 0x2F832, 0x537F /* CJK COMPATIBILITY IDEOGRAPH-2F832 */
, 0x2F833, 0x2F833, 0x537F /* CJK COMPATIBILITY IDEOGRAPH-2F833 */
, 0x2F834, 0x2F834, 0x20A2C /* CJK COMPATIBILITY IDEOGRAPH-2F834 */
, 0x2F835, 0x2F835, 0x7070 /* CJK COMPATIBILITY IDEOGRAPH-2F835 */
, 0x2F836, 0x2F836, 0x53CA /* CJK COMPATIBILITY IDEOGRAPH-2F836 */
, 0x2F837, 0x2F837, 0x53DF /* CJK COMPATIBILITY IDEOGRAPH-2F837 */
, 0x2F838, 0x2F838, 0x20B63 /* CJK COMPATIBILITY IDEOGRAPH-2F838 */
, 0x2F839, 0x2F839, 0x53EB /* CJK COMPATIBILITY IDEOGRAPH-2F839 */
, 0x2F83A, 0x2F83A, 0x53F1 /* CJK COMPATIBILITY IDEOGRAPH-2F83A */
, 0x2F83B, 0x2F83B, 0x5406 /* CJK COMPATIBILITY IDEOGRAPH-2F83B */
, 0x2F83C, 0x2F83C, 0x549E /* CJK COMPATIBILITY IDEOGRAPH-2F83C */
, 0x2F83D, 0x2F83D, 0x5438 /* CJK COMPATIBILITY IDEOGRAPH-2F83D */
, 0x2F83E, 0x2F83E, 0x5448 /* CJK COMPATIBILITY IDEOGRAPH-2F83E */
, 0x2F83F, 0x2F83F, 0x5468 /* CJK COMPATIBILITY IDEOGRAPH-2F83F */
, 0x2F840, 0x2F840, 0x54A2 /* CJK COMPATIBILITY IDEOGRAPH-2F840 */
, 0x2F841, 0x2F841, 0x54F6 /* CJK COMPATIBILITY IDEOGRAPH-2F841 */
, 0x2F842, 0x2F842, 0x5510 /* CJK COMPATIBILITY IDEOGRAPH-2F842 */
, 0x2F843, 0x2F843, 0x5553 /* CJK COMPATIBILITY IDEOGRAPH-2F843 */
, 0x2F844, 0x2F844, 0x5563 /* CJK COMPATIBILITY IDEOGRAPH-2F844 */
, 0x2F845, 0x2F845, 0x5584 /* CJK COMPATIBILITY IDEOGRAPH-2F845 */
, 0x2F846, 0x2F846, 0x5584 /* CJK COMPATIBILITY IDEOGRAPH-2F846 */
, 0x2F847, 0x2F847, 0x5599 /* CJK COMPATIBILITY IDEOGRAPH-2F847 */
, 0x2F848, 0x2F848, 0x55AB /* CJK COMPATIBILITY IDEOGRAPH-2F848 */
, 0x2F849, 0x2F849, 0x55B3 /* CJK COMPATIBILITY IDEOGRAPH-2F849 */
, 0x2F84A, 0x2F84A, 0x55C2 /* CJK COMPATIBILITY IDEOGRAPH-2F84A */
, 0x2F84B, 0x2F84B, 0x5716 /* CJK COMPATIBILITY IDEOGRAPH-2F84B */
, 0x2F84C, 0x2F84C, 0x5606 /* CJK COMPATIBILITY IDEOGRAPH-2F84C */
, 0x2F84D, 0x2F84D, 0x5717 /* CJK COMPATIBILITY IDEOGRAPH-2F84D */
, 0x2F84E, 0x2F84E, 0x5651 /* CJK COMPATIBILITY IDEOGRAPH-2F84E */
, 0x2F84F, 0x2F84F, 0x5674 /* CJK COMPATIBILITY IDEOGRAPH-2F84F */
, 0x2F850, 0x2F850, 0x5207 /* CJK COMPATIBILITY IDEOGRAPH-2F850 */
, 0x2F851, 0x2F851, 0x58EE /* CJK COMPATIBILITY IDEOGRAPH-2F851 */
, 0x2F852, 0x2F852, 0x57CE /* CJK COMPATIBILITY IDEOGRAPH-2F852 */
, 0x2F853, 0x2F853, 0x57F4 /* CJK COMPATIBILITY IDEOGRAPH-2F853 */
, 0x2F854, 0x2F854, 0x580D /* CJK COMPATIBILITY IDEOGRAPH-2F854 */
, 0x2F855, 0x2F855, 0x578B /* CJK COMPATIBILITY IDEOGRAPH-2F855 */
, 0x2F856, 0x2F856, 0x5832 /* CJK COMPATIBILITY IDEOGRAPH-2F856 */
, 0x2F857, 0x2F857, 0x5831 /* CJK COMPATIBILITY IDEOGRAPH-2F857 */
, 0x2F858, 0x2F858, 0x58AC /* CJK COMPATIBILITY IDEOGRAPH-2F858 */
, 0x2F859, 0x2F859, 0x214E4 /* CJK COMPATIBILITY IDEOGRAPH-2F859 */
, 0x2F85A, 0x2F85A, 0x58F2 /* CJK COMPATIBILITY IDEOGRAPH-2F85A */
, 0x2F85B, 0x2F85B, 0x58F7 /* CJK COMPATIBILITY IDEOGRAPH-2F85B */
, 0x2F85C, 0x2F85C, 0x5906 /* CJK COMPATIBILITY IDEOGRAPH-2F85C */
, 0x2F85D, 0x2F85D, 0x591A /* CJK COMPATIBILITY IDEOGRAPH-2F85D */
, 0x2F85E, 0x2F85E, 0x5922 /* CJK COMPATIBILITY IDEOGRAPH-2F85E */
, 0x2F85F, 0x2F85F, 0x5962 /* CJK COMPATIBILITY IDEOGRAPH-2F85F */
, 0x2F860, 0x2F860, 0x216A8 /* CJK COMPATIBILITY IDEOGRAPH-2F860 */
, 0x2F861, 0x2F861, 0x216EA /* CJK COMPATIBILITY IDEOGRAPH-2F861 */
, 0x2F862, 0x2F862, 0x59EC /* CJK COMPATIBILITY IDEOGRAPH-2F862 */
, 0x2F863, 0x2F863, 0x5A1B /* CJK COMPATIBILITY IDEOGRAPH-2F863 */
, 0x2F864, 0x2F864, 0x5A27 /* CJK COMPATIBILITY IDEOGRAPH-2F864 */
, 0x2F865, 0x2F865, 0x59D8 /* CJK COMPATIBILITY IDEOGRAPH-2F865 */
, 0x2F866, 0x2F866, 0x5A66 /* CJK COMPATIBILITY IDEOGRAPH-2F866 */
, 0x2F867, 0x2F867, 0x36EE /* CJK COMPATIBILITY IDEOGRAPH-2F867 */
, 0x2F868, 0x2F868, 0x36FC /* CJK COMPATIBILITY IDEOGRAPH-2F868 */
, 0x2F869, 0x2F869, 0x5B08 /* CJK COMPATIBILITY IDEOGRAPH-2F869 */
, 0x2F86A, 0x2F86A, 0x5B3E /* CJK COMPATIBILITY IDEOGRAPH-2F86A */
, 0x2F86B, 0x2F86B, 0x5B3E /* CJK COMPATIBILITY IDEOGRAPH-2F86B */
, 0x2F86C, 0x2F86C, 0x219C8 /* CJK COMPATIBILITY IDEOGRAPH-2F86C */
, 0x2F86D, 0x2F86D, 0x5BC3 /* CJK COMPATIBILITY IDEOGRAPH-2F86D */
, 0x2F86E, 0x2F86E, 0x5BD8 /* CJK COMPATIBILITY IDEOGRAPH-2F86E */
, 0x2F86F, 0x2F86F, 0x5BE7 /* CJK COMPATIBILITY IDEOGRAPH-2F86F */
, 0x2F870, 0x2F870, 0x5BF3 /* CJK COMPATIBILITY IDEOGRAPH-2F870 */
, 0x2F871, 0x2F871, 0x21B18 /* CJK COMPATIBILITY IDEOGRAPH-2F871 */
, 0x2F872, 0x2F872, 0x5BFF /* CJK COMPATIBILITY IDEOGRAPH-2F872 */
, 0x2F873, 0x2F873, 0x5C06 /* CJK COMPATIBILITY IDEOGRAPH-2F873 */
, 0x2F874, 0x2F874, 0x5F53 /* CJK COMPATIBILITY IDEOGRAPH-2F874 */
, 0x2F875, 0x2F875, 0x5C22 /* CJK COMPATIBILITY IDEOGRAPH-2F875 */
, 0x2F876, 0x2F876, 0x3781 /* CJK COMPATIBILITY IDEOGRAPH-2F876 */
, 0x2F877, 0x2F877, 0x5C60 /* CJK COMPATIBILITY IDEOGRAPH-2F877 */
, 0x2F878, 0x2F878, 0x5C6E /* CJK COMPATIBILITY IDEOGRAPH-2F878 */
, 0x2F879, 0x2F879, 0x5CC0 /* CJK COMPATIBILITY IDEOGRAPH-2F879 */
, 0x2F87A, 0x2F87A, 0x5C8D /* CJK COMPATIBILITY IDEOGRAPH-2F87A */
, 0x2F87B, 0x2F87B, 0x21DE4 /* CJK COMPATIBILITY IDEOGRAPH-2F87B */
, 0x2F87C, 0x2F87C, 0x5D43 /* CJK COMPATIBILITY IDEOGRAPH-2F87C */
, 0x2F87D, 0x2F87D, 0x21DE6 /* CJK COMPATIBILITY IDEOGRAPH-2F87D */
, 0x2F87E, 0x2F87E, 0x5D6E /* CJK COMPATIBILITY IDEOGRAPH-2F87E */
, 0x2F87F, 0x2F87F, 0x5D6B /* CJK COMPATIBILITY IDEOGRAPH-2F87F */
, 0x2F880, 0x2F880, 0x5D7C /* CJK COMPATIBILITY IDEOGRAPH-2F880 */
, 0x2F881, 0x2F881, 0x5DE1 /* CJK COMPATIBILITY IDEOGRAPH-2F881 */
, 0x2F882, 0x2F882, 0x5DE2 /* CJK COMPATIBILITY IDEOGRAPH-2F882 */
, 0x2F883, 0x2F883, 0x382F /* CJK COMPATIBILITY IDEOGRAPH-2F883 */
, 0x2F884, 0x2F884, 0x5DFD /* CJK COMPATIBILITY IDEOGRAPH-2F884 */
, 0x2F885, 0x2F885, 0x5E28 /* CJK COMPATIBILITY IDEOGRAPH-2F885 */
, 0x2F886, 0x2F886, 0x5E3D /* CJK COMPATIBILITY IDEOGRAPH-2F886 */
, 0x2F887, 0x2F887, 0x5E69 /* CJK COMPATIBILITY IDEOGRAPH-2F887 */
, 0x2F888, 0x2F888, 0x3862 /* CJK COMPATIBILITY IDEOGRAPH-2F888 */
, 0x2F889, 0x2F889, 0x22183 /* CJK COMPATIBILITY IDEOGRAPH-2F889 */
, 0x2F88A, 0x2F88A, 0x387C /* CJK COMPATIBILITY IDEOGRAPH-2F88A */
, 0x2F88B, 0x2F88B, 0x5EB0 /* CJK COMPATIBILITY IDEOGRAPH-2F88B */
, 0x2F88C, 0x2F88C, 0x5EB3 /* CJK COMPATIBILITY IDEOGRAPH-2F88C */
, 0x2F88D, 0x2F88D, 0x5EB6 /* CJK COMPATIBILITY IDEOGRAPH-2F88D */
, 0x2F88E, 0x2F88E, 0x5ECA /* CJK COMPATIBILITY IDEOGRAPH-2F88E */
, 0x2F88F, 0x2F88F, 0x2A392 /* CJK COMPATIBILITY IDEOGRAPH-2F88F */
, 0x2F890, 0x2F890, 0x5EFE /* CJK COMPATIBILITY IDEOGRAPH-2F890 */
, 0x2F891, 0x2F891, 0x22331 /* CJK COMPATIBILITY IDEOGRAPH-2F891 */
, 0x2F892, 0x2F892, 0x22331 /* CJK COMPATIBILITY IDEOGRAPH-2F892 */
, 0x2F893, 0x2F893, 0x8201 /* CJK COMPATIBILITY IDEOGRAPH-2F893 */
, 0x2F894, 0x2F894, 0x5F22 /* CJK COMPATIBILITY IDEOGRAPH-2F894 */
, 0x2F895, 0x2F895, 0x5F22 /* CJK COMPATIBILITY IDEOGRAPH-2F895 */
, 0x2F896, 0x2F896, 0x38C7 /* CJK COMPATIBILITY IDEOGRAPH-2F896 */
, 0x2F897, 0x2F897, 0x232B8 /* CJK COMPATIBILITY IDEOGRAPH-2F897 */
, 0x2F898, 0x2F898, 0x261DA /* CJK COMPATIBILITY IDEOGRAPH-2F898 */
, 0x2F899, 0x2F899, 0x5F62 /* CJK COMPATIBILITY IDEOGRAPH-2F899 */
, 0x2F89A, 0x2F89A, 0x5F6B /* CJK COMPATIBILITY IDEOGRAPH-2F89A */
, 0x2F89B, 0x2F89B, 0x38E3 /* CJK COMPATIBILITY IDEOGRAPH-2F89B */
, 0x2F89C, 0x2F89C, 0x5F9A /* CJK COMPATIBILITY IDEOGRAPH-2F89C */
, 0x2F89D, 0x2F89D, 0x5FCD /* CJK COMPATIBILITY IDEOGRAPH-2F89D */
, 0x2F89E, 0x2F89E, 0x5FD7 /* CJK COMPATIBILITY IDEOGRAPH-2F89E */
, 0x2F89F, 0x2F89F, 0x5FF9 /* CJK COMPATIBILITY IDEOGRAPH-2F89F */
, 0x2F8A0, 0x2F8A0, 0x6081 /* CJK COMPATIBILITY IDEOGRAPH-2F8A0 */
, 0x2F8A1, 0x2F8A1, 0x393A /* CJK COMPATIBILITY IDEOGRAPH-2F8A1 */
, 0x2F8A2, 0x2F8A2, 0x391C /* CJK COMPATIBILITY IDEOGRAPH-2F8A2 */
, 0x2F8A3, 0x2F8A3, 0x6094 /* CJK COMPATIBILITY IDEOGRAPH-2F8A3 */
, 0x2F8A4, 0x2F8A4, 0x226D4 /* CJK COMPATIBILITY IDEOGRAPH-2F8A4 */
, 0x2F8A5, 0x2F8A5, 0x60C7 /* CJK COMPATIBILITY IDEOGRAPH-2F8A5 */
, 0x2F8A6, 0x2F8A6, 0x6148 /* CJK COMPATIBILITY IDEOGRAPH-2F8A6 */
, 0x2F8A7, 0x2F8A7, 0x614C /* CJK COMPATIBILITY IDEOGRAPH-2F8A7 */
, 0x2F8A8, 0x2F8A8, 0x614E /* CJK COMPATIBILITY IDEOGRAPH-2F8A8 */
, 0x2F8A9, 0x2F8A9, 0x614C /* CJK COMPATIBILITY IDEOGRAPH-2F8A9 */
, 0x2F8AA, 0x2F8AA, 0x617A /* CJK COMPATIBILITY IDEOGRAPH-2F8AA */
, 0x2F8AB, 0x2F8AB, 0x618E /* CJK COMPATIBILITY IDEOGRAPH-2F8AB */
, 0x2F8AC, 0x2F8AC, 0x61B2 /* CJK COMPATIBILITY IDEOGRAPH-2F8AC */
, 0x2F8AD, 0x2F8AD, 0x61A4 /* CJK COMPATIBILITY IDEOGRAPH-2F8AD */
, 0x2F8AE, 0x2F8AE, 0x61AF /* CJK COMPATIBILITY IDEOGRAPH-2F8AE */
, 0x2F8AF, 0x2F8AF, 0x61DE /* CJK COMPATIBILITY IDEOGRAPH-2F8AF */
, 0x2F8B0, 0x2F8B0, 0x61F2 /* CJK COMPATIBILITY IDEOGRAPH-2F8B0 */
, 0x2F8B1, 0x2F8B1, 0x61F6 /* CJK COMPATIBILITY IDEOGRAPH-2F8B1 */
, 0x2F8B2, 0x2F8B2, 0x6210 /* CJK COMPATIBILITY IDEOGRAPH-2F8B2 */
, 0x2F8B3, 0x2F8B3, 0x621B /* CJK COMPATIBILITY IDEOGRAPH-2F8B3 */
, 0x2F8B4, 0x2F8B4, 0x625D /* CJK COMPATIBILITY IDEOGRAPH-2F8B4 */
, 0x2F8B5, 0x2F8B5, 0x62B1 /* CJK COMPATIBILITY IDEOGRAPH-2F8B5 */
, 0x2F8B6, 0x2F8B6, 0x62D4 /* CJK COMPATIBILITY IDEOGRAPH-2F8B6 */
, 0x2F8B7, 0x2F8B7, 0x6350 /* CJK COMPATIBILITY IDEOGRAPH-2F8B7 */
, 0x2F8B8, 0x2F8B8, 0x22B0C /* CJK COMPATIBILITY IDEOGRAPH-2F8B8 */
, 0x2F8B9, 0x2F8B9, 0x633D /* CJK COMPATIBILITY IDEOGRAPH-2F8B9 */
, 0x2F8BA, 0x2F8BA, 0x62FC /* CJK COMPATIBILITY IDEOGRAPH-2F8BA */
, 0x2F8BB, 0x2F8BB, 0x6368 /* CJK COMPATIBILITY IDEOGRAPH-2F8BB */
, 0x2F8BC, 0x2F8BC, 0x6383 /* CJK COMPATIBILITY IDEOGRAPH-2F8BC */
, 0x2F8BD, 0x2F8BD, 0x63E4 /* CJK COMPATIBILITY IDEOGRAPH-2F8BD */
, 0x2F8BE, 0x2F8BE, 0x22BF1 /* CJK COMPATIBILITY IDEOGRAPH-2F8BE */
, 0x2F8BF, 0x2F8BF, 0x6422 /* CJK COMPATIBILITY IDEOGRAPH-2F8BF */
, 0x2F8C0, 0x2F8C0, 0x63C5 /* CJK COMPATIBILITY IDEOGRAPH-2F8C0 */
, 0x2F8C1, 0x2F8C1, 0x63A9 /* CJK COMPATIBILITY IDEOGRAPH-2F8C1 */
, 0x2F8C2, 0x2F8C2, 0x3A2E /* CJK COMPATIBILITY IDEOGRAPH-2F8C2 */
, 0x2F8C3, 0x2F8C3, 0x6469 /* CJK COMPATIBILITY IDEOGRAPH-2F8C3 */
, 0x2F8C4, 0x2F8C4, 0x647E /* CJK COMPATIBILITY IDEOGRAPH-2F8C4 */
, 0x2F8C5, 0x2F8C5, 0x649D /* CJK COMPATIBILITY IDEOGRAPH-2F8C5 */
, 0x2F8C6, 0x2F8C6, 0x6477 /* CJK COMPATIBILITY IDEOGRAPH-2F8C6 */
, 0x2F8C7, 0x2F8C7, 0x3A6C /* CJK COMPATIBILITY IDEOGRAPH-2F8C7 */
, 0x2F8C8, 0x2F8C8, 0x654F /* CJK COMPATIBILITY IDEOGRAPH-2F8C8 */
, 0x2F8C9, 0x2F8C9, 0x656C /* CJK COMPATIBILITY IDEOGRAPH-2F8C9 */
, 0x2F8CA, 0x2F8CA, 0x2300A /* CJK COMPATIBILITY IDEOGRAPH-2F8CA */
, 0x2F8CB, 0x2F8CB, 0x65E3 /* CJK COMPATIBILITY IDEOGRAPH-2F8CB */
, 0x2F8CC, 0x2F8CC, 0x66F8 /* CJK COMPATIBILITY IDEOGRAPH-2F8CC */
, 0x2F8CD, 0x2F8CD, 0x6649 /* CJK COMPATIBILITY IDEOGRAPH-2F8CD */
, 0x2F8CE, 0x2F8CE, 0x3B19 /* CJK COMPATIBILITY IDEOGRAPH-2F8CE */
, 0x2F8CF, 0x2F8CF, 0x6691 /* CJK COMPATIBILITY IDEOGRAPH-2F8CF */
, 0x2F8D0, 0x2F8D0, 0x3B08 /* CJK COMPATIBILITY IDEOGRAPH-2F8D0 */
, 0x2F8D1, 0x2F8D1, 0x3AE4 /* CJK COMPATIBILITY IDEOGRAPH-2F8D1 */
, 0x2F8D2, 0x2F8D2, 0x5192 /* CJK COMPATIBILITY IDEOGRAPH-2F8D2 */
, 0x2F8D3, 0x2F8D3, 0x5195 /* CJK COMPATIBILITY IDEOGRAPH-2F8D3 */
, 0x2F8D4, 0x2F8D4, 0x6700 /* CJK COMPATIBILITY IDEOGRAPH-2F8D4 */
, 0x2F8D5, 0x2F8D5, 0x669C /* CJK COMPATIBILITY IDEOGRAPH-2F8D5 */
, 0x2F8D6, 0x2F8D6, 0x80AD /* CJK COMPATIBILITY IDEOGRAPH-2F8D6 */
, 0x2F8D7, 0x2F8D7, 0x43D9 /* CJK COMPATIBILITY IDEOGRAPH-2F8D7 */
, 0x2F8D8, 0x2F8D8, 0x6717 /* CJK COMPATIBILITY IDEOGRAPH-2F8D8 */
, 0x2F8D9, 0x2F8D9, 0x671B /* CJK COMPATIBILITY IDEOGRAPH-2F8D9 */
, 0x2F8DA, 0x2F8DA, 0x6721 /* CJK COMPATIBILITY IDEOGRAPH-2F8DA */
, 0x2F8DB, 0x2F8DB, 0x675E /* CJK COMPATIBILITY IDEOGRAPH-2F8DB */
, 0x2F8DC, 0x2F8DC, 0x6753 /* CJK COMPATIBILITY IDEOGRAPH-2F8DC */
, 0x2F8DD, 0x2F8DD, 0x233C3 /* CJK COMPATIBILITY IDEOGRAPH-2F8DD */
, 0x2F8DE, 0x2F8DE, 0x3B49 /* CJK COMPATIBILITY IDEOGRAPH-2F8DE */
, 0x2F8DF, 0x2F8DF, 0x67FA /* CJK COMPATIBILITY IDEOGRAPH-2F8DF */
, 0x2F8E0, 0x2F8E0, 0x6785 /* CJK COMPATIBILITY IDEOGRAPH-2F8E0 */
, 0x2F8E1, 0x2F8E1, 0x6852 /* CJK COMPATIBILITY IDEOGRAPH-2F8E1 */
, 0x2F8E2, 0x2F8E2, 0x6885 /* CJK COMPATIBILITY IDEOGRAPH-2F8E2 */
, 0x2F8E3, 0x2F8E3, 0x2346D /* CJK COMPATIBILITY IDEOGRAPH-2F8E3 */
, 0x2F8E4, 0x2F8E4, 0x688E /* CJK COMPATIBILITY IDEOGRAPH-2F8E4 */
, 0x2F8E5, 0x2F8E5, 0x681F /* CJK COMPATIBILITY IDEOGRAPH-2F8E5 */
, 0x2F8E6, 0x2F8E6, 0x6914 /* CJK COMPATIBILITY IDEOGRAPH-2F8E6 */
, 0x2F8E7, 0x2F8E7, 0x3B9D /* CJK COMPATIBILITY IDEOGRAPH-2F8E7 */
, 0x2F8E8, 0x2F8E8, 0x6942 /* CJK COMPATIBILITY IDEOGRAPH-2F8E8 */
, 0x2F8E9, 0x2F8E9, 0x69A3 /* CJK COMPATIBILITY IDEOGRAPH-2F8E9 */
, 0x2F8EA, 0x2F8EA, 0x69EA /* CJK COMPATIBILITY IDEOGRAPH-2F8EA */
, 0x2F8EB, 0x2F8EB, 0x6AA8 /* CJK COMPATIBILITY IDEOGRAPH-2F8EB */
, 0x2F8EC, 0x2F8EC, 0x236A3 /* CJK COMPATIBILITY IDEOGRAPH-2F8EC */
, 0x2F8ED, 0x2F8ED, 0x6ADB /* CJK COMPATIBILITY IDEOGRAPH-2F8ED */
, 0x2F8EE, 0x2F8EE, 0x3C18 /* CJK COMPATIBILITY IDEOGRAPH-2F8EE */
, 0x2F8EF, 0x2F8EF, 0x6B21 /* CJK COMPATIBILITY IDEOGRAPH-2F8EF */
, 0x2F8F0, 0x2F8F0, 0x238A7 /* CJK COMPATIBILITY IDEOGRAPH-2F8F0 */
, 0x2F8F1, 0x2F8F1, 0x6B54 /* CJK COMPATIBILITY IDEOGRAPH-2F8F1 */
, 0x2F8F2, 0x2F8F2, 0x3C4E /* CJK COMPATIBILITY IDEOGRAPH-2F8F2 */
, 0x2F8F3, 0x2F8F3, 0x6B72 /* CJK COMPATIBILITY IDEOGRAPH-2F8F3 */
, 0x2F8F4, 0x2F8F4, 0x6B9F /* CJK COMPATIBILITY IDEOGRAPH-2F8F4 */
, 0x2F8F5, 0x2F8F5, 0x6BBA /* CJK COMPATIBILITY IDEOGRAPH-2F8F5 */
, 0x2F8F6, 0x2F8F6, 0x6BBB /* CJK COMPATIBILITY IDEOGRAPH-2F8F6 */
, 0x2F8F7, 0x2F8F7, 0x23A8D /* CJK COMPATIBILITY IDEOGRAPH-2F8F7 */
, 0x2F8F8, 0x2F8F8, 0x21D0B /* CJK COMPATIBILITY IDEOGRAPH-2F8F8 */
, 0x2F8F9, 0x2F8F9, 0x23AFA /* CJK COMPATIBILITY IDEOGRAPH-2F8F9 */
, 0x2F8FA, 0x2F8FA, 0x6C4E /* CJK COMPATIBILITY IDEOGRAPH-2F8FA */
, 0x2F8FB, 0x2F8FB, 0x23CBC /* CJK COMPATIBILITY IDEOGRAPH-2F8FB */
, 0x2F8FC, 0x2F8FC, 0x6CBF /* CJK COMPATIBILITY IDEOGRAPH-2F8FC */
, 0x2F8FD, 0x2F8FD, 0x6CCD /* CJK COMPATIBILITY IDEOGRAPH-2F8FD */
, 0x2F8FE, 0x2F8FE, 0x6C67 /* CJK COMPATIBILITY IDEOGRAPH-2F8FE */
, 0x2F8FF, 0x2F8FF, 0x6D16 /* CJK COMPATIBILITY IDEOGRAPH-2F8FF */
, 0x2F900, 0x2F900, 0x6D3E /* CJK COMPATIBILITY IDEOGRAPH-2F900 */
, 0x2F901, 0x2F901, 0x6D77 /* CJK COMPATIBILITY IDEOGRAPH-2F901 */
, 0x2F902, 0x2F902, 0x6D41 /* CJK COMPATIBILITY IDEOGRAPH-2F902 */
, 0x2F903, 0x2F903, 0x6D69 /* CJK COMPATIBILITY IDEOGRAPH-2F903 */
, 0x2F904, 0x2F904, 0x6D78 /* CJK COMPATIBILITY IDEOGRAPH-2F904 */
, 0x2F905, 0x2F905, 0x6D85 /* CJK COMPATIBILITY IDEOGRAPH-2F905 */
, 0x2F906, 0x2F906, 0x23D1E /* CJK COMPATIBILITY IDEOGRAPH-2F906 */
, 0x2F907, 0x2F907, 0x6D34 /* CJK COMPATIBILITY IDEOGRAPH-2F907 */
, 0x2F908, 0x2F908, 0x6E2F /* CJK COMPATIBILITY IDEOGRAPH-2F908 */
, 0x2F909, 0x2F909, 0x6E6E /* CJK COMPATIBILITY IDEOGRAPH-2F909 */
, 0x2F90A, 0x2F90A, 0x3D33 /* CJK COMPATIBILITY IDEOGRAPH-2F90A */
, 0x2F90B, 0x2F90B, 0x6ECB /* CJK COMPATIBILITY IDEOGRAPH-2F90B */
, 0x2F90C, 0x2F90C, 0x6EC7 /* CJK COMPATIBILITY IDEOGRAPH-2F90C */
, 0x2F90D, 0x2F90D, 0x23ED1 /* CJK COMPATIBILITY IDEOGRAPH-2F90D */
, 0x2F90E, 0x2F90E, 0x6DF9 /* CJK COMPATIBILITY IDEOGRAPH-2F90E */
, 0x2F90F, 0x2F90F, 0x6F6E /* CJK COMPATIBILITY IDEOGRAPH-2F90F */
, 0x2F910, 0x2F910, 0x23F5E /* CJK COMPATIBILITY IDEOGRAPH-2F910 */
, 0x2F911, 0x2F911, 0x23F8E /* CJK COMPATIBILITY IDEOGRAPH-2F911 */
, 0x2F912, 0x2F912, 0x6FC6 /* CJK COMPATIBILITY IDEOGRAPH-2F912 */
, 0x2F913, 0x2F913, 0x7039 /* CJK COMPATIBILITY IDEOGRAPH-2F913 */
, 0x2F914, 0x2F914, 0x701E /* CJK COMPATIBILITY IDEOGRAPH-2F914 */
, 0x2F915, 0x2F915, 0x701B /* CJK COMPATIBILITY IDEOGRAPH-2F915 */
, 0x2F916, 0x2F916, 0x3D96 /* CJK COMPATIBILITY IDEOGRAPH-2F916 */
, 0x2F917, 0x2F917, 0x704A /* CJK COMPATIBILITY IDEOGRAPH-2F917 */
, 0x2F918, 0x2F918, 0x707D /* CJK COMPATIBILITY IDEOGRAPH-2F918 */
, 0x2F919, 0x2F919, 0x7077 /* CJK COMPATIBILITY IDEOGRAPH-2F919 */
, 0x2F91A, 0x2F91A, 0x70AD /* CJK COMPATIBILITY IDEOGRAPH-2F91A */
, 0x2F91B, 0x2F91B, 0x20525 /* CJK COMPATIBILITY IDEOGRAPH-2F91B */
, 0x2F91C, 0x2F91C, 0x7145 /* CJK COMPATIBILITY IDEOGRAPH-2F91C */
, 0x2F91D, 0x2F91D, 0x24263 /* CJK COMPATIBILITY IDEOGRAPH-2F91D */
, 0x2F91E, 0x2F91E, 0x719C /* CJK COMPATIBILITY IDEOGRAPH-2F91E */
, 0x2F91F, 0x2F91F, 0x243AB /* CJK COMPATIBILITY IDEOGRAPH-2F91F */
, 0x2F920, 0x2F920, 0x7228 /* CJK COMPATIBILITY IDEOGRAPH-2F920 */
, 0x2F921, 0x2F921, 0x7235 /* CJK COMPATIBILITY IDEOGRAPH-2F921 */
, 0x2F922, 0x2F922, 0x7250 /* CJK COMPATIBILITY IDEOGRAPH-2F922 */
, 0x2F923, 0x2F923, 0x24608 /* CJK COMPATIBILITY IDEOGRAPH-2F923 */
, 0x2F924, 0x2F924, 0x7280 /* CJK COMPATIBILITY IDEOGRAPH-2F924 */
, 0x2F925, 0x2F925, 0x7295 /* CJK COMPATIBILITY IDEOGRAPH-2F925 */
, 0x2F926, 0x2F926, 0x24735 /* CJK COMPATIBILITY IDEOGRAPH-2F926 */
, 0x2F927, 0x2F927, 0x24814 /* CJK COMPATIBILITY IDEOGRAPH-2F927 */
, 0x2F928, 0x2F928, 0x737A /* CJK COMPATIBILITY IDEOGRAPH-2F928 */
, 0x2F929, 0x2F929, 0x738B /* CJK COMPATIBILITY IDEOGRAPH-2F929 */
, 0x2F92A, 0x2F92A, 0x3EAC /* CJK COMPATIBILITY IDEOGRAPH-2F92A */
, 0x2F92B, 0x2F92B, 0x73A5 /* CJK COMPATIBILITY IDEOGRAPH-2F92B */
, 0x2F92C, 0x2F92C, 0x3EB8 /* CJK COMPATIBILITY IDEOGRAPH-2F92C */
, 0x2F92D, 0x2F92D, 0x3EB8 /* CJK COMPATIBILITY IDEOGRAPH-2F92D */
, 0x2F92E, 0x2F92E, 0x7447 /* CJK COMPATIBILITY IDEOGRAPH-2F92E */
, 0x2F92F, 0x2F92F, 0x745C /* CJK COMPATIBILITY IDEOGRAPH-2F92F */
, 0x2F930, 0x2F930, 0x7471 /* CJK COMPATIBILITY IDEOGRAPH-2F930 */
, 0x2F931, 0x2F931, 0x7485 /* CJK COMPATIBILITY IDEOGRAPH-2F931 */
, 0x2F932, 0x2F932, 0x74CA /* CJK COMPATIBILITY IDEOGRAPH-2F932 */
, 0x2F933, 0x2F933, 0x3F1B /* CJK COMPATIBILITY IDEOGRAPH-2F933 */
, 0x2F934, 0x2F934, 0x7524 /* CJK COMPATIBILITY IDEOGRAPH-2F934 */
, 0x2F935, 0x2F935, 0x24C36 /* CJK COMPATIBILITY IDEOGRAPH-2F935 */
, 0x2F936, 0x2F936, 0x753E /* CJK COMPATIBILITY IDEOGRAPH-2F936 */
, 0x2F937, 0x2F937, 0x24C92 /* CJK COMPATIBILITY IDEOGRAPH-2F937 */
, 0x2F938, 0x2F938, 0x7570 /* CJK COMPATIBILITY IDEOGRAPH-2F938 */
, 0x2F939, 0x2F939, 0x2219F /* CJK COMPATIBILITY IDEOGRAPH-2F939 */
, 0x2F93A, 0x2F93A, 0x7610 /* CJK COMPATIBILITY IDEOGRAPH-2F93A */
, 0x2F93B, 0x2F93B, 0x24FA1 /* CJK COMPATIBILITY IDEOGRAPH-2F93B */
, 0x2F93C, 0x2F93C, 0x24FB8 /* CJK COMPATIBILITY IDEOGRAPH-2F93C */
, 0x2F93D, 0x2F93D, 0x25044 /* CJK COMPATIBILITY IDEOGRAPH-2F93D */
, 0x2F93E, 0x2F93E, 0x3FFC /* CJK COMPATIBILITY IDEOGRAPH-2F93E */
, 0x2F93F, 0x2F93F, 0x4008 /* CJK COMPATIBILITY IDEOGRAPH-2F93F */
, 0x2F940, 0x2F940, 0x76F4 /* CJK COMPATIBILITY IDEOGRAPH-2F940 */
, 0x2F941, 0x2F941, 0x250F3 /* CJK COMPATIBILITY IDEOGRAPH-2F941 */
, 0x2F942, 0x2F942, 0x250F2 /* CJK COMPATIBILITY IDEOGRAPH-2F942 */
, 0x2F943, 0x2F943, 0x25119 /* CJK COMPATIBILITY IDEOGRAPH-2F943 */
, 0x2F944, 0x2F944, 0x25133 /* CJK COMPATIBILITY IDEOGRAPH-2F944 */
, 0x2F945, 0x2F945, 0x771E /* CJK COMPATIBILITY IDEOGRAPH-2F945 */
, 0x2F946, 0x2F946, 0x771F /* CJK COMPATIBILITY IDEOGRAPH-2F946 */
, 0x2F947, 0x2F947, 0x771F /* CJK COMPATIBILITY IDEOGRAPH-2F947 */
, 0x2F948, 0x2F948, 0x774A /* CJK COMPATIBILITY IDEOGRAPH-2F948 */
, 0x2F949, 0x2F949, 0x4039 /* CJK COMPATIBILITY IDEOGRAPH-2F949 */
, 0x2F94A, 0x2F94A, 0x778B /* CJK COMPATIBILITY IDEOGRAPH-2F94A */
, 0x2F94B, 0x2F94B, 0x4046 /* CJK COMPATIBILITY IDEOGRAPH-2F94B */
, 0x2F94C, 0x2F94C, 0x4096 /* CJK COMPATIBILITY IDEOGRAPH-2F94C */
, 0x2F94D, 0x2F94D, 0x2541D /* CJK COMPATIBILITY IDEOGRAPH-2F94D */
, 0x2F94E, 0x2F94E, 0x784E /* CJK COMPATIBILITY IDEOGRAPH-2F94E */
, 0x2F94F, 0x2F94F, 0x788C /* CJK COMPATIBILITY IDEOGRAPH-2F94F */
, 0x2F950, 0x2F950, 0x78CC /* CJK COMPATIBILITY IDEOGRAPH-2F950 */
, 0x2F951, 0x2F951, 0x40E3 /* CJK COMPATIBILITY IDEOGRAPH-2F951 */
, 0x2F952, 0x2F952, 0x25626 /* CJK COMPATIBILITY IDEOGRAPH-2F952 */
, 0x2F953, 0x2F953, 0x7956 /* CJK COMPATIBILITY IDEOGRAPH-2F953 */
, 0x2F954, 0x2F954, 0x2569A /* CJK COMPATIBILITY IDEOGRAPH-2F954 */
, 0x2F955, 0x2F955, 0x256C5 /* CJK COMPATIBILITY IDEOGRAPH-2F955 */
, 0x2F956, 0x2F956, 0x798F /* CJK COMPATIBILITY IDEOGRAPH-2F956 */
, 0x2F957, 0x2F957, 0x79EB /* CJK COMPATIBILITY IDEOGRAPH-2F957 */
, 0x2F958, 0x2F958, 0x412F /* CJK COMPATIBILITY IDEOGRAPH-2F958 */
, 0x2F959, 0x2F959, 0x7A40 /* CJK COMPATIBILITY IDEOGRAPH-2F959 */
, 0x2F95A, 0x2F95A, 0x7A4A /* CJK COMPATIBILITY IDEOGRAPH-2F95A */
, 0x2F95B, 0x2F95B, 0x7A4F /* CJK COMPATIBILITY IDEOGRAPH-2F95B */
, 0x2F95C, 0x2F95C, 0x2597C /* CJK COMPATIBILITY IDEOGRAPH-2F95C */
, 0x2F95D, 0x2F95D, 0x25AA7 /* CJK COMPATIBILITY IDEOGRAPH-2F95D */
, 0x2F95E, 0x2F95E, 0x25AA7 /* CJK COMPATIBILITY IDEOGRAPH-2F95E */
, 0x2F95F, 0x2F95F, 0x7AEE /* CJK COMPATIBILITY IDEOGRAPH-2F95F */
, 0x2F960, 0x2F960, 0x4202 /* CJK COMPATIBILITY IDEOGRAPH-2F960 */
, 0x2F961, 0x2F961, 0x25BAB /* CJK COMPATIBILITY IDEOGRAPH-2F961 */
, 0x2F962, 0x2F962, 0x7BC6 /* CJK COMPATIBILITY IDEOGRAPH-2F962 */
, 0x2F963, 0x2F963, 0x7BC9 /* CJK COMPATIBILITY IDEOGRAPH-2F963 */
, 0x2F964, 0x2F964, 0x4227 /* CJK COMPATIBILITY IDEOGRAPH-2F964 */
, 0x2F965, 0x2F965, 0x25C80 /* CJK COMPATIBILITY IDEOGRAPH-2F965 */
, 0x2F966, 0x2F966, 0x7CD2 /* CJK COMPATIBILITY IDEOGRAPH-2F966 */
, 0x2F967, 0x2F967, 0x42A0 /* CJK COMPATIBILITY IDEOGRAPH-2F967 */
, 0x2F968, 0x2F968, 0x7CE8 /* CJK COMPATIBILITY IDEOGRAPH-2F968 */
, 0x2F969, 0x2F969, 0x7CE3 /* CJK COMPATIBILITY IDEOGRAPH-2F969 */
, 0x2F96A, 0x2F96A, 0x7D00 /* CJK COMPATIBILITY IDEOGRAPH-2F96A */
, 0x2F96B, 0x2F96B, 0x25F86 /* CJK COMPATIBILITY IDEOGRAPH-2F96B */
, 0x2F96C, 0x2F96C, 0x7D63 /* CJK COMPATIBILITY IDEOGRAPH-2F96C */
, 0x2F96D, 0x2F96D, 0x4301 /* CJK COMPATIBILITY IDEOGRAPH-2F96D */
, 0x2F96E, 0x2F96E, 0x7DC7 /* CJK COMPATIBILITY IDEOGRAPH-2F96E */
, 0x2F96F, 0x2F96F, 0x7E02 /* CJK COMPATIBILITY IDEOGRAPH-2F96F */
, 0x2F970, 0x2F970, 0x7E45 /* CJK COMPATIBILITY IDEOGRAPH-2F970 */
, 0x2F971, 0x2F971, 0x4334 /* CJK COMPATIBILITY IDEOGRAPH-2F971 */
, 0x2F972, 0x2F972, 0x26228 /* CJK COMPATIBILITY IDEOGRAPH-2F972 */
, 0x2F973, 0x2F973, 0x26247 /* CJK COMPATIBILITY IDEOGRAPH-2F973 */
, 0x2F974, 0x2F974, 0x4359 /* CJK COMPATIBILITY IDEOGRAPH-2F974 */
, 0x2F975, 0x2F975, 0x262D9 /* CJK COMPATIBILITY IDEOGRAPH-2F975 */
, 0x2F976, 0x2F976, 0x7F7A /* CJK COMPATIBILITY IDEOGRAPH-2F976 */
, 0x2F977, 0x2F977, 0x2633E /* CJK COMPATIBILITY IDEOGRAPH-2F977 */
, 0x2F978, 0x2F978, 0x7F95 /* CJK COMPATIBILITY IDEOGRAPH-2F978 */
, 0x2F979, 0x2F979, 0x7FFA /* CJK COMPATIBILITY IDEOGRAPH-2F979 */
, 0x2F97A, 0x2F97A, 0x8005 /* CJK COMPATIBILITY IDEOGRAPH-2F97A */
, 0x2F97B, 0x2F97B, 0x264DA /* CJK COMPATIBILITY IDEOGRAPH-2F97B */
, 0x2F97C, 0x2F97C, 0x26523 /* CJK COMPATIBILITY IDEOGRAPH-2F97C */
, 0x2F97D, 0x2F97D, 0x8060 /* CJK COMPATIBILITY IDEOGRAPH-2F97D */
, 0x2F97E, 0x2F97E, 0x265A8 /* CJK COMPATIBILITY IDEOGRAPH-2F97E */
, 0x2F97F, 0x2F97F, 0x8070 /* CJK COMPATIBILITY IDEOGRAPH-2F97F */
, 0x2F980, 0x2F980, 0x2335F /* CJK COMPATIBILITY IDEOGRAPH-2F980 */
, 0x2F981, 0x2F981, 0x43D5 /* CJK COMPATIBILITY IDEOGRAPH-2F981 */
, 0x2F982, 0x2F982, 0x80B2 /* CJK COMPATIBILITY IDEOGRAPH-2F982 */
, 0x2F983, 0x2F983, 0x8103 /* CJK COMPATIBILITY IDEOGRAPH-2F983 */
, 0x2F984, 0x2F984, 0x440B /* CJK COMPATIBILITY IDEOGRAPH-2F984 */
, 0x2F985, 0x2F985, 0x813E /* CJK COMPATIBILITY IDEOGRAPH-2F985 */
, 0x2F986, 0x2F986, 0x5AB5 /* CJK COMPATIBILITY IDEOGRAPH-2F986 */
, 0x2F987, 0x2F987, 0x267A7 /* CJK COMPATIBILITY IDEOGRAPH-2F987 */
, 0x2F988, 0x2F988, 0x267B5 /* CJK COMPATIBILITY IDEOGRAPH-2F988 */
, 0x2F989, 0x2F989, 0x23393 /* CJK COMPATIBILITY IDEOGRAPH-2F989 */
, 0x2F98A, 0x2F98A, 0x2339C /* CJK COMPATIBILITY IDEOGRAPH-2F98A */
, 0x2F98B, 0x2F98B, 0x8201 /* CJK COMPATIBILITY IDEOGRAPH-2F98B */
, 0x2F98C, 0x2F98C, 0x8204 /* CJK COMPATIBILITY IDEOGRAPH-2F98C */
, 0x2F98D, 0x2F98D, 0x8F9E /* CJK COMPATIBILITY IDEOGRAPH-2F98D */
, 0x2F98E, 0x2F98E, 0x446B /* CJK COMPATIBILITY IDEOGRAPH-2F98E */
, 0x2F98F, 0x2F98F, 0x8291 /* CJK COMPATIBILITY IDEOGRAPH-2F98F */
, 0x2F990, 0x2F990, 0x828B /* CJK COMPATIBILITY IDEOGRAPH-2F990 */
, 0x2F991, 0x2F991, 0x829D /* CJK COMPATIBILITY IDEOGRAPH-2F991 */
, 0x2F992, 0x2F992, 0x52B3 /* CJK COMPATIBILITY IDEOGRAPH-2F992 */
, 0x2F993, 0x2F993, 0x82B1 /* CJK COMPATIBILITY IDEOGRAPH-2F993 */
, 0x2F994, 0x2F994, 0x82B3 /* CJK COMPATIBILITY IDEOGRAPH-2F994 */
, 0x2F995, 0x2F995, 0x82BD /* CJK COMPATIBILITY IDEOGRAPH-2F995 */
, 0x2F996, 0x2F996, 0x82E6 /* CJK COMPATIBILITY IDEOGRAPH-2F996 */
, 0x2F997, 0x2F997, 0x26B3C /* CJK COMPATIBILITY IDEOGRAPH-2F997 */
, 0x2F998, 0x2F998, 0x82E5 /* CJK COMPATIBILITY IDEOGRAPH-2F998 */
, 0x2F999, 0x2F999, 0x831D /* CJK COMPATIBILITY IDEOGRAPH-2F999 */
, 0x2F99A, 0x2F99A, 0x8363 /* CJK COMPATIBILITY IDEOGRAPH-2F99A */
, 0x2F99B, 0x2F99B, 0x83AD /* CJK COMPATIBILITY IDEOGRAPH-2F99B */
, 0x2F99C, 0x2F99C, 0x8323 /* CJK COMPATIBILITY IDEOGRAPH-2F99C */
, 0x2F99D, 0x2F99D, 0x83BD /* CJK COMPATIBILITY IDEOGRAPH-2F99D */
, 0x2F99E, 0x2F99E, 0x83E7 /* CJK COMPATIBILITY IDEOGRAPH-2F99E */
, 0x2F99F, 0x2F99F, 0x8457 /* CJK COMPATIBILITY IDEOGRAPH-2F99F */
, 0x2F9A0, 0x2F9A0, 0x8353 /* CJK COMPATIBILITY IDEOGRAPH-2F9A0 */
, 0x2F9A1, 0x2F9A1, 0x83CA /* CJK COMPATIBILITY IDEOGRAPH-2F9A1 */
, 0x2F9A2, 0x2F9A2, 0x83CC /* CJK COMPATIBILITY IDEOGRAPH-2F9A2 */
, 0x2F9A3, 0x2F9A3, 0x83DC /* CJK COMPATIBILITY IDEOGRAPH-2F9A3 */
, 0x2F9A4, 0x2F9A4, 0x26C36 /* CJK COMPATIBILITY IDEOGRAPH-2F9A4 */
, 0x2F9A5, 0x2F9A5, 0x26D6B /* CJK COMPATIBILITY IDEOGRAPH-2F9A5 */
, 0x2F9A6, 0x2F9A6, 0x26CD5 /* CJK COMPATIBILITY IDEOGRAPH-2F9A6 */
, 0x2F9A7, 0x2F9A7, 0x452B /* CJK COMPATIBILITY IDEOGRAPH-2F9A7 */
, 0x2F9A8, 0x2F9A8, 0x84F1 /* CJK COMPATIBILITY IDEOGRAPH-2F9A8 */
, 0x2F9A9, 0x2F9A9, 0x84F3 /* CJK COMPATIBILITY IDEOGRAPH-2F9A9 */
, 0x2F9AA, 0x2F9AA, 0x8516 /* CJK COMPATIBILITY IDEOGRAPH-2F9AA */
, 0x2F9AB, 0x2F9AB, 0x273CA /* CJK COMPATIBILITY IDEOGRAPH-2F9AB */
, 0x2F9AC, 0x2F9AC, 0x8564 /* CJK COMPATIBILITY IDEOGRAPH-2F9AC */
, 0x2F9AD, 0x2F9AD, 0x26F2C /* CJK COMPATIBILITY IDEOGRAPH-2F9AD */
, 0x2F9AE, 0x2F9AE, 0x455D /* CJK COMPATIBILITY IDEOGRAPH-2F9AE */
, 0x2F9AF, 0x2F9AF, 0x4561 /* CJK COMPATIBILITY IDEOGRAPH-2F9AF */
, 0x2F9B0, 0x2F9B0, 0x26FB1 /* CJK COMPATIBILITY IDEOGRAPH-2F9B0 */
, 0x2F9B1, 0x2F9B1, 0x270D2 /* CJK COMPATIBILITY IDEOGRAPH-2F9B1 */
, 0x2F9B2, 0x2F9B2, 0x456B /* CJK COMPATIBILITY IDEOGRAPH-2F9B2 */
, 0x2F9B3, 0x2F9B3, 0x8650 /* CJK COMPATIBILITY IDEOGRAPH-2F9B3 */
, 0x2F9B4, 0x2F9B4, 0x865C /* CJK COMPATIBILITY IDEOGRAPH-2F9B4 */
, 0x2F9B5, 0x2F9B5, 0x8667 /* CJK COMPATIBILITY IDEOGRAPH-2F9B5 */
, 0x2F9B6, 0x2F9B6, 0x8669 /* CJK COMPATIBILITY IDEOGRAPH-2F9B6 */
, 0x2F9B7, 0x2F9B7, 0x86A9 /* CJK COMPATIBILITY IDEOGRAPH-2F9B7 */
, 0x2F9B8, 0x2F9B8, 0x8688 /* CJK COMPATIBILITY IDEOGRAPH-2F9B8 */
, 0x2F9B9, 0x2F9B9, 0x870E /* CJK COMPATIBILITY IDEOGRAPH-2F9B9 */
, 0x2F9BA, 0x2F9BA, 0x86E2 /* CJK COMPATIBILITY IDEOGRAPH-2F9BA */
, 0x2F9BB, 0x2F9BB, 0x8779 /* CJK COMPATIBILITY IDEOGRAPH-2F9BB */
, 0x2F9BC, 0x2F9BC, 0x8728 /* CJK COMPATIBILITY IDEOGRAPH-2F9BC */
, 0x2F9BD, 0x2F9BD, 0x876B /* CJK COMPATIBILITY IDEOGRAPH-2F9BD */
, 0x2F9BE, 0x2F9BE, 0x8786 /* CJK COMPATIBILITY IDEOGRAPH-2F9BE */
, 0x2F9BF, 0x2F9BF, 0x45D7 /* CJK COMPATIBILITY IDEOGRAPH-2F9BF */
, 0x2F9C0, 0x2F9C0, 0x87E1 /* CJK COMPATIBILITY IDEOGRAPH-2F9C0 */
, 0x2F9C1, 0x2F9C1, 0x8801 /* CJK COMPATIBILITY IDEOGRAPH-2F9C1 */
, 0x2F9C2, 0x2F9C2, 0x45F9 /* CJK COMPATIBILITY IDEOGRAPH-2F9C2 */
, 0x2F9C3, 0x2F9C3, 0x8860 /* CJK COMPATIBILITY IDEOGRAPH-2F9C3 */
, 0x2F9C4, 0x2F9C4, 0x8863 /* CJK COMPATIBILITY IDEOGRAPH-2F9C4 */
, 0x2F9C5, 0x2F9C5, 0x27667 /* CJK COMPATIBILITY IDEOGRAPH-2F9C5 */
, 0x2F9C6, 0x2F9C6, 0x88D7 /* CJK COMPATIBILITY IDEOGRAPH-2F9C6 */
, 0x2F9C7, 0x2F9C7, 0x88DE /* CJK COMPATIBILITY IDEOGRAPH-2F9C7 */
, 0x2F9C8, 0x2F9C8, 0x4635 /* CJK COMPATIBILITY IDEOGRAPH-2F9C8 */
, 0x2F9C9, 0x2F9C9, 0x88FA /* CJK COMPATIBILITY IDEOGRAPH-2F9C9 */
, 0x2F9CA, 0x2F9CA, 0x34BB /* CJK COMPATIBILITY IDEOGRAPH-2F9CA */
, 0x2F9CB, 0x2F9CB, 0x278AE /* CJK COMPATIBILITY IDEOGRAPH-2F9CB */
, 0x2F9CC, 0x2F9CC, 0x27966 /* CJK COMPATIBILITY IDEOGRAPH-2F9CC */
, 0x2F9CD, 0x2F9CD, 0x46BE /* CJK COMPATIBILITY IDEOGRAPH-2F9CD */
, 0x2F9CE, 0x2F9CE, 0x46C7 /* CJK COMPATIBILITY IDEOGRAPH-2F9CE */
, 0x2F9CF, 0x2F9CF, 0x8AA0 /* CJK COMPATIBILITY IDEOGRAPH-2F9CF */
, 0x2F9D0, 0x2F9D0, 0x8AED /* CJK COMPATIBILITY IDEOGRAPH-2F9D0 */
, 0x2F9D1, 0x2F9D1, 0x8B8A /* CJK COMPATIBILITY IDEOGRAPH-2F9D1 */
, 0x2F9D2, 0x2F9D2, 0x8C55 /* CJK COMPATIBILITY IDEOGRAPH-2F9D2 */
, 0x2F9D3, 0x2F9D3, 0x27CA8 /* CJK COMPATIBILITY IDEOGRAPH-2F9D3 */
, 0x2F9D4, 0x2F9D4, 0x8CAB /* CJK COMPATIBILITY IDEOGRAPH-2F9D4 */
, 0x2F9D5, 0x2F9D5, 0x8CC1 /* CJK COMPATIBILITY IDEOGRAPH-2F9D5 */
, 0x2F9D6, 0x2F9D6, 0x8D1B /* CJK COMPATIBILITY IDEOGRAPH-2F9D6 */
, 0x2F9D7, 0x2F9D7, 0x8D77 /* CJK COMPATIBILITY IDEOGRAPH-2F9D7 */
, 0x2F9D8, 0x2F9D8, 0x27F2F /* CJK COMPATIBILITY IDEOGRAPH-2F9D8 */
, 0x2F9D9, 0x2F9D9, 0x20804 /* CJK COMPATIBILITY IDEOGRAPH-2F9D9 */
, 0x2F9DA, 0x2F9DA, 0x8DCB /* CJK COMPATIBILITY IDEOGRAPH-2F9DA */
, 0x2F9DB, 0x2F9DB, 0x8DBC /* CJK COMPATIBILITY IDEOGRAPH-2F9DB */
, 0x2F9DC, 0x2F9DC, 0x8DF0 /* CJK COMPATIBILITY IDEOGRAPH-2F9DC */
, 0x2F9DD, 0x2F9DD, 0x208DE /* CJK COMPATIBILITY IDEOGRAPH-2F9DD */
, 0x2F9DE, 0x2F9DE, 0x8ED4 /* CJK COMPATIBILITY IDEOGRAPH-2F9DE */
, 0x2F9DF, 0x2F9DF, 0x8F38 /* CJK COMPATIBILITY IDEOGRAPH-2F9DF */
, 0x2F9E0, 0x2F9E0, 0x285D2 /* CJK COMPATIBILITY IDEOGRAPH-2F9E0 */
, 0x2F9E1, 0x2F9E1, 0x285ED /* CJK COMPATIBILITY IDEOGRAPH-2F9E1 */
, 0x2F9E2, 0x2F9E2, 0x9094 /* CJK COMPATIBILITY IDEOGRAPH-2F9E2 */
, 0x2F9E3, 0x2F9E3, 0x90F1 /* CJK COMPATIBILITY IDEOGRAPH-2F9E3 */
, 0x2F9E4, 0x2F9E4, 0x9111 /* CJK COMPATIBILITY IDEOGRAPH-2F9E4 */
, 0x2F9E5, 0x2F9E5, 0x2872E /* CJK COMPATIBILITY IDEOGRAPH-2F9E5 */
, 0x2F9E6, 0x2F9E6, 0x911B /* CJK COMPATIBILITY IDEOGRAPH-2F9E6 */
, 0x2F9E7, 0x2F9E7, 0x9238 /* CJK COMPATIBILITY IDEOGRAPH-2F9E7 */
, 0x2F9E8, 0x2F9E8, 0x92D7 /* CJK COMPATIBILITY IDEOGRAPH-2F9E8 */
, 0x2F9E9, 0x2F9E9, 0x92D8 /* CJK COMPATIBILITY IDEOGRAPH-2F9E9 */
, 0x2F9EA, 0x2F9EA, 0x927C /* CJK COMPATIBILITY IDEOGRAPH-2F9EA */
, 0x2F9EB, 0x2F9EB, 0x93F9 /* CJK COMPATIBILITY IDEOGRAPH-2F9EB */
, 0x2F9EC, 0x2F9EC, 0x9415 /* CJK COMPATIBILITY IDEOGRAPH-2F9EC */
, 0x2F9ED, 0x2F9ED, 0x28BFA /* CJK COMPATIBILITY IDEOGRAPH-2F9ED */
, 0x2F9EE, 0x2F9EE, 0x958B /* CJK COMPATIBILITY IDEOGRAPH-2F9EE */
, 0x2F9EF, 0x2F9EF, 0x4995 /* CJK COMPATIBILITY IDEOGRAPH-2F9EF */
, 0x2F9F0, 0x2F9F0, 0x95B7 /* CJK COMPATIBILITY IDEOGRAPH-2F9F0 */
, 0x2F9F1, 0x2F9F1, 0x28D77 /* CJK COMPATIBILITY IDEOGRAPH-2F9F1 */
, 0x2F9F2, 0x2F9F2, 0x49E6 /* CJK COMPATIBILITY IDEOGRAPH-2F9F2 */
, 0x2F9F3, 0x2F9F3, 0x96C3 /* CJK COMPATIBILITY IDEOGRAPH-2F9F3 */
, 0x2F9F4, 0x2F9F4, 0x5DB2 /* CJK COMPATIBILITY IDEOGRAPH-2F9F4 */
, 0x2F9F5, 0x2F9F5, 0x9723 /* CJK COMPATIBILITY IDEOGRAPH-2F9F5 */
, 0x2F9F6, 0x2F9F6, 0x29145 /* CJK COMPATIBILITY IDEOGRAPH-2F9F6 */
, 0x2F9F7, 0x2F9F7, 0x2921A /* CJK COMPATIBILITY IDEOGRAPH-2F9F7 */
, 0x2F9F8, 0x2F9F8, 0x4A6E /* CJK COMPATIBILITY IDEOGRAPH-2F9F8 */
, 0x2F9F9, 0x2F9F9, 0x4A76 /* CJK COMPATIBILITY IDEOGRAPH-2F9F9 */
, 0x2F9FA, 0x2F9FA, 0x97E0 /* CJK COMPATIBILITY IDEOGRAPH-2F9FA */
, 0x2F9FB, 0x2F9FB, 0x2940A /* CJK COMPATIBILITY IDEOGRAPH-2F9FB */
, 0x2F9FC, 0x2F9FC, 0x4AB2 /* CJK COMPATIBILITY IDEOGRAPH-2F9FC */
, 0x2F9FD, 0x2F9FD, 0x29496 /* CJK COMPATIBILITY IDEOGRAPH-2F9FD */
, 0x2F9FE, 0x2F9FE, 0x980B /* CJK COMPATIBILITY IDEOGRAPH-2F9FE */
, 0x2F9FF, 0x2F9FF, 0x980B /* CJK COMPATIBILITY IDEOGRAPH-2F9FF */
, 0x2FA00, 0x2FA00, 0x9829 /* CJK COMPATIBILITY IDEOGRAPH-2FA00 */
, 0x2FA01, 0x2FA01, 0x295B6 /* CJK COMPATIBILITY IDEOGRAPH-2FA01 */
, 0x2FA02, 0x2FA02, 0x98E2 /* CJK COMPATIBILITY IDEOGRAPH-2FA02 */
, 0x2FA03, 0x2FA03, 0x4B33 /* CJK COMPATIBILITY IDEOGRAPH-2FA03 */
, 0x2FA04, 0x2FA04, 0x9929 /* CJK COMPATIBILITY IDEOGRAPH-2FA04 */
, 0x2FA05, 0x2FA05, 0x99A7 /* CJK COMPATIBILITY IDEOGRAPH-2FA05 */
, 0x2FA06, 0x2FA06, 0x99C2 /* CJK COMPATIBILITY IDEOGRAPH-2FA06 */
, 0x2FA07, 0x2FA07, 0x99FE /* CJK COMPATIBILITY IDEOGRAPH-2FA07 */
, 0x2FA08, 0x2FA08, 0x4BCE /* CJK COMPATIBILITY IDEOGRAPH-2FA08 */
, 0x2FA09, 0x2FA09, 0x29B30 /* CJK COMPATIBILITY IDEOGRAPH-2FA09 */
, 0x2FA0A, 0x2FA0A, 0x9B12 /* CJK COMPATIBILITY IDEOGRAPH-2FA0A */
, 0x2FA0B, 0x2FA0B, 0x9C40 /* CJK COMPATIBILITY IDEOGRAPH-2FA0B */
, 0x2FA0C, 0x2FA0C, 0x9CFD /* CJK COMPATIBILITY IDEOGRAPH-2FA0C */
, 0x2FA0D, 0x2FA0D, 0x4CCE /* CJK COMPATIBILITY IDEOGRAPH-2FA0D */
, 0x2FA0E, 0x2FA0E, 0x4CED /* CJK COMPATIBILITY IDEOGRAPH-2FA0E */
, 0x2FA0F, 0x2FA0F, 0x9D67 /* CJK COMPATIBILITY IDEOGRAPH-2FA0F */
, 0x2FA10, 0x2FA10, 0x2A0CE /* CJK COMPATIBILITY IDEOGRAPH-2FA10 */
, 0x2FA11, 0x2FA11, 0x4CF8 /* CJK COMPATIBILITY IDEOGRAPH-2FA11 */
, 0x2FA12, 0x2FA12, 0x2A105 /* CJK COMPATIBILITY IDEOGRAPH-2FA12 */
, 0x2FA13, 0x2FA13, 0x2A20E /* CJK COMPATIBILITY IDEOGRAPH-2FA13 */
, 0x2FA14, 0x2FA14, 0x2A291 /* CJK COMPATIBILITY IDEOGRAPH-2FA14 */
, 0x2FA15, 0x2FA15, 0x9EBB /* CJK COMPATIBILITY IDEOGRAPH-2FA15 */
, 0x2FA16, 0x2FA16, 0x4D56 /* CJK COMPATIBILITY IDEOGRAPH-2FA16 */
, 0x2FA17, 0x2FA17, 0x9EF9 /* CJK COMPATIBILITY IDEOGRAPH-2FA17 */
, 0x2FA18, 0x2FA18, 0x9EFE /* CJK COMPATIBILITY IDEOGRAPH-2FA18 */
, 0x2FA19, 0x2FA19, 0x9F05 /* CJK COMPATIBILITY IDEOGRAPH-2FA19 */
, 0x2FA1A, 0x2FA1A, 0x9F0F /* CJK COMPATIBILITY IDEOGRAPH-2FA1A */
, 0x2FA1B, 0x2FA1B, 0x9F16 /* CJK COMPATIBILITY IDEOGRAPH-2FA1B */
, 0x2FA1C, 0x2FA1C, 0x9F3B /* CJK COMPATIBILITY IDEOGRAPH-2FA1C */
, 0x2FA1D, 0x2FA1D, 0x2A600 /* CJK COMPATIBILITY IDEOGRAPH-2FA1D */
};
static inline PRBool IsUnicodeSpace(PRUint32 c) {
return (c == 0x0020) || (c == 0x00A0) || (c == 0x1680) || (c == 0x180E) || (c == 0x2000) || (c == 0x2001) || (c == 0x2002) || (c == 0x2003) || (c == 0x2004) || (c == 0x2005) || (c == 0x2006) || (c == 0x2007) || (c == 0x2008) || (c == 0x2009) || (c == 0x200A) || (c == 0x200B) || (c == 0x202F) || (c == 0x205F) || (c == 0x3000) || PR_FALSE;
}
|
#include <iostream>
#include <map>
#include <string>
using namespace std;
class EllysNewNickname
{
public:
int getLength(string nickname)
{
int cnt = 0;
char w;
bool isConsecutive = false;
for (int i=0; i<nickname.size(); ++i) {
w = nickname.at(i);
if (w == 'a' || w == 'i' || w== 'u' || w== 'e' || w=='o' || w=='y') {
if (isConsecutive)
continue;
isConsecutive = true;
}
else {
isConsecutive = false;
}
++cnt;
}
return cnt;
}
};
|
#pragma once
#include <array>
namespace breakout
{
enum class EEntityType : int
{
Awersome = 0,
Background = 1,
SolidBlock = 2,
Block = 3,
PlayerPaddle = 4,
PlayerBall = 5,
SpeedPowerUp = 6,
StickyPowerUp = 7,
PassThroughPowerUp = 8,
PadSizeIncreasePowerUp = 9,
ConfusePowerUp = 10,
ChaosPowerUp = 11,
MAX,
};
enum class EBreakoutInitGameDataId
{
playerPaddleSize = 0,
playerPaddleVelocity = 1,
playerBallSize = 2,
playerBallVelocity = 3,
powerUpSize = 4,
powerUpVelocity = 5,
playerLives = 6,
MAX = 7
};
struct BreakoutInitGameData
{
std::array<std::array<float, 2>, 7> data;
int playerId = -1;
int playerBallId = -1;
};
class ECSBreakout
{
public:
static void Init();
static int CreateComponent(EEntityType);
static BreakoutInitGameData& GetInitGameData();
private:
static void LoadInitDataFromConfig();
static void InitComponentsPools();
static void CreateWorld();
static void InitGameStateController();
};
}
|
// FileReadWrite.h
#ifndef SIMPLE_FILE_READ_WRITE_H
#define SIMPLE_FILE_READ_WRITE_H
#include <string>
namespace simple
{
std::string readFile( const std::string& name );
void writeFile( const std::string& out, const std::string& fileName );
} // simple
#endif // SIMPLE_FILE_READ_WRITE_H
|
#pragma once
#include "StdAfx.h"
#include "Object.h"
class CGrid : public CObject
{
public:
CGrid(int col, int row, int colSize, int rowSize):
CObject(NULL),
m_col(col),
m_row(row),
m_colSize(colSize),
m_rowSize(rowSize),
m_bShow(false)
{}
bool Init(){return true;}
void Update(float){}
void Render()
{
if(m_pHge->Input_KeyDown(HGEK_SPACE))
m_bShow = !m_bShow;
if(m_bShow)
{
for(int i = 0;i < m_col;i ++)
m_pHge->Gfx_RenderLine((float)m_colSize*i, 0,
(float)m_colSize*i,(float)m_row*m_rowSize);
for(int j = 0;j < m_row;j ++)
m_pHge->Gfx_RenderLine(0, (float)m_rowSize*j,
(float)m_col*m_colSize,(float)m_rowSize*j);
}
}
void Cleanup(){}
private:
int m_col;//列（宽）
int m_row;//行（高）
int m_colSize;//列（宽）
int m_rowSize;//行（高）
bool m_bShow;
};
|
#pragma once
#include <map>
#include <vector>
#include <Poco/SharedPtr.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/Object.h>
#include "gwmessage/GWResponse.h"
#include "model/DeviceID.h"
#include "model/ModuleID.h"
#include "model/RefreshTime.h"
#include "util/Loggable.h"
namespace BeeeOn {
/**
* @brief Represents a message sent byt the server to the gateway as a response
* to the GWDeviceListRequest.
*
* The message contains a list of paired devices with a specific prefix.
*
* For each device, there is an optional section under key _config_.
* Here, some configuration options might be available. Currently,
* the well known keys are: "refresh_time", "ip_address", "password".
*
* An example message:
* <pre>
* {
* "id": "60775a50-d91c-4325-89b1-283e38bd60b2",
* "message_type": "device_list_response",
* "status": 1,
* "devices": [
* {"device_id": "0xa300000000000001"}
* ],
* "values": {
* "0xa300000000000001": {
* "0": 0,
* "1": 10.0
* }
* },
* "config": {
* "0xa300000000000001": {
* "regresh_time": "30",
* "password": "super-secret",
* "ip-address": "10.0.0.1"
* }
* }
* }
* </pre>
*/
class GWDeviceListResponse : public GWResponse, Loggable {
public:
typedef Poco::SharedPtr<GWDeviceListResponse> Ptr;
GWDeviceListResponse();
GWDeviceListResponse(const Poco::JSON::Object::Ptr object);
void setDevices(const std::vector<DeviceID> &devices);
/**
* @returns device IDs of paired devices
*/
std::vector<DeviceID> devices() const;
void setModulesValues(
const DeviceID &device,
const std::map<ModuleID, double> &values);
/**
* @returns map of the most recent values for the given device
*/
std::map<ModuleID, double> modulesValues(const DeviceID &device) const;
void setRefreshFor(const DeviceID &device, const RefreshTime &refresh);
RefreshTime refreshFor(const DeviceID &device) const;
void setProperties(
const DeviceID &device,
const std::map<std::string, std::string> &properties);
std::map<std::string, std::string> properties(
const DeviceID &device) const;
};
}
|
//#ifdef DEBUG
#if 0
#include <stdint.h>
#include <string.h>
const int chardat=0x0000;
extern uint8_t * wram;
extern uint16_t * vram;
extern uint16_t * cgram;
extern uint8_t * aram;//not that I'll need this...
extern uint8_t * oam;
extern uint32_t palette[32768];
uint32_t * pixels;
void initstuff(uint32_t * mypixels)
{
pixels=mypixels;
}
void drawstuff()
{
for (int l=0;l<2;l++)
{
for (int xt=0;xt<64;xt++)
{
for (int yt=0;yt<64;yt++)
{
uint32_t * tilepix=pixels+(xt*8)+(yt*8*1024)+(l*512);
int stat=vram[0x2000+l*0x1000+(yt&32)*64+(xt&32)*32+(yt&31)*32+(xt&31)*1];
int tileoff=(chardat+(stat&0x3FF)*32)/2;
int pal=(stat&0x1C00)>>2>>4;
uint8_t tile[8][8];
memset(tile, 0, 64);
for (int yp=0;yp<8;yp++)
{
for (int xp=0;xp<8;xp++)
{
tile[(stat&0x8000)?7-yp:yp][(stat&0x4000)?7-xp:xp]=
((vram[tileoff+yp+0]>>(0+7-xp))&1)<<0|
((vram[tileoff+yp+0]>>(8+7-xp))&1)<<1|
((vram[tileoff+yp+8]>>(0+7-xp))&1)<<2|
((vram[tileoff+yp+8]>>(8+7-xp))&1)<<3;
}
}
for (int xp=0;xp<8;xp++)
{
for (int yp=0;yp<8;yp++)
{
int col=palette[cgram[tile[yp][xp]|pal]];
tilepix[yp*1024+xp]=((col<<16)&0xFF0000)|((col>>0)&0x00FF00)|((col>>16)&0x0000FF);
}
}
}
}
}
}
#endif
|
// Created on: 1993-01-09
// Created by: CKY / Contract Toubro-Larsen ( Kiran )
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESGeom_TransformationMatrix_HeaderFile
#define _IGESGeom_TransformationMatrix_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <IGESData_TransfEntity.hxx>
#include <Standard_Integer.hxx>
class gp_GTrsf;
class IGESGeom_TransformationMatrix;
DEFINE_STANDARD_HANDLE(IGESGeom_TransformationMatrix, IGESData_TransfEntity)
//! defines IGESTransformationMatrix, Type <124> Form <0>
//! in package IGESGeom
//! The transformation matrix entity transforms three-row column
//! vectors by means of matrix multiplication and then a vector
//! addition. This entity can be considered as an "operator"
//! entity in that it starts with the input vector, operates on
//! it as described above, and produces the output vector.
class IGESGeom_TransformationMatrix : public IGESData_TransfEntity
{
public:
Standard_EXPORT IGESGeom_TransformationMatrix();
//! This method is used to set the fields of the class
//! TransformationMatrix
//! - aMatrix : 3 x 4 array containing elements of the
//! transformation matrix
//! raises exception if aMatrix is not 3 x 4 array
Standard_EXPORT void Init (const Handle(TColStd_HArray2OfReal)& aMatrix);
//! Changes FormNumber (indicates the Type of Transf :
//! Transformation 0-1 or Coordinate System 10-11-12)
//! Error if not in ranges [0-1] or [10-12]
Standard_EXPORT void SetFormNumber (const Standard_Integer form);
//! returns individual Data
//! Error if I not in [1-3] or J not in [1-4]
Standard_EXPORT Standard_Real Data (const Standard_Integer I, const Standard_Integer J) const;
//! returns the transformation matrix
//! 4th row elements of GTrsf will always be 0, 0, 0, 1 (not defined)
Standard_EXPORT gp_GTrsf Value() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(IGESGeom_TransformationMatrix,IGESData_TransfEntity)
protected:
private:
Handle(TColStd_HArray2OfReal) theData;
};
#endif // _IGESGeom_TransformationMatrix_HeaderFile
|
#include "SqList.h"
void PrintMenu(void) {
/*
* Function Name: PrintMenu
* Parameter: None
* Return: None
* Use: Print the main menu
*/
printf("\n+-----------------------------------------------------+\n");
printf("| *THE* LINEAR LIST DEMO |\n");
printf("| |\n");
printf("| Functions |\n");
printf("| |\n");
printf("| 1.InitalList 2.DestroyList |\n");
printf("| 3.ClearList 4.IsListEmpty |\n");
printf("| 5.ListLength 6.GetElem |\n");
printf("| 7.LocateElem 8.PriorElem |\n");
printf("| 9.NextElem 10.ListInsert |\n");
printf("| 11.ListDelete 12.ListTraverse |\n");
printf("| |\n");
printf("| 0.Exit |\n");
printf("| |\n");
printf("| 78ij@8102 |\n");
printf("| |\n");
printf("+-----------------------------------------------------+\n");
printf("\n");
}
status LoadData(SqList **head) {
/*
* Function Name: LoadData
* Parameter: std::vector<SqList> lists
* Return Status(int)
* Use: load data from file
*/
FILE *fp = fopen("SLDB", "rb");
if (fp == NULL)
return ERROR;
int size = 0;
int count = 0;
SqList *tmp = (SqList *)malloc(sizeof(SqList));
size = fread(tmp, sizeof(SqList), 1, fp);
if (size == 0)
return OK;
count++;
tmp->head = (int *)malloc(sizeof(int) * tmp->listsize);
size = fread(tmp->head, sizeof(int) * tmp->listsize, 1, fp);
*head = tmp;
while (1) {
SqList *tmp = (SqList *)malloc(sizeof(SqList));
size = fread(tmp, sizeof(SqList), 1, fp);
if (size == 0)
break;
count++;
tmp->head = (int *)malloc(sizeof(int) * tmp->listsize);
size = fread(tmp->head, sizeof(int) * tmp->listsize, 1, fp);
(*head)->next = tmp;
*head = (*head)->next;
}
(*head)->next = NULL;
*head = tmp;
fclose(fp);
return OK;
}
status SaveData(SqList *head) {
/*
* Function Name: SaveData
* Parameter: vector<SqList> lists
* Return: Status(int)
* Use: save data to file
*/
FILE *fp = fopen("SLDB", "wb");
if (fp == NULL)
return ERROR;
SqList *L = head,*p = head;
while (L != NULL) {
fwrite(L, sizeof(SqList), 1, fp);
fwrite(L->head, sizeof(int) * L->listsize, 1, fp);
p = L->next;
DestroyList(*L);
L = p;
}
fclose(fp);
return OK;
}
int main() {
int selection = -1;
SqList *head = NULL;
while (selection != 0){
PrintMenu();
scanf("%d", &selection);
LoadData(&head);
SqList *L = head;
SqList *tmp = head;
int list_index;
switch (selection) {
case -1: //for debug purposes
while (head != NULL) {
printf("ListID:%d\tListlength:%d\tListsize:%d\n", head->ListID,head->length,head->listsize);
head = head->next;
}
head = L;
break;
case 1:
printf("* Function Name: InitaList\n");
printf("* Parameter: SqList &L\n");
printf("* Return: Status(int)\n");
printf("* Use: initialize the linear list\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head != NULL) {
printf("Error, the list %d already exist.\n", list_index);
}
else {
SqList *new_list = (SqList *)malloc(sizeof(SqList));
if (IntiaList(*new_list) == OK) {
printf("Inital the list %d succeed.\n", list_index);
new_list->ListID = list_index;
new_list->next = L;
head = new_list;
}
else {
printf("ERROR, something wrong with the RAM\n");
}
}
printf("\n");
break;
case 2:
printf("/*\n");
printf("* Function Name: DestroyList\n");
printf("* Parameter: SqList &L\n");
printf("* Return: Status(int)\n");
printf("* Use: destroy the linear list\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
break;
}
if (head->ListID == list_index) {
head = head->next;
DestroyList(*L);
printf("List %d has been removed\n", list_index);
break;
}
while (head->next != NULL) {
if (head->next->ListID == list_index)
break;
head = head->next;
}
if (head->next == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
L = head->next;
head->next = head->next->next;
DestroyList(*L);
printf("List %d has been removed\n", list_index);
head = tmp;
}
printf("\n");
break;
case 3:
printf("* Function Name: ClearList\n");
printf("* Parameter: SqList &L\n");
printf("* Return: Status(int)\n");
printf("* Use: make the list empty\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
ClearList(*head);
head = L;
printf("the list %d has been cleared.\n", list_index);
}
printf("\n");
break;
case 4:
printf("* Function Name: ListEmpty\n");
printf("* Parameter: const SqList &L\n");
printf("* Return: bool\n");
printf("* Use: check if the list is empty.\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
bool isempty = ListEmpty(*head);
head = L;
if(isempty)
printf("the list %d is empty.\n", list_index);
else
printf("the list %d is not empty.\n", list_index);
}
printf("\n");
break;
case 5:
printf("* Function Name: ListLength\n");
printf("* Parameter: SqList &L\n");
printf("* Return: int\n");
printf("* Use: returns the length of the list.\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
int length = ListLength(*head);
head = L;
printf("the list %d's length is %d.\n", list_index, length);
}
printf("\n");
break;
case 6:
printf("* Function Name: GetElem\n");
printf("* Parameter: const SqList &L, int i ElemType &e\n");
printf("* Return: Status(int)\n");
printf("* Use: get the i-th element of the list(i starts from 1)\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
printf("please enter the element number:\n");
int num;
ElemType value;
scanf("%d", &num);
status res = GetElem(*head, num, value);
head = L;
if (res == ERROR) {
printf("Sorry, your number is out of bound.\n");
break;
}
else
printf("the element value is %d.\n", value);
}
printf("\n");
break;
case 7:
printf("* Function Name: LocateElem\n");
printf("* Parameter: const SqList &L, const ElemType &e\n");
printf("* Return: int\n");
printf("* Use: return the number of the element that equals the parameter(number starts from 1)\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
printf("please enter the element value:\n");
ElemType value;
scanf("%d", &value);
int res = LocateElem(*head, value);
head = L;
if (res == 0) {
printf("Sorry, no such element.\n");
break;
}
else
printf("the element number is %d.\n", res);
}
printf("\n");
break;
case 8:
printf("* Function Name: PriorElem\n");
printf("* Parameter: const SqList &L, ElemType &cur_e, ElemType &pre_e\n");
printf("* Return: Status(int)\n");
printf("* Use: get the the prior element of the specified element, pass it using parameter.\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
printf("please enter the element value:\n");
ElemType cur;
ElemType value;
scanf("%d", &cur);
status res =PriorElem(*head, cur,value);
head = L;
if (res == ERROR) {
printf("Sorry, we encounter an error.\n");
break;
}
else
printf("the prior element number is %d.\n", value);
}
printf("\n");
break;
case 9:
printf("* Function Name: NextElem\n");
printf("* Parameter: const SqList &L, ElemType &cur_e, ElemType &next_e\n");
printf("* Return: Status(int)\n");
printf("* Use: get the the next element of the specified element, pass it using parameter.\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
printf("please enter the element value:\n");
ElemType cur;
ElemType value;
scanf("%d", &cur);
status res = NextElem(*head, cur, value);
head = L;
if (res == ERROR) {
printf("Sorry, we encounter an error.\n");
break;
}
else
printf("the next element number is %d.\n", value);
}
printf("\n");
break;
case 10:
printf("* Function Name: ListInsert\n");
printf("* Parameter: SqList &L, int i, ElemType &e\n");
printf("* Return: Status(int)\n");
printf("* Use: insert an element after the specifyed number(the list must be non-empty)\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
int num;
ElemType e;
printf("please input the number of the element\n");
scanf("%d", &num);
printf("please input the inserted value:\n");
scanf("%d", &e);
status res = ListInsert(*head, num, e);
head = L;
if (res == ERROR) {
printf("Sorry, we encounter an error.\n");
break;
}
else
printf("value %d has been successfully insert to the %d position of %d list.", e, num, list_index);
}
printf("\n");
break;
case 11:
printf("* Function Name: ListDelete\n");
printf("* Parameter: SqList &L, int i, ElemType &e\n");
printf("* Return: Status(int)\n");
printf("* Use: Delete the specified element.\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
int num;
printf("please input the number of the element\n");
scanf("%d", &num);
ElemType e;
status res = ListDelete(*head, num,e);
head = L;
if (res == ERROR) {
printf("Sorry, we encounter an error.\n");
break;
}
else
printf("value %d has benn successfully delete, it's in %d position of %d list.", e, num, list_index);
}
printf("\n");
break;
case 12:
printf("* Function Name: ListTraverse\n");
printf("* Parameter: const SqList &L\n");
printf("* Return: Status(int)\n");
printf("* Use: Traverse the list and output its elements.\n");
printf("please enter the id of the list:");
scanf("%d", &list_index);
while (head != NULL) {
if (head->ListID == list_index)
break;
head = head->next;
}
if (head == NULL) {
printf("Error, the list %d does not exist.\n", list_index);
head = L;
}
else {
printf("Traverse the %d-th list:\n", list_index);
ListTraverse(*head);
head = L;
}
printf("\n");
break;
case 0:
printf("Thank you for using~\n");
break;
default:
printf("no such selection.\n");
break;
}
SaveData(head);
}
return 0;
}
|
#ifndef HTTPWORKER_H
#define HTTPWORKER_H
#include <QObject>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QTextCodec>
#include <QStringList>
#include <QRegExp>
#include <QSemaphore>
#include <QMutex>
#include <QMutexLocker>
#include <QVector>
#include <QPoint>
#include <QDebug>
class QHttpWorker : public QObject
{
Q_OBJECT
Q_PROPERTY(bool isPaused READ getPaused WRITE setPause)
Q_PROPERTY(bool isWorking READ getWorking WRITE setWorking)
Q_PROPERTY(int workerId READ getId WRITE setId)
public:
explicit QHttpWorker(QObject *parent = 0);
~QHttpWorker();
bool getPaused() const {QMutexLocker locker(&_pause_mutex); return _isPaused;}
bool getWorking() const {QMutexLocker locker(&_pause_mutex); return _isWorking;}
int getId() const {QMutexLocker locker(&_pause_mutex); return _id;}
void setId(int id) {QMutexLocker locker(&_pause_mutex); _id = id;}
void setCaseSensitive(bool cs) {QMutexLocker locker(&_pause_mutex); _case_sens =(cs? Qt::CaseSensitive : Qt::CaseInsensitive) ;}
QString getPage() const {QMutexLocker locker(&_pause_mutex); return _page;}
signals:
void searchFinished(QString header, QString page, QVector<QPoint> positions);
void urlFound(QUrl url);
void finished();
void requestWork(int id);
public slots:
void start();
void startSearch(QUrl url, QString text);
void pause();
void resume();
void stop();
void setPause(bool pause_state) {if (pause_state) pause(); else resume();}
private slots:
void replyRecived(QNetworkReply * reply);
private:
void setWorking(bool working_state) {QMutexLocker locker(&_pause_mutex); _isWorking = working_state;}
void findUrls();
void findText();
bool _isWorking;
bool _isPaused;
Qt::CaseSensitivity _case_sens;
QSemaphore _pause_sem;
mutable QMutex _pause_mutex;
QNetworkAccessManager * _namanager;
QVector<QPoint> * _found_pos;
int _id;
QString _text;
QUrl _url;
QString _page;
};
#endif // HTTPWORKER_H
|
///////////////////////////////////////
//
// Computer Graphics TSBK03
// Conrad Wahlén - conwa099
//
///////////////////////////////////////
#include "Model.h"
#include "GL_utilities.h"
#include <iostream>
Model::Model() {
subDrawID = 0;
subVoxelizeID = 0;
diffuseID = 0;
maskID = 0;
diffColor = glm::vec3(1.0f, 0.0f, 0.0f);
vao = 0;
}
void Model::SetMaterial(TextureData* textureData) {
subDrawID = textureData->subID;
subVoxelizeID = (GLuint)(subDrawID != 0);
diffuseID = textureData->diffuseID;
maskID = textureData->maskID;
diffColor = textureData->diffColor;
}
void Model::SetStandardData(size_t numVertices, GLfloat* verticeData,
size_t numNormals, GLfloat* normalData,
size_t numIndices, GLuint* indexData,
size_t numTangents, GLfloat* tangentData,
size_t numBiTangents, GLfloat* biTangentData) {
nIndices = numIndices;
// Create buffers
if(vao == 0) {
glGenVertexArrays(1, &vao);
}
glGenBuffers(5, meshBuffers);
// Allocate enough memory for instanced drawing buffers
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * numVertices, verticeData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * numNormals, normalData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[2]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * numTangents, tangentData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[3]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * numBiTangents, biTangentData, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshBuffers[4]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * numIndices, indexData, GL_STATIC_DRAW);
// Set the GPU pointers for drawing
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[0]);
glEnableVertexAttribArray(VERT_POS);
glVertexAttribPointer(VERT_POS, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[1]);
glEnableVertexAttribArray(VERT_NORMAL);
glVertexAttribPointer(VERT_NORMAL, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[2]);
glEnableVertexAttribArray(VERT_TANGENT);
glVertexAttribPointer(VERT_TANGENT, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, meshBuffers[3]);
glEnableVertexAttribArray(VERT_BITANGENT);
glVertexAttribPointer(VERT_BITANGENT, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshBuffers[4]);
glBindVertexArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
void Model::SetTextureData(size_t numTexCoords, GLfloat* texCoordData) {
if(vao == 0) {
glGenVertexArrays(1, &vao);
}
glGenBuffers(1, &texbufferID);
// Allocate enough memory for instanced drawing buffers
glBindBuffer(GL_ARRAY_BUFFER, texbufferID);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * numTexCoords, texCoordData, GL_STATIC_DRAW);
// Set the data pointer for the draw program
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, texbufferID);
glEnableVertexAttribArray(VERT_TEX_COORD);
glVertexAttribPointer(VERT_TEX_COORD, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindVertexArray(0);
}
void Model::SetPositionData(GLuint positionBufferID) {
if(vao == 0) {
glGenVertexArrays(1, &vao);
}
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, positionBufferID);
glEnableVertexAttribArray(DATA_POS);
glVertexAttribIPointer(DATA_POS, 1, GL_UNSIGNED_INT, 0, 0);
glVertexAttribDivisor(DATA_POS, 1);
glBindVertexArray(0);
}
bool Model::hasDiffuseTex() {
return diffuseID != 0;
}
bool Model::hasMaskTex() {
return maskID != 0;
}
void Model::Voxelize() {
glUniform3f(DIFF_COLOR, diffColor.r, diffColor.g, diffColor.b);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseID);
glBindVertexArray(vao);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subVoxelizeID);
glDrawElements(GL_TRIANGLES, (GLsizei)nIndices, GL_UNSIGNED_INT, 0L);
}
void Model::ShadowMap() {
glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, (GLsizei)nIndices, GL_UNSIGNED_INT, 0L);
}
void Model::Draw() {
glUniform3f(DIFF_COLOR, diffColor.r, diffColor.g, diffColor.b);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseID);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, maskID);
glBindVertexArray(vao);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subDrawID);
// Disable cull faces for transparent models
if(hasMaskTex()) {
glDisable(GL_CULL_FACE);
} else {
glEnable(GL_CULL_FACE);
}
glDrawElements(GL_TRIANGLES, (GLsizei)nIndices, GL_UNSIGNED_INT, 0L);
}
|
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define FOR(i,n) for(ll i=0;i<n;i++)
#define FOR1(i,n) for(ll i=1;i<n;i++)
#define FORn1(i,n) for(ll i=1;i<=n;i++)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define mod 1000000007;
using namespace std;
int main() {
// your code goes here
fast;
ll t;
cin>>t;
while(t--)
{
ll n,pos=0,neg=0;
cin>>n;
//ll a[n];
FOR(i,n)
{
ll tmp;
cin>>tmp;
if(tmp>0)
pos++;
else if(tmp<0)
neg++;
}
if(pos==0 || neg==0)
cout<<max(pos,neg)<<" "<<max(pos,neg)<<endl;
else
cout<<max(pos,neg)<<" "<<min(pos,neg)<<endl;
}
return 0;
}
|
#ifndef _JOGADOR_H_
#define _JOGADOR_H_
#include "Personagem.h"
class Jogador : public Personagem
{
private:
const short int num;
// Varável que informa qual é o número do jogador
// jogador 1, jogador 2 etc...
public:
Jogador();
Jogador(const short int N);
~Jogador();
/* Gets */
const short int getnum();
/* Movimentação */
void Movimento();
/* Colisão */
void testecolisao(Jogador* P2, int Xmin, int Xmax, int Ymin, int Ymax);
};
#endif
/* coordenadas da imagem grande
BAIXO X 11 Y 5 || X 140 Y 358 -> L = 129
CIMA X 173 Y 5 || X 302 Y 358 -> A = 353
ESQUERDA X 349 Y 3 || X 702 Y 132 -> L = 353
DIREITA X 348 Y 154 || X = 701 Y 283 -> A = 129
*/
|
/**
* @file test_macro.cpp
*
*
* @author Fan Kai(fk), Peking University
* @date 2008年07月01日 20时55分18秒 CST
*
*/
#define _WRAP(X, Y) {X;Y;}
#define _THROW(EX) {\
LOG_ERROR("throw " <<#EX); \
throw EX; \
}
#define _CATCH(EX, FUNC) catch (EX &ex) {\
LOG_ERROR("catch " <<#EX); \
FUNC; \
}
#define _CATCH_THROW(EX, FUNC) catch (EX &ex) {\
LOG_ERROR("catch " <<#EX); \
FUNC; \
LOG_ERROR("rethrow"); \
throw ex; \
}
void func() {
try {
dosth();
}
_CATCH(std::exception, _WRAP(func2(), cout <<"joke" <<endl))
_CATCH_THROW(std::exception, func3())
_CATCH(std::exception, _WRAP(func(), _THROW(fk::exception())))
_CATCH(ex, break)
}
__DATE__
__FILE__
__LINE__
__STDC__
__STDC_VERSION__
__TIME__
#define LOG(format, ...) printf(format, __VA_ARGS__)
LOG("%s %s", str, count);
_WRAP(a(), b())
#define CONCAT(X, Y) X##Y
CONCAT(x,1)
#define M1(x) mmmm(x)
#define M2(x) xxxx;M1(x);yyy
M2(j)
#undef M1
#define M1(x) nnn(x)
M2(k)
#if 3 > 2
normal
#else
abnormal
#endif
void fk() {
printf("hello world");
printf(__func__);
}
#line 888
__LINE__
__LINE__
__LINE__
#line 88
__LINE__
#error WRONG
|
#include "INTEGER.hpp"
#include "iostream"
INTEGER::INTEGER() {
}
INTEGER::INTEGER(int x1) {
this->x1 = x1;
}
INTEGER::suma(int x, int y) {
return x + y;
}
INTEGER::resta(int x, int y) {
return x - y;
}
INTEGER::division(int x, int y) {
return x / y;
}
INTEGER::multiplicacion(int x, int y) {
return x * y;
}
|
#include "mainwindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
QSqlDatabase db;
createConnectionSqlite(db, "CdCollection");
createTable(db);
removeAllCds(db);
insertCd(db,"Alles wir gut! ", "Nina Ruge ", 2005);
insertCd(db,"Alles wir schlechter!", "A. Schwarzseher", 2015);
insertCd(db,"Katzenklo, Katzenklo ", "Der weiße Helge", 2012);
QStringList allCds = selectAllCds(db);
for(QString row : allCds){
qDebug() << row;
}
return a.exec();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.