blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2 values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905 values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M โ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22 values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 โ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 โ | gha_language stringclasses 141 values | src_encoding stringclasses 34 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 3 10.4M | extension stringclasses 115 values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
42b7a4beaa0aa7c72a3c602c78798b17139c55ba | 3f7ec296f05234f6a2dbcfa0611771f789e9535d | /secsymboldescription.h | 3212c3b8e2e6ad63866c338c9c6a1aaa69b8311f | [] | no_license | NikolayKuksa/stock | b12a4ba5c2d3d89e8e1196521817d75638da17e0 | 5beddd9f467b3254b1f0fa7e3b208e65f7ccc95e | refs/heads/master | 2021-01-19T23:25:46.024404 | 2017-06-10T09:12:40 | 2017-06-10T09:12:40 | 88,982,716 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 585 | h | #ifndef SECSYMBOLDESCRIPTION_H
#define SECSYMBOLDESCRIPTION_H
#include <QVector>
#include "securitytype.h"
#include "miscdef.h"
class SecSymbolDescription
{
private:
QVector<QString> securitySymbols;
QVector<QString> indexSymbols;
QVector<QString> securityDescriptions;
QVector<QString> indexDescriptions;
public:
SecSymbolDescription();
QString getSymbol(int ix, SecurityType secType);
int addSecurity(QString symbol, QString description,SecurityType);
QStringList getAllDescriptions(SecurityType secType);
};
#endif // SECSYMBOLDESCRIPTION_H
| [
"nick.k@i.ua"
] | nick.k@i.ua |
2a7d15c6c28a4b52ac528ded4bf1d16ddbf3f85f | 614369bd9a9452f6b48b9c667b12daacf153d6b8 | /Minji/Programmers/QUEUE,STACK/์ ๋ง๋๊ธฐ.cpp | 126652a90616bd71dbe8c1debb3400d5e6ce45c2 | [] | no_license | minji0320/Algorithm_for_CodingTest | 339ad05a81a89b2645dfab73d7bcbc2df9775d77 | 7fc091f93693d549fa1975044f4b4ff5ee056520 | refs/heads/master | 2022-06-26T05:14:27.149435 | 2021-06-30T00:16:38 | 2021-06-30T00:16:38 | 242,951,278 | 2 | 0 | null | 2020-02-25T08:43:49 | 2020-02-25T08:43:48 | null | UTF-8 | C++ | false | false | 544 | cpp | #include <string>
#include <vector>
using namespace std;
int solution(string arrangement) {
int len = arrangement.size();
int stick = 0;
int new_stick = 0;
int answer = 0;
for(int i = 0; i < len; i++) {
if(arrangement.substr(i,2) == "()"){
answer += stick + new_stick;
new_stick = 0;
i++;
continue;
}
if(arrangement[i] == '('){
stick++;
new_stick++;
}
else
stick--;
}
return answer;
}
| [
"rlaalswl0320@naver.com"
] | rlaalswl0320@naver.com |
a13af8fb866b898e201b39f960149a23b793e1ae | 9be246df43e02fba30ee2595c8cec14ac2b355d1 | /game_shared/tf2/tf_obj_base_manned_gun.h | 4e2a72abc1d43f9ce90b2f6ece51b0fdc47ea795 | [] | no_license | Clepoy3/LeakNet | 6bf4c5d5535b3824a350f32352f457d8be87d609 | 8866efcb9b0bf9290b80f7263e2ce2074302640a | refs/heads/master | 2020-05-30T04:53:22.193725 | 2019-04-12T16:06:26 | 2019-04-12T16:06:26 | 189,544,338 | 18 | 5 | null | 2019-05-31T06:59:39 | 2019-05-31T06:59:39 | null | WINDOWS-1252 | C++ | false | false | 5,003 | h | //========= Copyright ยฉ 1996-2002, Valve LLC, All rights reserved. ============
//
// Purpose: A stationary gun that players can man
//
// $NoKeywords: $
//=============================================================================
#ifndef TF_OBJ_BASE_MANNED_GUN_H
#define TF_OBJ_BASE_MANNED_GUN_H
#ifdef _WIN32
#pragma once
#endif
#include "basetfvehicle.h"
#include "tf_obj_manned_plasmagun_shared.h"
#include "env_laserdesignation.h"
#include "beam_shared.h"
class CMoveData;
#if defined( CLIENT_DLL )
#define CObjectBaseMannedGun C_ObjectBaseMannedGun
#define CBaseTFVehicle C_BaseTFVehicle
#endif
// ------------------------------------------------------------------------ //
// A stationary gun that players can man that's built by the player
// ------------------------------------------------------------------------ //
class CObjectBaseMannedGun : public CBaseTFVehicle
{
public:
DECLARE_NETWORKCLASS();
DECLARE_PREDICTABLE();
DECLARE_CLASS( CObjectBaseMannedGun, CBaseTFVehicle );
CObjectBaseMannedGun();
virtual void Spawn();
virtual void Precache();
virtual void UpdateOnRemove( void );
virtual void GetControlPanelInfo( int nPanelIndex, const char *&pPanelName );
virtual bool CanTakeEMPDamage( void ) { return true; }
virtual void OnGoInactive( void );
// Vehicle overrides
#ifndef CLIENT_DLL
virtual void SetPassenger( int nRole, CBasePlayer *pEnt );
#endif
virtual bool IsPassengerVisible( int nRole = VEHICLE_DRIVER ) { return true; }
// Returns the eye position
virtual void GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles );
// Manned plasma passengers aren't damagable
//virtual bool IsPassengerDamagable( int nRole = VEHICLE_DRIVER ) { return false; }
virtual void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove );
virtual void SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
virtual void FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move );
virtual bool ShouldAttachToParent( void ) { return true; }
virtual bool MustNotBeBuiltInConstructionYard( void ) const { return true; }
virtual bool ShouldUseThirdPersonVehicleView( void );
virtual void BaseMannedGunThink( void );
float GetGunYaw() const;
float GetGunPitch() const;
// Buff
bool CanBeHookedToBuffStation( void );
#if defined ( CLIENT_DLL )
// IClientVehicle overrides.
public:
virtual void DrawHudElements( void );
virtual void UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd );
virtual QAngle GetPassengerAngles( QAngle angCurrent, int nRole );
// C_BaseEntity overrides.
public:
virtual void OnDataChanged( DataUpdateType_t updateType );
virtual void GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS], float dadt);
private:
void DrawCrosshair( void );
#endif
protected:
// Sets up various attachment points once the model is selected
// Derived classes should call this from within their SetTeamModel call
void OnModelSelected();
// Can we get into the vehicle?
virtual bool CanGetInVehicle( CBaseTFPlayer *pPlayer );
// Here's where we deal with weapons
virtual void OnItemPostFrame( CBaseTFPlayer *pPassenger );
// Fire the weapon
virtual void Fire( void ) {}
void StopDesignating( void );
void UpdateDesignator( void );
virtual void SetupAttachedVersion( void );
virtual void SetupUnattachedVersion( void );
// Sets the movement style
void SetMovementStyle( MovementStyle_t style );
// Calculate the max range of this gun
void CalculateMaxRange( float flDefensiveRange, float flOffensiveRange );
protected:
// Movement...
CObjectMannedPlasmagunMovement m_Movement;
float m_flMaxRange;
// attachment points
int m_nBarrelAttachment;
int m_nBarrelPivotAttachment;
int m_nStandAttachment;
int m_nEyesAttachment;
// Movement style
CNetworkVar( MovementStyle_t, m_nMoveStyle );
// Barrel height...
float m_flBarrelHeight;
CNetworkVar( int, m_nAmmoType );
CNetworkVar( int, m_nAmmoCount );
CNetworkVar( float, m_flGunYaw ); // 0 = front, 90 = left, 180 = back, 270 = right
CNetworkVar( float, m_flGunPitch ); // 0 = forward, -90 = pointing down, 90 = pointing up..
CNetworkVar( float, m_flBarrelPitch );
float m_flReturnToInitialTime;
// Laser designation
CNetworkHandle( CBeam, m_hBeam );
CNetworkHandle( CEnvLaserDesignation, m_hLaserDesignation );
#if defined( CLIENT_DLL )
CHudTexture *iconCrosshair;
private:
CObjectBaseMannedGun( const CObjectBaseMannedGun & ); // not defined, not accessible
#endif
};
//-----------------------------------------------------------------------------
// Inline methods
//-----------------------------------------------------------------------------
inline bool CObjectBaseMannedGun::CanBeHookedToBuffStation( void )
{
return true;
}
#endif // TF_OBJ_BASE_MANNED_GUN_H
| [
"uavxp29@gmail.com"
] | uavxp29@gmail.com |
e08b701ec1a743f08718743ae56b168b60903372 | a30af10abb2abe1ab4894f6513eee96e9f7b72e7 | /lab5/assignment2/src/kernel/setup.cpp | 7f1f68b716af4694c70b0849a4b656bf2d0b4d9b | [] | no_license | avarpow/OS_lab | 740a2fe4801e049332fda3d11285101fd5303293 | af61a11fad855607fac8879bdfa8827ae9078339 | refs/heads/main | 2023-06-24T21:43:08.612078 | 2021-07-16T16:39:11 | 2021-07-16T16:39:11 | 348,664,354 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,184 | cpp | #include "asm_utils.h"
#include "interrupt.h"
#include "stdio.h"
#include "program.h"
#include "thread.h"
// ๅฑๅนIOๅค็ๅจ
STDIO stdio;
// ไธญๆญ็ฎก็ๅจ
InterruptManager interruptManager;
// ็จๅบ็ฎก็ๅจ
ProgramManager programManager;
void third_thread(void *arg) {
printf("pid %d name \"%s\": Hello third World!\n", programManager.running->pid, programManager.running->name);
int k=10;
while(k--) {
printf("pid %d name \"%s\": Hello third World!\n", programManager.running->pid, programManager.running->name);
for(int i=0;i<100000000;i++);
}
}
void second_thread(void *arg) {
printf("pid %d name \"%s\": Hello second World!\n", programManager.running->pid, programManager.running->name);
int k=10;
while(k--) {
printf("pid %d name \"%s\": Hello second World!\n", programManager.running->pid, programManager.running->name);
for(int i=0;i<100000000;i++);
}
}
void first_thread(void *arg)
{
// ็ฌฌ1ไธช็บฟ็จไธๅฏไปฅ่ฟๅ
printf("pid %d name \"%s\": Hello first World!\n", programManager.running->pid, programManager.running->name);
if (!programManager.running->pid)
{
programManager.executeThread(second_thread, nullptr, "second thread", 3);
programManager.executeThread(third_thread, nullptr, "third thread", 20);
}
asm_halt();
}
extern "C" void setup_kernel()
{
// ไธญๆญ็ฎก็ๅจ
interruptManager.initialize();
interruptManager.enableTimeInterrupt();
interruptManager.setTimeInterrupt((void *)asm_time_interrupt_handler);
// ่พๅบ็ฎก็ๅจ
stdio.initialize();
// ่ฟ็จ/็บฟ็จ็ฎก็ๅจ
programManager.initialize();
// ๅๅปบ็ฌฌไธไธช็บฟ็จ
int pid = programManager.executeThread(first_thread, nullptr, "first thread", 1);
if (pid == -1)
{
printf("can not execute thread\n");
asm_halt();
}
ListItem *item = programManager.readyPrograms.front();
PCB *firstThread = ListItem2PCB(item, tagInGeneralList);
firstThread->status = RUNNING;
programManager.readyPrograms.pop_front();
programManager.running = firstThread;
asm_switch_thread(0, firstThread);
asm_halt();
}
| [
"648120201@qq.com"
] | 648120201@qq.com |
72e849f4907636d3172f70bd86ab8b997df6450d | 36f533088d1c5a93e058bc72a6d643ee262e4401 | /CodeAdapter/EllipseArtist.cpp | b7d981f062d434141723a0319790214fd559eede | [
"MIT"
] | permissive | NeuroWhAI/CodeAdapter | 3fd16b3538d76f0c9d835ea370e94f6d8c1bd027 | b07815b9a610f74bcd50ae198a02b5131389cab7 | refs/heads/master | 2021-04-15T09:40:52.092641 | 2017-04-07T13:26:50 | 2017-04-07T13:26:50 | 55,895,368 | 7 | 3 | null | 2016-09-04T04:42:01 | 2016-04-10T11:34:11 | C++ | UTF-8 | C++ | false | false | 164 | cpp | #include "EllipseArtist.h"
BEGIN_NAMESPACE_CA_DRAWING
EllipseArtist::EllipseArtist()
{
}
EllipseArtist::~EllipseArtist ()
{
}
END_NAMESPACE_CA_DRAWING
| [
"neurowhai@gmail.com"
] | neurowhai@gmail.com |
05b9f64ee7d23ac0f7ffbeaa4db0ecf936cf49c5 | 37525014a50e09ea0507331206e4d835a94e29ce | /wire_core/include/wire/core/IStateEstimator.h | 496bd20850f5acced2f9681487c5b2fa2ecfe359 | [
"BSD-2-Clause"
] | permissive | ropod-project/wire | 11b40c1d821a125a5edf665f0cafc66564f92abe | 4962c36d5749a4f4aaea6a8c4610f5a1373ac5e4 | refs/heads/master | 2020-05-19T21:11:00.711705 | 2019-06-24T10:45:43 | 2019-06-24T10:45:43 | 185,217,799 | 1 | 1 | BSD-2-Clause | 2019-05-06T14:54:37 | 2019-05-06T14:54:36 | null | UTF-8 | C++ | false | false | 5,750 | h | /************************************************************************
* Copyright (C) 2012 Eindhoven University of Technology (TU/e). *
* All rights reserved. *
************************************************************************
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted provided that the following conditions *
* are met: *
* *
* 1. Redistributions of source code must retain the above *
* copyright notice, this list of conditions and the following *
* disclaimer. *
* *
* 2. Redistributions in binary form must reproduce the above *
* copyright notice, this list of conditions and the following *
* disclaimer in the documentation and/or other materials *
* provided with the distribution. *
* *
* THIS SOFTWARE IS PROVIDED BY TU/e "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 TU/e 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. *
* *
* The views and conclusions contained in the software and *
* documentation are those of the authors and should not be *
* interpreted as representing official policies, either expressed or *
* implied, of TU/e. *
************************************************************************/
#ifndef WM_I_STATE_ESTIMATOR_H_
#define WM_I_STATE_ESTIMATOR_H_
#include "wire/core/datatypes.h"
#include "problib/pdfs/PDF.h"
namespace mhf {
/**
* @author Sjoerd van den Dries
* @date December, 2012
*
* @brief Base class for all state estimators used by the world model.
*
* A state estimator estimates the value of one specific attribute
* of one specific object in the world. The attribute value is represented
* by a probability density over the domain of the attribute. For example,
* a position can be represented by a PDF over Cartesian space. A state
* estimator should implement three methods: propagate(Time t), which
* changes the internal state of the estimator to the estimated value at
* Time t; update(PDF z, Time time) which updates the internal state
* based on measurement z at Time t; and getValue() which returns the
* current state.
*/
class IStateEstimator {
public:
virtual ~IStateEstimator() {}
virtual IStateEstimator* clone() const = 0;
/**
* @brief Propagates the internal state to Time time
* @param time The time to which the internal state is propagated
*/
virtual void propagate(const Time& time) = 0;
/**
* @brief Updates the internal state based on measurement z
* @param z The measurement with which to update, represented as a probability density function
* @param time The time to which the internal state is propagated before updating
*/
virtual void update(const pbl::PDF& z, const Time& time) = 0;
/**
* @brief Resets the internal state of the estimator to its initial value
*/
virtual void reset() = 0;
/**
* @brief Returns the current estimated state value
* @return The current state, i.e., the current attribute value represented as probability density function
*/
virtual const pbl::PDF& getValue() const = 0;
/**
* @brief Resets the internal state of the estimator to the given PDF
* @param pdf The value to which the internal state is set
*/
//virtual void setValue(const pbl::PDF& pdf) {
//}
/**
* @brief Set a boolean parameter of this state estimator
* @param param The parameter name
* @param b The boolean value
* @return Returns true if the parameter was known to the estimator; false otherwise
*/
virtual bool setParameter(const std::string& param, bool b) {
return false;
}
/**
* @brief Set a real-valued parameter of this state estimator
* @param param The parameter name
* @param v The float value
* @return Returns true if the parameter was known to the estimator; false otherwise
*/
virtual bool setParameter(const std::string& param, double v) {
return false;
}
/**
* @brief Set a string parameter of this state estimator
* @param param The parameter name
* @param s The string value
* @return Returns true if the parameter was known to the estimator; false otherwise
*/
virtual bool setParameter(const std::string& param, const std::string& s) {
return false;
}
};
}
#endif /* WM_I_STATE_ESTIMATOR_H_ */
| [
"jos.elfring@tno.nl"
] | jos.elfring@tno.nl |
0a3edb5da0ac0aa14f423831d3cf6a897c9a9f0f | 75d4ee482b9c42694069db8f99c43a7fca40b35e | /src/twist_unstamper_node.cpp | 8381a75034266ee6989feafec4046a7315168bcf | [] | no_license | joshs333/twist_tools | 1fc70d8b487384d4e7e8758eae30308b39f76776 | b6606b5b7601aec1dc1631deea4f47bc21a46f11 | refs/heads/master | 2022-12-24T23:48:27.406809 | 2020-10-05T09:40:38 | 2020-10-05T09:40:38 | 301,355,271 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,929 | cpp | /**
* @brief Node that inputs a stamped twist message and outputs a regular twist message
* @author Joshua Spisak <joshs333@live.com>
* @date October 5, 2020
* @license MIT
**/
// ROS
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <geometry_msgs/TwistStamped.h>
namespace twist_tools {
/**
* @brief node that subscribes to a twist stamped and outputs a twist message
**/
class TwistUnstamperNode {
public:
/**
* @brief parameters for creating node
**/
struct Params {
//! Input twist stamped topic
std::string input_twist_stamped = "/twist_stamped_in";
//! Output twist topic
std::string output_twist = "/twist_out";
};
/**
* @brief creates node
* @param nh nodehandle to use to create topics, etc..
* @param params general params to generate node with
**/
TwistUnstamperNode(ros::NodeHandle& nh, Params& params) {
input_sub_ = nh.subscribe<geometry_msgs::TwistStamped>(params.input_twist_stamped, 1, &TwistUnstamperNode::twistCB, this);
output_pub_ = nh.advertise<geometry_msgs::Twist>(params.output_twist, 1, true);
}
/**
* @brief callback for twist messages
* @param input the input twist message
**/
void twistCB(const geometry_msgs::TwistStamped::ConstPtr& input) {
output_pub_.publish(input->twist);
}
private:
//! Input Sub
ros::Subscriber input_sub_;
//! Output Publisher
ros::Publisher output_pub_;
}; // TwistUnstamperNode
}; /* namespace twist_tools */
int main(int argc, char** argv) {
ros::init(argc, argv, "twist_stamper_node");
ros::NodeHandle nh("~");
twist_tools::TwistUnstamperNode::Params params;
nh.getParam("input_twist_stamped", params.input_twist_stamped);
nh.getParam("output_twist", params.output_twist);
twist_tools::TwistUnstamperNode node(nh, params);
ros::spin();
return 0;
} | [
"joshs333@live.com"
] | joshs333@live.com |
7eb154e0971736f90fd8e1624a9f14a56af7a73b | 83421eb1258fdbf93289d57b11a4160794664d7a | /src/general/mapa/Cubo.h | 47043b7289a413dadfb3c96aafe11a95b6907c41 | [] | no_license | BlenderCN-Org/nature | 2511efdb56e0a1b61c363f7e6caf5f29a6a820a2 | c7976a533e299baf1473775a592c892feefba853 | refs/heads/master | 2020-05-23T21:29:00.591053 | 2015-07-11T06:20:39 | 2015-07-11T06:20:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 516 | h | #ifndef _CUBO_H_
#define _CUBO_H_
#include "includeglm.h"
#include <iostream>
class Cubo{
public:
glm::vec3 p1;//punto
glm::vec3 p2;//tamanio
glm::vec3 t;//tamanio
glm::vec3 c;//centro
Cubo(glm::vec3 p1,glm::vec3 t){
set(p1,t);
}
void set(glm::vec3 p1,glm::vec3 t){
this->p1=p1;
this->t=t;
this->p2=p1+t;
c=p1+(t*0.5f);
}
};
std::ostream& operator<<(std::ostream& o,Cubo c);
#endif
| [
"forestmedina@gmail.com"
] | forestmedina@gmail.com |
fb418c976700f0c1c2b0a955b9099458220f228b | 9fe8defd8579cc805da43db25b5098c123c81e34 | /contest/dev2_a.cpp | 704bdfa963d46bd369ee66ecaada7f3fd8643568 | [] | no_license | Kanonahmed/ACM-Programming | a9ea92b3e6031a6a7c022d6359110ba0ff43ecb6 | 7ebb662e92cb334ecdf519278cdba39af9a1f67c | refs/heads/master | 2021-07-05T23:57:16.330893 | 2017-09-30T19:45:47 | 2017-09-30T19:45:47 | 105,396,479 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,042 | cpp | #include<bits/stdc++.h>
using namespace std;
#define xx first
#define yy second
#define pb push_back;
#define mp make_pair
#define LL long long
#define PI acos(-1.0)
#define AND(a,b) ((a) & (b))
#define OR(a,b) ((a)|(b))
#define XOR(a,b) ((a) ^ (b))
#define f1(i,n) for(int i=1;i<=n;i++)
#define f0(i,n) for(int i=0;i<n;i++)
#define meminf(B) memset(B,126,sizeof B)
#define all(a) a.begin(),a.end()
#define DEG_to_REDI(X) (X*PI/180)
#define REDI_to_DEG(X) (180*X/(PI))
#define UB(a,x) (upper_bound(all(a),x)-a.begin())
#define LB(a,x) (lower_bound(all(a),x)-a.begin())
#define countbit(x) __builtin_popcountll((ll)x)
//File input/output
#define input freopen("in.txt","r",stdin)
#define output freopen("out.txt","w",stdout)
template <class T> inline T bigmod(T p,T e,T M){
LL ret = 1;
for(; e > 0; e >>= 1){
if(e & 1) ret = (ret * p) % M;
p = (p * p) % M;
} return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}
/* ----------------------------------------
| Scratch where itches |
---------------------------------------- */
int Set(int N,int pos){ return N=N | (1<<pos);}
int Reset(int N,int pos){return N= N & ~(1<<pos);}
bool Chkbit(int N,int pos){return (bool)(N & (1<<pos));}
int month[]={-1,31,28,31,30,31,30,31,31,30,31,30,31}; //Not Leap Year
int dx[]={1,0,-1,0};int dy[]={0,1,0,-1}; //4 Direction
//int dx[]={1,1,0,-1,-1,-1,0,1};int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction
//int dx[]={2,1,-1,-2,-2,-1,1,2};int dy[]={1,2,2,1,-1,-2,-2,-1};//Knight Direction
//int dx[]={-1,-1,+0,+1,+1,+0};int dy[]={-1,+1,+2,+1,-1,-2}; //Hexagonal Direction
const double eps=1e-6;
int main()
{
int tc,ks=1;
cin>>tc;
while(tc--)
{
LL a,b;
cin>>a>>b;
a*=2LL;
printf("Case %d: %lld\n",ks++,(a*a-b*b));
}
return 0;
}
| [
"kanoncse41@gmail.com"
] | kanoncse41@gmail.com |
bd8750915d2e51006bb6509b27bc4a92c08e204d | 0543967d1fcd1ce4d682dbed0866a25b4fef73fd | /Midterm/solutions/midterm2017_72/L/000757-midterm2017_72-L.cpp | 2d685049cd5c95e3bb428a05a2a37f55354671e8 | [] | no_license | Beisenbek/PP12017 | 5e21fab031db8a945eb3fa12aac0db45c7cbb915 | 85a314d47cd067f4ecbbc24df1aa7a1acd37970a | refs/heads/master | 2021-01-19T18:42:22.866838 | 2017-11-25T12:13:24 | 2017-11-25T12:13:24 | 101,155,127 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 544 | cpp | #include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
using namespace std;
int b[1000],n,a[700][700],s1=0,s2=0,m,maxx,d=0,in;
int main()
{
cin>>n>>m;
for (int i=1;i<=n;++i)
for (int j=1;j<=m;++j)
{
cin>>a[i][j];
if (a[i][j]>0)
b[i]++;
}
maxx=b[1];
for (int i=1;i<=n;++i)
maxx=max(maxx,b[i]);
for (int i=1;i<=n;++i)
if (maxx==b[i])
in=i;
for (int i=1;i<=n;++i)
{
if (maxx!=b[i])
{
cout<<in;
return 0;
}
}
cout<<"Numbers are equal";
}
| [
"beysenbek@gmail.com"
] | beysenbek@gmail.com |
f931c298661803dab5720eca3beca6534316f49a | 90b1a86c16b0f7f99cb0bff3f05476dd95bd8697 | /source/kdpHistogram.cpp | 055c4523c10f33db577e68a479d52f6c7d326f86 | [] | no_license | keith-pedersen/libkdp | ade52b70630c2749e10b49c342ef4468f5daa081 | 99d26540f304ec94e76a967e7b8292b1fc6fd829 | refs/heads/master | 2020-03-24T16:40:23.029467 | 2019-01-27T00:40:38 | 2019-01-27T00:40:38 | 142,832,010 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 37,024 | cpp | // Copyright (C) 2016-2018 by Keith Pedersen (Keith.David.Pedersen@gmail.com)
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "kdpHistogram.hpp"
#include <fstream>
#include <limits>
#include <iostream>
#include <assert.h>
#include <algorithm>
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
____
| _ \ __ _ _ __ __ _ ___
| |_) / _` | '_ \ / _` |/ _ \
| _ < (_| | | | | (_| | __/
|_| \_\__,_|_| |_|\__, |\___|
|___/
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
template<typename edge_t>
kdp::Range<edge_t>::Range():Range(0., 1.) {}
template<typename edge_t>
kdp::Range<edge_t>::Range(edge_t const min_in, edge_t const max_in):
min(min_in), max(max_in)
{CheckSortedAndNumeric();}
template<typename edge_t>
kdp::Range<edge_t>::Range(std::initializer_list<edge_t> const& init)
{
if(init.size() not_eq 2)
throw std::invalid_argument("|Range| initializer_list must have 2 values");
min = *init.begin();
max = *(init.begin() + 1);
CheckSortedAndNumeric();
}
template<typename edge_t>
bool kdp::Range<edge_t>::operator == (Range const& that) const
{
return (this->min == that.min) and (this->max == that.max);
}
template<typename edge_t>
void kdp::Range<edge_t>::CheckSortedAndNumeric()
{
if(min > max) throw std::invalid_argument("|Range| min > max");
if(std::isnan(min)) throw std::invalid_argument("|Range| min = nan");
if(std::isnan(max)) throw std::invalid_argument("|Range| max = nan");
}
template class kdp::Range<float>;
template class kdp::Range<double>;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_____ _ _ _ ____
| ___(_)_ __ (_) |_ ___| _ \ __ _ _ __ __ _ ___
| |_ | | '_ \| | __/ _ \ |_) / _` | '_ \ / _` |/ _ \
| _| | | | | | | || __/ _ < (_| | | | | (_| | __/
|_| |_|_| |_|_|\__\___|_| \_\__,_|_| |_|\__, |\___|
|___/
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
template<typename edge_t>
kdp::FiniteRange<edge_t>::FiniteRange(edge_t const min_in, edge_t const max_in):
Range<edge_t>(min_in, max_in)
{CheckFinite();}
template<typename edge_t>
kdp::FiniteRange<edge_t>::FiniteRange(std::initializer_list<edge_t> const& init):
Range<edge_t>(init)
{CheckFinite();}
template<typename edge_t>
void kdp::FiniteRange<edge_t>::CheckFinite()
{
if(std::isinf(this->min)) throw std::invalid_argument("|Range| min = -inf, must be finite");
if(std::isinf(this->max)) throw std::invalid_argument("|Range| max = inf, must be finite");
}
template class kdp::FiniteRange<float>;
template class kdp::FiniteRange<double>;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
____ _ ____
| __ )(_)_ __ / ___| _ __ ___ ___ ___
| _ \| | '_ \\___ \| '_ \ / _ \/ __/ __|
| |_) | | | | |___) | |_) | __/ (__\__ \
|____/|_|_| |_|____/| .__/ \___|\___|___/
|_|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
kdp::edge_t const kdp::BinSpecs::INF = std::numeric_limits<edge_t>::infinity();
// numBins ctor
kdp::BinSpecs::BinSpecs(std::string const& name_in,
size_t const numBins_in,
std::initializer_list<edge_t> const& range_init,
UniformBinType const binType_in):
name(name_in), numBins(numBins_in),
range(), // Set below, to catch and rethrow exceptions, appending name
binWidth(-1.), // Set below, to keep conditional out of init list
binType(static_cast<BinType>(static_cast<int>(binType_in))),
pinned(PinnedEdge::BOTH) // Only option, given numBins
{
try
{
if(numBins == 0) throw std::invalid_argument("not enough bins supplied");
range = range_init;
UniformSanityChecks();
binWidth = ((binType == BinType::UNIFORM) ?
(range.max - range.min) :
std::log(range.max/range.min))/edge_t(numBins); // LOG_UNIFORM
FillEdges(false); // fromWidth = false
}
catch(std::exception& e)
{
ExceptionHandler(e);
}
}
// width/scale ctor
kdp::BinSpecs::BinSpecs(std::string const& name_in,
std::initializer_list<edge_t> const& range_init,
edge_t widthOrScale,
UniformBinType const binType_in, PinnedEdge const pinned_in):
name(name_in),
numBins(1), // Default value, will determine in FillEdges
range(), // Set below, to catch and rethrow exceptions, appending name
binWidth(-1.), // Set below, to keep conditional out of init list
binType(static_cast<BinType>(static_cast<int>(binType_in))),
pinned(pinned_in)
{
try
{
range = range_init;
UniformSanityChecks();
binWidth = (binType == BinType::UNIFORM) ?
widthOrScale :
std::log(widthOrScale);
FillEdges(true); // fromWidth = true
}
catch(std::exception& e)
{
ExceptionHandler(e);
}
}
// NON_UNIFORM ctor
kdp::BinSpecs::BinSpecs(std::string const& name_in,
std::vector<edge_t> const& edges_in):
name(name_in),
numBins(edges_in.size() - 1), // this could be very large if edges is empty
range(),// If edges_in is empty, trying to construct range would cause SEG_FAULT
binWidth(-1.), // nonsensical value
binType(BinType::NON_UNIFORM),
pinned(PinnedEdge::BOTH) // Only option, given edges
{
try
{
if(edges_in.size() < 2) throw std::invalid_argument("< 2 edges supplied, cannot form a bin");
else range = {edges_in.front(), edges_in.back()};
SharedSanityChecks();
// Verify the supplied edges are all finite
// DO NOT attempt to fix anything, let the user decide how to fix it
// (that way they are not surprised about this behavior under the hood)
{
auto prevEdge = edges_in.begin();
for(auto thisEdge = prevEdge + 1; thisEdge not_eq edges_in.end(); ++prevEdge, ++thisEdge)
{
// The duplicate check will only find all duplicates in a sorted list
// But an unsorted list will fail the sorting test
if(*thisEdge == *prevEdge) throw std::invalid_argument("edge list has duplicates");
if(*thisEdge < *prevEdge) throw std::invalid_argument("edge list not sorted");
if(std::isinf(*thisEdge)) throw std::invalid_argument("supplied edge is +/-inf");
if(std::isnan(*thisEdge)) throw std::invalid_argument("supplied edge is nan");
}
}
// Copy in input edges, padding infinity on each side
edges.reserve(numBins + 2);
edges.push_back(-INF);
edges.insert(edges.end(), edges_in.begin(), edges_in.end());
edges.push_back(INF);
}
catch(std::exception& e)
{
ExceptionHandler(e);
}
}
// Define this, otherwise -Winline complains about not inlining it
kdp::BinSpecs::~BinSpecs(){}
// Sanity checks used by all three ctors
void kdp::BinSpecs::SharedSanityChecks()
{
if(numBins > BinSpecs::MAX_BINS)
throw std::invalid_argument(std::to_string(numBins) + " = too many bins supplied");
}
// Sanity checks only used by UNIFORM/NON_UNIFORM
void kdp::BinSpecs::UniformSanityChecks()
{
if(range.min == range.max) // FiniteRange will accept this, but we can't
throw std::invalid_argument("min == max, cannot create bins");
SharedSanityChecks();
}
// When width/scale is supplied, make sure the resulting numBins is sensible
void kdp::BinSpecs::CalculatedNumBinsSanityChecks()
{
if(numBins == 0)
throw std::invalid_argument("Zero bins from width/scale ... this shouldn't happen (code logic error)");
else if(numBins > BinSpecs::MAX_BINS)
throw std::invalid_argument(std::to_string(numBins) + " = too many bins from width/scale");
}
bool kdp::BinSpecs::operator==(BinSpecs const& that) const
{
if(this == &that) return true;
else
{
// There must be the same number of bins spanning the same range
if((this->numBins == that.numBins) and
(this->range == that.range))
{
// If either is NON_UNIFORM, the only way to be absolutely sure
// is to check edge by edge
if((this->binType == BinType::NON_UNIFORM) or (that.binType == BinType::NON_UNIFORM))
{
auto itThis = this->edges.begin();
auto itThat = that.edges.begin();
// Keep iterating while both edges are the same and we
// haven't hit the end of either list
while(
(itThis not_eq this->edges.end()) and
(itThat not_eq that.edges.end()) and
(*itThis == *itThat))
{++itThis; ++itThat;}
// If all edges are the same, then both iterators should be
// at the end of their lists
return (itThis == this->edges.end()) and (itThat == that.edges.end());
}
else
{
// Otherwise, if both are uniform, then as long as they have
// identical binWidths and binTypes, they're the same
// (even if pinned is different). This is due to the algorithm
// which fills the bins, since it only depends on
// min, max, numBins, binWidth and binType
return ((this->binWidth == that.binWidth) and
(this->binType == that.binType));
}
}
else return false;
}
}
void kdp::BinSpecs::FillEdges(bool const fromWidth)
{
switch(binType)
{
case BinType::UNIFORM:
if(binWidth <= 0.) throw std::invalid_argument("bin width must be > 0");
Fill_Uniform_Edges(fromWidth);
break;
case BinType::LOG_UNIFORM:
if(range.min <= 0.)
throw std::invalid_argument("for LOG_UNIFORM, lower edge must be >= 0");
if(binWidth <= 0.)
throw std::invalid_argument("bin scale must be > 1.");
Fill_Uniform_Edges(fromWidth);
break;
default:
throw std::runtime_error("BinSpecs: no code to handle a new BinType (my mistake)");
break;
}
}
// ALWAYS FILL UNIFORM EDGES USING (min*i + max*(N-i)) scheme
// Introduces rounding error in every edge, but it's always Order(epsilon)
// (instead of accumulating as edges are defined incrementally)
void kdp::BinSpecs::Fill_Uniform_Edges(bool const fromWidth)
{
// Critical ASSUMPTION throughout:
// if binType != UNIFORM, then binType == LOG_UNIFORM
if(fromWidth)
{
edge_t& min = range.min;
edge_t& max = range.max;
const edge_t rangeWidth = (binType == BinType::UNIFORM) ?
(max - min) : std::log(max/min);
if(pinned == PinnedEdge::BOTH)
{
// If pinning of both edges requested,
// change the width by first rounding to an integer number of bins
numBins = std::max(size_t(std::round(rangeWidth/binWidth)), size_t(1));
binWidth = rangeWidth/edge_t(numBins);
}
else
{
// Otherwise, use just enough bins to accommodate rangeWidth
numBins = std::ceil(rangeWidth/binWidth);
// Now move min or max
if(pinned == PinnedEdge::LEFT)
{
max = (binType == BinType::UNIFORM) ?
(min + numBins*binWidth) : (min * std::exp(numBins*binWidth));
}
else if(pinned == PinnedEdge::RIGHT)
{
min = (binType == BinType::UNIFORM) ?
(max - numBins*binWidth) : (max * std::exp(-numBins*binWidth));
}
}
CalculatedNumBinsSanityChecks();
}
const edge_t minLoop = (binType == BinType::UNIFORM) ?
range.min : std::log(range.min);
const edge_t maxLoop = (binType == BinType::UNIFORM) ?
range.max : std::log(range.max);
// Reserve 2 extra slots for -inf/inf
edges.reserve(numBins + 2);
// Pad with infinity before/after
edges.push_back(-INF);
// For LOG_UNIFORM, add the edge for the zero bin (pseudo-underflow)
if(binType == BinType::LOG_UNIFORM) edges.push_back(0.);
// Manually push_back min/max, to avoid rounding error
edges.push_back(range.min);
// Even if using bin width, define edges in terms of num bins
// This prevents rounding error from accumulating, so even though
// the bins may have slightly uneven width, they are more likely
// to exist in the right place.
{
size_t minCounter = numBins - 1;
for(size_t maxCounter = 1; maxCounter < numBins; ++maxCounter, --minCounter)
{
edge_t thisEdge = (minLoop*minCounter + maxLoop*maxCounter)/edge_t(numBins);
if(binType == BinType::LOG_UNIFORM) thisEdge = std::exp(thisEdge);
edges.push_back(thisEdge);
}
}
edges.push_back(range.max);
edges.push_back(INF);
// Account for automatic addition of the zero bin for LOG_UNIFORM
// (this must be done here, after the loop,
// otherwise too many edges will be added in the loop)
if(binType == BinType::LOG_UNIFORM) ++numBins;
}
void kdp::BinSpecs::ExceptionHandler(std::exception& except)
{
throw std::invalid_argument("BinSpecs: (" + name + ") ... " +
except.what());
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
__ __ _ _ _ _____
\ \ / /__(_) __ _| |__ | |_| ____|_ __ _ __ ___ _ __
\ \ /\ / / _ \ |/ _` | '_ \| __| _| | '__| '__/ _ \| '__|
\ V V / __/ | (_| | | | | |_| |___| | | | | (_) | |
\_/\_/ \___|_|\__, |_| |_|\__|_____|_| |_| \___/|_|
|___/
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
kdp::WeightError& kdp::WeightError::operator /= (WeightError const& that)
{
// We need to avoid 0 / 0 ... this way also catches 0/something
if(this->weight > 0.)
{
// For * and /, *relative* errors add in quadrature
// dz/z = sqrt((dx/x)**2 + (dy/y)**2) (x=this, y=that, z = x/y)
// dz**2 = (x**2/y**2)*(dx**2/x**2 + dy**2/y**2)
// = (dx**2/y**2 + dy**2*x**2/y**4)
// = (dx**2 + dy**2*x**2/y**2)/y**2
// Note: a**2/b**2 is more accurate than (a/b)**2
this->error2 =
std::fma(that.error2, kdp::Squared(this->weight)/kdp::Squared(that.weight), this->error2)/
kdp::Squared(that.weight);
this->weight = this->weight / that.weight;
}
return *this;
}
////////////////////////////////////////////////////////////////////////
kdp::WeightError& kdp::WeightError::operator += (WeightError const& that)
{
// For + and -, *absolute* errors add in quadrature
// dz**2 = dx**2 + dy**2
this->error2 += that.error2;
this->weight += that.weight;
return *this;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_ ______ ____ _ _ _ _ __ __
| |/ / _ \| _ \| | | (_)___| |_ __\ \ / /__ ___
| ' /| | | | |_) | |_| | / __| __/ _ \ \ / / _ \/ __|
| . \| |_| | __/| _ | \__ \ || (_) \ V / __/ (__
|_|\_\____/|_| |_| |_|_|___/\__\___/ \_/ \___|\___|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
template<class content>
content& kdp::HistoVec<content>::FindBin(edge_t const val)
{
if(val >= binSpecs.range.max) return this->back();
else
{
auto bin = this->begin();
if(val >= binSpecs.range.min)
{
if(binSpecs.binType == BinType::NON_UNIFORM)
{
/* For non-uniform bins, use std::upper_bound
* (first edge > val, which finds the upper edge, so we have to subtract 1).
* If no value compares greater, we will land on the overflow bin.
* This assumes that upper_bound has the fastest search algorithm
* (knowing exactly when to transition from binary to linear search).
* Not only is this a good assumption, testing reveals that upper_bound
* can be up to twice as fast as the linear search it replaced.
*/
bin += (size_t(std::upper_bound(binSpecs.edges.cbegin(), binSpecs.edges.cend(), val)
- binSpecs.edges.cbegin()) - 1lu);
}
else
{
auto leftEdge = minEdge;
// For UNIFORM/LOG_UNIFORM bins, no need to search every edge
// However, there might be rounding error while calculating the bin.
// Start with the calculated/expected bin (minus 1, to catch rounding left error)
// and search past it. This will catch bin shifts to the left or right.
if(binSpecs.binType == BinType::UNIFORM)
{
leftEdge += (size_t((val - binSpecs.range.min)/binSpecs.binWidth) - 1);
}
else if(binSpecs.binType == BinType::LOG_UNIFORM)
{
++bin; // minEdge skipped the zero bin
// This is actually slower, if there are less than about 100 bins
// But it has constant execution time, for larger number of bins
leftEdge += (size_t(std::log(val/binSpecs.range.min)/binSpecs.binWidth) - 1);
}
// Keep moving the left edge until it is to our right
// Because +inf is the final value in the edge list,
// and we already checked for overflow,
// we do not need an extra check to prevent running off the list
while(val >= *leftEdge) ++leftEdge;
bin += size_t(leftEdge - minEdge);
}
}
else if((binSpecs.binType == BinType::LOG_UNIFORM) and (val >= 0.)) ++bin;
// For LOG_UNIFORM, use the zero bin [0, min)
assert(bin < this->end());
return *bin;
}
}
template<class content>
kdp::HistoVec<content>&
kdp::HistoVec<content>::operator/=(HistoVec<content> const& that)
{
if(this->binSpecs not_eq that.binSpecs)
throw std::runtime_error("HistoVec: Cannot divide, incompatible BinSpecs");
auto itDenom = that.begin();
for(auto itNumer = this->begin(); itNumer not_eq this->end(); ++itNumer, ++itDenom)
{
// This will call this function recursively until content = WeightError
// This makes it extremely simple to divide multi-D histograms
(*itNumer)/=(*itDenom);
}
return *this;
}
template class kdp::HistoVec<kdp::WeightError>;
template class kdp::HistoVec<kdp::HistoVec<kdp::WeightError> >;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_ _ _ _
| \ | | ___ _ __ _ __ ___ __ _| (_)_______
| \| |/ _ \| '__| '_ ` _ \ / _` | | |_ / _ \
| |\ | (_) | | | | | | | | (_| | | |/ / __/
|_| \_|\___/|_| |_| |_| |_|\__,_|_|_/___\___|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
// Have to declare as kdp:operator, otherwise defined in global scope
kdp::Normalize kdp::operator&(Normalize const lhs,
Normalize const rhs)
{
return static_cast<Normalize>
(static_cast<norm_t>(lhs) & static_cast<norm_t>(rhs));
}
kdp::Normalize kdp::operator|(Normalize const lhs, Normalize const rhs)
{
return static_cast<Normalize>
(static_cast<norm_t>(lhs) | static_cast<norm_t>(rhs));
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_ ______ ____ _ _ _ _ _
| |/ / _ \| _ \| | | (_)___| |_ ___ __ _ _ __ __ _ _ __ ___ | |__ __ _ ___ ___
| ' /| | | | |_) | |_| | / __| __/ _ \ / _` | '__/ _` | '_ ` _ \ | '_ \ / _` / __|/ _ \
| . \| |_| | __/| _ | \__ \ || (_) | (_| | | | (_| | | | | | | | |_) | (_| \__ \ __/
|_|\_\____/|_| |_| |_|_|___/\__\___/ \__, |_| \__,_|_| |_| |_|___|_.__/ \__,_|___/\___|
|___/ |_____|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
std::set<std::string> kdp::Histogram_base::fileNameMutex;
kdp::Histogram_base::Histogram_base(std::string const& fileName_in,
weight_t const totalWeight_in,
weight_t const writeScale_in,
Normalize const norm_in):
fileName(fileName_in),
totalWeight(totalWeight_in), writeScale(writeScale_in), norm(norm_in),
written(false)
{
// If fileName is blank, then this is a non-writing histogram
// (used only for reading or adding to other histograms)
if(fileName_in.size())
{
// nameMutex resturns false in the 2nd position if the name has already been used
if(not (fileNameMutex.insert(fileName).second))
RTExcept("another KDPHistogram is already using this fileName");
// Clear the file, if it already exists, and ensure we have write privileges
if(not(std::ofstream(fileName.c_str(), std::ios::out | std::ios::trunc)))
RTExcept("cannot open file (" + fileName +") for writing");
// Now remove the empty file, in case the histogram isn't used
// (because then it won't be written, which will be easier to detect
// if there is no file there
std::remove(fileName.c_str());
}
}
void kdp::Histogram_base::RTExcept(std::string const& info) const
{
throw std::runtime_error(ExceptionPrefix() + info);
}
std::string kdp::Histogram_base::ExceptionPrefix() const
{
return "KDPHistogram: (" + fileName + ") ... ";
}
void kdp::Histogram_base::CheckWeightError(weight_t const weight,
weight_t const error) const
{
if(std::isinf(weight)) RTExcept("binning weight is inf");
if(std::isnan(weight)) RTExcept("binning weight is nan");
if(weight <= 0.) RTExcept("binning weight is <= 0");
if(std::isinf(error)) RTExcept("binning error is inf");
if(std::isnan(error)) RTExcept("binning error is nan");
if(error < 0.) RTExcept("binning error is < 0");
}
// This must be called from the derived classes, because Write is virtual
void kdp::Histogram_base::AutomaticWrite()
{
try
{
// Don't erase fileName, so we don't screw ourselves within a single run
// fileNameMutex.erase(fileName);
// Write if no write was manual requested, and if weight has been binned,
// AND if we have been supplied a non-empty fileName
if((not written) and (totalWeight > 0.) and bool(fileName.size()))
this->Write(); // This should not throw an exception, but it might
}
catch(std::exception const& e)
{
std::cerr << "Error during Histogram1 deconstruction (probably Write())\n\n";
std::cerr << e.what();
}
}
void kdp::Histogram_base::WriteHeader(std::ofstream& outFile,
std::string const& className)
{
const std::string blankLine = "#\n";
char outBuff[1024]; // should be long enough for one line (ASSUMPTION)
outFile << "# Histogram generated by (" + className + "), ";
outFile << "in a format easily recognized by gnuplot.\n";
outFile << blankLine;
sprintf(outBuff, "# Total weight binned: %.16e \n", totalWeight);
outFile << outBuff;
outFile << blankLine;
if(bool(norm & Normalize::UNITARY))
{
outFile << "# histogram is UNITARY (bin weights, including under/over, ";
outFile << "are divided by total weight)\n";
}
if(bool(norm & Normalize::INTEGRATABLE))
{
outFile << "# histogram is INTEGRATEABLE (bins weights divided by bin width)\n";
}
if(norm == Normalize::PDF)
{
outFile << "# ... therefore histogram is a probability distribution (PDF)\n";
}
outFile << blankLine;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_ ______ ____ _ _ _ _ _
| |/ / _ \| _ \| | | (_)___| |_ ___ __ _ _ __ __ _ _ __ ___ / |
| ' /| | | | |_) | |_| | / __| __/ _ \ / _` | '__/ _` | '_ ` _ \| |
| . \| |_| | __/| _ | \__ \ || (_) | (_| | | | (_| | | | | | | |
|_|\_\____/|_| |_| |_|_|___/\__\___/ \__, |_| \__,_|_| |_| |_|_|
|___/
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
const std::string kdp::Histogram1::FILE_EXTENSION = ".histo1D";
// An empty set of active names
// Private ctor, for constructing a full object
kdp::Histogram1::Histogram1(std::string const& name,
weight_t const totalWeight_in,
weight_t const writeScale_in,
Normalize const norm_in,
HistoVec<WeightError>&& disowned):
Histogram_base(name + Histogram1::FILE_EXTENSION,
totalWeight_in, writeScale_in, norm_in),
hist(std::move(disowned)) {}
// ctor given writeScale
kdp::Histogram1::Histogram1(std::string const& name,
BinSpecs const& xBinSpecs,
weight_t const writeScale_in,
Normalize const norm_in):
Histogram1(name, 0., writeScale_in, norm_in,
std::move(HistoVec<WeightError>(xBinSpecs))) {}
// ctor given norm
kdp::Histogram1::Histogram1(std::string const& name,
BinSpecs const& xBinSpecs,
Normalize const norm_in):
Histogram1(name, xBinSpecs, 1., norm_in) {}
kdp::Histogram1::Histogram1(BinSpecs const& xBinSpecs, Normalize const norm_in):
Histogram_base(std::string(), 0., 1., norm_in), hist(xBinSpecs) {}
void kdp::Histogram1::Fill(edge_t const x, weight_t const weight,
weight_t const error)
{
// x can be infinite, but it cannot be nan
if(std::isnan(x)) RTExcept("trying to bin nan (x)");
CheckWeightError(weight, error);
totalWeight += weight;
WeightError& bin = hist.FindBin(x);
bin.weight += weight;
bin.error2 += error*error;
}
kdp::Histogram1& kdp::Histogram1::operator += (Histogram1 const& that)
{
// Cannot divide histograms unless they have identical BinSpecs
if(this->hist.binSpecs not_eq that.hist.binSpecs)
RTExcept("Cannot add (" + that.fileName + ") to (" +
this->fileName + ") ... incompatible bin specs.");
for(size_t i = 0; i < hist.size(); ++i)
hist[i] += that.hist[i];
totalWeight += that.totalWeight;
return *this;
}
// Divide two histograms to create a new histogram with their ratio
void kdp::Histogram1::WriteRatio(Histogram1 const& that,
std::string const& newName) const
{
// Cannot divide histograms unless they have identical BinSpecs
if(this->hist.binSpecs not_eq that.hist.binSpecs)
RTExcept("Cannot divide (" + this->fileName + ") by (" +
that.fileName + ") ... incompatible bin specs.");
//HistoVec<WeightError> ratio = this->hist;
auto ratio = this->hist;
ratio /= that.hist;
// Create and immediately destroy (and write) the histogram
// Pass a unit weight (no normalization, so it won't change anything)
// b/c histo won't auto-write unless it thinks something's there
Histogram1 ratioHist(newName, 1., 1., Normalize::NO, std::move(ratio));
}
void kdp::Histogram1::Write()
{
if(fileName.empty())
RTExcept("No file path supplied; nowhere to write");
// We already checked we could write to the file,
// there are no exceptions to generate, and we shouldn't encounter any
std::ofstream outFile;
outFile.open(fileName.c_str(), std::ios::out | std::ios::trunc);
if(outFile)
{
BinSpecs const& binSpecs = hist.binSpecs;
std::vector<edge_t> edges = binSpecs.edges;
assert(hist.size() == edges.size() - 1);
const bool divideByWeight = bool(norm & Normalize::UNITARY);
const bool divideByWidth = bool(norm & Normalize::INTEGRATABLE);
const bool uniform = (binSpecs.binType == BinType::UNIFORM);
const weight_t normWeight = divideByWeight ? totalWeight : 1.;
char outBuff[1024]; // should be long enough for one line (ASSUMPTION)
WriteHeader(outFile, "Histogram1");
if(uniform)
{
outFile << "# first/last bins are under/over, respectively \n\n";
// Change the edges we use, so we don't need fancy code
edges.front() = binSpecs.range.min - binSpecs.binWidth;
edges.back() = binSpecs.range.max + binSpecs.binWidth;
}
else // write under/overflow in the header
{
sprintf(outBuff, "# Under (wgt/err): %.16e %.16e \n",
(writeScale * hist.front().weight) / normWeight,
(writeScale * std::sqrt(hist.front().error2)) / normWeight);
outFile << outBuff;
sprintf(outBuff, "# Over (wgt/err): %.16e %.16e \n\n",
(writeScale * hist.back().weight) / normWeight,
(writeScale * std::sqrt(hist.back().error2)) / normWeight);
outFile << outBuff;
}
const int uniformShift = (uniform ? 0 : 1);
auto const endBin = hist.end() - uniformShift;
auto leftEdge = edges.begin() + uniformShift;
auto rightEdge = leftEdge + 1;
outFile << "# x pdf(x) pdfError(x) cdf(x) pdf-error pdf+error\n";
weight_t cumulative = 0.;
for(auto thisBin = hist.begin() + uniformShift; thisBin not_eq endBin; ++thisBin)
{
const weight_t thisWeight = thisBin->weight;
const weight_t thisError = std::sqrt(thisBin->error2);
const edge_t thisBinDenom = normWeight *
(divideByWidth ? (*rightEdge - *leftEdge) : 1.);
cumulative += thisWeight;
sprintf(outBuff, "% .6e % .6e % .6e % .6e % .6e % .6e\n",
0.5*(*rightEdge + *leftEdge),
(writeScale*thisWeight)/thisBinDenom,
(writeScale*thisError)/thisBinDenom,
cumulative/totalWeight,
(writeScale*(thisWeight-thisError))/thisBinDenom,
(writeScale*(thisWeight+thisError))/thisBinDenom);
outFile << outBuff;
leftEdge = rightEdge;
++rightEdge;
}
outFile.close();
written = true;
}
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_ ______ ____ _ _ _ _ ____
| |/ / _ \| _ \| | | (_)___| |_ ___ __ _ _ __ __ _ _ __ ___ |___ \
| ' /| | | | |_) | |_| | / __| __/ _ \ / _` | '__/ _` | '_ ` _ \ __) |
| . \| |_| | __/| _ | \__ \ || (_) | (_| | | | (_| | | | | | |/ __/
|_|\_\____/|_| |_| |_|_|___/\__\___/ \__, |_| \__,_|_| |_| |_|_____|
|___/
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
const std::string kdp::Histogram2::FILE_EXTENSION = ".histo2D";
// An empty set of active names
// Private ctor, for constructing a full object
kdp::Histogram2::Histogram2(std::string const& name,
weight_t const totalWeight_in,
weight_t const writeScale_in,
Normalize const norm_in,
HistoVec<HistoVec<WeightError> >&& disowned):
Histogram_base(name + Histogram2::FILE_EXTENSION,
totalWeight_in, writeScale_in, norm_in),
hist(std::move(disowned)) {}
// Public ctor, through which all other public ctors flow
kdp::Histogram2::Histogram2(std::string const& name,
BinSpecs const& xBinSpecs, BinSpecs const& yBinSpecs,
weight_t const writeScale_in,
Normalize const norm_in):
Histogram2(name, 0., writeScale_in, norm_in,
std::move(HistoVec<HistoVec<WeightError> >(xBinSpecs, yBinSpecs))) {}
// Minimal ctor (writeScale = 1., norm = PDF)
kdp::Histogram2::Histogram2(std::string const& name,
BinSpecs const& xBinSpecs, BinSpecs const& yBinSpecs,
Normalize const norm_in):
Histogram2(name, xBinSpecs, yBinSpecs, 1., norm_in) {}
void kdp::Histogram2::Fill(edge_t const x, edge_t const y,
weight_t const weight, weight_t const error)
{
if(std::isnan(x)) RTExcept("trying to bin nan (x)");
if(std::isnan(y)) RTExcept("trying to bin nan (y)");
CheckWeightError(weight, error);
totalWeight += weight;
WeightError& bin = hist.FindBin(x).FindBin(y);
bin.weight += weight;
bin.error2 += error*error;
}
// Divide two histograms to create a new histogram with their ratio
void kdp::Histogram2::WriteRatio(Histogram2 const& that,
std::string const& newName) const
{
// Cannot divide histograms unless they have identical BinSpecs
if((this->hist.binSpecs not_eq that.hist.binSpecs) or
(this->hist.front().binSpecs not_eq that.hist.front().binSpecs))
RTExcept("Cannot divide (" + this->fileName + ") by (" +
that.fileName + ") ... incompatible bin specs.");
//HistoVec<HistoVec<WeightError> > ratio = this->hist;
auto ratio = this->hist;
ratio /= that.hist;
// Create and immediately destroy (and write) the histogram
// Pass a unit weight, no normalization or writeScale,
// but it won't auto-write unless it thinks something's there
Histogram2 ratioHist(newName, 1., 1., Normalize::NO, std::move(ratio));
}
void kdp::Histogram2::Write()
{
// We already checked we could write to the file,
// there are no exceptions to generate, and we shouldn't encounter any
std::ofstream outFile;
outFile.open(fileName.c_str(), std::ios::out | std::ios::trunc);
if(outFile)
{
BinSpecs const& binSpecsX = hist.binSpecs;
BinSpecs const& binSpecsY = hist.front().binSpecs;
std::vector<edge_t> edgesX = binSpecsX.edges;
std::vector<edge_t> edgesY = binSpecsY.edges;
const bool divideByWeight = bool(norm & Normalize::UNITARY);
const bool divideByWidth = bool(norm & Normalize::INTEGRATABLE);
const bool uniformX = (binSpecsX.binType == BinType::UNIFORM);
const bool uniformY = (binSpecsY.binType == BinType::UNIFORM);
const weight_t normWeight = divideByWeight ? totalWeight : 1.;
char outBuff[1024]; // should be long enough for one line (ASSUMPTION)
WriteHeader(outFile, "Histogram2");
if(uniformX)
{
outFile << "# first/last x-bins are under/over, respectively \n";
// Change the edges we use, so we don't need fancy code
edgesX.front() = binSpecsX.range.min - binSpecsX.binWidth;
edgesX.back() = binSpecsX.range.max + binSpecsX.binWidth;
}
else WriteUnderOverX(outFile, normWeight);
if(uniformY)
{
outFile << "# first/last y-bins are under/over, respectively \n";
// Change the edges we use, so we don't need fancy code
edgesY.front() = binSpecsY.range.min - binSpecsY.binWidth;
edgesY.back() = binSpecsY.range.max + binSpecsY.binWidth;
}
else WriteUnderOverY(outFile, normWeight);
outFile << "# WARNING: data configured for gnuplot splot or splot with pm3d; \
the interpolation mesh is probably not being displayed accurately.\n";
outFile << "# To properly display in gnuplot, you must use \
\"set pm3d corners2color c1\"\n";
outFile << "#\n#\n";
const int uniformShiftX = (uniformX ? 0 : 1);
const int uniformShiftY = (uniformY ? 0 : 1);
auto const endHistoX = hist.end() - uniformShiftX;
auto leftEdgeX = edgesX.begin() + uniformShiftX;
auto rightEdgeX = leftEdgeX + 1;
outFile << "# x y pdf(x) pdfError(x)\n";
for(auto thisHistoX = hist.begin() + uniformShiftX;
thisHistoX not_eq endHistoX; ++thisHistoX)
{
//const edge_t xPos = 0.5*(*rightEdgeX + *leftEdgeX);
// gnuplot assumes you are giving it corners, not central positions
const edge_t xPos = *leftEdgeX;
const edge_t xWidth = (*rightEdgeX - *leftEdgeX);
auto const endBinY = thisHistoX->end() - uniformShiftY;
auto leftEdgeY = edgesY.begin() + uniformShiftY;
auto rightEdgeY = leftEdgeY + 1;
for(auto thisBinY = thisHistoX->begin() + uniformShiftY;
thisBinY not_eq endBinY; ++thisBinY)
{
const weight_t thisWeight = thisBinY->weight;
const weight_t thisError = std::sqrt(thisBinY->error2);
const edge_t thisBinDenom = normWeight *
(divideByWidth ? xWidth*(*rightEdgeY - *leftEdgeY) : 1.);
sprintf(outBuff, "% .6e % .6e % .6e % .6e\n",
xPos,
//0.5*(*rightEdgeY + *leftEdgeY),
// gnuplot assumes you are giving it corners, not central positions
*leftEdgeY,
(writeScale*thisWeight)/thisBinDenom,
(writeScale*thisError)/thisBinDenom);
outFile << outBuff;
leftEdgeY = rightEdgeY;
++rightEdgeY;
}
// gnuplot assumes you are giving it corners, not central positions
sprintf(outBuff, "% .6e % .6e % .6e % .6e\n",
xPos,
//0.5*(*rightEdgeY + *leftEdgeY),
// gnuplot assumes you are giving it corners, not central positions
*leftEdgeY, 0., 0.);
outFile << outBuff;
// gnuplot requires blank line in between x-values
outFile << "\n";
leftEdgeX = rightEdgeX;
++rightEdgeX;
}
// gnuplot assumes you are giving it corners, not central positions
// Therefore, we must supply the upper boundaries
for(auto leftEdgeY = edgesY.begin() + uniformShiftY;
leftEdgeY not_eq edgesY.end() - uniformShiftY; ++leftEdgeY)
{
sprintf(outBuff, "% .6e % .6e % .6e % .6e\n",
*leftEdgeX, *leftEdgeY, 0., 0.);
outFile << outBuff;
}
outFile.close();
written = true;
}
}
void kdp::Histogram2::WriteUnderOverX(std::ofstream& outFile,
weight_t const normWeight)
{
outFile << "#\n";
char buffer[1024];
assert(hist.front().size() == hist.back().size());
assert(hist.front().size() == hist.front().binSpecs.edges.size() - 1);
auto itUnder = hist.front().begin();
auto itOver = hist.back().begin();
auto leftEdge = hist.front().binSpecs.edges.begin();
auto rightEdge = leftEdge + 1;
auto const underEnd = hist.front().end();
while(itUnder not_eq underEnd)
{
sprintf(buffer,
"# x under-over (y-pos | under | over) %.7e %.7e %.7e\n",
0.5+(*leftEdge + *rightEdge),
(writeScale * itUnder->weight) / normWeight,
(writeScale * itOver->weight) / normWeight);
outFile << buffer;
++itUnder;
++itOver;
leftEdge = rightEdge;
++rightEdge;
}
}
void kdp::Histogram2::WriteUnderOverY(std::ofstream& outFile,
weight_t const normWeight)
{
outFile << "#\n";
char buffer[1024];
// Just assume each vector has the same weight
assert(hist.size() == hist.binSpecs.edges.size() - 1);
auto leftEdge = hist.binSpecs.edges.begin();
auto rightEdge = leftEdge + 1;
for(auto itXhist = hist.begin(); itXhist not_eq hist.end(); ++itXhist)
{
sprintf(buffer,
"# y under-over (x-pos | under | over) %.7e %.7e %.7e\n",
0.5+(*leftEdge + *rightEdge),
(writeScale * (itXhist->front().weight)) / normWeight,
(writeScale * (itXhist->back().weight)) / normWeight);
outFile << buffer;
leftEdge = rightEdge;
++rightEdge;
}
}
| [
"kpeders1@hawk.iit.edu"
] | kpeders1@hawk.iit.edu |
deb3a255e37a5ca9db1cbfa623aa1de8d998b3cb | 9401a919b491a6045955ae9511a2d8bca77e6884 | /HLS_Test/QP_HLS/QP/sim/autowrap/testbench/fp_test_tb.cpp_pre.cpp | c8660e9e1415ffa4dd3e736a01c4ef2657581444 | [] | no_license | wuyou33/MPC | 0bb56c499bd8c04b477840ef4a1c4bf41258ad14 | 35a0d9a4fd5e0c922720cf39d75a7db9bf1ea3c5 | refs/heads/master | 2021-05-18T02:17:26.404408 | 2020-01-16T19:15:59 | 2020-01-16T19:15:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 166 | cpp | # 1 "C:/Users/hkhaj/Desktop/MPC/HLS_Test/QP_HLS/fp_test_tb.cpp"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "C:/Users/hkhaj/Desktop/MPC/HLS_Test/QP_HLS/fp_test_tb.cpp"
| [
"hkhajanchi97@att.net"
] | hkhajanchi97@att.net |
a69fd8492c881d1ab489f0a97010836b57233465 | bb72b975267b12fb678248ce565f3fd9bd6153ee | /testgles/NdkOpenGL/jni/platform/CCFileUtilsAndroid.cpp | f9b957bab3e90920de27ae626c6442e7898d1cc0 | [] | no_license | fiskercui/testlanguage | cfbcc84ffaa31a535a7f898d6c7b42dcbf2dc71b | b15746d9fa387172b749e54a90e8c6251750f192 | refs/heads/master | 2021-05-30T13:26:11.792822 | 2016-01-13T02:03:26 | 2016-01-13T02:03:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,255 | cpp | #include "base/ccMacros.h"
#include "base/CCPlatformConfig.h"
#include "CCFileUtilsAndroid.h"
//#include "platform/CCCommon.h"
#include "help/Java_com_example_ndkopengl_Cocos2dxHelper.h"
#include "android/asset_manager.h"
#include "android/asset_manager_jni.h"
#include <stdlib.h>
#include <string>
#ifndef LOG_TAG
#define LOG_TAG "CCFileUtilsAndroid.cpp"
#endif
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
using namespace std;
NS_CC_BEGIN
AAssetManager* FileUtilsAndroid::assetmanager = nullptr;
void FileUtilsAndroid::setassetmanager(AAssetManager* a) {
if (nullptr == a) {
LOGD("setassetmanager : received unexpected nullptr parameter");
return;
}
cocos2d::FileUtilsAndroid::assetmanager = a;
}
FileUtils* FileUtils::getInstance()
{
if (s_sharedFileUtils == nullptr)
{
s_sharedFileUtils = new FileUtilsAndroid();
if(!s_sharedFileUtils->init())
{
delete s_sharedFileUtils;
s_sharedFileUtils = nullptr;
CCLOG("ERROR: Could not init CCFileUtilsAndroid");
}
}
return s_sharedFileUtils;
}
FileUtilsAndroid::FileUtilsAndroid()
{
}
FileUtilsAndroid::~FileUtilsAndroid()
{
}
bool FileUtilsAndroid::init()
{
_defaultResRootPath = "assets/";
return FileUtils::init();
}
bool FileUtilsAndroid::isFileExistInternal(const std::string& strFilePath) const
{
if (strFilePath.empty())
{
return false;
}
bool bFound = false;
// Check whether file exists in apk.
if (strFilePath[0] != '/')
{
const char* s = strFilePath.c_str();
// Found "assets/" at the beginning of the path and we don't want it
if (strFilePath.find(_defaultResRootPath) == 0) s += strlen("assets/");
if (FileUtilsAndroid::assetmanager) {
AAsset* aa = AAssetManager_open(FileUtilsAndroid::assetmanager, s, AASSET_MODE_UNKNOWN);
if (aa)
{
bFound = true;
AAsset_close(aa);
} else {
// CCLOG("[AssetManager] ... in APK %s, found = false!", strFilePath.c_str());
}
}
}
else
{
FILE *fp = fopen(strFilePath.c_str(), "r");
if(fp)
{
bFound = true;
fclose(fp);
}
}
return bFound;
}
bool FileUtilsAndroid::isAbsolutePath(const std::string& strPath) const
{
// On Android, there are two situations for full path.
// 1) Files in APK, e.g. assets/path/path/file.png
// 2) Files not in APK, e.g. /data/data/org.cocos2dx.hellocpp/cache/path/path/file.png, or /sdcard/path/path/file.png.
// So these two situations need to be checked on Android.
if (strPath[0] == '/' || strPath.find(_defaultResRootPath) == 0)
{
return true;
}
return false;
}
std::string FileUtilsAndroid::getStringFromFile(const std::string& filename)
{
return getData(filename, true);
}
std::string FileUtilsAndroid::getData(const std::string& filename, bool forString)
{
if (filename.empty())
{
return "";
}
unsigned char* data = nullptr;
ssize_t size = 0;
string fullPath = fullPathForFilename(filename);
if (fullPath[0] != '/')
{
string relativePath = string();
size_t position = fullPath.find("assets/");
if (0 == position) {
// "assets/" is at the beginning of the path and we don't want it
relativePath += fullPath.substr(strlen("assets/"));
} else {
relativePath += fullPath;
}
LOGD("relative path = %s", relativePath.c_str());
if (nullptr == FileUtilsAndroid::assetmanager) {
LOGD("... FileUtilsAndroid::assetmanager is nullptr");
return "";
}
// read asset data
AAsset* asset =
AAssetManager_open(FileUtilsAndroid::assetmanager,
relativePath.c_str(),
AASSET_MODE_UNKNOWN);
if (nullptr == asset) {
LOGD("asset is nullptr");
return "";
}
off_t fileSize = AAsset_getLength(asset);
if (forString)
{
data = (unsigned char*) malloc(fileSize + 1);
data[fileSize] = '\0';
}
else
{
data = (unsigned char*) malloc(fileSize);
}
int bytesread = AAsset_read(asset, (void*)data, fileSize);
size = bytesread;
AAsset_close(asset);
}
else
{
do
{
// read rrom other path than user set it
//CCLOG("GETTING FILE ABSOLUTE DATA: %s", filename);
const char* mode = nullptr;
if (forString)
mode = "rt";
else
mode = "rb";
FILE *fp = fopen(fullPath.c_str(), mode);
CC_BREAK_IF(!fp);
long fileSize;
fseek(fp,0,SEEK_END);
fileSize = ftell(fp);
fseek(fp,0,SEEK_SET);
if (forString)
{
data = (unsigned char*) malloc(fileSize + 1);
data[fileSize] = '\0';
}
else
{
data = (unsigned char*) malloc(fileSize);
}
fileSize = fread(data,sizeof(unsigned char), fileSize,fp);
fclose(fp);
size = fileSize;
} while (0);
}
std::string ret;
if (data == nullptr || size == 0)
{
std::string msg = "Get data from file(";
msg.append(filename).append(") failed!");
CCLOG("%s", msg.c_str());
return "";
}
else
{
// ret.fastSet(data, size);
std::string ret((char*)data, (int)size);
CCLOG("file data:%s", data);
return ret;
}
// return ret;
}
string FileUtilsAndroid::getWritablePath() const
{
// Fix for Nexus 10 (Android 4.2 multi-user environment)
// the path is retrieved through Java Context.getCacheDir() method
string dir("");
string tmp = getFileDirectoryJNI();
if (tmp.length() > 0)
{
dir.append(tmp).append("/");
return dir;
}
else
{
return "";
}
}
NS_CC_END
| [
"weihua@weihuacuideMac-mini.local"
] | weihua@weihuacuideMac-mini.local |
d36f1b79250b29026c085ff86a3b0184c0182d9c | cb38863a57da0fc7bbee3174f74f68dc59746cb9 | /code/rocket/RocketMenuPlugin.cpp | 5ccbf2e33fe17a0211bdbbfab937a276b11b9ad2 | [] | no_license | dylski/duke3d-megaton | 82397b8d0349496f680f7f2e84146dfd993eda11 | 4761ba83b46917aa4229365e40f32cf24ed71d0b | refs/heads/master | 2021-01-15T12:10:19.217462 | 2013-09-27T14:45:54 | 2013-09-27T14:45:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 35,860 | cpp | //
// Created by Sergei Shubin <s.v.shubin@gmail.com>
//
#include "RocketMenuPlugin.h"
#include <Rocket/Core.h>
#include <Rocket/Core/Element.h>
#include "PluginUtils.h"
#include "helpers.h"
#include "math.h"
static
void SetActiveKeySlot(Rocket::Core::Element *menu_item, int active_key);
/*** Context Data ***/
struct ContextData {
Rocket::Core::ElementDocument *current_document;
ContextData():current_document(0) {}
virtual ~ContextData(){};
};
static void
SetContextData(Rocket::Core::Context *context, ContextData *user_data) {
SetElementUserData(context->GetRootElement(), (void*)user_data, "__menu_context_data");
}
static ContextData*
GetContextData(Rocket::Core::Context *context) {
return (ContextData*)GetElementUserData(context->GetRootElement(), "__menu_context_data");
}
/*** Document Data ***/
struct DocumentData {
Rocket::Core::Element *menu;
Rocket::Core::Element *active_item;
Rocket::Core::Element *cursor_left, *cursor_right;
int active_key;
DocumentData():active_item(0),menu(0),cursor_left(0),cursor_right(0),active_key(0) {}
virtual ~DocumentData() {};
};
static void
SetDocumentData(Rocket::Core::ElementDocument *document, DocumentData *doc_data) {
SetElementUserData(document, (void*)doc_data, "__menu_doc_data");
}
static DocumentData*
GetDocumentData(Rocket::Core::ElementDocument *document) {
return (DocumentData*)GetElementUserData(document, "__menu_doc_data");
}
/*** Options Data ***/
struct OptionsData {
Rocket::Core::Element *menu_item;
Rocket::Core::Element *hdr, *ftr;
Rocket::Core::ElementList options;
Rocket::Core::ElementList::iterator current;
OptionsData():menu_item(NULL),hdr(NULL),ftr(NULL){}
virtual ~OptionsData() {};
};
static void
SetOptionsData(Rocket::Core::Element *element, OptionsData *data) {
SetElementUserData(element, (void*)data, "__menu_options_data");
}
static OptionsData*
GetOptionsData(Rocket::Core::Element *element) {
return (OptionsData*)GetElementUserData(element, "__menu_options_data");
}
/*** Range Data ***/
struct RangeData {
Rocket::Core::Element *menu_item;
Rocket::Core::Element *hdr, *ftr;
Rocket::Core::Element *range;
// Rocket::Core::Element *rail, *grip;
// float rail_x, rail_y, rail_length;
float min, max, value, step;
RangeData():menu_item(NULL),hdr(NULL),ftr(NULL),range(NULL),
// rail(NULL),grip(NULL),
min(0.0f),max(1.0f),value(0.0f),step(0.1f)
{}
virtual ~RangeData() {};
};
static void
SetRangeData(Rocket::Core::Element *element, RangeData *data) {
SetElementUserData(element, (void*)data, "__menu_range_data");
}
static RangeData*
GetRangeData(Rocket::Core::Element *element) {
return (RangeData*)GetElementUserData(element, "__menu_range_data");
}
/*** Key Data ***/
struct KeyData {
Rocket::Core::Element *menu_item;
Rocket::Core::Element *hdr1, *ftr1;
Rocket::Core::Element *hdr2, *ftr2;
Rocket::Core::Element *opt1, *opt2;
KeyData():menu_item(NULL),hdr1(NULL),ftr1(NULL),hdr2(NULL),ftr2(NULL),opt1(NULL),opt2(NULL){}
virtual ~KeyData(){}
};
static void
SetKeyData(Rocket::Core::Element *element, KeyData *data) {
SetElementUserData(element, (void*)data, "__menu_key_data");
}
static KeyData*
GetKeyData(Rocket::Core::Element *element) {
return (KeyData*)GetElementUserData(element, "__menu_key_data");
}
/************/
RocketMenuPlugin::RocketMenuPlugin():m_animation(0),m_delegate(0) {
}
RocketMenuPlugin::~RocketMenuPlugin() {
}
void RocketMenuPlugin::OnInitialise() {
}
void RocketMenuPlugin::OnShutdown() {
}
void RocketMenuPlugin::OnDocumentOpen(Rocket::Core::Context* context, const Rocket::Core::String& document_path) {
}
void RocketMenuPlugin::SetupOptions(Rocket::Core::Element *menu_item, Rocket::Core::Element *options_element) {
OptionsData *data = new OptionsData();
SetOptionsData(menu_item, data);
data->menu_item = menu_item;
options_element->GetElementsByTagName(data->options, "option");
if (data->options.size() == 0) {
if (m_delegate != NULL) {
m_delegate->PopulateOptions(menu_item, options_element);
options_element->GetElementsByTagName(data->options, "option");
}
}
data->hdr = Rocket::Core::Factory::InstanceElement(options_element, "hdr", "hdr", Rocket::Core::XMLAttributes());
data->hdr->AddEventListener("click", this);
data->hdr->SetInnerRML("<");
ShowElement(data->hdr, false);
options_element->InsertBefore(data->hdr, options_element->GetFirstChild());
data->hdr->RemoveReference();
data->ftr = Rocket::Core::Factory::InstanceElement(options_element, "ftr", "ftr", Rocket::Core::XMLAttributes());
data->ftr->AddEventListener("click", this);
data->ftr->SetInnerRML(">");
ShowElement(data->ftr, false);
options_element->AppendChild(data->ftr);
data->ftr->RemoveReference();
for (Rocket::Core::ElementList::iterator i = data->options.begin(); i != data->options.end(); i++) {
Rocket::Core::Element *element = *i;
ShowElement(element, false);
}
data->current = data->options.begin();
ShowElement(*data->current, true);
}
void RocketMenuPlugin::SetupRange(Rocket::Core::Element *menu_item, Rocket::Core::Element *range_element) {
RangeData *data = new RangeData();
SetRangeData(menu_item, data);
data->menu_item = menu_item;
if (range_element->HasAttribute("min")) {
data->min = range_element->GetAttribute("min")->Get<float>();
}
if (range_element->HasAttribute("max")) {
data->max = range_element->GetAttribute("max")->Get<float>();
}
if (range_element->HasAttribute("value")) {
data->value = range_element->GetAttribute("value")->Get<float>();
}
if (range_element->HasAttribute("step")) {
data->step = range_element->GetAttribute("step")->Get<float>();
}
data->hdr = Rocket::Core::Factory::InstanceElement(range_element, "hdr", "hdr", Rocket::Core::XMLAttributes());
data->hdr->AddEventListener("click", this);
data->hdr->SetInnerRML("<");
ShowElement(data->hdr, false);
//options_element->InsertBefore(data->hdr, options_element->GetFirstChild());
range_element->AppendChild(data->hdr);
data->hdr->RemoveReference();
Rocket::Core::XMLAttributes input_attrs;
input_attrs.Set("type", "range");
input_attrs.Set("min", 0.0f);
input_attrs.Set("max", 1.0f);
input_attrs.Set("step", 0.001f);
input_attrs.Set("value", (data->value - data->min)/(data->max - data->min));
data->range = Rocket::Core::Factory::InstanceElement(range_element, "input", "input", input_attrs);
data->range->AddEventListener("change", this);
data->range->SetProperty("margin-top", "15px");
range_element->AppendChild(data->range);
data->range->RemoveReference();
data->ftr = Rocket::Core::Factory::InstanceElement(range_element, "ftr", "ftr", Rocket::Core::XMLAttributes());
data->ftr->AddEventListener("click", this);
data->ftr->SetInnerRML(">");
ShowElement(data->ftr, false);
range_element->AppendChild(data->ftr);
data->ftr->RemoveReference();
SetRangeValue(menu_item, data->value, false);
}
void RocketMenuPlugin::SetupKeyChooser(Rocket::Core::Element *element) {
Rocket::Core::String caption;
element->GetInnerRML(caption);
element->SetInnerRML("<caption/><keys><key1><hdr><</hdr><keyval/><ftr>></ftr></key1><key2><hdr><</hdr><keyval/><ftr>></ftr></key2></keys>");
Rocket::Core::Element *caption_element = element->GetChild(0);
caption_element->SetInnerRML(caption);
Rocket::Core::Element *keys_element = element->GetChild(1);
Rocket::Core::Element *key1_element = keys_element->GetChild(0);
Rocket::Core::Element *key2_element = keys_element->GetChild(1);
key1_element->AddEventListener("mousemove", this, false);
key2_element->AddEventListener("mousemove", this, false);
KeyData *data = new KeyData();
data->menu_item = element;
data->hdr1 = key1_element->GetChild(0);
data->opt1 = key1_element->GetChild(1);
data->ftr1 = key1_element->GetChild(2);
data->hdr2 = key2_element->GetChild(0);
data->opt2 = key2_element->GetChild(1);
data->ftr2 = key2_element->GetChild(2);
data->opt1->SetInnerRML("None");
data->opt2->SetInnerRML("None");
ShowElement(data->hdr1, false);
ShowElement(data->ftr1, false);
ShowElement(data->hdr2, false);
ShowElement(data->ftr2, false);
SetKeyData(element, data);
}
void RocketMenuPlugin::SetupMenuItem(Rocket::Core::Element *element) {
element->AddEventListener("click", this);
element->AddEventListener("mousemove", this);
element->AddEventListener("mouseout", this);
if (element->HasAttribute("options") && element->GetNumChildren() > 0) {
Rocket::Core::ElementList options_list;
element->GetElementsByTagName(options_list, "options");
if (options_list.size() > 0) {
SetupOptions(element, options_list[0]);
}
}
if (element->HasAttribute("range") && element->GetNumChildren() > 0) {
Rocket::Core::ElementList elist;
element->GetElementsByTagName(elist, "range");
if (elist.size() > 0) {
SetupRange(element, elist[0]);
}
}
if (element->HasAttribute("key-chooser")) {
SetupKeyChooser(element);
}
}
void RocketMenuPlugin::OnDocumentLoad(Rocket::Core::ElementDocument* document) {
DocumentData *doc_data = new DocumentData();
doc_data->cursor_left = document->GetElementById("cursor-left");
doc_data->cursor_right = document->GetElementById("cursor-right");
doc_data->menu = document->GetElementById("menu");
if (doc_data->menu == NULL) {
for (int i = 0, n = document->GetNumChildren(); i!=n; i++) {
Rocket::Core::Element *element = document->GetChild(i);
if (element->IsClassSet("game-menu")) {
doc_data->menu = element;
break;
}
}
}
if (doc_data->menu != NULL) {
for (int i = 0, n = doc_data->menu->GetNumChildren(); i < n; i++) {
Rocket::Core::Element *e = doc_data->menu->GetChild(i);
SetupMenuItem(e);
}
SetDocumentData(document, doc_data);
} else {
delete doc_data;
}
}
// Called when a document is unloaded from its context. This is called after the document's 'unload' event.
void RocketMenuPlugin::OnDocumentUnload(Rocket::Core::ElementDocument* document) {
delete GetDocumentData(document);
}
// Called when a new context is created.
void RocketMenuPlugin::OnContextCreate(Rocket::Core::Context* context) {
SetContextData(context, new ContextData());
}
// Called when a context is destroyed.
void RocketMenuPlugin::OnContextDestroy(Rocket::Core::Context* context) {
ContextData *data = GetContextData(context);
if (data != NULL) {
delete data;
SetContextData(context, NULL);
}
}
// Called when a new element is created
void RocketMenuPlugin::OnElementCreate(Rocket::Core::Element* element) {
}
// Called when an element is destroyed.
void RocketMenuPlugin::OnElementDestroy(Rocket::Core::Element* element) {
OptionsData *options_data = GetOptionsData(element);
if (options_data != NULL) {
delete options_data;
SetOptionsData(element, NULL);
}
RangeData *range_data = GetRangeData(element);
if (range_data != NULL) {
delete range_data;
SetRangeData(element, NULL);
}
KeyData *key_data = GetKeyData(element);
if (key_data != NULL) {
delete key_data;
SetKeyData(element, NULL);
}
}
class ColorAnimation: public BasicAnimationActuator {
private:
rgb p, q;
//Rocket::Core::String initial_color;
//Rocket::Core::Colourb initial_color;
void ApplyColorsForPosition(Rocket::Core::Element *e, float position) {
rgb v = rgb_lerp(p, q, position);
char color[50];
int r = (int)(v.r*255);
int g = (int)(v.g*255);
int b = (int)(v.b*255);
sprintf(color, "rgb(%d,%d,%d)", r, g, b);
e->SetProperty("color", color);;
}
public:
ColorAnimation(rgb p, rgb q, float offset):p(p),q(q) {
}
virtual void Init(Rocket::Core::Element *element) {
/*
initial_color = element->GetProperty<Rocket::Core::Colourb>("color");
*/
};
virtual void Apply(Rocket::Core::Element *e, float position) {
ApplyColorsForPosition(e, position);
}
virtual void Stop(Rocket::Core::Element *e) {};
virtual void Reset(Rocket::Core::Element *e) {
e->RemoveProperty("color");
};
};
void RocketMenuPlugin::ProcessEvent(Rocket::Core::Event& event) {
Rocket::Core::Element *element = event.GetCurrentElement();
if (event.GetType() == "click") {
if (element->GetTagName() == "ftr") {
SetNextItemValue(element->GetParentNode()->GetParentNode());
event.StopPropagation();
} else if (element->GetTagName() == "hdr") {
SetPreviousItemValue(element->GetParentNode()->GetParentNode());
event.StopPropagation();
} else {
DoItemAction(ItemActionEnter, element);
}
} else if (event.GetType() == "mousemove") {
if (element->GetTagName() == "div") {
HighlightItem(element);
} else if (element->GetTagName() == "key1") {
Rocket::Core::Element *menu_item = element->GetParentNode()->GetParentNode();
SetActiveKeySlot(menu_item, 0);
} else if (element->GetTagName() == "key2") {
Rocket::Core::Element *menu_item = element->GetParentNode()->GetParentNode();
SetActiveKeySlot(menu_item, 1);
}
} else if (event.GetType() == "change") {
if (m_delegate != NULL && element->GetOwnerDocument()->IsVisible()) {
Rocket::Core::Element *menu_item = element->GetParentNode()->GetParentNode();
RangeData *data = GetRangeData(menu_item);
const Rocket::Core::Dictionary *p = event.GetParameters();
float v = p->Get("value")->Get<float>();
float new_value = data->min + v*(data->max - data->min);
if (fabs(new_value-data->value) > 0.001f) {
data->value = new_value;
m_delegate->DidChangeRangeValue(menu_item, data->value);
}
}
}
}
void RocketMenuPlugin::ShowDocument(Rocket::Core::Context* context, const Rocket::Core::String& id, bool backlink) {
ContextData *cd = GetContextData(context);
Rocket::Core::ElementDocument *new_doc = context->GetDocument(id);
if (new_doc != NULL) {
if (new_doc != cd->current_document) {
if (cd->current_document != NULL) {
if (cd->current_document->IsVisible()) {
cd->current_document->Hide();
if (m_delegate) {
m_delegate->DidCloseMenuPage(cd->current_document);
}
}
if (backlink) {
new_doc->SetAttribute("parent", cd->current_document->GetId());
}
}
cd->current_document = new_doc;
DocumentData *dd = GetDocumentData(cd->current_document);
if (cd->current_document->HasAttribute("default-item")) {
Rocket::Core::String def;
cd->current_document->GetAttribute("default-item")->GetInto(def);
if (dd->menu != NULL) {
HighlightItem(cd->current_document->GetElementById(def));
}
} else {
if (dd->active_item == NULL) {
if (dd->menu != NULL) {
HighlightItem(dd->menu->GetChild(0));
}
}
}
if (!cd->current_document->IsVisible()) {
cd->current_document->Show();
if (m_delegate) {
m_delegate->DidOpenMenuPage(cd->current_document);
}
}
}
} else {
printf("[ROCK] unable to show document with id: %s\n", id.CString());
}
}
bool RocketMenuPlugin::GoBack(Rocket::Core::Context *context, bool notify_delegate) {
ContextData *cd = GetContextData(context);
if (cd->current_document != NULL) {
Rocket::Core::Variant *attr = cd->current_document->GetAttribute("parent");
if (attr != NULL) {
Rocket::Core::String menu_id = attr->Get<Rocket::Core::String>();
if (cd->current_document->HasAttribute("closecmd") && notify_delegate) {
Rocket::Core::String closecmd;
cd->current_document->GetAttribute("closecmd")->GetInto(closecmd);
cd->current_document->RemoveAttribute("closecmd");
m_delegate->DoCommand(cd->current_document, closecmd);
cd->current_document->SetAttribute("closecmd", closecmd);
}
ShowDocument(context, menu_id, false);
return true;
}
}
return false;
}
void RocketMenuPlugin::SetAnimationPlugin(RocketAnimationPlugin *p) {
m_animation = p;
}
static
void AttachCursor(Rocket::Core::Element *menu_item, Rocket::Core::Element *cursor_left, Rocket::Core::Element *cursor_right) {
float item_width = menu_item->GetOffsetWidth();
float item_height = menu_item->GetOffsetHeight();
float item_x = menu_item->GetAbsoluteLeft();
float item_y = menu_item->GetAbsoluteTop();
if (cursor_left != NULL) {
float cursor_height = cursor_left->GetOffsetHeight();
cursor_left->SetProperty("left", Rocket::Core::Property(item_x-cursor_left->GetOffsetWidth(), Rocket::Core::Property::PX));
cursor_left->SetProperty("top", Rocket::Core::Property(item_y + (item_height-cursor_height)/2, Rocket::Core::Property::PX));
}
if (cursor_right != NULL) {
float cursor_height = cursor_right->GetOffsetHeight();
cursor_right->SetProperty("left", Rocket::Core::Property(item_x+item_width, Rocket::Core::Property::PX));
cursor_right->SetProperty("top", Rocket::Core::Property(item_y + (item_height-cursor_height)/2, Rocket::Core::Property::PX));
}
}
static
void DoScroll(Rocket::Core::Element *old, Rocket::Core::Element *neww, Rocket::Core::Element *scroll) {
//float scroll_height = scroll->GetScrollHeight();
float new_top = neww->GetOffsetTop();
float new_height = neww->GetOffsetHeight();
float window_height = scroll->GetOffsetHeight();
float position = scroll->GetScrollTop();
if (new_top < position || (new_top + new_height > position + window_height)) {
if (old == NULL) {
position = new_top+new_height/2-window_height/2;
} else {
float old_top = old->GetOffsetTop();
if (old_top < new_top) {
position = new_top+new_height-window_height;
} else {
position = new_top;
}
}
scroll->SetScrollTop(position);
}
}
static void
UpdateKeyChooser(KeyData *data, int active_key, bool highlight) {
ShowElement(data->hdr1, highlight && !active_key);
ShowElement(data->ftr1, highlight && !active_key);
ShowElement(data->hdr2, highlight && active_key);
ShowElement(data->ftr2, highlight && active_key);
}
void RocketMenuPlugin::HighlightItem(Rocket::Core::Element *e) {
static ColorAnimation colorAnimation(rgb(255,255,255), rgb(235, 156, 9), 1);
DocumentData *doc_data = GetDocumentData(e->GetOwnerDocument());
if (doc_data != NULL) {
if (doc_data->active_item != e && !e->IsClassSet("disabled")) {
if (doc_data->active_item != NULL) {
m_animation->CancelAnimation(doc_data->active_item);
OptionsData *options_data = GetOptionsData(doc_data->active_item);
if (options_data != NULL) {
ShowElement(options_data->hdr, false);
ShowElement(options_data->ftr, false);
}
RangeData *range_data = GetRangeData(doc_data->active_item);
if (range_data != NULL) {
ShowElement(range_data->hdr, false);
ShowElement(range_data->ftr, false);
}
KeyData *key_data = GetKeyData(doc_data->active_item);
if (key_data != NULL) {
UpdateKeyChooser(key_data, doc_data->active_key, false);
}
}
if (e != NULL) {
if (e->GetParentNode()->HasAttribute("scroll")) {
DoScroll(doc_data->active_item, e, e->GetParentNode()->GetParentNode());
}
if (!e->HasAttribute("noanim")) {
m_animation->AnimateElement(e, AnimationTypeBounce, 0.3f, &colorAnimation);
}
AttachCursor(e, doc_data->cursor_left, doc_data->cursor_right);
OptionsData *options_data = GetOptionsData(e);
if (options_data != NULL) {
ShowElement(options_data->hdr, true);
ShowElement(options_data->ftr, true);
}
RangeData *range_data = GetRangeData(e);
if (range_data != NULL) {
ShowElement(range_data->hdr, true);
ShowElement(range_data->ftr, true);
}
KeyData *key_data = GetKeyData(e);
if (key_data != NULL) {
UpdateKeyChooser(key_data, doc_data->active_key, true);
}
m_delegate->DidActivateItem(e);
}
doc_data->active_item = e;
}
}
}
void RocketMenuPlugin::HighlightItem(Rocket::Core::ElementDocument *document, const Rocket::Core::String& id) {
Rocket::Core::Element *element = document->GetElementById(id);
if (element != 0) {
HighlightItem(element);
} else {
printf("[ROCK] RocketMenuPlugin::HighlightItem: unable to find element with id='%s'\n", id.CString());
}
}
void RocketMenuPlugin::HighlightItem(Rocket::Core::Context *context, const Rocket::Core::String& docId, const Rocket::Core::String& elementId) {
Rocket::Core::ElementDocument *doc = context->GetDocument(docId);
if (doc != NULL) {
HighlightItem(doc, elementId);
} else {
printf("[ROCK] RocketMenuPlugin::HighlightItem: unable to find document with id='%s'\n", docId.CString());
}
}
void RocketMenuPlugin::HighlightItem(Rocket::Core::Context *context, const Rocket::Core::String& elementId) {
ContextData *cd = GetContextData(context);
if (cd->current_document != NULL) {
HighlightItem(cd->current_document, elementId);
}
}
Rocket::Core::Element* RocketMenuPlugin::FindNextItem(Rocket::Core::Element *menu_item) {
Rocket::Core::Element *next = menu_item;
do {
next = next->GetNextSibling();
if (next == NULL) {
next = menu_item->GetParentNode()->GetChild(0);
}
} while (next->IsClassSet("disabled") && next != menu_item);
return next;
}
Rocket::Core::Element* RocketMenuPlugin::FindPreviousItem(Rocket::Core::Element *menu_item) {
Rocket::Core::Element *next = menu_item;
do {
next = next->GetPreviousSibling();
if (next == NULL) {
next = menu_item->GetParentNode()->GetChild(menu_item->GetParentNode()->GetNumChildren()-1);
}
} while (next->IsClassSet("disabled") && next != menu_item);
return next;
}
void RocketMenuPlugin::HighlightNextItem(Rocket::Core::ElementDocument *document = NULL) {
DocumentData *doc_data = GetDocumentData(document);
if (doc_data != NULL) {
if (doc_data->active_item != NULL) {
Rocket::Core::Element *e = FindNextItem(doc_data->active_item);
if (e != NULL) {
HighlightItem(e);
}
}
} else {
printf("[ROCK] RocketMenuPlugin::HighlightNextItem: attempt to activate next item on the document with no menu\n");
}
}
void RocketMenuPlugin::HighlightNextItem(Rocket::Core::Context *context, const Rocket::Core::String& docId) {
Rocket::Core::ElementDocument *doc = NULL;
if (docId == "") {
ContextData *cd = GetContextData(context);
doc = cd->current_document;
} else {
doc = context->GetDocument(docId);
}
if (doc != NULL) {
HighlightNextItem(doc);
} else {
printf("[ROCK] RocketMenuPlugin::HighlightNextItem: document not found: %s\n", docId.CString());
}
}
void RocketMenuPlugin::HighlightPreviousItem(Rocket::Core::ElementDocument *document) {
DocumentData *doc_data = GetDocumentData(document);
if (doc_data != NULL) {
if (doc_data->active_item != NULL) {
Rocket::Core::Element *e = FindPreviousItem(doc_data->active_item);
if (e != NULL) {
HighlightItem(e);
}
}
} else {
printf("[ROCK] RocketMenuPlugin::HighlightPreviousItem: attempt to activate next item on the document with no menu\n");
}
}
void RocketMenuPlugin::HighlightPreviousItem(Rocket::Core::Context *context, const Rocket::Core::String& docId) {
Rocket::Core::ElementDocument *doc = NULL;
if (docId == "") {
ContextData *cd = GetContextData(context);
doc = cd->current_document;
} else {
doc = context->GetDocument(docId);
}
if (doc != NULL) {
HighlightPreviousItem(doc);
} else {
printf("[ROCK] RocketMenuPlugin::HighlightPreviousItem: document not found: %s\n", docId.CString());
}
}
void RocketMenuPlugin::DoItemAction(ItemAction action, Rocket::Core::Element *e) {
if (!e->IsClassSet("disabled")) {
switch (action) {
case ItemActionEnter: {
if (e->HasAttribute("submenu")) {
bool backlink = !e->HasAttribute("noref");
Rocket::Core::String submenu;
e->GetAttribute("submenu")->GetInto(submenu);
ShowDocument(e->GetContext(), submenu, backlink);
}
if (e->HasAttribute("command") && m_delegate != NULL) {
Rocket::Core::String command;
e->GetAttribute("command")->GetInto(command);
m_delegate->DoCommand(e, command);
}
if (e->HasAttribute("options")) {
ActivateNextOption(e);
}
RequestKeyForKeyChooser(e);
break;
}
case ItemActionLeft:
if (e->HasAttribute("options")) {
ActivatePreviousOption(e);
}
break;
case ItemActionRight:
if (e->HasAttribute("options")) {
ActivateNextOption(e);
}
break;
case ItemActionClear: {
ClearMenuItem(e);
break;
}
}
}
}
void RocketMenuPlugin::DoItemAction(ItemAction action, Rocket::Core::ElementDocument *document, const Rocket::Core::String& id) {
Rocket::Core::Element *element = document->GetElementById(id);
if (element != NULL) {
DoItemAction(action, element);
} else {
printf("[ROCK] RocketMenuPlugin::DoItemAction: element not found: %s\n", id.CString());
}
}
void RocketMenuPlugin::DoItemAction(ItemAction action, Rocket::Core::Context *context, const Rocket::Core::String& docId, const Rocket::Core::String& elementId) {
Rocket::Core::ElementDocument *doc = context->GetDocument(docId);
if (doc != NULL) {
DoItemAction(action, doc, elementId);
} else {
printf("[ROCK] RocketMenuPlugin::DoItemAction: document not found: %s\n", docId.CString());
}
}
void RocketMenuPlugin::DoItemAction(ItemAction action, Rocket::Core::Context *context, const Rocket::Core::String& id) {
ContextData *cd = GetContextData(context);
if (cd->current_document != NULL) {
DocumentData *dd = GetDocumentData(cd->current_document);
Rocket::Core::Element *e = NULL;
if (id != "") {
e = cd->current_document->GetElementById(id);
} else if (dd != NULL) {
e = dd->active_item;
}
if (e != NULL) {
DoItemAction(action, e);
}
}
}
Rocket::Core::Element* RocketMenuPlugin::GetHighlightedItem(Rocket::Core::ElementDocument *doc) {
DocumentData *dd = GetDocumentData(doc);
return dd ? dd->active_item : NULL;
}
Rocket::Core::Element* RocketMenuPlugin::GetHighlightedItem(Rocket::Core::Context *context, const Rocket::Core::String& docId) {
Rocket::Core::ElementDocument *doc = context->GetDocument(docId);
return doc ? GetHighlightedItem(doc) : NULL;
}
void RocketMenuPlugin::SetDelegate(RocketMenuDelegate *delegate) {
m_delegate = delegate;
}
RocketMenuDelegate* RocketMenuPlugin::GetDelegate() {
return m_delegate;
}
void RocketMenuPlugin::ActivateNextOption(Rocket::Core::Element *menu_item) {
OptionsData *data = GetOptionsData(menu_item);
if (data != NULL) {
Rocket::Core::ElementList::iterator next = data->current+1;
if (next == data->options.end()) {
next = data->options.begin();
}
ActivateOption(data, next);
}
}
void RocketMenuPlugin::ActivatePreviousOption(Rocket::Core::Element *menu_item) {
OptionsData *data = GetOptionsData(menu_item);
if (data != NULL) {
Rocket::Core::ElementList::iterator next = data->current;
if (next == data->options.begin()) {
next = data->options.end()-1;
} else {
next--;
}
ActivateOption(data, next);
}
}
void RocketMenuPlugin::ActivateOption(Rocket::Core::Element *menu_item, Rocket::Core::Element *option, bool notify_delegate) {
OptionsData *data = GetOptionsData(menu_item);
if (data != NULL) {
Rocket::Core::ElementList::iterator next = data->options.end();
for (Rocket::Core::ElementList::iterator i = data->options.begin(); i != data->options.end(); i++) {
if (*i == option) {
next = i;
break;
}
}
if (next != data->options.end()) {
ActivateOption(data, next, notify_delegate);
}
}
}
void RocketMenuPlugin::ActivateOption(Rocket::Core::Element *menu_item, const Rocket::Core::String& option_id, bool notify_delegate) {
OptionsData *data = GetOptionsData(menu_item);
if (data != NULL) {
Rocket::Core::ElementList::iterator next = data->options.end();
for (Rocket::Core::ElementList::iterator i = data->options.begin(); i != data->options.end(); i++) {
if ((*i)->GetId() == option_id) {
next = i;
break;
}
}
if (next != data->options.end()) {
ActivateOption(data, next, notify_delegate);
}
}
}
void RocketMenuPlugin::ActivateOption(OptionsData *data, Rocket::Core::ElementList::iterator next, bool notify_delegate) {
if (next != data->current) {
ShowElement(*data->current, false);
ShowElement(*next, true);
data->current = next;
if (m_delegate != NULL && notify_delegate) {
m_delegate->DidChangeOptionValue(data->menu_item, *(data->current));
}
}
}
void RocketMenuPlugin::SetNextItemValue(Rocket::Core::Context *context) {
ContextData *cd = GetContextData(context);
if (cd != NULL) {
Rocket::Core::ElementDocument *doc = cd->current_document;
if (doc != NULL) {
DocumentData *dd = GetDocumentData(doc);
if (dd != NULL) {
SetNextItemValue(dd->active_item);
}
}
}
}
void RocketMenuPlugin::SetPreviousItemValue(Rocket::Core::Context *context) {
ContextData *cd = GetContextData(context);
if (cd != NULL) {
Rocket::Core::ElementDocument *doc = cd->current_document;
if (doc != NULL) {
DocumentData *dd = GetDocumentData(doc);
if (dd != NULL) {
SetPreviousItemValue(dd->active_item);
}
}
}
}
Rocket::Core::ElementDocument* RocketMenuPlugin::GetCurrentPage(Rocket::Core::Context *context) {
ContextData *cd = GetContextData(context);
if (cd != NULL) {
return cd->current_document;
}
return NULL;
}
Rocket::Core::Element* RocketMenuPlugin::GetMenuItem(Rocket::Core::ElementDocument *doc, const Rocket::Core::String& id) {
DocumentData *dd = GetDocumentData(doc);
if (dd != NULL) {
return dd->menu->GetElementById(id);
}
return NULL;
}
Rocket::Core::Element* RocketMenuPlugin::GetMenuItem(Rocket::Core::ElementDocument *doc, int index) {
DocumentData *dd = GetDocumentData(doc);
if (dd != NULL) {
return dd->menu->GetChild(index);
}
return NULL;
}
int RocketMenuPlugin::GetNumMenuItems(Rocket::Core::ElementDocument *doc) {
DocumentData *dd = GetDocumentData(doc);
if (dd != NULL) {
return dd->menu->GetNumChildren();
}
return NULL;
}
Rocket::Core::Element* RocketMenuPlugin::GetActiveOption(Rocket::Core::Element *menu_item) {
OptionsData *data = GetOptionsData(menu_item);
if (data != NULL) {
return *(data->current);
}
return NULL;
}
Rocket::Core::Element* RocketMenuPlugin::GetOptionById(Rocket::Core::Element *menu_item, const Rocket::Core::String& option_id) {
OptionsData *data = GetOptionsData(menu_item);
if (data != NULL) {
for (Rocket::Core::ElementList::iterator i = data->options.begin(); i != data->options.end(); i++) {
if ((*i)->GetId() == option_id) {
return *i;
}
}
}
return NULL;
}
void RocketMenuPlugin::SetRangeValue(Rocket::Core::Element *menu_item, float value, bool notify_delegate) {
RangeData *data = GetRangeData(menu_item);
if (data != NULL) {
Rocket::Core::String tmp;
// printf("=======\n");
// data->range->GetAttribute("min")->GetInto(tmp);
// printf("min: %s\n", tmp.CString());
// data->range->GetAttribute("max")->GetInto(tmp);
// printf("max: %s\n", tmp.CString());
// data->range->GetAttribute("value")->GetInto(tmp);
// printf("value: %s\n", tmp.CString());
// data->range->GetAttribute("step")->GetInto(tmp);
// printf("step: %s\n", tmp.CString());
data->value = clamp(value, data->min, data->max);
data->range->SetAttribute("value", (data->value - data->min)/(data->max - data->min));
#if 0
float position = data->rail_x + data->value/(data->max-data->min)*data->rail_length;
data->grip->SetProperty("left", Rocket::Core::Property(position, Rocket::Core::Property::PX));
#endif
// if (m_delegate != NULL && notify_delegate) {
// m_delegate->DidChangeRangeValue(menu_item, value);
// }
}
}
float RocketMenuPlugin::GetRangeValue(Rocket::Core::Element *menu_item) {
RangeData *data = GetRangeData(menu_item);
if (data != NULL) {
return data->value;
}
return 0.0f;
}
void RocketMenuPlugin::IncreaseRangeValue(Rocket::Core::Element *menu_item) {
RangeData *data = GetRangeData(menu_item);
if (data != NULL) {
SetRangeValue(menu_item, data->value + data->step);
}
}
void RocketMenuPlugin::DecreaseRangeValue(Rocket::Core::Element *menu_item) {
RangeData *data = GetRangeData(menu_item);
if (data != NULL) {
SetRangeValue(menu_item, data->value - data->step);
}
}
static
void ChangeActiveKeySlot(Rocket::Core::Element *menu_item) {
Rocket::Core::Context *context = menu_item->GetContext();
DocumentData *document_data = GetDocumentData(menu_item->GetOwnerDocument());
KeyData *key_data = GetKeyData(menu_item);
if (document_data != NULL && key_data != NULL) {
document_data->active_key = 1-document_data->active_key;
UpdateKeyChooser(key_data, document_data->active_key, true);
}
}
static
void SetActiveKeySlot(Rocket::Core::Element *menu_item, int active_key) {
Rocket::Core::Context *context = menu_item->GetContext();
DocumentData *document_data = GetDocumentData(menu_item->GetOwnerDocument());
KeyData *key_data = GetKeyData(menu_item);
if (document_data != NULL && key_data != NULL) {
document_data->active_key = active_key;
UpdateKeyChooser(key_data, document_data->active_key, true);
}
}
void RocketMenuPlugin::SetNextItemValue(Rocket::Core::Element *menu_item) {
ActivateNextOption(menu_item);
IncreaseRangeValue(menu_item);
ChangeActiveKeySlot(menu_item);
}
void RocketMenuPlugin::SetPreviousItemValue(Rocket::Core::Element *menu_item) {
ActivatePreviousOption(menu_item);
DecreaseRangeValue(menu_item);
ChangeActiveKeySlot(menu_item);
}
void RocketMenuPlugin::RequestKeyForKeyChooser(Rocket::Core::Element *menu_item) {
Rocket::Core::Context *context = menu_item->GetContext();
DocumentData *document_data = GetDocumentData(menu_item->GetOwnerDocument());
KeyData *key_data = GetKeyData(menu_item);
if (document_data != NULL && key_data != NULL && m_delegate != NULL) {
m_delegate->DidRequestKey(menu_item, document_data->active_key);
}
}
void RocketMenuPlugin::SetKeyChooserValue(Rocket::Core::Element *menu_item, int slot, const Rocket::Core::String& text, const Rocket::Core::String& id) {
DocumentData *document_data = GetDocumentData(menu_item->GetOwnerDocument());
KeyData *key_data = GetKeyData(menu_item);
if (document_data != NULL && key_data != NULL && m_delegate != NULL) {
Rocket::Core::Element *slot_element = slot ? key_data->opt2 : key_data->opt1;
slot_element->SetId(id);
slot_element->SetInnerRML(text);
slot_element->SetClass("no-key-chosen", id == "None");
}
}
const Rocket::Core::String RocketMenuPlugin::GetKeyChooserValue(Rocket::Core::Element *menu_item, int slot) {
DocumentData *document_data = GetDocumentData(menu_item->GetOwnerDocument());
KeyData *key_data = GetKeyData(menu_item);
if (document_data != NULL && key_data != NULL && m_delegate != NULL) {
Rocket::Core::Element *slot_element = slot ? key_data->opt2 : key_data->opt1;
return slot_element->GetId();
}
return "";
}
void RocketMenuPlugin::ClearMenuItem(Rocket::Core::Element *menu_item) {
KeyData *key_data = GetKeyData(menu_item);
if (key_data != NULL) {
DocumentData *document_data = GetDocumentData(menu_item->GetOwnerDocument());
if (document_data != NULL) {
SetKeyChooserValue(menu_item, document_data->active_key, "None", "None");
if (m_delegate != NULL) {
m_delegate->DidClearKeyChooserValue(menu_item, document_data->active_key);
}
}
}
}
| [
"drtermit@gmail.com"
] | drtermit@gmail.com |
ea1ac8cf33734e88dd3d80c10656ba5a8b4c5c1b | a1fe3366863fd797feb19d83dccfd4c3a5cb690a | /SDRSpectrumAnalyzerOpenGL/SDRSpectrumAnalyzerOpenGL/GUI.cpp | 1215e19e32dcdfb01bef296ad2c69a0d89c46766 | [] | no_license | moderncoder/SDRReradiationSpectrumAnalyzer | da1733c8d1b6cd7817bf1e1d13ac17f6660189ef | c347e3ab9d62f48daf23dd76222abc44f596fd93 | refs/heads/master | 2023-03-14T22:22:16.068295 | 2021-03-10T12:15:43 | 2021-03-10T12:15:43 | 346,340,703 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 248 | cpp | #include "Graphs.h"
class GUI
{
private:
Graphs* graphs = new Graphs();
Graph *dataGraph, *fftGraphForDevicesRange, *correlationGraph, *fftGraphStrengthsForDeviceRange;
SelectedGraph selectedGraphStart;
SelectedGraph selectedGraphEnd;
}; | [
"clint@getfitnowapps.com"
] | clint@getfitnowapps.com |
0c16910a04dda4ec46f01ae098e97aa487928b65 | 2896d712be1d186526bb7611e539edc608b8b0a2 | /Object/arxiv/Geo2DObjectUtilFunc.h | de9055f6422df7438d70de97ab098d145cf57ad0 | [] | no_license | LArbys/Geo2D | bc694e92d801f8f5546a0d6d95fdf7fea57de7df | 8522ba20c78d5b03098185e4d86fe5fde9fec208 | refs/heads/master | 2021-09-08T09:42:09.860852 | 2016-09-28T23:11:09 | 2016-09-28T23:11:09 | 69,510,990 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 93 | h | #ifndef GEO2DOBJECTUTILFUNC_H
#define GEO2DOBJECTUTILFUNC_H
namespace geo2d {
}
#endif
| [
"kazuhiro@nevis.columbia.edu"
] | kazuhiro@nevis.columbia.edu |
ff891063324d65de746ed7925ad69c61fef1bf59 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/git/gumtree/git_old_hunk_3763.cpp | 566166f84130cf8dfd99af4a54a3a025a9724570 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 358 | cpp |
color = diff_get_color_opt(&opt->diffopt,
status ? DIFF_WHITESPACE : DIFF_FRAGINFO);
reset = diff_get_color_opt(&opt->diffopt, DIFF_RESET);
while (*bol) {
eol = strchrnul(bol, '\n');
printf("%s%.*s%s%s", color, (int)(eol - bol), bol, reset,
*eol ? "\n" : "");
graph_show_oneline(opt->graph);
bol = (*eol) ? (eol + 1) : eol;
}
}
| [
"993273596@qq.com"
] | 993273596@qq.com |
5fe190846fcc2b626f587cabaf931a1942c226d6 | b37c75b4e587211cd463176ee46e5b4268e96683 | /BinaryTree/InvertBinaryTree.cpp | 4627e08e7f9065376af3b0e6ad29b696e41efffe | [] | no_license | tangziyi001/LeetCode | 0171044b472658f1bb4ff36cf939522d43ae24ae | a51640a282f60696d2627283684b563af6d584bc | refs/heads/master | 2021-06-12T19:53:18.100244 | 2017-04-05T00:09:42 | 2017-04-05T00:09:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 477 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
void invert(TreeNode* now){
if(now == NULL) return;
invert(now->left);
invert(now->right);
swap(now->left, now->right);
}
TreeNode* invertTree(TreeNode* root) {
invert(root);
return root;
}
}; | [
"tangziyi001@gmail.com"
] | tangziyi001@gmail.com |
a748964d68da56901dbea8cd530b420b6c0fbeed | dc2a81c665f7a79a10760b4bbde6d98d48c0bcbe | /src/logging/log.cpp | a21f9a3569e42027aa5c576d8b6bcdca974c678f | [
"MIT"
] | permissive | clman94/Wolf-Gang-Engine | 14b219b9518f6a14317ebcff4e7516de29504b9b | 52fa71d6be1fb940a0998f29b4e0ce631e624b25 | refs/heads/master | 2021-07-23T20:57:44.552521 | 2021-02-11T20:15:50 | 2021-02-11T20:15:50 | 68,487,653 | 5 | 2 | null | 2017-05-21T00:33:37 | 2016-09-18T01:29:31 | C++ | UTF-8 | C++ | false | false | 3,331 | cpp | #include <wge/logging/log.hpp>
#include <fmt/chrono.h>
#include <fmt/format.h>
#include <iostream>
#include <fstream>
#include <array>
#include <filesystem>
using namespace wge;
static const char* get_ansi_color_reset()
{
return "\033[0m";
}
static const char* get_ansi_color_for_level(log::level pSeverity_level)
{
switch (pSeverity_level)
{
case log::level::unknown: return "\033[95m"; break;
case log::level::info: return get_ansi_color_reset(); break;
case log::level::debug: return "\033[96m"; break;
case log::level::warning: return "\033[93m"; break;
case log::level::error: return "\033[91m"; break;
default: return get_ansi_color_reset();
}
}
namespace wge::log
{
static std::vector<message> gLog;
static std::ofstream gLog_output_file;
void message::stamp_time()
{
time_stamp = std::time(nullptr);
}
std::string message::to_string(bool pAnsi_color) const
{
std::tm timeinfo;
#ifdef __linux__
localtime_r(&time, &timeinfo);
#else
localtime_s(&timeinfo, &time_stamp);
#endif
constexpr std::array severity_level_name = { "Unknown", "Info", "Debug", "Warning", "Error" };
fmt::memory_buffer buffer;
fmt::format_to(buffer, "[{:%m-%d-%y %T}] {}{}: ",
timeinfo, pAnsi_color ? get_ansi_color_for_level(severity_level) : "",
severity_level_name[static_cast<std::size_t>(severity_level)]);
std::string line_info_str = line_info.to_string();
if (!line_info_str.empty())
fmt::format_to(buffer, "{}: ", line_info_str);
fmt::format_to(buffer, "{}{}", string, pAnsi_color ? get_ansi_color_reset() : "");
return fmt::to_string(std::move(buffer));
}
util::span<const message> get_log()
{
return gLog;
}
message& add_message(message&& pMessage)
{
gLog.emplace_back(std::forward<message>(pMessage));
std::cout << gLog.back().to_string(true) << std::endl;
return gLog.back();
}
message& add_message(const message& pMessage)
{
gLog.push_back(pMessage);
std::cout << gLog.back().to_string(true) << std::endl;
return gLog.back();
}
void userdata(userdata_t pData)
{
if (!gLog.empty())
{
gLog.back().userdata = std::move(pData);
}
}
bool open_file(const char* pFile)
{
gLog_output_file.open(pFile);
if (gLog_output_file)
info("Log: Successfully opened log file \"{}\"", pFile);
else
error("Log: Failed to open log file \"{}\"", pFile);
return gLog_output_file.good();
}
bool soft_assert(bool pExpression, std::string_view pMessage, line_info pLine_info)
{
if (!pExpression)
{
pLine_info.shorten_path();
warning("{} Assertion Failure: {}", pLine_info.to_string(), pMessage);
}
return pExpression;
}
void line_info::shorten_path()
{
if (!file.empty() &&
system_filesystem &&
std::filesystem::exists(file))
{
std::filesystem::path relate_path = std::filesystem::relative(file);
std::string path_str = relate_path.string();
if (file.length() > path_str.length())
file = path_str;
}
}
std::string line_info::to_string() const
{
fmt::memory_buffer buffer;
if (!file.empty())
fmt::format_to(buffer, "{}", file);
const bool has_line = line >= 0;
const bool has_column = column >= 0;
if (has_line && !has_column)
fmt::format_to(buffer, "({})", line);
else if (has_column)
fmt::format_to(buffer, "({}, {})",
has_line ? std::to_string(line).c_str() : "?",
column);
return fmt::to_string(buffer);
}
} // namespace wge::log
| [
"capnsword@gmail.com"
] | capnsword@gmail.com |
aee44828d6f764216813590d329151b71ced1cfa | 006f035d65012b7c5af15d54716407a276a096a8 | /dependencies/include/cgal/CGAL/Segment_Delaunay_graph_2/Segment_Delaunay_graph_2_impl.h | f16d7b5ab7435b930411414b7a6faf40b60979a8 | [] | no_license | rosecodym/space-boundary-tool | 4ce5b67fd96ec9b66f45aca60e0e69f4f8936e93 | 300db4084cd19b092bdf2e8432da065daeaa7c55 | refs/heads/master | 2020-12-24T06:51:32.828579 | 2016-08-12T16:13:51 | 2016-08-12T16:13:51 | 65,566,229 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 97,667 | h | // Copyright (c) 2003,2004,2005,2006 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// 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.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/releases/CGAL-4.1-branch/Segment_Delaunay_graph_2/include/CGAL/Segment_Delaunay_graph_2/Segment_Delaunay_graph_2_impl.h $
// $Id: Segment_Delaunay_graph_2_impl.h 70787 2012-07-27 10:38:58Z sloriot $
//
//
// Author(s) : Menelaos Karavelas <mkaravel@iacm.forth.gr>
// class implementation continued
//=================================
namespace CGAL {
//====================================================================
//====================================================================
// CONSTRUCTORS
//====================================================================
//====================================================================
// copy constructor
template<class Gt, class ST, class D_S, class LTag>
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
Segment_Delaunay_graph_2(const Segment_Delaunay_graph_2& other)
: DG(other.geom_traits())
{
Segment_Delaunay_graph_2&
non_const_other = const_cast<Segment_Delaunay_graph_2&>(other);
copy(non_const_other);
CGAL_postcondition( is_valid() );
}
// assignment operator
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Self&
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
operator=(const Self& other)
{
if ( this != &other ) {
Segment_Delaunay_graph_2&
non_const_other = const_cast<Segment_Delaunay_graph_2&>(other);
copy(non_const_other);
}
return (*this);
}
//====================================================================
//====================================================================
// METHODS FOR INSERTION
//====================================================================
//====================================================================
//--------------------------------------------------------------------
// insertion of first three sites
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_first(const Storage_site_2& ss, const Point_2& )
{
CGAL_precondition( number_of_vertices() == 0 );
Vertex_handle v = this->_tds.insert_second();
v->set_site(ss);
return v;
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_second(const Storage_site_2& ss, const Point_2& p)
{
CGAL_precondition( number_of_vertices() == 1 );
// p0 is actually a point
Site_2 p0 = finite_vertices_begin()->site();
// MK: change the equality test between points by the functor in
// geometric traits
Site_2 tp = Site_2::construct_site_2(p);
if ( same_points(tp,p0) ) {
// merge info of identical sites
merge_info(finite_vertices_begin(), ss);
return finite_vertices_begin();
}
return create_vertex_dim_up(ss);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_third(const Storage_site_2& ss, const Point_2& p)
{
Site_2 t = Site_2::construct_site_2(p);
return insert_third(t, ss);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_third(const Site_2& t, const Storage_site_2& ss)
{
CGAL_precondition( number_of_vertices() == 2 );
// p0 and p1 are actually points
Vertex_handle v0 = finite_vertices_begin();
Vertex_handle v1 = ++finite_vertices_begin();
Site_2 t0 = v0->site();
Site_2 t1 = v1->site();
if ( same_points(t, t0) ) {
// merge info of identical sites
merge_info(v0, ss);
return v0;
}
if ( same_points(t, t1) ) {
// merge info of identical sites
merge_info(v1, ss);
return v1;
}
Vertex_handle v = create_vertex_dim_up(ss);
Face_handle f(finite_faces_begin());
Site_2 s1 = f->vertex(0)->site();
Site_2 s2 = f->vertex(1)->site();
Site_2 s3 = f->vertex(2)->site();
Orientation o =
geom_traits().orientation_2_object()(s1, s2, s3);
if ( o != COLLINEAR ) {
if ( o == RIGHT_TURN ) {
f->reorient();
for (int i = 0; i < 3; i++) {
f->neighbor(i)->reorient();
}
}
} else {
typename Geom_traits::Compare_x_2 compare_x =
geom_traits().compare_x_2_object();
Comparison_result xcmp12 = compare_x(s1, s2);
if ( xcmp12 == SMALLER ) { // x1 < x2
Comparison_result xcmp23 = compare_x(s2, s3);
if ( xcmp23 == SMALLER ) { // x2 < x3
flip(f, f->index(v1));
} else {
Comparison_result xcmp31 = compare_x(s3, s1);
if ( xcmp31 == SMALLER ) { // x3 < x1
flip(f, f->index(v0));
} else { // x1 < x3 < x2
flip(f, f->index(v));
}
}
} else if ( xcmp12 == LARGER ) { // x1 > x2
Comparison_result xcmp32 = compare_x(s3, s2);
if ( xcmp32 == SMALLER ) { // x3 < x2
flip(f, f->index(v1));
} else {
Comparison_result xcmp13 = compare_x(s1, s3);
if ( xcmp13 == SMALLER ) { // x1 < x3
flip(f, f->index(v0));
} else { // x2 < x3 < x1
flip(f, f->index(v));
}
}
} else { // x1 == x2
typename Geom_traits::Compare_y_2 compare_y =
geom_traits().compare_y_2_object();
Comparison_result ycmp12 = compare_y(s1, s2);
if ( ycmp12 == SMALLER ) { // y1 < y2
Comparison_result ycmp23 = compare_y(s2, s3);
if ( ycmp23 == SMALLER ) { // y2 < y3
flip(f, f->index(v1));
} else {
Comparison_result ycmp31 = compare_y(s3, s1);
if ( ycmp31 == SMALLER ) { // y3 < y1
flip(f, f->index(v0));
} else { // y1 < y3 < y2
flip(f, f->index(v));
}
}
} else if ( ycmp12 == LARGER ) { // y1 > y2
Comparison_result ycmp32 = compare_y(s3, s2);
if ( ycmp32 == SMALLER ) { // y3 < y2
flip(f, f->index(v1));
} else {
Comparison_result ycmp13 = compare_y(s1, s3);
if ( ycmp13 == SMALLER ) { // y1 < y3
flip(f, f->index(v0));
} else { // y2 < y3 < y1
flip(f, f->index(v));
}
}
} else {
// this line should never have been reached
CGAL_error();
}
}
}
return v;
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_third(const Storage_site_2& ss, Vertex_handle , Vertex_handle )
{
CGAL_precondition( number_of_vertices() == 2 );
// this can only be the case if the first site is a segment
CGAL_precondition( dimension() == 1 );
Vertex_handle v = create_vertex_dim_up(ss);
Face_circulator fc = incident_faces(v);
while ( true ) {
Face_handle f(fc);
if ( !is_infinite(f) ) {
flip(f, f->index(v));
break;
}
++fc;
}
return v;
}
//--------------------------------------------------------------------
// insertion of a point
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_point(const Storage_site_2& ss, const Point_2& p, Vertex_handle vnear)
{
size_type n = number_of_vertices();
if ( n == 0 ) {
return insert_first(ss, p);
} else if ( n == 1 ) {
return insert_second(ss, p);
} else if ( n == 2 ) {
return insert_third(ss, p);
}
Site_2 t = Site_2::construct_site_2(p);
return insert_point(ss, t, vnear);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_point(const Storage_site_2& ss, const Site_2& t,
Vertex_handle vnear)
{
CGAL_precondition( t.is_point() );
CGAL_assertion( number_of_vertices() > 2 );
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
// MK::ERROR: I need to write a insert_point_no_search method that
// does not search for the nearest neighbor; this should be used by
// insert_point. Below the first version of the code is correct. The
// second is what the insert_point method should do before calling
// insert_point_no_search.
// first find the nearest neighbor
#if 1
Vertex_handle vnearest = nearest_neighbor( t, vnear );
#else
Vertex_handle vnearest;
if ( vnear == Vertex_handle() ) {
vnearest = nearest_neighbor( t, vnear );
} else {
vnearest = vnear;
}
#endif
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
// check is the point has already been inserted or lies on
// a segment already inserted
Arrangement_type at_res = arrangement_type(t, vnearest);
if ( vnearest->is_point() ) {
if ( at_res == AT2::IDENTICAL ) {
// merge info of identical sites
merge_info(vnearest, ss);
return vnearest;
}
} else {
CGAL_assertion( vnearest->is_segment() );
CGAL_assertion( at_res != AT2::TOUCH_1 );
CGAL_assertion( at_res != AT2::TOUCH_2 );
CGAL_assertion( at_res == AT2::DISJOINT || at_res == AT2::INTERIOR );
if ( at_res == AT2::INTERIOR ) {
CGAL_assertion( t.is_input() );
Vertex_triple vt = insert_exact_point_on_segment(ss, t, vnearest);
return vt.first;
} else {
// the point to be inserted does not belong to the interior of a
// segment
CGAL_assertion( at_res == AT2::DISJOINT );
}
}
return insert_point2(ss, t, vnearest);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_point2(const Storage_site_2& ss, const Site_2& t,
Vertex_handle vnearest)
{
CGAL_precondition( t.is_point() );
CGAL_assertion( number_of_vertices() > 2 );
CGAL_expensive_precondition
( nearest_neighbor(t, vnearest) == vnearest );
// find the first conflict
#if !defined(CGAL_NO_ASSERTIONS) && !defined(NDEBUG)
// verify that there are no intersections...
Vertex_circulator vc = incident_vertices(vnearest);
Vertex_circulator vc_start = vc;
do {
Vertex_handle vv(vc);
Arrangement_type at_res = arrangement_type(t, vv);
CGAL_assertion( at_res == AT2::DISJOINT );
++vc;
} while ( vc != vc_start );
#endif
// first look for conflict with vertex
Face_circulator fc_start = incident_faces(vnearest);
Face_circulator fc = fc_start;
Face_handle start_f;
Sign s;
#ifndef CGAL_SDG_NO_FACE_MAP
std::map<Face_handle,Sign> sign_map;
#endif
do {
Face_handle f(fc);
s = incircle(f, t);
#ifdef CGAL_SDG_NO_FACE_MAP
f->tds_data().set_incircle_sign(s);
#else
sign_map[f] = s;
#endif
if ( s == NEGATIVE ) {
start_f = f;
break;
}
++fc;
} while ( fc != fc_start );
// we are not in conflict with a Voronoi vertex, so we have to
// be in conflict with the interior of a Voronoi edge
if ( s != NEGATIVE ) {
Edge_circulator ec_start = incident_edges(vnearest);
Edge_circulator ec = ec_start;
bool interior_in_conflict(false);
Edge e;
do {
e = *ec;
#ifdef CGAL_SDG_NO_FACE_MAP
Sign s1 = e.first->tds_data().incircle_sign();
Sign s2 = e.first->neighbor(e.second)->tds_data().incircle_sign();
#else
Sign s1 = sign_map[e.first];
Sign s2 = sign_map[e.first->neighbor(e.second)];
#endif
if ( s1 == s2 ) {
interior_in_conflict = edge_interior(e, t, s1);
} else {
// It seems that there was a problem here when one of the
// signs was positive and the other zero. In this case we
// still check pretending that both signs where positive
interior_in_conflict = edge_interior(e, t, POSITIVE);
}
if ( interior_in_conflict ) { break; }
++ec;
} while ( ec != ec_start );
#ifndef CGAL_SDG_NO_FACE_MAP
sign_map.clear();
#endif
CGAL_assertion( interior_in_conflict );
return insert_degree_2(e, ss);
}
// we are in conflict with a Voronoi vertex; start from that and
// find the entire conflict region and then repair the diagram
List l;
#ifndef CGAL_SDG_NO_FACE_MAP
Face_map fm;
#endif
Triple<bool, Vertex_handle, Arrangement_type>
vcross(false, Vertex_handle(), AT2::DISJOINT);
// MK:: NEED TO WRITE A FUNCTION CALLED find_conflict_region WHICH
// IS GIVEN A STARTING FACE, A LIST, A FACE MAP, A VERTEX MAP AND A
// LIST OF FLIPPED EDGES AND WHAT IS DOES IS INITIALIZE THE CONFLICT
// REGION AND EXPANDS THE CONFLICT REGION.
initialize_conflict_region(start_f, l);
#ifdef CGAL_SDG_NO_FACE_MAP
expand_conflict_region(start_f, t, ss, l, vcross);
#else
expand_conflict_region(start_f, t, ss, l, fm, sign_map, vcross);
#endif
CGAL_assertion( !vcross.first );
Vertex_handle v = create_vertex(ss);
#ifdef CGAL_SDG_NO_FACE_MAP
retriangulate_conflict_region(v, l);
#else
retriangulate_conflict_region(v, l, fm);
#endif
return v;
}
//--------------------------------------------------------------------
// insertion of a point that lies on a segment
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Face_pair
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
find_faces_to_split(const Vertex_handle& v, const Site_2& t) const
{
CGAL_precondition( v->is_segment() );
#ifndef CGAL_NO_ASSERTIONS
{
// count number of adjacent infinite faces
Face_circulator fc = incident_faces(v);
Face_circulator fc_start = fc;
int n_inf = 0;
do {
if ( is_infinite(fc) ) { n_inf++; }
fc++;
} while ( fc != fc_start );
CGAL_assertion( n_inf == 0 || n_inf == 2 || n_inf == 4 );
}
#endif
Face_circulator fc1 = incident_faces(v);
Face_circulator fc2 = fc1; ++fc2;
Face_circulator fc_start = fc1;
Face_handle f1, f2;
bool found_f1 = false, found_f2 = false;
Site_2 sitev_supp = v->site().supporting_site();
do {
Face_handle ff1(fc1), ff2(fc2);
Oriented_side os1, os2;
if ( is_infinite(ff1) ) {
int id_v = ff1->index(v);
int cw_v = this->cw( id_v );
int ccw_v = this->ccw( id_v );
Site_2 sv_ep;
if ( is_infinite( ff1->vertex(cw_v) ) ) {
CGAL_assertion( !is_infinite( ff1->vertex(ccw_v) ) );
CGAL_assertion( ff1->vertex(ccw_v)->site().is_point() );
sv_ep = ff1->vertex(ccw_v)->site();
} else {
CGAL_assertion( !is_infinite( ff1->vertex( cw_v) ) );
CGAL_assertion( ff1->vertex( cw_v)->site().is_point() );
sv_ep = ff1->vertex( cw_v)->site();
}
os1 = oriented_side(sv_ep, sitev_supp, t);
} else {
os1 = oriented_side(fc1->vertex(0)->site(),
fc1->vertex(1)->site(),
fc1->vertex(2)->site(),
sitev_supp, t);
}
if ( is_infinite(ff2) ) {
int id_v = ff2->index(v);
int cw_v = this->cw( id_v );
int ccw_v = this->ccw( id_v );
Site_2 sv_ep;
if ( is_infinite( ff2->vertex(cw_v) ) ) {
CGAL_assertion( !is_infinite( ff2->vertex(ccw_v) ) );
CGAL_assertion( ff2->vertex(ccw_v)->site().is_point() );
sv_ep = ff2->vertex(ccw_v)->site();
} else {
CGAL_assertion( !is_infinite( ff2->vertex( cw_v) ) );
CGAL_assertion( ff2->vertex( cw_v)->site().is_point() );
sv_ep = ff2->vertex( cw_v)->site();
}
os2 = oriented_side(sv_ep, sitev_supp, t);
} else {
os2 = oriented_side(fc2->vertex(0)->site(),
fc2->vertex(1)->site(),
fc2->vertex(2)->site(),
sitev_supp, t);
}
if ( !found_f1 &&
os1 != ON_POSITIVE_SIDE && os2 == ON_POSITIVE_SIDE ) {
f1 = ff2;
found_f1 = true;
}
if ( !found_f2 &&
os1 == ON_POSITIVE_SIDE && os2 != ON_POSITIVE_SIDE ) {
f2 = ff2;
found_f2 = true;
}
if ( found_f1 && found_f2 ) { break; }
++fc1, ++fc2;
} while ( fc_start != fc1 );
CGAL_assertion( found_f1 && found_f2 );
CGAL_assertion( f1 != f2 );
return Face_pair(f1, f2);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_triple
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_exact_point_on_segment(const Storage_site_2& ss, const Site_2& t,
Vertex_handle v)
{
// splits the segment site v->site() in two and inserts represented by t
// on return the three vertices are, respectively, the vertex
// corresponding to t and the two subsegments of v->site()
CGAL_assertion( t.is_point() );
CGAL_assertion( t.is_input() );
Storage_site_2 ssitev = v->storage_site();
CGAL_assertion( ssitev.is_segment() );
Face_pair fpair = find_faces_to_split(v, t);
boost::tuples::tuple<Vertex_handle,Vertex_handle,Face_handle,Face_handle>
qq = this->_tds.split_vertex(v, fpair.first, fpair.second);
// now I need to update the sites for vertices v1 and v2
Vertex_handle v1 = boost::tuples::get<0>(qq); //qq.first;
Storage_site_2 ssv1 = split_storage_site(ssitev, ss, true);
v1->set_site( ssv1 );
Vertex_handle v2 = boost::tuples::get<1>(qq); //qq.second;
Storage_site_2 ssv2 = split_storage_site(ssitev, ss, false);
v2->set_site( ssv2 );
Face_handle qqf = boost::tuples::get<2>(qq); //qq.third;
Vertex_handle vsx =
this->_tds.insert_in_edge(qqf, cw(qqf->index(v1)));
vsx->set_site(ss);
// merge info of point and segment; the point lies on the segment
merge_info(vsx, ssitev);
return Vertex_triple(vsx, v1, v2);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_triple
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_point_on_segment(const Storage_site_2& ss, const Site_2& ,
Vertex_handle v, const Tag_true&)
{
// splits the segment site v->site() in two and inserts the point of
// intersection of t and v->site()
// on return the three vertices are, respectively, the point of
// intersection and the two subsegments of v->site()
Storage_site_2 ssitev = v->storage_site();
Storage_site_2 ssx = st_.construct_storage_site_2_object()(ss, ssitev);
Site_2 sitev = ssitev.site();
Face_pair fpair = find_faces_to_split(v, ssx.site());
boost::tuples::tuple<Vertex_handle,Vertex_handle,Face_handle,Face_handle>
qq = this->_tds.split_vertex(v, fpair.first, fpair.second);
// now I need to update the sites for vertices v1 and v2
Vertex_handle v1 = boost::tuples::get<0>(qq); //qq.first;
Vertex_handle v2 = boost::tuples::get<1>(qq); //qq.second;
Storage_site_2 ssv1 =
st_.construct_storage_site_2_object()(ssitev, ss, true);
Storage_site_2 ssv2 =
st_.construct_storage_site_2_object()(ssitev, ss, false);
Site_2 sv1 = ssv1.site();
Site_2 sv2 = ssv2.site();
v1->set_site( ssv1 );
v2->set_site( ssv2 );
Face_handle qqf = boost::tuples::get<2>(qq); //qq.third;
Vertex_handle vsx =
this->_tds.insert_in_edge(qqf, cw(qqf->index(v1)));
vsx->set_site(ssx);
return Vertex_triple(vsx, v1, v2);
}
//--------------------------------------------------------------------
// insertion of a segment
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnear)
{
CGAL_precondition( t.is_segment() );
CGAL_precondition( t.is_input() );
if ( is_degenerate_segment(t) ) {
Storage_site_2 ss_src = ss.source_site();
convert_info(ss_src, ss, true);
return insert_point(ss_src, t.source(), vnear);
}
Storage_site_2 ss_src = ss.source_site();
convert_info(ss_src, ss, true);
Storage_site_2 ss_trg = ss.target_site();
convert_info(ss_trg, ss, false);
Vertex_handle v0 = insert_point( ss_src, t.source(), vnear );
CGAL_assertion( is_valid() );
Vertex_handle v1 = insert_point( ss_trg, t.target(), v0 );
CGAL_assertion( is_valid() );
if ( number_of_vertices() == 2 ) {
return insert_third(ss, v0, v1);
}
return insert_segment_interior(t, ss, v0);
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_segment_interior(const Site_2& t, const Storage_site_2& ss,
Vertex_handle vnearest)
{
CGAL_precondition( t.is_segment() );
CGAL_precondition( number_of_vertices() > 2 );
CGAL_assertion( vnearest != Vertex_handle() );
// find the first conflict
// first look if there are intersections...
Vertex_circulator vc = incident_vertices(vnearest);
Vertex_circulator vc_start = vc;
do {
Vertex_handle vv(vc);
if ( is_infinite(vv) ) {
vc++;
continue;
}
Arrangement_type at_res = arrangement_type(t, vv);
if ( vv->is_segment() ) {
if ( at_res == AT2::DISJOINT || at_res == AT2::TOUCH_1 ||
at_res == AT2::TOUCH_2 || at_res == AT2::TOUCH_11 ||
at_res == AT2::TOUCH_12 || at_res == AT2::TOUCH_21 ||
at_res == AT2::TOUCH_22 ) {
// do nothing
} else if ( at_res == AT2::IDENTICAL ) {
// merge info of identical items
merge_info(vv, ss);
return vv;
} else if ( at_res == AT2::CROSSING ) {
Intersections_tag itag;
return insert_intersecting_segment(ss, t, vv, itag);
} else if ( at_res == AT2::TOUCH_11_INTERIOR_1 ) {
Vertex_handle vp = second_endpoint_of_segment(vv);
Storage_site_2 ssvp = vp->storage_site();
Storage_site_2 sss = split_storage_site(ss, ssvp, false);
Storage_site_2 sss1 = split_storage_site(ss, ssvp, true);
// merge the info of the first (common) subsegment
merge_info(vv, sss1);
// merge the info of the (common) splitting endpoint
merge_info(vp, ss);
return insert_segment_interior(sss.site(), sss, vp);
} else if ( at_res == AT2::TOUCH_12_INTERIOR_1 ) {
Vertex_handle vp = first_endpoint_of_segment(vv);
Storage_site_2 ssvp = vp->storage_site();
Storage_site_2 sss = split_storage_site(ss, ssvp, true);
/*Storage_site_2 sss1 =*/
split_storage_site(ss, ssvp, false);
// merge the info of the second (common) subsegment
// merge_info(vv, sss);
// merge the info of the (common) splitting endpoint
merge_info(vp, ss);
return insert_segment_interior(sss.site(), sss, vp);
} else {
// this should never be reached; the only possible values for
// at_res are DISJOINT, CROSSING, TOUCH_11_INTERIOR_1
// and TOUCH_12_INTERIOR_1
CGAL_error();
}
} else {
CGAL_assertion( vv->is_point() );
if ( at_res == AT2::INTERIOR ) {
Storage_site_2 ssvv = vv->storage_site();
if ( ssvv.is_input() ) {
Storage_site_2 ss1 = split_storage_site(ss, ssvv, true);
Storage_site_2 ss2 = split_storage_site(ss, ssvv, false);
// merge the info of the splitting point and the segment
merge_info(vv, ss);
insert_segment_interior(ss1.site(), ss1, vv);
return insert_segment_interior(ss2.site(), ss2, vv);
} else {
// this should never be reached; the only possible values for
// at_res are DISJOINT and INTERIOR
CGAL_error();
}
}
}
++vc;
} while ( vc != vc_start );
// first look for conflict with vertex
Face_circulator fc_start = incident_faces(vnearest);
Face_circulator fc = fc_start;
Face_handle start_f;
Sign s;
#ifndef CGAL_SDG_NO_FACE_MAP
std::map<Face_handle,Sign> sign_map;
#endif
do {
Face_handle f(fc);
s = incircle(f, t);
#ifdef CGAL_SDG_NO_FACE_MAP
f->tds_data().set_incircle_sign(s);
#else
sign_map[f] = s;
#endif
if ( s == NEGATIVE ) {
start_f = f;
break;
}
++fc;
} while ( fc != fc_start );
// segments must have a conflict with at least one vertex
CGAL_assertion( s == NEGATIVE );
// we are in conflict with a Voronoi vertex; start from that and
// find the entire conflict region and then repair the diagram
List l;
#ifndef CGAL_SDG_NO_FACE_MAP
Face_map fm;
#endif
Triple<bool, Vertex_handle, Arrangement_type>
vcross(false, Vertex_handle(), AT2::DISJOINT);
// MK:: NEED TO WRITE A FUNCTION CALLED find_conflict_region WHICH
// IS GIVEN A STARTING FACE, A LIST, A FACE MAP, A VERTEX MAP AND A
// LIST OF FLIPPED EDGES AND WHAT IS DOES IS INITIALIZE THE CONFLICT
// REGION AND EXPANDS THE CONFLICT REGION.
initialize_conflict_region(start_f, l);
#ifdef CGAL_SDG_NO_FACE_MAP
expand_conflict_region(start_f, t, ss, l, vcross);
#else
expand_conflict_region(start_f, t, ss, l, fm, sign_map, vcross);
#endif
CGAL_assertion( vcross.third == AT2::DISJOINT ||
vcross.third == AT2::CROSSING ||
vcross.third == AT2::INTERIOR );
// the following condition becomes true only if intersecting
// segments are found
if ( vcross.first ) {
if ( t.is_segment() ) {
if ( vcross.third == AT2::CROSSING ) {
Intersections_tag itag;
return insert_intersecting_segment(ss, t, vcross.second, itag);
} else if ( vcross.third == AT2::INTERIOR ) {
Storage_site_2 ssvv = vcross.second->storage_site();
Storage_site_2 ss1 = split_storage_site(ss, ssvv, true);
Storage_site_2 ss2 = split_storage_site(ss, ssvv, false);
// merge the info of the splitting point and the segment
merge_info(vcross.second, ss);
insert_segment_interior(ss1.site(), ss1, vcross.second);
return insert_segment_interior(ss2.site(), ss2, vcross.second);
} else {
// this should never be reached; the only possible values for
// vcross.third are CROSSING, INTERIOR and DISJOINT
CGAL_error();
}
}
}
// no intersecting segment has been found; we insert the segment as
// usual...
Vertex_handle v = create_vertex(ss);
#ifdef CGAL_SDG_NO_FACE_MAP
retriangulate_conflict_region(v, l);
#else
retriangulate_conflict_region(v, l, fm);
#endif
return v;
}
//--------------------------------------------------------------------
// insertion of an intersecting segment
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_intersecting_segment_with_tag(const Storage_site_2& /* ss */,
const Site_2& /* t */, Vertex_handle /* v */,
Tag_false)
{
#if defined(__POWERPC__) && \
defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
// hack to avoid nasty warning for G++ 3.4 on Darwin
static int i;
#else
static int i = 0;
#endif
if ( i == 0 ) {
i = 1;
print_error_message();
}
return Vertex_handle();
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
insert_intersecting_segment_with_tag(const Storage_site_2& ss,
const Site_2& t, Vertex_handle v,
Tag_true tag)
{
CGAL_precondition( t.is_segment() && v->is_segment() );
const Storage_site_2& ssitev = v->storage_site();
Site_2 sitev = ssitev.site();
if ( same_segments(t, sitev) ) {
merge_info(v, ss);
return v;
}
Vertex_triple vt = insert_point_on_segment(ss, t, v, tag);
Vertex_handle vsx = vt.first;
Storage_site_2 ss3 = st_.construct_storage_site_2_object()(ss, ssitev, true);
Storage_site_2 ss4 = st_.construct_storage_site_2_object()(ss, ssitev, false);
Site_2 s3 = ss3.site();
Site_2 s4 = ss4.site();
insert_segment_interior(s3, ss3, vsx);
insert_segment_interior(s4, ss4, vsx);
return vsx;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// helper methods for insertion (find conflict region)
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
initialize_conflict_region(const Face_handle& f, List& l)
{
l.clear();
for (int i = 0; i < 3; i++) {
l.push_back(sym_edge(f, i));
}
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
expand_conflict_region(const Face_handle& f, const Site_2& t,
const Storage_site_2& ss,
#ifdef CGAL_SDG_NO_FACE_MAP
List& l,
#else
List& l, Face_map& fm,
std::map<Face_handle,Sign>& sign_map,
#endif
Triple<bool,Vertex_handle,Arrangement_type>& vcross)
{
#ifdef CGAL_SDG_NO_FACE_MAP
if ( f->tds_data().is_in_conflict() ) { return; }
#else
if ( fm.find(f) != fm.end() ) { return; }
#endif
// this is done to stop the recursion when intersecting segments
// are found
if ( vcross.first ) { return; }
// setting fm[f] to true means that the face has been reached and
// that the face is available for recycling. If we do not want the
// face to be available for recycling we must set this flag to
// false.
#ifdef CGAL_SDG_NO_FACE_MAP
f->tds_data().mark_in_conflict();
fhc_.push_back(f);
#else
fm[f] = true;
#endif
// CGAL_assertion( fm.find(f) != fm.end() );
for (int i = 0; i < 3; i++) {
Face_handle n = f->neighbor(i);
#ifdef CGAL_SDG_NO_FACE_MAP
bool face_registered = n->tds_data().is_in_conflict();
#else
bool face_registered = (fm.find(n) != fm.end());
#endif
if ( !face_registered ) {
for (int j = 0; j < 3; j++) {
Vertex_handle vf = n->vertex(j);
if ( is_infinite(vf) ) { continue; }
Arrangement_type at_res = arrangement_type(t, vf);
CGAL_assertion( vcross.third == AT2::DISJOINT ||
vcross.third == AT2::CROSSING ||
vcross.third == AT2::INTERIOR );
if ( vf->is_segment() ) {
CGAL_assertion( at_res != AT2::IDENTICAL );
CGAL_assertion( at_res != AT2::TOUCH_11_INTERIOR_1 );
CGAL_assertion( at_res != AT2::TOUCH_12_INTERIOR_1 );
if ( at_res == AT2::CROSSING ) {
vcross.first = true;
vcross.second = vf;
vcross.third = AT2::CROSSING;
l.clear();
#ifdef CGAL_SDG_NO_FACE_MAP
fhc_.clear();
#else
fm.clear();
#endif
return;
} else {
CGAL_assertion ( at_res == AT2::DISJOINT ||
at_res == AT2::TOUCH_1 ||
at_res == AT2::TOUCH_2 ||
at_res == AT2::TOUCH_11 ||
at_res == AT2::TOUCH_12 ||
at_res == AT2::TOUCH_21 ||
at_res == AT2::TOUCH_22 );
// we do nothing in these cases
}
} else {
CGAL_assertion( vf->is_point() );
if ( at_res == AT2::INTERIOR ) {
vcross.first = true;
vcross.second = vf;
vcross.third = AT2::INTERIOR;
l.clear();
#ifdef CGAL_SDG_NO_FACE_MAP
fhc_.clear();
#else
fm.clear();
#endif
return;
}
}
}
}
Sign s = incircle(n, t);
#ifdef CGAL_SDG_NO_FACE_MAP
n->tds_data().set_incircle_sign(s);
Sign s_f = f->tds_data().incircle_sign();
#else
sign_map[n] = s;
Sign s_f = sign_map[f];
#endif
if ( s == POSITIVE ) { continue; }
if ( s != s_f ) { continue; }
bool interior_in_conflict = edge_interior(f, i, t, s);
if ( !interior_in_conflict ) { continue; }
if ( face_registered ) { continue; }
Edge e = sym_edge(f, i);
CGAL_assertion( l.is_in_list(e) );
int j = this->_tds.mirror_index(f, i);
Edge e_before = sym_edge(n, ccw(j));
Edge e_after = sym_edge(n, cw(j));
if ( !l.is_in_list(e_before) ) {
l.insert_before(e, e_before);
}
if ( !l.is_in_list(e_after) ) {
l.insert_after(e, e_after);
}
l.remove(e);
#ifdef CGAL_SDG_NO_FACE_MAP
expand_conflict_region(n, t, ss, l, vcross);
#else
expand_conflict_region(n, t, ss, l, fm, sign_map, vcross);
#endif
// this is done to stop the recursion when intersecting segments
// are found
// if ( fm.size() == 0 && l.size() == 0 ) { return; }
if ( vcross.first ) { return; }
} // for-loop
}
//--------------------------------------------------------------------
// retriangulate conflict region
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
add_bogus_vertex(Edge e, List& l)
{
Edge esym = sym_edge(e);
Face_handle g1 = e.first;
Face_handle g2 = esym.first;
Vertex_handle v = insert_degree_2(e);
Face_circulator fc(v);
Face_handle f1(fc);
Face_handle f2(++fc);
int i1 = f1->index(v);
int i2 = f2->index(v);
CGAL_assertion( ((f1->neighbor(i1) == g1) && (f2->neighbor(i2) == g2)) ||
((f1->neighbor(i1) == g2) && (f2->neighbor(i2) == g1)) );
Edge ee, eesym;
if ( f1->neighbor(i1) == g1 ) {
ee = Edge(f2, i2);
eesym = Edge(f1, i1);
} else {
ee = Edge(f1, i1);
eesym = Edge(f2, i2);
}
l.replace(e, ee);
l.replace(esym, eesym);
return v;
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_list
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
add_bogus_vertices(List& l)
{
#if defined(USE_INPLACE_LIST) && defined(CGAL_SDG_NO_FACE_MAP)
Vertex_list vertex_list;
Edge e_start = l.front();
Edge e = e_start;
std::list<Edge> edge_list;
do {
Edge esym = sym_edge(e);
if ( l.is_in_list(esym) ) {
if ( !esym.first->tds_data().is_selected(esym.second) ) {
e.first->tds_data().mark_selected(e.second);
edge_list.push_back(e);
}
}
e = l.next(e);
} while ( e != e_start );
e_start = l.front();
e = e_start;
do {
if ( e.first->tds_data().is_selected(e.second) ) {
e.first->tds_data().mark_unselected(e.second);
}
} while ( e != e_start );
typename std::list<Edge>::iterator it;
for (it = edge_list.begin(); it != edge_list.end(); ++it) {
Vertex_handle v = add_bogus_vertex(*it, l);
vertex_list.push_back(v);
}
return vertex_list;
#else
Vertex_list vertex_list;
std::set<Edge> edge_list;
edge_list.clear();
Edge e_start = l.front();
Edge e = e_start;
do {
Edge esym = sym_edge(e);
if ( l.is_in_list(esym) &&
edge_list.find(esym) == edge_list.end() ) {
edge_list.insert(e);
}
e = l.next(e);
} while ( e != e_start );
typename std::set<Edge>::iterator it;
for (it = edge_list.begin(); it != edge_list.end(); ++it) {
Vertex_handle v = add_bogus_vertex(*it, l);
vertex_list.push_back(v);
}
return vertex_list;
#endif
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove_bogus_vertices(Vertex_list& vl)
{
while ( vl.size() > 0 ) {
Vertex_handle v = vl.front();
vl.pop_front();
remove_degree_2(v);
}
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
#ifdef CGAL_SDG_NO_FACE_MAP
retriangulate_conflict_region(Vertex_handle v, List& l)
#else
retriangulate_conflict_region(Vertex_handle v, List& l,
Face_map& fm)
#endif
{
// 1. add the bogus vetrices
Vertex_list dummy_vertices = add_bogus_vertices(l);
// 2. repair the face pointers...
Edge e_start = l.front();
Edge eit = e_start;
do {
Edge esym = sym_edge(eit);
Face_handle f = eit.first;
int k = eit.second;
CGAL_assertion( !l.is_in_list(esym) );
#ifdef CGAL_SDG_NO_FACE_MAP
CGAL_assertion( !f->tds_data().is_in_conflict() );
#else
CGAL_assertion( fm.find(f) == fm.end() );
#endif
f->vertex(ccw(k))->set_face(f);
f->vertex( cw(k))->set_face(f);
eit = l.next(eit);
} while ( eit != e_start );
// 3. copy the edge list to a vector of edges and clear the edge list
// MK:: here I actually need to copy the edges to an std::list<Edge>, or
// even better add iterators to the list of type List
std::vector<Edge> ve(l.size());
Edge efront = l.front();
Edge e = efront;
unsigned int k = 0;
do {
ve[k] = e;
++k;
e = l.next(e);
} while ( e != efront );
l.clear();
// 4. retriangulate the hole
this->_tds.star_hole(v, ve.begin(), ve.end());
// 5. remove the bogus vertices
remove_bogus_vertices(dummy_vertices);
// 6. remove the unused faces
#ifdef CGAL_SDG_NO_FACE_MAP
typename std::vector<Face_handle>::iterator it;
for (it = fhc_.begin(); it != fhc_.end(); ++it) {
(*it)->tds_data().clear();
this->_tds.delete_face( *it );
}
fhc_.clear();
#else
typename Face_map::iterator it;
for (it = fm.begin(); it != fm.end(); ++it) {
Face_handle fh = (*it).first;
this->_tds.delete_face(fh);
}
fm.clear();
#endif
// 7. DONE!!!!
}
//====================================================================
//====================================================================
// METHODS FOR REMOVAL
//====================================================================
//====================================================================
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
is_star(const Vertex_handle& v) const
{
CGAL_precondition( v->storage_site().is_point() );
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
Storage_site_2 p = v->storage_site();
size_type count = 0;
do {
Storage_site_2 ss = vc->storage_site();
if ( ss.is_segment() && is_endpoint_of_segment(p, ss) ) {
++count;
// if ( count == 3 ) { break; }
if ( count == 3 ) { return true; }
}
++vc;
} while ( vc != vc_start );
return false;
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
is_linear_chain(const Vertex_handle& v0, const Vertex_handle& v1,
const Vertex_handle& v2) const
{
Site_2 tt[3] = { v0->site(), v1->site(), v2->site() };
if ( tt[1].is_point() &&
tt[0].is_segment() &&
tt[2].is_segment() &&
is_endpoint_of_segment(tt[1], tt[0]) &&
is_endpoint_of_segment(tt[1], tt[2]) ) {
typename Geom_traits::Equal_2 are_equal = geom_traits().equal_2_object();
Site_2 s_end[2];
if ( are_equal( tt[1], tt[0].source_site() ) ) {
s_end[0] = tt[0].target_site();
} else {
s_end[0] = tt[0].source_site();
}
if ( are_equal( tt[1], tt[2].source_site() ) ) {
s_end[1] = tt[2].target_site();
} else {
s_end[1] = tt[2].source_site();
}
typename Geom_traits::Orientation_2 orientation =
geom_traits().orientation_2_object();
return orientation(s_end[0], s_end[1], tt[1]) == COLLINEAR;
}
return false;
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
is_flippable(const Face_handle& f, int i) const
{
CGAL_assertion( !is_infinite(f->vertex( cw(i) )) );
Vertex_handle v_other = f->vertex( ccw(i) );
Vertex_handle v0 = f->vertex( i );
Vertex_handle v1 = this->_tds.mirror_vertex( f, i );
if ( is_infinite(v_other) || is_infinite(v0) || is_infinite(v1) ) {
return false;
}
Vertex_handle v = f->vertex( cw(i) );
Storage_site_2 ss = v->storage_site();
Storage_site_2 ss_other = v_other->storage_site();
if ( ss_other.is_point() && ss.is_segment() &&
is_endpoint_of_segment(ss_other, ss) && is_star(v_other) ) {
return false;
}
if ( is_linear_chain(v0, v_other, v1) ) { return false; }
return (v0 != v1) && is_degenerate_edge(f, i);
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
minimize_degree(const Vertex_handle& v)
{
CGAL_precondition ( degree(v) > 3 );
Face_circulator fc_start = incident_faces(v);
Face_circulator fc = incident_faces(v);
bool found(false);
do {
Face_handle f = Face_handle(fc);
int i = ccw( f->index(v) );
CGAL_assertion( f->vertex( cw(i) ) == v );
if ( is_flippable(f,i) ) {
Edge e = flip(f, i);
f = e.first;
if ( !f->has_vertex(v) ) {
f = e.first->neighbor(e.second);
CGAL_assertion( f->has_vertex(v) );
}
fc = --( incident_faces(v,f) );
fc_start = fc;
found = true;
} else {
++fc;
found = false;
}
} while ( found || fc != fc_start );
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
equalize_degrees(const Vertex_handle& v, Self& small_d,
std::map<Vertex_handle,Vertex_handle>& vmap,
List& l) const
{
size_type deg = degree(v);
CGAL_assertion( l.size() <= deg );
if ( l.size() == deg ) { return; }
#if 0
std::cerr << "size of l : " << l.size() << std::endl;
std::cerr << "degree of v: " << deg << std::endl;
#endif
// typedef std::map<Edge,Edge> Edge_map;
// maps edges on the boundary of the conflict region from the small
// diagram to edges of the star of v in the small diagram
// Edge_map emap;
Edge e_small_start = l.front();
Edge e_small = e_small_start;
bool found;
Edge e_small_begin;
Edge e_large_begin;
do {
found = false;
Vertex_handle v_sml_src = e_small.first->vertex(cw(e_small.second));
Vertex_handle v_sml_trg = e_small.first->vertex(ccw(e_small.second));
// first we find a first edge in common
Face_circulator fc_start = incident_faces(v);
Face_circulator fc = fc_start;
do {
int id = fc->index(v);
Vertex_handle v_lrg_src = fc->vertex(ccw(id));
Vertex_handle v_lrg_trg = fc->vertex(cw(id));
if ( vmap[v_sml_src] == v_lrg_src && vmap[v_sml_trg] == v_lrg_trg ) {
found = true;
e_large_begin = Edge(fc, id);
e_small_begin = e_small;
break;
}
} while ( ++fc != fc_start );
if ( found ) { break; }
e_small = l.next(e_small);
} while ( e_small != e_small_start );
CGAL_assertion( found );
Face_circulator fc_start = incident_faces(v, e_large_begin.first);
Face_circulator fc = fc_start;
e_small = e_small_begin;
do {
int id = fc->index(v);
Vertex_handle vsml_src = e_small.first->vertex(cw(e_small.second));
Vertex_handle vsml_trg = e_small.first->vertex(ccw(e_small.second));
Vertex_handle vlrg_src = fc->vertex(ccw(id));
Vertex_handle vlrg_trg = fc->vertex(cw(id));
if ( vmap[vsml_src] != vlrg_src || vmap[vsml_trg] != vlrg_trg ) {
Edge e_small_prev = l.previous(e_small);
std::cerr << "size of l: " << l.size() << std::endl;
l.remove(e_small);
std::cerr << "size of l: " << l.size() << std::endl;
Edge e_small_new = small_d.flip(e_small);
Edge e_small_new_sym = small_d.sym_edge(e_small_new);
Face_handle f1 = e_small_new.first;
Face_handle f2 = e_small_new_sym.first;
if ( f2->vertex(e_small_new_sym.second) == vsml_src ) {
std::swap(f1, f2);
std::swap(e_small_new, e_small_new_sym);
CGAL_assertion( f1->vertex(e_small_new.second) == vsml_src );
CGAL_assertion( f2->vertex(e_small_new_sym.second) == vsml_trg );
}
Edge to_list1(f1, cw(e_small_new.second));
Edge to_list2(f2, ccw(e_small_new_sym.second));
e_small = small_d.sym_edge(to_list1);
l.insert_after(e_small_prev, e_small);
std::cerr << "size of l: " << l.size() << std::endl;
l.insert_after(e_small, small_d.sym_edge(to_list2));
std::cerr << "size of l: " << l.size() << std::endl;
} else {
e_small = l.next(e_small);
++fc;
}
CGAL_assertion( l.size() <= deg );
} while ( fc != fc_start );
#if 0
std::cerr << "size of l : " << l.size() << std::endl;
std::cerr << "degree of v: " << deg << std::endl;
#endif
#if !defined(CGAL_NO_ASSERTIONS) && !defined(NDEBUG)
// we go around the boundary of the conflict region verify that all
// edges are there
CGAL_assertion( l.size() == degree(v) );
e_small = e_small_begin;
fc_start = incident_faces(v, e_large_begin.first);
fc = fc_start;
do {
int id = fc->index(v);
Vertex_handle vsml_src = e_small.first->vertex(cw(e_small.second));
Vertex_handle vsml_trg = e_small.first->vertex(ccw(e_small.second));
Vertex_handle vlrg_src = fc->vertex(ccw(id));
Vertex_handle vlrg_trg = fc->vertex(cw(id));
CGAL_assertion(vmap[vsml_src] == vlrg_src && vmap[vsml_trg] == vlrg_trg );
// go to next edge
e_small = l.next(e_small);
} while ( ++fc != fc_start );
#endif
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
expand_conflict_region_remove(const Face_handle& f, const Site_2& t,
const Storage_site_2& ss,
List& l, Face_map& fm, Sign_map& sign_map)
{
if ( fm.find(f) != fm.end() ) { return; }
// setting fm[f] to true means that the face has been reached and
// that the face is available for recycling. If we do not want the
// face to be available for recycling we must set this flag to
// false.
fm[f] = true;
// CGAL_assertion( fm.find(f) != fm.end() );
for (int i = 0; i < 3; i++) {
Face_handle n = f->neighbor(i);
bool face_registered = (fm.find(n) != fm.end());
Sign s = incircle(n, t);
sign_map[n] = s;
Sign s_f = sign_map[f];
if ( s == POSITIVE ) { continue; }
if ( s != s_f ) { continue; }
bool interior_in_conflict = edge_interior(f, i, t, s);
if ( !interior_in_conflict ) { continue; }
if ( face_registered ) { continue; }
Edge e = sym_edge(f, i);
CGAL_assertion( l.is_in_list(e) );
int j = this->_tds.mirror_index(f, i);
Edge e_before = sym_edge(n, ccw(j));
Edge e_after = sym_edge(n, cw(j));
if ( !l.is_in_list(e_before) ) {
l.insert_before(e, e_before);
}
if ( !l.is_in_list(e_after) ) {
l.insert_after(e, e_after);
}
l.remove(e);
expand_conflict_region_remove(n, t, ss, l, fm, sign_map);
} // for-loop
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
find_conflict_region_remove(const Vertex_handle& v,
const Vertex_handle& vnearest,
List& l, Face_map& fm, Sign_map&)
{
CGAL_precondition( vnearest != Vertex_handle() );
Storage_site_2 ss = v->storage_site();
Site_2 t = ss.site();
// find the first conflict
// first look for conflict with vertex
Face_circulator fc_start = incident_faces(vnearest);
Face_circulator fc = fc_start;
Face_handle start_f;
Sign s;
Sign_map sign_map;
do {
Face_handle f(fc);
s = incircle(f, t);
sign_map[f] = s;
if ( s == NEGATIVE ) {
start_f = f;
break;
}
++fc;
} while ( fc != fc_start );
CGAL_assertion( s == NEGATIVE );
// we are not in conflict with a Voronoi vertex, so we have to
// be in conflict with the interior of a Voronoi edge
if ( s != NEGATIVE ) {
Edge_circulator ec_start = incident_edges(vnearest);
Edge_circulator ec = ec_start;
bool interior_in_conflict(false);
Edge e;
do {
e = *ec;
Sign s1 = sign_map[e.first];
Sign s2 = sign_map[e.first->neighbor(e.second)];
if ( s1 == s2 ) {
interior_in_conflict = edge_interior(e, t, s1);
} else {
// It seems that there was a problem here when one of the
// signs was positive and the other zero. In this case we
// still check pretending that both signs where positive
interior_in_conflict = edge_interior(e, t, POSITIVE);
}
if ( interior_in_conflict ) { break; }
++ec;
} while ( ec != ec_start );
sign_map.clear();
CGAL_assertion( interior_in_conflict );
l.push_back(e);
l.push_back(sym_edge(e));
return;
}
initialize_conflict_region(start_f, l);
expand_conflict_region_remove(start_f, t, ss, l, fm, sign_map);
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::size_type
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
count_faces(const List& l) const
{
std::vector<Face_handle> flist;
get_faces(l, std::back_inserter(flist));
return flist.size();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
fill_hole(const Self& small_d, const Vertex_handle& v, const List& l,
std::map<Vertex_handle,Vertex_handle>& vmap)
{
#if 0
std::cerr << "size of l : " << l.size() << std::endl;
std::cerr << "degree of v: " << degree(v) << std::endl;
#endif
typedef std::map<Edge,Edge> Edge_map;
// maps edges on the boundary of the conflict region from the small
// diagram to edges of the star of v in the small diagram
Edge_map emap;
Edge e_sml_sym = sym_edge(l.front());
Vertex_handle v_sml_src = e_sml_sym.first->vertex(ccw(e_sml_sym.second));
Vertex_handle v_sml_trg = e_sml_sym.first->vertex(cw(e_sml_sym.second));
// first we find a first edge in common
Face_circulator fc_start = incident_faces(v);
Face_circulator fc = fc_start;
Face_circulator fc_begin;
bool found = false;
do {
int id = fc->index(v);
Vertex_handle v_lrg_src = fc->vertex(ccw(id));
Vertex_handle v_lrg_trg = fc->vertex(cw(id));
if ( vmap[v_sml_src] == v_lrg_src && vmap[v_sml_trg] == v_lrg_trg ) {
found = true;
fc_begin = fc;
break;
}
} while ( ++fc != fc_start );
CGAL_assertion( found );
// container of faces to delete
std::list<Face_handle> to_delete;
// next we go around the boundary of the conflict region and map all edges
Edge e_small = l.front();
fc_start = incident_faces(v, fc_begin);
fc = fc_start;
do {
int id = fc->index(v);
#if !defined(CGAL_NO_ASSERTIONS) && !defined(NDEBUG)
Vertex_handle vsml_src = e_small.first->vertex(cw(e_small.second));
Vertex_handle vsml_trg = e_small.first->vertex(ccw(e_small.second));
Vertex_handle vlrg_src = fc->vertex(ccw(id));
Vertex_handle vlrg_trg = fc->vertex(cw(id));
CGAL_assertion(vmap[vsml_src] == vlrg_src && vmap[vsml_trg] == vlrg_trg );
#endif
// set mapping
emap[e_small] = sym_edge(fc, id);
// keep face for deletion
to_delete.push_back(fc);
// go to next edge
e_small = l.next(e_small);
} while ( ++fc != fc_start );
// map the faces of the small diagram with the new faces of the
// large diagram
std::map<Face_handle,Face_handle> fmap;
std::vector<Face_handle> f_small, f_large;
small_d.get_faces(l, std::back_inserter(f_small));
for (unsigned int i = 0; i < f_small.size(); i++) {
Face_handle f = this->_tds.create_face();
fmap[ f_small[i] ] = f;
f_large.push_back(f);
}
CGAL_assertion( l.size() == degree(v) );
CGAL_assertion( f_small.size() == f_large.size() );
CGAL_assertion( f_small.size() == l.size() - 2 );
CGAL_assertion( f_small.size() == count_faces(l) );
// set the vertices for the new faces; also set the face for each
// vertex
for (typename std::vector<Face_handle>::iterator fit = f_small.begin();
fit != f_small.end(); ++fit) {
Face_handle ff_small = *fit;
Face_handle f = fmap[ff_small];
for (int i = 0; i < 3; ++i) {
CGAL_assertion( vmap.find(ff_small->vertex(i)) != vmap.end() );
f->set_vertex(i, vmap[ff_small->vertex(i)]);
// we are setting the face for each vertex a lot of times; we
// could possibly do it faster if we use the edges on the
// boundary of the conflict region
// in fact we may not even need it since the make_hole method
// updates the faces of the vertices of the boundary of the
// hole, and we do not introduce any new vertices
f->vertex(i)->set_face(f);
}
}
// set the neighbors for each face
for (typename std::vector<Face_handle>::iterator fit = f_small.begin();
fit != f_small.end(); ++fit) {
Face_handle ff_small = *fit;
for (int i = 0; i < 3; i++) {
Face_handle f = fmap[ff_small];
Face_handle n_small = ff_small->neighbor(i);
if ( fmap.find(n_small) != fmap.end() ) {
// this is one of the new faces
f->set_neighbor(i, fmap[n_small]);
} else {
// otherwise it is one of the old faces outside the conflict
// region; we have to use the edge map in this case
Edge e_small_sym = small_d.sym_edge(ff_small, i);
CGAL_assertion(emap.find(e_small_sym) != emap.end());
Edge e_large = emap[e_small_sym];
f->set_neighbor(i, e_large.first);
e_large.first->set_neighbor(e_large.second, f);
}
}
}
// delete the unused faces and the vertex
while ( !to_delete.empty() ) {
delete_face(to_delete.front());
to_delete.pop_front();
}
delete_vertex(v);
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove_first(const Vertex_handle& v)
{
Delaunay_graph::remove_first(v);
return true;
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove_second(const Vertex_handle& v)
{
Delaunay_graph::remove_second(v);
return true;
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove_third(const Vertex_handle& v)
{
if ( is_degree_2(v) ) {
CGAL_assertion( v->storage_site().is_point() );
Face_handle fh( incident_faces(v) );
int i = fh->index(v);
flip(fh, i);
} else if ( degree(v) == 4 ) {
Edge_circulator ec = incident_edges(v);
for (int i = 0; i < 4; i++) {
Edge e = *ec;
Edge sym = sym_edge(e);
if ( e.first->vertex(e.second) != sym.first->vertex(sym.second) ) {
flip(e);
break;
}
++ec;
}
}
this->_tds.remove_dim_down( v );
return true;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
compute_small_diagram(const Vertex_handle& v, Self& small_d) const
{
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
// insert all neighboring sites
do {
if ( !is_infinite(vc) ) {
Site_2 t = vc->site();
if ( t.is_input() ) {
small_d.insert(t);
} else if ( t.is_point() ) {
small_d.insert(t.supporting_site(0));
/*Vertex_handle vnear =*/ small_d.insert(t.supporting_site(1));
// vh_small = sdg_small.nearest_neighbor(t, vnear);
} else {
CGAL_assertion( t.is_segment() );
/*Vertex_handle vnear =*/ small_d.insert(t.supporting_site());
// vh_small = sdg_small.nearest_neighbor(t, vnear);
}
// CGAL_assertion( vh_small != Vertex_handle() );
// vmap[vh_small] = vh_large;
}
++vc;
} while ( vc != vc_start );
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
compute_vertex_map(const Vertex_handle& v, const Self& small_d,
std::map<Vertex_handle,Vertex_handle>& vmap) const
{
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
Vertex_handle vh_large, vh_small;
do {
vh_large = Vertex_handle(vc);
if ( is_infinite(vh_large) ) {
vh_small = small_d.infinite_vertex();
vmap[vh_small] = vh_large;
} else {
#if !defined(CGAL_NO_ASSERTIONS) && !defined(NDEBUG)
vh_small = Vertex_handle();
#endif
Site_2 t = vc->site();
if ( t.is_input() ) {
if ( t.is_segment() ) {
Vertex_handle vv = small_d.nearest_neighbor( t.source() );
Vertex_circulator vvc_start = small_d.incident_vertices(vv);
Vertex_circulator vvc = vvc_start;
do {
if ( small_d.same_segments(t, vvc) ) {
vh_small = vvc;
break;
}
} while ( ++vvc != vvc_start );
CGAL_assertion( small_d.same_segments(t, vh_small) );
} else {
CGAL_assertion( t.is_point() );
vh_small = small_d.nearest_neighbor( t.point() );
CGAL_assertion( small_d.same_points(t, vh_small->site()) );
}
} else if ( t.is_segment() ) {
Vertex_handle vv =
small_d.nearest_neighbor( t.source_site(), Vertex_handle() );
Vertex_circulator vvc_start = small_d.incident_vertices(vv);
Vertex_circulator vvc = vvc_start;
do {
if ( small_d.same_segments(t, vvc) ) {
vh_small = vvc;
break;
}
} while ( ++vvc != vvc_start );
CGAL_assertion( small_d.same_segments(t, vh_small) );
} else {
CGAL_assertion( t.is_point() );
vh_small = small_d.nearest_neighbor( t, Vertex_handle() );
CGAL_assertion( small_d.same_points(t, vh_small->site()) );
}
CGAL_assertion( vh_small != Vertex_handle() );
vmap[vh_small] = vh_large;
}
++vc;
} while ( vc != vc_start );
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove_degree_d_vertex(const Vertex_handle& v)
{
#if 0
Self sdg_small;
compute_small_diagram(v, sdg_small);
std::map<Vertex_handle,Vertex_handle> vmap;
compute_vertex_map(v, sdg_small, vmap);
// find nearest neighbor of v in small diagram
Site_2 t = v->site();
Vertex_handle vn;
CGAL_assertion( t.is_input() );
if ( t.is_point() ) {
vn = sdg_small.nearest_neighbor( t.point() );
} else {
vn = sdg_small.nearest_neighbor( t.source() );
}
CGAL_assertion( vn != Vertex_handle() );
List l;
Face_map fm;
Sign_map sign_map;
sdg_small.find_conflict_region_remove(v, vn, l, fm, sign_map);
fm.clear();
sign_map.clear();
equalize_degrees(v, sdg_small, vmap, l);
fill_hole(sdg_small, v, l, vmap);
l.clear();
return;
#else
minimize_degree(v);
size_type deg = degree(v);
if ( deg == 3 ) {
remove_degree_3(v);
return;
}
if ( deg == 2 ) {
remove_degree_2(v);
return;
}
Self sdg_small;
compute_small_diagram(v, sdg_small);
if ( sdg_small.number_of_vertices() <= 2 ) {
CGAL_assertion( sdg_small.number_of_vertices() == 2 );
CGAL_assertion( deg == 4 );
Edge_circulator ec_start = incident_edges(v);
Edge_circulator ec = ec_start;
do {
if ( is_infinite(*ec) ) { break; }
++ec;
} while ( ec != ec_start );
CGAL_assertion( is_infinite(ec) );
flip(*ec);
remove_degree_3(v);
return;
}
std::map<Vertex_handle,Vertex_handle> vmap;
compute_vertex_map(v, sdg_small, vmap);
// find nearest neighbor of v in small diagram
Site_2 t = v->site();
Vertex_handle vn;
CGAL_assertion( t.is_input() );
// here we find a site in the small diagram that serves as a
// starting point for finding all conflicts.
// To do that we find the nearest neighbor of t if t is a point;
// t is guarranteed to have a conflict with its nearest neighbor
// If t is a segment, then one endpoint of t is enough; t is
// guarranteed to have a conflict with the Voronoi edges around
// this endpoint
if ( t.is_point() ) {
vn = sdg_small.nearest_neighbor( t.point() );
} else {
vn = sdg_small.nearest_neighbor( t.source() );
}
CGAL_assertion( vn != Vertex_handle() );
List l;
Face_map fm;
Sign_map sign_map;
sdg_small.find_conflict_region_remove(v, vn, l, fm, sign_map);
fill_hole(sdg_small, v, l, vmap);
l.clear();
fm.clear();
sign_map.clear();
#endif
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove_base(const Vertex_handle& v)
{
Storage_site_2 ssv = v->storage_site();
CGAL_precondition( ssv.is_input() );
// first consider the case where we have up to 2 points
size_type n = number_of_vertices();
if ( n == 1 ) {
return remove_first(v);
} else if ( n == 2 ) {
return remove_second(v);
}
// secondly check if the point to be deleted is adjacent to a segment
if ( ssv.is_point() ) {
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
do {
Storage_site_2 ss = vc->storage_site();
if ( ss.is_segment() && is_endpoint_of_segment(ssv, ss) ) {
return false;
}
++vc;
} while ( vc != vc_start );
}
// now do the deletion
if ( n == 3 ) {
return remove_third(v);
}
size_type deg = degree(v);
if ( deg == 2 ) {
remove_degree_2(v);
} else if ( deg == 3 ) {
remove_degree_3(v);
} else {
remove_degree_d_vertex(v);
}
return true;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
remove(const Vertex_handle& v)
{
CGAL_precondition( !is_infinite(v) );
const Storage_site_2& ss = v->storage_site();
if ( !ss.is_input() ) { return false; }
Point_handle h1, h2;
bool is_point = ss.is_point();
if ( is_point ) {
h1 = ss.point();
} else {
CGAL_assertion( ss.is_segment() );
h1 = ss.source_of_supporting_site();
h2 = ss.target_of_supporting_site();
}
bool success = remove_base(v);
if ( success ) {
// unregister the input site
if ( is_point ) {
unregister_input_site( h1 );
} else {
unregister_input_site( h1, h2 );
}
}
return success;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// combinatorial operations
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// point location
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
nearest_neighbor(const Site_2& p,
Vertex_handle start_vertex) const
{
CGAL_precondition( p.is_point() );
if ( number_of_vertices() == 0 ) {
return Vertex_handle();
}
if ( start_vertex == Vertex_handle() ) {
start_vertex = finite_vertex();
}
// if ( start_vertex == NULL ) { return start_vertex; }
Vertex_handle vclosest;
Vertex_handle v = start_vertex;
if ( number_of_vertices() < 3 ) {
vclosest = v;
Finite_vertices_iterator vit = finite_vertices_begin();
for (; vit != finite_vertices_end(); ++vit) {
Vertex_handle v1(vit);
if ( v1 != vclosest /*&& !is_infinite(v1)*/ ) {
Site_2 t0 = vclosest->site();
Site_2 t1 = v1->site();
if ( side_of_bisector(t0, t1, p) == ON_NEGATIVE_SIDE ) {
vclosest = v1;
}
}
}
return vclosest;
}
do {
vclosest = v;
Site_2 t0 = v->site();
// if ( t0.is_point() && same_points(p, t0) ) {
// return vclosest;
// }
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
do {
if ( !is_infinite(vc) ) {
Vertex_handle v1(vc);
Site_2 t1 = v1->site();
Oriented_side os = side_of_bisector(t0, t1, p);
if ( os == ON_NEGATIVE_SIDE ) {
v = v1;
break;
}
}
++vc;
} while ( vc != vc_start );
} while ( vclosest != v );
return vclosest;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// methods for the predicates
//----------------------------------------------------------------------
//----------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
Sign
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
incircle(const Face_handle& f, const Site_2& q) const
{
if ( !is_infinite(f) ) {
return incircle(f->vertex(0)->site(),
f->vertex(1)->site(),
f->vertex(2)->site(), q);
}
int inf_i(-1); // to avoid compiler warning
for (int i = 0; i < 3; i++) {
if ( is_infinite(f->vertex(i)) ) {
inf_i = i;
break;
}
}
return incircle( f->vertex( ccw(inf_i) )->site(),
f->vertex( cw(inf_i) )->site(), q );
}
template<class Gt, class ST, class D_S, class LTag>
Sign
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
incircle(const Vertex_handle& v0, const Vertex_handle& v1,
const Vertex_handle& v2, const Vertex_handle& v) const
{
CGAL_precondition( !is_infinite(v) );
if ( !is_infinite(v0) && !is_infinite(v1) &&
!is_infinite(v2) ) {
return incircle(v0->site(), v1->site(),
v2->site(), v->site());
}
if ( is_infinite(v0) ) {
CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) );
return incircle( v1->site(), v2->site(), v->site());
}
if ( is_infinite(v1) ) {
CGAL_precondition( !is_infinite(v0) && !is_infinite(v2) );
return incircle( v2->site(), v0->site(), v->site());
}
CGAL_assertion( is_infinite(v2) );
CGAL_precondition( !is_infinite(v0) && !is_infinite(v1) );
return incircle( v0->site(), v1->site(), v->site());
}
// this the finite edge interior predicate for a degenerate edge
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
finite_edge_interior(const Face_handle& f, int i, const Site_2& q,
Sign sgn, int) const
{
if ( !is_infinite( this->_tds.mirror_vertex(f, i) ) ) {
CGAL_precondition( is_infinite(f->vertex(i)) );
Face_handle g = f->neighbor(i);
int j = this->_tds.mirror_index(f, i);
return finite_edge_interior(g, j, q, sgn, 0 /* degenerate */);
}
CGAL_precondition( is_infinite( this->_tds.mirror_vertex(f, i) ) );
Site_2 t1 = f->vertex( ccw(i) )->site();
Site_2 t2 = f->vertex( cw(i) )->site();
if ( is_infinite(f->vertex(i)) ) {
return finite_edge_interior(t1, t2, q, sgn);
}
Site_2 t3 = f->vertex(i)->site();
return finite_edge_interior(t1, t2, t3, q, sgn);
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
finite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2,
const Vertex_handle& v3, const Vertex_handle& v4,
const Vertex_handle& v, Sign sgn, int) const
{
CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) &&
!is_infinite(v) );
if ( !is_infinite( v4 ) ) {
CGAL_precondition( is_infinite(v3) );
return
finite_edge_interior(v2, v1, v4, v3, v, sgn, 0 /* degenerate */);
}
CGAL_precondition( is_infinite( v4 ) );
Site_2 t1 = v1->site();
Site_2 t2 = v2->site();
Site_2 q = v->site();
if ( is_infinite(v3) ) {
return finite_edge_interior(t1, t2, q, sgn);
}
Site_2 t3 = v3->site();
return finite_edge_interior(t1, t2, t3, q, sgn);
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
infinite_edge_interior(const Face_handle& f, int i,
const Site_2& q, Sign sgn) const
{
if ( !is_infinite( f->vertex(ccw(i)) ) ) {
CGAL_precondition( is_infinite( f->vertex(cw(i)) ) );
Face_handle g = f->neighbor(i);
int j = this->_tds.mirror_index(f, i);
return infinite_edge_interior(g, j, q, sgn);
}
CGAL_precondition( is_infinite( f->vertex(ccw(i)) ) );
Site_2 t2 = f->vertex( cw(i) )->site();
Site_2 t3 = f->vertex( i )->site();
Site_2 t4 = this->_tds.mirror_vertex(f, i)->site();
return infinite_edge_interior(t2, t3, t4, q, sgn);
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
infinite_edge_interior(const Vertex_handle& v1,
const Vertex_handle& v2,
const Vertex_handle& v3,
const Vertex_handle& v4,
const Vertex_handle& v, Sign sgn) const
{
CGAL_precondition( !is_infinite(v3) && !is_infinite(v4) &&
!is_infinite(v) );
if ( !is_infinite( v1 ) ) {
CGAL_precondition( is_infinite( v2 ) );
return infinite_edge_interior(v2, v1, v4, v3, v, sgn);
}
CGAL_precondition( is_infinite( v1 ) );
Site_2 t2 = v2->site();
Site_2 t3 = v3->site();
Site_2 t4 = v4->site();
Site_2 q = v->site();
return infinite_edge_interior(t2, t3, t4, q, sgn);
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
edge_interior(const Vertex_handle& v1,
const Vertex_handle& v2,
const Vertex_handle& v3,
const Vertex_handle& v4,
const Vertex_handle& v, Sign sgn) const
{
CGAL_precondition( !is_infinite(v) );
bool is_inf_v1 = is_infinite(v1);
bool is_inf_v2 = is_infinite(v2);
bool is_inf_v3 = is_infinite(v3);
bool is_inf_v4 = is_infinite(v4);
bool result;
if ( !is_inf_v1 && !is_inf_v2 && !is_inf_v3 && !is_inf_v4 ) {
result = finite_edge_interior(v1, v2, v3, v4, v, sgn);
} else if ( is_inf_v3 || is_inf_v4 ) {
result = finite_edge_interior(v1, v2, v3, v4, v, sgn, 0/* degenerate */);
} else {
result = infinite_edge_interior(v1, v2, v3, v4, v, sgn);
}
return result;
}
template<class Gt, class ST, class D_S, class LTag>
bool
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
edge_interior(const Face_handle& f, int i,
const Site_2& q, Sign sgn) const
{
Face_handle g = f->neighbor(i);
bool is_inf_f = is_infinite(f);
bool is_inf_g = is_infinite(g);
bool result;
if ( !is_inf_f && !is_inf_g ) {
result = finite_edge_interior(f, i, q, sgn);
} else if ( !is_inf_f || !is_inf_g ) {
result = finite_edge_interior(f, i, q, sgn, 0 /* denegerate */);
} else {
if ( !is_infinite(f, i) ) {
result = finite_edge_interior(f, i, q, sgn, 0 /* degenerate */);
} else {
result = infinite_edge_interior(f, i, q, sgn);
}
}
return result;
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Arrangement_type
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
arrangement_type(const Site_2& p, const Site_2& q) const
{
typedef typename Geom_traits::Arrangement_type_2 AT2;
typedef typename AT2::result_type Arrangement_type;
Arrangement_type res = geom_traits().arrangement_type_2_object()(p, q);
// The valeus that have to be treated are the following:
// DISJOINT, TOUCH_1, TOUCH_2, CROSSING, IDENTICAL, INTERIOR,
// TOUCH_11_INTERIOR_1, TOUCH_12_INTERIOR_1, TOUCH_21_INTERIOR_1 and
// TOUCH_22_INTERIOR_1.
//
// The remaining values will either never appear because of one of
// the following reasons:
// 1. we insert the endpoints of the segments first and then the
// interior (OVERLAPPING_*, INTERIOR_*, TOUCH_*_INTERIOR_2).
// 2. the values have no meaning since we consider the segments to
// be open (TOUCH_INTERIOR_*). In this case, the conflict will
// appear when we test with the endpoint.
// 3. a conflict will first happen with an endpoint before testing
// for the segment (TOUCH_2*_INTERIOR_1). In this case the
// segment to be inserted will first find an endpoint in its
// interior before actually finding that there is another segment
// it overlaps with.
CGAL_assertion( res != AT2::INTERIOR_1 );
CGAL_assertion( res != AT2::INTERIOR_2 );
CGAL_assertion( res != AT2::OVERLAPPING_11 );
CGAL_assertion( res != AT2::OVERLAPPING_12 );
CGAL_assertion( res != AT2::OVERLAPPING_21 );
CGAL_assertion( res != AT2::OVERLAPPING_22 );
CGAL_assertion( res != AT2::TOUCH_11_INTERIOR_2 );
CGAL_assertion( res != AT2::TOUCH_21_INTERIOR_2 );
CGAL_assertion( res != AT2::TOUCH_12_INTERIOR_2 );
CGAL_assertion( res != AT2::TOUCH_22_INTERIOR_2 );
CGAL_assertion( res != AT2::TOUCH_21_INTERIOR_1 );
CGAL_assertion( res != AT2::TOUCH_22_INTERIOR_1 );
if ( res == AT2::TOUCH_INTERIOR_12 || res == AT2::TOUCH_INTERIOR_21 ||
res == AT2::TOUCH_INTERIOR_11 || res == AT2::TOUCH_INTERIOR_22 ) {
return AT2::DISJOINT;
}
if ( res == AT2::TOUCH_11 || res == AT2::TOUCH_12 ||
res == AT2::TOUCH_21 || res == AT2::TOUCH_22 ) {
return AT2::DISJOINT;
}
return res;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// embedding and visualization methods and constructions for primal
// and dual
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// primal
template<class Gt, class ST, class D_S, class LTag>
Object
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
primal(const Edge e) const
{
typedef typename Gt::Line_2 Line_2;
typedef typename Gt::Ray_2 Ray_2;
CGAL_precondition( !is_infinite(e) );
if ( this->dimension() == 1 ) {
Site_2 p = (e.first)->vertex(cw(e.second))->site();
Site_2 q = (e.first)->vertex(ccw(e.second))->site();
Line_2 l = construct_sdg_bisector_2_object()(p,q);
return make_object(l);
}
// dimension == 2
// none of the two adjacent faces is infinite
if( (!is_infinite(e.first)) &&
(!is_infinite(e.first->neighbor(e.second))) ) {
Site_2 p = (e.first)->vertex( ccw(e.second) )->site();
Site_2 q = (e.first)->vertex( cw(e.second) )->site();
Site_2 r = (e.first)->vertex( e.second )->site();
Site_2 s = this->_tds.mirror_vertex(e.first, e.second)->site();
return construct_sdg_bisector_segment_2_object()(p,q,r,s);
}
// both of the adjacent faces are infinite
if ( is_infinite(e.first) &&
is_infinite(e.first->neighbor(e.second)) ) {
Site_2 p = (e.first)->vertex(cw(e.second))->site();
Site_2 q = (e.first)->vertex(ccw(e.second))->site();
Line_2 l = construct_sdg_bisector_2_object()(p,q);
return make_object(l);
}
// only one of the adjacent faces is infinite
CGAL_assertion( is_infinite( e.first ) ||
is_infinite( e.first->neighbor(e.second) )
);
CGAL_assertion( !(is_infinite( e.first ) &&
is_infinite( e.first->neighbor(e.second) )
)
);
CGAL_assertion( is_infinite(e.first->vertex(e.second)) ||
is_infinite(this->_tds.mirror_vertex(e.first, e.second)) );
Edge ee = e;
if ( is_infinite( e.first->vertex(e.second) ) ) {
ee = sym_edge(e);
}
Site_2 p = ee.first->vertex( ccw(ee.second) )->site();
Site_2 q = ee.first->vertex( cw(ee.second) )->site();
Site_2 r = ee.first->vertex( ee.second )->site();
Ray_2 ray = construct_sdg_bisector_ray_2_object()(p,q,r);
return make_object(ray);
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// validity test method
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
bool Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
is_valid(bool verbose, int level) const
{
if (level < 0) { return true; }
if (number_of_vertices() <= 1) {
if ( verbose && number_of_vertices() == 1 ) {
std::cerr << "SDGDS is ok... " << std::flush;
}
return true;
}
// level 0 test: check the TDS
bool result = data_structure().is_valid(verbose, level);
if ( result && verbose ) {
std::cerr << "SDGDS is ok... " << std::flush;
}
if (level == 0) { return result; }
// level 1 test: do the incircle tests
if (number_of_vertices() < 3) { return true; }
for (All_edges_iterator eit = all_edges_begin();
eit != all_edges_end(); ++eit) {
Edge e = *eit;
Face_handle f = e.first;
Vertex_handle v = this->_tds.mirror_vertex(f, e.second);
if ( f->vertex(e.second) == v ) { continue; }
if ( !is_infinite(v) ) {
result = result &&
( incircle(f, v->site()) != NEGATIVE );
}
Edge sym_e = sym_edge(e);
f = sym_e.first;
v = this->_tds.mirror_vertex(f, sym_e.second);
if ( !is_infinite(v) ) {
result = result &&
( incircle(f, v->site()) != NEGATIVE );
}
}
if ( result && verbose ) {
std::cerr << "Segment Delaunay graph is ok..." << std::flush;
}
if ( !result && verbose ) {
std::cerr << "Segment Delaunay graph is NOT valid..." << std::flush;
}
return result;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// misc
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
print_error_message() const
{
std::cerr << std::endl;
std::cerr << "WARNING:" << std::endl;
std::cerr << "A segment-segment intersection was found."
<< std::endl;
std::cerr << "The Segment_Delaunay_graph_2 class is not configured"
<< " to handle this situation." << std::endl;
std::cerr << "Please look at the documentation on how to handle"
<< " this behavior." << std::endl;
std::cerr << std::endl;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// the copy method
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Storage_site_2
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
copy_storage_site(const Storage_site_2& ss_other, Handle_map& hm,
const Tag_false&)
{
if ( ss_other.is_segment() ) {
Point_handle p0 = hm[ ss_other.source_of_supporting_site() ];
Point_handle p1 = hm[ ss_other.target_of_supporting_site() ];
return st_.construct_storage_site_2_object()(p0, p1);
} else {
Point_handle p0 = hm[ ss_other.point() ];
return st_.construct_storage_site_2_object()(p0);
}
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Storage_site_2
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
copy_storage_site(const Storage_site_2& ss_other, Handle_map& hm,
const Tag_true&)
{
if ( ss_other.is_segment() ) {
if ( ss_other.is_input() ) {
Point_handle p0 = hm[ ss_other.source_of_supporting_site() ];
Point_handle p1 = hm[ ss_other.target_of_supporting_site() ];
return st_.construct_storage_site_2_object()(p0, p1);
} else if ( ss_other.is_input(0) ) {
Point_handle p0 = hm[ ss_other.source_of_supporting_site() ];
Point_handle p1 = hm[ ss_other.target_of_supporting_site() ];
Point_handle p4 = hm[ ss_other.source_of_crossing_site(1) ];
Point_handle p5 = hm[ ss_other.target_of_crossing_site(1) ];
return st_.construct_storage_site_2_object()(p0, p1, p4, p5, true);
} else if ( ss_other.is_input(1) ) {
Point_handle p0 = hm[ ss_other.source_of_supporting_site() ];
Point_handle p1 = hm[ ss_other.target_of_supporting_site() ];
Point_handle p2 = hm[ ss_other.source_of_crossing_site(0) ];
Point_handle p3 = hm[ ss_other.target_of_crossing_site(0) ];
return st_.construct_storage_site_2_object()(p0, p1, p2, p3, false);
} else {
Point_handle p0 = hm[ ss_other.source_of_supporting_site() ];
Point_handle p1 = hm[ ss_other.target_of_supporting_site() ];
Point_handle p2 = hm[ ss_other.source_of_crossing_site(0) ];
Point_handle p3 = hm[ ss_other.target_of_crossing_site(0) ];
Point_handle p4 = hm[ ss_other.source_of_crossing_site(1) ];
Point_handle p5 = hm[ ss_other.target_of_crossing_site(1) ];
return st_.construct_storage_site_2_object()(p0, p1, p2, p3, p4, p5);
}
} else {
if ( ss_other.is_input() ) {
Point_handle p0 = hm[ ss_other.point() ];
return st_.construct_storage_site_2_object()(p0);
} else {
Point_handle p2 = hm[ ss_other.source_of_supporting_site(0) ];
Point_handle p3 = hm[ ss_other.target_of_supporting_site(0) ];
Point_handle p4 = hm[ ss_other.source_of_supporting_site(1) ];
Point_handle p5 = hm[ ss_other.target_of_supporting_site(1) ];
return st_.construct_storage_site_2_object()(p2, p3, p4, p5);
}
}
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
copy(Segment_Delaunay_graph_2& other)
{
// first copy the point container
pc_ = other.pc_;
// copy storage traits
st_ = other.st_;
// first create a map between the old point handles and the new ones
Handle_map hm;
Point_handle it_other = other.pc_.begin();
Point_handle it_this = pc_.begin();
for (; it_other != other.pc_.end(); ++it_other, ++it_this) {
hm.insert( Point_handle_pair(it_other, it_this) );
}
copy(other, hm);
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
copy(Segment_Delaunay_graph_2& other, Handle_map& hm)
{
// second, copy the site representation info for the input sites
// using the correct handles (i.e., the handles from the new point
// container
isc_.clear();
typename Input_sites_container::iterator iit_other = other.isc_.begin();
for (; iit_other != other.isc_.end(); ++iit_other) {
Site_rep_2 old_srep = *iit_other;
Site_rep_2 new_srep( hm[boost::tuples::get<0>(old_srep)],
hm[boost::tuples::get<1>(old_srep)],
boost::tuples::get<2>(old_srep) );
isc_.insert( new_srep );
}
CGAL_assertion( pc_.size() == other.pc_.size() );
CGAL_assertion( isc_.size() == other.isc_.size() );
#ifndef CGAL_NO_ASSERTIONS
{
Point_handle it_other = other.pc_.begin();
Point_handle it_this = pc_.begin();
for (; it_other != other.pc_.end(); ++it_other, ++it_this) {
CGAL_assertion( *it_other == *it_this );
}
}
#endif
// then copy the diagram
DG::operator=(other);
// now we have to update the sotrage sites in each vertex of the
// diagram and also update the
// then update the storage sites for each vertex
Intersections_tag itag;
Finite_vertices_iterator vit_other = other.finite_vertices_begin();
Finite_vertices_iterator vit_this = finite_vertices_begin();
for (; vit_other != other.finite_vertices_end(); vit_other++,
vit_this++) {
Storage_site_2 ss_other = vit_other->storage_site();
#ifndef CGAL_NO_ASSERTIONS
Storage_site_2 ss_this = vit_this->storage_site();
if ( ss_other.is_segment() ) {
CGAL_assertion( ss_this.is_segment() );
CGAL_assertion( same_segments(ss_this.site(), ss_other.site()) );
} else {
CGAL_assertion( ss_this.is_point() );
CGAL_assertion( same_points(ss_this.site(), ss_other.site()) );
}
#endif
Storage_site_2 new_ss_this = copy_storage_site(ss_other, hm, itag);
vit_this->set_site( new_ss_this );
}
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// getting endpoints of segments
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
first_endpoint_of_segment(const Vertex_handle& v) const
{
CGAL_assertion( v->is_segment() );
Site_2 fe = v->site().source_site();
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
do {
// Vertex_handle vv(vc);
if ( !is_infinite(vc) && vc->is_point() ) {
if ( same_points(fe, vc->site()) ) {
return Vertex_handle(vc);
}
}
vc++;
} while ( vc != vc_start );
// we should never reach this point
CGAL_error();
return Vertex_handle();
}
template<class Gt, class ST, class D_S, class LTag>
typename Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::Vertex_handle
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
second_endpoint_of_segment(const Vertex_handle& v) const
{
CGAL_assertion( v->is_segment() );
Site_2 fe = v->site().target_site();
Vertex_circulator vc_start = incident_vertices(v);
Vertex_circulator vc = vc_start;
do {
// Vertex_handle vv(vc);
if ( !is_infinite(vc) && vc->is_point() ) {
if ( same_points(fe, vc->site()) ) {
return Vertex_handle(vc);
}
}
vc++;
} while ( vc != vc_start );
// we should never reach this point
CGAL_error();
return Vertex_handle();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// file I/O
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
file_output(std::ostream& os, const Storage_site_2& t,
Point_handle_mapper& P) const
{
CGAL_precondition( t.is_defined() );
if ( t.is_point() ) {
// 0 for point
os << 0;
if ( is_ascii(os) ) { os << ' '; }
if ( t.is_input() ) {
// 0 for input
os << 0;
if ( is_ascii(os) ) { os << ' '; }
os << P[t.point()];
} else {
// 1 for non-input
os << 1;
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_supporting_site(0)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_supporting_site(0)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_supporting_site(1)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_supporting_site(1)];
}
} else { // t is a segment
// 1 for segment
os << 1;
if ( is_ascii(os) ) { os << ' '; }
if ( t.is_input() ) {
// 0 for input
os << 0;
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_supporting_site()];
} else if ( t.is_input(0) ) {
// 1 for input source
os << 1;
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_crossing_site(1)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_crossing_site(1)];
} else if ( t.is_input(1) ) {
// 2 for input target
os << 2;
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_crossing_site(0)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_crossing_site(0)];
} else {
// 3 for non-input src & trg
os << 3;
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_supporting_site()];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_crossing_site(0)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_crossing_site(0)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.source_of_crossing_site(1)];
if ( is_ascii(os) ) { os << ' '; }
os << P[t.target_of_crossing_site(1)];
}
}
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
file_input(std::istream& is, Storage_site_2& t,
const Point_handle_vector& P, const Tag_false&) const
{
int type, input;
is >> type >> input;
CGAL_assertion( type == 0 || type == 1 );
CGAL_assertion( input == 0 );
if ( type == 0 ) {
// we have an input point
size_type p;
is >> p;
t = st_.construct_storage_site_2_object()(P[p]);
} else {
CGAL_assertion( type == 1 );
// we have an input segment
size_type p1, p2;
is >> p1 >> p2;
t = st_.construct_storage_site_2_object()(P[p1], P[p2]);
}
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
file_input(std::istream& is, Storage_site_2& t,
const Point_handle_vector& P, const Tag_true&) const
{
int type, input;
is >> type >> input;
CGAL_assertion( type == 0 || type == 1 );
CGAL_assertion( input >= 0 && input <= 3 );
if ( type == 0 ) {
// we have a point
if ( input == 0 ) {
// we have an input point
size_type p;
is >> p;
t = st_.construct_storage_site_2_object()(P[p]);
} else {
// we have a point that is the intersection of two segments
CGAL_assertion( input == 1 );
size_type p1, p2, q1, q2;
is >> p1 >> p2 >> q1 >> q2;
t = st_.construct_storage_site_2_object()(P[p1], P[p2], P[q1], P[q2]);
}
} else {
// we have a segment
CGAL_assertion( type == 1 );
if ( input == 0 ) {
// we have an input segment
size_type p1, p2;
is >> p1 >> p2;
t = st_.construct_storage_site_2_object()(P[p1], P[p2]);
} else if ( input < 3 ) {
// we have a segment whose source or target is input but not both
size_type p1, p2, q1, q2;
is >> p1 >> p2 >> q1 >> q2;
t = st_.construct_storage_site_2_object()(P[p1], P[p2],
P[q1], P[q2], input == 1);
} else {
// we have a segment whose neither its source nor its target is input
CGAL_assertion( input == 3 );
size_type p1, p2, q1, q2, r1, r2;
is >> p1 >> p2 >> q1 >> q2 >> r1 >> r2;
t = st_.construct_storage_site_2_object()(P[p1], P[p2],
P[q1], P[q2],
P[r1], P[r2]);
}
}
}
//--------------------------------------------------------------------
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
file_output(std::ostream& os, Point_handle_mapper& P,
bool print_point_container) const
{
// ouput to a file
size_type n = this->_tds.number_of_vertices();
size_type m = this->_tds.number_of_full_dim_faces();
CGAL_assertion( n >= 1 );
if( is_ascii(os) ) {
os << n << ' ' << m << ' ' << dimension() << std::endl;
} else {
os << n << m << dimension();
}
// points in point container and input sites container
if ( print_point_container ) {
if ( is_ascii(os) ) { os << std::endl; }
os << pc_.size();
if ( is_ascii(os) ) { os << std::endl; }
for (const_Point_handle ph = pc_.begin(); ph != pc_.end(); ++ph) {
os << *ph;
if ( is_ascii(os) ) { os << std::endl; }
}
// print the input sites container
if ( is_ascii(os) ) { os << std::endl; }
os << isc_.size();
if ( is_ascii(os) ) { os << std::endl; }
for (typename Input_sites_container::const_iterator it = isc_.begin();
it != isc_.end(); ++it) {
os << P[boost::tuples::get<0>(*it)];
if ( is_ascii(os) ) { os << " "; }
os << P[boost::tuples::get<1>(*it)];
if ( is_ascii(os) ) { os << std::endl; }
}
}
std::map<Vertex_handle,size_type> V;
std::map<Face_handle,size_type> F;
// first vertex (infinite vertex)
size_type inum = 0;
V[infinite_vertex()] = inum++;
// finite vertices
if (is_ascii(os)) os << std::endl;
for (Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end(); ++vit) {
V[vit] = inum++;
// os << vit->site();
file_output(os, vit->storage_site(), P);
// write non-combinatorial info of the vertex
// os << *vit ;
if ( is_ascii(os) ) { os << std::endl; }
}
if ( is_ascii(os) ) { os << std::endl; }
// vertices of the faces
inum = 0;
int dim = (dimension() == -1 ? 1 : dimension() + 1);
for(All_faces_iterator fit = all_faces_begin();
fit != all_faces_end(); ++fit) {
F[fit] = inum++;
for(int j = 0; j < dim ; ++j) {
os << V[ fit->vertex(j) ];
if( is_ascii(os) ) { os << ' '; }
}
// write non-combinatorial info of the face
// os << *fit ;
if( is_ascii(os) ) { os << std::endl; }
}
if( is_ascii(os) ) { os << std::endl; }
// neighbor pointers of the faces
for( All_faces_iterator it = all_faces_begin();
it != all_faces_end(); ++it) {
for(int j = 0; j < dimension()+1; ++j){
os << F[ it->neighbor(j) ];
if( is_ascii(os) ) { os << ' '; }
}
if( is_ascii(os) ) { os << std::endl; }
}
if ( is_ascii(os) ) { os << std::endl; }
}
template<class Gt, class ST, class D_S, class LTag>
void
Segment_Delaunay_graph_2<Gt,ST,D_S,LTag>::
file_input(std::istream& is, bool read_handle_vector,
Point_handle_vector& P)
{
//input from file
size_type n, m;
int d;
is >> n >> m >> d;
CGAL_assertion( n >= 1 );
size_type i = 0;
Storage_site_2 ss;
if ( read_handle_vector ) {
pc_.clear();
size_type np;
is >> np;
for (; i < np; i++) {
Point_2 p;
is >> p;
std::pair<Point_handle,bool> res = pc_.insert(p);
P.push_back(res.first);
CGAL_assertion( P[i] == res.first );
}
// now read the input sites container
isc_.clear();
size_type nisc;
is >> nisc;
int id1, id2;
for (i = 0; i < nisc; i++) {
is >> id1 >> id2;
isc_.insert( Site_rep_2(P[id1], P[id2], id1 == id2) );
}
}
if ( n == 1 ) {
CGAL_assertion( d == -1 );
if ( number_of_vertices() > 0 ) { clear(); }
return;
}
if ( n == 2 ) {
CGAL_assertion( d == 0 );
if ( number_of_vertices() > 0 ) { clear(); }
file_input(is, ss, P, Intersections_tag());
insert_first(ss, *ss.point());
return;
}
if ( n == 3 ) {
CGAL_assertion( d == 1 );
if ( number_of_vertices() > 0 ) { clear(); }
file_input(is, ss, P, Intersections_tag());
insert_first(ss, *ss.point());
file_input(is, ss, P, Intersections_tag());
insert_second(ss, *ss.point());
return;
}
if (this->_tds.number_of_vertices() != 0) { this->_tds.clear(); }
this->_tds.set_dimension(d);
std::vector<Vertex_handle> V(n);
std::vector<Face_handle> F(m);
// first vertex (infinite vertex)
V[0] = this->_tds.create_vertex();
this->set_infinite_vertex(V[0]);
i = 1;
// read vertices
for (; i < n; ++i) {
V[i] = this->_tds.create_vertex();
file_input(is, ss, P, Intersections_tag());
V[i]->set_site(ss);
// read non-combinatorial info of the vertex
// is >> *(V[i]);
}
// Creation of the faces
int index;
int dim = (dimension() == -1 ? 1 : dimension() + 1);
for (i = 0; i < m; ++i) {
F[i] = this->_tds.create_face();
for (int j = 0; j < dim ; ++j){
is >> index;
F[i]->set_vertex(j, V[index]);
// The face pointer of vertices is set too often,
// but otherwise we had to use a further map
V[index]->set_face(F[i]);
}
// read in non-combinatorial info of the face
// is >> *(F[i]) ;
}
// Setting the neighbor pointers
for (i = 0; i < m; ++i) {
for (int j = 0; j < dimension()+1; ++j){
is >> index;
F[i]->set_neighbor(j, F[index]);
}
}
}
} //namespace CGAL
// EOF
| [
"cmrose@lbl.gov"
] | cmrose@lbl.gov |
13bb12a1a97b7b7e8bdbede655c5e25acc7b99c6 | 6581ff32670e4b30dd17c781975c95eac2153ebc | /libnode-v10.15.3/deps/v8/src/arm/simulator-arm.cc | e8eb4740900c211aad305df742c1bc2f54d8eccc | [
"Apache-2.0",
"LicenseRef-scancode-unicode",
"Zlib",
"ISC",
"LicenseRef-scancode-public-domain",
"NAIST-2003",
"BSD-3-Clause",
"BSD-2-Clause",
"Artistic-2.0",
"LicenseRef-scancode-unknown-license-reference",
"NTP",
"LicenseRef-scancode-openssl",
"MIT",
"ICU",
"LicenseRef-scancode-free-un... | permissive | pxscene/Spark-Externals | 6f3a16bafae1d89015f635b1ad1aa2efe342a001 | 92501a5d10c2a167bac07915eb9c078dc9aab158 | refs/heads/master | 2023-01-22T12:48:39.455338 | 2020-05-01T14:19:54 | 2020-05-01T14:19:54 | 205,173,203 | 1 | 35 | Apache-2.0 | 2023-01-07T09:41:55 | 2019-08-29T13:43:36 | C | UTF-8 | C++ | false | false | 208,273 | cc | // Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdarg.h>
#include <stdlib.h>
#include <cmath>
#if V8_TARGET_ARCH_ARM
#include "src/arm/constants-arm.h"
#include "src/arm/simulator-arm.h"
#include "src/assembler-inl.h"
#include "src/base/bits.h"
#include "src/codegen.h"
#include "src/disasm.h"
#include "src/macro-assembler.h"
#include "src/objects-inl.h"
#include "src/runtime/runtime-utils.h"
#if defined(USE_SIMULATOR)
// Only build the simulator if not compiling for real ARM hardware.
namespace v8 {
namespace internal {
// static
base::LazyInstance<Simulator::GlobalMonitor>::type Simulator::global_monitor_ =
LAZY_INSTANCE_INITIALIZER;
// This macro provides a platform independent use of sscanf. The reason for
// SScanF not being implemented in a platform independent way through
// ::v8::internal::OS in the same way as SNPrintF is that the
// Windows C Run-Time Library does not provide vsscanf.
#define SScanF sscanf // NOLINT
// The ArmDebugger class is used by the simulator while debugging simulated ARM
// code.
class ArmDebugger {
public:
explicit ArmDebugger(Simulator* sim) : sim_(sim) { }
void Stop(Instruction* instr);
void Debug();
private:
static const Instr kBreakpointInstr =
(al | (7*B25) | (1*B24) | kBreakpoint);
static const Instr kNopInstr = (al | (13*B21));
Simulator* sim_;
int32_t GetRegisterValue(int regnum);
double GetRegisterPairDoubleValue(int regnum);
double GetVFPDoubleRegisterValue(int regnum);
bool GetValue(const char* desc, int32_t* value);
bool GetVFPSingleValue(const char* desc, float* value);
bool GetVFPDoubleValue(const char* desc, double* value);
// Set or delete a breakpoint. Returns true if successful.
bool SetBreakpoint(Instruction* breakpc);
bool DeleteBreakpoint(Instruction* breakpc);
// Undo and redo all breakpoints. This is needed to bracket disassembly and
// execution to skip past breakpoints when run from the debugger.
void UndoBreakpoints();
void RedoBreakpoints();
};
void ArmDebugger::Stop(Instruction* instr) {
// Get the stop code.
uint32_t code = instr->SvcValue() & kStopCodeMask;
// Print the stop message and code if it is not the default code.
if (code != kMaxStopCode) {
PrintF("Simulator hit stop %u\n", code);
} else {
PrintF("Simulator hit\n");
}
Debug();
}
int32_t ArmDebugger::GetRegisterValue(int regnum) {
if (regnum == kPCRegister) {
return sim_->get_pc();
} else {
return sim_->get_register(regnum);
}
}
double ArmDebugger::GetRegisterPairDoubleValue(int regnum) {
return sim_->get_double_from_register_pair(regnum);
}
double ArmDebugger::GetVFPDoubleRegisterValue(int regnum) {
return sim_->get_double_from_d_register(regnum).get_scalar();
}
bool ArmDebugger::GetValue(const char* desc, int32_t* value) {
int regnum = Registers::Number(desc);
if (regnum != kNoRegister) {
*value = GetRegisterValue(regnum);
return true;
} else {
if (strncmp(desc, "0x", 2) == 0) {
return SScanF(desc + 2, "%x", reinterpret_cast<uint32_t*>(value)) == 1;
} else {
return SScanF(desc, "%u", reinterpret_cast<uint32_t*>(value)) == 1;
}
}
return false;
}
bool ArmDebugger::GetVFPSingleValue(const char* desc, float* value) {
bool is_double;
int regnum = VFPRegisters::Number(desc, &is_double);
if (regnum != kNoRegister && !is_double) {
*value = sim_->get_float_from_s_register(regnum).get_scalar();
return true;
}
return false;
}
bool ArmDebugger::GetVFPDoubleValue(const char* desc, double* value) {
bool is_double;
int regnum = VFPRegisters::Number(desc, &is_double);
if (regnum != kNoRegister && is_double) {
*value = sim_->get_double_from_d_register(regnum).get_scalar();
return true;
}
return false;
}
bool ArmDebugger::SetBreakpoint(Instruction* breakpc) {
// Check if a breakpoint can be set. If not return without any side-effects.
if (sim_->break_pc_ != nullptr) {
return false;
}
// Set the breakpoint.
sim_->break_pc_ = breakpc;
sim_->break_instr_ = breakpc->InstructionBits();
// Not setting the breakpoint instruction in the code itself. It will be set
// when the debugger shell continues.
return true;
}
bool ArmDebugger::DeleteBreakpoint(Instruction* breakpc) {
if (sim_->break_pc_ != nullptr) {
sim_->break_pc_->SetInstructionBits(sim_->break_instr_);
}
sim_->break_pc_ = nullptr;
sim_->break_instr_ = 0;
return true;
}
void ArmDebugger::UndoBreakpoints() {
if (sim_->break_pc_ != nullptr) {
sim_->break_pc_->SetInstructionBits(sim_->break_instr_);
}
}
void ArmDebugger::RedoBreakpoints() {
if (sim_->break_pc_ != nullptr) {
sim_->break_pc_->SetInstructionBits(kBreakpointInstr);
}
}
void ArmDebugger::Debug() {
intptr_t last_pc = -1;
bool done = false;
#define COMMAND_SIZE 63
#define ARG_SIZE 255
#define STR(a) #a
#define XSTR(a) STR(a)
char cmd[COMMAND_SIZE + 1];
char arg1[ARG_SIZE + 1];
char arg2[ARG_SIZE + 1];
char* argv[3] = { cmd, arg1, arg2 };
// make sure to have a proper terminating character if reaching the limit
cmd[COMMAND_SIZE] = 0;
arg1[ARG_SIZE] = 0;
arg2[ARG_SIZE] = 0;
// Undo all set breakpoints while running in the debugger shell. This will
// make them invisible to all commands.
UndoBreakpoints();
while (!done && !sim_->has_bad_pc()) {
if (last_pc != sim_->get_pc()) {
disasm::NameConverter converter;
disasm::Disassembler dasm(converter);
// use a reasonably large buffer
v8::internal::EmbeddedVector<char, 256> buffer;
dasm.InstructionDecode(buffer,
reinterpret_cast<byte*>(sim_->get_pc()));
PrintF(" 0x%08x %s\n", sim_->get_pc(), buffer.start());
last_pc = sim_->get_pc();
}
char* line = ReadLine("sim> ");
if (line == nullptr) {
break;
} else {
char* last_input = sim_->last_debugger_input();
if (strcmp(line, "\n") == 0 && last_input != nullptr) {
line = last_input;
} else {
// Ownership is transferred to sim_;
sim_->set_last_debugger_input(line);
}
// Use sscanf to parse the individual parts of the command line. At the
// moment no command expects more than two parameters.
int argc = SScanF(line,
"%" XSTR(COMMAND_SIZE) "s "
"%" XSTR(ARG_SIZE) "s "
"%" XSTR(ARG_SIZE) "s",
cmd, arg1, arg2);
if ((strcmp(cmd, "si") == 0) || (strcmp(cmd, "stepi") == 0)) {
sim_->InstructionDecode(reinterpret_cast<Instruction*>(sim_->get_pc()));
} else if ((strcmp(cmd, "c") == 0) || (strcmp(cmd, "cont") == 0)) {
// Execute the one instruction we broke at with breakpoints disabled.
sim_->InstructionDecode(reinterpret_cast<Instruction*>(sim_->get_pc()));
// Leave the debugger shell.
done = true;
} else if ((strcmp(cmd, "p") == 0) || (strcmp(cmd, "print") == 0)) {
if (argc == 2 || (argc == 3 && strcmp(arg2, "fp") == 0)) {
int32_t value;
float svalue;
double dvalue;
if (strcmp(arg1, "all") == 0) {
for (int i = 0; i < kNumRegisters; i++) {
value = GetRegisterValue(i);
PrintF(
"%3s: 0x%08x %10d",
RegisterConfiguration::Default()->GetGeneralRegisterName(i),
value, value);
if ((argc == 3 && strcmp(arg2, "fp") == 0) &&
i < 8 &&
(i % 2) == 0) {
dvalue = GetRegisterPairDoubleValue(i);
PrintF(" (%f)\n", dvalue);
} else {
PrintF("\n");
}
}
for (int i = 0; i < DwVfpRegister::NumRegisters(); i++) {
dvalue = GetVFPDoubleRegisterValue(i);
uint64_t as_words = bit_cast<uint64_t>(dvalue);
PrintF("%3s: %f 0x%08x %08x\n", VFPRegisters::Name(i, true),
dvalue, static_cast<uint32_t>(as_words >> 32),
static_cast<uint32_t>(as_words & 0xFFFFFFFF));
}
} else {
if (GetValue(arg1, &value)) {
PrintF("%s: 0x%08x %d \n", arg1, value, value);
} else if (GetVFPSingleValue(arg1, &svalue)) {
uint32_t as_word = bit_cast<uint32_t>(svalue);
PrintF("%s: %f 0x%08x\n", arg1, svalue, as_word);
} else if (GetVFPDoubleValue(arg1, &dvalue)) {
uint64_t as_words = bit_cast<uint64_t>(dvalue);
PrintF("%s: %f 0x%08x %08x\n", arg1, dvalue,
static_cast<uint32_t>(as_words >> 32),
static_cast<uint32_t>(as_words & 0xFFFFFFFF));
} else {
PrintF("%s unrecognized\n", arg1);
}
}
} else {
PrintF("print <register>\n");
}
} else if ((strcmp(cmd, "po") == 0)
|| (strcmp(cmd, "printobject") == 0)) {
if (argc == 2) {
int32_t value;
OFStream os(stdout);
if (GetValue(arg1, &value)) {
Object* obj = reinterpret_cast<Object*>(value);
os << arg1 << ": \n";
#ifdef DEBUG
obj->Print(os);
os << "\n";
#else
os << Brief(obj) << "\n";
#endif
} else {
os << arg1 << " unrecognized\n";
}
} else {
PrintF("printobject <value>\n");
}
} else if (strcmp(cmd, "stack") == 0 || strcmp(cmd, "mem") == 0) {
int32_t* cur = nullptr;
int32_t* end = nullptr;
int next_arg = 1;
if (strcmp(cmd, "stack") == 0) {
cur = reinterpret_cast<int32_t*>(sim_->get_register(Simulator::sp));
} else { // "mem"
int32_t value;
if (!GetValue(arg1, &value)) {
PrintF("%s unrecognized\n", arg1);
continue;
}
cur = reinterpret_cast<int32_t*>(value);
next_arg++;
}
int32_t words;
if (argc == next_arg) {
words = 10;
} else {
if (!GetValue(argv[next_arg], &words)) {
words = 10;
}
}
end = cur + words;
while (cur < end) {
PrintF(" 0x%08" V8PRIxPTR ": 0x%08x %10d",
reinterpret_cast<intptr_t>(cur), *cur, *cur);
HeapObject* obj = reinterpret_cast<HeapObject*>(*cur);
int value = *cur;
Heap* current_heap = sim_->isolate_->heap();
if (((value & 1) == 0) ||
current_heap->ContainsSlow(obj->address())) {
PrintF(" (");
if ((value & 1) == 0) {
PrintF("smi %d", value / 2);
} else {
obj->ShortPrint();
}
PrintF(")");
}
PrintF("\n");
cur++;
}
} else if (strcmp(cmd, "disasm") == 0 || strcmp(cmd, "di") == 0) {
disasm::NameConverter converter;
disasm::Disassembler dasm(converter);
// use a reasonably large buffer
v8::internal::EmbeddedVector<char, 256> buffer;
byte* prev = nullptr;
byte* cur = nullptr;
byte* end = nullptr;
if (argc == 1) {
cur = reinterpret_cast<byte*>(sim_->get_pc());
end = cur + (10 * Instruction::kInstrSize);
} else if (argc == 2) {
int regnum = Registers::Number(arg1);
if (regnum != kNoRegister || strncmp(arg1, "0x", 2) == 0) {
// The argument is an address or a register name.
int32_t value;
if (GetValue(arg1, &value)) {
cur = reinterpret_cast<byte*>(value);
// Disassemble 10 instructions at <arg1>.
end = cur + (10 * Instruction::kInstrSize);
}
} else {
// The argument is the number of instructions.
int32_t value;
if (GetValue(arg1, &value)) {
cur = reinterpret_cast<byte*>(sim_->get_pc());
// Disassemble <arg1> instructions.
end = cur + (value * Instruction::kInstrSize);
}
}
} else {
int32_t value1;
int32_t value2;
if (GetValue(arg1, &value1) && GetValue(arg2, &value2)) {
cur = reinterpret_cast<byte*>(value1);
end = cur + (value2 * Instruction::kInstrSize);
}
}
while (cur < end) {
prev = cur;
cur += dasm.InstructionDecode(buffer, cur);
PrintF(" 0x%08" V8PRIxPTR " %s\n", reinterpret_cast<intptr_t>(prev),
buffer.start());
}
} else if (strcmp(cmd, "gdb") == 0) {
PrintF("relinquishing control to gdb\n");
v8::base::OS::DebugBreak();
PrintF("regaining control from gdb\n");
} else if (strcmp(cmd, "break") == 0) {
if (argc == 2) {
int32_t value;
if (GetValue(arg1, &value)) {
if (!SetBreakpoint(reinterpret_cast<Instruction*>(value))) {
PrintF("setting breakpoint failed\n");
}
} else {
PrintF("%s unrecognized\n", arg1);
}
} else {
PrintF("break <address>\n");
}
} else if (strcmp(cmd, "del") == 0) {
if (!DeleteBreakpoint(nullptr)) {
PrintF("deleting breakpoint failed\n");
}
} else if (strcmp(cmd, "flags") == 0) {
PrintF("N flag: %d; ", sim_->n_flag_);
PrintF("Z flag: %d; ", sim_->z_flag_);
PrintF("C flag: %d; ", sim_->c_flag_);
PrintF("V flag: %d\n", sim_->v_flag_);
PrintF("INVALID OP flag: %d; ", sim_->inv_op_vfp_flag_);
PrintF("DIV BY ZERO flag: %d; ", sim_->div_zero_vfp_flag_);
PrintF("OVERFLOW flag: %d; ", sim_->overflow_vfp_flag_);
PrintF("UNDERFLOW flag: %d; ", sim_->underflow_vfp_flag_);
PrintF("INEXACT flag: %d;\n", sim_->inexact_vfp_flag_);
} else if (strcmp(cmd, "stop") == 0) {
int32_t value;
intptr_t stop_pc = sim_->get_pc() - Instruction::kInstrSize;
Instruction* stop_instr = reinterpret_cast<Instruction*>(stop_pc);
if ((argc == 2) && (strcmp(arg1, "unstop") == 0)) {
// Remove the current stop.
if (sim_->isStopInstruction(stop_instr)) {
stop_instr->SetInstructionBits(kNopInstr);
} else {
PrintF("Not at debugger stop.\n");
}
} else if (argc == 3) {
// Print information about all/the specified breakpoint(s).
if (strcmp(arg1, "info") == 0) {
if (strcmp(arg2, "all") == 0) {
PrintF("Stop information:\n");
for (uint32_t i = 0; i < sim_->kNumOfWatchedStops; i++) {
sim_->PrintStopInfo(i);
}
} else if (GetValue(arg2, &value)) {
sim_->PrintStopInfo(value);
} else {
PrintF("Unrecognized argument.\n");
}
} else if (strcmp(arg1, "enable") == 0) {
// Enable all/the specified breakpoint(s).
if (strcmp(arg2, "all") == 0) {
for (uint32_t i = 0; i < sim_->kNumOfWatchedStops; i++) {
sim_->EnableStop(i);
}
} else if (GetValue(arg2, &value)) {
sim_->EnableStop(value);
} else {
PrintF("Unrecognized argument.\n");
}
} else if (strcmp(arg1, "disable") == 0) {
// Disable all/the specified breakpoint(s).
if (strcmp(arg2, "all") == 0) {
for (uint32_t i = 0; i < sim_->kNumOfWatchedStops; i++) {
sim_->DisableStop(i);
}
} else if (GetValue(arg2, &value)) {
sim_->DisableStop(value);
} else {
PrintF("Unrecognized argument.\n");
}
}
} else {
PrintF("Wrong usage. Use help command for more information.\n");
}
} else if ((strcmp(cmd, "t") == 0) || strcmp(cmd, "trace") == 0) {
::v8::internal::FLAG_trace_sim = !::v8::internal::FLAG_trace_sim;
PrintF("Trace of executed instructions is %s\n",
::v8::internal::FLAG_trace_sim ? "on" : "off");
} else if ((strcmp(cmd, "h") == 0) || (strcmp(cmd, "help") == 0)) {
PrintF("cont\n");
PrintF(" continue execution (alias 'c')\n");
PrintF("stepi\n");
PrintF(" step one instruction (alias 'si')\n");
PrintF("print <register>\n");
PrintF(" print register content (alias 'p')\n");
PrintF(" use register name 'all' to print all registers\n");
PrintF(" add argument 'fp' to print register pair double values\n");
PrintF("printobject <register>\n");
PrintF(" print an object from a register (alias 'po')\n");
PrintF("flags\n");
PrintF(" print flags\n");
PrintF("stack [<words>]\n");
PrintF(" dump stack content, default dump 10 words)\n");
PrintF("mem <address> [<words>]\n");
PrintF(" dump memory content, default dump 10 words)\n");
PrintF("disasm [<instructions>]\n");
PrintF("disasm [<address/register>]\n");
PrintF("disasm [[<address/register>] <instructions>]\n");
PrintF(" disassemble code, default is 10 instructions\n");
PrintF(" from pc (alias 'di')\n");
PrintF("gdb\n");
PrintF(" enter gdb\n");
PrintF("break <address>\n");
PrintF(" set a break point on the address\n");
PrintF("del\n");
PrintF(" delete the breakpoint\n");
PrintF("trace (alias 't')\n");
PrintF(" toogle the tracing of all executed statements\n");
PrintF("stop feature:\n");
PrintF(" Description:\n");
PrintF(" Stops are debug instructions inserted by\n");
PrintF(" the Assembler::stop() function.\n");
PrintF(" When hitting a stop, the Simulator will\n");
PrintF(" stop and and give control to the ArmDebugger.\n");
PrintF(" The first %d stop codes are watched:\n",
Simulator::kNumOfWatchedStops);
PrintF(" - They can be enabled / disabled: the Simulator\n");
PrintF(" will / won't stop when hitting them.\n");
PrintF(" - The Simulator keeps track of how many times they \n");
PrintF(" are met. (See the info command.) Going over a\n");
PrintF(" disabled stop still increases its counter. \n");
PrintF(" Commands:\n");
PrintF(" stop info all/<code> : print infos about number <code>\n");
PrintF(" or all stop(s).\n");
PrintF(" stop enable/disable all/<code> : enables / disables\n");
PrintF(" all or number <code> stop(s)\n");
PrintF(" stop unstop\n");
PrintF(" ignore the stop instruction at the current location\n");
PrintF(" from now on\n");
} else {
PrintF("Unknown command: %s\n", cmd);
}
}
}
// Add all the breakpoints back to stop execution and enter the debugger
// shell when hit.
RedoBreakpoints();
#undef COMMAND_SIZE
#undef ARG_SIZE
#undef STR
#undef XSTR
}
bool Simulator::ICacheMatch(void* one, void* two) {
DCHECK_EQ(reinterpret_cast<intptr_t>(one) & CachePage::kPageMask, 0);
DCHECK_EQ(reinterpret_cast<intptr_t>(two) & CachePage::kPageMask, 0);
return one == two;
}
static uint32_t ICacheHash(void* key) {
return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key)) >> 2;
}
static bool AllOnOnePage(uintptr_t start, int size) {
intptr_t start_page = (start & ~CachePage::kPageMask);
intptr_t end_page = ((start + size) & ~CachePage::kPageMask);
return start_page == end_page;
}
void Simulator::set_last_debugger_input(char* input) {
DeleteArray(last_debugger_input_);
last_debugger_input_ = input;
}
void Simulator::SetRedirectInstruction(Instruction* instruction) {
instruction->SetInstructionBits(al | (0xF * B24) | kCallRtRedirected);
}
void Simulator::FlushICache(base::CustomMatcherHashMap* i_cache,
void* start_addr, size_t size) {
intptr_t start = reinterpret_cast<intptr_t>(start_addr);
int intra_line = (start & CachePage::kLineMask);
start -= intra_line;
size += intra_line;
size = ((size - 1) | CachePage::kLineMask) + 1;
int offset = (start & CachePage::kPageMask);
while (!AllOnOnePage(start, size - 1)) {
int bytes_to_flush = CachePage::kPageSize - offset;
FlushOnePage(i_cache, start, bytes_to_flush);
start += bytes_to_flush;
size -= bytes_to_flush;
DCHECK_EQ(0, start & CachePage::kPageMask);
offset = 0;
}
if (size != 0) {
FlushOnePage(i_cache, start, size);
}
}
CachePage* Simulator::GetCachePage(base::CustomMatcherHashMap* i_cache,
void* page) {
base::HashMap::Entry* entry = i_cache->LookupOrInsert(page, ICacheHash(page));
if (entry->value == nullptr) {
CachePage* new_page = new CachePage();
entry->value = new_page;
}
return reinterpret_cast<CachePage*>(entry->value);
}
// Flush from start up to and not including start + size.
void Simulator::FlushOnePage(base::CustomMatcherHashMap* i_cache,
intptr_t start, int size) {
DCHECK_LE(size, CachePage::kPageSize);
DCHECK(AllOnOnePage(start, size - 1));
DCHECK_EQ(start & CachePage::kLineMask, 0);
DCHECK_EQ(size & CachePage::kLineMask, 0);
void* page = reinterpret_cast<void*>(start & (~CachePage::kPageMask));
int offset = (start & CachePage::kPageMask);
CachePage* cache_page = GetCachePage(i_cache, page);
char* valid_bytemap = cache_page->ValidityByte(offset);
memset(valid_bytemap, CachePage::LINE_INVALID, size >> CachePage::kLineShift);
}
void Simulator::CheckICache(base::CustomMatcherHashMap* i_cache,
Instruction* instr) {
intptr_t address = reinterpret_cast<intptr_t>(instr);
void* page = reinterpret_cast<void*>(address & (~CachePage::kPageMask));
void* line = reinterpret_cast<void*>(address & (~CachePage::kLineMask));
int offset = (address & CachePage::kPageMask);
CachePage* cache_page = GetCachePage(i_cache, page);
char* cache_valid_byte = cache_page->ValidityByte(offset);
bool cache_hit = (*cache_valid_byte == CachePage::LINE_VALID);
char* cached_line = cache_page->CachedData(offset & ~CachePage::kLineMask);
if (cache_hit) {
// Check that the data in memory matches the contents of the I-cache.
CHECK_EQ(0,
memcmp(reinterpret_cast<void*>(instr),
cache_page->CachedData(offset), Instruction::kInstrSize));
} else {
// Cache miss. Load memory into the cache.
memcpy(cached_line, line, CachePage::kLineLength);
*cache_valid_byte = CachePage::LINE_VALID;
}
}
Simulator::Simulator(Isolate* isolate) : isolate_(isolate) {
// Set up simulator support first. Some of this information is needed to
// setup the architecture state.
size_t stack_size = 1 * 1024*1024; // allocate 1MB for stack
stack_ = reinterpret_cast<char*>(malloc(stack_size));
pc_modified_ = false;
icount_ = 0;
break_pc_ = nullptr;
break_instr_ = 0;
// Set up architecture state.
// All registers are initialized to zero to start with.
for (int i = 0; i < num_registers; i++) {
registers_[i] = 0;
}
n_flag_ = false;
z_flag_ = false;
c_flag_ = false;
v_flag_ = false;
// Initializing VFP registers.
// All registers are initialized to zero to start with
// even though s_registers_ & d_registers_ share the same
// physical registers in the target.
for (int i = 0; i < num_d_registers * 2; i++) {
vfp_registers_[i] = 0;
}
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = false;
v_flag_FPSCR_ = false;
FPSCR_rounding_mode_ = RN;
FPSCR_default_NaN_mode_ = false;
inv_op_vfp_flag_ = false;
div_zero_vfp_flag_ = false;
overflow_vfp_flag_ = false;
underflow_vfp_flag_ = false;
inexact_vfp_flag_ = false;
// The sp is initialized to point to the bottom (high address) of the
// allocated stack area. To be safe in potential stack underflows we leave
// some buffer below.
registers_[sp] = reinterpret_cast<int32_t>(stack_) + stack_size - 64;
// The lr and pc are initialized to a known bad value that will cause an
// access violation if the simulator ever tries to execute it.
registers_[pc] = bad_lr;
registers_[lr] = bad_lr;
last_debugger_input_ = nullptr;
}
Simulator::~Simulator() {
global_monitor_.Pointer()->RemoveProcessor(&global_monitor_processor_);
free(stack_);
}
// Get the active Simulator for the current thread.
Simulator* Simulator::current(Isolate* isolate) {
v8::internal::Isolate::PerIsolateThreadData* isolate_data =
isolate->FindOrAllocatePerThreadDataForThisThread();
DCHECK_NOT_NULL(isolate_data);
Simulator* sim = isolate_data->simulator();
if (sim == nullptr) {
// TODO(146): delete the simulator object when a thread/isolate goes away.
sim = new Simulator(isolate);
isolate_data->set_simulator(sim);
}
return sim;
}
// Sets the register in the architecture state. It will also deal with updating
// Simulator internal state for special registers such as PC.
void Simulator::set_register(int reg, int32_t value) {
DCHECK((reg >= 0) && (reg < num_registers));
if (reg == pc) {
pc_modified_ = true;
}
registers_[reg] = value;
}
// Get the register from the architecture state. This function does handle
// the special case of accessing the PC register.
int32_t Simulator::get_register(int reg) const {
DCHECK((reg >= 0) && (reg < num_registers));
// Stupid code added to avoid bug in GCC.
// See: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43949
if (reg >= num_registers) return 0;
// End stupid code.
return registers_[reg] + ((reg == pc) ? Instruction::kPCReadOffset : 0);
}
double Simulator::get_double_from_register_pair(int reg) {
DCHECK((reg >= 0) && (reg < num_registers) && ((reg % 2) == 0));
double dm_val = 0.0;
// Read the bits from the unsigned integer register_[] array
// into the double precision floating point value and return it.
char buffer[2 * sizeof(vfp_registers_[0])];
memcpy(buffer, ®isters_[reg], 2 * sizeof(registers_[0]));
memcpy(&dm_val, buffer, 2 * sizeof(registers_[0]));
return(dm_val);
}
void Simulator::set_register_pair_from_double(int reg, double* value) {
DCHECK((reg >= 0) && (reg < num_registers) && ((reg % 2) == 0));
memcpy(registers_ + reg, value, sizeof(*value));
}
void Simulator::set_dw_register(int dreg, const int* dbl) {
DCHECK((dreg >= 0) && (dreg < num_d_registers));
registers_[dreg] = dbl[0];
registers_[dreg + 1] = dbl[1];
}
void Simulator::get_d_register(int dreg, uint64_t* value) {
DCHECK((dreg >= 0) && (dreg < DwVfpRegister::NumRegisters()));
memcpy(value, vfp_registers_ + dreg * 2, sizeof(*value));
}
void Simulator::set_d_register(int dreg, const uint64_t* value) {
DCHECK((dreg >= 0) && (dreg < DwVfpRegister::NumRegisters()));
memcpy(vfp_registers_ + dreg * 2, value, sizeof(*value));
}
void Simulator::get_d_register(int dreg, uint32_t* value) {
DCHECK((dreg >= 0) && (dreg < DwVfpRegister::NumRegisters()));
memcpy(value, vfp_registers_ + dreg * 2, sizeof(*value) * 2);
}
void Simulator::set_d_register(int dreg, const uint32_t* value) {
DCHECK((dreg >= 0) && (dreg < DwVfpRegister::NumRegisters()));
memcpy(vfp_registers_ + dreg * 2, value, sizeof(*value) * 2);
}
template <typename T, int SIZE>
void Simulator::get_neon_register(int reg, T (&value)[SIZE / sizeof(T)]) {
DCHECK(SIZE == kSimd128Size || SIZE == kDoubleSize);
DCHECK_LE(0, reg);
DCHECK_GT(SIZE == kSimd128Size ? num_q_registers : num_d_registers, reg);
memcpy(value, vfp_registers_ + reg * (SIZE / 4), SIZE);
}
template <typename T, int SIZE>
void Simulator::set_neon_register(int reg, const T (&value)[SIZE / sizeof(T)]) {
DCHECK(SIZE == kSimd128Size || SIZE == kDoubleSize);
DCHECK_LE(0, reg);
DCHECK_GT(SIZE == kSimd128Size ? num_q_registers : num_d_registers, reg);
memcpy(vfp_registers_ + reg * (SIZE / 4), value, SIZE);
}
// Raw access to the PC register.
void Simulator::set_pc(int32_t value) {
pc_modified_ = true;
registers_[pc] = value;
}
bool Simulator::has_bad_pc() const {
return ((registers_[pc] == bad_lr) || (registers_[pc] == end_sim_pc));
}
// Raw access to the PC register without the special adjustment when reading.
int32_t Simulator::get_pc() const {
return registers_[pc];
}
// Getting from and setting into VFP registers.
void Simulator::set_s_register(int sreg, unsigned int value) {
DCHECK((sreg >= 0) && (sreg < num_s_registers));
vfp_registers_[sreg] = value;
}
unsigned int Simulator::get_s_register(int sreg) const {
DCHECK((sreg >= 0) && (sreg < num_s_registers));
return vfp_registers_[sreg];
}
template<class InputType, int register_size>
void Simulator::SetVFPRegister(int reg_index, const InputType& value) {
unsigned bytes = register_size * sizeof(vfp_registers_[0]);
DCHECK_EQ(sizeof(InputType), bytes);
DCHECK_GE(reg_index, 0);
if (register_size == 1) DCHECK(reg_index < num_s_registers);
if (register_size == 2) DCHECK(reg_index < DwVfpRegister::NumRegisters());
memcpy(&vfp_registers_[reg_index * register_size], &value, bytes);
}
template<class ReturnType, int register_size>
ReturnType Simulator::GetFromVFPRegister(int reg_index) {
unsigned bytes = register_size * sizeof(vfp_registers_[0]);
DCHECK_EQ(sizeof(ReturnType), bytes);
DCHECK_GE(reg_index, 0);
if (register_size == 1) DCHECK(reg_index < num_s_registers);
if (register_size == 2) DCHECK(reg_index < DwVfpRegister::NumRegisters());
ReturnType value;
memcpy(&value, &vfp_registers_[register_size * reg_index], bytes);
return value;
}
void Simulator::SetSpecialRegister(SRegisterFieldMask reg_and_mask,
uint32_t value) {
// Only CPSR_f is implemented. Of that, only N, Z, C and V are implemented.
if ((reg_and_mask == CPSR_f) && ((value & ~kSpecialCondition) == 0)) {
n_flag_ = ((value & (1 << 31)) != 0);
z_flag_ = ((value & (1 << 30)) != 0);
c_flag_ = ((value & (1 << 29)) != 0);
v_flag_ = ((value & (1 << 28)) != 0);
} else {
UNIMPLEMENTED();
}
}
uint32_t Simulator::GetFromSpecialRegister(SRegister reg) {
uint32_t result = 0;
// Only CPSR_f is implemented.
if (reg == CPSR) {
if (n_flag_) result |= (1 << 31);
if (z_flag_) result |= (1 << 30);
if (c_flag_) result |= (1 << 29);
if (v_flag_) result |= (1 << 28);
} else {
UNIMPLEMENTED();
}
return result;
}
// Runtime FP routines take:
// - two double arguments
// - one double argument and zero or one integer arguments.
// All are consructed here from r0-r3 or d0, d1 and r0.
void Simulator::GetFpArgs(double* x, double* y, int32_t* z) {
if (use_eabi_hardfloat()) {
*x = get_double_from_d_register(0).get_scalar();
*y = get_double_from_d_register(1).get_scalar();
*z = get_register(0);
} else {
// Registers 0 and 1 -> x.
*x = get_double_from_register_pair(0);
// Register 2 and 3 -> y.
*y = get_double_from_register_pair(2);
// Register 2 -> z
*z = get_register(2);
}
}
// The return value is either in r0/r1 or d0.
void Simulator::SetFpResult(const double& result) {
if (use_eabi_hardfloat()) {
char buffer[2 * sizeof(vfp_registers_[0])];
memcpy(buffer, &result, sizeof(buffer));
// Copy result to d0.
memcpy(vfp_registers_, buffer, sizeof(buffer));
} else {
char buffer[2 * sizeof(registers_[0])];
memcpy(buffer, &result, sizeof(buffer));
// Copy result to r0 and r1.
memcpy(registers_, buffer, sizeof(buffer));
}
}
void Simulator::TrashCallerSaveRegisters() {
// We don't trash the registers with the return value.
registers_[2] = 0x50BAD4U;
registers_[3] = 0x50BAD4U;
registers_[12] = 0x50BAD4U;
}
int Simulator::ReadW(int32_t addr, Instruction* instr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoad(addr);
intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
return *ptr;
}
int Simulator::ReadExW(int32_t addr, Instruction* instr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoadExcl(addr, TransactionSize::Word);
global_monitor_.Pointer()->NotifyLoadExcl_Locked(addr,
&global_monitor_processor_);
intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
return *ptr;
}
void Simulator::WriteW(int32_t addr, int value, Instruction* instr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyStore(addr);
global_monitor_.Pointer()->NotifyStore_Locked(addr,
&global_monitor_processor_);
intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
*ptr = value;
}
int Simulator::WriteExW(int32_t addr, int value, Instruction* instr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
if (local_monitor_.NotifyStoreExcl(addr, TransactionSize::Word) &&
global_monitor_.Pointer()->NotifyStoreExcl_Locked(
addr, &global_monitor_processor_)) {
intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
*ptr = value;
return 0;
} else {
return 1;
}
}
uint16_t Simulator::ReadHU(int32_t addr, Instruction* instr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoad(addr);
uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
return *ptr;
}
int16_t Simulator::ReadH(int32_t addr, Instruction* instr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoad(addr);
int16_t* ptr = reinterpret_cast<int16_t*>(addr);
return *ptr;
}
uint16_t Simulator::ReadExHU(int32_t addr, Instruction* instr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoadExcl(addr, TransactionSize::HalfWord);
global_monitor_.Pointer()->NotifyLoadExcl_Locked(addr,
&global_monitor_processor_);
uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
return *ptr;
}
void Simulator::WriteH(int32_t addr, uint16_t value, Instruction* instr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyStore(addr);
global_monitor_.Pointer()->NotifyStore_Locked(addr,
&global_monitor_processor_);
uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
*ptr = value;
}
void Simulator::WriteH(int32_t addr, int16_t value, Instruction* instr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyStore(addr);
global_monitor_.Pointer()->NotifyStore_Locked(addr,
&global_monitor_processor_);
int16_t* ptr = reinterpret_cast<int16_t*>(addr);
*ptr = value;
}
int Simulator::WriteExH(int32_t addr, uint16_t value, Instruction* instr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
if (local_monitor_.NotifyStoreExcl(addr, TransactionSize::HalfWord) &&
global_monitor_.Pointer()->NotifyStoreExcl_Locked(
addr, &global_monitor_processor_)) {
uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
*ptr = value;
return 0;
} else {
return 1;
}
}
uint8_t Simulator::ReadBU(int32_t addr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoad(addr);
uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
return *ptr;
}
int8_t Simulator::ReadB(int32_t addr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoad(addr);
int8_t* ptr = reinterpret_cast<int8_t*>(addr);
return *ptr;
}
uint8_t Simulator::ReadExBU(int32_t addr) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoadExcl(addr, TransactionSize::Byte);
global_monitor_.Pointer()->NotifyLoadExcl_Locked(addr,
&global_monitor_processor_);
uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
return *ptr;
}
void Simulator::WriteB(int32_t addr, uint8_t value) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyStore(addr);
global_monitor_.Pointer()->NotifyStore_Locked(addr,
&global_monitor_processor_);
uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
*ptr = value;
}
void Simulator::WriteB(int32_t addr, int8_t value) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyStore(addr);
global_monitor_.Pointer()->NotifyStore_Locked(addr,
&global_monitor_processor_);
int8_t* ptr = reinterpret_cast<int8_t*>(addr);
*ptr = value;
}
int Simulator::WriteExB(int32_t addr, uint8_t value) {
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
if (local_monitor_.NotifyStoreExcl(addr, TransactionSize::Byte) &&
global_monitor_.Pointer()->NotifyStoreExcl_Locked(
addr, &global_monitor_processor_)) {
uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
*ptr = value;
return 0;
} else {
return 1;
}
}
int32_t* Simulator::ReadDW(int32_t addr) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyLoad(addr);
int32_t* ptr = reinterpret_cast<int32_t*>(addr);
return ptr;
}
void Simulator::WriteDW(int32_t addr, int32_t value1, int32_t value2) {
// All supported ARM targets allow unaligned accesses, so we don't need to
// check the alignment here.
base::LockGuard<base::Mutex> lock_guard(&global_monitor_.Pointer()->mutex);
local_monitor_.NotifyStore(addr);
global_monitor_.Pointer()->NotifyStore_Locked(addr,
&global_monitor_processor_);
int32_t* ptr = reinterpret_cast<int32_t*>(addr);
*ptr++ = value1;
*ptr = value2;
}
// Returns the limit of the stack area to enable checking for stack overflows.
uintptr_t Simulator::StackLimit(uintptr_t c_limit) const {
// The simulator uses a separate JS stack. If we have exhausted the C stack,
// we also drop down the JS limit to reflect the exhaustion on the JS stack.
if (GetCurrentStackPosition() < c_limit) {
return reinterpret_cast<uintptr_t>(get_sp());
}
// Otherwise the limit is the JS stack. Leave a safety margin of 1024 bytes
// to prevent overrunning the stack when pushing values.
return reinterpret_cast<uintptr_t>(stack_) + 1024;
}
// Unsupported instructions use Format to print an error and stop execution.
void Simulator::Format(Instruction* instr, const char* format) {
PrintF("Simulator found unsupported instruction:\n 0x%08" V8PRIxPTR ": %s\n",
reinterpret_cast<intptr_t>(instr), format);
UNIMPLEMENTED();
}
// Checks if the current instruction should be executed based on its
// condition bits.
bool Simulator::ConditionallyExecute(Instruction* instr) {
switch (instr->ConditionField()) {
case eq: return z_flag_;
case ne: return !z_flag_;
case cs: return c_flag_;
case cc: return !c_flag_;
case mi: return n_flag_;
case pl: return !n_flag_;
case vs: return v_flag_;
case vc: return !v_flag_;
case hi: return c_flag_ && !z_flag_;
case ls: return !c_flag_ || z_flag_;
case ge: return n_flag_ == v_flag_;
case lt: return n_flag_ != v_flag_;
case gt: return !z_flag_ && (n_flag_ == v_flag_);
case le: return z_flag_ || (n_flag_ != v_flag_);
case al: return true;
default: UNREACHABLE();
}
return false;
}
// Calculate and set the Negative and Zero flags.
void Simulator::SetNZFlags(int32_t val) {
n_flag_ = (val < 0);
z_flag_ = (val == 0);
}
// Set the Carry flag.
void Simulator::SetCFlag(bool val) {
c_flag_ = val;
}
// Set the oVerflow flag.
void Simulator::SetVFlag(bool val) {
v_flag_ = val;
}
// Calculate C flag value for additions.
bool Simulator::CarryFrom(int32_t left, int32_t right, int32_t carry) {
uint32_t uleft = static_cast<uint32_t>(left);
uint32_t uright = static_cast<uint32_t>(right);
uint32_t urest = 0xFFFFFFFFU - uleft;
return (uright > urest) ||
(carry && (((uright + 1) > urest) || (uright > (urest - 1))));
}
// Calculate C flag value for subtractions.
bool Simulator::BorrowFrom(int32_t left, int32_t right, int32_t carry) {
uint32_t uleft = static_cast<uint32_t>(left);
uint32_t uright = static_cast<uint32_t>(right);
return (uright > uleft) ||
(!carry && (((uright + 1) > uleft) || (uright > (uleft - 1))));
}
// Calculate V flag value for additions and subtractions.
bool Simulator::OverflowFrom(int32_t alu_out,
int32_t left, int32_t right, bool addition) {
bool overflow;
if (addition) {
// operands have the same sign
overflow = ((left >= 0 && right >= 0) || (left < 0 && right < 0))
// and operands and result have different sign
&& ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
} else {
// operands have different signs
overflow = ((left < 0 && right >= 0) || (left >= 0 && right < 0))
// and first operand and result have different signs
&& ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
}
return overflow;
}
// Support for VFP comparisons.
void Simulator::Compute_FPSCR_Flags(float val1, float val2) {
if (std::isnan(val1) || std::isnan(val2)) {
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = true;
v_flag_FPSCR_ = true;
// All non-NaN cases.
} else if (val1 == val2) {
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = true;
c_flag_FPSCR_ = true;
v_flag_FPSCR_ = false;
} else if (val1 < val2) {
n_flag_FPSCR_ = true;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = false;
v_flag_FPSCR_ = false;
} else {
// Case when (val1 > val2).
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = true;
v_flag_FPSCR_ = false;
}
}
void Simulator::Compute_FPSCR_Flags(double val1, double val2) {
if (std::isnan(val1) || std::isnan(val2)) {
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = true;
v_flag_FPSCR_ = true;
// All non-NaN cases.
} else if (val1 == val2) {
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = true;
c_flag_FPSCR_ = true;
v_flag_FPSCR_ = false;
} else if (val1 < val2) {
n_flag_FPSCR_ = true;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = false;
v_flag_FPSCR_ = false;
} else {
// Case when (val1 > val2).
n_flag_FPSCR_ = false;
z_flag_FPSCR_ = false;
c_flag_FPSCR_ = true;
v_flag_FPSCR_ = false;
}
}
void Simulator::Copy_FPSCR_to_APSR() {
n_flag_ = n_flag_FPSCR_;
z_flag_ = z_flag_FPSCR_;
c_flag_ = c_flag_FPSCR_;
v_flag_ = v_flag_FPSCR_;
}
// Addressing Mode 1 - Data-processing operands:
// Get the value based on the shifter_operand with register.
int32_t Simulator::GetShiftRm(Instruction* instr, bool* carry_out) {
ShiftOp shift = instr->ShiftField();
int shift_amount = instr->ShiftAmountValue();
int32_t result = get_register(instr->RmValue());
if (instr->Bit(4) == 0) {
// by immediate
if ((shift == ROR) && (shift_amount == 0)) {
UNIMPLEMENTED();
return result;
} else if (((shift == LSR) || (shift == ASR)) && (shift_amount == 0)) {
shift_amount = 32;
}
switch (shift) {
case ASR: {
if (shift_amount == 0) {
if (result < 0) {
result = 0xFFFFFFFF;
*carry_out = true;
} else {
result = 0;
*carry_out = false;
}
} else {
result >>= (shift_amount - 1);
*carry_out = (result & 1) == 1;
result >>= 1;
}
break;
}
case LSL: {
if (shift_amount == 0) {
*carry_out = c_flag_;
} else {
result <<= (shift_amount - 1);
*carry_out = (result < 0);
result <<= 1;
}
break;
}
case LSR: {
if (shift_amount == 0) {
result = 0;
*carry_out = c_flag_;
} else {
uint32_t uresult = static_cast<uint32_t>(result);
uresult >>= (shift_amount - 1);
*carry_out = (uresult & 1) == 1;
uresult >>= 1;
result = static_cast<int32_t>(uresult);
}
break;
}
case ROR: {
if (shift_amount == 0) {
*carry_out = c_flag_;
} else {
uint32_t left = static_cast<uint32_t>(result) >> shift_amount;
uint32_t right = static_cast<uint32_t>(result) << (32 - shift_amount);
result = right | left;
*carry_out = (static_cast<uint32_t>(result) >> 31) != 0;
}
break;
}
default: {
UNREACHABLE();
break;
}
}
} else {
// by register
int rs = instr->RsValue();
shift_amount = get_register(rs) & 0xFF;
switch (shift) {
case ASR: {
if (shift_amount == 0) {
*carry_out = c_flag_;
} else if (shift_amount < 32) {
result >>= (shift_amount - 1);
*carry_out = (result & 1) == 1;
result >>= 1;
} else {
DCHECK_GE(shift_amount, 32);
if (result < 0) {
*carry_out = true;
result = 0xFFFFFFFF;
} else {
*carry_out = false;
result = 0;
}
}
break;
}
case LSL: {
if (shift_amount == 0) {
*carry_out = c_flag_;
} else if (shift_amount < 32) {
result <<= (shift_amount - 1);
*carry_out = (result < 0);
result <<= 1;
} else if (shift_amount == 32) {
*carry_out = (result & 1) == 1;
result = 0;
} else {
DCHECK_GT(shift_amount, 32);
*carry_out = false;
result = 0;
}
break;
}
case LSR: {
if (shift_amount == 0) {
*carry_out = c_flag_;
} else if (shift_amount < 32) {
uint32_t uresult = static_cast<uint32_t>(result);
uresult >>= (shift_amount - 1);
*carry_out = (uresult & 1) == 1;
uresult >>= 1;
result = static_cast<int32_t>(uresult);
} else if (shift_amount == 32) {
*carry_out = (result < 0);
result = 0;
} else {
*carry_out = false;
result = 0;
}
break;
}
case ROR: {
if (shift_amount == 0) {
*carry_out = c_flag_;
} else {
uint32_t left = static_cast<uint32_t>(result) >> shift_amount;
uint32_t right = static_cast<uint32_t>(result) << (32 - shift_amount);
result = right | left;
*carry_out = (static_cast<uint32_t>(result) >> 31) != 0;
}
break;
}
default: {
UNREACHABLE();
break;
}
}
}
return result;
}
// Addressing Mode 1 - Data-processing operands:
// Get the value based on the shifter_operand with immediate.
int32_t Simulator::GetImm(Instruction* instr, bool* carry_out) {
int rotate = instr->RotateValue() * 2;
int immed8 = instr->Immed8Value();
int imm = base::bits::RotateRight32(immed8, rotate);
*carry_out = (rotate == 0) ? c_flag_ : (imm < 0);
return imm;
}
static int count_bits(int bit_vector) {
int count = 0;
while (bit_vector != 0) {
if ((bit_vector & 1) != 0) {
count++;
}
bit_vector >>= 1;
}
return count;
}
int32_t Simulator::ProcessPU(Instruction* instr,
int num_regs,
int reg_size,
intptr_t* start_address,
intptr_t* end_address) {
int rn = instr->RnValue();
int32_t rn_val = get_register(rn);
switch (instr->PUField()) {
case da_x: {
UNIMPLEMENTED();
break;
}
case ia_x: {
*start_address = rn_val;
*end_address = rn_val + (num_regs * reg_size) - reg_size;
rn_val = rn_val + (num_regs * reg_size);
break;
}
case db_x: {
*start_address = rn_val - (num_regs * reg_size);
*end_address = rn_val - reg_size;
rn_val = *start_address;
break;
}
case ib_x: {
*start_address = rn_val + reg_size;
*end_address = rn_val + (num_regs * reg_size);
rn_val = *end_address;
break;
}
default: {
UNREACHABLE();
break;
}
}
return rn_val;
}
// Addressing Mode 4 - Load and Store Multiple
void Simulator::HandleRList(Instruction* instr, bool load) {
int rlist = instr->RlistValue();
int num_regs = count_bits(rlist);
intptr_t start_address = 0;
intptr_t end_address = 0;
int32_t rn_val =
ProcessPU(instr, num_regs, kPointerSize, &start_address, &end_address);
intptr_t* address = reinterpret_cast<intptr_t*>(start_address);
// Catch null pointers a little earlier.
DCHECK(start_address > 8191 || start_address < 0);
int reg = 0;
while (rlist != 0) {
if ((rlist & 1) != 0) {
if (load) {
set_register(reg, *address);
} else {
*address = get_register(reg);
}
address += 1;
}
reg++;
rlist >>= 1;
}
DCHECK(end_address == ((intptr_t)address) - 4);
if (instr->HasW()) {
set_register(instr->RnValue(), rn_val);
}
}
// Addressing Mode 6 - Load and Store Multiple Coprocessor registers.
void Simulator::HandleVList(Instruction* instr) {
VFPRegPrecision precision =
(instr->SzValue() == 0) ? kSinglePrecision : kDoublePrecision;
int operand_size = (precision == kSinglePrecision) ? 4 : 8;
bool load = (instr->VLValue() == 0x1);
int vd;
int num_regs;
vd = instr->VFPDRegValue(precision);
if (precision == kSinglePrecision) {
num_regs = instr->Immed8Value();
} else {
num_regs = instr->Immed8Value() / 2;
}
intptr_t start_address = 0;
intptr_t end_address = 0;
int32_t rn_val =
ProcessPU(instr, num_regs, operand_size, &start_address, &end_address);
intptr_t* address = reinterpret_cast<intptr_t*>(start_address);
for (int reg = vd; reg < vd + num_regs; reg++) {
if (precision == kSinglePrecision) {
if (load) {
set_s_register_from_sinteger(
reg, ReadW(reinterpret_cast<int32_t>(address), instr));
} else {
WriteW(reinterpret_cast<int32_t>(address),
get_sinteger_from_s_register(reg), instr);
}
address += 1;
} else {
if (load) {
int32_t data[] = {
ReadW(reinterpret_cast<int32_t>(address), instr),
ReadW(reinterpret_cast<int32_t>(address + 1), instr)
};
set_d_register(reg, reinterpret_cast<uint32_t*>(data));
} else {
uint32_t data[2];
get_d_register(reg, data);
WriteW(reinterpret_cast<int32_t>(address), data[0], instr);
WriteW(reinterpret_cast<int32_t>(address + 1), data[1], instr);
}
address += 2;
}
}
DCHECK(reinterpret_cast<intptr_t>(address) - operand_size == end_address);
if (instr->HasW()) {
set_register(instr->RnValue(), rn_val);
}
}
// Calls into the V8 runtime are based on this very simple interface.
// Note: To be able to return two values from some calls the code in runtime.cc
// uses the ObjectPair which is essentially two 32-bit values stuffed into a
// 64-bit value. With the code below we assume that all runtime calls return
// 64 bits of result. If they don't, the r1 result register contains a bogus
// value, which is fine because it is caller-saved.
typedef int64_t (*SimulatorRuntimeCall)(int32_t arg0, int32_t arg1,
int32_t arg2, int32_t arg3,
int32_t arg4, int32_t arg5,
int32_t arg6, int32_t arg7,
int32_t arg8);
// These prototypes handle the four types of FP calls.
typedef int64_t (*SimulatorRuntimeCompareCall)(double darg0, double darg1);
typedef double (*SimulatorRuntimeFPFPCall)(double darg0, double darg1);
typedef double (*SimulatorRuntimeFPCall)(double darg0);
typedef double (*SimulatorRuntimeFPIntCall)(double darg0, int32_t arg0);
// This signature supports direct call in to API function native callback
// (refer to InvocationCallback in v8.h).
typedef void (*SimulatorRuntimeDirectApiCall)(int32_t arg0);
typedef void (*SimulatorRuntimeProfilingApiCall)(int32_t arg0, void* arg1);
// This signature supports direct call to accessor getter callback.
typedef void (*SimulatorRuntimeDirectGetterCall)(int32_t arg0, int32_t arg1);
typedef void (*SimulatorRuntimeProfilingGetterCall)(
int32_t arg0, int32_t arg1, void* arg2);
// Software interrupt instructions are used by the simulator to call into the
// C-based V8 runtime.
void Simulator::SoftwareInterrupt(Instruction* instr) {
int svc = instr->SvcValue();
switch (svc) {
case kCallRtRedirected: {
// Check if stack is aligned. Error if not aligned is reported below to
// include information on the function called.
bool stack_aligned =
(get_register(sp)
& (::v8::internal::FLAG_sim_stack_alignment - 1)) == 0;
Redirection* redirection = Redirection::FromInstruction(instr);
int32_t arg0 = get_register(r0);
int32_t arg1 = get_register(r1);
int32_t arg2 = get_register(r2);
int32_t arg3 = get_register(r3);
int32_t* stack_pointer = reinterpret_cast<int32_t*>(get_register(sp));
int32_t arg4 = stack_pointer[0];
int32_t arg5 = stack_pointer[1];
int32_t arg6 = stack_pointer[2];
int32_t arg7 = stack_pointer[3];
int32_t arg8 = stack_pointer[4];
STATIC_ASSERT(kMaxCParameters == 9);
bool fp_call =
(redirection->type() == ExternalReference::BUILTIN_FP_FP_CALL) ||
(redirection->type() == ExternalReference::BUILTIN_COMPARE_CALL) ||
(redirection->type() == ExternalReference::BUILTIN_FP_CALL) ||
(redirection->type() == ExternalReference::BUILTIN_FP_INT_CALL);
// This is dodgy but it works because the C entry stubs are never moved.
// See comment in codegen-arm.cc and bug 1242173.
int32_t saved_lr = get_register(lr);
intptr_t external =
reinterpret_cast<intptr_t>(redirection->external_function());
if (fp_call) {
double dval0, dval1; // one or two double parameters
int32_t ival; // zero or one integer parameters
int64_t iresult = 0; // integer return value
double dresult = 0; // double return value
GetFpArgs(&dval0, &dval1, &ival);
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
SimulatorRuntimeCall generic_target =
reinterpret_cast<SimulatorRuntimeCall>(external);
switch (redirection->type()) {
case ExternalReference::BUILTIN_FP_FP_CALL:
case ExternalReference::BUILTIN_COMPARE_CALL:
PrintF("Call to host function at %p with args %f, %f",
reinterpret_cast<void*>(FUNCTION_ADDR(generic_target)),
dval0, dval1);
break;
case ExternalReference::BUILTIN_FP_CALL:
PrintF("Call to host function at %p with arg %f",
reinterpret_cast<void*>(FUNCTION_ADDR(generic_target)),
dval0);
break;
case ExternalReference::BUILTIN_FP_INT_CALL:
PrintF("Call to host function at %p with args %f, %d",
reinterpret_cast<void*>(FUNCTION_ADDR(generic_target)),
dval0, ival);
break;
default:
UNREACHABLE();
break;
}
if (!stack_aligned) {
PrintF(" with unaligned stack %08x\n", get_register(sp));
}
PrintF("\n");
}
CHECK(stack_aligned);
switch (redirection->type()) {
case ExternalReference::BUILTIN_COMPARE_CALL: {
SimulatorRuntimeCompareCall target =
reinterpret_cast<SimulatorRuntimeCompareCall>(external);
iresult = target(dval0, dval1);
set_register(r0, static_cast<int32_t>(iresult));
set_register(r1, static_cast<int32_t>(iresult >> 32));
break;
}
case ExternalReference::BUILTIN_FP_FP_CALL: {
SimulatorRuntimeFPFPCall target =
reinterpret_cast<SimulatorRuntimeFPFPCall>(external);
dresult = target(dval0, dval1);
SetFpResult(dresult);
break;
}
case ExternalReference::BUILTIN_FP_CALL: {
SimulatorRuntimeFPCall target =
reinterpret_cast<SimulatorRuntimeFPCall>(external);
dresult = target(dval0);
SetFpResult(dresult);
break;
}
case ExternalReference::BUILTIN_FP_INT_CALL: {
SimulatorRuntimeFPIntCall target =
reinterpret_cast<SimulatorRuntimeFPIntCall>(external);
dresult = target(dval0, ival);
SetFpResult(dresult);
break;
}
default:
UNREACHABLE();
break;
}
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
switch (redirection->type()) {
case ExternalReference::BUILTIN_COMPARE_CALL:
PrintF("Returned %08x\n", static_cast<int32_t>(iresult));
break;
case ExternalReference::BUILTIN_FP_FP_CALL:
case ExternalReference::BUILTIN_FP_CALL:
case ExternalReference::BUILTIN_FP_INT_CALL:
PrintF("Returned %f\n", dresult);
break;
default:
UNREACHABLE();
break;
}
}
} else if (redirection->type() == ExternalReference::DIRECT_API_CALL) {
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
PrintF("Call to host function at %p args %08x",
reinterpret_cast<void*>(external), arg0);
if (!stack_aligned) {
PrintF(" with unaligned stack %08x\n", get_register(sp));
}
PrintF("\n");
}
CHECK(stack_aligned);
SimulatorRuntimeDirectApiCall target =
reinterpret_cast<SimulatorRuntimeDirectApiCall>(external);
target(arg0);
} else if (
redirection->type() == ExternalReference::PROFILING_API_CALL) {
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
PrintF("Call to host function at %p args %08x %08x",
reinterpret_cast<void*>(external), arg0, arg1);
if (!stack_aligned) {
PrintF(" with unaligned stack %08x\n", get_register(sp));
}
PrintF("\n");
}
CHECK(stack_aligned);
SimulatorRuntimeProfilingApiCall target =
reinterpret_cast<SimulatorRuntimeProfilingApiCall>(external);
target(arg0, Redirection::ReverseRedirection(arg1));
} else if (
redirection->type() == ExternalReference::DIRECT_GETTER_CALL) {
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
PrintF("Call to host function at %p args %08x %08x",
reinterpret_cast<void*>(external), arg0, arg1);
if (!stack_aligned) {
PrintF(" with unaligned stack %08x\n", get_register(sp));
}
PrintF("\n");
}
CHECK(stack_aligned);
SimulatorRuntimeDirectGetterCall target =
reinterpret_cast<SimulatorRuntimeDirectGetterCall>(external);
target(arg0, arg1);
} else if (
redirection->type() == ExternalReference::PROFILING_GETTER_CALL) {
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
PrintF("Call to host function at %p args %08x %08x %08x",
reinterpret_cast<void*>(external), arg0, arg1, arg2);
if (!stack_aligned) {
PrintF(" with unaligned stack %08x\n", get_register(sp));
}
PrintF("\n");
}
CHECK(stack_aligned);
SimulatorRuntimeProfilingGetterCall target =
reinterpret_cast<SimulatorRuntimeProfilingGetterCall>(
external);
target(arg0, arg1, Redirection::ReverseRedirection(arg2));
} else {
// builtin call.
DCHECK(redirection->type() == ExternalReference::BUILTIN_CALL ||
redirection->type() == ExternalReference::BUILTIN_CALL_PAIR);
SimulatorRuntimeCall target =
reinterpret_cast<SimulatorRuntimeCall>(external);
if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
PrintF(
"Call to host function at %p "
"args %08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x",
reinterpret_cast<void*>(FUNCTION_ADDR(target)), arg0, arg1, arg2,
arg3, arg4, arg5, arg6, arg7, arg8);
if (!stack_aligned) {
PrintF(" with unaligned stack %08x\n", get_register(sp));
}
PrintF("\n");
}
CHECK(stack_aligned);
int64_t result =
target(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
int32_t lo_res = static_cast<int32_t>(result);
int32_t hi_res = static_cast<int32_t>(result >> 32);
if (::v8::internal::FLAG_trace_sim) {
PrintF("Returned %08x\n", lo_res);
}
set_register(r0, lo_res);
set_register(r1, hi_res);
}
set_register(lr, saved_lr);
set_pc(get_register(lr));
break;
}
case kBreakpoint: {
ArmDebugger dbg(this);
dbg.Debug();
break;
}
// stop uses all codes greater than 1 << 23.
default: {
if (svc >= (1 << 23)) {
uint32_t code = svc & kStopCodeMask;
if (isWatchedStop(code)) {
IncreaseStopCounter(code);
}
// Stop if it is enabled, otherwise go on jumping over the stop
// and the message address.
if (isEnabledStop(code)) {
ArmDebugger dbg(this);
dbg.Stop(instr);
}
} else {
// This is not a valid svc code.
UNREACHABLE();
break;
}
}
}
}
float Simulator::canonicalizeNaN(float value) {
// Default NaN value, see "NaN handling" in "IEEE 754 standard implementation
// choices" of the ARM Reference Manual.
constexpr uint32_t kDefaultNaN = 0x7FC00000u;
if (FPSCR_default_NaN_mode_ && std::isnan(value)) {
value = bit_cast<float>(kDefaultNaN);
}
return value;
}
Float32 Simulator::canonicalizeNaN(Float32 value) {
// Default NaN value, see "NaN handling" in "IEEE 754 standard implementation
// choices" of the ARM Reference Manual.
constexpr Float32 kDefaultNaN = Float32::FromBits(0x7FC00000u);
return FPSCR_default_NaN_mode_ && value.is_nan() ? kDefaultNaN : value;
}
double Simulator::canonicalizeNaN(double value) {
// Default NaN value, see "NaN handling" in "IEEE 754 standard implementation
// choices" of the ARM Reference Manual.
constexpr uint64_t kDefaultNaN = uint64_t{0x7FF8000000000000};
if (FPSCR_default_NaN_mode_ && std::isnan(value)) {
value = bit_cast<double>(kDefaultNaN);
}
return value;
}
Float64 Simulator::canonicalizeNaN(Float64 value) {
// Default NaN value, see "NaN handling" in "IEEE 754 standard implementation
// choices" of the ARM Reference Manual.
constexpr Float64 kDefaultNaN =
Float64::FromBits(uint64_t{0x7FF8000000000000});
return FPSCR_default_NaN_mode_ && value.is_nan() ? kDefaultNaN : value;
}
// Stop helper functions.
bool Simulator::isStopInstruction(Instruction* instr) {
return (instr->Bits(27, 24) == 0xF) && (instr->SvcValue() >= kStopCode);
}
bool Simulator::isWatchedStop(uint32_t code) {
DCHECK_LE(code, kMaxStopCode);
return code < kNumOfWatchedStops;
}
bool Simulator::isEnabledStop(uint32_t code) {
DCHECK_LE(code, kMaxStopCode);
// Unwatched stops are always enabled.
return !isWatchedStop(code) ||
!(watched_stops_[code].count & kStopDisabledBit);
}
void Simulator::EnableStop(uint32_t code) {
DCHECK(isWatchedStop(code));
if (!isEnabledStop(code)) {
watched_stops_[code].count &= ~kStopDisabledBit;
}
}
void Simulator::DisableStop(uint32_t code) {
DCHECK(isWatchedStop(code));
if (isEnabledStop(code)) {
watched_stops_[code].count |= kStopDisabledBit;
}
}
void Simulator::IncreaseStopCounter(uint32_t code) {
DCHECK_LE(code, kMaxStopCode);
DCHECK(isWatchedStop(code));
if ((watched_stops_[code].count & ~(1 << 31)) == 0x7FFFFFFF) {
PrintF("Stop counter for code %i has overflowed.\n"
"Enabling this code and reseting the counter to 0.\n", code);
watched_stops_[code].count = 0;
EnableStop(code);
} else {
watched_stops_[code].count++;
}
}
// Print a stop status.
void Simulator::PrintStopInfo(uint32_t code) {
DCHECK_LE(code, kMaxStopCode);
if (!isWatchedStop(code)) {
PrintF("Stop not watched.");
} else {
const char* state = isEnabledStop(code) ? "Enabled" : "Disabled";
int32_t count = watched_stops_[code].count & ~kStopDisabledBit;
// Don't print the state of unused breakpoints.
if (count != 0) {
if (watched_stops_[code].desc) {
PrintF("stop %i - 0x%x: \t%s, \tcounter = %i, \t%s\n",
code, code, state, count, watched_stops_[code].desc);
} else {
PrintF("stop %i - 0x%x: \t%s, \tcounter = %i\n",
code, code, state, count);
}
}
}
}
// Handle execution based on instruction types.
// Instruction types 0 and 1 are both rolled into one function because they
// only differ in the handling of the shifter_operand.
void Simulator::DecodeType01(Instruction* instr) {
int type = instr->TypeValue();
if ((type == 0) && instr->IsSpecialType0()) {
// multiply instruction or extra loads and stores
if (instr->Bits(7, 4) == 9) {
if (instr->Bit(24) == 0) {
// Raw field decoding here. Multiply instructions have their Rd in
// funny places.
int rn = instr->RnValue();
int rm = instr->RmValue();
int rs = instr->RsValue();
int32_t rs_val = get_register(rs);
int32_t rm_val = get_register(rm);
if (instr->Bit(23) == 0) {
if (instr->Bit(21) == 0) {
// The MUL instruction description (A 4.1.33) refers to Rd as being
// the destination for the operation, but it confusingly uses the
// Rn field to encode it.
// Format(instr, "mul'cond's 'rn, 'rm, 'rs");
int rd = rn; // Remap the rn field to the Rd register.
int32_t alu_out = rm_val * rs_val;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
}
} else {
int rd = instr->RdValue();
int32_t acc_value = get_register(rd);
if (instr->Bit(22) == 0) {
// The MLA instruction description (A 4.1.28) refers to the order
// of registers as "Rd, Rm, Rs, Rn". But confusingly it uses the
// Rn field to encode the Rd register and the Rd field to encode
// the Rn register.
// Format(instr, "mla'cond's 'rn, 'rm, 'rs, 'rd");
int32_t mul_out = rm_val * rs_val;
int32_t result = acc_value + mul_out;
set_register(rn, result);
} else {
// Format(instr, "mls'cond's 'rn, 'rm, 'rs, 'rd");
int32_t mul_out = rm_val * rs_val;
int32_t result = acc_value - mul_out;
set_register(rn, result);
}
}
} else {
// The signed/long multiply instructions use the terms RdHi and RdLo
// when referring to the target registers. They are mapped to the Rn
// and Rd fields as follows:
// RdLo == Rd
// RdHi == Rn (This is confusingly stored in variable rd here
// because the mul instruction from above uses the
// Rn field to encode the Rd register. Good luck figuring
// this out without reading the ARM instruction manual
// at a very detailed level.)
// Format(instr, "'um'al'cond's 'rd, 'rn, 'rs, 'rm");
int rd_hi = rn; // Remap the rn field to the RdHi register.
int rd_lo = instr->RdValue();
int32_t hi_res = 0;
int32_t lo_res = 0;
if (instr->Bit(22) == 1) {
int64_t left_op = static_cast<int32_t>(rm_val);
int64_t right_op = static_cast<int32_t>(rs_val);
uint64_t result = left_op * right_op;
hi_res = static_cast<int32_t>(result >> 32);
lo_res = static_cast<int32_t>(result & 0xFFFFFFFF);
} else {
// unsigned multiply
uint64_t left_op = static_cast<uint32_t>(rm_val);
uint64_t right_op = static_cast<uint32_t>(rs_val);
uint64_t result = left_op * right_op;
hi_res = static_cast<int32_t>(result >> 32);
lo_res = static_cast<int32_t>(result & 0xFFFFFFFF);
}
set_register(rd_lo, lo_res);
set_register(rd_hi, hi_res);
if (instr->HasS()) {
UNIMPLEMENTED();
}
}
} else {
if (instr->Bits(24, 23) == 3) {
if (instr->Bit(20) == 1) {
// ldrex
int rt = instr->RtValue();
int rn = instr->RnValue();
int32_t addr = get_register(rn);
switch (instr->Bits(22, 21)) {
case 0: {
// Format(instr, "ldrex'cond 'rt, ['rn]");
int value = ReadExW(addr, instr);
set_register(rt, value);
break;
}
case 2: {
// Format(instr, "ldrexb'cond 'rt, ['rn]");
uint8_t value = ReadExBU(addr);
set_register(rt, value);
break;
}
case 3: {
// Format(instr, "ldrexh'cond 'rt, ['rn]");
uint16_t value = ReadExHU(addr, instr);
set_register(rt, value);
break;
}
default:
UNREACHABLE();
break;
}
} else {
// The instruction is documented as strex rd, rt, [rn], but the
// "rt" register is using the rm bits.
int rd = instr->RdValue();
int rt = instr->RmValue();
int rn = instr->RnValue();
DCHECK_NE(rd, rn);
DCHECK_NE(rd, rt);
int32_t addr = get_register(rn);
switch (instr->Bits(22, 21)) {
case 0: {
// Format(instr, "strex'cond 'rd, 'rm, ['rn]");
int value = get_register(rt);
int status = WriteExW(addr, value, instr);
set_register(rd, status);
break;
}
case 2: {
// Format(instr, "strexb'cond 'rd, 'rm, ['rn]");
uint8_t value = get_register(rt);
int status = WriteExB(addr, value);
set_register(rd, status);
break;
}
case 3: {
// Format(instr, "strexh'cond 'rd, 'rm, ['rn]");
uint16_t value = get_register(rt);
int status = WriteExH(addr, value, instr);
set_register(rd, status);
break;
}
default:
UNREACHABLE();
break;
}
}
} else {
UNIMPLEMENTED(); // Not used by V8.
}
}
} else {
// extra load/store instructions
int rd = instr->RdValue();
int rn = instr->RnValue();
int32_t rn_val = get_register(rn);
int32_t addr = 0;
if (instr->Bit(22) == 0) {
int rm = instr->RmValue();
int32_t rm_val = get_register(rm);
switch (instr->PUField()) {
case da_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn], -'rm");
DCHECK(!instr->HasW());
addr = rn_val;
rn_val -= rm_val;
set_register(rn, rn_val);
break;
}
case ia_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn], +'rm");
DCHECK(!instr->HasW());
addr = rn_val;
rn_val += rm_val;
set_register(rn, rn_val);
break;
}
case db_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn, -'rm]'w");
rn_val -= rm_val;
addr = rn_val;
if (instr->HasW()) {
set_register(rn, rn_val);
}
break;
}
case ib_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn, +'rm]'w");
rn_val += rm_val;
addr = rn_val;
if (instr->HasW()) {
set_register(rn, rn_val);
}
break;
}
default: {
// The PU field is a 2-bit field.
UNREACHABLE();
break;
}
}
} else {
int32_t imm_val = (instr->ImmedHValue() << 4) | instr->ImmedLValue();
switch (instr->PUField()) {
case da_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn], #-'off8");
DCHECK(!instr->HasW());
addr = rn_val;
rn_val -= imm_val;
set_register(rn, rn_val);
break;
}
case ia_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn], #+'off8");
DCHECK(!instr->HasW());
addr = rn_val;
rn_val += imm_val;
set_register(rn, rn_val);
break;
}
case db_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn, #-'off8]'w");
rn_val -= imm_val;
addr = rn_val;
if (instr->HasW()) {
set_register(rn, rn_val);
}
break;
}
case ib_x: {
// Format(instr, "'memop'cond'sign'h 'rd, ['rn, #+'off8]'w");
rn_val += imm_val;
addr = rn_val;
if (instr->HasW()) {
set_register(rn, rn_val);
}
break;
}
default: {
// The PU field is a 2-bit field.
UNREACHABLE();
break;
}
}
}
if (((instr->Bits(7, 4) & 0xD) == 0xD) && (instr->Bit(20) == 0)) {
DCHECK_EQ(rd % 2, 0);
if (instr->HasH()) {
// The strd instruction.
int32_t value1 = get_register(rd);
int32_t value2 = get_register(rd+1);
WriteDW(addr, value1, value2);
} else {
// The ldrd instruction.
int* rn_data = ReadDW(addr);
set_dw_register(rd, rn_data);
}
} else if (instr->HasH()) {
if (instr->HasSign()) {
if (instr->HasL()) {
int16_t val = ReadH(addr, instr);
set_register(rd, val);
} else {
int16_t val = get_register(rd);
WriteH(addr, val, instr);
}
} else {
if (instr->HasL()) {
uint16_t val = ReadHU(addr, instr);
set_register(rd, val);
} else {
uint16_t val = get_register(rd);
WriteH(addr, val, instr);
}
}
} else {
// signed byte loads
DCHECK(instr->HasSign());
DCHECK(instr->HasL());
int8_t val = ReadB(addr);
set_register(rd, val);
}
return;
}
} else if ((type == 0) && instr->IsMiscType0()) {
if ((instr->Bits(27, 23) == 2) && (instr->Bits(21, 20) == 2) &&
(instr->Bits(15, 4) == 0xF00)) {
// MSR
int rm = instr->RmValue();
DCHECK_NE(pc, rm); // UNPREDICTABLE
SRegisterFieldMask sreg_and_mask =
instr->BitField(22, 22) | instr->BitField(19, 16);
SetSpecialRegister(sreg_and_mask, get_register(rm));
} else if ((instr->Bits(27, 23) == 2) && (instr->Bits(21, 20) == 0) &&
(instr->Bits(11, 0) == 0)) {
// MRS
int rd = instr->RdValue();
DCHECK_NE(pc, rd); // UNPREDICTABLE
SRegister sreg = static_cast<SRegister>(instr->BitField(22, 22));
set_register(rd, GetFromSpecialRegister(sreg));
} else if (instr->Bits(22, 21) == 1) {
int rm = instr->RmValue();
switch (instr->BitField(7, 4)) {
case BX:
set_pc(get_register(rm));
break;
case BLX: {
uint32_t old_pc = get_pc();
set_pc(get_register(rm));
set_register(lr, old_pc + Instruction::kInstrSize);
break;
}
case BKPT: {
ArmDebugger dbg(this);
PrintF("Simulator hit BKPT.\n");
dbg.Debug();
break;
}
default:
UNIMPLEMENTED();
}
} else if (instr->Bits(22, 21) == 3) {
int rm = instr->RmValue();
int rd = instr->RdValue();
switch (instr->BitField(7, 4)) {
case CLZ: {
uint32_t bits = get_register(rm);
int leading_zeros = 0;
if (bits == 0) {
leading_zeros = 32;
} else {
while ((bits & 0x80000000u) == 0) {
bits <<= 1;
leading_zeros++;
}
}
set_register(rd, leading_zeros);
break;
}
default:
UNIMPLEMENTED();
}
} else {
PrintF("%08x\n", instr->InstructionBits());
UNIMPLEMENTED();
}
} else if ((type == 1) && instr->IsNopLikeType1()) {
if (instr->BitField(7, 0) == 0) {
// NOP.
} else if (instr->BitField(7, 0) == 20) {
// CSDB.
} else {
PrintF("%08x\n", instr->InstructionBits());
UNIMPLEMENTED();
}
} else {
int rd = instr->RdValue();
int rn = instr->RnValue();
int32_t rn_val = get_register(rn);
int32_t shifter_operand = 0;
bool shifter_carry_out = 0;
if (type == 0) {
shifter_operand = GetShiftRm(instr, &shifter_carry_out);
} else {
DCHECK_EQ(instr->TypeValue(), 1);
shifter_operand = GetImm(instr, &shifter_carry_out);
}
int32_t alu_out;
switch (instr->OpcodeField()) {
case AND: {
// Format(instr, "and'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "and'cond's 'rd, 'rn, 'imm");
alu_out = rn_val & shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
}
break;
}
case EOR: {
// Format(instr, "eor'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "eor'cond's 'rd, 'rn, 'imm");
alu_out = rn_val ^ shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
}
break;
}
case SUB: {
// Format(instr, "sub'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "sub'cond's 'rd, 'rn, 'imm");
alu_out = rn_val - shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(!BorrowFrom(rn_val, shifter_operand));
SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
}
break;
}
case RSB: {
// Format(instr, "rsb'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "rsb'cond's 'rd, 'rn, 'imm");
alu_out = shifter_operand - rn_val;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(!BorrowFrom(shifter_operand, rn_val));
SetVFlag(OverflowFrom(alu_out, shifter_operand, rn_val, false));
}
break;
}
case ADD: {
// Format(instr, "add'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "add'cond's 'rd, 'rn, 'imm");
alu_out = rn_val + shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(CarryFrom(rn_val, shifter_operand));
SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
}
break;
}
case ADC: {
// Format(instr, "adc'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "adc'cond's 'rd, 'rn, 'imm");
alu_out = rn_val + shifter_operand + GetCarry();
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(CarryFrom(rn_val, shifter_operand, GetCarry()));
SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
}
break;
}
case SBC: {
// Format(instr, "sbc'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "sbc'cond's 'rd, 'rn, 'imm");
alu_out = (rn_val - shifter_operand) - (GetCarry() ? 0 : 1);
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(!BorrowFrom(rn_val, shifter_operand, GetCarry()));
SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
}
break;
}
case RSC: {
Format(instr, "rsc'cond's 'rd, 'rn, 'shift_rm");
Format(instr, "rsc'cond's 'rd, 'rn, 'imm");
break;
}
case TST: {
if (instr->HasS()) {
// Format(instr, "tst'cond 'rn, 'shift_rm");
// Format(instr, "tst'cond 'rn, 'imm");
alu_out = rn_val & shifter_operand;
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
} else {
// Format(instr, "movw'cond 'rd, 'imm").
alu_out = instr->ImmedMovwMovtValue();
set_register(rd, alu_out);
}
break;
}
case TEQ: {
if (instr->HasS()) {
// Format(instr, "teq'cond 'rn, 'shift_rm");
// Format(instr, "teq'cond 'rn, 'imm");
alu_out = rn_val ^ shifter_operand;
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
} else {
// Other instructions matching this pattern are handled in the
// miscellaneous instructions part above.
UNREACHABLE();
}
break;
}
case CMP: {
if (instr->HasS()) {
// Format(instr, "cmp'cond 'rn, 'shift_rm");
// Format(instr, "cmp'cond 'rn, 'imm");
alu_out = rn_val - shifter_operand;
SetNZFlags(alu_out);
SetCFlag(!BorrowFrom(rn_val, shifter_operand));
SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
} else {
// Format(instr, "movt'cond 'rd, 'imm").
alu_out =
(get_register(rd) & 0xFFFF) | (instr->ImmedMovwMovtValue() << 16);
set_register(rd, alu_out);
}
break;
}
case CMN: {
if (instr->HasS()) {
// Format(instr, "cmn'cond 'rn, 'shift_rm");
// Format(instr, "cmn'cond 'rn, 'imm");
alu_out = rn_val + shifter_operand;
SetNZFlags(alu_out);
SetCFlag(CarryFrom(rn_val, shifter_operand));
SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
} else {
// Other instructions matching this pattern are handled in the
// miscellaneous instructions part above.
UNREACHABLE();
}
break;
}
case ORR: {
// Format(instr, "orr'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "orr'cond's 'rd, 'rn, 'imm");
alu_out = rn_val | shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
}
break;
}
case MOV: {
// Format(instr, "mov'cond's 'rd, 'shift_rm");
// Format(instr, "mov'cond's 'rd, 'imm");
alu_out = shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
}
break;
}
case BIC: {
// Format(instr, "bic'cond's 'rd, 'rn, 'shift_rm");
// Format(instr, "bic'cond's 'rd, 'rn, 'imm");
alu_out = rn_val & ~shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
}
break;
}
case MVN: {
// Format(instr, "mvn'cond's 'rd, 'shift_rm");
// Format(instr, "mvn'cond's 'rd, 'imm");
alu_out = ~shifter_operand;
set_register(rd, alu_out);
if (instr->HasS()) {
SetNZFlags(alu_out);
SetCFlag(shifter_carry_out);
}
break;
}
default: {
UNREACHABLE();
break;
}
}
}
}
void Simulator::DecodeType2(Instruction* instr) {
int rd = instr->RdValue();
int rn = instr->RnValue();
int32_t rn_val = get_register(rn);
int32_t im_val = instr->Offset12Value();
int32_t addr = 0;
switch (instr->PUField()) {
case da_x: {
// Format(instr, "'memop'cond'b 'rd, ['rn], #-'off12");
DCHECK(!instr->HasW());
addr = rn_val;
rn_val -= im_val;
set_register(rn, rn_val);
break;
}
case ia_x: {
// Format(instr, "'memop'cond'b 'rd, ['rn], #+'off12");
DCHECK(!instr->HasW());
addr = rn_val;
rn_val += im_val;
set_register(rn, rn_val);
break;
}
case db_x: {
// Format(instr, "'memop'cond'b 'rd, ['rn, #-'off12]'w");
rn_val -= im_val;
addr = rn_val;
if (instr->HasW()) {
set_register(rn, rn_val);
}
break;
}
case ib_x: {
// Format(instr, "'memop'cond'b 'rd, ['rn, #+'off12]'w");
rn_val += im_val;
addr = rn_val;
if (instr->HasW()) {
set_register(rn, rn_val);
}
break;
}
default: {
UNREACHABLE();
break;
}
}
if (instr->HasB()) {
if (instr->HasL()) {
byte val = ReadBU(addr);
set_register(rd, val);
} else {
byte val = get_register(rd);
WriteB(addr, val);
}
} else {
if (instr->HasL()) {
set_register(rd, ReadW(addr, instr));
} else {
WriteW(addr, get_register(rd), instr);
}
}
}
void Simulator::DecodeType3(Instruction* instr) {
int rd = instr->RdValue();
int rn = instr->RnValue();
int32_t rn_val = get_register(rn);
bool shifter_carry_out = 0;
int32_t shifter_operand = GetShiftRm(instr, &shifter_carry_out);
int32_t addr = 0;
switch (instr->PUField()) {
case da_x: {
DCHECK(!instr->HasW());
Format(instr, "'memop'cond'b 'rd, ['rn], -'shift_rm");
UNIMPLEMENTED();
break;
}
case ia_x: {
if (instr->Bit(4) == 0) {
// Memop.
} else {
if (instr->Bit(5) == 0) {
switch (instr->Bits(22, 21)) {
case 0:
if (instr->Bit(20) == 0) {
if (instr->Bit(6) == 0) {
// Pkhbt.
uint32_t rn_val = get_register(rn);
uint32_t rm_val = get_register(instr->RmValue());
int32_t shift = instr->Bits(11, 7);
rm_val <<= shift;
set_register(rd, (rn_val & 0xFFFF) | (rm_val & 0xFFFF0000U));
} else {
// Pkhtb.
uint32_t rn_val = get_register(rn);
int32_t rm_val = get_register(instr->RmValue());
int32_t shift = instr->Bits(11, 7);
if (shift == 0) {
shift = 32;
}
rm_val >>= shift;
set_register(rd, (rn_val & 0xFFFF0000U) | (rm_val & 0xFFFF));
}
} else {
UNIMPLEMENTED();
}
break;
case 1:
UNIMPLEMENTED();
break;
case 2:
UNIMPLEMENTED();
break;
case 3: {
// Usat.
int32_t sat_pos = instr->Bits(20, 16);
int32_t sat_val = (1 << sat_pos) - 1;
int32_t shift = instr->Bits(11, 7);
int32_t shift_type = instr->Bit(6);
int32_t rm_val = get_register(instr->RmValue());
if (shift_type == 0) { // LSL
rm_val <<= shift;
} else { // ASR
rm_val >>= shift;
}
// If saturation occurs, the Q flag should be set in the CPSR.
// There is no Q flag yet, and no instruction (MRS) to read the
// CPSR directly.
if (rm_val > sat_val) {
rm_val = sat_val;
} else if (rm_val < 0) {
rm_val = 0;
}
set_register(rd, rm_val);
break;
}
}
} else {
switch (instr->Bits(22, 21)) {
case 0:
UNIMPLEMENTED();
break;
case 1:
if (instr->Bits(9, 6) == 1) {
if (instr->Bit(20) == 0) {
if (instr->Bits(19, 16) == 0xF) {
// Sxtb.
int32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, static_cast<int8_t>(rm_val));
} else {
// Sxtab.
int32_t rn_val = get_register(rn);
int32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, rn_val + static_cast<int8_t>(rm_val));
}
} else {
if (instr->Bits(19, 16) == 0xF) {
// Sxth.
int32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, static_cast<int16_t>(rm_val));
} else {
// Sxtah.
int32_t rn_val = get_register(rn);
int32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, rn_val + static_cast<int16_t>(rm_val));
}
}
} else {
UNREACHABLE();
}
break;
case 2:
if ((instr->Bit(20) == 0) && (instr->Bits(9, 6) == 1)) {
if (instr->Bits(19, 16) == 0xF) {
// Uxtb16.
uint32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, (rm_val & 0xFF) | (rm_val & 0xFF0000));
} else {
UNIMPLEMENTED();
}
} else {
UNIMPLEMENTED();
}
break;
case 3:
if ((instr->Bits(9, 6) == 1)) {
if (instr->Bit(20) == 0) {
if (instr->Bits(19, 16) == 0xF) {
// Uxtb.
uint32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, (rm_val & 0xFF));
} else {
// Uxtab.
uint32_t rn_val = get_register(rn);
uint32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, rn_val + (rm_val & 0xFF));
}
} else {
if (instr->Bits(19, 16) == 0xF) {
// Uxth.
uint32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, (rm_val & 0xFFFF));
} else {
// Uxtah.
uint32_t rn_val = get_register(rn);
uint32_t rm_val = get_register(instr->RmValue());
int32_t rotate = instr->Bits(11, 10);
switch (rotate) {
case 0:
break;
case 1:
rm_val = (rm_val >> 8) | (rm_val << 24);
break;
case 2:
rm_val = (rm_val >> 16) | (rm_val << 16);
break;
case 3:
rm_val = (rm_val >> 24) | (rm_val << 8);
break;
}
set_register(rd, rn_val + (rm_val & 0xFFFF));
}
}
} else {
// PU == 0b01, BW == 0b11, Bits(9, 6) != 0b0001
if ((instr->Bits(20, 16) == 0x1F) &&
(instr->Bits(11, 4) == 0xF3)) {
// Rbit.
uint32_t rm_val = get_register(instr->RmValue());
set_register(rd, base::bits::ReverseBits(rm_val));
} else {
UNIMPLEMENTED();
}
}
break;
}
}
return;
}
break;
}
case db_x: {
if (instr->Bits(22, 20) == 0x5) {
if (instr->Bits(7, 4) == 0x1) {
int rm = instr->RmValue();
int32_t rm_val = get_register(rm);
int rs = instr->RsValue();
int32_t rs_val = get_register(rs);
if (instr->Bits(15, 12) == 0xF) {
// SMMUL (in V8 notation matching ARM ISA format)
// Format(instr, "smmul'cond 'rn, 'rm, 'rs");
rn_val = base::bits::SignedMulHigh32(rm_val, rs_val);
} else {
// SMMLA (in V8 notation matching ARM ISA format)
// Format(instr, "smmla'cond 'rn, 'rm, 'rs, 'rd");
int rd = instr->RdValue();
int32_t rd_val = get_register(rd);
rn_val = base::bits::SignedMulHighAndAdd32(rm_val, rs_val, rd_val);
}
set_register(rn, rn_val);
return;
}
}
if (instr->Bits(5, 4) == 0x1) {
if ((instr->Bit(22) == 0x0) && (instr->Bit(20) == 0x1)) {
// (s/u)div (in V8 notation matching ARM ISA format) rn = rm/rs
// Format(instr, "'(s/u)div'cond'b 'rn, 'rm, 'rs);
int rm = instr->RmValue();
int32_t rm_val = get_register(rm);
int rs = instr->RsValue();
int32_t rs_val = get_register(rs);
int32_t ret_val = 0;
// udiv
if (instr->Bit(21) == 0x1) {
ret_val = bit_cast<int32_t>(base::bits::UnsignedDiv32(
bit_cast<uint32_t>(rm_val), bit_cast<uint32_t>(rs_val)));
} else {
ret_val = base::bits::SignedDiv32(rm_val, rs_val);
}
set_register(rn, ret_val);
return;
}
}
// Format(instr, "'memop'cond'b 'rd, ['rn, -'shift_rm]'w");
addr = rn_val - shifter_operand;
if (instr->HasW()) {
set_register(rn, addr);
}
break;
}
case ib_x: {
if (instr->HasW() && (instr->Bits(6, 4) == 0x5)) {
uint32_t widthminus1 = static_cast<uint32_t>(instr->Bits(20, 16));
uint32_t lsbit = static_cast<uint32_t>(instr->Bits(11, 7));
uint32_t msbit = widthminus1 + lsbit;
if (msbit <= 31) {
if (instr->Bit(22)) {
// ubfx - unsigned bitfield extract.
uint32_t rm_val =
static_cast<uint32_t>(get_register(instr->RmValue()));
uint32_t extr_val = rm_val << (31 - msbit);
extr_val = extr_val >> (31 - widthminus1);
set_register(instr->RdValue(), extr_val);
} else {
// sbfx - signed bitfield extract.
int32_t rm_val = get_register(instr->RmValue());
int32_t extr_val = rm_val << (31 - msbit);
extr_val = extr_val >> (31 - widthminus1);
set_register(instr->RdValue(), extr_val);
}
} else {
UNREACHABLE();
}
return;
} else if (!instr->HasW() && (instr->Bits(6, 4) == 0x1)) {
uint32_t lsbit = static_cast<uint32_t>(instr->Bits(11, 7));
uint32_t msbit = static_cast<uint32_t>(instr->Bits(20, 16));
if (msbit >= lsbit) {
// bfc or bfi - bitfield clear/insert.
uint32_t rd_val =
static_cast<uint32_t>(get_register(instr->RdValue()));
uint32_t bitcount = msbit - lsbit + 1;
uint32_t mask = 0xFFFFFFFFu >> (32 - bitcount);
rd_val &= ~(mask << lsbit);
if (instr->RmValue() != 15) {
// bfi - bitfield insert.
uint32_t rm_val =
static_cast<uint32_t>(get_register(instr->RmValue()));
rm_val &= mask;
rd_val |= rm_val << lsbit;
}
set_register(instr->RdValue(), rd_val);
} else {
UNREACHABLE();
}
return;
} else {
// Format(instr, "'memop'cond'b 'rd, ['rn, +'shift_rm]'w");
addr = rn_val + shifter_operand;
if (instr->HasW()) {
set_register(rn, addr);
}
}
break;
}
default: {
UNREACHABLE();
break;
}
}
if (instr->HasB()) {
if (instr->HasL()) {
uint8_t byte = ReadB(addr);
set_register(rd, byte);
} else {
uint8_t byte = get_register(rd);
WriteB(addr, byte);
}
} else {
if (instr->HasL()) {
set_register(rd, ReadW(addr, instr));
} else {
WriteW(addr, get_register(rd), instr);
}
}
}
void Simulator::DecodeType4(Instruction* instr) {
DCHECK_EQ(instr->Bit(22), 0); // only allowed to be set in privileged mode
if (instr->HasL()) {
// Format(instr, "ldm'cond'pu 'rn'w, 'rlist");
HandleRList(instr, true);
} else {
// Format(instr, "stm'cond'pu 'rn'w, 'rlist");
HandleRList(instr, false);
}
}
void Simulator::DecodeType5(Instruction* instr) {
// Format(instr, "b'l'cond 'target");
int off = (instr->SImmed24Value() << 2);
intptr_t pc_address = get_pc();
if (instr->HasLink()) {
set_register(lr, pc_address + Instruction::kInstrSize);
}
int pc_reg = get_register(pc);
set_pc(pc_reg + off);
}
void Simulator::DecodeType6(Instruction* instr) {
DecodeType6CoprocessorIns(instr);
}
void Simulator::DecodeType7(Instruction* instr) {
if (instr->Bit(24) == 1) {
SoftwareInterrupt(instr);
} else {
switch (instr->CoprocessorValue()) {
case 10: // Fall through.
case 11:
DecodeTypeVFP(instr);
break;
case 15:
DecodeTypeCP15(instr);
break;
default:
UNIMPLEMENTED();
}
}
}
// void Simulator::DecodeTypeVFP(Instruction* instr)
// The Following ARMv7 VFPv instructions are currently supported.
// vmov :Sn = Rt
// vmov :Rt = Sn
// vcvt: Dd = Sm
// vcvt: Sd = Dm
// vcvt.f64.s32 Dd, Dd, #<fbits>
// Dd = vabs(Dm)
// Sd = vabs(Sm)
// Dd = vneg(Dm)
// Sd = vneg(Sm)
// Dd = vadd(Dn, Dm)
// Sd = vadd(Sn, Sm)
// Dd = vsub(Dn, Dm)
// Sd = vsub(Sn, Sm)
// Dd = vmul(Dn, Dm)
// Sd = vmul(Sn, Sm)
// Dd = vdiv(Dn, Dm)
// Sd = vdiv(Sn, Sm)
// vcmp(Dd, Dm)
// vcmp(Sd, Sm)
// Dd = vsqrt(Dm)
// Sd = vsqrt(Sm)
// vmrs
// vdup.size Qd, Rt.
void Simulator::DecodeTypeVFP(Instruction* instr) {
DCHECK((instr->TypeValue() == 7) && (instr->Bit(24) == 0x0) );
DCHECK_EQ(instr->Bits(11, 9), 0x5);
// Obtain single precision register codes.
int m = instr->VFPMRegValue(kSinglePrecision);
int d = instr->VFPDRegValue(kSinglePrecision);
int n = instr->VFPNRegValue(kSinglePrecision);
// Obtain double precision register codes.
int vm = instr->VFPMRegValue(kDoublePrecision);
int vd = instr->VFPDRegValue(kDoublePrecision);
int vn = instr->VFPNRegValue(kDoublePrecision);
if (instr->Bit(4) == 0) {
if (instr->Opc1Value() == 0x7) {
// Other data processing instructions
if ((instr->Opc2Value() == 0x0) && (instr->Opc3Value() == 0x1)) {
// vmov register to register.
if (instr->SzValue() == 0x1) {
uint32_t data[2];
get_d_register(vm, data);
set_d_register(vd, data);
} else {
set_s_register(d, get_s_register(m));
}
} else if ((instr->Opc2Value() == 0x0) && (instr->Opc3Value() == 0x3)) {
// vabs
if (instr->SzValue() == 0x1) {
Float64 dm = get_double_from_d_register(vm);
constexpr uint64_t kSignBit64 = uint64_t{1} << 63;
Float64 dd = Float64::FromBits(dm.get_bits() & ~kSignBit64);
dd = canonicalizeNaN(dd);
set_d_register_from_double(vd, dd);
} else {
Float32 sm = get_float_from_s_register(m);
constexpr uint32_t kSignBit32 = uint32_t{1} << 31;
Float32 sd = Float32::FromBits(sm.get_bits() & ~kSignBit32);
sd = canonicalizeNaN(sd);
set_s_register_from_float(d, sd);
}
} else if ((instr->Opc2Value() == 0x1) && (instr->Opc3Value() == 0x1)) {
// vneg
if (instr->SzValue() == 0x1) {
Float64 dm = get_double_from_d_register(vm);
constexpr uint64_t kSignBit64 = uint64_t{1} << 63;
Float64 dd = Float64::FromBits(dm.get_bits() ^ kSignBit64);
dd = canonicalizeNaN(dd);
set_d_register_from_double(vd, dd);
} else {
Float32 sm = get_float_from_s_register(m);
constexpr uint32_t kSignBit32 = uint32_t{1} << 31;
Float32 sd = Float32::FromBits(sm.get_bits() ^ kSignBit32);
sd = canonicalizeNaN(sd);
set_s_register_from_float(d, sd);
}
} else if ((instr->Opc2Value() == 0x7) && (instr->Opc3Value() == 0x3)) {
DecodeVCVTBetweenDoubleAndSingle(instr);
} else if ((instr->Opc2Value() == 0x8) && (instr->Opc3Value() & 0x1)) {
DecodeVCVTBetweenFloatingPointAndInteger(instr);
} else if ((instr->Opc2Value() == 0xA) && (instr->Opc3Value() == 0x3) &&
(instr->Bit(8) == 1)) {
// vcvt.f64.s32 Dd, Dd, #<fbits>
int fraction_bits = 32 - ((instr->Bits(3, 0) << 1) | instr->Bit(5));
int fixed_value = get_sinteger_from_s_register(vd * 2);
double divide = 1 << fraction_bits;
set_d_register_from_double(vd, fixed_value / divide);
} else if (((instr->Opc2Value() >> 1) == 0x6) &&
(instr->Opc3Value() & 0x1)) {
DecodeVCVTBetweenFloatingPointAndInteger(instr);
} else if (((instr->Opc2Value() == 0x4) || (instr->Opc2Value() == 0x5)) &&
(instr->Opc3Value() & 0x1)) {
DecodeVCMP(instr);
} else if (((instr->Opc2Value() == 0x1)) && (instr->Opc3Value() == 0x3)) {
// vsqrt
lazily_initialize_fast_sqrt(isolate_);
if (instr->SzValue() == 0x1) {
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = fast_sqrt(dm_value, isolate_);
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = fast_sqrt(sm_value, isolate_);
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else if (instr->Opc3Value() == 0x0) {
// vmov immediate.
if (instr->SzValue() == 0x1) {
set_d_register_from_double(vd, instr->DoubleImmedVmov());
} else {
// Cast double to float.
float value = instr->DoubleImmedVmov().get_scalar();
set_s_register_from_float(d, value);
}
} else if (((instr->Opc2Value() == 0x6)) && (instr->Opc3Value() == 0x3)) {
// vrintz - truncate
if (instr->SzValue() == 0x1) {
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = trunc(dm_value);
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = truncf(sm_value);
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else {
UNREACHABLE(); // Not used by V8.
}
} else if (instr->Opc1Value() == 0x3) {
if (instr->Opc3Value() & 0x1) {
// vsub
if (instr->SzValue() == 0x1) {
double dn_value = get_double_from_d_register(vn).get_scalar();
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = dn_value - dm_value;
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
float sn_value = get_float_from_s_register(n).get_scalar();
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = sn_value - sm_value;
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else {
// vadd
if (instr->SzValue() == 0x1) {
double dn_value = get_double_from_d_register(vn).get_scalar();
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = dn_value + dm_value;
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
float sn_value = get_float_from_s_register(n).get_scalar();
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = sn_value + sm_value;
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
}
} else if ((instr->Opc1Value() == 0x2) && !(instr->Opc3Value() & 0x1)) {
// vmul
if (instr->SzValue() == 0x1) {
double dn_value = get_double_from_d_register(vn).get_scalar();
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = dn_value * dm_value;
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
float sn_value = get_float_from_s_register(n).get_scalar();
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = sn_value * sm_value;
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else if ((instr->Opc1Value() == 0x0)) {
// vmla, vmls
const bool is_vmls = (instr->Opc3Value() & 0x1);
if (instr->SzValue() == 0x1) {
const double dd_val = get_double_from_d_register(vd).get_scalar();
const double dn_val = get_double_from_d_register(vn).get_scalar();
const double dm_val = get_double_from_d_register(vm).get_scalar();
// Note: we do the mul and add/sub in separate steps to avoid getting a
// result with too high precision.
const double res = dn_val * dm_val;
set_d_register_from_double(vd, res);
if (is_vmls) {
set_d_register_from_double(vd, canonicalizeNaN(dd_val - res));
} else {
set_d_register_from_double(vd, canonicalizeNaN(dd_val + res));
}
} else {
const float sd_val = get_float_from_s_register(d).get_scalar();
const float sn_val = get_float_from_s_register(n).get_scalar();
const float sm_val = get_float_from_s_register(m).get_scalar();
// Note: we do the mul and add/sub in separate steps to avoid getting a
// result with too high precision.
const float res = sn_val * sm_val;
set_s_register_from_float(d, res);
if (is_vmls) {
set_s_register_from_float(d, canonicalizeNaN(sd_val - res));
} else {
set_s_register_from_float(d, canonicalizeNaN(sd_val + res));
}
}
} else if ((instr->Opc1Value() == 0x4) && !(instr->Opc3Value() & 0x1)) {
// vdiv
if (instr->SzValue() == 0x1) {
double dn_value = get_double_from_d_register(vn).get_scalar();
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = dn_value / dm_value;
div_zero_vfp_flag_ = (dm_value == 0);
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
float sn_value = get_float_from_s_register(n).get_scalar();
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = sn_value / sm_value;
div_zero_vfp_flag_ = (sm_value == 0);
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else {
UNIMPLEMENTED(); // Not used by V8.
}
} else {
if ((instr->VCValue() == 0x0) &&
(instr->VAValue() == 0x0)) {
DecodeVMOVBetweenCoreAndSinglePrecisionRegisters(instr);
} else if ((instr->VLValue() == 0x0) && (instr->VCValue() == 0x1)) {
if (instr->Bit(23) == 0) {
// vmov (ARM core register to scalar)
int vd = instr->VFPNRegValue(kDoublePrecision);
int rt = instr->RtValue();
int opc1_opc2 = (instr->Bits(22, 21) << 2) | instr->Bits(6, 5);
if ((opc1_opc2 & 0xB) == 0) {
// NeonS32/NeonU32
uint32_t data[2];
get_d_register(vd, data);
data[instr->Bit(21)] = get_register(rt);
set_d_register(vd, data);
} else {
uint64_t data;
get_d_register(vd, &data);
uint64_t rt_value = get_register(rt);
if ((opc1_opc2 & 0x8) != 0) {
// NeonS8 / NeonU8
int i = opc1_opc2 & 0x7;
int shift = i * kBitsPerByte;
const uint64_t mask = 0xFF;
data &= ~(mask << shift);
data |= (rt_value & mask) << shift;
set_d_register(vd, &data);
} else if ((opc1_opc2 & 0x1) != 0) {
// NeonS16 / NeonU16
int i = (opc1_opc2 >> 1) & 0x3;
int shift = i * kBitsPerByte * kShortSize;
const uint64_t mask = 0xFFFF;
data &= ~(mask << shift);
data |= (rt_value & mask) << shift;
set_d_register(vd, &data);
} else {
UNREACHABLE(); // Not used by V8.
}
}
} else {
// vdup.size Qd, Rt.
NeonSize size = Neon32;
if (instr->Bit(5) != 0)
size = Neon16;
else if (instr->Bit(22) != 0)
size = Neon8;
int vd = instr->VFPNRegValue(kSimd128Precision);
int rt = instr->RtValue();
uint32_t rt_value = get_register(rt);
uint32_t q_data[4];
switch (size) {
case Neon8: {
rt_value &= 0xFF;
uint8_t* dst = reinterpret_cast<uint8_t*>(q_data);
for (int i = 0; i < 16; i++) {
dst[i] = rt_value;
}
break;
}
case Neon16: {
// Perform pairwise op.
rt_value &= 0xFFFFu;
uint32_t rt_rt = (rt_value << 16) | (rt_value & 0xFFFFu);
for (int i = 0; i < 4; i++) {
q_data[i] = rt_rt;
}
break;
}
case Neon32: {
for (int i = 0; i < 4; i++) {
q_data[i] = rt_value;
}
break;
}
default:
UNREACHABLE();
break;
}
set_neon_register(vd, q_data);
}
} else if ((instr->VLValue() == 0x1) && (instr->VCValue() == 0x1)) {
// vmov (scalar to ARM core register)
int vn = instr->VFPNRegValue(kDoublePrecision);
int rt = instr->RtValue();
int opc1_opc2 = (instr->Bits(22, 21) << 2) | instr->Bits(6, 5);
uint64_t data;
get_d_register(vn, &data);
if ((opc1_opc2 & 0xB) == 0) {
// NeonS32 / NeonU32
int32_t int_data[2];
memcpy(int_data, &data, sizeof(int_data));
set_register(rt, int_data[instr->Bit(21)]);
} else {
uint64_t data;
get_d_register(vn, &data);
bool u = instr->Bit(23) != 0;
if ((opc1_opc2 & 0x8) != 0) {
// NeonS8 / NeonU8
int i = opc1_opc2 & 0x7;
int shift = i * kBitsPerByte;
uint32_t scalar = (data >> shift) & 0xFFu;
if (!u && (scalar & 0x80) != 0) scalar |= 0xFFFFFF00;
set_register(rt, scalar);
} else if ((opc1_opc2 & 0x1) != 0) {
// NeonS16 / NeonU16
int i = (opc1_opc2 >> 1) & 0x3;
int shift = i * kBitsPerByte * kShortSize;
uint32_t scalar = (data >> shift) & 0xFFFFu;
if (!u && (scalar & 0x8000) != 0) scalar |= 0xFFFF0000;
set_register(rt, scalar);
} else {
UNREACHABLE(); // Not used by V8.
}
}
} else if ((instr->VLValue() == 0x1) &&
(instr->VCValue() == 0x0) &&
(instr->VAValue() == 0x7) &&
(instr->Bits(19, 16) == 0x1)) {
// vmrs
uint32_t rt = instr->RtValue();
if (rt == 0xF) {
Copy_FPSCR_to_APSR();
} else {
// Emulate FPSCR from the Simulator flags.
uint32_t fpscr = (n_flag_FPSCR_ << 31) |
(z_flag_FPSCR_ << 30) |
(c_flag_FPSCR_ << 29) |
(v_flag_FPSCR_ << 28) |
(FPSCR_default_NaN_mode_ << 25) |
(inexact_vfp_flag_ << 4) |
(underflow_vfp_flag_ << 3) |
(overflow_vfp_flag_ << 2) |
(div_zero_vfp_flag_ << 1) |
(inv_op_vfp_flag_ << 0) |
(FPSCR_rounding_mode_);
set_register(rt, fpscr);
}
} else if ((instr->VLValue() == 0x0) &&
(instr->VCValue() == 0x0) &&
(instr->VAValue() == 0x7) &&
(instr->Bits(19, 16) == 0x1)) {
// vmsr
uint32_t rt = instr->RtValue();
if (rt == pc) {
UNREACHABLE();
} else {
uint32_t rt_value = get_register(rt);
n_flag_FPSCR_ = (rt_value >> 31) & 1;
z_flag_FPSCR_ = (rt_value >> 30) & 1;
c_flag_FPSCR_ = (rt_value >> 29) & 1;
v_flag_FPSCR_ = (rt_value >> 28) & 1;
FPSCR_default_NaN_mode_ = (rt_value >> 25) & 1;
inexact_vfp_flag_ = (rt_value >> 4) & 1;
underflow_vfp_flag_ = (rt_value >> 3) & 1;
overflow_vfp_flag_ = (rt_value >> 2) & 1;
div_zero_vfp_flag_ = (rt_value >> 1) & 1;
inv_op_vfp_flag_ = (rt_value >> 0) & 1;
FPSCR_rounding_mode_ =
static_cast<VFPRoundingMode>((rt_value) & kVFPRoundingModeMask);
}
} else {
UNIMPLEMENTED(); // Not used by V8.
}
}
}
void Simulator::DecodeTypeCP15(Instruction* instr) {
DCHECK((instr->TypeValue() == 7) && (instr->Bit(24) == 0x0));
DCHECK_EQ(instr->CoprocessorValue(), 15);
if (instr->Bit(4) == 1) {
// mcr
int crn = instr->Bits(19, 16);
int crm = instr->Bits(3, 0);
int opc1 = instr->Bits(23, 21);
int opc2 = instr->Bits(7, 5);
if ((opc1 == 0) && (crn == 7)) {
// ARMv6 memory barrier operations.
// Details available in ARM DDI 0406C.b, B3-1750.
if (((crm == 10) && (opc2 == 5)) || // CP15DMB
((crm == 10) && (opc2 == 4)) || // CP15DSB
((crm == 5) && (opc2 == 4))) { // CP15ISB
// These are ignored by the simulator for now.
} else {
UNIMPLEMENTED();
}
}
} else {
UNIMPLEMENTED();
}
}
void Simulator::DecodeVMOVBetweenCoreAndSinglePrecisionRegisters(
Instruction* instr) {
DCHECK((instr->Bit(4) == 1) && (instr->VCValue() == 0x0) &&
(instr->VAValue() == 0x0));
int t = instr->RtValue();
int n = instr->VFPNRegValue(kSinglePrecision);
bool to_arm_register = (instr->VLValue() == 0x1);
if (to_arm_register) {
int32_t int_value = get_sinteger_from_s_register(n);
set_register(t, int_value);
} else {
int32_t rs_val = get_register(t);
set_s_register_from_sinteger(n, rs_val);
}
}
void Simulator::DecodeVCMP(Instruction* instr) {
DCHECK((instr->Bit(4) == 0) && (instr->Opc1Value() == 0x7));
DCHECK(((instr->Opc2Value() == 0x4) || (instr->Opc2Value() == 0x5)) &&
(instr->Opc3Value() & 0x1));
// Comparison.
VFPRegPrecision precision = kSinglePrecision;
if (instr->SzValue() == 0x1) {
precision = kDoublePrecision;
}
int d = instr->VFPDRegValue(precision);
int m = 0;
if (instr->Opc2Value() == 0x4) {
m = instr->VFPMRegValue(precision);
}
if (precision == kDoublePrecision) {
double dd_value = get_double_from_d_register(d).get_scalar();
double dm_value = 0.0;
if (instr->Opc2Value() == 0x4) {
dm_value = get_double_from_d_register(m).get_scalar();
}
// Raise exceptions for quiet NaNs if necessary.
if (instr->Bit(7) == 1) {
if (std::isnan(dd_value)) {
inv_op_vfp_flag_ = true;
}
}
Compute_FPSCR_Flags(dd_value, dm_value);
} else {
float sd_value = get_float_from_s_register(d).get_scalar();
float sm_value = 0.0;
if (instr->Opc2Value() == 0x4) {
sm_value = get_float_from_s_register(m).get_scalar();
}
// Raise exceptions for quiet NaNs if necessary.
if (instr->Bit(7) == 1) {
if (std::isnan(sd_value)) {
inv_op_vfp_flag_ = true;
}
}
Compute_FPSCR_Flags(sd_value, sm_value);
}
}
void Simulator::DecodeVCVTBetweenDoubleAndSingle(Instruction* instr) {
DCHECK((instr->Bit(4) == 0) && (instr->Opc1Value() == 0x7));
DCHECK((instr->Opc2Value() == 0x7) && (instr->Opc3Value() == 0x3));
VFPRegPrecision dst_precision = kDoublePrecision;
VFPRegPrecision src_precision = kSinglePrecision;
if (instr->SzValue() == 1) {
dst_precision = kSinglePrecision;
src_precision = kDoublePrecision;
}
int dst = instr->VFPDRegValue(dst_precision);
int src = instr->VFPMRegValue(src_precision);
if (dst_precision == kSinglePrecision) {
double val = get_double_from_d_register(src).get_scalar();
set_s_register_from_float(dst, static_cast<float>(val));
} else {
float val = get_float_from_s_register(src).get_scalar();
set_d_register_from_double(dst, static_cast<double>(val));
}
}
bool get_inv_op_vfp_flag(VFPRoundingMode mode,
double val,
bool unsigned_) {
DCHECK((mode == RN) || (mode == RM) || (mode == RZ));
double max_uint = static_cast<double>(0xFFFFFFFFu);
double max_int = static_cast<double>(kMaxInt);
double min_int = static_cast<double>(kMinInt);
// Check for NaN.
if (val != val) {
return true;
}
// Check for overflow. This code works because 32bit integers can be
// exactly represented by ieee-754 64bit floating-point values.
switch (mode) {
case RN:
return unsigned_ ? (val >= (max_uint + 0.5)) ||
(val < -0.5)
: (val >= (max_int + 0.5)) ||
(val < (min_int - 0.5));
case RM:
return unsigned_ ? (val >= (max_uint + 1.0)) ||
(val < 0)
: (val >= (max_int + 1.0)) ||
(val < min_int);
case RZ:
return unsigned_ ? (val >= (max_uint + 1.0)) ||
(val <= -1)
: (val >= (max_int + 1.0)) ||
(val <= (min_int - 1.0));
default:
UNREACHABLE();
}
}
// We call this function only if we had a vfp invalid exception.
// It returns the correct saturated value.
int VFPConversionSaturate(double val, bool unsigned_res) {
if (val != val) {
return 0;
} else {
if (unsigned_res) {
return (val < 0) ? 0 : 0xFFFFFFFFu;
} else {
return (val < 0) ? kMinInt : kMaxInt;
}
}
}
int32_t Simulator::ConvertDoubleToInt(double val, bool unsigned_integer,
VFPRoundingMode mode) {
// TODO(jkummerow): These casts are undefined behavior if the integral
// part of {val} does not fit into the destination type.
int32_t result =
unsigned_integer ? static_cast<uint32_t>(val) : static_cast<int32_t>(val);
inv_op_vfp_flag_ = get_inv_op_vfp_flag(mode, val, unsigned_integer);
double abs_diff = unsigned_integer
? std::fabs(val - static_cast<uint32_t>(result))
: std::fabs(val - result);
inexact_vfp_flag_ = (abs_diff != 0);
if (inv_op_vfp_flag_) {
result = VFPConversionSaturate(val, unsigned_integer);
} else {
switch (mode) {
case RN: {
int val_sign = (val > 0) ? 1 : -1;
if (abs_diff > 0.5) {
result += val_sign;
} else if (abs_diff == 0.5) {
// Round to even if exactly halfway.
result = ((result % 2) == 0) ? result : result + val_sign;
}
break;
}
case RM:
result = result > val ? result - 1 : result;
break;
case RZ:
// Nothing to do.
break;
default:
UNREACHABLE();
}
}
return result;
}
void Simulator::DecodeVCVTBetweenFloatingPointAndInteger(Instruction* instr) {
DCHECK((instr->Bit(4) == 0) && (instr->Opc1Value() == 0x7) &&
(instr->Bits(27, 23) == 0x1D));
DCHECK(((instr->Opc2Value() == 0x8) && (instr->Opc3Value() & 0x1)) ||
(((instr->Opc2Value() >> 1) == 0x6) && (instr->Opc3Value() & 0x1)));
// Conversion between floating-point and integer.
bool to_integer = (instr->Bit(18) == 1);
VFPRegPrecision src_precision = (instr->SzValue() == 1) ? kDoublePrecision
: kSinglePrecision;
if (to_integer) {
// We are playing with code close to the C++ standard's limits below,
// hence the very simple code and heavy checks.
//
// Note:
// C++ defines default type casting from floating point to integer as
// (close to) rounding toward zero ("fractional part discarded").
int dst = instr->VFPDRegValue(kSinglePrecision);
int src = instr->VFPMRegValue(src_precision);
// Bit 7 in vcvt instructions indicates if we should use the FPSCR rounding
// mode or the default Round to Zero mode.
VFPRoundingMode mode = (instr->Bit(7) != 1) ? FPSCR_rounding_mode_
: RZ;
DCHECK((mode == RM) || (mode == RZ) || (mode == RN));
bool unsigned_integer = (instr->Bit(16) == 0);
bool double_precision = (src_precision == kDoublePrecision);
double val = double_precision ? get_double_from_d_register(src).get_scalar()
: get_float_from_s_register(src).get_scalar();
int32_t temp = ConvertDoubleToInt(val, unsigned_integer, mode);
// Update the destination register.
set_s_register_from_sinteger(dst, temp);
} else {
bool unsigned_integer = (instr->Bit(7) == 0);
int dst = instr->VFPDRegValue(src_precision);
int src = instr->VFPMRegValue(kSinglePrecision);
int val = get_sinteger_from_s_register(src);
if (src_precision == kDoublePrecision) {
if (unsigned_integer) {
set_d_register_from_double(
dst, static_cast<double>(static_cast<uint32_t>(val)));
} else {
set_d_register_from_double(dst, static_cast<double>(val));
}
} else {
if (unsigned_integer) {
set_s_register_from_float(
dst, static_cast<float>(static_cast<uint32_t>(val)));
} else {
set_s_register_from_float(dst, static_cast<float>(val));
}
}
}
}
// void Simulator::DecodeType6CoprocessorIns(Instruction* instr)
// Decode Type 6 coprocessor instructions.
// Dm = vmov(Rt, Rt2)
// <Rt, Rt2> = vmov(Dm)
// Ddst = MEM(Rbase + 4*offset).
// MEM(Rbase + 4*offset) = Dsrc.
void Simulator::DecodeType6CoprocessorIns(Instruction* instr) {
DCHECK_EQ(instr->TypeValue(), 6);
if (instr->CoprocessorValue() == 0xA) {
switch (instr->OpcodeValue()) {
case 0x8:
case 0xA:
case 0xC:
case 0xE: { // Load and store single precision float to memory.
int rn = instr->RnValue();
int vd = instr->VFPDRegValue(kSinglePrecision);
int offset = instr->Immed8Value();
if (!instr->HasU()) {
offset = -offset;
}
int32_t address = get_register(rn) + 4 * offset;
// Load and store address for singles must be at least four-byte
// aligned.
DCHECK_EQ(address % 4, 0);
if (instr->HasL()) {
// Load single from memory: vldr.
set_s_register_from_sinteger(vd, ReadW(address, instr));
} else {
// Store single to memory: vstr.
WriteW(address, get_sinteger_from_s_register(vd), instr);
}
break;
}
case 0x4:
case 0x5:
case 0x6:
case 0x7:
case 0x9:
case 0xB:
// Load/store multiple single from memory: vldm/vstm.
HandleVList(instr);
break;
default:
UNIMPLEMENTED(); // Not used by V8.
}
} else if (instr->CoprocessorValue() == 0xB) {
switch (instr->OpcodeValue()) {
case 0x2:
// Load and store double to two GP registers
if (instr->Bits(7, 6) != 0 || instr->Bit(4) != 1) {
UNIMPLEMENTED(); // Not used by V8.
} else {
int rt = instr->RtValue();
int rn = instr->RnValue();
int vm = instr->VFPMRegValue(kDoublePrecision);
if (instr->HasL()) {
uint32_t data[2];
get_d_register(vm, data);
set_register(rt, data[0]);
set_register(rn, data[1]);
} else {
int32_t data[] = { get_register(rt), get_register(rn) };
set_d_register(vm, reinterpret_cast<uint32_t*>(data));
}
}
break;
case 0x8:
case 0xA:
case 0xC:
case 0xE: { // Load and store double to memory.
int rn = instr->RnValue();
int vd = instr->VFPDRegValue(kDoublePrecision);
int offset = instr->Immed8Value();
if (!instr->HasU()) {
offset = -offset;
}
int32_t address = get_register(rn) + 4 * offset;
// Load and store address for doubles must be at least four-byte
// aligned.
DCHECK_EQ(address % 4, 0);
if (instr->HasL()) {
// Load double from memory: vldr.
int32_t data[] = {
ReadW(address, instr),
ReadW(address + 4, instr)
};
set_d_register(vd, reinterpret_cast<uint32_t*>(data));
} else {
// Store double to memory: vstr.
uint32_t data[2];
get_d_register(vd, data);
WriteW(address, data[0], instr);
WriteW(address + 4, data[1], instr);
}
break;
}
case 0x4:
case 0x5:
case 0x6:
case 0x7:
case 0x9:
case 0xB:
// Load/store multiple double from memory: vldm/vstm.
HandleVList(instr);
break;
default:
UNIMPLEMENTED(); // Not used by V8.
}
} else {
UNIMPLEMENTED(); // Not used by V8.
}
}
// Templated operations for NEON instructions.
template <typename T, typename U>
U Widen(T value) {
static_assert(sizeof(int64_t) > sizeof(T), "T must be int32_t or smaller");
static_assert(sizeof(U) > sizeof(T), "T must smaller than U");
return static_cast<U>(value);
}
template <typename T, typename U>
U Narrow(T value) {
static_assert(sizeof(int8_t) < sizeof(T), "T must be int16_t or larger");
static_assert(sizeof(U) < sizeof(T), "T must larger than U");
static_assert(std::is_unsigned<T>() == std::is_unsigned<U>(),
"Signed-ness of T and U must match");
// Make sure value can be expressed in the smaller type; otherwise, the
// casted result is implementation defined.
DCHECK_LE(std::numeric_limits<T>::min(), value);
DCHECK_GE(std::numeric_limits<T>::max(), value);
return static_cast<U>(value);
}
template <typename T>
T Clamp(int64_t value) {
static_assert(sizeof(int64_t) > sizeof(T), "T must be int32_t or smaller");
int64_t min = static_cast<int64_t>(std::numeric_limits<T>::min());
int64_t max = static_cast<int64_t>(std::numeric_limits<T>::max());
int64_t clamped = std::max(min, std::min(max, value));
return static_cast<T>(clamped);
}
template <typename T, typename U>
void Widen(Simulator* simulator, int Vd, int Vm) {
static const int kLanes = 8 / sizeof(T);
T src[kLanes];
U dst[kLanes];
simulator->get_neon_register<T, kDoubleSize>(Vm, src);
for (int i = 0; i < kLanes; i++) {
dst[i] = Widen<T, U>(src[i]);
}
simulator->set_neon_register(Vd, dst);
}
template <typename T, int SIZE>
void Abs(Simulator* simulator, int Vd, int Vm) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
for (int i = 0; i < kElems; i++) {
src[i] = std::abs(src[i]);
}
simulator->set_neon_register<T, SIZE>(Vd, src);
}
template <typename T, int SIZE>
void Neg(Simulator* simulator, int Vd, int Vm) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
for (int i = 0; i < kElems; i++) {
src[i] = -src[i];
}
simulator->set_neon_register<T, SIZE>(Vd, src);
}
template <typename T, typename U>
void SaturatingNarrow(Simulator* simulator, int Vd, int Vm) {
static const int kLanes = 16 / sizeof(T);
T src[kLanes];
U dst[kLanes];
simulator->get_neon_register(Vm, src);
for (int i = 0; i < kLanes; i++) {
dst[i] = Narrow<T, U>(Clamp<U>(src[i]));
}
simulator->set_neon_register<U, kDoubleSize>(Vd, dst);
}
template <typename T>
void AddSaturate(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kLanes = 16 / sizeof(T);
T src1[kLanes], src2[kLanes];
simulator->get_neon_register(Vn, src1);
simulator->get_neon_register(Vm, src2);
for (int i = 0; i < kLanes; i++) {
src1[i] = Clamp<T>(Widen<T, int64_t>(src1[i]) + Widen<T, int64_t>(src2[i]));
}
simulator->set_neon_register(Vd, src1);
}
template <typename T>
void SubSaturate(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kLanes = 16 / sizeof(T);
T src1[kLanes], src2[kLanes];
simulator->get_neon_register(Vn, src1);
simulator->get_neon_register(Vm, src2);
for (int i = 0; i < kLanes; i++) {
src1[i] = Clamp<T>(Widen<T, int64_t>(src1[i]) - Widen<T, int64_t>(src2[i]));
}
simulator->set_neon_register(Vd, src1);
}
template <typename T, int SIZE>
void Zip(Simulator* simulator, int Vd, int Vm) {
static const int kElems = SIZE / sizeof(T);
static const int kPairs = kElems / 2;
T src1[kElems], src2[kElems], dst1[kElems], dst2[kElems];
simulator->get_neon_register<T, SIZE>(Vd, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kPairs; i++) {
dst1[i * 2] = src1[i];
dst1[i * 2 + 1] = src2[i];
dst2[i * 2] = src1[i + kPairs];
dst2[i * 2 + 1] = src2[i + kPairs];
}
simulator->set_neon_register<T, SIZE>(Vd, dst1);
simulator->set_neon_register<T, SIZE>(Vm, dst2);
}
template <typename T, int SIZE>
void Unzip(Simulator* simulator, int Vd, int Vm) {
static const int kElems = SIZE / sizeof(T);
static const int kPairs = kElems / 2;
T src1[kElems], src2[kElems], dst1[kElems], dst2[kElems];
simulator->get_neon_register<T, SIZE>(Vd, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kPairs; i++) {
dst1[i] = src1[i * 2];
dst1[i + kPairs] = src2[i * 2];
dst2[i] = src1[i * 2 + 1];
dst2[i + kPairs] = src2[i * 2 + 1];
}
simulator->set_neon_register<T, SIZE>(Vd, dst1);
simulator->set_neon_register<T, SIZE>(Vm, dst2);
}
template <typename T, int SIZE>
void Transpose(Simulator* simulator, int Vd, int Vm) {
static const int kElems = SIZE / sizeof(T);
static const int kPairs = kElems / 2;
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vd, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kPairs; i++) {
std::swap(src1[2 * i + 1], src2[2 * i]);
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
simulator->set_neon_register<T, SIZE>(Vm, src2);
}
template <typename T, int SIZE>
void Test(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
src1[i] = (src1[i] & src2[i]) != 0 ? -1 : 0;
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T, int SIZE>
void Add(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
src1[i] += src2[i];
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T, int SIZE>
void Sub(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
src1[i] -= src2[i];
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T, int SIZE>
void Mul(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
src1[i] *= src2[i];
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T, int SIZE>
void ShiftLeft(Simulator* simulator, int Vd, int Vm, int shift) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
for (int i = 0; i < kElems; i++) {
src[i] <<= shift;
}
simulator->set_neon_register<T, SIZE>(Vd, src);
}
template <typename T, int SIZE>
void ShiftRight(Simulator* simulator, int Vd, int Vm, int shift) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
for (int i = 0; i < kElems; i++) {
src[i] >>= shift;
}
simulator->set_neon_register<T, SIZE>(Vd, src);
}
template <typename T, int SIZE>
void ArithmeticShiftRight(Simulator* simulator, int Vd, int Vm, int shift) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
for (int i = 0; i < kElems; i++) {
src[i] = ArithmeticShiftRight(src[i], shift);
}
simulator->set_neon_register<T, SIZE>(Vd, src);
}
template <typename T, int SIZE>
void ShiftLeftAndInsert(Simulator* simulator, int Vd, int Vm, int shift) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
T dst[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
simulator->get_neon_register<T, SIZE>(Vd, dst);
uint64_t mask = (1llu << shift) - 1llu;
for (int i = 0; i < kElems; i++) {
dst[i] = (src[i] << shift) | (dst[i] & mask);
}
simulator->set_neon_register<T, SIZE>(Vd, dst);
}
template <typename T, int SIZE>
void ShiftRightAndInsert(Simulator* simulator, int Vd, int Vm, int shift) {
static const int kElems = SIZE / sizeof(T);
T src[kElems];
T dst[kElems];
simulator->get_neon_register<T, SIZE>(Vm, src);
simulator->get_neon_register<T, SIZE>(Vd, dst);
uint64_t mask = ~((1llu << (kBitsPerByte * SIZE - shift)) - 1llu);
for (int i = 0; i < kElems; i++) {
dst[i] = (src[i] >> shift) | (dst[i] & mask);
}
simulator->set_neon_register<T, SIZE>(Vd, dst);
}
template <typename T, int SIZE>
void CompareEqual(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
src1[i] = src1[i] == src2[i] ? -1 : 0;
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T, int SIZE>
void CompareGreater(Simulator* simulator, int Vd, int Vm, int Vn, bool ge) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
if (ge)
src1[i] = src1[i] >= src2[i] ? -1 : 0;
else
src1[i] = src1[i] > src2[i] ? -1 : 0;
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T>
T MinMax(T a, T b, bool is_min) {
return is_min ? std::min(a, b) : std::max(a, b);
}
template <typename T, int SIZE>
void MinMax(Simulator* simulator, int Vd, int Vm, int Vn, bool min) {
static const int kElems = SIZE / sizeof(T);
T src1[kElems], src2[kElems];
simulator->get_neon_register<T, SIZE>(Vn, src1);
simulator->get_neon_register<T, SIZE>(Vm, src2);
for (int i = 0; i < kElems; i++) {
src1[i] = MinMax(src1[i], src2[i], min);
}
simulator->set_neon_register<T, SIZE>(Vd, src1);
}
template <typename T>
void PairwiseMinMax(Simulator* simulator, int Vd, int Vm, int Vn, bool min) {
static const int kElems = kDoubleSize / sizeof(T);
static const int kPairs = kElems / 2;
T dst[kElems], src1[kElems], src2[kElems];
simulator->get_neon_register<T, kDoubleSize>(Vn, src1);
simulator->get_neon_register<T, kDoubleSize>(Vm, src2);
for (int i = 0; i < kPairs; i++) {
dst[i] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
dst[i + kPairs] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
}
simulator->set_neon_register<T, kDoubleSize>(Vd, dst);
}
template <typename T>
void PairwiseAdd(Simulator* simulator, int Vd, int Vm, int Vn) {
static const int kElems = kDoubleSize / sizeof(T);
static const int kPairs = kElems / 2;
T dst[kElems], src1[kElems], src2[kElems];
simulator->get_neon_register<T, kDoubleSize>(Vn, src1);
simulator->get_neon_register<T, kDoubleSize>(Vm, src2);
for (int i = 0; i < kPairs; i++) {
dst[i] = src1[i * 2] + src1[i * 2 + 1];
dst[i + kPairs] = src2[i * 2] + src2[i * 2 + 1];
}
simulator->set_neon_register<T, kDoubleSize>(Vd, dst);
}
void Simulator::DecodeSpecialCondition(Instruction* instr) {
switch (instr->SpecialValue()) {
case 4: {
int Vd, Vm, Vn;
if (instr->Bit(6) == 0) {
Vd = instr->VFPDRegValue(kDoublePrecision);
Vm = instr->VFPMRegValue(kDoublePrecision);
Vn = instr->VFPNRegValue(kDoublePrecision);
} else {
Vd = instr->VFPDRegValue(kSimd128Precision);
Vm = instr->VFPMRegValue(kSimd128Precision);
Vn = instr->VFPNRegValue(kSimd128Precision);
}
switch (instr->Bits(11, 8)) {
case 0x0: {
if (instr->Bit(4) == 1) {
// vqadd.s<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
AddSaturate<int8_t>(this, Vd, Vm, Vn);
break;
case Neon16:
AddSaturate<int16_t>(this, Vd, Vm, Vn);
break;
case Neon32:
AddSaturate<int32_t>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
}
case 0x1: {
if (instr->Bits(21, 20) == 2 && instr->Bit(6) == 1 &&
instr->Bit(4) == 1) {
// vmov Qd, Qm.
// vorr, Qd, Qm, Qn.
uint32_t src1[4];
get_neon_register(Vm, src1);
if (Vm != Vn) {
uint32_t src2[4];
get_neon_register(Vn, src2);
for (int i = 0; i < 4; i++) {
src1[i] = src1[i] | src2[i];
}
}
set_neon_register(Vd, src1);
} else if (instr->Bits(21, 20) == 0 && instr->Bit(6) == 1 &&
instr->Bit(4) == 1) {
// vand Qd, Qm, Qn.
uint32_t src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
for (int i = 0; i < 4; i++) {
src1[i] = src1[i] & src2[i];
}
set_neon_register(Vd, src1);
} else {
UNIMPLEMENTED();
}
break;
}
case 0x2: {
if (instr->Bit(4) == 1) {
// vqsub.s<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
SubSaturate<int8_t>(this, Vd, Vm, Vn);
break;
case Neon16:
SubSaturate<int16_t>(this, Vd, Vm, Vn);
break;
case Neon32:
SubSaturate<int32_t>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
}
case 0x3: {
// vcge/vcgt.s<size> Qd, Qm, Qn.
bool ge = instr->Bit(4) == 1;
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
CompareGreater<int8_t, kSimd128Size>(this, Vd, Vm, Vn, ge);
break;
case Neon16:
CompareGreater<int16_t, kSimd128Size>(this, Vd, Vm, Vn, ge);
break;
case Neon32:
CompareGreater<int32_t, kSimd128Size>(this, Vd, Vm, Vn, ge);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0x6: {
// vmin/vmax.s<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
bool min = instr->Bit(4) != 0;
switch (size) {
case Neon8:
MinMax<int8_t, kSimd128Size>(this, Vd, Vm, Vn, min);
break;
case Neon16:
MinMax<int16_t, kSimd128Size>(this, Vd, Vm, Vn, min);
break;
case Neon32:
MinMax<int32_t, kSimd128Size>(this, Vd, Vm, Vn, min);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0x8: {
// vadd/vtst
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
if (instr->Bit(4) == 0) {
// vadd.i<size> Qd, Qm, Qn.
switch (size) {
case Neon8:
Add<uint8_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon16:
Add<uint16_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon32:
Add<uint32_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
// vtst.i<size> Qd, Qm, Qn.
switch (size) {
case Neon8:
Test<uint8_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon16:
Test<uint16_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon32:
Test<uint32_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
}
break;
}
case 0x9: {
if (instr->Bit(6) == 1 && instr->Bit(4) == 1) {
// vmul.i<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
Mul<uint8_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon16:
Mul<uint16_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon32:
Mul<uint32_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
}
case 0xA: {
// vpmin/vpmax.s<size> Dd, Dm, Dn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
bool min = instr->Bit(4) != 0;
switch (size) {
case Neon8:
PairwiseMinMax<int8_t>(this, Vd, Vm, Vn, min);
break;
case Neon16:
PairwiseMinMax<int16_t>(this, Vd, Vm, Vn, min);
break;
case Neon32:
PairwiseMinMax<int32_t>(this, Vd, Vm, Vn, min);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0xB: {
// vpadd.i<size> Dd, Dm, Dn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
PairwiseAdd<int8_t>(this, Vd, Vm, Vn);
break;
case Neon16:
PairwiseAdd<int16_t>(this, Vd, Vm, Vn);
break;
case Neon32:
PairwiseAdd<int32_t>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0xD: {
if (instr->Bit(4) == 0) {
float src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
for (int i = 0; i < 4; i++) {
if (instr->Bit(21) == 0) {
// vadd.f32 Qd, Qm, Qn.
src1[i] = src1[i] + src2[i];
} else {
// vsub.f32 Qd, Qm, Qn.
src1[i] = src1[i] - src2[i];
}
}
set_neon_register(Vd, src1);
} else {
UNIMPLEMENTED();
}
break;
}
case 0xE: {
if (instr->Bits(21, 20) == 0 && instr->Bit(4) == 0) {
// vceq.f32.
float src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
uint32_t dst[4];
for (int i = 0; i < 4; i++) {
dst[i] = (src1[i] == src2[i]) ? 0xFFFFFFFF : 0;
}
set_neon_register(Vd, dst);
} else {
UNIMPLEMENTED();
}
break;
}
case 0xF: {
if (instr->Bit(20) == 0 && instr->Bit(6) == 1) {
float src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
if (instr->Bit(4) == 1) {
if (instr->Bit(21) == 0) {
// vrecps.f32 Qd, Qm, Qn.
for (int i = 0; i < 4; i++) {
src1[i] = 2.0f - src1[i] * src2[i];
}
} else {
// vrsqrts.f32 Qd, Qm, Qn.
for (int i = 0; i < 4; i++) {
src1[i] = (3.0f - src1[i] * src2[i]) * 0.5f;
}
}
} else {
// vmin/vmax.f32 Qd, Qm, Qn.
bool min = instr->Bit(21) == 1;
for (int i = 0; i < 4; i++) {
src1[i] = MinMax(src1[i], src2[i], min);
}
}
set_neon_register(Vd, src1);
} else {
UNIMPLEMENTED();
}
break;
}
default:
UNIMPLEMENTED();
break;
}
break;
}
case 5:
if ((instr->Bits(18, 16) == 0) && (instr->Bits(11, 6) == 0x28) &&
(instr->Bit(4) == 1)) {
// vmovl signed
if ((instr->VdValue() & 1) != 0) UNIMPLEMENTED();
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kDoublePrecision);
int imm3 = instr->Bits(21, 19);
switch (imm3) {
case 1:
Widen<int8_t, int16_t>(this, Vd, Vm);
break;
case 2:
Widen<int16_t, int32_t>(this, Vd, Vm);
break;
case 4:
Widen<int32_t, int64_t>(this, Vd, Vm);
break;
default:
UNIMPLEMENTED();
break;
}
} else if (instr->Bits(21, 20) == 3 && instr->Bit(4) == 0) {
// vext.
int imm4 = instr->Bits(11, 8);
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
int Vn = instr->VFPNRegValue(kSimd128Precision);
uint8_t src1[16], src2[16], dst[16];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
int boundary = kSimd128Size - imm4;
int i = 0;
for (; i < boundary; i++) {
dst[i] = src1[i + imm4];
}
for (; i < 16; i++) {
dst[i] = src2[i - boundary];
}
set_neon_register(Vd, dst);
} else if (instr->Bits(11, 7) == 0xA && instr->Bit(4) == 1) {
// vshl.i<size> Qd, Qm, shift
int size = base::bits::RoundDownToPowerOfTwo32(instr->Bits(21, 16));
int shift = instr->Bits(21, 16) - size;
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
NeonSize ns = static_cast<NeonSize>(size / 16);
switch (ns) {
case Neon8:
ShiftLeft<uint8_t, kSimd128Size>(this, Vd, Vm, shift);
break;
case Neon16:
ShiftLeft<uint16_t, kSimd128Size>(this, Vd, Vm, shift);
break;
case Neon32:
ShiftLeft<uint32_t, kSimd128Size>(this, Vd, Vm, shift);
break;
default:
UNREACHABLE();
break;
}
} else if (instr->Bits(11, 7) == 0 && instr->Bit(4) == 1) {
// vshr.s<size> Qd, Qm, shift
int size = base::bits::RoundDownToPowerOfTwo32(instr->Bits(21, 16));
int shift = 2 * size - instr->Bits(21, 16);
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
NeonSize ns = static_cast<NeonSize>(size / 16);
switch (ns) {
case Neon8:
ArithmeticShiftRight<int8_t, kSimd128Size>(this, Vd, Vm, shift);
break;
case Neon16:
ArithmeticShiftRight<int16_t, kSimd128Size>(this, Vd, Vm, shift);
break;
case Neon32:
ArithmeticShiftRight<int32_t, kSimd128Size>(this, Vd, Vm, shift);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
case 6: {
int Vd, Vm, Vn;
if (instr->Bit(6) == 0) {
Vd = instr->VFPDRegValue(kDoublePrecision);
Vm = instr->VFPMRegValue(kDoublePrecision);
Vn = instr->VFPNRegValue(kDoublePrecision);
} else {
Vd = instr->VFPDRegValue(kSimd128Precision);
Vm = instr->VFPMRegValue(kSimd128Precision);
Vn = instr->VFPNRegValue(kSimd128Precision);
}
switch (instr->Bits(11, 8)) {
case 0x0: {
if (instr->Bit(4) == 1) {
// vqadd.u<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
AddSaturate<uint8_t>(this, Vd, Vm, Vn);
break;
case Neon16:
AddSaturate<uint16_t>(this, Vd, Vm, Vn);
break;
case Neon32:
AddSaturate<uint32_t>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
}
case 0x1: {
if (instr->Bits(21, 20) == 1 && instr->Bit(4) == 1) {
// vbsl.size Qd, Qm, Qn.
uint32_t dst[4], src1[4], src2[4];
get_neon_register(Vd, dst);
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
for (int i = 0; i < 4; i++) {
dst[i] = (dst[i] & src1[i]) | (~dst[i] & src2[i]);
}
set_neon_register(Vd, dst);
} else if (instr->Bits(21, 20) == 0 && instr->Bit(4) == 1) {
if (instr->Bit(6) == 0) {
// veor Dd, Dn, Dm
uint64_t src1, src2;
get_d_register(Vn, &src1);
get_d_register(Vm, &src2);
src1 ^= src2;
set_d_register(Vd, &src1);
} else {
// veor Qd, Qn, Qm
uint32_t src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
for (int i = 0; i < 4; i++) src1[i] ^= src2[i];
set_neon_register(Vd, src1);
}
} else {
UNIMPLEMENTED();
}
break;
}
case 0x2: {
if (instr->Bit(4) == 1) {
// vqsub.u<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
SubSaturate<uint8_t>(this, Vd, Vm, Vn);
break;
case Neon16:
SubSaturate<uint16_t>(this, Vd, Vm, Vn);
break;
case Neon32:
SubSaturate<uint32_t>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
}
case 0x3: {
// vcge/vcgt.u<size> Qd, Qm, Qn.
bool ge = instr->Bit(4) == 1;
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
CompareGreater<uint8_t, kSimd128Size>(this, Vd, Vm, Vn, ge);
break;
case Neon16:
CompareGreater<uint16_t, kSimd128Size>(this, Vd, Vm, Vn, ge);
break;
case Neon32:
CompareGreater<uint32_t, kSimd128Size>(this, Vd, Vm, Vn, ge);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0x6: {
// vmin/vmax.u<size> Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
bool min = instr->Bit(4) != 0;
switch (size) {
case Neon8:
MinMax<uint8_t, kSimd128Size>(this, Vd, Vm, Vn, min);
break;
case Neon16:
MinMax<uint16_t, kSimd128Size>(this, Vd, Vm, Vn, min);
break;
case Neon32:
MinMax<uint32_t, kSimd128Size>(this, Vd, Vm, Vn, min);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0x8: {
if (instr->Bit(4) == 0) {
// vsub.size Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
Sub<uint8_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon16:
Sub<uint16_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon32:
Sub<uint32_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
} else {
// vceq.size Qd, Qm, Qn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
switch (size) {
case Neon8:
CompareEqual<uint8_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon16:
CompareEqual<uint16_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
case Neon32:
CompareEqual<uint32_t, kSimd128Size>(this, Vd, Vm, Vn);
break;
default:
UNREACHABLE();
break;
}
}
break;
}
case 0xA: {
// vpmin/vpmax.u<size> Dd, Dm, Dn.
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
bool min = instr->Bit(4) != 0;
switch (size) {
case Neon8:
PairwiseMinMax<uint8_t>(this, Vd, Vm, Vn, min);
break;
case Neon16:
PairwiseMinMax<uint16_t>(this, Vd, Vm, Vn, min);
break;
case Neon32:
PairwiseMinMax<uint32_t>(this, Vd, Vm, Vn, min);
break;
default:
UNREACHABLE();
break;
}
break;
}
case 0xD: {
if (instr->Bits(21, 20) == 0 && instr->Bit(6) == 1 &&
instr->Bit(4) == 1) {
// vmul.f32 Qd, Qn, Qm
float src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
for (int i = 0; i < 4; i++) {
src1[i] = src1[i] * src2[i];
}
set_neon_register(Vd, src1);
} else if (instr->Bits(21, 20) == 0 && instr->Bit(6) == 0 &&
instr->Bit(4) == 0) {
// vpadd.f32 Dd, Dn, Dm
PairwiseAdd<float>(this, Vd, Vm, Vn);
} else {
UNIMPLEMENTED();
}
break;
}
case 0xE: {
if (instr->Bit(20) == 0 && instr->Bit(4) == 0) {
// vcge/vcgt.f32 Qd, Qm, Qn
bool ge = instr->Bit(21) == 0;
float src1[4], src2[4];
get_neon_register(Vn, src1);
get_neon_register(Vm, src2);
uint32_t dst[4];
for (int i = 0; i < 4; i++) {
if (ge) {
dst[i] = src1[i] >= src2[i] ? 0xFFFFFFFFu : 0;
} else {
dst[i] = src1[i] > src2[i] ? 0xFFFFFFFFu : 0;
}
}
set_neon_register(Vd, dst);
} else {
UNIMPLEMENTED();
}
break;
}
default:
UNREACHABLE();
break;
}
break;
}
case 7:
if ((instr->Bits(18, 16) == 0) && (instr->Bits(11, 6) == 0x28) &&
(instr->Bit(4) == 1)) {
// vmovl unsigned
if ((instr->VdValue() & 1) != 0) UNIMPLEMENTED();
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kDoublePrecision);
int imm3 = instr->Bits(21, 19);
switch (imm3) {
case 1:
Widen<uint8_t, uint16_t>(this, Vd, Vm);
break;
case 2:
Widen<uint16_t, uint32_t>(this, Vd, Vm);
break;
case 4:
Widen<uint32_t, uint64_t>(this, Vd, Vm);
break;
default:
UNIMPLEMENTED();
break;
}
} else if (instr->Opc1Value() == 7 && instr->Bit(4) == 0) {
if (instr->Bits(19, 16) == 0xB && instr->Bits(11, 9) == 0x3 &&
instr->Bit(6) == 1) {
// vcvt.<Td>.<Tm> Qd, Qm.
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
uint32_t q_data[4];
get_neon_register(Vm, q_data);
int op = instr->Bits(8, 7);
for (int i = 0; i < 4; i++) {
switch (op) {
case 0:
// f32 <- s32, round towards nearest.
q_data[i] = bit_cast<uint32_t>(std::round(
static_cast<float>(bit_cast<int32_t>(q_data[i]))));
break;
case 1:
// f32 <- u32, round towards nearest.
q_data[i] = bit_cast<uint32_t>(
std::round(static_cast<float>(q_data[i])));
break;
case 2:
// s32 <- f32, round to zero.
q_data[i] = static_cast<uint32_t>(
ConvertDoubleToInt(bit_cast<float>(q_data[i]), false, RZ));
break;
case 3:
// u32 <- f32, round to zero.
q_data[i] = static_cast<uint32_t>(
ConvertDoubleToInt(bit_cast<float>(q_data[i]), true, RZ));
break;
}
}
set_neon_register(Vd, q_data);
} else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 7) == 0) {
if (instr->Bit(6) == 0) {
// vswp Dd, Dm.
uint64_t dval, mval;
int vd = instr->VFPDRegValue(kDoublePrecision);
int vm = instr->VFPMRegValue(kDoublePrecision);
get_d_register(vd, &dval);
get_d_register(vm, &mval);
set_d_register(vm, &dval);
set_d_register(vd, &mval);
} else {
// vswp Qd, Qm.
uint32_t dval[4], mval[4];
int vd = instr->VFPDRegValue(kSimd128Precision);
int vm = instr->VFPMRegValue(kSimd128Precision);
get_neon_register(vd, dval);
get_neon_register(vm, mval);
set_neon_register(vm, dval);
set_neon_register(vd, mval);
}
} else if (instr->Bits(11, 7) == 0x18) {
// vdup.<size> Dd, Dm[index].
// vdup.<size> Qd, Dm[index].
int vm = instr->VFPMRegValue(kDoublePrecision);
int imm4 = instr->Bits(19, 16);
int size = 0, index = 0, mask = 0;
if ((imm4 & 0x1) != 0) {
size = 8;
index = imm4 >> 1;
mask = 0xFFu;
} else if ((imm4 & 0x2) != 0) {
size = 16;
index = imm4 >> 2;
mask = 0xFFFFu;
} else {
size = 32;
index = imm4 >> 3;
mask = 0xFFFFFFFFu;
}
uint64_t d_data;
get_d_register(vm, &d_data);
uint32_t scalar = (d_data >> (size * index)) & mask;
uint32_t duped = scalar;
for (int i = 1; i < 32 / size; i++) {
scalar <<= size;
duped |= scalar;
}
uint32_t result[4] = {duped, duped, duped, duped};
if (instr->Bit(6) == 0) {
int vd = instr->VFPDRegValue(kDoublePrecision);
set_d_register(vd, result);
} else {
int vd = instr->VFPDRegValue(kSimd128Precision);
set_neon_register(vd, result);
}
} else if (instr->Bits(19, 16) == 0 && instr->Bits(11, 6) == 0x17) {
// vmvn Qd, Qm.
int vd = instr->VFPDRegValue(kSimd128Precision);
int vm = instr->VFPMRegValue(kSimd128Precision);
uint32_t q_data[4];
get_neon_register(vm, q_data);
for (int i = 0; i < 4; i++) q_data[i] = ~q_data[i];
set_neon_register(vd, q_data);
} else if (instr->Bits(11, 10) == 0x2) {
// vtb[l,x] Dd, <list>, Dm.
int vd = instr->VFPDRegValue(kDoublePrecision);
int vn = instr->VFPNRegValue(kDoublePrecision);
int vm = instr->VFPMRegValue(kDoublePrecision);
int table_len = (instr->Bits(9, 8) + 1) * kDoubleSize;
bool vtbx = instr->Bit(6) != 0; // vtbl / vtbx
uint64_t destination = 0, indices = 0, result = 0;
get_d_register(vd, &destination);
get_d_register(vm, &indices);
for (int i = 0; i < kDoubleSize; i++) {
int shift = i * kBitsPerByte;
int index = (indices >> shift) & 0xFF;
if (index < table_len) {
uint64_t table;
get_d_register(vn + index / kDoubleSize, &table);
result |=
((table >> ((index % kDoubleSize) * kBitsPerByte)) & 0xFF)
<< shift;
} else if (vtbx) {
result |= destination & (0xFFull << shift);
}
}
set_d_register(vd, &result);
} else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 8) == 0x1) {
NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
if (instr->Bit(6) == 0) {
int Vd = instr->VFPDRegValue(kDoublePrecision);
int Vm = instr->VFPMRegValue(kDoublePrecision);
if (instr->Bit(7) == 1) {
// vzip.<size> Dd, Dm.
switch (size) {
case Neon8:
Zip<uint8_t, kDoubleSize>(this, Vd, Vm);
break;
case Neon16:
Zip<uint16_t, kDoubleSize>(this, Vd, Vm);
break;
case Neon32:
UNIMPLEMENTED();
break;
default:
UNREACHABLE();
break;
}
} else {
// vuzp.<size> Dd, Dm.
switch (size) {
case Neon8:
Unzip<uint8_t, kDoubleSize>(this, Vd, Vm);
break;
case Neon16:
Unzip<uint16_t, kDoubleSize>(this, Vd, Vm);
break;
case Neon32:
UNIMPLEMENTED();
break;
default:
UNREACHABLE();
break;
}
}
} else {
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
if (instr->Bit(7) == 1) {
// vzip.<size> Qd, Qm.
switch (size) {
case Neon8:
Zip<uint8_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon16:
Zip<uint16_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon32:
Zip<uint32_t, kSimd128Size>(this, Vd, Vm);
break;
default:
UNREACHABLE();
break;
}
} else {
// vuzp.<size> Qd, Qm.
switch (size) {
case Neon8:
Unzip<uint8_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon16:
Unzip<uint16_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon32:
Unzip<uint32_t, kSimd128Size>(this, Vd, Vm);
break;
default:
UNREACHABLE();
break;
}
}
}
} else if (instr->Bits(17, 16) == 0 && instr->Bits(11, 9) == 0) {
// vrev<op>.size Qd, Qm
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
NeonSize op = static_cast<NeonSize>(static_cast<int>(Neon64) -
instr->Bits(8, 7));
switch (op) {
case Neon16: {
DCHECK_EQ(Neon8, size);
uint8_t src[16];
get_neon_register(Vm, src);
for (int i = 0; i < 16; i += 2) {
std::swap(src[i], src[i + 1]);
}
set_neon_register(Vd, src);
break;
}
case Neon32: {
switch (size) {
case Neon16: {
uint16_t src[8];
get_neon_register(Vm, src);
for (int i = 0; i < 8; i += 2) {
std::swap(src[i], src[i + 1]);
}
set_neon_register(Vd, src);
break;
}
case Neon8: {
uint8_t src[16];
get_neon_register(Vm, src);
for (int i = 0; i < 4; i++) {
std::swap(src[i * 4], src[i * 4 + 3]);
std::swap(src[i * 4 + 1], src[i * 4 + 2]);
}
set_neon_register(Vd, src);
break;
}
default:
UNREACHABLE();
break;
}
break;
}
case Neon64: {
switch (size) {
case Neon32: {
uint32_t src[4];
get_neon_register(Vm, src);
std::swap(src[0], src[1]);
std::swap(src[2], src[3]);
set_neon_register(Vd, src);
break;
}
case Neon16: {
uint16_t src[8];
get_neon_register(Vm, src);
for (int i = 0; i < 2; i++) {
std::swap(src[i * 4], src[i * 4 + 3]);
std::swap(src[i * 4 + 1], src[i * 4 + 2]);
}
set_neon_register(Vd, src);
break;
}
case Neon8: {
uint8_t src[16];
get_neon_register(Vm, src);
for (int i = 0; i < 4; i++) {
std::swap(src[i], src[7 - i]);
std::swap(src[i + 8], src[15 - i]);
}
set_neon_register(Vd, src);
break;
}
default:
UNREACHABLE();
break;
}
break;
}
default:
UNREACHABLE();
break;
}
} else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 7) == 0x1) {
NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
if (instr->Bit(6) == 0) {
int Vd = instr->VFPDRegValue(kDoublePrecision);
int Vm = instr->VFPMRegValue(kDoublePrecision);
// vtrn.<size> Dd, Dm.
switch (size) {
case Neon8:
Transpose<uint8_t, kDoubleSize>(this, Vd, Vm);
break;
case Neon16:
Transpose<uint16_t, kDoubleSize>(this, Vd, Vm);
break;
case Neon32:
Transpose<uint32_t, kDoubleSize>(this, Vd, Vm);
break;
default:
UNREACHABLE();
break;
}
} else {
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
// vtrn.<size> Qd, Qm.
switch (size) {
case Neon8:
Transpose<uint8_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon16:
Transpose<uint16_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon32:
Transpose<uint32_t, kSimd128Size>(this, Vd, Vm);
break;
default:
UNREACHABLE();
break;
}
}
} else if (instr->Bits(17, 16) == 0x1 && instr->Bit(11) == 0) {
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
if (instr->Bits(9, 6) == 0xD) {
// vabs<type>.<size> Qd, Qm
if (instr->Bit(10) != 0) {
// floating point (clear sign bits)
uint32_t src[4];
get_neon_register(Vm, src);
for (int i = 0; i < 4; i++) {
src[i] &= ~0x80000000;
}
set_neon_register(Vd, src);
} else {
// signed integer
switch (size) {
case Neon8:
Abs<int8_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon16:
Abs<int16_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon32:
Abs<int32_t, kSimd128Size>(this, Vd, Vm);
break;
default:
UNIMPLEMENTED();
break;
}
}
} else if (instr->Bits(9, 6) == 0xF) {
// vneg<type>.<size> Qd, Qm (signed integer)
if (instr->Bit(10) != 0) {
// floating point (toggle sign bits)
uint32_t src[4];
get_neon_register(Vm, src);
for (int i = 0; i < 4; i++) {
src[i] ^= 0x80000000;
}
set_neon_register(Vd, src);
} else {
// signed integer
switch (size) {
case Neon8:
Neg<int8_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon16:
Neg<int16_t, kSimd128Size>(this, Vd, Vm);
break;
case Neon32:
Neg<int32_t, kSimd128Size>(this, Vd, Vm);
break;
default:
UNIMPLEMENTED();
break;
}
}
} else {
UNIMPLEMENTED();
}
} else if (instr->Bits(19, 18) == 0x2 && instr->Bits(11, 8) == 0x5) {
// vrecpe/vrsqrte.f32 Qd, Qm.
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
uint32_t src[4];
get_neon_register(Vm, src);
if (instr->Bit(7) == 0) {
for (int i = 0; i < 4; i++) {
float denom = bit_cast<float>(src[i]);
div_zero_vfp_flag_ = (denom == 0);
float result = 1.0f / denom;
result = canonicalizeNaN(result);
src[i] = bit_cast<uint32_t>(result);
}
} else {
lazily_initialize_fast_sqrt(isolate_);
for (int i = 0; i < 4; i++) {
float radicand = bit_cast<float>(src[i]);
float result = 1.0f / fast_sqrt(radicand, isolate_);
result = canonicalizeNaN(result);
src[i] = bit_cast<uint32_t>(result);
}
}
set_neon_register(Vd, src);
} else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 8) == 0x2 &&
instr->Bits(7, 6) != 0) {
// vqmovn.<type><size> Dd, Qm.
int Vd = instr->VFPDRegValue(kDoublePrecision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
bool is_unsigned = instr->Bit(6) != 0;
switch (size) {
case Neon8: {
if (is_unsigned) {
SaturatingNarrow<uint16_t, uint8_t>(this, Vd, Vm);
} else {
SaturatingNarrow<int16_t, int8_t>(this, Vd, Vm);
}
break;
}
case Neon16: {
if (is_unsigned) {
SaturatingNarrow<uint32_t, uint16_t>(this, Vd, Vm);
} else {
SaturatingNarrow<int32_t, int16_t>(this, Vd, Vm);
}
break;
}
case Neon32: {
if (is_unsigned) {
SaturatingNarrow<uint64_t, uint32_t>(this, Vd, Vm);
} else {
SaturatingNarrow<int64_t, int32_t>(this, Vd, Vm);
}
break;
}
default:
UNIMPLEMENTED();
break;
}
} else {
UNIMPLEMENTED();
}
} else if (instr->Bits(11, 7) == 0 && instr->Bit(4) == 1) {
// vshr.u<size> Qd, Qm, shift
int size = base::bits::RoundDownToPowerOfTwo32(instr->Bits(21, 16));
int shift = 2 * size - instr->Bits(21, 16);
int Vd = instr->VFPDRegValue(kSimd128Precision);
int Vm = instr->VFPMRegValue(kSimd128Precision);
NeonSize ns = static_cast<NeonSize>(size / 16);
switch (ns) {
case Neon8:
ShiftRight<uint8_t, kSimd128Size>(this, Vd, Vm, shift);
break;
case Neon16:
ShiftRight<uint16_t, kSimd128Size>(this, Vd, Vm, shift);
break;
case Neon32:
ShiftRight<uint32_t, kSimd128Size>(this, Vd, Vm, shift);
break;
default:
UNREACHABLE();
break;
}
} else if (instr->Bits(11, 8) == 0x5 && instr->Bit(6) == 0 &&
instr->Bit(4) == 1) {
// vsli.<size> Dd, Dm, shift
int imm7 = instr->Bits(21, 16);
if (instr->Bit(7) != 0) imm7 += 64;
int size = base::bits::RoundDownToPowerOfTwo32(imm7);
int shift = imm7 - size;
int Vd = instr->VFPDRegValue(kDoublePrecision);
int Vm = instr->VFPMRegValue(kDoublePrecision);
switch (size) {
case 8:
ShiftLeftAndInsert<uint8_t, kDoubleSize>(this, Vd, Vm, shift);
break;
case 16:
ShiftLeftAndInsert<uint16_t, kDoubleSize>(this, Vd, Vm, shift);
break;
case 32:
ShiftLeftAndInsert<uint32_t, kDoubleSize>(this, Vd, Vm, shift);
break;
case 64:
ShiftLeftAndInsert<uint64_t, kDoubleSize>(this, Vd, Vm, shift);
break;
default:
UNREACHABLE();
break;
}
} else if (instr->Bits(11, 8) == 0x4 && instr->Bit(6) == 0 &&
instr->Bit(4) == 1) {
// vsri.<size> Dd, Dm, shift
int imm7 = instr->Bits(21, 16);
if (instr->Bit(7) != 0) imm7 += 64;
int size = base::bits::RoundDownToPowerOfTwo32(imm7);
int shift = 2 * size - imm7;
int Vd = instr->VFPDRegValue(kDoublePrecision);
int Vm = instr->VFPMRegValue(kDoublePrecision);
switch (size) {
case 8:
ShiftRightAndInsert<uint8_t, kDoubleSize>(this, Vd, Vm, shift);
break;
case 16:
ShiftRightAndInsert<uint16_t, kDoubleSize>(this, Vd, Vm, shift);
break;
case 32:
ShiftRightAndInsert<uint32_t, kDoubleSize>(this, Vd, Vm, shift);
break;
case 64:
ShiftRightAndInsert<uint64_t, kDoubleSize>(this, Vd, Vm, shift);
break;
default:
UNREACHABLE();
break;
}
} else {
UNIMPLEMENTED();
}
break;
case 8:
if (instr->Bits(21, 20) == 0) {
// vst1
int Vd = (instr->Bit(22) << 4) | instr->VdValue();
int Rn = instr->VnValue();
int type = instr->Bits(11, 8);
int Rm = instr->VmValue();
int32_t address = get_register(Rn);
int regs = 0;
switch (type) {
case nlt_1:
regs = 1;
break;
case nlt_2:
regs = 2;
break;
case nlt_3:
regs = 3;
break;
case nlt_4:
regs = 4;
break;
default:
UNIMPLEMENTED();
break;
}
int r = 0;
while (r < regs) {
uint32_t data[2];
get_d_register(Vd + r, data);
WriteW(address, data[0], instr);
WriteW(address + 4, data[1], instr);
address += 8;
r++;
}
if (Rm != 15) {
if (Rm == 13) {
set_register(Rn, address);
} else {
set_register(Rn, get_register(Rn) + get_register(Rm));
}
}
} else if (instr->Bits(21, 20) == 2) {
// vld1
int Vd = (instr->Bit(22) << 4) | instr->VdValue();
int Rn = instr->VnValue();
int type = instr->Bits(11, 8);
int Rm = instr->VmValue();
int32_t address = get_register(Rn);
int regs = 0;
switch (type) {
case nlt_1:
regs = 1;
break;
case nlt_2:
regs = 2;
break;
case nlt_3:
regs = 3;
break;
case nlt_4:
regs = 4;
break;
default:
UNIMPLEMENTED();
break;
}
int r = 0;
while (r < regs) {
uint32_t data[2];
data[0] = ReadW(address, instr);
data[1] = ReadW(address + 4, instr);
set_d_register(Vd + r, data);
address += 8;
r++;
}
if (Rm != 15) {
if (Rm == 13) {
set_register(Rn, address);
} else {
set_register(Rn, get_register(Rn) + get_register(Rm));
}
}
} else {
UNIMPLEMENTED();
}
break;
case 0xA:
case 0xB:
if ((instr->Bits(22, 20) == 5) && (instr->Bits(15, 12) == 0xF)) {
// pld: ignore instruction.
} else if (instr->SpecialValue() == 0xA && instr->Bits(22, 20) == 7) {
// dsb, dmb, isb: ignore instruction for now.
// TODO(binji): implement
// Also refer to the ARMv6 CP15 equivalents in DecodeTypeCP15.
} else {
UNIMPLEMENTED();
}
break;
case 0x1D:
if (instr->Opc1Value() == 0x7 && instr->Opc3Value() == 0x1 &&
instr->Bits(11, 9) == 0x5 && instr->Bits(19, 18) == 0x2) {
if (instr->SzValue() == 0x1) {
int vm = instr->VFPMRegValue(kDoublePrecision);
int vd = instr->VFPDRegValue(kDoublePrecision);
double dm_value = get_double_from_d_register(vm).get_scalar();
double dd_value = 0.0;
int rounding_mode = instr->Bits(17, 16);
switch (rounding_mode) {
case 0x0: // vrinta - round with ties to away from zero
dd_value = round(dm_value);
break;
case 0x1: { // vrintn - round with ties to even
dd_value = nearbyint(dm_value);
break;
}
case 0x2: // vrintp - ceil
dd_value = ceil(dm_value);
break;
case 0x3: // vrintm - floor
dd_value = floor(dm_value);
break;
default:
UNREACHABLE(); // Case analysis is exhaustive.
break;
}
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(vd, dd_value);
} else {
int m = instr->VFPMRegValue(kSinglePrecision);
int d = instr->VFPDRegValue(kSinglePrecision);
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value = 0.0;
int rounding_mode = instr->Bits(17, 16);
switch (rounding_mode) {
case 0x0: // vrinta - round with ties to away from zero
sd_value = roundf(sm_value);
break;
case 0x1: { // vrintn - round with ties to even
sd_value = nearbyintf(sm_value);
break;
}
case 0x2: // vrintp - ceil
sd_value = ceilf(sm_value);
break;
case 0x3: // vrintm - floor
sd_value = floorf(sm_value);
break;
default:
UNREACHABLE(); // Case analysis is exhaustive.
break;
}
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else if ((instr->Opc1Value() == 0x4) && (instr->Bits(11, 9) == 0x5) &&
(instr->Bit(4) == 0x0)) {
if (instr->SzValue() == 0x1) {
int m = instr->VFPMRegValue(kDoublePrecision);
int n = instr->VFPNRegValue(kDoublePrecision);
int d = instr->VFPDRegValue(kDoublePrecision);
double dn_value = get_double_from_d_register(n).get_scalar();
double dm_value = get_double_from_d_register(m).get_scalar();
double dd_value;
if (instr->Bit(6) == 0x1) { // vminnm
if ((dn_value < dm_value) || std::isnan(dm_value)) {
dd_value = dn_value;
} else if ((dm_value < dn_value) || std::isnan(dn_value)) {
dd_value = dm_value;
} else {
DCHECK_EQ(dn_value, dm_value);
// Make sure that we pick the most negative sign for +/-0.
dd_value = std::signbit(dn_value) ? dn_value : dm_value;
}
} else { // vmaxnm
if ((dn_value > dm_value) || std::isnan(dm_value)) {
dd_value = dn_value;
} else if ((dm_value > dn_value) || std::isnan(dn_value)) {
dd_value = dm_value;
} else {
DCHECK_EQ(dn_value, dm_value);
// Make sure that we pick the most positive sign for +/-0.
dd_value = std::signbit(dn_value) ? dm_value : dn_value;
}
}
dd_value = canonicalizeNaN(dd_value);
set_d_register_from_double(d, dd_value);
} else {
int m = instr->VFPMRegValue(kSinglePrecision);
int n = instr->VFPNRegValue(kSinglePrecision);
int d = instr->VFPDRegValue(kSinglePrecision);
float sn_value = get_float_from_s_register(n).get_scalar();
float sm_value = get_float_from_s_register(m).get_scalar();
float sd_value;
if (instr->Bit(6) == 0x1) { // vminnm
if ((sn_value < sm_value) || std::isnan(sm_value)) {
sd_value = sn_value;
} else if ((sm_value < sn_value) || std::isnan(sn_value)) {
sd_value = sm_value;
} else {
DCHECK_EQ(sn_value, sm_value);
// Make sure that we pick the most negative sign for +/-0.
sd_value = std::signbit(sn_value) ? sn_value : sm_value;
}
} else { // vmaxnm
if ((sn_value > sm_value) || std::isnan(sm_value)) {
sd_value = sn_value;
} else if ((sm_value > sn_value) || std::isnan(sn_value)) {
sd_value = sm_value;
} else {
DCHECK_EQ(sn_value, sm_value);
// Make sure that we pick the most positive sign for +/-0.
sd_value = std::signbit(sn_value) ? sm_value : sn_value;
}
}
sd_value = canonicalizeNaN(sd_value);
set_s_register_from_float(d, sd_value);
}
} else {
UNIMPLEMENTED();
}
break;
case 0x1C:
if ((instr->Bits(11, 9) == 0x5) && (instr->Bit(6) == 0) &&
(instr->Bit(4) == 0)) {
// VSEL* (floating-point)
bool condition_holds;
switch (instr->Bits(21, 20)) {
case 0x0: // VSELEQ
condition_holds = (z_flag_ == 1);
break;
case 0x1: // VSELVS
condition_holds = (v_flag_ == 1);
break;
case 0x2: // VSELGE
condition_holds = (n_flag_ == v_flag_);
break;
case 0x3: // VSELGT
condition_holds = ((z_flag_ == 0) && (n_flag_ == v_flag_));
break;
default:
UNREACHABLE(); // Case analysis is exhaustive.
break;
}
if (instr->SzValue() == 0x1) {
int n = instr->VFPNRegValue(kDoublePrecision);
int m = instr->VFPMRegValue(kDoublePrecision);
int d = instr->VFPDRegValue(kDoublePrecision);
Float64 result = get_double_from_d_register(condition_holds ? n : m);
set_d_register_from_double(d, result);
} else {
int n = instr->VFPNRegValue(kSinglePrecision);
int m = instr->VFPMRegValue(kSinglePrecision);
int d = instr->VFPDRegValue(kSinglePrecision);
Float32 result = get_float_from_s_register(condition_holds ? n : m);
set_s_register_from_float(d, result);
}
} else {
UNIMPLEMENTED();
}
break;
default:
UNIMPLEMENTED();
break;
}
}
// Executes the current instruction.
void Simulator::InstructionDecode(Instruction* instr) {
if (v8::internal::FLAG_check_icache) {
CheckICache(i_cache(), instr);
}
pc_modified_ = false;
if (::v8::internal::FLAG_trace_sim) {
disasm::NameConverter converter;
disasm::Disassembler dasm(converter);
// use a reasonably large buffer
v8::internal::EmbeddedVector<char, 256> buffer;
dasm.InstructionDecode(buffer,
reinterpret_cast<byte*>(instr));
PrintF(" 0x%08" V8PRIxPTR " %s\n", reinterpret_cast<intptr_t>(instr),
buffer.start());
}
if (instr->ConditionField() == kSpecialCondition) {
DecodeSpecialCondition(instr);
} else if (ConditionallyExecute(instr)) {
switch (instr->TypeValue()) {
case 0:
case 1: {
DecodeType01(instr);
break;
}
case 2: {
DecodeType2(instr);
break;
}
case 3: {
DecodeType3(instr);
break;
}
case 4: {
DecodeType4(instr);
break;
}
case 5: {
DecodeType5(instr);
break;
}
case 6: {
DecodeType6(instr);
break;
}
case 7: {
DecodeType7(instr);
break;
}
default: {
UNIMPLEMENTED();
break;
}
}
}
if (!pc_modified_) {
set_register(pc, reinterpret_cast<int32_t>(instr)
+ Instruction::kInstrSize);
}
}
void Simulator::Execute() {
// Get the PC to simulate. Cannot use the accessor here as we need the
// raw PC value and not the one used as input to arithmetic instructions.
int program_counter = get_pc();
if (::v8::internal::FLAG_stop_sim_at == 0) {
// Fast version of the dispatch loop without checking whether the simulator
// should be stopping at a particular executed instruction.
while (program_counter != end_sim_pc) {
Instruction* instr = reinterpret_cast<Instruction*>(program_counter);
icount_++;
InstructionDecode(instr);
program_counter = get_pc();
}
} else {
// FLAG_stop_sim_at is at the non-default value. Stop in the debugger when
// we reach the particular instruction count.
while (program_counter != end_sim_pc) {
Instruction* instr = reinterpret_cast<Instruction*>(program_counter);
icount_++;
if (icount_ == ::v8::internal::FLAG_stop_sim_at) {
ArmDebugger dbg(this);
dbg.Debug();
} else {
InstructionDecode(instr);
}
program_counter = get_pc();
}
}
}
void Simulator::CallInternal(Address entry) {
// Adjust JS-based stack limit to C-based stack limit.
isolate_->stack_guard()->AdjustStackLimitForSimulator();
// Prepare to execute the code at entry
set_register(pc, static_cast<int32_t>(entry));
// Put down marker for end of simulation. The simulator will stop simulation
// when the PC reaches this value. By saving the "end simulation" value into
// the LR the simulation stops when returning to this call point.
set_register(lr, end_sim_pc);
// Remember the values of callee-saved registers.
// The code below assumes that r9 is not used as sb (static base) in
// simulator code and therefore is regarded as a callee-saved register.
int32_t r4_val = get_register(r4);
int32_t r5_val = get_register(r5);
int32_t r6_val = get_register(r6);
int32_t r7_val = get_register(r7);
int32_t r8_val = get_register(r8);
int32_t r9_val = get_register(r9);
int32_t r10_val = get_register(r10);
int32_t r11_val = get_register(r11);
// Set up the callee-saved registers with a known value. To be able to check
// that they are preserved properly across JS execution.
int32_t callee_saved_value = icount_;
set_register(r4, callee_saved_value);
set_register(r5, callee_saved_value);
set_register(r6, callee_saved_value);
set_register(r7, callee_saved_value);
set_register(r8, callee_saved_value);
set_register(r9, callee_saved_value);
set_register(r10, callee_saved_value);
set_register(r11, callee_saved_value);
// Start the simulation
Execute();
// Check that the callee-saved registers have been preserved.
CHECK_EQ(callee_saved_value, get_register(r4));
CHECK_EQ(callee_saved_value, get_register(r5));
CHECK_EQ(callee_saved_value, get_register(r6));
CHECK_EQ(callee_saved_value, get_register(r7));
CHECK_EQ(callee_saved_value, get_register(r8));
CHECK_EQ(callee_saved_value, get_register(r9));
CHECK_EQ(callee_saved_value, get_register(r10));
CHECK_EQ(callee_saved_value, get_register(r11));
// Restore callee-saved registers with the original value.
set_register(r4, r4_val);
set_register(r5, r5_val);
set_register(r6, r6_val);
set_register(r7, r7_val);
set_register(r8, r8_val);
set_register(r9, r9_val);
set_register(r10, r10_val);
set_register(r11, r11_val);
}
intptr_t Simulator::CallImpl(Address entry, int argument_count,
const intptr_t* arguments) {
// Set up arguments
// First four arguments passed in registers.
int reg_arg_count = std::min(4, argument_count);
if (reg_arg_count > 0) set_register(r0, arguments[0]);
if (reg_arg_count > 1) set_register(r1, arguments[1]);
if (reg_arg_count > 2) set_register(r2, arguments[2]);
if (reg_arg_count > 3) set_register(r3, arguments[3]);
// Remaining arguments passed on stack.
int original_stack = get_register(sp);
// Compute position of stack on entry to generated code.
int entry_stack = (original_stack - (argument_count - 4) * sizeof(int32_t));
if (base::OS::ActivationFrameAlignment() != 0) {
entry_stack &= -base::OS::ActivationFrameAlignment();
}
// Store remaining arguments on stack, from low to high memory.
memcpy(reinterpret_cast<intptr_t*>(entry_stack), arguments + reg_arg_count,
(argument_count - reg_arg_count) * sizeof(*arguments));
set_register(sp, entry_stack);
CallInternal(entry);
// Pop stack passed arguments.
CHECK_EQ(entry_stack, get_register(sp));
set_register(sp, original_stack);
return get_register(r0);
}
intptr_t Simulator::CallFPImpl(Address entry, double d0, double d1) {
if (use_eabi_hardfloat()) {
set_d_register_from_double(0, d0);
set_d_register_from_double(1, d1);
} else {
set_register_pair_from_double(0, &d0);
set_register_pair_from_double(2, &d1);
}
CallInternal(entry);
return get_register(r0);
}
uintptr_t Simulator::PushAddress(uintptr_t address) {
int new_sp = get_register(sp) - sizeof(uintptr_t);
uintptr_t* stack_slot = reinterpret_cast<uintptr_t*>(new_sp);
*stack_slot = address;
set_register(sp, new_sp);
return new_sp;
}
uintptr_t Simulator::PopAddress() {
int current_sp = get_register(sp);
uintptr_t* stack_slot = reinterpret_cast<uintptr_t*>(current_sp);
uintptr_t address = *stack_slot;
set_register(sp, current_sp + sizeof(uintptr_t));
return address;
}
Simulator::LocalMonitor::LocalMonitor()
: access_state_(MonitorAccess::Open),
tagged_addr_(0),
size_(TransactionSize::None) {}
void Simulator::LocalMonitor::Clear() {
access_state_ = MonitorAccess::Open;
tagged_addr_ = 0;
size_ = TransactionSize::None;
}
void Simulator::LocalMonitor::NotifyLoad(int32_t addr) {
if (access_state_ == MonitorAccess::Exclusive) {
// A load could cause a cache eviction which will affect the monitor. As a
// result, it's most strict to unconditionally clear the local monitor on
// load.
Clear();
}
}
void Simulator::LocalMonitor::NotifyLoadExcl(int32_t addr,
TransactionSize size) {
access_state_ = MonitorAccess::Exclusive;
tagged_addr_ = addr;
size_ = size;
}
void Simulator::LocalMonitor::NotifyStore(int32_t addr) {
if (access_state_ == MonitorAccess::Exclusive) {
// It is implementation-defined whether a non-exclusive store to an address
// covered by the local monitor during exclusive access transitions to open
// or exclusive access. See ARM DDI 0406C.b, A3.4.1.
//
// However, a store could cause a cache eviction which will affect the
// monitor. As a result, it's most strict to unconditionally clear the
// local monitor on store.
Clear();
}
}
bool Simulator::LocalMonitor::NotifyStoreExcl(int32_t addr,
TransactionSize size) {
if (access_state_ == MonitorAccess::Exclusive) {
// It is allowed for a processor to require that the address matches
// exactly (A3.4.5), so this comparison does not mask addr.
if (addr == tagged_addr_ && size_ == size) {
Clear();
return true;
} else {
// It is implementation-defined whether an exclusive store to a
// non-tagged address will update memory. Behavior is unpredictable if
// the transaction size of the exclusive store differs from that of the
// exclusive load. See ARM DDI 0406C.b, A3.4.5.
Clear();
return false;
}
} else {
DCHECK(access_state_ == MonitorAccess::Open);
return false;
}
}
Simulator::GlobalMonitor::Processor::Processor()
: access_state_(MonitorAccess::Open),
tagged_addr_(0),
next_(nullptr),
prev_(nullptr),
failure_counter_(0) {}
void Simulator::GlobalMonitor::Processor::Clear_Locked() {
access_state_ = MonitorAccess::Open;
tagged_addr_ = 0;
}
void Simulator::GlobalMonitor::Processor::NotifyLoadExcl_Locked(int32_t addr) {
access_state_ = MonitorAccess::Exclusive;
tagged_addr_ = addr;
}
void Simulator::GlobalMonitor::Processor::NotifyStore_Locked(
int32_t addr, bool is_requesting_processor) {
if (access_state_ == MonitorAccess::Exclusive) {
// It is implementation-defined whether a non-exclusive store by the
// requesting processor to an address covered by the global monitor
// during exclusive access transitions to open or exclusive access.
//
// For any other processor, the access state always transitions to open
// access.
//
// See ARM DDI 0406C.b, A3.4.2.
//
// However, similar to the local monitor, it is possible that a store
// caused a cache eviction, which can affect the montior, so
// conservatively, we always clear the monitor.
Clear_Locked();
}
}
bool Simulator::GlobalMonitor::Processor::NotifyStoreExcl_Locked(
int32_t addr, bool is_requesting_processor) {
if (access_state_ == MonitorAccess::Exclusive) {
if (is_requesting_processor) {
// It is allowed for a processor to require that the address matches
// exactly (A3.4.5), so this comparison does not mask addr.
if (addr == tagged_addr_) {
// The access state for the requesting processor after a successful
// exclusive store is implementation-defined, but according to the ARM
// DDI, this has no effect on the subsequent operation of the global
// monitor.
Clear_Locked();
// Introduce occasional strex failures. This is to simulate the
// behavior of hardware, which can randomly fail due to background
// cache evictions.
if (failure_counter_++ >= kMaxFailureCounter) {
failure_counter_ = 0;
return false;
} else {
return true;
}
}
} else if ((addr & kExclusiveTaggedAddrMask) ==
(tagged_addr_ & kExclusiveTaggedAddrMask)) {
// Check the masked addresses when responding to a successful lock by
// another processor so the implementation is more conservative (i.e. the
// granularity of locking is as large as possible.)
Clear_Locked();
return false;
}
}
return false;
}
Simulator::GlobalMonitor::GlobalMonitor() : head_(nullptr) {}
void Simulator::GlobalMonitor::NotifyLoadExcl_Locked(int32_t addr,
Processor* processor) {
processor->NotifyLoadExcl_Locked(addr);
PrependProcessor_Locked(processor);
}
void Simulator::GlobalMonitor::NotifyStore_Locked(int32_t addr,
Processor* processor) {
// Notify each processor of the store operation.
for (Processor* iter = head_; iter; iter = iter->next_) {
bool is_requesting_processor = iter == processor;
iter->NotifyStore_Locked(addr, is_requesting_processor);
}
}
bool Simulator::GlobalMonitor::NotifyStoreExcl_Locked(int32_t addr,
Processor* processor) {
DCHECK(IsProcessorInLinkedList_Locked(processor));
if (processor->NotifyStoreExcl_Locked(addr, true)) {
// Notify the other processors that this StoreExcl succeeded.
for (Processor* iter = head_; iter; iter = iter->next_) {
if (iter != processor) {
iter->NotifyStoreExcl_Locked(addr, false);
}
}
return true;
} else {
return false;
}
}
bool Simulator::GlobalMonitor::IsProcessorInLinkedList_Locked(
Processor* processor) const {
return head_ == processor || processor->next_ || processor->prev_;
}
void Simulator::GlobalMonitor::PrependProcessor_Locked(Processor* processor) {
if (IsProcessorInLinkedList_Locked(processor)) {
return;
}
if (head_) {
head_->prev_ = processor;
}
processor->prev_ = nullptr;
processor->next_ = head_;
head_ = processor;
}
void Simulator::GlobalMonitor::RemoveProcessor(Processor* processor) {
base::LockGuard<base::Mutex> lock_guard(&mutex);
if (!IsProcessorInLinkedList_Locked(processor)) {
return;
}
if (processor->prev_) {
processor->prev_->next_ = processor->next_;
} else {
head_ = processor->next_;
}
if (processor->next_) {
processor->next_->prev_ = processor->prev_;
}
processor->prev_ = nullptr;
processor->next_ = nullptr;
}
} // namespace internal
} // namespace v8
#endif // USE_SIMULATOR
#endif // V8_TARGET_ARCH_ARM
| [
"madanagopal_thirumalai@comcast.com"
] | madanagopal_thirumalai@comcast.com |
164f6620e6df1402cb1b6512ed3e8d7a04cfbef3 | 2ea1df8ee5b919b3d076fa192bce2081340e0cce | /OOP_Lab_08/Strategy/Newspaper.cpp | 2d0acbe555f76591e72398559c2f38b0c295428c | [] | no_license | nadiyafomenko/OOP | a8c6efdb635951bd65f7a3f6dcd4ca916bb5f42b | 14ccc533c7d87d79175cb505329fec669ed4ad03 | refs/heads/master | 2021-04-10T20:39:34.812484 | 2020-06-15T16:28:44 | 2020-06-15T16:28:44 | 248,963,871 | 0 | 1 | null | 2020-03-21T13:39:06 | 2020-03-21T11:40:06 | C++ | UTF-8 | C++ | false | false | 1,343 | cpp | #include "Newspaper.h"
#include "PrintedProducts.h"
void Newspaper::Print(std::ostream& out)
{
out
<< "Newspaper table: " << std::endl
<< "Title:" << "\t\t\t\t" << GetTitle() << std::endl
<< "Author:" << "\t\t\t\t" << GetAuthorName() << std::endl
<< "Pages:" << "\t\t\t\t" << GetPages() << std::endl
<< "Page size:" << "\t\t\t" << GetPageWidth() << " x " << GetPageHeight() << std::endl
<< "Amount:" << "\t\t\t\t" << GetAmount() << std::endl
<< "Period:" << "\t\t\t\t" << GetPeriod() << std::endl;
}
Newspaper::Newspaper() : PrintedProducts()
{
this->Amount = 0;
this->pageHeight = 0;
this->pageWidth = 0;
this->Period = 0;
}
Newspaper::Newspaper(
const std::string AuthorName,
const std::string title,
const double pages,
const int pageHeight,
const int pageWidth,
const int Amount,
const int Period) : PrintedProducts(AuthorName, title, pages)
{
if (Amount < 0) {
throw "wrong amount";
}
this->pageHeight = pageHeight;
this->pageWidth = pageWidth;
this->Amount = Amount;
this->Period = Period;
}
Newspaper::~Newspaper() { }
const int Newspaper::GetAmount() const
{
return this->Amount;
}
const int Newspaper::GetPeriod() const
{
return this->Period;
}
const int Newspaper::GetPageHeight() const
{
return this->pageHeight;
}
const int Newspaper::GetPageWidth() const
{
return this->pageWidth;
}
| [
"47325620+nadiyafomenko@users.noreply.github.com"
] | 47325620+nadiyafomenko@users.noreply.github.com |
eda02bf7db83d6bf3105dcc429ca94f232bc6562 | b7ee5b78d5e48ba336e0a252cfe99c76def8f27d | /src/renderers/samplerrenderer.h | b27bd53b231f086d0a57ad5786b718c83a73bf74 | [
"BSD-2-Clause"
] | permissive | mgharbi/rendernet_pbrt | f09796532600b1cd876b4a02bb1c80ecf2fb6ed7 | 8dce288eea765f0e472af6906968dcd6e2b1f7c7 | refs/heads/master | 2020-03-31T18:03:51.772096 | 2019-04-21T13:33:31 | 2019-04-21T13:33:31 | 152,445,182 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,312 | h |
/*
pbrt source code Copyright(c) 1998-2012 Matt Pharr and Greg Humphreys.
This file is part of pbrt.
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.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef PBRT_RENDERERS_SAMPLERRENDERER_H
#define PBRT_RENDERERS_SAMPLERRENDERER_H
// renderers/samplerrenderer.h*
#include "pbrt.h"
#include "renderer.h"
#include "parallel.h"
// SamplerRenderer Declarations
class SamplerRenderer : public Renderer {
public:
// SamplerRenderer Public Methods
SamplerRenderer(Sampler *s, Camera *c, SurfaceIntegrator *si,
VolumeIntegrator *vi, bool visIds);
~SamplerRenderer();
void Render(const Scene *scene);
Spectrum Li(const Scene *scene, const RayDifferential &ray,
const Sample *sample, RNG &rng, MemoryArena &arena,
Intersection *isect = NULL, Spectrum *T = NULL) const;
Spectrum Transmittance(const Scene *scene, const RayDifferential &ray,
const Sample *sample, RNG &rng, MemoryArena &arena) const;
private:
// SamplerRenderer Private Data
bool visualizeObjectIds;
Sampler *sampler;
Camera *camera;
SurfaceIntegrator *surfaceIntegrator;
VolumeIntegrator *volumeIntegrator;
};
// SamplerRendererTask Declarations
class SamplerRendererTask : public Task {
public:
// SamplerRendererTask Public Methods
SamplerRendererTask(const Scene *sc, Renderer *ren, Camera *c,
ProgressReporter &pr, Sampler *ms, Sample *sam,
bool visIds, int tn, int tc)
: reporter(pr)
{
scene = sc; renderer = ren; camera = c; mainSampler = ms;
origSample = sam; visualizeObjectIds = visIds; taskNum = tn; taskCount = tc;
}
void Run();
private:
// SamplerRendererTask Private Data
const Scene *scene;
const Renderer *renderer;
Camera *camera;
Sampler *mainSampler;
ProgressReporter &reporter;
Sample *origSample;
bool visualizeObjectIds;
int taskNum, taskCount;
};
#endif // PBRT_RENDERERS_SAMPLERRENDERER_H
| [
"gharbi@mit.edu"
] | gharbi@mit.edu |
faf69ce454a6653405b4cd3c8ea089a65f38871f | a6b5b78fe6f83a92231337e1cdd9ac20bc10d478 | /asio/j.cc | 5a84bd66c2609f46b23d83dca17c8f1415a477a4 | [
"CC0-1.0"
] | permissive | guoxiaoyong/simple-useful | faf33b03f3772f78bbfd5e8050244ac365d90713 | 63f483250cc5e96ef112aac7499ab9e3a35572a8 | refs/heads/master | 2023-03-09T11:51:56.168743 | 2020-06-13T23:14:07 | 2020-06-13T23:14:07 | 43,603,113 | 0 | 0 | CC0-1.0 | 2023-03-01T12:30:26 | 2015-10-03T15:12:43 | Jupyter Notebook | UTF-8 | C++ | false | false | 1,459 | cc | //
// server.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include <ctime>
#include <iostream>
#include <string>
#include <boost/array.hpp>
#include <boost/asio.hpp>
using boost::asio::ip::udp;
std::string make_daytime_string()
{
using namespace std; // For time_t, time and ctime;
time_t now = time(0);
return ctime(&now);
}
int main()
{
try
{
boost::asio::io_service io_service;
udp::socket socket(io_service, udp::endpoint(udp::v4(), 13));
for (;;)
{
boost::array<char, 1> recv_buf;
udp::endpoint remote_endpoint;
boost::system::error_code error;
socket.receive_from(boost::asio::buffer(recv_buf),
remote_endpoint, 0, error);
if (error && error != boost::asio::error::message_size)
throw boost::system::system_error(error);
std::string message = make_daytime_string();
boost::system::error_code ignored_error;
socket.send_to(boost::asio::buffer(message),
remote_endpoint, 0, ignored_error);
}
}
catch (std::exception& e)
{
std::cerr << e.what() << std::endl;
}
return 0;
}
| [
"guo.xiaoyong@gmail.com"
] | guo.xiaoyong@gmail.com |
aa4581b8d9dfbb67b507c4d7e76615c61b2123a4 | 48a73a0ba850ac2925118dd304baa8f7b2874582 | /C++/source/HttpInterface/HttpInterfaceMethodWorker.cpp | 692f5cb4e0708da0f4671701e36b4e267ca250d0 | [
"Apache-2.0"
] | permissive | cxvisa/Wave | 5e66dfbe32c85405bc2761c509ba8507ff66f8fe | 1aca714933ff1df53d660f038c76ca3f2202bf4a | refs/heads/master | 2021-05-03T15:00:49.991391 | 2018-03-31T23:06:40 | 2018-03-31T23:06:40 | 56,774,204 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,123 | cpp | /***************************************************************************
* Copyright (C) 2005-2011 Vidyasagara Guntaka *
* All rights reserved. *
* Author : Vidyasagara Reddy Guntaka *
***************************************************************************/
#include "HttpInterface/HttpInterfaceMethodWorker.h"
#include "HttpInterface/HttpInterfaceReceiverObjectManager.h"
namespace WaveNs
{
HttpInterfaceMethodWorker::HttpInterfaceMethodWorker (HttpInterfaceReceiverObjectManager* pHttpInterfaceReceiverObjectManager, const WaveHttpInterfaceMethod& waveHttpInterfaceMethod)
: WaveWorker (pHttpInterfaceReceiverObjectManager),
m_waveHttpInterfaceMethod (waveHttpInterfaceMethod)
{
pHttpInterfaceReceiverObjectManager->addHttpInterfaceMethodWorker (waveHttpInterfaceMethod, this);
}
HttpInterfaceMethodWorker::~HttpInterfaceMethodWorker()
{
}
WaveHttpInterfaceMethod HttpInterfaceMethodWorker::getWaveHttpInterfaceMethod () const
{
return (m_waveHttpInterfaceMethod);
}
}
| [
"sagar@wave.sagar.cisco.com"
] | sagar@wave.sagar.cisco.com |
11ce43bc04e9b2ae857ff37009196d95d732c543 | 4feaa7c33d6ad4885de30b90568a909332cbe334 | /main.cpp | 7fa2c6c41cc5f43798188597b8977ea2604a3b73 | [] | no_license | WilliamAuCS/Edit-Distance | a71165f0cf2f17728d7467d119f87504a95cce61 | a32dd497335d5e5c9574c957f02c10038c720796 | refs/heads/master | 2020-09-13T16:32:14.582349 | 2019-11-20T19:07:30 | 2019-11-20T19:07:30 | 222,842,074 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 123 | cpp | #include <iostream>
#include "Edits.cpp"
int main()
{
EditDistance edit;
edit.findMatrix("broad", "board");
return 0;
} | [
"WilliamAuCS@gmail.com"
] | WilliamAuCS@gmail.com |
e3ddc06da817b5b6fff697c858b4e2b1c41e14ed | 427419228ca489739e16c380d7bc68a6ef509e5a | /A_Colorful_Stones_Simplified_Edition_.cpp | d575549318212f810f562f4ef50aa95b16266e17 | [] | no_license | wolverinezgit/cpsolutions | d5dca485190a27f4d27e9610cd6ea02d98a50072 | e0e695036cbd4c51ec9bf57d585b40204c8566a1 | refs/heads/main | 2023-03-10T12:31:27.848231 | 2021-02-18T13:04:00 | 2021-02-18T13:04:00 | 332,387,127 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 550 | cpp | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mp make_pair
#define pb push_back
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
int main()
{
fast_cin();
ll t,i,n,j,flag=0,mx=0,mn=1e9+7;
string s1, s2;
cin >> s1 >> s2;
ll p1 = 0;
for (i = 0; i < s2.length();i++)
{
if(s1[p1]==s2[i])
p1++;
}
cout << p1 + 1 << endl;
return 0;
} | [
"iamharsh05@gmail.com"
] | iamharsh05@gmail.com |
5277bb9e1686556c1da0c5c00fe0a54979a1d648 | 6d9133176e013e4145d8ea785f6927b72ae678b7 | /Cyborg/src/cNeck.cpp | c6b5dc4e6a56437e3315aef4f98f96ba9d772bd3 | [] | no_license | Memaguer/OpenGL_Cyborg | cc2a18285718ea27e0c0035935329464df66551c | 02ae38db99b02a641f42ac27dde8c099bbfef454 | refs/heads/master | 2021-05-03T11:14:49.619732 | 2018-02-07T01:44:05 | 2018-02-07T01:44:05 | 120,547,765 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 536 | cpp | //
// cNeck.cpp
// Cyborg
//
// Created by MBG on 2/5/18.
// Copyright ยฉ 2018 MBG. All rights reserved.
//
#include "cNeck.hpp"
Neck::Neck()
{
neck = new Part(1, 1, 1);
head = new Head();
}
Neck::~Neck()
{
delete neck;
delete head;
}
void Neck::draw()
{
// ############## NECK #############
glTranslatef(0, 0.6, 0);
glScalef(0.25, 0.3, 0.3);
neck -> draw();
// ####### HEAD #######
glPushMatrix();
{
head -> draw();
}
glPopMatrix();
}
void Neck:: update()
{
}
| [
"gbarrientos@alabool.mx"
] | gbarrientos@alabool.mx |
0582b1edaf1466093b64f9fbc5b5f33d68cf7469 | ec0a5d5ddf5436ddeebc095341c95ffb4cc0c471 | /core/utils/LinearInterpolator.h | 64269c51417af31f8e05a7f9fcfbf684a161c690 | [
"MIT"
] | permissive | egbaquela/CODeM-Toolkit | ca08e8c26fd8fab58da217e958aa71d708f20f57 | c08f578bd54a5de9abd459d6f3f320db2991764a | refs/heads/master | 2020-03-20T19:45:04.086811 | 2018-07-05T01:09:31 | 2018-07-05T01:09:31 | 137,651,950 | 0 | 0 | null | 2018-06-17T12:02:48 | 2018-06-17T12:02:47 | null | UTF-8 | C++ | false | false | 2,196 | h | /****************************************************************************
**
** The MIT License (MIT)
**
** Copyright (c) 2016 The University of Sheffield (www.sheffield.ac.uk)
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to deal
** in the Software without restriction, including without limitation the rights
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
** copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in all
** copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
** SOFTWARE
**
****************************************************************************/
#ifndef LINEARINTERPOLATOR_H
#define LINEARINTERPOLATOR_H
#include <core/CODeMGlobal.h>
#include <vector>
namespace CODeM {
namespace Utils {
class LinearInterpolator
{
public:
LinearInterpolator(std::vector<double> xv, std::vector<double> yv);
~LinearInterpolator();
double interpolate(double xq);
std::vector<double> interpolateV(std::vector<double> xq);
virtual void defineXY(std::vector<double> x, std::vector<double> y);
bool isConfigured();
protected:
double baseInterpolate(int j, double x);
int locate(const double x);
int hunt(const double x);
virtual bool checkConfiguration();
int n;
int mm;
int jsav;
int cor;
int dj;
bool m_isConfigured;
std::vector<double> xx;
std::vector<double> yy;
};
} // namespace Utils
} // namespace CODeM
#endif // LINEARINTERPOLATOR_H
| [
"s.salomon@sheffield.ac.uk"
] | s.salomon@sheffield.ac.uk |
f1409e22bea3c7f76058e8d2ad666776a6c55e36 | 3cd1fa9c7282a351975bf4bc57e2feb2017cd795 | /data_structures/lab-5/lab_5.cpp | a151963fc96017afd47148529bf94cedfc16a16e | [] | no_license | ReznikovRoman/mirea-hw | f1ce52a4a6dca977c072cc7d2e19bc2376fda1ce | c4cdc8bc5f9ed8fb71e336da58e68e056da07e2b | refs/heads/master | 2023-05-08T09:45:27.979411 | 2021-06-02T17:40:10 | 2021-06-02T17:40:10 | 292,531,575 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,623 | cpp | #include <string>
#include <iostream>
#include <stack>
using namespace std;
// ะะฐะดะฐะฝะธะต 1
// ะะพะปััะฐะตะผ ะฟัะธะพัะธัะตั ะพะฟะตัะฐัะพัะพะฒ
int getOperatorsPrecedence(char c)
{
if (c == '^')
return 3;
else if (c == '*' || c == '/')
return 2;
else if (c == '+' || c == '-')
return 1;
else
return -1;
}
// ะะพะฝะฒะตััะธััะตะผ ะธะฝัะธะบัะฝัั ัะพัะผั ะฒ ะฟะพัััะธะบัะฝัั
string infixToPostfix(string s)
{
stack<char> operationsStack;
string result;
for (int i = 0; i < s.length(); i++)
{
char c = s[i];
// ะะพะฑะฐะฒะปัะตะผ ะพะฟะตัะฐะฝะดั ะบ ัะตะทัะปััะฐัั
if ((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9'))
{
result += c;
}
// "ะะฑัะฐะฑะพัะบะฐ ัะบะพะฑะพะบ"
else if (c == '(')
operationsStack.push('(');
else if (c == ')')
{
while (!operationsStack.empty() && operationsStack.top() != '(')
{
char temp = operationsStack.top();
operationsStack.pop();
result += temp;
}
operationsStack.pop();
}
else
{
while (!operationsStack.empty() &&
getOperatorsPrecedence(s[i]) < getOperatorsPrecedence(operationsStack.top()))
{
char temp = operationsStack.top();
operationsStack.pop();
result += temp;
}
operationsStack.push(c);
}
}
// ะฃะฑะธัะฐะตะผ ะพััะฐะฒัะธะตัั ัะปะตะผะตะฝัั ะธะท ัััะบะฐ
while (!operationsStack.empty())
{
char temp = operationsStack.top();
operationsStack.pop();
result += temp;
}
return result;
}
// ะะฐะดะฐะฝะธะต - 2 (ััะตะบ ัะตะฐะปะธะทะพะฒะฐะฝ ั ะฟะพะผะพััั ัะฟะธัะบะฐ)
struct StackNode
{
int data;
StackNode *next;
};
StackNode *newNode(int data)
{
StackNode *stackNode = new StackNode();
stackNode->data = data;
stackNode->next = NULL;
return stackNode;
}
// 2 - "ะััั ะปะธ ััะตะบ"
int isEmpty(StackNode *root)
{
return !root;
}
// 2 - "ะะพัะบะฝััั ัะปะตะผะตะฝั ะฒ ััะตะบ"
void push(StackNode **root, int data)
{
StackNode *stackNode = newNode(data);
stackNode->next = *root;
*root = stackNode;
cout << data << " pushed to stack\n";
}
// 2 - "ะััะพะปะบะฝััั ัะปะตะผะตะฝั ะธะท ััะตะบ"
int pop(StackNode **root)
{
if (isEmpty(*root))
return INT_MIN;
StackNode *temp = *root;
*root = (*root)->next;
int popped = temp->data;
free(temp);
return popped;
}
// 2 - "ะะตัะฝััั ะทะฝะฐัะตะฝะธะต ะฒะตััะธะฝั ััะตะบะฐ"
int peek(StackNode *root)
{
if (isEmpty(root))
return INT_MIN;
return root->data;
}
void task1()
{
string exp = "((a+b)*c)";
cout << infixToPostfix(exp) << endl; // ab + c*
}
void task2()
{
StackNode *root = NULL;
push(&root, 1);
push(&root, 2);
push(&root, 3);
cout << pop(&root) << " has been popped from stack\n";
cout << "Top element is " << peek(root) << endl;
cout << "Elements in stack : ";
while (!isEmpty(root))
{
// ะัะฒะพะดะธะผ ะทะฝะฐัะตะฝะธะต "ะฒะตัั
ะฝะตะณะพ" ัะปะตะผะตะฝัะฐ
cout << peek(root) << " ";
// ะฃะดะฐะปัะตะผ ะทะฝะฐัะตะฝะธะต "ะฒะตัั
ะฝะตะณะพ" ัะปะตะผะตะฝัะฐ
pop(&root);
}
}
int main()
{
task1();
cout << endl;
task2();
cout << endl;
return 0;
}
| [
"romanreznikov2002@yandex.ru"
] | romanreznikov2002@yandex.ru |
ea040ae3d0c9228c1dfec95128fb32e5aeda2a29 | 84db845cc485c91e6dbc44e4944a85d27518c9a8 | /2018/2018_Jul/Week4/WF/wf_I_hdoj4642.cpp | 8b5eb95565527533ea170fefd760320422962bdc | [] | no_license | sunyinkai/ACM_ICPC | c13398c6963f0267db282e71d11baaf7ff619c71 | 8e54240df29b4a722efd27b5866384ba84f859a4 | refs/heads/master | 2021-07-07T07:39:36.553203 | 2020-07-26T06:50:54 | 2020-07-26T06:50:54 | 158,057,635 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 246 | cpp | #include<cstdio>
int main(){
int T;scanf("%d",&T);
while(T--){
int N,M;scanf("%d%d",&N,&M);
int num;
for(int i=0;i<N;++i)
for(int j=0;j<M;++j)
scanf("%d",&num);
if(num&1)printf("Alice\n");
else printf("Bob\n");
}
return 0;
}
| [
"1091491336@qq.com"
] | 1091491336@qq.com |
3bbbd5f278722dac8eff2e8d192736daa5643246 | 72392c0ff4ecd2cb024d7b59e3c9bcc036133e4e | /example3.cpp | 8964e5483b10ea02a47c2b56761e5aa9836a61e2 | [] | no_license | thomasphillips3/gists | 931658b394ce400b8a825d77af6d08620a3e3494 | 48e3861bb1fb5a25d2f29efef83d634b57e64ae2 | refs/heads/master | 2020-04-05T13:05:24.047257 | 2017-07-25T13:01:24 | 2017-07-25T13:01:24 | 95,075,015 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 418 | cpp | // https://developers.google.com/edu/c++/getting-started
// Example 3: What does this program output?
// Time tables
// Thomas Phillips
#include <iostream>
using namespace std;
int main(void) {
cout << " 1\t2\t3\t4\t5\t6\t7\t8\t9" << endl << "" << endl;
for (int c = 1; c < 10; c++) {
cout << c << "| ";
for (int i = 1; i < 10; i++) {
cout << i*c << '\t';
}
cout << endl;
}
return 0;
}
| [
"thomasphillips3@gmail.com"
] | thomasphillips3@gmail.com |
57ab20cbd07f2d017592cefb5c9ee2705358843c | ca31ca0a28d45606100ab38e52c529a9899a925c | /agl/kernel/matrixt.h | 951fab8a62ad429f227ca20bffd65372f11913d8 | [] | no_license | Arcen/MedicalImage | e30d1edac5013fcfbe129868fa0da174e91efff8 | bf44553c7dddfe98d248033a1fd84afccafb0b97 | refs/heads/master | 2020-12-30T09:26:29.382207 | 2013-10-27T01:14:14 | 2013-10-27T01:14:14 | null | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 40,238 | h | ////////////////////////////////////////////////////////////////////////////////
// Matrix ๅใจ่ฆ็ด ๆฐใฎใใณใใฌใผใ็๏ผๆฐๅค่จ็ฎ็จใฎใใ็ฒพๅบฆใจๆฌกๅ
ใๅฟ
่ฆใง็กใใจใใซใฏ็จใใชใ๏ผ
// ๆชๅฎๆ BUG DEBUG
template<typename T>
class matrixT
{
array< vectorT<T> > mat;
// ๆจชใฎ่ก(row)ใใใฏใใซใจใใฆใใกใ็ธฆใฎๅ(column)ๆนๅใฎๆฐ
void allocate( const matrixT & m1, const matrixT & m2 )
{
allocate( minimum( m1.row(), m2.row() ), minimum( m1.column(), m2.column() ) );
}
void allocate( const int R, const int C )
{
mat.resize( R, 0 );
for ( int i = 0; i < R; ++i ) {
mat[i].allocate( C );
}
}
public:
matrixT() {}
matrixT( const int R, const int C ) { allocate( R, C ); zero(); }
matrixT( const matrixT & m1, const matrixT & m2 ) { allocate( m1, m2 ); zero(); }
matrixT( const matrixT & m ) { *this = m; }
matrixT & operator=( const matrixT & m ) { allocate( m.row(), m.column() ); for ( int r = 0; r < row(); ++r ) mat[r] = m.mat[r]; return *this; }
void input( const matrixC<T> & m ) { *this = matrixT( m.row(), m.column() ); for ( int r = 0; r < row(); ++r ) for ( int c = 0; c < column(); ++c ) mat[r][c] = m[r][c].real(); }
void output( matrixC<T> & m ) const { m = matrixC<T>( row(), column() ); for ( int r = 0; r < row(); ++r ) for ( int c = 0; c < column(); ++c ) m[r][c] = mat[r][c]; }
//่ก(row)ใฎๆฐใ่ฅใใใฏๅ(column)ใฎ่ฆ็ด ๆฐ
int row() const { return mat.size; }
//ๅ(column)ใฎๆฐใ่ฅใใใฏ่ก(row)ใฎ่ฆ็ด ๆฐ
int column() const { if ( ! row() ) return 0; return mat.first().dimension(); }
//ๆผ็ฎ
const matrixT operator-() const { matrixT result( row(), column() ); for ( int r = 0; r < row(); ++r ) result[r] = - mat[r]; return result; }
const matrixT operator+( const matrixT & m ) const { matrixT result( *this, m ); for ( int r = 0; r < result.row(); ++r ) result[r] = mat[r] + m.mat[r]; return result; }
const matrixT operator-( const matrixT & m ) const { matrixT result( *this, m ); for ( int r = 0; r < result.row(); ++r ) result[r] = mat[r] - m.mat[r]; return result; }
void operator+=( const matrixT & m ) { allocate( *this, m ); for ( int r = 0; r < row(); ++r ) mat[r] += m.mat[r]; }
void operator-=( const matrixT & m ) { allocate( *this, m ); for ( int r = 0; r < row(); ++r ) mat[r] -= m.mat[r]; }
const matrixT operator+( const T & m ) const { matrixT result( *this ); for ( int r = 0; r < result.row(); ++r ) result[r] += m; return result; }
const matrixT operator-( const T & m ) const { matrixT result( *this ); for ( int r = 0; r < result.row(); ++r ) result[r] -= m; return result; }
const matrixT operator*( const T & m ) const { matrixT result( *this ); for ( int r = 0; r < result.row(); ++r ) result[r] *= m; return result; }
const matrixT operator/( const T & m ) const { matrixT result( *this ); for ( int r = 0; r < result.row(); ++r ) result[r] /= m; return result; }
void operator+=( const T & m ) { for ( int r = 0; r < row(); ++r ) mat[r] += m; }
void operator-=( const T & m ) { for ( int r = 0; r < row(); ++r ) mat[r] -= m; }
void operator*=( const T & m ) { for ( int r = 0; r < row(); ++r ) mat[r] *= m; }
void operator/=( const T & m ) { for ( int r = 0; r < row(); ++r ) mat[r] /= m; }
bool operator==( const matrixT & m ) const { if ( row() != v.row() || column() != v.column() ) return false; for ( int i = 0; i < row(); ++i ) if ( mat[i] != m[i] ) return false; return true; }
bool operator!=( const matrixT & m ) const { return ! ( *this == m ); }
const vectorT<T> & operator[]( int r ) const { return mat[r]; }
vectorT<T> & operator[]( int r ) { return mat[r]; }
const matrixT operator*( const matrixT & m ) const
{
const int LR = row(), LC = column(), RR = m.row(), RC = m.column();
matrixT result = matrixT::zero( LR, RC );
for ( int r = 0; r < LR; ++r ) {
for ( int c = 0; c < RC; ++c ) {
T & sum = result[r][c];
for ( int s = 0; s < LC && s < RR; ++s ) {
sum += mat[r][s] * m[s][c];
}
}
}
return result;
}
const vectorT<T> operator*( const vectorT<T> v )
{
vectorT<T> result = vectorT<T>::zero( row() );
for ( int r = 0; r < row(); ++r ) {
T & sum = result[r];
for ( int c = 0; c < column() && c < v.dimension(); ++c ) {
sum += mat[r][c] * v[c];
}
}
return result;
}
//ๆจชใใฏใใซใจใใฆๅใๅบใใ
const vectorT<T> bra( int r ) const
{
return mat[r];
}
//็ธฆใใฏใใซใจใใฆๅใๅบใใ
const vectorT<T> ket( int c ) const
{
vectorT<T> result( row() );
for ( int r = 0; r < row(); ++r ) {
result[r] = mat[r][c];
}
return result;
}
//ๆจชใใฏใใซใ่กๅๅฝขๅผใซๅคๆ
static matrixT bra( const vectorT<T> & v )
{
matrixT result( 1, v.dimension() );
result[0] = v;
return result;
}
//็ธฆใใฏใใซใ่กๅๅฝขๅผใซๅคๆ
static matrixT ket( const vectorT<T> & v )
{
matrixT result( v.dimension(), 1 );
for ( int r = 0; r < v.dimension(); ++r ) {
result[r][0] = v[r];
}
return result;
}
void zero() { for ( int r = 0; r < row(); ++r ) mat[r].zero(); }
void one() { for ( int r = 0; r < row(); ++r ) mat[r].one(); }
void identity() { for ( int r = 0; r < row(); ++r ) mat[r].basis( r ); }
static const matrixT identity( int N ) { matrixT result( N, N ); result.identity(); return result; }
static const matrixT zero( int N ) { matrixT result( N, N ); result.zero(); return result; }
static const matrixT one( int N ) { matrixT result( N, N ); result.one(); return result; }
static const matrixT identity( int R, int C ) { matrixT result( R, C ); result.identity(); return result; }
static const matrixT zero( int R, int C ) { matrixT result( R, C ); result.zero(); return result; }
static const matrixT one( int R, int C ) { matrixT result( R, C ); result.one(); return result; }
//่กใฎไบคๆ
void swapbra( int i, int j )
{
for ( int c = 0; c < column(); ++c ) swap( mat[i][c], mat[j][c] );
}
//ๅใฎไบคๆ
void swapket( int i, int j )
{
for ( int r = 0; r < row(); ++r ) swap( mat[r][i], mat[r][j] );
}
//่กใๅฅใฎ่กใซไฟๆฐใๆใใฆ่ถณใ
void addbra( int from, int to, T v )
{
for ( int c = 0; c < column(); ++c ) mat[to][c] += v * mat[from][c];
}
//ๆๅนใ่ชฟในใ
bool valid() const
{
for ( int r = 0; r < row(); ++r ) if ( ! mat[r].valid() ) return false;
return true;
}
//0ใซ่ฟใ่ฆ็ด ใ๏ผใซใใ
static const matrixT fix( const matrixT & m )
{
matrixT result( m );
for ( int i = 0; i < m.row(); ++i ) {
result[i] = vectorT<T>::fix( result[i] );
}
return result;
}
//่ปข็ฝฎ
static const matrixT transpose( const matrixT & m )
{
matrixT result( m.column(), m.row() );
for ( int r = 0; r < m.row(); ++r ) {
for ( int c = 0; c < m.column(); ++c ) {
result[c][r] = m[r][c];
}
}
return result;
}
//ๅ
็ฉ
static T dot( const matrixT & left, const matrixT & right )
{
T result = 0;
for ( int r = 0; r < left.row() && r < right.row(); ++r ) {
result += vectorT<T>::dot( left[r], right[r] );
}
return result;
}
//ใใซใ
static T norm( const matrixT & m )
{
checkMaximum<T> mx;
for ( int r = 0; r < m.row(); ++r ) {
checkMaximum<T> mx;
T sum = 0;
for ( int c = 0; c < m.column(); ++c ) {
sum += absolute( m[r][c] );
}
mx( sum );
}
return mx ? mx() : 0;
}
//ๅฏพ่งใฎ็ฉ
const T trace() const
{
T result = 1;
for ( int r = 0; r < row() && r < column(); ++r ) {
result *= mat[r][r];
}
return result;
}
//ๅฏพ่ง่กๅ
bool diagMatrix( T limit = epsilon ) const
{
T sum = 0;
for ( int r = 0; r < row(); ++r ) {
for ( int c = 0; c < column(); ++c ) {
if ( r != c ) sum += absolute( mat[r][c] );
}
}
return ( sum < limit );
}
//ไธไธ่ง่กๅ
bool lowerMatrix( T limit = epsilon ) const
{
T sum = 0;
for ( int r = 0; r < row(); ++r ) {
for ( int c = 0; c < r && c < column(); ++c ) {
sum += absolute( mat[r][c] );
}
}
return ( sum < limit );
}
//ไธไธ่ง่กๅ
bool upperMatrix( T limit = epsilon ) const
{
T sum = 0;
for ( int r = 0; r < row(); ++r ) {
for ( int c = r + 1; c < column(); ++c ) {
sum += absolute( mat[r][c] );
}
}
return ( sum < limit );
}
//ๆญฃๆน่กๅ
bool squareMatrix() const
{
if ( row() != column() ) return false;
return true;
}
//ๅฏพ็งฐ่กๅ
bool symmetricMatrix() const
{
if ( row() != column() ) return false;
for ( int r = 0; r < row(); ++r ) {
for ( int c = 0; c < r; ++c ) {
if ( absolute( mat[c][r] - mat[c][r] ) > epsilon ) return false;
}
}
return true;
}
//ๅฐ่กๅใๅๅพ
//็ธฆๆนๅใจๆจชๆนๅใฎๆๅใจๆๅพใฎ่ฆ็ด ใๆๅฎ
const matrixT minor( int rs, int cs, int re, int ce ) const
{
matrixT result( re - rs, ce - cs );
for ( int r = 0; r+rs < row() && r < result.row(); ++r ) {
for ( int c = 0; c+cs < column() && c < result.column(); ++c ) {
result[r][c] = mat[r+rs][c+cs];
}
}
return result;
}
//ๅฐ่กๅใๅๅพ
const matrixT minor( int start, int end ) const
{
return minor( start, start, end, end );
}
//ๅฐ่กๅใใณใใผใใฆๅๆ
void copy( int rs, int cs, const matrixT & src )
{
const int DR = row();
const int DC = column();
const int SR = src.row();
const int SC = src.column();
for ( int r = 0; r+rs < DR && r < SR; ++r ) {
for ( int c = 0; c+cs < DC && c < SC; ++c ) {
mat[r+rs][c+cs] = src[r][c];
}
}
}
//ๅฏพ่ง่ฆ็ด ใฎใฟใใใคๆญฃๆน่กๅใไฝๆ
const matrixT diag() const
{
matrixT result = identity( minimum( row(), column() ) );
for ( int r = 0; r < row() && r < column(); ++r ) {
result[r][r] = mat[r][r];
}
return result;
}
//ๅฏพ่ง่ฆ็ด ใฎใใฏใใซใไฝๆ
const vectorT<T> diagVector() const
{
vectorT<T> result = vectorT<T>::zero( minimum( row(), column() ) );
for ( int r = 0; r < row() && r < column(); ++r ) {
result[r] = mat[r][r];
}
return result;
}
//ๅฏพ่ง่กๅใฎไธ่ฌ้่กๅใๆปใ
const matrixT inverseDiag() const
{
matrixT result = identity( minimum( row(), column() ) );
for ( int r = 0; r < row() && r < column(); ++r ) {
result[r][r] = zerodivide<T>( 1, mat[r][r] );
}
return result;
}
//LUๅ่งฃ
//ๅ
ฅๅใใ่กๅใluๅ่งฃใใ
//Lๅทฆไธไธ่ง่กๅใฎๅฏพ่งๆๅใ๏ผ๏ผUๅณไธไธ่ง่กๅใงL * Uใฎๅฝขใซ่กๅใๅ่งฃใใ
//ใฌใฆในใฎๆถๅปๆณใง็จใใๅฏพ่ง่ฆ็ด ใซๆใใๅคใL่กๅใฎ๏ผใซใใๅๆใซไปฃๅ
ฅใใฆ็ฝฎใไบใงLใ่จ็ฎใงใใ๏ผ
//Uใฏใฌใฆในใฎๆถๅปๆณใฎ็ตๆใงใใ๏ผ
//ใฝใผในใฎๅ
ใฏใขใซใดใชใบใ ่พๅ
ธ
//ๆณจใใฌใฆในใฎๆถๅปๆณ๏ผๅทฆไธใฎ่ฆ็ด ใ๏ผใซใใใใใซ
//ๅใๅใฎๅฏพ่ง่ฆ็ด ใฎๅคใซใใๅคใๆใใฆใใฎ่กๅ
จไฝใๅผใ๏ผ
//ใใใๅทฆไธใใๅทฆใใๅณใธ๏ผใใฎๅพไธใใไธใธ้ ใซ่กใฃใฆใใๆๆณ
// LUๅ่งฃใฎ็ตๆใ็จใใฆm*x=bใใxใ่งฃใ
bool luFactorization( matrixT & lu, vectorT<int> & exchange ) const
{
if ( ! squareMatrix() ) return false;
int N = row();
vectorT<T> weight( N );
exchange = vectorT<int>( N );
for ( int k = 0; k < N; k++ ) { // ๅๅใซใคใใฆ
exchange[k] = k;// ่กไบคๆๆ
ๅ ฑใฎๅๆๅค
checkMaximum<T> mx;// ใใฎ่กใฎ็ตถๅฏพๅคๆๅคงใฎ่ฆ็ด ใๆฑใใ
for ( int j = 0; j < N; j++ ) {
mx( absolute( mat[k][j] ) );
}
if ( mx() == 0 ) return false; // 0 ใชใ่กๅใฏLUๅ่งฃใงใใชใ
weight[k] = T( 1.0 / mx() ); // ๆๅคง็ตถๅฏพๅคใฎ้ๆฐ
}
lu = *this;
for ( int k = 0; k < N; k++ ) { // ๅ่กใซใคใใฆ
// ใใไธใฎๅ่กใซใคใใฆ้ใฟร็ตถๅฏพๅค ใๆๅคงใฎ่กใ่ฆใคใใ
{
checkMaximum<T> mx;
for ( int i = k; i < N; i++ ) {
const int ii = exchange[i];
mx( absolute( lu[ii][k] ) * weight[ii], i );
}
// ่ก็ชๅทใไบคๆ
swap( exchange[mx.sub], exchange[k] );
}
const int ik = exchange[k];//ไบคๆใใๅพใฎk
const T vkk = lu[ik][k];//ๅฏพ่งๆๅ
if ( vkk == 0 ) return false;// 0 ใชใ่กๅใฏLUๅ่งฃใงใใชใ
for ( int i = k + 1; i < N; i++) { // Gaussๆถๅปๆณ
const int ii = exchange[i];//ไบคๆใใๅพใฎi
lu[ii][k] /= vkk;//Lใฎ่ฆ็ด
const T vik = lu[ii][k];
for ( int j = k + 1; j < N; j++) {
lu[ii][j] -= vik * lu[ik][j];
}
}
}
return true;
}
// ไธไธ่ง่กๅใจใใฆใใฌใฆในใฎๅใๅบใๆณใ่กใ
// L x = b
bool lSolve( const vectorT<T> & b, vectorT<T> & x, const vectorT<int> * exchange = NULL ) const
{
if ( ! squareMatrix() ) return false;
const int N = row();
if ( exchange && exchange->dimension() != N ) return false;
if ( b.dimension() != N ) return false;
x = vectorT<T>::zero( N );
// l * x = bใ่งฃใ
for ( int i = 0; i < N; i++ ) {
const int ii = exchange ? (*exchange)[i] : i;
T t = b[ii];
for ( int j = 0; j < i; j++ ) {
t -= mat[ii][j] * x[j];
}
x[i] = zerodivide( t, mat[ii][i] );//0ใชใใฐไธๅฎ
}
return true;
}
// ไธไธ่ง่กๅใจใใฆใใฌใฆในใฎๅใๅบใๆณใ่กใ
// R x = b
bool rSolve( const vectorT<T> & b, vectorT<T> & x, const vectorT<int> * exchange = NULL ) const
{
if ( ! squareMatrix() ) return false;
const int N = row();
if ( exchange && exchange->dimension() != N ) return false;
if ( b.dimension() != N ) return false;
x = vectorT<T>::zero( N );
// r * x = bใ่งฃใ
for ( int i = N - 1; i >= 0; i-- ) {
const int ii = exchange ? (*exchange)[i] : i;
T t = b[ii];
for ( int j = i + 1; j < N; j++ ) {
t -= mat[ii][j] * x[j];
}
x[i] = zerodivide( t, mat[ii][i] );//0ใชใใฐไธๅฎ
}
return true;
}
//LUๅ่งฃใซใฆๆน็จๅผใ่งฃใ๏ผthis=lu๏ผLU x = b
bool luSolve( const vectorT<T> & b, vectorT<T> & x, const vectorT<int> * exchange = NULL ) const
{
matrixT L = *this;
matrixT R = *this;
for ( int r = 0; r < row(); ++r ) {
const int rr = exchange ? (*exchange)[r] : r;
L[rr][r] = 1;
for ( int c = r + 1; c < column(); ++c ) {
L[rr][c] = 0;
}
for ( int c = 0; c < r; ++c ) {
R[rr][c] = 0;
}
}
// L U x = b
// L y = bใ่งฃใใU x = yใ่งฃใ
vectorT<T> y;
if ( ! L.lSolve( b, y, exchange ) ) return false;
if ( ! R.rSolve( y, x, exchange ) ) return false;
return true;
}
//GramSchmidt
//็ดไบคใใฏใใซใ่จ็ฎใใใ
//ๆกไปถ๏ผๅๅใใฏใใซใ1ๆฌก็ฌ็ซใงใชใๅ ดๅใซใฏใๆฐใฏๅฐใชใใชใใ
void gramSchmidt( matrixT & q ) const
{
if ( row() < column() ) {//ๆจช้ทใชใใฐใ่ปข็ฝฎใใฆ่จ็ฎใใ
matrixT AT = transpose( *this );
AT.gramSchmidt( q );
q = transpose( q );
return;
}
//็ธฆ้ทใชใฎใงใๅใใฏใใซใ็ดไบคใใใใใซๆฑใใ
const int R = row();
const int C = column();
//ใฐใฉใ ใทใฅใใใใฎๆนๆณ
matrixT AT = transpose( *this );
array< vectorT<T> > orthogonal;
orthogonal.reserve( C );
for ( int c = 0; c < C; ++c ) {
const vectorT<T> & vc = AT[c];//cๅใฎใใฏใใซ
vectorT<T> vo = vc;//็ดไบคใใใใฏใใซ
//ใใใพใงใซๆฑใใใใฏใใซ็พคใจๅนณ่กใชๆๅใฏๅ
จใฆๅ้คใใ
for ( int i = 0; i < orthogonal.size; ++i ) {
vo -= orthogonal[i] * vectorT<T>::dot( vc, orthogonal[i] );
}
//ๅ็ดใชๆๅใใใใ่ชฟในใ
T n = vectorT<T>::norm( vo );
if ( n < epsilon ) continue;//ๅ็ดใชๆๅใ็กใใฎใงใ็ฌ็ซใงใฏใชใใใๅ้ค
orthogonal.push_back( vo / n );//ๆญฃ่ฆๅใใฆไฟๅญ
}
q.allocate( orthogonal.size, R );
for ( int c = 0; c < orthogonal.size; ++c ) {
q[c] = orthogonal[c];
}
q = transpose( q );
}
//่กๅใฎ้ๆฐใSVDใซใใ่งฃๆณใๆฎ้ใฟใใใ ใใ1ๆฌก็ฌ็ซใชใใฏใใซใใใใคใใใใ่จ็ฎใใฆๆฑใใ
int rank() const
{
matrixT q;
gramSchmidt( q );
return minimum( q.row(), q.column() );
}
//QRๅ่งฃ
//่กๅAใ็ดไบค่กๅQใจๅณไธไธ่ง่กๅRใซๅ่งฃใใ๏ผ
//ๆกไปถ๏ผๅๅใใฏใใซใ1ๆฌก็ฌ็ซใๆญฃๆนใ็ธฆ้ทใฎ่กๅใงใใใใจ
void qrFactorization( matrixT & q, matrixT & r ) const
{
//if ( row() < column() ) return false;//็ธฆ้ทใฎ่กๅใฎๆใฎใฟ่จ็ฎๅฏ่ฝ
const int R = row();
const int C = column();
//ไฟฎๆญฃใฐใฉใ ใทใฅใใใใฎๆนๆณ
matrixT qT = transpose( *this );
r = identity( C );
for ( int k = 0; k < C; ++k ) {
//ๅฏพ่ง่ฆ็ด ใซใคใใฆ
T & rkk = r[k][k];
rkk = vectorT<T>::norm( qT[k] );
//้ถใใฏใใซใงใ่จ็ฎใ็ถใใ
qT[k] /= rkk;//rkk=0->qTk=0
for ( int j = k + 1; j < C; ++j ) {//ใใฎๅณ
T & rkj = r[k][j];
rkj = vectorT<T>::dot( qT[k], qT[j] );//rkk=0->rkj=0
qT[j] -= qT[k] * rkj;
}
}
q = transpose( qT );
}
//่กๅใQRๅคๆใใๅใๅบใๆณใงๆน็จๅผใ่งฃใ
bool qrSolve( const vectorT<T> & b, vectorT<T> & x ) const
{
matrixT q, matrixT r;
qrFactorization( q, r );
// q r x = b
// r x = qT b
return r.rSolve( transpose( q ) * b, x );
}
//QRๅคๆ
//A=QRใจๅ่งฃใใA'=RQใจๅคๆใใใใใใฏใA'=Q'AQใง็ธไผผๅคๆ
//P^-1APใจ็ธไผผๅคๆใ่กใๆใฎPใๆปใ
//ๆกไปถ๏ผๆญฃๆน่กๅใQRๅ่งฃๅฏ่ฝ๏ผๅๅใใฏใใซใ1ๆฌก็ฌ็ซ๏ผ
bool qrTransform( matrixT & P )
{
if ( ! squareMatrix() ) return false;
matrixT q, r;
qrFactorization( q, r );
*this = r * q;
P = transpose( q );
return true;
}
//ใณใฌในใญใผๅ่งฃ mat=L (L*)ใฎๅฝขใซๅ่งฃ
//ๆกไปถ๏ผๆญฃๅฎๅคๅฏพ็งฐๆญฃๅ๏ผๅ
จใฆใฎๅบๆๅคใๆญฃ๏ผ๏ผๅ
จใฆใฎไธปๅบงๅฐ่กๅๅผใ้้ถ
bool choleskyFactorization( matrixT & l ) const
{
if ( ! symmetricMatrix() ) return false;
const int N = row();
l = identity( N );
for ( int i = 0; i < N; ++i ) {
for ( int j = 0; j < i; ++j ) {
T sum = 0;
for ( int k = 0; k < j; ++k ) {
sum += l[i][k] * l[j][k];
}
l[i][j] = zerodivide( sqrt( mat[i][j] - sum ), l[j][j] );
}
T sum = 0;
for ( int k = 0; k < i; ++k ) {
sum += l[i][k] * l[i][k];
}
T & lii = l[i][i];
lii = mat[i][i] - sum;
if ( lii <= 0 ) return false;
lii = sqrt( lii );
}
return true;
}
//ไฟฎๆญฃใณใฌในใญใผๅ่งฃ mat=L D (L*)ใฎๅฝขใซๅ่งฃ
//ๆกไปถ๏ผๅฏพ็งฐๆญฃๅ๏ผๅ
จใฆใฎไธปๅบงๅฐ่กๅๅผใ้้ถ
bool choleskyFactorization( matrixT<T> & l, matrixT<T> & d ) const
{
if ( ! symmetricMatrix( *this ) ) return false;
const int N = row();
l = identity( N );
d = identity( N );
for ( int i = 0; i < N; ++i ) {
for ( int j = 0; j < i; ++j ) {
T & lij = l[i][j];
lij = mat[i][j];
for ( int k = 0; k < j; ++k ) {
lij -= d[k][k] * l[i][k] * l[j][k];
}
if ( lij < 0 ) return false;
lij = zerodivide( lij, d[j][j] );
}
T & dii = d[i][i];
dii = mat[i][i];
for ( int k = 0; k < i; ++k ) {
dii -= d[k][k] * square( l[i][k] );
}
if ( dii <= 0 ) return false;
}
return true;
}
//้่กๅ
bool inverse( matrixT<T> & result ) const
{
if ( ! squareMatrix() ) {
result = generalInverse();//็น็ฐๅคๅ่งฃใๅฟ
่ฆ
return false;
}
const int N = row();
result = identity( N );
//LUๅ่งฃ
matrixT lu;//่จ็ฎ็จ
vectorT<int> exchange;//ใใใใ้ธๆใฎใใใฎใใผใใซใ่กใๅ
ฅใๆฟใใ
if ( ! luFactorization( lu, exchange ) ) {
result = generalInverse();//็น็ฐๅคๅ่งฃใๅฟ
่ฆ
return false;
}
//๏ฝใซ้่กๅใฎ๏ผๅใๅ
ฅใใใใซ๏ฝใๅไฝ่กๅใใๆใๅบใใฆ่จ็ฎใใ
vectorT<T> b;
vectorT<T> x;
for ( int i = 0; i < N; ++i ) {
b = vectorT<T>::zero( N );
b[i] = 1;
if ( ! lu.luSolve( b, x, & exchange ) ) {
result = generalInverse();//็น็ฐๅคๅ่งฃใๅฟ
่ฆ
return false;
}
for ( int j = 0; j < N; ++j ) result[j][i] = x[j];
}
return true;
}
//่กๅๅค
static T determinant( const matrixT<T> & m )
{
if ( ! m.squareMatrix() ) return 0;
const int N = m.row();
if ( N == 1 ) return m[0][0];
//ๆฌกๅ
ใๅคงใใใจใใซใฏLUๅ่งฃใ๏ผๅฏพ่ง่ฆ็ด ใฎ็ฉใใ่กๅๅผใ่จ็ฎใใ
matrixT lu;//่จ็ฎ็จ
vectorT<int> exchange;//ใใใใ้ธๆใฎใใใฎใใผใใซใ่กใๅ
ฅใๆฟใใ
if ( ! m.luFactorization( lu, exchange ) ) return 0;
T result = 1;
for ( int i = 0; i < N; ++i ) result *= lu[exchange[i]][i];
return result;
}
//ๆญฃ่ฆๅ
static const matrixT normalize( const matrixT & m )
{
T l = determinant( m );
if ( absolute( l - 1 ) < epsilon ) return m;
return m / l;
}
//Householderๅคๆ
//ๅใใฏใใซvใซๅ็ดใชๅนณ้ข้กใซๆ ใฃใๅใใฏใใซxใฎๅyใฏ
//u=normalize(v)
//y=x-2(u๏ฝฅx)u
//y=(E-2v(vT)/((vT)v) ่กๅๅฝขๅผ
//x(x1,...,xn)Tใy(x1,...,xi,y,0,...,0)T ใซ็งปใHouseholderๅคๆ 0<=i<=N-2
//s=length(xi+1,...,xn) ้ทใใ่จ็ฎ
//y=-sign( x[i] )*|s| ็ฌฆๅทใซๆฐใใคใใฆใyใฎ่ฆ็ด ใ่จ็ฎ
//v=c(x-y)ใฎใใ v(0,...,0,c( (xi+1) - y ), c(xi+2),...,c xn)
//cใฏvใโ๏ผใฎ้ทใใๆใคใใใฎไฟๆฐ
//vใปv = s^2 + y^2 - 2 xi y = 2 ( s^2 + | xi | * |s| ) = 2 c
//c=s^2 + | xi | * |s|ใงๅฒใใฐใใใ
//i: number of constant element
void householder( const vectorT<T> & x, vectorT<T> & v, T & y, int constant )
{
const int N = x.dimension();
*this = identity( N );
v = vectorT<T>::zero( N );
y = 0;
if ( N <= 0 || ! between( 0, constant, N - 2 ) ) {//็กๅคๆ
return;
}
T s = 0;//ๅคๆดๅฏ่ฝใช่ฆ็ด ใฎใฆใผใฏใชใใใใซใ ใ่จ็ฎ
for ( int j = constant; j < N; ++j ) {
s += square( x[j] );
}
s = sqrt( s );
if ( s == 0 ) {//้ทใใ๏ผใชใฎใง๏ผๅ
จใฆ๏ผ๏ผๅคๆใฏๅไฝ่กๅ
return;
}
y = - plus( x[constant] ) * s;//y=-sign( x[i] )*|s|
v = x;
for ( int j = 0; j < constant; ++j ) {
v[j] = 0;
}
v[constant] = x[constant] - y;
const T c = ::sqrt( square( s ) + absolute( x[constant] * s ) );
v /= c;
*this -= ket( v ) * bra( v );//็ธฆใใฏใใซ๏ฝๆจชใใฏใใซใง่กๅใซใใฆ๏ผๅไฝ่กๅใใๅผใ
}
//x(x1,...,xn)Tใy(y1,0,...,0)T |ใซใใคใๅคๆ
//ไบ้ๅฏพ่งๅใง็จใใ
void householder1( const vectorT<T> & x, vectorT<T> & v, T & y1 )
{
householder( x, v, y1, 0 );
}
//x(x1,...,xn)Tใy(x1,y2,0,...,0)T |ใซใใคใๅคๆ
//ไธ้ๅฏพ่งๅใHessenbergๅใง็จใใ
void householder2( const vectorT<T> & x, vectorT<T> & v, T & y2 )
{
householder( x, v, y2, 1 );
}
//Givensๅคๆ
// ( c, -s )
// ( s, c )
//ๅไฝ่กๅใซใใใฆใใๅคๆใใใ๏ผใคใฎ่กใๅใฎๅฏพๅฟใใไฝ็ฝฎใซcosฮธใจยฑsinฮธใฎ่ฆ็ด ใใใคๅ่ปขๅคๆ
//้ๅธธ๏ผใคใฎ่กใพใใฏๅใฎใใกใใ่ฆ็ด ใ้ถใซใใใใใซๅ่ปขใใใ
//G (a,b)T๏ผaใ้ถใซใใใใใชGivensๅคๆใฎ่งๅบฆใ่ฟใ
static const T givensLeftA( const T a, const T b )
{ return atan2( a, b ); }
//G (a,b)T๏ผbใ้ถใซใใใใใชGivensๅคๆใฎ่งๅบฆใ่ฟใ
static const T givensLeftB( const T a, const T b )
{ return atan2( -b, a ); }
//(a,b) G๏ผaใ้ถใซใใใใใชGivensๅคๆใฎ่งๅบฆใ่ฟใ
static const T givensRightA( const T a, const T b )
{ return atan2( -a, b ); }
//(a,b) G๏ผbใ้ถใซใใใใใชGivensๅคๆใฎ่งๅบฆใ่ฟใ
static const T givensRightB( const T a, const T b )
{ return atan2( b, a ); }
//ๅทฆๅดใใๆใใฆ๏ผiใจkใฎ่กใๅคๆดใi,jใฎ่ฆ็ด ใ๏ผใซใใใใใชGivensๅคๆ่กๅใ่ฟใ
const matrixT givensLeft( const int i, const int j, const int k )
{
matrixT g = identity( row(), column() );
const T & sita = ( j < i ) ? //ๆถใ่ฆ็ด ใๅฏพ่ง็ทใใใฉใกใใซใใใใๆๆจใจใชใ
givensLeftB( mat[k][j], mat[i][j] ) ://ๅทฆไธใซใใๅ ดๅ
givensLeftA( mat[i][j], mat[k][j] );//ๅณไธใซใใๅ ดๅ
const T & c = cos( sita );
const T & s = sin( sita );
//ๅทฆไธใฎ่ฆ็ด ใซๆญฃใฎsใๆฅใใใใซใใ
if ( k < i ) {
g[k][k] = c; g[k][i] = -s;
g[i][k] = s; g[i][i] = c;
} else {
g[i][i] = c; g[i][k] = -s;
g[k][i] = s; g[k][k] = c;
}
return g;
}
//ๅณๅดใใๆใใฆ๏ผkใจjใฎๅใๅคๆดใi,jใฎ่ฆ็ด ใ๏ผใซใใใใใชGivensๅคๆ่กๅใ่ฟใ
const matrixT givensRight( const int i, const int j, const int k )
{
matrixT g = identity( row(), column() );
const T & sita = ( j < i ) ?
givensRightA( mat[i][j], mat[i][k] ) :
givensRightB( mat[i][k], mat[i][j] );
const T & c = cos( sita );
const T & s = sin( sita );
if ( j < k ) {
g[j][j] = c; g[j][k] = -s;
g[k][j] = s; g[k][k] = c;
} else {
g[k][k] = c; g[k][j] = -s;
g[j][k] = s; g[j][j] = c;
}
return g;
}
//ๅทฆๅดใใๆใใฆ๏ผiใจjใฎ่กใๅคๆดใi,jใฎ่ฆ็ด ใ๏ผใซใใใใใชGivensๅคๆ่กๅใ่ฟใ
const matrixT givensLeft( const int i, const int j )
{
return givensLeft( i, j, j );
}
//ๅณๅดใใๆใใฆ๏ผiใจjใฎๅใๅคๆดใi,jใฎ่ฆ็ด ใ๏ผใซใใใใใชGivensๅคๆ่กๅใ่ฟใ
const matrixT givensRight( const int i, const int j )
{
return givensRight( i, j, i );
}
//ไธ้ๅฏพ่งๅ
//A->Pโ D3 Pใจ็ธไผผๅคๆใ่กใๆใฎPใๆปใ
void diag3( matrixT & P, bool U = true )
{
*this = fix( *this );
const int N = row();
P = identity( N );
if ( ! squareMatrix() ) return;
vectorT<T> x, v, vi;
x = vectorT<T>::zero( N );
v = vectorT<T>::zero( N );
T y2;
matrixT Pi;
for ( int i = 0; i < N - 2; ++i ) {
//ๅณไธใฎๅฐ่กๅใ ใใๆฐใซใใ
x = vectorT<T>::zero( N - i );//๏ผใซใใๅใฎ่ฆ็ด ใ ใใๅใๅบใ
for ( int j = i; j < N; ++j ) {
x[j-i] = mat[j][i];
}
Pi.householder2( x, vi, y2 );
//ๆฌกๅ
ใใใใใ
for ( int j = 0; j < i; ++j ) v[j] = 0;
for ( int j = i; j < N; ++j ) v[j] = vi[j-i];
Pi = identity( N ) - ket( v ) * bra( v );
P = P * Pi;//hessenbergๅใฎใจใใฎๅฐๅฝฑใฏๆญฃ่ฆ็ดไบค่กๅใฎใใใ่ปข็ฝฎใฏใใใชใ
*this = fix( Pi * *this * Pi );
//้ถใซใชใฃใฆใใๅๆใ๏ผใซๆธใๆใใฆใใ
for ( int j = i + 2; j < N; ++j ) {
if ( U ) mat[i][j] = 0;//Uใfalseใฎๆใซใฏ๏ผๅณไธใซ่ฆ็ด ใใใhessenbergๅใ่กใฃใฆใใ
mat[j][i] = 0;
}
}
}
//Hessenbergๅ
void hessenberg( matrixT & P )
{
diag3( P, false );
}
//ไบ้ๅฏพ่งๅ
//householderๅคๆใซใใ๏ผๅทฆๅณใใ็ฐใชใ็ดไบคๅคๆใงไบ้ๅฏพ่งๅใ่กใ๏ผ
//ๆกไปถ๏ผๆญฃๆน่กๅ
//A->L D2 R=diag2ใจ็ดไบคๅคๆใ่กใๆใฎL,Rใๆปใ
void diag2( matrixT & L, matrixT & R )
{
*this = fix( *this );
L = identity( row() );
R = identity( column() );
vectorT<T> x, v;
T y;
matrixT P;
for ( int i = 0; i < row() - 1 && i < column() - 1; ++i ) {
//[i][i]ใใไธใฎๅคใ๏ผใจใใ
x = ket( i );
P.householder( x, v, y, i );
L = P * L;
*this = fix( P * *this );
if ( i == column() - 2 ) break;//ใใใง็ตไบๅคๅฎ
//[i][i+1]ใใๅณใฎๅคใ๏ผใจใใ
x = bra( i );
P.householder( x, v, y, i+1 );
R = R * P;
*this = fix( *this * P );
}
}
private:
////////////////////////////////////////////////////////////////////////////////
//ไธ้ๅฏพ่งๅๅฏพ็งฐ่กๅใฎ[3][0],[0][3]ใฎ้ๅฏพ่ง่ฆ็ด ใ๏ผใฎๆใซ๏ผ้ๅฏพ่ง่กๅใซๆปใใใใฎ่ฟฝใ่พผใฟ
//่ฟฝใ่พผใฟใฎ้ ๅบใฏใใญใฅใกใณใๅ็
ง
void chasingDiag3( matrixT & u )
{
if ( column() <= 2 ) return;
const int c = column();
for ( int i = 2; i < column(); ++i ) {
if ( mat[i][i-2] == 0 ) return;
const matrixT & g = givensLeft( i, i - 2, i - 1 );
// ( Uโ Gโ ) G A Gโ ( G U )
u = g * u;
*this = fix( g * *this * transpose( g ) );
}
}
////////////////////////////////////////////////////////////////////////////////
//ไธ้ๅฏพ่งๅๅฏพ็งฐ่กๅ็จใฎๅบๆๅคๅ่งฃ
//A=Uโ D Uใซๅ่งฃ Dใฏ่ช่บซใซๅ
ฅใ
//U A Uโ =D
void evd4diag3( matrixT & u )
{
// Uโ D3 U ->U'โ D U'
const int C = column();
//๏ผๅใฎไธ้ๅฏพ่ง่กๅใฎๅ ดๅใซใฏ๏ผๅบๆๅคๅ่งฃใ็ตไบใใฆใใ
if ( C == 1 ) return;
while ( ! diagMatrix() ) {
//ๆๅใฎGivensๅคๆใๆฑใใใ
matrixT G = identity( C, C );
{
const T & a = mat[0][0];
const T & b = mat[1][0];
const T & d = mat[1][1];
const T D = square( a - d ) + 4 * square( b );
const T lamda = ( a + d - sqrt( D ) ) / 2;
const T size = sqrt( square( a - lamda ) + square( b ) );
G[0][0] = ( a - lamda ) / size; G[0][1] = -b / size;
G[1][0] = b / size; G[1][1] = ( a - lamda ) / size;
}
// Gโ A Gใจใใฆๅคๅฝขใใ
matrixT GT = transpose( G );
u = GT * u;// ( Uโ G ) Gโ A G ( Gโ U )
*this = fix( GT * *this * G );
chasingDiag3( u );
//ๅทฆไธใฎ้ๅฏพ่ง่ฆ็ด ใใใงใใฏ
if ( absolute( mat[1][0] ) < epsilon ) {
//ใใฎ็ถๆ
ใงi,iใง๏ผใคใซๅใใๆใซใฏๅณไธใ้ถ่กๅใซใชใใใใ๏ผใคใซๅใใฆๅฆ็ใ่กใ
//C==2ใชใใใใงใซๅฏพ่งๅๆธใฟใงใใใ
if ( C == 2 ) return;
// ๅบๆๅคใไธใคๅบๅฎใใๅณไธใฎ่กๅใฎใฟใง่จ็ฎใใ
matrixT d1 = minor( 1, 1, row(), column() );
matrixT u1 = identity( d1.column(), d1.column() );
d1.evd4diag3( u1 );
copy( 1, 1, d1 );
matrixT nu = identity( row(), column() );
nu.copy( 1, 1, u1 );
u = nu * u;
return;
}
}
}
public:
////////////////////////////////////////////////////////////////////////////////
//ๅบๆๅคใฎ่งฃๆ็จใซๅบๆๅคใฎ็ตถๅฏพๅคใฎๅคงใใ้ ใซใฝใผใ
static void sort4evd( vectorT<T> & values, matrixT & vectors )
{
const int N = values.dimension();
//้ธๆใฝใผใ
for ( int i = 0; i < N; ++i ) {
//ๆๅคงใๆขใ
checkMaximum<T> mx;
for ( int j = i; j < N; ++j ) {
mx( absolute( values[j] ), j );
}
if ( i != mn.sub ) {
swap( values[i], values[mx.sub] );
swap( vectors[i], vectors[mx.sub] );
}
}
}
////////////////////////////////////////////////////////////////////////////////
//ๅฎๅฏพ็งฐ่กๅใฎๅบๆๅคใจๅบๆใใฏใใซ
//Householder-QRๆณใซใใ
//้ๅฏพ่ฑกๅฎ่กๅใฎๅบๆๅคใปๅบๆใใฏใใซใฏ่ค็ด ๆฐใซใชใใไธ่ฌ้่กๅใๆฑใใใ ใใชใใฐ็น็ฐๅคๅ่งฃใงๅๅใชใใใๅฎๅฏพ็งฐ่กๅใฎใฟใจใใใ
bool eigen( vectorT<T> & values, matrixT & vectors ) const
{
if ( ! symmetricMatrix() ) return false;
//ไธ้ๅฏพ่ง่กๅใซๅคๆด
matrixT A = *this;
// A->Pโ D3 P
A.diag3( vectors );
//ๅบๆๅคๅ่งฃ
// Pโ D3 P ->Uโ D U
A.evd4diag3( vectors );
values = A.diagVector();
vectors = transpose( vectors );//evec eval evecโ ใซใใ
//sort4evd( values, vectors );
return true;
}
////////////////////////////////////////////////////////////////////////////////
//ๅชไนๆณ
//ๆๅคงใฎๅบๆๅคใจๅฏพๅฟใใๅบๆใใฏใใซใๆฑใใ
void powerMethod( T & eigenvalue, vectorT<T> & eigenvector ) const
{
eigenvector = vectorT<T>::normalize( vectorT<T>::one( column() ) );
do {
eigenvalue = vectorT<T>::dot( eigenvector, *this * eigenvector );
eigenvector = vectorT<T>::normalize( *this * eigenvector );
} while ( absolute( eigenvalue - vectorT<T>::dot( eigenvector, *this * eigenvector ) ) < tiny );
}
////////////////////////////////////////////////////////////////////////////////
//ใฌใคใชใผๅ้ๅๅพฉๆณ
//ๅบๆใใฏใใซใฎ่ฟไผผๅคใใๅบๆๅคใๅพใๅบๆใใฏใใซใ่ฟไผผใใฆใใ
void rayleighQuotientInverseIterationMethod( T & eigenvalue, vectorT<T> & eigenvector ) const
{
matrixT A = *this;
matrixT I = identity( row() );
eigenvalue = rayleighQuotient( eigenvector );
while ( vectorT<T>::norm( *this * eigenvector - eigenvector * eigenvalue ) > epsilon ) {
vectorT<T> nv = eigenvector;
( A - I * eigenvalue ).qrSolve( eigenvector, nv );
eigenvector = normalize( nv );
eigenvalue = rayleighQuotient( eigenvector );
};
}
////////////////////////////////////////////////////////////////////////////////
//ใฌใคใชใผๅ
//่ฟไผผ็ใชๅบๆใใฏใใซใใ๏ผๅบๆๅคใ่จ็ฎใใ
const T rayleighQuotient( const vectorT<T> & eigenvector ) const
{
return zerodivide( vectorT<T>::dot( *this * eigenvector, eigenvector ),
vectorT<T>::dot( eigenvector, eigenvector ) );
}
private:
////////////////////////////////////////////////////////////////////////////////
//็น็ฐๅคๅ่งฃ
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//็ธฆๅ้ทๆนไบ้ๅฏพ่ง่กๅใฎๅณไธใฎๅฏพ่ง่ฆ็ด ใ๏ผใฎๆใซใใฎไธใฎ่ฆ็ด ใ๏ผใซใใใใใฎGivensๅคๆ
//่ฟฝใ่พผใฟใฎ้ ๅบใฏใใญใฅใกใณใๅ็
ง
void chasingRightBottom( matrixT & u )
{
if ( column() <= 1 ) return;
const int c = column();
for ( int i = c - 2; 0 <= i; --i ) {
if ( mat[i][c-1] == 0 ) return;
const matrixT & g = givensRight( i, c - 1 );
u = u * g;// X * G * Gโ * Uโ =X * G * (U*G)โ
*this = fix( *this * g );
}
}
////////////////////////////////////////////////////////////////////////////////
//็ธฆๅ้ทๆนไบ้ๅฏพ่ง่กๅใฎๅณไธใงใชใๅฏพ่ง่ฆ็ด ใ๏ผใฎๆใซใใฎๅณใฎ่ฆ็ด ใ๏ผใซใใใใใฎGivensๅคๆ
//่ฟฝใ่พผใฟใฎ้ ๅบใฏใใญใฅใกใณใๅ็
ง
void chasingDiag( matrixT & v, const int i )
{
if ( column() <= 1 ) return;
const int c = column();
for ( int j = i + 1; j < c; ++j ) {
if ( absolute( mat[i][j] ) < epsilon ) return;
const matrixT & g = givensLeft( i, j );
v = v * transpose( g );
*this = fix( g * *this );
}
}
////////////////////////////////////////////////////////////////////////////////
//็ธฆๅ้ทๆนไบ้ๅฏพ่ง่กๅใฎๅฏพ่ง่ฆ็ด ใจใใฎไธใฎ่ฆ็ด ใ้๏ผใฎๆใซๅฏพ่ง่กๅใซ่ฟใฅใใ
//่ฟฝใ่พผใฟใฎ้ ๅบใฏใใญใฅใกใณใๅ็
ง
void chasing( matrixT & v, matrixT & u )
{
if ( column() <= 1 ) return;
const matrixT & g01 = givensRight( 0, 1 );
u = u * g01;
*this = fix( *this * g01 );
const matrixT & g10 = givensLeft( 1, 0 );
v = v * transpose( g10 );
*this = fix( g10 * *this );
const int c = column();
const int r = row();
int i = 0, j = 2;
for ( ; i < r && j < c; ) {
const matrixT & gr = givensRight( i, j, i+1 );
u = u * gr;
*this = fix( *this * gr );
i += 2; j -= 1;
if ( ! ( i < r && j < c ) ) break;
const matrixT & gl = givensLeft( i, j );
v = v * transpose( gl );
*this = fix( gl * *this );
i -= 1; j += 2;
}
}
////////////////////////////////////////////////////////////////////////////////
//ไบ้ๅฏพ่งๅ่กๅ็จใฎ็น็ฐๅคๅ่งฃ
//A=V D Uโ ใซๅ่งฃ Dใฏ่ช่บซใซๅ
ฅใ
void svd4diag2( matrixT & v, matrixT & u )
{
//้ถ่ฆ็ด ใๆค็ดข
const int C = column();
//๏ผๅใฎไบ้ๅฏพ่ง่กๅใฎๅ ดๅใซใฏ๏ผ็น็ฐๅคๅ่งฃใ็ตไบใใฆใใ
if ( C == 1 ) return;
while ( ! diagMatrix() ) {
//ๅณไธใฎๅฏพ่ง่ฆ็ด ใใใงใใฏ
if ( absolute( mat[C-1][C-1] ) < epsilon ) {
chasingRightBottom( u );//ๅทฆๅดใใ่ฟฝใ่พผใใงใใฎไธใฎ่ฆ็ด ใๅ
จใฆ้ถใซใใ
}
for ( int i = C - 2; 0 <= i; --i ) {
// i, iใฎๅฏพ่ง่ฆ็ด ใใใงใใฏ
if ( absolute( mat[i][i] ) < epsilon ) {
chasingDiag( v, i );//ๅณๅดใใ่ฟฝใ่พผใใงใใฎๅณใฎ่ฆ็ด ใๅ
จใฆ้ถใซใใ
}
// i, i+1ใใใงใใฏ
if ( absolute( mat[i][i+1] ) < epsilon ) {
//ใใฎ็ถๆ
ใงi,iใง๏ผใคใซๅใใๆใซใฏๅณไธใ้ถ่กๅใซใชใใใใ๏ผใคใซๅใใฆๅฆ็ใ่กใ
// i,iใพใงใจi+1,i+1ใใใงไบใคใซใใใ
matrixT d1 = minor( 0, 0, i + 1, i + 1 );
matrixT v1 = identity( d1.row(), d1.row() );
matrixT u1 = identity( d1.column(), d1.column() );
d1.svd4diag2( v1, u1 );
matrixT d2 = minor( i + 1, i + 1, row(), column() );
matrixT v2 = identity( d2.row(), d2.row() );
matrixT u2 = identity( d2.column(), d2.column() );
d2.svd4diag2( v2, u2 );
*this = zero( row(), column() );
copy( 0, 0, d1 );
copy( d1.row(), d1.column(), d2 );
matrixT nv = zero( row(), row() );
nv.copy( 0, 0, v1 );
nv.copy( v1.row(), v1.column(), v2 );
v = v * nv;
matrixT nu = zero( column(), column() );
nu.copy( 0, 0, u1 );
nu.copy( u1.row(), u1.column(), u2 );
u = u * nu;
return;
}
}
//่ฟฝใ่พผใฟ
chasing( v, u );
}
}
public:
////////////////////////////////////////////////////////////////////////////////
//็น็ฐๅคๅ่งฃ็จใซ็น็ฐๅคใฎ็ตถๅฏพๅคใฎๅคงใใ้ ใซใฝใผใ
static void sort4svd( matrixT & v, matrixT & d, matrixT & u )
{
const int N = minimum( d.row(), d.column() );
//้ธๆใฝใผใ
for ( int i = 0; i < N; ++i ) {
//ๆๅคงใๆขใ
checkMaximum<T> mx;
for ( int j = i; j < N; ++j ) {
mx( absolute( d[j][j] ), j );
}
if ( i != mn.sub ) {
swap( d[i][i], d[mx.sub][mx.sub] );
swap( v[i], v[mx.sub] );
swap( u[i], u[mx.sub] );
}
}
}
////////////////////////////////////////////////////////////////////////////////
//็น็ฐๅคๅ่งฃ
//A=V D Uโ ใซๅ่งฃ
//ไบ้ๅฏพ่งๅใ่กใ๏ผGivensๅคๆใซใใ้ๅฏพ่งๅ่ฆ็ด ใ่ฟฝใ่พผใฟใง้ถใซ่ฟใฅใใฆ๏ผๅ่งฃใ่กใๆๆณ
//ๆกไปถ๏ผ็กใ ใใ ใ๏ผๆชใฝใผใ
void singularValueDecomposition( matrixT & v, matrixT & d, matrixT & u ) const
{
const int R = row();
const int C = column();
if ( C < R ) {//็ธฆ้ทๆน่กๅใธๅคๆ
matrixT A = transpose( *this );
A.singularValueDecomposition( u, d, v );
u = transpose( u );
v = transpose( v );
return;
}
//ไบ้ๅฏพ่งๅ่กๅใธๅคๆ
d = *this;
d.diag2( u, v );// A -> u A v = A'ใจใใฆไบ้ๅฏพ่งๅ
// A = vโ A' uโ ๅ่งฃใจใใฆใฏ้ใซใชใ
v = transpose( v );// v A uโ ๅฝขๅผใซๅคๆ
d.svd4diag2( v, u );//ๅ่งฃ
//sort4svd( v, d, u );//ใฝใผใ
}
////////////////////////////////////////////////////////////////////////////////
//Moore-Penroseใฎไธ่ฌ้่กๅ
const matrixT generalInverse() const
{
matrixT v, d, u;// A=v d uโ ใจๅ่งฃ
singularValueDecomposition( v, d, u );
// A^+ = u 1/d vโ
return u * d.inverseDiag() * transpose( v );
}
////////////////////////////////////////////////////////////////////////////////
//ใใใใฐ็จๆๅญๅบๅ
static void debug( const matrixT & m, const char * tag = NULL )
{
if ( tag ) {
OutputDebugString( tag );
OutputDebugString( ":[matrix]\n" );
}
for ( int i = 0; i < m.row(); ++i ) {
vectorT<T>::debug( m[i] );
}
}
};
//ๅๅๆผ็ฎ
template<typename T>
const matrixT<T> operator+( const T & s, const matrixT<T> & m ) { return m + s; }
template<typename T>
const matrixT<T> operator-( const T & s, const matrixT<T> & m ) { return - m + s; }
template<typename T>
const matrixT<T> operator*( const T & s, const matrixT<T> & m ) { return m * s; }
template<typename T>
const matrixT<T> operator/( const T & s, const matrixT<T> & m )
{
matrixT<T> result( m );
for ( int r = 0; r < result.row(); ++r ) {
for ( int c = 0; c < result.column(); ++c ) {
result[r][c] = s / m[r][c];
}
}
return r;
}
template<typename T>
const vectorT<T> operator*( const vectorT<T> v, const matrixT<T> & m )
{
vectorT<T> result = vectorT<T>::zero( column() );
for ( int c = 0; c < column(); ++c ) {
T & sum = result[c];
for ( int r = 0; r < row() && r < v.dimension(); ++r ) {
sum += v[r] * m[r][c];
}
}
return result;
}
| [
"akira_asakura@dwango.co.jp"
] | akira_asakura@dwango.co.jp |
85396ef802709fa64b6bc2b0a6f6cea4f0e46ee5 | 8f021f68cd0949afa8d119582c0b419b014919d8 | /URIOJ/uri1507-v2.cpp | 00566e3627fded0baad4c3c763e65259a9a8f781 | [] | no_license | Jonatankk/codigos | b9c8426c2f33b5142460a84337480b147169b3e6 | 233ae668bdf6cdd12dbc9ef243fb4ccdab49c933 | refs/heads/master | 2022-07-22T11:09:27.271029 | 2020-05-09T20:57:42 | 2020-05-09T20:57:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 536 | cpp | /*
* Leonardo Deliyannis Constantin
* URI 1507 - Subsequรชncias
*/
#include <stdio.h>
#include <string.h>
#define LEN 112345
char s[LEN];
char t[112];
bool isSubSeq(int m, int n){
if(n == 0) return true;
if(m == 0) return false;
if(s[m-1] == t[n-1]){
return isSubSeq(m-1, n-1);
}
return isSubSeq(m-1, n);
}
int main(){
int N, Q;
scanf("%d", &N);
while(N--){
scanf("%s", s);
scanf("%d", &Q);
while(Q--){
scanf("%s", t);
printf("%s\n", isSubSeq(strlen(s), strlen(t)) ?
"Yes" : "No");
}
}
return 0;
}
| [
"constantin.leo@gmail.com"
] | constantin.leo@gmail.com |
567c0cf94456223a5772e2f0437c4c629dc781e2 | 3bbaac515ad3cd3bf2c27e886a47b3c2a7acbecf | /src/Tree.h | 9a589c59a9b34ada594c61de1bf41648931087a4 | [] | no_license | zc444/image-clasification | e28a4031b18d9d6dd11eb05ac613e545f6501903 | 3966339433d41d4ba9f2920f7f9f195e289616c5 | refs/heads/master | 2022-12-22T15:40:46.609637 | 2020-09-11T01:59:26 | 2020-09-11T01:59:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,764 | h | //========================================================================
// Tree.h
//========================================================================
// Declarations for generic tree.
#ifndef TREE_H
#define TREE_H
#include <cstddef>
template <typename T>
class Tree {
private:
struct Node {
//Node( T v ) : value( v ), left( nullptr ), right( nullptr ) {}
Node( T v ){
value = v;
left = nullptr;
right = nullptr;
}
T value;
Node* left;
Node* right;
};
public:
Tree( unsigned int K = 0 );
~Tree();
// Copy constructor
Tree( const Tree<T>& tree );
// Methods
size_t size() const;
void add( const T& value );
bool find( const T& value ) const;
const T& find_closest( const T& value ) const;
void print() const;
int getK() const;
void setK(unsigned int K);
// Operator overloading
Tree<T>& operator=( const Tree<T>& tree );
private:
// helper function
void RemoveSubtree( Node* node_p );
void add_h( Node* nodetocheck, T value, Node* parentnode, int leftright );
void insert( Node* nodetoinsert, T value, Node* parentnode, int leftright );
//void size_h( Node* node, size_t& count ) const;
void find_h( Node* node, const T& value, bool& flag ) const;
Tree<T>::Node* binary_search( Node* node, int level, const T& value ) const; //const Tree<T>::Node*
T* exhaustive_search( Node* node, const T& value ) const;
void print_h( Node* node, int level ) const;
void copy( Node*& curr1, Node*& curr2 );
void addtree( Node* node );
Node* m_root;
size_t m_size;
unsigned int m_K;
};
// Include inline definitions
#include "Tree.inl"
#endif /* TREE_H */
| [
"zc444@cornell.edu"
] | zc444@cornell.edu |
be8273c47a9cfb86b9055e871f6fdcfb33a526df | 9fbff544471056f0816fa52d1bbf0c4db47c1f24 | /template/tree/ไบๅๆ ็้ๅ2.cpp | cd4f217c451f0e2c5497f99369b5fdd597ea9442 | [] | no_license | theDreamBear/algorithmn | 88d1159fb70e60b5a16bb64673d7383e20dc5fe5 | c672d871848a7453ac3ddb8335b1e38d112626ee | refs/heads/master | 2023-06-08T15:47:08.368054 | 2023-06-02T13:00:30 | 2023-06-02T13:00:30 | 172,293,806 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,545 | cpp | #include <iostream>
#include <iterator>
#include <queue>
#include <stack>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution1 {
public:
bool isSymmetricHeler(TreeNode *left, TreeNode *right) {
if (nullptr == left && nullptr == right) {
return true;
}
if (nullptr == left || nullptr == right || left->val != right->val) {
return false;
}
return isSymmetricHeler(left->left, right->right) && isSymmetricHeler(left->right, right->left);
}
bool isSymmetric(TreeNode *root) {
// ่ฟๆฏไธ็งๅพ็ด็ฝ็ๅๅบ
return isSymmetricHeler(root, root);
}
};
class Solution2 {
public:
bool isSymmetric(TreeNode *root) {
if (nullptr == root) {
return true;
}
stack<pair<TreeNode *, TreeNode *>> st;
st.push(make_pair(root, root));
while (!st.empty()) {
auto[lhs, rhs] = st.top();
st.pop();
if (nullptr == lhs && nullptr == rhs) {
continue;
}
if (nullptr == lhs || nullptr == rhs || lhs->val != rhs->val) {
return false;
}
st.push(make_pair(lhs->right, rhs->left));
st.push(make_pair(lhs->left, rhs->right));
}
return true;
}
};
void postTraversal1(TreeNode *root) {
if (nullptr == root) {
return;
}
// ๅญๅจๅพ
่ฎฟ้ฎ่็น
// ็บฆๅฎ1ใไธ่ฝๆ็ฉบ่็น
stack<TreeNode *> st;
TreeNode *cur = root;
// ไธไธไธช่ฎฟ้ฎ็่็น
TreeNode *pre = nullptr;
while (cur || !st.empty()) {
while (cur) {
st.push(cur);
cur = cur->left;
}
cur = st.top();
if (nullptr == cur->right || cur->right == pre) {
cout << cur->val << "\t" << endl;
st.pop();
pre = cur;
cur = nullptr;
} else {
cur = cur->right;
}
}
}
void postTraversal3(TreeNode *root) {
if (nullptr == root) {
return;
}
// ๅญๅจๅพ
่ฎฟ้ฎ่็น
// ็บฆๅฎ1ใไธ่ฝๆ็ฉบ่็น
stack<TreeNode *> st;
TreeNode* cur = root;
TreeNode* preHandled = nullptr;
while (cur || !st.empty()) {
// cur ๆฏๆชๆทปๅ ่็น
while (cur) {
st.push(cur);
if (cur->left) {
cur = cur->left;
} else {
break;
}
}
if (nullptr == cur) {
cur = st.top();
}
if (!cur->right || cur->right == preHandled) {
cout << cur->val << "\t";
preHandled = cur;
st.pop();
cur = nullptr;
} else {
cur = cur->right;
}
}
}
void postTraversal4(TreeNode *root) {
if (nullptr == root) {
return;
}
// ๅญๅจๅพ
่ฎฟ้ฎ่็น
// ็บฆๅฎ1ใไธ่ฝๆ็ฉบ่็น
stack<TreeNode *> st;
TreeNode* cur = root;
TreeNode* preHandled = nullptr;
while (cur) {
st.push(cur);
cur = cur->left;
}
while (!st.empty()) {
// ่ณๅฐ็ฌฌไบๆฌก้ๅฐ
cur = st.top();
if (nullptr == cur->right || cur->right == preHandled) {
cout << cur->val << "\t";
preHandled = cur;
st.pop();
} else {
cur = cur->right;
while (cur) {
st.push(cur);
cur = cur->left;
}
}
}
}
void postTraversal2(TreeNode *root) {
if (nullptr == root) {
return;
}
// ๅญๅจๅพ
่ฎฟ้ฎ่็น
// ็บฆๅฎ1ใไธ่ฝๆ็ฉบ่็น
stack<TreeNode *> st;
TreeNode *pre = nullptr;
TreeNode *cur = root;
while (cur) {
// ๆๆ่็น็ฌฌไธๆฌก่ฎฟ้ฎ
st.push(cur);
cur = cur->left;
}
while (!st.empty()) {
// ไฟ่ฏ้ๅฐ็้ฝๆฏ็ฌฌไบๆฌก,็ฌฌไธๆฌก่ฎฟ้ฎ็
cur = st.top();
// ็ฌฌไบๆฌก ๆ่
็ฌฌไธๆฌก
if (nullptr == cur->right || cur->right == pre) {
cout << cur->val << "\t";
pre = cur;
st.pop();
continue;
}
cur = cur->right;
while (cur) {
// ๆๆ่็น็ฌฌไธๆฌก่ฎฟ้ฎ
st.push(cur);
cur = cur->left;
}
}
}
bool postTraversal(TreeNode *root) {
if (nullptr == root) {
return true;
}
// ๅญๅจๅพ
่ฎฟ้ฎ่็น
// ็บฆๅฎ1ใ็บฆๅฎๅฏไปฅๆ็ฉบ่็น
TreeNode dummy{-1};
auto gen = [&dummy](TreeNode *node, TreeNode *TreeNode::*lhs, TreeNode *TreeNode::*rhs) {
stack<TreeNode *> st;
TreeNode *pre = nullptr;
TreeNode *cur = node;
while (cur) {
st.push(cur);
cur = cur->*lhs;
}
queue<TreeNode *> q;
return [=, &dummy]() mutable -> TreeNode * {
while (!st.empty()) {
if (!q.empty()) {
auto res = q.front();
q.pop();
return res;
}
// yield
if (nullptr == cur) {
cur = st.top();
q.push(nullptr);
}
if (nullptr == cur->*rhs) {
q.push(nullptr);
pre = cur;
st.pop();
if (!st.empty()) {
cur = st.top();
}
// push
q.push(pre);
} else if (cur->*rhs && cur->*rhs == pre) {
pre = cur;
st.pop();
if (!st.empty()) {
cur = st.top();
}
// push
q.push(pre);
}
cur = cur->*rhs;
while (cur) {
st.push(cur);
cur = cur->*lhs;
}
}
if (!q.empty()) {
auto res = q.front();
q.pop();
return res;
}
return &dummy;
};
};
auto gen1 = gen(root, &TreeNode::left, &TreeNode::right);
auto gen2 = gen(root, &TreeNode::right, &TreeNode::left);
for (;;) {
auto l = gen1();
auto r = gen2();
if (nullptr == l && nullptr == r) {
continue;
}
if (nullptr == l || nullptr == r) {
return false;
}
if (&dummy == l && &dummy == r) {
break;
}
if (&dummy == l || &dummy == r) {
return false;
}
if (l->val != r->val) {
return false;
}
}
return true;
}
class Solution {
public:
bool isSymmetric(TreeNode *root) {
if (nullptr == root) {
return true;
}
// ๅญๅจๅพ
่ฎฟ้ฎ่็น
// ็บฆๅฎ1ใ็บฆๅฎๅฏไปฅๆ็ฉบ่็น
TreeNode dummy{-1};
auto gen = [&dummy](TreeNode *node, TreeNode *TreeNode::*lhs, TreeNode *TreeNode::*rhs) {
stack<TreeNode *> st;
queue<TreeNode *> q;
TreeNode *pre = nullptr;
TreeNode *cur = node;
return [=, &dummy]() mutable -> TreeNode * {
while (cur || !st.empty()) {
while (cur) {
st.push(cur);
cur = cur->*lhs;
if (nullptr == cur) {
q.push(nullptr);
}
}
cur = st.top();
if (nullptr == cur->*rhs || (cur->*rhs && cur->*rhs == pre)) {
if (nullptr == cur->*rhs) {
q.push(nullptr);
}
q.push(cur);
st.pop();
pre = cur;
cur = nullptr;
continue;
} else {
cur = cur->*rhs;
}
if (!q.empty()) {
auto res = q.front();
q.pop();
return res;
}
}
if (!q.empty()) {
auto res = q.front();
q.pop();
return res;
}
return &dummy;
};
};
auto gen1 = gen(root->left, &TreeNode::left, &TreeNode::right);
auto gen2 = gen(root->right, &TreeNode::right, &TreeNode::left);
for (;;) {
auto l = gen1();
auto r = gen2();
if (nullptr == l && nullptr == r) {
continue;
}
if (nullptr == l || nullptr == r) {
return false;
}
if (&dummy == l && &dummy == r) {
break;
}
if (&dummy == l || &dummy == r) {
return false;
}
if (l->val != r->val) {
return false;
}
}
return true;
}
};
// 1,2,2,3,4,4,3
// ๅ
ณ้ฎ้่ฆๅ็ฐ่พน็
void bfs(TreeNode* root) {
if (nullptr == root) {
return;
}
queue<TreeNode*> q;
q.push(root);
q.push(nullptr);
while (q.size() > 1) {
auto node = q.front();
q.pop();
if (node) {
cout << node->val << "\t";
if (node->left) {
q.push(node->left);
}
if (node->right) {
q.push(node->right);
}
} else {
cout << endl;
q.push(nullptr);
}
}
}
int main(int argc, char *argv[]) {
TreeNode *root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(2);
root->left->left = new TreeNode(3);
root->left->right = new TreeNode(4);
root->right->left = new TreeNode(4);
root->right->right = new TreeNode(3);
//cout << Solution{}.isSymmetric(root);
postTraversal4(root);
}
#include <iostream>
#include <iterator>
#include <queue>
#include <stack>
#include <unordered_map>
using namespace std;
struct TreeNode {
struct TreeNode *left, *right;
int val;
explicit TreeNode(int val) : val(val), left(left), right(right) {
auto x = &TreeNode::left;
}
};
enum Order {
PRE,
IN,
POST,
};
vector<TreeNode *TreeNode::*> children = {&TreeNode::left, &TreeNode::right, nullptr};
void traversal(TreeNode *root, Order order) {
if (nullptr == root) {
return;
}
for (auto next: children) {
if (next == children[order]) {
cout << root->val << "\t";
}
if (next == nullptr) {
return;
}
traversal(root->*next, order);
}
}
bool isNULL(const string &s) {
return s == "null";
}
TreeNode *makeNode(string value) {
if (isNULL(value)) {
return nullptr;
}
return new TreeNode(atoi(value.c_str()));
}
TreeNode *makeTree(const vector<std::string> &data) {
if (data.empty()) {
return NULL;
}
int cur_available_pos = 0;
TreeNode *root = makeNode(data[cur_available_pos++]);
assert(root != nullptr);
queue<pair<TreeNode *, int>> q;
q.push(make_pair(root, cur_available_pos));
cur_available_pos += 2;
auto addChild = [&](TreeNode *node, int idx, TreeNode *TreeNode::* child) {
if (idx >= data.size()) {
return;
}
auto newNode = makeNode(data[idx]);
node->*child = newNode;
// for child's children
if (nullptr != newNode) {
q.push(make_pair(newNode, cur_available_pos));
cur_available_pos += 2;
}
};
while (!q.empty()) {
int sz = q.size();
for (int i = 0; i < sz; i++) {
auto[node, start] = q.front();
q.pop();
// start ๅฟ
ๅฎๆฏๅๆณ็
addChild(node, start, &TreeNode::left);
addChild(node, start + 1, &TreeNode::right);
}
}
return root;
}
int main(int argc, char *argv[]) {
auto root = makeTree({"1", "2", "3", "null", "4", "null", "null", "5"});
traversal(root, PRE);
cout << endl;
traversal(root, IN);
cout << endl;
traversal(root, POST);
cout << endl;
} | [
"nichao@zuoyebang.com"
] | nichao@zuoyebang.com |
cd80871c28454c48040719b15f7501bb732a6bf5 | 751f0297891d8ea6975842e887689b7024c32fda | /Source/bmalloc/bmalloc/SmallLine.h | e044e70dfb9299f6969cff4e739eacfefa60bab6 | [] | no_license | gskachkov/webkit | 4d162c15a2db7d9455fe2200c7ffa2002f34a59a | c9aeb6d32e22bfa22ad468324f3e0ea48354badb | refs/heads/master | 2023-03-01T05:32:31.643945 | 2016-04-13T18:24:52 | 2016-04-13T18:24:52 | 30,821,838 | 0 | 0 | null | 2015-02-15T08:15:59 | 2015-02-15T08:15:58 | null | UTF-8 | C++ | false | false | 2,319 | h | /*
* Copyright (C) 2014-2016 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SmallLine_h
#define SmallLine_h
#include "BAssert.h"
#include "Mutex.h"
#include "ObjectType.h"
#include <mutex>
namespace bmalloc {
class SmallLine {
public:
static const unsigned char maxRefCount = std::numeric_limits<unsigned char>::max();
static_assert(smallLineSize / alignment < maxRefCount, "maximum object count must fit in Line");
static SmallLine* get(void*);
void ref(std::lock_guard<StaticMutex>&, unsigned char);
bool deref(std::lock_guard<StaticMutex>&);
unsigned refCount(std::lock_guard<StaticMutex>&) { return m_refCount; }
char* begin();
char* end();
private:
unsigned char m_refCount;
};
inline void SmallLine::ref(std::lock_guard<StaticMutex>&, unsigned char refCount)
{
BASSERT(!m_refCount);
m_refCount = refCount;
}
inline bool SmallLine::deref(std::lock_guard<StaticMutex>&)
{
BASSERT(m_refCount);
--m_refCount;
return !m_refCount;
}
} // namespace bmalloc
#endif // SmallLine_h
| [
"ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc"
] | ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc |
03ae6d0aad26417884105d807f020981b7733a85 | 4503b4ec29e9a30d26c433bac376f2bddaefd9e5 | /boost_1_56_0_WinCE/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp | 6df2553040f7f71976e223f1406c80a50f9e6f05 | [] | no_license | SwunZH/ecocommlibs | 0a872e0bbecbb843a0584fb787cf0c5e8a2a270b | 4cff09ff1e479f5f519f207262a61ee85f543b3a | refs/heads/master | 2021-01-25T12:02:39.067444 | 2018-02-23T07:04:43 | 2018-02-23T07:04:43 | 123,447,012 | 1 | 0 | null | 2018-03-01T14:37:53 | 2018-03-01T14:37:53 | null | UTF-8 | C++ | false | false | 18,352 | hpp | /*
[auto_generated]
boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp
[begin_description]
Range algebra for OpenMP.
[end_description]
Copyright 2013 Karsten Ahnert
Copyright 2013 Mario Mulansky
Copyright 2013 Pascal Germroth
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_RANGE_ALGEBRA_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_RANGE_ALGEBRA_HPP_INCLUDED
#include <boost/assert.hpp>
#include <boost/range.hpp>
#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
#include <boost/numeric/odeint/util/n_ary_helper.hpp>
namespace boost {
namespace numeric {
namespace odeint {
/** \brief OpenMP-parallelized range algebra.
*
* State must be a model of Random Access Range.
*/
struct openmp_range_algebra
{
#if __cplusplus >= 201103L // C++11 supports _Pragma
#define BOOST_ODEINT_GEN_LOCAL(z, n, unused) \
BOOST_ASSERT_MSG( len == boost::size(s ## n), "All state ranges must have the same size." ); \
typename boost::range_iterator<S ## n>::type beg ## n = boost::begin(s ## n);
#define BOOST_ODEINT_GEN_BODY(n) \
const size_t len = boost::size(s0); \
BOOST_PP_REPEAT(n, BOOST_ODEINT_GEN_LOCAL, ~) \
_Pragma("omp parallel for schedule(runtime)") \
for( size_t i = 0 ; i < len ; i++ ) \
op( BOOST_PP_ENUM_BINARY_PARAMS(n, beg, [i] BOOST_PP_INTERCEPT) );
BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY)
#undef BOOST_ODEINT_GEN_BODY
#undef BOOST_ODEINT_GEN_LOCAL
#else
template< class S0 , class Op > static void for_each1 ( S0 &s0 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] );
}
template< class S0 , class S1 , class Op > static void for_each2 ( S0 &s0 , S1 &s1 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] );
}
template< class S0 , class S1 , class S2 , class Op > static void for_each3 ( S0 &s0 , S1 &s1 , S2 &s2 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class Op > static void for_each4 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class Op > static void for_each5 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each6 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each7 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each8 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each9 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each10 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each11 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each12 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each13 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each14 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] );
}
template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each15 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) {
const size_t len = boost::size(s0);
typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
typename boost::range_iterator<S14>::type beg14 = boost::begin(s14);
#pragma omp parallel for schedule(runtime)
for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , beg14 [i] );
}
#endif
template< class S >
static typename norm_result_type< S >::type norm_inf( const S &s )
{
using std::max;
using std::abs;
typedef typename norm_result_type< S >::type result_type;
result_type init = static_cast< result_type >( 0 );
const size_t len = boost::size(s);
typename boost::range_iterator<S>::type beg = boost::begin(s);
# pragma omp parallel for reduction(max: init) schedule(dynamic)
for( size_t i = 0 ; i < len ; ++i )
init = max( init , abs( beg[i] ) );
return init;
}
};
}
}
}
#endif
| [
"lycos7x@3e9e098e-e079-49b3-9d2b-ee27db7392fb"
] | lycos7x@3e9e098e-e079-49b3-9d2b-ee27db7392fb |
48f19691a6a9c816e6c741dfe21e8e2c00c9813a | c9787aef563b1cb6a24a3ec4c09e5f4535a28c46 | /pp5_AlejandroCoronado/mips.cc | 84509743fde8d4449c4f3bb29a35d4202648d2aa | [] | no_license | coronate-zz/compiladorDecaf | 3fa0c927b8e24a78414df253b69cc18d47fb6636 | 2d2fb3c24b47279db402f7a9e7bdc45a0b7ec8e8 | refs/heads/master | 2021-06-16T11:16:55.003205 | 2017-05-26T08:47:44 | 2017-05-26T08:47:44 | 83,354,158 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 15,356 | cc |
#include <stdarg.h>
#include <cstring>
#include "mips.h"
// Helper to check if two variable locations are one and the same
// (same name, segment, and offset)
static bool LocationsAreSame(Location *var1, Location *var2) {
return (var1 == var2 ||
(var1 && var2
&& !strcmp(var1->GetName(), var2->GetName())
&& var1->GetSegment() == var2->GetSegment()
&& var1->GetOffset() == var2->GetOffset()));
}
/* Method: SpillRegister
* ---------------------
* Used to spill a register from reg to dst. All it does is emit a store
* from that register to its location on the stack.
*/
void Mips::SpillRegister(Location *dst, Register reg) {
Assert(dst);
const char *offsetFromWhere = dst->GetSegment() == fpRelative
? regs[fp].name : regs[gp].name;
Assert(dst->GetOffset() % 4 == 0); // all variables are 4 bytes in size
Emit("sw %s, %d(%s)\t# spill %s from %s to %s%+d", regs[reg].name,
dst->GetOffset(), offsetFromWhere, dst->GetName(), regs[reg].name,
offsetFromWhere,dst->GetOffset());
}
/* Method: FillRegister
* --------------------
* Fill a register from location src into reg.
* Simply load a word into a register.
*/
void Mips::FillRegister(Location *src, Register reg) {
Assert(src);
const char *offsetFromWhere = src->GetSegment() == fpRelative
? regs[fp].name : regs[gp].name;
Assert(src->GetOffset() % 4 == 0); // all variables are 4 bytes in size
Emit("lw %s, %d(%s)\t# fill %s to %s from %s%+d", regs[reg].name,
src->GetOffset(), offsetFromWhere, src->GetName(), regs[reg].name,
offsetFromWhere,src->GetOffset());
}
/* Method: Emit
* ------------
* General purpose helper used to emit assembly instructions in
* a reasonable tidy manner. Takes printf-style formatting strings
* and variable arguments.
*/
void Mips::Emit(const char *fmt, ...) {
va_list args;
char buf[1024];
va_start(args, fmt);
vsprintf(buf, fmt, args);
va_end(args);
if (buf[strlen(buf) - 1] != ':') printf("\t"); // don't tab in labels
if (buf[0] != '#') printf(" "); // outdent comments a little
printf("%s", buf);
if (buf[strlen(buf)-1] != '\n') printf("\n"); // end with a newline
}
/* Method: EmitLoadConstant
* ------------------------
* Used to assign variable an integer constant value. Slaves dst into
* a register (using GetRegister above) and then emits an li (load
* immediate) instruction with the constant value.
*/
void Mips::EmitLoadConstant(Location *dst, int val) {
Register r = rd;
Emit("li %s, %d\t\t# load constant value %d into %s", regs[r].name,
val, val, regs[r].name);
SpillRegister(dst, rd);
}
/* Method: EmitLoadStringConstant
* ------------------------------
* Used to assign a variable a pointer to string constant. Emits
* assembly directives to create a new null-terminated string in the
* data segment and assigns it a unique label. Slaves dst into a register
* and loads that label address into the register.
*/
void Mips::EmitLoadStringConstant(Location *dst, const char *str) {
static int strNum = 1;
char label[16];
sprintf(label, "_string%d", strNum++);
Emit(".data\t\t\t# create string constant marked with label");
Emit("%s: .asciiz %s", label, str);
Emit(".text");
EmitLoadLabel(dst, label);
}
/* Method: EmitLoadLabel
* ---------------------
* Used to load a label (ie address in text/data segment) into a variable.
* Slaves dst into a register and emits an la (load address) instruction
*/
void Mips::EmitLoadLabel(Location *dst, const char *label) {
Emit("la %s, %s\t# load label", regs[rd].name, label);
SpillRegister(dst, rd);
}
/* Method: EmitCopy
* ----------------
* Used to copy the value of one variable to another. Slaves both
* src and dst into registers and then emits a move instruction to
* copy the contents from src to dst.
*/
void Mips::EmitCopy(Location *dst, Location *src) {
FillRegister(src, rd);
SpillRegister(dst, rd);
}
/* Method: EmitLoad
* ----------------
* Used to assign dst the contents of memory at the address in reference,
* potentially with some positive/negative offset (defaults to 0).
* Slaves both ref and dst to registers, then emits a lw instruction
* using constant-offset addressing mode y(rx) which accesses the address
* at an offset of y bytes from the address currently contained in rx.
*/
void Mips::EmitLoad(Location *dst, Location *reference, int offset) {
FillRegister(reference, rs);
Emit("lw %s, %d(%s) \t# load with offset", regs[rd].name,
offset, regs[rs].name);
SpillRegister(dst, rd);
}
/* Method: EmitStore
* -----------------
* Used to write value to memory at the address in reference,
* potentially with some positive/negative offset (defaults to 0).
* Slaves both ref and dst to registers, then emits a sw instruction
* using constant-offset addressing mode y(rx) which writes to the address
* at an offset of y bytes from the address currently contained in rx.
*/
void Mips::EmitStore(Location *reference, Location *value, int offset) {
FillRegister(value, rs);
FillRegister(reference, rd);
Emit("sw %s, %d(%s) \t# store with offset",
regs[rs].name, offset, regs[rd].name);
}
/* Method: EmitBinaryOp
* --------------------
* Used to perform a binary operation on 2 operands and store result
* in dst. All binary forms for arithmetic, logical, relational, equality
* use this method. Slaves both operands and dst to registers, then
* emits the appropriate instruction by looking up the mips name
* for the particular op code.
*/
void Mips::EmitBinaryOp(BinaryOp::OpCode code, Location *dst,
Location *op1, Location *op2)
{
FillRegister(op1, rs);
FillRegister(op2, rt);
Emit("%s %s, %s, %s\t", NameForTac(code), regs[rd].name,
regs[rs].name, regs[rt].name);
SpillRegister(dst, rd);
}
/* Method: EmitLabel
* -----------------
* Used to emit label marker. Before a label, we spill all registers since
* we can't be sure what the situation upon arriving at this label (ie
* starts new basic block), and rather than try to be clever, we just
* wipe the slate clean.
*/
void Mips::EmitLabel(const char *label) {
Emit("%s:", label);
}
/* Method: EmitGoto
* ----------------
* Used for an unconditional transfer to a named label. Before a goto,
* we spill all registers, since we don't know what the situation is
* we are heading to (ie this ends current basic block) and rather than
* try to be clever, we just wipe slate clean.
*/
void Mips::EmitGoto(const char *label) {
Emit("b %s\t\t# unconditional branch", label);
}
/* Method: EmitIfZ
* ---------------
* Used for a conditional branch based on value of test variable.
* We slave test var to register and use in the emitted test instruction,
* either beqz. See comments above on Goto for why we spill
* all registers here.
*/
void Mips::EmitIfZ(Location *test, const char *label) {
FillRegister(test, rs);
Emit("beqz %s, %s\t# branch if %s is zero ", regs[rs].name, label,
test->GetName());
}
/* Method: EmitParam
* -----------------
* Used to push a parameter on the stack in anticipation of upcoming
* function call. Decrements the stack pointer by 4. Slaves argument into
* register and then stores contents to location just made at end of
* stack.
*/
void Mips::EmitParam(Location *arg) {
Emit("subu $sp, $sp, 4\t# decrement sp to make space for param");
FillRegister(arg, rs);
Emit("sw %s, 4($sp)\t# copy param value to stack", regs[rs].name);
}
/* Method: EmitCallInstr
* ---------------------
* Used to effect a function call. All necessary arguments should have
* already been pushed on the stack, this is the last step that
* transfers control from caller to callee. See comments on Goto method
* above for why we spill all registers before making the jump. We issue
* jal for a label, a jalr if address in register. Both will save the
* return address in $ra. If there is an expected result passed, we slave
* the var to a register and copy function return value from $v0 into that
* register.
*/
void Mips::EmitCallInstr(Location *result, const char *fn, bool isLabel) {
Emit("%s %-15s\t# jump to function", isLabel? "jal": "jalr", fn);
if (result != NULL) {
Emit("move %s, %s\t\t# copy function return value from $v0",
regs[rd].name, regs[v0].name);
SpillRegister(result, rd);
}
}
// Two covers for the above method for specific LCall/ACall variants
void Mips::EmitLCall(Location *dst, const char *label) {
EmitCallInstr(dst, label, true);
}
void Mips::EmitACall(Location *dst, Location *fn) {
FillRegister(fn, rs);
EmitCallInstr(dst, regs[rs].name, false);
}
/*
* We remove all parameters from the stack after a completed call
* by adjusting the stack pointer upwards.
*/
void Mips::EmitPopParams(int bytes) {
if (bytes != 0)
Emit("add $sp, $sp, %d\t# pop params off stack", bytes);
}
/* Method: EmitReturn
* ------------------
* Used to emit code for returning from a function (either from an
* explicit return or falling off the end of the function body).
* If there is an expression to return, we slave that variable into
* a register and move its contents to $v0 (the standard register for
* function result). Before exiting, we spill dirty registers (to
* commit contents of slaved registers to memory, necessary for
* consistency, see comments at SpillForEndFunction above). We also
* do the last part of the callee's job in function call protocol,
* which is to remove our locals/temps from the stack, remove
* saved registers ($fp and $ra) and restore previous values of
* $fp and $ra so everything is returned to the state we entered.
* We then emit jr to jump to the saved $ra.
*/
void Mips::EmitReturn(Location *returnVal) {
if (returnVal != NULL) {
FillRegister(returnVal, rd);
Emit("move $v0, %s\t\t# assign return value into $v0",
regs[rd].name);
}
Emit("move $sp, $fp\t\t# pop callee frame off stack");
Emit("lw $ra, -4($fp)\t# restore saved ra");
Emit("lw $fp, 0($fp)\t# restore saved fp");
Emit("jr $ra\t\t# return from function");
}
/* Method: EmitBeginFunction
* -------------------------
* Used to handle the callee's part of the function call protocol
* upon entering a new function. We decrement the $sp to make space
* and then save the current values of $fp and $ra (since we are
* going to change them), then set up the $fp and bump the $sp down
* to make space for all our locals/temps.
*/
void Mips::EmitBeginFunction(int stackFrameSize) {
Assert(stackFrameSize >= 0);
Emit("subu $sp, $sp, 8\t# decrement sp to make space to save ra, fp");
Emit("sw $fp, 8($sp)\t# save fp");
Emit("sw $ra, 4($sp)\t# save ra");
Emit("addiu $fp, $sp, 8\t# set up new fp");
if (stackFrameSize != 0)
Emit(
"subu $sp, $sp, %d\t# decrement sp to make space for locals/temps",
stackFrameSize);
}
/* Method: EmitEndFunction
* -----------------------
* Used to end the body of a function. Does an implicit return in fall off
* case to clean up stack frame, return to caller etc. See comments on
* EmitReturn above.
*/
void Mips::EmitEndFunction() {
Emit("# (below handles reaching end of fn body with no explicit return)");
EmitReturn(NULL);
}
/* Method: EmitVTable
* ------------------
* Used to layout a vtable. Uses assembly directives to set up new
* entry in data segment, emits label, and lays out the function
* labels one after another.
*/
void Mips::EmitVTable(const char *label, List<const char*> *methodLabels) {
Emit(".data");
Emit(".align 2");
Emit("%s:\t\t# label for class %s vtable", label, label);
for (int i = 0; i < methodLabels->NumElements(); i++)
Emit(".word %s\n", methodLabels->Nth(i));
Emit(".text");
}
/* Method: EmitPreamble
* --------------------
* Used to emit the starting sequence needed for a program. Not much
* here, but need to indicate what follows is in text segment and
* needs to be aligned on word boundary. main is our only global symbol.
*/
void Mips::EmitPreamble() {
Emit("# standard Decaf preamble ");
Emit(".text");
Emit(".align 2");
Emit(".globl main");
}
/* Method: NameForTac
* ------------------
* Returns the appropriate MIPS instruction (add, seq, etc.) for
* a given BinaryOp:OpCode (BinaryOp::Add, BinaryOp:Equals, etc.).
* Asserts if asked for name of an unset/out of bounds code.
*/
const char *Mips::NameForTac(BinaryOp::OpCode code) {
Assert(code >=0 && code < BinaryOp::NumOps);
const char *name = mipsName[code];
Assert(name != NULL);
return name;
}
/* Constructor
* ----------
* Constructor sets up the mips names and register descriptors to
* the initial starting state.
*/
Mips::Mips() {
mipsName[BinaryOp::Add] = "add";
mipsName[BinaryOp::Sub] = "sub";
mipsName[BinaryOp::Mul] = "mul";
mipsName[BinaryOp::Div] = "div";
mipsName[BinaryOp::Mod] = "rem";
mipsName[BinaryOp::Eq] = "seq";
mipsName[BinaryOp::Ne] = "sne";
mipsName[BinaryOp::Lt] = "slt";
mipsName[BinaryOp::Le] = "sle";
mipsName[BinaryOp::Gt] = "sgt";
mipsName[BinaryOp::Ge] = "sge";
mipsName[BinaryOp::And] = "and";
mipsName[BinaryOp::Or] = "or";
regs[zero] = (RegContents){false, NULL, "$zero", false};
regs[at] = (RegContents){false, NULL, "$at", false};
regs[v0] = (RegContents){false, NULL, "$v0", false};
regs[v1] = (RegContents){false, NULL, "$v1", false};
regs[a0] = (RegContents){false, NULL, "$a0", false};
regs[a1] = (RegContents){false, NULL, "$a1", false};
regs[a2] = (RegContents){false, NULL, "$a2", false};
regs[a3] = (RegContents){false, NULL, "$a3", false};
regs[k0] = (RegContents){false, NULL, "$k0", false};
regs[k1] = (RegContents){false, NULL, "$k1", false};
regs[gp] = (RegContents){false, NULL, "$gp", false};
regs[sp] = (RegContents){false, NULL, "$sp", false};
regs[fp] = (RegContents){false, NULL, "$fp", false};
regs[ra] = (RegContents){false, NULL, "$ra", false};
regs[t0] = (RegContents){false, NULL, "$t0", true};
regs[t1] = (RegContents){false, NULL, "$t1", true};
regs[t2] = (RegContents){false, NULL, "$t2", true};
regs[t3] = (RegContents){false, NULL, "$t3", true};
regs[t4] = (RegContents){false, NULL, "$t4", true};
regs[t5] = (RegContents){false, NULL, "$t5", true};
regs[t6] = (RegContents){false, NULL, "$t6", true};
regs[t7] = (RegContents){false, NULL, "$t7", true};
regs[t8] = (RegContents){false, NULL, "$t8", true};
regs[t9] = (RegContents){false, NULL, "$t9", true};
regs[s0] = (RegContents){false, NULL, "$s0", true};
regs[s1] = (RegContents){false, NULL, "$s1", true};
regs[s2] = (RegContents){false, NULL, "$s2", true};
regs[s3] = (RegContents){false, NULL, "$s3", true};
regs[s4] = (RegContents){false, NULL, "$s4", true};
regs[s5] = (RegContents){false, NULL, "$s5", true};
regs[s6] = (RegContents){false, NULL, "$s6", true};
regs[s7] = (RegContents){false, NULL, "$s7", true};
rs = t0; rt = t1; rd = t2;
}
const char *Mips::mipsName[BinaryOp::NumOps];
| [
"acoronadn@gmail.com"
] | acoronadn@gmail.com |
514ac0ee036fe990dbe4e6bb5c099f194b9b961d | 493fa2172dc55557d9d882d12cf9822c78fff08c | /BaseVr2/Plugins/VRExpansionPlugin/VRExpansionPlugin/Source/VRExpansionPlugin/Private/VRCharacterMovementComponent.cpp | f21825c3deaf84eba5abfbdf98e297b75f0ee75a | [
"MIT"
] | permissive | chriszavadil/OculusHandsWithAnimation | 217c534a050952866b1b4dbd6bef13ddd6e2e0b8 | 9157371e1874670a6f3cb4138dc65ff86d850265 | refs/heads/master | 2023-01-21T11:40:33.542357 | 2020-11-28T17:38:59 | 2020-11-28T17:38:59 | 310,038,703 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 172,424 | cpp | // Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
/*=============================================================================
Movement.cpp: Character movement implementation
=============================================================================*/
#include "VRCharacterMovementComponent.h"
#include "GameFramework/PhysicsVolume.h"
#include "GameFramework/GameNetworkManager.h"
#include "GameFramework/Character.h"
#include "GameFramework/GameState.h"
#include "Components/PrimitiveComponent.h"
#include "Animation/AnimMontage.h"
#include "DrawDebugHelpers.h"
//#include "PhysicsEngine/DestructibleActor.h"
#include "VRCharacter.h"
#include "VRExpansionFunctionLibrary.h"
// @todo this is here only due to circular dependency to AIModule. To be removed
#include "Navigation/PathFollowingComponent.h"
#include "AI/Navigation/AvoidanceManager.h"
#include "Components/CapsuleComponent.h"
#include "Components/BrushComponent.h"
//#include "Components/DestructibleComponent.h"
#include "Engine/DemoNetDriver.h"
#include "Engine/NetworkObjectList.h"
//#include "PerfCountersHelpers.h"
DEFINE_LOG_CATEGORY(LogVRCharacterMovement);
/**
* Character stats
*/
DECLARE_CYCLE_STAT(TEXT("Char StepUp"), STAT_CharStepUp, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char FindFloor"), STAT_CharFindFloor, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char ReplicateMoveToServer"), STAT_CharacterMovementReplicateMoveToServer, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char CallServerMove"), STAT_CharacterMovementCallServerMove, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char CombineNetMove"), STAT_CharacterMovementCombineNetMove, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char PhysWalking"), STAT_CharPhysWalking, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char PhysFalling"), STAT_CharPhysFalling, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char PhysNavWalking"), STAT_CharPhysNavWalking, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char NavProjectPoint"), STAT_CharNavProjectPoint, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char NavProjectLocation"), STAT_CharNavProjectLocation, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char AdjustFloorHeight"), STAT_CharAdjustFloorHeight, STATGROUP_Character);
DECLARE_CYCLE_STAT(TEXT("Char ProcessLanded"), STAT_CharProcessLanded, STATGROUP_Character);
// MAGIC NUMBERS
const float MAX_STEP_SIDE_Z = 0.08f; // maximum z value for the normal on the vertical side of steps
const float SWIMBOBSPEED = -80.f;
const float VERTICAL_SLOPE_NORMAL_Z = 0.001f; // Slope is vertical if Abs(Normal.Z) <= this threshold. Accounts for precision problems that sometimes angle normals slightly off horizontal for vertical surface.
// Defines for build configs
#if DO_CHECK && !UE_BUILD_SHIPPING // Disable even if checks in shipping are enabled.
#define devCode( Code ) checkCode( Code )
#else
#define devCode(...)
#endif
// Statics
namespace CharacterMovementComponentStatics
{
static const FName CrouchTraceName = FName(TEXT("CrouchTrace"));
static const FName ImmersionDepthName = FName(TEXT("MovementComp_Character_ImmersionDepth"));
static float fRotationCorrectionThreshold = 0.02f;
FAutoConsoleVariableRef CVarRotationCorrectionThreshold(
TEXT("vre.RotationCorrectionThreshold"),
fRotationCorrectionThreshold,
TEXT("Error threshold value before correcting a clients rotation.\n")
TEXT("Rotation is replicated at 2 decimal precision, so values less than 0.01 won't matter."),
ECVF_Default);
}
void UVRCharacterMovementComponent::Crouch(bool bClientSimulation)
{
if (!HasValidData())
{
return;
}
if (!bClientSimulation && !CanCrouchInCurrentState())
{
return;
}
// See if collision is already at desired size.
if (CharacterOwner->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight() == CrouchedHalfHeight)
{
if (!bClientSimulation)
{
CharacterOwner->bIsCrouched = true;
}
CharacterOwner->OnStartCrouch(0.f, 0.f);
return;
}
if (bClientSimulation && CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy)
{
// restore collision size before crouching
ACharacter* DefaultCharacter = CharacterOwner->GetClass()->GetDefaultObject<ACharacter>();
if (VRRootCapsule)
VRRootCapsule->SetCapsuleSizeVR(DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleRadius(), DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight());
else
CharacterOwner->GetCapsuleComponent()->SetCapsuleSize(DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleRadius(), DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight());
bShrinkProxyCapsule = true;
}
// Change collision size to crouching dimensions
const float ComponentScale = CharacterOwner->GetCapsuleComponent()->GetShapeScale();
const float OldUnscaledHalfHeight = CharacterOwner->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight();
const float OldUnscaledRadius = CharacterOwner->GetCapsuleComponent()->GetUnscaledCapsuleRadius();
// Height is not allowed to be smaller than radius.
const float ClampedCrouchedHalfHeight = FMath::Max3(0.f, OldUnscaledRadius, CrouchedHalfHeight);
if (VRRootCapsule)
VRRootCapsule->SetCapsuleSizeVR(OldUnscaledRadius, ClampedCrouchedHalfHeight);
else
CharacterOwner->GetCapsuleComponent()->SetCapsuleSize(OldUnscaledRadius, ClampedCrouchedHalfHeight);
float HalfHeightAdjust = (OldUnscaledHalfHeight - ClampedCrouchedHalfHeight);
float ScaledHalfHeightAdjust = HalfHeightAdjust * ComponentScale;
if (!bClientSimulation)
{
// Crouching to a larger height? (this is rare)
if (ClampedCrouchedHalfHeight > OldUnscaledHalfHeight)
{
FCollisionQueryParams CapsuleParams(CharacterMovementComponentStatics::CrouchTraceName, false, CharacterOwner);
FCollisionResponseParams ResponseParam;
InitCollisionParams(CapsuleParams, ResponseParam);
FVector capLocation;
if (VRRootCapsule)
{
capLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
}
else
capLocation = UpdatedComponent->GetComponentLocation();
const bool bEncroached = GetWorld()->OverlapBlockingTestByChannel(capLocation - FVector(0.f, 0.f, ScaledHalfHeightAdjust), FQuat::Identity,
UpdatedComponent->GetCollisionObjectType(), GetPawnCapsuleCollisionShape(SHRINK_None), CapsuleParams, ResponseParam);
// If encroached, cancel
if (bEncroached)
{
if (VRRootCapsule)
VRRootCapsule->SetCapsuleSizeVR(OldUnscaledRadius, OldUnscaledHalfHeight);
else
CharacterOwner->GetCapsuleComponent()->SetCapsuleSize(OldUnscaledRadius, OldUnscaledHalfHeight);
return;
}
}
// Skipping this move down as the VR character's base root doesn't behave the same
if (bCrouchMaintainsBaseLocation)
{
// Intentionally not using MoveUpdatedComponent, where a horizontal plane constraint would prevent the base of the capsule from staying at the same spot.
//UpdatedComponent->MoveComponent(FVector(0.f, 0.f, -ScaledHalfHeightAdjust), UpdatedComponent->GetComponentQuat(), true, nullptr, EMoveComponentFlags::MOVECOMP_NoFlags, ETeleportType::TeleportPhysics);
}
CharacterOwner->bIsCrouched = true;
}
bForceNextFloorCheck = true;
// OnStartCrouch takes the change from the Default size, not the current one (though they are usually the same).
const float MeshAdjust = ScaledHalfHeightAdjust;
ACharacter* DefaultCharacter = CharacterOwner->GetClass()->GetDefaultObject<ACharacter>();
HalfHeightAdjust = (DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight() - ClampedCrouchedHalfHeight);
ScaledHalfHeightAdjust = HalfHeightAdjust * ComponentScale;
AdjustProxyCapsuleSize();
CharacterOwner->OnStartCrouch(HalfHeightAdjust, ScaledHalfHeightAdjust);
// Don't smooth this change in mesh position
if ((bClientSimulation && CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy) || (IsNetMode(NM_ListenServer) && CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy))
{
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (ClientData)
{
ClientData->MeshTranslationOffset -= FVector(0.f, 0.f, MeshAdjust);
ClientData->OriginalMeshTranslationOffset = ClientData->MeshTranslationOffset;
}
}
}
void UVRCharacterMovementComponent::UnCrouch(bool bClientSimulation)
{
if (!HasValidData())
{
return;
}
ACharacter* DefaultCharacter = CharacterOwner->GetClass()->GetDefaultObject<ACharacter>();
// See if collision is already at desired size.
if (CharacterOwner->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight() == DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight())
{
if (!bClientSimulation)
{
CharacterOwner->bIsCrouched = false;
}
CharacterOwner->OnEndCrouch(0.f, 0.f);
return;
}
const float CurrentCrouchedHalfHeight = CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();
const float ComponentScale = CharacterOwner->GetCapsuleComponent()->GetShapeScale();
const float OldUnscaledHalfHeight = CharacterOwner->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight();
const float HalfHeightAdjust = DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight() - OldUnscaledHalfHeight;
const float ScaledHalfHeightAdjust = HalfHeightAdjust * ComponentScale;
/*const*/ FVector PawnLocation = UpdatedComponent->GetComponentLocation();
if (VRRootCapsule)
{
PawnLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
}
// Grow to uncrouched size.
check(CharacterOwner->GetCapsuleComponent());
if (!bClientSimulation)
{
// Try to stay in place and see if the larger capsule fits. We use a slightly taller capsule to avoid penetration.
const UWorld* MyWorld = GetWorld();
const float SweepInflation = KINDA_SMALL_NUMBER * 10.f;
FCollisionQueryParams CapsuleParams(CharacterMovementComponentStatics::CrouchTraceName, false, CharacterOwner);
FCollisionResponseParams ResponseParam;
InitCollisionParams(CapsuleParams, ResponseParam);
// Compensate for the difference between current capsule size and standing size
const FCollisionShape StandingCapsuleShape = GetPawnCapsuleCollisionShape(SHRINK_HeightCustom, -SweepInflation - ScaledHalfHeightAdjust); // Shrink by negative amount, so actually grow it.
const ECollisionChannel CollisionChannel = UpdatedComponent->GetCollisionObjectType();
bool bEncroached = true;
if (!bCrouchMaintainsBaseLocation)
{
// Expand in place
bEncroached = MyWorld->OverlapBlockingTestByChannel(PawnLocation, FQuat::Identity, CollisionChannel, StandingCapsuleShape, CapsuleParams, ResponseParam);
if (bEncroached)
{
// Try adjusting capsule position to see if we can avoid encroachment.
if (ScaledHalfHeightAdjust > 0.f)
{
// Shrink to a short capsule, sweep down to base to find where that would hit something, and then try to stand up from there.
float PawnRadius, PawnHalfHeight;
CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(PawnRadius, PawnHalfHeight);
const float ShrinkHalfHeight = PawnHalfHeight - PawnRadius;
const float TraceDist = PawnHalfHeight - ShrinkHalfHeight;
const FVector Down = FVector(0.f, 0.f, -TraceDist);
FHitResult Hit(1.f);
const FCollisionShape ShortCapsuleShape = GetPawnCapsuleCollisionShape(SHRINK_HeightCustom, ShrinkHalfHeight);
const bool bBlockingHit = MyWorld->SweepSingleByChannel(Hit, PawnLocation, PawnLocation + Down, FQuat::Identity, CollisionChannel, ShortCapsuleShape, CapsuleParams);
if (Hit.bStartPenetrating)
{
bEncroached = true;
}
else
{
// Compute where the base of the sweep ended up, and see if we can stand there
const float DistanceToBase = (Hit.Time * TraceDist) + ShortCapsuleShape.Capsule.HalfHeight;
const FVector NewLoc = FVector(PawnLocation.X, PawnLocation.Y, PawnLocation.Z - DistanceToBase + StandingCapsuleShape.Capsule.HalfHeight + SweepInflation + MIN_FLOOR_DIST / 2.f);
bEncroached = MyWorld->OverlapBlockingTestByChannel(NewLoc, FQuat::Identity, CollisionChannel, StandingCapsuleShape, CapsuleParams, ResponseParam);
if (!bEncroached)
{
// Intentionally not using MoveUpdatedComponent, where a horizontal plane constraint would prevent the base of the capsule from staying at the same spot.
UpdatedComponent->MoveComponent(NewLoc - PawnLocation, UpdatedComponent->GetComponentQuat(), false, nullptr, EMoveComponentFlags::MOVECOMP_NoFlags, ETeleportType::TeleportPhysics);
}
}
}
}
}
else
{
// Expand while keeping base location the same.
FVector StandingLocation = PawnLocation + FVector(0.f, 0.f, StandingCapsuleShape.GetCapsuleHalfHeight() - CurrentCrouchedHalfHeight);
bEncroached = MyWorld->OverlapBlockingTestByChannel(StandingLocation, FQuat::Identity, CollisionChannel, StandingCapsuleShape, CapsuleParams, ResponseParam);
if (bEncroached)
{
if (IsMovingOnGround())
{
// Something might be just barely overhead, try moving down closer to the floor to avoid it.
const float MinFloorDist = KINDA_SMALL_NUMBER * 10.f;
if (CurrentFloor.bBlockingHit && CurrentFloor.FloorDist > MinFloorDist)
{
StandingLocation.Z -= CurrentFloor.FloorDist - MinFloorDist;
bEncroached = MyWorld->OverlapBlockingTestByChannel(StandingLocation, FQuat::Identity, CollisionChannel, StandingCapsuleShape, CapsuleParams, ResponseParam);
}
}
}
// Canceling this move because our VR capsule isn't actor based like it expects it to be
if (!bEncroached)
{
// Commit the change in location.
//UpdatedComponent->MoveComponent(StandingLocation - PawnLocation, UpdatedComponent->GetComponentQuat(), false, nullptr, EMoveComponentFlags::MOVECOMP_NoFlags, ETeleportType::TeleportPhysics);
bForceNextFloorCheck = true;
}
}
// If still encroached then abort.
if (bEncroached)
{
return;
}
CharacterOwner->bIsCrouched = false;
}
else
{
bShrinkProxyCapsule = true;
}
// Now call SetCapsuleSize() to cause touch/untouch events and actually grow the capsule
if (VRRootCapsule)
VRRootCapsule->SetCapsuleSizeVR(DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleRadius(), DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight(), true);
else
CharacterOwner->GetCapsuleComponent()->SetCapsuleSize(DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleRadius(), DefaultCharacter->GetCapsuleComponent()->GetUnscaledCapsuleHalfHeight(), true);
const float MeshAdjust = ScaledHalfHeightAdjust;
AdjustProxyCapsuleSize();
CharacterOwner->OnEndCrouch(HalfHeightAdjust, ScaledHalfHeightAdjust);
// Don't smooth this change in mesh position
if ((bClientSimulation && CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy) || (IsNetMode(NM_ListenServer) && CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy))
{
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (ClientData)
{
ClientData->MeshTranslationOffset += FVector(0.f, 0.f, MeshAdjust);
ClientData->OriginalMeshTranslationOffset = ClientData->MeshTranslationOffset;
}
}
}
FNetworkPredictionData_Client* UVRCharacterMovementComponent::GetPredictionData_Client() const
{
// Should only be called on client or listen server (for remote clients) in network games
check(CharacterOwner != NULL);
checkSlow(CharacterOwner->GetLocalRole() < ROLE_Authority || (CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy && GetNetMode() == NM_ListenServer));
checkSlow(GetNetMode() == NM_Client || GetNetMode() == NM_ListenServer);
if (!ClientPredictionData)
{
UVRCharacterMovementComponent* MutableThis = const_cast<UVRCharacterMovementComponent*>(this);
MutableThis->ClientPredictionData = new FNetworkPredictionData_Client_VRCharacter(*this);
}
return ClientPredictionData;
}
FNetworkPredictionData_Server* UVRCharacterMovementComponent::GetPredictionData_Server() const
{
// Should only be called on server in network games
check(CharacterOwner != NULL);
check(CharacterOwner->GetLocalRole() == ROLE_Authority);
checkSlow(GetNetMode() < NM_Client);
if (!ServerPredictionData)
{
UVRCharacterMovementComponent* MutableThis = const_cast<UVRCharacterMovementComponent*>(this);
MutableThis->ServerPredictionData = new FNetworkPredictionData_Server_VRCharacter(*this);
}
return ServerPredictionData;
}
void FSavedMove_VRCharacter::SetInitialPosition(ACharacter* C)
{
// See if we can get the VR capsule location
if (AVRCharacter * VRC = Cast<AVRCharacter>(C))
{
UVRCharacterMovementComponent * CharMove = Cast<UVRCharacterMovementComponent>(VRC->GetCharacterMovement());
if (VRC->VRRootReference)
{
VRCapsuleLocation = VRC->VRRootReference->curCameraLoc;
VRCapsuleRotation = UVRExpansionFunctionLibrary::GetHMDPureYaw_I(VRC->VRRootReference->curCameraRot);
LFDiff = VRC->VRRootReference->DifferenceFromLastFrame;
}
else
{
VRCapsuleLocation = FVector::ZeroVector;
VRCapsuleRotation = FRotator::ZeroRotator;
LFDiff = FVector::ZeroVector;
}
}
FSavedMove_VRBaseCharacter::SetInitialPosition(C);
}
void FSavedMove_VRCharacter::PrepMoveFor(ACharacter* Character)
{
UVRCharacterMovementComponent * CharMove = Cast<UVRCharacterMovementComponent>(Character->GetCharacterMovement());
// Set capsule location prior to testing movement
// I am overriding the replicated value here when movement is made on purpose
if (CharMove && CharMove->VRRootCapsule)
{
CharMove->VRRootCapsule->curCameraLoc = this->VRCapsuleLocation;
CharMove->VRRootCapsule->curCameraRot = this->VRCapsuleRotation;//FRotator(0.0f, FRotator::DecompressAxisFromByte(CapsuleYaw), 0.0f);
CharMove->VRRootCapsule->DifferenceFromLastFrame = FVector(LFDiff.X, LFDiff.Y, 0.0f);
CharMove->AdditionalVRInputVector = CharMove->VRRootCapsule->DifferenceFromLastFrame;
if (AVRBaseCharacter * BaseChar = Cast<AVRBaseCharacter>(CharMove->GetCharacterOwner()))
{
if (BaseChar->VRReplicateCapsuleHeight && this->LFDiff.Z > 0.0f && !FMath::IsNearlyEqual(this->LFDiff.Z, CharMove->VRRootCapsule->GetUnscaledCapsuleHalfHeight()))
{
BaseChar->SetCharacterHalfHeightVR(LFDiff.Z, false);
//CharMove->VRRootCapsule->SetCapsuleHalfHeight(this->LFDiff.Z, false);
}
}
CharMove->VRRootCapsule->GenerateOffsetToWorld(false, false);
}
FSavedMove_VRBaseCharacter::PrepMoveFor(Character);
}
bool UVRCharacterMovementComponent::ServerMoveVROld_Validate(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags, FVRConditionalMoveRep ConditionalReps)
{
return true;
}
bool UVRCharacterMovementComponent::ServerMoveVR_Validate(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 MoveFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
return true;
}
bool UVRCharacterMovementComponent::ServerMoveVRExLight_Validate(float TimeStamp, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 MoveFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
return true;
}
bool UVRCharacterMovementComponent::ServerMoveVRDual_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, FVector_NetQuantize100 OldCapsuleLoc, FVRConditionalMoveRep OldConditionalReps, FVector_NetQuantize100 OldLFDiff, uint16 OldCapsuleYaw, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 NewFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
return true;
}
bool UVRCharacterMovementComponent::ServerMoveVRDualExLight_Validate(float TimeStamp0, uint8 PendingFlags, uint32 View0, FVector_NetQuantize100 OldCapsuleLoc, FVRConditionalMoveRep OldConditionalReps, FVector_NetQuantize100 OldLFDiff, uint16 OldCapsuleYaw, float TimeStamp, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 NewFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
return true;
}
bool UVRCharacterMovementComponent::ServerMoveVRDualHybridRootMotion_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, FVector_NetQuantize100 OldCapsuleLoc, FVRConditionalMoveRep OldConditionalReps, FVector_NetQuantize100 OldLFDiff, uint16 OldCapsuleYaw, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 NewFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
return true;
}
void UVRCharacterMovementComponent::ServerMoveVRDualHybridRootMotion_Implementation(
float TimeStamp0,
FVector_NetQuantize10 InAccel0,
uint8 PendingFlags,
uint32 View0,
FVector_NetQuantize100 OldCapsuleLoc,
FVRConditionalMoveRep OldConditionalReps,
FVector_NetQuantize100 OldLFDiff,
uint16 OldCapsuleYaw,
float TimeStamp,
FVector_NetQuantize10 InAccel,
FVector_NetQuantize100 ClientLoc,
FVector_NetQuantize100 CapsuleLoc,
FVRConditionalMoveRep ConditionalReps,
FVector_NetQuantize100 LFDiff,
uint16 CapsuleYaw,
uint8 NewFlags,
FVRConditionalMoveRep2 MoveReps,
uint8 ClientMovementMode)
{
// Keep new moves base and bone, but use the View of the old move
FVRConditionalMoveRep2 MoveRepsOld;
MoveRepsOld.ClientBaseBoneName = MoveReps.ClientBaseBoneName;
MoveRepsOld.ClientMovementBase = MoveReps.ClientMovementBase;
MoveRepsOld.UnpackAndSetINTRotations(View0);
// Scope these, they nest with Outer references so it should work fine, this keeps the update rotation and move autonomous from double updating the char
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableServerDualMoveScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
// First move received didn't use root motion, process it as such.
CharacterOwner->bServerMoveIgnoreRootMotion = CharacterOwner->IsPlayingNetworkedRootMotionMontage();
ServerMoveVR_Implementation(TimeStamp0, InAccel0, FVector(1.f, 2.f, 3.f), OldCapsuleLoc, OldConditionalReps, OldLFDiff, OldCapsuleYaw, PendingFlags, MoveRepsOld, ClientMovementMode);
CharacterOwner->bServerMoveIgnoreRootMotion = false;
ServerMoveVR_Implementation(TimeStamp, InAccel, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, NewFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRDual_Implementation(
float TimeStamp0,
FVector_NetQuantize10 InAccel0,
uint8 PendingFlags,
uint32 View0,
FVector_NetQuantize100 OldCapsuleLoc,
FVRConditionalMoveRep OldConditionalReps,
FVector_NetQuantize100 OldLFDiff,
uint16 OldCapsuleYaw,
float TimeStamp,
FVector_NetQuantize10 InAccel,
FVector_NetQuantize100 ClientLoc,
FVector_NetQuantize100 CapsuleLoc,
FVRConditionalMoveRep ConditionalReps,
FVector_NetQuantize100 LFDiff,
uint16 CapsuleYaw,
uint8 NewFlags,
FVRConditionalMoveRep2 MoveReps,
uint8 ClientMovementMode)
{
// Keep new moves base and bone, but use the View of the old move
FVRConditionalMoveRep2 MoveRepsOld;
MoveRepsOld.ClientBaseBoneName = MoveReps.ClientBaseBoneName;
MoveRepsOld.ClientMovementBase = MoveReps.ClientMovementBase;
MoveRepsOld.UnpackAndSetINTRotations(View0);
// Scope these, they nest with Outer references so it should work fine, this keeps the update rotation and move autonomous from double updating the char
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableServerDualMoveScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
ServerMoveVR_Implementation(TimeStamp0, InAccel0, FVector(1.f, 2.f, 3.f), OldCapsuleLoc, OldConditionalReps, OldLFDiff, OldCapsuleYaw, PendingFlags, MoveRepsOld, ClientMovementMode);
ServerMoveVR_Implementation(TimeStamp, InAccel, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, NewFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRDualExLight_Implementation(
float TimeStamp0,
uint8 PendingFlags,
uint32 View0,
FVector_NetQuantize100 OldCapsuleLoc,
FVRConditionalMoveRep OldConditionalReps,
FVector_NetQuantize100 OldLFDiff,
uint16 OldCapsuleYaw,
float TimeStamp,
FVector_NetQuantize100 ClientLoc,
FVector_NetQuantize100 CapsuleLoc,
FVRConditionalMoveRep ConditionalReps,
FVector_NetQuantize100 LFDiff,
uint16 CapsuleYaw,
uint8 NewFlags,
FVRConditionalMoveRep2 MoveReps,
uint8 ClientMovementMode)
{
// Keep new moves base and bone, but use the View of the old move
FVRConditionalMoveRep2 MoveRepsOld;
MoveRepsOld.ClientBaseBoneName = MoveReps.ClientBaseBoneName;
MoveRepsOld.ClientMovementBase = MoveReps.ClientMovementBase;
MoveRepsOld.UnpackAndSetINTRotations(View0);
// Scope these, they nest with Outer references so it should work fine, this keeps the update rotation and move autonomous from double updating the char
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableServerDualMoveScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
ServerMoveVR_Implementation(TimeStamp0, FVector::ZeroVector, FVector(1.f, 2.f, 3.f), OldCapsuleLoc, OldConditionalReps, OldLFDiff, OldCapsuleYaw, PendingFlags, MoveRepsOld, ClientMovementMode);
ServerMoveVR_Implementation(TimeStamp, FVector::ZeroVector, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, NewFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRExLight_Implementation(
float TimeStamp,
FVector_NetQuantize100 ClientLoc,
FVector_NetQuantize100 CapsuleLoc,
FVRConditionalMoveRep ConditionalReps,
FVector_NetQuantize100 LFDiff,
uint16 CapsuleYaw,
uint8 MoveFlags,
FVRConditionalMoveRep2 MoveReps,
uint8 ClientMovementMode)
{
ServerMoveVR_Implementation(TimeStamp, FVector::ZeroVector, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, MoveFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVROld_Implementation
(
float OldTimeStamp,
FVector_NetQuantize10 OldAccel,
uint8 OldMoveFlags,
FVRConditionalMoveRep ConditionalReps
)
{
if (!HasValidData() || !IsActive())
{
return;
}
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
check(ServerData);
bool bAutoAcceptPacket = false;
if (MovementMode == MOVE_Custom && CustomMovementMode == (uint8)EVRCustomMovementMode::VRMOVE_Seated)
{
return;
}
else if (bJustUnseated)
{
ServerData->CurrentClientTimeStamp = OldTimeStamp;
bAutoAcceptPacket = true;
bJustUnseated = false;
}
if (!bAutoAcceptPacket && !VerifyClientTimeStamp(OldTimeStamp, *ServerData))
{
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("ServerMoveOld: TimeStamp expired. %f, CurrentTimeStamp: %f, Character: %s"), OldTimeStamp, ServerData->CurrentClientTimeStamp, *GetNameSafe(CharacterOwner));
return;
}
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Recovered move from OldTimeStamp %f, DeltaTime: %f"), OldTimeStamp, OldTimeStamp - ServerData->CurrentClientTimeStamp);
if (!ConditionalReps.RequestedVelocity.IsZero())
{
RequestedVelocity = ConditionalReps.RequestedVelocity;
bHasRequestedVelocity = true;
}
CustomVRInputVector = ConditionalReps.CustomVRInputVector;
MoveActionArray = ConditionalReps.MoveActionArray;
// Set capsule location prior to testing movement
// I am overriding the replicated value here when movement is made on purpose
/*if (VRRootCapsule)
{
VRRootCapsule->curCameraLoc = CapsuleLoc;
VRRootCapsule->curCameraRot = FRotator(0.0f, FRotator::DecompressAxisFromShort(CapsuleYaw), 0.0f);
VRRootCapsule->DifferenceFromLastFrame = FVector(LFDiff.X, LFDiff.Y, 0.0f);
AdditionalVRInputVector = VRRootCapsule->DifferenceFromLastFrame;
if (AVRBaseCharacter * BaseChar = Cast<AVRBaseCharacter>(CharacterOwner))
{
if (BaseChar->VRReplicateCapsuleHeight && LFDiff.Z > 0.0f && !FMath::IsNearlyEqual(LFDiff.Z, VRRootCapsule->GetUnscaledCapsuleHalfHeight()))
{
BaseChar->SetCharacterHalfHeightVR(LFDiff.Z, false);
}
}
VRRootCapsule->GenerateOffsetToWorld(false, false);
}*/
UE_LOG(LogVRCharacterMovement, Log, TEXT("Recovered move from OldTimeStamp %f, DeltaTime: %f"), OldTimeStamp, OldTimeStamp - ServerData->CurrentClientTimeStamp);
const UWorld* MyWorld = GetWorld();
const float DeltaTime = ServerData->GetServerMoveDeltaTime(OldTimeStamp, CharacterOwner->GetActorTimeDilation(*MyWorld));
if (DeltaTime > 0.f)
{
ServerData->CurrentClientTimeStamp = OldTimeStamp;
ServerData->ServerAccumulatedClientTimeStamp += DeltaTime;
ServerData->ServerTimeStamp = MyWorld->GetTimeSeconds();
ServerData->ServerTimeStampLastServerMove = ServerData->ServerTimeStamp;
MoveAutonomous(OldTimeStamp, DeltaTime, OldMoveFlags, OldAccel);
}
else
{
UE_LOG(LogVRCharacterMovement, Warning, TEXT("OldTimeStamp(%f) results in zero or negative actual DeltaTime(%f). Theoretical DeltaTime(%f)"),
OldTimeStamp, DeltaTime, OldTimeStamp - ServerData->CurrentClientTimeStamp);
}
}
void UVRCharacterMovementComponent::ServerMoveVR_Implementation(
float TimeStamp,
FVector_NetQuantize10 InAccel,
FVector_NetQuantize100 ClientLoc,
FVector_NetQuantize100 CapsuleLoc,
FVRConditionalMoveRep ConditionalReps,
FVector_NetQuantize100 LFDiff,
uint16 CapsuleYaw,
uint8 MoveFlags,
FVRConditionalMoveRep2 MoveReps,
uint8 ClientMovementMode)
{
if (!HasValidData() || !IsComponentTickEnabled())
{
return;
}
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
check(ServerData);
bool bAutoAcceptPacket = false;
if (MovementMode == MOVE_Custom && CustomMovementMode == (uint8)EVRCustomMovementMode::VRMOVE_Seated)
{
return;
}
else if (bJustUnseated)
{
ServerData->CurrentClientTimeStamp = TimeStamp;
bAutoAcceptPacket = true;
bJustUnseated = false;
}
if (!bAutoAcceptPacket && !VerifyClientTimeStamp(TimeStamp, *ServerData))
{
const float ServerTimeStamp = ServerData->CurrentClientTimeStamp;
// This is more severe if the timestamp has a large discrepancy and hasn't been recently reset.
static const auto CVarNetServerMoveTimestampExpiredWarningThreshold = IConsoleManager::Get().FindConsoleVariable(TEXT("net.NetServerMoveTimestampExpiredWarningThreshold"));
if (ServerTimeStamp > 1.0f && FMath::Abs(ServerTimeStamp - TimeStamp) > CVarNetServerMoveTimestampExpiredWarningThreshold->GetFloat())
{
UE_LOG(LogVRCharacterMovement, Warning, TEXT("ServerMove: TimeStamp expired: %f, CurrentTimeStamp: %f, Character: %s"), TimeStamp, ServerTimeStamp, *GetNameSafe(CharacterOwner));
}
else
{
UE_LOG(LogVRCharacterMovement, Log, TEXT("ServerMove: TimeStamp expired: %f, CurrentTimeStamp: %f, Character: %s"), TimeStamp, ServerTimeStamp, *GetNameSafe(CharacterOwner));
}
return;
}
// Scope these, they nest with Outer references so it should work fine, this keeps the update rotation and move autonomous from double updating the char
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
bool bServerReadyForClient = true;
APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
if (PC)
{
bServerReadyForClient = PC->NotifyServerReceivedClientData(CharacterOwner, TimeStamp);
if (!bServerReadyForClient)
{
InAccel = FVector::ZeroVector;
}
}
// View components
//const uint16 ViewPitch = (View & 65535);
//const uint16 ViewYaw = ClientYaw;//(View >> 16);
const FVector Accel = InAccel;
const UWorld* MyWorld = GetWorld();
// Save move parameters.
const float DeltaTime = ServerData->GetServerMoveDeltaTime(TimeStamp, CharacterOwner->GetActorTimeDilation(*MyWorld));
ServerData->CurrentClientTimeStamp = TimeStamp;
ServerData->ServerTimeStamp = MyWorld->GetTimeSeconds();
ServerData->ServerTimeStampLastServerMove = ServerData->ServerTimeStamp;
FRotator ViewRot;
ViewRot.Pitch = FRotator::DecompressAxisFromShort(MoveReps.ClientPitch);
ViewRot.Yaw = FRotator::DecompressAxisFromShort(MoveReps.ClientYaw);
ViewRot.Roll = FRotator::DecompressAxisFromByte(MoveReps.ClientRoll);
if (PC && bUseClientControlRotation)
{
PC->SetControlRotation(ViewRot);
}
if (!bServerReadyForClient)
{
return;
}
// Perform actual movement
if ((MyWorld->GetWorldSettings()->GetPauserPlayerState() == NULL) && (DeltaTime > 0.f))
{
if (PC)
{
PC->UpdateRotation(DeltaTime);
}
if (!ConditionalReps.RequestedVelocity.IsZero())
{
RequestedVelocity = ConditionalReps.RequestedVelocity;
bHasRequestedVelocity = true;
}
CustomVRInputVector = ConditionalReps.CustomVRInputVector;
MoveActionArray = ConditionalReps.MoveActionArray;
// Set capsule location prior to testing movement
// I am overriding the replicated value here when movement is made on purpose
if (VRRootCapsule)
{
VRRootCapsule->curCameraLoc = CapsuleLoc;
VRRootCapsule->curCameraRot = FRotator(0.0f, FRotator::DecompressAxisFromShort(CapsuleYaw), 0.0f);
VRRootCapsule->DifferenceFromLastFrame = FVector(LFDiff.X, LFDiff.Y, 0.0f);
AdditionalVRInputVector = VRRootCapsule->DifferenceFromLastFrame;
if (BaseVRCharacterOwner)
{
if (BaseVRCharacterOwner->VRReplicateCapsuleHeight && LFDiff.Z > 0.0f && !FMath::IsNearlyEqual(LFDiff.Z, VRRootCapsule->GetUnscaledCapsuleHalfHeight()))
{
BaseVRCharacterOwner->SetCharacterHalfHeightVR(LFDiff.Z, false);
// BaseChar->ReplicatedCapsuleHeight.CapsuleHeight = LFDiff.Z;
//VRRootCapsule->SetCapsuleHalfHeight(LFDiff.Z, false);
}
}
VRRootCapsule->GenerateOffsetToWorld(false, false);
// #TODO: Should I actually implement the mesh translation from "Crouch"? Generally people are going to be
// IKing any mesh from the HMD instead.
/*
// Don't smooth this change in mesh position
if (bClientSimulation && CharacterOwner->Role == ROLE_SimulatedProxy)
{
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (ClientData && ClientData->MeshTranslationOffset.Z != 0.f)
{
ClientData->MeshTranslationOffset += FVector(0.f, 0.f, MeshAdjust);
ClientData->OriginalMeshTranslationOffset = ClientData->MeshTranslationOffset;
}
}
*/
}
MoveAutonomous(TimeStamp, DeltaTime, MoveFlags, Accel);
bHasRequestedVelocity = false;
}
UE_CLOG(CharacterOwner&& UpdatedComponent, LogVRCharacterMovement, VeryVerbose, TEXT("ServerMove Time %f Acceleration %s Velocity %s Position %s Rotation %s DeltaTime %f Mode %s MovementBase %s.%s (Dynamic:%d)"),
TimeStamp, *Accel.ToString(), *Velocity.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *UpdatedComponent->GetComponentRotation().ToCompactString(), DeltaTime, *GetMovementName(),
*GetNameSafe(GetMovementBase()), *CharacterOwner->GetBasedMovement().BoneName.ToString(), MovementBaseUtility::IsDynamicBase(GetMovementBase()) ? 1 : 0);
// #TODO: Handle this better at some point? Client also denies it later on during correction (ApplyNetworkMovementMode in base movement)
// Pre handling the errors, lets avoid rolling back to/from custom movement modes, they tend to be scripted and this can screw things up
const uint8 CurrentPackedMovementMode = PackNetworkMovementMode();
if (CurrentPackedMovementMode != ClientMovementMode)
{
TEnumAsByte<EMovementMode> NetMovementMode(MOVE_None);
TEnumAsByte<EMovementMode> NetGroundMode(MOVE_None);
uint8 NetCustomMode(0);
UnpackNetworkMovementMode(ClientMovementMode, NetMovementMode, NetCustomMode, NetGroundMode);
// Custom movement modes aren't going to be rolled back as they are client authed for our pawns
if (NetMovementMode == EMovementMode::MOVE_Custom || MovementMode == EMovementMode::MOVE_Custom)
{
if(NetCustomMode == (uint8)EVRCustomMovementMode::VRMOVE_Climbing || CustomMovementMode == (uint8)EVRCustomMovementMode::VRMOVE_Climbing)
SetMovementMode(NetMovementMode, NetCustomMode);
}
}
ServerMoveHandleClientErrorVR(TimeStamp, DeltaTime, Accel, ClientLoc, ViewRot.Yaw, MoveReps.ClientMovementBase, MoveReps.ClientBaseBoneName, ClientMovementMode);
}
void UVRCharacterMovementComponent::CallServerMove
(
const class FSavedMove_Character* NewCMove,
const class FSavedMove_Character* OldCMove
)
{
// This is technically "safe", I know for sure that I am using my own FSavedMove
// I would have like to not override any of this, but I need a lot more specific information about the pawn
// So just setting flags in the FSaved Move doesn't cut it
// I could see a problem if someone overrides this override though
const FSavedMove_VRCharacter * NewMove = (const FSavedMove_VRCharacter *)NewCMove;
const FSavedMove_VRCharacter * OldMove = (const FSavedMove_VRCharacter *)OldCMove;
check(NewMove != nullptr);
//uint32 ClientYawPitchINT = 0;
//uint8 ClientRollBYTE = 0;
//NewMove->GetPackedAngles(ClientYawPitchINT, ClientRollBYTE);
const uint16 CapsuleYawShort = FRotator::CompressAxisToShort(NewMove->VRCapsuleRotation.Yaw);
const uint16 ClientYawShort = FRotator::CompressAxisToShort(NewMove->SavedControlRotation.Yaw);
// Determine if we send absolute or relative location
UPrimitiveComponent* ClientMovementBase = NewMove->EndBase.Get();
const FName ClientBaseBone = NewMove->EndBoneName;
const FVector SendLocation = MovementBaseUtility::UseRelativeLocation(ClientMovementBase) ? NewMove->SavedRelativeLocation : NewMove->SavedLocation;
// send old move if it exists
if (OldMove)
{
//const uint16 CapsuleYawShort = FRotator::CompressAxisToShort(OldMove->VRCapsuleRotation.Yaw);
ServerMoveVROld(OldMove->TimeStamp, OldMove->Acceleration, OldMove->GetCompressedFlags(), OldMove->ConditionalValues);
}
// Pass these in here, don't pass in to old move, it will receive the new move values in dual operations
// Will automatically not replicate them if movement base is nullptr (1 bit cost to check this)
FVRConditionalMoveRep2 NewMoveConds;
NewMoveConds.ClientMovementBase = ClientMovementBase;
NewMoveConds.ClientBaseBoneName = ClientBaseBone;
if (CharacterOwner && (CharacterOwner->bUseControllerRotationRoll || CharacterOwner->bUseControllerRotationPitch))
{
NewMoveConds.ClientPitch = FRotator::CompressAxisToShort(NewMove->SavedControlRotation.Pitch);
NewMoveConds.ClientRoll = FRotator::CompressAxisToByte(NewMove->SavedControlRotation.Roll);
}
NewMoveConds.ClientYaw = FRotator::CompressAxisToShort(NewMove->SavedControlRotation.Yaw);
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (const FSavedMove_Character* const PendingMove = ClientData->PendingMove.Get())
{
// This should send same as the uint16 because it uses a packedINT send by default for shorts
//uint32 OldClientYawPitchINT = 0;
//uint8 OldClientRollBYTE = 0;
//ClientData->PendingMove->GetPackedAngles(OldClientYawPitchINT, OldClientRollBYTE);
uint32 cPitch = 0;
if (CharacterOwner && (CharacterOwner->bUseControllerRotationPitch))
cPitch = FRotator::CompressAxisToShort(ClientData->PendingMove->SavedControlRotation.Pitch);
uint32 cYaw = FRotator::CompressAxisToShort(ClientData->PendingMove->SavedControlRotation.Yaw);
// Switch the order of pitch and yaw to place Yaw in smallest value, this will cut down on rep cost since normally pitch is zero'd out in VR
uint32 OldClientYawPitchINT = (cPitch << 16) | (cYaw);
FSavedMove_VRCharacter* oldMove = (FSavedMove_VRCharacter*)ClientData->PendingMove.Get();
const uint16 OldCapsuleYawShort = FRotator::CompressAxisToShort(oldMove->VRCapsuleRotation.Yaw);
//const uint16 OldClientYawShort = FRotator::CompressAxisToShort(ClientData->PendingMove->SavedControlRotation.Yaw);
// If we delayed a move without root motion, and our new move has root motion, send these through a special function, so the server knows how to process them.
if ((PendingMove->RootMotionMontage == NULL) && (NewMove->RootMotionMontage != NULL))
{
// send two moves simultaneously
ServerMoveVRDualHybridRootMotion
(
PendingMove->TimeStamp,
PendingMove->Acceleration,
PendingMove->GetCompressedFlags(),
OldClientYawPitchINT,
oldMove->VRCapsuleLocation,
oldMove->ConditionalValues,
oldMove->LFDiff,
OldCapsuleYawShort,
NewMove->TimeStamp,
NewMove->Acceleration,
SendLocation,
NewMove->VRCapsuleLocation,
NewMove->ConditionalValues,
NewMove->LFDiff,
CapsuleYawShort,
NewMove->GetCompressedFlags(),
NewMoveConds,
NewMove->EndPackedMovementMode
);
}
else // Not Hybrid root motion rpc
{
// send two moves simultaneously
if (oldMove->Acceleration.IsZero() && NewMove->Acceleration.IsZero())
{
ServerMoveVRDualExLight
(
PendingMove->TimeStamp,
PendingMove->GetCompressedFlags(),
OldClientYawPitchINT,
oldMove->VRCapsuleLocation,
oldMove->ConditionalValues,
oldMove->LFDiff,
OldCapsuleYawShort,
NewMove->TimeStamp,
SendLocation,
NewMove->VRCapsuleLocation,
NewMove->ConditionalValues,
NewMove->LFDiff,
CapsuleYawShort,
NewMove->GetCompressedFlags(),
NewMoveConds,
NewMove->EndPackedMovementMode
);
}
else
{
ServerMoveVRDual
(
PendingMove->TimeStamp,
PendingMove->Acceleration,
PendingMove->GetCompressedFlags(),
OldClientYawPitchINT,
oldMove->VRCapsuleLocation,
oldMove->ConditionalValues,
oldMove->LFDiff,
OldCapsuleYawShort,
NewMove->TimeStamp,
NewMove->Acceleration,
SendLocation,
NewMove->VRCapsuleLocation,
NewMove->ConditionalValues,
NewMove->LFDiff,
CapsuleYawShort,
NewMove->GetCompressedFlags(),
NewMoveConds,
NewMove->EndPackedMovementMode
);
}
}
}
else
{
if (NewMove->Acceleration.IsZero())
{
ServerMoveVRExLight
(
NewMove->TimeStamp,
SendLocation,
NewMove->VRCapsuleLocation,
NewMove->ConditionalValues,
NewMove->LFDiff,
CapsuleYawShort,
NewMove->GetCompressedFlags(),
NewMoveConds,
NewMove->EndPackedMovementMode
);
}
else
{
ServerMoveVR
(
NewMove->TimeStamp,
NewMove->Acceleration,
SendLocation,
NewMove->VRCapsuleLocation,
NewMove->ConditionalValues,
NewMove->LFDiff,
CapsuleYawShort,
NewMove->GetCompressedFlags(),
NewMoveConds,
NewMove->EndPackedMovementMode
);
}
}
MarkForClientCameraUpdate();
}
void UVRCharacterMovementComponent::ServerMoveVROld(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags, FVRConditionalMoveRep ConditionalReps)
{
((AVRCharacter*)CharacterOwner)->ServerMoveVROld(OldTimeStamp, OldAccel, OldMoveFlags,ConditionalReps);
}
void UVRCharacterMovementComponent::ServerMoveVR(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 CompressedMoveFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
((AVRCharacter*)CharacterOwner)->ServerMoveVR(TimeStamp, InAccel, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, CompressedMoveFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRExLight(float TimeStamp, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 CompressedMoveFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
((AVRCharacter*)CharacterOwner)->ServerMoveVRExLight(TimeStamp, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, CompressedMoveFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRDual(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, FVector_NetQuantize100 OldCapsuleLoc, FVRConditionalMoveRep OldConditionalReps, FVector_NetQuantize100 OldLFDiff, uint16 OldCapsuleYaw, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 NewFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
((AVRCharacter*)CharacterOwner)->ServerMoveVRDual(TimeStamp0, InAccel0, PendingFlags, View0, OldCapsuleLoc, OldConditionalReps, OldLFDiff, OldCapsuleYaw, TimeStamp, InAccel, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, NewFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRDualExLight(float TimeStamp0, uint8 PendingFlags, uint32 View0, FVector_NetQuantize100 OldCapsuleLoc, FVRConditionalMoveRep OldConditionalReps, FVector_NetQuantize100 OldLFDiff, uint16 OldCapsuleYaw, float TimeStamp, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 NewFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
((AVRCharacter*)CharacterOwner)->ServerMoveVRDualExLight(TimeStamp0, PendingFlags, View0, OldCapsuleLoc, OldConditionalReps, OldLFDiff, OldCapsuleYaw, TimeStamp, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, NewFlags, MoveReps, ClientMovementMode);
}
void UVRCharacterMovementComponent::ServerMoveVRDualHybridRootMotion(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, FVector_NetQuantize100 OldCapsuleLoc, FVRConditionalMoveRep OldConditionalReps, FVector_NetQuantize100 OldLFDiff, uint16 OldCapsuleYaw, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, FVector_NetQuantize100 CapsuleLoc, FVRConditionalMoveRep ConditionalReps, FVector_NetQuantize100 LFDiff, uint16 CapsuleYaw, uint8 NewFlags, FVRConditionalMoveRep2 MoveReps, uint8 ClientMovementMode)
{
((AVRCharacter*)CharacterOwner)->ServerMoveVRDualHybridRootMotion(TimeStamp0, InAccel0, PendingFlags, View0, OldCapsuleLoc, OldConditionalReps, OldLFDiff, OldCapsuleYaw, TimeStamp, InAccel, ClientLoc, CapsuleLoc, ConditionalReps, LFDiff, CapsuleYaw, NewFlags, MoveReps, ClientMovementMode);
}
bool UVRCharacterMovementComponent::ShouldCheckForValidLandingSpot(float DeltaTime, const FVector& Delta, const FHitResult& Hit) const
{
// See if we hit an edge of a surface on the lower portion of the capsule.
// In this case the normal will not equal the impact normal, and a downward sweep may find a walkable surface on top of the edge.
if (Hit.Normal.Z > KINDA_SMALL_NUMBER && !Hit.Normal.Equals(Hit.ImpactNormal))
{
FVector PawnLocation = UpdatedComponent->GetComponentLocation();
if (VRRootCapsule)
PawnLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
if (IsWithinEdgeTolerance(PawnLocation, Hit.ImpactPoint, CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleRadius()))
{
return true;
}
}
return false;
}
void UVRCharacterMovementComponent::PhysWalking(float deltaTime, int32 Iterations)
{
SCOPE_CYCLE_COUNTER(STAT_CharPhysWalking);
if (deltaTime < MIN_TICK_TIME)
{
return;
}
if (!CharacterOwner || (!CharacterOwner->Controller && !bRunPhysicsWithNoController && !HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && (CharacterOwner->GetLocalRole() != ROLE_SimulatedProxy)))
{
Acceleration = FVector::ZeroVector;
Velocity = FVector::ZeroVector;
return;
}
if (!UpdatedComponent->IsQueryCollisionEnabled())
{
SetMovementMode(MOVE_Walking);
return;
}
devCode(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysWalking: Velocity contains NaN before Iteration (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
bJustTeleported = false;
bool bCheckedFall = false;
bool bTriedLedgeMove = false;
float remainingTime = deltaTime;
// Rewind the players position by the new capsule location
RewindVRRelativeMovement();
// Perform the move
while ((remainingTime >= MIN_TICK_TIME) && (Iterations < MaxSimulationIterations) && CharacterOwner && (CharacterOwner->Controller || bRunPhysicsWithNoController || HasAnimRootMotion() || CurrentRootMotion.HasOverrideVelocity() || (CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy)))
{
Iterations++;
bJustTeleported = false;
const float timeTick = GetSimulationTimeStep(remainingTime, Iterations);
remainingTime -= timeTick;
// Save current values
UPrimitiveComponent * const OldBase = GetMovementBase();
const FVector PreviousBaseLocation = (OldBase != NULL) ? OldBase->GetComponentLocation() : FVector::ZeroVector;
const FVector OldLocation = UpdatedComponent->GetComponentLocation();
// Used for ledge check
FVector OldCapsuleLocation = VRRootCapsule ? VRRootCapsule->OffsetComponentToWorld.GetLocation() : OldLocation;
const FFindFloorResult OldFloor = CurrentFloor;
RestorePreAdditiveRootMotionVelocity();
//RestorePreAdditiveVRMotionVelocity();
// Ensure velocity is horizontal.
MaintainHorizontalGroundVelocity();
const FVector OldVelocity = Velocity;
Acceleration.Z = 0.f;
// Apply acceleration
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
CalcVelocity(timeTick, GroundFriction, false, GetMaxBrakingDeceleration());
devCode(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysWalking: Velocity contains NaN after CalcVelocity (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
}
ApplyRootMotionToVelocity(timeTick);
ApplyVRMotionToVelocity(deltaTime);//timeTick);
devCode(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysWalking: Velocity contains NaN after Root Motion application (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
if (IsFalling())
{
// Root motion could have put us into Falling.
// No movement has taken place this movement tick so we pass on full time/past iteration count
StartNewPhysics(remainingTime + timeTick, Iterations - 1);
return;
}
// Compute move parameters
const FVector MoveVelocity = Velocity;
const FVector Delta = timeTick * MoveVelocity;
const bool bZeroDelta = Delta.IsNearlyZero();
FStepDownResult StepDownResult;
if (bZeroDelta)
{
remainingTime = 0.f;
// TODO: Bugged currently
/*if (VRRootCapsule && VRRootCapsule->bUseWalkingCollisionOverride)
{
FHitResult HitRes;
FCollisionQueryParams Params("RelativeMovementSweep", false, GetOwner());
FCollisionResponseParams ResponseParam;
VRRootCapsule->InitSweepCollisionParams(Params, ResponseParam);
Params.bFindInitialOverlaps = true;
bool bWasBlockingHit = false;
bWasBlockingHit = GetWorld()->SweepSingleByChannel(HitRes, VRRootCapsule->OffsetComponentToWorld.GetLocation(), VRRootCapsule->OffsetComponentToWorld.GetLocation() + VRRootCapsule->DifferenceFromLastFrame, FQuat(0.0f, 0.0f, 0.0f, 1.0f), VRRootCapsule->GetCollisionObjectType(), VRRootCapsule->GetCollisionShape(), Params, ResponseParam);
const FVector GravDir(0.f, 0.f, -1.f);
if (CanStepUp(HitRes) || (CharacterOwner->GetMovementBase() != NULL && CharacterOwner->GetMovementBase()->GetOwner() == HitRes.GetActor()))
StepUp(GravDir,VRRootCapsule->DifferenceFromLastFrame.GetSafeNormal2D(), HitRes, &StepDownResult);
}*/
}
else
{
// try to move forward
MoveAlongFloor(MoveVelocity, timeTick, &StepDownResult);
if (IsFalling())
{
// pawn decided to jump up
const float DesiredDist = Delta.Size();
if (DesiredDist > KINDA_SMALL_NUMBER)
{
const float ActualDist = (UpdatedComponent->GetComponentLocation() - OldLocation).Size2D();
remainingTime += timeTick * (1.f - FMath::Min(1.f, ActualDist / DesiredDist));
}
RestorePreAdditiveVRMotionVelocity();
StartNewPhysics(remainingTime, Iterations);
return;
}
else if (IsSwimming()) //just entered water
{
RestorePreAdditiveVRMotionVelocity();
StartSwimmingVR(OldCapsuleLocation, OldVelocity, timeTick, remainingTime, Iterations);
return;
}
}
// Update floor.
// StepUp might have already done it for us.
if (StepDownResult.bComputedFloor)
{
CurrentFloor = StepDownResult.FloorResult;
}
else
{
FindFloor(UpdatedComponent->GetComponentLocation(), CurrentFloor, bZeroDelta, NULL);
}
// check for ledges here
const bool bCheckLedges = !CanWalkOffLedges();
if (bCheckLedges && !CurrentFloor.IsWalkableFloor())
{
// calculate possible alternate movement
const FVector GravDir = FVector(0.f, 0.f, -1.f);
const FVector NewDelta = bTriedLedgeMove ? FVector::ZeroVector : GetLedgeMove(OldCapsuleLocation, Delta, GravDir);
if (!NewDelta.IsZero())
{
// first revert this move
RevertMove(OldLocation, OldBase, PreviousBaseLocation, OldFloor, false);
// avoid repeated ledge moves if the first one fails
bTriedLedgeMove = true;
// Try new movement direction
Velocity = NewDelta / timeTick;
remainingTime += timeTick;
RestorePreAdditiveVRMotionVelocity();
continue;
}
else
{
// see if it is OK to jump
// @todo collision : only thing that can be problem is that oldbase has world collision on
bool bMustJump = bZeroDelta || (OldBase == NULL || (!OldBase->IsQueryCollisionEnabled() && MovementBaseUtility::IsDynamicBase(OldBase)));
if ((bMustJump || !bCheckedFall) && CheckFall(OldFloor, CurrentFloor.HitResult, Delta, OldLocation, remainingTime, timeTick, Iterations, bMustJump))
{
RestorePreAdditiveVRMotionVelocity();
return;
}
bCheckedFall = true;
// revert this move
RevertMove(OldLocation, OldBase, PreviousBaseLocation, OldFloor, true);
remainingTime = 0.f;
RestorePreAdditiveVRMotionVelocity();
break;
}
}
else
{
// Validate the floor check
if (CurrentFloor.IsWalkableFloor())
{
if (ShouldCatchAir(OldFloor, CurrentFloor))
{
RestorePreAdditiveVRMotionVelocity();
HandleWalkingOffLedge(OldFloor.HitResult.ImpactNormal, OldFloor.HitResult.Normal, OldLocation, timeTick);
if (IsMovingOnGround())
{
// If still walking, then fall. If not, assume the user set a different mode they want to keep.
StartFalling(Iterations, remainingTime, timeTick, Delta, OldLocation);
}
return;
}
AdjustFloorHeight();
SetBase(CurrentFloor.HitResult.Component.Get(), CurrentFloor.HitResult.BoneName);
}
else if (CurrentFloor.HitResult.bStartPenetrating && remainingTime <= 0.f)
{
// The floor check failed because it started in penetration
// We do not want to try to move downward because the downward sweep failed, rather we'd like to try to pop out of the floor.
FHitResult Hit(CurrentFloor.HitResult);
Hit.TraceEnd = Hit.TraceStart + FVector(0.f, 0.f, MAX_FLOOR_DIST);
const FVector RequestedAdjustment = GetPenetrationAdjustment(Hit);
ResolvePenetration(RequestedAdjustment, Hit, UpdatedComponent->GetComponentQuat());
bForceNextFloorCheck = true;
}
// check if just entered water
if (IsSwimming())
{
RestorePreAdditiveVRMotionVelocity();
StartSwimmingVR(OldCapsuleLocation, Velocity, timeTick, remainingTime, Iterations);
return;
}
// See if we need to start falling.
if (!CurrentFloor.IsWalkableFloor() && !CurrentFloor.HitResult.bStartPenetrating)
{
const bool bMustJump = bJustTeleported || bZeroDelta || (OldBase == NULL || (!OldBase->IsQueryCollisionEnabled() && MovementBaseUtility::IsDynamicBase(OldBase)));
if ((bMustJump || !bCheckedFall) && CheckFall(OldFloor, CurrentFloor.HitResult, Delta, OldLocation, remainingTime, timeTick, Iterations, bMustJump))
{
RestorePreAdditiveVRMotionVelocity();
return;
}
bCheckedFall = true;
}
}
// Allow overlap events and such to change physics state and velocity
if (IsMovingOnGround())
{
// Make velocity reflect actual move
if (!bJustTeleported && timeTick >= MIN_TICK_TIME)
{
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
// TODO-RootMotionSource: Allow this to happen during partial override Velocity, but only set allowed axes?
Velocity = ((UpdatedComponent->GetComponentLocation() - OldLocation) / timeTick);
}
RestorePreAdditiveVRMotionVelocity();
}
}
// If we didn't move at all this iteration then abort (since future iterations will also be stuck).
if (UpdatedComponent->GetComponentLocation() == OldLocation)
{
RestorePreAdditiveVRMotionVelocity();
remainingTime = 0.f;
break;
}
}
if (IsMovingOnGround())
{
MaintainHorizontalGroundVelocity();
}
}
void UVRCharacterMovementComponent::CapsuleTouched(UPrimitiveComponent* OverlappedComp, AActor* Other, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
if (!bEnablePhysicsInteraction)
{
return;
}
if (OtherComp != NULL && OtherComp->IsAnySimulatingPhysics())
{
/*const*/FVector OtherLoc = OtherComp->GetComponentLocation();
if (UVRRootComponent * rCap = Cast<UVRRootComponent>(OtherComp))
{
OtherLoc = rCap->OffsetComponentToWorld.GetLocation();
}
const FVector Loc = VRRootCapsule->OffsetComponentToWorld.GetLocation();//UpdatedComponent->GetComponentLocation();
FVector ImpulseDir = FVector(OtherLoc.X - Loc.X, OtherLoc.Y - Loc.Y, 0.25f).GetSafeNormal();
ImpulseDir = (ImpulseDir + Velocity.GetSafeNormal2D()) * 0.5f;
ImpulseDir.Normalize();
FName BoneName = NAME_None;
if (OtherBodyIndex != INDEX_NONE)
{
BoneName = ((USkinnedMeshComponent*)OtherComp)->GetBoneName(OtherBodyIndex);
}
float TouchForceFactorModified = TouchForceFactor;
if (bTouchForceScaledToMass)
{
FBodyInstance* BI = OtherComp->GetBodyInstance(BoneName);
TouchForceFactorModified *= BI ? BI->GetBodyMass() : 1.0f;
}
float ImpulseStrength = FMath::Clamp(Velocity.Size2D() * TouchForceFactorModified,
MinTouchForce > 0.0f ? MinTouchForce : -FLT_MAX,
MaxTouchForce > 0.0f ? MaxTouchForce : FLT_MAX);
FVector Impulse = ImpulseDir * ImpulseStrength;
OtherComp->AddImpulse(Impulse, BoneName);
}
}
void UVRCharacterMovementComponent::ReplicateMoveToServer(float DeltaTime, const FVector& NewAcceleration)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementReplicateMoveToServer);
check(CharacterOwner != NULL);
// Can only start sending moves if our controllers are synced up over the network, otherwise we flood the reliable buffer.
APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
if (PC && PC->AcknowledgedPawn != CharacterOwner)
{
return;
}
// Bail out if our character's controller doesn't have a Player. This may be the case when the local player
// has switched to another controller, such as a debug camera controller.
if (PC && PC->Player == nullptr)
{
return;
}
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (!ClientData)
{
return;
}
// Update our delta time for physics simulation.
DeltaTime = ClientData->UpdateTimeStampAndDeltaTime(DeltaTime, *CharacterOwner, *this);
// Find the oldest (unacknowledged) important move (OldMove).
// Don't include the last move because it may be combined with the next new move.
// A saved move is interesting if it differs significantly from the last acknowledged move
FSavedMovePtr OldMove = NULL;
if (ClientData->LastAckedMove.IsValid())
{
for (int32 i = 0; i < ClientData->SavedMoves.Num() - 1; i++)
{
const FSavedMovePtr& CurrentMove = ClientData->SavedMoves[i];
if (CurrentMove->IsImportantMove(ClientData->LastAckedMove))
{
OldMove = CurrentMove;
break;
}
}
}
// Get a SavedMove object to store the movement in.
FSavedMovePtr NewMovePtr = ClientData->CreateSavedMove();
FSavedMove_Character* const NewMove = NewMovePtr.Get();
if (NewMove == nullptr)
{
return;
}
NewMove->SetMoveFor(CharacterOwner, DeltaTime, NewAcceleration, *ClientData);
const UWorld* MyWorld = GetWorld();
// Causing really bad crash when using vr offset location, rather remove for now than have it merge move improperly.
// see if the two moves could be combined
// do not combine moves which have different TimeStamps (before and after reset).
if (const FSavedMove_Character* PendingMove = ClientData->PendingMove.Get())
{
if (bAllowMovementMerging && PendingMove->CanCombineWith(NewMovePtr, CharacterOwner, ClientData->MaxMoveDeltaTime * CharacterOwner->GetActorTimeDilation(*MyWorld)))
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_VRCharacterMovementComponent_CombineNetMove);
//SCOPE_CYCLE_COUNTER(STAT_CharacterMovementCombineNetMove);
// Only combine and move back to the start location if we don't move back in to a spot that would make us collide with something new.
/*const */FVector OldStartLocation = PendingMove->GetRevertedLocation();
// Modifying the location to account for capsule loc
FVector OverlapLocation = OldStartLocation;
if (VRRootCapsule)
OverlapLocation += VRRootCapsule->OffsetComponentToWorld.GetLocation() - VRRootCapsule->GetComponentLocation();
const bool bAttachedToObject = (NewMovePtr->StartAttachParent != nullptr);
if (bAttachedToObject || !OverlapTest(OverlapLocation, PendingMove->StartRotation.Quaternion(), UpdatedComponent->GetCollisionObjectType(), GetPawnCapsuleCollisionShape(SHRINK_None), CharacterOwner))
{
// Avoid updating Mesh bones to physics during the teleport back, since PerformMovement() will update it right away anyway below.
// Note: this must be before the FScopedMovementUpdate below, since that scope is what actually moves the character and mesh.
//AVRBaseCharacter * BaseCharacter = Cast<AVRBaseCharacter>(CharacterOwner);
FScopedMeshBoneUpdateOverrideVR ScopedNoMeshBoneUpdate(CharacterOwner->GetMesh(), EKinematicBonesUpdateToPhysics::SkipAllBones);
// Accumulate multiple transform updates until scope ends.
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, EScopedUpdate::DeferredUpdates);
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("CombineMove: add delta %f + %f and revert from %f %f to %f %f"), DeltaTime, ClientData->PendingMove->DeltaTime, UpdatedComponent->GetComponentLocation().X, UpdatedComponent->GetComponentLocation().Y, /*OldStartLocation.X*/OverlapLocation.X, /*OldStartLocation.Y*/OverlapLocation.Y);
NewMove->CombineWith(PendingMove, CharacterOwner, PC, OldStartLocation);
/************************/
if (PC)
{
// We reverted position to that at the start of the pending move (above), however some code paths expect rotation to be set correctly
// before character movement occurs (via FaceRotation), so try that now. The bOrientRotationToMovement path happens later as part of PerformMovement() and PhysicsRotation().
CharacterOwner->FaceRotation(PC->GetControlRotation(), NewMove->DeltaTime);
}
SaveBaseLocation();
NewMove->SetInitialPosition(CharacterOwner);
// Remove pending move from move list. It would have to be the last move on the list.
if (ClientData->SavedMoves.Num() > 0 && ClientData->SavedMoves.Last() == ClientData->PendingMove)
{
const bool bAllowShrinking = false;
ClientData->SavedMoves.Pop(bAllowShrinking);
}
ClientData->FreeMove(ClientData->PendingMove);
ClientData->PendingMove = nullptr;
PendingMove = nullptr; // Avoid dangling reference, it's deleted above.
}
else
{
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Not combining move [would collide at start location]"));
}
}
/*else
{
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Not combining move [not allowed by CanCombineWith()]"));
}*/
}
// Acceleration should match what we send to the server, plus any other restrictions the server also enforces (see MoveAutonomous).
Acceleration = NewMove->Acceleration.GetClampedToMaxSize(GetMaxAcceleration());
AnalogInputModifier = ComputeAnalogInputModifier(); // recompute since acceleration may have changed.
// Perform the move locally
CharacterOwner->ClientRootMotionParams.Clear();
CharacterOwner->SavedRootMotion.Clear();
PerformMovement(NewMove->DeltaTime);
NewMove->PostUpdate(CharacterOwner, FSavedMove_Character::PostUpdate_Record);
// Add NewMove to the list
if (CharacterOwner->IsReplicatingMovement())
{
check(NewMove == NewMovePtr.Get());
ClientData->SavedMoves.Push(NewMovePtr);
static const auto CVarNetEnableMoveCombining = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetEnableMoveCombining"));
const bool bCanDelayMove = (CVarNetEnableMoveCombining->GetInt() != 0) && CanDelaySendingMove(NewMovePtr);
if (bCanDelayMove && ClientData->PendingMove.IsValid() == false)
{
// Decide whether to hold off on move
// Decide whether to hold off on move
const float NetMoveDelta = FMath::Clamp(GetClientNetSendDeltaTime(PC, ClientData, NewMovePtr), 1.f / 120.f, 1.f / 5.f);
if ((MyWorld->TimeSeconds - ClientData->ClientUpdateTime) * MyWorld->GetWorldSettings()->GetEffectiveTimeDilation() < NetMoveDelta)
{
// Delay sending this move.
ClientData->PendingMove = NewMovePtr;
return;
}
}
ClientData->ClientUpdateTime = MyWorld->TimeSeconds;
UE_CLOG(CharacterOwner&& UpdatedComponent, LogVRCharacterMovement, VeryVerbose, TEXT("ClientMove Time %f Acceleration %s Velocity %s Position %s Rotation %s DeltaTime %f Mode %s MovementBase %s.%s (Dynamic:%d) DualMove? %d"),
NewMove->TimeStamp, *NewMove->Acceleration.ToString(), *Velocity.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *UpdatedComponent->GetComponentRotation().ToCompactString(), NewMove->DeltaTime, *GetMovementName(),
*GetNameSafe(NewMove->EndBase.Get()), *NewMove->EndBoneName.ToString(), MovementBaseUtility::IsDynamicBase(NewMove->EndBase.Get()) ? 1 : 0, ClientData->PendingMove.IsValid() ? 1 : 0);
bool bSendServerMove = true;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
// Testing options: Simulated packet loss to server
const float TimeSinceLossStart = (MyWorld->RealTimeSeconds - ClientData->DebugForcedPacketLossTimerStart);
static const auto CVarNetForceClientServerMoveLossDuration = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetForceClientServerMoveLossDuration"));
static const auto CVarNetForceClientServerMoveLossPercent = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetForceClientServerMoveLossPercent"));
if (ClientData->DebugForcedPacketLossTimerStart > 0.f && (TimeSinceLossStart < CVarNetForceClientServerMoveLossDuration->GetFloat()))
{
bSendServerMove = false;
UE_LOG(LogVRCharacterMovement, Log, TEXT("Drop ServerMove, %.2f time remains"), CVarNetForceClientServerMoveLossDuration->GetFloat() - TimeSinceLossStart);
}
else if (CVarNetForceClientServerMoveLossPercent->GetFloat() != 0.f && (RandomStream.FRand() < CVarNetForceClientServerMoveLossPercent->GetFloat()))
{
bSendServerMove = false;
ClientData->DebugForcedPacketLossTimerStart = (CVarNetForceClientServerMoveLossDuration->GetFloat() > 0) ? MyWorld->RealTimeSeconds : 0.0f;
UE_LOG(LogVRCharacterMovement, Log, TEXT("Drop ServerMove, %.2f time remains"), CVarNetForceClientServerMoveLossDuration->GetFloat());
}
else
{
ClientData->DebugForcedPacketLossTimerStart = 0.f;
}
#endif
// Send move to server if this character is replicating movement
if (bSendServerMove)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementCallServerMove);
CallServerMove(NewMove, OldMove.Get());
}
}
ClientData->PendingMove = NULL;
}
/*
*
*
* END TEST AREA
*
*
*/
UVRCharacterMovementComponent::UVRCharacterMovementComponent(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
PostPhysicsTickFunction.bCanEverTick = true;
PostPhysicsTickFunction.bStartWithTickEnabled = false;
PrimaryComponentTick.TickGroup = TG_PrePhysics;
VRRootCapsule = NULL;
//VRCameraCollider = NULL;
// 0.1f is low slide and still impacts surfaces well
// This variable is a bit of a hack, it reduces the movement of the pawn in the direction of relative movement
//WallRepulsionMultiplier = 0.01f;
bUseClientControlRotation = false;
bAllowMovementMerging = true;
bRequestedMoveUseAcceleration = false;
}
void UVRCharacterMovementComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
if (!HasValidData())
{
return;
}
if (CharacterOwner && CharacterOwner->IsLocallyControlled())
{
// Root capsule is now throwing out the difference itself, I use the difference for multiplayer sends
if (VRRootCapsule)
{
AdditionalVRInputVector = VRRootCapsule->DifferenceFromLastFrame;
}
else
{
AdditionalVRInputVector = FVector::ZeroVector;
}
}
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}
// No support for crouching code yet
bool UVRCharacterMovementComponent::CanCrouch()
{
return false;
}
void UVRCharacterMovementComponent::ApplyRepulsionForce(float DeltaSeconds)
{
if (UpdatedPrimitive && RepulsionForce > 0.0f && CharacterOwner != nullptr)
{
const TArray<FOverlapInfo>& Overlaps = UpdatedPrimitive->GetOverlapInfos();
if (Overlaps.Num() > 0)
{
FCollisionQueryParams QueryParams;
QueryParams.bReturnFaceIndex = false;
QueryParams.bReturnPhysicalMaterial = false;
float CapsuleRadius = 0.f;
float CapsuleHalfHeight = 0.f;
CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(CapsuleRadius, CapsuleHalfHeight);
const float RepulsionForceRadius = CapsuleRadius * 1.2f;
const float StopBodyDistance = 2.5f;
FVector MyLocation;
if (VRRootCapsule)
MyLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
else
MyLocation = UpdatedPrimitive->GetComponentLocation();
for (int32 i = 0; i < Overlaps.Num(); i++)
{
const FOverlapInfo& Overlap = Overlaps[i];
UPrimitiveComponent* OverlapComp = Overlap.OverlapInfo.Component.Get();
if (!OverlapComp || OverlapComp->Mobility < EComponentMobility::Movable)
{
continue;
}
// Use the body instead of the component for cases where we have multi-body overlaps enabled
FBodyInstance* OverlapBody = nullptr;
const int32 OverlapBodyIndex = Overlap.GetBodyIndex();
const USkeletalMeshComponent* SkelMeshForBody = (OverlapBodyIndex != INDEX_NONE) ? Cast<USkeletalMeshComponent>(OverlapComp) : nullptr;
if (SkelMeshForBody != nullptr)
{
OverlapBody = SkelMeshForBody->Bodies.IsValidIndex(OverlapBodyIndex) ? SkelMeshForBody->Bodies[OverlapBodyIndex] : nullptr;
}
else
{
OverlapBody = OverlapComp->GetBodyInstance();
}
if (!OverlapBody)
{
UE_LOG(LogVRCharacterMovement, Warning, TEXT("%s could not find overlap body for body index %d"), *GetName(), OverlapBodyIndex);
continue;
}
if (!OverlapBody->IsInstanceSimulatingPhysics())
{
continue;
}
FTransform BodyTransform = OverlapBody->GetUnrealWorldTransform();
FVector BodyVelocity = OverlapBody->GetUnrealWorldVelocity();
FVector BodyLocation = BodyTransform.GetLocation();
// Trace to get the hit location on the capsule
FHitResult Hit;
bool bHasHit = UpdatedPrimitive->LineTraceComponent(Hit, BodyLocation,
FVector(MyLocation.X, MyLocation.Y, BodyLocation.Z),
QueryParams);
FVector HitLoc = Hit.ImpactPoint;
bool bIsPenetrating = Hit.bStartPenetrating || Hit.PenetrationDepth > StopBodyDistance;
// If we didn't hit the capsule, we're inside the capsule
if (!bHasHit)
{
HitLoc = BodyLocation;
bIsPenetrating = true;
}
const float DistanceNow = (HitLoc - BodyLocation).SizeSquared2D();
const float DistanceLater = (HitLoc - (BodyLocation + BodyVelocity * DeltaSeconds)).SizeSquared2D();
if (bHasHit && DistanceNow < StopBodyDistance && !bIsPenetrating)
{
OverlapBody->SetLinearVelocity(FVector(0.0f, 0.0f, 0.0f), false);
}
else if (DistanceLater <= DistanceNow || bIsPenetrating)
{
FVector ForceCenter = MyLocation;
if (bHasHit)
{
ForceCenter.Z = HitLoc.Z;
}
else
{
ForceCenter.Z = FMath::Clamp(BodyLocation.Z, MyLocation.Z - CapsuleHalfHeight, MyLocation.Z + CapsuleHalfHeight);
}
OverlapBody->AddRadialForceToBody(ForceCenter, RepulsionForceRadius, RepulsionForce * Mass, ERadialImpulseFalloff::RIF_Constant);
}
}
}
}
}
void UVRCharacterMovementComponent::SetUpdatedComponent(USceneComponent* NewUpdatedComponent)
{
Super::SetUpdatedComponent(NewUpdatedComponent);
if (UpdatedComponent)
{
// Fill the VRRootCapsule if we can
VRRootCapsule = Cast<UVRRootComponent>(UpdatedComponent);
// Fill in the camera collider if we can
/*if (AVRCharacter * vrOwner = Cast<AVRCharacter>(this->GetOwner()))
{
VRCameraCollider = vrOwner->VRCameraCollider;
}*/
// Stop the tick forcing
UpdatedComponent->PrimaryComponentTick.RemovePrerequisite(this, PrimaryComponentTick);
// Start forcing the root to tick before this, the actor tick will still tick after the movement component
// We want the root component to tick first because it is setting its offset location based off of tick
this->PrimaryComponentTick.AddPrerequisite(UpdatedComponent, UpdatedComponent->PrimaryComponentTick);
}
}
FORCEINLINE_DEBUGGABLE bool UVRCharacterMovementComponent::SafeMoveUpdatedComponent(const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport)
{
return SafeMoveUpdatedComponent(Delta, NewRotation.Quaternion(), bSweep, OutHit, Teleport);
}
bool UVRCharacterMovementComponent::SafeMoveUpdatedComponent(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport)
{
if (UpdatedComponent == NULL)
{
OutHit.Reset(1.f);
return false;
}
bool bMoveResult = MoveUpdatedComponent(Delta, NewRotation, bSweep, &OutHit, Teleport);
// Handle initial penetrations
if (OutHit.bStartPenetrating && UpdatedComponent)
{
const FVector RequestedAdjustment = GetPenetrationAdjustment(OutHit);
if (ResolvePenetration(RequestedAdjustment, OutHit, NewRotation))
{
FHitResult TempHit;
// Retry original move
bMoveResult = MoveUpdatedComponent(Delta, NewRotation, bSweep, &TempHit, Teleport);
// Remove start penetrating if this is a clean move, otherwise use the last moves hit as the result so step up actually attempts to work.
if (TempHit.bStartPenetrating)
OutHit = TempHit;
else
OutHit.bStartPenetrating = TempHit.bStartPenetrating;
}
}
return bMoveResult;
}
void UVRCharacterMovementComponent::MoveAlongFloor(const FVector& InVelocity, float DeltaSeconds, FStepDownResult* OutStepDownResult)
{
if (!CurrentFloor.IsWalkableFloor())
{
return;
}
// Move along the current floor
const FVector Delta = FVector(InVelocity.X, InVelocity.Y, 0.f) * DeltaSeconds;
FHitResult Hit(1.f);
FVector RampVector = ComputeGroundMovementDelta(Delta, CurrentFloor.HitResult, CurrentFloor.bLineTrace);
SafeMoveUpdatedComponent(RampVector, UpdatedComponent->GetComponentQuat(), true, Hit);
float LastMoveTimeSlice = DeltaSeconds;
if (Hit.bStartPenetrating)
{
// Allow this hit to be used as an impact we can deflect off, otherwise we do nothing the rest of the update and appear to hitch.
HandleImpact(Hit);
SlideAlongSurface(Delta, 1.f, Hit.Normal, Hit, true);
if (Hit.bStartPenetrating)
{
OnCharacterStuckInGeometry(&Hit);
}
}
else if (Hit.IsValidBlockingHit())
{
// We impacted something (most likely another ramp, but possibly a barrier).
float PercentTimeApplied = Hit.Time;
if ((Hit.Time > 0.f) && (Hit.Normal.Z > KINDA_SMALL_NUMBER) && IsWalkable(Hit))
{
// Another walkable ramp.
const float InitialPercentRemaining = 1.f - PercentTimeApplied;
RampVector = ComputeGroundMovementDelta(Delta * InitialPercentRemaining, Hit, false);
LastMoveTimeSlice = InitialPercentRemaining * LastMoveTimeSlice;
SafeMoveUpdatedComponent(RampVector, UpdatedComponent->GetComponentQuat(), true, Hit);
const float SecondHitPercent = Hit.Time * InitialPercentRemaining;
PercentTimeApplied = FMath::Clamp(PercentTimeApplied + SecondHitPercent, 0.f, 1.f);
}
if (Hit.IsValidBlockingHit())
{
if (CanStepUp(Hit) || (CharacterOwner->GetMovementBase() != NULL && CharacterOwner->GetMovementBase()->GetOwner() == Hit.GetActor()))
{
// hit a barrier, try to step up
const FVector GravDir(0.f, 0.f, -1.f);
// I add in the HMD difference from last frame to the step up check to enforce it stepping up
if (!StepUp(GravDir, (Delta * (1.f - PercentTimeApplied)) /*+ AdditionalVRInputVector.GetSafeNormal2D()*/, Hit, OutStepDownResult))
{
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("- StepUp (ImpactNormal %s, Normal %s"), *Hit.ImpactNormal.ToString(), *Hit.Normal.ToString());
HandleImpact(Hit, LastMoveTimeSlice, RampVector);
SlideAlongSurface(Delta, 1.f - PercentTimeApplied, Hit.Normal, Hit, true);
}
else
{
// Don't recalculate velocity based on this height adjustment, if considering vertical adjustments.
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("+ StepUp (ImpactNormal %s, Normal %s"), *Hit.ImpactNormal.ToString(), *Hit.Normal.ToString());
bJustTeleported |= !bMaintainHorizontalGroundVelocity;
}
}
else if (Hit.Component.IsValid() && !Hit.Component.Get()->CanCharacterStepUp(CharacterOwner))
{
HandleImpact(Hit, LastMoveTimeSlice, RampVector);
SlideAlongSurface(Delta, 1.f - PercentTimeApplied, Hit.Normal, Hit, true);
}
}
}
}
bool UVRCharacterMovementComponent::StepUp(const FVector& GravDir, const FVector& Delta, const FHitResult &InHit, FStepDownResult* OutStepDownResult)
{
SCOPE_CYCLE_COUNTER(STAT_CharStepUp);
if (!CanStepUp(InHit) || MaxStepHeight <= 0.f)
{
return false;
}
FVector OldLocation;
if (VRRootCapsule)
OldLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
else
OldLocation = UpdatedComponent->GetComponentLocation();
float PawnRadius, PawnHalfHeight;
CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(PawnRadius, PawnHalfHeight);
// Don't bother stepping up if top of capsule is hitting something.
const float InitialImpactZ = InHit.ImpactPoint.Z;
if (InitialImpactZ > OldLocation.Z + (PawnHalfHeight - PawnRadius))
{
return false;
}
if (GravDir.IsZero())
{
return false;
}
// Gravity should be a normalized direction
ensure(GravDir.IsNormalized());
float StepTravelUpHeight = MaxStepHeight;
float StepTravelDownHeight = StepTravelUpHeight;
const float StepSideZ = -1.f * FVector::DotProduct(InHit.ImpactNormal, GravDir);//const float StepSideZ = -1.f * (InHit.ImpactNormal | GravDir);
float PawnInitialFloorBaseZ = OldLocation.Z -PawnHalfHeight;
float PawnFloorPointZ = PawnInitialFloorBaseZ;
if (IsMovingOnGround() && CurrentFloor.IsWalkableFloor())
{
// Since we float a variable amount off the floor, we need to enforce max step height off the actual point of impact with the floor.
const float FloorDist = FMath::Max(0.f, CurrentFloor.GetDistanceToFloor());
PawnInitialFloorBaseZ -= FloorDist;
StepTravelUpHeight = FMath::Max(StepTravelUpHeight - FloorDist, 0.f);
StepTravelDownHeight = (MaxStepHeight + MAX_FLOOR_DIST*2.f);
const bool bHitVerticalFace = !IsWithinEdgeTolerance(InHit.Location, InHit.ImpactPoint, PawnRadius);
if (!CurrentFloor.bLineTrace && !bHitVerticalFace)
{
PawnFloorPointZ = CurrentFloor.HitResult.ImpactPoint.Z;
}
else
{
// Base floor point is the base of the capsule moved down by how far we are hovering over the surface we are hitting.
PawnFloorPointZ -= CurrentFloor.FloorDist;
}
}
// Don't step up if the impact is below us, accounting for distance from floor.
if (InitialImpactZ <= PawnInitialFloorBaseZ)
{
return false;
}
// Scope our movement updates, and do not apply them until all intermediate moves are completed.
/*FScopedMovementUpdate*/ FVRCharacterScopedMovementUpdate ScopedStepUpMovement(UpdatedComponent, EScopedUpdate::DeferredUpdates);
// step up - treat as vertical wall
FHitResult SweepUpHit(1.f);
const FQuat PawnRotation = UpdatedComponent->GetComponentQuat();
MoveUpdatedComponent(-GravDir * StepTravelUpHeight, PawnRotation, true, &SweepUpHit);
if (SweepUpHit.bStartPenetrating)
{
// Undo movement
ScopedStepUpMovement.RevertMove();
return false;
}
// step fwd
FHitResult Hit(1.f);
MoveUpdatedComponent(Delta, PawnRotation, true, &Hit);
// Check result of forward movement
if (Hit.bBlockingHit)
{
if (Hit.bStartPenetrating)
{
// Undo movement
ScopedStepUpMovement.RevertMove();
return false;
}
// If we hit something above us and also something ahead of us, we should notify about the upward hit as well.
// The forward hit will be handled later (in the bSteppedOver case below).
// In the case of hitting something above but not forward, we are not blocked from moving so we don't need the notification.
if (SweepUpHit.bBlockingHit && Hit.bBlockingHit)
{
HandleImpact(SweepUpHit);
}
// pawn ran into a wall
HandleImpact(Hit);
if (IsFalling())
{
return true;
}
// adjust and try again
const float ForwardHitTime = Hit.Time;
const float ForwardSlideAmount = SlideAlongSurface(Delta, 1.f - Hit.Time, Hit.Normal, Hit, true);
if (IsFalling())
{
ScopedStepUpMovement.RevertMove();
return false;
}
// If both the forward hit and the deflection got us nowhere, there is no point in this step up.
if (ForwardHitTime == 0.f && ForwardSlideAmount == 0.f)
{
ScopedStepUpMovement.RevertMove();
return false;
}
}
// Step down
MoveUpdatedComponent(GravDir * StepTravelDownHeight, UpdatedComponent->GetComponentQuat(), true, &Hit);
// If step down was initially penetrating abort the step up
if (Hit.bStartPenetrating)
{
ScopedStepUpMovement.RevertMove();
return false;
}
FStepDownResult StepDownResult;
if (Hit.IsValidBlockingHit())
{
// See if this step sequence would have allowed us to travel higher than our max step height allows.
const float DeltaZ = Hit.ImpactPoint.Z - PawnFloorPointZ;
if (DeltaZ > MaxStepHeight)
{
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (too high Height %.3f) up from floor base %f"), DeltaZ, PawnInitialFloorBaseZ);
ScopedStepUpMovement.RevertMove();
return false;
}
// Reject unwalkable surface normals here.
if (!IsWalkable(Hit))
{
// Reject if normal opposes movement direction
const bool bNormalTowardsMe = (Delta | Hit.ImpactNormal) < 0.f;
if (bNormalTowardsMe)
{
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (unwalkable normal %s opposed to movement)"), *Hit.ImpactNormal.ToString());
ScopedStepUpMovement.RevertMove();
return false;
}
// Also reject if we would end up being higher than our starting location by stepping down.
// It's fine to step down onto an unwalkable normal below us, we will just slide off. Rejecting those moves would prevent us from being able to walk off the edge.
if (Hit.Location.Z > OldLocation.Z)
{
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (unwalkable normal %s above old position)"), *Hit.ImpactNormal.ToString());
ScopedStepUpMovement.RevertMove();
return false;
}
}
// Reject moves where the downward sweep hit something very close to the edge of the capsule. This maintains consistency with FindFloor as well.
if (!IsWithinEdgeTolerance(Hit.Location, Hit.ImpactPoint, PawnRadius))
{
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (outside edge tolerance)"));
ScopedStepUpMovement.RevertMove();
return false;
}
// Don't step up onto invalid surfaces if traveling higher.
if (DeltaZ > 0.f && !CanStepUp(Hit))
{
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (up onto surface with !CanStepUp())"));
ScopedStepUpMovement.RevertMove();
return false;
}
// See if we can validate the floor as a result of this step down. In almost all cases this should succeed, and we can avoid computing the floor outside this method.
if (OutStepDownResult != NULL)
{
FindFloor(UpdatedComponent->GetComponentLocation(), StepDownResult.FloorResult, false, &Hit);
// Reject unwalkable normals if we end up higher than our initial height.
// It's fine to walk down onto an unwalkable surface, don't reject those moves.
if (Hit.Location.Z > OldLocation.Z)
{
// We should reject the floor result if we are trying to step up an actual step where we are not able to perch (this is rare).
// In those cases we should instead abort the step up and try to slide along the stair.
if (!StepDownResult.FloorResult.bBlockingHit && StepSideZ < MAX_STEP_SIDE_Z)
{
ScopedStepUpMovement.RevertMove();
return false;
}
}
StepDownResult.bComputedFloor = true;
}
}
// Copy step down result.
if (OutStepDownResult != NULL)
{
*OutStepDownResult = StepDownResult;
}
// Don't recalculate velocity based on this height adjustment, if considering vertical adjustments.
bJustTeleported |= !bMaintainHorizontalGroundVelocity;
return true;
}
bool UVRCharacterMovementComponent::IsWithinEdgeTolerance(const FVector& CapsuleLocation, const FVector& TestImpactPoint, const float CapsuleRadius) const
{
const float DistFromCenterSq = (TestImpactPoint - CapsuleLocation).SizeSquared2D();
const float ReducedRadiusSq = FMath::Square(FMath::Max(VREdgeRejectDistance + KINDA_SMALL_NUMBER, CapsuleRadius - VREdgeRejectDistance));
return DistFromCenterSq < ReducedRadiusSq;
}
bool UVRCharacterMovementComponent::IsWithinClimbingEdgeTolerance(const FVector& CapsuleLocation, const FVector& TestImpactPoint, const float CapsuleRadius) const
{
const float DistFromCenterSq = (TestImpactPoint - CapsuleLocation).SizeSquared2D();
const float ReducedRadiusSq = FMath::Square(FMath::Max(VRClimbingEdgeRejectDistance + KINDA_SMALL_NUMBER, CapsuleRadius - VRClimbingEdgeRejectDistance));
return DistFromCenterSq < ReducedRadiusSq;
}
bool UVRCharacterMovementComponent::VRClimbStepUp(const FVector& GravDir, const FVector& Delta, const FHitResult &InHit, FStepDownResult* OutStepDownResult)
{
SCOPE_CYCLE_COUNTER(STAT_CharStepUp);
if (!CanStepUp(InHit) || MaxStepHeight <= 0.f)
{
return false;
}
FVector OldLocation;
if (VRRootCapsule)
OldLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
else
OldLocation = UpdatedComponent->GetComponentLocation();
float PawnRadius, PawnHalfHeight;
CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(PawnRadius, PawnHalfHeight);
// Don't bother stepping up if top of capsule is hitting something.
const float InitialImpactZ = InHit.ImpactPoint.Z;
if (InitialImpactZ > OldLocation.Z + (PawnHalfHeight - PawnRadius))
{
return false;
}
// Don't step up if the impact is below us
if (InitialImpactZ <= OldLocation.Z - PawnHalfHeight)
{
return false;
}
if (GravDir.IsZero())
{
return false;
}
// Gravity should be a normalized direction
ensure(GravDir.IsNormalized());
float StepTravelUpHeight = MaxStepHeight;
float StepTravelDownHeight = StepTravelUpHeight;
const float StepSideZ = -1.f * (InHit.ImpactNormal | GravDir);
float PawnInitialFloorBaseZ = OldLocation.Z - PawnHalfHeight;
float PawnFloorPointZ = PawnInitialFloorBaseZ;
// Scope our movement updates, and do not apply them until all intermediate moves are completed.
FVRCharacterScopedMovementUpdate ScopedStepUpMovement(UpdatedComponent, EScopedUpdate::DeferredUpdates);
// step up - treat as vertical wall
FHitResult SweepUpHit(1.f);
const FQuat PawnRotation = UpdatedComponent->GetComponentQuat();
MoveUpdatedComponent(-GravDir * StepTravelUpHeight, PawnRotation, true, &SweepUpHit);
if (SweepUpHit.bStartPenetrating)
{
// Undo movement
ScopedStepUpMovement.RevertMove();
return false;
}
// step fwd
FHitResult Hit(1.f);
// Adding in the directional difference of the last HMD movement to promote stepping up
// Probably entirely wrong as Delta is divided by movement ticks but I want the effect to be stronger anyway
// This won't effect control based movement unless stepping forward at the same time, but gives RW movement
// the extra boost to get up over a lip
// #TODO test this more, currently appears to be needed for walking, but is harmful for other modes
// if (VRRootCapsule)
// MoveUpdatedComponent(Delta + VRRootCapsule->DifferenceFromLastFrame.GetSafeNormal2D(), PawnRotation, true, &Hit);
// else
MoveUpdatedComponent(Delta, PawnRotation, true, &Hit);
//MoveUpdatedComponent(Delta, PawnRotation, true, &Hit);
// Check result of forward movement
if (Hit.bBlockingHit)
{
if (Hit.bStartPenetrating)
{
// Undo movement
ScopedStepUpMovement.RevertMove();
return false;
}
// If we hit something above us and also something ahead of us, we should notify about the upward hit as well.
// The forward hit will be handled later (in the bSteppedOver case below).
// In the case of hitting something above but not forward, we are not blocked from moving so we don't need the notification.
if (SweepUpHit.bBlockingHit && Hit.bBlockingHit)
{
HandleImpact(SweepUpHit);
}
// pawn ran into a wall
HandleImpact(Hit);
if (IsFalling())
{
return true;
}
//Don't adjust for VR, it doesn't work correctly
ScopedStepUpMovement.RevertMove();
return false;
// adjust and try again
//const float ForwardHitTime = Hit.Time;
//const float ForwardSlideAmount = SlideAlongSurface(Delta, 1.f - Hit.Time, Hit.Normal, Hit, true);
//if (IsFalling())
//{
// ScopedStepUpMovement.RevertMove();
// return false;
//}
// If both the forward hit and the deflection got us nowhere, there is no point in this step up.
//if (ForwardHitTime == 0.f && ForwardSlideAmount == 0.f)
//{
// ScopedStepUpMovement.RevertMove();
// return false;
//}
}
// Step down
MoveUpdatedComponent(GravDir * StepTravelDownHeight, UpdatedComponent->GetComponentQuat(), true, &Hit);
// If step down was initially penetrating abort the step up
if (Hit.bStartPenetrating)
{
ScopedStepUpMovement.RevertMove();
return false;
}
FStepDownResult StepDownResult;
if (Hit.IsValidBlockingHit())
{
// See if this step sequence would have allowed us to travel higher than our max step height allows.
const float DeltaZ = Hit.ImpactPoint.Z - PawnFloorPointZ;
if (DeltaZ > MaxStepHeight)
{
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (too high Height %.3f) up from floor base %f"), DeltaZ, PawnInitialFloorBaseZ);
ScopedStepUpMovement.RevertMove();
return false;
}
// Reject unwalkable surface normals here.
if (!IsWalkable(Hit))
{
// Reject if normal opposes movement direction
const bool bNormalTowardsMe = (Delta | Hit.ImpactNormal) < 0.f;
if (bNormalTowardsMe)
{
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (unwalkable normal %s opposed to movement)"), *Hit.ImpactNormal.ToString());
ScopedStepUpMovement.RevertMove();
return false;
}
// Also reject if we would end up being higher than our starting location by stepping down.
// It's fine to step down onto an unwalkable normal below us, we will just slide off. Rejecting those moves would prevent us from being able to walk off the edge.
if (Hit.Location.Z > OldLocation.Z)
{
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (unwalkable normal %s above old position)"), *Hit.ImpactNormal.ToString());
ScopedStepUpMovement.RevertMove();
return false;
}
}
// Reject moves where the downward sweep hit something very close to the edge of the capsule. This maintains consistency with FindFloor as well.
if (!IsWithinClimbingEdgeTolerance(Hit.Location, Hit.ImpactPoint, PawnRadius))
{
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (outside edge tolerance)"));
ScopedStepUpMovement.RevertMove();
return false;
}
// Don't step up onto invalid surfaces if traveling higher.
if (DeltaZ > 0.f && !CanStepUp(Hit))
{
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("- Reject StepUp (up onto surface with !CanStepUp())"));
ScopedStepUpMovement.RevertMove();
return false;
}
// See if we can validate the floor as a result of this step down. In almost all cases this should succeed, and we can avoid computing the floor outside this method.
if (OutStepDownResult != NULL)
{
FindFloor(UpdatedComponent->GetComponentLocation(), StepDownResult.FloorResult, false, &Hit);
// Reject unwalkable normals if we end up higher than our initial height.
// It's fine to walk down onto an unwalkable surface, don't reject those moves.
if (Hit.Location.Z > OldLocation.Z)
{
// We should reject the floor result if we are trying to step up an actual step where we are not able to perch (this is rare).
// In those cases we should instead abort the step up and try to slide along the stair.
if (!StepDownResult.FloorResult.bBlockingHit && StepSideZ < MAX_STEP_SIDE_Z)
{
ScopedStepUpMovement.RevertMove();
return false;
}
}
StepDownResult.bComputedFloor = true;
}
}
// Copy step down result.
if (OutStepDownResult != NULL)
{
*OutStepDownResult = StepDownResult;
}
// Don't recalculate velocity based on this height adjustment, if considering vertical adjustments.
bJustTeleported |= !bMaintainHorizontalGroundVelocity;
return true;
}
void UVRCharacterMovementComponent::UpdateBasedMovement(float DeltaSeconds)
{
if (!HasValidData())
{
return;
}
const UPrimitiveComponent* MovementBase = CharacterOwner->GetMovementBase();
if (!MovementBaseUtility::UseRelativeLocation(MovementBase))
{
return;
}
if (!IsValid(MovementBase) || !IsValid(MovementBase->GetOwner()))
{
SetBase(NULL);
return;
}
// Ignore collision with bases during these movements.
TGuardValue<EMoveComponentFlags> ScopedFlagRestore(MoveComponentFlags, MoveComponentFlags | MOVECOMP_IgnoreBases);
FQuat DeltaQuat = FQuat::Identity;
FVector DeltaPosition = FVector::ZeroVector;
FQuat NewBaseQuat;
FVector NewBaseLocation;
if (!MovementBaseUtility::GetMovementBaseTransform(MovementBase, CharacterOwner->GetBasedMovement().BoneName, NewBaseLocation, NewBaseQuat))
{
return;
}
// Find change in rotation
const bool bRotationChanged = !OldBaseQuat.Equals(NewBaseQuat, 1e-8f);
if (bRotationChanged)
{
DeltaQuat = NewBaseQuat * OldBaseQuat.Inverse();
}
// only if base moved
if (bRotationChanged || (OldBaseLocation != NewBaseLocation))
{
// Calculate new transform matrix of base actor (ignoring scale).
const FQuatRotationTranslationMatrix OldLocalToWorld(OldBaseQuat, OldBaseLocation);
const FQuatRotationTranslationMatrix NewLocalToWorld(NewBaseQuat, NewBaseLocation);
if (CharacterOwner->IsMatineeControlled())
{
FRotationTranslationMatrix HardRelMatrix(CharacterOwner->GetBasedMovement().Rotation, CharacterOwner->GetBasedMovement().Location);
const FMatrix NewWorldTM = HardRelMatrix * NewLocalToWorld;
const FQuat NewWorldRot = bIgnoreBaseRotation ? UpdatedComponent->GetComponentQuat() : NewWorldTM.ToQuat();
MoveUpdatedComponent(NewWorldTM.GetOrigin() - UpdatedComponent->GetComponentLocation(), NewWorldRot, true);
}
else
{
FQuat FinalQuat = UpdatedComponent->GetComponentQuat();
if (bRotationChanged && !bIgnoreBaseRotation)
{
// Apply change in rotation and pipe through FaceRotation to maintain axis restrictions
const FQuat PawnOldQuat = UpdatedComponent->GetComponentQuat();
const FQuat TargetQuat = DeltaQuat * FinalQuat;
FRotator TargetRotator(TargetQuat);
CharacterOwner->FaceRotation(TargetRotator, 0.f);
FinalQuat = UpdatedComponent->GetComponentQuat();
if (PawnOldQuat.Equals(FinalQuat, 1e-6f))
{
// Nothing changed. This means we probably are using another rotation mechanism (bOrientToMovement etc). We should still follow the base object.
// @todo: This assumes only Yaw is used, currently a valid assumption. This is the only reason FaceRotation() is used above really, aside from being a virtual hook.
if (bOrientRotationToMovement || (bUseControllerDesiredRotation && CharacterOwner->Controller))
{
TargetRotator.Pitch = 0.f;
TargetRotator.Roll = 0.f;
MoveUpdatedComponent(FVector::ZeroVector, TargetRotator, false);
FinalQuat = UpdatedComponent->GetComponentQuat();
}
}
// Pipe through ControlRotation, to affect camera.
if (CharacterOwner->Controller)
{
const FQuat PawnDeltaRotation = FinalQuat * PawnOldQuat.Inverse();
FRotator FinalRotation = FinalQuat.Rotator();
UpdateBasedRotation(FinalRotation, PawnDeltaRotation.Rotator());
FinalQuat = UpdatedComponent->GetComponentQuat();
}
}
// We need to offset the base of the character here, not its origin, so offset by half height
float HalfHeight, Radius;
CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(Radius, HalfHeight);
FVector const BaseOffset(0.0f, 0.0f, 0.0f);//(0.0f, 0.0f, HalfHeight);
FVector const LocalBasePos = OldLocalToWorld.InverseTransformPosition(UpdatedComponent->GetComponentLocation() - BaseOffset);
FVector const NewWorldPos = ConstrainLocationToPlane(NewLocalToWorld.TransformPosition(LocalBasePos) + BaseOffset);
DeltaPosition = ConstrainDirectionToPlane(NewWorldPos - UpdatedComponent->GetComponentLocation());
// move attached actor
if (bFastAttachedMove)
{
// we're trusting no other obstacle can prevent the move here
UpdatedComponent->SetWorldLocationAndRotation(NewWorldPos, FinalQuat, false);
}
else
{
// hack - transforms between local and world space introducing slight error FIXMESTEVE - discuss with engine team: just skip the transforms if no rotation?
FVector BaseMoveDelta = NewBaseLocation - OldBaseLocation;
if (!bRotationChanged && (BaseMoveDelta.X == 0.f) && (BaseMoveDelta.Y == 0.f))
{
DeltaPosition.X = 0.f;
DeltaPosition.Y = 0.f;
}
FHitResult MoveOnBaseHit(1.f);
const FVector OldLocation = UpdatedComponent->GetComponentLocation();
MoveUpdatedComponent(DeltaPosition, FinalQuat, true, &MoveOnBaseHit);
if ((UpdatedComponent->GetComponentLocation() - (OldLocation + DeltaPosition)).IsNearlyZero() == false)
{
OnUnableToFollowBaseMove(DeltaPosition, OldLocation, MoveOnBaseHit);
}
}
}
if (MovementBase->IsSimulatingPhysics() && CharacterOwner->GetMesh())
{
CharacterOwner->GetMesh()->ApplyDeltaToAllPhysicsTransforms(DeltaPosition, DeltaQuat);
}
}
}
FVector UVRCharacterMovementComponent::GetImpartedMovementBaseVelocity() const
{
FVector Result = FVector::ZeroVector;
if (CharacterOwner)
{
UPrimitiveComponent* MovementBase = CharacterOwner->GetMovementBase();
if (MovementBaseUtility::IsDynamicBase(MovementBase))
{
FVector BaseVelocity = MovementBaseUtility::GetMovementBaseVelocity(MovementBase, CharacterOwner->GetBasedMovement().BoneName);
if (bImpartBaseAngularVelocity)
{
// Base position should be the bottom of the actor since I offset the capsule now
const FVector CharacterBasePosition = (UpdatedComponent->GetComponentLocation()/* - FVector(0.f, 0.f, CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleHalfHeight())*/);
const FVector BaseTangentialVel = MovementBaseUtility::GetMovementBaseTangentialVelocity(MovementBase, CharacterOwner->GetBasedMovement().BoneName, CharacterBasePosition);
BaseVelocity += BaseTangentialVel;
}
if (bImpartBaseVelocityX)
{
Result.X = BaseVelocity.X;
}
if (bImpartBaseVelocityY)
{
Result.Y = BaseVelocity.Y;
}
if (bImpartBaseVelocityZ)
{
Result.Z = BaseVelocity.Z;
}
}
}
return Result;
}
void UVRCharacterMovementComponent::FindFloor(const FVector& CapsuleLocation, FFindFloorResult& OutFloorResult, bool bCanUseCachedLocation, const FHitResult* DownwardSweepResult) const
{
SCOPE_CYCLE_COUNTER(STAT_CharFindFloor);
//UE_LOG(LogVRCharacterMovement, Warning, TEXT("Find Floor"));
// No collision, no floor...
if (!HasValidData() || !UpdatedComponent->IsQueryCollisionEnabled())
{
OutFloorResult.Clear();
return;
}
//UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("[Role:%d] FindFloor: %s at location %s"), (int32)CharacterOwner->Role, *GetNameSafe(CharacterOwner), *CapsuleLocation.ToString());
check(CharacterOwner->GetCapsuleComponent());
FVector UseCapsuleLocation = CapsuleLocation;
if (VRRootCapsule)
UseCapsuleLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
// Increase height check slightly if walking, to prevent floor height adjustment from later invalidating the floor result.
const float HeightCheckAdjust = ((IsMovingOnGround() || IsClimbing()) ? MAX_FLOOR_DIST + KINDA_SMALL_NUMBER : -MAX_FLOOR_DIST);
float FloorSweepTraceDist = FMath::Max(MAX_FLOOR_DIST, MaxStepHeight + HeightCheckAdjust);
float FloorLineTraceDist = FloorSweepTraceDist;
bool bNeedToValidateFloor = true;
// For reverting
FFindFloorResult LastFloor = CurrentFloor;
// Sweep floor
if (FloorLineTraceDist > 0.f || FloorSweepTraceDist > 0.f)
{
UCharacterMovementComponent* MutableThis = const_cast<UCharacterMovementComponent*>((UCharacterMovementComponent*)this);
if (bAlwaysCheckFloor || !bCanUseCachedLocation || bForceNextFloorCheck || bJustTeleported)
{
MutableThis->bForceNextFloorCheck = false;
ComputeFloorDist(UseCapsuleLocation, FloorLineTraceDist, FloorSweepTraceDist, OutFloorResult, CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleRadius(), DownwardSweepResult);
}
else
{
// Force floor check if base has collision disabled or if it does not block us.
UPrimitiveComponent* MovementBase = CharacterOwner->GetMovementBase();
const AActor* BaseActor = MovementBase ? MovementBase->GetOwner() : NULL;
const ECollisionChannel CollisionChannel = UpdatedComponent->GetCollisionObjectType();
if (MovementBase != NULL)
{
MutableThis->bForceNextFloorCheck = !MovementBase->IsQueryCollisionEnabled()
|| MovementBase->GetCollisionResponseToChannel(CollisionChannel) != ECR_Block
|| MovementBaseUtility::IsDynamicBase(MovementBase);
}
const bool IsActorBasePendingKill = BaseActor && BaseActor->IsPendingKill();
if (!bForceNextFloorCheck && !IsActorBasePendingKill && MovementBase)
{
//UE_LOG(LogVRCharacterMovement, Log, TEXT("%s SKIP check for floor"), *CharacterOwner->GetName());
OutFloorResult = CurrentFloor;
bNeedToValidateFloor = false;
}
else
{
MutableThis->bForceNextFloorCheck = false;
ComputeFloorDist(UseCapsuleLocation, FloorLineTraceDist, FloorSweepTraceDist, OutFloorResult, CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleRadius(), DownwardSweepResult);
}
}
}
// #TODO: Modify the floor compute floor distance instead? Or just run movement logic differently for the bWalkingCollisionOverride setup.
// #VR Specific - ignore floor traces that are negative, this can be caused by a failed floor check while starting in penetration
if (VRRootCapsule && VRRootCapsule->bUseWalkingCollisionOverride && OutFloorResult.bBlockingHit && OutFloorResult.FloorDist <= 0.0f)
{
if (OutFloorResult.FloorDist <= -FMath::Max(MAX_FLOOR_DIST, CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleRadius()))
{
// This was a negative trace result, the game wants us to pull out of penetration
// But with walking collision override we don't want to do that, so check for the correct channel and throw away
// the new floor if it matches
ECollisionResponse FloorResponse;
if (OutFloorResult.HitResult.Component.IsValid())
{
FloorResponse = OutFloorResult.HitResult.Component->GetCollisionResponseToChannel(VRRootCapsule->WalkingCollisionOverride);
if (FloorResponse == ECR_Ignore || FloorResponse == ECR_Overlap)
OutFloorResult = LastFloor; // Move back to the last floor value, we are in penetration with a walking override
}
}
}
// OutFloorResult.HitResult is now the result of the vertical floor check.
// See if we should try to "perch" at this location.
if (bNeedToValidateFloor && OutFloorResult.bBlockingHit && !OutFloorResult.bLineTrace)
{
const bool bCheckRadius = true;
if (ShouldComputePerchResult(OutFloorResult.HitResult, bCheckRadius))
{
float MaxPerchFloorDist = FMath::Max(MAX_FLOOR_DIST, MaxStepHeight + HeightCheckAdjust);
if (IsMovingOnGround() || IsClimbing())
{
MaxPerchFloorDist += FMath::Max(0.f, PerchAdditionalHeight);
}
FFindFloorResult PerchFloorResult;
if (ComputePerchResult(GetValidPerchRadius(), OutFloorResult.HitResult, MaxPerchFloorDist, PerchFloorResult))
{
// Don't allow the floor distance adjustment to push us up too high, or we will move beyond the perch distance and fall next time.
const float AvgFloorDist = (MIN_FLOOR_DIST + MAX_FLOOR_DIST) * 0.5f;
const float MoveUpDist = (AvgFloorDist - OutFloorResult.FloorDist);
if (MoveUpDist + PerchFloorResult.FloorDist >= MaxPerchFloorDist)
{
OutFloorResult.FloorDist = AvgFloorDist;
}
// If the regular capsule is on an unwalkable surface but the perched one would allow us to stand, override the normal to be one that is walkable.
if (!OutFloorResult.bWalkableFloor)
{
OutFloorResult.SetFromLineTrace(PerchFloorResult.HitResult, OutFloorResult.FloorDist, FMath::Max(OutFloorResult.FloorDist, MIN_FLOOR_DIST), true);
}
}
else
{
// We had no floor (or an invalid one because it was unwalkable), and couldn't perch here, so invalidate floor (which will cause us to start falling).
OutFloorResult.bWalkableFloor = false;
}
}
}
}
// MOVED TO BASE VR CHARCTER MOVEMENT COMPONENT
// Also added a control variable for it there
/*
bool UVRCharacterMovementComponent::FloorSweepTest(
FHitResult& OutHit,
const FVector& Start,
const FVector& End,
ECollisionChannel TraceChannel,
const struct FCollisionShape& CollisionShape,
const struct FCollisionQueryParams& Params,
const struct FCollisionResponseParams& ResponseParam
) const
{
bool bBlockingHit = false;
if (!bUseFlatBaseForFloorChecks)
{
TArray<FHitResult> OutHits;
GetWorld()->SweepMultiByChannel(OutHits, Start, End, FQuat::Identity, TraceChannel, CollisionShape, Params, ResponseParam);
for (int i = 0; i < OutHits.Num(); i++)
{
if (OutHits[i].bBlockingHit && (OutHits[i].Component.IsValid() && !OutHits[i].Component->IsSimulatingPhysics()))
{
OutHit = OutHits[i];
bBlockingHit = true;
break;
}
}
//bBlockingHit = GetWorld()->SweepSingleByChannel(OutHit, Start, End, FQuat::Identity, TraceChannel, CollisionShape, Params, ResponseParam);
}
else
{
// Test with a box that is enclosed by the capsule.
const float CapsuleRadius = CollisionShape.GetCapsuleRadius();
const float CapsuleHeight = CollisionShape.GetCapsuleHalfHeight();
const FCollisionShape BoxShape = FCollisionShape::MakeBox(FVector(CapsuleRadius * 0.707f, CapsuleRadius * 0.707f, CapsuleHeight));
// First test with the box rotated so the corners are along the major axes (ie rotated 45 degrees).
TArray<FHitResult> OutHits;
GetWorld()->SweepMultiByChannel(OutHits, Start, End, FQuat(FVector(0.f, 0.f, -1.f), PI * 0.25f), TraceChannel, BoxShape, Params, ResponseParam);
for (int i = 0; i < OutHits.Num(); i++)
{
if (OutHits[i].bBlockingHit && (OutHits[i].Component.IsValid() && !OutHits[i].Component->IsSimulatingPhysics()))
{
OutHit = OutHits[i];
bBlockingHit = true;
break;
}
}
//bBlockingHit = GetWorld()->SweepSingleByChannel(OutHit, Start, End, FQuat(FVector(0.f, 0.f, -1.f), PI * 0.25f), TraceChannel, BoxShape, Params, ResponseParam);
if (!bBlockingHit)
{
// Test again with the same box, not rotated.
OutHit.Reset(1.f, false);
OutHits.Reset();
//TArray<FHitResult> OutHits;
GetWorld()->SweepMultiByChannel(OutHits, Start, End, FQuat::Identity, TraceChannel, BoxShape, Params, ResponseParam);
for (int i = 0; i < OutHits.Num(); i++)
{
if (OutHits[i].bBlockingHit && (OutHits[i].Component.IsValid() && !OutHits[i].Component->IsSimulatingPhysics()))
{
OutHit = OutHits[i];
bBlockingHit = true;
break;
}
}
//bBlockingHit = GetWorld()->SweepSingleByChannel(OutHit, Start, End, FQuat::Identity, TraceChannel, BoxShape, Params, ResponseParam);
}
}
return bBlockingHit;
}*/
float UVRCharacterMovementComponent::ImmersionDepth() const
{
float depth = 0.f;
if (CharacterOwner && GetPhysicsVolume()->bWaterVolume)
{
const float CollisionHalfHeight = CharacterOwner->GetSimpleCollisionHalfHeight();
if ((CollisionHalfHeight == 0.f) || (Buoyancy == 0.f))
{
depth = 1.f;
}
else
{
UBrushComponent* VolumeBrushComp = GetPhysicsVolume()->GetBrushComponent();
FHitResult Hit(1.f);
if (VolumeBrushComp)
{
FVector TraceStart;
FVector TraceEnd;
if (VRRootCapsule)
{
TraceStart = VRRootCapsule->OffsetComponentToWorld.GetLocation() + FVector(0.f, 0.f, CollisionHalfHeight);
TraceEnd = VRRootCapsule->OffsetComponentToWorld.GetLocation() - FVector(0.f, 0.f, CollisionHalfHeight);
}
else
{
TraceStart = UpdatedComponent->GetComponentLocation() + FVector(0.f, 0.f, CollisionHalfHeight);
TraceEnd = UpdatedComponent->GetComponentLocation() -FVector(0.f, 0.f, CollisionHalfHeight);
}
FCollisionQueryParams NewTraceParams(CharacterMovementComponentStatics::ImmersionDepthName, true);
VolumeBrushComp->LineTraceComponent(Hit, TraceStart, TraceEnd, NewTraceParams);
}
depth = (Hit.Time == 1.f) ? 1.f : (1.f - Hit.Time);
}
}
return depth;
}
///////////////////////////
// Navigation Functions
///////////////////////////
bool UVRCharacterMovementComponent::TryToLeaveNavWalking()
{
SetNavWalkingPhysics(false);
bool bCanTeleport = true;
if (CharacterOwner)
{
FVector CollisionFreeLocation;
if (VRRootCapsule)
CollisionFreeLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
else
CollisionFreeLocation = UpdatedComponent->GetComponentLocation();
// Think I need to create a custom "FindTeleportSpot" function, it is using ComponentToWorld location
bCanTeleport = GetWorld()->FindTeleportSpot(CharacterOwner, CollisionFreeLocation, UpdatedComponent->GetComponentRotation());
if (bCanTeleport)
{
if (VRRootCapsule)
{
// Technically the same actor but i am keepign the usage convention for clarity.
// Subtracting actor location from capsule to get difference in worldspace, then removing from collision free location
// So that it uses the correct location.
CharacterOwner->SetActorLocation(CollisionFreeLocation - (VRRootCapsule->OffsetComponentToWorld.GetLocation() - UpdatedComponent->GetComponentLocation()));
}
else
CharacterOwner->SetActorLocation(CollisionFreeLocation);
}
else
{
SetNavWalkingPhysics(true);
}
}
bWantsToLeaveNavWalking = !bCanTeleport;
return bCanTeleport;
}
void UVRCharacterMovementComponent::PhysFlying(float deltaTime, int32 Iterations)
{
if (deltaTime < MIN_TICK_TIME)
{
return;
}
// Rewind the players position by the new capsule location
RewindVRRelativeMovement();
RestorePreAdditiveRootMotionVelocity();
//RestorePreAdditiveVRMotionVelocity();
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
if (bCheatFlying && Acceleration.IsZero())
{
Velocity = FVector::ZeroVector;
}
const float Friction = 0.5f * GetPhysicsVolume()->FluidFriction;
CalcVelocity(deltaTime, Friction, true, GetMaxBrakingDeceleration());
}
ApplyRootMotionToVelocity(deltaTime);
//ApplyVRMotionToVelocity(deltaTime);
// Manually handle the velocity setup
LastPreAdditiveVRVelocity = (AdditionalVRInputVector) / deltaTime;
bool bExtremeInput = false;
if (LastPreAdditiveVRVelocity.SizeSquared() > FMath::Square(TrackingLossThreshold))
{
// Default to always holding position during flight to avoid too much velocity injection
AdditionalVRInputVector = FVector::ZeroVector;
LastPreAdditiveVRVelocity = FVector::ZeroVector;
}
Iterations++;
bJustTeleported = false;
FVector OldLocation = UpdatedComponent->GetComponentLocation();
const FVector Adjusted = Velocity * deltaTime;
FHitResult Hit(1.f);
SafeMoveUpdatedComponent(Adjusted + AdditionalVRInputVector, UpdatedComponent->GetComponentQuat(), true, Hit);
if (Hit.Time < 1.f)
{
const FVector GravDir = FVector(0.f, 0.f, -1.f);
const FVector VelDir = Velocity.GetSafeNormal();
const float UpDown = GravDir | VelDir;
bool bSteppedUp = false;
if ((FMath::Abs(Hit.ImpactNormal.Z) < 0.2f) && (UpDown < 0.5f) && (UpDown > -0.2f) && CanStepUp(Hit))
{
float stepZ = UpdatedComponent->GetComponentLocation().Z;
bSteppedUp = StepUp(GravDir, (Adjusted + AdditionalVRInputVector) * (1.f - Hit.Time) /*+ AdditionalVRInputVector.GetSafeNormal2D()*/, Hit, nullptr);
if (bSteppedUp)
{
OldLocation.Z = UpdatedComponent->GetComponentLocation().Z + (OldLocation.Z - stepZ);
}
}
if (!bSteppedUp)
{
//adjust and try again
HandleImpact(Hit, deltaTime, Adjusted);
SlideAlongSurface(Adjusted, (1.f - Hit.Time), Hit.Normal, Hit, true);
}
}
if (!bJustTeleported)
{
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
//Velocity = ((UpdatedComponent->GetComponentLocation() - OldLocation) - AdditionalVRInputVector) / deltaTime;
Velocity = ((UpdatedComponent->GetComponentLocation() - OldLocation)) / deltaTime;
}
RestorePreAdditiveVRMotionVelocity();
}
}
void UVRCharacterMovementComponent::PhysFalling(float deltaTime, int32 Iterations)
{
SCOPE_CYCLE_COUNTER(STAT_CharPhysFalling);
if (deltaTime < MIN_TICK_TIME)
{
return;
}
FVector FallAcceleration = GetFallingLateralAcceleration(deltaTime);
FallAcceleration.Z = 0.f;
const bool bHasLimitedAirControl = ShouldLimitAirControl(deltaTime, FallAcceleration);
// Rewind the players position by the new capsule location
RewindVRRelativeMovement();
float remainingTime = deltaTime;
while ((remainingTime >= MIN_TICK_TIME) && (Iterations < MaxSimulationIterations))
{
Iterations++;
float timeTick = GetSimulationTimeStep(remainingTime, Iterations);
remainingTime -= timeTick;
const FVector OldLocation = UpdatedComponent->GetComponentLocation();
const FVector OldCapsuleLocation = VRRootCapsule ? VRRootCapsule->OffsetComponentToWorld.GetLocation() : OldLocation;
const FQuat PawnRotation = UpdatedComponent->GetComponentQuat();
bJustTeleported = false;
RestorePreAdditiveRootMotionVelocity();
RestorePreAdditiveVRMotionVelocity();
const FVector OldVelocity = Velocity;
// Apply input
const float MaxDecel = GetMaxBrakingDeceleration();
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
// Compute Velocity
{
// Acceleration = FallAcceleration for CalcVelocity(), but we restore it after using it.
TGuardValue<FVector> RestoreAcceleration(Acceleration, FallAcceleration);
Velocity.Z = 0.f;
CalcVelocity(timeTick, FallingLateralFriction, false, BrakingDecelerationFalling);
Velocity.Z = OldVelocity.Z;
}
}
//Velocity += CustomVRInputVector / deltaTime;
// Compute current gravity
const FVector Gravity(0.f, 0.f, GetGravityZ());
float GravityTime = timeTick;
// If jump is providing force, gravity may be affected.
bool bEndingJumpForce = false;
if (CharacterOwner->JumpForceTimeRemaining > 0.0f)
{
// Consume some of the force time. Only the remaining time (if any) is affected by gravity when bApplyGravityWhileJumping=false.
const float JumpForceTime = FMath::Min(CharacterOwner->JumpForceTimeRemaining, timeTick);
GravityTime = bApplyGravityWhileJumping ? timeTick : FMath::Max(0.0f, timeTick - JumpForceTime);
// Update Character state
CharacterOwner->JumpForceTimeRemaining -= JumpForceTime;
if (CharacterOwner->JumpForceTimeRemaining <= 0.0f)
{
CharacterOwner->ResetJumpState();
bEndingJumpForce = true;
}
}
// Apply gravity
Velocity = NewFallVelocity(Velocity, Gravity, GravityTime);
// See if we need to sub-step to exactly reach the apex. This is important for avoiding "cutting off the top" of the trajectory as framerate varies.
static const auto CVarForceJumpPeakSubstep = IConsoleManager::Get().FindConsoleVariable(TEXT("p.ForceJumpPeakSubstep"));
if (CVarForceJumpPeakSubstep->GetInt() != 0 && OldVelocity.Z > 0.f && Velocity.Z <= 0.f && NumJumpApexAttempts < MaxJumpApexAttemptsPerSimulation)
{
const FVector DerivedAccel = (Velocity - OldVelocity) / timeTick;
if (!FMath::IsNearlyZero(DerivedAccel.Z))
{
const float TimeToApex = -OldVelocity.Z / DerivedAccel.Z;
// The time-to-apex calculation should be precise, and we want to avoid adding a substep when we are basically already at the apex from the previous iteration's work.
const float ApexTimeMinimum = 0.0001f;
if (TimeToApex >= ApexTimeMinimum && TimeToApex < timeTick)
{
const FVector ApexVelocity = OldVelocity + DerivedAccel * TimeToApex;
Velocity = ApexVelocity;
Velocity.Z = 0.f; // Should be nearly zero anyway, but this makes apex notifications consistent.
// We only want to move the amount of time it takes to reach the apex, and refund the unused time for next iteration.
remainingTime += (timeTick - TimeToApex);
timeTick = TimeToApex;
Iterations--;
NumJumpApexAttempts++;
}
}
}
//UE_LOG(LogCharacterMovement, Log, TEXT("dt=(%.6f) OldLocation=(%s) OldVelocity=(%s) NewVelocity=(%s)"), timeTick, *(UpdatedComponent->GetComponentLocation()).ToString(), *OldVelocity.ToString(), *Velocity.ToString());
ApplyRootMotionToVelocity(timeTick);
ApplyVRMotionToVelocity(deltaTime);
if (bNotifyApex && (Velocity.Z < 0.f))
{
// Just passed jump apex since now going down
bNotifyApex = false;
NotifyJumpApex();
}
// Compute change in position (using midpoint integration method).
FVector Adjusted = (0.5f * (OldVelocity + Velocity) * timeTick) /*+ ((AdditionalVRInputVector / deltaTime) * timeTick)*/;
// Special handling if ending the jump force where we didn't apply gravity during the jump.
if (bEndingJumpForce && !bApplyGravityWhileJumping)
{
// We had a portion of the time at constant speed then a portion with acceleration due to gravity.
// Account for that here with a more correct change in position.
const float NonGravityTime = FMath::Max(0.f, timeTick - GravityTime);
Adjusted = ((OldVelocity * NonGravityTime) + (0.5f * (OldVelocity + Velocity) * GravityTime)) /*+ ((AdditionalVRInputVector / deltaTime) * timeTick)*/;
}
// Move
FHitResult Hit(1.f);
SafeMoveUpdatedComponent(Adjusted, PawnRotation, true, Hit);
if (!HasValidData())
{
return;
}
float LastMoveTimeSlice = timeTick;
float subTimeTickRemaining = timeTick * (1.f - Hit.Time);
if (IsSwimming()) //just entered water
{
remainingTime += subTimeTickRemaining;
StartSwimmingVR(OldCapsuleLocation, OldVelocity, timeTick, remainingTime, Iterations);
return;
}
else if (Hit.bBlockingHit)
{
if (IsValidLandingSpot(VRRootCapsule->OffsetComponentToWorld.GetLocation()/*UpdatedComponent->GetComponentLocation()*/, Hit))
{
remainingTime += subTimeTickRemaining;
ProcessLanded(Hit, remainingTime, Iterations);
return;
}
else
{
// Compute impact deflection based on final velocity, not integration step.
// This allows us to compute a new velocity from the deflected vector, and ensures the full gravity effect is included in the slide result.
Adjusted = Velocity * timeTick;
// See if we can convert a normally invalid landing spot (based on the hit result) to a usable one.
if (!Hit.bStartPenetrating && ShouldCheckForValidLandingSpot(timeTick, Adjusted, Hit))
{
/*const */FVector PawnLocation = UpdatedComponent->GetComponentLocation();
if (VRRootCapsule)
PawnLocation = VRRootCapsule->OffsetComponentToWorld.GetLocation();
FFindFloorResult FloorResult;
FindFloor(PawnLocation, FloorResult, false, NULL);
if (FloorResult.IsWalkableFloor() && IsValidLandingSpot(PawnLocation, FloorResult.HitResult))
{
remainingTime += subTimeTickRemaining;
ProcessLanded(FloorResult.HitResult, remainingTime, Iterations);
return;
}
}
HandleImpact(Hit, LastMoveTimeSlice, Adjusted);
// If we've changed physics mode, abort.
if (!HasValidData() || !IsFalling())
{
return;
}
// Limit air control based on what we hit.
// We moved to the impact point using air control, but may want to deflect from there based on a limited air control acceleration.
FVector VelocityNoAirControl = OldVelocity;
FVector AirControlAccel = Acceleration;
if (bHasLimitedAirControl)
{
// Compute VelocityNoAirControl
{
// Find velocity *without* acceleration.
TGuardValue<FVector> RestoreAcceleration(Acceleration, FVector::ZeroVector);
TGuardValue<FVector> RestoreVelocity(Velocity, OldVelocity);
Velocity.Z = 0.f;
CalcVelocity(timeTick, FallingLateralFriction, false, MaxDecel);
VelocityNoAirControl = FVector(Velocity.X, Velocity.Y, OldVelocity.Z);
VelocityNoAirControl = NewFallVelocity(VelocityNoAirControl, Gravity, GravityTime);
}
const bool bCheckLandingSpot = false; // we already checked above.
AirControlAccel = (Velocity - VelocityNoAirControl) / timeTick;
const FVector AirControlDeltaV = LimitAirControl(LastMoveTimeSlice, AirControlAccel, Hit, bCheckLandingSpot) * LastMoveTimeSlice;
Adjusted = (VelocityNoAirControl + AirControlDeltaV) * LastMoveTimeSlice;
}
const FVector OldHitNormal = Hit.Normal;
const FVector OldHitImpactNormal = Hit.ImpactNormal;
FVector Delta = ComputeSlideVector(Adjusted, 1.f - Hit.Time, OldHitNormal, Hit);
// Compute velocity after deflection (only gravity component for RootMotion)
if (subTimeTickRemaining > KINDA_SMALL_NUMBER && !bJustTeleported)
{
const FVector NewVelocity = (Delta / subTimeTickRemaining);
Velocity = HasAnimRootMotion() || CurrentRootMotion.HasOverrideVelocityWithIgnoreZAccumulate() ? FVector(Velocity.X, Velocity.Y, NewVelocity.Z) : NewVelocity;
}
if (subTimeTickRemaining > KINDA_SMALL_NUMBER && (Delta | Adjusted) > 0.f)
{
// Move in deflected direction.
SafeMoveUpdatedComponent(Delta, PawnRotation, true, Hit);
if (Hit.bBlockingHit)
{
// hit second wall
LastMoveTimeSlice = subTimeTickRemaining;
subTimeTickRemaining = subTimeTickRemaining * (1.f - Hit.Time);
if (IsValidLandingSpot(VRRootCapsule->OffsetComponentToWorld.GetLocation()/*UpdatedComponent->GetComponentLocation()*/, Hit))
{
remainingTime += subTimeTickRemaining;
ProcessLanded(Hit, remainingTime, Iterations);
return;
}
HandleImpact(Hit, LastMoveTimeSlice, Delta);
// If we've changed physics mode, abort.
if (!HasValidData() || !IsFalling())
{
return;
}
// Act as if there was no air control on the last move when computing new deflection.
if (bHasLimitedAirControl && Hit.Normal.Z > VERTICAL_SLOPE_NORMAL_Z)
{
const FVector LastMoveNoAirControl = VelocityNoAirControl * LastMoveTimeSlice;
Delta = ComputeSlideVector(LastMoveNoAirControl, 1.f, OldHitNormal, Hit);
}
FVector PreTwoWallDelta = Delta;
TwoWallAdjust(Delta, Hit, OldHitNormal);
// Limit air control, but allow a slide along the second wall.
if (bHasLimitedAirControl)
{
const bool bCheckLandingSpot = false; // we already checked above.
const FVector AirControlDeltaV = LimitAirControl(subTimeTickRemaining, AirControlAccel, Hit, bCheckLandingSpot) * subTimeTickRemaining;
// Only allow if not back in to first wall
if (FVector::DotProduct(AirControlDeltaV, OldHitNormal) > 0.f)
{
Delta += (AirControlDeltaV * subTimeTickRemaining);
}
}
// Compute velocity after deflection (only gravity component for RootMotion)
if (subTimeTickRemaining > KINDA_SMALL_NUMBER && !bJustTeleported)
{
const FVector NewVelocity = (Delta / subTimeTickRemaining);
Velocity = HasAnimRootMotion() || CurrentRootMotion.HasOverrideVelocityWithIgnoreZAccumulate() ? FVector(Velocity.X, Velocity.Y, NewVelocity.Z) : NewVelocity;
}
// bDitch=true means that pawn is straddling two slopes, neither of which he can stand on
bool bDitch = ((OldHitImpactNormal.Z > 0.f) && (Hit.ImpactNormal.Z > 0.f) && (FMath::Abs(Delta.Z) <= KINDA_SMALL_NUMBER) && ((Hit.ImpactNormal | OldHitImpactNormal) < 0.f));
SafeMoveUpdatedComponent(Delta, PawnRotation, true, Hit);
if (Hit.Time == 0.f)
{
// if we are stuck then try to side step
FVector SideDelta = (OldHitNormal + Hit.ImpactNormal).GetSafeNormal2D();
if (SideDelta.IsNearlyZero())
{
SideDelta = FVector(OldHitNormal.Y, -OldHitNormal.X, 0).GetSafeNormal();
}
SafeMoveUpdatedComponent(SideDelta, PawnRotation, true, Hit);
}
if (bDitch || IsValidLandingSpot(VRRootCapsule->OffsetComponentToWorld.GetLocation()/*UpdatedComponent->GetComponentLocation()*/, Hit) || Hit.Time == 0.f)
{
remainingTime = 0.f;
ProcessLanded(Hit, remainingTime, Iterations);
return;
}
else if (GetPerchRadiusThreshold() > 0.f && Hit.Time == 1.f && OldHitImpactNormal.Z >= GetWalkableFloorZ())
{
// We might be in a virtual 'ditch' within our perch radius. This is rare.
const FVector PawnLocation = UpdatedComponent->GetComponentLocation();
const float ZMovedDist = FMath::Abs(PawnLocation.Z - OldLocation.Z);
const float MovedDist2DSq = (PawnLocation - OldLocation).SizeSquared2D();
if (ZMovedDist <= 0.2f * timeTick && MovedDist2DSq <= 4.f * timeTick)
{
Velocity.X += 0.25f * GetMaxSpeed() * (RandomStream.FRand() - 0.5f);
Velocity.Y += 0.25f * GetMaxSpeed() * (RandomStream.FRand() - 0.5f);
Velocity.Z = FMath::Max<float>(JumpZVelocity * 0.25f, 1.f);
Delta = Velocity * timeTick;
SafeMoveUpdatedComponent(Delta, PawnRotation, true, Hit);
}
}
}
}
}
}
else
{
// We are finding the floor and adjusting here now
// This matches the final falling Z up to the PhysWalking floor offset to prevent the visible hitch when going
// From falling to walking.
FindFloor(UpdatedComponent->GetComponentLocation(), CurrentFloor, false, NULL);
if (CurrentFloor.IsWalkableFloor())
{
// If the current floor distance is within the physwalking required floor offset
if (CurrentFloor.GetDistanceToFloor() < (MIN_FLOOR_DIST + MAX_FLOOR_DIST) / 2)
{
// Adjust to correct height
AdjustFloorHeight();
SetBase(CurrentFloor.HitResult.Component.Get(), CurrentFloor.HitResult.BoneName);
// If this is a valid landing spot, stop falling now so that we land correctly
if (IsValidLandingSpot(VRRootCapsule->OffsetComponentToWorld.GetLocation()/*UpdatedComponent->GetComponentLocation()*/, CurrentFloor.HitResult))
{
remainingTime += subTimeTickRemaining;
ProcessLanded(CurrentFloor.HitResult, remainingTime, Iterations);
return;
}
}
}
else if (CurrentFloor.HitResult.bStartPenetrating)
{
// The floor check failed because it started in penetration
// We do not want to try to move downward because the downward sweep failed, rather we'd like to try to pop out of the floor.
FHitResult Hitt(CurrentFloor.HitResult);
Hit.TraceEnd = Hit.TraceStart + FVector(0.f, 0.f, MAX_FLOOR_DIST);
const FVector RequestedAdjustment = GetPenetrationAdjustment(Hit);
ResolvePenetration(RequestedAdjustment, Hitt, UpdatedComponent->GetComponentQuat());
bForceNextFloorCheck = true;
}
}
if (Velocity.SizeSquared2D() <= KINDA_SMALL_NUMBER * 10.f)
{
Velocity.X = 0.f;
Velocity.Y = 0.f;
}
}
}
void UVRCharacterMovementComponent::PhysNavWalking(float deltaTime, int32 Iterations)
{
SCOPE_CYCLE_COUNTER(STAT_CharPhysNavWalking);
if (deltaTime < MIN_TICK_TIME)
{
return;
}
// Root motion not for VR
if ((!CharacterOwner || !CharacterOwner->Controller) && !bRunPhysicsWithNoController && !HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
Acceleration = FVector::ZeroVector;
Velocity = FVector::ZeroVector;
return;
}
// Rewind the players position by the new capsule location
RewindVRRelativeMovement();
RestorePreAdditiveRootMotionVelocity();
//RestorePreAdditiveVRMotionVelocity();
// Ensure velocity is horizontal.
MaintainHorizontalGroundVelocity();
devCode(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysNavWalking: Velocity contains NaN before CalcVelocity (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
//bound acceleration
Acceleration.Z = 0.f;
//if (!HasRootMotion())
//{
CalcVelocity(deltaTime, GroundFriction, false, BrakingDecelerationWalking);
devCode(ensureMsgf(!Velocity.ContainsNaN(), TEXT("PhysNavWalking: Velocity contains NaN after CalcVelocity (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
//}
ApplyRootMotionToVelocity(deltaTime);
ApplyVRMotionToVelocity(deltaTime);
/*if (IsFalling())
{
// Root motion could have put us into Falling
StartNewPhysics(deltaTime, Iterations);
return;
}*/
Iterations++;
FVector DesiredMove = Velocity;
DesiredMove.Z = 0.f;
//const FVector OldPlayerLocation = GetActorFeetLocation();
const FVector OldLocation = GetActorFeetLocationVR();
const FVector DeltaMove = DesiredMove * deltaTime;
const bool bDeltaMoveNearlyZero = DeltaMove.IsNearlyZero();
FVector AdjustedDest = OldLocation + DeltaMove;
FNavLocation DestNavLocation;
bool bSameNavLocation = false;
if (CachedNavLocation.NodeRef != INVALID_NAVNODEREF)
{
if (bProjectNavMeshWalking)
{
const float DistSq2D = (OldLocation - CachedNavLocation.Location).SizeSquared2D();
const float DistZ = FMath::Abs(OldLocation.Z - CachedNavLocation.Location.Z);
const float TotalCapsuleHeight = CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleHalfHeight() * 2.0f;
const float ProjectionScale = (OldLocation.Z > CachedNavLocation.Location.Z) ? NavMeshProjectionHeightScaleUp : NavMeshProjectionHeightScaleDown;
const float DistZThr = TotalCapsuleHeight * FMath::Max(0.f, ProjectionScale);
bSameNavLocation = (DistSq2D <= KINDA_SMALL_NUMBER) && (DistZ < DistZThr);
}
else
{
bSameNavLocation = CachedNavLocation.Location.Equals(OldLocation);
}
if (bDeltaMoveNearlyZero && bSameNavLocation)
{
if (const INavigationDataInterface * NavData = GetNavData())
{
if (!NavData->IsNodeRefValid(CachedNavLocation.NodeRef))
{
CachedNavLocation.NodeRef = INVALID_NAVNODEREF;
bSameNavLocation = false;
}
}
}
}
if (bDeltaMoveNearlyZero && bSameNavLocation)
{
DestNavLocation = CachedNavLocation;
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("%s using cached navmesh location! (bProjectNavMeshWalking = %d)"), *GetNameSafe(CharacterOwner), bProjectNavMeshWalking);
}
else
{
SCOPE_CYCLE_COUNTER(STAT_CharNavProjectPoint);
// Start the trace from the Z location of the last valid trace.
// Otherwise if we are projecting our location to the underlying geometry and it's far above or below the navmesh,
// we'll follow that geometry's plane out of range of valid navigation.
if (bSameNavLocation && bProjectNavMeshWalking)
{
AdjustedDest.Z = CachedNavLocation.Location.Z;
}
// Find the point on the NavMesh
const bool bHasNavigationData = FindNavFloor(AdjustedDest, DestNavLocation);
if (!bHasNavigationData)
{
RestorePreAdditiveVRMotionVelocity();
SetMovementMode(MOVE_Walking);
return;
}
CachedNavLocation = DestNavLocation;
}
if (DestNavLocation.NodeRef != INVALID_NAVNODEREF)
{
FVector NewLocation(AdjustedDest.X, AdjustedDest.Y, DestNavLocation.Location.Z);
if (bProjectNavMeshWalking)
{
SCOPE_CYCLE_COUNTER(STAT_CharNavProjectLocation);
const float TotalCapsuleHeight = CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleHalfHeight() * 2.0f;
const float UpOffset = TotalCapsuleHeight * FMath::Max(0.f, NavMeshProjectionHeightScaleUp);
const float DownOffset = TotalCapsuleHeight * FMath::Max(0.f, NavMeshProjectionHeightScaleDown);
NewLocation = ProjectLocationFromNavMesh(deltaTime, OldLocation, NewLocation, UpOffset, DownOffset);
}
FVector AdjustedDelta = NewLocation - OldLocation;
if (!AdjustedDelta.IsNearlyZero())
{
// 4.16 UNCOMMENT
FHitResult HitResult;
SafeMoveUpdatedComponent(AdjustedDelta, UpdatedComponent->GetComponentQuat(), bSweepWhileNavWalking, HitResult);
/* 4.16 Delete*/
//const bool bSweep = UpdatedPrimitive ? UpdatedPrimitive->bGenerateOverlapEvents : false;
//FHitResult HitResult;
//SafeMoveUpdatedComponent(AdjustedDelta, UpdatedComponent->GetComponentQuat(), bSweep, HitResult);
// End 4.16 delete
}
// Update velocity to reflect actual move
if (!bJustTeleported && !HasAnimRootMotion() && !CurrentRootMotion.HasVelocity())
{
Velocity = (GetActorFeetLocationVR() - OldLocation) / deltaTime;
MaintainHorizontalGroundVelocity();
}
bJustTeleported = false;
}
else
{
StartFalling(Iterations, deltaTime, deltaTime, DeltaMove, OldLocation);
}
RestorePreAdditiveVRMotionVelocity();
}
void UVRCharacterMovementComponent::PhysSwimming(float deltaTime, int32 Iterations)
{
if (deltaTime < MIN_TICK_TIME)
{
return;
}
// Rewind the players position by the new capsule location
RewindVRRelativeMovement();
RestorePreAdditiveRootMotionVelocity();
float NetFluidFriction = 0.f;
float Depth = ImmersionDepth();
float NetBuoyancy = Buoyancy * Depth;
float OriginalAccelZ = Acceleration.Z;
bool bLimitedUpAccel = false;
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && (Velocity.Z > 0.33f * MaxSwimSpeed) && (NetBuoyancy != 0.f))
{
//damp positive Z out of water
Velocity.Z = FMath::Max(0.33f * MaxSwimSpeed, Velocity.Z * Depth*Depth);
}
else if (Depth < 0.65f)
{
bLimitedUpAccel = (Acceleration.Z > 0.f);
Acceleration.Z = FMath::Min(0.1f, Acceleration.Z);
}
Iterations++;
FVector OldLocation = UpdatedComponent->GetComponentLocation();
bJustTeleported = false;
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
const float Friction = 0.5f * GetPhysicsVolume()->FluidFriction * Depth;
CalcVelocity(deltaTime, Friction, true, GetMaxBrakingDeceleration());
Velocity.Z += GetGravityZ() * deltaTime * (1.f - NetBuoyancy);
}
ApplyRootMotionToVelocity(deltaTime);
FVector Adjusted = Velocity * deltaTime;
FHitResult Hit(1.f);
float remainingTime = deltaTime * SwimVR(Adjusted + AdditionalVRInputVector, Hit);
//may have left water - if so, script might have set new physics mode
if (!IsSwimming())
{
StartNewPhysics(remainingTime, Iterations);
return;
}
if (Hit.Time < 1.f && CharacterOwner)
{
HandleSwimmingWallHit(Hit, deltaTime);
if (bLimitedUpAccel && (Velocity.Z >= 0.f))
{
// allow upward velocity at surface if against obstacle
Velocity.Z += OriginalAccelZ * deltaTime;
Adjusted = Velocity * (1.f - Hit.Time)*deltaTime;
SwimVR(Adjusted, Hit);
if (!IsSwimming())
{
StartNewPhysics(remainingTime, Iterations);
return;
}
}
const FVector GravDir = FVector(0.f, 0.f, -1.f);
const FVector VelDir = Velocity.GetSafeNormal();
const float UpDown = GravDir | VelDir;
bool bSteppedUp = false;
if ((FMath::Abs(Hit.ImpactNormal.Z) < 0.2f) && (UpDown < 0.5f) && (UpDown > -0.2f) && CanStepUp(Hit))
{
float stepZ = UpdatedComponent->GetComponentLocation().Z;
const FVector RealVelocity = Velocity;
Velocity.Z = 1.f; // HACK: since will be moving up, in case pawn leaves the water
bSteppedUp = StepUp(GravDir, (Adjusted + AdditionalVRInputVector) * (1.f - Hit.Time), Hit);
if (bSteppedUp)
{
//may have left water - if so, script might have set new physics mode
if (!IsSwimming())
{
StartNewPhysics(remainingTime, Iterations);
return;
}
OldLocation.Z = UpdatedComponent->GetComponentLocation().Z + (OldLocation.Z - stepZ);
}
Velocity = RealVelocity;
}
if (!bSteppedUp)
{
//adjust and try again
HandleImpact(Hit, deltaTime, Adjusted);
SlideAlongSurface(Adjusted, (1.f - Hit.Time), Hit.Normal, Hit, true);
}
}
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && !bJustTeleported && ((deltaTime - remainingTime) > KINDA_SMALL_NUMBER) && CharacterOwner)
{
bool bWaterJump = !GetPhysicsVolume()->bWaterVolume;
float velZ = Velocity.Z;
Velocity = ((UpdatedComponent->GetComponentLocation() - OldLocation) - AdditionalVRInputVector) / (deltaTime - remainingTime);
if (bWaterJump)
{
Velocity.Z = velZ;
}
}
if (!GetPhysicsVolume()->bWaterVolume && IsSwimming())
{
SetMovementMode(MOVE_Falling); //in case script didn't change it (w/ zone change)
}
//may have left water - if so, script might have set new physics mode
if (!IsSwimming())
{
StartNewPhysics(remainingTime, Iterations);
}
}
void UVRCharacterMovementComponent::StartSwimmingVR(FVector OldLocation, FVector OldVelocity, float timeTick, float remainingTime, int32 Iterations)
{
if (remainingTime < MIN_TICK_TIME || timeTick < MIN_TICK_TIME)
{
return;
}
FVector NewLocation = VRRootCapsule ? VRRootCapsule->OffsetComponentToWorld.GetLocation() : UpdatedComponent->GetComponentLocation();
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && !bJustTeleported)
{
Velocity = (NewLocation - OldLocation) / timeTick; //actual average velocity
Velocity = 2.f*Velocity - OldVelocity; //end velocity has 2* accel of avg
Velocity = Velocity.GetClampedToMaxSize(GetPhysicsVolume()->TerminalVelocity);
}
const FVector End = FindWaterLine(NewLocation, OldLocation);
float waterTime = 0.f;
if (End != NewLocation)
{
const float ActualDist = (NewLocation - OldLocation).Size();
if (ActualDist > KINDA_SMALL_NUMBER)
{
waterTime = timeTick * (End - NewLocation).Size() / ActualDist;
remainingTime += waterTime;
}
MoveUpdatedComponent(End - NewLocation, UpdatedComponent->GetComponentQuat(), true);
}
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity() && (Velocity.Z > 2.f*SWIMBOBSPEED) && (Velocity.Z < 0.f)) //allow for falling out of water
{
Velocity.Z = SWIMBOBSPEED - Velocity.Size2D() * 0.7f; //smooth bobbing
}
if ((remainingTime >= MIN_TICK_TIME) && (Iterations < MaxSimulationIterations))
{
PhysSwimming(remainingTime, Iterations);
}
}
float UVRCharacterMovementComponent::SwimVR(FVector Delta, FHitResult& Hit)
{
FVector Start = VRRootCapsule ? VRRootCapsule->OffsetComponentToWorld.GetLocation() : UpdatedComponent->GetComponentLocation();
float airTime = 0.f;
SafeMoveUpdatedComponent(Delta, UpdatedComponent->GetComponentQuat(), true, Hit);
if (!GetPhysicsVolume()->bWaterVolume) //then left water
{
FVector NewLoc = VRRootCapsule ? VRRootCapsule->OffsetComponentToWorld.GetLocation() : UpdatedComponent->GetComponentLocation();
const FVector End = FindWaterLine(Start, NewLoc);
const float DesiredDist = Delta.Size();
if (End != NewLoc && DesiredDist > KINDA_SMALL_NUMBER)
{
airTime = (End - NewLoc).Size() / DesiredDist;
if (((NewLoc - Start) | (End - NewLoc)) > 0.f)
{
airTime = 0.f;
}
SafeMoveUpdatedComponent(End - NewLoc, UpdatedComponent->GetComponentQuat(), true, Hit);
}
}
return airTime;
}
bool UVRCharacterMovementComponent::CheckWaterJump(FVector CheckPoint, FVector& WallNormal)
{
if (!HasValidData())
{
return false;
}
FVector currentLoc = VRRootCapsule ? VRRootCapsule->OffsetComponentToWorld.GetLocation() : UpdatedComponent->GetComponentLocation();
// check if there is a wall directly in front of the swimming pawn
CheckPoint.Z = 0.f;
FVector CheckNorm = CheckPoint.GetSafeNormal();
float PawnCapsuleRadius, PawnCapsuleHalfHeight;
CharacterOwner->GetCapsuleComponent()->GetScaledCapsuleSize(PawnCapsuleRadius, PawnCapsuleHalfHeight);
CheckPoint = currentLoc + 1.2f * PawnCapsuleRadius * CheckNorm;
FVector Extent(PawnCapsuleRadius, PawnCapsuleRadius, PawnCapsuleHalfHeight);
FHitResult HitInfo(1.f);
FCollisionQueryParams CapsuleParams(SCENE_QUERY_STAT(CheckWaterJump), false, CharacterOwner);
FCollisionResponseParams ResponseParam;
InitCollisionParams(CapsuleParams, ResponseParam);
FCollisionShape CapsuleShape = GetPawnCapsuleCollisionShape(SHRINK_None);
const ECollisionChannel CollisionChannel = UpdatedComponent->GetCollisionObjectType();
bool bHit = GetWorld()->SweepSingleByChannel(HitInfo, currentLoc, CheckPoint, FQuat::Identity, CollisionChannel, CapsuleShape, CapsuleParams, ResponseParam);
if (bHit && !Cast<APawn>(HitInfo.GetActor()))
{
// hit a wall - check if it is low enough
WallNormal = -1.f * HitInfo.ImpactNormal;
FVector Start = currentLoc;//UpdatedComponent->GetComponentLocation();
Start.Z += MaxOutOfWaterStepHeight;
CheckPoint = Start + 3.2f * PawnCapsuleRadius * WallNormal;
FCollisionQueryParams LineParams(SCENE_QUERY_STAT(CheckWaterJump), true, CharacterOwner);
FCollisionResponseParams LineResponseParam;
InitCollisionParams(LineParams, LineResponseParam);
bHit = GetWorld()->LineTraceSingleByChannel(HitInfo, Start, CheckPoint, CollisionChannel, LineParams, LineResponseParam);
// if no high obstruction, or it's a valid floor, then pawn can jump out of water
return !bHit || IsWalkable(HitInfo);
}
return false;
}
FBasedPosition UVRCharacterMovementComponent::GetActorFeetLocationBased() const
{
return FBasedPosition(NULL, GetActorFeetLocationVR());
}
void UVRCharacterMovementComponent::ProcessLanded(const FHitResult& Hit, float remainingTime, int32 Iterations)
{
SCOPE_CYCLE_COUNTER(STAT_CharProcessLanded);
if (CharacterOwner && CharacterOwner->ShouldNotifyLanded(Hit))
{
CharacterOwner->Landed(Hit);
}
if (IsFalling())
{
if (GetGroundMovementMode() == MOVE_NavWalking)
{
// verify navmesh projection and current floor
// otherwise movement will be stuck in infinite loop:
// navwalking -> (no navmesh) -> falling -> (standing on something) -> navwalking -> ....
const FVector TestLocation = GetActorFeetLocationVR();
FNavLocation NavLocation;
const bool bHasNavigationData = FindNavFloor(TestLocation, NavLocation);
if (!bHasNavigationData || NavLocation.NodeRef == INVALID_NAVNODEREF)
{
SetGroundMovementMode(MOVE_Walking);
//GroundMovementMode = MOVE_Walking;
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("ProcessLanded(): %s tried to go to NavWalking but couldn't find NavMesh! Using Walking instead."), *GetNameSafe(CharacterOwner));
}
}
SetPostLandedPhysics(Hit);
}
IPathFollowingAgentInterface* PFAgent = GetPathFollowingAgent();
if (PFAgent)
{
PFAgent->OnLanded();
}
StartNewPhysics(remainingTime, Iterations);
}
///////////////////////////
// End Navigation Functions
///////////////////////////
void UVRCharacterMovementComponent::PostPhysicsTickComponent(float DeltaTime, FCharacterMovementComponentPostPhysicsTickFunction& ThisTickFunction)
{
if (bDeferUpdateBasedMovement)
{
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
UpdateBasedMovement(DeltaTime);
SaveBaseLocation();
bDeferUpdateBasedMovement = false;
}
}
void UVRCharacterMovementComponent::SimulateMovement(float DeltaSeconds)
{
if (!HasValidData() || UpdatedComponent->Mobility != EComponentMobility::Movable || UpdatedComponent->IsSimulatingPhysics())
{
return;
}
const bool bIsSimulatedProxy = (CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy);
const FRepMovement& ConstRepMovement = CharacterOwner->GetReplicatedMovement();
// Workaround for replication not being updated initially
if (bIsSimulatedProxy &&
ConstRepMovement.Location.IsZero() &&
ConstRepMovement.Rotation.IsZero() &&
ConstRepMovement.LinearVelocity.IsZero())
{
return;
}
// If base is not resolved on the client, we should not try to simulate at all
if (CharacterOwner->GetReplicatedBasedMovement().IsBaseUnresolved())
{
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Base for simulated character '%s' is not resolved on client, skipping SimulateMovement"), *CharacterOwner->GetName());
return;
}
FVector OldVelocity;
FVector OldLocation;
// Scoped updates can improve performance of multiple MoveComponent calls.
{
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
bool bHandledNetUpdate = false;
if (bIsSimulatedProxy)
{
// Handle network changes
if (bNetworkUpdateReceived)
{
bNetworkUpdateReceived = false;
bHandledNetUpdate = true;
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Proxy %s received net update"), *GetNameSafe(CharacterOwner));
if (bNetworkMovementModeChanged)
{
ApplyNetworkMovementMode(CharacterOwner->GetReplicatedMovementMode());
bNetworkMovementModeChanged = false;
}
else if (bJustTeleported || bForceNextFloorCheck)
{
// Make sure floor is current. We will continue using the replicated base, if there was one.
bJustTeleported = false;
UpdateFloorFromAdjustment();
}
}
else if (bForceNextFloorCheck)
{
UpdateFloorFromAdjustment();
}
}
UpdateCharacterStateBeforeMovement(DeltaSeconds);
if (MovementMode != MOVE_None)
{
//TODO: Also ApplyAccumulatedForces()?
HandlePendingLaunch();
}
ClearAccumulatedForces();
if (MovementMode == MOVE_None)
{
return;
}
const bool bSimGravityDisabled = (bIsSimulatedProxy && CharacterOwner->bSimGravityDisabled);
const bool bZeroReplicatedGroundVelocity = (bIsSimulatedProxy && IsMovingOnGround() && ConstRepMovement.LinearVelocity.IsZero());
// bSimGravityDisabled means velocity was zero when replicated and we were stuck in something. Avoid external changes in velocity as well.
// Being in ground movement with zero velocity, we cannot simulate proxy velocities safely because we might not get any further updates from the server.
if (bSimGravityDisabled || bZeroReplicatedGroundVelocity)
{
Velocity = FVector::ZeroVector;
}
MaybeUpdateBasedMovement(DeltaSeconds);
// simulated pawns predict location
OldVelocity = Velocity;
OldLocation = UpdatedComponent->GetComponentLocation();
UpdateProxyAcceleration();
static const auto CVarNetEnableSkipProxyPredictionOnNetUpdate = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetEnableSkipProxyPredictionOnNetUpdate"));
// May only need to simulate forward on frames where we haven't just received a new position update.
if (!bHandledNetUpdate || !bNetworkSkipProxyPredictionOnNetUpdate || !CVarNetEnableSkipProxyPredictionOnNetUpdate->GetInt())
{
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Proxy %s simulating movement"), *GetNameSafe(CharacterOwner));
FStepDownResult StepDownResult;
MoveSmooth(Velocity, DeltaSeconds, &StepDownResult);
// find floor and check if falling
if (IsMovingOnGround() || MovementMode == MOVE_Falling)
{
if (StepDownResult.bComputedFloor)
{
CurrentFloor = StepDownResult.FloorResult;
}
else if (Velocity.Z <= 0.f)
{
FindFloor(UpdatedComponent->GetComponentLocation(), CurrentFloor, Velocity.IsZero(), NULL);
}
else
{
CurrentFloor.Clear();
}
if (!CurrentFloor.IsWalkableFloor())
{
if (!bSimGravityDisabled)
{
// No floor, must fall.
if (Velocity.Z <= 0.f || bApplyGravityWhileJumping || !CharacterOwner->IsJumpProvidingForce())
{
Velocity = NewFallVelocity(Velocity, FVector(0.f, 0.f, GetGravityZ()), DeltaSeconds);
}
}
SetMovementMode(MOVE_Falling);
}
else
{
// Walkable floor
if (IsMovingOnGround())
{
AdjustFloorHeight();
SetBase(CurrentFloor.HitResult.Component.Get(), CurrentFloor.HitResult.BoneName);
}
else if (MovementMode == MOVE_Falling)
{
if (CurrentFloor.FloorDist <= MIN_FLOOR_DIST || (bSimGravityDisabled && CurrentFloor.FloorDist <= MAX_FLOOR_DIST))
{
// Landed
SetPostLandedPhysics(CurrentFloor.HitResult);
}
else
{
if (!bSimGravityDisabled)
{
// Continue falling.
Velocity = NewFallVelocity(Velocity, FVector(0.f, 0.f, GetGravityZ()), DeltaSeconds);
}
CurrentFloor.Clear();
}
}
}
}
}
else
{
UE_LOG(LogVRCharacterMovement, Verbose, TEXT("Proxy %s SKIPPING simulate movement"), *GetNameSafe(CharacterOwner));
}
UpdateCharacterStateAfterMovement(DeltaSeconds);
// consume path following requested velocity
bHasRequestedVelocity = false;
OnMovementUpdated(DeltaSeconds, OldLocation, OldVelocity);
} // End scoped movement update
// Call custom post-movement events. These happen after the scoped movement completes in case the events want to use the current state of overlaps etc.
CallMovementUpdateDelegate(DeltaSeconds, OldLocation, OldVelocity);
SaveBaseLocation();
UpdateComponentVelocity();
bJustTeleported = false;
LastUpdateLocation = UpdatedComponent ? UpdatedComponent->GetComponentLocation() : FVector::ZeroVector;
LastUpdateRotation = UpdatedComponent ? UpdatedComponent->GetComponentQuat() : FQuat::Identity;
LastUpdateVelocity = Velocity;
}
void UVRCharacterMovementComponent::MoveSmooth(const FVector& InVelocity, const float DeltaSeconds, FStepDownResult* OutStepDownResult)
{
if (!HasValidData())
{
return;
}
// Custom movement mode.
// Custom movement may need an update even if there is zero velocity.
if (MovementMode == MOVE_Custom)
{
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
PhysCustom(DeltaSeconds, 0);
return;
}
FVector Delta = InVelocity * DeltaSeconds;
if (Delta.IsZero())
{
return;
}
FVRCharacterScopedMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates ? EScopedUpdate::DeferredUpdates : EScopedUpdate::ImmediateUpdates);
if (IsMovingOnGround())
{
MoveAlongFloor(InVelocity, DeltaSeconds, OutStepDownResult);
}
else
{
FHitResult Hit(1.f);
SafeMoveUpdatedComponent(Delta, UpdatedComponent->GetComponentQuat(), true, Hit);
if (Hit.IsValidBlockingHit())
{
bool bSteppedUp = false;
if (IsFlying())
{
if (CanStepUp(Hit))
{
OutStepDownResult = NULL; // No need for a floor when not walking.
if (FMath::Abs(Hit.ImpactNormal.Z) < 0.2f)
{
const FVector GravDir = FVector(0.f, 0.f, -1.f);
const FVector DesiredDir = Delta.GetSafeNormal();
const float UpDown = GravDir | DesiredDir;
if ((UpDown < 0.5f) && (UpDown > -0.2f))
{
bSteppedUp = StepUp(GravDir, Delta * (1.f - Hit.Time), Hit, OutStepDownResult);
}
}
}
}
// If StepUp failed, try sliding.
if (!bSteppedUp)
{
SlideAlongSurface(Delta, 1.f - Hit.Time, Hit.Normal, Hit, false);
}
}
}
}
void UVRCharacterMovementComponent::SendClientAdjustment()
{
if (!HasValidData())
{
return;
}
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
check(ServerData);
if (ServerData->PendingAdjustment.TimeStamp <= 0.f)
{
return;
}
const float CurrentTime = GetWorld()->GetTimeSeconds();
if (ServerData->PendingAdjustment.bAckGoodMove)
{
// just notify client this move was received
if (CurrentTime - ServerLastClientGoodMoveAckTime > NetworkMinTimeBetweenClientAckGoodMoves)
{
ServerLastClientGoodMoveAckTime = CurrentTime;
ClientAckGoodMove(ServerData->PendingAdjustment.TimeStamp);
}
}
else
{
// We won't be back in here until the next client move and potential correction is received, so use the correct time now.
// Protect against bad data by taking appropriate min/max of editable values.
const float AdjustmentTimeThreshold = bNetworkLargeClientCorrection ?
FMath::Min(NetworkMinTimeBetweenClientAdjustmentsLargeCorrection, NetworkMinTimeBetweenClientAdjustments) :
FMath::Max(NetworkMinTimeBetweenClientAdjustmentsLargeCorrection, NetworkMinTimeBetweenClientAdjustments);
// Check if correction is throttled based on time limit between updates.
if (CurrentTime - ServerLastClientAdjustmentTime > AdjustmentTimeThreshold)
{
ServerLastClientAdjustmentTime = CurrentTime;
const bool bIsPlayingNetworkedRootMotionMontage = CharacterOwner->IsPlayingNetworkedRootMotionMontage();
if (HasRootMotionSources())
{
FRotator Rotation = ServerData->PendingAdjustment.NewRot.GetNormalized();
FVector_NetQuantizeNormal CompressedRotation(Rotation.Pitch / 180.f, Rotation.Yaw / 180.f, Rotation.Roll / 180.f);
ClientAdjustRootMotionSourcePosition
(
ServerData->PendingAdjustment.TimeStamp,
CurrentRootMotion,
bIsPlayingNetworkedRootMotionMontage,
bIsPlayingNetworkedRootMotionMontage ? CharacterOwner->GetRootMotionAnimMontageInstance()->GetPosition() : -1.f,
ServerData->PendingAdjustment.NewLoc,
CompressedRotation,
ServerData->PendingAdjustment.NewVel.Z,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
PackNetworkMovementMode()
);
}
else if (bIsPlayingNetworkedRootMotionMontage)
{
FRotator Rotation = ServerData->PendingAdjustment.NewRot.GetNormalized();
FVector_NetQuantizeNormal CompressedRotation(Rotation.Pitch / 180.f, Rotation.Yaw / 180.f, Rotation.Roll / 180.f);
ClientAdjustRootMotionPosition
(
ServerData->PendingAdjustment.TimeStamp,
CharacterOwner->GetRootMotionAnimMontageInstance()->GetPosition(),
ServerData->PendingAdjustment.NewLoc,
CompressedRotation,
ServerData->PendingAdjustment.NewVel.Z,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
PackNetworkMovementMode()
);
}
else if (ServerData->PendingAdjustment.NewVel.IsZero())
{
ClientVeryShortAdjustPositionVR
(
ServerData->PendingAdjustment.TimeStamp,
ServerData->PendingAdjustment.NewLoc,
FRotator::CompressAxisToShort(ServerData->PendingAdjustment.NewRot.Yaw),
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
PackNetworkMovementMode()
);
}
else
{
ClientAdjustPositionVR
(
ServerData->PendingAdjustment.TimeStamp,
ServerData->PendingAdjustment.NewLoc,
FRotator::CompressAxisToShort(ServerData->PendingAdjustment.NewRot.Yaw),
ServerData->PendingAdjustment.NewVel,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
PackNetworkMovementMode()
);
}
}
}
ServerData->PendingAdjustment.TimeStamp = 0;
ServerData->PendingAdjustment.bAckGoodMove = false;
ServerData->bForceClientUpdate = false;
}
void UVRCharacterMovementComponent::ClientVeryShortAdjustPositionVR(float TimeStamp, FVector NewLoc, uint16 NewYaw, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode)
{
((AVRCharacter*)CharacterOwner)->ClientVeryShortAdjustPositionVR(TimeStamp, NewLoc, NewYaw, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode);
}
void UVRCharacterMovementComponent::ClientVeryShortAdjustPositionVR_Implementation
(
float TimeStamp,
FVector NewLoc,
uint16 NewYaw,
UPrimitiveComponent* NewBase,
FName NewBaseBoneName,
bool bHasBase,
bool bBaseRelativePosition,
uint8 ServerMovementMode
)
{
if (HasValidData())
{
ClientAdjustPositionVR(TimeStamp, NewLoc, NewYaw, FVector::ZeroVector, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode);
}
}
void UVRCharacterMovementComponent::ClientAdjustPositionVR(float TimeStamp, FVector NewLoc, uint16 NewYaw, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode)
{
((AVRCharacter*)CharacterOwner)->ClientAdjustPositionVR(TimeStamp, NewLoc, NewYaw, NewVel, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode);
}
void UVRCharacterMovementComponent::ClientAdjustPositionVR_Implementation
(
float TimeStamp,
FVector NewLocation,
uint16 NewYaw,
FVector NewVelocity,
UPrimitiveComponent* NewBase,
FName NewBaseBoneName,
bool bHasBase,
bool bBaseRelativePosition,
uint8 ServerMovementMode
)
{
if (!HasValidData() || !IsActive())
{
return;
}
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
check(ClientData);
// Make sure the base actor exists on this client.
const bool bUnresolvedBase = bHasBase && (NewBase == NULL);
if (bUnresolvedBase)
{
if (bBaseRelativePosition)
{
UE_LOG(LogNetPlayerMovement, Warning, TEXT("ClientAdjustPosition_Implementation could not resolve the new relative movement base actor, ignoring server correction! Client currently at world location %s on base %s"),
*UpdatedComponent->GetComponentLocation().ToString(), *GetNameSafe(GetMovementBase()));
return;
}
else
{
UE_LOG(LogNetPlayerMovement, Verbose, TEXT("ClientAdjustPosition_Implementation could not resolve the new absolute movement base actor, but WILL use the position!"));
}
}
// Ack move if it has not expired.
int32 MoveIndex = ClientData->GetSavedMoveIndex(TimeStamp);
if (MoveIndex == INDEX_NONE)
{
if (ClientData->LastAckedMove.IsValid())
{
UE_LOG(LogNetPlayerMovement, Log, TEXT("ClientAdjustPosition_Implementation could not find Move for TimeStamp: %f, LastAckedTimeStamp: %f, CurrentTimeStamp: %f"), TimeStamp, ClientData->LastAckedMove->TimeStamp, ClientData->CurrentTimeStamp);
}
return;
}
if (!bUseClientControlRotation)
{
float YawValue = FRotator::DecompressAxisFromShort(NewYaw);
// Trust the server's control yaw
if (ClientData->LastAckedMove.IsValid() && !FMath::IsNearlyEqual(ClientData->LastAckedMove->SavedControlRotation.Yaw, YawValue))
{
if (BaseVRCharacterOwner)
{
if (BaseVRCharacterOwner->bUseControllerRotationYaw)
{
AController * myController = BaseVRCharacterOwner->GetController();
if (myController)
{
//FRotator newRot = myController->GetControlRotation();
myController->SetControlRotation(FRotator(0.f, YawValue, 0.f));//(ClientData->LastAckedMove->SavedControlRotation);
}
}
BaseVRCharacterOwner->SetActorRotation(FRotator(0.f, YawValue, 0.f));
}
}
}
ClientData->AckMove(MoveIndex, *this);
FVector WorldShiftedNewLocation;
// Received Location is relative to dynamic base
if (bBaseRelativePosition)
{
FVector BaseLocation;
FQuat BaseRotation;
MovementBaseUtility::GetMovementBaseTransform(NewBase, NewBaseBoneName, BaseLocation, BaseRotation); // TODO: error handling if returns false
WorldShiftedNewLocation = NewLocation + BaseLocation;
}
else
{
WorldShiftedNewLocation = FRepMovement::RebaseOntoLocalOrigin(NewLocation, this);
}
// Trigger event
OnClientCorrectionReceived(*ClientData, TimeStamp, WorldShiftedNewLocation, NewVelocity, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode);
// Trust the server's positioning.
if (UpdatedComponent)
{
UpdatedComponent->SetWorldLocation(WorldShiftedNewLocation, false, nullptr, ETeleportType::TeleportPhysics);
}
Velocity = NewVelocity;
// Trust the server's movement mode
UPrimitiveComponent* PreviousBase = CharacterOwner->GetMovementBase();
ApplyNetworkMovementMode(ServerMovementMode);
// Set base component
UPrimitiveComponent* FinalBase = NewBase;
FName FinalBaseBoneName = NewBaseBoneName;
if (bUnresolvedBase)
{
check(NewBase == NULL);
check(!bBaseRelativePosition);
// We had an unresolved base from the server
// If walking, we'd like to continue walking if possible, to avoid falling for a frame, so try to find a base where we moved to.
if (PreviousBase && UpdatedComponent)
{
FindFloor(UpdatedComponent->GetComponentLocation(), CurrentFloor, false);
if (CurrentFloor.IsWalkableFloor())
{
FinalBase = CurrentFloor.HitResult.Component.Get();
FinalBaseBoneName = CurrentFloor.HitResult.BoneName;
}
else
{
FinalBase = nullptr;
FinalBaseBoneName = NAME_None;
}
}
}
SetBase(FinalBase, FinalBaseBoneName);
// Update floor at new location
UpdateFloorFromAdjustment();
bJustTeleported = true;
// Even if base has not changed, we need to recompute the relative offsets (since we've moved).
SaveBaseLocation();
LastUpdateLocation = UpdatedComponent ? UpdatedComponent->GetComponentLocation() : FVector::ZeroVector;
LastUpdateRotation = UpdatedComponent ? UpdatedComponent->GetComponentQuat() : FQuat::Identity;
LastUpdateVelocity = Velocity;
UpdateComponentVelocity();
ClientData->bUpdatePosition = true;
}
bool UVRCharacterMovementComponent::ServerCheckClientErrorVR(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& ClientWorldLocation, float ClientYaw, const FVector& RelativeClientLocation, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
// Check location difference against global setting
if (!bIgnoreClientMovementErrorChecksAndCorrection)
{
//const FVector LocDiff = UpdatedComponent->GetComponentLocation() - ClientWorldLocation;
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnAnyThread() == 1)
{
const FVector LocDiff = UpdatedComponent->GetComponentLocation() - ClientWorldLocation;
FString AdjustedDebugString = FString::Printf(TEXT("ServerCheckClientError LocDiff(%.1f) ExceedsAllowablePositionError(%d) TimeStamp(%f)"),
LocDiff.Size(), GetDefault<AGameNetworkManager>()->ExceedsAllowablePositionError(LocDiff), ClientTimeStamp);
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
#endif
if (ServerExceedsAllowablePositionError(ClientTimeStamp, DeltaTime, Accel, ClientWorldLocation, RelativeClientLocation, ClientMovementBase, ClientBaseBoneName, ClientMovementMode))
{
return true;
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
static const auto CVarNetForceClientAdjustmentPercent = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetForceClientAdjustmentPercent"));
if (CVarNetForceClientAdjustmentPercent->GetFloat() > SMALL_NUMBER)
{
if (RandomStream.FRand() < CVarNetForceClientAdjustmentPercent->GetFloat())
{
UE_LOG(LogVRCharacterMovement, VeryVerbose, TEXT("** ServerCheckClientError forced by p.NetForceClientAdjustmentPercent"));
return true;
}
}
#endif
}
else
{
#if !UE_BUILD_SHIPPING
static const auto CVarNetShowCorrections = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetShowCorrections"));
if (CVarNetShowCorrections->GetInt() != 0)
{
UE_LOG(LogVRCharacterMovement, Warning, TEXT("*** Server: %s is set to ignore error checks and corrections."), *GetNameSafe(CharacterOwner));
}
#endif // !UE_BUILD_SHIPPING
}
// If we are rolling back client rotation
if (!bUseClientControlRotation && !FMath::IsNearlyEqual(FRotator::ClampAxis(ClientYaw), FRotator::ClampAxis(UpdatedComponent->GetComponentRotation().Yaw), CharacterMovementComponentStatics::fRotationCorrectionThreshold))
{
return true;
}
return false;
}
void UVRCharacterMovementComponent::ServerMoveHandleClientErrorVR(float ClientTimeStamp, float DeltaTime, const FVector& Accel, const FVector& RelativeClientLoc, float ClientYaw, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
if (RelativeClientLoc == FVector(1.f, 2.f, 3.f)) // first part of double servermove
{
return;
}
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
check(ServerData);
// Don't prevent more recent updates from being sent if received this frame.
// We're going to send out an update anyway, might as well be the most recent one.
APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
if ((ServerData->LastUpdateTime != GetWorld()->TimeSeconds))
{
const AGameNetworkManager* GameNetworkManager = (const AGameNetworkManager*)(AGameNetworkManager::StaticClass()->GetDefaultObject());
if (GameNetworkManager->WithinUpdateDelayBounds(PC, ServerData->LastUpdateTime))
{
return;
}
}
// Offset may be relative to base component
FVector ClientLoc = RelativeClientLoc;
if (MovementBaseUtility::UseRelativeLocation(ClientMovementBase))
{
FVector BaseLocation;
FQuat BaseRotation;
MovementBaseUtility::GetMovementBaseTransform(ClientMovementBase, ClientBaseBoneName, BaseLocation, BaseRotation);
ClientLoc += BaseLocation;
}
// Client may send a null movement base when walking on bases with no relative location (to save bandwidth).
// In this case don't check movement base in error conditions, use the server one (which avoids an error based on differing bases). Position will still be validated.
if (ClientMovementBase == nullptr && ClientMovementMode == MOVE_Walking)
{
ClientMovementBase = CharacterOwner->GetBasedMovement().MovementBase;
ClientBaseBoneName = CharacterOwner->GetBasedMovement().BoneName;
}
// Compute the client error from the server's position
// If client has accumulated a noticeable positional error, correct them.
bNetworkLargeClientCorrection = ServerData->bForceClientUpdate;
if (ServerData->bForceClientUpdate || ServerCheckClientErrorVR(ClientTimeStamp, DeltaTime, Accel, ClientLoc, ClientYaw, RelativeClientLoc, ClientMovementBase, ClientBaseBoneName, ClientMovementMode))
{
UPrimitiveComponent* MovementBase = CharacterOwner->GetMovementBase();
ServerData->PendingAdjustment.NewVel = Velocity;
ServerData->PendingAdjustment.NewBase = MovementBase;
ServerData->PendingAdjustment.NewBaseBoneName = CharacterOwner->GetBasedMovement().BoneName;
ServerData->PendingAdjustment.NewLoc = FRepMovement::RebaseOntoZeroOrigin(UpdatedComponent->GetComponentLocation(), this);
ServerData->PendingAdjustment.NewRot = UpdatedComponent->GetComponentRotation();
ServerData->PendingAdjustment.bBaseRelativePosition = MovementBaseUtility::UseRelativeLocation(MovementBase);
if (ServerData->PendingAdjustment.bBaseRelativePosition)
{
// Relative location
ServerData->PendingAdjustment.NewLoc = CharacterOwner->GetBasedMovement().Location;
// TODO: this could be a relative rotation, but all client corrections ignore rotation right now except the root motion one, which would need to be updated.
//ServerData->PendingAdjustment.NewRot = CharacterOwner->GetBasedMovement().Rotation;
}
#if !UE_BUILD_SHIPPING
static const auto CVarNetShowCorrections = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetShowCorrections"));
static const auto CVarNetCorrectionLifetime = IConsoleManager::Get().FindConsoleVariable(TEXT("p.NetCorrectionLifetime"));
if (CVarNetShowCorrections->GetInt() != 0)
{
const FVector LocDiff = UpdatedComponent->GetComponentLocation() - ClientLoc;
const FString BaseString = MovementBase ? MovementBase->GetPathName(MovementBase->GetOutermost()) : TEXT("None");
UE_LOG(LogVRCharacterMovement, Warning, TEXT("*** Server: Error for %s at Time=%.3f is %3.3f LocDiff(%s) ClientLoc(%s) ServerLoc(%s) Base: %s Bone: %s Accel(%s) Velocity(%s)"),
*GetNameSafe(CharacterOwner), ClientTimeStamp, LocDiff.Size(), *LocDiff.ToString(), *ClientLoc.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *BaseString, *ServerData->PendingAdjustment.NewBaseBoneName.ToString(), *Accel.ToString(), *Velocity.ToString());
const float DebugLifetime = CVarNetCorrectionLifetime->GetFloat();
DrawDebugCapsule(GetWorld(), UpdatedComponent->GetComponentLocation(), CharacterOwner->GetSimpleCollisionHalfHeight(), CharacterOwner->GetSimpleCollisionRadius(), FQuat::Identity, FColor(100, 255, 100), false, DebugLifetime);
DrawDebugCapsule(GetWorld(), ClientLoc, CharacterOwner->GetSimpleCollisionHalfHeight(), CharacterOwner->GetSimpleCollisionRadius(), FQuat::Identity, FColor(255, 100, 100), false, DebugLifetime);
}
#endif
ServerData->LastUpdateTime = GetWorld()->TimeSeconds;
ServerData->PendingAdjustment.DeltaTime = DeltaTime;
ServerData->PendingAdjustment.TimeStamp = ClientTimeStamp;
ServerData->PendingAdjustment.bAckGoodMove = false;
ServerData->PendingAdjustment.MovementMode = PackNetworkMovementMode();
//PerfCountersIncrement(PerfCounter_NumServerMoveCorrections);
}
else
{
if (ServerShouldUseAuthoritativePosition(ClientTimeStamp, DeltaTime, Accel, ClientLoc, RelativeClientLoc, ClientMovementBase, ClientBaseBoneName, ClientMovementMode))
{
const FVector LocDiff = UpdatedComponent->GetComponentLocation() - ClientLoc; //-V595
if (!LocDiff.IsZero() || ClientMovementMode != PackNetworkMovementMode() || GetMovementBase() != ClientMovementBase || (CharacterOwner && CharacterOwner->GetBasedMovement().BoneName != ClientBaseBoneName))
{
// Just set the position. On subsequent moves we will resolve initially overlapping conditions.
UpdatedComponent->SetWorldLocation(ClientLoc, false); //-V595
// Trust the client's movement mode.
ApplyNetworkMovementMode(ClientMovementMode);
// Update base and floor at new location.
SetBase(ClientMovementBase, ClientBaseBoneName);
UpdateFloorFromAdjustment();
// Even if base has not changed, we need to recompute the relative offsets (since we've moved).
SaveBaseLocation();
LastUpdateLocation = UpdatedComponent ? UpdatedComponent->GetComponentLocation() : FVector::ZeroVector;
LastUpdateRotation = UpdatedComponent ? UpdatedComponent->GetComponentQuat() : FQuat::Identity;
LastUpdateVelocity = Velocity;
}
}
// acknowledge receipt of this successful servermove()
ServerData->PendingAdjustment.TimeStamp = ClientTimeStamp;
ServerData->PendingAdjustment.bAckGoodMove = true;
}
//PerfCountersIncrement(PerfCounter_NumServerMoves);
ServerData->bForceClientUpdate = false;
}
FVector UVRCharacterMovementComponent::GetPenetrationAdjustment(const FHitResult& Hit) const
{
// This checks for a walking collision override on the penetrated object
// If found then it stops penetration adjustments.
if (MovementMode == EMovementMode::MOVE_Walking && VRRootCapsule && VRRootCapsule->bUseWalkingCollisionOverride && Hit.Component.IsValid())
{
ECollisionResponse WalkingResponse;
WalkingResponse = Hit.Component->GetCollisionResponseToChannel(VRRootCapsule->WalkingCollisionOverride);
if (WalkingResponse == ECR_Ignore || WalkingResponse == ECR_Overlap)
{
return FVector::ZeroVector;
}
}
FVector Result = Super::GetPenetrationAdjustment(Hit);
if (CharacterOwner)
{
const bool bIsProxy = (CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy);
float MaxDistance = bIsProxy ? MaxDepenetrationWithGeometryAsProxy : MaxDepenetrationWithGeometry;
const AActor* HitActor = Hit.GetActor();
if (Cast<APawn>(HitActor))
{
MaxDistance = bIsProxy ? MaxDepenetrationWithPawnAsProxy : MaxDepenetrationWithPawn;
}
Result = Result.GetClampedToMaxSize(MaxDistance);
}
return Result;
} | [
"chris.leapforce@gmail.com"
] | chris.leapforce@gmail.com |
9deff1803e77be2ffec995e34b566349cc087493 | db1979b2b8626f5e7c7a1ae47c6d2f70d573563d | /emulator/src/operations/branching.cpp | d857735a12951b7ee0cbe9b0be34cbc2ede1604c | [] | no_license | AaronJV/6808Emulator | 184920717e278115f67b2ceaa7ec6458c6827996 | 214cabcc180016a99e2c961e76fc5d7b21ef2eb7 | refs/heads/master | 2022-02-20T17:45:11.386272 | 2019-09-16T23:00:44 | 2019-09-16T23:00:44 | 140,091,148 | 0 | 0 | null | 2022-02-11T00:56:48 | 2018-07-07T14:29:01 | C++ | UTF-8 | C++ | false | false | 1,241 | cpp | #include "../m6808.hxx"
void M6808::BCC() {
FAIL();
};
void M6808::BCS() {
FAIL();
};
void M6808::BEQ() {
FAIL();
};
void M6808::CBEQ() {
FAIL();
};
void M6808::DBNZ() {
FAIL();
};
void M6808::BHCC() {
FAIL();
};
void M6808::BHCS() {
FAIL();
};
void M6808::BHI() {
FAIL();
};
void M6808::BIH() {
FAIL();
};
void M6808::BIL() {
FAIL();
};
void M6808::BLS() {
FAIL();
};
void M6808::BMC() {
FAIL();
};
void M6808::BMI() {
FAIL();
};
void M6808::BMS() {
FAIL();
};
void M6808::BNE() {
FAIL();
};
void M6808::BPL() {
FAIL();
};
void M6808::BRA() {
FAIL();
};
void M6808::BRN() {
FAIL();
};
void M6808::JMP() {
FAIL();
};
void M6808::BSR() {
FAIL();
};
void M6808::JSR() {
FAIL();
};
/**
* @brief Branch if Bit n in Memory Clear
*
* Tests bit n (n = 7, 6, 5, โฆ 0) of location M and branches if the bit is clear
*
* CCR:
* - C: Set if Mn = 1; cleared otherwise
*/
void M6808::BRCLR() {
FAIL();
};
/**
* @brief Branch if Bit n in Memory Set
*
* Tests bit n (n = 7, 6, 5, โฆ 0) of location M and branches if the bit is set
*
* CCR:
* - C: Set if Mn = 1; cleared otherwise
*/
void M6808::BRSET() {
FAIL();
}; | [
"aaron.vos@gmail.com"
] | aaron.vos@gmail.com |
f75643296f621a97b4965f32cf7d0a11246f838d | a4321d20e4c0cd1b4a79d323e28133071ad98685 | /src/qt/askpassphrasedialog.cpp | 6dee01376ebebaf5ab3c86fbb98214cad626d82e | [
"MIT"
] | permissive | sherlockcoin/8coin | 8089ce9a0633f6754fb50b225a9f5e2c0d206201 | 5755d41c3b49e5fa0ede9cc8abddffd314c04949 | refs/heads/master | 2021-01-09T09:17:48.704806 | 2014-04-23T09:15:48 | 2014-04-23T09:15:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,924 | cpp | #include "askpassphrasedialog.h"
#include "ui_askpassphrasedialog.h"
#include "guiconstants.h"
#include "walletmodel.h"
#include <QMessageBox>
#include <QPushButton>
#include <QKeyEvent>
AskPassphraseDialog::AskPassphraseDialog(Mode mode, QWidget *parent) :
QDialog(parent),
ui(new Ui::AskPassphraseDialog),
mode(mode),
model(0),
fCapsLock(false)
{
ui->setupUi(this);
ui->passEdit1->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit2->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit3->setMaxLength(MAX_PASSPHRASE_SIZE);
// Setup Caps Lock detection.
ui->passEdit1->installEventFilter(this);
ui->passEdit2->installEventFilter(this);
ui->passEdit3->installEventFilter(this);
switch(mode)
{
case Encrypt: // Ask passphrase x2
ui->passLabel1->hide();
ui->passEdit1->hide();
ui->warningLabel->setText(tr("Enter the new passphrase to the wallet.<br/>Please use a passphrase of <b>10 or more random characters</b>, or <b>eight or more words</b>."));
setWindowTitle(tr("Encrypt wallet"));
break;
case Unlock: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to unlock the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Unlock wallet"));
break;
case Decrypt: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to decrypt the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Decrypt wallet"));
break;
case ChangePass: // Ask old passphrase + new passphrase x2
setWindowTitle(tr("Change passphrase"));
ui->warningLabel->setText(tr("Enter the old and new passphrase to the wallet."));
break;
}
textChanged();
connect(ui->passEdit1, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit2, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit3, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
}
AskPassphraseDialog::~AskPassphraseDialog()
{
// Attempt to overwrite text so that they do not linger around in memory
ui->passEdit1->setText(QString(" ").repeated(ui->passEdit1->text().size()));
ui->passEdit2->setText(QString(" ").repeated(ui->passEdit2->text().size()));
ui->passEdit3->setText(QString(" ").repeated(ui->passEdit3->text().size()));
delete ui;
}
void AskPassphraseDialog::setModel(WalletModel *model)
{
this->model = model;
}
void AskPassphraseDialog::accept()
{
SecureString oldpass, newpass1, newpass2;
if(!model)
return;
oldpass.reserve(MAX_PASSPHRASE_SIZE);
newpass1.reserve(MAX_PASSPHRASE_SIZE);
newpass2.reserve(MAX_PASSPHRASE_SIZE);
// TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
// Alternately, find a way to make this input mlock()'d to begin with.
oldpass.assign(ui->passEdit1->text().toStdString().c_str());
newpass1.assign(ui->passEdit2->text().toStdString().c_str());
newpass2.assign(ui->passEdit3->text().toStdString().c_str());
switch(mode)
{
case Encrypt: {
if(newpass1.empty() || newpass2.empty())
{
// Cannot encrypt with empty passphrase
break;
}
QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm wallet encryption"),
tr("WARNING: If you encrypt your wallet and lose your passphrase, you will <b>LOSE ALL OF YOUR 8coinS</b>!\nAre you sure you wish to encrypt your wallet?"),
QMessageBox::Yes|QMessageBox::Cancel,
QMessageBox::Cancel);
if(retval == QMessageBox::Yes)
{
if(newpass1 == newpass2)
{
if(model->setWalletEncrypted(true, newpass1))
{
QMessageBox::warning(this, tr("Wallet encrypted"),
tr("8Coin will close now to finish the encryption process. Remember that encrypting your wallet cannot fully protect your 8coin from being stolen by malware infecting your computer."));
QApplication::quit();
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("Wallet encryption failed due to an internal error. Your wallet was not encrypted."));
}
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
}
else
{
QDialog::reject(); // Cancelled
}
} break;
case Unlock:
if(!model->setWalletLocked(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet unlock failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case Decrypt:
if(!model->setWalletEncrypted(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet decryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case ChangePass:
if(newpass1 == newpass2)
{
if(model->changePassphrase(oldpass, newpass1))
{
QMessageBox::information(this, tr("Wallet encrypted"),
tr("Wallet passphrase was successfully changed."));
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
break;
}
}
void AskPassphraseDialog::textChanged()
{
// Validate input, set Ok button to enabled when accepable
bool acceptable = false;
switch(mode)
{
case Encrypt: // New passphrase x2
acceptable = !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
case Unlock: // Old passphrase x1
case Decrypt:
acceptable = !ui->passEdit1->text().isEmpty();
break;
case ChangePass: // Old passphrase x1, new passphrase x2
acceptable = !ui->passEdit1->text().isEmpty() && !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
}
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(acceptable);
}
bool AskPassphraseDialog::event(QEvent *event)
{
// Detect Caps Lock key press.
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_CapsLock) {
fCapsLock = !fCapsLock;
}
if (fCapsLock) {
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on."));
} else {
ui->capsLabel->clear();
}
}
return QWidget::event(event);
}
bool AskPassphraseDialog::eventFilter(QObject *, QEvent *event)
{
/* Detect Caps Lock.
* There is no good OS-independent way to check a key state in Qt, but we
* can detect Caps Lock by checking for the following condition:
* Shift key is down and the result is a lower case character, or
* Shift key is not down and the result is an upper case character.
*/
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
QString str = ke->text();
if (str.length() != 0) {
const QChar *psz = str.unicode();
bool fShift = (ke->modifiers() & Qt::ShiftModifier) != 0;
if ((fShift && psz->isLower()) || (!fShift && psz->isUpper())) {
fCapsLock = true;
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on."));
} else if (psz->isLetter()) {
fCapsLock = false;
ui->capsLabel->clear();
}
}
}
return false;
}
| [
"root@d1stkfactory"
] | root@d1stkfactory |
3b7381212e4917b329e6a3ea3d92f7a0d9077de4 | e65e6b345e98633cccc501ad0d6df9918b2aa25e | /Atcoder/Grand/050/A.cpp | a163fe4ed1875901e18487a6e6959b90d532029b | [] | no_license | wcysai/CodeLibrary | 6eb99df0232066cf06a9267bdcc39dc07f5aab29 | 6517cef736f1799b77646fe04fb280c9503d7238 | refs/heads/master | 2023-08-10T08:31:58.057363 | 2023-07-29T11:56:38 | 2023-07-29T11:56:38 | 134,228,833 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 762 | cpp | #pragma GCC optimize(3)
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/priority_queue.hpp>
#define MAXN 100005
#define INF 1000000000
#define MOD 1000000007
#define F first
#define S second
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef pair<int,int> P;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef __gnu_pbds::priority_queue<int,greater<int>,pairing_heap_tag> pq;
int n;
int main()
{
scanf("%d",&n);
if(n==1) {puts("1 1"); return 0;}
for(int i=1;i<=n;i++)
{
int x=2*i%n,y=(2*i+1)%n;
if(x==0) x=n; if(y==0) y=n;
printf("%d %d\n",x,y);
}
return 0;
}
| [
"wcysai@foxmail.com"
] | wcysai@foxmail.com |
701e70c051151b6e5638ad0de7d1929b37d44801 | 5f9cff6db34ebfa86a3794eb491b0e0f0f8d53c3 | /src/qt/guiutil.cpp | 00128e2e2bd3b0015de793745554624287be2035 | [
"MIT"
] | permissive | selfdirectedcoin/selfdirectedcoin | 7d788a20c5207630f2bb9ed8a3ff78602e113274 | 75524be2848e1d508908c393c9f306fb0d9979e5 | refs/heads/master | 2021-05-12T19:18:49.694630 | 2018-01-11T13:43:03 | 2018-01-11T13:43:03 | 117,089,400 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,554 | cpp | // Copyright (c) 2011-2014 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <QApplication>
#include "guiutil.h"
#include "bitcoinaddressvalidator.h"
#include "walletmodel.h"
#include "bitcoinunits.h"
#include "util.h"
#include "init.h"
#include <QDateTime>
#include <QDoubleValidator>
#include <QFont>
#include <QLineEdit>
#if QT_VERSION >= 0x050000
#include <QUrlQuery>
#else
#include <QUrl>
#endif
#include <QTextDocument> // for Qt::mightBeRichText
#include <QAbstractItemView>
#include <QClipboard>
#include <QFileDialog>
#include <QDesktopServices>
#include <QThread>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#ifdef WIN32
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include "shlwapi.h"
#include "shlobj.h"
#include "shellapi.h"
#endif
namespace GUIUtil {
QString dateTimeStr(const QDateTime &date)
{
return date.date().toString(Qt::SystemLocaleShortDate) + QString(" ") + date.toString("hh:mm");
}
QString dateTimeStr(qint64 nTime)
{
return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
}
QFont bitcoinAddressFont()
{
QFont font("Monospace");
font.setStyleHint(QFont::TypeWriter);
return font;
}
void setupAddressWidget(QLineEdit *widget, QWidget *parent)
{
widget->setMaxLength(BitcoinAddressValidator::MaxAddressLength);
widget->setValidator(new BitcoinAddressValidator(parent));
widget->setFont(bitcoinAddressFont());
}
void setupAmountWidget(QLineEdit *widget, QWidget *parent)
{
QDoubleValidator *amountValidator = new QDoubleValidator(parent);
amountValidator->setDecimals(8);
amountValidator->setBottom(0.0);
widget->setValidator(amountValidator);
widget->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
}
bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out)
{
// return if URI is not valid or is no bitcoin URI
if(!uri.isValid() || uri.scheme() != QString("SelfDirectedCoin"))
return false;
SendCoinsRecipient rv;
rv.address = uri.path();
rv.amount = 0;
#if QT_VERSION < 0x050000
QList<QPair<QString, QString> > items = uri.queryItems();
#else
QUrlQuery uriQuery(uri);
QList<QPair<QString, QString> > items = uriQuery.queryItems();
#endif
for (QList<QPair<QString, QString> >::iterator i = items.begin(); i != items.end(); i++)
{
bool fShouldReturnFalse = false;
if (i->first.startsWith("req-"))
{
i->first.remove(0, 4);
fShouldReturnFalse = true;
}
if (i->first == "label")
{
rv.label = i->second;
fShouldReturnFalse = false;
}
else if (i->first == "amount")
{
if(!i->second.isEmpty())
{
if(!BitcoinUnits::parse(BitcoinUnits::BTC, i->second, &rv.amount))
{
return false;
}
}
fShouldReturnFalse = false;
}
if (fShouldReturnFalse)
return false;
}
if(out)
{
*out = rv;
}
return true;
}
bool parseBitcoinURI(QString uri, SendCoinsRecipient *out)
{
// Convert bitcoin:// to bitcoin:
//
// Cannot handle this later, because bitcoin:// will cause Qt to see the part after // as host,
// which will lower-case it (and thus invalidate the address).
if(uri.startsWith("SelfDirectedCoin://"))
{
uri.replace(0, 11, "SelfDirectedCoin:");
}
QUrl uriInstance(uri);
return parseBitcoinURI(uriInstance, out);
}
QString HtmlEscape(const QString& str, bool fMultiLine)
{
#if QT_VERSION < 0x050000
QString escaped = Qt::escape(str);
#else
QString escaped = str.toHtmlEscaped();
#endif
if(fMultiLine)
{
escaped = escaped.replace("\n", "<br>\n");
}
return escaped;
}
QString HtmlEscape(const std::string& str, bool fMultiLine)
{
return HtmlEscape(QString::fromStdString(str), fMultiLine);
}
void copyEntryData(QAbstractItemView *view, int column, int role)
{
if(!view || !view->selectionModel())
return;
QModelIndexList selection = view->selectionModel()->selectedRows(column);
if(!selection.isEmpty())
{
// Copy first item (global clipboard)
QApplication::clipboard()->setText(selection.at(0).data(role).toString(), QClipboard::Clipboard);
// Copy first item (global mouse selection for e.g. X11 - NOP on Windows)
QApplication::clipboard()->setText(selection.at(0).data(role).toString(), QClipboard::Selection);
}
}
void setClipboard(const QString& str)
{
QApplication::clipboard()->setText(str, QClipboard::Clipboard);
QApplication::clipboard()->setText(str, QClipboard::Selection);
}
QString getSaveFileName(QWidget *parent, const QString &caption,
const QString &dir,
const QString &filter,
QString *selectedSuffixOut)
{
QString selectedFilter;
QString myDir;
if(dir.isEmpty()) // Default to user documents location
{
#if QT_VERSION < 0x050000
myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
#else
myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
#endif
}
else
{
myDir = dir;
}
QString result = QFileDialog::getSaveFileName(parent, caption, myDir, filter, &selectedFilter);
/* Extract first suffix from filter pattern "Description (*.foo)" or "Description (*.foo *.bar ...) */
QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
QString selectedSuffix;
if(filter_re.exactMatch(selectedFilter))
{
selectedSuffix = filter_re.cap(1);
}
/* Add suffix if needed */
QFileInfo info(result);
if(!result.isEmpty())
{
if(info.suffix().isEmpty() && !selectedSuffix.isEmpty())
{
/* No suffix specified, add selected suffix */
if(!result.endsWith("."))
result.append(".");
result.append(selectedSuffix);
}
}
/* Return selected suffix if asked to */
if(selectedSuffixOut)
{
*selectedSuffixOut = selectedSuffix;
}
return result;
}
Qt::ConnectionType blockingGUIThreadConnection()
{
if(QThread::currentThread() != qApp->thread())
{
return Qt::BlockingQueuedConnection;
}
else
{
return Qt::DirectConnection;
}
}
bool checkPoint(const QPoint &p, const QWidget *w)
{
QWidget *atW = QApplication::widgetAt(w->mapToGlobal(p));
if (!atW) return false;
return atW->topLevelWidget() == w;
}
bool isObscured(QWidget *w)
{
return !(checkPoint(QPoint(0, 0), w)
&& checkPoint(QPoint(w->width() - 1, 0), w)
&& checkPoint(QPoint(0, w->height() - 1), w)
&& checkPoint(QPoint(w->width() - 1, w->height() - 1), w)
&& checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
}
void openDebugLogfile()
{
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
/* Open debug.log with the associated application */
if (boost::filesystem::exists(pathDebug))
QDesktopServices::openUrl(QUrl::fromLocalFile(QString::fromStdString(pathDebug.string())));
}
ToolTipToRichTextFilter::ToolTipToRichTextFilter(int size_threshold, QObject *parent) :
QObject(parent), size_threshold(size_threshold)
{
}
bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt)
{
if(evt->type() == QEvent::ToolTipChange)
{
QWidget *widget = static_cast<QWidget*>(obj);
QString tooltip = widget->toolTip();
if(tooltip.size() > size_threshold && !tooltip.startsWith("<qt") && !Qt::mightBeRichText(tooltip))
{
// Envelop with <qt></qt> to make sure Qt detects this as rich text
// Escape the current message as HTML and replace \n by <br>
tooltip = "<qt>" + HtmlEscape(tooltip, true) + "</qt>";
widget->setToolTip(tooltip);
return true;
}
}
return QObject::eventFilter(obj, evt);
}
#ifdef WIN32
boost::filesystem::path static StartupShortcutPath()
{
return GetSpecialFolderPath(CSIDL_STARTUP) / "SelfDirectedCoin.lnk";
}
bool GetStartOnSystemStartup()
{
// check for Bitcoin.lnk
return boost::filesystem::exists(StartupShortcutPath());
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
// If the shortcut exists already, remove it for updating
boost::filesystem::remove(StartupShortcutPath());
if (fAutoStart)
{
CoInitialize(NULL);
// Get a pointer to the IShellLink interface.
IShellLink* psl = NULL;
HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL,
CLSCTX_INPROC_SERVER, IID_IShellLink,
reinterpret_cast<void**>(&psl));
if (SUCCEEDED(hres))
{
// Get the current executable path
TCHAR pszExePath[MAX_PATH];
GetModuleFileName(NULL, pszExePath, sizeof(pszExePath));
TCHAR pszArgs[5] = TEXT("-min");
// Set the path to the shortcut target
psl->SetPath(pszExePath);
PathRemoveFileSpec(pszExePath);
psl->SetWorkingDirectory(pszExePath);
psl->SetShowCmd(SW_SHOWMINNOACTIVE);
psl->SetArguments(pszArgs);
// Query IShellLink for the IPersistFile interface for
// saving the shortcut in persistent storage.
IPersistFile* ppf = NULL;
hres = psl->QueryInterface(IID_IPersistFile,
reinterpret_cast<void**>(&ppf));
if (SUCCEEDED(hres))
{
WCHAR pwsz[MAX_PATH];
// Ensure that the string is ANSI.
MultiByteToWideChar(CP_ACP, 0, StartupShortcutPath().string().c_str(), -1, pwsz, MAX_PATH);
// Save the link by calling IPersistFile::Save.
hres = ppf->Save(pwsz, TRUE);
ppf->Release();
psl->Release();
CoUninitialize();
return true;
}
psl->Release();
}
CoUninitialize();
return false;
}
return true;
}
#elif defined(LINUX)
// Follow the Desktop Application Autostart Spec:
// http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
boost::filesystem::path static GetAutostartDir()
{
namespace fs = boost::filesystem;
char* pszConfigHome = getenv("XDG_CONFIG_HOME");
if (pszConfigHome) return fs::path(pszConfigHome) / "autostart";
char* pszHome = getenv("HOME");
if (pszHome) return fs::path(pszHome) / ".config" / "autostart";
return fs::path();
}
boost::filesystem::path static GetAutostartFilePath()
{
return GetAutostartDir() / "SelfDirectedCoin.desktop";
}
bool GetStartOnSystemStartup()
{
boost::filesystem::ifstream optionFile(GetAutostartFilePath());
if (!optionFile.good())
return false;
// Scan through file for "Hidden=true":
std::string line;
while (!optionFile.eof())
{
getline(optionFile, line);
if (line.find("Hidden") != std::string::npos &&
line.find("true") != std::string::npos)
return false;
}
optionFile.close();
return true;
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
if (!fAutoStart)
boost::filesystem::remove(GetAutostartFilePath());
else
{
char pszExePath[MAX_PATH+1];
memset(pszExePath, 0, sizeof(pszExePath));
if (readlink("/proc/self/exe", pszExePath, sizeof(pszExePath)-1) == -1)
return false;
boost::filesystem::create_directories(GetAutostartDir());
boost::filesystem::ofstream optionFile(GetAutostartFilePath(), std::ios_base::out|std::ios_base::trunc);
if (!optionFile.good())
return false;
// Write a bitcoin.desktop file to the autostart directory:
optionFile << "[Desktop Entry]\n";
optionFile << "Type=Application\n";
optionFile << "Name=SelfDirectedCoin\n";
optionFile << "Exec=" << pszExePath << " -min\n";
optionFile << "Terminal=false\n";
optionFile << "Hidden=false\n";
optionFile.close();
}
return true;
}
#elif defined(Q_OS_MAC)
// based on: https://github.com/Mozketo/LaunchAtLoginController/blob/master/LaunchAtLoginController.m
#include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h>
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl);
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl)
{
// loop through the list of startup items and try to find the bitcoin app
CFArrayRef listSnapshot = LSSharedFileListCopySnapshot(list, NULL);
for(int i = 0; i < CFArrayGetCount(listSnapshot); i++) {
LSSharedFileListItemRef item = (LSSharedFileListItemRef)CFArrayGetValueAtIndex(listSnapshot, i);
UInt32 resolutionFlags = kLSSharedFileListNoUserInteraction | kLSSharedFileListDoNotMountVolumes;
CFURLRef currentItemURL = NULL;
LSSharedFileListItemResolve(item, resolutionFlags, ¤tItemURL, NULL);
if(currentItemURL && CFEqual(currentItemURL, findUrl)) {
// found
CFRelease(currentItemURL);
return item;
}
if(currentItemURL) {
CFRelease(currentItemURL);
}
}
return NULL;
}
bool GetStartOnSystemStartup()
{
CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
LSSharedFileListRef loginItems = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);
return !!foundItem; // return boolified object
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
LSSharedFileListRef loginItems = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);
if(fAutoStart && !foundItem) {
// add bitcoin app to startup item list
LSSharedFileListInsertItemURL(loginItems, kLSSharedFileListItemBeforeFirst, NULL, NULL, bitcoinAppUrl, NULL, NULL);
}
else if(!fAutoStart && foundItem) {
// remove item
LSSharedFileListItemRemove(loginItems, foundItem);
}
return true;
}
#else
bool GetStartOnSystemStartup() { return false; }
bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
#endif
HelpMessageBox::HelpMessageBox(QWidget *parent) :
QMessageBox(parent)
{
header = tr("SelfDirectedCoin-Qt") + " " + tr("version") + " " +
QString::fromStdString(FormatFullVersion()) + "\n\n" +
tr("Usage:") + "\n" +
" SelfDirectedCoin-qt [" + tr("command-line options") + "] " + "\n";
coreOptions = QString::fromStdString(HelpMessage());
uiOptions = tr("UI options") + ":\n" +
" -lang=<lang> " + tr("Set language, for example \"de_DE\" (default: system locale)") + "\n" +
" -min " + tr("Start minimized") + "\n" +
" -splash " + tr("Show splash screen on startup (default: 1)") + "\n";
setWindowTitle(tr("SelfDirectedCoin-Qt"));
setTextFormat(Qt::PlainText);
// setMinimumWidth is ignored for QMessageBox so put in non-breaking spaces to make it wider.
setText(header + QString(QChar(0x2003)).repeated(50));
setDetailedText(coreOptions + "\n" + uiOptions);
}
void HelpMessageBox::printToConsole()
{
// On other operating systems, the expected action is to print the message to the console.
QString strUsage = header + "\n" + coreOptions + "\n" + uiOptions;
fprintf(stdout, "%s", strUsage.toStdString().c_str());
}
void HelpMessageBox::showOrPrint()
{
#if defined(WIN32)
// On Windows, show a message box, as there is no stderr/stdout in windowed applications
exec();
#else
// On other operating systems, print help text to console
printToConsole();
#endif
}
} // namespace GUIUtil
| [
"peterburns89@gmail.com"
] | peterburns89@gmail.com |
4fc07e3ffd7207f2fe00af68d4f61a968d1f99a8 | ee7390c9affabf29b5f048d6b79282a7448402df | /mvinuse.cpp | 8bd65f707e9ec39c03758ce70e986f856e021f9a | [] | no_license | sudarkoff/sandbox | cd369656f2c24866a8ad501c9be0e7e6ece6680a | ea4f2333547af0560cf51e3d84e88d872cbfe431 | refs/heads/master | 2016-09-06T05:58:46.959587 | 2014-09-22T23:39:57 | 2014-09-22T23:39:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 801 | cpp | #define STRICT
#include <windows.h>
#include <iostream>
int main(int argc, char* argv[])
{
if (argc < 3) {
std::cout << "Renames file that is currently in use.\n"
"\nUSAGE:\n\tmvinuse <src> <dst>\n";
return -1;
}
BOOL res = MoveFileEx(argv[1], argv[2], MOVEFILE_DELAY_UNTIL_REBOOT);
if (!res) {
DWORD err = GetLastError();
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
std::cerr << "ERROR: " << lpMsgBuf << std::endl;
LocalFree( lpMsgBuf );
return err;
}
else {
std::cout << "Now, reboot the computer.\n";
return 0;
}
} | [
"george@sudarkoff.com"
] | george@sudarkoff.com |
fa5616bb814864d57b6da7c6fff39c044322ad63 | 9763c69ff8a2d338bea4e7d57ae1d4f32c3a8a9a | /ethernet_tcp_relay/ethernet_tcp_relay.ino | e5eb775a27763894a959c824c08d3b80fd0675c0 | [] | no_license | appspace/arduino | 6840e7e341b755c12615fe16bfc2a5a7a916d74a | 41e33a6767caf871a6d14fa5aac8678f0c8ac7fa | refs/heads/master | 2020-05-17T23:09:06.160534 | 2014-10-09T03:07:27 | 2014-10-09T03:07:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,095 | ino | #include <SPI.h>
#include <Ethernet.h>
//#include <EthernetUdp.h>
#include <LiquidCrystal.h>
const byte LCD_RS = 48; const byte LCD_E = 49;
const byte LCD_D4 = 44; const byte LCD_D5 = 45;
const byte LCD_D6 = 46; const byte LCD_D7 = 47;
int RELAY_ON = LOW;
int RELAY_OFF = HIGH;
int relayPin[] = {31, 33, 35, 37, 39};
boolean relayState[] = {RELAY_OFF, RELAY_OFF, RELAY_OFF, RELAY_OFF, RELAY_OFF};
const int pinsConnected = 5;
byte mac[] = { 0xEE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 177);
IPAddress gateway(192,168,1, 1);
IPAddress subnet(255, 255, 0, 0);
unsigned long port = 1981;
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
EthernetServer server(port);
boolean alreadyConnected = false; // whether or not the client was connected previously
LiquidCrystal lcd(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7);
void setup() {
lcd.begin(16, 2);
initRelay();
initDHCPNetwork();
printNetworkInfo();
Serial.begin(115200);
Serial.print("Relay server address:");
Serial.println(Ethernet.localIP());
}
void printNetworkInfo() {
lcd.clear();
lcd.print(Ethernet.localIP()[0], DEC);
lcd.print(".");
lcd.print(Ethernet.localIP()[1], DEC);
lcd.print(".");
lcd.print(Ethernet.localIP()[2], DEC);
lcd.print(".");
lcd.print(Ethernet.localIP()[3], DEC);
lcd.setCursor(0, 1);
lcd.print("Port: ");
lcd.print(port, DEC);
}
void initStaticNetwork() {
Ethernet.begin(mac, ip, gateway, subnet);
server.begin();
}
void initDHCPNetwork() {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("DHCP Init");
if (Ethernet.begin(mac)==0) {
lcd.setCursor(0, 0);
lcd.print("DHCP failure");
lcd.setCursor(0, 1);
lcd.print("Cannot obtain IP");
for(;;) ;
}
}
void initRelay() {
lcd.setCursor(0,0);
lcd.print("Relay Pins Init");
for (int i=0; i<pinsConnected; i++) {
pinMode(relayPin[i], OUTPUT);
digitalWrite(relayPin[i], RELAY_OFF);
}
}
void loop() {
// wait for a new client:
EthernetClient client = server.available();
// when the client sends the first byte, say hello:
if (client) {
if (!alreadyConnected) {
// clead out the input buffer:
client.flush();
Serial.println("We have a new client");
client.println("Hello, client!");
alreadyConnected = true;
}
if (client.available() > 0) {
// read the bytes incoming from the client:
char thisChar = client.read();
// echo the bytes back to the client:
server.write(thisChar);
// echo the bytes to the server as well:
Serial.write(thisChar);
int relayInput = thisChar - 49;
if (relayInput>=0 && relayInput<pinsConnected) {
boolean state = relayState[relayInput];
state = !state;
Serial.print("Setting pin ");
Serial.print(relayInput, DEC);
Serial.print(" to ");
Serial.println(state, BIN);
relayState[relayInput] = state;
}
}
activateRelays();
}
}
void activateRelays() {
for (int i=0; i<pinsConnected; i++) {
digitalWrite(relayPin[i], relayState[i]);
}
}
| [
"eugenes.mobile@gmail.com"
] | eugenes.mobile@gmail.com |
a6b470acab9800e54f320aedd081fb28c62315de | 4e3300ebbbc59e9e8528670ff1499c9df4fe21b9 | /source/render/NPlot/NPlotWidgetScope.cpp | e63e000a3da8e3c7873dfb6a4f684602e782dbfe | [] | no_license | droggen/Labeller | 6966da0649c131beea9721b60c34d41700295750 | 1120345a17f51940772d0dd8ec1fa2b3a2b1e3dc | refs/heads/master | 2022-11-29T20:07:23.446813 | 2020-08-13T16:14:56 | 2020-08-13T16:14:56 | 280,924,085 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,010 | cpp | #include "NPlotWidgetScope.h"
#include "SDL_gfxPrimitives_font.h"
NPlotWidgetScope::NPlotWidgetScope(QWidget * parent, Qt::WindowFlags f)
: NPlotWidgetBase(parent,f)
, Scope(0,0,2,2)
, alpha(false)
{
}
NPlotWidgetScope::~NPlotWidgetScope()
{
}
void NPlotWidgetScope::setData(const vector<vector<int> *> &_v,const vector<unsigned> &_color)
{
v=_v;
color=_color;
}
void NPlotWidgetScope::setAlpha(bool _alpha)
{
alpha=_alpha;
}
void NPlotWidgetScope::setSampleOffset(int co)
{
NPlotWidgetBase::setSampleOffset(co);
offsetsample = co;
}
void NPlotWidgetScope::plot()
{
painter.begin(&pixmap);
Scope::Plot(v,color);
painter.end();
NPlotWidgetBase::plot();
}
void NPlotWidgetScope::cleararea()
{
painter.setClipRect(basex,basey,w,h);
// Optimized version for 32-bit that keeps the alpha channel unchanged.
if( pixmap.format()==QImage::Format_RGB32 ||
pixmap.format()==QImage::Format_ARGB32 ||
pixmap.format()==QImage::Format_ARGB32_Premultiplied
)
{
rgb = pixmap.bits();
bpl = pixmap.bytesPerLine();
unsigned char *pixel,*pixelline;
pixel = rgb+4*basex+bpl*basey;
if(alpha)
{
// Optimized fadeout
for(unsigned y=0;y<h;y++)
{
pixelline=pixel;
for(unsigned x=0;x<w;x++)
{
// Read pixel
unsigned p=*(unsigned *)pixelline;
// Write divided by 2 (alpha=128) with corrected shifted bits.
*(unsigned *)pixelline = ((p>>1)&0x7f7f7f);
pixelline+=4;
}
pixel+=bpl;
}
}
else
{
// Clear.
for(unsigned y=0;y<h;y++)
{
pixelline=pixel;
for(unsigned x=0;x<w;x++)
{
// Keep alpha, clear RGB
*(unsigned *)pixelline = 0;
pixelline+=4;
}
pixel+=bpl;
}
}
}
else
{
// Unoptimized (non 32-bit)
if(alpha)
{
// QT version of fadeout.
painter.fillRect(basex,basey,w,h,QColor(0,0,0,208));
}
else
{
// QT version of clear.
painter.fillRect(basex,basey,w,h,QColor(0,0,0,255));
}
}
}
void NPlotWidgetScope::fastPixelColor(int x,int y,unsigned color)
{
painter.setPen(color);
painter.drawPoint(basex+x,basey+y);
}
void NPlotWidgetScope::lineColor(int x1,int y1,int x2,int y2,unsigned color)
{
painter.setPen(color);
painter.drawLine(basex+x1,basey+y1,basex+x2,basey+y2);
}
void NPlotWidgetScope::hLineColor(int x1,int y,int x2,unsigned color)
{
//if(pixmap->format()==QImage::Format_RGB32)
if( pixmap.format()==QImage::Format_RGB32 ||
pixmap.format()==QImage::Format_ARGB32 ||
pixmap.format()==QImage::Format_ARGB32_Premultiplied
)
//if(0)
{
int xtmp;
// Sort
if (x1 > x2) {
xtmp = x1;
x1 = x2;
x2 = xtmp;
}
//Check visibility of vline
if((y<0) || (y>=h))
return;
if((x1<0) && (x2<0))
return;
if((x1>=w) && (x2>=w))
return;
// Clip y
if(x1<0)
x1 = 0;
if(x2>=w)
x2=w-1;
// Rebase
x1+=basex;
x2+=basex;
y+=basey;
unsigned char *pixel,*pixellast;
pixel = rgb + 4*x1 + bpl*y;
pixellast = pixel + 4*(x2-x1);
for(;pixel<=pixellast;pixel+=4)
*(unsigned *)pixel=color;
}
else
{
lineColor(x1,y,x2,y,color);
}
}
void NPlotWidgetScope::fasthLineColor(int x1, int y, int x2, unsigned color)
{
hLineColor(x1,y,x2,color);
//lineColor(x1,y,x2,y,color);
}
void NPlotWidgetScope::vLineColor(int x,int y1,int y2,unsigned color)
{
//if(pixmap->format()==QImage::Format_RGB32)
if( pixmap.format()==QImage::Format_RGB32 ||
pixmap.format()==QImage::Format_ARGB32 ||
pixmap.format()==QImage::Format_ARGB32_Premultiplied
)
//if(0)
{
int ytmp;
// Sort
if (y1 > y2) {
ytmp = y1;
y1 = y2;
y2 = ytmp;
}
//Check visibility of vline
if((x<0) || (x>=w))
return;
if((y1<0) && (y2<0))
return;
if((y1>=h) && (y2>=h))
return;
// Clip y
if(y1<0)
y1 = 0;
if(y2>=h)
y2=h-1;
// Rebase
x+=basex;
y1+=basey;
y2+=basey;
// Height
int h=y2-y1;
//int bpl = 1;
unsigned char *pixel,*pixellast;
pixel = rgb + 4*x + bpl*y1;
pixellast = pixel + bpl*h;
for(;pixel<=pixellast;pixel+=bpl)
*(unsigned *)pixel=color;
}
else
{
//painter.fillRect(x1,y1,1,y2-y1+1,QColor(color));
lineColor(x,y1,x,y2,color);
}
// lineColor(x,y1,x1,y2,color);
}
void NPlotWidgetScope::fastvLineColor(int x, int y1, int y2, unsigned color)
{
vLineColor(x,y1,y2,color);
//lineColor(x,y1,x,y2,color);
}
void NPlotWidgetScope::fastStringColor(int x,int y,const char *s,unsigned color)
{
/* painter.setPen(color);
QFont f("Helvetica");
f.setPixelSize(11);
//f.setFixedPitch(true);
painter.setFont(f);
painter.drawText(basex+x,basey+y,s);
return;*/
//return;
// Empty string
if(*s==0)
return;
if(x<0 || y<0)
return;
if(y+7>=h)
return;
if(x+8*strlen(s)>=w)
return;
if(pixmap.format()!=QImage::Format_RGB32) // RGB32 is optimized
painter.setPen(color);
do
{
icharacterColor(x,y,*s,color);
x+=8;
}
while(*++s);
}
void NPlotWidgetScope::icharacterColor(int x,int y,char c,unsigned color)
{
unsigned char *data;
data = gfxPrimitivesFontdata+c*8;
unsigned char mask;
//if(pixmap->format()==QImage::Format_RGB32)
if( pixmap.format()==QImage::Format_RGB32 ||
pixmap.format()==QImage::Format_ARGB32 ||
pixmap.format()==QImage::Format_ARGB32_Premultiplied
)
//if(0)
{
x+=basex;
y+=basey;
unsigned pitch = pixmap.bytesPerLine();
unsigned char *p = pixmap.bits() + y*pitch + x*4;
for (int iy = 0; iy < 8; iy++)
{
mask=0x80;
for (int ix = 0; ix < 8; ix++)
{
if(*data&mask)
{
*(unsigned*)p=color;
}
mask>>=1;
p+=4;
}
data++;
p+=pitch-32;
}
}
else
{
for (int iy = 0; iy < 8; iy++)
{
mask=0x80;
for (int ix = 0; ix < 8; ix++)
{
if(*data&mask)
{
painter.drawPoint(basex+x+ix,basey+y+iy);
}
mask>>=1;
}
data++;
}
}
}
unsigned NPlotWidgetScope::fastColor(unsigned color)
{
return color;
}
void NPlotWidgetScope::fastStart()
{
//printf("S %p. T: %d. A: %d. px: %p f:%d x,y,w,h: %d,%d %d,%d\n",this,transparent,alpha,pixmap,pixmap->format(),basex,basey,w,h);
rgb = pixmap.bits();
bpl = pixmap.bytesPerLine();
}
void NPlotWidgetScope::fastStop()
{
return;
}
unsigned NPlotWidgetScope::ColorBlack()
{
return 0xff000000;
}
unsigned NPlotWidgetScope::ColorWhite()
{
return 0xffffffff;
}
unsigned NPlotWidgetScope::ColorGrey()
{
return 0xff7f7f7f;
}
unsigned NPlotWidgetScope::ColorLGrey()
{
return 0xff3f3f3f;
}
unsigned NPlotWidgetScope::ColorRed()
{
return 0xffff0000;
}
void NPlotWidgetScope::resizeEvent(QResizeEvent *event)
{
//printf("NPlotWidgetScope::resizeEvent: new size %d,%d.\n",event->size().width(),event->size().height());
Scope::Resize(0,0,event->size().width()/scale,event->size().height()/scale);
// Create a temporary event to fake the scaled size
QSize s(event->size().width()/scale,event->size().height()/scale);
QResizeEvent event2(s,event->oldSize());
//NPlotWidgetBase::resizeEvent(event); // Original
NPlotWidgetBase::resizeEvent(&event2); // With scale
event->accept();
}
void NPlotWidgetScope::mouseMoveEvent ( QMouseEvent * event )
{
//printf("mouseMoveEvent\n");
emit mouseMoved(x2s(event->x()/scale));
event->accept();
}
void NPlotWidgetScope::mousePressEvent ( QMouseEvent * event )
{
// signal / slot
emit mousePressed(event->button(),x2s(event->x()/scale));
//printf("mouse pressed: %d %d %d\n",event->x(),event->y(),event->button());
//printf("Converstion of pix -> sample %d -> %d\n",event->x(),x2s(event->x()));
switch(event->button())
{
case Qt::MidButton:
switch(event->modifiers())
{
case Qt::ShiftModifier:
SetVAuto();
break;
case Qt::NoModifier:
HZoomReset();
emit zoomHReseted();
break;
default:
event->ignore();
return;
}
break;
default:
event->ignore();
return;
}
event->accept();
repaint();
}
void NPlotWidgetScope::mouseReleaseEvent ( QMouseEvent * event )
{
// signal / slot
emit mouseReleased(event->button(),x2s(event->x()/scale));
event->ignore();
repaint();
}
void NPlotWidgetScope::wheelEvent (QWheelEvent * event)
{
QWidget::wheelEvent(event);
if(event->delta()>0)
{
if(event->modifiers()==Qt::ShiftModifier)
VZoomin();
if(event->modifiers()==Qt::ControlModifier)
PanDown();
if(event->modifiers()==Qt::NoModifier) {
HZoomin();
emit zoomHInned();
}
}
else
{
if(event->modifiers()==Qt::ShiftModifier)
VZoomout();
if(event->modifiers()==Qt::ControlModifier)
PanUp();
if(event->modifiers()==Qt::NoModifier) {
HZoomout();
emit zoomHOuted();
}
}
event->accept();
repaint();
}
void NPlotWidgetScope::keyPressEvent(QKeyEvent * event)
{
//printf("Key press event %d\n",event->key());
if(event->key()==Qt::Key_Up)
{
PanUp();
}
if(event->key()==Qt::Key_Down)
{
PanDown();
}
if(event->key()==Qt::Key_Left)
{
emit panLeft();
}
if(event->key()==Qt::Key_Right)
{
emit panRight();
}
if(event->key()==Qt::Key_PageUp)
{
// Zoom
if(event->modifiers()==Qt::ShiftModifier)
VZoomin();
if(event->modifiers()==Qt::NoModifier) {
HZoomin();
emit zoomHInned();
}
}
if(event->key()==Qt::Key_PageDown)
{
// Zoom
if(event->modifiers()==Qt::ShiftModifier)
VZoomout();
if(event->modifiers()==Qt::NoModifier) {
HZoomout();
emit zoomHOuted();
}
}
if(event->key()==Qt::Key_Return)
{
if(event->modifiers()==Qt::ShiftModifier)
SetVAuto();
if(event->modifiers()==Qt::NoModifier) {
HZoomReset();
emit zoomHReseted();
}
}
QPoint p = mapFromGlobal(QCursor::pos());
int sx = x2s(p.x());
//printf("mouse coord?: %d %d -> %d\n",p.x(),p.y(),sx);
emit keyPressed(event->key(),sx);
event->accept();
repaint();
}
| [
"droggen@gmail.com"
] | droggen@gmail.com |
3b238e15441879df39e339e8d10231f70940900b | bebb909a566c046afe55348f266982c678b45dde | /include/bitmanip/build.hpp | 2edfa392ea85e30c4f6cdb7ab8e95f221192bd47 | [
"MIT"
] | permissive | Eisenwave/bitmanip | 7b11529a723500613ebe1566a7705d6eb5765f40 | 5160121631db0fae01d60c58d03ddd7878bbb3a0 | refs/heads/master | 2023-07-19T11:01:01.239940 | 2021-09-28T15:50:44 | 2021-09-28T15:50:44 | 273,203,441 | 15 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 4,725 | hpp | #ifndef BITMANIP_BUILD_HPP
#define BITMANIP_BUILD_HPP
/*
* build.hpp
* -----------
* Captures information about the build, such as the C++ standard, compiler, debug/release build, etc.
*
* This header does not and should never have additional includes.
* See https://godbolt.org/z/xza5qY for testing.
*/
// C++ STANDARD DETECTION ==============================================================================================
#if __cplusplus >= 199711L
#define BITMANIP_CPP98_LEAST
#endif
#if __cplusplus >= 201103L
#define BITMANIP_CPP11_LEAST
#endif
#if __cplusplus >= 201402L
#define BITMANIP_CPP14_LEAST
#endif
#if __cplusplus >= 201703L
#define BITMANIP_CPP17_LEAST
#endif
#if __cplusplus >= 202002L
#define BITMANIP_CPP20_LEAST
#endif
#if __cplusplus == 199711L
#define BITMANIP_CPP98
#elif __cplusplus == 201103L
#define BITMANIP_CPP11
#elif __cplusplus == 201402L
#define BITMANIP_CPP14
#elif __cplusplus == 201703L
#define BITMANIP_CPP17
#elif __cplusplus == 202002L
#define BITMANIP_CPP20
#endif
// COMPILER DETECTION ==================================================================================================
#ifdef _MSC_VER
#define BITMANIP_MSVC _MSC_VER
#endif
#ifdef __GNUC__
#define BITMANIP_GNU_OR_CLANG
#endif
#ifdef __clang__
#define BITMANIP_CLANG __clang_major__
#endif
#if defined(__GNUC__) && !defined(__clang__)
#define BITMANIP_GNU __GNUC__
#endif
// Ensure that alternative operator keywords like not, and, etc. exist for MSVC (they don't by default).
// In C++20, the <ciso646> header was removed from the standard.
#if defined(BITMANIP_MSVC) && !defined(BITMANIP_CPP20_LEAST)
#include <ciso646>
#endif
#ifdef BITMANIP_GNU_OR_CLANG
#define BITMANIP_FWDHEADER(header) <bits/header##fwd.h>
#else
#define BITMANIP_FWDHEADER(header) <header>
#endif
// ARCH DETECTION ======================================================================================================
#ifdef __i386__
#define BITMANIP_X86
#endif
#ifdef __x86_64__
#define BITMANIP_X64
#endif
#ifdef _M_IX86
#define BITMANIP_X86
#endif
#ifdef _M_AMD64
#define BITMANIP_X64
#endif
#ifdef _M_ARM64
#define BITMANIP_ARM64
#endif
#if defined(BITMANIP_X86) || defined(BITMANIP_X64)
#define BITMANIP_X86_OR_X64
#endif
#if defined(BITMANIP_X64) || defined(BITMANIP_ARM64)
#define BITMANIP_64_BIT
#endif
// OS DETECTION ========================================================================================================
#ifdef __unix__
#define BITMANIP_UNIX
#endif
// ENDIANNES DETECTION =================================================================================================
/*
* In this section, the bool constant NATIVE_ENDIAN_LITTLE is defined.
* This happens either using __BYTE_ORDER__ macros or C++20's std::endian.
*/
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__
// C++17 ENDIANNESS DETECTION USING __BYTE__ORDER MACRO ----------------------------------------------------------------
namespace bitmanip::build {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
constexpr bool NATIVE_ENDIAN_LITTLE = true;
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
constexpr bool NATIVE_ENDIAN_LITTLE = false;
#elif __BYTE_ORDER == __ORDER_PDP_ENDIAN__
#error "voxelio can't compile on platforms with PDP endianness"
#else
#error "__BYTE_ORDER__ has unrecognized value"
#endif
} // namespace bitmanip::build
#elif BITMANIP_CPP20_LEAST
// C++20 ENDIANNESS DETECTION ------------------------------------------------------------------------------------------
#include <bit>
namespace voxelio::build {
constexpr bool NATIVE_ENDIAN_LITTLE = std::endian::native == std::endian::little;
} // namespace voxelio::build
#elif defined(BITMANIP_X86_OR_X64)
// ARCHITECTURE BASED ENDIANNESS DETECTION -----------------------------------------------------------------------------
namespace voxelio::build {
constexpr bool NATIVE_ENDIAN_LITTLE = true;
} // namespace voxelio::build
#else
#error "Failed to detect platform endianness"
#endif
// ENDIAN ENUM =========================================================================================================
namespace bitmanip::build {
/**
* @brief Represents a byte order. Can be either Big Endian or Little Endian.
*/
enum class Endian : unsigned {
/// Least significant byte first.
LITTLE = 0,
/// Most significant byte first.
BIG = 1,
NATIVE = NATIVE_ENDIAN_LITTLE ? LITTLE : BIG
};
} // namespace bitmanip::build
// SOURCE LOCATION =====================================================================================================
namespace bitmanip {
struct SourceLocation {
const char *file;
const char *function;
unsigned long line;
};
} // namespace bitmanip
#endif // BITMANIP_BUILD_HPP
| [
"me@eisenwave.net"
] | me@eisenwave.net |
c9d75442edcf3767d81dcc76599b83911b15e801 | 0ca42c18e18b73fb8ea824113d2e6cd2f8584602 | /HexaVectorWin32Console/lib/RawStrHexaDecimal.h | 7164625ab957ec2d7c4ac6ad4811935f6e75b506 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | YuhichYOC/HexaVectorWin32Console | 5931800eb7d329a2705f65fe8b77b9c76c552a3f | 838663ee36ec9b05d19261cc40c0415f9b051554 | refs/heads/master | 2020-05-23T08:11:04.494105 | 2017-05-05T07:51:55 | 2017-05-05T07:51:55 | 70,298,625 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 941 | h | #ifdef RAWSTRHEXADECIMAL_EXPORTS
#define RAWSTRHEXADECIMAL_API __declspec(dllexport)
#else
#define RAWSTRHEXADECIMAL_API __declspec(dllimport)
#endif // RAWSTRHEXADECIMAL_EXPORTS
#pragma once
#include "stdafx.h"
#include "IHexaDecimal.h"
namespace HexaDecimalWin32
{
class RawStrHexaDecimal : public IHexaDecimal
{
private:
int mySize;
std::vector<HexaByte> * hexaValue;
std::string * myValue;
public:
ValueType GetType();
void SetSize(int arg);
int GetSize();
void SetHexa(std::vector<HexaByte> * arg);
std::vector<HexaByte> * GetHexa();
void SetValue(std::string * arg);
std::string * GetValue();
int GetNumericValue();
std::string GetRawValue();
void HexaToValue();
void ValueToHexa();
RawStrHexaDecimal();
~RawStrHexaDecimal();
};
}
using namespace HexaDecimalWin32;
| [
"y@DESKTOP-20VAU6S"
] | y@DESKTOP-20VAU6S |
88013e4e5ea9c1b974583d9d96c25c98044aa95f | 2af6cd77013844234c2dca0e34cb44dcd25cba20 | /codeforces/499B.cpp | 7b8b8895126170d5c4536654919acd17777610d4 | [] | no_license | SwampertX/judge_adventures | d593c8090b78a4aee6e467b3a5492c7b6e019fd1 | 7838eb6249f23f48da7ae0b2714a3bcd1e0fb721 | refs/heads/master | 2021-06-30T05:53:08.361556 | 2020-12-08T15:57:17 | 2020-12-08T15:57:17 | 165,352,481 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 426 | cpp | #include <bits/stdc++.h>
#define INF 2e18
#define MOD 10000007
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int n,m;
map<string,string> stlg;
int main(){
cin>>n>>m;
while(m--){
string s1,s2;cin>>s1>>s2;
stlg[s1]=(s1.length()<=s2.length()?s1:s2);
}
while(n--){
string s; cin>>s;
cout<<stlg[s]<<' ';
}
return 0;
}
| [
"tanyeejian@gmail.com"
] | tanyeejian@gmail.com |
3c82e1947229ddb771c66159767cd181d493d6cd | c365d25ee2237b3c260198827b33b0253d43eaf4 | /desafios/9298340-batch1/9298340-A04-PD/d.cpp | 0701789ed5eeb427f5d4ce4ee5773c1b0c437931 | [] | no_license | germanohn/competitive-programming | fb1249910ce951fe290e9a5be3876d3870ab8aa3 | fab9dc0e2998dd395c1b9d6639f8c187cf637669 | refs/heads/master | 2021-06-12T08:17:52.907705 | 2021-03-17T19:06:19 | 2021-03-17T19:06:19 | 58,595,999 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,007 | cpp | #include <bits/stdc++.h>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define debug(args...) fprintf (stderr, args)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
// ATENCAO: cuidado com as variรกveis dadas no exercรญcio, nao as reutilize
ll fexp (ll b, ll e, ll mod) {
if (e == 0) return 1;
if (e == 1) return b % mod;
if (e % 2 == 0) return fexp (b*b % mod, e/2, mod) % mod;
return (b * fexp (b*b % mod, e/2, mod)) % mod;
}
int main () {
int t;
scanf ("%d", &t);
while (t--) {
int n, p, q;
scanf ("%d", &n);
for (int i = 2; i*i <= n; i++) {
if (n % i == 0) {
p = i, q = n/i;
break;
}
}
int phi = (p-1)*(q-1);
printf ("0 1 ");
int a, b;
a = (p * fexp (p % q, phi-1, q)) % n;
b = (q * fexp (q % p, phi-1, p)) % n;
if (a > b) swap (a, b);
printf ("%d %d\n", a, b);
}
}
| [
"Germano@Air-de-Germano.home"
] | Germano@Air-de-Germano.home |
ce5f53304855c095ae155ec0d6c5d085c726bc55 | b65982b9f43db47ac6a7b055d0d2eebad10a1597 | /CSES-Problem-master/Additional/prufer.cpp | 4a3140a7918cb941d8b5f80463486e5a03e99a72 | [] | no_license | HarshitVerma1/Competitive_Coding_Study_Material | 1a419f3a603e65e523103216aecab688a0203604 | 10657c26197174070d8767ddc1c0e640a672d3d0 | refs/heads/main | 2023-07-27T20:49:22.127595 | 2021-09-03T18:01:46 | 2021-09-03T18:01:46 | 335,115,275 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 870 | cpp | #include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <list>
#include <utility>
using namespace std;
int main()
{
int n;
cin >> n;
int counting[n] = {0};
set<int> set2;
for(int i=0;i<n;i++){
set2.insert(i);
}
vector<int> prufer(n-2);
for(int& x : prufer){
cin >> x;
--x;
counting[x]++;
set2.erase(x);
}
list<pair<int,int>> ans;
for(int x : prufer){
int y = *set2.begin();
ans.push_back({y,x});
set2.erase(y);
counting[x]--;
if(counting[x] == 0){
set2.insert(x);
}
}
set<int> :: iterator it,it2;
it = set2.begin();
it2 = it;
it++;
ans.push_back({*it,*it2});
for(pair<int,int> x : ans){
cout << x.first + 1 << ' ' << x.second + 1 << '\n';
}
return 0;
} | [
"harshitverma14366@gmail.com"
] | harshitverma14366@gmail.com |
6fb5c1daa8133c73a25017b69a971aac2fbf1335 | b6450920eea267353cf42a352a2199eab1c52683 | /src/IO/ParticleWriter.cpp | 760fb391dc68e218ea270e394490fe106554aeef | [
"BSD-2-Clause"
] | permissive | adityaIyerramesh98/quinoa | 2669cec1ba66c0a91a10120c714af7711957f060 | 81024013472ec286aa53ce1f0425580df7d5e047 | refs/heads/master | 2022-09-09T03:26:51.109709 | 2019-09-11T23:15:06 | 2019-09-11T23:15:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 660 | cpp | // *****************************************************************************
/*!
\file src/IO/ParticleWriter.cpp
\copyright 2012-2015 J. Bakosi,
2016-2018 Los Alamos National Security, LLC.,
2019 Triad National Security, LLC.
All rights reserved. See the LICENSE file for details.
\brief Charm++ group for outputing particle data to file via H5Part
\details Charm++ group for outputing particle data to file via H5Part in
parallel using MPI-IO.
*/
// *****************************************************************************
#include "ParticleWriter.hpp"
#include "particlewriter.def.h"
| [
"jbakosi@lanl.gov"
] | jbakosi@lanl.gov |
6c168101c929c0c3ae90c00b6dff38aaa8f9cad3 | 6372f95e2ea3ae0fff7d946c09c710bbd56092b4 | /Development/Plugin/Warcraft3/yd_jass_api/DisableButtonBlp.cpp | b65537c7ac3509c10389ff5867222528d5897a36 | [
"Apache-2.0"
] | permissive | ttitt/YDWE | 341aa73e6d9e9ae8354b581aebb7f9981c09f7e0 | 427999a596309ef66982650592bf9ffe7e595f19 | refs/heads/master | 2021-01-20T16:28:58.344790 | 2017-06-24T05:00:33 | 2017-06-24T05:00:33 | 95,728,505 | 0 | 0 | null | 2017-06-29T02:01:41 | 2017-06-29T02:01:41 | null | GB18030 | C++ | false | false | 10,943 | cpp | #include <base/hook/iat.h>
#include <base/hook/fp_call.h>
#include <base/filesystem.h>
#include <base/path/helper.h>
#include <base/file/stream.h>
#include <base/warcraft3/virtual_mpq.h>
#include <base/warcraft3/jass/hook.h>
#include <base/warcraft3/jass.h>
#include <base/warcraft3/event.h>
#include <BlpConv/BlpConv.h>
#include <BlpConv/Blp.h>
#include <algorithm>
#include <map>
#include <stdint.h>
namespace base { namespace warcraft3 { namespace japi {
uint32_t kPasButton[] = {
#include "PasButton.h"
};
static inline unsigned char clamp_channel_bits8(int c)
{
if (c > 255)
return 255;
if (c < 0)
return 0;
return static_cast<unsigned char>(c);
}
static const size_t kBlpSize = 64;
bool BlpDisable(const IMAGE::BUFFER& input, IMAGE::BUFFER& output)
{
int input_width = 0;
int input_height = 0;
IMAGE::BUFFER input_pic, output_pic;
if (!IMAGE::BLP().Read(input, input_pic, &input_width, &input_height))
{
return false;
}
if (input_width != kBlpSize || input_height != kBlpSize)
{
return false;
}
output_pic.Resize(kBlpSize * kBlpSize * 4);
unsigned char* ptr = output_pic.GetData();
bool enable = false;
for (size_t i = 0; i < kBlpSize * kBlpSize; ++i)
{
IMAGE::BLP_RGBA const& pixel_a = reinterpret_cast<IMAGE::BLP_RGBA*>(kPasButton)[i];
IMAGE::BLP_RGBA const& pixel_b = reinterpret_cast<IMAGE::BLP_RGBA*>(input_pic.GetData())[i];
*ptr = clamp_channel_bits8(((255 - pixel_a.Alpha) * pixel_b.Red + pixel_a.Red) / (255 * 2));
if (*ptr++ > 63) enable = true;
*ptr = clamp_channel_bits8(((255 - pixel_a.Alpha) * pixel_b.Green + pixel_a.Green) / (255 * 2));
if (*ptr++ > 63) enable = true;
*ptr = clamp_channel_bits8(((255 - pixel_a.Alpha) * pixel_b.Blue + pixel_a.Blue) / (255 * 2));
if (*ptr++ > 63) enable = true;
*ptr++ = clamp_channel_bits8(255 - (255 - pixel_a.Alpha) * (255 - pixel_b.Alpha) / 255);
}
if (!enable)
{
ptr = output_pic.GetData();
for (size_t i = 0; i < kBlpSize * kBlpSize; ++i)
{
*ptr++ *= 2;
*ptr++ *= 2;
*ptr++ *= 2;
ptr++;
}
}
if (!IMAGE::BLP().Write(output_pic, output, kBlpSize, kBlpSize, 95))
{
return false;
}
return true;
}
bool BlpBlend(const IMAGE::BUFFER& input_a, const IMAGE::BUFFER& input_b, IMAGE::BUFFER& output)
{
int input_width = 0;
int input_height = 0;
IMAGE::BUFFER input_a_pic, input_b_pic, output_pic;
if (!IMAGE::BLP().Read(input_a, input_a_pic, &input_width, &input_height))
{
return false;
}
if (input_width != kBlpSize || input_height != kBlpSize)
{
return false;
}
if (!IMAGE::BLP().Read(input_b, input_b_pic, &input_width, &input_height))
{
return false;
}
if (input_width != kBlpSize || input_height != kBlpSize)
{
return false;
}
output_pic.Resize(kBlpSize * kBlpSize * 4);
unsigned char* ptr = output_pic.GetData();
for (size_t i = 0; i < kBlpSize * kBlpSize; ++i)
{
IMAGE::BLP_RGBA const& pixel_a = reinterpret_cast<IMAGE::BLP_RGBA*>(input_a_pic.GetData())[i];
IMAGE::BLP_RGBA const& pixel_b = reinterpret_cast<IMAGE::BLP_RGBA*>(input_b_pic.GetData())[i];
*ptr++ = clamp_channel_bits8(((255 - pixel_a.Alpha) * pixel_b.Red + pixel_a.Alpha * pixel_a.Red) / 255);
*ptr++ = clamp_channel_bits8(((255 - pixel_a.Alpha) * pixel_b.Green + pixel_a.Alpha * pixel_a.Green) / 255);
*ptr++ = clamp_channel_bits8(((255 - pixel_a.Alpha) * pixel_b.Blue + pixel_a.Alpha * pixel_a.Blue) / 255);
*ptr++ = clamp_channel_bits8(255 - (255 - pixel_a.Alpha) * (255 - pixel_b.Alpha) / 255);
}
if (!IMAGE::BLP().Write(output_pic, output, kBlpSize, kBlpSize, 95))
{
return false;
}
return true;
}
std::string ToFileName(const std::string& file)
{
size_t pos = file.find_last_of('\\');
if (pos == std::string::npos)
{
return file;
}
return file.substr(pos + 1, std::string::npos);
}
namespace real
{
uintptr_t SMemAlloc = 0;
uintptr_t SFileLoadFile = 0;
uintptr_t SFileUnloadFile = 0;
}
namespace fake
{
template <class T>
struct less
{
bool operator()(const T& lft, const T& rht) const
{
return (lft < _Right);
}
};
template <>
struct less<char>
{
bool operator()(const char& lft, const char& rht) const
{
return (tolower(static_cast<unsigned char>(lft)) < tolower(static_cast<unsigned char>(rht)));
}
};
template <>
struct less<std::string>
{
bool operator()(const std::string& lft, const std::string& rht) const
{
return std::lexicographical_compare(lft.begin(), lft.end(), rht.begin(), rht.end(), less<char>());
}
};
static std::map<std::string, std::string, less<std::string>> g_history;
static std::map<std::string, IMAGE::BUFFER, less<std::string>> g_virtualblp;
static std::string g_lastfilepath;
void* SMemAlloc(size_t amount)
{
return base::std_call<void*>(real::SMemAlloc, amount, ".\\SFile.cpp", 4072, 0);
}
bool read_virtual_button_blp(const char* filepath, IMAGE::BUFFER& blp)
{
auto it = g_virtualblp.find(filepath);
if (it == g_virtualblp.end())
{
return false;
}
blp.Assign(it->second.begin(), it->second.end());
return true;
}
bool read_virtual_button_blp(const char* filepath, const void** buffer_ptr, uint32_t* size_ptr, uint32_t reserve_size, OVERLAPPED* overlapped_ptr)
{
auto it = g_virtualblp.find(filepath);
if (it == g_virtualblp.end())
{
return false;
}
IMAGE::BUFFER& blp = it->second;
void* result = SMemAlloc(blp.GetSize() + reserve_size);
if (!result)
{
return false;
}
memcpy(result, blp.GetData(), blp.GetSize());
*buffer_ptr = result;
if (reserve_size) memset((unsigned char*)result + blp.GetSize(), 0, reserve_size);
if (size_ptr) *size_ptr = blp.GetSize();
if (overlapped_ptr && overlapped_ptr->hEvent) ::SetEvent(overlapped_ptr->hEvent);
return true;
}
bool read_button_blp(const char* filepath, IMAGE::BUFFER& blp)
{
if (read_virtual_button_blp(filepath, blp))
{
return true;
}
const void* buffer = 0;
uint32_t size = 0;
if (!base::std_call<bool>(real::SFileLoadFile, filepath, &buffer, &size, 0, 0))
{
return false;
}
blp.Assign((const char*)buffer, (const char*)buffer + size);
base::std_call<bool>(real::SFileUnloadFile, buffer);
return true;
}
bool disable_button_blp(const char* filename, const void** buffer_ptr, uint32_t* size_ptr, uint32_t reserve_size)
{
IMAGE::BUFFER input;
IMAGE::BUFFER output;
if (!read_button_blp(filename, input))
{
return false;
}
if (!BlpDisable(input, output))
{
return false;
}
void* result = SMemAlloc(output.GetSize() + reserve_size);
if (!result)
{
return false;
}
memcpy(result, output.GetData(), output.GetSize());
*buffer_ptr = result;
if (reserve_size) memset((unsigned char*)result + output.GetSize(), 0, reserve_size);
if (size_ptr) *size_ptr = output.GetSize();
return true;
}
int __stdcall SFileLoadFile(const char* filepath, const void** buffer_ptr, uint32_t* size_ptr, uint32_t reserve_size, OVERLAPPED* overlapped_ptr)
{
if (!buffer_ptr || !filepath)
{
return base::std_call<int>(real::SFileLoadFile, filepath, buffer_ptr, size_ptr, reserve_size, overlapped_ptr);
}
if (read_virtual_button_blp(filepath, buffer_ptr, size_ptr, reserve_size, overlapped_ptr))
{
g_lastfilepath = filepath;
return 1;
}
int suc = base::std_call<int>(real::SFileLoadFile, filepath, buffer_ptr, size_ptr, reserve_size, overlapped_ptr);
if (suc)
{
g_lastfilepath = filepath;
return suc;
}
#define DisString "replaceabletextures\\commandbuttonsdisabled\\dis"
#define StrLen(s) (sizeof(s) - 1)
if (0 == _strnicmp(filepath, DisString, StrLen(DisString)))
{
const char* filename = filepath + StrLen(DisString);
if (0 != _stricmp(ToFileName(g_lastfilepath).c_str(), filename))
{
for (const char* cur = filename;; cur += 3)
{
auto it = g_history.find(cur);
if (it != g_history.end())
{
suc = disable_button_blp(it->second.c_str(), buffer_ptr, size_ptr, reserve_size);
break;
}
if (0 != _strnicmp(cur, "dis", 3))
{
break;
}
}
}
else
{
suc = disable_button_blp(g_lastfilepath.c_str(), buffer_ptr, size_ptr, reserve_size);
if (suc)
{
g_history[filename] = g_lastfilepath;
}
else
{
if (0 == _strnicmp(g_lastfilepath.c_str(), DisString, StrLen(DisString)))
{
for (const char* cur = g_lastfilepath.c_str() + StrLen(DisString);; cur += 3)
{
auto it = g_history.find(cur);
if (it != g_history.end())
{
suc = disable_button_blp(it->second.c_str(), buffer_ptr, size_ptr, reserve_size);
if (suc)
{
g_history[filename] = it->second;
}
break;
}
if (0 != _strnicmp(cur, "dis", 3))
{
break;
}
}
}
}
}
}
g_lastfilepath = filepath;
if (overlapped_ptr && overlapped_ptr->hEvent) ::SetEvent(overlapped_ptr->hEvent);
return suc;
}
}
void __cdecl EXDclareButtonIcon(jass::jstring_t path)
{
std::string str_path = jass::from_trigstring(jass::from_string(path));
fake::g_history[ToFileName(str_path)] = str_path;
}
jass::jboolean_t __cdecl EXBlendButtonIcon(jass::jstring_t input_a, jass::jstring_t intput_b, jass::jstring_t output)
{
std::string str_intput_a = jass::from_trigstring(jass::from_string(input_a));
std::string str_intput_b = jass::from_trigstring(jass::from_string(intput_b));
std::string str_output = jass::from_trigstring(jass::from_string(output));
IMAGE::BUFFER buf_input_a, buf_input_b, buf_output;
if (!fake::read_button_blp(str_intput_a.c_str(), buf_input_a))
{
return false;
}
if (!fake::read_button_blp(str_intput_b.c_str(), buf_input_b))
{
return false;
}
if (!BlpBlend(buf_input_a, buf_input_b, fake::g_virtualblp[str_output]))
{
fake::g_virtualblp.erase(str_output);
return false;
}
return true;
}
void InitializeDisableButtonBlp()
{
// ไผๅ่ๆmpqๅฒ็ช๏ผๆๆถ็่งฃๅณๆนๆณๅ
ๆ่ๆmpqๅ ่ฝฝ่ตทๆฅ
HMODULE module_handle = ::GetModuleHandleW(L"Game.dll");
virtual_mpq::initialize(module_handle);
real::SMemAlloc = (uintptr_t)::GetProcAddress(::GetModuleHandleW(L"Storm.dll"), (const char*)401);
real::SFileUnloadFile = (uintptr_t)::GetProcAddress(::GetModuleHandleW(L"Storm.dll"), (const char*)280);
real::SFileLoadFile = base::hook::iat(module_handle, "Storm.dll", (const char*)(279), (uintptr_t)fake::SFileLoadFile);
jass::japi_add((uintptr_t)EXDclareButtonIcon, "EXDclareButtonIcon", "(S)V");
jass::japi_add((uintptr_t)EXBlendButtonIcon, "EXBlendButtonIcon", "(SSS)B");
register_game_reset_event([&](uintptr_t)
{
fake::g_virtualblp.clear();
fake::g_lastfilepath.clear();
fake::g_history.clear();
});
}
}}}
| [
"actboy168@gmail.com"
] | actboy168@gmail.com |
81a6b14f674e9ac3f9966ec6af3f7b29dbf39638 | 1d6abe27a802d53f7fbd6eb5e59949044cbb3b98 | /tensorflow/compiler/xla/service/cpu/elemental_ir_emitter.cc | 05364a4492bc4f00e5da91653aaf9f1cfe207cb6 | [
"Apache-2.0"
] | permissive | STSjeerasak/tensorflow | 6bc8bf27fb74fd51a71150f25dc1127129f70222 | b57499d4ec0c24adc3a840a8e7e82bd4ce0d09ed | refs/heads/master | 2022-12-20T20:32:15.855563 | 2020-09-29T21:22:35 | 2020-09-29T21:29:31 | 299,743,927 | 5 | 1 | Apache-2.0 | 2020-09-29T21:38:19 | 2020-09-29T21:38:18 | null | UTF-8 | C++ | false | false | 4,382 | cc | /* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/xla/service/cpu/elemental_ir_emitter.h"
#include <string>
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Module.h"
#include "tensorflow/compiler/xla/service/hlo_casting_utils.h"
#include "tensorflow/compiler/xla/service/hlo_instruction.h"
#include "tensorflow/compiler/xla/service/hlo_instructions.h"
#include "tensorflow/compiler/xla/service/hlo_opcode.h"
#include "tensorflow/compiler/xla/service/llvm_ir/llvm_util.h"
#include "tensorflow/compiler/xla/types.h"
#include "tensorflow/compiler/xla/util.h"
#include "tensorflow/compiler/xla/xla_data.pb.h"
using xla::llvm_ir::IrArray;
namespace xla {
namespace cpu {
StatusOr<llvm::Value*> CpuElementalIrEmitter::EmitAtan2(PrimitiveType prim_type,
llvm::Value* lhs,
llvm::Value* rhs) {
string function_name;
bool cast_result_to_fp16 = false;
switch (prim_type) {
case F16:
cast_result_to_fp16 = true;
lhs = FPCast(lhs, b_->getFloatTy());
rhs = FPCast(rhs, b_->getFloatTy());
TF_FALLTHROUGH_INTENDED;
case F32:
function_name = "atan2f";
break;
case F64:
function_name = "atan2";
break;
default:
return Unimplemented("atan2");
}
// Create a function declaration.
llvm::Function* function = llvm::dyn_cast<llvm::Function>(
module_
->getOrInsertFunction(function_name, lhs->getType(), lhs->getType(),
rhs->getType())
.getCallee());
function->setCallingConv(llvm::CallingConv::C);
function->setDoesNotThrow();
function->setDoesNotAccessMemory();
// Create an instruction to call the function.
llvm::Value* result = Call(function, {lhs, rhs});
if (cast_result_to_fp16) {
result = FPCast(result, b_->getHalfTy());
}
return result;
}
StatusOr<llvm::Value*> CpuElementalIrEmitter::EmitTanh(PrimitiveType prim_type,
llvm::Value* value) {
bool cast_result_to_fp16 = false;
string function_name;
switch (prim_type) {
case F16:
cast_result_to_fp16 = true;
value = FPCast(value, b_->getFloatTy());
TF_FALLTHROUGH_INTENDED;
case F32:
function_name = "tanhf";
break;
case F64:
function_name = "tanh";
break;
default:
return Unimplemented("tanh");
}
// Create a function declaration.
llvm::Function* function = llvm::dyn_cast<llvm::Function>(
module_
->getOrInsertFunction(function_name, value->getType(),
value->getType())
.getCallee());
function->setCallingConv(llvm::CallingConv::C);
function->setDoesNotThrow();
function->setDoesNotAccessMemory();
// Create an instruction to call the function.
llvm::Value* result = Call(function, value);
if (cast_result_to_fp16) {
result = FPCast(result, b_->getHalfTy());
}
return result;
}
llvm_ir::ElementGenerator CpuElementalIrEmitter::MakeElementGenerator(
const HloInstruction* hlo,
const HloToElementGeneratorMap& operand_to_generator) {
switch (hlo->opcode()) {
case HloOpcode::kConvolution:
return [this, hlo, &operand_to_generator](const IrArray::Index& index) {
return ir_emitter_->EmitElementalConvolution(
Cast<HloConvolutionInstruction>(hlo),
operand_to_generator.at(hlo->operand(0)),
operand_to_generator.at(hlo->operand(1)), index);
};
default:
return ElementalIrEmitter::MakeElementGenerator(hlo,
operand_to_generator);
}
}
} // namespace cpu
} // namespace xla
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
71ff4dbfea604d4f3e9416112ffcf9e3cca0131f | 3521808de88ff83d9a78bfc9fc4aee04bd513a32 | /include/NovosteBetaCath.hh | e1b757fe18d746bf3ba3d305a85d003d095bed82 | [] | no_license | kiarash-eng/IVBT | 3f3c2b9c6a7ee74166bb966caff6a2f259e07c88 | f9fe8d661cecfdab4c7f40963662605c551ac426 | refs/heads/main | 2023-03-04T21:49:01.300850 | 2021-02-17T18:59:51 | 2021-02-17T18:59:51 | 339,785,930 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,754 | hh | //////////////////////////////////////////////////////////////////////////
//
// Author: Joseph M. Decunha <joseph.decunha@mail.mcgill.ca>
//
// License & Copyright
// ===================
//
// Copyright 2016 Joseph M. Decunha <joseph.decunha@mail.mcgill.ca>
//
//
// 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/>.
//
//
//-----------------------------------------------------------------------
// Header file that defines the Novoste Beta Cath 3.5 French model
// for Intravascular Brachytherapy
//////////////////////////////////////////////////////////////////////////
#ifndef NovosteBetaCath_H
#define NovosteBetaCath_H 1
#include "globals.hh"
#include "SourceModel.hh"
class NovosteBetaCath : public SourceModel
{
public:
NovosteBetaCath(G4int, G4bool);
void CreateSource(G4VPhysicalVolume*);
void CleanSource();
void SetupDimensions();
private:
G4double sourceradius, shellradius, jacketradius, catheterouterradius, guidewireradius;
G4double sourcelength, shelllength, sourcetrainlength, jacketlength, catheterlength;
G4double catheterthickness;
G4double sourcetrainshift;
G4int numberofsources;
G4bool guidewire;
};
#endif | [
"jonathan.kalinowski@mail.mcgill.ca"
] | jonathan.kalinowski@mail.mcgill.ca |
d4c4b1d730cbcabaefbb9138991f75d66425be53 | 748705e88fc2decb21871dcdacb7392037412c7c | /2C++WinterTest/(4)C++WinterTestDay4-1-17/(4)C++WinterTestDay4-1-17/main3.cpp | 5171751f51ff2da5af0554b1e0380c71e1ce8821 | [] | no_license | YangXxin1/persistence | 96ebe1d79e4b179cd3c03fcf5becaa30d7c0e659 | 79916f63576a1fdb5849a8f799696c0ea31036ec | refs/heads/master | 2022-12-06T05:23:48.117569 | 2020-09-02T10:07:44 | 2020-09-02T10:07:44 | 178,318,682 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 348 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
for (int i = m, j = 0; i < m + n, j < n; ++i, ++j)
{
nums1[i] = nums2[j];
}
sort(nums1.begin(), nums1.end());
}
};
int main()
{
system("pause");
return 0;
} | [
"yx140513@163.com"
] | yx140513@163.com |
ba91e8d5b53b109723afae95ae7d9d7190e9fce7 | 6e050a341ac6a56aa2959ee12a078a68631fa394 | /ros/crossing/src/wallCentering.cpp | 658453f5424decba829c4fabbe5fec349f9d8412 | [] | no_license | wliu88/turtlebot_avoidance | a7c4183c3765c55a1a3ce284e6c8bcc2cad5e6a1 | af03dfadd1ebbfd0ae3f9aacfb948a88c261d3d1 | refs/heads/master | 2020-06-27T20:01:47.604326 | 2016-11-30T23:41:55 | 2016-11-30T23:41:55 | 74,520,234 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,759 | cpp | //
// WallCentering.cpp
// Version 2.0
// Created by Hongrui Zheng on 10/30/14.
// Revised by Carol Young on 11/03/14.
// Revised by Weiyu Liu on 11/10/14
//
//
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <sensor_msgs/LaserScan.h>
#include <nav_msgs/Odometry.h>
#include <math.h>
//functions
void publish( double _angular, double _linear );
void scan_callback( const sensor_msgs::LaserScan& _msg );
void odometry_callback( const nav_msgs::Odometry& _msg );
// global variables
bool turnRight = false, turnLeft = false, goStraight = true;
int scanPoint = 50;
float cutoff = 0.1;
float gain = .25;
ros::Publisher pub;
int main( int argc, char** argv ) {
ros::init(argc, argv, "follow");
ros::NodeHandle nh;
ros::NodeHandle odm;
ros::Subscriber scan = nh.subscribe( "scan", 1, scan_callback);
ros::Subscriber subodm = odm.subscribe( "odom", 1, odometry_callback);
pub = nh.advertise<geometry_msgs::Twist>("cmd_vel", 1);
ros::Rate loop_rate(10);
while( ros::ok()) {
ros::spinOnce();
}
return(0);
}
void publish( double _angular, double _linear ) {
geometry_msgs::Twist vel;
vel.angular.z = _angular;
vel.linear.x = _linear;
pub.publish(vel);
return;
}
void odometry_callback( const nav_msgs::Odometry& _msg ){
// when turnRight is true and goStraight is false
// publish following velocities
if (turnRight && !goStraight) {
publish(-1 * gain * 1, 0.1);
}
// when turnLeft is true and goStraight is false
// publish following velocities
if (turnLeft && !goStraight) {
publish(gain * 1, 0.1);
}
// when goStraight is true, publish following velocities
if (goStraight) {
publish(0.0, 0.1);
}
return;
}
void scan_callback( const sensor_msgs::LaserScan& _msg ){
turnRight = false;
turnLeft = false;
goStraight = false;
// get the length of the ranges[] array
int arrayLength = (_msg.angle_max - _msg.angle_min) / _msg.angle_increment;
// get the distance to the right
float rightDis = _msg.ranges[scanPoint];
// left and right edge of the data has a difference of 12 points
// get the distance to the left
float leftDis = _msg.ranges[arrayLength - scanPoint - 12];
// The gain is used to adjust the angular velocity to make the turn more smoothly.
gain = fabs(rightDis - leftDis);
//ROS_INFO("%f, %f ", rightDis, leftDis);
// Here the action states are determined. A cutoff are used to ignore negligible noises.
if (rightDis > leftDis + cutoff) {
turnRight = true;
} else if (rightDis + cutoff < leftDis) {
turnLeft = true;
} else {
goStraight = true;
}
return;
}
| [
"weiyuliu69@yahoo.com"
] | weiyuliu69@yahoo.com |
f0664f93fb4261f90a4b500bcc6e0739a5872cc6 | 2a8e57063eb04cf62490d272f560ed016f635741 | /utils/BP.h | 7dce19fb2c982ee9bb3a414a206f171e2a3463c6 | [
"BSD-3-Clause"
] | permissive | Kingsford-Group/squid | 668b2f502f0d4d4e596896c4763490ef77565811 | 851bde47a3ee83a11e22384f4ede479ce2ff6246 | refs/heads/master | 2022-04-29T07:55:20.190296 | 2022-04-07T13:13:51 | 2022-04-07T13:13:51 | 72,505,158 | 42 | 26 | BSD-3-Clause | 2022-04-06T23:20:12 | 2016-11-01T04:56:30 | C++ | UTF-8 | C++ | false | false | 960 | h | #ifndef __BP_H__
#define __BP_H__
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
class BP_t{
public:
string Chr;
int StartPos;
int EndPos;
bool IsLeft;
public:
BP_t(){}
BP_t(string Chr, int StartPos, int EndPos, bool IsLeft): Chr(Chr), StartPos(StartPos), EndPos(EndPos), IsLeft(IsLeft){};
bool operator < (const BP_t& rhs) const{
if(Chr!=rhs.Chr)
return Chr<rhs.Chr;
else if(StartPos!=rhs.StartPos)
return StartPos<rhs.StartPos;
else if(EndPos!=rhs.EndPos)
return EndPos<rhs.EndPos;
else
return IsLeft<rhs.IsLeft;
};
bool operator == (const BP_t& rhs) const{
return (Chr==rhs.Chr && StartPos==rhs.StartPos && EndPos==rhs.EndPos && IsLeft==rhs.IsLeft);
};
bool operator != (const BP_t& rhs) const{
return !(*this==rhs);
};
string Print(){
return Chr+"\t"+to_string(StartPos)+"\t"+to_string(EndPos)+"\t"+to_string(IsLeft);
};
};
#endif | [
"congm1@andrew.cmu.edu"
] | congm1@andrew.cmu.edu |
562a5c98bbee7c409b07ec3bbd4916598500dbdf | 94bdfe022f9d13a679b12f2a01ba9e06d3dd3295 | /codeforces/PRACTISE/1000-1200/K. Video Posts.cpp | 3371c59b28b56d2cfafec374acef3ba19fc27ef8 | [] | no_license | SaiVinay007/Competitive-Programming | 80d66b93531277172eedd87aac582c085b25803f | d79f4e5975b2aa66b96f62154d2d41a9192e4ab7 | refs/heads/master | 2020-08-07T05:10:17.324047 | 2020-01-09T09:55:01 | 2020-01-09T09:55:01 | 213,310,514 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,472 | cpp | #pragma GCC optimize ("-O3")
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef pair<int,int> p32;
typedef pair<ll,ll> p64;
typedef pair<double,double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int> > vv32;
typedef vector<vector<ll> > vv64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
ll MOD = 998244353;
ll NUM = 1e9+7;
#define forn(i,e) for(ll i = 0; i < e; i++)
#define forsn(i,s,e) for(ll i = s; i < e; i++)
#define rforn(i,s) for(ll i = s; i >= 0; i--)
#define rforsn(i,s,e) for(ll i = s; i >= e; i--)
#define ln "\n"
#define dbg(x) cout<<#x<<" = "<<x<<ln
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define INF 1e18
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define zer ll(0)
// 10min
int main()
{
ll n,k;
cin>>n>>k;
v64 v(n,0);
ll sum=0;
forn(i,n)
{
cin>>v[i];
sum+=v[i];
}
ll each_len = sum/k;
ll flg = 0, cnt=0, tmp;
v64 s(k,0);
forn(i,n)
{
tmp += v[i];
s[cnt]+=1;
if(tmp==each_len)
{
cnt+=1;
tmp=0;
}
}
if(cnt==k)
{
cout<<"Yes"<<ln;
forn(i,k)
{
cout<< s[i]<<" ";
}
}
else
{
cout<<"No";
}
return 0;
} | [
"g.saivinay007@gmail.com"
] | g.saivinay007@gmail.com |
5222c0f52186043864044198530b148e5fd4e192 | f15de2aceb891d74477e4ec89c4628de03237ec7 | /Objeto.cpp | cbbb68c6c9147b4797ff1d467b27b4bdbf5292da | [] | no_license | sergioarispejulio/RaytraceGraficas | 964e953bec2b158dbae8c7ef811a2d489788b2d8 | 0967b7e3cd9b92981fa3f040659be6977cf72a20 | refs/heads/master | 2020-06-02T14:53:25.203791 | 2015-03-23T00:16:44 | 2015-03-23T00:16:44 | 32,700,686 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 67 | cpp | #include "Objeto.h"
Objeto::Objeto()
{
}
Objeto::~Objeto()
{
}
| [
"sergio_arispe@hotmail.com"
] | sergio_arispe@hotmail.com |
72b225c84ce1db72785066a23ee3688aa035d6bf | 3b9b4049a8e7d38b49e07bb752780b2f1d792851 | /src/chrome/browser/ui/views/browser_dialogs_views.cc | 0ccb913976517ce2d59f8c0c4f2d178cbddf4557 | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | webosce/chromium53 | f8e745e91363586aee9620c609aacf15b3261540 | 9171447efcf0bb393d41d1dc877c7c13c46d8e38 | refs/heads/webosce | 2020-03-26T23:08:14.416858 | 2018-08-23T08:35:17 | 2018-09-20T14:25:18 | 145,513,343 | 0 | 2 | Apache-2.0 | 2019-08-21T22:44:55 | 2018-08-21T05:52:31 | null | UTF-8 | C++ | false | false | 2,647 | cc | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/browser_dialogs.h"
#include <memory>
#include "chrome/browser/extensions/api/chrome_device_permissions_prompt.h"
#include "chrome/browser/extensions/chrome_extension_chooser_dialog.h"
#include "chrome/browser/extensions/extension_install_prompt.h"
#include "chrome/browser/ui/login/login_handler.h"
#include "chrome/browser/ui/views/new_task_manager_view.h"
#include "components/chooser_controller/chooser_controller.h"
#if defined(OS_CHROMEOS)
#include "chrome/browser/ui/views/intent_picker_bubble_view.h"
#endif // OS_CHROMEOS
// This file provides definitions of desktop browser dialog-creation methods for
// all toolkit-views platforms other than Mac. It also provides the definitions
// on Mac when mac_views_browser=1 is specified in GYP_DEFINES. The file is
// excluded in a Mac Cocoa build: definitions under chrome/browser/ui/cocoa may
// select at runtime whether to show a Cocoa dialog, or the toolkit-views dialog
// provided by browser_dialogs.h.
// static
LoginHandler* LoginHandler::Create(net::AuthChallengeInfo* auth_info,
net::URLRequest* request) {
return chrome::CreateLoginHandlerViews(auth_info, request);
}
// static
void BookmarkEditor::Show(gfx::NativeWindow parent_window,
Profile* profile,
const EditDetails& details,
Configuration configuration) {
chrome::ShowBookmarkEditorViews(parent_window, profile, details,
configuration);
}
// static
ExtensionInstallPrompt::ShowDialogCallback
ExtensionInstallPrompt::GetDefaultShowDialogCallback() {
return ExtensionInstallPrompt::GetViewsShowDialogCallback();
}
void ChromeDevicePermissionsPrompt::ShowDialog() {
ShowDialogViews();
}
void ChromeExtensionChooserDialog::ShowDialog(
std::unique_ptr<ChooserController> chooser_controller) const {
ShowDialogImpl(std::move(chooser_controller));
}
namespace chrome {
ui::TableModel* ShowTaskManager(Browser* browser) {
return task_management::NewTaskManagerView::Show(browser);
}
void HideTaskManager() {
task_management::NewTaskManagerView::Hide();
}
bool NotifyOldTaskManagerBytesRead(const net::URLRequest& request,
int64_t bytes_read) {
return false;
}
} // namespace chrome
#if defined(OS_CHROMEOS)
BubbleShowPtr ShowIntentPickerBubble() {
return IntentPickerBubbleView::ShowBubble;
}
#endif // OS_CHROMEOS
| [
"changhyeok.bae@lge.com"
] | changhyeok.bae@lge.com |
f112704534f8444bfcb1b68a99a6723400fc2ae5 | 911b977e29c308588e6f5664db15dd2b0b6f6bdc | /code/1143.ๆ้ฟๅ
ฌๅ
ฑๅญๅบๅ.cpp | 1da1899a341af2b0e28713a9eee0d6ef1f419f58 | [] | no_license | kevin-mei/leetcode | c9bd8fd763ad93421beb17f6d0a9a65587cc4a8d | b20cb39c809fb3df8e566f0c3f76704f8995d395 | refs/heads/master | 2023-04-29T15:53:35.691017 | 2021-05-19T00:14:44 | 2021-05-19T00:14:44 | 269,921,164 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,043 | cpp | /*
* @lc app=leetcode.cn id=1143 lang=cpp
*
* [1143] ๆ้ฟๅ
ฌๅ
ฑๅญๅบๅ
*
* https://leetcode-cn.com/problems/longest-common-subsequence/description/
*
* algorithms
* Medium (60.39%)
* Likes: 276
* Dislikes: 0
* Total Accepted: 52.6K
* Total Submissions: 87.1K
* Testcase Example: '"abcde"\n"ace"'
*
* ็ปๅฎไธคไธชๅญ็ฌฆไธฒย text1 ๅย text2๏ผ่ฟๅ่ฟไธคไธชๅญ็ฌฆไธฒ็ๆ้ฟๅ
ฌๅ
ฑๅญๅบๅ็้ฟๅบฆใ
*
* ไธไธชๅญ็ฌฆไธฒ็ย ๅญๅบๅย ๆฏๆ่ฟๆ ทไธไธชๆฐ็ๅญ็ฌฆไธฒ๏ผๅฎๆฏ็ฑๅๅญ็ฌฆไธฒๅจไธๆนๅๅญ็ฌฆ็็ธๅฏน้กบๅบ็ๆ
ๅตไธๅ ้คๆไบๅญ็ฌฆ๏ผไนๅฏไปฅไธๅ ้คไปปไฝๅญ็ฌฆ๏ผๅ็ปๆ็ๆฐๅญ็ฌฆไธฒใ
* ไพๅฆ๏ผ"ace" ๆฏ "abcde" ็ๅญๅบๅ๏ผไฝ "aec" ไธๆฏ "abcde"
* ็ๅญๅบๅใไธคไธชๅญ็ฌฆไธฒ็ใๅ
ฌๅ
ฑๅญๅบๅใๆฏ่ฟไธคไธชๅญ็ฌฆไธฒๆๅ
ฑๅๆฅๆ็ๅญๅบๅใ
*
* ่ฅ่ฟไธคไธชๅญ็ฌฆไธฒๆฒกๆๅ
ฌๅ
ฑๅญๅบๅ๏ผๅ่ฟๅ 0ใ
*
*
*
* ็คบไพ 1:
*
* ่พๅ
ฅ๏ผtext1 = "abcde", text2 = "ace"
* ่พๅบ๏ผ3
* ่งฃ้๏ผๆ้ฟๅ
ฌๅ
ฑๅญๅบๅๆฏ "ace"๏ผๅฎ็้ฟๅบฆไธบ 3ใ
*
*
* ็คบไพ 2:
*
* ่พๅ
ฅ๏ผtext1 = "abc", text2 = "abc"
* ่พๅบ๏ผ3
* ่งฃ้๏ผๆ้ฟๅ
ฌๅ
ฑๅญๅบๅๆฏ "abc"๏ผๅฎ็้ฟๅบฆไธบ 3ใ
*
*
* ็คบไพ 3:
*
* ่พๅ
ฅ๏ผtext1 = "abc", text2 = "def"
* ่พๅบ๏ผ0
* ่งฃ้๏ผไธคไธชๅญ็ฌฆไธฒๆฒกๆๅ
ฌๅ
ฑๅญๅบๅ๏ผ่ฟๅ 0ใ
*
*
*
*
* ๆ็คบ:
*
*
* 1 <= text1.length <= 1000
* 1 <= text2.length <= 1000
* ่พๅ
ฅ็ๅญ็ฌฆไธฒๅชๅซๆๅฐๅ่ฑๆๅญ็ฌฆใ
*
*
*/
// @lc code=start
//#include "pch.h"
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
// dp[i][j] (i,j>0)่กจ็คบ text1็[0,i) ๅtext2็[0,j) ไธคไธชๅญ็ฌฆไธฒ็LCS็้ฟๅบฆ
// dp[m][n]่กจ็คบ text1็ ๅtext2็ไธคไธชๅญ็ฌฆไธฒ็LCS็้ฟๅบฆ
// ๆไปฅๅฃฐๆ็ไบ็ปดๆฐ็ปdp็ๅคงๅฐๅบไธบm+1,n+1
int m = text1.size(), n = text2.size();
// ๅๅงๅ(m+1,n+1)ไบ็ปดๆฐ็ป
vector< vector<int> > dp(m+1, vector<int>(n+1, 0));
// ๅ่ๆฒปไน๏ผๅฆๆ text[i] == text[j], dp[i][j] = dp[i-1][j-1]+1;
// ๅ่ๆฒปไน๏ผๅฆๆ text[i] != text[j], dp[i,j] = max(dp[i-1,j], dp[i,j-1]);
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
// ็ฌฌiไธชๅ
็ด ไธๆ ไธบi-1
if(text1[i-1] == text2[j-1])
{
dp[i][j] = dp[i-1][j-1]+1;
}else
{
dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
}
return dp[m][n];
}
};
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
// ๅฎไนdp[i][j] ไธบtext1[0,i] ๅtext2[0,j]็LCS้ฟๅบฆ
// if(text1[i] == text2[j]) dp[i][j] = dp[i-1][j-1]+1; (i>=1,j>=1)
// if(text1[i] != text2[j]) dp[i][j] = max(dp[i-1][j], dp[i][j-1]);(i>=1,j>=1)
// ้ๅฝๅบ๏ผdp[0][0] = text1[0] == text2[0]?1:0;
// dp[0][1] = ๏ผdp[0][0] || text1[0] == text2[1])?1:0;
// dp[0][2] = ๏ผdp[0][1] || text1[0] == text2[2])?1:0;
int m = text1.length(), n = text2.length();
if(0 == m || 0 == n)
return 0;
vector<vector<int> > dp(m, vector<int>(n,0));
// ๅค็้ๅฝๅบ
dp[0][0] = text1[0] == text2[0]?1:0;
for(int i = 1; i < m;i++)
{
dp[i][0] = (dp[i-1][0] || text1[i] == text2[0])?1:0;
}
for(int j=1; j< n;j++)
{
dp[0][j] = (dp[0][j-1] || text1[0] == text2[j])?1:0;
}
//dp[i][j] ไพ่ตไบ dp[i-1][j-1]๏ผๅ
็ฅ้ๅฐ็๏ผๅ็ฅ้ๅคง็๏ผๆไปฅ๏ผi,j ้ฝๆฏ้ๅข้ๅ
for(int i=1; i < m; i++)
{
for(int j=1; j < n;j++)
{
if(text1[i] == text2[j])
dp[i][j] = dp[i-1][j-1]+1;
else
dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
return dp[m-1][n-1];
}
};
// @lc code=end
| [
"824087038@qq.com"
] | 824087038@qq.com |
49d00962ce2f6bb6ce8d0351d321e9249d5a914a | 8c671476b2aedebc8fee2fcf0c07fffbd11c5463 | /LYH/lyh_reactor/src/io_buf.cpp | 3b58035ca02b69b770c9c8c950ac2d88a2a0ce69 | [] | no_license | LEEYATWAH/MySimpleServer | 233e1dddba435f4ff25d184f682cb1510e9f5340 | 2d649b16fc28e5607017c7471ddb6d5f96eb5ab0 | refs/heads/master | 2022-11-22T10:34:08.512593 | 2020-07-19T10:15:55 | 2020-07-19T10:15:55 | 266,255,105 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 686 | cpp | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <io_buf.h>
io_buf::io_buf(int size):capacity(size),length(0),head(0),next(NULL){
data = new char[size];
assert(data);
}
//ๅฐๅทฒ็ปๅค็่ฟ็ๆฐๆฎ๏ผๆธ
็ฉบ,ๅฐๆชๅค็็ๆฐๆฎๆๅ่ณๆฐๆฎ้ฆๅฐๅ
void io_buf::adjust(){
if(head != 0){
if(length != 0){
memmove(data,data+head,length);
}
head = 0;
}
}
//ๅฐๅ
ถไปio_bufๅฏน่ฑกๆฐๆฎ่ๆฌๅฐ่ชๅทฑไธญ
void io_buf::copy(const io_buf *other){
memcpy(data,other->data+other->head,other->length);
head = 0;
length = other->length;
}
//ๅค็้ฟๅบฆไธบlen็ๆฐๆฎ๏ผ็งปๅจheadๅไฟฎๆญฃlength
void io_buf::pop(int len){
length -= len;
head += len;
} | [
"you@example.com"
] | you@example.com |
7d7fbfdad93ad62946fe48178ed4a6cdf7995a1c | ec31f362bac924ba904a071a95a9ffebd43389d3 | /BOSS/src/utility/strnormalize.cpp | dd9ddfaecf68a86711a2357edef4227d319114b7 | [] | no_license | GaoJianchao/miniprog | 9562ba2703557cd923bade1e4b75da573e7088c3 | 929cc6a10291f58559980c7f285a78bc1ab05355 | refs/heads/master | 2022-03-06T00:54:04.229759 | 2016-12-17T12:48:05 | 2016-12-17T12:48:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 310,614 | cpp | #include "strnormalize.h"
using namespace std;
namespace b2bmlr{
#define SWAPBYTE(x) (((unsigned short)(x) >> 8) | (unsigned short)(x) << 8)
#define COMPBYTE(x, y) ((unsigned char)(x) << 8 | (unsigned char)(y))
static const unsigned short _tns[] =
{
0x8147 /* ไธ */, 0xB6AA /* ไธข */, // {{{
0x814B /* ไธฆ */, 0xB2A2 /* ๅนถ */,
0xC7AC /* ไนพ */, 0xB8C9 /* ๅนฒ */,
0x8179 /* ไบ */, 0xC2D2 /* ไนฑ */,
0x8183 /* ไบ */, 0xD8A8 /* ไบ */,
0x8186 /* ไบ */, 0xD1C7 /* ไบ */,
0x81B3 /* ไผ */, 0xBCB3 /* ๆฑฒ */,
0x81B8 /* ไผ */, 0xB7F2 /* ๅคซ */,
0x81BB /* ไผ */, 0xB4AB /* ไผ */,
0x81D0 /* ไฝ */, 0xD8F9 /* ไผซ */,
0x81D1 /* ไฝ */, 0xB2BC /* ๅธ */,
0x81D7 /* ไฝ */, 0xD5BC /* ๅ */,
0x81DD /* ไฝช */, 0xBBB2 /* ๅพ */,
0x81E3 /* ไฝต */, 0xB2A2 /* ๅนถ */,
0x81ED /* ไพ */, 0xC0B4 /* ๆฅ */,
0x81F6 /* ไพ */, 0xC2D8 /* ไป */,
0x8248 /* ไพถ */, 0xC2C2 /* ไพฃ */,
0x8249 /* ไพท */, 0xBED6 /* ๅฑ */,
0x8252 /* ไฟ */, 0xD9B6 /* ไฟฃ */,
0x8253 /* ไฟ */, 0xCFB5 /* ็ณป */,
0x8262 /* ไฟ */, 0xCFC0 /* ไพ */,
0x8274 /* ๅ */, 0xD8F6 /* ไผฅ */,
0x827A /* ๅ */, 0xC1A9 /* ไฟฉ */,
0x827D /* ๅ */, 0xB2D6 /* ไป */,
0x8280 /* ๅ */, 0xB8F6 /* ไธช */,
0x8283 /* ๅ */, 0xC3C7 /* ไปฌ */,
0x8286 /* ๅ */, 0xD0D2 /* ๅนธ */,
0x828D /* ๅฃ */, 0xB7C2 /* ไปฟ */,
0x8290 /* ๅซ */, 0xC2D7 /* ไผฆ */,
0x82A5 /* ๅ */, 0xCEB0 /* ไผ */,
0x82BF /* ๅช */, 0xB1C6 /* ้ผ */,
0x82C8 /* ๅด */, 0xB2E0 /* ไพง */,
0x82C9 /* ๅต */, 0xD5EC /* ไพฆ */,
0x82CC /* ๅบ */, 0xD4DB /* ๅฑ */,
0x82CE /* ๅฝ */, 0xCEB1 /* ไผช */,
0x82D8 /* ๅ */, 0xC2EE /* ้ช */,
0x82DC /* ๅ */, 0xBDDC /* ๆฐ */,
0x82E1 /* ๅ */, 0xD8F7 /* ไผง */,
0x82E3 /* ๅ */, 0xC9A1 /* ไผ */,
0x82E4 /* ๅ */, 0xB1B8 /* ๅค */,
0x82E5 /* ๅ */, 0xD0A7 /* ๆ */,
0x82E7 /* ๅ */, 0xD1FE /* ็ถ */,
0x82ED /* ๅข */, 0xBCD2 /* ๅฎถ */,
0x82F2 /* ๅญ */, 0xD3B6 /* ไฝฃ */,
0x82F4 /* ๅฏ */, 0xD9CC /* ๅฌ */,
0x82F7 /* ๅณ */, 0xB4AB /* ไผ */,
0x82F8 /* ๅด */, 0xD8F1 /* ไผ */,
0x82F9 /* ๅต */, 0xD5AE /* ๅบ */,
0x82FB /* ๅท */, 0xC9CB /* ไผค */,
0x8341 /* ๅพ */, 0xC7E3 /* ๅพ */,
0x8345 /* ๅ */, 0xD9CD /* ๅป */,
0x8348 /* ๅ
*/, 0xBDF6 /* ไป
*/,
0x834A /* ๅ */, 0xC2BE /* ๆฎ */,
0x834C /* ๅ */, 0xD9DD /* ไฝฅ */,
0x834D /* ๅ */, 0xCFC9 /* ไป */,
0x8353 /* ๅ */, 0xC7C8 /* ไพจ */,
0x8357 /* ๅ */, 0xC6CD /* ไป */,
0x8365 /* ๅฅ */, 0xBDC4 /* ไพฅ */,
0x8366 /* ๅจ */, 0xD9C7 /* ๅพ */,
0x836C /* ๅฑ */, 0xB9CD /* ้ */,
0x8372 /* ๅน */, 0xBCDB /* ไปท */,
0x8378 /* ๅ */, 0xD2C7 /* ไปช */,
0x837A /* ๅ */, 0xD9AF /* ไพฌ */,
0x837C /* ๅ */, 0xD2DA /* ไบฟ */,
0x837D /* ๅ
*/, 0xB5B1 /* ๅฝ */,
0x837E /* ๅ */, 0xBFEB /* ไพฉ */,
0x8380 /* ๅ */, 0xBCF3 /* ไฟญ */,
0x8382 /* ๅ */, 0xE1E8 /* ๅพผ */,
0x8386 /* ๅ */, 0xD9CF /* ๅง */,
0x8389 /* ๅ */, 0xD9B1 /* ไฟฆ */,
0x838A /* ๅ */, 0xD9AD /* ไพช */,
0x838C /* ๅ */, 0xC4E2 /* ๆ */,
0x838D /* ๅ */, 0xBEA1 /* ๅฐฝ */,
0x8394 /* ๅ */, 0xB3A5 /* ๅฟ */,
0x839E /* ๅช */, 0xD3C5 /* ไผ */,
0x83A6 /* ๅฒ */, 0xB4A2 /* ๅจ */,
0x83AB /* ๅท */, 0xD9B3 /* ไฟช */,
0x83AC /* ๅธ */, 0xC2DE /* ็ฝ */,
0x83AD /* ๅน */, 0xD4DC /* ๆ */,
0x83AE /* ๅบ */, 0xD9D0 /* ๅฉ */,
0x83AF /* ๅป */, 0xD9CE /* ๅฅ */,
0x83B0 /* ๅผ */, 0xD9B2 /* ไฟจ */,
0x83B4 /* ๅ
*/, 0xD0D7 /* ๅถ */,
0x83B6 /* ๅ
*/, 0xB6D2 /* ๅ
*/,
0x83BA /* ๅ
*/, 0xB6F9 /* ๅฟ */,
0x83BC /* ๅ
*/, 0xD9F0 /* ๅ
*/,
0x83C8 /* ๅ
ง */, 0xC4DA /* ๅ
*/,
0x83C9 /* ๅ
ฉ */, 0xC1BD /* ไธค */,
0x83D3 /* ๅ */, 0xCEDE /* ๆ */,
0x83D4 /* ๅ */, 0xB2E1 /* ๅ */,
0x83D9 /* ๅ */, 0xEBD0 /* ่ */,
0x83E7 /* ๅช */, 0xC3DD /* ๅน */,
0x83F4 /* ๅ */, 0xBEBB /* ๅ */,
0x83F6 /* ๅ */, 0xB6B3 /* ๅป */,
0x8443 /* ๅ */, 0xC1DD /* ๅ */,
0x8450 /* ๅฑ */, 0xBFAD /* ๅฏ */,
0x8465 /* ๅฅ */, 0xB1F0 /* ๅซ */,
0x8468 /* ๅช */, 0xC9BE /* ๅ */,
0x8471 /* ๅ */, 0xD8D9 /* ๅญ */,
0x8474 /* ๅ */, 0xD4F2 /* ๅ */,
0x8476 /* ๅ */, 0xEFB1 /* ้ */,
0x8477 /* ๅ */, 0xBFCB /* ๅ
*/,
0x8478 /* ๅ */, 0xC9B2 /* ๅน */,
0x8482 /* ๅ */, 0xB8D5 /* ๅ */,
0x8483 /* ๅ */, 0xB0FE /* ๅฅ */,
0x848E /* ๅฎ */, 0xB9D0 /* ๅ */,
0x8492 /* ๅด */, 0xD8DC /* ๅ */,
0x8493 /* ๅต */, 0xB4B4 /* ๅ */,
0x8495 /* ๅท */, 0xB2F9 /* ้ฒ */,
0x849D /* ๅ */, 0xBBAE /* ๅ */,
0x849E /* ๅ */, 0xD4FD /* ๆญ */,
0x84A1 /* ๅ */, 0xBEE7 /* ๅง */,
0x84A2 /* ๅ */, 0xC1F5 /* ๅ */,
0x84A3 /* ๅ */, 0xB9F4 /* ๅฝ */,
0x84A5 /* ๅ */, 0xD8DB /* ๅฟ */,
0x84A6 /* ๅ */, 0xBDA3 /* ๅ */,
0x84A9 /* ๅ */, 0xBCC1 /* ๅ */,
0x84C1 /* ๅป */, 0xBFEF /* ๅก */,
0x84C5 /* ๅ */, 0xBEA2 /* ๅฒ */,
0x84D3 /* ๅ */, 0xB6AF /* ๅจ */,
0x84D4 /* ๅ */, 0xDBC3 /* ๅ */,
0x84D5 /* ๅ */, 0xCEF1 /* ๅก */,
0x84D7 /* ๅ */, 0xD1AB /* ๅ */,
0x84D9 /* ๅ */, 0xCAA4 /* ่ */,
0x84DA /* ๅ */, 0xC0CD /* ๅณ */,
0x84DD /* ๅข */, 0xCAC6 /* ๅฟ */,
0x84DE /* ๅฃ */, 0xBBFD /* ็งฏ */,
0x84E0 /* ๅฆ */, 0xBDCB /* ๅฟ */,
0x84EA /* ๅฑ */, 0xDBBD /* ๅข */,
0x84EC /* ๅณ */, 0xD1AB /* ๅ */,
0x84EE /* ๅต */, 0xC0F8 /* ๅฑ */,
0x84F1 /* ๅธ */, 0xC8B0 /* ๅ */,
0x84F2 /* ๅป */, 0xD4C8 /* ๅ */,
0x8548 /* ๅ */, 0xBFBB /* ็ */,
0x8551 /* ๅญ */, 0xD8D0 /* ๅฆ */,
0x8552 /* ๅฏ */, 0xBBE3 /* ๆฑ */,
0x8554 /* ๅฑ */, 0xD8D1 /* ๅฎ */,
0x855E /* ๅ */, 0xC7F8 /* ๅบ */,
0x8566 /* ๅ */, 0xD0AD /* ๅ */,
0x8572 /* ๅน */, 0xD0F4 /* ๆค */,
0x8573 /* ๅป */, 0xC8B4 /* ๅด */,
0x8587 /* ๅ */, 0xD8C7 /* ๅ */,
0x858D /* ๅค */, 0xC0FA /* ๅ */,
0x8592 /* ๅญ */, 0xD1E1 /* ๅ */,
0x8596 /* ๅฒ */, 0xC0F7 /* ๅ */,
0x8598 /* ๅด */, 0xD8C9 /* ๅฃ */,
0x85A2 /* ๅ */, 0xB2CE /* ๅ */,
0x85B2 /* ๅข */, 0xB4D4 /* ไธ */,
0x85BC /* ๅ */, 0xB4E7 /* ๅฏธ */,
0x85C7 /* ๅณ */, 0xCEE2 /* ๅด */,
0x85C8 /* ๅถ */, 0xC4C5 /* ๅ */,
0x85CE /* ๅ */, 0xC2C0 /* ๅ */,
0x85D5 /* ๅ */, 0xB3DF /* ๅฐบ */,
0x864A /* ๅผ */, 0xDFC3 /* ๅ */,
0x8654 /* ๅก */, 0xD4B1 /* ๅ */,
0x8668 /* ๅ */, 0xDFC2 /* ๅ */,
0x8688 /* ๅธ */, 0xC4EE /* ๅฟต */,
0x8696 /* ๅ */, 0xCECA /* ้ฎ */,
0x8697 /* ๅ */, 0xE0A9 /* ๅ */,
0x869B /* ๅ */, 0xE0A2 /* ๅ */,
0x86A1 /* ๅ */, 0xD1C6 /* ๅ */,
0x86A2 /* ๅ */, 0xC6F4 /* ๅฏ */,
0x86A5 /* ๅฃ */, 0xCFCE /* ่ก */,
0x86B9 /* ๅ */, 0xD4DB /* ๅฑ */,
0x86BE /* ๅ */, 0xBBBD /* ๅค */,
0x86CA /* ๅช */, 0xC9A5 /* ไธง */,
0x86CB /* ๅซ */, 0xB3D4 /* ๅ */,
0x86CC /* ๅฌ */, 0xC7C7 /* ไน */,
0x86CE /* ๅฎ */, 0xB5A5 /* ๅ */,
0x86D1 /* ๅฒ */, 0xD3B4 /* ๅ */,
0x86DC /* ๅ */, 0xC7BA /* ๅ */,
0x86DD /* ๅ */, 0xD8C4 /* ๅฌ */,
0x86E1 /* ๅ */, 0xC2F0 /* ๅ */,
0x86E8 /* ๅ */, 0xCED8 /* ๅ */,
0x86EE /* ๅฉ */, 0xDFEF /* ๅข */,
0x86F4 /* ๅถ */, 0xDFD9 /* ๅ */,
0x8740 /* ๅ */, 0xCCBE /* ๅน */,
0x8744 /* ๅ */, 0xE0B6 /* ๅฝ */,
0x8749 /* ๅ */, 0xC5BB /* ๅ */,
0x874B /* ๅ */, 0xDFF5 /* ๅง */,
0x874C /* ๅ */, 0xB3A2 /* ๅฐ */,
0x874F /* ๅ */, 0xDFE9 /* ๅ */,
0x8757 /* ๅฉ */, 0xBBA9 /* ๅ */,
0x875A /* ๅฎ */, 0xDFEB /* ๅ */,
0x875B /* ๅฏ */, 0xD0A5 /* ๅธ */,
0x875C /* ๅฐ */, 0xDFB4 /* ๅฝ */,
0x875E /* ๅต */, 0xDFD8 /* ๅ */,
0x8760 /* ๅธ */, 0xDFBC /* ๅ */,
0x8766 /* ๅ */, 0xB6F1 /* ๆถ */,
0x876E /* ๅ */, 0xE0A2 /* ๅ */,
0x8775 /* ๅ */, 0xD0EA /* ๅ */,
0x877D /* ๅ */, 0xDFD5 /* ๅ */,
0x8781 /* ๅฅ */, 0xDFE6 /* ๅ */,
0x8782 /* ๅฆ */, 0xDFDC /* ๅ */,
0x8786 /* ๅฏ */, 0xE0C8 /* ๅณ */,
0x8788 /* ๅฒ */, 0xDFE0 /* ๅ */,
0x878A /* ๅด */, 0xC5E7 /* ๅท */,
0x878D /* ๅธ */, 0xB6D6 /* ๅจ */,
0x878E /* ๅน */, 0xB5B1 /* ๅฝ */,
0x8793 /* ๅ */, 0xDFCC /* ๅ */,
0x8798 /* ๅ */, 0xCFC5 /* ๅ */,
0x879D /* ๅ */, 0xDFE2 /* ๅ */,
0x879F /* ๅ */, 0xB3A2 /* ๅฐ */,
0x87A3 /* ๅ */, 0xE0E0 /* ๅ */,
0x87A7 /* ๅ */, 0xC4F6 /* ๅฎ */,
0x87B2 /* ๅฅ */, 0xD1CA /* ๅฝ */,
0x87B3 /* ๅฆ */, 0xDFBF /* ๅ */,
0x87B5 /* ๅจ */, 0xC1FC /* ๅ */,
0x87BB /* ๅฎ */, 0xCFF2 /* ๅ */,
0x87BF /* ๅณ */, 0xE0B7 /* ๅพ */,
0x87C0 /* ๅด */, 0xD1CF /* ไธฅ */,
0x87C2 /* ๅถ */, 0xE0D3 /* ๅค */,
0x87CA /* ๅ */, 0xDFF9 /* ๅญ */,
0x87CB /* ๅ */, 0xE0BF /* ๅซ */,
0x87CC /* ๅ */, 0xCFF9 /* ๅฃ */,
0x87CF /* ๅ
*/, 0xD9E6 /* ๅ */,
0x87D2 /* ๅ */, 0xDFBD /* ๅ */,
0x87D3 /* ๅ */, 0xC2DE /* ็ฝ */,
0x87D5 /* ๅ */, 0xCBD5 /* ่ */,
0x87D6 /* ๅ */, 0xCFB2 /* ๅ */,
0x87DA /* ๅ */, 0xD6F6 /* ๅฑ */,
0x87DC /* ๅ */, 0xC4F6 /* ๅฎ */,
0x87E8 /* ๅช */, 0xB4D1 /* ๅฑ */,
0x87F7 /* ๅ */, 0xE0F0 /* ๅต */,
0x87F8 /* ๅ */, 0xB9FA /* ๅฝ */,
0x87FA /* ๅ */, 0xCEA7 /* ๅด */,
0x8840 /* ๅ */, 0xD4B0 /* ๅญ */,
0x8841 /* ๅ */, 0xD4B2 /* ๅ */,
0x8844 /* ๅ */, 0xCDBC /* ๅพ */,
0x8846 /* ๅ */, 0xCDC5 /* ๅข */,
0x8873 /* ๅฐ */, 0xDBF0 /* ๅง */,
0x8877 /* ๅต */, 0xC7F0 /* ไธ */,
0x88B8 /* ๅ */, 0xD2B0 /* ้ */,
0x88BA /* ๅก */, 0xDBEB /* ๅญ */,
0x88BF /* ๅง */, 0xB0D3 /* ๅ */,
0x88C6 /* ๅฐ */, 0xB2C9 /* ้ */,
0x88C9 /* ๅณ */, 0xBFB2 /* ๅ */,
0x88CC /* ๅท */, 0xD6B4 /* ๆง */,
0x88D4 /* ๅ
*/, 0xBCE1 /* ๅ */,
0x88D7 /* ๅ */, 0xDBD1 /* ๅฉ */,
0x88E5 /* ๅ */, 0xDBF6 /* ๅ */,
0x88F2 /* ๅ ฏ */, 0xD2A2 /* ๅฐง */,
0x88F3 /* ๅ ฑ */, 0xB1A8 /* ๆฅ */,
0x88F6 /* ๅ ด */, 0xB3A1 /* ๅบ */,
0x8941 /* ๅ ฟ */, 0xBCEE /* ็ขฑ */,
0x894B /* ๅก */, 0xBFE9 /* ๅ */,
0x894C /* ๅก */, 0xDCE3 /* ่ */,
0x894E /* ๅก */, 0xDBEE /* ๅฒ */,
0x8950 /* ๅก */, 0xDBF5 /* ๅ */,
0x8954 /* ๅก */, 0xCDBF /* ๆถ */,
0x8956 /* ๅก */, 0xDAA3 /* ๅข */,
0x895D /* ๅกข */, 0xCEEB /* ๅ */,
0x895F /* ๅกค */, 0xDBF7 /* ๅ */,
0x8969 /* ๅกฑ */, 0xC0CA /* ๆ */,
0x896D /* ๅกต */, 0xB3BE /* ๅฐ */,
0x8971 /* ๅกน */, 0xC7B5 /* ๅ */,
0x8974 /* ๅกผ */, 0xD7A9 /* ็ */,
0x897C /* ๅข */, 0xB5E6 /* ๅซ */,
0x8984 /* ๅข */, 0xC9CA /* ๅข */,
0x898B /* ๅข */, 0xD7B9 /* ๅ */,
0x898C /* ๅข */, 0xEDCD /* ็ก */,
0x8999 /* ๅขฎ */, 0xB6E9 /* ๅ */,
0x899E /* ๅขณ */, 0xB7D8 /* ๅ */,
0x89A8 /* ๅขพ */, 0xBFD1 /* ๅฆ */,
0x89AF /* ๅฃ */, 0xCCB3 /* ๅ */,
0x89B6 /* ๅฃ */, 0xDBF7 /* ๅ */,
0x89BA /* ๅฃ */, 0xD1B9 /* ๅ */,
0x89BE /* ๅฃ */, 0xC0DD /* ๅ */,
0x89BF /* ๅฃ */, 0xDBDB /* ๅน */,
0x89C0 /* ๅฃ */, 0xDBE4 /* ๅ */,
0x89C4 /* ๅฃ */, 0xBBB5 /* ๅ */,
0x89C5 /* ๅฃ */, 0xC2A2 /* ๅ */,
0x89C8 /* ๅฃข */, 0xDBDE /* ๅ */,
0x89CE /* ๅฃฉ */, 0xB0D3 /* ๅ */,
0x89D1 /* ๅฃฏ */, 0xD7B3 /* ๅฃฎ */,
0x89D8 /* ๅฃบ */, 0xBAF8 /* ๅฃถ */,
0x89DB /* ๅฃฝ */, 0xCAD9 /* ๅฏฟ */,
0x89F2 /* ๅค */, 0xB9BB /* ๅค */,
0x89F4 /* ๅคข */, 0xC3CE /* ๆขฆ */,
0xE2B7 /* ๅคฅ */, 0xBBEF /* ไผ */,
0x8A41 /* ๅคพ */, 0xBCD0 /* ๅคน */,
0x8A4A /* ๅฅ */, 0xDBBC /* ๅฅ */,
0x8A57 /* ๅฅง */, 0xB0C2 /* ๅฅฅ */,
0x8A59 /* ๅฅฉ */, 0xDEC6 /* ๅฅ */,
0x8A5A /* ๅฅช */, 0xB6E1 /* ๅคบ */,
0x8A5E /* ๅฅฎ */, 0xB7DC /* ๅฅ */,
0x8A79 /* ๅฆ */, 0xD7B1 /* ๅฆ */,
0x8A85 /* ๅฆณ */, 0xC4E3 /* ไฝ */,
0x8A99 /* ๅง */, 0xE6A9 /* ๅง */,
0x8AA6 /* ๅงฆ */, 0xBCE9 /* ๅฅธ */,
0x8AA9 /* ๅงช */, 0xD6B6 /* ไพ */,
0x8ACA /* ๅจ */, 0xD3E9 /* ๅจฑ */,
0x8AE4 /* ๅฉ */, 0xC2A6 /* ๅจ */,
0x8AF0 /* ๅฉ */, 0xE6B9 /* ๅฉ */,
0x8B44 /* ๅฉฆ */, 0xB8BE /* ๅฆ */,
0x8B48 /* ๅฉฌ */, 0xD2F9 /* ๆทซ */,
0x8B49 /* ๅฉญ */, 0xE6AB /* ๅจ
*/,
0x8B53 /* ๅฉผ */, 0xC8F4 /* ่ฅ */,
0x8B7A /* ๅชง */, 0xE6B4 /* ๅจฒ */,
0x8B81 /* ๅชฎ */, 0xCDB5 /* ๅท */,
0x8B82 /* ๅชฏ */, 0xE6A3 /* ๅฆซ */,
0x8B8B /* ๅชผ */, 0xE6C1 /* ๅชช */,
0x8B8C /* ๅชฝ */, 0xC2E8 /* ๅฆ */,
0x8B9E /* ๅซ */, 0xE5FD /* ๅฆช */,
0x8BB3 /* ๅซต */, 0xE5FC /* ๅฆฉ */,
0x8BB9 /* ๅซป */, 0xE6B5 /* ๅจด */,
0x8BC6 /* ๅฌ */, 0xE6AC /* ๅจ */,
0x8BC8 /* ๅฌ */, 0xE6BF /* ๅฉต */,
0x8BC9 /* ๅฌ */, 0xBDBF /* ๅจ */,
0x8BD4 /* ๅฌ */, 0xE6CD /* ๅซฑ */,
0x8BD8 /* ๅฌ */, 0xF4C1 /* ่ข
*/,
0x8BDC /* ๅฌก */, 0xE6C8 /* ๅซ */,
0x8BDF /* ๅฌค */, 0xE6D6 /* ๅฌท */,
0x8BE5 /* ๅฌช */, 0xE6C9 /* ๅซ */,
0x8BE8 /* ๅฌญ */, 0xC4CC /* ๅฅถ */,
0x8BEB /* ๅฌฐ */, 0xD3A4 /* ๅฉด */,
0x8BF0 /* ๅฌธ */, 0xC9F4 /* ๅฉถ */,
0x8BF6 /* ๅฌพ */, 0xC0C1 /* ๆ */,
0x8BFA /* ๅญ */, 0xC4EF /* ๅจ */,
0x8C44 /* ๅญ */, 0xE6AE /* ๅจ */,
0x8C4F /* ๅญซ */, 0xCBEF /* ๅญ */,
0x8C57 /* ๅญธ */, 0xD1A7 /* ๅญฆ */,
0x8C5C /* ๅญฟ */, 0xC2CF /* ๅญช */,
0x8C6D /* ๅฎฎ */, 0xB9AC /* ๅฎซ */,
0x8C75 /* ๅฏ */, 0xB2C9 /* ้ */,
0x8C80 /* ๅฏ */, 0xC7DE /* ๅฏ */,
0x8C81 /* ๅฏ */, 0xCAB5 /* ๅฎ */,
0x8C85 /* ๅฏ */, 0xD6C3 /* ็ฝฎ */,
0x8C8B /* ๅฏข */, 0xC7DE /* ๅฏ */,
0x8C8D /* ๅฏฆ */, 0xCAB5 /* ๅฎ */,
0x8C8E /* ๅฏง */, 0xC4FE /* ๅฎ */,
0x8C8F /* ๅฏฉ */, 0xC9F3 /* ๅฎก */,
0x8C91 /* ๅฏซ */, 0xD0B4 /* ๅ */,
0x8C92 /* ๅฏฌ */, 0xBFED /* ๅฎฝ */,
0x8C94 /* ๅฏฏ */, 0xBFA1 /* ไฟ */,
0x8C99 /* ๅฏต */, 0xB3E8 /* ๅฎ */,
0x8C9A /* ๅฏถ */, 0xB1A6 /* ๅฎ */,
0x8CA2 /* ๅฐ */, 0xBDAB /* ๅฐ */,
0x8CA3 /* ๅฐ */, 0xD7A8 /* ไธ */,
0x8CA4 /* ๅฐ */, 0xD1B0 /* ๅฏป */,
0x8CA6 /* ๅฐ */, 0xB6D4 /* ๅฏน */,
0x8CA7 /* ๅฐ */, 0xB5BC /* ๅฏผ */,
0x8CA9 /* ๅฐ */, 0xB6FB /* ๅฐ */,
0x8CAF /* ๅฐ */, 0xCFCA /* ้ฒ */,
0x8CC0 /* ๅฐท */, 0xDECF /* ๅฐด */,
0x8CC3 /* ๅฑ */, 0xBDEC /* ๅฑ */,
0x8CC6 /* ๅฑ */, 0xCAAC /* ๅฐธ */,
0x8CCF /* ๅฑ */, 0xCCEB /* ๅฑ */,
0x8CD0 /* ๅฑ */, 0xECE9 /* ๆ */,
0x8CD2 /* ๅฑข */, 0xC2C5 /* ๅฑก */,
0x8CD3 /* ๅฑค */, 0xB2E3 /* ๅฑ */,
0x8CD5 /* ๅฑจ */, 0xE5F0 /* ๅฑฆ */,
0x8CD9 /* ๅฑฌ */, 0xCAF4 /* ๅฑ */,
0x8CF9 /* ๅฒก */, 0xB8D4 /* ๅ */,
0x8CFD /* ๅฒง */, 0xCCF6 /* ่ฟข */,
0x8D73 /* ๅณด */, 0xE1AD /* ๅฒ */,
0x8D75 /* ๅณถ */, 0xB5BA /* ๅฒ */,
0x8D7B /* ๅณฝ */, 0xCFBF /* ๅณก */,
0x8D80 /* ๅด */, 0xBFB2 /* ๅ */,
0x8D88 /* ๅด */, 0xE1C1 /* ๅด */,
0x8D8B /* ๅด */, 0xC0A5 /* ๆ */,
0x8D8F /* ๅด */, 0xB8DA /* ๅฒ */,
0x8D91 /* ๅด */, 0xC2D8 /* ไป */,
0x8D92 /* ๅด */, 0xC0E2 /* ๆฃฑ */,
0x8D96 /* ๅด */, 0xE1B4 /* ๅฒฝ */,
0x8D98 /* ๅดข */, 0xE1BF /* ๅณฅ */,
0x8DA3 /* ๅดณ */, 0xE1CE /* ๅต */,
0x8DB9 /* ๅต */, 0xE1B0 /* ๅฒ */,
0x8DBB /* ๅต */, 0xD1D2 /* ๅฒฉ */,
0x8DC1 /* ๅต */, 0xBFC6 /* ็ง */,
0x8DE2 /* ๅถ */, 0xE1D0 /* ๅต */,
0x8DE4 /* ๅถ */, 0xD5B8 /* ๅดญ */,
0x8DE7 /* ๅถ */, 0xE1AB /* ๅฒ */,
0x8DF7 /* ๅถ */, 0xE1C0 /* ๅด */,
0x8DFE /* ๅถ */, 0xE1BD /* ๅณค */,
0x8E46 /* ๅถง */, 0xE1BB /* ๅณ */,
0x8E56 /* ๅถธ */, 0xE1C9 /* ๅต */,
0x8E58 /* ๅถบ */, 0xC1EB /* ๅฒญ */,
0x8E5A /* ๅถผ */, 0xD3EC /* ๅฑฟ */,
0x8E5B /* ๅถฝ */, 0xD4C0 /* ๅฒณ */,
0x8E68 /* ๅท */, 0xBFF9 /* ๅฒฟ */,
0x8E6E /* ๅท */, 0xC2CD /* ๅณฆ */,
0x8E70 /* ๅท */, 0xE1DB /* ๅท
*/,
0x8E72 /* ๅท */, 0xD1D2 /* ๅฒฉ */,
0x8E84 /* ๅทน */, 0xDAE1 /* ๅบ */,
0x8E9B /* ๅธฅ */, 0xCBA7 /* ๅธ
*/,
0x8E9F /* ๅธซ */, 0xCAA6 /* ๅธ */,
0x8EA4 /* ๅธณ */, 0xD5CA /* ๅธ */,
0x8EA7 /* ๅธถ */, 0xB4F8 /* ๅธฆ */,
0x8EAC /* ๅน */, 0xD6A1 /* ๅธง */,
0x8EAE /* ๅน */, 0xE0F8 /* ๅธ */,
0x8EBD /* ๅน */, 0xE0FE /* ๅธผ */,
0x8EBE /* ๅน */, 0xE0FD /* ๅธป */,
0x8EC3 /* ๅน */, 0xD6C4 /* ๅธ */,
0x8EC5 /* ๅนฃ */, 0xB1D2 /* ๅธ */,
0x8ECD /* ๅนซ */, 0xB0EF /* ๅธฎ */,
0x8ECE /* ๅนฌ */, 0xE0FC /* ๅธฑ */,
0x8ED6 /* ๅนน */, 0xB8C9 /* ๅนฒ */,
0x8ED7 /* ๅนพ */, 0xBCB8 /* ๅ */,
0x8ED9 /* ๅบ */, 0xD8C6 /* ไป */,
0x8EEC /* ๅบซ */, 0xBFE2 /* ๅบ */,
0x8EFA /* ๅป */, 0xB2DE /* ๅ */,
0x8EFB /* ๅป */, 0xCFE1 /* ๅข */,
0x8EFD /* ๅป */, 0xBEC7 /* ๅฉ */,
0x8F42 /* ๅป */, 0xCFC3 /* ๅฆ */,
0x8F4A /* ๅป */, 0xD2F1 /* ่ซ */,
0x8F4E /* ๅป */, 0xB3F8 /* ๅจ */,
0x8F50 /* ๅป */, 0xD8CB /* ๅฎ */,
0x8F52 /* ๅป */, 0xC3ED /* ๅบ */,
0x8F53 /* ๅป */, 0xB3A7 /* ๅ */,
0x8F54 /* ๅปก */, 0xE2D0 /* ๅบ */,
0x8F55 /* ๅปข */, 0xB7CF /* ๅบ */,
0x8F56 /* ๅปฃ */, 0xB9E3 /* ๅนฟ */,
0x8F5B /* ๅปฉ */, 0xE2DE /* ๅปช */,
0x8F5D /* ๅปฌ */, 0xC2AE /* ๅบ */,
0x8F62 /* ๅปฑ */, 0xD3B8 /* ็ */,
0x8F64 /* ๅปณ */, 0xCCFC /* ๅ
*/,
0x8F73 /* ๅผ */, 0xDFB1 /* ๅผ */,
0x8F74 /* ๅผ */, 0xB5F5 /* ๅ */,
0x8F86 /* ๅผณ */, 0xE5F2 /* ๅผช */,
0x8F88 /* ๅผต */, 0xD5C5 /* ๅผ */,
0x8F8A /* ๅผท */, 0xC7BF /* ๅผบ */,
0x8F95 /* ๅฝ */, 0xB1F0 /* ๅซ */,
0x8F97 /* ๅฝ */, 0xB5AF /* ๅผน */,
0x8F99 /* ๅฝ */, 0xC7BF /* ๅผบ */,
0x8F9B /* ๅฝ */, 0xC3D6 /* ๅผฅ */,
0x8F9D /* ๅฝ */, 0xCDE4 /* ๅผฏ */,
0x8FA0 /* ๅฝ */, 0xC2BC /* ๅฝ */,
0x8FA1 /* ๅฝ */, 0xBBE3 /* ๆฑ */,
0x8FA9 /* ๅฝฅ */, 0xD1E5 /* ๅฝฆ */,
0x8FAC /* ๅฝซ */, 0xB5F1 /* ้ */,
0x8FB7 /* ๅฝฟ */, 0xB7F0 /* ไฝ */,
0xE1E1 /* ๅพ */, 0xBAF3 /* ๅ */,
0x8FBD /* ๅพ */, 0xBEB6 /* ๅพ */,
0x8FC4 /* ๅพ */, 0xB4D3 /* ไป */,
0x8FC6 /* ๅพ */, 0xE1E2 /* ๅพ */,
0x8FCD /* ๅพฉ */, 0xB8B4 /* ๅค */,
0x8FCF /* ๅพฌ */, 0xC5D4 /* ๆ */,
0xE1E7 /* ๅพต */, 0xD5F7 /* ๅพ */,
0x8FD8 /* ๅพน */, 0xB3B9 /* ๅฝป */,
0x9055 /* ๆณ */, 0xBBD0 /* ๆ */,
0x9061 /* ๆ */, 0xBAE3 /* ๆ */,
0x9075 /* ๆฅ */, 0xB3DC /* ่ป */,
0x9082 /* ๆ
*/, 0xD4C3 /* ๆฆ */,
0x909D /* ๆต */, 0xE2EA /* ๆ
*/,
0x909E /* ๆถ */, 0xC3C6 /* ้ท */,
0x90A2 /* ๆฝ */, 0xC6E0 /* ๅ */,
0x90B0 /* ๆ */, 0xC0B7 /* ๅฉช */,
0x90BA /* ๆก */, 0xB6F1 /* ๆถ */,
0x90C0 /* ๆฑ */, 0xC4D5 /* ๆผ */,
0x90C1 /* ๆฒ */, 0xE3A2 /* ๆฝ */,
0x90C5 /* ๆป */, 0xE2FC /* ๆป */,
0x90DB /* ๆ */, 0xB0AE /* ็ฑ */,
0x90DC /* ๆ */, 0xE3AB /* ๆฌ */,
0x90E2 /* ๆจ */, 0xEDA8 /* ๆซ */,
0x90ED /* ๆด */, 0xE2EB /* ๆ */,
0x90F0 /* ๆท */, 0xE2FD /* ๆบ */,
0x90F7 /* ๆพ */, 0xE2E9 /* ๅฟพ */,
0x90FC /* ๆ
*/, 0xC0F5 /* ๆ */,
0x9140 /* ๆ
*/, 0xD2F3 /* ๆฎท */,
0x9142 /* ๆ
*/, 0xCCAC /* ๆ */,
0x9143 /* ๆ
*/, 0xE3B3 /* ๆ */,
0x914B /* ๆ
*/, 0xB2D2 /* ๆจ */,
0x914D /* ๆ
*/, 0xB2D1 /* ๆญ */,
0x9151 /* ๆ
*/, 0xE2FA /* ๆธ */,
0x9154 /* ๆ
ฃ */, 0xB9DF /* ๆฏ */,
0x9159 /* ๆ
ช */, 0xE2E6 /* ๆ */,
0x915A /* ๆ
ซ */, 0xCBCB /* ๆ */,
0x915D /* ๆ
ฎ */, 0xC2C7 /* ่ */,
0x9161 /* ๆ
ณ */, 0xE3A5 /* ๆญ */,
0x9162 /* ๆ
ด */, 0xC9E5 /* ๆ
*/,
0x9163 /* ๆ
ถ */, 0xC7EC /* ๅบ */,
0x9168 /* ๆ
ผ */, 0xC6DD /* ๆ */,
0x916A /* ๆ
พ */, 0xD3FB /* ๆฌฒ */,
0x916E /* ๆ */, 0xD3C7 /* ๅฟง */,
0x9176 /* ๆ */, 0xB1B9 /* ๆซ */,
0x917A /* ๆ */, 0xC1AF /* ๆ */,
0x917B /* ๆ */, 0xC6BE /* ๅญ */,
0x917C /* ๆ */, 0xE3B4 /* ๆฆ */,
0x9184 /* ๆ */, 0xB5AC /* ๆฎ */,
0x918D /* ๆค */, 0xB7DF /* ๆค */,
0x9191 /* ๆซ */, 0xC3F5 /* ๆฏ */,
0x9193 /* ๆฎ */, 0xE2E4 /* ๆ */,
0x9197 /* ๆฒ */, 0xCFDC /* ๅฎช */,
0x919B /* ๆถ */, 0xD2E4 /* ๅฟ */,
0x91A5 /* ๆ */, 0xC7DA /* ๅค */,
0x91A9 /* ๆ */, 0xBFD2 /* ๆณ */,
0x91AA /* ๆ */, 0xD3A6 /* ๅบ */,
0x91AB /* ๆ */, 0xE2F8 /* ๆฟ */,
0x91AC /* ๆ */, 0xE9DD /* ๆชฉ */,
0x91BA /* ๆ */, 0xC3C9 /* ่ */,
0x91BB /* ๆ */, 0xEDA1 /* ๆผ */,
0x91BF /* ๆฃ */, 0xEDAF /* ๆ */,
0x91C3 /* ๆจ */, 0xE2FB /* ๆน */,
0x91CD /* ๆฒ */, 0xB3CD /* ๆฉ */,
0x91D0 /* ๆถ */, 0xC0C1 /* ๆ */,
0x91D1 /* ๆท */, 0xBBB3 /* ๆ */,
0x91D2 /* ๆธ */, 0xD0FC /* ๆฌ */,
0x91D4 /* ๆบ */, 0xE2E3 /* ๅฟ */,
0x91D6 /* ๆผ */, 0xBEE5 /* ๆง */,
0x91D7 /* ๆฝ */, 0xBBB6 /* ๆฌข */,
0x91D8 /* ๆพ */, 0xC9E5 /* ๆ
*/,
0x91D9 /* ๆ */, 0xC1B5 /* ๆ */,
0x91DF /* ๆ */, 0xEDB0 /* ๆ */,
0x91E0 /* ๆ */, 0xEEE1 /* ้บ */,
0x91E2 /* ๆ */, 0xEAA7 /* ๆ */,
0x91EA /* ๆง */, 0xEAA8 /* ๆ */,
0x91EC /* ๆฉ */, 0xEAAF /* ๆฌ */,
0x91F0 /* ๆฐ */, 0xD5BD /* ๆ */,
0x91F2 /* ๆฒ */, 0xCFB7 /* ๆ */,
0x91F4 /* ๆถ */, 0xBBA7 /* ๆท */,
0x9241 /* ๆ */, 0xD8EC /* ไป */,
0x9249 /* ๆ */, 0xBAB4 /* ๆ */,
0x924B /* ๆ */, 0xB2E6 /* ๅ */,
0x9257 /* ๆบ */, 0xB5D6 /* ๆต */,
0x925C /* ๆ */, 0xDED5 /* ๆ */,
0x925E /* ๆ */, 0xB2C1 /* ๆฆ */,
0x9264 /* ๆ */, 0xE9E6 /* ๆฎ */,
0x9277 /* ๆด */, 0xD2B7 /* ๆณ */,
0x9281 /* ๆ */, 0xC5D7 /* ๆ */,
0x9282 /* ๆ */, 0xC4C3 /* ๆฟ */,
0x9283 /* ๆ */, 0xC7AF /* ้ณ */,
0x929D /* ๆ */, 0xC4C3 /* ๆฟ */,
0x92B1 /* ๆถ */, 0xBED6 /* ๅฑ */,
0x92B6 /* ๆพ */, 0xD0AE /* ๆ */,
0x92BA /* ๆ */, 0xBEC8 /* ๆ */,
0x92CE /* ๆจ */, 0xC9E1 /* ่ */,
0x92D0 /* ๆซ */, 0xDED1 /* ๆช */,
0x92D4 /* ๆฒ */, 0xBEED /* ๅท */,
0x92DF /* ๆ */, 0xC9A8 /* ๆซ */,
0x92E0 /* ๆ */, 0xC2D5 /* ๆก */,
0x92EA /* ๆ */, 0xD5F5 /* ๆฃ */,
0x92EC /* ๆ */, 0xB9D2 /* ๆ */,
0x92F1 /* ๆก */, 0xB2C9 /* ้ */,
0x92F6 /* ๆฑ */, 0xB0C7 /* ๆ */,
0x92FC /* ๆฝ */, 0xC5F6 /* ็ขฐ */,
0x92FE /* ๆ */, 0xBCF0 /* ๆฃ */,
0x9348 /* ๆ */, 0xC8FB /* ๅก */,
0x9350 /* ๆ */, 0xD1EF /* ๆฌ */,
0x9351 /* ๆ */, 0xBBBB /* ๆข */,
0x9352 /* ๆ */, 0xD1DA /* ๆฉ */,
0x935B /* ๆซ */, 0xBEBE /* ๆช */,
0x935D /* ๆฎ */, 0xBBD3 /* ๆฅ */,
0x9364 /* ๆน */, 0xB1B3 /* ่ */,
0x936B /* ๆ */, 0xB9B9 /* ๆ */,
0x936E /* ๆ */, 0xC8B6 /* ๆฆท */,
0x9370 /* ๆ */, 0xCBF0 /* ๆ */,
0x9375 /* ๆ */, 0xD2A1 /* ๆ */,
0x9376 /* ๆ */, 0xB5B7 /* ๆฃ */,
0x937B /* ๆ */, 0xDFA6 /* ๆ */,
0x9380 /* ๆฅ */, 0xB4B7 /* ๆถ */,
0x9381 /* ๆง */, 0xC9BF /* ็
ฝ */,
0x9382 /* ๆจ */, 0xCDD8 /* ๆ */,
0x938C /* ๆถ */, 0xC7C0 /* ๆข */,
0x9392 /* ๆพ */, 0xD5A5 /* ๆฆจ */,
0x9393 /* ๆ */, 0xCEE6 /* ๆ */,
0x9395 /* ๆ */, 0xBFB8 /* ๆ */,
0x939D /* ๆ */, 0xDEE2 /* ๆด */,
0x93A5 /* ๆ */, 0xDEE8 /* ๆผ */,
0x93A7 /* ๆ */, 0xC2A7 /* ๆ */,
0x93B4 /* ๆฏ */, 0xD6BF /* ๆ */,
0x93B8 /* ๆณ */, 0xBFD9 /* ๆ */,
0x93BB /* ๆถ */, 0xDED2 /* ๆ */,
0x93BD /* ๆป */, 0xB2F4 /* ๆบ */,
0x93C6 /* ๆ */, 0xC0CC /* ๆ */,
0x93CE /* ๆ */, 0xB3C5 /* ๆ */,
0x93CF /* ๆ */, 0xC4D3 /* ๆ */,
0x93D3 /* ๆ */, 0xC4ED /* ๆป */,
0x93D7 /* ๆ */, 0xDED8 /* ๆข */,
0x93DA /* ๆข */, 0xB5A7 /* ๆธ */,
0x93DB /* ๆฃ */, 0xB5A7 /* ๆธ */,
0x93DC /* ๆฅ */, 0xB2A6 /* ๆจ */,
0x93DD /* ๆฆ */, 0xB3B6 /* ๆฏ */,
0x93E1 /* ๆซ */, 0xB8A7 /* ๆ */,
0x93E4 /* ๆฒ */, 0xC6CB /* ๆ */,
0x93E5 /* ๆณ */, 0xDEEC /* ๆฟ */,
0x93E9 /* ๆป */, 0xCCA2 /* ๆ */,
0x93EB /* ๆพ */, 0xCECE /* ๆ */,
0x93EC /* ๆฟ */, 0xBCF1 /* ๆก */,
0x93ED /* ๆ */, 0xD3B5 /* ๆฅ */,
0x93EF /* ๆ */, 0xC2B0 /* ๆณ */,
0x93F1 /* ๆ */, 0xD4F1 /* ๆฉ */,
0x93F4 /* ๆ */, 0xBBF7 /* ๅป */,
0x93F5 /* ๆ */, 0xB5B2 /* ๆก */,
0x93FA /* ๆ */, 0xB5A3 /* ๆ
*/,
0x93FE /* ๆ */, 0xBEDD /* ๆฎ */,
0x9444 /* ๆ */, 0xBCB7 /* ๆค */,
0x9446 /* ๆฃ */, 0xB5B7 /* ๆฃ */,
0x944D /* ๆฌ */, 0xC4E2 /* ๆ */,
0x944E /* ๆญ */, 0xBBA4 /* ๆค */,
0x9450 /* ๆฏ */, 0xB1F7 /* ๆ */,
0x9451 /* ๆฐ */, 0xC5A1 /* ๆง */,
0x9452 /* ๆฑ */, 0xB8E9 /* ๆ */,
0x9453 /* ๆฒ */, 0xD6C0 /* ๆท */,
0x9455 /* ๆด */, 0xC0A9 /* ๆฉ */,
0x9458 /* ๆท */, 0xDFA2 /* ๆท */,
0x945B /* ๆบ */, 0xB0DA /* ๆ */,
0x945C /* ๆป */, 0xCBD3 /* ๆ */,
0x945D /* ๆผ */, 0xDFA3 /* ๆธ */,
0x945F /* ๆพ */, 0xC8C5 /* ๆฐ */,
0x9464 /* ๆ */, 0xDEF3 /* ๆ
*/,
0x9466 /* ๆ */, 0xC4EC /* ๆต */,
0x946E /* ๆ */, 0xC2A3 /* ๆข */,
0x9472 /* ๆ */, 0xC0B9 /* ๆฆ */,
0x9473 /* ๆ */, 0xCFCB /* ็บค */,
0x9474 /* ๆ */, 0xDEFC /* ๆ */,
0x9476 /* ๆ */, 0xB2F3 /* ๆ */,
0x9478 /* ๆ */, 0xDFA5 /* ๆบ */,
0x9479 /* ๆ */, 0xD0AF /* ๆบ */,
0x947A /* ๆ */, 0xC9E3 /* ๆ */,
0x9480 /* ๆข */, 0xD4DC /* ๆ */,
0x9481 /* ๆฃ */, 0xC2CE /* ๆ */,
0x9482 /* ๆค */, 0xCCAF /* ๆ */,
0x9487 /* ๆช */, 0xBDC1 /* ๆ
*/,
0x9488 /* ๆฌ */, 0xC0BF /* ๆฝ */,
0x948E /* ๆท */, 0xBFBC /* ่ */,
0x9493 /* ๆ */, 0xB5E0 /* ๆ */,
0x94A1 /* ๆ */, 0xB0DC /* ่ดฅ */,
0x94A2 /* ๆ */, 0xD0F0 /* ๅ */,
0x94AD /* ๆช */, 0xB6DE /* ๆ */,
0x94B3 /* ๆต */, 0xB5D0 /* ๆ */,
0x94B5 /* ๆธ */, 0xCAFD /* ๆฐ */,
0x94B7 /* ๆบ */, 0xC7FD /* ้ฉฑ */,
0x94BF /* ๆ */, 0xC1B2 /* ๆ */,
0x94C0 /* ๆ */, 0xB1D0 /* ๆฏ */,
0x94CC /* ๆ */, 0xECB5 /* ๆ */,
0x94D8 /* ๆฌ */, 0xD5B6 /* ๆฉ */,
0x94D9 /* ๆฎ */, 0xEDBD /* ๆซ */,
0x94DB /* ๆฒ */, 0xEDBD /* ๆซ */,
0x94E0 /* ๆท */, 0xB6CF /* ๆญ */,
0xECB6 /* ๆผ */, 0xD3DA /* ไบ */,
0x94E7 /* ๆ */, 0xC6EC /* ๆ */,
0x94F5 /* ๆ */, 0xE1A6 /* ๅนก */,
0x954E /* ๆ */, 0xC9FD /* ๅ */,
0x9572 /* ๆ */, 0xCAB1 /* ๆถ */,
0x9578 /* ๆ */, 0xBDFA /* ๆ */,
0x9583 /* ๆ */, 0xD6E7 /* ๆผ */,
0x9584 /* ๆ */, 0xEAD8 /* ๆฆ */,
0x959E /* ๆ */, 0xD4CE /* ๆ */,
0x959F /* ๆ */, 0xEACD /* ๆ */,
0x95AA /* ๆ */, 0xD1F4 /* ้ณ */,
0x95B1 /* ๆ */, 0xF0A9 /* ็ */,
0x95B3 /* ๆข */, 0xB3A9 /* ็
*/,
0x95BA /* ๆซ */, 0xD4DD /* ๆ */,
0x95BF /* ๆฑ */, 0xEAC7 /* ๆต */,
0x95C5 /* ๆธ */, 0xC1CB /* ไบ */,
0x95CF /* ๆ */, 0xEACA /* ๆ */,
0x95D1 /* ๆ */, 0xC0FA /* ๅ */,
0x95D2 /* ๆ */, 0xEABC /* ๆ */,
0x95D4 /* ๆ */, 0xCFFE /* ๆ */,
0x95DA /* ๆ */, 0xCFF2 /* ๅ */,
0x95E1 /* ๆ */, 0xEAD3 /* ๆง */,
0x95E7 /* ๆ */, 0xBFF5 /* ๆท */,
0x95F1 /* ๆฌ */, 0xC9B9 /* ๆ */,
0x95F8 /* ๆธ */, 0xCAE9 /* ไนฆ */,
0x95FE /* ๆ */, 0xBBE1 /* ไผ */,
0x9652 /* ๆข */, 0xCDFB /* ๆ */,
0x9656 /* ๆง */, 0xEBCA /* ่ง */,
0x9658 /* ๆฎ */, 0xCAF5 /* ๆฏ */,
0x9667 /* ๆ */, 0xDBD8 /* ๅฌ */,
0x967C /* ๆฑ */, 0xB6AB /* ไธ */,
0x9691 /* ๆ */, 0xE8E2 /* ๆก */,
0x9695 /* ๆ */, 0xE8D9 /* ๆ */,
0x96A1 /* ๆด */, 0xB9D5 /* ๆ */,
0x96B9 /* ๆ */, 0xE9AA /* ๆฅ */,
0x96C5 /* ๆต */, 0xD5A4 /* ๆ
*/,
0x96CA /* ๆบ */, 0xB9D5 /* ๆ */,
0x96D5 /* ๆ */, 0xD1AE /* ๆฌ */,
0x96D6 /* ๆ */, 0xC6F5 /* ๅฅ */,
0x9747 /* ๆกฎ */, 0xB1AD /* ๆฏ */,
0x9755 /* ๆกฟ */, 0xB8CB /* ๆ */,
0x975B /* ๆข */, 0xD7AE /* ๆกฉ */,
0x9764 /* ๆข */, 0xE8D9 /* ๆ */,
0x976B /* ๆข */, 0xB2DF /* ็ญ */,
0x976C /* ๆข */, 0xCCF5 /* ๆก */,
0x976E /* ๆข */, 0xE8C9 /* ๆญ */,
0x9779 /* ๆขฑ */, 0xC0A6 /* ๆ */,
0x9789 /* ๆฃ */, 0xC6FA /* ๅผ */,
0x9793 /* ๆฃ */, 0xC5C5 /* ๆ */,
0x9796 /* ๆฃ */, 0xE8C7 /* ๆจ */,
0x9797 /* ๆฃ */, 0xD4E6 /* ๆฃ */,
0x979D /* ๆฃ */, 0xB6B0 /* ๆ */,
0x97A3 /* ๆฃง */, 0xD5BB /* ๆ */,
0x97AB /* ๆฃฒ */, 0xC6DC /* ๆ */,
0x97BF /* ๆค */, 0xE8E2 /* ๆก */,
0x97C5 /* ๆค */, 0xEDD6 /* ็ข */,
0x97DF /* ๆคท */, 0xBCEA /* ็ผ */,
0x97EE /* ๆฅ */, 0xD1EE /* ๆจ */,
0x97F7 /* ๆฅ */, 0xB7E3 /* ๆซ */,
0x9845 /* ๆฅจ */, 0xE8E5 /* ๆกข */,
0x9849 /* ๆฅญ */, 0xD2B5 /* ไธ */,
0x984F /* ๆฅต */, 0xBCAB /* ๆ */,
0x985E /* ๆฆ */, 0xDEF8 /* ๆ */,
0x986C /* ๆฆฃ */, 0xD2A1 /* ๆ */,
0x986F /* ๆฆฆ */, 0xB8C9 /* ๅนฒ */,
0x9871 /* ๆฆช */, 0xE8BF /* ๆฉ */,
0x9873 /* ๆฆฎ */, 0xC8D9 /* ่ฃ */,
0x9881 /* ๆฆฟ */, 0xE8E7 /* ๆกค */,
0x9884 /* ๆง */, 0xC5CC /* ็ */,
0x988B /* ๆง */, 0xB9B9 /* ๆ */,
0x988C /* ๆง */, 0xC7B9 /* ๆช */,
0x9890 /* ๆง */, 0xB8DC /* ๆ */,
0x98A0 /* ๆงง */, 0xE8FD /* ๆค */,
0x98A1 /* ๆงจ */, 0xE9A4 /* ๆค */,
0x98AA /* ๆงณ */, 0xBDB0 /* ๆกจ */,
0x98B3 /* ๆงผ */, 0xB9E6 /* ่ง */,
0x98B6 /* ๆจ */, 0xD7AE /* ๆกฉ */,
0x98B7 /* ๆจ */, 0xC0D6 /* ไน */,
0x98BA /* ๆจ
*/, 0xE8C8 /* ๆ */,
0x98C5 /* ๆจ */, 0xC1BA /* ๆข */,
0x98C7 /* ๆจ */, 0xC2A5 /* ๆฅผ */,
0x98CB /* ๆจ */, 0xB1EA /* ๆ */,
0x98D0 /* ๆจ */, 0xCAE0 /* ๆข */,
0x98D3 /* ๆจฃ */, 0xD1F9 /* ๆ ท */,
0x98E3 /* ๆจธ */, 0xC6D3 /* ๆด */,
0x98E4 /* ๆจน */, 0xCAF7 /* ๆ */,
0x98E5 /* ๆจบ */, 0xE8EB /* ๆกฆ */,
0x98EF /* ๆฉ */, 0xE8E3 /* ๆกก */,
0x98F2 /* ๆฉ */, 0xC7C5 /* ๆกฅ */,
0x9943 /* ๆฉ */, 0xBBFA /* ๆบ */,
0x9945 /* ๆฉข */, 0xCDD6 /* ๆคญ */,
0x9947 /* ๆฉค */, 0xC8EF /* ่ */,
0x994D /* ๆฉซ */, 0xBAE1 /* ๆจช */,
0x995F /* ๆช */, 0xE9DD /* ๆชฉ */,
0x9966 /* ๆช */, 0xE8DF /* ๆฝ */,
0x996E /* ๆช */, 0xB5B5 /* ๆกฃ */,
0x9975 /* ๆช */, 0xE8ED /* ๆกง */,
0x997A /* ๆชข */, 0xBCEC /* ๆฃ */,
0x997B /* ๆชฃ */, 0xE9C9 /* ๆจฏ */,
0x9985 /* ๆชฏ */, 0xCCA8 /* ๅฐ */,
0x9989 /* ๆชณ */, 0xE9C4 /* ๆง */,
0x998D /* ๆชท */, 0xECF2 /* ็ฅข */,
0x998E /* ๆชธ */, 0xC4FB /* ๆ */,
0x9991 /* ๆชป */, 0xBCF7 /* ๆง */,
0x9998 /* ๆซ */, 0xE8FE /* ๆฃน */,
0x9999 /* ๆซ */, 0xB9F1 /* ๆ */,
0x99A9 /* ๆซ */, 0xE9D6 /* ๆฉน */,
0x99B0 /* ๆซ */, 0xE9B5 /* ๆฆ */,
0x99B1 /* ๆซ */, 0xE8CE /* ๆ */,
0x99B3 /* ๆซ */, 0xE8FC /* ๆค */,
0x99B4 /* ๆซ */, 0xE9DA /* ๆฉผ */,
0x99B5 /* ๆซ */, 0xE8DD /* ๆ */,
0x99BB /* ๆซฅ */, 0xB3F7 /* ๆฉฑ */,
0x99BD /* ๆซง */, 0xE9C6 /* ๆง */,
0x99BE /* ๆซจ */, 0xE8D3 /* ๆ */,
0x99C0 /* ๆซช */, 0xE8C0 /* ๆฅ */,
0x99C2 /* ๆซฌ */, 0xE9B4 /* ๆฆ */,
0x99C9 /* ๆซณ */, 0xE8D0 /* ๆ */,
0x99CE /* ๆซธ */, 0xE9B7 /* ๆฆ */,
0x99D0 /* ๆซบ */, 0xE8F9 /* ๆฃ */,
0x99D1 /* ๆซป */, 0xD3A3 /* ๆจฑ */,
0x99DA /* ๆฌ */, 0xC0B8 /* ๆ */,
0x99E0 /* ๆฌ */, 0xC8A8 /* ๆ */,
0x99E5 /* ๆฌ */, 0xE9A1 /* ๆคค */,
0x99E8 /* ๆฌ */, 0xE8EF /* ๆ พ */,
0x99EC /* ๆฌ */, 0xE9AD /* ๆฆ */,
0x99F4 /* ๆฌ */, 0xE8F9 /* ๆฃ */,
0x9A42 /* ๆฌฑ */, 0xBAC8 /* ๅ */,
0x9A47 /* ๆฌธ */, 0xB0A6 /* ๅ */,
0x9A4A /* ๆฌฝ */, 0xC7D5 /* ้ฆ */,
0x9A55 /* ๆญ */, 0xCCBE /* ๅน */,
0x9A57 /* ๆญ */, 0xC5B7 /* ๆฌง */,
0x9A61 /* ๆญ */, 0xC1B2 /* ๆ */,
0x9A65 /* ๆญ */, 0xECA3 /* ๆฌค */,
0x9A67 /* ๆญก */, 0xBBB6 /* ๆฌข */,
0x9A71 /* ๆญฒ */, 0xCBEA /* ๅฒ */,
0x9A76 /* ๆญท */, 0xC0FA /* ๅ */,
0x9A77 /* ๆญธ */, 0xB9E9 /* ๅฝ */,
0x9A7B /* ๆญฟ */, 0xE9E2 /* ๆฎ */,
0x9A7C /* ๆฎ */, 0xD8B2 /* ๅคญ */,
0x9A88 /* ๆฎ */, 0xB2D0 /* ๆฎ */,
0x9A8C /* ๆฎ */, 0xE9E6 /* ๆฎ */,
0x9A91 /* ๆฎค */, 0xE9E4 /* ๆฎ */,
0x9A97 /* ๆฎซ */, 0xE9E9 /* ๆฎ */,
0x9A99 /* ๆฎญ */, 0xBDA9 /* ๅต */,
0x9A9A /* ๆฎฎ */, 0xE9E7 /* ๆฎ */,
0x9A9B /* ๆฎฏ */, 0xE9EB /* ๆฎก */,
0x9A9E /* ๆฎฒ */, 0xBCDF /* ๆญผ */,
0x9AA2 /* ๆฎบ */, 0xC9B1 /* ๆ */,
0x9AA4 /* ๆฎผ */, 0xBFC7 /* ๅฃณ */,
0x9AA5 /* ๆฎฝ */, 0xCFFD /* ๆท */,
0x9AA7 /* ๆฏ */, 0xBBD9 /* ๆฏ */,
0x9AAA /* ๆฏ */, 0xC5B9 /* ๆฎด */,
0x9AAF /* ๆฏ */, 0xCEE3 /* ๆฏ */,
0x9AB3 /* ๆฏ */, 0xC5FE /* ๆฏ */,
0x9AC2 /* ๆฏฌ */, 0xC7F2 /* ็ */,
0x9AD0 /* ๆฏฟ */, 0xEBA7 /* ๆฏต */,
0x9AD3 /* ๆฐ */, 0xEAF3 /* ็ฆ */,
0x9AD6 /* ๆฐ */, 0xD5B1 /* ๆฏก */,
0x9ADA /* ๆฐ */, 0xEBAA /* ๆฐ */,
0x9AE2 /* ๆฐฃ */, 0xC6F8 /* ๆฐ */,
0x9AE4 /* ๆฐซ */, 0xC7E2 /* ๆฐข */,
0x9AE5 /* ๆฐฌ */, 0xEBB2 /* ๆฐฉ */,
0x9AE8 /* ๆฐณ */, 0xEBB5 /* ๆฐฒ */,
0x9AEF /* ๆฐพ */, 0xB7BA /* ๆณ */,
0x9AF7 /* ๆฑ */, 0xCDE8 /* ไธธ */,
0x9AF8 /* ๆฑ */, 0xB7BA /* ๆณ */,
0x9B40 /* ๆฑ */, 0xCEDB /* ๆฑก */,
0x9B51 /* ๆฑบ */, 0xBEF6 /* ๅณ */,
0x9B5A /* ๆฒ */, 0xD9FC /* ๅฑ */,
0x9B5D /* ๆฒ */, 0xC3BB /* ๆฒก */,
0x9B5F /* ๆฒ */, 0xB3E5 /* ๅฒ */,
0x9B72 /* ๆณ */, 0xBFF6 /* ๅต */,
0x9B83 /* ๆณ */, 0xCBDD /* ๆบฏ */,
0x9BAA /* ๆดฉ */, 0xD0B9 /* ๆณ */,
0x9BB0 /* ๆดถ */, 0xD0DA /* ๆฑน */,
0x9BC9 /* ๆตฌ */, 0xC0EF /* ้ */,
0x9BD1 /* ๆตน */, 0xE4A4 /* ๆต */,
0x9BDC /* ๆถ */, 0xE3FE /* ๆณพ */,
0x9BF2 /* ๆถท */, 0xB6B3 /* ๅป */,
0x9BF6 /* ๆถผ */, 0xC1B9 /* ๅ */,
0x9C44 /* ๆท */, 0xC6E0 /* ๅ */,
0x9C49 /* ๆท */, 0xC0E1 /* ๆณช */,
0x9C4A /* ๆท */, 0xD5E3 /* ๆต */,
0x9C4F /* ๆทฅ */, 0xE4CB /* ๆธ */,
0x9C51 /* ๆทจ */, 0xBEBB /* ๅ */,
0x9C52 /* ๆทฉ */, 0xC1E8 /* ๅ */,
0x9C53 /* ๆทช */, 0xC2D9 /* ๆฒฆ */,
0x9C59 /* ๆทต */, 0xD4A8 /* ๆธ */,
0x9C5A /* ๆทถ */, 0xE4B5 /* ๆถ */,
0x9C5C /* ๆทบ */, 0xC7B3 /* ๆต
*/,
0x9C6F /* ๆธ */, 0xBBC1 /* ๆถฃ */,
0x9C70 /* ๆธ */, 0xBCF5 /* ๅ */,
0x9C75 /* ๆธฆ */, 0xCED0 /* ๆถก */,
0x9C79 /* ๆธฌ */, 0xB2E2 /* ๆต */,
0x9C86 /* ๆธพ */, 0xBBEB /* ๆต */,
0x9C90 /* ๆน */, 0xB4D5 /* ๅ */,
0x9C9D /* ๆน */, 0xE4A5 /* ๆต */,
0x9CA5 /* ๆนง */, 0xD3BF /* ๆถ */,
0x9CAB /* ๆนฏ */, 0xCCC0 /* ๆฑค */,
0x9CBF /* ๆบ */, 0xE3ED /* ๆฒฉ */,
0x9CCA /* ๆบ */, 0xD7BC /* ๅ */,
0x9CCF /* ๆบ */, 0xB9B5 /* ๆฒ */,
0x9CD8 /* ๆบซ */, 0xCEC2 /* ๆธฉ */,
0x9CE1 /* ๆบผ */, 0xCAAA /* ๆนฟ */,
0x9CE6 /* ๆป */, 0xB2D7 /* ๆฒง */,
0x9CE7 /* ๆป
*/, 0xC3F0 /* ็ญ */,
0x9CEC /* ๆป */, 0xB5D3 /* ๆถค */,
0x9CEE /* ๆป */, 0xDCFE /* ่ฅ */,
0x9CFB /* ๆปฌ */, 0xBBA6 /* ๆฒช */,
0x9CFE /* ๆปฏ */, 0xD6CD /* ๆป */,
0x9D42 /* ๆปฒ */, 0xC9F8 /* ๆธ */,
0x9D46 /* ๆปท */, 0xC2B1 /* ๅค */,
0x9D47 /* ๆปธ */, 0xE4B0 /* ๆต */,
0x9D4C /* ๆปพ */, 0xB9F6 /* ๆป */,
0x9D4D /* ๆปฟ */, 0xC2FA /* ๆปก */,
0x9D4F /* ๆผ */, 0xD3E6 /* ๆธ */,
0x9D61 /* ๆผ */, 0xC5BD /* ๆฒค */,
0x9D68 /* ๆผข */, 0xBABA /* ๆฑ */,
0x9D69 /* ๆผฃ */, 0xC1B0 /* ๆถ */,
0x9D6A /* ๆผฅ */, 0xCDDD /* ๆดผ */,
0x9D6E /* ๆผฌ */, 0xD7D5 /* ๆธ */,
0x9D71 /* ๆผฒ */, 0xD5C7 /* ๆถจ */,
0x9D75 /* ๆผธ */, 0xBDA5 /* ๆธ */,
0x9D7B /* ๆผฟ */, 0xBDAC /* ๆต */,
0x9D7D /* ๆฝ */, 0xF2A3 /* ้ข */,
0x9D8A /* ๆฝ */, 0xC6C3 /* ๆณผ */,
0x9D8D /* ๆฝ */, 0xBDE0 /* ๆด */,
0x9D93 /* ๆฝ */, 0xC7B1 /* ๆฝ */,
0x9D95 /* ๆฝ */, 0xD0BA /* ๆณป */,
0x9D99 /* ๆฝค */, 0xC8F3 /* ๆถฆ */,
0x9DA1 /* ๆฝฏ */, 0xE4B1 /* ๆต */,
0x9DA2 /* ๆฝฐ */, 0xC0A3 /* ๆบ */,
0x9DA7 /* ๆฝท */, 0xE4E4 /* ๆป */,
0x9DAC /* ๆฝฟ */, 0xE4B6 /* ๆถ */,
0x9DAD /* ๆพ */, 0xC9AC /* ๆถฉ */,
0x9DB2 /* ๆพ */, 0xBDBD /* ๆต */,
0x9DB3 /* ๆพ */, 0xC0D4 /* ๆถ */,
0x9DBE /* ๆพ */, 0xBDA7 /* ๆถง */,
0x9DC6 /* ๆพ */, 0xE4C5 /* ๆธ */,
0x9DC8 /* ๆพฃ */, 0xE4BD /* ๆตฃ */,
0x9DC9 /* ๆพค */, 0xD4F3 /* ๆณฝ */,
0x9DCD /* ๆพฉ */, 0xEDB4 /* ๆณถ */,
0x9DD2 /* ๆพฎ */, 0xE4AB /* ๆต */,
0x9DD5 /* ๆพฑ */, 0xB5ED /* ๆท */,
0x9DE1 /* ๆฟ */, 0xD7C7 /* ๆต */,
0x9DE2 /* ๆฟ */, 0xC5A8 /* ๆต */,
0x9DE6 /* ๆฟ */, 0xC9AC /* ๆถฉ */,
0x9DF1 /* ๆฟ */, 0xCAAA /* ๆนฟ */,
0x9DF4 /* ๆฟ */, 0xC5A2 /* ๆณ */,
0x9DF7 /* ๆฟ */, 0xC3C9 /* ่ */,
0x9DFA /* ๆฟ */, 0xBCC3 /* ๆต */,
0x9DFD /* ๆฟค */, 0xCCCE /* ๆถ */,
0x9E45 /* ๆฟซ */, 0xC0C4 /* ๆปฅ */,
0x9E46 /* ๆฟฌ */, 0xBFA3 /* ๆต */,
0x9E48 /* ๆฟฐ */, 0xCEAB /* ๆฝ */,
0x9E49 /* ๆฟฑ */, 0xB1F5 /* ๆปจ */,
0x9E52 /* ๆฟบ */, 0xBDA6 /* ๆบ
*/,
0x9E54 /* ๆฟผ */, 0xE3F8 /* ๆณบ */,
0x9E56 /* ๆฟพ */, 0xC2CB /* ๆปค */,
0x9E5D /* ็
*/, 0xE4DE /* ๆปข */,
0x9E5E /* ็ */, 0xE4C2 /* ๆธ */,
0x9E61 /* ็ */, 0xD0BA /* ๆณป */,
0x9E63 /* ็ */, 0xC9F2 /* ๆฒ */,
0x9E67 /* ็ */, 0xE4AF /* ๆต */,
0x9E6C /* ็ */, 0xB1F4 /* ๆฟ */,
0x9E6F /* ็ */, 0xE3F2 /* ๆณธ */,
0x9E72 /* ็ */, 0xC1A4 /* ๆฒฅ */,
0x9E74 /* ็ */, 0xE4EC /* ๆฝ */,
0x9E75 /* ็ */, 0xE4EB /* ๆฝ */,
0x9E7B /* ็ง */, 0xE3F1 /* ๆณท */,
0x9E7C /* ็จ */, 0xE4FE /* ๆฟ */,
0x9E85 /* ็ฐ */, 0xC3D6 /* ๅผฅ */,
0x9E87 /* ็ฒ */, 0xE4F2 /* ๆฝ */,
0x9E91 /* ็พ */, 0xC0BD /* ๆพ */,
0x9E96 /* ็ */, 0xE3E3 /* ๆฒฃ */,
0x9E97 /* ็ */, 0xE4DC /* ๆป */,
0x9EA2 /* ็ */, 0xC8F7 /* ๆด */,
0x9EA6 /* ็ */, 0xC0EC /* ๆผ */,
0x9EA9 /* ็ */, 0xCCB2 /* ๆปฉ */,
0x9EAE /* ็ */, 0xE5B0 /* ็ */,
0x9EB0 /* ็ */, 0xE4ED /* ๆผค */,
0x9EB3 /* ็ฃ */, 0xCDE5 /* ๆนพ */,
0x9EB4 /* ็ค */, 0xC2D0 /* ๆปฆ */,
0x9EB8 /* ็จ */, 0xB8D3 /* ่ตฃ */,
0x9EB9 /* ็ฉ */, 0xD1DE /* ่ณ */,
0x9EC4 /* ็ฝ */, 0xD4D6 /* ็พ */,
0x9EDD /* ็ค */, 0xD5D5 /* ็
ง */,
0x9EE9 /* ็บ */, 0xCEAA /* ไธบ */,
0x9EF5 /* ็ */, 0xCEDA /* ไน */,
0x9F4E /* ็ด */, 0xCCFE /* ็ */,
0x9F6A /* ็ */, 0xC0A5 /* ๆ */,
0x9F6E /* ็ */, 0xB4E3 /* ๆทฌ */,
0x9F6F /* ็ก */, 0xCEDE /* ๆ */,
0x9F90 /* ็
*/, 0xBBD4 /* ่พ */,
0x9F92 /* ็
*/, 0xC1B6 /* ็ผ */,
0x9F98 /* ็
*/, 0xECBF /* ็ */,
0x9F9C /* ็
*/, 0xC5AF /* ๆ */,
0x9F9F /* ็
*/, 0xD1CC /* ็ */,
0x9FA4 /* ็
*/, 0xD5A8 /* ็ธ */,
0x9FA6 /* ็
ข */, 0xDCE4 /* ่ */,
0x9FA8 /* ็
ฅ */, 0xBBC0 /* ็ */,
0x9FA9 /* ็
ฉ */, 0xB7B3 /* ็ฆ */,
0x9FAC /* ็
ฌ */, 0xECBE /* ็ */,
0x9FC9 /* ็ */, 0xD3AB /* ่ง */,
0x9FCD /* ็ */, 0xECC1 /* ็ */,
0x9FE1 /* ็ฑ */, 0xC8C8 /* ็ญ */,
0x9FEB /* ็พ */, 0xB3E3 /* ็ฝ */,
0x9FEE /* ็ */, 0xECC7 /* ็จ */,
0x9FF0 /* ็ */, 0xD1E6 /* ็ฐ */,
0x9FF4 /* ็ */, 0xB5C6 /* ็ฏ */,
0x9FF5 /* ็ */, 0xECC0 /* ็ */,
0x9FFB /* ็ */, 0xC1D7 /* ็ฃท */,
0x9FFD /* ็ */, 0xC9D5 /* ็ง */,
0xA043 /* ็ */, 0xCCCC /* ็ซ */,
0xA046 /* ็ */, 0xECCB /* ็ */,
0xA049 /* ็ */, 0xD3AA /* ่ฅ */,
0xA04E /* ็ฆ */, 0xB2D3 /* ็ฟ */,
0xA053 /* ็ฌ */, 0xBBD9 /* ๆฏ */,
0xA054 /* ็ญ */, 0xD6F2 /* ็ */,
0xA05A /* ็ด */, 0xBBE2 /* ็ฉ */,
0xA060 /* ็ป */, 0xD1AC /* ็ */,
0xA061 /* ็ผ */, 0xBDFD /* ็ฌ */,
0xA063 /* ็พ */, 0xECE2 /* ็ */,
0xA071 /* ็ */, 0xCBB8 /* ็ */,
0xA074 /* ็ */, 0xC2AF /* ็ */,
0xA080 /* ็ */, 0xC0C3 /* ็ */,
0xA08E /* ็ญ */, 0xD5F9 /* ไบ */,
0xA094 /* ็บ */, 0xD2AF /* ็ท */,
0xA096 /* ็พ */, 0xB6FB /* ๅฐ */,
0xA09D /* ็ */, 0xC7BD /* ๅข */,
0xA0A9 /* ็ */, 0xEBB9 /* ็ */,
0xA0AD /* ็ */, 0xCBFC /* ๅฎ */,
0xA0B9 /* ็ด */, 0xB5D6 /* ๆต */,
0xA0BF /* ็ฝ */, 0xC7A3 /* ็ต */,
0xA0CE /* ็ */, 0xDCFD /* ่ฆ */,
0xA0D3 /* ็ */, 0xC0E7 /* ็ */,
0xA0D9 /* ็ข */, 0xB6BF /* ็ */,
0xA0DE /* ็ง */, 0xCEFE /* ็บ */,
0xA0EE /* ็ */, 0xD7B4 /* ็ถ */,
0xAA4D /* ็น */, 0xCFC1 /* ็ญ */,
0xAA4E /* ็ฝ */, 0xB1B7 /* ็ */,
0xAA62 /* ็ */, 0xD5F8 /* ็ฐ */,
0xAA71 /* ็ถ */, 0xD3CC /* ็น */,
0xAA72 /* ็บ */, 0xD1FE /* ็ถ */,
0xAA73 /* ็ป */, 0xE1F8 /* ็ฒ */,
0xAA79 /* ็ */, 0xB4F4 /* ๅ */,
0xAA7A /* ็ */, 0xD3FC /* ็ฑ */,
0xAA7B /* ็
*/, 0xCAA8 /* ็ฎ */,
0xAA84 /* ็ */, 0xBDB1 /* ๅฅ */,
0xAA9A /* ็จ */, 0xB6C0 /* ็ฌ */,
0xAA9C /* ็ช */, 0xE1F6 /* ็ฏ */,
0xAA9D /* ็ซ */, 0xE1FD /* ็ */,
0xAA9E /* ็ฎ */, 0xE2A8 /* ็ */,
0xAA9F /* ็ฐ */, 0xC4FC /* ็ */,
0xAB40 /* ็ฒ */, 0xBBF1 /* ่ท */,
0xAB43 /* ็ต */, 0xC1D4 /* ็ */,
0xAB45 /* ็ท */, 0xE1EE /* ็ท */,
0xAB46 /* ็ธ */, 0xCADE /* ๅ
ฝ */,
0xAB48 /* ็บ */, 0xCCA1 /* ็ญ */,
0xAB49 /* ็ป */, 0xCFD7 /* ็ฎ */,
0xAB4A /* ็ผ */, 0xE2A8 /* ็ */,
0xAB4D /* ็ */, 0xE2A4 /* ็ก */,
0xAB51 /* ็
*/, 0xC3EE /* ๅฆ */,
0xAB52 /* ็ */, 0xD7C8 /* ๅ
น */,
0xAB65 /* ็ก */, 0xE7F0 /* ็ */,
0xAB6B /* ็จ */, 0xE7E5 /* ็ */,
0xAB98 /* ็ฎ */, 0xC5E5 /* ไฝฉ */,
0xAC46 /* ็พ */, 0xCFD6 /* ็ฐ */,
0xAC50 /* ็ */, 0xC1A7 /* ็ */,
0xAC57 /* ็ */, 0xD5B5 /* ็ */,
0xAC68 /* ็ฑ */, 0xB5F1 /* ้ */,
0xAC6D /* ็บ */, 0xB7A9 /* ็ */,
0xAC71 /* ็ฟ */, 0xE7F5 /* ็ฒ */,
0xAC7C /* ็ */, 0xE7E2 /* ็ฎ */,
0xAC8D /* ็ฃ */, 0xCBF6 /* ็ */,
0xAC8E /* ็ค */, 0xD1FE /* ็ถ */,
0xAC93 /* ็ฉ */, 0xD3A8 /* ่น */,
0xAC94 /* ็ช */, 0xC2EA /* ็ */,
0xAC98 /* ็ฏ */, 0xC0C5 /* ็
*/,
0xAD49 /* ็ */, 0xE7F6 /* ็ */,
0xAD5E /* ็ฃ */, 0xE7E1 /* ็ */,
0xAD61 /* ็ฆ */, 0xE8A8 /* ็ท */,
0xAD68 /* ็ฐ */, 0xBBB7 /* ็ฏ */,
0xAD74 /* ็ฝ */, 0xE7F4 /* ็บ */,
0xAD76 /* ็ฟ */, 0xE8AF /* ็ */,
0xAD82 /* ็ */, 0xC7ED /* ็ผ */,
0xAD87 /* ็ */, 0xE7E7 /* ็ */,
0xAD8B /* ็ */, 0xE8AC /* ็ */,
0xAD8D /* ็ */, 0xCFE2 /* ้ถ */,
0xAD91 /* ็ */, 0xE8B6 /* ็ */,
0xAE54 /* ็ */, 0xEAB1 /* ็ฏ */,
0xAE59 /* ็ */, 0xCECD /* ็ฎ */,
0xAE61 /* ็ข */, 0xB2FA /* ไบง */,
0xAE64 /* ็ฆ */, 0xCBD5 /* ่ */,
0xAE6C /* ็ฝ */, 0xDBDA /* ๅณ */,
0xAE80 /* ็ */, 0xC4B6 /* ไบฉ */,
0xAE85 /* ็ข */, 0xB1CF /* ๆฏ */,
0xAE8B /* ็ซ */, 0xBBAD /* ็ป */,
0xAE8C /* ็ฌ */, 0xEEB4 /* ็ฒ */,
0xAE90 /* ็ฐ */, 0xD2EC /* ๅผ */,
0xAE94 /* ็ถ */, 0xB5B1 /* ๅฝ */,
0xAEA0 /* ็ */, 0xB3EB /* ็ด */,
0xAF42 /* ็ */, 0xB5FE /* ๅ */,
0xAF49 /* ็ */, 0xB8D8 /* ่ */,
0xAF58 /* ็ฟ */, 0xF0F2 /* ็ฑ */,
0xAF5D /* ็ */, 0xB6B2 /* ๆซ */,
0xAF64 /* ็ */, 0xBEB7 /* ็ */,
0xAF69 /* ็ */, 0xCBE1 /* ้
ธ */,
0xAF71 /* ็ฒ */, 0xC2E9 /* ้บป */,
0xAF72 /* ็ณ */, 0xC2E9 /* ้บป */,
0xAF77 /* ็บ */, 0xB1D4 /* ็น */,
0xAF80 /* ็ */, 0xF1A1 /* ็ */,
0xAF81 /* ็ */, 0xD3FA /* ๆ */,
0xAF82 /* ็ */, 0xB7E8 /* ็ฏ */,
0xAF83 /* ็ */, 0xD1F1 /* ็ก */,
0xAF88 /* ็ */, 0xBBBE /* ็ช */,
0xAF8A /* ็ */, 0xE0B3 /* ๅ */,
0xAF8E /* ็ */, 0xF0F9 /* ็ */,
0xAF8F /* ็ก */, 0xB4AF /* ็ฎ */,
0xAF91 /* ็ง */, 0xC5B1 /* ็ */,
0xAF9B /* ็บ */, 0xF0FC /* ็ */,
0xAF9F /* ็ */, 0xC1C6 /* ็ */,
0xB041 /* ็ */, 0xF0EC /* ็จ */,
0xB042 /* ็ */, 0xF0EF /* ็ซ */,
0xB043 /* ็ */, 0xB7CF /* ๅบ */,
0xB044 /* ็ */, 0xF0F7 /* ็
*/,
0xB04B /* ็ */, 0xD3FA /* ๆ */,
0xB04F /* ็ */, 0xF0DD /* ็ */,
0xB054 /* ็ */, 0xB1F1 /* ็ช */,
0xB056 /* ็ก */, 0xB3D5 /* ็ด */,
0xB057 /* ็ข */, 0xD1F7 /* ็ */,
0xB058 /* ็ค */, 0xF0DC /* ็ */,
0xB059 /* ็ฅ */, 0xD6A2 /* ็ */,
0xB05D /* ็ฉ */, 0xF1AE /* ็ */,
0xB05F /* ็ฌ */, 0xD1A2 /* ็ฃ */,
0xB060 /* ็ญ */, 0xF1A8 /* ็ฟ */,
0xB061 /* ็ฎ */, 0xF1AB /* ็พ */,
0xB062 /* ็ฐ */, 0xD3B8 /* ็ */,
0xB063 /* ็ฑ */, 0xCCB1 /* ็ซ */,
0xB064 /* ็ฒ */, 0xF1B2 /* ็ซ */,
0xB06C /* ็ผ */, 0xB7A2 /* ๅ */,
0xB06F /* ็ */, 0xD4ED /* ็ */,
0xB07D /* ็ */, 0xB0A8 /* ็ */,
0xB080 /* ็ */, 0xF0A9 /* ็ */,
0xB092 /* ็ฐ */, 0xF0E5 /* ็ฑ */,
0xB097 /* ็ธ */, 0xF1E4 /* ็ฒ */,
0xB099 /* ็บ */, 0xD6E5 /* ็ฑ */,
0xB0A0 /* ็ */, 0xB1AD /* ๆฏ */,
0xB149 /* ็ */, 0xB5C1 /* ็ */,
0xB14B /* ็ */, 0xD5B5 /* ็ */,
0xB14D /* ็ก */, 0xBEA1 /* ๅฐฝ */,
0xB14F /* ็ฃ */, 0xBCE0 /* ็ */,
0xB150 /* ็ค */, 0xC5CC /* ็ */,
0xB152 /* ็ง */, 0xC2AC /* ๅข */,
0xB155 /* ็ช */, 0xB5B4 /* ่ก */,
0xB17B /* ็ฅ */, 0xEDF6 /* ็ฆ */,
0xB18A /* ็พ */, 0xD6DA /* ไผ */,
0xB197 /* ็ */, 0xC0A7 /* ๅฐ */,
0xB1A0 /* ็ */, 0xD5F6 /* ็ */,
0xB241 /* ็ */, 0xEDF9 /* ็ */,
0xB243 /* ็ */, 0xBEEC /* ็ท */,
0xB247 /* ็ช */, 0xD8BA /* ็พ */,
0xB25B /* ็ */, 0xC3D0 /* ็ฏ */,
0xB25F /* ็ */, 0xEEAA /* ็ */,
0xB26D /* ็ */, 0xC2F7 /* ็ */,
0xB274 /* ็ญ */, 0xC1CB /* ไบ */,
0xB280 /* ็ผ */, 0xEDFA /* ็ */,
0xB289 /* ็ */, 0xC3C9 /* ่ */,
0xB294 /* ็ */, 0xEBCA /* ่ง */,
0xB299 /* ็ */, 0xEEAB /* ็ฐ */,
0xB29A /* ็ */, 0xD6F5 /* ็ฉ */,
0xB343 /* ็ฏ */, 0xBDC3 /* ็ซ */,
0xB368 /* ็ ฒ */, 0xC5DA /* ็ฎ */,
0xB370 /* ็ก */, 0xD6EC /* ๆฑ */,
0xB388 /* ็กค */, 0xEDCC /* ็ก */,
0xB38C /* ็กจ */, 0xEDBA /* ็ */,
0xB38E /* ็กฏ */, 0xD1E2 /* ็ */,
0xB454 /* ็ขฉ */, 0xCBB6 /* ็ก */,
0xB455 /* ็ขช */, 0xD5E8 /* ็ ง */,
0xB458 /* ็ขญ */, 0xEDB8 /* ็ */,
0xB45F /* ็ขบ */, 0xC8B7 /* ็กฎ */,
0xB460 /* ็ขป */, 0xC8B7 /* ็กฎ */,
0xB461 /* ็ขผ */, 0xC2EB /* ็ */,
0xB475 /* ็ฃ */, 0xD7A9 /* ็ */,
0xB47E /* ็ฃฃ */, 0xEDD7 /* ็ข */,
0xB483 /* ็ฃง */, 0xEDD3 /* ็ข */,
0xB489 /* ็ฃฏ */, 0xEDB6 /* ็ถ */,
0xB493 /* ็ฃฝ */, 0xEDCD /* ็ก */,
0xB541 /* ็ค */, 0xB4A1 /* ็ก */,
0xB54B /* ็ค */, 0xB0AD /* ็ข */,
0xB556 /* ็คฆ */, 0xBFF3 /* ็ฟ */,
0xB559 /* ็คฉ */, 0xF5D9 /* ่ธฌ */,
0xB55A /* ็คช */, 0xEDC2 /* ็ บ */,
0xB55B /* ็คซ */, 0xC0F9 /* ็ พ */,
0xB55C /* ็คฌ */, 0xB7AF /* ็พ */,
0xB561 /* ็คฑ */, 0xEDC3 /* ็ ป */,
0xB56B /* ็ฅ */, 0xCBFB /* ไป */,
0xB56E /* ็ฅ
*/, 0xECEC /* ็ฅ */,
0xB56F /* ็ฅ */, 0xD6BB /* ๅช */,
0xB576 /* ็ฅ */, 0xD3D3 /* ไฝ */,
0xB57A /* ็ฅ */, 0xC3D8 /* ็ง */,
0xB593 /* ็ฅฟ */, 0xC2BB /* ็ฆ */,
0xB59C /* ็ฆ */, 0xBBF6 /* ็ฅธ */,
0xB59D /* ็ฆ */, 0xECF5 /* ็ฅฏ */,
0xB652 /* ็ฆฆ */, 0xD3F9 /* ๅพก */,
0xB655 /* ็ฆช */, 0xECF8 /* ็ฆ
*/,
0xB659 /* ็ฆฎ */, 0xC0F1 /* ็คผ */,
0xB65B /* ็ฆฐ */, 0xECF2 /* ็ฅข */,
0xB65C /* ็ฆฑ */, 0xB5BB /* ็ฅท */,
0xB664 /* ็ฆฟ */, 0xCDBA /* ็ง */,
0xB669 /* ็ง */, 0xF4CC /* ็ฑผ */,
0xB690 /* ็จ
*/, 0xCBB0 /* ็จ */,
0xB692 /* ็จ */, 0xB8D1 /* ็ง */,
0xB6A0 /* ็จ */, 0xC0E2 /* ๆฃฑ */,
0xB741 /* ็จ */, 0xD9F7 /* ็ฆ */,
0xB74E /* ็จฎ */, 0xD6D6 /* ็ง */,
0xB751 /* ็จฑ */, 0xB3C6 /* ็งฐ */,
0xB759 /* ็ฉ */, 0xB9C8 /* ่ฐท */,
0xB760 /* ็ฉ */, 0xC3D3 /* ็ณ */,
0xB764 /* ็ฉ */, 0xF6D5 /* ็จฃ */,
0xB765 /* ็ฉ */, 0xBBFD /* ็งฏ */,
0xB766 /* ็ฉ */, 0xD3B1 /* ้ข */,
0xB777 /* ็ฉก */, 0xF0A3 /* ็ฉ */,
0xB778 /* ็ฉข */, 0xBBE0 /* ็งฝ */,
0xB77E /* ็ฉจ */, 0xCDC7 /* ้ข */,
0xB780 /* ็ฉฉ */, 0xCEC8 /* ็จณ */,
0xB782 /* ็ฉซ */, 0xBBF1 /* ่ท */,
0xB784 /* ็ฉญ */, 0xEFF9 /* ็จ */,
0xB78A /* ็ฉต */, 0xCDDA /* ๆ */,
0xB798 /* ็ช */, 0xCDDD /* ๆดผ */,
0xB843 /* ็ชฉ */, 0xCED1 /* ็ช */,
0xB844 /* ็ชช */, 0xCDDD /* ๆดผ */,
0xB846 /* ็ชฎ */, 0xC7EE /* ็ฉท */,
0xB847 /* ็ชฏ */, 0xD2A4 /* ็ช */,
0xB84D /* ็ชถ */, 0xF1C0 /* ็ชญ */,
0xB851 /* ็ชบ */, 0xBFFA /* ็ชฅ */,
0xB85A /* ็ซ */, 0xB4DC /* ็ช */,
0xB85B /* ็ซ
*/, 0xC7CF /* ็ช */,
0xB85D /* ็ซ */, 0xF1BC /* ็ชฆ */,
0xB860 /* ็ซ */, 0xC7D4 /* ็ช */,
0xB882 /* ็ซถ */, 0xBEBA /* ็ซ */,
0xB948 /* ็ฌป */, 0xF3CC /* ็ญ */,
0xB950 /* ็ญ */, 0xB1CA /* ็ฌ */,
0xB953 /* ็ญ */, 0xCBF1 /* ็ฌ */,
0xB960 /* ็ญฆ */, 0xB9DC /* ็ฎก */,
0xB961 /* ็ญง */, 0xF3C8 /* ็ฌ */,
0xB963 /* ็ญฉ */, 0xCDB2 /* ็ญ */,
0xB969 /* ็ญฐ */, 0xF3D0 /* ็ฌฎ */,
0xB96B /* ็ญด */, 0xB2DF /* ็ญ */,
0xB975 /* ็ฎ */, 0xF3EB /* ็ฎ
*/,
0xB977 /* ็ฎ */, 0xB8F6 /* ไธช */,
0xB97B /* ็ฎ */, 0xBCE3 /* ็ฌบ */,
0xB97D /* ็ฎ */, 0xF3F8 /* ็ฏช */,
0xB97E /* ็ฎ */, 0xF3DD /* ็ญ */,
0xB98A /* ็ฎ */, 0xE9A2 /* ๆฃฐ */,
0xB99D /* ็ฏ */, 0xBDDA /* ่ */,
0xB9A0 /* ็ฏ */, 0xB7B6 /* ่ */,
0xBA42 /* ็ฏ */, 0xD6FE /* ็ญ */,
0xBA44 /* ็ฏ */, 0xF3E6 /* ็ฎง */,
0xBA4F /* ็ฏ */, 0xF3E8 /* ็ฎฌ */,
0xBA53 /* ็ฏ */, 0xF3E3 /* ็ญฑ */,
0xBA56 /* ็ฏค */, 0xF3C6 /* ็ฌ */,
0xBA59 /* ็ฏฉ */, 0xC9B8 /* ็ญ */,
0xBA5F /* ็ฏฒ */, 0xE5E7 /* ๅฝ */,
0xBA60 /* ็ฏณ */, 0xF3D9 /* ็ญ */,
0xBA6A /* ็ฐ */, 0xF3E5 /* ็ฎฆ */,
0xBA70 /* ็ฐ */, 0xBFDC /* ๅฏ */,
0xBA74 /* ็ฐ */, 0xC2A8 /* ็ฏ */,
0xBA77 /* ็ฐ */, 0xCBF2 /* ่ */,
0xBA84 /* ็ฐ */, 0xF3EC /* ็ฎช */,
0xBA86 /* ็ฐก */, 0xBCF2 /* ็ฎ */,
0xBA88 /* ็ฐฃ */, 0xF3F1 /* ็ฏ */,
0xBA8D /* ็ฐซ */, 0xF3EF /* ็ฎซ */,
0xBA99 /* ็ฐท */, 0xE9DC /* ๆช */,
0xBA9E /* ็ฐฝ */, 0xC7A9 /* ็ญพ */,
0xBA9F /* ็ฐพ */, 0xC1B1 /* ๅธ */,
0xBB40 /* ็ฑ */, 0xC0BA /* ็ฏฎ */,
0xBB49 /* ็ฑ */, 0xB3EF /* ็ญน */,
0xBB4C /* ็ฑ */, 0xCCD9 /* ่ค */,
0xBB58 /* ็ฑ */, 0xF3EA /* ็ฎจ */,
0xBB5B /* ็ฑ */, 0xF4A5 /* ็ฑ */,
0xBB5C /* ็ฑ */, 0xC1FD /* ็ฌผ */,
0xBB60 /* ็ฑค */, 0xC7A9 /* ็ญพ */,
0xBB61 /* ็ฑฅ */, 0xD9DF /* ้พ */,
0xBB65 /* ็ฑฉ */, 0xF3D6 /* ็ฌพ */,
0xBB66 /* ็ฑช */, 0xF3FD /* ็ฐ */,
0xBB68 /* ็ฑฌ */, 0xC0E9 /* ็ฏฑ */,
0xBB6A /* ็ฑฎ */, 0xC2E1 /* ็ฎฉ */,
0xBB6E /* ็ฑฒ */, 0xD3F5 /* ๅ */,
0xBB72 /* ็ฑธ */, 0xF4D6 /* ็ณ */,
0xBB7B /* ็ฒ */, 0xB0E5 /* ๆฟ */,
0xBB9B /* ็ฒต */, 0xD4C1 /* ็ฒค */,
0xBB9F /* ็ฒบ */, 0xB0DE /* ็จ */,
0xBC52 /* ็ณ */, 0xF4D6 /* ็ณ */,
0xBC53 /* ็ณ */, 0xB7E0 /* ็ฒช */,
0xBC55 /* ็ณข */, 0xE2C9 /* ้ฆ */,
0xBC5A /* ็ณง */, 0xC1B8 /* ็ฒฎ */,
0xBC61 /* ็ณฐ */, 0xCDC5 /* ๅข */,
0xBC63 /* ็ณฒ */, 0xF4CF /* ็ฒ */,
0xBC65 /* ็ณด */, 0xD9E1 /* ็ฑด */,
0xBC67 /* ็ณถ */, 0xF4D0 /* ็ฒ */,
0xBC6D /* ็ณพ */, 0xBEC0 /* ็บ */,
0xBC6F /* ็ด */, 0xBCCD /* ็บช */,
0xBC71 /* ็ด */, 0xE6FB /* ็บฃ */,
0xBC73 /* ็ด */, 0xD4BC /* ็บฆ */,
0xBC74 /* ็ด
*/, 0xBAEC /* ็บข */,
0xBC75 /* ็ด */, 0xE6FA /* ็บก */,
0xBC76 /* ็ด */, 0xE6FC /* ็บฅ */,
0xBC77 /* ็ด */, 0xE6FD /* ็บจ */,
0xBC78 /* ็ด */, 0xC8D2 /* ็บซ */,
0xBC79 /* ็ด */, 0xCEC6 /* ็บน */,
0xBC7B /* ็ด */, 0xC4C9 /* ็บณ */,
0xBC7E /* ็ด */, 0xC5A6 /* ็บฝ */,
0xBC82 /* ็ด */, 0xE7A3 /* ็บพ */,
0xBC83 /* ็ด */, 0xB4BF /* ็บฏ */,
0xBC84 /* ็ด */, 0xE7A2 /* ็บฐ */,
0xBC86 /* ็ด */, 0xC9B4 /* ็บฑ */,
0xBC88 /* ็ด */, 0xD6BD /* ็บธ */,
0xBC89 /* ็ด */, 0xBCB6 /* ็บง */,
0xBC8A /* ็ด */, 0xB7D7 /* ็บท */,
0xBC8B /* ็ด */, 0xE7A1 /* ็บญ */,
0xBC8F /* ็ดก */, 0xB7C4 /* ็บบ */,
0xBC99 /* ็ดฎ */, 0xD4FA /* ๆ */,
0xBC9A /* ็ดฐ */, 0xCFB8 /* ็ป */,
0xBC9B /* ็ดฑ */, 0xE7A6 /* ็ป */,
0xBC9C /* ็ดฒ */, 0xE7A5 /* ็ป */,
0xBC9D /* ็ดณ */, 0xC9F0 /* ็ป
*/,
0xBD42 /* ็ดน */, 0xC9DC /* ็ป */,
0xBD43 /* ็ดบ */, 0xE7A4 /* ็ป */,
0xBD45 /* ็ดผ */, 0xE7A8 /* ็ป */,
0xBD48 /* ็ดฟ */, 0xE7AA /* ็ป */,
0xBD49 /* ็ต */, 0xE7A9 /* ็ป */,
0xBD4B /* ็ต */, 0xD6D5 /* ็ป */,
0xBD4C /* ็ต */, 0xCFD2 /* ๅผฆ */,
0xBD4D /* ็ต */, 0xD7E9 /* ็ป */,
0xBD4F /* ็ต */, 0xB0ED /* ็ป */,
0xBD57 /* ็ต */, 0xE7AC /* ็ป */,
0xBD58 /* ็ต */, 0xE7A5 /* ็ป */,
0xBD59 /* ็ต */, 0xBDE1 /* ็ป */,
0xBD5E /* ็ต */, 0xBEF8 /* ็ป */,
0xBD64 /* ็ต */, 0xCCD0 /* ็ปฆ */,
0xBD65 /* ็ต */, 0xBDE0 /* ๆด */,
0xBD67 /* ็ต */, 0xBDCA /* ็ป */,
0xBD6A /* ็ตก */, 0xC2E7 /* ็ป */,
0xBD6B /* ็ตข */, 0xD1A4 /* ็ป */,
0xBD6F /* ็ตฆ */, 0xB8F8 /* ็ป */,
0xBD71 /* ็ตจ */, 0xC8DE /* ็ป */,
0xBD78 /* ็ตฐ */, 0xD6C2 /* ่ด */,
0xBD79 /* ็ตฑ */, 0xCDB3 /* ็ป */,
0xBD7A /* ็ตฒ */, 0xCBBF /* ไธ */,
0xBD7B /* ็ตณ */, 0xE7AD /* ็ป */,
0xBD81 /* ็ตน */, 0xBEEE /* ็ปข */,
0xBD89 /* ็ถ */, 0xB0F3 /* ็ป */,
0xBD8B /* ็ถ */, 0xE7AF /* ็ปก */,
0xBD8E /* ็ถ */, 0xE7AE /* ็ป */,
0xBD90 /* ็ถ */, 0xE7B0 /* ็ปจ */,
0xBD97 /* ็ถ */, 0xCBE7 /* ็ปฅ */,
0xBD99 /* ็ถ */, 0xC0A6 /* ๆ */,
0xBD9B /* ็ถ */, 0xBEAD /* ็ป */,
0xBE43 /* ็ถ */, 0xD7DB /* ็ปผ */,
0xBE45 /* ็ถ */, 0xE7B6 /* ็ผ */,
0xBE47 /* ็ถ */, 0xC2CC /* ็ปฟ */,
0xBE49 /* ็ถข */, 0xB3F1 /* ็ปธ */,
0xBE4A /* ็ถฃ */, 0xE7B9 /* ็ปป */,
0xBE52 /* ็ถฌ */, 0xE7B7 /* ็ปถ */,
0xBE53 /* ็ถญ */, 0xCEAC /* ็ปด */,
0xBE55 /* ็ถฐ */, 0xE7BA /* ็ปพ */,
0xBE56 /* ็ถฑ */, 0xB8D9 /* ็บฒ */,
0xBE57 /* ็ถฒ */, 0xCDF8 /* ็ฝ */,
0xBE59 /* ็ถด */, 0xD7BA /* ็ผ */,
0xBE5A /* ็ถต */, 0xB2CA /* ๅฝฉ */,
0xBE5D /* ็ถธ */, 0xC2DA /* ็บถ */,
0xBE5E /* ็ถน */, 0xE7B8 /* ็ปบ */,
0xBE5F /* ็ถบ */, 0xE7B2 /* ็ปฎ */,
0xBE60 /* ็ถป */, 0xD5C0 /* ็ปฝ */,
0xBE62 /* ็ถฝ */, 0xB4C2 /* ็ปฐ */,
0xBE63 /* ็ถพ */, 0xE7B1 /* ็ปซ */,
0xBE64 /* ็ถฟ */, 0xC3E0 /* ็ปต */,
0xBE69 /* ็ท */, 0xE7B5 /* ็ปฒ */,
0xBE6C /* ็ท */, 0xE7BB /* ็ผ */,
0xBE6F /* ็ท */, 0xBDF4 /* ็ดง */,
0xBE70 /* ็ท */, 0xE7B3 /* ็ปฏ */,
0xBE77 /* ็ท */, 0xD0F7 /* ็ปช */,
0xBE7C /* ็ท */, 0xE7BD /* ็ผ */,
0xBE7D /* ็ท */, 0xBCEA /* ็ผ */,
0xBE7E /* ็ท */, 0xE7BC /* ็ผ */,
0xBE80 /* ็ท */, 0xCFDF /* ็บฟ */,
0xBE83 /* ็ท */, 0xBCA9 /* ็ผ */,
0xBE84 /* ็ท */, 0xB6D0 /* ็ผ */,
0xBE86 /* ็ท */, 0xB5DE /* ็ผ */,
0xBE87 /* ็ทก */, 0xE7C5 /* ็ผ */,
0xBE89 /* ็ทฃ */, 0xD4B5 /* ็ผ */,
0xBE8C /* ็ทฆ */, 0xE7C1 /* ็ผ */,
0xBE8E /* ็ทจ */, 0xB1E0 /* ็ผ */,
0xBE8F /* ็ทฉ */, 0xBBBA /* ็ผ */,
0xBE92 /* ็ทฌ */, 0xC3E5 /* ็ผ
*/,
0xBE95 /* ็ทฏ */, 0xCEB3 /* ็บฌ */,
0xBE97 /* ็ทฑ */, 0xE7C3 /* ็ผ */,
0xBE98 /* ็ทฒ */, 0xE7BF /* ็ผ */,
0xBE9A /* ็ทด */, 0xC1B7 /* ็ป */,
0xBE9C /* ็ทถ */, 0xE7C2 /* ็ผ */,
0xBE9F /* ็ทน */, 0xE7BE /* ็ผ */,
0xBF40 /* ็ทป */, 0xD6C2 /* ่ด */,
0xBF4D /* ็ธ */, 0xDDD3 /* ่ฆ */,
0xBF4E /* ็ธ */, 0xE7C6 /* ็ผ */,
0xBF4F /* ็ธ */, 0xE7CB /* ็ผข */,
0xBF50 /* ็ธ */, 0xE7C4 /* ็ผ */,
0xBF55 /* ็ธ */, 0xE7A7 /* ็ป */,
0xBF56 /* ็ธ */, 0xE7CC /* ็ผฃ */,
0xBF5F /* ็ธ */, 0xCCD0 /* ็ปฆ */,
0xBF60 /* ็ธ */, 0xB8BF /* ็ผ */,
0xBF62 /* ็ธ */, 0xE7C7 /* ็ผ */,
0xBF63 /* ็ธ */, 0xE7C9 /* ็ผ */,
0xBF64 /* ็ธ */, 0xE7C8 /* ็ผ */,
0xBF68 /* ็ธฃ */, 0xCFD8 /* ๅฟ */,
0xBF70 /* ็ธซ */, 0xB7EC /* ็ผ */,
0xBF72 /* ็ธญ */, 0xE7CA /* ็ผก */,
0xBF73 /* ็ธฎ */, 0xCBF5 /* ็ผฉ */,
0xBF74 /* ็ธฏ */, 0xD1DD /* ๆผ */,
0xBF76 /* ็ธฑ */, 0xD7DD /* ็บต */,
0xBF77 /* ็ธฒ */, 0xE7D0 /* ็ผง */,
0xBF78 /* ็ธณ */, 0xB8BF /* ็ผ */,
0xBF79 /* ็ธด */, 0xCFCB /* ็บค */,
0xBF7A /* ็ธต */, 0xE7CF /* ็ผฆ */,
0xBF7B /* ็ธถ */, 0xF4EA /* ็ตท */,
0xBF7C /* ็ธท */, 0xC2C6 /* ็ผ */,
0xBF7E /* ็ธน */, 0xE7CE /* ็ผฅ */,
0xBF82 /* ็ธฝ */, 0xD7DC /* ๆป */,
0xBF83 /* ็ธพ */, 0xBCA8 /* ็ปฉ */,
0xBF87 /* ็น */, 0xB1C1 /* ็ปท */,
0xBF89 /* ็น
*/, 0xE7D2 /* ็ผซ */,
0xBF8A /* ็น */, 0xE7D1 /* ็ผช */,
0xBF8B /* ็น */, 0xF1DF /* ่ฅ */,
0xBF93 /* ็น */, 0xCBEB /* ็ฉ */,
0xBF95 /* ็น */, 0xE7D5 /* ็ผฏ */,
0xBF97 /* ็น */, 0xD6AF /* ็ป */,
0xBF98 /* ็น */, 0xC9C9 /* ็ผฎ */,
0xBF99 /* ็น */, 0xC9A1 /* ไผ */,
0xBF9C /* ็น */, 0xB7AD /* ็ฟป */,
0xBF9D /* ็น */, 0xE7D4 /* ็ผญ */,
0xC040 /* ็น */, 0xC8C6 /* ็ป */,
0xC043 /* ็นก */, 0xD0E5 /* ็ปฃ */,
0xC044 /* ็นข */, 0xE7C0 /* ็ผ */,
0xC04B /* ็นฉ */, 0xC9FE /* ็ปณ */,
0xC04C /* ็นช */, 0xBBE6 /* ็ป */,
0xC04D /* ็นซ */, 0xCFB5 /* ็ณป */,
0xC04F /* ็นญ */, 0xBCEB /* ่ง */,
0xC051 /* ็นฏ */, 0xE7D9 /* ็ผณ */,
0xC052 /* ็นฐ */, 0xE7D8 /* ็ผฒ */,
0xC055 /* ็นณ */, 0xBDC9 /* ็ผด */,
0xC05B /* ็นน */, 0xD2EF /* ็ป */,
0xC05E /* ็นผ */, 0xBCCC /* ็ปง */,
0xC05F /* ็นฝ */, 0xE7CD /* ็ผค */,
0xC060 /* ็นพ */, 0xE7D7 /* ็ผฑ */,
0xC069 /* ็บ */, 0xE7D3 /* ็ผฌ */,
0xC06B /* ็บ */, 0xE6FE /* ็บฉ */,
0xC06D /* ็บ */, 0xD0F8 /* ็ปญ */,
0xC06E /* ็บ */, 0xC0DB /* ็ดฏ */,
0xC070 /* ็บ */, 0xB2F8 /* ็ผ */,
0xC074 /* ็บ */, 0xD3A7 /* ็ผจ */,
0xC075 /* ็บ */, 0xB2C5 /* ๆ */,
0xC077 /* ็บ */, 0xCFCB /* ็บค */,
0xC079 /* ็บ */, 0xE7DA /* ็ผต */,
0xC07C /* ็บ */, 0xC0C2 /* ็ผ */,
0xC08F /* ็ผฝ */, 0xB2A7 /* ้ต */,
0xC097 /* ็ฝ */, 0xCCB3 /* ๅ */,
0xC09A /* ็ฝ */, 0xCECD /* ็ฎ */,
0xC09B /* ็ฝ */, 0xF3BF /* ็ฝ */,
0xC09E /* ็ฝ */, 0xDBE4 /* ๅ */,
0xC147 /* ็ฝฃ */, 0xB9D2 /* ๆ */,
0xC150 /* ็ฝฐ */, 0xB7A3 /* ็ฝ */,
0xC152 /* ็ฝต */, 0xC2EE /* ้ช */,
0xC154 /* ็ฝท */, 0xB0D5 /* ็ฝข */,
0xC15F /* ็พ
*/, 0xC2DE /* ็ฝ */,
0xC160 /* ็พ */, 0xEEBC /* ็ฝด */,
0xC162 /* ็พ */, 0xEEBF /* ็พ */,
0xC164 /* ็พ */, 0xD8C2 /* ่ */,
0xC173 /* ็พข */, 0xC8DE /* ็ป */,
0xC175 /* ็พฅ */, 0xF4C7 /* ็พ */,
0xC177 /* ็พจ */, 0xCFDB /* ็พก */,
0xC178 /* ็พฉ */, 0xD2E5 /* ไน */,
0xC183 /* ็พถ */, 0xEBFE /* ่ป */,
0xC195 /* ็ฟ */, 0xCFB0 /* ไน */,
0xC244 /* ็ฟซ */, 0xCDE6 /* ็ฉ */,
0xC24E /* ็ฟน */, 0xC7CC /* ็ฟ */,
0xC25A /* ่ */, 0xD7A8 /* ไธ */,
0xC265 /* ่ฌ */, 0xF1EF /* ่ง */,
0xC27D /* ่ */, 0xCAA5 /* ๅฃ */,
0xC284 /* ่ */, 0xCEC5 /* ้ป */,
0xC293 /* ่ฏ */, 0xC1AA /* ่ */,
0xC294 /* ่ฐ */, 0xB4CF /* ่ช */,
0xC295 /* ่ฒ */, 0xC9F9 /* ๅฃฐ */,
0xC296 /* ่ณ */, 0xCBCA /* ่ธ */,
0xC298 /* ่ต */, 0xF1F9 /* ่ฉ */,
0xC299 /* ่ถ */, 0xC4F4 /* ่ */,
0xC29A /* ่ท */, 0xD6B0 /* ่ */,
0xC29C /* ่น */, 0xF1F7 /* ่ */,
0xC2A0 /* ่ฝ */, 0xCCFD /* ๅฌ */,
0xC340 /* ่พ */, 0xC1FB /* ่ */,
0xC343 /* ่
*/, 0xCBE0 /* ่ */,
0xC345 /* ่ */, 0xD2DC /* ่ */,
0xC349 /* ่ */, 0xB8EC /* ่ณ */,
0xC37B /* ่
*/, 0xD0B2 /* ่ */,
0xC37D /* ่ */, 0xC2F6 /* ่ */,
0xC384 /* ่ */, 0xEBD6 /* ่ซ */,
0xC38B /* ่ฃ */, 0xB4BD /* ๅ */,
0xC38F /* ่ง */, 0xEDFC /* ็ */,
0xC391 /* ่ฉ */, 0xD0DE /* ไฟฎ */,
0xC393 /* ่ซ */, 0xCDD1 /* ่ฑ */,
0xC39B /* ่น */, 0xD5CD /* ่ */,
0xC39C /* ่บ */, 0xD2C8 /* ่ฐ */,
0xC449 /* ่
*/, 0xC9F6 /* ่พ */,
0xC454 /* ่
ก */, 0xEBE1 /* ่ถ */,
0xC458 /* ่
ฆ */, 0xC4D4 /* ่ */,
0xC45B /* ่
ซ */, 0xD6D7 /* ่ฟ */,
0xC45F /* ่
ณ */, 0xBDC5 /* ่ */,
0xC463 /* ่
ธ */, 0xB3A6 /* ่ */,
0xC465 /* ่ */, 0xEBF0 /* ่
ฝ */,
0xC468 /* ่ */, 0xE0BC /* ๅ */,
0xC477 /* ่ */, 0xB7F4 /* ่ค */,
0xC47A /* ่ */, 0xBDBA /* ่ถ */,
0xC481 /* ่ฉ */, 0xC4E5 /* ่
ป */,
0xC48B /* ่ต */, 0xD2C8 /* ่ฐ */,
0xC491 /* ่ฝ */, 0xB5A8 /* ่ */,
0xC492 /* ่พ */, 0xEBDA /* ่ */,
0xC493 /* ่ฟ */, 0xC5A7 /* ่ */,
0xC498 /* ่ */, 0xC1B3 /* ่ธ */,
0xC49A /* ่ */, 0xC6EA /* ่ */,
0xC49C /* ่ */, 0xEBF7 /* ่ */,
0xC544 /* ่ */, 0xC0B0 /* ่
*/,
0xC546 /* ่ */, 0xEBCD /* ่ช */,
0xC549 /* ่ */, 0xC2E3 /* ่ฃธ */,
0xC54B /* ่ */, 0xD4E0 /* ่ */,
0xC54C /* ่ */, 0xD9F5 /* ่ */,
0xC550 /* ่ฅ */, 0xCED4 /* ๅง */,
0xC552 /* ่จ */, 0xC1D9 /* ไธด */,
0xC55F /* ่บ */, 0xCCA8 /* ๅฐ */,
0xC563 /* ่ */, 0xD3EB /* ไธ */,
0xC564 /* ่ */, 0xD0CB /* ๅ
ด */,
0xC565 /* ่ */, 0xBED9 /* ไธพ */,
0xC566 /* ่ */, 0xBEC9 /* ๆง */,
0xC567 /* ่ */, 0xD0C6 /* ่ก
*/,
0xC56D /* ่ */, 0xC6CC /* ้บ */,
0xC593 /* ่ */, 0xB2D5 /* ่ฑ */,
0xC59B /* ่ฃ */, 0xE9D6 /* ๆฉน */,
0xC59C /* ่ค */, 0xF4AF /* ่ฃ */,
0xC59E /* ่ฆ */, 0xBDA2 /* ่ฐ */,
0xC641 /* ่ซ */, 0xF4B5 /* ่ป */,
0xC644 /* ่ฑ */, 0xBCE8 /* ่ฐ */,
0xC647 /* ่ท */, 0xD1DE /* ่ณ */,
0xC648 /* ่ธ */, 0xDCB3 /* ่น */,
0xC653 /* ่ */, 0xDCD0 /* ่ */,
0xC663 /* ่ป */, 0xDBBB /* ๅ */,
0xC672 /* ่ง */, 0xDCD1 /* ่ */,
0xC688 /* ่ */, 0xB9B6 /* ่ */,
0xC69D /* ่ฒ */, 0xD7C8 /* ๅ
น */,
0xC745 /* ่
*/, 0xB4F0 /* ็ญ */,
0xC747 /* ่ */, 0xBEA3 /* ่ */,
0xC74A /* ่ */, 0xDCF1 /* ่ */,
0xC757 /* ่ณ */, 0xB6B9 /* ่ฑ */,
0xC766 /* ่ */, 0xD7AF /* ๅบ */,
0xC76E /* ่ */, 0xDCF4 /* ่ */,
0xC76F /* ่ */, 0xBEA5 /* ่ */,
0xC776 /* ่ข */, 0xBCD4 /* ่ */,
0xC77B /* ่ง */, 0xDCC8 /* ่ */,
0xC78A /* ่ */, 0xC2CC /* ็ปฟ */,
0xC78F /* ่ */, 0xD4D6 /* ็พ */,
0xC841 /* ่ฏ */, 0xBBAA /* ๅ */,
0xC843 /* ่ด */, 0xE2D6 /* ๅบต */,
0xC84F /* ่ */, 0xDCC9 /* ่ */,
0xC852 /* ่ */, 0xC0B3 /* ่ฑ */,
0xC866 /* ่ฌ */, 0xCDF2 /* ไธ */,
0xC86B /* ่ฒ */, 0xDDE6 /* ่ฑ */,
0xC86E /* ่ต */, 0xDDAB /* ่ด */,
0xC87B /* ่
*/, 0xDDCF /* ่น */,
0xC87E /* ่ */, 0xD2B6 /* ๅถ */,
0xC887 /* ่ */, 0xDDA6 /* ่ญ */,
0xD6F8 /* ่ */, 0xD7C5 /* ็ */,
0xC890 /* ่ */, 0xB2CE /* ๅ */,
0xC894 /* ่ฆ */, 0xCEAD /* ่ */,
0xC899 /* ่ฏ */, 0xD2A9 /* ่ฏ */,
0xC89D /* ่ท */, 0xBBE7 /* ่ค */,
0xC94C /* ่ */, 0xCBD1 /* ๆ */,
0xC950 /* ่ */, 0xDDAA /* ่ณ */,
0xC957 /* ่ */, 0xDDB0 /* ่
*/,
0xC960 /* ่จ */, 0xDCE7 /* ่ */,
0xC962 /* ่ช */, 0xDDBB /* ่ผ */,
0xC96E /* ่ผ */, 0xB2D4 /* ่ */,
0xC970 /* ่ */, 0xDDA5 /* ่ช */,
0xC974 /* ่ */, 0xCFAF /* ๅธญ */,
0xC977 /* ่ */, 0xB8C7 /* ็ */,
0xC98F /* ่ฎ */, 0xC1AB /* ่ฒ */,
0xC990 /* ่ฏ */, 0xDCCA /* ่ */,
0xC99C /* ่ฝ */, 0xDCEA /* ่ */,
0xCA43 /* ่ */, 0xC1E2 /* ่ฑ */,
0xCA4E /* ่ */, 0xB2B7 /* ๅ */,
0xCA4F /* ่ */, 0xB5D9 /* ่ */,
0xCA56 /* ่ */, 0xDDE4 /* ่ */,
0xCA59 /* ่ฃ */, 0xBDAF /* ่ */,
0xCA5B /* ่ฅ */, 0xB4D0 /* ่ฑ */,
0xCA5C /* ่ฆ */, 0xDCE0 /* ่ */,
0xCA61 /* ่ญ */, 0xD2F1 /* ่ซ */,
0xCA6B /* ่พ */, 0xDEBC /* ่ */,
0xCA6E /* ่ */, 0xDDA1 /* ่จ */,
0xCA72 /* ่ */, 0xDDDB /* ่ */,
0xCA77 /* ่ */, 0xDCF1 /* ่ */,
0xCA7C /* ่ */, 0xDCBF /* ่ธ */,
0xCA7E /* ่ */, 0xDDB5 /* ่ธ */,
0xCA81 /* ่ */, 0xDCE9 /* ่ */,
0xCA89 /* ่ข */, 0xDDDE /* ่ */,
0xCA8E /* ่ฉ */, 0xB5B4 /* ่ก */,
0xCA8F /* ่ช */, 0xCEDF /* ่ */,
0xCA92 /* ่ญ */, 0xCFF4 /* ่ง */,
0xCA9A /* ่ท */, 0xDDF7 /* ่ฃ */,
0xCB43 /* ่ */, 0xDCF6 /* ่ */,
0xCB45 /* ่ */, 0xBCBB /* ่ */,
0xCB47 /* ่ */, 0xDCBC /* ่ */,
0xCB4B /* ่ */, 0xBDAA /* ๅง */,
0xCB4E /* ่ */, 0xC7BE /* ่ท */,
0xCB53 /* ่ */, 0xCCEA /* ๅ */,
0xCB57 /* ่ */, 0xDDB2 /* ่ถ */,
0xCB5D /* ่ฆ */, 0xBCF6 /* ่ */,
0xCB5E /* ่ง */, 0xE9C2 /* ๆง */,
0xCB5F /* ่ฉ */, 0xC8F8 /* ่จ */,
0xCB6A /* ่บ */, 0xDCF9 /* ่ */,
0xBDE5 /* ่ */, 0xBDE8 /* ๅ */,
0xCB7B /* ่ */, 0xC0B6 /* ่ */,
0xCB7C /* ่ */, 0xDDA3 /* ่ฉ */,
0xCB87 /* ่ */, 0xD2D5 /* ่บ */,
0xCB8E /* ่ฅ */, 0xD2A9 /* ่ฏ */,
0xCB92 /* ่ช */, 0xDEB4 /* ่ฎ */,
0xCB9E /* ่ถ */, 0xDCC2 /* ่ */,
0xCB9F /* ่ท */, 0xCAED /* ่ฏ */,
0xCC40 /* ่น */, 0xB0AA /* ่ผ */,
0xCC41 /* ่บ */, 0xDDFE /* ่บ */,
0xCC49 /* ่ */, 0xDEAD /* ่ฒ */,
0xCC4A /* ่ */, 0xC2AB /* ่ฆ */,
0xCC4B /* ่ */, 0xCBD5 /* ่ */,
0xCC4E /* ่ */, 0xD4CC /* ่ด */,
0xCC4F /* ่ */, 0xC6BB /* ่น */,
0xCC59 /* ่ */, 0xDEC1 /* ่ */,
0xCC5C /* ่ */, 0xDEBA /* ่ */,
0xCC60 /* ่ */, 0xDDFC /* ่น */,
0xCC64 /* ่ข */, 0xDCD7 /* ่ */,
0xCC6D /* ่ญ */, 0xC0BC /* ๅ
ฐ */,
0xCC79 /* ่บ */, 0xDDF1 /* ่ */,
0xCC7D /* ่ฟ */, 0xC2DC /* ่ */,
0xCC8E /* ่ */, 0xB4A6 /* ๅค */,
0xCC8F /* ่ */, 0xBAF4 /* ๅผ */,
0xCC93 /* ่ */, 0xD0E9 /* ่ */,
0xCC94 /* ่ */, 0xC2B2 /* ่ */,
0xCC96 /* ่ */, 0xBAC5 /* ๅท */,
0xCC9D /* ่ง */, 0xBFF7 /* ไบ */,
0xCD90 /* ่บ */, 0xF2CC /* ่ฑ */,
0xCD91 /* ่ป */, 0xCDC9 /* ่ */,
0xCD98 /* ่ */, 0xF2B9 /* ่ฌ */,
0xCE48 /* ่จ */, 0xB5FB /* ่ถ */,
0xCE55 /* ่บ */, 0xC4DE /* ้ */,
0xCE67 /* ่ */, 0xCAB4 /* ่ */,
0xCE6F /* ่ */, 0xE2AC /* ็ฌ */,
0xCE72 /* ่ฆ */, 0xCFBA /* ่พ */,
0xCE74 /* ่จ */, 0xCAAD /* ่ฑ */,
0xCE7A /* ่ฏ */, 0xD4B3 /* ็ฟ */,
0xCE81 /* ่ธ */, 0xCECF /* ่ */,
0xCE87 /* ่ */, 0xF2CF /* ่ณ */,
0xCE9B /* ่ */, 0xC2EC /* ่ */,
0xCE9E /* ่ข */, 0xD3A9 /* ่ค */,
0xCF4E /* ่ป */, 0xF2F7 /* ่ผ */,
0xCF55 /* ่ */, 0xD5DD /* ่ฐ */,
0xCF58 /* ่ */, 0xF2E5 /* ่ */,
0xCF6C /* ่ฃ */, 0xF2B1 /* ่ฎ */,
0xCF73 /* ่ฌ */, 0xB2F5 /* ่ */,
0xCF75 /* ่ฏ */, 0xF2CD /* ่ฒ */,
0xCF78 /* ่ฒ */, 0xB3E6 /* ่ซ */,
0xCF7C /* ่ถ */, 0xF2C9 /* ่ */,
0xCF81 /* ่ป */, 0xD2CF /* ่ */,
0xCF89 /* ่
*/, 0xD3AC /* ่ */,
0xCF8A /* ่ */, 0xF2B2 /* ่ฟ */,
0xCF90 /* ่ */, 0xD0AB /* ่ */,
0xCF93 /* ่ */, 0xF2D3 /* ่ด */,
0xCF94 /* ่ */, 0xF2EE /* ่พ */,
0xCF96 /* ่ */, 0xF2BA /* ่ */,
0xCF9E /* ่ */, 0xC0AF /* ่ก */,
0xCFA0 /* ่ ฃ */, 0xF2C3 /* ่ */,
0xD04D /* ่ ฑ */, 0xB9C6 /* ่ */,
0xD051 /* ่ ถ */, 0xB2CF /* ่ */,
0xD052 /* ่ ท */, 0xF3BD /* ่ ผ */,
0xD055 /* ่ ป */, 0xC2F9 /* ่ฎ */,
0xD060 /* ่ก */, 0xC3EF /* ่ */,
0xD066 /* ่ก */, 0xECC5 /* ็ซ */,
0xD067 /* ่ก */, 0xCAF5 /* ๆฏ */,
0xD068 /* ่ก */, 0xCDAC /* ๅ */,
0xD069 /* ่ก */, 0xC5AA /* ๅผ */,
0xD06B /* ่ก */, 0xBAFA /* ่ก */,
0xD06C /* ่ก */, 0xCEC0 /* ๅซ */,
0xD06E /* ่ก */, 0xB3E5 /* ๅฒ */,
0xD07D /* ่กน */, 0xD6BB /* ๅช */,
0xD096 /* ่ข */, 0xD9F2 /* ่กฎ */,
0xD155 /* ่ฃ */, 0xF4C1 /* ่ข
*/,
0xD157 /* ่ฃ */, 0xBCD0 /* ๅคน */,
0xD161 /* ่ฃ */, 0xB2B9 /* ่กฅ */,
0xD162 /* ่ฃ */, 0xD7B0 /* ่ฃ
*/,
0xD165 /* ่ฃก */, 0xC0EF /* ้ */,
0xD175 /* ่ฃฝ */, 0xD6C6 /* ๅถ */,
0xD17D /* ่ค */, 0xB8B4 /* ๅค */,
0xD184 /* ่ค */, 0xD0E4 /* ่ข */,
0xD19D /* ่คฒ */, 0xBFE3 /* ่ฃค */,
0xD19E /* ่คณ */, 0xF1CD /* ่ฃข */,
0xD240 /* ่คธ */, 0xF1DA /* ่ค */,
0xD243 /* ่คป */, 0xD9F4 /* ไบต */,
0xD24F /* ่ฅ */, 0xF1D0 /* ่ฃฅ */,
0xD25C /* ่ฅ */, 0xB0C0 /* ่ข */,
0xD263 /* ่ฅ */, 0xF1CF /* ่ฃฃ */,
0xD264 /* ่ฅ */, 0xF1C9 /* ่ฃ */,
0xD266 /* ่ฅข */, 0xCCBB /* ่ข */,
0xD268 /* ่ฅค */, 0xF1DC /* ่คด */,
0xD26D /* ่ฅช */, 0xCDE0 /* ่ข */,
0xD26F /* ่ฅฌ */, 0xB0DA /* ๆ */,
0xD272 /* ่ฅฏ */, 0xB3C4 /* ่กฌ */,
0xD275 /* ่ฅฒ */, 0xCFAE /* ่ขญ */,
0xD287 /* ่ฆ */, 0xBACB /* ๆ ธ */,
0xD28A /* ่ฆ */, 0xBCFB /* ่ง */,
0xD28E /* ่ฆ */, 0xB9E6 /* ่ง */,
0xD292 /* ่ฆ */, 0xC3D9 /* ่ง
*/,
0xD295 /* ่ฆ */, 0xCAD3 /* ่ง */,
0xD297 /* ่ฆ */, 0xEAE8 /* ่ง */,
0xD29B /* ่ฆ */, 0xCCF7 /* ็บ */,
0xD2A0 /* ่ฆก */, 0xEAEA /* ่ง */,
0xD344 /* ่ฆฆ */, 0xEAEC /* ่ง */,
0xD348 /* ่ฆช */, 0xC7D7 /* ไบฒ */,
0xD34A /* ่ฆฌ */, 0xEAE9 /* ่ง */,
0xD34D /* ่ฆฏ */, 0xEAED /* ่ง */,
0xD350 /* ่ฆฒ */, 0xEAEE /* ่ง */,
0xD355 /* ่ฆท */, 0xEAEF /* ่ง */,
0xD358 /* ่ฆบ */, 0xBEF5 /* ่ง */,
0xD35B /* ่ฆฝ */, 0xC0C0 /* ่ง */,
0xD35D /* ่ฆฟ */, 0xEAEB /* ่ง */,
0xD35E /* ่ง */, 0xB9DB /* ่ง */,
0xD362 /* ่ง */, 0xBDEE /* ็ญ */,
0xD363 /* ่ง */, 0xB4D6 /* ็ฒ */,
0xD378 /* ่งด */, 0xF5FC /* ่ง */,
0xD37A /* ่งถ */, 0xF6A3 /* ่งฏ */,
0xD37C /* ่งธ */, 0xB4A5 /* ่งฆ */,
0xD386 /* ่จ */, 0xB6A9 /* ่ฎข */,
0xD387 /* ่จ */, 0xB8BC /* ่ฎฃ */,
0xD38B /* ่จ */, 0xBCC6 /* ่ฎก */,
0xD38D /* ่จ */, 0xD1B6 /* ่ฎฏ */,
0xD38F /* ่จ */, 0xDAA7 /* ่ฎง */,
0xD391 /* ่จ */, 0xCCD6 /* ่ฎจ */,
0xD393 /* ่จ */, 0xDAA6 /* ่ฎฆ */,
0xD396 /* ่จ */, 0xD1B5 /* ่ฎญ */,
0xD398 /* ่จ */, 0xDAA8 /* ่ฎช */,
0xD399 /* ่จ */, 0xC6FD /* ่ฎซ */,
0xD39A /* ่จ */, 0xCDD0 /* ๆ */,
0xD39B /* ่จ */, 0xBCC7 /* ่ฎฐ */,
0xD39E /* ่จ */, 0xB6EF /* ่ฎน */,
0xD3A0 /* ่จ */, 0xD1C8 /* ่ฎถ */,
0xD441 /* ่จ */, 0xCBCF /* ่ฎผ */,
0xD445 /* ่จฃ */, 0xBEF7 /* ่ฏ */,
0xD447 /* ่จฅ */, 0xDAAB /* ่ฎท */,
0xD44C /* ่จช */, 0xB7C3 /* ่ฎฟ */,
0xD44F /* ่จญ */, 0xC9E8 /* ่ฎพ */,
0xD453 /* ่จฑ */, 0xD0ED /* ่ฎธ */,
0xD456 /* ่จด */, 0xCBDF /* ่ฏ */,
0xD458 /* ่จถ */, 0xDAAD /* ่ฏ */,
0xD45C /* ่จบ */, 0xD5EF /* ่ฏ */,
0xD45D /* ่จป */, 0xD7A2 /* ๆณจ */,
0xD45E /* ่จผ */, 0xD6A4 /* ่ฏ */,
0xD462 /* ่ฉ */, 0xDAAC /* ่ฏ */,
0xD467 /* ่ฉ */, 0xDAAE /* ่ฏ */,
0xD46E /* ่ฉ */, 0xDAAA /* ่ฎต */,
0xD470 /* ่ฉ */, 0xD5A9 /* ่ฏ */,
0xD472 /* ่ฉ */, 0xDAB1 /* ่ฏ */,
0xD474 /* ่ฉ */, 0xDAAF /* ่ฏ */,
0xD475 /* ่ฉ */, 0xC6C0 /* ่ฏ */,
0xD478 /* ่ฉ */, 0xDAB0 /* ่ฏ */,
0xD47B /* ่ฉ */, 0xD7E7 /* ่ฏ
*/,
0xD47E /* ่ฉ */, 0xB4CA /* ่ฏ */,
0xD481 /* ่ฉ */, 0xD3BD /* ๅ */,
0xD482 /* ่ฉก */, 0xDABC /* ่ฏฉ */,
0xD483 /* ่ฉข */, 0xD1AF /* ่ฏข */,
0xD484 /* ่ฉฃ */, 0xD2E8 /* ่ฏฃ */,
0xD487 /* ่ฉฆ */, 0xCAD4 /* ่ฏ */,
0xD48A /* ่ฉฉ */, 0xCAAB /* ่ฏ */,
0xD48C /* ่ฉซ */, 0xB2EF /* ่ฏง */,
0xD48D /* ่ฉฌ */, 0xDAB8 /* ่ฏ */,
0xD48E /* ่ฉญ */, 0xB9EE /* ่ฏก */,
0xD48F /* ่ฉฎ */, 0xDAB9 /* ่ฏ */,
0xD491 /* ่ฉฐ */, 0xDAB5 /* ่ฏ */,
0xD492 /* ่ฉฑ */, 0xBBB0 /* ่ฏ */,
0xD493 /* ่ฉฒ */, 0xB8C3 /* ่ฏฅ */,
0xD494 /* ่ฉณ */, 0xCFEA /* ่ฏฆ */,
0xD496 /* ่ฉต */, 0xDAB7 /* ่ฏ */,
0xD49C /* ่ฉผ */, 0xDAB6 /* ่ฏ */,
0xD49F /* ่ฉฟ */, 0xDAB4 /* ่ฏ */,
0xD543 /* ่ช */, 0xDAB3 /* ่ฏ */,
0xD544 /* ่ช
*/, 0xD6EF /* ่ฏ */,
0xD545 /* ่ช */, 0xDAB2 /* ่ฏ */,
0xD546 /* ่ช */, 0xBFE4 /* ๅคธ */,
0xD549 /* ่ช */, 0xD6BE /* ๅฟ */,
0xD54A /* ่ช */, 0xC8CF /* ่ฎค */,
0xD54E /* ่ช */, 0xDABF /* ่ฏณ */,
0xD54F /* ่ช */, 0xDAC0 /* ่ฏถ */,
0xD551 /* ่ช */, 0xB5AE /* ่ฏ */,
0xD552 /* ่ช */, 0xE3A3 /* ๆ */,
0xD554 /* ่ช */, 0xD3D5 /* ่ฏฑ */,
0xD556 /* ่ช */, 0xDABD /* ่ฏฎ */,
0xD55A /* ่ช */, 0xD3EF /* ่ฏญ */,
0xD55C /* ่ช */, 0xB3CF /* ่ฏ */,
0xD55D /* ่ชก */, 0xBDEB /* ่ฏซ */,
0xD55F /* ่ชฃ */, 0xCEDC /* ่ฏฌ */,
0xD560 /* ่ชค */, 0xCEF3 /* ่ฏฏ */,
0xD561 /* ่ชฅ */, 0xDABE /* ่ฏฐ */,
0xD562 /* ่ชฆ */, 0xCBD0 /* ่ฏต */,
0xD564 /* ่ชจ */, 0xBBE5 /* ่ฏฒ */,
0xD566 /* ่ชช */, 0xCBB5 /* ่ฏด */,
0xD56C /* ่ชฐ */, 0xCBAD /* ่ฐ */,
0xD56E /* ่ชฒ */, 0xBFCE /* ่ฏพ */,
0xD572 /* ่ชถ */, 0xDAC7 /* ่ฐ */,
0xD575 /* ่ชน */, 0xB7CC /* ่ฏฝ */,
0xD578 /* ่ชผ */, 0xD2EA /* ่ฐ */,
0xD57B /* ่ชฟ */, 0xB5F7 /* ่ฐ */,
0xD57E /* ่ซ */, 0xDAC6 /* ่ฐ */,
0xD581 /* ่ซ */, 0xD7BB /* ่ฐ */,
0xD584 /* ่ซ */, 0xCCB8 /* ่ฐ */,
0xD586 /* ่ซ */, 0xDAC3 /* ่ฏฟ */,
0xD588 /* ่ซ */, 0xC7EB /* ่ฏท */,
0xD58A /* ่ซ */, 0xDABA /* ่ฏค */,
0xD58C /* ่ซ */, 0xDAC1 /* ่ฏน */,
0xD58E /* ่ซ */, 0xDAC2 /* ่ฏผ */,
0xD58F /* ่ซ */, 0xC1C2 /* ่ฐ
*/,
0xD593 /* ่ซ */, 0xC2DB /* ่ฎบ */,
0xD594 /* ่ซ */, 0xDAC5 /* ่ฐ */,
0xD598 /* ่ซ */, 0xDAC4 /* ่ฐ */,
0xD599 /* ่ซ */, 0xB5FD /* ่ฐ */,
0xD59B /* ่ซ */, 0xDAD2 /* ่ฐ */,
0xD59D /* ่ซ */, 0xD0FA /* ๅง */,
0xD59E /* ่ซก */, 0xDAD6 /* ่ฐฅ */,
0xD59F /* ่ซข */, 0xDABB /* ่ฏจ */,
0xD640 /* ่ซค */, 0xDACC /* ่ฐ */,
0xD642 /* ่ซฆ */, 0xDAD0 /* ่ฐ */,
0xD643 /* ่ซง */, 0xD0B3 /* ่ฐ */,
0xD647 /* ่ซซ */, 0xDAC9 /* ่ฐ */,
0xD649 /* ่ซญ */, 0xDACD /* ่ฐ */,
0xD64A /* ่ซฎ */, 0xDAD1 /* ่ฐ */,
0xD64D /* ่ซฑ */, 0xBBE4 /* ่ฎณ */,
0xD64F /* ่ซณ */, 0xDACF /* ่ฐ */,
0xD652 /* ่ซถ */, 0xDAC8 /* ่ฐ */,
0xD653 /* ่ซท */, 0xB7ED /* ่ฎฝ */,
0xD654 /* ่ซธ */, 0xD6EE /* ่ฏธ */,
0xD656 /* ่ซบ */, 0xD1E8 /* ่ฐ */,
0xD658 /* ่ซผ */, 0xDACE /* ่ฐ */,
0xD65A /* ่ซพ */, 0xC5B5 /* ่ฏบ */,
0xD65C /* ่ฌ */, 0xC4B1 /* ่ฐ */,
0xD65D /* ่ฌ */, 0xDACB /* ่ฐ */,
0xD65E /* ่ฌ */, 0xCEBD /* ่ฐ */,
0xD660 /* ่ฌ */, 0xCCDC /* ่ช */,
0xD661 /* ่ฌ
*/, 0xD6DF /* ่ฏ */,
0xD665 /* ่ฌ */, 0xBBD1 /* ่ฐ */,
0xD669 /* ่ฌ */, 0xC3D5 /* ่ฐ */,
0xD66B /* ่ฌ */, 0xDAD7 /* ่ฐง */,
0xD66F /* ่ฌ */, 0xDACA /* ่ฐ */,
0xD671 /* ่ฌ */, 0xDAD5 /* ่ฐก */,
0xD672 /* ่ฌ */, 0xB0F9 /* ่ฐค */,
0xD674 /* ่ฌ */, 0xC7AB /* ่ฐฆ */,
0xD675 /* ่ฌ */, 0xDAD6 /* ่ฐฅ */,
0xD676 /* ่ฌ */, 0xBDB2 /* ่ฎฒ */,
0xD678 /* ่ฌ */, 0xD0BB /* ่ฐข */,
0xD67B /* ่ฌ */, 0xD2A5 /* ่ฐฃ */,
0xD683 /* ่ฌจ */, 0xDAD3 /* ่ฐ */,
0xD686 /* ่ฌซ */, 0xDAD8 /* ่ฐช */,
0xD687 /* ่ฌฌ */, 0xC3FD /* ่ฐฌ */,
0xD68E /* ่ฌณ */, 0xDAA9 /* ่ฎด */,
0xD694 /* ่ฌน */, 0xBDF7 /* ่ฐจ */,
0xD697 /* ่ฌผ */, 0xBAF4 /* ๅผ */,
0xD698 /* ่ฌฝ */, 0xEAF1 /* ็ */,
0xD699 /* ่ฌพ */, 0xC3A1 /* ่ฐฉ */,
0xD69C /* ่ญ */, 0xBBA9 /* ๅ */,
0xD740 /* ่ญ */, 0xCEFB /* ๅป */,
0xD743 /* ่ญ */, 0xD6A4 /* ่ฏ */,
0xD748 /* ่ญ */, 0xDADC /* ่ฐฒ */,
0xD749 /* ่ญ */, 0xBCA5 /* ่ฎฅ */,
0xD750 /* ่ญ */, 0xDADA /* ่ฐฎ */,
0xD752 /* ่ญ */, 0xCAB6 /* ่ฏ */,
0xD753 /* ่ญ */, 0xDADB /* ่ฐฏ */,
0xD754 /* ่ญ */, 0xCCB7 /* ่ฐญ */,
0xD756 /* ่ญ */, 0xC6D7 /* ่ฐฑ */,
0xD759 /* ่ญ */, 0xD4EB /* ๅช */,
0xD764 /* ่ญซ */, 0xDADE /* ่ฐต */,
0xD765 /* ่ญญ */, 0xBBD9 /* ๆฏ */,
0xD767 /* ่ญฏ */, 0xD2EB /* ่ฏ */,
0xD768 /* ่ญฐ */, 0xD2E9 /* ่ฎฎ */,
0xD76C /* ่ญด */, 0xC7B4 /* ่ฐด */,
0xD76F /* ่ญท */, 0xBBA4 /* ๆค */,
0xD775 /* ่ญฝ */, 0xD3FE /* ่ช */,
0xD778 /* ่ฎ */, 0xB6C1 /* ่ฏป */,
0xD783 /* ่ฎ */, 0xB1E4 /* ๅ */,
0xD785 /* ่ฎ */, 0xD1E0 /* ็ */,
0xD787 /* ่ฎ */, 0xF6C5 /* ้ */,
0xD78B /* ่ฎ */, 0xB2F7 /* ่ฐ */,
0xD78C /* ่ฎ */, 0xC8C3 /* ่ฎฉ */,
0xD78E /* ่ฎ */, 0xC0BE /* ่ฐฐ */,
0xD78F /* ่ฎ */, 0xDADF /* ่ฐถ */,
0xD792 /* ่ฎ */, 0xBBB6 /* ๆฌข */,
0xD793 /* ่ฎ */, 0xD4DE /* ่ต */,
0xD795 /* ่ฎ */, 0xDAD4 /* ่ฐ */,
0xD797 /* ่ฎ */, 0xDADD /* ่ฐณ */,
0xD847 /* ่ฐฟ */, 0xCFAA /* ๆบช */,
0xD84D /* ่ฑ */, 0xC6F1 /* ๅฒ */,
0xD851 /* ่ฑ */, 0xCAFA /* ็ซ */,
0xD853 /* ่ฑ */, 0xB7E1 /* ไธฐ */,
0xD857 /* ่ฑ */, 0xD1DE /* ่ณ */,
0xD869 /* ่ฑฌ */, 0xD6ED /* ็ช */,
0xD882 /* ่ฒ */, 0xC0EA /* ็ธ */,
0xD888 /* ่ฒ */, 0xC3A8 /* ็ซ */,
0xD890 /* ่ฒ */, 0xB1B4 /* ่ด */,
0xD891 /* ่ฒ */, 0xD5EA /* ่ด */,
0xD893 /* ่ฒ */, 0xB8BA /* ่ด */,
0xD894 /* ่ฒก */, 0xB2C6 /* ่ดข */,
0xD895 /* ่ฒข */, 0xB9B1 /* ่ดก */,
0xD89A /* ่ฒง */, 0xC6B6 /* ่ดซ */,
0xD89B /* ่ฒจ */, 0xBBF5 /* ่ดง */,
0xD89C /* ่ฒฉ */, 0xB7B7 /* ่ดฉ */,
0xD89D /* ่ฒช */, 0xCCB0 /* ่ดช */,
0xD89E /* ่ฒซ */, 0xB9E1 /* ่ดฏ */,
0xD89F /* ่ฒฌ */, 0xD4F0 /* ่ดฃ */,
0xD941 /* ่ฒฏ */, 0xD6FC /* ่ดฎ */,
0xD942 /* ่ฒฐ */, 0xEADB /* ่ดณ */,
0xD944 /* ่ฒฒ */, 0xEADF /* ่ต */,
0xD945 /* ่ฒณ */, 0xB7A1 /* ่ดฐ */,
0xD946 /* ่ฒด */, 0xB9F3 /* ่ดต */,
0xD948 /* ่ฒถ */, 0xB1E1 /* ่ดฌ */,
0xD949 /* ่ฒท */, 0xC2F2 /* ไนฐ */,
0xD94A /* ่ฒธ */, 0xB4FB /* ่ดท */,
0xD94C /* ่ฒบ */, 0xEADC /* ่ดถ */,
0xD94D /* ่ฒป */, 0xB7D1 /* ่ดน */,
0xD94E /* ่ฒผ */, 0xCCF9 /* ่ดด */,
0xD94F /* ่ฒฝ */, 0xEADD /* ่ดป */,
0xD951 /* ่ฒฟ */, 0xC3B3 /* ่ดธ */,
0xD952 /* ่ณ */, 0xBAD8 /* ่ดบ */,
0xD953 /* ่ณ */, 0xEADA /* ่ดฒ */,
0xD954 /* ่ณ */, 0xC2B8 /* ่ต */,
0xD955 /* ่ณ */, 0xC1DE /* ่ต */,
0xD956 /* ่ณ */, 0xBBDF /* ่ดฟ */,
0xD957 /* ่ณ
*/, 0xEAE0 /* ่ต
*/,
0xD959 /* ่ณ */, 0xD7CA /* ่ต */,
0xD95A /* ่ณ */, 0xBCD6 /* ่ดพ */,
0xD95C /* ่ณ */, 0xD4F4 /* ่ดผ */,
0xD963 /* ่ณ */, 0xEAE2 /* ่ต */,
0xD964 /* ่ณ */, 0xC9DE /* ่ต */,
0xD965 /* ่ณ */, 0xB1F6 /* ๅฎพ */,
0xD967 /* ่ณ */, 0xEAE4 /* ่ต */,
0xD96C /* ่ณ */, 0xEAE3 /* ่ต */,
0xD96E /* ่ณ */, 0xB4CD /* ่ต */,
0xD970 /* ่ณ */, 0xC9CD /* ่ต */,
0xD972 /* ่ณ */, 0xC5E2 /* ่ต */,
0xD973 /* ่ณก */, 0xE2D9 /* ่ต */,
0xD974 /* ่ณข */, 0xCFCD /* ่ดค */,
0xD975 /* ่ณฃ */, 0xC2F4 /* ๅ */,
0xD976 /* ่ณค */, 0xBCFA /* ่ดฑ */,
0xD978 /* ่ณฆ */, 0xB8B3 /* ่ต */,
0xD979 /* ่ณง */, 0xEAE6 /* ่ต */,
0xD97C /* ่ณช */, 0xD6CA /* ่ดจ */,
0xD97E /* ่ณฌ */, 0xD5CB /* ่ดฆ */,
0xD980 /* ่ณญ */, 0xB6C4 /* ่ต */,
0xD981 /* ่ณฎ */, 0xEAE1 /* ่ต */,
0xD987 /* ่ณด */, 0xC0B5 /* ่ต */,
0xD98B /* ่ณธ */, 0xCAA3 /* ๅฉ */,
0xD98D /* ่ณบ */, 0xD7AC /* ่ต */,
0xD98E /* ่ณป */, 0xEAE7 /* ่ต */,
0xD98F /* ่ณผ */, 0xB9BA /* ่ดญ */,
0xD990 /* ่ณฝ */, 0xC8FC /* ่ต */,
0xD991 /* ่ณพ */, 0xD8D3 /* ่ต */,
0xD997 /* ่ด */, 0xEADE /* ่ดฝ */,
0xD998 /* ่ด
*/, 0xD7B8 /* ่ต */,
0xD99B /* ่ด */, 0xD4F9 /* ่ต */,
0xD99D /* ่ด */, 0xD4DE /* ่ต */,
0xD9A0 /* ่ด */, 0xC9C4 /* ่ตก */,
0xDA41 /* ่ด */, 0xD3AE /* ่ตข */,
0xDA42 /* ่ด */, 0xEAE1 /* ่ต */,
0xDA45 /* ่ด */, 0xD4DF /* ่ต */,
0xDA48 /* ่ด */, 0xCAEA /* ่ต */,
0xDA49 /* ่ด */, 0xD8CD /* ่ต */,
0xDA4D /* ่ด */, 0xB8D3 /* ่ตฃ */,
0xDA73 /* ่ถ */, 0xB8CF /* ่ตถ */,
0xDA77 /* ่ถ */, 0xD5D4 /* ่ตต */,
0xDA85 /* ่ถจ */, 0xC7F7 /* ่ถ */,
0xDA8E /* ่ถฒ */, 0xF4F5 /* ่ถฑ */,
0xDB45 /* ่ทก */, 0xBCA3 /* ่ฟน */,
0xDB50 /* ่ทด */, 0xB2C8 /* ่ธฉ */,
0xDB52 /* ่ทผ */, 0xBED6 /* ๅฑ */,
0xDB60 /* ่ธ */, 0xBCF9 /* ่ทต */,
0xDB6D /* ่ธก */, 0xF2E9 /* ่ท */,
0xDB73 /* ่ธซ */, 0xC5F6 /* ็ขฐ */,
0xDB75 /* ่ธฐ */, 0xD3E2 /* ้พ */,
0xDB78 /* ่ธด */, 0xD3BB /* ่ธ */,
0xDB7D /* ่ธผ */, 0xCCDF /* ่ธข */,
0xDB84 /* ่น */, 0xF5C4 /* ่ท */,
0xDB8B /* ่น */, 0xF5CF /* ่ทธ */,
0xDB8F /* ่น */, 0xCCCB /* ่ถ */,
0xDB94 /* ่น */, 0xBCA3 /* ่ฟน */,
0xDB95 /* ่น */, 0xF5C5 /* ่ท */,
0xDB98 /* ่นฃ */, 0xF5E7 /* ่น */,
0xDB99 /* ่นค */, 0xD7D9 /* ่ธช */,
0xDB9B /* ่นง */, 0xD4E3 /* ็ณ */,
0xDC45 /* ่นบ */, 0xF5CE /* ่ทท */,
0xDC46 /* ่นป */, 0xF5CE /* ่ทท */,
0xDC4A /* ่บ */, 0xCCA4 /* ่ธ */,
0xDC4F /* ่บ */, 0xF5BB /* ่ถธ */,
0xDC50 /* ่บ */, 0xB3EC /* ่ธ */,
0xDC51 /* ่บ */, 0xF5D2 /* ่ทป */,
0xDC53 /* ่บ */, 0xD4BE /* ่ท */,
0xDC55 /* ่บ */, 0xF5DC /* ่ธฏ */,
0xDC56 /* ่บ */, 0xF5C8 /* ่ท */,
0xDC57 /* ่บ */, 0xF5D9 /* ่ธฌ */,
0xDC58 /* ่บ */, 0xF5E9 /* ่นฐ */,
0xDC5D /* ่บ */, 0xF5D1 /* ่ทน */,
0xDC62 /* ่บก */, 0xF5E6 /* ่น */,
0xDC66 /* ่บฅ */, 0xB4DA /* ่นฟ */,
0xDC67 /* ่บฆ */, 0xF5F2 /* ่บ */,
0xDC6B /* ่บช */, 0xF5EF /* ่บ */,
0xDC7C /* ่ป */, 0xC7FB /* ่บฏ */,
0xDC87 /* ่ป */, 0xB3B5 /* ่ฝฆ */,
0xDC88 /* ่ป */, 0xD4FE /* ่ฝง */,
0xDC89 /* ่ป */, 0xB9EC /* ่ฝจ */,
0xDC8A /* ่ป */, 0xBEFC /* ๅ */,
0xDC8E /* ่ป */, 0xD0F9 /* ่ฝฉ */,
0xDC90 /* ่ป */, 0xE9ED /* ่ฝซ */,
0xDC97 /* ่ป */, 0xE9EE /* ่ฝญ */,
0xDC9B /* ่ป */, 0xC8ED /* ่ฝฏ */,
0xDD46 /* ่ปซ */, 0xE9F4 /* ่ฝธ */,
0xDD53 /* ่ปธ */, 0xD6E1 /* ่ฝด */,
0xDD54 /* ่ปน */, 0xE9F2 /* ่ฝต */,
0xDD55 /* ่ปบ */, 0xE9F7 /* ่ฝบ */,
0xDD56 /* ่ปป */, 0xE9F0 /* ่ฝฒ */,
0xDD57 /* ่ปผ */, 0xE9F3 /* ่ฝถ */,
0xDD59 /* ่ปพ */, 0xE9F8 /* ่ฝผ */,
0xDD5E /* ่ผ */, 0xBDCF /* ่พ */,
0xDD60 /* ่ผ
*/, 0xE9FB /* ่พ */,
0xDD62 /* ่ผ */, 0xE9FA /* ่พ */,
0xDD64 /* ่ผ */, 0xD4D8 /* ่ฝฝ */,
0xDD65 /* ่ผ */, 0xE9F9 /* ่ฝพ */,
0xDD6D /* ่ผ */, 0xE9FC /* ่พ */,
0xDD6E /* ่ผ */, 0xCDEC /* ๆฝ */,
0xDD6F /* ่ผ */, 0xB8A8 /* ่พ
*/,
0xDD70 /* ่ผ */, 0xC7E1 /* ่ฝป */,
0xDD76 /* ่ผ */, 0xC1BE /* ่พ */,
0xDD77 /* ่ผ */, 0xEAA2 /* ่พ */,
0xDD78 /* ่ผ */, 0xBBD4 /* ่พ */,
0xDD79 /* ่ผ */, 0xE9FE /* ่พ */,
0xDD7A /* ่ผ */, 0xEAA1 /* ่พ */,
0xDD81 /* ่ผฅ */, 0xB9F5 /* ่พ */,
0xDD82 /* ่ผฆ */, 0xE9FD /* ่พ */,
0xDD85 /* ่ผฉ */, 0xB1B2 /* ่พ */,
0xDD86 /* ่ผช */, 0xC2D6 /* ่ฝฎ */,
0xDD8B /* ่ผฏ */, 0xBCAD /* ่พ */,
0xDD8F /* ่ผณ */, 0xEAA3 /* ่พ */,
0xDD94 /* ่ผธ */, 0xCAE4 /* ่พ */,
0xDD97 /* ่ผป */, 0xB7F8 /* ่พ */,
0xDD9A /* ่ผพ */, 0xD5B7 /* ่พ */,
0xDD9B /* ่ผฟ */, 0xD3DF /* ่ */,
0xDD9E /* ่ฝ */, 0xECB1 /* ๆฏ */,
0xDDA0 /* ่ฝ */, 0xCFBD /* ่พ */,
0xDE40 /* ่ฝ
*/, 0xD4AF /* ่พ */,
0xDE41 /* ่ฝ */, 0xEAA4 /* ่พ */,
0xDE44 /* ่ฝ */, 0xD7AA /* ่ฝฌ */,
0xDE48 /* ่ฝ */, 0xD5DE /* ่พ */,
0xDE49 /* ่ฝ */, 0xBDCE /* ่ฝฟ */,
0xDE4F /* ่ฝ */, 0xEAA5 /* ่พ */,
0xDE5A /* ่ฝ */, 0xBAE4 /* ่ฝฐ */,
0xDE5C /* ่ฝก */, 0xE0CE /* ่พ */,
0xDE5D /* ่ฝข */, 0xE9F6 /* ่ฝน */,
0xDE5F /* ่ฝค */, 0xE9F1 /* ่ฝณ */,
0xDE6B /* ่พฆ */, 0xB0EC /* ๅ */,
0xDE6F /* ่พญ */, 0xB4C7 /* ่พ */,
0xDE70 /* ่พฎ */, 0xB1E8 /* ่พซ */,
0xDE71 /* ่พฏ */, 0xB1E7 /* ่พฉ */,
0xDE72 /* ่พฒ */, 0xC5A9 /* ๅ */,
0xDE7E /* ่ฟ */, 0xE5C6 /* ่ฟค */,
0xDE92 /* ่ฟด */, 0xBBD8 /* ๅ */,
0xDE95 /* ่ฟบ */, 0xC4CB /* ไน */,
0xDE96 /* ่ฟป */, 0xD2C6 /* ็งป */,
0xDE9F /* ้ */, 0xE5C9 /* ่ฟณ */,
0xDF40 /* ้ */, 0xD5E2 /* ่ฟ */,
0xDF42 /* ้ฃ */, 0xC1AC /* ่ฟ */,
0xDF4C /* ้ฑ */, 0xD6DC /* ๅจ */,
0xDF4D /* ้ฒ */, 0xBDF8 /* ่ฟ */,
0xDF5A /* ้ */, 0xD5EC /* ไพฆ */,
0xDF5B /* ้ */, 0xD3CE /* ๆธธ */,
0xDF5C /* ้ */, 0xD4CB /* ่ฟ */,
0xDF5E /* ้ */, 0xB9FD /* ่ฟ */,
0xDF5F /* ้ */, 0xB4EF /* ่พพ */,
0xDF60 /* ้ */, 0xCEA5 /* ่ฟ */,
0xDF62 /* ้ */, 0xD2A3 /* ้ฅ */,
0xDF64 /* ้ */, 0xD1B7 /* ้ */,
0xDF66 /* ้ */, 0xB5DD /* ้ */,
0xDF68 /* ้ */, 0xD4B6 /* ่ฟ */,
0xDF6D /* ้ฉ */, 0xCACA /* ้ */,
0xDF74 /* ้ฒ */, 0xB3D9 /* ่ฟ */,
0xDF76 /* ้ถ */, 0xC8C6 /* ็ป */,
0xDF77 /* ้ท */, 0xC7A8 /* ่ฟ */,
0xDF78 /* ้ธ */, 0xD1A1 /* ้ */,
0xDF7A /* ้บ */, 0xD2C5 /* ้ */,
0xDF7C /* ้ผ */, 0xC1C9 /* ่พฝ */,
0xDF7E /* ้ */, 0xC2F5 /* ่ฟ */,
0xDF80 /* ้ */, 0xBBB9 /* ่ฟ */,
0xDF83 /* ้ */, 0xE5C7 /* ่ฟฉ */,
0xDF85 /* ้ */, 0xB1DF /* ่พน */,
0xDF89 /* ้ */, 0xC2DF /* ้ป */,
0xDF8A /* ้ */, 0xE5CE /* ้ฆ */,
0xE041 /* ้ */, 0xBACF /* ๅ */,
0xE050 /* ้ */, 0xDBA3 /* ้ */,
0xE05D /* ้ต */, 0xD3CA /* ้ฎ */,
0xE069 /* ้ */, 0xDBA9 /* ้ */,
0xE06C /* ้ */, 0xCFE7 /* ไนก */,
0xE075 /* ้ */, 0xD7DE /* ้น */,
0xE077 /* ้ */, 0xDAF9 /* ้ฌ */,
0xE079 /* ้ */, 0xD4C7 /* ้ง */,
0xE087 /* ้ง */, 0xB5CB /* ้ */,
0xE08D /* ้ญ */, 0xD6A3 /* ้ */,
0xE08F /* ้ฐ */, 0xC1DA /* ้ป */,
0xE090 /* ้ฒ */, 0xB5A6 /* ้ธ */,
0xE092 /* ้ด */, 0xDAFE /* ้บ */,
0xE094 /* ้ถ */, 0xDBA6 /* ้ */,
0xE097 /* ้บ */, 0xDAF7 /* ้ */,
0xE142 /* ้
*/, 0xDBAA /* ้ฆ */,
0xE147 /* ้
*/, 0xF0B2 /* ้ธฉ */,
0xE15A /* ้ */, 0xEBE7 /* ่
*/,
0xE168 /* ้ */, 0xB3F3 /* ไธ */,
0xE16A /* ้ */, 0xD4CD /* ้
*/,
0xE174 /* ้ซ */, 0xD2BD /* ๅป */,
0xE175 /* ้ฌ */, 0xBDB4 /* ้
ฑ */,
0xE177 /* ้ฑ */, 0xB2A6 /* ๆจ */,
0xE180 /* ้ผ */, 0xD1E0 /* ็ */,
0xE184 /* ้ */, 0xC4F0 /* ้
ฟ */,
0xE185 /* ้ */, 0xD0C6 /* ่ก
*/,
0xE187 /* ้ */, 0xF5A7 /* ้
พ */,
0xE189 /* ้
*/, 0xF5A6 /* ้
ฝ */,
0xE18C /* ้ */, 0xCACD /* ้ */,
0xE18D /* ้ */, 0xC0E5 /* ๅ */,
0xE18F /* ้ */, 0xEEC5 /* ้ */,
0xE190 /* ้ */, 0xEEC6 /* ้ */,
0xE191 /* ้ */, 0xEEC9 /* ้ */,
0xE193 /* ้ */, 0xEEC8 /* ้ */,
0xE194 /* ้ */, 0xB6A4 /* ้ */,
0xE195 /* ้ */, 0xEEC7 /* ้ */,
0xE198 /* ้ */, 0xD5EB /* ้ */,
0xE19E /* ้ฃ */, 0xB5F6 /* ้ */,
0xE19F /* ้ค */, 0xEECC /* ้ */,
0xE240 /* ้ฆ */, 0xBFDB /* ๆฃ */,
0xE241 /* ้ง */, 0xEECB /* ้ */,
0xE243 /* ้ฉ */, 0xB7B0 /* ้ */,
0xE246 /* ้ฌ */, 0xC7A5 /* ้ */,
0xE24F /* ้ต */, 0xEECE /* ้ */,
0xE251 /* ้ท */, 0xEECA /* ้ */,
0xE253 /* ้น */, 0xEECF /* ้ */,
0xE25A /* ้ */, 0xEED9 /* ้ฏ */,
0xE25B /* ้ */, 0xEED5 /* ้ซ */,
0xE25E /* ้ */, 0xEED7 /* ้ญ */,
0xE263 /* ้ */, 0xC4C6 /* ้ */,
0xE267 /* ้ */, 0xB6DB /* ้ */,
0xE26A /* ้ */, 0xEED4 /* ้ค */,
0xE26B /* ้ */, 0xEED3 /* ้ฃ */,
0xE26E /* ้ */, 0xB3AE /* ้ */,
0xE26F /* ้ */, 0xC5A5 /* ้ฎ */,
0xE278 /* ้ */, 0xBEFB /* ้ง */,
0xE27D /* ้ฃ */, 0xB8C6 /* ้ */,
0xE280 /* ้ฅ */, 0xEED8 /* ้ฌ */,
0xE281 /* ้ฆ */, 0xEED1 /* ้ */,
0xE282 /* ้ง */, 0xEED6 /* ้ช */,
0xE289 /* ้ฎ */, 0xEEEA /* ้ */,
0xE28B /* ้ฐ */, 0xEEE6 /* ้ */,
0xE28E /* ้ณ */, 0xEEDD /* ้ถ */,
0xE28F /* ้ด */, 0xC1E5 /* ้ */,
0xE292 /* ้ท */, 0xEEDC /* ้ด */,
0xE293 /* ้ธ */, 0xEEE0 /* ้น */,
0xE294 /* ้น */, 0xEEEB /* ้ */,
0xE295 /* ้บ */, 0xEEDA /* ้ฐ */,
0xE298 /* ้ฝ */, 0xEEDF /* ้ธ */,
0xE299 /* ้พ */, 0xD3CB /* ้ */,
0xE29A /* ้ฟ */, 0xEEE4 /* ้ฟ */,
0xE29B /* ้ */, 0xBCD8 /* ้พ */,
0xE2A0 /* ้
*/, 0xEED2 /* ้ */,
0xE340 /* ้ */, 0xD7EA /* ้ป */,
0xE342 /* ้ */, 0xEEE8 /* ้ */,
0xE343 /* ้ */, 0xEEE7 /* ้ */,
0xE345 /* ้ */, 0xC5D9 /* ๅจ */,
0xE347 /* ้ */, 0xEEE9 /* ้ */,
0xE34B /* ้ */, 0xB2AC /* ้ */,
0xE351 /* ้ */, 0xC7AF /* ้ณ */,
0xE354 /* ้ */, 0xC3AD /* ้ */,
0xE355 /* ้ */, 0xC7A6 /* ้
*/,
0xE358 /* ้ */, 0xEEE1 /* ้บ */,
0xE35E /* ้ค */, 0xB9B3 /* ้ฉ */,
0xE360 /* ้ฆ */, 0xEEDB /* ้ฒ */,
0xE366 /* ้ฌ */, 0xEEE2 /* ้ผ */,
0xE367 /* ้ญ */, 0xEEE3 /* ้ฝ */,
0xE371 /* ้ธ */, 0xBDC2 /* ้ฐ */,
0xE373 /* ้บ */, 0xEEEF /* ้ */,
0xE374 /* ้ป */, 0xB8F5 /* ้ฌ */,
0xE378 /* ้ฟ */, 0xEEFE /* ้ช */,
0xE379 /* ้ */, 0xD2F8 /* ้ถ */,
0xE37C /* ้ */, 0xEFA5 /* ้ณ */,
0xE37E /* ้
*/, 0xCDAD /* ้ */,
0xE38A /* ้ */, 0xCFB3 /* ้ฃ */,
0xE38C /* ้ */, 0xEEFD /* ้จ */,
0xE38E /* ้ */, 0xCCFA /* ้ */,
0xE38F /* ้ */, 0xEEF9 /* ้ข */,
0xE391 /* ้ */, 0xC3FA /* ้ญ */,
0xE393 /* ้ */, 0xEFA2 /* ้ซ */,
0xE395 /* ้ */, 0xCFCE /* ่ก */,
0xE399 /* ้ */, 0xEEEE /* ้ */,
0xE39C /* ้ฃ */, 0xEFA8 /* ้ท */,
0xE39E /* ้ฅ */, 0xD2BF /* ้ฑ */,
0xE39F /* ้ฆ */, 0xEEF7 /* ้ */,
0xE440 /* ้จ */, 0xEFA7 /* ้ต */,
0xE441 /* ้ฉ */, 0xEEFB /* ้ฅ */,
0xE442 /* ้ช */, 0xEEF0 /* ้ */,
0xE443 /* ้ซ */, 0xEFA4 /* ้ฏ */,
0xE444 /* ้ฌ */, 0xEEED /* ้ */,
0xE449 /* ้ฒ */, 0xBAB8 /* ็ */,
0xE44A /* ้ณ */, 0xC8F1 /* ้ */,
0xE44E /* ้ท */, 0xCFFA /* ้ */,
0xE452 /* ้ป */, 0xCCE0 /* ้ */,
0xE453 /* ้ผ */, 0xEFB1 /* ้ */,
0xE458 /* ้ */, 0xC2C1 /* ้ */,
0xE45A /* ้ */, 0xEFB6 /* ้ */,
0xE45C /* ้
*/, 0xD0BF /* ้ */,
0xE45E /* ้ */, 0xB1B5 /* ้ก */,
0xE462 /* ้ */, 0xEEFA /* ้ค */,
0xE465 /* ้ */, 0xEEF2 /* ้ */,
0xE468 /* ้ */, 0xB7E6 /* ้ */,
0xE473 /* ้ */, 0xEFB2 /* ้ */,
0xE475 /* ้ */, 0xEFB7 /* ้ */,
0xE47A /* ้ค */, 0xB3FA /* ้ */,
0xE47C /* ้ฆ */, 0xEFB8 /* ้ */,
0xE47E /* ้จ */, 0xEFB0 /* ้ */,
0xE481 /* ้ช */, 0xC6CC /* ้บ */,
0xE485 /* ้ฎ */, 0xEEF1 /* ้ */,
0xE486 /* ้ฏ */, 0xEFAF /* ้ */,
0xE487 /* ้ฐ */, 0xEFAE /* ้ */,
0xE488 /* ้ฑ */, 0xEFAB /* ้ฝ */,
0xE48F /* ้ธ */, 0xBEE2 /* ้ฏ */,
0xE493 /* ้ผ */, 0xB8D6 /* ้ข */,
0xE498 /* ้ */, 0xEFBE /* ้ */,
0xE49B /* ้ */, 0xC2BC /* ๅฝ */,
0xE49D /* ้ */, 0xEFBA /* ้ */,
0xE49F /* ้ */, 0xEFC3 /* ้ฉ */,
0xE546 /* ้ */, 0xD7B6 /* ้ฅ */,
0xE548 /* ้ */, 0xEFB9 /* ้ */,
0xE54B /* ้ */, 0xEFBF /* ้ */,
0xE54E /* ้ */, 0xB4B8 /* ้ค */,
0xE54F /* ้ */, 0xEFC5 /* ้ฑ */,
0xE550 /* ้ */, 0xEFA3 /* ้ฎ */,
0xE551 /* ้ */, 0xEFBC /* ้ */,
0xE555 /* ้ */, 0xEFC4 /* ้ฌ */,
0xE556 /* ้ */, 0xB6A7 /* ้ญ */,
0xE558 /* ้ข */, 0xC7AE /* ้ฑ */,
0xE55C /* ้ฆ */, 0xBDF5 /* ้ฆ */,
0xE55E /* ้จ */, 0xC3AA /* ้ */,
0xE561 /* ้ซ */, 0xCEFD /* ้ก */,
0xE564 /* ้ฎ */, 0xEFC0 /* ้ข */,
0xE565 /* ้ฏ */, 0xB4ED /* ้ */,
0xE569 /* ้ณ */, 0xC3CC /* ้ฐ */,
0xE56C /* ้ถ */, 0xB1ED /* ่กจ */,
0xE56E /* ้ธ */, 0xEFAA /* ้ผ */,
0xE57B /* ้ */, 0xEECD /* ้ */,
0xE57C /* ้ */, 0xEFC7 /* ้ด */,
0xE580 /* ้ */, 0xC1B4 /* ้พ */,
0xE581 /* ้ */, 0xB9F8 /* ้
*/,
0xE583 /* ้ */, 0xB6C6 /* ้ */,
0xE58A /* ้ */, 0xEFC9 /* ้ท */,
0xE58E /* ้ */, 0xD5A1 /* ้ก */,
0xE590 /* ้ */, 0xCEFD /* ้ก */,
0xE591 /* ้ */, 0xB6CD /* ้ป */,
0xE59A /* ้ค */, 0xEFCA /* ้ธ */,
0xE59B /* ้ฅ */, 0xEFC6 /* ้ฒ */,
0xE640 /* ้ฌ */, 0xC7C2 /* ้น */,
0xE644 /* ้ฐ */, 0xEFCC /* ้พ */,
0xE649 /* ้ต */, 0xBCFC /* ้ฎ */,
0xE64A /* ้ถ */, 0xEFC8 /* ้ถ */,
0xE64E /* ้บ */, 0xD5E0 /* ้ */,
0xE650 /* ้ผ */, 0xD5EB /* ้ */,
0xE652 /* ้พ */, 0xD6D3 /* ้ */,
0xE656 /* ้ */, 0xC3BE /* ้ */,
0xE65E /* ้ */, 0xB0F7 /* ้ */,
0xE667 /* ้ */, 0xC8DB /* ็ */,
0xE669 /* ้ */, 0xCBF8 /* ้ */,
0xE66A /* ้ */, 0xC7B9 /* ๆช */,
0xE66B /* ้ */, 0xEFD3 /* ้ */,
0xE66D /* ้ */, 0xB4B8 /* ้ค */,
0xE675 /* ้ข */, 0xCED9 /* ้จ */,
0xE676 /* ้ฃ */, 0xDDF6 /* ่ฅ */,
0xE679 /* ้ฆ */, 0xEFD6 /* ้ */,
0xE67A /* ้ง */, 0xEEF8 /* ้ */,
0xE67C /* ้ฉ */, 0xEFA1 /* ้ฉ */,
0xE67D /* ้ช */, 0xEFCB /* ้ผ */,
0xE680 /* ้ฌ */, 0xB8E4 /* ้ */,
0xE682 /* ้ฎ */, 0xD5F2 /* ้ */,
0xE683 /* ้ฏ */, 0xC0C6 /* ๆฆ */,
0xE684 /* ้ฐ */, 0xEFD7 /* ้ */,
0xE687 /* ้ณ */, 0xC4F8 /* ้ */,
0xE689 /* ้ต */, 0xEFD8 /* ้ */,
0xE697 /* ้ */, 0xEFDF /* ้ */,
0xE69B /* ้ */, 0xEFE0 /* ้ */,
0xE69C /* ้ */, 0xC1B4 /* ้พ */,
0xE69F /* ้ */, 0xEFD2 /* ้ */,
0xE6A0 /* ้ */, 0xEFDD /* ้ */,
0xE743 /* ้ */, 0xEFE1 /* ้ */,
0xE748 /* ้ */, 0xEFAC /* ้ฟ */,
0xE749 /* ้ */, 0xEFCF /* ้ต */,
0xE74B /* ้ */, 0xC6DD /* ๆ */,
0xE74D /* ้ */, 0xEFDB /* ้ */,
0xE74E /* ้ */, 0xEFDC /* ้ */,
0xE74F /* ้ */, 0xEFDE /* ้ */,
0xE750 /* ้ */, 0xB2F9 /* ้ฒ */,
0xE752 /* ้ก */, 0xBEB5 /* ้ */,
0xE753 /* ้ข */, 0xEFDA /* ้ */,
0xE755 /* ้ค */, 0xEFCE /* ้ */,
0xE759 /* ้จ */, 0xF6C9 /* ้พ */,
0xE766 /* ้ต */, 0xEEFC /* ้ง */,
0xE768 /* ้ท */, 0xEFE4 /* ้ค */,
0xE76A /* ้น */, 0xEFEA /* ้ช */,
0xE76E /* ้ฝ */, 0xD0E2 /* ้ */,
0xE774 /* ้ */, 0xEEF3 /* ้ */,
0xE77A /* ้ */, 0xCFB3 /* ้ฃ */,
0xE77C /* ้ */, 0xEFA6 /* ้ด */,
0xE782 /* ้ */, 0xC1CD /* ้ฃ */,
0xE784 /* ้ */, 0xEFA9 /* ้น */,
0xE785 /* ้ */, 0xEFE6 /* ้ฆ */,
0xE786 /* ้ */, 0xEFE2 /* ้ก */,
0xE78A /* ้ */, 0xD6D3 /* ้ */,
0xE78B /* ้ */, 0xEFEB /* ้ซ */,
0xE792 /* ้ */, 0xEFE8 /* ้จ */,
0xE79A /* ้จ */, 0xEFD0 /* ้ */,
0xE79D /* ้ซ */, 0xEFD4 /* ้ */,
0xE7A0 /* ้ฎ */, 0xC1AD /* ้ฐ */,
0xE843 /* ้ฒ */, 0xEFED /* ้ฏ */,
0xE844 /* ้ณ */, 0xC0D8 /* ้ญ */,
0xE846 /* ้ต */, 0xCCFA /* ้ */,
0xE849 /* ้ธ */, 0xEEEC /* ้ */,
0xE84B /* ้บ */, 0xEEF5 /* ้ */,
0xE84E /* ้ฝ */, 0xEEE3 /* ้ฝ */,
0xE84F /* ้ฟ */, 0xEFEE /* ้ฑ */,
0xE854 /* ้ */, 0xD6FD /* ้ธ */,
0xE85A /* ้ */, 0xEFEC /* ้ฌ */,
0xE85C /* ้ */, 0xEFD9 /* ้ */,
0xE861 /* ้ */, 0xBCF8 /* ้ด */,
0xE862 /* ้ */, 0xBCF8 /* ้ด */,
0xE870 /* ้ */, 0xEEE5 /* ้ */,
0xE873 /* ้ฃ */, 0xEFF0 /* ้ณ */,
0xE874 /* ้ค */, 0xC5D9 /* ๅจ */,
0xE87A /* ้ช */, 0xC2AF /* ็ */,
0xE87C /* ้ญ */, 0xEFE7 /* ้ง */,
0xE880 /* ้ฐ */, 0xD4BF /* ้ฅ */,
0xE882 /* ้ฒ */, 0xCFE2 /* ้ถ */,
0xE887 /* ้ท */, 0xC4F7 /* ้ */,
0xE88C /* ้ผ */, 0xC2E0 /* ้ฃ */,
0xE88D /* ้ฝ */, 0xD7EA /* ้ป */,
0xE88E /* ้พ */, 0xF6C7 /* ้ฎ */,
0xE88F /* ้ฟ */, 0xD4E4 /* ๅฟ */,
0xE893 /* ้ */, 0xEFED /* ้ฏ */,
0xE94C /* ้ท */, 0xB3A4 /* ้ฟ */,
0xE954 /* ้ */, 0xC3C5 /* ้จ */,
0xE956 /* ้ */, 0xE3C5 /* ้ฉ */,
0xE957 /* ้ */, 0xC9C1 /* ้ช */,
0xE95A /* ้ */, 0xE3C6 /* ้ซ */,
0xE95D /* ้ */, 0xB1D5 /* ้ญ */,
0xE95F /* ้ */, 0xBFAA /* ๅผ */,
0xE960 /* ้ */, 0xE3CA /* ้ถ */,
0xE962 /* ้ */, 0xE3C8 /* ้ณ */,
0xE963 /* ้ */, 0xC8F2 /* ้ฐ */,
0xE965 /* ้ */, 0xCFD0 /* ้ฒ */,
0xE966 /* ้ */, 0xCFD0 /* ้ฒ */,
0xE967 /* ้ */, 0xBCE4 /* ้ด */,
0xE968 /* ้ */, 0xE3C9 /* ้ต */,
0xE96C /* ้ */, 0xD5A2 /* ้ธ */,
0xE975 /* ้ก */, 0xBAD2 /* ้ */,
0xE977 /* ้ฃ */, 0xB8F3 /* ้ */,
0xE978 /* ้ค */, 0xBACF /* ๅ */,
0xE979 /* ้ฅ */, 0xB7A7 /* ้ */,
0xE97C /* ้จ */, 0xB9EB /* ้บ */,
0xE97D /* ้ฉ */, 0xC3F6 /* ้ฝ */,
0xE980 /* ้ซ */, 0xE3CD /* ้ */,
0xE981 /* ้ฌ */, 0xE3CF /* ้ */,
0xE982 /* ้ญ */, 0xE3CC /* ้พ */,
0xE986 /* ้ฑ */, 0xD4C4 /* ้
*/,
0xE98B /* ้ถ */, 0xE3D1 /* ้ */,
0xE98E /* ้น */, 0xD1CB /* ้ */,
0xE990 /* ้ป */, 0xD1D6 /* ้ */,
0xE991 /* ้ผ */, 0xE3D5 /* ้ */,
0xE992 /* ้ฝ */, 0xE3D4 /* ้ */,
0xE993 /* ้พ */, 0xE3D0 /* ้ */,
0xE994 /* ้ฟ */, 0xE3D3 /* ้ */,
0xE998 /* ้ */, 0xE3D6 /* ้ */,
0xE99B /* ้ */, 0xB0E5 /* ๆฟ */,
0xE99C /* ้ */, 0xB0B5 /* ๆ */,
0xE99D /* ้ */, 0xE3C7 /* ้ฑ */,
0xE99F /* ้ */, 0xC0AB /* ้ */,
0xE9A0 /* ้ */, 0xE3D7 /* ้ */,
0xEA40 /* ้ */, 0xC0BB /* ้ */,
0xEA44 /* ้ */, 0xE3D9 /* ้ */,
0xEA48 /* ้ */, 0xE3D8 /* ้ */,
0xEA49 /* ้ */, 0xE3DA /* ้ */,
0xEA4A /* ้ */, 0xB4B3 /* ้ฏ */,
0xEA50 /* ้ */, 0xB9D8 /* ๅ
ณ */,
0xEA52 /* ้ */, 0xE3DB /* ้ */,
0xEA55 /* ้ก */, 0xB2FB /* ้ */,
0xEA56 /* ้ข */, 0xB1D9 /* ่พ */,
0xEA59 /* ้ฅ */, 0xE3CB /* ้ผ */,
0xEA69 /* ้จ */, 0xB6F2 /* ๅ */,
0xEA6C /* ้ฌ */, 0xBFD3 /* ๅ */,
0xEA6E /* ้ฏ */, 0xD6B7 /* ๅ */,
0xEA80 /* ้ */, 0xDAEA /* ้ */,
0xEA83 /* ้ */, 0xC9C2 /* ้ */,
0xEA84 /* ้ */, 0xC9C2 /* ้ */,
0xEA85 /* ้ */, 0xC9FD /* ๅ */,
0xEA87 /* ้ฃ */, 0xD5F3 /* ้ต */,
0xEA8E /* ้ฐ */, 0xD2F5 /* ้ด */,
0xEA90 /* ้ณ */, 0xB3C2 /* ้ */,
0xEA91 /* ้ธ */, 0xC2BD /* ้ */,
0xEA96 /* ้ฝ */, 0xD1F4 /* ้ณ */,
0xEA9D /* ้ */, 0xB5CC /* ๅ ค */,
0xEA9F /* ้ */, 0xDAED /* ้ง */,
0xEAA0 /* ้ */, 0xB6D3 /* ้ */,
0xEB41 /* ้ */, 0xBDD7 /* ้ถ */,
0xEB45 /* ้ */, 0xD4C9 /* ้จ */,
0xEB48 /* ้ */, 0xBCCA /* ้
*/,
0xEB53 /* ้จ */, 0xCBE6 /* ้ */,
0xEB55 /* ้ช */, 0xCFD5 /* ้ฉ */,
0xEB5B /* ้ฑ */, 0xD2FE /* ้ */,
0xEB5D /* ้ด */, 0xC2A4 /* ้ */,
0xEB60 /* ้ธ */, 0xC1A5 /* ้ถ */,
0xEB62 /* ้ป */, 0xD6BB /* ๅช */,
0xEB68 /* ้ */, 0xF6C1 /* ้ฝ */,
0xEB6D /* ้ */, 0xCBE4 /* ่ฝ */,
0xEB70 /* ้ */, 0xCBAB /* ๅ */,
0xEB72 /* ้ */, 0xB3FB /* ้ */,
0xEB73 /* ้ */, 0xD4D3 /* ๆ */,
0xEB74 /* ้ */, 0xD3BA /* ้ */,
0xEB75 /* ้ */, 0xBCA6 /* ้ธก */,
0xEB78 /* ้ข */, 0xC0EB /* ็ฆป */,
0xEB79 /* ้ฃ */, 0xC4D1 /* ้พ */,
0xEB83 /* ้ฐ */, 0xB7D5 /* ๆฐ */,
0xEB85 /* ้ฒ */, 0xD4C6 /* ไบ */,
0xEB8A /* ้ป */, 0xB5E7 /* ็ต */,
0xEB95 /* ้ */, 0xD5B4 /* ๆฒพ */,
0xEC43 /* ้ค */, 0xC1EF /* ๆบ */,
0xEC46 /* ้ง */, 0xCEED /* ้พ */,
0xEC56 /* ้ฝ */, 0xF6AB /* ้ */,
0xEC5A /* ้ */, 0xF6A8 /* ้ณ */,
0xEC5C /* ้ */, 0xF6B0 /* ้ญ */,
0xEC60 /* ้ */, 0xC1E9 /* ็ต */,
0xEC6E /* ้ */, 0xF6A6 /* ้ */,
0xEC6F /* ้ */, 0xBEB2 /* ้ */,
0xEC74 /* ้ฆ */, 0xEBEF /* ่
ผ */,
0xEC76 /* ้จ */, 0xD8CC /* ้ฅ */,
0xEC8A /* ้ */, 0xD8BB /* ้ผ */,
0xEC96 /* ้ */, 0xB9AE /* ๅทฉ */,
0xECA0 /* ้ */, 0xE7B4 /* ็ปฑ */,
0xED46 /* ้ฆ */, 0xC7EF /* ็ง */,
0xED5C /* ้ */, 0xE7D6 /* ็ผฐ */,
0xED5E /* ้ */, 0xF7B2 /* ้ */,
0xED61 /* ้ */, 0xC7A7 /* ๅ */,
0xED64 /* ้ */, 0xF7B5 /* ้ฏ */,
0xED66 /* ้ */, 0xCEA4 /* ้ฆ */,
0xED67 /* ้ */, 0xC8CD /* ้ง */,
0xED6E /* ้ */, 0xBAAB /* ้ฉ */,
0xED74 /* ้ */, 0xE8B8 /* ้ช */,
0xED77 /* ้ */, 0xE8BA /* ้ฌ */,
0xED79 /* ้ */, 0xE8B9 /* ้ซ */,
0xED8D /* ้ป */, 0xD4CF /* ้ต */,
0xED91 /* ้ฟ */, 0xCFEC /* ๅ */,
0xED93 /* ้ */, 0xD2B3 /* ้กต */,
0xED94 /* ้ */, 0xB6A5 /* ้กถ */,
0xED95 /* ้ */, 0xC7EA /* ้กท */,
0xED97 /* ้
*/, 0xCFEE /* ้กน */,
0xED98 /* ้ */, 0xCBB3 /* ้กบ */,
0xED99 /* ้ */, 0xF1FC /* ้กธ */,
0xED9A /* ้ */, 0xD0EB /* ้กป */,
0xED9C /* ้ */, 0xE7EF /* ้กผ */,
0xED9E /* ้ */, 0xCBCC /* ้ข */,
0xEDA0 /* ้ */, 0xF1FD /* ้ข */,
0xEE40 /* ้ */, 0xF1FE /* ้ข */,
0xEE41 /* ้ */, 0xD4A4 /* ้ข */,
0xEE42 /* ้ */, 0xCDE7 /* ้กฝ */,
0xEE43 /* ้ */, 0xB0E4 /* ้ข */,
0xEE44 /* ้ */, 0xB6D9 /* ้กฟ */,
0xEE48 /* ้ */, 0xC6C4 /* ้ข */,
0xEE49 /* ้ */, 0xC1EC /* ้ข */,
0xEE4D /* ้ */, 0xF2A2 /* ้ข */,
0xEE52 /* ้ ก */, 0xF2A1 /* ้ข */,
0xEE55 /* ้ ค */, 0xD2C3 /* ้ข */,
0xEE57 /* ้ ฆ */, 0xF2A4 /* ้ข */,
0xEE5C /* ้ ซ */, 0xB8A9 /* ไฟฏ */,
0xEE5E /* ้ ญ */, 0xCDB7 /* ๅคด */,
0xEE61 /* ้ ฐ */, 0xBCD5 /* ้ข */,
0xEE68 /* ้ ท */, 0xF2A5 /* ้ข */,
0xEE69 /* ้ ธ */, 0xBEB1 /* ้ข */,
0xEE6A /* ้ น */, 0xCDC7 /* ้ข */,
0xEE6C /* ้ ป */, 0xC6B5 /* ้ข */,
0xEE77 /* ้ก */, 0xBFC5 /* ้ข */,
0xEE7D /* ้ก */, 0xCCE2 /* ้ข */,
0xEE7E /* ้ก */, 0xB6EE /* ้ข */,
0xEE80 /* ้ก */, 0xF2A6 /* ้ข */,
0xEE81 /* ้ก */, 0xD1D5 /* ้ข */,
0xEE85 /* ้ก */, 0xF2A7 /* ้ข */,
0xEE8A /* ้ก */, 0xD4B8 /* ๆฟ */,
0xEE8B /* ้ก */, 0xF2AA /* ้ขก */,
0xEE8D /* ้ก */, 0xB5DF /* ้ข */,
0xEE90 /* ้ก */, 0xC0E0 /* ็ฑป */,
0xEE94 /* ้กข */, 0xF2A9 /* ้ข */,
0xEE97 /* ้กฅ */, 0xF2AB /* ้ขข */,
0xEE99 /* ้กง */, 0xB9CB /* ้กพ */,
0xEE9D /* ้กซ */, 0xB2FC /* ้ขค */,
0xEF40 /* ้กฏ */, 0xCFD4 /* ๆพ */,
0xEF41 /* ้กฐ */, 0xF2AD /* ้ขฆ */,
0xEF42 /* ้กฑ */, 0xC2AD /* ้ข
*/,
0xEF44 /* ้กณ */, 0xF2A8 /* ้ข */,
0xEF45 /* ้กด */, 0xC8A7 /* ้ขง */,
0xEF4C /* ้ขจ */, 0xB7E7 /* ้ฃ */,
0xEF52 /* ้ขฎ */, 0xECA9 /* ้ฃ */,
0xEF53 /* ้ขฏ */, 0xECAA /* ้ฃ */,
0xEF55 /* ้ขฑ */, 0xCCA8 /* ๅฐ */,
0xEF57 /* ้ขณ */, 0xB9CE /* ๅฎ */,
0xEF5A /* ้ขถ */, 0xECAB /* ้ฃ */,
0xEF5E /* ้ขบ */, 0xD1EF /* ๆฌ */,
0xEF60 /* ้ขผ */, 0xECAC /* ้ฃ */,
0xEF63 /* ้ขฟ */, 0xB7AB /* ๅธ */,
0xEF64 /* ้ฃ */, 0xE5DE /* ้ */,
0xEF68 /* ้ฃ */, 0xC6AE /* ้ฃ */,
0xEF6A /* ้ฃ */, 0xECAD /* ้ฃ */,
0xEF77 /* ้ฃ */, 0xB7C9 /* ้ฃ */,
0xEF7C /* ้ฃข */, 0xBCA2 /* ้ฅฅ */,
0xEF82 /* ้ฃฉ */, 0xE2BD /* ้ฅจ */,
0xEF83 /* ้ฃช */, 0xE2BF /* ้ฅช */,
0xEF84 /* ้ฃซ */, 0xE2C0 /* ้ฅซ */,
0xEF86 /* ้ฃญ */, 0xE2C1 /* ้ฅฌ */,
0xEF88 /* ้ฃฏ */, 0xB7B9 /* ้ฅญ */,
0xEF8B /* ้ฃฒ */, 0xD2FB /* ้ฅฎ */,
0xEF8D /* ้ฃด */, 0xE2C2 /* ้ฅด */,
0xEF95 /* ้ฃผ */, 0xCBC7 /* ้ฅฒ */,
0xEF96 /* ้ฃฝ */, 0xB1A5 /* ้ฅฑ */,
0xEF97 /* ้ฃพ */, 0xCACE /* ้ฅฐ */,
0xEF9C /* ้ค */, 0xBDC8 /* ้ฅบ */,
0xEF9E /* ้ค
*/, 0xB1FD /* ้ฅผ */,
0xF041 /* ้ค */, 0xE2C3 /* ้ฅท */,
0xF042 /* ้ค */, 0xD1F8 /* ๅ
ป */,
0xF044 /* ้ค */, 0xB6FC /* ้ฅต */,
0xF047 /* ้ค */, 0xE2C4 /* ้ฅฝ */,
0xF048 /* ้ค */, 0xC4D9 /* ้ฆ */,
0xF049 /* ้ค */, 0xB6F6 /* ้ฅฟ */,
0xF04E /* ้ค */, 0xD3E0 /* ไฝ */,
0xF050 /* ้ค */, 0xEBC8 /* ่ด */,
0xF051 /* ้ค */, 0xE2C6 /* ้ฆ */,
0xF054 /* ้ค */, 0xBDA4 /* ้ฅฏ */,
0xF057 /* ้คก */, 0xCFDA /* ้ฆ
*/,
0xF05D /* ้คง */, 0xCEB9 /* ๅ */,
0xF05E /* ้คจ */, 0xB9DD /* ้ฆ */,
0xF062 /* ้คฌ */, 0xBAFD /* ็ณ */,
0xF068 /* ้คณ */, 0xE2BC /* ้ฅง */,
0xF06A /* ้คต */, 0xCEB9 /* ๅ */,
0xF071 /* ้คผ */, 0xE2BE /* ้ฅฉ */,
0xF072 /* ้คฝ */, 0xC0A1 /* ้ฆ */,
0xF073 /* ้คพ */, 0xC1F3 /* ้ฆ */,
0xF074 /* ้คฟ */, 0xE2C8 /* ้ฆ */,
0xF078 /* ้ฅ */, 0xE2C9 /* ้ฆ */,
0xF07A /* ้ฅ
*/, 0xC2F8 /* ้ฆ */,
0xF07D /* ้ฅ */, 0xE2CA /* ้ฆ */,
0xF07E /* ้ฅ */, 0xE2CB /* ้ฆ */,
0xF081 /* ้ฅ */, 0xC0A1 /* ้ฆ */,
0xF082 /* ้ฅ */, 0xE2CD /* ้ฆ */,
0xF087 /* ้ฅ */, 0xBCA2 /* ้ฅฅ */,
0xF088 /* ้ฅ */, 0xC8C4 /* ้ฅถ */,
0xF08B /* ้ฅ */, 0xF7CF /* ้ฃจ */,
0xF090 /* ้ฅ */, 0xF7D0 /* ้ค */,
0xF092 /* ้ฅ */, 0xB2F6 /* ้ฆ */,
0xF152 /* ้ฆฌ */, 0xC2ED /* ้ฉฌ */,
0xF153 /* ้ฆญ */, 0xD4A6 /* ้ฉญ */,
0xF154 /* ้ฆฎ */, 0xB7EB /* ๅฏ */,
0xF157 /* ้ฆฑ */, 0xCDD4 /* ้ฉฎ */,
0xF159 /* ้ฆณ */, 0xB3DB /* ้ฉฐ */,
0xF15A /* ้ฆด */, 0xD1B1 /* ้ฉฏ */,
0xF167 /* ้ง */, 0xB2B5 /* ้ฉณ */,
0xF176 /* ้ง */, 0xD7A4 /* ้ฉป */,
0xF177 /* ้ง */, 0xE6E5 /* ้ฉฝ */,
0xF178 /* ้ง */, 0xBED4 /* ้ฉน */,
0xF17A /* ้ง */, 0xE6E0 /* ้ฉต */,
0xF17B /* ้ง */, 0xBCDD /* ้ฉพ */,
0xF17E /* ้ง */, 0xE6E6 /* ้ช */,
0xF180 /* ้ง */, 0xE6E2 /* ้ฉธ */,
0xF182 /* ้ง */, 0xCABB /* ้ฉถ */,
0xF184 /* ้ง */, 0xCDD5 /* ้ฉผ */,
0xF186 /* ้ง */, 0xE6E1 /* ้ฉท */,
0xF189 /* ้งข */, 0xE6E9 /* ้ช */,
0xF194 /* ้งญ */, 0xBAA7 /* ้ช */,
0xF198 /* ้งฑ */, 0xC2E6 /* ้ช */,
0xF245 /* ้งฟ */, 0xBFA5 /* ้ช */,
0xF247 /* ้จ */, 0xB3D2 /* ้ช */,
0xF249 /* ้จ */, 0xB4F4 /* ๅ */,
0xF24B /* ้จ
*/, 0xE6ED /* ้ช */,
0xF253 /* ้จ */, 0xE6EC /* ้ช */,
0xF254 /* ้จ */, 0xC6EF /* ้ช */,
0xF255 /* ้จ */, 0xE6EB /* ้ช */,
0xF25C /* ้จ */, 0xE6F0 /* ้ช */,
0xF25F /* ้จ */, 0xC6AD /* ้ช */,
0xF269 /* ้จฃ */, 0xD7D7 /* ้ฌ */,
0xF271 /* ้จซ */, 0xE5B9 /* ้ช */,
0xF273 /* ้จญ */, 0xE6EF /* ้ช */,
0xF274 /* ้จฎ */, 0xE6F2 /* ้ช */,
0xF276 /* ้จฐ */, 0xCCDA /* ่
พ */,
0xF27C /* ้จถ */, 0xE6E3 /* ้ฉบ */,
0xF27D /* ้จท */, 0xC9A7 /* ้ช */,
0xF27E /* ้จธ */, 0xE6F3 /* ้ช */,
0xF285 /* ้จพ */, 0xC2E2 /* ้ชก */,
0xF287 /* ้ฉ */, 0xDDEB /* ่ฆ */,
0xF288 /* ้ฉ */, 0xE6F1 /* ้ช */,
0xF289 /* ้ฉ */, 0xE6EE /* ้ช */,
0xF28A /* ้ฉ */, 0xE6F4 /* ้ช */,
0xF28B /* ้ฉ */, 0xE6F5 /* ้ชข */,
0xF28C /* ้ฉ
*/, 0xC7FD /* ้ฉฑ */,
0xF291 /* ้ฉ */, 0xE6E8 /* ้ช
*/,
0xF294 /* ้ฉ */, 0xE6E7 /* ้ช */,
0xF296 /* ้ฉ */, 0xE6F6 /* ้ชฃ */,
0xF29C /* ้ฉ */, 0xBDBE /* ้ช */,
0xF29E /* ้ฉ */, 0xD1E9 /* ้ช */,
0xF340 /* ้ฉ */, 0xBEAA /* ๆ */,
0xF341 /* ้ฉ */, 0xE6E4 /* ้ฉฟ */,
0xF345 /* ้ฉ */, 0xD6E8 /* ้ชค */,
0xF348 /* ้ฉข */, 0xC2BF /* ้ฉด */,
0xF34A /* ้ฉค */, 0xE6F8 /* ้ชง */,
0xF34B /* ้ฉฅ */, 0xE6F7 /* ้ชฅ */,
0xF350 /* ้ฉช */, 0xE6EA /* ้ช */,
0xF361 /* ้ชฏ */, 0xB0B9 /* ่ฎ */,
0xF369 /* ้ชพ */, 0xF6E1 /* ้ฒ */,
0xF374 /* ้ซ */, 0xF7C3 /* ้ซ
*/,
0xF376 /* ้ซ */, 0xD4E0 /* ่ */,
0xF377 /* ้ซ */, 0xCCE5 /* ไฝ */,
0xF378 /* ้ซ */, 0xF7C6 /* ้ซ */,
0xF379 /* ้ซ */, 0xF7C5 /* ้ซ */,
0xF38C /* ้ซฎ */, 0xB7A2 /* ๅ */,
0xF3A0 /* ้ฌ */, 0xCBC9 /* ๆพ */,
0xF445 /* ้ฌ */, 0xBAFA /* ่ก */,
0xF450 /* ้ฌ */, 0xD0EB /* ้กป */,
0xF457 /* ้ฌข */, 0xF7DE /* ้ฌ */,
0xF459 /* ้ฌฅ */, 0xB6B7 /* ๆ */,
0xF45B /* ้ฌง */, 0xC4D6 /* ้น */,
0xF45C /* ้ฌจ */, 0xBAE5 /* ๅ */,
0xF45D /* ้ฌฉ */, 0xE3D2 /* ้ */,
0xF462 /* ้ฌฎ */, 0xE3CE /* ้ */,
0xF464 /* ้ฌฑ */, 0xD3F4 /* ้ */,
0xF475 /* ้ญ */, 0xF7CB /* ้ญ */,
0xF47C /* ้ญ */, 0xF7CA /* ้ญ */,
0xF47E /* ้ญ */, 0xD3E3 /* ้ฑผ */,
0xF494 /* ้ญฏ */, 0xC2B3 /* ้ฒ */,
0xF499 /* ้ญด */, 0xF6D0 /* ้ฒ */,
0xF49C /* ้ญท */, 0xF6CF /* ้ฑฟ */,
0xF554 /* ้ฎ */, 0xF6D8 /* ้ฒ */,
0xF555 /* ้ฎ */, 0xB1AB /* ้ฒ */,
0xF556 /* ้ฎ */, 0xF6D6 /* ้ฒ */,
0xF55E /* ้ฎ */, 0xF6DA /* ้ฒ */,
0xF562 /* ้ฎ */, 0xF6DC /* ้ฒ */,
0xF56E /* ้ฎช */, 0xF6DB /* ้ฒ */,
0xF56F /* ้ฎซ */, 0xF6DE /* ้ฒ */,
0xF571 /* ้ฎญ */, 0xF6D9 /* ้ฒ */,
0xF572 /* ้ฎฎ */, 0xCFCA /* ้ฒ */,
0xF585 /* ้ฏ */, 0xF6E7 /* ้ฒง */,
0xF586 /* ้ฏ */, 0xF6E1 /* ้ฒ */,
0xF58C /* ้ฏ */, 0xF6E9 /* ้ฒฉ */,
0xF58D /* ้ฏ */, 0xF6E6 /* ้ฒฆ */,
0xF58E /* ้ฏ */, 0xC0F0 /* ้ฒค */,
0xF58F /* ้ฏ */, 0xF6E8 /* ้ฒจ */,
0xF599 /* ้ฏ */, 0xF6F6 /* ้ฒป */,
0xF59B /* ้ฏ */, 0xF6EB /* ้ฒญ */,
0xF5A0 /* ้ฏ */, 0xF6F4 /* ้ฒท */,
0xF645 /* ้ฏก */, 0xF6EE /* ้ฒฑ */,
0xF646 /* ้ฏข */, 0xF6F2 /* ้ฒต */,
0xF648 /* ้ฏค */, 0xF6EF /* ้ฒฒ */,
0xF64B /* ้ฏง */, 0xF6F0 /* ้ฒณ */,
0xF64C /* ้ฏจ */, 0xBEA8 /* ้ฒธ */,
0xF64E /* ้ฏช */, 0xF6EC /* ้ฒฎ */,
0xF64F /* ้ฏซ */, 0xF6ED /* ้ฒฐ */,
0xF654 /* ้ฏฐ */, 0xF6F3 /* ้ฒถ */,
0xF661 /* ้ฏฝ */, 0xF6EA /* ้ฒซ */,
0xF66C /* ้ฐ */, 0xF6F8 /* ้ฒฝ */,
0xF66D /* ้ฐ */, 0xF6FC /* ้ณ */,
0xF671 /* ้ฐ */, 0xF6FA /* ้ณ
*/,
0xF676 /* ้ฐ */, 0xF6FB /* ้ณ */,
0xF677 /* ้ฐ */, 0xC8FA /* ้ณ */,
0xF688 /* ้ฐฃ */, 0xF6E5 /* ้ฒฅ */,
0xF68A /* ้ฐฅ */, 0xF7A4 /* ้ณ */,
0xF68D /* ้ฐจ */, 0xF7A3 /* ้ณ */,
0xF68E /* ้ฐฉ */, 0xF7A5 /* ้ณ */,
0xF692 /* ้ฐญ */, 0xF7A2 /* ้ณ */,
0xF696 /* ้ฐฑ */, 0xF6E3 /* ้ฒข */,
0xF697 /* ้ฐฒ */, 0xF7A1 /* ้ณ */,
0xF698 /* ้ฐณ */, 0xF7A6 /* ้ณ */,
0xF69C /* ้ฐท */, 0xF6E6 /* ้ฒฆ */,
0xF69E /* ้ฐน */, 0xF6E4 /* ้ฒฃ */,
0xF6A0 /* ้ฐป */, 0xF7A9 /* ้ณ */,
0xF742 /* ้ฐพ */, 0xF7A7 /* ้ณ */,
0xF74C /* ้ฑ */, 0xF7A8 /* ้ณ */,
0xF74D /* ้ฑ */, 0xB1EE /* ้ณ */,
0xF756 /* ้ฑ */, 0xF7AE /* ้ณ */,
0xF758 /* ้ฑ */, 0xF7AD /* ้ณ */,
0xF75A /* ้ฑ */, 0xF7AC /* ้ณ */,
0xF75B /* ้ฑ */, 0xC1DB /* ้ณ */,
0xF75C /* ้ฑ */, 0xF6E0 /* ้ฒ */,
0xF763 /* ้ฑ */, 0xF6D7 /* ้ฒ */,
0xF76B /* ้ฑง */, 0xF7AF /* ้ณข */,
0xF771 /* ้ฑญ */, 0xF6DD /* ้ฒ */,
0xF77B /* ้ฑท */, 0xF6F9 /* ้ณ */,
0xF77C /* ้ฑธ */, 0xF6D4 /* ้ฒ */,
0xF77E /* ้ฑบ */, 0xF6E2 /* ้ฒก */,
0xF842 /* ้ณฅ */, 0xC4F1 /* ้ธ */,
0xF844 /* ้ณง */, 0xD9EC /* ๅซ */,
0xF846 /* ้ณฉ */, 0xF0AF /* ้ธ */,
0xF850 /* ้ณณ */, 0xB7EF /* ๅค */,
0xF851 /* ้ณด */, 0xC3F9 /* ้ธฃ */,
0xF853 /* ้ณถ */, 0xF0B0 /* ้ธข */,
0xF863 /* ้ด */, 0xF0B2 /* ้ธฉ */,
0xF864 /* ้ด */, 0xF0B1 /* ้ธจ */,
0xF865 /* ้ด */, 0xD1E3 /* ้ */,
0xF866 /* ้ด */, 0xD1BB /* ้ธฆ */,
0xF872 /* ้ด */, 0xCDD2 /* ้ธต */,
0xF878 /* ้ด */, 0xD4A7 /* ้ธณ */,
0xF87A /* ้ด */, 0xF0B6 /* ้ธฒ */,
0xF87C /* ้ด */, 0xF0B7 /* ้ธฑ */,
0xF881 /* ้ดฃ */, 0xF0B3 /* ้ธช */,
0xF884 /* ้ดฆ */, 0xD1EC /* ้ธฏ */,
0xF886 /* ้ดจ */, 0xD1BC /* ้ธญ */,
0xF88D /* ้ดฏ */, 0xF0B9 /* ้ธธ */,
0xF88E /* ้ดฐ */, 0xF0BB /* ้ธน */,
0xF899 /* ้ดป */, 0xBAE8 /* ้ธฟ */,
0xF89D /* ้ดฟ */, 0xB8EB /* ้ธฝ */,
0xF8A0 /* ้ต */, 0xF0BC /* ้ธบ */,
0xF94E /* ้ต */, 0xBEE9 /* ้น */,
0xF94F /* ้ต */, 0xF0C1 /* ้น */,
0xF950 /* ้ต */, 0xF0BE /* ้น */,
0xF959 /* ้ต */, 0xF0C3 /* ้น */,
0xF95A /* ้ต */, 0xB6EC /* ้น
*/,
0xF95D /* ้ต */, 0xF0C0 /* ้น */,
0xF95E /* ้ตก */, 0xF0C4 /* ้น */,
0xF967 /* ้ตช */, 0xF0C6 /* ้น */,
0xF969 /* ้ตฌ */, 0xC5F4 /* ้น */,
0xF96C /* ้ตฏ */, 0xF0C7 /* ้น */,
0xF96D /* ้ตฐ */, 0xB5F1 /* ้ */,
0xF96F /* ้ตฒ */, 0xC8B5 /* ้น */,
0xF985 /* ้ถ */, 0xF0B4 /* ้ธซ */,
0xF987 /* ้ถ */, 0xF0C8 /* ้น */,
0xF996 /* ้ถ */, 0xF0C9 /* ้น */,
0xF998 /* ้ถ */, 0xF0CA /* ้น */,
0xFA46 /* ้ถฉ */, 0xF0CD /* ้น */,
0xFA4C /* ้ถฏ */, 0xDDBA /* ่บ */,
0xFA4E /* ้ถฑ */, 0xE5B9 /* ้ช */,
0xFA51 /* ้ถด */, 0xBAD7 /* ้นค */,
0xFA58 /* ้ถป */, 0xF7BD /* ้น */,
0xFA59 /* ้ถผ */, 0xF0CF /* ้นฃ */,
0xFA5C /* ้ถฟ */, 0xF0CB /* ้น */,
0xFA5F /* ้ท */, 0xF0CE /* ้น */,
0xFA70 /* ้ท */, 0xF0D1 /* ้นง */,
0xFA74 /* ้ท */, 0xC5B8 /* ้ธฅ */,
0xFA76 /* ้ท */, 0xF0BA /* ้ธท */,
0xFA77 /* ้ท */, 0xF0D2 /* ้นจ */,
0xFA83 /* ้ทฅ */, 0xF0B8 /* ้ธถ */,
0xFA84 /* ้ทฆ */, 0xF0D4 /* ้นช */,
0xFA8D /* ้ทฏ */, 0xF0D3 /* ้นฉ */,
0xFA90 /* ้ทฒ */, 0xF0D5 /* ้นซ */,
0xFA91 /* ้ทณ */, 0xF0C2 /* ้น */,
0xFA92 /* ้ทด */, 0xF0C2 /* ้น */,
0xFA96 /* ้ทธ */, 0xF0D6 /* ้นฌ */,
0xFA97 /* ้ทน */, 0xD3A5 /* ้นฐ */,
0xFA98 /* ้ทบ */, 0xF0D8 /* ้นญ */,
0xFB52 /* ้ธ */, 0xF0B5 /* ้ธฌ */,
0xFB57 /* ้ธ */, 0xF0D0 /* ้นฆ */,
0xFB58 /* ้ธ */, 0xF0D9 /* ้นณ */,
0xFB5A /* ้ธ */, 0xF0BF /* ้น */,
0xFB5B /* ้ธ */, 0xF0BD /* ้ธพ */,
0xFB75 /* ้นต */, 0xC2B1 /* ๅค */,
0xFB79 /* ้นน */, 0xCFCC /* ๅธ */,
0xFB7A /* ้นบ */, 0xF5BA /* ้นพ */,
0xFB7C /* ้นผ */, 0xBCEE /* ็ขฑ */,
0xFB7D /* ้นฝ */, 0xD1CE /* ็ */,
0xFB90 /* ้บ */, 0xC0F6 /* ไธฝ */,
0xFB9B /* ้บค */, 0xB4D6 /* ็ฒ */,
0xFB9C /* ้บฅ */, 0xC2F3 /* ้บฆ */,
0xFB9F /* ้บฉ */, 0xF4EF /* ้บธ */,
0xFC49 /* ้บต */, 0xC3E6 /* ้ข */,
0xFC4E /* ้บผ */, 0xC3B4 /* ไน */,
0xFC53 /* ้ป */, 0xBBC6 /* ้ป */,
0xFC5A /* ้ป */, 0xD9E4 /* ้ป */,
0xFC63 /* ้ป */, 0xB5E3 /* ็น */,
0xFC68 /* ้ปจ */, 0xB5B3 /* ๅ
*/,
0xFC6F /* ้ปฒ */, 0xF7F5 /* ้ปช */,
0xFC71 /* ้ปด */, 0xC3B9 /* ้ */,
0xFC74 /* ้ปท */, 0xF7F2 /* ้ปฉ */,
0xFC77 /* ้ปฝ */, 0xF6BC /* ้ปพ */,
0xFC78 /* ้ปฟ */, 0xF6BD /* ้ผ */,
0xFC81 /* ้ผ */, 0xF7A1 /* ้ณ */,
0xFC83 /* ้ผ */, 0xF6BE /* ้ผ */,
0xFC8A /* ้ผ */, 0xB6AC /* ๅฌ */,
0xFD42 /* ้ผด */, 0xF7FA /* ้ผน */,
0xFD52 /* ้ฝ */, 0xC6EB /* ้ฝ */,
0xFD53 /* ้ฝ */, 0xD5AB /* ๆ */,
0xFD57 /* ้ฝ */, 0xECB4 /* ้ฝ */,
0xFD58 /* ้ฝ */, 0xB3DD /* ้ฝฟ */,
0xFD5A /* ้ฝ */, 0xF6B3 /* ้พ */,
0xFD5F /* ้ฝ */, 0xF6B5 /* ้พ
*/,
0xFD62 /* ้ฝ */, 0xF6B7 /* ้พ */,
0xFD65 /* ้ฝ */, 0xF6B4 /* ้พ */,
0xFD66 /* ้ฝ */, 0xF6B6 /* ้พ */,
0xFD67 /* ้ฝก */, 0xC1E4 /* ้พ */,
0xFD69 /* ้ฝฃ */, 0xB3F6 /* ๅบ */,
0xFD6C /* ้ฝฆ */, 0xF6B8 /* ้พ */,
0xFD6D /* ้ฝง */, 0xC4F6 /* ๅฎ */,
0xFD70 /* ้ฝช */, 0xF6BA /* ้พ */,
0xFD72 /* ้ฝฌ */, 0xF6B9 /* ้พ */,
0xFD78 /* ้ฝฒ */, 0xC8A3 /* ้พ */,
0xFD7C /* ้ฝถ */, 0xEBF1 /* ่
ญ */,
0xFD7D /* ้ฝท */, 0xF6BB /* ้พ */,
0xFD88 /* ้พ */, 0xC1FA /* ้พ */,
0xFD8B /* ้พ */, 0xC5D3 /* ๅบ */,
0xFD8F /* ้พ */, 0xB9A8 /* ้พ */,
0xFD90 /* ้พ */, 0xEDE8 /* ้พ */,
0xFD94 /* ้พ */, 0xB9EA /* ้พ */,
0xFD98 /* ้พข */, 0xBACD /* ๅ */, // }}}
};
static const unsigned short _gbk2utf16_2[] =
{
0x8140, 0x4E02, // {{{
0x8144, 0x4E0F,
0x8145, 0x4E12,
0x8146, 0x4E17,
0x814A, 0x4E23,
0x814B, 0x4E26,
0x814C, 0x4E29,
0x814F, 0x4E31,
0x8150, 0x4E33,
0x8151, 0x4E35,
0x8152, 0x4E37,
0x8153, 0x4E3C,
0x8157, 0x4E44,
0x8158, 0x4E46,
0x8159, 0x4E4A,
0x815A, 0x4E51,
0x815B, 0x4E55,
0x815C, 0x4E57,
0x816B, 0x4E72,
0x817D, 0x4E87,
0x817E, 0x4E8A,
0x8180, 0x4E90,
0x8183, 0x4E99,
0x8187, 0x4EA3,
0x8188, 0x4EAA,
0x818C, 0x4EB4,
0x8194, 0x4EC8,
0x8195, 0x4ECC,
0x8198, 0x4ED2,
0x819C, 0x4EE0,
0x819D, 0x4EE2,
0x81A0, 0x4EE9,
0x81A4, 0x4EF1,
0x81A5, 0x4EF4,
0x81A9, 0x4EFC,
0x81AA, 0x4EFE,
0x81AB, 0x4F00,
0x81BC, 0x4F21,
0x81BD, 0x4F23,
0x81C3, 0x4F31,
0x81C4, 0x4F33,
0x81C5, 0x4F35,
0x81C6, 0x4F37,
0x81C7, 0x4F39,
0x81C8, 0x4F3B,
0x81D6, 0x4F52,
0x81D7, 0x4F54,
0x81D8, 0x4F56,
0x81DB, 0x4F66,
0x81DC, 0x4F68,
0x81E3, 0x4F75,
0x81E8, 0x4F7D,
0x81EF, 0x4F8A,
0x81F0, 0x4F8C,
0x81F1, 0x4F8E,
0x81F2, 0x4F90,
0x81FA, 0x4F9C,
0x8240, 0x4FA4,
0x8241, 0x4FAB,
0x8242, 0x4FAD,
0x8260, 0x4FD9,
0x8261, 0x4FDB,
0x8262, 0x4FE0,
0x8263, 0x4FE2,
0x8266, 0x4FE7,
0x8269, 0x4FF0,
0x826A, 0x4FF2,
0x826F, 0x4FF9,
0x8280, 0x500B,
0x8281, 0x500E,
0x8284, 0x5013,
0x8288, 0x501B,
0x828B, 0x5020,
0x828F, 0x5027,
0x8290, 0x502B,
0x829C, 0x503B,
0x829D, 0x503D,
0x82A8, 0x504D,
0x82B2, 0x505B,
0x82EE, 0x50A4,
0x82EF, 0x50A6,
0x82FE, 0x50BC,
0x836E, 0x50F4,
0x837E, 0x5108,
0x83B3, 0x5142,
0x83B4, 0x5147,
0x83B5, 0x514A,
0x83B6, 0x514C,
0x83BF, 0x515B,
0x83CB, 0x516F,
0x83CC, 0x5172,
0x83CD, 0x517A,
0x83DC, 0x5198,
0x83DD, 0x519A,
0x83E1, 0x51A1,
0x83E2, 0x51A3,
0x83EA, 0x51B4,
0x83F3, 0x51C5,
0x83F4, 0x51C8,
0x83F5, 0x51CA,
0x83F8, 0x51D0,
0x8443, 0x51DC,
0x844E, 0x51EC,
0x844F, 0x51EE,
0x8452, 0x51F4,
0x8453, 0x51F7,
0x8454, 0x51FE,
0x8457, 0x5209,
0x845F, 0x521C,
0x8468, 0x522A,
0x8469, 0x522C,
0x846A, 0x522F,
0x846F, 0x523C,
0x8470, 0x523E,
0x8477, 0x524B,
0x847C, 0x5255,
0x8483, 0x525D,
0x8489, 0x5266,
0x848A, 0x5268,
0x849B, 0x527E,
0x849C, 0x5280,
0x84B2, 0x529C,
0x84CA, 0x52C8,
0x84CB, 0x52CA,
0x84D0, 0x52D1,
0x84D4, 0x52D7,
0x84F9, 0x5307,
0x84FE, 0x530E,
0x8544, 0x5318,
0x8549, 0x5322,
0x855E, 0x5340,
0x855F, 0x5342,
0x8560, 0x5344,
0x8561, 0x5346,
0x8565, 0x5350,
0x8566, 0x5354,
0x8569, 0x535B,
0x856A, 0x535D,
0x856B, 0x5365,
0x856C, 0x5368,
0x856D, 0x536A,
0x8570, 0x5372,
0x8571, 0x5376,
0x8572, 0x5379,
0x8579, 0x5383,
0x857C, 0x538A,
0x8587, 0x5399,
0x858A, 0x539E,
0x858D, 0x53A4,
0x858E, 0x53A7,
0x85A1, 0x53C0,
0x85AC, 0x53D5,
0x85AD, 0x53DA,
0x85B3, 0x53E7,
0x85B4, 0x53F4,
0x85B5, 0x53FA,
0x85B9, 0x5402,
0x85BA, 0x5405,
0x85BB, 0x5407,
0x85BC, 0x540B,
0x85BD, 0x5414,
0x85C1, 0x541C,
0x85C2, 0x5422,
0x85C5, 0x542A,
0x85C6, 0x5430,
0x85C7, 0x5433,
0x85CA, 0x543A,
0x85CB, 0x543D,
0x85CC, 0x543F,
0x85D1, 0x5447,
0x85D2, 0x5449,
0x85D7, 0x5451,
0x85D8, 0x545A,
0x85DE, 0x5463,
0x85DF, 0x5465,
0x85E0, 0x5467,
0x85E9, 0x5474,
0x85EE, 0x5481,
0x85EF, 0x5483,
0x85F0, 0x5485,
0x85F5, 0x548D,
0x85F6, 0x5491,
0x85F7, 0x5493,
0x85FA, 0x549C,
0x8640, 0x54A2,
0x8641, 0x54A5,
0x8642, 0x54AE,
0x8643, 0x54B0,
0x8644, 0x54B2,
0x864A, 0x54BC,
0x864B, 0x54BE,
0x864C, 0x54C3,
0x864D, 0x54C5,
0x8650, 0x54D6,
0x8651, 0x54D8,
0x8652, 0x54DB,
0x8663, 0x54FB,
0x8664, 0x54FE,
0x8665, 0x5500,
0x866A, 0x5508,
0x867C, 0x5521,
0x8682, 0x552B,
0x8683, 0x552D,
0x8684, 0x5532,
0x868C, 0x553D,
0x868D, 0x5540,
0x868E, 0x5542,
0x868F, 0x5545,
0x86A8, 0x556B,
0x86B1, 0x557D,
0x86B2, 0x557F,
0x86B8, 0x5590,
0x86C0, 0x559E,
0x86D1, 0x55B2,
0x86D2, 0x55B4,
0x86D3, 0x55B6,
0x86D4, 0x55B8,
0x86D5, 0x55BA,
0x86D6, 0x55BC,
0x86E4, 0x55D5,
0x86EA, 0x55DE,
0x86EB, 0x55E0,
0x86EC, 0x55E2,
0x86ED, 0x55E7,
0x86EE, 0x55E9,
0x86F3, 0x55F4,
0x86F4, 0x55F6,
0x86FA, 0x55FF,
0x8744, 0x560D,
0x875D, 0x5633,
0x875E, 0x5635,
0x8761, 0x563A,
0x8780, 0x5663,
0x87E1, 0x56DC,
0x87E2, 0x56E3,
0x87E9, 0x56EC,
0x87F6, 0x5705,
0x87F7, 0x5707,
0x8853, 0x572B,
0x885D, 0x573F,
0x885E, 0x5741,
0x8865, 0x574B,
0x886F, 0x5765,
0x8870, 0x5767,
0x8871, 0x576C,
0x8872, 0x576E,
0x8880, 0x5781,
0x8895, 0x57A5,
0x8896, 0x57A8,
0x8897, 0x57AA,
0x8898, 0x57AC,
0x889C, 0x57B3,
0x88B4, 0x57D3,
0x88B9, 0x57DE,
0x88C5, 0x57EE,
0x88D1, 0x5801,
0x88D8, 0x580C,
0x88E6, 0x581F,
0x8976, 0x587F,
0x8977, 0x5882,
0x8978, 0x5884,
0x89D0, 0x58ED,
0x89D1, 0x58EF,
0x89E0, 0x5903,
0x89E8, 0x590E,
0x89EF, 0x591B,
0x89F6, 0x5926,
0x89F7, 0x5928,
0x89F8, 0x592C,
0x89F9, 0x5930,
0x89FE, 0x593B,
0x8A44, 0x5943,
0x8A47, 0x594A,
0x8A4A, 0x5950,
0x8A4D, 0x5959,
0x8A53, 0x5961,
0x8A63, 0x5975,
0x8A64, 0x5977,
0x8A6B, 0x5985,
0x8A6C, 0x5989,
0x8A75, 0x5998,
0x8A7E, 0x59A6,
0x8A80, 0x59A7,
0x8A8B, 0x59BA,
0x8A9E, 0x59D9,
0x8A9F, 0x59DB,
0x8AA5, 0x59E4,
0x8AB7, 0x59FA,
0x8ABB, 0x5A00,
0x8ABC, 0x5A02,
0x8AC3, 0x5A12,
0x8ACF, 0x5A24,
0x8ADA, 0x5A33,
0x8ADB, 0x5A35,
0x8B40, 0x5A61,
0x8B85, 0x5AB4,
0x8B9C, 0x5AD3,
0x8B9D, 0x5AD5,
0x8B9E, 0x5AD7,
0x8BA5, 0x5AE2,
0x8BAA, 0x5AEA,
0x8BED, 0x5B33,
0x8C48, 0x5B52,
0x8C49, 0x5B56,
0x8C4A, 0x5B5E,
0x8C4F, 0x5B6B,
0x8C53, 0x5B72,
0x8C54, 0x5B74,
0x8C5D, 0x5B82,
0x8C5E, 0x5B86,
0x8C5F, 0x5B8A,
0x8C65, 0x5B94,
0x8C66, 0x5B96,
0x8C67, 0x5B9F,
0x8C71, 0x5BB7,
0x8C77, 0x5BC3,
0x8C80, 0x5BD1,
0x8C8A, 0x5BE0,
0x8C94, 0x5BEF,
0x8C9E, 0x5C00,
0x8CA1, 0x5C05,
0x8CA8, 0x5C10,
0x8CAB, 0x5C17,
0x8CAC, 0x5C19,
0x8CAD, 0x5C1B,
0x8CB2, 0x5C23,
0x8CB3, 0x5C26,
0x8CD1, 0x5C5F,
0x8CD2, 0x5C62,
0x8CD3, 0x5C64,
0x8CDB, 0x5C70,
0x8CE7, 0x5C80,
0x8CF4, 0x5C95,
0x8D40, 0x5CAA,
0x8D44, 0x5CB2,
0x8D45, 0x5CB4,
0x8D46, 0x5CB6,
0x8D4B, 0x5CBE,
0x8D4C, 0x5CC0,
0x8D6A, 0x5CE7,
0x8D6B, 0x5CE9,
0x8D80, 0x5D01,
0x8D8E, 0x5D15,
0x8D9A, 0x5D25,
0x8D9B, 0x5D28,
0x8DC3, 0x5D5C,
0x8DCF, 0x5D6A,
0x8E77, 0x5DDC,
0x8E7C, 0x5DEA,
0x8E80, 0x5DF0,
0x8E8A, 0x5E04,
0x8E8B, 0x5E07,
0x8E93, 0x5E17,
0x8EAE, 0x5E43,
0x8ED4, 0x5E75,
0x8ED5, 0x5E77,
0x8ED6, 0x5E79,
0x8ED7, 0x5E7E,
0x8EDB, 0x5E85,
0x8EE1, 0x5E92,
0x8EE2, 0x5E98,
0x8EE3, 0x5E9B,
0x8EE4, 0x5E9D,
0x8EF3, 0x5EB4,
0x8F5B, 0x5EE9,
0x8F65, 0x5EF5,
0x8F6E, 0x5F09,
0x8F72, 0x5F10,
0x8F73, 0x5F12,
0x8F74, 0x5F14,
0x8F75, 0x5F16,
0x8F80, 0x5F28,
0x8F83, 0x5F2E,
0x8F84, 0x5F30,
0x8F8C, 0x5F3B,
0x8F9F, 0x5F51,
0x8FA0, 0x5F54,
0x8FA8, 0x5F63,
0x8FA9, 0x5F65,
0x8FAC, 0x5F6B,
0x8FAF, 0x5F72,
0x8FB3, 0x5F78,
0x8FB4, 0x5F7A,
0x8FB8, 0x5F83,
0x8FB9, 0x5F86,
0x8FBD, 0x5F91,
0x8FC0, 0x5F96,
0x8FCD, 0x5FA9,
0x8FD6, 0x5FB6,
0x8FE4, 0x5FCE,
0x8FF3, 0x5FEC,
0x8FFD, 0x5FFC,
0x8FFE, 0x6007,
0x9046, 0x6013,
0x9049, 0x601A,
0x905E, 0x6040,
0x9066, 0x604C,
0x9069, 0x6051,
0x9077, 0x606E,
0x907C, 0x6077,
0x907D, 0x607E,
0x907E, 0x6080,
0x908C, 0x6093,
0x908D, 0x6095,
0x9091, 0x609C,
0x9092, 0x609E,
0x9097, 0x60A7,
0x909A, 0x60AE,
0x909B, 0x60B0,
0x909C, 0x60B3,
0x90B7, 0x60D9,
0x90B8, 0x60DB,
0x90B9, 0x60DE,
0x90BF, 0x60EA,
0x90C2, 0x60F5,
0x90CE, 0x6107,
0x90E1, 0x6125,
0x9140, 0x6147,
0x9141, 0x6149,
0x9142, 0x614B,
0x9143, 0x614D,
0x9163, 0x6176,
0x917E, 0x6195,
0x91AA, 0x61C9,
0x91B0, 0x61D3,
0x91DF, 0x6207,
0x91E0, 0x6209,
0x91E3, 0x6219,
0x91E7, 0x6220,
0x91E8, 0x6223,
0x91ED, 0x622B,
0x91EE, 0x622D,
0x91FA, 0x6242,
0x91FE, 0x624A,
0x9250, 0x6268,
0x9259, 0x627D,
0x9267, 0x6294,
0x9268, 0x6299,
0x926C, 0x62A3,
0x927B, 0x62BA,
0x927C, 0x62BE,
0x9280, 0x62C3,
0x9281, 0x62CB,
0x9282, 0x62CF,
0x9283, 0x62D1,
0x9284, 0x62D5,
0x9289, 0x62E4,
0x928C, 0x62F0,
0x928D, 0x62F2,
0x928E, 0x62F5,
0x9293, 0x6300,
0x92A5, 0x631C,
0x92A8, 0x6329,
0x92BA, 0x6344,
0x92BD, 0x634A,
0x92CA, 0x6360,
0x92CE, 0x6368,
0x92DE, 0x6381,
0x92E3, 0x638B,
0x92E4, 0x638D,
0x92E5, 0x6391,
0x92E9, 0x6397,
0x92F1, 0x63A1,
0x92F2, 0x63A4,
0x92F3, 0x63A6,
0x92F4, 0x63AB,
0x92F5, 0x63AF,
0x92FA, 0x63B9,
0x92FB, 0x63BB,
0x92FC, 0x63BD,
0x9343, 0x63C5,
0x9349, 0x63D1,
0x9354, 0x63DF,
0x9355, 0x63E2,
0x9361, 0x63F3,
0x9362, 0x63F5,
0x9363, 0x63F7,
0x9368, 0x63FE,
0x937A, 0x641D,
0x937B, 0x641F,
0x9380, 0x6425,
0x9384, 0x642B,
0x9392, 0x643E,
0x9393, 0x6440,
0x9396, 0x6449,
0x939E, 0x6453,
0x93AF, 0x6468,
0x93C4, 0x6483,
0x93C5, 0x6486,
0x93E2, 0x64AF,
0x93E7, 0x64B6,
0x93E8, 0x64B9,
0x93E9, 0x64BB,
0x93ED, 0x64C1,
0x93F7, 0x64CF,
0x93F8, 0x64D1,
0x9446, 0x64E3,
0x9447, 0x64E5,
0x948E, 0x6537,
0x948F, 0x653A,
0x949D, 0x6550,
0x94A3, 0x655A,
0x94A4, 0x655C,
0x94B1, 0x6571,
0x94B2, 0x6573,
0x94CA, 0x6592,
0x94CE, 0x6598,
0x94CF, 0x659A,
0x94D2, 0x65A0,
0x94D5, 0x65A6,
0x94D6, 0x65A8,
0x94D7, 0x65AA,
0x94D8, 0x65AC,
0x94D9, 0x65AE,
0x94E7, 0x65C2,
0x94EC, 0x65CD,
0x94FA, 0x65E1,
0x954B, 0x6601,
0x9551, 0x660B,
0x9552, 0x660D,
0x955C, 0x661E,
0x9561, 0x6626,
0x9566, 0x662E,
0x9567, 0x6630,
0x956F, 0x663D,
0x9572, 0x6642,
0x957E, 0x6658,
0x9580, 0x6659,
0x9585, 0x6660,
0x9588, 0x6665,
0x9589, 0x6667,
0x9592, 0x6675,
0x959B, 0x6683,
0x95E4, 0x66DA,
0x95F5, 0x66F1,
0x95F8, 0x66F8,
0x95FB, 0x66FD,
0x9644, 0x670C,
0x964A, 0x6716,
0x964E, 0x671C,
0x964F, 0x671E,
0x9656, 0x6727,
0x9657, 0x6729,
0x9658, 0x672E,
0x9659, 0x6730,
0x9664, 0x6741,
0x9667, 0x6747,
0x966A, 0x674D,
0x966B, 0x6752,
0x9673, 0x675D,
0x967B, 0x676E,
0x967C, 0x6771,
0x967D, 0x6774,
0x967E, 0x6776,
0x9684, 0x677D,
0x9685, 0x6780,
0x968A, 0x6788,
0x968B, 0x678A,
0x9694, 0x6796,
0x9695, 0x6799,
0x9696, 0x679B,
0x969A, 0x67A4,
0x969B, 0x67A6,
0x969C, 0x67A9,
0x969D, 0x67AC,
0x969E, 0x67AE,
0x96A1, 0x67B4,
0x96AA, 0x67C2,
0x96B8, 0x67DB,
0x96B9, 0x67DF,
0x96BA, 0x67E1,
0x96C4, 0x67F2,
0x96CD, 0x67FE,
0x96D2, 0x6806,
0x96D3, 0x680D,
0x96D4, 0x6810,
0x96D5, 0x6812,
0x96F3, 0x683F,
0x96F4, 0x6847,
0x96F5, 0x684B,
0x96F6, 0x684D,
0x96F7, 0x684F,
0x96F8, 0x6852,
0x9744, 0x686A,
0x974D, 0x6875,
0x9757, 0x6882,
0x9758, 0x6884,
0x9778, 0x68AE,
0x977B, 0x68B4,
0x9787, 0x68C1,
0x978E, 0x68CA,
0x978F, 0x68CC,
0x9798, 0x68D9,
0x97AA, 0x68EF,
0x97B1, 0x68FB,
0x97BE, 0x690C,
0x97BF, 0x690F,
0x97C0, 0x6911,
0x97E4, 0x693E,
0x97FE, 0x695F,
0x9856, 0x6981,
0x9857, 0x6983,
0x9858, 0x6985,
0x9872, 0x69AC,
0x988B, 0x69CB,
0x988C, 0x69CD,
0x988D, 0x69CF,
0x98B4, 0x69FE,
0x98D1, 0x6A20,
0x98D8, 0x6A29,
0x98DD, 0x6A30,
0x98FE, 0x6A5A,
0x996B, 0x6A8F,
0x9982, 0x6AAA,
0x9A47, 0x6B38,
0x9A51, 0x6B48,
0x9A78, 0x6B7A,
0x9A7D, 0x6B85,
0x9A7E, 0x6B88,
0x9A80, 0x6B8C,
0x9A9F, 0x6BB6,
0x9AA7, 0x6BC0,
0x9AAF, 0x6BCC,
0x9AB0, 0x6BCE,
0x9AB3, 0x6BD8,
0x9AB4, 0x6BDA,
0x9AC8, 0x6BF4,
0x9ADB, 0x6C0E,
0x9ADC, 0x6C12,
0x9ADD, 0x6C17,
0x9AE1, 0x6C20,
0x9AE2, 0x6C23,
0x9AE3, 0x6C25,
0x9AE7, 0x6C31,
0x9AE8, 0x6C33,
0x9AF4, 0x6C48,
0x9AFD, 0x6C56,
0x9AFE, 0x6C58,
0x9B4C, 0x6C71,
0x9B4D, 0x6C73,
0x9B4E, 0x6C75,
0x9B56, 0x6C84,
0x9B57, 0x6C87,
0x9B62, 0x6C9A,
0x9B66, 0x6CA0,
0x9B67, 0x6CA2,
0x9B68, 0x6CA8,
0x9B69, 0x6CAC,
0x9B70, 0x6CBA,
0x9B78, 0x6CCB,
0x9B7E, 0x6CD8,
0x9B84, 0x6CDF,
0x9B85, 0x6CE4,
0x9B88, 0x6CE9,
0x9B8B, 0x6CF2,
0x9B8C, 0x6CF4,
0x9B8D, 0x6CF9,
0x9B97, 0x6D0D,
0x9B9F, 0x6D18,
0x9BA8, 0x6D26,
0x9BAF, 0x6D34,
0x9BB3, 0x6D3A,
0x9BB6, 0x6D42,
0x9BB7, 0x6D44,
0x9BB8, 0x6D49,
0x9BB9, 0x6D4C,
0x9BBA, 0x6D50,
0x9BBF, 0x6D5B,
0x9BC0, 0x6D5D,
0x9BC1, 0x6D5F,
0x9BDF, 0x6D8D,
0x9BE2, 0x6D92,
0x9BE8, 0x6D9C,
0x9BE9, 0x6DA2,
0x9BEA, 0x6DA5,
0x9C48, 0x6DD7,
0x9C4C, 0x6DDF,
0x9C4F, 0x6DE5,
0x9C54, 0x6DED,
0x9C57, 0x6DF2,
0x9C5B, 0x6DF8,
0x9C5C, 0x6DFA,
0x9C69, 0x6E0B,
0x9C6A, 0x6E0F,
0x9C6D, 0x6E15,
0x9C74, 0x6E22,
0x9C78, 0x6E2A,
0x9C79, 0x6E2C,
0x9C7A, 0x6E2E,
0x9C7D, 0x6E33,
0x9C7E, 0x6E35,
0x9C82, 0x6E39,
0x9C97, 0x6E55,
0x9C98, 0x6E57,
0x9CBD, 0x6E84,
0x9CD5, 0x6EA6,
0x9CDC, 0x6EB0,
0x9CDD, 0x6EB3,
0x9CDE, 0x6EB5,
0x9CE1, 0x6EBC,
0x9CEF, 0x6ED0,
0x9CF0, 0x6ED2,
0x9CF1, 0x6ED6,
0x9CF7, 0x6EE3,
0x9CF8, 0x6EE7,
0x9D6E, 0x6F2C,
0x9D6F, 0x6F2E,
0x9D70, 0x6F30,
0x9D71, 0x6F32,
0x9D86, 0x6F4C,
0x9D94, 0x6F5D,
0x9DA4, 0x6F73,
0x9DA8, 0x6F79,
0x9DA9, 0x6F7B,
0x9DE1, 0x6FC1,
0x9DFA, 0x6FDF,
0x9EBB, 0x706E,
0x9EC0, 0x7077,
0x9EC4, 0x707D,
0x9ED2, 0x7093,
0x9EE4, 0x70B0,
0x9EE5, 0x70B2,
0x9EE9, 0x70BA,
0x9EF0, 0x70C9,
0x9EFE, 0x70DA,
0x9F47, 0x70E5,
0x9F48, 0x70EA,
0x9F49, 0x70EE,
0x9F51, 0x70F8,
0x9F67, 0x7114,
0x9F68, 0x7117,
0x9F80, 0x7135,
0x9F93, 0x714B,
0x9F94, 0x714D,
0x9FA2, 0x715D,
0x9FA8, 0x7165,
0x9FB5, 0x7179,
0x9FE3, 0x71B4,
0xA04E, 0x71E6,
0xA08C, 0x7229,
0xA08D, 0x722B,
0xA094, 0x723A,
0xA095, 0x723C,
0xA096, 0x723E,
0xA0AA, 0x725A,
0xA0AB, 0x725C,
0xA0AC, 0x725E,
0xA0AD, 0x7260,
0xA0B1, 0x7268,
0xA0C7, 0x728C,
0xA0C8, 0x728E,
0xA0E3, 0x72AE,
0xA0E7, 0x72B5,
0xA0F6, 0x72CF,
0xA0F7, 0x72D1,
0xA0FC, 0x72D8,
0xA1A4, 0x00B7,
0xA1A5, 0x02C9,
0xA1A6, 0x02C7,
0xA1A7, 0x00A8,
0xA1A8, 0x3003,
0xA1A9, 0x3005,
0xA1AA, 0x2014,
0xA1AB, 0xFF5E,
0xA1AC, 0x2016,
0xA1AD, 0x2026,
0xA1C0, 0x00B1,
0xA1C1, 0x00D7,
0xA1C2, 0x00F7,
0xA1C3, 0x2236,
0xA1C6, 0x2211,
0xA1C7, 0x220F,
0xA1C8, 0x222A,
0xA1C9, 0x2229,
0xA1CA, 0x2208,
0xA1CB, 0x2237,
0xA1CC, 0x221A,
0xA1CD, 0x22A5,
0xA1CE, 0x2225,
0xA1CF, 0x2220,
0xA1D0, 0x2312,
0xA1D1, 0x2299,
0xA1D2, 0x222B,
0xA1D3, 0x222E,
0xA1D4, 0x2261,
0xA1D5, 0x224C,
0xA1D6, 0x2248,
0xA1D7, 0x223D,
0xA1D8, 0x221D,
0xA1D9, 0x2260,
0xA1DE, 0x221E,
0xA1DF, 0x2235,
0xA1E0, 0x2234,
0xA1E1, 0x2642,
0xA1E2, 0x2640,
0xA1E3, 0x00B0,
0xA1E6, 0x2103,
0xA1E7, 0xFF04,
0xA1E8, 0x00A4,
0xA1EB, 0x2030,
0xA1EC, 0x00A7,
0xA1ED, 0x2116,
0xA1EE, 0x2606,
0xA1EF, 0x2605,
0xA1F0, 0x25CB,
0xA1F1, 0x25CF,
0xA1F2, 0x25CE,
0xA1F3, 0x25C7,
0xA1F4, 0x25C6,
0xA1F5, 0x25A1,
0xA1F6, 0x25A0,
0xA1F7, 0x25B3,
0xA1F8, 0x25B2,
0xA1F9, 0x203B,
0xA1FA, 0x2192,
0xA1FD, 0x2193,
0xA1FE, 0x3013,
0xA3A4, 0xFFE5,
0xA3FE, 0xFFE3,
0xA6F2, 0xFE31,
0xA7A7, 0x0401,
0xA7D7, 0x0451,
0xA842, 0x02D9,
0xA843, 0x2013,
0xA844, 0x2015,
0xA845, 0x2025,
0xA846, 0x2035,
0xA847, 0x2105,
0xA848, 0x2109,
0xA84D, 0x2215,
0xA84E, 0x221F,
0xA84F, 0x2223,
0xA850, 0x2252,
0xA853, 0x22BF,
0xA891, 0x2609,
0xA892, 0x2295,
0xA893, 0x3012,
0xA8A1, 0x0101,
0xA8A2, 0x00E1,
0xA8A3, 0x01CE,
0xA8A4, 0x00E0,
0xA8A5, 0x0113,
0xA8A6, 0x00E9,
0xA8A7, 0x011B,
0xA8A8, 0x00E8,
0xA8A9, 0x012B,
0xA8AA, 0x00ED,
0xA8AB, 0x01D0,
0xA8AC, 0x00EC,
0xA8AD, 0x014D,
0xA8AE, 0x00F3,
0xA8AF, 0x01D2,
0xA8B0, 0x00F2,
0xA8B1, 0x016B,
0xA8B2, 0x00FA,
0xA8B3, 0x01D4,
0xA8B4, 0x00F9,
0xA8B5, 0x01D6,
0xA8B6, 0x01D8,
0xA8B7, 0x01DA,
0xA8B8, 0x01DC,
0xA8B9, 0x00FC,
0xA8BA, 0x00EA,
0xA8BB, 0x0251,
0xA8BC, 0xE7C7,
0xA8BD, 0x0144,
0xA8BE, 0x0148,
0xA8BF, 0xE7C8,
0xA8C0, 0x0261,
0xA949, 0x32A3,
0xA94F, 0x33A1,
0xA950, 0x33C4,
0xA951, 0x33CE,
0xA954, 0x33D5,
0xA955, 0xFE30,
0xA956, 0xFFE2,
0xA957, 0xFFE4,
0xA959, 0x2121,
0xA95A, 0x3231,
0xA95C, 0x2010,
0xA960, 0x30FC,
0xA965, 0x3006,
0xA996, 0x3007,
0xAA42, 0x72DF,
0xAA4D, 0x72F9,
0xAA52, 0x7302,
0xAA60, 0x7314,
0xAA6B, 0x732D,
0xAA86, 0x7351,
0xAA9E, 0x736E,
0xAB53, 0x7388,
0xAB54, 0x738A,
0xAB6C, 0x73AA,
0xAB6F, 0x73B1,
0xAB79, 0x73C1,
0xAB82, 0x73CE,
0xAB8E, 0x73DF,
0xAB93, 0x73E6,
0xAB94, 0x73E8,
0xAC4B, 0x7404,
0xAC63, 0x7427,
0xAC64, 0x7429,
0xAC65, 0x742B,
0xAC66, 0x742D,
0xAC67, 0x742F,
0xAC87, 0x7456,
0xAC88, 0x7458,
0xAC89, 0x745D,
0xAD43, 0x747F,
0xAD44, 0x7482,
0xAD4D, 0x748F,
0xAD59, 0x749D,
0xAD93, 0x74DD,
0xAD94, 0x74DF,
0xAD95, 0x74E1,
0xAD96, 0x74E5,
0xAE40, 0x74F3,
0xAE41, 0x74F5,
0xAE55, 0x750E,
0xAE56, 0x7510,
0xAE57, 0x7512,
0xAE5C, 0x751B,
0xAE66, 0x752A,
0xAE67, 0x752E,
0xAE68, 0x7534,
0xAE69, 0x7536,
0xAE6A, 0x7539,
0xAE6D, 0x753F,
0xAE76, 0x754D,
0xAE92, 0x7573,
0xAEA0, 0x7587,
0xAF46, 0x7590,
0xAF47, 0x7593,
0xAF48, 0x7595,
0xAF49, 0x7598,
0xAF4C, 0x759E,
0xAF4D, 0x75A2,
0xAF53, 0x75AD,
0xAF5B, 0x75C6,
0xAF62, 0x75D3,
0xAF63, 0x75D7,
0xAF6B, 0x75E5,
0xAF6C, 0x75E9,
0xAF7B, 0x7602,
0xAF7C, 0x7604,
0xAF82, 0x760B,
0xAF8A, 0x7616,
0xAF8B, 0x761A,
0xAF8F, 0x7621,
0xAF90, 0x7623,
0xAF93, 0x762C,
0xAF9D, 0x763D,
0xAFA0, 0x7644,
0xB04D, 0x7655,
0xB053, 0x765D,
0xB06C, 0x767C,
0xB070, 0x7683,
0xB071, 0x7685,
0xB078, 0x7692,
0xB093, 0x76B3,
0xB0A0, 0x76C3,
0xB0A1, 0x554A,
0xB0A2, 0x963F,
0xB0A3, 0x57C3,
0xB0A4, 0x6328,
0xB0A5, 0x54CE,
0xB0A6, 0x5509,
0xB0A7, 0x54C0,
0xB0A8, 0x7691,
0xB0A9, 0x764C,
0xB0AA, 0x853C,
0xB0AB, 0x77EE,
0xB0AC, 0x827E,
0xB0AD, 0x788D,
0xB0AE, 0x7231,
0xB0AF, 0x9698,
0xB0B0, 0x978D,
0xB0B1, 0x6C28,
0xB0B2, 0x5B89,
0xB0B3, 0x4FFA,
0xB0B4, 0x6309,
0xB0B5, 0x6697,
0xB0B6, 0x5CB8,
0xB0B7, 0x80FA,
0xB0B8, 0x6848,
0xB0B9, 0x80AE,
0xB0BA, 0x6602,
0xB0BB, 0x76CE,
0xB0BC, 0x51F9,
0xB0BD, 0x6556,
0xB0BE, 0x71AC,
0xB0BF, 0x7FF1,
0xB0C0, 0x8884,
0xB0C1, 0x50B2,
0xB0C2, 0x5965,
0xB0C3, 0x61CA,
0xB0C4, 0x6FB3,
0xB0C5, 0x82AD,
0xB0C6, 0x634C,
0xB0C7, 0x6252,
0xB0C8, 0x53ED,
0xB0C9, 0x5427,
0xB0CA, 0x7B06,
0xB0CB, 0x516B,
0xB0CC, 0x75A4,
0xB0CD, 0x5DF4,
0xB0CE, 0x62D4,
0xB0CF, 0x8DCB,
0xB0D0, 0x9776,
0xB0D1, 0x628A,
0xB0D2, 0x8019,
0xB0D3, 0x575D,
0xB0D4, 0x9738,
0xB0D5, 0x7F62,
0xB0D6, 0x7238,
0xB0D7, 0x767D,
0xB0D8, 0x67CF,
0xB0D9, 0x767E,
0xB0DA, 0x6446,
0xB0DB, 0x4F70,
0xB0DC, 0x8D25,
0xB0DD, 0x62DC,
0xB0DE, 0x7A17,
0xB0DF, 0x6591,
0xB0E0, 0x73ED,
0xB0E1, 0x642C,
0xB0E2, 0x6273,
0xB0E3, 0x822C,
0xB0E4, 0x9881,
0xB0E5, 0x677F,
0xB0E6, 0x7248,
0xB0E7, 0x626E,
0xB0E8, 0x62CC,
0xB0E9, 0x4F34,
0xB0EA, 0x74E3,
0xB0EB, 0x534A,
0xB0EC, 0x529E,
0xB0ED, 0x7ECA,
0xB0EE, 0x90A6,
0xB0EF, 0x5E2E,
0xB0F0, 0x6886,
0xB0F1, 0x699C,
0xB0F2, 0x8180,
0xB0F3, 0x7ED1,
0xB0F4, 0x68D2,
0xB0F5, 0x78C5,
0xB0F6, 0x868C,
0xB0F7, 0x9551,
0xB0F8, 0x508D,
0xB0F9, 0x8C24,
0xB0FA, 0x82DE,
0xB0FB, 0x80DE,
0xB0FC, 0x5305,
0xB0FD, 0x8912,
0xB0FE, 0x5265,
0xB140, 0x76C4,
0xB141, 0x76C7,
0xB142, 0x76C9,
0xB145, 0x76D3,
0xB146, 0x76D5,
0xB159, 0x76F0,
0xB15A, 0x76F3,
0xB160, 0x76FD,
0xB167, 0x770A,
0xB168, 0x770C,
0xB178, 0x7721,
0xB17C, 0x7727,
0xB180, 0x772C,
0xB181, 0x772E,
0xB187, 0x7739,
0xB188, 0x773B,
0xB18C, 0x7742,
0xB1A0, 0x775C,
0xB1A1, 0x8584,
0xB1A2, 0x96F9,
0xB1A3, 0x4FDD,
0xB1A4, 0x5821,
0xB1A5, 0x9971,
0xB1A6, 0x5B9D,
0xB1A7, 0x62B1,
0xB1A8, 0x62A5,
0xB1A9, 0x66B4,
0xB1AA, 0x8C79,
0xB1AB, 0x9C8D,
0xB1AC, 0x7206,
0xB1AD, 0x676F,
0xB1AE, 0x7891,
0xB1AF, 0x60B2,
0xB1B0, 0x5351,
0xB1B1, 0x5317,
0xB1B2, 0x8F88,
0xB1B3, 0x80CC,
0xB1B4, 0x8D1D,
0xB1B5, 0x94A1,
0xB1B6, 0x500D,
0xB1B7, 0x72C8,
0xB1B8, 0x5907,
0xB1B9, 0x60EB,
0xB1BA, 0x7119,
0xB1BB, 0x88AB,
0xB1BC, 0x5954,
0xB1BD, 0x82EF,
0xB1BE, 0x672C,
0xB1BF, 0x7B28,
0xB1C0, 0x5D29,
0xB1C1, 0x7EF7,
0xB1C2, 0x752D,
0xB1C3, 0x6CF5,
0xB1C4, 0x8E66,
0xB1C5, 0x8FF8,
0xB1C6, 0x903C,
0xB1C7, 0x9F3B,
0xB1C8, 0x6BD4,
0xB1C9, 0x9119,
0xB1CA, 0x7B14,
0xB1CB, 0x5F7C,
0xB1CC, 0x78A7,
0xB1CD, 0x84D6,
0xB1CE, 0x853D,
0xB1CF, 0x6BD5,
0xB1D0, 0x6BD9,
0xB1D1, 0x6BD6,
0xB1D2, 0x5E01,
0xB1D3, 0x5E87,
0xB1D4, 0x75F9,
0xB1D5, 0x95ED,
0xB1D6, 0x655D,
0xB1D7, 0x5F0A,
0xB1D8, 0x5FC5,
0xB1D9, 0x8F9F,
0xB1DA, 0x58C1,
0xB1DB, 0x81C2,
0xB1DC, 0x907F,
0xB1DD, 0x965B,
0xB1DE, 0x97AD,
0xB1DF, 0x8FB9,
0xB1E0, 0x7F16,
0xB1E1, 0x8D2C,
0xB1E2, 0x6241,
0xB1E3, 0x4FBF,
0xB1E4, 0x53D8,
0xB1E5, 0x535E,
0xB1E8, 0x8FAB,
0xB1E9, 0x904D,
0xB1EA, 0x6807,
0xB1EB, 0x5F6A,
0xB1EC, 0x8198,
0xB1ED, 0x8868,
0xB1EE, 0x9CD6,
0xB1EF, 0x618B,
0xB1F0, 0x522B,
0xB1F1, 0x762A,
0xB1F2, 0x5F6C,
0xB1F3, 0x658C,
0xB1F4, 0x6FD2,
0xB1F5, 0x6EE8,
0xB1F6, 0x5BBE,
0xB1F7, 0x6448,
0xB1F8, 0x5175,
0xB1F9, 0x51B0,
0xB1FA, 0x67C4,
0xB1FB, 0x4E19,
0xB1FC, 0x79C9,
0xB1FD, 0x997C,
0xB1FE, 0x70B3,
0xB244, 0x7764,
0xB245, 0x7767,
0xB26E, 0x77A1,
0xB271, 0x77A6,
0xB272, 0x77A8,
0xB273, 0x77AB,
0xB279, 0x77B4,
0xB280, 0x77BC,
0xB281, 0x77BE,
0xB2A0, 0x77E4,
0xB2A1, 0x75C5,
0xB2A2, 0x5E76,
0xB2A3, 0x73BB,
0xB2A4, 0x83E0,
0xB2A5, 0x64AD,
0xB2A6, 0x62E8,
0xB2A7, 0x94B5,
0xB2A8, 0x6CE2,
0xB2A9, 0x535A,
0xB2AA, 0x52C3,
0xB2AB, 0x640F,
0xB2AC, 0x94C2,
0xB2AD, 0x7B94,
0xB2AE, 0x4F2F,
0xB2AF, 0x5E1B,
0xB2B0, 0x8236,
0xB2B1, 0x8116,
0xB2B2, 0x818A,
0xB2B3, 0x6E24,
0xB2B4, 0x6CCA,
0xB2B5, 0x9A73,
0xB2B6, 0x6355,
0xB2B7, 0x535C,
0xB2B8, 0x54FA,
0xB2B9, 0x8865,
0xB2BA, 0x57E0,
0xB2BB, 0x4E0D,
0xB2BC, 0x5E03,
0xB2BD, 0x6B65,
0xB2BE, 0x7C3F,
0xB2BF, 0x90E8,
0xB2C0, 0x6016,
0xB2C1, 0x64E6,
0xB2C2, 0x731C,
0xB2C3, 0x88C1,
0xB2C4, 0x6750,
0xB2C5, 0x624D,
0xB2C6, 0x8D22,
0xB2C7, 0x776C,
0xB2C8, 0x8E29,
0xB2C9, 0x91C7,
0xB2CA, 0x5F69,
0xB2CB, 0x83DC,
0xB2CC, 0x8521,
0xB2CD, 0x9910,
0xB2CE, 0x53C2,
0xB2CF, 0x8695,
0xB2D0, 0x6B8B,
0xB2D1, 0x60ED,
0xB2D2, 0x60E8,
0xB2D3, 0x707F,
0xB2D4, 0x82CD,
0xB2D5, 0x8231,
0xB2D6, 0x4ED3,
0xB2D7, 0x6CA7,
0xB2D8, 0x85CF,
0xB2D9, 0x64CD,
0xB2DA, 0x7CD9,
0xB2DB, 0x69FD,
0xB2DC, 0x66F9,
0xB2DD, 0x8349,
0xB2DE, 0x5395,
0xB2DF, 0x7B56,
0xB2E0, 0x4FA7,
0xB2E1, 0x518C,
0xB2E2, 0x6D4B,
0xB2E3, 0x5C42,
0xB2E4, 0x8E6D,
0xB2E5, 0x63D2,
0xB2E6, 0x53C9,
0xB2E7, 0x832C,
0xB2E8, 0x8336,
0xB2E9, 0x67E5,
0xB2EA, 0x78B4,
0xB2EB, 0x643D,
0xB2EC, 0x5BDF,
0xB2ED, 0x5C94,
0xB2EE, 0x5DEE,
0xB2EF, 0x8BE7,
0xB2F0, 0x62C6,
0xB2F1, 0x67F4,
0xB2F2, 0x8C7A,
0xB2F3, 0x6400,
0xB2F4, 0x63BA,
0xB2F5, 0x8749,
0xB2F6, 0x998B,
0xB2F7, 0x8C17,
0xB2F8, 0x7F20,
0xB2F9, 0x94F2,
0xB2FA, 0x4EA7,
0xB2FB, 0x9610,
0xB2FC, 0x98A4,
0xB2FD, 0x660C,
0xB2FE, 0x7316,
0xB340, 0x77E6,
0xB341, 0x77E8,
0xB342, 0x77EA,
0xB349, 0x77F7,
0xB359, 0x7813,
0xB35A, 0x7815,
0xB35B, 0x7819,
0xB35C, 0x781B,
0xB35D, 0x781E,
0xB361, 0x7824,
0xB362, 0x7828,
0xB36C, 0x783D,
0xB36D, 0x783F,
0xB372, 0x7846,
0xB377, 0x784D,
0xB378, 0x784F,
0xB379, 0x7851,
0xB3A1, 0x573A,
0xB3A2, 0x5C1D,
0xB3A3, 0x5E38,
0xB3A4, 0x957F,
0xB3A5, 0x507F,
0xB3A6, 0x80A0,
0xB3A7, 0x5382,
0xB3A8, 0x655E,
0xB3A9, 0x7545,
0xB3AA, 0x5531,
0xB3AB, 0x5021,
0xB3AC, 0x8D85,
0xB3AD, 0x6284,
0xB3AE, 0x949E,
0xB3AF, 0x671D,
0xB3B0, 0x5632,
0xB3B1, 0x6F6E,
0xB3B2, 0x5DE2,
0xB3B3, 0x5435,
0xB3B4, 0x7092,
0xB3B5, 0x8F66,
0xB3B6, 0x626F,
0xB3B7, 0x64A4,
0xB3B8, 0x63A3,
0xB3B9, 0x5F7B,
0xB3BA, 0x6F88,
0xB3BB, 0x90F4,
0xB3BC, 0x81E3,
0xB3BD, 0x8FB0,
0xB3BE, 0x5C18,
0xB3BF, 0x6668,
0xB3C0, 0x5FF1,
0xB3C1, 0x6C89,
0xB3C2, 0x9648,
0xB3C3, 0x8D81,
0xB3C4, 0x886C,
0xB3C5, 0x6491,
0xB3C6, 0x79F0,
0xB3C7, 0x57CE,
0xB3C8, 0x6A59,
0xB3C9, 0x6210,
0xB3CA, 0x5448,
0xB3CB, 0x4E58,
0xB3CC, 0x7A0B,
0xB3CD, 0x60E9,
0xB3CE, 0x6F84,
0xB3CF, 0x8BDA,
0xB3D0, 0x627F,
0xB3D1, 0x901E,
0xB3D2, 0x9A8B,
0xB3D3, 0x79E4,
0xB3D4, 0x5403,
0xB3D5, 0x75F4,
0xB3D6, 0x6301,
0xB3D7, 0x5319,
0xB3D8, 0x6C60,
0xB3D9, 0x8FDF,
0xB3DA, 0x5F1B,
0xB3DB, 0x9A70,
0xB3DC, 0x803B,
0xB3DD, 0x9F7F,
0xB3DE, 0x4F88,
0xB3DF, 0x5C3A,
0xB3E0, 0x8D64,
0xB3E1, 0x7FC5,
0xB3E2, 0x65A5,
0xB3E3, 0x70BD,
0xB3E4, 0x5145,
0xB3E5, 0x51B2,
0xB3E6, 0x866B,
0xB3E7, 0x5D07,
0xB3E8, 0x5BA0,
0xB3E9, 0x62BD,
0xB3EA, 0x916C,
0xB3EB, 0x7574,
0xB3EC, 0x8E0C,
0xB3ED, 0x7A20,
0xB3EE, 0x6101,
0xB3EF, 0x7B79,
0xB3F0, 0x4EC7,
0xB3F1, 0x7EF8,
0xB3F2, 0x7785,
0xB3F3, 0x4E11,
0xB3F4, 0x81ED,
0xB3F5, 0x521D,
0xB3F6, 0x51FA,
0xB3F7, 0x6A71,
0xB3F8, 0x53A8,
0xB3F9, 0x8E87,
0xB3FA, 0x9504,
0xB3FB, 0x96CF,
0xB3FC, 0x6EC1,
0xB3FD, 0x9664,
0xB3FE, 0x695A,
0xB443, 0x7888,
0xB448, 0x7892,
0xB44C, 0x7899,
0xB44F, 0x78A0,
0xB450, 0x78A2,
0xB451, 0x78A4,
0xB452, 0x78A6,
0xB48C, 0x78F3,
0xB4A1, 0x7840,
0xB4A2, 0x50A8,
0xB4A3, 0x77D7,
0xB4A4, 0x6410,
0xB4A5, 0x89E6,
0xB4A6, 0x5904,
0xB4A7, 0x63E3,
0xB4A8, 0x5DDD,
0xB4A9, 0x7A7F,
0xB4AA, 0x693D,
0xB4AB, 0x4F20,
0xB4AC, 0x8239,
0xB4AD, 0x5598,
0xB4AE, 0x4E32,
0xB4AF, 0x75AE,
0xB4B0, 0x7A97,
0xB4B1, 0x5E62,
0xB4B2, 0x5E8A,
0xB4B3, 0x95EF,
0xB4B4, 0x521B,
0xB4B5, 0x5439,
0xB4B6, 0x708A,
0xB4B7, 0x6376,
0xB4B8, 0x9524,
0xB4B9, 0x5782,
0xB4BA, 0x6625,
0xB4BB, 0x693F,
0xB4BC, 0x9187,
0xB4BD, 0x5507,
0xB4BE, 0x6DF3,
0xB4BF, 0x7EAF,
0xB4C0, 0x8822,
0xB4C1, 0x6233,
0xB4C2, 0x7EF0,
0xB4C3, 0x75B5,
0xB4C4, 0x8328,
0xB4C5, 0x78C1,
0xB4C6, 0x96CC,
0xB4C7, 0x8F9E,
0xB4C8, 0x6148,
0xB4C9, 0x74F7,
0xB4CA, 0x8BCD,
0xB4CB, 0x6B64,
0xB4CC, 0x523A,
0xB4CD, 0x8D50,
0xB4CE, 0x6B21,
0xB4CF, 0x806A,
0xB4D0, 0x8471,
0xB4D1, 0x56F1,
0xB4D2, 0x5306,
0xB4D3, 0x4ECE,
0xB4D4, 0x4E1B,
0xB4D5, 0x51D1,
0xB4D6, 0x7C97,
0xB4D7, 0x918B,
0xB4D8, 0x7C07,
0xB4D9, 0x4FC3,
0xB4DA, 0x8E7F,
0xB4DB, 0x7BE1,
0xB4DC, 0x7A9C,
0xB4DD, 0x6467,
0xB4DE, 0x5D14,
0xB4DF, 0x50AC,
0xB4E0, 0x8106,
0xB4E1, 0x7601,
0xB4E2, 0x7CB9,
0xB4E3, 0x6DEC,
0xB4E4, 0x7FE0,
0xB4E5, 0x6751,
0xB4E6, 0x5B58,
0xB4E7, 0x5BF8,
0xB4E8, 0x78CB,
0xB4E9, 0x64AE,
0xB4EA, 0x6413,
0xB4EB, 0x63AA,
0xB4EC, 0x632B,
0xB4ED, 0x9519,
0xB4EE, 0x642D,
0xB4EF, 0x8FBE,
0xB4F0, 0x7B54,
0xB4F1, 0x7629,
0xB4F2, 0x6253,
0xB4F3, 0x5927,
0xB4F4, 0x5446,
0xB4F5, 0x6B79,
0xB4F6, 0x50A3,
0xB4F7, 0x6234,
0xB4F8, 0x5E26,
0xB4F9, 0x6B86,
0xB4FA, 0x4EE3,
0xB4FB, 0x8D37,
0xB4FC, 0x888B,
0xB4FD, 0x5F85,
0xB4FE, 0x902E,
0xB569, 0x793D,
0xB56A, 0x793F,
0xB56F, 0x7947,
0xB57D, 0x7961,
0xB57E, 0x7963,
0xB580, 0x7964,
0xB581, 0x7966,
0xB586, 0x796E,
0xB58E, 0x7979,
0xB5A1, 0x6020,
0xB5A2, 0x803D,
0xB5A3, 0x62C5,
0xB5A4, 0x4E39,
0xB5A5, 0x5355,
0xB5A6, 0x90F8,
0xB5A7, 0x63B8,
0xB5A8, 0x80C6,
0xB5A9, 0x65E6,
0xB5AA, 0x6C2E,
0xB5AB, 0x4F46,
0xB5AC, 0x60EE,
0xB5AD, 0x6DE1,
0xB5AE, 0x8BDE,
0xB5AF, 0x5F39,
0xB5B0, 0x86CB,
0xB5B1, 0x5F53,
0xB5B2, 0x6321,
0xB5B3, 0x515A,
0xB5B4, 0x8361,
0xB5B5, 0x6863,
0xB5B6, 0x5200,
0xB5B7, 0x6363,
0xB5B8, 0x8E48,
0xB5B9, 0x5012,
0xB5BA, 0x5C9B,
0xB5BB, 0x7977,
0xB5BC, 0x5BFC,
0xB5BD, 0x5230,
0xB5BE, 0x7A3B,
0xB5BF, 0x60BC,
0xB5C0, 0x9053,
0xB5C1, 0x76D7,
0xB5C2, 0x5FB7,
0xB5C3, 0x5F97,
0xB5C4, 0x7684,
0xB5C5, 0x8E6C,
0xB5C6, 0x706F,
0xB5C7, 0x767B,
0xB5C8, 0x7B49,
0xB5C9, 0x77AA,
0xB5CA, 0x51F3,
0xB5CB, 0x9093,
0xB5CC, 0x5824,
0xB5CD, 0x4F4E,
0xB5CE, 0x6EF4,
0xB5CF, 0x8FEA,
0xB5D0, 0x654C,
0xB5D1, 0x7B1B,
0xB5D2, 0x72C4,
0xB5D3, 0x6DA4,
0xB5D4, 0x7FDF,
0xB5D5, 0x5AE1,
0xB5D6, 0x62B5,
0xB5D7, 0x5E95,
0xB5D8, 0x5730,
0xB5D9, 0x8482,
0xB5DA, 0x7B2C,
0xB5DB, 0x5E1D,
0xB5DC, 0x5F1F,
0xB5DD, 0x9012,
0xB5DE, 0x7F14,
0xB5DF, 0x98A0,
0xB5E0, 0x6382,
0xB5E1, 0x6EC7,
0xB5E2, 0x7898,
0xB5E3, 0x70B9,
0xB5E4, 0x5178,
0xB5E5, 0x975B,
0xB5E6, 0x57AB,
0xB5E7, 0x7535,
0xB5E8, 0x4F43,
0xB5E9, 0x7538,
0xB5EA, 0x5E97,
0xB5EB, 0x60E6,
0xB5EC, 0x5960,
0xB5ED, 0x6DC0,
0xB5EE, 0x6BBF,
0xB5EF, 0x7889,
0xB5F0, 0x53FC,
0xB5F1, 0x96D5,
0xB5F2, 0x51CB,
0xB5F3, 0x5201,
0xB5F4, 0x6389,
0xB5F5, 0x540A,
0xB5F6, 0x9493,
0xB5F7, 0x8C03,
0xB5F8, 0x8DCC,
0xB5F9, 0x7239,
0xB5FA, 0x789F,
0xB5FB, 0x8776,
0xB5FC, 0x8FED,
0xB5FD, 0x8C0D,
0xB5FE, 0x53E0,
0xB663, 0x79BC,
0xB664, 0x79BF,
0xB665, 0x79C2,
0xB66A, 0x79CA,
0xB66B, 0x79CC,
0xB67C, 0x79E5,
0xB67D, 0x79E8,
0xB67E, 0x79EA,
0xB680, 0x79EC,
0xB681, 0x79EE,
0xB68B, 0x79FC,
0xB68E, 0x7A01,
0xB695, 0x7A0C,
0xB6A1, 0x4E01,
0xB6A2, 0x76EF,
0xB6A3, 0x53EE,
0xB6A4, 0x9489,
0xB6A5, 0x9876,
0xB6A6, 0x9F0E,
0xB6A7, 0x952D,
0xB6A8, 0x5B9A,
0xB6A9, 0x8BA2,
0xB6AA, 0x4E22,
0xB6AB, 0x4E1C,
0xB6AC, 0x51AC,
0xB6AD, 0x8463,
0xB6AE, 0x61C2,
0xB6AF, 0x52A8,
0xB6B0, 0x680B,
0xB6B1, 0x4F97,
0xB6B2, 0x606B,
0xB6B3, 0x51BB,
0xB6B4, 0x6D1E,
0xB6B5, 0x515C,
0xB6B6, 0x6296,
0xB6B7, 0x6597,
0xB6B8, 0x9661,
0xB6B9, 0x8C46,
0xB6BA, 0x9017,
0xB6BB, 0x75D8,
0xB6BC, 0x90FD,
0xB6BD, 0x7763,
0xB6BE, 0x6BD2,
0xB6BF, 0x728A,
0xB6C0, 0x72EC,
0xB6C1, 0x8BFB,
0xB6C2, 0x5835,
0xB6C3, 0x7779,
0xB6C4, 0x8D4C,
0xB6C5, 0x675C,
0xB6C6, 0x9540,
0xB6C7, 0x809A,
0xB6C8, 0x5EA6,
0xB6C9, 0x6E21,
0xB6CA, 0x5992,
0xB6CB, 0x7AEF,
0xB6CC, 0x77ED,
0xB6CD, 0x953B,
0xB6CE, 0x6BB5,
0xB6CF, 0x65AD,
0xB6D0, 0x7F0E,
0xB6D1, 0x5806,
0xB6D2, 0x5151,
0xB6D3, 0x961F,
0xB6D4, 0x5BF9,
0xB6D5, 0x58A9,
0xB6D6, 0x5428,
0xB6D7, 0x8E72,
0xB6D8, 0x6566,
0xB6D9, 0x987F,
0xB6DA, 0x56E4,
0xB6DB, 0x949D,
0xB6DC, 0x76FE,
0xB6DD, 0x9041,
0xB6DE, 0x6387,
0xB6DF, 0x54C6,
0xB6E0, 0x591A,
0xB6E1, 0x593A,
0xB6E2, 0x579B,
0xB6E3, 0x8EB2,
0xB6E4, 0x6735,
0xB6E5, 0x8DFA,
0xB6E6, 0x8235,
0xB6E7, 0x5241,
0xB6E8, 0x60F0,
0xB6E9, 0x5815,
0xB6EA, 0x86FE,
0xB6EB, 0x5CE8,
0xB6EC, 0x9E45,
0xB6ED, 0x4FC4,
0xB6EE, 0x989D,
0xB6EF, 0x8BB9,
0xB6F0, 0x5A25,
0xB6F1, 0x6076,
0xB6F2, 0x5384,
0xB6F3, 0x627C,
0xB6F4, 0x904F,
0xB6F5, 0x9102,
0xB6F6, 0x997F,
0xB6F7, 0x6069,
0xB6F8, 0x800C,
0xB6F9, 0x513F,
0xB6FA, 0x8033,
0xB6FB, 0x5C14,
0xB6FC, 0x9975,
0xB6FD, 0x6D31,
0xB6FE, 0x4E8C,
0xB740, 0x7A1D,
0xB741, 0x7A1F,
0xB756, 0x7A38,
0xB757, 0x7A3A,
0xB758, 0x7A3E,
0xB78A, 0x7A75,
0xB78F, 0x7A82,
0xB790, 0x7A85,
0xB791, 0x7A87,
0xB79E, 0x7A9E,
0xB7A1, 0x8D30,
0xB7A2, 0x53D1,
0xB7A3, 0x7F5A,
0xB7A4, 0x7B4F,
0xB7A5, 0x4F10,
0xB7A6, 0x4E4F,
0xB7A7, 0x9600,
0xB7A8, 0x6CD5,
0xB7A9, 0x73D0,
0xB7AA, 0x85E9,
0xB7AB, 0x5E06,
0xB7AC, 0x756A,
0xB7AD, 0x7FFB,
0xB7AE, 0x6A0A,
0xB7AF, 0x77FE,
0xB7B0, 0x9492,
0xB7B1, 0x7E41,
0xB7B2, 0x51E1,
0xB7B3, 0x70E6,
0xB7B4, 0x53CD,
0xB7B5, 0x8FD4,
0xB7B6, 0x8303,
0xB7B7, 0x8D29,
0xB7B8, 0x72AF,
0xB7B9, 0x996D,
0xB7BA, 0x6CDB,
0xB7BB, 0x574A,
0xB7BC, 0x82B3,
0xB7BD, 0x65B9,
0xB7BE, 0x80AA,
0xB7BF, 0x623F,
0xB7C0, 0x9632,
0xB7C1, 0x59A8,
0xB7C2, 0x4EFF,
0xB7C3, 0x8BBF,
0xB7C4, 0x7EBA,
0xB7C5, 0x653E,
0xB7C6, 0x83F2,
0xB7C7, 0x975E,
0xB7C8, 0x5561,
0xB7C9, 0x98DE,
0xB7CA, 0x80A5,
0xB7CB, 0x532A,
0xB7CC, 0x8BFD,
0xB7CD, 0x5420,
0xB7CE, 0x80BA,
0xB7CF, 0x5E9F,
0xB7D0, 0x6CB8,
0xB7D1, 0x8D39,
0xB7D2, 0x82AC,
0xB7D3, 0x915A,
0xB7D4, 0x5429,
0xB7D5, 0x6C1B,
0xB7D6, 0x5206,
0xB7D7, 0x7EB7,
0xB7D8, 0x575F,
0xB7D9, 0x711A,
0xB7DA, 0x6C7E,
0xB7DB, 0x7C89,
0xB7DC, 0x594B,
0xB7DD, 0x4EFD,
0xB7DE, 0x5FFF,
0xB7DF, 0x6124,
0xB7E0, 0x7CAA,
0xB7E1, 0x4E30,
0xB7E2, 0x5C01,
0xB7E3, 0x67AB,
0xB7E4, 0x8702,
0xB7E5, 0x5CF0,
0xB7E6, 0x950B,
0xB7E7, 0x98CE,
0xB7E8, 0x75AF,
0xB7E9, 0x70FD,
0xB7EA, 0x9022,
0xB7EB, 0x51AF,
0xB7EC, 0x7F1D,
0xB7ED, 0x8BBD,
0xB7EE, 0x5949,
0xB7EF, 0x51E4,
0xB7F0, 0x4F5B,
0xB7F1, 0x5426,
0xB7F2, 0x592B,
0xB7F3, 0x6577,
0xB7F4, 0x80A4,
0xB7F5, 0x5B75,
0xB7F6, 0x6276,
0xB7F7, 0x62C2,
0xB7F8, 0x8F90,
0xB7F9, 0x5E45,
0xB7FA, 0x6C1F,
0xB7FB, 0x7B26,
0xB7FC, 0x4F0F,
0xB7FD, 0x4FD8,
0xB7FE, 0x670D,
0xB842, 0x7AA7,
0xB873, 0x7AE4,
0xB87A, 0x7AEE,
0xB887, 0x7AFE,
0xB88B, 0x7B05,
0xB88C, 0x7B07,
0xB88D, 0x7B09,
0xB891, 0x7B10,
0xB897, 0x7B1A,
0xB89A, 0x7B1F,
0xB89E, 0x7B27,
0xB89F, 0x7B29,
0xB8A0, 0x7B2D,
0xB8A1, 0x6D6E,
0xB8A2, 0x6DAA,
0xB8A3, 0x798F,
0xB8A4, 0x88B1,
0xB8A5, 0x5F17,
0xB8A6, 0x752B,
0xB8A7, 0x629A,
0xB8A8, 0x8F85,
0xB8A9, 0x4FEF,
0xB8AA, 0x91DC,
0xB8AB, 0x65A7,
0xB8AC, 0x812F,
0xB8AD, 0x8151,
0xB8AE, 0x5E9C,
0xB8AF, 0x8150,
0xB8B0, 0x8D74,
0xB8B1, 0x526F,
0xB8B2, 0x8986,
0xB8B3, 0x8D4B,
0xB8B4, 0x590D,
0xB8B5, 0x5085,
0xB8B6, 0x4ED8,
0xB8B7, 0x961C,
0xB8B8, 0x7236,
0xB8B9, 0x8179,
0xB8BA, 0x8D1F,
0xB8BB, 0x5BCC,
0xB8BC, 0x8BA3,
0xB8BD, 0x9644,
0xB8BE, 0x5987,
0xB8BF, 0x7F1A,
0xB8C0, 0x5490,
0xB8C1, 0x5676,
0xB8C2, 0x560E,
0xB8C3, 0x8BE5,
0xB8C4, 0x6539,
0xB8C5, 0x6982,
0xB8C6, 0x9499,
0xB8C7, 0x76D6,
0xB8C8, 0x6E89,
0xB8C9, 0x5E72,
0xB8CA, 0x7518,
0xB8CB, 0x6746,
0xB8CC, 0x67D1,
0xB8CD, 0x7AFF,
0xB8CE, 0x809D,
0xB8CF, 0x8D76,
0xB8D0, 0x611F,
0xB8D1, 0x79C6,
0xB8D2, 0x6562,
0xB8D3, 0x8D63,
0xB8D4, 0x5188,
0xB8D5, 0x521A,
0xB8D6, 0x94A2,
0xB8D7, 0x7F38,
0xB8D8, 0x809B,
0xB8D9, 0x7EB2,
0xB8DA, 0x5C97,
0xB8DB, 0x6E2F,
0xB8DC, 0x6760,
0xB8DD, 0x7BD9,
0xB8DE, 0x768B,
0xB8DF, 0x9AD8,
0xB8E0, 0x818F,
0xB8E1, 0x7F94,
0xB8E2, 0x7CD5,
0xB8E3, 0x641E,
0xB8E4, 0x9550,
0xB8E5, 0x7A3F,
0xB8E6, 0x544A,
0xB8E7, 0x54E5,
0xB8E8, 0x6B4C,
0xB8E9, 0x6401,
0xB8EA, 0x6208,
0xB8EB, 0x9E3D,
0xB8EC, 0x80F3,
0xB8ED, 0x7599,
0xB8EE, 0x5272,
0xB8EF, 0x9769,
0xB8F0, 0x845B,
0xB8F1, 0x683C,
0xB8F2, 0x86E4,
0xB8F3, 0x9601,
0xB8F4, 0x9694,
0xB8F5, 0x94EC,
0xB8F6, 0x4E2A,
0xB8F7, 0x5404,
0xB8F8, 0x7ED9,
0xB8F9, 0x6839,
0xB8FA, 0x8DDF,
0xB8FB, 0x8015,
0xB8FC, 0x66F4,
0xB8FD, 0x5E9A,
0xB8FE, 0x7FB9,
0xB942, 0x7B32,
0xB947, 0x7B39,
0xB948, 0x7B3B,
0xB949, 0x7B3D,
0xB950, 0x7B46,
0xB951, 0x7B48,
0xB952, 0x7B4A,
0xB955, 0x7B53,
0xB956, 0x7B55,
0xB957, 0x7B57,
0xB958, 0x7B59,
0xB959, 0x7B5C,
0xB95C, 0x7B61,
0xB96C, 0x7B76,
0xB96D, 0x7B78,
0xB96E, 0x7B7A,
0xB971, 0x7B7F,
0xB983, 0x7B96,
0xB9A1, 0x57C2,
0xB9A2, 0x803F,
0xB9A3, 0x6897,
0xB9A4, 0x5DE5,
0xB9A5, 0x653B,
0xB9A6, 0x529F,
0xB9A7, 0x606D,
0xB9A8, 0x9F9A,
0xB9A9, 0x4F9B,
0xB9AA, 0x8EAC,
0xB9AB, 0x516C,
0xB9AC, 0x5BAB,
0xB9AD, 0x5F13,
0xB9AE, 0x5DE9,
0xB9AF, 0x6C5E,
0xB9B0, 0x62F1,
0xB9B1, 0x8D21,
0xB9B2, 0x5171,
0xB9B3, 0x94A9,
0xB9B4, 0x52FE,
0xB9B5, 0x6C9F,
0xB9B6, 0x82DF,
0xB9B7, 0x72D7,
0xB9B8, 0x57A2,
0xB9B9, 0x6784,
0xB9BA, 0x8D2D,
0xB9BB, 0x591F,
0xB9BC, 0x8F9C,
0xB9BD, 0x83C7,
0xB9BE, 0x5495,
0xB9BF, 0x7B8D,
0xB9C0, 0x4F30,
0xB9C1, 0x6CBD,
0xB9C2, 0x5B64,
0xB9C3, 0x59D1,
0xB9C4, 0x9F13,
0xB9C5, 0x53E4,
0xB9C6, 0x86CA,
0xB9C7, 0x9AA8,
0xB9C8, 0x8C37,
0xB9C9, 0x80A1,
0xB9CA, 0x6545,
0xB9CB, 0x987E,
0xB9CC, 0x56FA,
0xB9CD, 0x96C7,
0xB9CE, 0x522E,
0xB9CF, 0x74DC,
0xB9D0, 0x5250,
0xB9D1, 0x5BE1,
0xB9D2, 0x6302,
0xB9D3, 0x8902,
0xB9D4, 0x4E56,
0xB9D5, 0x62D0,
0xB9D6, 0x602A,
0xB9D7, 0x68FA,
0xB9D8, 0x5173,
0xB9D9, 0x5B98,
0xB9DA, 0x51A0,
0xB9DB, 0x89C2,
0xB9DC, 0x7BA1,
0xB9DD, 0x9986,
0xB9DE, 0x7F50,
0xB9DF, 0x60EF,
0xB9E0, 0x704C,
0xB9E1, 0x8D2F,
0xB9E2, 0x5149,
0xB9E3, 0x5E7F,
0xB9E4, 0x901B,
0xB9E5, 0x7470,
0xB9E6, 0x89C4,
0xB9E7, 0x572D,
0xB9E8, 0x7845,
0xB9E9, 0x5F52,
0xB9EA, 0x9F9F,
0xB9EB, 0x95FA,
0xB9EC, 0x8F68,
0xB9ED, 0x9B3C,
0xB9EE, 0x8BE1,
0xB9EF, 0x7678,
0xB9F0, 0x6842,
0xB9F1, 0x67DC,
0xB9F2, 0x8DEA,
0xB9F3, 0x8D35,
0xB9F4, 0x523D,
0xB9F5, 0x8F8A,
0xB9F6, 0x6EDA,
0xB9F7, 0x68CD,
0xB9F8, 0x9505,
0xB9F9, 0x90ED,
0xB9FA, 0x56FD,
0xB9FB, 0x679C,
0xB9FC, 0x88F9,
0xB9FD, 0x8FC7,
0xB9FE, 0x54C8,
0xBA40, 0x7BC5,
0xBA49, 0x7BD2,
0xBA68, 0x7BFD,
0xBAA0, 0x7C42,
0xBAA1, 0x9AB8,
0xBAA2, 0x5B69,
0xBAA3, 0x6D77,
0xBAA4, 0x6C26,
0xBAA5, 0x4EA5,
0xBAA6, 0x5BB3,
0xBAA7, 0x9A87,
0xBAA8, 0x9163,
0xBAA9, 0x61A8,
0xBAAA, 0x90AF,
0xBAAB, 0x97E9,
0xBAAC, 0x542B,
0xBAAD, 0x6DB5,
0xBAAE, 0x5BD2,
0xBAAF, 0x51FD,
0xBAB0, 0x558A,
0xBAB1, 0x7F55,
0xBAB2, 0x7FF0,
0xBAB3, 0x64BC,
0xBAB4, 0x634D,
0xBAB5, 0x65F1,
0xBAB6, 0x61BE,
0xBAB7, 0x608D,
0xBAB8, 0x710A,
0xBAB9, 0x6C57,
0xBABA, 0x6C49,
0xBABB, 0x592F,
0xBABC, 0x676D,
0xBABD, 0x822A,
0xBABE, 0x58D5,
0xBABF, 0x568E,
0xBAC0, 0x8C6A,
0xBAC1, 0x6BEB,
0xBAC2, 0x90DD,
0xBAC3, 0x597D,
0xBAC4, 0x8017,
0xBAC5, 0x53F7,
0xBAC6, 0x6D69,
0xBAC7, 0x5475,
0xBAC8, 0x559D,
0xBAC9, 0x8377,
0xBACA, 0x83CF,
0xBACB, 0x6838,
0xBACC, 0x79BE,
0xBACD, 0x548C,
0xBACE, 0x4F55,
0xBACF, 0x5408,
0xBAD0, 0x76D2,
0xBAD1, 0x8C89,
0xBAD2, 0x9602,
0xBAD3, 0x6CB3,
0xBAD4, 0x6DB8,
0xBAD5, 0x8D6B,
0xBAD6, 0x8910,
0xBAD7, 0x9E64,
0xBAD8, 0x8D3A,
0xBAD9, 0x563F,
0xBADA, 0x9ED1,
0xBADB, 0x75D5,
0xBADC, 0x5F88,
0xBADD, 0x72E0,
0xBADE, 0x6068,
0xBADF, 0x54FC,
0xBAE0, 0x4EA8,
0xBAE1, 0x6A2A,
0xBAE2, 0x8861,
0xBAE3, 0x6052,
0xBAE4, 0x8F70,
0xBAE5, 0x54C4,
0xBAE6, 0x70D8,
0xBAE7, 0x8679,
0xBAE8, 0x9E3F,
0xBAE9, 0x6D2A,
0xBAEA, 0x5B8F,
0xBAEB, 0x5F18,
0xBAEC, 0x7EA2,
0xBAED, 0x5589,
0xBAEE, 0x4FAF,
0xBAEF, 0x7334,
0xBAF0, 0x543C,
0xBAF1, 0x539A,
0xBAF2, 0x5019,
0xBAF3, 0x540E,
0xBAF4, 0x547C,
0xBAF5, 0x4E4E,
0xBAF6, 0x5FFD,
0xBAF7, 0x745A,
0xBAF8, 0x58F6,
0xBAF9, 0x846B,
0xBAFA, 0x80E1,
0xBAFB, 0x8774,
0xBAFC, 0x72D0,
0xBAFD, 0x7CCA,
0xBAFE, 0x6E56,
0xBB80, 0x7C88,
0xBB8A, 0x7C96,
0xBB90, 0x7CA3,
0xBBA1, 0x5F27,
0xBBA2, 0x864E,
0xBBA3, 0x552C,
0xBBA4, 0x62A4,
0xBBA5, 0x4E92,
0xBBA6, 0x6CAA,
0xBBA7, 0x6237,
0xBBA8, 0x82B1,
0xBBA9, 0x54D7,
0xBBAA, 0x534E,
0xBBAB, 0x733E,
0xBBAC, 0x6ED1,
0xBBAD, 0x753B,
0xBBAE, 0x5212,
0xBBAF, 0x5316,
0xBBB0, 0x8BDD,
0xBBB1, 0x69D0,
0xBBB2, 0x5F8A,
0xBBB3, 0x6000,
0xBBB4, 0x6DEE,
0xBBB5, 0x574F,
0xBBB6, 0x6B22,
0xBBB7, 0x73AF,
0xBBB8, 0x6853,
0xBBB9, 0x8FD8,
0xBBBA, 0x7F13,
0xBBBB, 0x6362,
0xBBBC, 0x60A3,
0xBBBD, 0x5524,
0xBBBE, 0x75EA,
0xBBBF, 0x8C62,
0xBBC0, 0x7115,
0xBBC1, 0x6DA3,
0xBBC2, 0x5BA6,
0xBBC3, 0x5E7B,
0xBBC4, 0x8352,
0xBBC5, 0x614C,
0xBBC6, 0x9EC4,
0xBBC7, 0x78FA,
0xBBC8, 0x8757,
0xBBC9, 0x7C27,
0xBBCA, 0x7687,
0xBBCB, 0x51F0,
0xBBCC, 0x60F6,
0xBBCD, 0x714C,
0xBBCE, 0x6643,
0xBBCF, 0x5E4C,
0xBBD0, 0x604D,
0xBBD1, 0x8C0E,
0xBBD2, 0x7070,
0xBBD3, 0x6325,
0xBBD4, 0x8F89,
0xBBD5, 0x5FBD,
0xBBD6, 0x6062,
0xBBD7, 0x86D4,
0xBBD8, 0x56DE,
0xBBD9, 0x6BC1,
0xBBDA, 0x6094,
0xBBDB, 0x6167,
0xBBDC, 0x5349,
0xBBDD, 0x60E0,
0xBBDE, 0x6666,
0xBBDF, 0x8D3F,
0xBBE0, 0x79FD,
0xBBE1, 0x4F1A,
0xBBE2, 0x70E9,
0xBBE3, 0x6C47,
0xBBE4, 0x8BB3,
0xBBE5, 0x8BF2,
0xBBE6, 0x7ED8,
0xBBE7, 0x8364,
0xBBE8, 0x660F,
0xBBE9, 0x5A5A,
0xBBEA, 0x9B42,
0xBBEB, 0x6D51,
0xBBEC, 0x6DF7,
0xBBED, 0x8C41,
0xBBEE, 0x6D3B,
0xBBEF, 0x4F19,
0xBBF0, 0x706B,
0xBBF1, 0x83B7,
0xBBF2, 0x6216,
0xBBF3, 0x60D1,
0xBBF4, 0x970D,
0xBBF5, 0x8D27,
0xBBF6, 0x7978,
0xBBF7, 0x51FB,
0xBBF8, 0x573E,
0xBBF9, 0x57FA,
0xBBFA, 0x673A,
0xBBFB, 0x7578,
0xBBFC, 0x7A3D,
0xBBFD, 0x79EF,
0xBBFE, 0x7B95,
0xBC45, 0x7CC6,
0xBC46, 0x7CC9,
0xBC47, 0x7CCB,
0xBC4F, 0x7CD8,
0xBC8F, 0x7D21,
0xBCA1, 0x808C,
0xBCA2, 0x9965,
0xBCA3, 0x8FF9,
0xBCA4, 0x6FC0,
0xBCA5, 0x8BA5,
0xBCA6, 0x9E21,
0xBCA7, 0x59EC,
0xBCA8, 0x7EE9,
0xBCA9, 0x7F09,
0xBCAA, 0x5409,
0xBCAB, 0x6781,
0xBCAC, 0x68D8,
0xBCAD, 0x8F91,
0xBCAE, 0x7C4D,
0xBCAF, 0x96C6,
0xBCB0, 0x53CA,
0xBCB1, 0x6025,
0xBCB2, 0x75BE,
0xBCB3, 0x6C72,
0xBCB4, 0x5373,
0xBCB5, 0x5AC9,
0xBCB6, 0x7EA7,
0xBCB7, 0x6324,
0xBCB8, 0x51E0,
0xBCB9, 0x810A,
0xBCBA, 0x5DF1,
0xBCBB, 0x84DF,
0xBCBC, 0x6280,
0xBCBD, 0x5180,
0xBCBE, 0x5B63,
0xBCBF, 0x4F0E,
0xBCC0, 0x796D,
0xBCC1, 0x5242,
0xBCC2, 0x60B8,
0xBCC3, 0x6D4E,
0xBCC4, 0x5BC4,
0xBCC5, 0x5BC2,
0xBCC6, 0x8BA1,
0xBCC7, 0x8BB0,
0xBCC8, 0x65E2,
0xBCC9, 0x5FCC,
0xBCCA, 0x9645,
0xBCCB, 0x5993,
0xBCCC, 0x7EE7,
0xBCCD, 0x7EAA,
0xBCCE, 0x5609,
0xBCCF, 0x67B7,
0xBCD0, 0x5939,
0xBCD1, 0x4F73,
0xBCD2, 0x5BB6,
0xBCD3, 0x52A0,
0xBCD4, 0x835A,
0xBCD5, 0x988A,
0xBCD6, 0x8D3E,
0xBCD7, 0x7532,
0xBCD8, 0x94BE,
0xBCD9, 0x5047,
0xBCDA, 0x7A3C,
0xBCDB, 0x4EF7,
0xBCDC, 0x67B6,
0xBCDD, 0x9A7E,
0xBCDE, 0x5AC1,
0xBCDF, 0x6B7C,
0xBCE0, 0x76D1,
0xBCE1, 0x575A,
0xBCE2, 0x5C16,
0xBCE3, 0x7B3A,
0xBCE4, 0x95F4,
0xBCE5, 0x714E,
0xBCE6, 0x517C,
0xBCE7, 0x80A9,
0xBCE8, 0x8270,
0xBCE9, 0x5978,
0xBCEA, 0x7F04,
0xBCEB, 0x8327,
0xBCEC, 0x68C0,
0xBCED, 0x67EC,
0xBCEE, 0x78B1,
0xBCEF, 0x7877,
0xBCF0, 0x62E3,
0xBCF1, 0x6361,
0xBCF2, 0x7B80,
0xBCF3, 0x4FED,
0xBCF4, 0x526A,
0xBCF5, 0x51CF,
0xBCF6, 0x8350,
0xBCF7, 0x69DB,
0xBCF8, 0x9274,
0xBCF9, 0x8DF5,
0xBCFA, 0x8D31,
0xBCFB, 0x89C1,
0xBCFC, 0x952E,
0xBCFD, 0x7BAD,
0xBCFE, 0x4EF6,
0xBDA1, 0x5065,
0xBDA2, 0x8230,
0xBDA3, 0x5251,
0xBDA4, 0x996F,
0xBDA5, 0x6E10,
0xBDA6, 0x6E85,
0xBDA7, 0x6DA7,
0xBDA8, 0x5EFA,
0xBDA9, 0x50F5,
0xBDAA, 0x59DC,
0xBDAB, 0x5C06,
0xBDAC, 0x6D46,
0xBDAD, 0x6C5F,
0xBDAE, 0x7586,
0xBDAF, 0x848B,
0xBDB0, 0x6868,
0xBDB1, 0x5956,
0xBDB2, 0x8BB2,
0xBDB3, 0x5320,
0xBDB4, 0x9171,
0xBDB5, 0x964D,
0xBDB6, 0x8549,
0xBDB7, 0x6912,
0xBDB8, 0x7901,
0xBDB9, 0x7126,
0xBDBA, 0x80F6,
0xBDBB, 0x4EA4,
0xBDBC, 0x90CA,
0xBDBD, 0x6D47,
0xBDBE, 0x9A84,
0xBDBF, 0x5A07,
0xBDC0, 0x56BC,
0xBDC1, 0x6405,
0xBDC2, 0x94F0,
0xBDC3, 0x77EB,
0xBDC4, 0x4FA5,
0xBDC5, 0x811A,
0xBDC6, 0x72E1,
0xBDC7, 0x89D2,
0xBDC8, 0x997A,
0xBDC9, 0x7F34,
0xBDCA, 0x7EDE,
0xBDCB, 0x527F,
0xBDCC, 0x6559,
0xBDCD, 0x9175,
0xBDCE, 0x8F7F,
0xBDCF, 0x8F83,
0xBDD0, 0x53EB,
0xBDD1, 0x7A96,
0xBDD2, 0x63ED,
0xBDD3, 0x63A5,
0xBDD4, 0x7686,
0xBDD5, 0x79F8,
0xBDD6, 0x8857,
0xBDD7, 0x9636,
0xBDD8, 0x622A,
0xBDD9, 0x52AB,
0xBDDA, 0x8282,
0xBDDB, 0x6854,
0xBDDC, 0x6770,
0xBDDD, 0x6377,
0xBDDE, 0x776B,
0xBDDF, 0x7AED,
0xBDE0, 0x6D01,
0xBDE1, 0x7ED3,
0xBDE2, 0x89E3,
0xBDE3, 0x59D0,
0xBDE4, 0x6212,
0xBDE5, 0x85C9,
0xBDE6, 0x82A5,
0xBDE7, 0x754C,
0xBDE8, 0x501F,
0xBDE9, 0x4ECB,
0xBDEA, 0x75A5,
0xBDEB, 0x8BEB,
0xBDEC, 0x5C4A,
0xBDED, 0x5DFE,
0xBDEE, 0x7B4B,
0xBDEF, 0x65A4,
0xBDF0, 0x91D1,
0xBDF1, 0x4ECA,
0xBDF2, 0x6D25,
0xBDF3, 0x895F,
0xBDF4, 0x7D27,
0xBDF5, 0x9526,
0xBDF6, 0x4EC5,
0xBDF7, 0x8C28,
0xBDF8, 0x8FDB,
0xBDF9, 0x9773,
0xBDFA, 0x664B,
0xBDFB, 0x7981,
0xBDFC, 0x8FD1,
0xBDFD, 0x70EC,
0xBDFE, 0x6D78,
0xBEA1, 0x5C3D,
0xBEA2, 0x52B2,
0xBEA3, 0x8346,
0xBEA4, 0x5162,
0xBEA5, 0x830E,
0xBEA6, 0x775B,
0xBEA7, 0x6676,
0xBEA8, 0x9CB8,
0xBEA9, 0x4EAC,
0xBEAA, 0x60CA,
0xBEAB, 0x7CBE,
0xBEAC, 0x7CB3,
0xBEAD, 0x7ECF,
0xBEAE, 0x4E95,
0xBEAF, 0x8B66,
0xBEB0, 0x666F,
0xBEB1, 0x9888,
0xBEB2, 0x9759,
0xBEB3, 0x5883,
0xBEB4, 0x656C,
0xBEB5, 0x955C,
0xBEB6, 0x5F84,
0xBEB7, 0x75C9,
0xBEB8, 0x9756,
0xBEB9, 0x7ADF,
0xBEBA, 0x7ADE,
0xBEBB, 0x51C0,
0xBEBC, 0x70AF,
0xBEBD, 0x7A98,
0xBEBE, 0x63EA,
0xBEBF, 0x7A76,
0xBEC0, 0x7EA0,
0xBEC1, 0x7396,
0xBEC2, 0x97ED,
0xBEC3, 0x4E45,
0xBEC4, 0x7078,
0xBEC5, 0x4E5D,
0xBEC6, 0x9152,
0xBEC7, 0x53A9,
0xBEC8, 0x6551,
0xBEC9, 0x65E7,
0xBECA, 0x81FC,
0xBECB, 0x8205,
0xBECC, 0x548E,
0xBECD, 0x5C31,
0xBECE, 0x759A,
0xBECF, 0x97A0,
0xBED0, 0x62D8,
0xBED1, 0x72D9,
0xBED2, 0x75BD,
0xBED3, 0x5C45,
0xBED4, 0x9A79,
0xBED5, 0x83CA,
0xBED6, 0x5C40,
0xBED7, 0x5480,
0xBED8, 0x77E9,
0xBED9, 0x4E3E,
0xBEDA, 0x6CAE,
0xBEDB, 0x805A,
0xBEDC, 0x62D2,
0xBEDD, 0x636E,
0xBEDE, 0x5DE8,
0xBEDF, 0x5177,
0xBEE0, 0x8DDD,
0xBEE1, 0x8E1E,
0xBEE2, 0x952F,
0xBEE3, 0x4FF1,
0xBEE4, 0x53E5,
0xBEE5, 0x60E7,
0xBEE6, 0x70AC,
0xBEE7, 0x5267,
0xBEE8, 0x6350,
0xBEE9, 0x9E43,
0xBEEA, 0x5A1F,
0xBEEB, 0x5026,
0xBEEC, 0x7737,
0xBEED, 0x5377,
0xBEEE, 0x7EE2,
0xBEEF, 0x6485,
0xBEF0, 0x652B,
0xBEF1, 0x6289,
0xBEF2, 0x6398,
0xBEF3, 0x5014,
0xBEF4, 0x7235,
0xBEF5, 0x89C9,
0xBEF6, 0x51B3,
0xBEF7, 0x8BC0,
0xBEF8, 0x7EDD,
0xBEF9, 0x5747,
0xBEFA, 0x83CC,
0xBEFB, 0x94A7,
0xBEFC, 0x519B,
0xBEFD, 0x541B,
0xBEFE, 0x5CFB,
0xBF80, 0x7E3A,
0xBFA1, 0x4FCA,
0xBFA2, 0x7AE3,
0xBFA3, 0x6D5A,
0xBFA4, 0x90E1,
0xBFA5, 0x9A8F,
0xBFA6, 0x5580,
0xBFA7, 0x5496,
0xBFA8, 0x5361,
0xBFA9, 0x54AF,
0xBFAA, 0x5F00,
0xBFAB, 0x63E9,
0xBFAC, 0x6977,
0xBFAD, 0x51EF,
0xBFAE, 0x6168,
0xBFAF, 0x520A,
0xBFB0, 0x582A,
0xBFB1, 0x52D8,
0xBFB2, 0x574E,
0xBFB3, 0x780D,
0xBFB4, 0x770B,
0xBFB5, 0x5EB7,
0xBFB6, 0x6177,
0xBFB7, 0x7CE0,
0xBFB8, 0x625B,
0xBFB9, 0x6297,
0xBFBA, 0x4EA2,
0xBFBB, 0x7095,
0xBFBC, 0x8003,
0xBFBD, 0x62F7,
0xBFBE, 0x70E4,
0xBFBF, 0x9760,
0xBFC0, 0x5777,
0xBFC1, 0x82DB,
0xBFC2, 0x67EF,
0xBFC3, 0x68F5,
0xBFC4, 0x78D5,
0xBFC5, 0x9897,
0xBFC6, 0x79D1,
0xBFC7, 0x58F3,
0xBFC8, 0x54B3,
0xBFC9, 0x53EF,
0xBFCA, 0x6E34,
0xBFCB, 0x514B,
0xBFCC, 0x523B,
0xBFCD, 0x5BA2,
0xBFCE, 0x8BFE,
0xBFCF, 0x80AF,
0xBFD0, 0x5543,
0xBFD1, 0x57A6,
0xBFD2, 0x6073,
0xBFD3, 0x5751,
0xBFD4, 0x542D,
0xBFD5, 0x7A7A,
0xBFD6, 0x6050,
0xBFD7, 0x5B54,
0xBFD8, 0x63A7,
0xBFD9, 0x62A0,
0xBFDA, 0x53E3,
0xBFDB, 0x6263,
0xBFDC, 0x5BC7,
0xBFDD, 0x67AF,
0xBFDE, 0x54ED,
0xBFDF, 0x7A9F,
0xBFE0, 0x82E6,
0xBFE1, 0x9177,
0xBFE2, 0x5E93,
0xBFE3, 0x88E4,
0xBFE4, 0x5938,
0xBFE5, 0x57AE,
0xBFE6, 0x630E,
0xBFE7, 0x8DE8,
0xBFE8, 0x80EF,
0xBFE9, 0x5757,
0xBFEA, 0x7B77,
0xBFEB, 0x4FA9,
0xBFEC, 0x5FEB,
0xBFED, 0x5BBD,
0xBFEE, 0x6B3E,
0xBFEF, 0x5321,
0xBFF0, 0x7B50,
0xBFF1, 0x72C2,
0xBFF2, 0x6846,
0xBFF3, 0x77FF,
0xBFF4, 0x7736,
0xBFF5, 0x65F7,
0xBFF6, 0x51B5,
0xBFF7, 0x4E8F,
0xBFF8, 0x76D4,
0xBFF9, 0x5CBF,
0xBFFA, 0x7AA5,
0xBFFB, 0x8475,
0xBFFC, 0x594E,
0xBFFD, 0x9B41,
0xBFFE, 0x5080,
0xC080, 0x7EAE,
0xC081, 0x7EB4,
0xC084, 0x7ED6,
0xC085, 0x7EE4,
0xC086, 0x7EEC,
0xC087, 0x7EF9,
0xC088, 0x7F0A,
0xC089, 0x7F10,
0xC08A, 0x7F1E,
0xC08B, 0x7F37,
0xC08C, 0x7F39,
0xC094, 0x7F43,
0xC0A1, 0x9988,
0xC0A2, 0x6127,
0xC0A3, 0x6E83,
0xC0A4, 0x5764,
0xC0A5, 0x6606,
0xC0A6, 0x6346,
0xC0A7, 0x56F0,
0xC0A8, 0x62EC,
0xC0A9, 0x6269,
0xC0AA, 0x5ED3,
0xC0AB, 0x9614,
0xC0AC, 0x5783,
0xC0AD, 0x62C9,
0xC0AE, 0x5587,
0xC0AF, 0x8721,
0xC0B0, 0x814A,
0xC0B1, 0x8FA3,
0xC0B2, 0x5566,
0xC0B3, 0x83B1,
0xC0B4, 0x6765,
0xC0B5, 0x8D56,
0xC0B6, 0x84DD,
0xC0B7, 0x5A6A,
0xC0B8, 0x680F,
0xC0B9, 0x62E6,
0xC0BA, 0x7BEE,
0xC0BB, 0x9611,
0xC0BC, 0x5170,
0xC0BD, 0x6F9C,
0xC0BE, 0x8C30,
0xC0BF, 0x63FD,
0xC0C0, 0x89C8,
0xC0C1, 0x61D2,
0xC0C2, 0x7F06,
0xC0C3, 0x70C2,
0xC0C4, 0x6EE5,
0xC0C5, 0x7405,
0xC0C6, 0x6994,
0xC0C7, 0x72FC,
0xC0C8, 0x5ECA,
0xC0C9, 0x90CE,
0xC0CA, 0x6717,
0xC0CB, 0x6D6A,
0xC0CC, 0x635E,
0xC0CD, 0x52B3,
0xC0CE, 0x7262,
0xC0CF, 0x8001,
0xC0D0, 0x4F6C,
0xC0D1, 0x59E5,
0xC0D2, 0x916A,
0xC0D3, 0x70D9,
0xC0D4, 0x6D9D,
0xC0D5, 0x52D2,
0xC0D6, 0x4E50,
0xC0D7, 0x96F7,
0xC0D8, 0x956D,
0xC0D9, 0x857E,
0xC0DA, 0x78CA,
0xC0DB, 0x7D2F,
0xC0DC, 0x5121,
0xC0DD, 0x5792,
0xC0DE, 0x64C2,
0xC0DF, 0x808B,
0xC0E0, 0x7C7B,
0xC0E1, 0x6CEA,
0xC0E2, 0x68F1,
0xC0E3, 0x695E,
0xC0E4, 0x51B7,
0xC0E5, 0x5398,
0xC0E6, 0x68A8,
0xC0E7, 0x7281,
0xC0E8, 0x9ECE,
0xC0E9, 0x7BF1,
0xC0EA, 0x72F8,
0xC0EB, 0x79BB,
0xC0EC, 0x6F13,
0xC0ED, 0x7406,
0xC0EE, 0x674E,
0xC0EF, 0x91CC,
0xC0F0, 0x9CA4,
0xC0F1, 0x793C,
0xC0F2, 0x8389,
0xC0F3, 0x8354,
0xC0F4, 0x540F,
0xC0F5, 0x6817,
0xC0F6, 0x4E3D,
0xC0F7, 0x5389,
0xC0F8, 0x52B1,
0xC0F9, 0x783E,
0xC0FA, 0x5386,
0xC0FB, 0x5229,
0xC0FC, 0x5088,
0xC0FD, 0x4F8B,
0xC0FE, 0x4FD0,
0xC140, 0x7F56,
0xC141, 0x7F59,
0xC146, 0x7F60,
0xC151, 0x7F73,
0xC164, 0x7F8B,
0xC165, 0x7F8D,
0xC172, 0x7FA0,
0xC17E, 0x7FB1,
0xC187, 0x7FBE,
0xC188, 0x7FC0,
0xC190, 0x7FCB,
0xC191, 0x7FCD,
0xC1A1, 0x75E2,
0xC1A2, 0x7ACB,
0xC1A3, 0x7C92,
0xC1A4, 0x6CA5,
0xC1A5, 0x96B6,
0xC1A6, 0x529B,
0xC1A7, 0x7483,
0xC1A8, 0x54E9,
0xC1A9, 0x4FE9,
0xC1AA, 0x8054,
0xC1AB, 0x83B2,
0xC1AC, 0x8FDE,
0xC1AD, 0x9570,
0xC1AE, 0x5EC9,
0xC1AF, 0x601C,
0xC1B0, 0x6D9F,
0xC1B1, 0x5E18,
0xC1B2, 0x655B,
0xC1B3, 0x8138,
0xC1B4, 0x94FE,
0xC1B5, 0x604B,
0xC1B6, 0x70BC,
0xC1B7, 0x7EC3,
0xC1B8, 0x7CAE,
0xC1B9, 0x51C9,
0xC1BA, 0x6881,
0xC1BB, 0x7CB1,
0xC1BC, 0x826F,
0xC1BD, 0x4E24,
0xC1BE, 0x8F86,
0xC1BF, 0x91CF,
0xC1C0, 0x667E,
0xC1C1, 0x4EAE,
0xC1C2, 0x8C05,
0xC1C3, 0x64A9,
0xC1C4, 0x804A,
0xC1C5, 0x50DA,
0xC1C6, 0x7597,
0xC1C7, 0x71CE,
0xC1C8, 0x5BE5,
0xC1C9, 0x8FBD,
0xC1CA, 0x6F66,
0xC1CB, 0x4E86,
0xC1CC, 0x6482,
0xC1CD, 0x9563,
0xC1CE, 0x5ED6,
0xC1CF, 0x6599,
0xC1D0, 0x5217,
0xC1D1, 0x88C2,
0xC1D2, 0x70C8,
0xC1D3, 0x52A3,
0xC1D4, 0x730E,
0xC1D5, 0x7433,
0xC1D6, 0x6797,
0xC1D7, 0x78F7,
0xC1D8, 0x9716,
0xC1D9, 0x4E34,
0xC1DA, 0x90BB,
0xC1DB, 0x9CDE,
0xC1DC, 0x6DCB,
0xC1DD, 0x51DB,
0xC1DE, 0x8D41,
0xC1DF, 0x541D,
0xC1E0, 0x62CE,
0xC1E1, 0x73B2,
0xC1E2, 0x83F1,
0xC1E3, 0x96F6,
0xC1E4, 0x9F84,
0xC1E5, 0x94C3,
0xC1E6, 0x4F36,
0xC1E7, 0x7F9A,
0xC1E8, 0x51CC,
0xC1E9, 0x7075,
0xC1EA, 0x9675,
0xC1EB, 0x5CAD,
0xC1EC, 0x9886,
0xC1ED, 0x53E6,
0xC1EE, 0x4EE4,
0xC1EF, 0x6E9C,
0xC1F0, 0x7409,
0xC1F1, 0x69B4,
0xC1F2, 0x786B,
0xC1F3, 0x998F,
0xC1F4, 0x7559,
0xC1F5, 0x5218,
0xC1F6, 0x7624,
0xC1F7, 0x6D41,
0xC1F8, 0x67F3,
0xC1F9, 0x516D,
0xC1FA, 0x9F99,
0xC1FB, 0x804B,
0xC1FC, 0x5499,
0xC1FD, 0x7B3C,
0xC1FE, 0x7ABF,
0xC240, 0x7FE4,
0xC247, 0x7FEF,
0xC248, 0x7FF2,
0xC253, 0x8002,
0xC25A, 0x8011,
0xC25B, 0x8013,
0xC261, 0x8021,
0xC26A, 0x8032,
0xC26B, 0x8034,
0xC26E, 0x803C,
0xC26F, 0x803E,
0xC27B, 0x8053,
0xC280, 0x8059,
0xC2A1, 0x9686,
0xC2A2, 0x5784,
0xC2A3, 0x62E2,
0xC2A4, 0x9647,
0xC2A5, 0x697C,
0xC2A6, 0x5A04,
0xC2A7, 0x6402,
0xC2A8, 0x7BD3,
0xC2A9, 0x6F0F,
0xC2AA, 0x964B,
0xC2AB, 0x82A6,
0xC2AC, 0x5362,
0xC2AD, 0x9885,
0xC2AE, 0x5E90,
0xC2AF, 0x7089,
0xC2B0, 0x63B3,
0xC2B1, 0x5364,
0xC2B2, 0x864F,
0xC2B3, 0x9C81,
0xC2B4, 0x9E93,
0xC2B5, 0x788C,
0xC2B6, 0x9732,
0xC2B7, 0x8DEF,
0xC2B8, 0x8D42,
0xC2B9, 0x9E7F,
0xC2BA, 0x6F5E,
0xC2BB, 0x7984,
0xC2BC, 0x5F55,
0xC2BD, 0x9646,
0xC2BE, 0x622E,
0xC2BF, 0x9A74,
0xC2C0, 0x5415,
0xC2C1, 0x94DD,
0xC2C2, 0x4FA3,
0xC2C3, 0x65C5,
0xC2C4, 0x5C65,
0xC2C5, 0x5C61,
0xC2C6, 0x7F15,
0xC2C7, 0x8651,
0xC2C8, 0x6C2F,
0xC2C9, 0x5F8B,
0xC2CA, 0x7387,
0xC2CB, 0x6EE4,
0xC2CC, 0x7EFF,
0xC2CD, 0x5CE6,
0xC2CE, 0x631B,
0xC2CF, 0x5B6A,
0xC2D0, 0x6EE6,
0xC2D1, 0x5375,
0xC2D2, 0x4E71,
0xC2D3, 0x63A0,
0xC2D4, 0x7565,
0xC2D5, 0x62A1,
0xC2D6, 0x8F6E,
0xC2D7, 0x4F26,
0xC2D8, 0x4ED1,
0xC2D9, 0x6CA6,
0xC2DA, 0x7EB6,
0xC2DB, 0x8BBA,
0xC2DC, 0x841D,
0xC2DD, 0x87BA,
0xC2DE, 0x7F57,
0xC2DF, 0x903B,
0xC2E0, 0x9523,
0xC2E1, 0x7BA9,
0xC2E2, 0x9AA1,
0xC2E3, 0x88F8,
0xC2E4, 0x843D,
0xC2E5, 0x6D1B,
0xC2E6, 0x9A86,
0xC2E7, 0x7EDC,
0xC2E8, 0x5988,
0xC2E9, 0x9EBB,
0xC2EA, 0x739B,
0xC2EB, 0x7801,
0xC2EC, 0x8682,
0xC2ED, 0x9A6C,
0xC2EE, 0x9A82,
0xC2EF, 0x561B,
0xC2F0, 0x5417,
0xC2F1, 0x57CB,
0xC2F2, 0x4E70,
0xC2F3, 0x9EA6,
0xC2F4, 0x5356,
0xC2F5, 0x8FC8,
0xC2F6, 0x8109,
0xC2F7, 0x7792,
0xC2F8, 0x9992,
0xC2F9, 0x86EE,
0xC2FA, 0x6EE1,
0xC2FB, 0x8513,
0xC2FC, 0x66FC,
0xC2FD, 0x6162,
0xC2FE, 0x6F2B,
0xC340, 0x807E,
0xC343, 0x8085,
0xC344, 0x8088,
0xC345, 0x808A,
0xC34E, 0x8097,
0xC34F, 0x8099,
0xC350, 0x809E,
0xC351, 0x80A3,
0xC355, 0x80AC,
0xC356, 0x80B0,
0xC357, 0x80B3,
0xC35C, 0x80BB,
0xC35D, 0x80C5,
0xC36A, 0x80D8,
0xC36F, 0x80E6,
0xC370, 0x80EE,
0xC371, 0x80F5,
0xC372, 0x80F7,
0xC373, 0x80F9,
0xC374, 0x80FB,
0xC37E, 0x810B,
0xC380, 0x810C,
0xC381, 0x8115,
0xC382, 0x8117,
0xC383, 0x8119,
0xC396, 0x8130,
0xC39A, 0x8137,
0xC3A0, 0x813F,
0xC3A1, 0x8C29,
0xC3A2, 0x8292,
0xC3A3, 0x832B,
0xC3A4, 0x76F2,
0xC3A5, 0x6C13,
0xC3A6, 0x5FD9,
0xC3A7, 0x83BD,
0xC3A8, 0x732B,
0xC3A9, 0x8305,
0xC3AA, 0x951A,
0xC3AB, 0x6BDB,
0xC3AC, 0x77DB,
0xC3AD, 0x94C6,
0xC3AE, 0x536F,
0xC3AF, 0x8302,
0xC3B0, 0x5192,
0xC3B1, 0x5E3D,
0xC3B2, 0x8C8C,
0xC3B3, 0x8D38,
0xC3B4, 0x4E48,
0xC3B5, 0x73AB,
0xC3B6, 0x679A,
0xC3B7, 0x6885,
0xC3B8, 0x9176,
0xC3B9, 0x9709,
0xC3BA, 0x7164,
0xC3BB, 0x6CA1,
0xC3BC, 0x7709,
0xC3BD, 0x5A92,
0xC3BE, 0x9541,
0xC3BF, 0x6BCF,
0xC3C0, 0x7F8E,
0xC3C1, 0x6627,
0xC3C2, 0x5BD0,
0xC3C3, 0x59B9,
0xC3C4, 0x5A9A,
0xC3C5, 0x95E8,
0xC3C6, 0x95F7,
0xC3C7, 0x4EEC,
0xC3C8, 0x840C,
0xC3C9, 0x8499,
0xC3CA, 0x6AAC,
0xC3CB, 0x76DF,
0xC3CC, 0x9530,
0xC3CD, 0x731B,
0xC3CE, 0x68A6,
0xC3CF, 0x5B5F,
0xC3D0, 0x772F,
0xC3D1, 0x919A,
0xC3D2, 0x9761,
0xC3D3, 0x7CDC,
0xC3D4, 0x8FF7,
0xC3D5, 0x8C1C,
0xC3D6, 0x5F25,
0xC3D7, 0x7C73,
0xC3D8, 0x79D8,
0xC3D9, 0x89C5,
0xC3DA, 0x6CCC,
0xC3DB, 0x871C,
0xC3DC, 0x5BC6,
0xC3DD, 0x5E42,
0xC3DE, 0x68C9,
0xC3DF, 0x7720,
0xC3E0, 0x7EF5,
0xC3E1, 0x5195,
0xC3E2, 0x514D,
0xC3E3, 0x52C9,
0xC3E4, 0x5A29,
0xC3E5, 0x7F05,
0xC3E6, 0x9762,
0xC3E7, 0x82D7,
0xC3E8, 0x63CF,
0xC3E9, 0x7784,
0xC3EA, 0x85D0,
0xC3EB, 0x79D2,
0xC3EC, 0x6E3A,
0xC3ED, 0x5E99,
0xC3EE, 0x5999,
0xC3EF, 0x8511,
0xC3F0, 0x706D,
0xC3F1, 0x6C11,
0xC3F2, 0x62BF,
0xC3F3, 0x76BF,
0xC3F4, 0x654F,
0xC3F5, 0x60AF,
0xC3F6, 0x95FD,
0xC3F7, 0x660E,
0xC3F8, 0x879F,
0xC3F9, 0x9E23,
0xC3FA, 0x94ED,
0xC3FB, 0x540D,
0xC3FC, 0x547D,
0xC3FD, 0x8C2C,
0xC3FE, 0x6478,
0xC446, 0x8147,
0xC447, 0x8149,
0xC44B, 0x8152,
0xC458, 0x8166,
0xC459, 0x8168,
0xC45D, 0x816F,
0xC464, 0x8181,
0xC46A, 0x8189,
0xC46F, 0x8190,
0xC480, 0x81A7,
0xC481, 0x81A9,
0xC499, 0x81CB,
0xC4A1, 0x6479,
0xC4A2, 0x8611,
0xC4A3, 0x6A21,
0xC4A4, 0x819C,
0xC4A5, 0x78E8,
0xC4A6, 0x6469,
0xC4A7, 0x9B54,
0xC4A8, 0x62B9,
0xC4A9, 0x672B,
0xC4AA, 0x83AB,
0xC4AB, 0x58A8,
0xC4AC, 0x9ED8,
0xC4AD, 0x6CAB,
0xC4AE, 0x6F20,
0xC4AF, 0x5BDE,
0xC4B0, 0x964C,
0xC4B1, 0x8C0B,
0xC4B2, 0x725F,
0xC4B3, 0x67D0,
0xC4B4, 0x62C7,
0xC4B5, 0x7261,
0xC4B6, 0x4EA9,
0xC4B7, 0x59C6,
0xC4B8, 0x6BCD,
0xC4B9, 0x5893,
0xC4BA, 0x66AE,
0xC4BB, 0x5E55,
0xC4BC, 0x52DF,
0xC4BD, 0x6155,
0xC4BE, 0x6728,
0xC4BF, 0x76EE,
0xC4C0, 0x7766,
0xC4C1, 0x7267,
0xC4C2, 0x7A46,
0xC4C3, 0x62FF,
0xC4C4, 0x54EA,
0xC4C5, 0x5450,
0xC4C6, 0x94A0,
0xC4C7, 0x90A3,
0xC4C8, 0x5A1C,
0xC4C9, 0x7EB3,
0xC4CA, 0x6C16,
0xC4CB, 0x4E43,
0xC4CC, 0x5976,
0xC4CD, 0x8010,
0xC4CE, 0x5948,
0xC4CF, 0x5357,
0xC4D0, 0x7537,
0xC4D1, 0x96BE,
0xC4D2, 0x56CA,
0xC4D3, 0x6320,
0xC4D4, 0x8111,
0xC4D5, 0x607C,
0xC4D6, 0x95F9,
0xC4D7, 0x6DD6,
0xC4D8, 0x5462,
0xC4D9, 0x9981,
0xC4DA, 0x5185,
0xC4DB, 0x5AE9,
0xC4DC, 0x80FD,
0xC4DD, 0x59AE,
0xC4DE, 0x9713,
0xC4DF, 0x502A,
0xC4E0, 0x6CE5,
0xC4E1, 0x5C3C,
0xC4E2, 0x62DF,
0xC4E3, 0x4F60,
0xC4E4, 0x533F,
0xC4E5, 0x817B,
0xC4E6, 0x9006,
0xC4E7, 0x6EBA,
0xC4E8, 0x852B,
0xC4E9, 0x62C8,
0xC4EA, 0x5E74,
0xC4EB, 0x78BE,
0xC4EC, 0x64B5,
0xC4ED, 0x637B,
0xC4EE, 0x5FF5,
0xC4EF, 0x5A18,
0xC4F0, 0x917F,
0xC4F1, 0x9E1F,
0xC4F2, 0x5C3F,
0xC4F3, 0x634F,
0xC4F4, 0x8042,
0xC4F5, 0x5B7D,
0xC4F6, 0x556E,
0xC4F7, 0x954A,
0xC4F8, 0x954D,
0xC4F9, 0x6D85,
0xC4FA, 0x60A8,
0xC4FB, 0x67E0,
0xC4FC, 0x72DE,
0xC4FD, 0x51DD,
0xC4FE, 0x5B81,
0xC554, 0x81EB,
0xC560, 0x81FD,
0xC561, 0x81FF,
0xC562, 0x8203,
0xC56A, 0x8211,
0xC56B, 0x8213,
0xC572, 0x821D,
0xC573, 0x8220,
0xC578, 0x8229,
0xC579, 0x822E,
0xC57A, 0x8232,
0xC57B, 0x823A,
0xC57E, 0x823F,
0xC586, 0x8248,
0xC587, 0x824A,
0xC593, 0x8259,
0xC5A0, 0x8269,
0xC5A1, 0x62E7,
0xC5A2, 0x6CDE,
0xC5A3, 0x725B,
0xC5A4, 0x626D,
0xC5A5, 0x94AE,
0xC5A6, 0x7EBD,
0xC5A7, 0x8113,
0xC5A8, 0x6D53,
0xC5A9, 0x519C,
0xC5AA, 0x5F04,
0xC5AB, 0x5974,
0xC5AC, 0x52AA,
0xC5AD, 0x6012,
0xC5AE, 0x5973,
0xC5AF, 0x6696,
0xC5B0, 0x8650,
0xC5B1, 0x759F,
0xC5B2, 0x632A,
0xC5B3, 0x61E6,
0xC5B4, 0x7CEF,
0xC5B5, 0x8BFA,
0xC5B6, 0x54E6,
0xC5B7, 0x6B27,
0xC5B8, 0x9E25,
0xC5B9, 0x6BB4,
0xC5BA, 0x85D5,
0xC5BB, 0x5455,
0xC5BC, 0x5076,
0xC5BD, 0x6CA4,
0xC5BE, 0x556A,
0xC5BF, 0x8DB4,
0xC5C0, 0x722C,
0xC5C1, 0x5E15,
0xC5C2, 0x6015,
0xC5C3, 0x7436,
0xC5C4, 0x62CD,
0xC5C5, 0x6392,
0xC5C6, 0x724C,
0xC5C7, 0x5F98,
0xC5C8, 0x6E43,
0xC5C9, 0x6D3E,
0xC5CA, 0x6500,
0xC5CB, 0x6F58,
0xC5CC, 0x76D8,
0xC5CD, 0x78D0,
0xC5CE, 0x76FC,
0xC5CF, 0x7554,
0xC5D0, 0x5224,
0xC5D1, 0x53DB,
0xC5D2, 0x4E53,
0xC5D3, 0x5E9E,
0xC5D4, 0x65C1,
0xC5D5, 0x802A,
0xC5D6, 0x80D6,
0xC5D7, 0x629B,
0xC5D8, 0x5486,
0xC5D9, 0x5228,
0xC5DA, 0x70AE,
0xC5DB, 0x888D,
0xC5DC, 0x8DD1,
0xC5DD, 0x6CE1,
0xC5DE, 0x5478,
0xC5DF, 0x80DA,
0xC5E0, 0x57F9,
0xC5E1, 0x88F4,
0xC5E2, 0x8D54,
0xC5E3, 0x966A,
0xC5E4, 0x914D,
0xC5E5, 0x4F69,
0xC5E6, 0x6C9B,
0xC5E7, 0x55B7,
0xC5E8, 0x76C6,
0xC5E9, 0x7830,
0xC5EA, 0x62A8,
0xC5EB, 0x70F9,
0xC5EC, 0x6F8E,
0xC5ED, 0x5F6D,
0xC5EE, 0x84EC,
0xC5EF, 0x68DA,
0xC5F0, 0x787C,
0xC5F1, 0x7BF7,
0xC5F2, 0x81A8,
0xC5F3, 0x670B,
0xC5F4, 0x9E4F,
0xC5F5, 0x6367,
0xC5F6, 0x78B0,
0xC5F7, 0x576F,
0xC5F8, 0x7812,
0xC5F9, 0x9739,
0xC5FA, 0x6279,
0xC5FB, 0x62AB,
0xC5FC, 0x5288,
0xC5FD, 0x7435,
0xC5FE, 0x6BD7,
0xC644, 0x8271,
0xC64D, 0x8283,
0xC651, 0x8289,
0xC652, 0x828C,
0xC653, 0x8290,
0xC65A, 0x829E,
0xC65B, 0x82A0,
0xC65E, 0x82A7,
0xC65F, 0x82B2,
0xC66B, 0x82C9,
0xC66C, 0x82D0,
0xC66D, 0x82D6,
0xC670, 0x82DD,
0xC671, 0x82E2,
0xC679, 0x82F0,
0xC67E, 0x82F8,
0xC680, 0x82FA,
0xC688, 0x830D,
0xC689, 0x8310,
0xC68C, 0x8316,
0xC69B, 0x832E,
0xC69C, 0x8330,
0xC69D, 0x8332,
0xC69E, 0x8337,
0xC69F, 0x833B,
0xC6A0, 0x833D,
0xC6A1, 0x5564,
0xC6A2, 0x813E,
0xC6A3, 0x75B2,
0xC6A4, 0x76AE,
0xC6A5, 0x5339,
0xC6A6, 0x75DE,
0xC6A7, 0x50FB,
0xC6A8, 0x5C41,
0xC6A9, 0x8B6C,
0xC6AA, 0x7BC7,
0xC6AB, 0x504F,
0xC6AC, 0x7247,
0xC6AD, 0x9A97,
0xC6AE, 0x98D8,
0xC6AF, 0x6F02,
0xC6B0, 0x74E2,
0xC6B1, 0x7968,
0xC6B2, 0x6487,
0xC6B3, 0x77A5,
0xC6B4, 0x62FC,
0xC6B5, 0x9891,
0xC6B6, 0x8D2B,
0xC6B7, 0x54C1,
0xC6B8, 0x8058,
0xC6B9, 0x4E52,
0xC6BA, 0x576A,
0xC6BB, 0x82F9,
0xC6BC, 0x840D,
0xC6BD, 0x5E73,
0xC6BE, 0x51ED,
0xC6BF, 0x74F6,
0xC6C0, 0x8BC4,
0xC6C1, 0x5C4F,
0xC6C2, 0x5761,
0xC6C3, 0x6CFC,
0xC6C4, 0x9887,
0xC6C5, 0x5A46,
0xC6C6, 0x7834,
0xC6C7, 0x9B44,
0xC6C8, 0x8FEB,
0xC6C9, 0x7C95,
0xC6CA, 0x5256,
0xC6CB, 0x6251,
0xC6CC, 0x94FA,
0xC6CD, 0x4EC6,
0xC6CE, 0x8386,
0xC6CF, 0x8461,
0xC6D0, 0x83E9,
0xC6D1, 0x84B2,
0xC6D2, 0x57D4,
0xC6D3, 0x6734,
0xC6D4, 0x5703,
0xC6D5, 0x666E,
0xC6D6, 0x6D66,
0xC6D7, 0x8C31,
0xC6D8, 0x66DD,
0xC6D9, 0x7011,
0xC6DA, 0x671F,
0xC6DB, 0x6B3A,
0xC6DC, 0x6816,
0xC6DD, 0x621A,
0xC6DE, 0x59BB,
0xC6DF, 0x4E03,
0xC6E0, 0x51C4,
0xC6E1, 0x6F06,
0xC6E2, 0x67D2,
0xC6E3, 0x6C8F,
0xC6E4, 0x5176,
0xC6E5, 0x68CB,
0xC6E6, 0x5947,
0xC6E7, 0x6B67,
0xC6E8, 0x7566,
0xC6E9, 0x5D0E,
0xC6EA, 0x8110,
0xC6EB, 0x9F50,
0xC6EC, 0x65D7,
0xC6ED, 0x7948,
0xC6EE, 0x7941,
0xC6EF, 0x9A91,
0xC6F0, 0x8D77,
0xC6F1, 0x5C82,
0xC6F2, 0x4E5E,
0xC6F3, 0x4F01,
0xC6F4, 0x542F,
0xC6F5, 0x5951,
0xC6F6, 0x780C,
0xC6F7, 0x5668,
0xC6F8, 0x6C14,
0xC6F9, 0x8FC4,
0xC6FA, 0x5F03,
0xC6FB, 0x6C7D,
0xC6FC, 0x6CE3,
0xC6FD, 0x8BAB,
0xC6FE, 0x6390,
0xC746, 0x8348,
0xC74C, 0x8353,
0xC752, 0x835D,
0xC753, 0x8362,
0xC773, 0x839D,
0xC774, 0x839F,
0xC780, 0x83AF,
0xC781, 0x83B5,
0xC782, 0x83BB,
0xC788, 0x83C6,
0xC78B, 0x83CB,
0xC792, 0x83D5,
0xC793, 0x83D7,
0xC797, 0x83DE,
0xC7A1, 0x6070,
0xC7A2, 0x6D3D,
0xC7A3, 0x7275,
0xC7A4, 0x6266,
0xC7A5, 0x948E,
0xC7A6, 0x94C5,
0xC7A7, 0x5343,
0xC7A8, 0x8FC1,
0xC7A9, 0x7B7E,
0xC7AA, 0x4EDF,
0xC7AB, 0x8C26,
0xC7AC, 0x4E7E,
0xC7AD, 0x9ED4,
0xC7AE, 0x94B1,
0xC7AF, 0x94B3,
0xC7B0, 0x524D,
0xC7B1, 0x6F5C,
0xC7B2, 0x9063,
0xC7B3, 0x6D45,
0xC7B4, 0x8C34,
0xC7B5, 0x5811,
0xC7B6, 0x5D4C,
0xC7B7, 0x6B20,
0xC7B8, 0x6B49,
0xC7B9, 0x67AA,
0xC7BA, 0x545B,
0xC7BB, 0x8154,
0xC7BC, 0x7F8C,
0xC7BD, 0x5899,
0xC7BE, 0x8537,
0xC7BF, 0x5F3A,
0xC7C0, 0x62A2,
0xC7C1, 0x6A47,
0xC7C2, 0x9539,
0xC7C3, 0x6572,
0xC7C4, 0x6084,
0xC7C5, 0x6865,
0xC7C6, 0x77A7,
0xC7C7, 0x4E54,
0xC7C8, 0x4FA8,
0xC7C9, 0x5DE7,
0xC7CA, 0x9798,
0xC7CB, 0x64AC,
0xC7CC, 0x7FD8,
0xC7CD, 0x5CED,
0xC7CE, 0x4FCF,
0xC7CF, 0x7A8D,
0xC7D0, 0x5207,
0xC7D1, 0x8304,
0xC7D2, 0x4E14,
0xC7D3, 0x602F,
0xC7D4, 0x7A83,
0xC7D5, 0x94A6,
0xC7D6, 0x4FB5,
0xC7D7, 0x4EB2,
0xC7D8, 0x79E6,
0xC7D9, 0x7434,
0xC7DA, 0x52E4,
0xC7DB, 0x82B9,
0xC7DC, 0x64D2,
0xC7DD, 0x79BD,
0xC7DE, 0x5BDD,
0xC7DF, 0x6C81,
0xC7E0, 0x9752,
0xC7E1, 0x8F7B,
0xC7E2, 0x6C22,
0xC7E3, 0x503E,
0xC7E4, 0x537F,
0xC7E5, 0x6E05,
0xC7E6, 0x64CE,
0xC7E7, 0x6674,
0xC7E8, 0x6C30,
0xC7E9, 0x60C5,
0xC7EA, 0x9877,
0xC7EB, 0x8BF7,
0xC7EC, 0x5E86,
0xC7ED, 0x743C,
0xC7EE, 0x7A77,
0xC7EF, 0x79CB,
0xC7F0, 0x4E18,
0xC7F1, 0x90B1,
0xC7F2, 0x7403,
0xC7F3, 0x6C42,
0xC7F4, 0x56DA,
0xC7F5, 0x914B,
0xC7F6, 0x6CC5,
0xC7F7, 0x8D8B,
0xC7F8, 0x533A,
0xC7F9, 0x86C6,
0xC7FA, 0x66F2,
0xC7FB, 0x8EAF,
0xC7FC, 0x5C48,
0xC7FD, 0x9A71,
0xC7FE, 0x6E20,
0xC84D, 0x8402,
0xC84E, 0x8405,
0xC853, 0x8410,
0xC88C, 0x8458,
0xC891, 0x8462,
0xC897, 0x846A,
0xC89B, 0x8472,
0xC89C, 0x8474,
0xC89D, 0x8477,
0xC89E, 0x8479,
0xC8A1, 0x53D6,
0xC8A2, 0x5A36,
0xC8A3, 0x9F8B,
0xC8A4, 0x8DA3,
0xC8A5, 0x53BB,
0xC8A6, 0x5708,
0xC8A7, 0x98A7,
0xC8A8, 0x6743,
0xC8A9, 0x919B,
0xC8AA, 0x6CC9,
0xC8AB, 0x5168,
0xC8AC, 0x75CA,
0xC8AD, 0x62F3,
0xC8AE, 0x72AC,
0xC8AF, 0x5238,
0xC8B0, 0x529D,
0xC8B1, 0x7F3A,
0xC8B2, 0x7094,
0xC8B3, 0x7638,
0xC8B4, 0x5374,
0xC8B5, 0x9E4A,
0xC8B6, 0x69B7,
0xC8B7, 0x786E,
0xC8B8, 0x96C0,
0xC8B9, 0x88D9,
0xC8BA, 0x7FA4,
0xC8BB, 0x7136,
0xC8BC, 0x71C3,
0xC8BD, 0x5189,
0xC8BE, 0x67D3,
0xC8BF, 0x74E4,
0xC8C0, 0x58E4,
0xC8C1, 0x6518,
0xC8C2, 0x56B7,
0xC8C3, 0x8BA9,
0xC8C4, 0x9976,
0xC8C5, 0x6270,
0xC8C6, 0x7ED5,
0xC8C7, 0x60F9,
0xC8C8, 0x70ED,
0xC8C9, 0x58EC,
0xC8CA, 0x4EC1,
0xC8CB, 0x4EBA,
0xC8CC, 0x5FCD,
0xC8CD, 0x97E7,
0xC8CE, 0x4EFB,
0xC8CF, 0x8BA4,
0xC8D0, 0x5203,
0xC8D1, 0x598A,
0xC8D2, 0x7EAB,
0xC8D3, 0x6254,
0xC8D4, 0x4ECD,
0xC8D5, 0x65E5,
0xC8D6, 0x620E,
0xC8D7, 0x8338,
0xC8D8, 0x84C9,
0xC8D9, 0x8363,
0xC8DA, 0x878D,
0xC8DB, 0x7194,
0xC8DC, 0x6EB6,
0xC8DD, 0x5BB9,
0xC8DE, 0x7ED2,
0xC8DF, 0x5197,
0xC8E0, 0x63C9,
0xC8E1, 0x67D4,
0xC8E2, 0x8089,
0xC8E3, 0x8339,
0xC8E4, 0x8815,
0xC8E5, 0x5112,
0xC8E6, 0x5B7A,
0xC8E7, 0x5982,
0xC8E8, 0x8FB1,
0xC8E9, 0x4E73,
0xC8EA, 0x6C5D,
0xC8EB, 0x5165,
0xC8EC, 0x8925,
0xC8ED, 0x8F6F,
0xC8EE, 0x962E,
0xC8EF, 0x854A,
0xC8F0, 0x745E,
0xC8F1, 0x9510,
0xC8F2, 0x95F0,
0xC8F3, 0x6DA6,
0xC8F4, 0x82E5,
0xC8F5, 0x5F31,
0xC8F6, 0x6492,
0xC8F7, 0x6D12,
0xC8F8, 0x8428,
0xC8F9, 0x816E,
0xC8FA, 0x9CC3,
0xC8FB, 0x585E,
0xC8FC, 0x8D5B,
0xC8FD, 0x4E09,
0xC8FE, 0x53C1,
0xC949, 0x848A,
0xC94A, 0x848D,
0xC953, 0x8498,
0xC969, 0x84B3,
0xC96F, 0x84BE,
0xC970, 0x84C0,
0xC97B, 0x84D2,
0xC97E, 0x84D7,
0xC985, 0x84DE,
0xC988, 0x84E4,
0xC9A1, 0x4F1E,
0xC9A2, 0x6563,
0xC9A3, 0x6851,
0xC9A4, 0x55D3,
0xC9A5, 0x4E27,
0xC9A6, 0x6414,
0xC9A7, 0x9A9A,
0xC9A8, 0x626B,
0xC9A9, 0x5AC2,
0xC9AA, 0x745F,
0xC9AB, 0x8272,
0xC9AC, 0x6DA9,
0xC9AD, 0x68EE,
0xC9AE, 0x50E7,
0xC9AF, 0x838E,
0xC9B0, 0x7802,
0xC9B1, 0x6740,
0xC9B2, 0x5239,
0xC9B3, 0x6C99,
0xC9B4, 0x7EB1,
0xC9B5, 0x50BB,
0xC9B6, 0x5565,
0xC9B7, 0x715E,
0xC9B8, 0x7B5B,
0xC9B9, 0x6652,
0xC9BA, 0x73CA,
0xC9BB, 0x82EB,
0xC9BC, 0x6749,
0xC9BD, 0x5C71,
0xC9BE, 0x5220,
0xC9BF, 0x717D,
0xC9C0, 0x886B,
0xC9C1, 0x95EA,
0xC9C2, 0x9655,
0xC9C3, 0x64C5,
0xC9C4, 0x8D61,
0xC9C5, 0x81B3,
0xC9C6, 0x5584,
0xC9C7, 0x6C55,
0xC9C8, 0x6247,
0xC9C9, 0x7F2E,
0xC9CA, 0x5892,
0xC9CB, 0x4F24,
0xC9CC, 0x5546,
0xC9CD, 0x8D4F,
0xC9CE, 0x664C,
0xC9CF, 0x4E0A,
0xC9D0, 0x5C1A,
0xC9D1, 0x88F3,
0xC9D2, 0x68A2,
0xC9D3, 0x634E,
0xC9D4, 0x7A0D,
0xC9D5, 0x70E7,
0xC9D6, 0x828D,
0xC9D7, 0x52FA,
0xC9D8, 0x97F6,
0xC9D9, 0x5C11,
0xC9DA, 0x54E8,
0xC9DB, 0x90B5,
0xC9DC, 0x7ECD,
0xC9DD, 0x5962,
0xC9DE, 0x8D4A,
0xC9DF, 0x86C7,
0xC9E2, 0x8D66,
0xC9E3, 0x6444,
0xC9E4, 0x5C04,
0xC9E5, 0x6151,
0xC9E6, 0x6D89,
0xC9E7, 0x793E,
0xC9E8, 0x8BBE,
0xC9E9, 0x7837,
0xC9EA, 0x7533,
0xC9EB, 0x547B,
0xC9EC, 0x4F38,
0xC9ED, 0x8EAB,
0xC9EE, 0x6DF1,
0xC9EF, 0x5A20,
0xC9F0, 0x7EC5,
0xC9F1, 0x795E,
0xC9F2, 0x6C88,
0xC9F3, 0x5BA1,
0xC9F4, 0x5A76,
0xC9F5, 0x751A,
0xC9F6, 0x80BE,
0xC9F7, 0x614E,
0xC9F8, 0x6E17,
0xC9F9, 0x58F0,
0xC9FA, 0x751F,
0xC9FB, 0x7525,
0xC9FC, 0x7272,
0xC9FD, 0x5347,
0xC9FE, 0x7EF3,
0xCA4D, 0x8512,
0xCA57, 0x8520,
0xCA97, 0x8573,
0xCAA1, 0x7701,
0xCAA2, 0x76DB,
0xCAA3, 0x5269,
0xCAA4, 0x80DC,
0xCAA5, 0x5723,
0xCAA6, 0x5E08,
0xCAA7, 0x5931,
0xCAA8, 0x72EE,
0xCAA9, 0x65BD,
0xCAAA, 0x6E7F,
0xCAAB, 0x8BD7,
0xCAAC, 0x5C38,
0xCAAD, 0x8671,
0xCAAE, 0x5341,
0xCAAF, 0x77F3,
0xCAB0, 0x62FE,
0xCAB1, 0x65F6,
0xCAB2, 0x4EC0,
0xCAB3, 0x98DF,
0xCAB4, 0x8680,
0xCAB5, 0x5B9E,
0xCAB6, 0x8BC6,
0xCAB7, 0x53F2,
0xCAB8, 0x77E2,
0xCAB9, 0x4F7F,
0xCABA, 0x5C4E,
0xCABB, 0x9A76,
0xCABC, 0x59CB,
0xCABD, 0x5F0F,
0xCABE, 0x793A,
0xCABF, 0x58EB,
0xCAC0, 0x4E16,
0xCAC1, 0x67FF,
0xCAC2, 0x4E8B,
0xCAC3, 0x62ED,
0xCAC4, 0x8A93,
0xCAC5, 0x901D,
0xCAC6, 0x52BF,
0xCAC7, 0x662F,
0xCAC8, 0x55DC,
0xCAC9, 0x566C,
0xCACA, 0x9002,
0xCACB, 0x4ED5,
0xCACC, 0x4F8D,
0xCACD, 0x91CA,
0xCACE, 0x9970,
0xCACF, 0x6C0F,
0xCAD0, 0x5E02,
0xCAD1, 0x6043,
0xCAD2, 0x5BA4,
0xCAD3, 0x89C6,
0xCAD4, 0x8BD5,
0xCAD5, 0x6536,
0xCAD6, 0x624B,
0xCAD7, 0x9996,
0xCAD8, 0x5B88,
0xCAD9, 0x5BFF,
0xCADA, 0x6388,
0xCADB, 0x552E,
0xCADC, 0x53D7,
0xCADD, 0x7626,
0xCADE, 0x517D,
0xCADF, 0x852C,
0xCAE0, 0x67A2,
0xCAE1, 0x68B3,
0xCAE2, 0x6B8A,
0xCAE3, 0x6292,
0xCAE4, 0x8F93,
0xCAE5, 0x53D4,
0xCAE6, 0x8212,
0xCAE7, 0x6DD1,
0xCAE8, 0x758F,
0xCAE9, 0x4E66,
0xCAEA, 0x8D4E,
0xCAEB, 0x5B70,
0xCAEC, 0x719F,
0xCAED, 0x85AF,
0xCAEE, 0x6691,
0xCAEF, 0x66D9,
0xCAF0, 0x7F72,
0xCAF1, 0x8700,
0xCAF2, 0x9ECD,
0xCAF3, 0x9F20,
0xCAF4, 0x5C5E,
0xCAF5, 0x672F,
0xCAF6, 0x8FF0,
0xCAF7, 0x6811,
0xCAF8, 0x675F,
0xCAF9, 0x620D,
0xCAFA, 0x7AD6,
0xCAFB, 0x5885,
0xCAFC, 0x5EB6,
0xCAFD, 0x6570,
0xCAFE, 0x6F31,
0xCB42, 0x8586,
0xCB5F, 0x85A9,
0xCB69, 0x85B8,
0xCB80, 0x85D4,
0xCBA1, 0x6055,
0xCBA2, 0x5237,
0xCBA3, 0x800D,
0xCBA4, 0x6454,
0xCBA5, 0x8870,
0xCBA6, 0x7529,
0xCBA7, 0x5E05,
0xCBA8, 0x6813,
0xCBA9, 0x62F4,
0xCBAA, 0x971C,
0xCBAB, 0x53CC,
0xCBAC, 0x723D,
0xCBAD, 0x8C01,
0xCBAE, 0x6C34,
0xCBAF, 0x7761,
0xCBB0, 0x7A0E,
0xCBB1, 0x542E,
0xCBB2, 0x77AC,
0xCBB3, 0x987A,
0xCBB4, 0x821C,
0xCBB5, 0x8BF4,
0xCBB6, 0x7855,
0xCBB7, 0x6714,
0xCBB8, 0x70C1,
0xCBB9, 0x65AF,
0xCBBA, 0x6495,
0xCBBB, 0x5636,
0xCBBC, 0x601D,
0xCBBD, 0x79C1,
0xCBBE, 0x53F8,
0xCBBF, 0x4E1D,
0xCBC0, 0x6B7B,
0xCBC1, 0x8086,
0xCBC2, 0x5BFA,
0xCBC3, 0x55E3,
0xCBC4, 0x56DB,
0xCBC5, 0x4F3A,
0xCBC6, 0x4F3C,
0xCBC7, 0x9972,
0xCBC8, 0x5DF3,
0xCBC9, 0x677E,
0xCBCA, 0x8038,
0xCBCB, 0x6002,
0xCBCC, 0x9882,
0xCBCD, 0x9001,
0xCBCE, 0x5B8B,
0xCBCF, 0x8BBC,
0xCBD0, 0x8BF5,
0xCBD1, 0x641C,
0xCBD2, 0x8258,
0xCBD3, 0x64DE,
0xCBD4, 0x55FD,
0xCBD5, 0x82CF,
0xCBD6, 0x9165,
0xCBD7, 0x4FD7,
0xCBD8, 0x7D20,
0xCBD9, 0x901F,
0xCBDA, 0x7C9F,
0xCBDB, 0x50F3,
0xCBDC, 0x5851,
0xCBDD, 0x6EAF,
0xCBDE, 0x5BBF,
0xCBDF, 0x8BC9,
0xCBE0, 0x8083,
0xCBE1, 0x9178,
0xCBE2, 0x849C,
0xCBE3, 0x7B97,
0xCBE4, 0x867D,
0xCBE5, 0x968B,
0xCBE6, 0x968F,
0xCBE7, 0x7EE5,
0xCBE8, 0x9AD3,
0xCBE9, 0x788E,
0xCBEA, 0x5C81,
0xCBEB, 0x7A57,
0xCBEC, 0x9042,
0xCBED, 0x96A7,
0xCBEE, 0x795F,
0xCBEF, 0x5B59,
0xCBF0, 0x635F,
0xCBF1, 0x7B0B,
0xCBF2, 0x84D1,
0xCBF3, 0x68AD,
0xCBF4, 0x5506,
0xCBF5, 0x7F29,
0xCBF6, 0x7410,
0xCBF7, 0x7D22,
0xCBF8, 0x9501,
0xCBF9, 0x6240,
0xCBFA, 0x584C,
0xCBFB, 0x4ED6,
0xCBFC, 0x5B83,
0xCBFD, 0x5979,
0xCBFE, 0x5854,
0xCC69, 0x8628,
0xCCA1, 0x736D,
0xCCA2, 0x631E,
0xCCA3, 0x8E4B,
0xCCA4, 0x8E0F,
0xCCA5, 0x80CE,
0xCCA6, 0x82D4,
0xCCA7, 0x62AC,
0xCCA8, 0x53F0,
0xCCA9, 0x6CF0,
0xCCAA, 0x915E,
0xCCAB, 0x592A,
0xCCAC, 0x6001,
0xCCAD, 0x6C70,
0xCCAE, 0x574D,
0xCCAF, 0x644A,
0xCCB0, 0x8D2A,
0xCCB1, 0x762B,
0xCCB2, 0x6EE9,
0xCCB3, 0x575B,
0xCCB4, 0x6A80,
0xCCB5, 0x75F0,
0xCCB6, 0x6F6D,
0xCCB7, 0x8C2D,
0xCCB8, 0x8C08,
0xCCB9, 0x5766,
0xCCBA, 0x6BEF,
0xCCBB, 0x8892,
0xCCBC, 0x78B3,
0xCCBD, 0x63A2,
0xCCBE, 0x53F9,
0xCCBF, 0x70AD,
0xCCC0, 0x6C64,
0xCCC1, 0x5858,
0xCCC2, 0x642A,
0xCCC3, 0x5802,
0xCCC4, 0x68E0,
0xCCC5, 0x819B,
0xCCC6, 0x5510,
0xCCC7, 0x7CD6,
0xCCC8, 0x5018,
0xCCC9, 0x8EBA,
0xCCCA, 0x6DCC,
0xCCCB, 0x8D9F,
0xCCCC, 0x70EB,
0xCCCD, 0x638F,
0xCCCE, 0x6D9B,
0xCCCF, 0x6ED4,
0xCCD0, 0x7EE6,
0xCCD1, 0x8404,
0xCCD2, 0x6843,
0xCCD3, 0x9003,
0xCCD4, 0x6DD8,
0xCCD5, 0x9676,
0xCCD6, 0x8BA8,
0xCCD7, 0x5957,
0xCCD8, 0x7279,
0xCCD9, 0x85E4,
0xCCDA, 0x817E,
0xCCDB, 0x75BC,
0xCCDC, 0x8A8A,
0xCCDD, 0x68AF,
0xCCDE, 0x5254,
0xCCDF, 0x8E22,
0xCCE0, 0x9511,
0xCCE1, 0x63D0,
0xCCE2, 0x9898,
0xCCE3, 0x8E44,
0xCCE4, 0x557C,
0xCCE5, 0x4F53,
0xCCE6, 0x66FF,
0xCCE7, 0x568F,
0xCCE8, 0x60D5,
0xCCE9, 0x6D95,
0xCCEA, 0x5243,
0xCCEB, 0x5C49,
0xCCEC, 0x5929,
0xCCED, 0x6DFB,
0xCCEE, 0x586B,
0xCCEF, 0x7530,
0xCCF0, 0x751C,
0xCCF1, 0x606C,
0xCCF2, 0x8214,
0xCCF3, 0x8146,
0xCCF4, 0x6311,
0xCCF5, 0x6761,
0xCCF6, 0x8FE2,
0xCCF7, 0x773A,
0xCCF8, 0x8DF3,
0xCCF9, 0x8D34,
0xCCFA, 0x94C1,
0xCCFB, 0x5E16,
0xCCFC, 0x5385,
0xCCFD, 0x542C,
0xCCFE, 0x70C3,
0xCD40, 0x866D,
0xCD56, 0x8694,
0xCD64, 0x86AB,
0xCD74, 0x86C5,
0xCD75, 0x86C8,
0xCD7D, 0x86DA,
0xCD7E, 0x86DC,
0xCD80, 0x86DD,
0xCD8C, 0x86EF,
0xCD94, 0x86FF,
0xCD95, 0x8701,
0xCD9F, 0x8714,
0xCDA0, 0x8716,
0xCDA1, 0x6C40,
0xCDA2, 0x5EF7,
0xCDA3, 0x505C,
0xCDA4, 0x4EAD,
0xCDA5, 0x5EAD,
0xCDA6, 0x633A,
0xCDA7, 0x8247,
0xCDA8, 0x901A,
0xCDA9, 0x6850,
0xCDAA, 0x916E,
0xCDAB, 0x77B3,
0xCDAC, 0x540C,
0xCDAD, 0x94DC,
0xCDAE, 0x5F64,
0xCDAF, 0x7AE5,
0xCDB0, 0x6876,
0xCDB1, 0x6345,
0xCDB2, 0x7B52,
0xCDB3, 0x7EDF,
0xCDB4, 0x75DB,
0xCDB5, 0x5077,
0xCDB6, 0x6295,
0xCDB7, 0x5934,
0xCDB8, 0x900F,
0xCDB9, 0x51F8,
0xCDBA, 0x79C3,
0xCDBB, 0x7A81,
0xCDBC, 0x56FE,
0xCDBD, 0x5F92,
0xCDBE, 0x9014,
0xCDBF, 0x6D82,
0xCDC0, 0x5C60,
0xCDC1, 0x571F,
0xCDC2, 0x5410,
0xCDC3, 0x5154,
0xCDC4, 0x6E4D,
0xCDC5, 0x56E2,
0xCDC6, 0x63A8,
0xCDC7, 0x9893,
0xCDC8, 0x817F,
0xCDC9, 0x8715,
0xCDCA, 0x892A,
0xCDCB, 0x9000,
0xCDCC, 0x541E,
0xCDCD, 0x5C6F,
0xCDCE, 0x81C0,
0xCDCF, 0x62D6,
0xCDD0, 0x6258,
0xCDD1, 0x8131,
0xCDD2, 0x9E35,
0xCDD3, 0x9640,
0xCDD4, 0x9A6E,
0xCDD5, 0x9A7C,
0xCDD6, 0x692D,
0xCDD7, 0x59A5,
0xCDD8, 0x62D3,
0xCDD9, 0x553E,
0xCDDA, 0x6316,
0xCDDB, 0x54C7,
0xCDDC, 0x86D9,
0xCDDD, 0x6D3C,
0xCDDE, 0x5A03,
0xCDDF, 0x74E6,
0xCDE0, 0x889C,
0xCDE1, 0x6B6A,
0xCDE2, 0x5916,
0xCDE3, 0x8C4C,
0xCDE4, 0x5F2F,
0xCDE5, 0x6E7E,
0xCDE6, 0x73A9,
0xCDE7, 0x987D,
0xCDE8, 0x4E38,
0xCDE9, 0x70F7,
0xCDEA, 0x5B8C,
0xCDEB, 0x7897,
0xCDEC, 0x633D,
0xCDED, 0x665A,
0xCDEE, 0x7696,
0xCDEF, 0x60CB,
0xCDF0, 0x5B9B,
0xCDF1, 0x5A49,
0xCDF2, 0x4E07,
0xCDF3, 0x8155,
0xCDF4, 0x6C6A,
0xCDF5, 0x738B,
0xCDF6, 0x4EA1,
0xCDF7, 0x6789,
0xCDF8, 0x7F51,
0xCDF9, 0x5F80,
0xCDFA, 0x65FA,
0xCDFB, 0x671B,
0xCDFC, 0x5FD8,
0xCDFD, 0x5984,
0xCDFE, 0x5A01,
0xCE40, 0x8719,
0xCE41, 0x871B,
0xCE42, 0x871D,
0xCE45, 0x8724,
0xCE61, 0x874D,
0xCE69, 0x8758,
0xCE7A, 0x876F,
0xCE7E, 0x8775,
0xCE87, 0x8784,
0xCE8C, 0x878C,
0xCEA1, 0x5DCD,
0xCEA2, 0x5FAE,
0xCEA3, 0x5371,
0xCEA4, 0x97E6,
0xCEA5, 0x8FDD,
0xCEA6, 0x6845,
0xCEA7, 0x56F4,
0xCEA8, 0x552F,
0xCEA9, 0x60DF,
0xCEAA, 0x4E3A,
0xCEAB, 0x6F4D,
0xCEAC, 0x7EF4,
0xCEAD, 0x82C7,
0xCEAE, 0x840E,
0xCEAF, 0x59D4,
0xCEB0, 0x4F1F,
0xCEB1, 0x4F2A,
0xCEB2, 0x5C3E,
0xCEB3, 0x7EAC,
0xCEB4, 0x672A,
0xCEB5, 0x851A,
0xCEB6, 0x5473,
0xCEB7, 0x754F,
0xCEB8, 0x80C3,
0xCEB9, 0x5582,
0xCEBA, 0x9B4F,
0xCEBB, 0x4F4D,
0xCEBC, 0x6E2D,
0xCEBD, 0x8C13,
0xCEBE, 0x5C09,
0xCEBF, 0x6170,
0xCEC0, 0x536B,
0xCEC1, 0x761F,
0xCEC2, 0x6E29,
0xCEC3, 0x868A,
0xCEC4, 0x6587,
0xCEC5, 0x95FB,
0xCEC6, 0x7EB9,
0xCEC7, 0x543B,
0xCEC8, 0x7A33,
0xCEC9, 0x7D0A,
0xCECA, 0x95EE,
0xCECB, 0x55E1,
0xCECC, 0x7FC1,
0xCECD, 0x74EE,
0xCECE, 0x631D,
0xCECF, 0x8717,
0xCED0, 0x6DA1,
0xCED1, 0x7A9D,
0xCED2, 0x6211,
0xCED3, 0x65A1,
0xCED4, 0x5367,
0xCED5, 0x63E1,
0xCED6, 0x6C83,
0xCED7, 0x5DEB,
0xCED8, 0x545C,
0xCED9, 0x94A8,
0xCEDA, 0x4E4C,
0xCEDB, 0x6C61,
0xCEDC, 0x8BEC,
0xCEDD, 0x5C4B,
0xCEDE, 0x65E0,
0xCEDF, 0x829C,
0xCEE0, 0x68A7,
0xCEE1, 0x543E,
0xCEE2, 0x5434,
0xCEE3, 0x6BCB,
0xCEE4, 0x6B66,
0xCEE5, 0x4E94,
0xCEE6, 0x6342,
0xCEE7, 0x5348,
0xCEE8, 0x821E,
0xCEE9, 0x4F0D,
0xCEEA, 0x4FAE,
0xCEEB, 0x575E,
0xCEEC, 0x620A,
0xCEED, 0x96FE,
0xCEEE, 0x6664,
0xCEEF, 0x7269,
0xCEF0, 0x52FF,
0xCEF1, 0x52A1,
0xCEF2, 0x609F,
0xCEF3, 0x8BEF,
0xCEF4, 0x6614,
0xCEF5, 0x7199,
0xCEF6, 0x6790,
0xCEF7, 0x897F,
0xCEF8, 0x7852,
0xCEF9, 0x77FD,
0xCEFA, 0x6670,
0xCEFB, 0x563B,
0xCEFC, 0x5438,
0xCEFD, 0x9521,
0xCEFE, 0x727A,
0xCF45, 0x87AE,
0xCF49, 0x87B4,
0xCF96, 0x8814,
0xCFA0, 0x8823,
0xCFA1, 0x7A00,
0xCFA2, 0x606F,
0xCFA3, 0x5E0C,
0xCFA4, 0x6089,
0xCFA5, 0x819D,
0xCFA6, 0x5915,
0xCFA7, 0x60DC,
0xCFA8, 0x7184,
0xCFA9, 0x70EF,
0xCFAA, 0x6EAA,
0xCFAB, 0x6C50,
0xCFAC, 0x7280,
0xCFAD, 0x6A84,
0xCFAE, 0x88AD,
0xCFAF, 0x5E2D,
0xCFB0, 0x4E60,
0xCFB1, 0x5AB3,
0xCFB2, 0x559C,
0xCFB3, 0x94E3,
0xCFB4, 0x6D17,
0xCFB5, 0x7CFB,
0xCFB6, 0x9699,
0xCFB7, 0x620F,
0xCFB8, 0x7EC6,
0xCFB9, 0x778E,
0xCFBA, 0x867E,
0xCFBB, 0x5323,
0xCFBC, 0x971E,
0xCFBD, 0x8F96,
0xCFBE, 0x6687,
0xCFBF, 0x5CE1,
0xCFC0, 0x4FA0,
0xCFC1, 0x72ED,
0xCFC2, 0x4E0B,
0xCFC3, 0x53A6,
0xCFC4, 0x590F,
0xCFC5, 0x5413,
0xCFC6, 0x6380,
0xCFC7, 0x9528,
0xCFC8, 0x5148,
0xCFC9, 0x4ED9,
0xCFCA, 0x9C9C,
0xCFCB, 0x7EA4,
0xCFCC, 0x54B8,
0xCFCD, 0x8D24,
0xCFCE, 0x8854,
0xCFCF, 0x8237,
0xCFD0, 0x95F2,
0xCFD1, 0x6D8E,
0xCFD2, 0x5F26,
0xCFD3, 0x5ACC,
0xCFD4, 0x663E,
0xCFD5, 0x9669,
0xCFD6, 0x73B0,
0xCFD7, 0x732E,
0xCFD8, 0x53BF,
0xCFD9, 0x817A,
0xCFDA, 0x9985,
0xCFDB, 0x7FA1,
0xCFDC, 0x5BAA,
0xCFDD, 0x9677,
0xCFDE, 0x9650,
0xCFDF, 0x7EBF,
0xCFE0, 0x76F8,
0xCFE1, 0x53A2,
0xCFE2, 0x9576,
0xCFE3, 0x9999,
0xCFE4, 0x7BB1,
0xCFE5, 0x8944,
0xCFE6, 0x6E58,
0xCFE7, 0x4E61,
0xCFE8, 0x7FD4,
0xCFE9, 0x7965,
0xCFEA, 0x8BE6,
0xCFEB, 0x60F3,
0xCFEC, 0x54CD,
0xCFED, 0x4EAB,
0xCFEE, 0x9879,
0xCFEF, 0x5DF7,
0xCFF0, 0x6A61,
0xCFF1, 0x50CF,
0xCFF2, 0x5411,
0xCFF3, 0x8C61,
0xCFF4, 0x8427,
0xCFF5, 0x785D,
0xCFF6, 0x9704,
0xCFF7, 0x524A,
0xCFF8, 0x54EE,
0xCFF9, 0x56A3,
0xCFFA, 0x9500,
0xCFFB, 0x6D88,
0xCFFC, 0x5BB5,
0xCFFD, 0x6DC6,
0xCFFE, 0x6653,
0xD06A, 0x8858,
0xD074, 0x886A,
0xD075, 0x886D,
0xD076, 0x886F,
0xD077, 0x8871,
0xD082, 0x8880,
0xD083, 0x8883,
0xD088, 0x888C,
0xD09A, 0x88A3,
0xD0A1, 0x5C0F,
0xD0A2, 0x5B5D,
0xD0A3, 0x6821,
0xD0A4, 0x8096,
0xD0A5, 0x5578,
0xD0A6, 0x7B11,
0xD0A7, 0x6548,
0xD0A8, 0x6954,
0xD0A9, 0x4E9B,
0xD0AA, 0x6B47,
0xD0AB, 0x874E,
0xD0AC, 0x978B,
0xD0AD, 0x534F,
0xD0AE, 0x631F,
0xD0AF, 0x643A,
0xD0B0, 0x90AA,
0xD0B1, 0x659C,
0xD0B2, 0x80C1,
0xD0B3, 0x8C10,
0xD0B4, 0x5199,
0xD0B5, 0x68B0,
0xD0B6, 0x5378,
0xD0B7, 0x87F9,
0xD0B8, 0x61C8,
0xD0B9, 0x6CC4,
0xD0BA, 0x6CFB,
0xD0BB, 0x8C22,
0xD0BC, 0x5C51,
0xD0BD, 0x85AA,
0xD0BE, 0x82AF,
0xD0BF, 0x950C,
0xD0C0, 0x6B23,
0xD0C1, 0x8F9B,
0xD0C2, 0x65B0,
0xD0C3, 0x5FFB,
0xD0C4, 0x5FC3,
0xD0C5, 0x4FE1,
0xD0C6, 0x8845,
0xD0C7, 0x661F,
0xD0C8, 0x8165,
0xD0C9, 0x7329,
0xD0CA, 0x60FA,
0xD0CB, 0x5174,
0xD0CC, 0x5211,
0xD0CD, 0x578B,
0xD0CE, 0x5F62,
0xD0CF, 0x90A2,
0xD0D0, 0x884C,
0xD0D1, 0x9192,
0xD0D2, 0x5E78,
0xD0D3, 0x674F,
0xD0D4, 0x6027,
0xD0D5, 0x59D3,
0xD0D6, 0x5144,
0xD0D7, 0x51F6,
0xD0D8, 0x80F8,
0xD0D9, 0x5308,
0xD0DA, 0x6C79,
0xD0DB, 0x96C4,
0xD0DC, 0x718A,
0xD0DD, 0x4F11,
0xD0DE, 0x4FEE,
0xD0DF, 0x7F9E,
0xD0E0, 0x673D,
0xD0E1, 0x55C5,
0xD0E2, 0x9508,
0xD0E3, 0x79C0,
0xD0E4, 0x8896,
0xD0E5, 0x7EE3,
0xD0E6, 0x589F,
0xD0E7, 0x620C,
0xD0E8, 0x9700,
0xD0E9, 0x865A,
0xD0EA, 0x5618,
0xD0EB, 0x987B,
0xD0EC, 0x5F90,
0xD0ED, 0x8BB8,
0xD0EE, 0x84C4,
0xD0EF, 0x9157,
0xD0F0, 0x53D9,
0xD0F1, 0x65ED,
0xD0F2, 0x5E8F,
0xD0F3, 0x755C,
0xD0F4, 0x6064,
0xD0F5, 0x7D6E,
0xD0F6, 0x5A7F,
0xD0F7, 0x7EEA,
0xD0F8, 0x7EED,
0xD0F9, 0x8F69,
0xD0FA, 0x55A7,
0xD0FB, 0x5BA3,
0xD0FC, 0x60AC,
0xD0FD, 0x65CB,
0xD0FE, 0x7384,
0xD140, 0x88AC,
0xD15C, 0x88D3,
0xD16F, 0x88F2,
0xD175, 0x88FD,
0xD180, 0x8909,
0xD186, 0x8911,
0xD19F, 0x8935,
0xD1A0, 0x8937,
0xD1A1, 0x9009,
0xD1A2, 0x7663,
0xD1A3, 0x7729,
0xD1A4, 0x7EDA,
0xD1A5, 0x9774,
0xD1A6, 0x859B,
0xD1A7, 0x5B66,
0xD1A8, 0x7A74,
0xD1A9, 0x96EA,
0xD1AA, 0x8840,
0xD1AB, 0x52CB,
0xD1AC, 0x718F,
0xD1AD, 0x5FAA,
0xD1AE, 0x65EC,
0xD1AF, 0x8BE2,
0xD1B0, 0x5BFB,
0xD1B1, 0x9A6F,
0xD1B2, 0x5DE1,
0xD1B3, 0x6B89,
0xD1B4, 0x6C5B,
0xD1B5, 0x8BAD,
0xD1B6, 0x8BAF,
0xD1B7, 0x900A,
0xD1B8, 0x8FC5,
0xD1B9, 0x538B,
0xD1BA, 0x62BC,
0xD1BB, 0x9E26,
0xD1BC, 0x9E2D,
0xD1BD, 0x5440,
0xD1BE, 0x4E2B,
0xD1BF, 0x82BD,
0xD1C0, 0x7259,
0xD1C1, 0x869C,
0xD1C2, 0x5D16,
0xD1C3, 0x8859,
0xD1C4, 0x6DAF,
0xD1C5, 0x96C5,
0xD1C6, 0x54D1,
0xD1C7, 0x4E9A,
0xD1C8, 0x8BB6,
0xD1C9, 0x7109,
0xD1CA, 0x54BD,
0xD1CB, 0x9609,
0xD1CC, 0x70DF,
0xD1CD, 0x6DF9,
0xD1CE, 0x76D0,
0xD1CF, 0x4E25,
0xD1D0, 0x7814,
0xD1D1, 0x8712,
0xD1D2, 0x5CA9,
0xD1D3, 0x5EF6,
0xD1D4, 0x8A00,
0xD1D5, 0x989C,
0xD1D6, 0x960E,
0xD1D7, 0x708E,
0xD1D8, 0x6CBF,
0xD1D9, 0x5944,
0xD1DA, 0x63A9,
0xD1DB, 0x773C,
0xD1DC, 0x884D,
0xD1DD, 0x6F14,
0xD1DE, 0x8273,
0xD1DF, 0x5830,
0xD1E0, 0x71D5,
0xD1E1, 0x538C,
0xD1E2, 0x781A,
0xD1E3, 0x96C1,
0xD1E4, 0x5501,
0xD1E5, 0x5F66,
0xD1E6, 0x7130,
0xD1E7, 0x5BB4,
0xD1E8, 0x8C1A,
0xD1E9, 0x9A8C,
0xD1EA, 0x6B83,
0xD1EB, 0x592E,
0xD1EC, 0x9E2F,
0xD1ED, 0x79E7,
0xD1EE, 0x6768,
0xD1EF, 0x626C,
0xD1F0, 0x4F6F,
0xD1F1, 0x75A1,
0xD1F2, 0x7F8A,
0xD1F3, 0x6D0B,
0xD1F4, 0x9633,
0xD1F5, 0x6C27,
0xD1F6, 0x4EF0,
0xD1F7, 0x75D2,
0xD1F8, 0x517B,
0xD1F9, 0x6837,
0xD1FA, 0x6F3E,
0xD1FB, 0x9080,
0xD1FC, 0x8170,
0xD1FD, 0x5996,
0xD1FE, 0x7476,
0xD27E, 0x897C,
0xD282, 0x8980,
0xD283, 0x8982,
0xD2A1, 0x6447,
0xD2A2, 0x5C27,
0xD2A3, 0x9065,
0xD2A4, 0x7A91,
0xD2A5, 0x8C23,
0xD2A6, 0x59DA,
0xD2A7, 0x54AC,
0xD2A8, 0x8200,
0xD2A9, 0x836F,
0xD2AA, 0x8981,
0xD2AB, 0x8000,
0xD2AC, 0x6930,
0xD2AD, 0x564E,
0xD2AE, 0x8036,
0xD2AF, 0x7237,
0xD2B0, 0x91CE,
0xD2B1, 0x51B6,
0xD2B2, 0x4E5F,
0xD2B3, 0x9875,
0xD2B4, 0x6396,
0xD2B5, 0x4E1A,
0xD2B6, 0x53F6,
0xD2B7, 0x66F3,
0xD2B8, 0x814B,
0xD2B9, 0x591C,
0xD2BA, 0x6DB2,
0xD2BB, 0x4E00,
0xD2BC, 0x58F9,
0xD2BD, 0x533B,
0xD2BE, 0x63D6,
0xD2BF, 0x94F1,
0xD2C0, 0x4F9D,
0xD2C1, 0x4F0A,
0xD2C2, 0x8863,
0xD2C3, 0x9890,
0xD2C4, 0x5937,
0xD2C5, 0x9057,
0xD2C6, 0x79FB,
0xD2C7, 0x4EEA,
0xD2C8, 0x80F0,
0xD2C9, 0x7591,
0xD2CA, 0x6C82,
0xD2CB, 0x5B9C,
0xD2CC, 0x59E8,
0xD2CD, 0x5F5D,
0xD2CE, 0x6905,
0xD2CF, 0x8681,
0xD2D0, 0x501A,
0xD2D1, 0x5DF2,
0xD2D2, 0x4E59,
0xD2D3, 0x77E3,
0xD2D4, 0x4EE5,
0xD2D5, 0x827A,
0xD2D6, 0x6291,
0xD2D7, 0x6613,
0xD2D8, 0x9091,
0xD2D9, 0x5C79,
0xD2DA, 0x4EBF,
0xD2DB, 0x5F79,
0xD2DC, 0x81C6,
0xD2DD, 0x9038,
0xD2DE, 0x8084,
0xD2DF, 0x75AB,
0xD2E0, 0x4EA6,
0xD2E1, 0x88D4,
0xD2E2, 0x610F,
0xD2E3, 0x6BC5,
0xD2E4, 0x5FC6,
0xD2E5, 0x4E49,
0xD2E6, 0x76CA,
0xD2E7, 0x6EA2,
0xD2E8, 0x8BE3,
0xD2E9, 0x8BAE,
0xD2EA, 0x8C0A,
0xD2EB, 0x8BD1,
0xD2EC, 0x5F02,
0xD2ED, 0x7FFC,
0xD2EE, 0x7FCC,
0xD2EF, 0x7ECE,
0xD2F0, 0x8335,
0xD2F1, 0x836B,
0xD2F2, 0x56E0,
0xD2F3, 0x6BB7,
0xD2F4, 0x97F3,
0xD2F5, 0x9634,
0xD2F6, 0x59FB,
0xD2F7, 0x541F,
0xD2F8, 0x94F6,
0xD2F9, 0x6DEB,
0xD2FA, 0x5BC5,
0xD2FB, 0x996E,
0xD2FC, 0x5C39,
0xD2FD, 0x5F15,
0xD2FE, 0x9690,
0xD35F, 0x89C3,
0xD360, 0x89CD,
0xD367, 0x89DB,
0xD368, 0x89DD,
0xD36D, 0x89E4,
0xD3A1, 0x5370,
0xD3A2, 0x82F1,
0xD3A3, 0x6A31,
0xD3A4, 0x5A74,
0xD3A5, 0x9E70,
0xD3A6, 0x5E94,
0xD3A7, 0x7F28,
0xD3A8, 0x83B9,
0xD3AB, 0x8367,
0xD3AC, 0x8747,
0xD3AD, 0x8FCE,
0xD3AE, 0x8D62,
0xD3AF, 0x76C8,
0xD3B0, 0x5F71,
0xD3B1, 0x9896,
0xD3B2, 0x786C,
0xD3B3, 0x6620,
0xD3B4, 0x54DF,
0xD3B5, 0x62E5,
0xD3B6, 0x4F63,
0xD3B7, 0x81C3,
0xD3B8, 0x75C8,
0xD3B9, 0x5EB8,
0xD3BA, 0x96CD,
0xD3BB, 0x8E0A,
0xD3BC, 0x86F9,
0xD3BD, 0x548F,
0xD3BE, 0x6CF3,
0xD3BF, 0x6D8C,
0xD3C0, 0x6C38,
0xD3C1, 0x607F,
0xD3C2, 0x52C7,
0xD3C3, 0x7528,
0xD3C4, 0x5E7D,
0xD3C5, 0x4F18,
0xD3C6, 0x60A0,
0xD3C7, 0x5FE7,
0xD3C8, 0x5C24,
0xD3C9, 0x7531,
0xD3CA, 0x90AE,
0xD3CB, 0x94C0,
0xD3CC, 0x72B9,
0xD3CD, 0x6CB9,
0xD3CE, 0x6E38,
0xD3CF, 0x9149,
0xD3D0, 0x6709,
0xD3D1, 0x53CB,
0xD3D2, 0x53F3,
0xD3D3, 0x4F51,
0xD3D4, 0x91C9,
0xD3D5, 0x8BF1,
0xD3D6, 0x53C8,
0xD3D7, 0x5E7C,
0xD3D8, 0x8FC2,
0xD3D9, 0x6DE4,
0xD3DA, 0x4E8E,
0xD3DB, 0x76C2,
0xD3DC, 0x6986,
0xD3DD, 0x865E,
0xD3DE, 0x611A,
0xD3DF, 0x8206,
0xD3E0, 0x4F59,
0xD3E1, 0x4FDE,
0xD3E2, 0x903E,
0xD3E3, 0x9C7C,
0xD3E4, 0x6109,
0xD3E5, 0x6E1D,
0xD3E6, 0x6E14,
0xD3E7, 0x9685,
0xD3E8, 0x4E88,
0xD3E9, 0x5A31,
0xD3EA, 0x96E8,
0xD3EB, 0x4E0E,
0xD3EC, 0x5C7F,
0xD3ED, 0x79B9,
0xD3EE, 0x5B87,
0xD3EF, 0x8BED,
0xD3F0, 0x7FBD,
0xD3F1, 0x7389,
0xD3F2, 0x57DF,
0xD3F3, 0x828B,
0xD3F4, 0x90C1,
0xD3F5, 0x5401,
0xD3F6, 0x9047,
0xD3F7, 0x55BB,
0xD3F8, 0x5CEA,
0xD3F9, 0x5FA1,
0xD3FA, 0x6108,
0xD3FB, 0x6B32,
0xD3FC, 0x72F1,
0xD3FD, 0x80B2,
0xD3FE, 0x8A89,
0xD4A1, 0x6D74,
0xD4A2, 0x5BD3,
0xD4A3, 0x88D5,
0xD4A4, 0x9884,
0xD4A5, 0x8C6B,
0xD4A6, 0x9A6D,
0xD4A7, 0x9E33,
0xD4A8, 0x6E0A,
0xD4A9, 0x51A4,
0xD4AA, 0x5143,
0xD4AB, 0x57A3,
0xD4AC, 0x8881,
0xD4AD, 0x539F,
0xD4AE, 0x63F4,
0xD4AF, 0x8F95,
0xD4B0, 0x56ED,
0xD4B1, 0x5458,
0xD4B2, 0x5706,
0xD4B3, 0x733F,
0xD4B4, 0x6E90,
0xD4B5, 0x7F18,
0xD4B6, 0x8FDC,
0xD4B7, 0x82D1,
0xD4B8, 0x613F,
0xD4B9, 0x6028,
0xD4BA, 0x9662,
0xD4BB, 0x66F0,
0xD4BC, 0x7EA6,
0xD4BD, 0x8D8A,
0xD4BE, 0x8DC3,
0xD4BF, 0x94A5,
0xD4C0, 0x5CB3,
0xD4C1, 0x7CA4,
0xD4C2, 0x6708,
0xD4C3, 0x60A6,
0xD4C4, 0x9605,
0xD4C5, 0x8018,
0xD4C6, 0x4E91,
0xD4C7, 0x90E7,
0xD4C8, 0x5300,
0xD4C9, 0x9668,
0xD4CA, 0x5141,
0xD4CB, 0x8FD0,
0xD4CC, 0x8574,
0xD4CD, 0x915D,
0xD4CE, 0x6655,
0xD4CF, 0x97F5,
0xD4D0, 0x5B55,
0xD4D1, 0x531D,
0xD4D2, 0x7838,
0xD4D3, 0x6742,
0xD4D4, 0x683D,
0xD4D5, 0x54C9,
0xD4D6, 0x707E,
0xD4D7, 0x5BB0,
0xD4D8, 0x8F7D,
0xD4D9, 0x518D,
0xD4DA, 0x5728,
0xD4DB, 0x54B1,
0xD4DC, 0x6512,
0xD4DD, 0x6682,
0xD4DE, 0x8D5E,
0xD4DF, 0x8D43,
0xD4E0, 0x810F,
0xD4E1, 0x846C,
0xD4E2, 0x906D,
0xD4E3, 0x7CDF,
0xD4E4, 0x51FF,
0xD4E5, 0x85FB,
0xD4E6, 0x67A3,
0xD4E7, 0x65E9,
0xD4E8, 0x6FA1,
0xD4E9, 0x86A4,
0xD4EA, 0x8E81,
0xD4EB, 0x566A,
0xD4EC, 0x9020,
0xD4ED, 0x7682,
0xD4EE, 0x7076,
0xD4EF, 0x71E5,
0xD4F0, 0x8D23,
0xD4F1, 0x62E9,
0xD4F2, 0x5219,
0xD4F3, 0x6CFD,
0xD4F4, 0x8D3C,
0xD4F5, 0x600E,
0xD4F6, 0x589E,
0xD4F7, 0x618E,
0xD4F8, 0x66FE,
0xD4F9, 0x8D60,
0xD4FA, 0x624E,
0xD4FB, 0x55B3,
0xD4FC, 0x6E23,
0xD4FD, 0x672D,
0xD4FE, 0x8F67,
0xD5A1, 0x94E1,
0xD5A2, 0x95F8,
0xD5A3, 0x7728,
0xD5A4, 0x6805,
0xD5A5, 0x69A8,
0xD5A6, 0x548B,
0xD5A7, 0x4E4D,
0xD5A8, 0x70B8,
0xD5A9, 0x8BC8,
0xD5AA, 0x6458,
0xD5AB, 0x658B,
0xD5AC, 0x5B85,
0xD5AD, 0x7A84,
0xD5AE, 0x503A,
0xD5AF, 0x5BE8,
0xD5B0, 0x77BB,
0xD5B1, 0x6BE1,
0xD5B2, 0x8A79,
0xD5B3, 0x7C98,
0xD5B4, 0x6CBE,
0xD5B5, 0x76CF,
0xD5B6, 0x65A9,
0xD5B7, 0x8F97,
0xD5B8, 0x5D2D,
0xD5B9, 0x5C55,
0xD5BA, 0x8638,
0xD5BB, 0x6808,
0xD5BC, 0x5360,
0xD5BD, 0x6218,
0xD5BE, 0x7AD9,
0xD5BF, 0x6E5B,
0xD5C0, 0x7EFD,
0xD5C1, 0x6A1F,
0xD5C2, 0x7AE0,
0xD5C3, 0x5F70,
0xD5C4, 0x6F33,
0xD5C5, 0x5F20,
0xD5C6, 0x638C,
0xD5C7, 0x6DA8,
0xD5C8, 0x6756,
0xD5C9, 0x4E08,
0xD5CA, 0x5E10,
0xD5CB, 0x8D26,
0xD5CC, 0x4ED7,
0xD5CD, 0x80C0,
0xD5CE, 0x7634,
0xD5CF, 0x969C,
0xD5D0, 0x62DB,
0xD5D1, 0x662D,
0xD5D2, 0x627E,
0xD5D3, 0x6CBC,
0xD5D4, 0x8D75,
0xD5D5, 0x7167,
0xD5D6, 0x7F69,
0xD5D7, 0x5146,
0xD5D8, 0x8087,
0xD5D9, 0x53EC,
0xD5DA, 0x906E,
0xD5DB, 0x6298,
0xD5DC, 0x54F2,
0xD5DD, 0x86F0,
0xD5DE, 0x8F99,
0xD5DF, 0x8005,
0xD5E0, 0x9517,
0xD5E1, 0x8517,
0xD5E2, 0x8FD9,
0xD5E3, 0x6D59,
0xD5E4, 0x73CD,
0xD5E5, 0x659F,
0xD5E6, 0x771F,
0xD5E7, 0x7504,
0xD5E8, 0x7827,
0xD5E9, 0x81FB,
0xD5EA, 0x8D1E,
0xD5EB, 0x9488,
0xD5EC, 0x4FA6,
0xD5ED, 0x6795,
0xD5EE, 0x75B9,
0xD5EF, 0x8BCA,
0xD5F0, 0x9707,
0xD5F1, 0x632F,
0xD5F2, 0x9547,
0xD5F3, 0x9635,
0xD5F4, 0x84B8,
0xD5F5, 0x6323,
0xD5F6, 0x7741,
0xD5F7, 0x5F81,
0xD5F8, 0x72F0,
0xD5F9, 0x4E89,
0xD5FA, 0x6014,
0xD5FB, 0x6574,
0xD5FC, 0x62EF,
0xD5FD, 0x6B63,
0xD5FE, 0x653F,
0xD6A1, 0x5E27,
0xD6A2, 0x75C7,
0xD6A3, 0x90D1,
0xD6A4, 0x8BC1,
0xD6A5, 0x829D,
0xD6A6, 0x679D,
0xD6A7, 0x652F,
0xD6A8, 0x5431,
0xD6A9, 0x8718,
0xD6AA, 0x77E5,
0xD6AB, 0x80A2,
0xD6AC, 0x8102,
0xD6AD, 0x6C41,
0xD6AE, 0x4E4B,
0xD6AF, 0x7EC7,
0xD6B0, 0x804C,
0xD6B1, 0x76F4,
0xD6B2, 0x690D,
0xD6B3, 0x6B96,
0xD6B4, 0x6267,
0xD6B5, 0x503C,
0xD6B6, 0x4F84,
0xD6B7, 0x5740,
0xD6B8, 0x6307,
0xD6B9, 0x6B62,
0xD6BA, 0x8DBE,
0xD6BB, 0x53EA,
0xD6BC, 0x65E8,
0xD6BD, 0x7EB8,
0xD6BE, 0x5FD7,
0xD6BF, 0x631A,
0xD6C0, 0x63B7,
0xD6C3, 0x7F6E,
0xD6C4, 0x5E1C,
0xD6C5, 0x5CD9,
0xD6C6, 0x5236,
0xD6C7, 0x667A,
0xD6C8, 0x79E9,
0xD6C9, 0x7A1A,
0xD6CA, 0x8D28,
0xD6CB, 0x7099,
0xD6CC, 0x75D4,
0xD6CD, 0x6EDE,
0xD6CE, 0x6CBB,
0xD6CF, 0x7A92,
0xD6D0, 0x4E2D,
0xD6D1, 0x76C5,
0xD6D2, 0x5FE0,
0xD6D3, 0x949F,
0xD6D4, 0x8877,
0xD6D5, 0x7EC8,
0xD6D6, 0x79CD,
0xD6D7, 0x80BF,
0xD6D8, 0x91CD,
0xD6D9, 0x4EF2,
0xD6DA, 0x4F17,
0xD6DB, 0x821F,
0xD6DC, 0x5468,
0xD6DD, 0x5DDE,
0xD6DE, 0x6D32,
0xD6DF, 0x8BCC,
0xD6E0, 0x7CA5,
0xD6E1, 0x8F74,
0xD6E2, 0x8098,
0xD6E3, 0x5E1A,
0xD6E4, 0x5492,
0xD6E5, 0x76B1,
0xD6E6, 0x5B99,
0xD6E7, 0x663C,
0xD6E8, 0x9AA4,
0xD6E9, 0x73E0,
0xD6EA, 0x682A,
0xD6EB, 0x86DB,
0xD6EC, 0x6731,
0xD6ED, 0x732A,
0xD6EE, 0x8BF8,
0xD6EF, 0x8BDB,
0xD6F0, 0x9010,
0xD6F1, 0x7AF9,
0xD6F2, 0x70DB,
0xD6F3, 0x716E,
0xD6F4, 0x62C4,
0xD6F5, 0x77A9,
0xD6F6, 0x5631,
0xD6F7, 0x4E3B,
0xD6F8, 0x8457,
0xD6F9, 0x67F1,
0xD6FA, 0x52A9,
0xD6FB, 0x86C0,
0xD6FC, 0x8D2E,
0xD6FD, 0x94F8,
0xD6FE, 0x7B51,
0xD799, 0x8BAC,
0xD79A, 0x8BB1,
0xD79B, 0x8BBB,
0xD79C, 0x8BC7,
0xD79D, 0x8BD0,
0xD79E, 0x8BEA,
0xD79F, 0x8C09,
0xD7A0, 0x8C1E,
0xD7A1, 0x4F4F,
0xD7A2, 0x6CE8,
0xD7A3, 0x795D,
0xD7A4, 0x9A7B,
0xD7A5, 0x6293,
0xD7A6, 0x722A,
0xD7A7, 0x62FD,
0xD7A8, 0x4E13,
0xD7A9, 0x7816,
0xD7AA, 0x8F6C,
0xD7AB, 0x64B0,
0xD7AC, 0x8D5A,
0xD7AD, 0x7BC6,
0xD7AE, 0x6869,
0xD7AF, 0x5E84,
0xD7B0, 0x88C5,
0xD7B1, 0x5986,
0xD7B2, 0x649E,
0xD7B3, 0x58EE,
0xD7B4, 0x72B6,
0xD7B5, 0x690E,
0xD7B6, 0x9525,
0xD7B7, 0x8FFD,
0xD7B8, 0x8D58,
0xD7B9, 0x5760,
0xD7BA, 0x7F00,
0xD7BB, 0x8C06,
0xD7BC, 0x51C6,
0xD7BD, 0x6349,
0xD7BE, 0x62D9,
0xD7BF, 0x5353,
0xD7C0, 0x684C,
0xD7C1, 0x7422,
0xD7C2, 0x8301,
0xD7C3, 0x914C,
0xD7C4, 0x5544,
0xD7C5, 0x7740,
0xD7C6, 0x707C,
0xD7C7, 0x6D4A,
0xD7C8, 0x5179,
0xD7C9, 0x54A8,
0xD7CA, 0x8D44,
0xD7CB, 0x59FF,
0xD7CC, 0x6ECB,
0xD7CD, 0x6DC4,
0xD7CE, 0x5B5C,
0xD7CF, 0x7D2B,
0xD7D0, 0x4ED4,
0xD7D1, 0x7C7D,
0xD7D2, 0x6ED3,
0xD7D3, 0x5B50,
0xD7D4, 0x81EA,
0xD7D5, 0x6E0D,
0xD7D6, 0x5B57,
0xD7D7, 0x9B03,
0xD7D8, 0x68D5,
0xD7D9, 0x8E2A,
0xD7DA, 0x5B97,
0xD7DB, 0x7EFC,
0xD7DC, 0x603B,
0xD7DD, 0x7EB5,
0xD7DE, 0x90B9,
0xD7DF, 0x8D70,
0xD7E0, 0x594F,
0xD7E1, 0x63CD,
0xD7E2, 0x79DF,
0xD7E3, 0x8DB3,
0xD7E4, 0x5352,
0xD7E5, 0x65CF,
0xD7E6, 0x7956,
0xD7E7, 0x8BC5,
0xD7E8, 0x963B,
0xD7E9, 0x7EC4,
0xD7EA, 0x94BB,
0xD7EB, 0x7E82,
0xD7EC, 0x5634,
0xD7ED, 0x9189,
0xD7EE, 0x6700,
0xD7EF, 0x7F6A,
0xD7F0, 0x5C0A,
0xD7F1, 0x9075,
0xD7F2, 0x6628,
0xD7F3, 0x5DE6,
0xD7F4, 0x4F50,
0xD7F5, 0x67DE,
0xD7F6, 0x505A,
0xD7F7, 0x4F5C,
0xD7F8, 0x5750,
0xD7F9, 0x5EA7,
0xD84D, 0x8C48,
0xD880, 0x8C88,
0xD881, 0x8C8B,
0xD8A1, 0x4E8D,
0xD8A2, 0x4E0C,
0xD8A3, 0x5140,
0xD8A4, 0x4E10,
0xD8A5, 0x5EFF,
0xD8A6, 0x5345,
0xD8A7, 0x4E15,
0xD8A8, 0x4E98,
0xD8A9, 0x4E1E,
0xD8AA, 0x9B32,
0xD8AB, 0x5B6C,
0xD8AC, 0x5669,
0xD8AD, 0x4E28,
0xD8AE, 0x79BA,
0xD8AF, 0x4E3F,
0xD8B0, 0x5315,
0xD8B1, 0x4E47,
0xD8B2, 0x592D,
0xD8B3, 0x723B,
0xD8B4, 0x536E,
0xD8B5, 0x6C10,
0xD8B6, 0x56DF,
0xD8B7, 0x80E4,
0xD8B8, 0x9997,
0xD8B9, 0x6BD3,
0xD8BA, 0x777E,
0xD8BB, 0x9F17,
0xD8BC, 0x4E36,
0xD8BD, 0x4E9F,
0xD8BE, 0x9F10,
0xD8BF, 0x4E5C,
0xD8C0, 0x4E69,
0xD8C1, 0x4E93,
0xD8C2, 0x8288,
0xD8C3, 0x5B5B,
0xD8C4, 0x556C,
0xD8C5, 0x560F,
0xD8C6, 0x4EC4,
0xD8C7, 0x538D,
0xD8C8, 0x539D,
0xD8C9, 0x53A3,
0xD8CA, 0x53A5,
0xD8CB, 0x53AE,
0xD8CC, 0x9765,
0xD8CD, 0x8D5D,
0xD8CE, 0x531A,
0xD8CF, 0x53F5,
0xD8D0, 0x5326,
0xD8D1, 0x532E,
0xD8D2, 0x533E,
0xD8D3, 0x8D5C,
0xD8D4, 0x5366,
0xD8D5, 0x5363,
0xD8D6, 0x5202,
0xD8D7, 0x5208,
0xD8D8, 0x520E,
0xD8D9, 0x522D,
0xD8DA, 0x5233,
0xD8DD, 0x524C,
0xD8DE, 0x525E,
0xD8DF, 0x5261,
0xD8E0, 0x525C,
0xD8E1, 0x84AF,
0xD8E2, 0x527D,
0xD8E3, 0x5282,
0xD8E4, 0x5281,
0xD8E5, 0x5290,
0xD8E6, 0x5293,
0xD8E7, 0x5182,
0xD8E8, 0x7F54,
0xD8E9, 0x4EBB,
0xD8EA, 0x4EC3,
0xD8EB, 0x4EC9,
0xD8EC, 0x4EC2,
0xD8ED, 0x4EE8,
0xD8EE, 0x4EE1,
0xD8EF, 0x4EEB,
0xD8F0, 0x4EDE,
0xD8F1, 0x4F1B,
0xD8F2, 0x4EF3,
0xD8F3, 0x4F22,
0xD8F4, 0x4F64,
0xD8F5, 0x4EF5,
0xD8F6, 0x4F25,
0xD8F7, 0x4F27,
0xD8F8, 0x4F09,
0xD8F9, 0x4F2B,
0xD8FA, 0x4F5E,
0xD8FB, 0x4F67,
0xD8FC, 0x6538,
0xD8FD, 0x4F5A,
0xD8FE, 0x4F5D,
0xD9A1, 0x4F5F,
0xD9A2, 0x4F57,
0xD9A3, 0x4F32,
0xD9A4, 0x4F3D,
0xD9A5, 0x4F76,
0xD9A6, 0x4F74,
0xD9A7, 0x4F91,
0xD9A8, 0x4F89,
0xD9A9, 0x4F83,
0xD9AA, 0x4F8F,
0xD9AB, 0x4F7E,
0xD9AC, 0x4F7B,
0xD9AD, 0x4FAA,
0xD9AE, 0x4F7C,
0xD9AF, 0x4FAC,
0xD9B0, 0x4F94,
0xD9B1, 0x4FE6,
0xD9B2, 0x4FE8,
0xD9B3, 0x4FEA,
0xD9B4, 0x4FC5,
0xD9B5, 0x4FDA,
0xD9B6, 0x4FE3,
0xD9B7, 0x4FDC,
0xD9B8, 0x4FD1,
0xD9B9, 0x4FDF,
0xD9BA, 0x4FF8,
0xD9BB, 0x5029,
0xD9BC, 0x504C,
0xD9BD, 0x4FF3,
0xD9BE, 0x502C,
0xD9BF, 0x500F,
0xD9C0, 0x502E,
0xD9C1, 0x502D,
0xD9C2, 0x4FFE,
0xD9C3, 0x501C,
0xD9C4, 0x500C,
0xD9C5, 0x5025,
0xD9C6, 0x5028,
0xD9C7, 0x507E,
0xD9C8, 0x5043,
0xD9C9, 0x5055,
0xD9CA, 0x5048,
0xD9CB, 0x504E,
0xD9CC, 0x506C,
0xD9CD, 0x507B,
0xD9CE, 0x50A5,
0xD9CF, 0x50A7,
0xD9D0, 0x50A9,
0xD9D1, 0x50BA,
0xD9D2, 0x50D6,
0xD9D3, 0x5106,
0xD9D4, 0x50ED,
0xD9D5, 0x50EC,
0xD9D6, 0x50E6,
0xD9D7, 0x50EE,
0xD9D8, 0x5107,
0xD9D9, 0x510B,
0xD9DA, 0x4EDD,
0xD9DB, 0x6C3D,
0xD9DC, 0x4F58,
0xD9DD, 0x4F65,
0xD9DE, 0x4FCE,
0xD9DF, 0x9FA0,
0xD9E0, 0x6C46,
0xD9E1, 0x7C74,
0xD9E2, 0x516E,
0xD9E3, 0x5DFD,
0xD9E4, 0x9EC9,
0xD9E5, 0x9998,
0xD9E6, 0x5181,
0xD9E7, 0x5914,
0xD9E8, 0x52F9,
0xD9E9, 0x530D,
0xD9EA, 0x8A07,
0xD9EB, 0x5310,
0xD9EC, 0x51EB,
0xD9ED, 0x5919,
0xD9EE, 0x5155,
0xD9EF, 0x4EA0,
0xD9F0, 0x5156,
0xD9F1, 0x4EB3,
0xD9F2, 0x886E,
0xD9F3, 0x88A4,
0xD9F4, 0x4EB5,
0xD9F5, 0x8114,
0xD9F6, 0x88D2,
0xD9F7, 0x7980,
0xD9F8, 0x5B34,
0xD9F9, 0x8803,
0xD9FA, 0x7FB8,
0xD9FB, 0x51AB,
0xD9FC, 0x51B1,
0xD9FD, 0x51BD,
0xD9FE, 0x51BC,
0xDA4F, 0x8D20,
0xDA52, 0x8D57,
0xDA53, 0x8D5F,
0xDA54, 0x8D65,
0xDA58, 0x8D6C,
0xDA80, 0x8DA2,
0xDA8E, 0x8DB2,
0xDA91, 0x8DB9,
0xDA92, 0x8DBB,
0xDA93, 0x8DBD,
0xDA97, 0x8DC5,
0xDA9C, 0x8DCD,
0xDA9D, 0x8DD0,
0xDAA1, 0x51C7,
0xDAA2, 0x5196,
0xDAA3, 0x51A2,
0xDAA4, 0x51A5,
0xDAA5, 0x8BA0,
0xDAA8, 0x8BAA,
0xDAAB, 0x8BB7,
0xDAAE, 0x8BCB,
0xDAAF, 0x8BCF,
0xDAB0, 0x8BCE,
0xDAB4, 0x8BD6,
0xDAB7, 0x8BDC,
0xDABA, 0x8BE4,
0xDABD, 0x8BEE,
0xDABE, 0x8BF0,
0xDABF, 0x8BF3,
0xDAC0, 0x8BF6,
0xDAC1, 0x8BF9,
0xDAC2, 0x8BFC,
0xDAC5, 0x8C02,
0xDAC6, 0x8C04,
0xDAC7, 0x8C07,
0xDAC8, 0x8C0C,
0xDAC9, 0x8C0F,
0xDACF, 0x8C19,
0xDAD0, 0x8C1B,
0xDAD1, 0x8C18,
0xDAD2, 0x8C1D,
0xDAD6, 0x8C25,
0xDAD7, 0x8C27,
0xDAE0, 0x5369,
0xDAE1, 0x537A,
0xDAE2, 0x961D,
0xDAE3, 0x9622,
0xDAE4, 0x9621,
0xDAE5, 0x9631,
0xDAE6, 0x962A,
0xDAE7, 0x963D,
0xDAE8, 0x963C,
0xDAE9, 0x9642,
0xDAEA, 0x9649,
0xDAEB, 0x9654,
0xDAEC, 0x965F,
0xDAED, 0x9667,
0xDAEE, 0x966C,
0xDAEF, 0x9672,
0xDAF0, 0x9674,
0xDAF1, 0x9688,
0xDAF2, 0x968D,
0xDAF3, 0x9697,
0xDAF4, 0x96B0,
0xDAF5, 0x9097,
0xDAF6, 0x909B,
0xDAF7, 0x909D,
0xDAF8, 0x9099,
0xDAF9, 0x90AC,
0xDAFA, 0x90A1,
0xDAFB, 0x90B4,
0xDAFC, 0x90B3,
0xDAFD, 0x90B6,
0xDAFE, 0x90BA,
0xDB40, 0x8DD5,
0xDB43, 0x8DDC,
0xDB4A, 0x8DE9,
0xDB50, 0x8DF4,
0xDB51, 0x8DF6,
0xDB52, 0x8DFC,
0xDB5D, 0x8E0B,
0xDB73, 0x8E2B,
0xDB74, 0x8E2D,
0xDB75, 0x8E30,
0xDB7E, 0x8E3E,
0xDB80, 0x8E3F,
0xDB81, 0x8E43,
0xDB9F, 0x8E6E,
0xDBA0, 0x8E71,
0xDBA1, 0x90B8,
0xDBA2, 0x90B0,
0xDBA3, 0x90CF,
0xDBA4, 0x90C5,
0xDBA5, 0x90BE,
0xDBA6, 0x90D0,
0xDBA7, 0x90C4,
0xDBA8, 0x90C7,
0xDBA9, 0x90D3,
0xDBAA, 0x90E6,
0xDBAB, 0x90E2,
0xDBAC, 0x90DC,
0xDBAD, 0x90D7,
0xDBAE, 0x90DB,
0xDBAF, 0x90EB,
0xDBB0, 0x90EF,
0xDBB1, 0x90FE,
0xDBB2, 0x9104,
0xDBB3, 0x9122,
0xDBB4, 0x911E,
0xDBB5, 0x9123,
0xDBB6, 0x9131,
0xDBB7, 0x912F,
0xDBB8, 0x9139,
0xDBB9, 0x9143,
0xDBBA, 0x9146,
0xDBBB, 0x520D,
0xDBBC, 0x5942,
0xDBBD, 0x52A2,
0xDBC0, 0x52BE,
0xDBC1, 0x54FF,
0xDBC2, 0x52D0,
0xDBC3, 0x52D6,
0xDBC4, 0x52F0,
0xDBC5, 0x53DF,
0xDBC6, 0x71EE,
0xDBC7, 0x77CD,
0xDBC8, 0x5EF4,
0xDBC9, 0x51F5,
0xDBCA, 0x51FC,
0xDBCB, 0x9B2F,
0xDBCC, 0x53B6,
0xDBCD, 0x5F01,
0xDBCE, 0x755A,
0xDBCF, 0x5DEF,
0xDBD0, 0x574C,
0xDBD1, 0x57A9,
0xDBD2, 0x57A1,
0xDBD3, 0x587E,
0xDBD4, 0x58BC,
0xDBD5, 0x58C5,
0xDBD6, 0x58D1,
0xDBD7, 0x5729,
0xDBD8, 0x572C,
0xDBD9, 0x572A,
0xDBDA, 0x5733,
0xDBDB, 0x5739,
0xDBDE, 0x575C,
0xDBDF, 0x573B,
0xDBE0, 0x5742,
0xDBE1, 0x5769,
0xDBE2, 0x5785,
0xDBE3, 0x576B,
0xDBE4, 0x5786,
0xDBE5, 0x577C,
0xDBE6, 0x577B,
0xDBE7, 0x5768,
0xDBE8, 0x576D,
0xDBE9, 0x5776,
0xDBEA, 0x5773,
0xDBEB, 0x57AD,
0xDBEC, 0x57A4,
0xDBED, 0x578C,
0xDBEE, 0x57B2,
0xDBEF, 0x57CF,
0xDBF0, 0x57A7,
0xDBF1, 0x57B4,
0xDBF2, 0x5793,
0xDBF3, 0x57A0,
0xDBF4, 0x57D5,
0xDBF5, 0x57D8,
0xDBF6, 0x57DA,
0xDBF7, 0x57D9,
0xDBF8, 0x57D2,
0xDBF9, 0x57B8,
0xDBFA, 0x57F4,
0xDBFB, 0x57EF,
0xDBFC, 0x57F8,
0xDBFD, 0x57E4,
0xDBFE, 0x57DD,
0xDC40, 0x8E73,
0xDC41, 0x8E75,
0xDC49, 0x8E80,
0xDC4D, 0x8E86,
0xDC5F, 0x8E9D,
0xDCA1, 0x580B,
0xDCA2, 0x580D,
0xDCA3, 0x57FD,
0xDCA4, 0x57ED,
0xDCA5, 0x5800,
0xDCA6, 0x581E,
0xDCA7, 0x5819,
0xDCA8, 0x5844,
0xDCA9, 0x5820,
0xDCAA, 0x5865,
0xDCAB, 0x586C,
0xDCAC, 0x5881,
0xDCAD, 0x5889,
0xDCAE, 0x589A,
0xDCAF, 0x5880,
0xDCB0, 0x99A8,
0xDCB1, 0x9F19,
0xDCB2, 0x61FF,
0xDCB3, 0x8279,
0xDCB4, 0x827D,
0xDCB5, 0x827F,
0xDCB6, 0x828F,
0xDCB7, 0x828A,
0xDCB8, 0x82A8,
0xDCB9, 0x8284,
0xDCBA, 0x828E,
0xDCBB, 0x8291,
0xDCBC, 0x8297,
0xDCBD, 0x8299,
0xDCBE, 0x82AB,
0xDCBF, 0x82B8,
0xDCC0, 0x82BE,
0xDCC1, 0x82B0,
0xDCC2, 0x82C8,
0xDCC3, 0x82CA,
0xDCC4, 0x82E3,
0xDCC5, 0x8298,
0xDCC6, 0x82B7,
0xDCC7, 0x82AE,
0xDCCA, 0x82C1,
0xDCCB, 0x82A9,
0xDCCC, 0x82B4,
0xDCCD, 0x82A1,
0xDCCE, 0x82AA,
0xDCCF, 0x829F,
0xDCD0, 0x82C4,
0xDCD1, 0x82CE,
0xDCD2, 0x82A4,
0xDCD3, 0x82E1,
0xDCD4, 0x8309,
0xDCD5, 0x82F7,
0xDCD6, 0x82E4,
0xDCD7, 0x830F,
0xDCD8, 0x8307,
0xDCD9, 0x82DC,
0xDCDA, 0x82F4,
0xDCDB, 0x82D2,
0xDCDC, 0x82D8,
0xDCDD, 0x830C,
0xDCDE, 0x82FB,
0xDCDF, 0x82D3,
0xDCE0, 0x8311,
0xDCE1, 0x831A,
0xDCE2, 0x8306,
0xDCE5, 0x82E0,
0xDCE6, 0x82D5,
0xDCE7, 0x831C,
0xDCE8, 0x8351,
0xDCEB, 0x8308,
0xDCEC, 0x8392,
0xDCED, 0x833C,
0xDCEE, 0x8334,
0xDCEF, 0x8331,
0xDCF0, 0x839B,
0xDCF1, 0x835E,
0xDCF2, 0x832F,
0xDCF3, 0x834F,
0xDCF4, 0x8347,
0xDCF5, 0x8343,
0xDCF6, 0x835F,
0xDCF7, 0x8340,
0xDCF8, 0x8317,
0xDCF9, 0x8360,
0xDCFA, 0x832D,
0xDCFB, 0x833A,
0xDCFC, 0x8333,
0xDCFD, 0x8366,
0xDCFE, 0x8365,
0xDDA1, 0x8368,
0xDDA2, 0x831B,
0xDDA3, 0x8369,
0xDDA4, 0x836C,
0xDDA5, 0x836A,
0xDDA8, 0x83B0,
0xDDA9, 0x8378,
0xDDAC, 0x83A0,
0xDDAD, 0x83AA,
0xDDAE, 0x8393,
0xDDAF, 0x839C,
0xDDB0, 0x8385,
0xDDB1, 0x837C,
0xDDB2, 0x83B6,
0xDDB3, 0x83A9,
0xDDB4, 0x837D,
0xDDB5, 0x83B8,
0xDDB6, 0x837B,
0xDDB7, 0x8398,
0xDDB8, 0x839E,
0xDDB9, 0x83A8,
0xDDBA, 0x83BA,
0xDDBB, 0x83BC,
0xDDBC, 0x83C1,
0xDDBD, 0x8401,
0xDDBE, 0x83E5,
0xDDBF, 0x83D8,
0xDDC0, 0x5807,
0xDDC1, 0x8418,
0xDDC2, 0x840B,
0xDDC3, 0x83DD,
0xDDC4, 0x83FD,
0xDDC5, 0x83D6,
0xDDC6, 0x841C,
0xDDC7, 0x8438,
0xDDC8, 0x8411,
0xDDC9, 0x8406,
0xDDCA, 0x83D4,
0xDDCB, 0x83DF,
0xDDCC, 0x840F,
0xDDCD, 0x8403,
0xDDD0, 0x83EA,
0xDDD1, 0x83C5,
0xDDD2, 0x83C0,
0xDDD3, 0x8426,
0xDDD4, 0x83F0,
0xDDD5, 0x83E1,
0xDDD6, 0x845C,
0xDDD7, 0x8451,
0xDDD8, 0x845A,
0xDDD9, 0x8459,
0xDDDA, 0x8473,
0xDDDD, 0x847A,
0xDDDE, 0x8489,
0xDDDF, 0x8478,
0xDDE0, 0x843C,
0xDDE1, 0x8446,
0xDDE2, 0x8469,
0xDDE3, 0x8476,
0xDDE4, 0x848C,
0xDDE5, 0x848E,
0xDDE6, 0x8431,
0xDDE7, 0x846D,
0xDDE8, 0x84C1,
0xDDE9, 0x84CD,
0xDDEA, 0x84D0,
0xDDEB, 0x84E6,
0xDDEC, 0x84BD,
0xDDED, 0x84D3,
0xDDEE, 0x84CA,
0xDDEF, 0x84BF,
0xDDF0, 0x84BA,
0xDDF1, 0x84E0,
0xDDF2, 0x84A1,
0xDDF3, 0x84B9,
0xDDF4, 0x84B4,
0xDDF5, 0x8497,
0xDDF6, 0x84E5,
0xDDF7, 0x84E3,
0xDDF8, 0x850C,
0xDDF9, 0x750D,
0xDDFA, 0x8538,
0xDDFB, 0x84F0,
0xDDFC, 0x8539,
0xDDFD, 0x851F,
0xDDFE, 0x853A,
0xDE61, 0x8F6A,
0xDE62, 0x8F80,
0xDE63, 0x8F8C,
0xDE64, 0x8F92,
0xDE65, 0x8F9D,
0xDE6D, 0x8FAA,
0xDE7D, 0x8FC3,
0xDE7E, 0x8FC6,
0xDE85, 0x8FCF,
0xDE86, 0x8FD2,
0xDE89, 0x8FDA,
0xDE8C, 0x8FE3,
0xDE8D, 0x8FE7,
0xDE8E, 0x8FEC,
0xDE8F, 0x8FEF,
0xDE9C, 0x900C,
0xDE9D, 0x900E,
0xDE9E, 0x9013,
0xDE9F, 0x9015,
0xDEA0, 0x9018,
0xDEA1, 0x8556,
0xDEA2, 0x853B,
0xDEA3, 0x84FF,
0xDEA4, 0x84FC,
0xDEA5, 0x8559,
0xDEA6, 0x8548,
0xDEA7, 0x8568,
0xDEA8, 0x8564,
0xDEA9, 0x855E,
0xDEAA, 0x857A,
0xDEAB, 0x77A2,
0xDEAC, 0x8543,
0xDEAD, 0x8572,
0xDEAE, 0x857B,
0xDEAF, 0x85A4,
0xDEB0, 0x85A8,
0xDEB1, 0x8587,
0xDEB2, 0x858F,
0xDEB3, 0x8579,
0xDEB4, 0x85AE,
0xDEB5, 0x859C,
0xDEB6, 0x8585,
0xDEB7, 0x85B9,
0xDEB8, 0x85B7,
0xDEB9, 0x85B0,
0xDEBA, 0x85D3,
0xDEBB, 0x85C1,
0xDEBC, 0x85DC,
0xDEBD, 0x85FF,
0xDEBE, 0x8627,
0xDEBF, 0x8605,
0xDEC0, 0x8629,
0xDEC1, 0x8616,
0xDEC2, 0x863C,
0xDEC3, 0x5EFE,
0xDEC4, 0x5F08,
0xDEC5, 0x593C,
0xDEC6, 0x5941,
0xDEC7, 0x8037,
0xDEC8, 0x5955,
0xDEC9, 0x595A,
0xDECA, 0x5958,
0xDECB, 0x530F,
0xDECC, 0x5C22,
0xDECD, 0x5C25,
0xDECE, 0x5C2C,
0xDECF, 0x5C34,
0xDED0, 0x624C,
0xDED1, 0x626A,
0xDED2, 0x629F,
0xDED3, 0x62BB,
0xDED4, 0x62CA,
0xDED5, 0x62DA,
0xDED6, 0x62D7,
0xDED7, 0x62EE,
0xDED8, 0x6322,
0xDED9, 0x62F6,
0xDEDA, 0x6339,
0xDEDB, 0x634B,
0xDEDC, 0x6343,
0xDEDD, 0x63AD,
0xDEDE, 0x63F6,
0xDEDF, 0x6371,
0xDEE0, 0x637A,
0xDEE1, 0x638E,
0xDEE2, 0x63B4,
0xDEE3, 0x636D,
0xDEE4, 0x63AC,
0xDEE5, 0x638A,
0xDEE6, 0x6369,
0xDEE7, 0x63AE,
0xDEE8, 0x63BC,
0xDEE9, 0x63F2,
0xDEEA, 0x63F8,
0xDEEB, 0x63E0,
0xDEEC, 0x63FF,
0xDEED, 0x63C4,
0xDEEE, 0x63DE,
0xDEEF, 0x63CE,
0xDEF0, 0x6452,
0xDEF1, 0x63C6,
0xDEF2, 0x63BE,
0xDEF3, 0x6445,
0xDEF4, 0x6441,
0xDEF5, 0x640B,
0xDEF6, 0x641B,
0xDEF7, 0x6420,
0xDEF8, 0x640C,
0xDEF9, 0x6426,
0xDEFA, 0x6421,
0xDEFB, 0x645E,
0xDEFC, 0x6484,
0xDEFD, 0x646D,
0xDEFE, 0x6496,
0xDF40, 0x9019,
0xDF41, 0x901C,
0xDF50, 0x9037,
0xDF53, 0x903D,
0xDF56, 0x9043,
0xDF5E, 0x904E,
0xDF6A, 0x9064,
0xDF7D, 0x907E,
0xDF7E, 0x9081,
0xDF8B, 0x9092,
0xDF8C, 0x9094,
0xDF8D, 0x9096,
0xDF8E, 0x9098,
0xDF8F, 0x909A,
0xDF90, 0x909C,
0xDF99, 0x90AB,
0xDF9A, 0x90AD,
0xDF9B, 0x90B2,
0xDF9C, 0x90B7,
0xDFA1, 0x647A,
0xDFA4, 0x6499,
0xDFA5, 0x64BA,
0xDFA6, 0x64C0,
0xDFA7, 0x64D0,
0xDFA8, 0x64D7,
0xDFA9, 0x64E4,
0xDFAA, 0x64E2,
0xDFAB, 0x6509,
0xDFAC, 0x6525,
0xDFAD, 0x652E,
0xDFAE, 0x5F0B,
0xDFAF, 0x5FD2,
0xDFB0, 0x7519,
0xDFB1, 0x5F11,
0xDFB2, 0x535F,
0xDFB3, 0x53F1,
0xDFB4, 0x53FD,
0xDFB5, 0x53E9,
0xDFB6, 0x53E8,
0xDFB7, 0x53FB,
0xDFB8, 0x5412,
0xDFB9, 0x5416,
0xDFBA, 0x5406,
0xDFBB, 0x544B,
0xDFBF, 0x5456,
0xDFC0, 0x5443,
0xDFC1, 0x5421,
0xDFC2, 0x5457,
0xDFC3, 0x5459,
0xDFC4, 0x5423,
0xDFC5, 0x5432,
0xDFC6, 0x5482,
0xDFC7, 0x5494,
0xDFC8, 0x5477,
0xDFC9, 0x5471,
0xDFCA, 0x5464,
0xDFCD, 0x5484,
0xDFCE, 0x5476,
0xDFCF, 0x5466,
0xDFD0, 0x549D,
0xDFD1, 0x54D0,
0xDFD2, 0x54AD,
0xDFD3, 0x54C2,
0xDFD4, 0x54B4,
0xDFD5, 0x54D2,
0xDFD6, 0x54A7,
0xDFD7, 0x54A6,
0xDFDA, 0x5472,
0xDFDB, 0x54A3,
0xDFDC, 0x54D5,
0xDFDD, 0x54BB,
0xDFDE, 0x54BF,
0xDFDF, 0x54CC,
0xDFE2, 0x54DC,
0xDFE5, 0x54A4,
0xDFE6, 0x54DD,
0xDFE7, 0x54CF,
0xDFE8, 0x54DE,
0xDFE9, 0x551B,
0xDFEA, 0x54E7,
0xDFEB, 0x5520,
0xDFEC, 0x54FD,
0xDFED, 0x5514,
0xDFEE, 0x54F3,
0xDFF1, 0x550F,
0xDFF2, 0x5511,
0xDFF3, 0x5527,
0xDFF4, 0x552A,
0xDFF5, 0x5567,
0xDFF6, 0x558F,
0xDFF7, 0x55B5,
0xDFF8, 0x5549,
0xDFF9, 0x556D,
0xDFFA, 0x5541,
0xDFFB, 0x5555,
0xDFFC, 0x553F,
0xDFFD, 0x5550,
0xDFFE, 0x553C,
0xE042, 0x90C6,
0xE048, 0x90D2,
0xE057, 0x90EC,
0xE058, 0x90EE,
0xE067, 0x9103,
0xE080, 0x911D,
0xE08F, 0x9130,
0xE0A0, 0x9144,
0xE0A1, 0x5537,
0xE0A2, 0x5556,
0xE0A6, 0x5533,
0xE0A7, 0x5530,
0xE0A8, 0x555C,
0xE0A9, 0x558B,
0xE0AA, 0x55D2,
0xE0AB, 0x5583,
0xE0AC, 0x55B1,
0xE0AD, 0x55B9,
0xE0AE, 0x5588,
0xE0AF, 0x5581,
0xE0B0, 0x559F,
0xE0B1, 0x557E,
0xE0B2, 0x55D6,
0xE0B3, 0x5591,
0xE0B4, 0x557B,
0xE0B5, 0x55DF,
0xE0B8, 0x5594,
0xE0B9, 0x5599,
0xE0BA, 0x55EA,
0xE0BB, 0x55F7,
0xE0BC, 0x55C9,
0xE0BD, 0x561F,
0xE0BE, 0x55D1,
0xE0C1, 0x55D4,
0xE0C2, 0x55E6,
0xE0C3, 0x55DD,
0xE0C4, 0x55C4,
0xE0C5, 0x55EF,
0xE0C6, 0x55E5,
0xE0CB, 0x55E8,
0xE0CC, 0x55F5,
0xE0CD, 0x55E4,
0xE0CE, 0x8F94,
0xE0CF, 0x561E,
0xE0D0, 0x5608,
0xE0D1, 0x560C,
0xE0D2, 0x5601,
0xE0D3, 0x5624,
0xE0D4, 0x5623,
0xE0D5, 0x55FE,
0xE0D6, 0x5600,
0xE0D7, 0x5627,
0xE0D8, 0x562D,
0xE0D9, 0x5658,
0xE0DA, 0x5639,
0xE0DB, 0x5657,
0xE0DC, 0x562C,
0xE0DD, 0x564D,
0xE0DE, 0x5662,
0xE0DF, 0x5659,
0xE0E0, 0x565C,
0xE0E1, 0x564C,
0xE0E2, 0x5654,
0xE0E3, 0x5686,
0xE0E4, 0x5664,
0xE0E5, 0x5671,
0xE0E6, 0x566B,
0xE0E9, 0x5685,
0xE0EA, 0x5693,
0xE0EB, 0x56AF,
0xE0EC, 0x56D4,
0xE0ED, 0x56D7,
0xE0EE, 0x56DD,
0xE0EF, 0x56E1,
0xE0F0, 0x56F5,
0xE0F1, 0x56EB,
0xE0F2, 0x56F9,
0xE0F3, 0x56FF,
0xE0F4, 0x5704,
0xE0F5, 0x570A,
0xE0F6, 0x5709,
0xE0F7, 0x571C,
0xE0F8, 0x5E0F,
0xE0F9, 0x5E19,
0xE0FA, 0x5E14,
0xE0FB, 0x5E11,
0xE0FC, 0x5E31,
0xE140, 0x9145,
0xE143, 0x9151,
0xE151, 0x916B,
0xE152, 0x916D,
0xE153, 0x9173,
0xE15C, 0x9186,
0xE15D, 0x9188,
0xE15E, 0x918A,
0xE17E, 0x91BB,
0xE18B, 0x91C8,
0xE18C, 0x91CB,
0xE18D, 0x91D0,
0xE1A1, 0x5E37,
0xE1A2, 0x5E44,
0xE1A3, 0x5E54,
0xE1A4, 0x5E5B,
0xE1A5, 0x5E5E,
0xE1A6, 0x5E61,
0xE1A7, 0x5C8C,
0xE1A8, 0x5C7A,
0xE1A9, 0x5C8D,
0xE1AA, 0x5C90,
0xE1AB, 0x5C96,
0xE1AC, 0x5C88,
0xE1AF, 0x5C91,
0xE1B0, 0x5C9A,
0xE1B1, 0x5C9C,
0xE1B2, 0x5CB5,
0xE1B3, 0x5CA2,
0xE1B4, 0x5CBD,
0xE1B5, 0x5CAC,
0xE1B6, 0x5CAB,
0xE1B7, 0x5CB1,
0xE1B8, 0x5CA3,
0xE1B9, 0x5CC1,
0xE1BA, 0x5CB7,
0xE1BB, 0x5CC4,
0xE1BC, 0x5CD2,
0xE1BD, 0x5CE4,
0xE1BE, 0x5CCB,
0xE1BF, 0x5CE5,
0xE1C2, 0x5D27,
0xE1C3, 0x5D26,
0xE1C4, 0x5D2E,
0xE1C5, 0x5D24,
0xE1C6, 0x5D1E,
0xE1C7, 0x5D06,
0xE1C8, 0x5D1B,
0xE1C9, 0x5D58,
0xE1CA, 0x5D3E,
0xE1CB, 0x5D34,
0xE1CC, 0x5D3D,
0xE1CD, 0x5D6C,
0xE1CE, 0x5D5B,
0xE1CF, 0x5D6F,
0xE1D0, 0x5D5D,
0xE1D1, 0x5D6B,
0xE1D2, 0x5D4B,
0xE1D3, 0x5D4A,
0xE1D4, 0x5D69,
0xE1D5, 0x5D74,
0xE1D6, 0x5D82,
0xE1D7, 0x5D99,
0xE1D8, 0x5D9D,
0xE1D9, 0x8C73,
0xE1DA, 0x5DB7,
0xE1DB, 0x5DC5,
0xE1DC, 0x5F73,
0xE1DD, 0x5F77,
0xE1DE, 0x5F82,
0xE1DF, 0x5F87,
0xE1E0, 0x5F89,
0xE1E1, 0x5F8C,
0xE1E2, 0x5F95,
0xE1E3, 0x5F99,
0xE1E4, 0x5F9C,
0xE1E5, 0x5FA8,
0xE1E6, 0x5FAD,
0xE1E7, 0x5FB5,
0xE1E8, 0x5FBC,
0xE1E9, 0x8862,
0xE1EA, 0x5F61,
0xE1EB, 0x72AD,
0xE1EC, 0x72B0,
0xE1ED, 0x72B4,
0xE1F0, 0x72C3,
0xE1F1, 0x72C1,
0xE1F2, 0x72CE,
0xE1F3, 0x72CD,
0xE1F4, 0x72D2,
0xE1F5, 0x72E8,
0xE1F6, 0x72EF,
0xE1F7, 0x72E9,
0xE1F8, 0x72F2,
0xE1F9, 0x72F4,
0xE1FA, 0x72F7,
0xE1FB, 0x7301,
0xE1FC, 0x72F3,
0xE1FD, 0x7303,
0xE1FE, 0x72FA,
0xE2A1, 0x72FB,
0xE2A2, 0x7317,
0xE2A3, 0x7313,
0xE2A4, 0x7321,
0xE2A5, 0x730A,
0xE2A6, 0x731E,
0xE2A7, 0x731D,
0xE2A8, 0x7315,
0xE2A9, 0x7322,
0xE2AA, 0x7339,
0xE2AB, 0x7325,
0xE2AC, 0x732C,
0xE2AD, 0x7338,
0xE2AE, 0x7331,
0xE2AF, 0x7350,
0xE2B0, 0x734D,
0xE2B1, 0x7357,
0xE2B2, 0x7360,
0xE2B3, 0x736C,
0xE2B4, 0x736F,
0xE2B5, 0x737E,
0xE2B6, 0x821B,
0xE2B7, 0x5925,
0xE2B8, 0x98E7,
0xE2B9, 0x5924,
0xE2BA, 0x5902,
0xE2BB, 0x9963,
0xE2C2, 0x9974,
0xE2C3, 0x9977,
0xE2C4, 0x997D,
0xE2C5, 0x9980,
0xE2C6, 0x9984,
0xE2C7, 0x9987,
0xE2C8, 0x998A,
0xE2C9, 0x998D,
0xE2CF, 0x5E80,
0xE2D0, 0x5E91,
0xE2D1, 0x5E8B,
0xE2D2, 0x5E96,
0xE2D3, 0x5EA5,
0xE2D4, 0x5EA0,
0xE2D5, 0x5EB9,
0xE2D6, 0x5EB5,
0xE2D7, 0x5EBE,
0xE2D8, 0x5EB3,
0xE2D9, 0x8D53,
0xE2DA, 0x5ED2,
0xE2DB, 0x5ED1,
0xE2DC, 0x5EDB,
0xE2DD, 0x5EE8,
0xE2DE, 0x5EEA,
0xE2DF, 0x81BA,
0xE2E0, 0x5FC4,
0xE2E1, 0x5FC9,
0xE2E2, 0x5FD6,
0xE2E3, 0x5FCF,
0xE2E4, 0x6003,
0xE2E5, 0x5FEE,
0xE2E6, 0x6004,
0xE2E7, 0x5FE1,
0xE2E8, 0x5FE4,
0xE2E9, 0x5FFE,
0xE2EC, 0x5FEA,
0xE2ED, 0x5FED,
0xE2EE, 0x5FF8,
0xE2EF, 0x6019,
0xE2F0, 0x6035,
0xE2F1, 0x6026,
0xE2F2, 0x601B,
0xE2F3, 0x600F,
0xE2F4, 0x600D,
0xE2F5, 0x6029,
0xE2F6, 0x602B,
0xE2F7, 0x600A,
0xE2F8, 0x603F,
0xE2F9, 0x6021,
0xE2FC, 0x607B,
0xE2FD, 0x607A,
0xE2FE, 0x6042,
0xE3A1, 0x606A,
0xE3A2, 0x607D,
0xE3A3, 0x6096,
0xE3A4, 0x609A,
0xE3A5, 0x60AD,
0xE3A6, 0x609D,
0xE3A7, 0x6083,
0xE3A8, 0x6092,
0xE3A9, 0x608C,
0xE3AA, 0x609B,
0xE3AB, 0x60EC,
0xE3AC, 0x60BB,
0xE3AD, 0x60B1,
0xE3AE, 0x60DD,
0xE3AF, 0x60D8,
0xE3B0, 0x60C6,
0xE3B1, 0x60DA,
0xE3B2, 0x60B4,
0xE3B3, 0x6120,
0xE3B4, 0x6126,
0xE3B5, 0x6115,
0xE3B6, 0x6123,
0xE3B7, 0x60F4,
0xE3B8, 0x6100,
0xE3B9, 0x610E,
0xE3BA, 0x612B,
0xE3BB, 0x614A,
0xE3BC, 0x6175,
0xE3BD, 0x61AC,
0xE3BE, 0x6194,
0xE3BF, 0x61A7,
0xE3C0, 0x61B7,
0xE3C1, 0x61D4,
0xE3C2, 0x61F5,
0xE3C3, 0x5FDD,
0xE3C4, 0x96B3,
0xE3C5, 0x95E9,
0xE3C6, 0x95EB,
0xE3C7, 0x95F1,
0xE3C8, 0x95F3,
0xE3CB, 0x95FC,
0xE3CC, 0x95FE,
0xE3CF, 0x9606,
0xE3D0, 0x9608,
0xE3D5, 0x960F,
0xE3D6, 0x9612,
0xE3DC, 0x4E2C,
0xE3DD, 0x723F,
0xE3DE, 0x6215,
0xE3DF, 0x6C35,
0xE3E0, 0x6C54,
0xE3E1, 0x6C5C,
0xE3E2, 0x6C4A,
0xE3E3, 0x6CA3,
0xE3E4, 0x6C85,
0xE3E5, 0x6C90,
0xE3E6, 0x6C94,
0xE3E7, 0x6C8C,
0xE3EA, 0x6C74,
0xE3EB, 0x6C76,
0xE3EC, 0x6C86,
0xE3ED, 0x6CA9,
0xE3EE, 0x6CD0,
0xE3EF, 0x6CD4,
0xE3F0, 0x6CAD,
0xE3F3, 0x6CF1,
0xE3F4, 0x6CD7,
0xE3F5, 0x6CB2,
0xE3F6, 0x6CE0,
0xE3F7, 0x6CD6,
0xE3F8, 0x6CFA,
0xE3F9, 0x6CEB,
0xE3FA, 0x6CEE,
0xE3FB, 0x6CB1,
0xE3FC, 0x6CD3,
0xE3FD, 0x6CEF,
0xE3FE, 0x6CFE,
0xE4A1, 0x6D39,
0xE4A2, 0x6D27,
0xE4A3, 0x6D0C,
0xE4A4, 0x6D43,
0xE4A5, 0x6D48,
0xE4A6, 0x6D07,
0xE4A7, 0x6D04,
0xE4A8, 0x6D19,
0xE4A9, 0x6D0E,
0xE4AA, 0x6D2B,
0xE4AB, 0x6D4D,
0xE4AC, 0x6D2E,
0xE4AD, 0x6D35,
0xE4AE, 0x6D1A,
0xE4AF, 0x6D4F,
0xE4B0, 0x6D52,
0xE4B1, 0x6D54,
0xE4B2, 0x6D33,
0xE4B3, 0x6D91,
0xE4B4, 0x6D6F,
0xE4B5, 0x6D9E,
0xE4B6, 0x6DA0,
0xE4B7, 0x6D5E,
0xE4BA, 0x6D5C,
0xE4BB, 0x6D60,
0xE4BC, 0x6D7C,
0xE4BD, 0x6D63,
0xE4BE, 0x6E1A,
0xE4BF, 0x6DC7,
0xE4C0, 0x6DC5,
0xE4C1, 0x6DDE,
0xE4C2, 0x6E0E,
0xE4C3, 0x6DBF,
0xE4C4, 0x6DE0,
0xE4C5, 0x6E11,
0xE4C6, 0x6DE6,
0xE4C7, 0x6DDD,
0xE4C8, 0x6DD9,
0xE4C9, 0x6E16,
0xE4CA, 0x6DAB,
0xE4CB, 0x6E0C,
0xE4CC, 0x6DAE,
0xE4CD, 0x6E2B,
0xE4CE, 0x6E6E,
0xE4CF, 0x6E4E,
0xE4D0, 0x6E6B,
0xE4D1, 0x6EB2,
0xE4D2, 0x6E5F,
0xE4D3, 0x6E86,
0xE4D6, 0x6E32,
0xE4D7, 0x6E25,
0xE4D8, 0x6E44,
0xE4D9, 0x6EDF,
0xE4DA, 0x6EB1,
0xE4DB, 0x6E98,
0xE4DC, 0x6EE0,
0xE4DD, 0x6F2D,
0xE4DE, 0x6EE2,
0xE4DF, 0x6EA5,
0xE4E0, 0x6EA7,
0xE4E1, 0x6EBD,
0xE4E2, 0x6EBB,
0xE4E3, 0x6EB7,
0xE4E4, 0x6ED7,
0xE4E5, 0x6EB4,
0xE4E6, 0x6ECF,
0xE4E7, 0x6E8F,
0xE4E8, 0x6EC2,
0xE4E9, 0x6E9F,
0xE4EA, 0x6F62,
0xE4ED, 0x6F24,
0xE4EE, 0x6F15,
0xE4EF, 0x6EF9,
0xE4F0, 0x6F2F,
0xE4F1, 0x6F36,
0xE4F2, 0x6F4B,
0xE4F3, 0x6F74,
0xE4F4, 0x6F2A,
0xE4F5, 0x6F09,
0xE4F6, 0x6F29,
0xE4F7, 0x6F89,
0xE4F8, 0x6F8D,
0xE4F9, 0x6F8C,
0xE4FA, 0x6F78,
0xE4FB, 0x6F72,
0xE4FC, 0x6F7C,
0xE4FD, 0x6F7A,
0xE4FE, 0x6FD1,
0xE5A0, 0x936B,
0xE5A1, 0x6FC9,
0xE5A2, 0x6FA7,
0xE5A3, 0x6FB9,
0xE5A4, 0x6FB6,
0xE5A5, 0x6FC2,
0xE5A6, 0x6FE1,
0xE5A7, 0x6FEE,
0xE5A8, 0x6FDE,
0xE5A9, 0x6FE0,
0xE5AA, 0x6FEF,
0xE5AB, 0x701A,
0xE5AC, 0x7023,
0xE5AD, 0x701B,
0xE5AE, 0x7039,
0xE5AF, 0x7035,
0xE5B0, 0x704F,
0xE5B1, 0x705E,
0xE5B2, 0x5B80,
0xE5B3, 0x5B84,
0xE5B4, 0x5B95,
0xE5B5, 0x5B93,
0xE5B6, 0x5BA5,
0xE5B7, 0x5BB8,
0xE5B8, 0x752F,
0xE5B9, 0x9A9E,
0xE5BA, 0x6434,
0xE5BB, 0x5BE4,
0xE5BC, 0x5BEE,
0xE5BD, 0x8930,
0xE5BE, 0x5BF0,
0xE5BF, 0x8E47,
0xE5C0, 0x8B07,
0xE5C1, 0x8FB6,
0xE5C2, 0x8FD3,
0xE5C3, 0x8FD5,
0xE5C4, 0x8FE5,
0xE5C5, 0x8FEE,
0xE5C6, 0x8FE4,
0xE5C7, 0x8FE9,
0xE5C8, 0x8FE6,
0xE5C9, 0x8FF3,
0xE5CA, 0x8FE8,
0xE5CB, 0x9005,
0xE5CC, 0x9004,
0xE5CD, 0x900B,
0xE5CE, 0x9026,
0xE5CF, 0x9011,
0xE5D0, 0x900D,
0xE5D1, 0x9016,
0xE5D2, 0x9021,
0xE5D5, 0x902D,
0xE5D6, 0x902F,
0xE5D7, 0x9044,
0xE5DA, 0x9050,
0xE5DB, 0x9068,
0xE5DC, 0x9058,
0xE5DD, 0x9062,
0xE5DE, 0x905B,
0xE5DF, 0x66B9,
0xE5E0, 0x9074,
0xE5E1, 0x907D,
0xE5E2, 0x9082,
0xE5E3, 0x9088,
0xE5E4, 0x9083,
0xE5E5, 0x908B,
0xE5E6, 0x5F50,
0xE5E7, 0x5F57,
0xE5E8, 0x5F56,
0xE5E9, 0x5F58,
0xE5EA, 0x5C3B,
0xE5EB, 0x54AB,
0xE5EC, 0x5C50,
0xE5ED, 0x5C59,
0xE5EE, 0x5B71,
0xE5EF, 0x5C63,
0xE5F0, 0x5C66,
0xE5F1, 0x7FBC,
0xE5F2, 0x5F2A,
0xE5F3, 0x5F29,
0xE5F4, 0x5F2D,
0xE5F5, 0x8274,
0xE5F6, 0x5F3C,
0xE5F7, 0x9B3B,
0xE5F8, 0x5C6E,
0xE5F9, 0x5981,
0xE5FA, 0x5983,
0xE5FB, 0x598D,
0xE5FE, 0x59A3,
0xE6A1, 0x5997,
0xE6A2, 0x59CA,
0xE6A3, 0x59AB,
0xE6A4, 0x599E,
0xE6A5, 0x59A4,
0xE6A6, 0x59D2,
0xE6A7, 0x59B2,
0xE6A8, 0x59AF,
0xE6A9, 0x59D7,
0xE6AA, 0x59BE,
0xE6AD, 0x59DD,
0xE6AE, 0x5A08,
0xE6AF, 0x59E3,
0xE6B0, 0x59D8,
0xE6B1, 0x59F9,
0xE6B2, 0x5A0C,
0xE6B3, 0x5A09,
0xE6B4, 0x5A32,
0xE6B5, 0x5A34,
0xE6B6, 0x5A11,
0xE6B7, 0x5A23,
0xE6B8, 0x5A13,
0xE6B9, 0x5A40,
0xE6BA, 0x5A67,
0xE6BB, 0x5A4A,
0xE6BC, 0x5A55,
0xE6BD, 0x5A3C,
0xE6BE, 0x5A62,
0xE6BF, 0x5A75,
0xE6C0, 0x80EC,
0xE6C1, 0x5AAA,
0xE6C2, 0x5A9B,
0xE6C3, 0x5A77,
0xE6C4, 0x5A7A,
0xE6C5, 0x5ABE,
0xE6C6, 0x5AEB,
0xE6C7, 0x5AB2,
0xE6C8, 0x5AD2,
0xE6C9, 0x5AD4,
0xE6CA, 0x5AB8,
0xE6CB, 0x5AE0,
0xE6CC, 0x5AE3,
0xE6CD, 0x5AF1,
0xE6CE, 0x5AD6,
0xE6CF, 0x5AE6,
0xE6D0, 0x5AD8,
0xE6D1, 0x5ADC,
0xE6D2, 0x5B09,
0xE6D3, 0x5B17,
0xE6D4, 0x5B16,
0xE6D5, 0x5B32,
0xE6D6, 0x5B37,
0xE6D7, 0x5B40,
0xE6D8, 0x5C15,
0xE6D9, 0x5C1C,
0xE6DA, 0x5B5A,
0xE6DB, 0x5B65,
0xE6DC, 0x5B73,
0xE6DD, 0x5B51,
0xE6DE, 0x5B53,
0xE6DF, 0x5B62,
0xE6E0, 0x9A75,
0xE6E3, 0x9A7A,
0xE6E4, 0x9A7F,
0xE6E5, 0x9A7D,
0xE6E8, 0x9A85,
0xE6E9, 0x9A88,
0xE6EA, 0x9A8A,
0xE6EB, 0x9A90,
0xE6EE, 0x9A96,
0xE6EF, 0x9A98,
0xE6F7, 0x9AA5,
0xE6F8, 0x9AA7,
0xE6F9, 0x7E9F,
0xE6FA, 0x7EA1,
0xE6FB, 0x7EA3,
0xE6FC, 0x7EA5,
0xE7A1, 0x7EAD,
0xE7A2, 0x7EB0,
0xE7A3, 0x7EBE,
0xE7A7, 0x7EC9,
0xE7AA, 0x7ED0,
0xE7AB, 0x7ED4,
0xE7AC, 0x7ED7,
0xE7AD, 0x7EDB,
0xE7B0, 0x7EE8,
0xE7B1, 0x7EEB,
0xE7B6, 0x7F0D,
0xE7B7, 0x7EF6,
0xE7BA, 0x7EFE,
0xE7C2, 0x7F0F,
0xE7C5, 0x7F17,
0xE7C6, 0x7F19,
0xE7C7, 0x7F1C,
0xE7C8, 0x7F1B,
0xE7C9, 0x7F1F,
0xE7DA, 0x7F35,
0xE7DB, 0x5E7A,
0xE7DC, 0x757F,
0xE7DD, 0x5DDB,
0xE7DE, 0x753E,
0xE7DF, 0x9095,
0xE7E0, 0x738E,
0xE7E1, 0x7391,
0xE7E2, 0x73AE,
0xE7E3, 0x73A2,
0xE7E4, 0x739F,
0xE7E5, 0x73CF,
0xE7E6, 0x73C2,
0xE7E7, 0x73D1,
0xE7E8, 0x73B7,
0xE7E9, 0x73B3,
0xE7EA, 0x73C0,
0xE7EB, 0x73C9,
0xE7EC, 0x73C8,
0xE7ED, 0x73E5,
0xE7EE, 0x73D9,
0xE7EF, 0x987C,
0xE7F0, 0x740A,
0xE7F1, 0x73E9,
0xE7F2, 0x73E7,
0xE7F3, 0x73DE,
0xE7F4, 0x73BA,
0xE7F5, 0x73F2,
0xE7F6, 0x740F,
0xE7F7, 0x742A,
0xE7F8, 0x745B,
0xE7F9, 0x7426,
0xE7FA, 0x7425,
0xE7FB, 0x7428,
0xE7FC, 0x7430,
0xE7FD, 0x742E,
0xE7FE, 0x742C,
0xE895, 0x9491,
0xE896, 0x9496,
0xE897, 0x9498,
0xE898, 0x94C7,
0xE899, 0x94CF,
0xE89C, 0x94DA,
0xE89D, 0x94E6,
0xE89E, 0x94FB,
0xE89F, 0x951C,
0xE8A0, 0x9520,
0xE8A1, 0x741B,
0xE8A2, 0x741A,
0xE8A3, 0x7441,
0xE8A4, 0x745C,
0xE8A5, 0x7457,
0xE8A6, 0x7455,
0xE8A7, 0x7459,
0xE8A8, 0x7477,
0xE8A9, 0x746D,
0xE8AA, 0x747E,
0xE8AB, 0x749C,
0xE8AC, 0x748E,
0xE8AF, 0x7487,
0xE8B0, 0x748B,
0xE8B1, 0x749E,
0xE8B4, 0x7490,
0xE8B5, 0x74A7,
0xE8B6, 0x74D2,
0xE8B7, 0x74BA,
0xE8BB, 0x674C,
0xE8BC, 0x6753,
0xE8BD, 0x675E,
0xE8BE, 0x6748,
0xE8BF, 0x6769,
0xE8C0, 0x67A5,
0xE8C1, 0x6787,
0xE8C2, 0x676A,
0xE8C3, 0x6773,
0xE8C4, 0x6798,
0xE8C5, 0x67A7,
0xE8C6, 0x6775,
0xE8C7, 0x67A8,
0xE8C8, 0x679E,
0xE8C9, 0x67AD,
0xE8CA, 0x678B,
0xE8CB, 0x6777,
0xE8CC, 0x677C,
0xE8CD, 0x67F0,
0xE8CE, 0x6809,
0xE8CF, 0x67D8,
0xE8D0, 0x680A,
0xE8D1, 0x67E9,
0xE8D2, 0x67B0,
0xE8D3, 0x680C,
0xE8D4, 0x67D9,
0xE8D5, 0x67B5,
0xE8D6, 0x67DA,
0xE8D7, 0x67B3,
0xE8D8, 0x67DD,
0xE8D9, 0x6800,
0xE8DA, 0x67C3,
0xE8DB, 0x67B8,
0xE8DC, 0x67E2,
0xE8DD, 0x680E,
0xE8DE, 0x67C1,
0xE8DF, 0x67FD,
0xE8E4, 0x684E,
0xE8E5, 0x6862,
0xE8E6, 0x6844,
0xE8E7, 0x6864,
0xE8E8, 0x6883,
0xE8E9, 0x681D,
0xE8EA, 0x6855,
0xE8EB, 0x6866,
0xE8EC, 0x6841,
0xE8ED, 0x6867,
0xE8EE, 0x6840,
0xE8EF, 0x683E,
0xE8F0, 0x684A,
0xE8F1, 0x6849,
0xE8F2, 0x6829,
0xE8F3, 0x68B5,
0xE8F4, 0x688F,
0xE8F5, 0x6874,
0xE8F6, 0x6877,
0xE8F7, 0x6893,
0xE8F8, 0x686B,
0xE8F9, 0x68C2,
0xE8FA, 0x696E,
0xE8FB, 0x68FC,
0xE8FE, 0x68F9,
0xE940, 0x9527,
0xE941, 0x9533,
0xE942, 0x953D,
0xE943, 0x9543,
0xE944, 0x9548,
0xE945, 0x954B,
0xE946, 0x9555,
0xE947, 0x955A,
0xE948, 0x9560,
0xE949, 0x956E,
0xE9A1, 0x6924,
0xE9A2, 0x68F0,
0xE9A3, 0x690B,
0xE9A4, 0x6901,
0xE9A5, 0x6957,
0xE9A6, 0x68E3,
0xE9A7, 0x6910,
0xE9A8, 0x6971,
0xE9A9, 0x6939,
0xE9AA, 0x6960,
0xE9AB, 0x6942,
0xE9AC, 0x695D,
0xE9AD, 0x6984,
0xE9AE, 0x696B,
0xE9AF, 0x6980,
0xE9B0, 0x6998,
0xE9B1, 0x6978,
0xE9B2, 0x6934,
0xE9B3, 0x69CC,
0xE9B6, 0x69CE,
0xE9B7, 0x6989,
0xE9B8, 0x6966,
0xE9B9, 0x6963,
0xE9BA, 0x6979,
0xE9BB, 0x699B,
0xE9BC, 0x69A7,
0xE9BD, 0x69BB,
0xE9BE, 0x69AB,
0xE9BF, 0x69AD,
0xE9C0, 0x69D4,
0xE9C1, 0x69B1,
0xE9C2, 0x69C1,
0xE9C3, 0x69CA,
0xE9C4, 0x69DF,
0xE9C5, 0x6995,
0xE9C6, 0x69E0,
0xE9C7, 0x698D,
0xE9C8, 0x69FF,
0xE9C9, 0x6A2F,
0xE9CA, 0x69ED,
0xE9CD, 0x6A65,
0xE9CE, 0x69F2,
0xE9CF, 0x6A44,
0xE9D0, 0x6A3E,
0xE9D1, 0x6AA0,
0xE9D2, 0x6A50,
0xE9D3, 0x6A5B,
0xE9D4, 0x6A35,
0xE9D5, 0x6A8E,
0xE9D6, 0x6A79,
0xE9D7, 0x6A3D,
0xE9D8, 0x6A28,
0xE9D9, 0x6A58,
0xE9DA, 0x6A7C,
0xE9DB, 0x6A91,
0xE9DC, 0x6A90,
0xE9DD, 0x6AA9,
0xE9DE, 0x6A97,
0xE9DF, 0x6AAB,
0xE9E0, 0x7337,
0xE9E1, 0x7352,
0xE9E4, 0x6B87,
0xE9E5, 0x6B84,
0xE9E8, 0x6B8D,
0xE9EB, 0x6BA1,
0xE9EC, 0x6BAA,
0xE9ED, 0x8F6B,
0xE9EE, 0x8F6D,
0xE9F4, 0x8F78,
0xE9F5, 0x8F77,
0xE9F8, 0x8F7C,
0xE9F9, 0x8F7E,
0xE9FC, 0x8F84,
0xE9FD, 0x8F87,
0xE9FE, 0x8F8B,
0xEA5C, 0x95EC,
0xEA5D, 0x95FF,
0xEA5E, 0x9607,
0xEA5F, 0x9613,
0xEA60, 0x9618,
0xEA61, 0x961B,
0xEA62, 0x961E,
0xEA63, 0x9620,
0xEA74, 0x963E,
0xEA75, 0x9641,
0xEA76, 0x9643,
0xEA77, 0x964A,
0xEA86, 0x9660,
0xEA87, 0x9663,
0xEA8A, 0x966B,
0xEA90, 0x9673,
0xEA9E, 0x9687,
0xEAA4, 0x8F98,
0xEAA5, 0x8F9A,
0xEAA6, 0x8ECE,
0xEAA7, 0x620B,
0xEAA8, 0x6217,
0xEAA9, 0x621B,
0xEAAA, 0x621F,
0xEAAB, 0x6222,
0xEAAC, 0x6221,
0xEAAD, 0x6225,
0xEAAE, 0x6224,
0xEAAF, 0x622C,
0xEAB0, 0x81E7,
0xEAB1, 0x74EF,
0xEAB2, 0x74F4,
0xEAB3, 0x74FF,
0xEAB4, 0x750F,
0xEAB5, 0x7511,
0xEAB6, 0x7513,
0xEAB7, 0x6534,
0xEABB, 0x660A,
0xEABC, 0x6619,
0xEABD, 0x6772,
0xEABE, 0x6603,
0xEABF, 0x6615,
0xEAC0, 0x6600,
0xEAC1, 0x7085,
0xEAC2, 0x66F7,
0xEAC3, 0x661D,
0xEAC4, 0x6634,
0xEAC5, 0x6631,
0xEAC6, 0x6636,
0xEAC7, 0x6635,
0xEAC8, 0x8006,
0xEAC9, 0x665F,
0xEACA, 0x6654,
0xEACB, 0x6641,
0xEACC, 0x664F,
0xEACD, 0x6656,
0xEACE, 0x6661,
0xEACF, 0x6657,
0xEAD0, 0x6677,
0xEAD1, 0x6684,
0xEAD2, 0x668C,
0xEAD3, 0x66A7,
0xEAD4, 0x669D,
0xEAD5, 0x66BE,
0xEAD8, 0x66E6,
0xEAD9, 0x66E9,
0xEADC, 0x8D36,
0xEADD, 0x8D3B,
0xEADE, 0x8D3D,
0xEADF, 0x8D40,
0xEAE4, 0x8D47,
0xEAE5, 0x8D4D,
0xEAE6, 0x8D55,
0xEAE7, 0x8D59,
0xEAE8, 0x89C7,
0xEAF0, 0x726E,
0xEAF1, 0x729F,
0xEAF2, 0x725D,
0xEAF3, 0x7266,
0xEAF4, 0x726F,
0xEAF7, 0x7284,
0xEAF8, 0x728B,
0xEAF9, 0x728D,
0xEAFA, 0x728F,
0xEAFB, 0x7292,
0xEAFC, 0x6308,
0xEAFD, 0x6332,
0xEAFE, 0x63B0,
0xEB40, 0x968C,
0xEB41, 0x968E,
0xEB63, 0x96BF,
0xEB66, 0x96C8,
0xEB7E, 0x96EB,
0xEB88, 0x96F8,
0xEB8D, 0x96FF,
0xEB90, 0x9705,
0xEB9E, 0x971D,
0xEBA1, 0x643F,
0xEBA2, 0x64D8,
0xEBA3, 0x8004,
0xEBA4, 0x6BEA,
0xEBA5, 0x6BF3,
0xEBA6, 0x6BFD,
0xEBA7, 0x6BF5,
0xEBA8, 0x6BF9,
0xEBA9, 0x6C05,
0xEBAA, 0x6C07,
0xEBAB, 0x6C06,
0xEBAC, 0x6C0D,
0xEBAD, 0x6C15,
0xEBB1, 0x6C21,
0xEBB2, 0x6C29,
0xEBB3, 0x6C24,
0xEBB4, 0x6C2A,
0xEBB5, 0x6C32,
0xEBB6, 0x6535,
0xEBB7, 0x6555,
0xEBB8, 0x656B,
0xEBB9, 0x724D,
0xEBBA, 0x7252,
0xEBBB, 0x7256,
0xEBBC, 0x7230,
0xEBBD, 0x8662,
0xEBBE, 0x5216,
0xEBBF, 0x809F,
0xEBC0, 0x809C,
0xEBC1, 0x8093,
0xEBC2, 0x80BC,
0xEBC3, 0x670A,
0xEBC4, 0x80BD,
0xEBC5, 0x80B1,
0xEBC6, 0x80AB,
0xEBC7, 0x80AD,
0xEBC8, 0x80B4,
0xEBC9, 0x80B7,
0xEBCE, 0x80DB,
0xEBCF, 0x80C2,
0xEBD0, 0x80C4,
0xEBD1, 0x80D9,
0xEBD2, 0x80CD,
0xEBD3, 0x80D7,
0xEBD4, 0x6710,
0xEBD5, 0x80DD,
0xEBD6, 0x80EB,
0xEBD7, 0x80F1,
0xEBD8, 0x80F4,
0xEBD9, 0x80ED,
0xEBDC, 0x80F2,
0xEBDD, 0x80FC,
0xEBDE, 0x6715,
0xEBDF, 0x8112,
0xEBE0, 0x8C5A,
0xEBE1, 0x8136,
0xEBE2, 0x811E,
0xEBE3, 0x812C,
0xEBE4, 0x8118,
0xEBE5, 0x8132,
0xEBE6, 0x8148,
0xEBE7, 0x814C,
0xEBE8, 0x8153,
0xEBE9, 0x8174,
0xEBEC, 0x8171,
0xEBED, 0x8160,
0xEBEE, 0x8169,
0xEBF1, 0x816D,
0xEBF2, 0x8167,
0xEBF3, 0x584D,
0xEBF4, 0x5AB5,
0xEBF5, 0x8188,
0xEBF6, 0x8182,
0xEBF7, 0x8191,
0xEBF8, 0x6ED5,
0xEBF9, 0x81A3,
0xEBFA, 0x81AA,
0xEBFB, 0x81CC,
0xEBFC, 0x6726,
0xEBFD, 0x81CA,
0xEBFE, 0x81BB,
0xEC4D, 0x9731,
0xEC6E, 0x975A,
0xEC71, 0x975F,
0xEC80, 0x9772,
0xEC81, 0x9775,
0xEC94, 0x978C,
0xEC98, 0x9793,
0xECA1, 0x81C1,
0xECA2, 0x81A6,
0xECA3, 0x6B24,
0xECA4, 0x6B37,
0xECA5, 0x6B39,
0xECA6, 0x6B43,
0xECA7, 0x6B46,
0xECA8, 0x6B59,
0xECAC, 0x98D5,
0xECAF, 0x6BB3,
0xECB0, 0x5F40,
0xECB1, 0x6BC2,
0xECB2, 0x89F3,
0xECB3, 0x6590,
0xECB4, 0x9F51,
0xECB5, 0x6593,
0xECB6, 0x65BC,
0xECB7, 0x65C6,
0xECB8, 0x65C4,
0xECB9, 0x65C3,
0xECBA, 0x65CC,
0xECBB, 0x65CE,
0xECBC, 0x65D2,
0xECBD, 0x65D6,
0xECBE, 0x7080,
0xECBF, 0x709C,
0xECC0, 0x7096,
0xECC1, 0x709D,
0xECC2, 0x70BB,
0xECC3, 0x70C0,
0xECC4, 0x70B7,
0xECC5, 0x70AB,
0xECC6, 0x70B1,
0xECC7, 0x70E8,
0xECC8, 0x70CA,
0xECC9, 0x7110,
0xECCA, 0x7113,
0xECCB, 0x7116,
0xECCC, 0x712F,
0xECCD, 0x7131,
0xECCE, 0x7173,
0xECCF, 0x715C,
0xECD0, 0x7168,
0xECD1, 0x7145,
0xECD2, 0x7172,
0xECD3, 0x714A,
0xECD4, 0x7178,
0xECD5, 0x717A,
0xECD6, 0x7198,
0xECD7, 0x71B3,
0xECD8, 0x71B5,
0xECD9, 0x71A8,
0xECDA, 0x71A0,
0xECDB, 0x71E0,
0xECDC, 0x71D4,
0xECDD, 0x71E7,
0xECDE, 0x71F9,
0xECDF, 0x721D,
0xECE0, 0x7228,
0xECE1, 0x706C,
0xECE2, 0x7118,
0xECE3, 0x7166,
0xECE4, 0x71B9,
0xECE5, 0x623E,
0xECE6, 0x623D,
0xECE7, 0x6243,
0xECEA, 0x793B,
0xECEB, 0x7940,
0xECEC, 0x7946,
0xECED, 0x7949,
0xECF0, 0x7953,
0xECF1, 0x795A,
0xECF2, 0x7962,
0xECF3, 0x7957,
0xECF4, 0x7960,
0xECF5, 0x796F,
0xECF6, 0x7967,
0xECF7, 0x797A,
0xECF8, 0x7985,
0xECF9, 0x798A,
0xECFA, 0x799A,
0xECFB, 0x79A7,
0xECFC, 0x79B3,
0xECFD, 0x5FD1,
0xECFE, 0x5FD0,
0xED4B, 0x97AC,
0xED4C, 0x97AE,
0xED4F, 0x97B3,
0xED82, 0x97E8,
0xED88, 0x97F4,
0xEDA1, 0x603C,
0xEDA2, 0x605D,
0xEDA3, 0x605A,
0xEDA4, 0x6067,
0xEDA5, 0x6041,
0xEDA6, 0x6059,
0xEDA7, 0x6063,
0xEDA8, 0x60AB,
0xEDA9, 0x6106,
0xEDAA, 0x610D,
0xEDAB, 0x615D,
0xEDAC, 0x61A9,
0xEDAD, 0x619D,
0xEDAE, 0x61CB,
0xEDAF, 0x61D1,
0xEDB0, 0x6206,
0xEDB1, 0x8080,
0xEDB2, 0x807F,
0xEDB3, 0x6C93,
0xEDB4, 0x6CF6,
0xEDB5, 0x6DFC,
0xEDB6, 0x77F6,
0xEDB7, 0x77F8,
0xEDB8, 0x7800,
0xEDB9, 0x7809,
0xEDBC, 0x7811,
0xEDBD, 0x65AB,
0xEDBE, 0x782D,
0xEDC4, 0x781F,
0xEDC5, 0x783C,
0xEDC6, 0x7825,
0xEDC7, 0x782C,
0xEDC8, 0x7823,
0xEDC9, 0x7829,
0xEDCA, 0x784E,
0xEDCB, 0x786D,
0xEDCE, 0x7826,
0xEDCF, 0x7850,
0xEDD0, 0x7847,
0xEDD1, 0x784C,
0xEDD2, 0x786A,
0xEDD3, 0x789B,
0xEDD4, 0x7893,
0xEDD5, 0x789A,
0xEDD6, 0x7887,
0xEDD7, 0x789C,
0xEDD8, 0x78A1,
0xEDD9, 0x78A3,
0xEDDA, 0x78B2,
0xEDDB, 0x78B9,
0xEDDC, 0x78A5,
0xEDDD, 0x78D4,
0xEDDE, 0x78D9,
0xEDDF, 0x78C9,
0xEDE0, 0x78EC,
0xEDE1, 0x78F2,
0xEDE2, 0x7905,
0xEDE3, 0x78F4,
0xEDE4, 0x7913,
0xEDE5, 0x7924,
0xEDE6, 0x791E,
0xEDE7, 0x7934,
0xEDE8, 0x9F9B,
0xEDE9, 0x9EF9,
0xEDEC, 0x76F1,
0xEDED, 0x7704,
0xEDEE, 0x770D,
0xEDEF, 0x76F9,
0xEDF2, 0x771A,
0xEDF3, 0x7722,
0xEDF4, 0x7719,
0xEDF5, 0x772D,
0xEDF6, 0x7726,
0xEDF7, 0x7735,
0xEDF8, 0x7738,
0xEDFB, 0x7747,
0xEDFC, 0x7743,
0xEDFD, 0x775A,
0xEDFE, 0x7768,
0xEEA1, 0x7762,
0xEEA2, 0x7765,
0xEEA3, 0x777F,
0xEEA4, 0x778D,
0xEEA5, 0x777D,
0xEEA6, 0x7780,
0xEEA7, 0x778C,
0xEEA8, 0x7791,
0xEEAB, 0x77B0,
0xEEAC, 0x77B5,
0xEEAD, 0x77BD,
0xEEAE, 0x753A,
0xEEAF, 0x7540,
0xEEB0, 0x754E,
0xEEB1, 0x754B,
0xEEB2, 0x7548,
0xEEB3, 0x755B,
0xEEB4, 0x7572,
0xEEB5, 0x7579,
0xEEB6, 0x7583,
0xEEB7, 0x7F58,
0xEEB8, 0x7F61,
0xEEB9, 0x7F5F,
0xEEBA, 0x8A48,
0xEEBB, 0x7F68,
0xEEBC, 0x7F74,
0xEEBD, 0x7F71,
0xEEBE, 0x7F79,
0xEEBF, 0x7F81,
0xEEC0, 0x7F7E,
0xEEC1, 0x76CD,
0xEEC2, 0x76E5,
0xEEC3, 0x8832,
0xEEC7, 0x948B,
0xEEC8, 0x948A,
0xEECD, 0x9494,
0xEECE, 0x9497,
0xEECF, 0x9495,
0xEED5, 0x94AB,
0xEED6, 0x94AA,
0xEED7, 0x94AD,
0xEED8, 0x94AC,
0xEEDB, 0x94B2,
0xEEDC, 0x94B4,
0xEEE4, 0x94BF,
0xEEE5, 0x94C4,
0xEEF3, 0x94D9,
0xEEF4, 0x94D8,
0xEEF5, 0x94DB,
0xEEF9, 0x94E2,
0xEEFE, 0x94EA,
0xEF46, 0x988B,
0xEF47, 0x988E,
0xEF48, 0x9892,
0xEF49, 0x9895,
0xEF4A, 0x9899,
0xEF4B, 0x98A3,
0xEF74, 0x98D4,
0xEFA1, 0x94E9,
0xEFA2, 0x94EB,
0xEFA8, 0x94F7,
0xEFA9, 0x94F9,
0xEFAC, 0x94FF,
0xEFAD, 0x9503,
0xEFAE, 0x9502,
0xEFBB, 0x9518,
0xEFBC, 0x951B,
0xEFC0, 0x9522,
0xEFC3, 0x9529,
0xEFC4, 0x952C,
0xEFC7, 0x9534,
0xEFCB, 0x953C,
0xEFCE, 0x9542,
0xEFCF, 0x9535,
0xEFD3, 0x9549,
0xEFD4, 0x954C,
0xEFDE, 0x955B,
0xEFE1, 0x955D,
0xEFED, 0x956F,
0xEFF1, 0x953A,
0xEFF2, 0x77E7,
0xEFF3, 0x77EC,
0xEFF4, 0x96C9,
0xEFF5, 0x79D5,
0xEFF6, 0x79ED,
0xEFF7, 0x79E3,
0xEFF8, 0x79EB,
0xEFF9, 0x7A06,
0xEFFA, 0x5D47,
0xEFFB, 0x7A03,
0xEFFC, 0x7A02,
0xEFFD, 0x7A1E,
0xEFFE, 0x7A14,
0xF097, 0x9964,
0xF098, 0x9966,
0xF099, 0x9973,
0xF09C, 0x997B,
0xF09D, 0x997E,
0xF0A0, 0x9989,
0xF0A1, 0x7A39,
0xF0A2, 0x7A37,
0xF0A3, 0x7A51,
0xF0A4, 0x9ECF,
0xF0A5, 0x99A5,
0xF0A6, 0x7A70,
0xF0A7, 0x7688,
0xF0A8, 0x768E,
0xF0A9, 0x7693,
0xF0AA, 0x7699,
0xF0AB, 0x76A4,
0xF0AC, 0x74DE,
0xF0AD, 0x74E0,
0xF0AE, 0x752C,
0xF0AF, 0x9E20,
0xF0B0, 0x9E22,
0xF0B6, 0x9E32,
0xF0B7, 0x9E31,
0xF0B8, 0x9E36,
0xF0B9, 0x9E38,
0xF0BA, 0x9E37,
0xF0BD, 0x9E3E,
0xF0C0, 0x9E44,
0xF0C7, 0x9E4E,
0xF0C8, 0x9E51,
0xF0C9, 0x9E55,
0xF0CA, 0x9E57,
0xF0CE, 0x9E5E,
0xF0CF, 0x9E63,
0xF0D7, 0x9E71,
0xF0D8, 0x9E6D,
0xF0D9, 0x9E73,
0xF0DA, 0x7592,
0xF0DB, 0x7594,
0xF0DC, 0x7596,
0xF0DD, 0x75A0,
0xF0DE, 0x759D,
0xF0DF, 0x75AC,
0xF0E0, 0x75A3,
0xF0E3, 0x75B8,
0xF0E4, 0x75C4,
0xF0E5, 0x75B1,
0xF0E6, 0x75B0,
0xF0E7, 0x75C3,
0xF0E8, 0x75C2,
0xF0E9, 0x75D6,
0xF0EA, 0x75CD,
0xF0EB, 0x75E3,
0xF0EC, 0x75E8,
0xF0ED, 0x75E6,
0xF0EE, 0x75E4,
0xF0EF, 0x75EB,
0xF0F0, 0x75E7,
0xF0F1, 0x7603,
0xF0F2, 0x75F1,
0xF0F3, 0x75FC,
0xF0F4, 0x75FF,
0xF0F5, 0x7610,
0xF0F6, 0x7600,
0xF0F7, 0x7605,
0xF0F8, 0x760C,
0xF0F9, 0x7617,
0xF0FA, 0x760A,
0xF0FB, 0x7625,
0xF0FC, 0x7618,
0xF0FD, 0x7615,
0xF0FE, 0x7619,
0xF140, 0x998C,
0xF141, 0x998E,
0xF1A1, 0x761B,
0xF1A2, 0x763C,
0xF1A3, 0x7622,
0xF1A4, 0x7620,
0xF1A5, 0x7640,
0xF1A6, 0x762D,
0xF1A7, 0x7630,
0xF1A8, 0x763F,
0xF1A9, 0x7635,
0xF1AA, 0x7643,
0xF1AB, 0x763E,
0xF1AC, 0x7633,
0xF1AD, 0x764D,
0xF1AE, 0x765E,
0xF1AF, 0x7654,
0xF1B0, 0x765C,
0xF1B1, 0x7656,
0xF1B2, 0x766B,
0xF1B3, 0x766F,
0xF1B4, 0x7FCA,
0xF1B5, 0x7AE6,
0xF1B8, 0x7A80,
0xF1B9, 0x7A86,
0xF1BA, 0x7A88,
0xF1BB, 0x7A95,
0xF1BC, 0x7AA6,
0xF1BD, 0x7AA0,
0xF1BE, 0x7AAC,
0xF1BF, 0x7AA8,
0xF1C0, 0x7AAD,
0xF1C1, 0x7AB3,
0xF1C2, 0x8864,
0xF1C3, 0x8869,
0xF1C4, 0x8872,
0xF1C5, 0x887D,
0xF1C6, 0x887F,
0xF1C7, 0x8882,
0xF1C8, 0x88A2,
0xF1C9, 0x88C6,
0xF1CA, 0x88B7,
0xF1CB, 0x88BC,
0xF1CC, 0x88C9,
0xF1CD, 0x88E2,
0xF1CE, 0x88CE,
0xF1CF, 0x88E3,
0xF1D0, 0x88E5,
0xF1D1, 0x88F1,
0xF1D2, 0x891A,
0xF1D3, 0x88FC,
0xF1D4, 0x88E8,
0xF1D5, 0x88FE,
0xF1D6, 0x88F0,
0xF1D7, 0x8921,
0xF1D8, 0x8919,
0xF1D9, 0x8913,
0xF1DA, 0x891B,
0xF1DB, 0x890A,
0xF1DC, 0x8934,
0xF1DD, 0x892B,
0xF1DE, 0x8936,
0xF1DF, 0x8941,
0xF1E0, 0x8966,
0xF1E1, 0x897B,
0xF1E2, 0x758B,
0xF1E3, 0x80E5,
0xF1E4, 0x76B2,
0xF1E5, 0x76B4,
0xF1E6, 0x77DC,
0xF1E7, 0x8012,
0xF1E8, 0x8014,
0xF1E9, 0x8016,
0xF1EA, 0x801C,
0xF1EB, 0x8020,
0xF1EC, 0x8022,
0xF1F0, 0x8029,
0xF1F1, 0x8028,
0xF1F2, 0x8031,
0xF1F3, 0x800B,
0xF1F4, 0x8035,
0xF1F5, 0x8043,
0xF1F6, 0x8046,
0xF1F7, 0x804D,
0xF1F8, 0x8052,
0xF1F9, 0x8069,
0xF1FA, 0x8071,
0xF1FB, 0x8983,
0xF1FC, 0x9878,
0xF1FD, 0x9880,
0xF1FE, 0x9883,
0xF2A1, 0x9889,
0xF2A4, 0x988F,
0xF2A5, 0x9894,
0xF2AE, 0x864D,
0xF2AF, 0x8654,
0xF2B0, 0x866C,
0xF2B1, 0x866E,
0xF2B2, 0x867F,
0xF2B3, 0x867A,
0xF2B4, 0x867C,
0xF2B5, 0x867B,
0xF2B6, 0x86A8,
0xF2B7, 0x868D,
0xF2B8, 0x868B,
0xF2B9, 0x86AC,
0xF2BA, 0x869D,
0xF2BB, 0x86A7,
0xF2BC, 0x86A3,
0xF2BD, 0x86AA,
0xF2BE, 0x8693,
0xF2BF, 0x86A9,
0xF2C0, 0x86B6,
0xF2C1, 0x86C4,
0xF2C2, 0x86B5,
0xF2C3, 0x86CE,
0xF2C4, 0x86B0,
0xF2C5, 0x86BA,
0xF2C6, 0x86B1,
0xF2C7, 0x86AF,
0xF2C8, 0x86C9,
0xF2C9, 0x86CF,
0xF2CA, 0x86B4,
0xF2CB, 0x86E9,
0xF2CE, 0x86ED,
0xF2CF, 0x86F3,
0xF2D0, 0x86D0,
0xF2D1, 0x8713,
0xF2D2, 0x86DE,
0xF2D3, 0x86F4,
0xF2D4, 0x86DF,
0xF2D5, 0x86D8,
0xF2D6, 0x86D1,
0xF2D7, 0x8703,
0xF2D8, 0x8707,
0xF2D9, 0x86F8,
0xF2DA, 0x8708,
0xF2DB, 0x870A,
0xF2DC, 0x870D,
0xF2DD, 0x8709,
0xF2DE, 0x8723,
0xF2DF, 0x873B,
0xF2E0, 0x871E,
0xF2E1, 0x8725,
0xF2E2, 0x872E,
0xF2E3, 0x871A,
0xF2E4, 0x873E,
0xF2E5, 0x8748,
0xF2E6, 0x8734,
0xF2E7, 0x8731,
0xF2E8, 0x8729,
0xF2E9, 0x8737,
0xF2EA, 0x873F,
0xF2EB, 0x8782,
0xF2EC, 0x8722,
0xF2EF, 0x877B,
0xF2F0, 0x8760,
0xF2F1, 0x8770,
0xF2F2, 0x874C,
0xF2F3, 0x876E,
0xF2F4, 0x878B,
0xF2F5, 0x8753,
0xF2F6, 0x8763,
0xF2F7, 0x877C,
0xF2F8, 0x8764,
0xF2F9, 0x8759,
0xF2FA, 0x8765,
0xF2FB, 0x8793,
0xF2FC, 0x87AF,
0xF2FD, 0x87A8,
0xF2FE, 0x87D2,
0xF352, 0x9A72,
0xF353, 0x9A83,
0xF354, 0x9A89,
0xF359, 0x9A99,
0xF35A, 0x9AA6,
0xF366, 0x9AB9,
0xF367, 0x9ABB,
0xF376, 0x9AD2,
0xF382, 0x9AE0,
0xF38B, 0x9AEC,
0xF38C, 0x9AEE,
0xF396, 0x9AFA,
0xF3A1, 0x87C6,
0xF3A2, 0x8788,
0xF3A3, 0x8785,
0xF3A4, 0x87AD,
0xF3A5, 0x8797,
0xF3A6, 0x8783,
0xF3A7, 0x87AB,
0xF3A8, 0x87E5,
0xF3A9, 0x87AC,
0xF3AA, 0x87B5,
0xF3AB, 0x87B3,
0xF3AC, 0x87CB,
0xF3AD, 0x87D3,
0xF3AE, 0x87BD,
0xF3AF, 0x87D1,
0xF3B0, 0x87C0,
0xF3B1, 0x87CA,
0xF3B2, 0x87DB,
0xF3B3, 0x87EA,
0xF3B4, 0x87E0,
0xF3B5, 0x87EE,
0xF3B6, 0x8816,
0xF3B7, 0x8813,
0xF3B8, 0x87FE,
0xF3B9, 0x880A,
0xF3BA, 0x881B,
0xF3BB, 0x8821,
0xF3BC, 0x8839,
0xF3BD, 0x883C,
0xF3BE, 0x7F36,
0xF3BF, 0x7F42,
0xF3C2, 0x8210,
0xF3C3, 0x7AFA,
0xF3C4, 0x7AFD,
0xF3C5, 0x7B08,
0xF3C8, 0x7B15,
0xF3C9, 0x7B0A,
0xF3CA, 0x7B2B,
0xF3CB, 0x7B0F,
0xF3CC, 0x7B47,
0xF3CD, 0x7B38,
0xF3CE, 0x7B2A,
0xF3CF, 0x7B19,
0xF3D0, 0x7B2E,
0xF3D1, 0x7B31,
0xF3D2, 0x7B20,
0xF3D3, 0x7B25,
0xF3D4, 0x7B24,
0xF3D5, 0x7B33,
0xF3D6, 0x7B3E,
0xF3D7, 0x7B1E,
0xF3D8, 0x7B58,
0xF3D9, 0x7B5A,
0xF3DA, 0x7B45,
0xF3DB, 0x7B75,
0xF3DC, 0x7B4C,
0xF3DD, 0x7B5D,
0xF3DE, 0x7B60,
0xF3DF, 0x7B6E,
0xF3E0, 0x7B7B,
0xF3E1, 0x7B62,
0xF3E2, 0x7B72,
0xF3E3, 0x7B71,
0xF3E4, 0x7B90,
0xF3E7, 0x7BB8,
0xF3E8, 0x7BAC,
0xF3E9, 0x7B9D,
0xF3EA, 0x7BA8,
0xF3EB, 0x7B85,
0xF3EC, 0x7BAA,
0xF3ED, 0x7B9C,
0xF3EE, 0x7BA2,
0xF3EF, 0x7BAB,
0xF3F0, 0x7BB4,
0xF3F1, 0x7BD1,
0xF3F2, 0x7BC1,
0xF3F3, 0x7BCC,
0xF3F4, 0x7BDD,
0xF3F5, 0x7BDA,
0xF3F8, 0x7BEA,
0xF3F9, 0x7C0C,
0xF3FA, 0x7BFE,
0xF3FB, 0x7BFC,
0xF3FC, 0x7C0F,
0xF3FD, 0x7C16,
0xF3FE, 0x7C0B,
0xF440, 0x9B07,
0xF471, 0x9B46,
0xF475, 0x9B4E,
0xF476, 0x9B50,
0xF4A1, 0x7C1F,
0xF4A2, 0x7C2A,
0xF4A3, 0x7C26,
0xF4A4, 0x7C38,
0xF4A5, 0x7C41,
0xF4A6, 0x7C40,
0xF4A7, 0x81FE,
0xF4AA, 0x8204,
0xF4AB, 0x81EC,
0xF4AC, 0x8844,
0xF4B0, 0x822D,
0xF4B1, 0x822F,
0xF4B2, 0x8228,
0xF4B3, 0x822B,
0xF4B4, 0x8238,
0xF4B5, 0x823B,
0xF4B8, 0x823E,
0xF4B9, 0x8244,
0xF4BA, 0x8249,
0xF4BB, 0x824B,
0xF4BC, 0x824F,
0xF4BD, 0x825A,
0xF4BE, 0x825F,
0xF4BF, 0x8268,
0xF4C0, 0x887E,
0xF4C1, 0x8885,
0xF4C2, 0x8888,
0xF4C3, 0x88D8,
0xF4C4, 0x88DF,
0xF4C5, 0x895E,
0xF4C6, 0x7F9D,
0xF4C7, 0x7F9F,
0xF4C8, 0x7FA7,
0xF4CB, 0x7FB2,
0xF4CC, 0x7C7C,
0xF4CD, 0x6549,
0xF4CE, 0x7C91,
0xF4CF, 0x7C9D,
0xF4D0, 0x7C9C,
0xF4D1, 0x7C9E,
0xF4D2, 0x7CA2,
0xF4D3, 0x7CB2,
0xF4D6, 0x7CC1,
0xF4D7, 0x7CC7,
0xF4DA, 0x7CC8,
0xF4DB, 0x7CC5,
0xF4DC, 0x7CD7,
0xF4DD, 0x7CE8,
0xF4DE, 0x826E,
0xF4DF, 0x66A8,
0xF4E0, 0x7FBF,
0xF4E1, 0x7FCE,
0xF4E2, 0x7FD5,
0xF4E3, 0x7FE5,
0xF4E4, 0x7FE1,
0xF4E5, 0x7FE6,
0xF4E6, 0x7FE9,
0xF4E7, 0x7FEE,
0xF4E8, 0x7FF3,
0xF4E9, 0x7CF8,
0xF4EA, 0x7D77,
0xF4EB, 0x7DA6,
0xF4EC, 0x7DAE,
0xF4ED, 0x7E47,
0xF4EE, 0x7E9B,
0xF4EF, 0x9EB8,
0xF4F0, 0x9EB4,
0xF4F1, 0x8D73,
0xF4F2, 0x8D84,
0xF4F3, 0x8D94,
0xF4F4, 0x8D91,
0xF4F5, 0x8DB1,
0xF4F6, 0x8D67,
0xF4F7, 0x8D6D,
0xF4F8, 0x8C47,
0xF4F9, 0x8C49,
0xF4FA, 0x914A,
0xF4FB, 0x9150,
0xF4FE, 0x9164,
0xF5A1, 0x9162,
0xF5A2, 0x9161,
0xF5A3, 0x9170,
0xF5A4, 0x9169,
0xF5A5, 0x916F,
0xF5A8, 0x9172,
0xF5A9, 0x9174,
0xF5AA, 0x9179,
0xF5AB, 0x918C,
0xF5AC, 0x9185,
0xF5AD, 0x9190,
0xF5AE, 0x918D,
0xF5AF, 0x9191,
0xF5B2, 0x91AA,
0xF5B6, 0x91B5,
0xF5B7, 0x91B4,
0xF5B8, 0x91BA,
0xF5B9, 0x8C55,
0xF5BA, 0x9E7E,
0xF5BB, 0x8DB8,
0xF5BC, 0x8DEB,
0xF5BD, 0x8E05,
0xF5BE, 0x8E59,
0xF5BF, 0x8E69,
0xF5C0, 0x8DB5,
0xF5C1, 0x8DBF,
0xF5C2, 0x8DBC,
0xF5C3, 0x8DBA,
0xF5C4, 0x8DC4,
0xF5C7, 0x8DDA,
0xF5C8, 0x8DDE,
0xF5CB, 0x8DDB,
0xF5CC, 0x8DC6,
0xF5CD, 0x8DEC,
0xF5D0, 0x8DE3,
0xF5D1, 0x8DF9,
0xF5D2, 0x8DFB,
0xF5D3, 0x8DE4,
0xF5D4, 0x8E09,
0xF5D5, 0x8DFD,
0xF5D6, 0x8E14,
0xF5D7, 0x8E1D,
0xF5D8, 0x8E1F,
0xF5D9, 0x8E2C,
0xF5DA, 0x8E2E,
0xF5DB, 0x8E23,
0xF5DC, 0x8E2F,
0xF5DD, 0x8E3A,
0xF5DE, 0x8E40,
0xF5DF, 0x8E39,
0xF5E0, 0x8E35,
0xF5E1, 0x8E3D,
0xF5E2, 0x8E31,
0xF5E3, 0x8E49,
0xF5E8, 0x8E4A,
0xF5E9, 0x8E70,
0xF5EA, 0x8E76,
0xF5EB, 0x8E7C,
0xF5EC, 0x8E6F,
0xF5ED, 0x8E74,
0xF5EE, 0x8E85,
0xF5EF, 0x8E8F,
0xF5F0, 0x8E94,
0xF5F1, 0x8E90,
0xF5F2, 0x8E9C,
0xF5F3, 0x8E9E,
0xF5F4, 0x8C78,
0xF5F5, 0x8C82,
0xF5F6, 0x8C8A,
0xF5F7, 0x8C85,
0xF5F8, 0x8C98,
0xF5F9, 0x8C94,
0xF5FA, 0x659B,
0xF5FB, 0x89D6,
0xF5FC, 0x89DE,
0xF5FD, 0x89DA,
0xF5FE, 0x89DC,
0xF6A1, 0x89E5,
0xF6A2, 0x89EB,
0xF6A3, 0x89EF,
0xF6A4, 0x8A3E,
0xF6A5, 0x8B26,
0xF6A6, 0x9753,
0xF6A7, 0x96E9,
0xF6A8, 0x96F3,
0xF6A9, 0x96EF,
0xF6AA, 0x9706,
0xF6AB, 0x9701,
0xF6AC, 0x9708,
0xF6AD, 0x970F,
0xF6AE, 0x970E,
0xF6AF, 0x972A,
0xF6B0, 0x972D,
0xF6B1, 0x9730,
0xF6B2, 0x973E,
0xF6B3, 0x9F80,
0xF6B4, 0x9F83,
0xF6BB, 0x9F8C,
0xF6BC, 0x9EFE,
0xF6BD, 0x9F0B,
0xF6BE, 0x9F0D,
0xF6BF, 0x96B9,
0xF6C2, 0x96CE,
0xF6C3, 0x96D2,
0xF6C4, 0x77BF,
0xF6C5, 0x96E0,
0xF6C6, 0x928E,
0xF6C7, 0x92AE,
0xF6C8, 0x92C8,
0xF6C9, 0x933E,
0xF6CA, 0x936A,
0xF6CB, 0x93CA,
0xF6CC, 0x938F,
0xF6CD, 0x943E,
0xF6CE, 0x946B,
0xF6CF, 0x9C7F,
0xF6D0, 0x9C82,
0xF6D5, 0x7A23,
0xF6D6, 0x9C8B,
0xF6D7, 0x9C8E,
0xF6EA, 0x9CAB,
0xF780, 0x9C7B,
0xF783, 0x9C80,
0xF788, 0x9C8C,
0xF789, 0x9C8F,
0xF78A, 0x9C93,
0xF78F, 0x9C9D,
0xF790, 0x9CAA,
0xF791, 0x9CAC,
0xF792, 0x9CAF,
0xF793, 0x9CB9,
0xF7AE, 0x9CDF,
0xF7AF, 0x9CE2,
0xF7B0, 0x977C,
0xF7B1, 0x9785,
0xF7B4, 0x9794,
0xF7B5, 0x97AF,
0xF7B6, 0x97AB,
0xF7B7, 0x97A3,
0xF7B8, 0x97B2,
0xF7B9, 0x97B4,
0xF7BA, 0x9AB1,
0xF7BB, 0x9AB0,
0xF7BC, 0x9AB7,
0xF7BD, 0x9E58,
0xF7BE, 0x9AB6,
0xF7BF, 0x9ABA,
0xF7C0, 0x9ABC,
0xF7C1, 0x9AC1,
0xF7C2, 0x9AC0,
0xF7C3, 0x9AC5,
0xF7C4, 0x9AC2,
0xF7C7, 0x9AD1,
0xF7C8, 0x9B45,
0xF7C9, 0x9B43,
0xF7CA, 0x9B47,
0xF7CB, 0x9B49,
0xF7CC, 0x9B48,
0xF7CD, 0x9B4D,
0xF7CE, 0x9B51,
0xF7CF, 0x98E8,
0xF7D0, 0x990D,
0xF7D1, 0x992E,
0xF7D2, 0x9955,
0xF7D3, 0x9954,
0xF7D4, 0x9ADF,
0xF7D5, 0x9AE1,
0xF7D6, 0x9AE6,
0xF7D7, 0x9AEF,
0xF7D8, 0x9AEB,
0xF7D9, 0x9AFB,
0xF7DA, 0x9AED,
0xF7DB, 0x9AF9,
0xF7DC, 0x9B08,
0xF7DD, 0x9B0F,
0xF7DE, 0x9B13,
0xF7DF, 0x9B1F,
0xF7E0, 0x9B23,
0xF7E3, 0x7E3B,
0xF7E4, 0x9E82,
0xF7E7, 0x9E8B,
0xF7E8, 0x9E92,
0xF7E9, 0x93D6,
0xF7EA, 0x9E9D,
0xF7EB, 0x9E9F,
0xF7EF, 0x9EE0,
0xF7F0, 0x9EDF,
0xF7F1, 0x9EE2,
0xF7F2, 0x9EE9,
0xF7F3, 0x9EE7,
0xF7F4, 0x9EE5,
0xF7F5, 0x9EEA,
0xF7F6, 0x9EEF,
0xF7F7, 0x9F22,
0xF7F8, 0x9F2C,
0xF7F9, 0x9F2F,
0xF7FA, 0x9F39,
0xF7FB, 0x9F37,
0xF7FE, 0x9F44,
0xFB5C, 0x9E24,
0xFB5D, 0x9E27,
0xFB5E, 0x9E2E,
0xFB5F, 0x9E30,
0xFB60, 0x9E34,
0xFB63, 0x9E40,
0xFB64, 0x9E4D,
0xFB65, 0x9E50,
0xFB69, 0x9E56,
0xFB6A, 0x9E59,
0xFB6B, 0x9E5D,
0xFB70, 0x9E65,
0xFB73, 0x9E72,
0xFB7E, 0x9E80,
0xFB80, 0x9E81,
0xFB96, 0x9E9E,
0xFC4E, 0x9EBC,
0xFC5B, 0x9ED0,
0xFC63, 0x9EDE,
0xFC64, 0x9EE1,
0xFC67, 0x9EE6,
0xFC68, 0x9EE8,
0xFC76, 0x9EFA,
0xFC77, 0x9EFD,
0xFC85, 0x9F0C,
0xFC86, 0x9F0F,
0xFC8C, 0x9F18,
0xFC93, 0x9F21,
0xFD45, 0x9F38,
0xFD46, 0x9F3A,
0xFD47, 0x9F3C,
0xFD9C, 0xF92C,
0xFD9D, 0xF979,
0xFD9E, 0xF995,
0xFD9F, 0xF9E7,
0xFDA0, 0xF9F1,
0xFE44, 0xFA11,
0xFE47, 0xFA18, // }}}
};
static const unsigned short _gbk2utf16_3[] =
{
0x8141, 0x8143, 0x4E04, // {{{
0x8147, 0x8149, 0x4E1F,
0x814D, 0x814E, 0x4E2E,
0x8154, 0x8156, 0x4E40,
0x815D, 0x815E, 0x4E5A,
0x815F, 0x8162, 0x4E62,
0x8163, 0x8164, 0x4E67,
0x8165, 0x816A, 0x4E6A,
0x816C, 0x8175, 0x4E74,
0x8176, 0x817C, 0x4E7F,
0x8181, 0x8182, 0x4E96,
0x8184, 0x8186, 0x4E9C,
0x8189, 0x818B, 0x4EAF,
0x818D, 0x8190, 0x4EB6,
0x8191, 0x8193, 0x4EBC,
0x8196, 0x8197, 0x4ECF,
0x8199, 0x819B, 0x4EDA,
0x819E, 0x819F, 0x4EE6,
0x81A1, 0x81A3, 0x4EED,
0x81A6, 0x81A8, 0x4EF8,
0x81AC, 0x81B2, 0x4F02,
0x81B3, 0x81B4, 0x4F0B,
0x81B5, 0x81B9, 0x4F12,
0x81BA, 0x81BB, 0x4F1C,
0x81BE, 0x81BF, 0x4F28,
0x81C0, 0x81C2, 0x4F2C,
0x81C9, 0x81CD, 0x4F3E,
0x81CE, 0x81CF, 0x4F44,
0x81D0, 0x81D5, 0x4F47,
0x81D9, 0x81DA, 0x4F61,
0x81DD, 0x81DE, 0x4F6A,
0x81DF, 0x81E0, 0x4F6D,
0x81E1, 0x81E2, 0x4F71,
0x81E4, 0x81E7, 0x4F77,
0x81E9, 0x81EB, 0x4F80,
0x81EC, 0x81EE, 0x4F85,
0x81F3, 0x81F4, 0x4F92,
0x81F5, 0x81F6, 0x4F95,
0x81F7, 0x81F9, 0x4F98,
0x81FB, 0x81FC, 0x4F9E,
0x81FD, 0x81FE, 0x4FA1,
0x8243, 0x8247, 0x4FB0,
0x8248, 0x8250, 0x4FB6,
0x8251, 0x8253, 0x4FC0,
0x8254, 0x8257, 0x4FC6,
0x8258, 0x825A, 0x4FCB,
0x825B, 0x825F, 0x4FD2,
0x8264, 0x8265, 0x4FE4,
0x8267, 0x8268, 0x4FEB,
0x826B, 0x826E, 0x4FF4,
0x8270, 0x8272, 0x4FFB,
0x8273, 0x827E, 0x4FFF,
0x8282, 0x8283, 0x5010,
0x8285, 0x8287, 0x5015,
0x8289, 0x828A, 0x501D,
0x828C, 0x828E, 0x5022,
0x8291, 0x829B, 0x502F,
0x829E, 0x82A1, 0x503F,
0x82A2, 0x82A4, 0x5044,
0x82A5, 0x82A7, 0x5049,
0x82A9, 0x82AD, 0x5050,
0x82AE, 0x82B1, 0x5056,
0x82B3, 0x82BA, 0x505D,
0x82BB, 0x82C0, 0x5066,
0x82C1, 0x82C9, 0x506D,
0x82CA, 0x82CC, 0x5078,
0x82CD, 0x82CE, 0x507C,
0x82CF, 0x82D2, 0x5081,
0x82D3, 0x82D4, 0x5086,
0x82D5, 0x82D8, 0x5089,
0x82D9, 0x82ED, 0x508E,
0x82F0, 0x82F1, 0x50AA,
0x82F2, 0x82F6, 0x50AD,
0x82F7, 0x82FD, 0x50B3,
0x8340, 0x8351, 0x50BD,
0x8352, 0x8357, 0x50D0,
0x8358, 0x835A, 0x50D7,
0x835B, 0x8365, 0x50DB,
0x8366, 0x8369, 0x50E8,
0x836A, 0x836D, 0x50EF,
0x836F, 0x8373, 0x50F6,
0x8374, 0x837D, 0x50FC,
0x8380, 0x8381, 0x5109,
0x8382, 0x8387, 0x510C,
0x8388, 0x8395, 0x5113,
0x8396, 0x83B2, 0x5122,
0x83B7, 0x83B9, 0x514E,
0x83BA, 0x83BB, 0x5152,
0x83BC, 0x83BE, 0x5157,
0x83C0, 0x83C4, 0x515D,
0x83C5, 0x83C6, 0x5163,
0x83C7, 0x83C8, 0x5166,
0x83C9, 0x83CA, 0x5169,
0x83CE, 0x83CF, 0x517E,
0x83D0, 0x83D1, 0x5183,
0x83D2, 0x83D3, 0x5186,
0x83D4, 0x83D5, 0x518A,
0x83D6, 0x83D9, 0x518E,
0x83DA, 0x83DB, 0x5193,
0x83DE, 0x83E0, 0x519D,
0x83E3, 0x83E7, 0x51A6,
0x83E8, 0x83E9, 0x51AD,
0x83EB, 0x83ED, 0x51B8,
0x83EE, 0x83EF, 0x51BE,
0x83F0, 0x83F2, 0x51C1,
0x83F6, 0x83F7, 0x51CD,
0x83F9, 0x83FE, 0x51D2,
0x8440, 0x8442, 0x51D8,
0x8444, 0x8445, 0x51DE,
0x8446, 0x8447, 0x51E2,
0x8448, 0x844D, 0x51E5,
0x8450, 0x8451, 0x51F1,
0x8455, 0x8456, 0x5204,
0x8458, 0x8459, 0x520B,
0x845A, 0x845B, 0x520F,
0x845C, 0x845E, 0x5213,
0x8460, 0x8461, 0x521E,
0x8462, 0x8464, 0x5221,
0x8465, 0x8467, 0x5225,
0x846B, 0x846C, 0x5231,
0x846D, 0x846E, 0x5234,
0x8471, 0x8476, 0x5244,
0x8478, 0x8479, 0x524E,
0x847A, 0x847B, 0x5252,
0x847D, 0x847E, 0x5257,
0x8480, 0x8482, 0x5259,
0x8484, 0x8485, 0x525F,
0x8486, 0x8488, 0x5262,
0x848B, 0x848E, 0x526B,
0x848F, 0x8490, 0x5270,
0x8491, 0x849A, 0x5273,
0x849D, 0x84A1, 0x5283,
0x84A2, 0x84A8, 0x5289,
0x84A9, 0x84AA, 0x5291,
0x84AB, 0x84B1, 0x5294,
0x84B3, 0x84B6, 0x52A4,
0x84B7, 0x84B9, 0x52AE,
0x84BA, 0x84C3, 0x52B4,
0x84C4, 0x84C6, 0x52C0,
0x84C7, 0x84C9, 0x52C4,
0x84CC, 0x84CF, 0x52CC,
0x84D1, 0x84D3, 0x52D3,
0x84D5, 0x84DA, 0x52D9,
0x84DB, 0x84DE, 0x52E0,
0x84DF, 0x84E9, 0x52E5,
0x84EA, 0x84F1, 0x52F1,
0x84F2, 0x84F4, 0x52FB,
0x84F5, 0x84F8, 0x5301,
0x84FA, 0x84FD, 0x5309,
0x8540, 0x8543, 0x5311,
0x8545, 0x8546, 0x531B,
0x8547, 0x8548, 0x531E,
0x854A, 0x854B, 0x5324,
0x854C, 0x854E, 0x5327,
0x854F, 0x8551, 0x532B,
0x8552, 0x855B, 0x532F,
0x855C, 0x855D, 0x533C,
0x8562, 0x8564, 0x534B,
0x8567, 0x8568, 0x5358,
0x856E, 0x856F, 0x536C,
0x8573, 0x8576, 0x537B,
0x8577, 0x8578, 0x5380,
0x857A, 0x857B, 0x5387,
0x857D, 0x857E, 0x538E,
0x8580, 0x8584, 0x5390,
0x8585, 0x8586, 0x5396,
0x8588, 0x8589, 0x539B,
0x858B, 0x858C, 0x53A0,
0x858F, 0x8592, 0x53AA,
0x8593, 0x8599, 0x53AF,
0x859A, 0x859D, 0x53B7,
0x859E, 0x85A0, 0x53BC,
0x85A2, 0x85A6, 0x53C3,
0x85A7, 0x85A9, 0x53CE,
0x85AA, 0x85AB, 0x53D2,
0x85AE, 0x85B0, 0x53DC,
0x85B1, 0x85B2, 0x53E1,
0x85B6, 0x85B8, 0x53FE,
0x85BE, 0x85C0, 0x5418,
0x85C3, 0x85C4, 0x5424,
0x85C8, 0x85C9, 0x5436,
0x85CD, 0x85CE, 0x5441,
0x85CF, 0x85D0, 0x5444,
0x85D3, 0x85D6, 0x544C,
0x85D9, 0x85DD, 0x545D,
0x85E1, 0x85E8, 0x5469,
0x85EA, 0x85EB, 0x5479,
0x85EC, 0x85ED, 0x547E,
0x85F1, 0x85F4, 0x5487,
0x85F8, 0x85F9, 0x5497,
0x85FB, 0x85FE, 0x549E,
0x8645, 0x8647, 0x54B5,
0x8648, 0x8649, 0x54B9,
0x864E, 0x864F, 0x54CA,
0x8653, 0x8657, 0x54E0,
0x8658, 0x8659, 0x54EB,
0x865A, 0x865C, 0x54EF,
0x865D, 0x8662, 0x54F4,
0x8666, 0x8669, 0x5502,
0x866B, 0x866F, 0x550A,
0x8670, 0x8671, 0x5512,
0x8672, 0x8677, 0x5515,
0x8678, 0x867B, 0x551C,
0x867D, 0x867E, 0x5525,
0x8680, 0x8681, 0x5528,
0x8685, 0x8687, 0x5534,
0x8688, 0x868B, 0x5538,
0x8690, 0x8691, 0x5547,
0x8692, 0x8696, 0x554B,
0x8697, 0x869A, 0x5551,
0x869B, 0x869F, 0x5557,
0x86A0, 0x86A3, 0x555D,
0x86A4, 0x86A5, 0x5562,
0x86A6, 0x86A7, 0x5568,
0x86A9, 0x86AE, 0x556F,
0x86AF, 0x86B0, 0x5579,
0x86B3, 0x86B4, 0x5585,
0x86B5, 0x86B7, 0x558C,
0x86B9, 0x86BA, 0x5592,
0x86BB, 0x86BD, 0x5595,
0x86BE, 0x86BF, 0x559A,
0x86C1, 0x86C7, 0x55A0,
0x86C8, 0x86D0, 0x55A8,
0x86D7, 0x86DB, 0x55BF,
0x86DC, 0x86DE, 0x55C6,
0x86DF, 0x86E0, 0x55CA,
0x86E1, 0x86E3, 0x55CE,
0x86E5, 0x86E9, 0x55D7,
0x86EF, 0x86F0, 0x55ED,
0x86F1, 0x86F2, 0x55F0,
0x86F5, 0x86F9, 0x55F8,
0x86FB, 0x86FE, 0x5602,
0x8740, 0x8741, 0x5606,
0x8742, 0x8743, 0x560A,
0x8745, 0x874C, 0x5610,
0x874D, 0x874E, 0x5619,
0x874F, 0x8750, 0x561C,
0x8751, 0x8753, 0x5620,
0x8754, 0x8755, 0x5625,
0x8756, 0x8759, 0x5628,
0x875A, 0x875C, 0x562E,
0x875F, 0x8760, 0x5637,
0x8762, 0x8764, 0x563C,
0x8765, 0x8770, 0x5640,
0x8771, 0x8775, 0x564F,
0x8776, 0x8777, 0x5655,
0x8778, 0x8779, 0x565A,
0x877A, 0x877E, 0x565D,
0x8781, 0x8783, 0x5665,
0x8784, 0x8787, 0x566D,
0x8788, 0x878B, 0x5672,
0x878C, 0x878F, 0x5677,
0x8790, 0x8797, 0x567D,
0x8798, 0x879E, 0x5687,
0x879F, 0x87A1, 0x5690,
0x87A2, 0x87B0, 0x5694,
0x87B1, 0x87BB, 0x56A4,
0x87BC, 0x87C2, 0x56B0,
0x87C3, 0x87C6, 0x56B8,
0x87C7, 0x87D3, 0x56BD,
0x87D4, 0x87DC, 0x56CB,
0x87DD, 0x87DE, 0x56D5,
0x87DF, 0x87E0, 0x56D8,
0x87E3, 0x87E8, 0x56E5,
0x87EA, 0x87EB, 0x56EE,
0x87EC, 0x87ED, 0x56F2,
0x87EE, 0x87F0, 0x56F6,
0x87F1, 0x87F2, 0x56FB,
0x87F3, 0x87F5, 0x5700,
0x87F8, 0x87FE, 0x570B,
0x8840, 0x8849, 0x5712,
0x884A, 0x884B, 0x571D,
0x884C, 0x884E, 0x5720,
0x884F, 0x8852, 0x5724,
0x8854, 0x8855, 0x5731,
0x8856, 0x885A, 0x5734,
0x885B, 0x885C, 0x573C,
0x885F, 0x8862, 0x5743,
0x8863, 0x8864, 0x5748,
0x8866, 0x886A, 0x5752,
0x886B, 0x886C, 0x5758,
0x886D, 0x886E, 0x5762,
0x8873, 0x8875, 0x5770,
0x8876, 0x8877, 0x5774,
0x8878, 0x887A, 0x5778,
0x887B, 0x887E, 0x577D,
0x8881, 0x8884, 0x5787,
0x8885, 0x8889, 0x578D,
0x888A, 0x8890, 0x5794,
0x8891, 0x8894, 0x579C,
0x8899, 0x889B, 0x57AF,
0x889D, 0x889F, 0x57B5,
0x88A0, 0x88A8, 0x57B9,
0x88A9, 0x88AF, 0x57C4,
0x88B0, 0x88B1, 0x57CC,
0x88B2, 0x88B3, 0x57D0,
0x88B5, 0x88B6, 0x57D6,
0x88B7, 0x88B8, 0x57DB,
0x88BA, 0x88BC, 0x57E1,
0x88BD, 0x88C4, 0x57E5,
0x88C6, 0x88C9, 0x57F0,
0x88CA, 0x88CC, 0x57F5,
0x88CD, 0x88CE, 0x57FB,
0x88CF, 0x88D0, 0x57FE,
0x88D2, 0x88D4, 0x5803,
0x88D5, 0x88D7, 0x5808,
0x88D9, 0x88DB, 0x580E,
0x88DC, 0x88DE, 0x5812,
0x88DF, 0x88E1, 0x5816,
0x88E2, 0x88E5, 0x581A,
0x88E7, 0x88E8, 0x5822,
0x88E9, 0x88ED, 0x5825,
0x88EE, 0x88F2, 0x582B,
0x88F3, 0x88F6, 0x5831,
0x88F7, 0x88FE, 0x5836,
0x8940, 0x8945, 0x583E,
0x8946, 0x894C, 0x5845,
0x894D, 0x894F, 0x584E,
0x8950, 0x8951, 0x5852,
0x8952, 0x8954, 0x5855,
0x8955, 0x8959, 0x5859,
0x895A, 0x895F, 0x585F,
0x8960, 0x8964, 0x5866,
0x8965, 0x8975, 0x586D,
0x8979, 0x897B, 0x5886,
0x897C, 0x897E, 0x588A,
0x8980, 0x8984, 0x588D,
0x8985, 0x8989, 0x5894,
0x898A, 0x898C, 0x589B,
0x898D, 0x8994, 0x58A0,
0x8995, 0x89A6, 0x58AA,
0x89A7, 0x89AA, 0x58BD,
0x89AB, 0x89AD, 0x58C2,
0x89AE, 0x89B8, 0x58C6,
0x89B9, 0x89BB, 0x58D2,
0x89BC, 0x89C9, 0x58D6,
0x89CA, 0x89CF, 0x58E5,
0x89D2, 0x89D3, 0x58F1,
0x89D4, 0x89D5, 0x58F4,
0x89D6, 0x89D7, 0x58F7,
0x89D8, 0x89DF, 0x58FA,
0x89E1, 0x89E2, 0x5905,
0x89E3, 0x89E7, 0x5908,
0x89E9, 0x89EC, 0x5910,
0x89ED, 0x89EE, 0x5917,
0x89F0, 0x89F1, 0x591D,
0x89F2, 0x89F5, 0x5920,
0x89FA, 0x89FB, 0x5932,
0x89FC, 0x89FD, 0x5935,
0x8A40, 0x8A43, 0x593D,
0x8A45, 0x8A46, 0x5945,
0x8A48, 0x8A49, 0x594C,
0x8A4B, 0x8A4C, 0x5952,
0x8A4E, 0x8A52, 0x595B,
0x8A54, 0x8A55, 0x5963,
0x8A56, 0x8A62, 0x5966,
0x8A65, 0x8A67, 0x597A,
0x8A68, 0x8A6A, 0x597E,
0x8A6D, 0x8A6E, 0x598B,
0x8A6F, 0x8A72, 0x598E,
0x8A73, 0x8A74, 0x5994,
0x8A76, 0x8A79, 0x599A,
0x8A7A, 0x8A7D, 0x599F,
0x8A81, 0x8A82, 0x59AC,
0x8A83, 0x8A84, 0x59B0,
0x8A85, 0x8A8A, 0x59B3,
0x8A8C, 0x8A8D, 0x59BC,
0x8A8E, 0x8A94, 0x59BF,
0x8A95, 0x8A97, 0x59C7,
0x8A98, 0x8A9B, 0x59CC,
0x8A9C, 0x8A9D, 0x59D5,
0x8AA0, 0x8AA4, 0x59DE,
0x8AA6, 0x8AA7, 0x59E6,
0x8AA8, 0x8AAA, 0x59E9,
0x8AAB, 0x8AB6, 0x59ED,
0x8AB8, 0x8ABA, 0x59FC,
0x8ABD, 0x8ABE, 0x5A0A,
0x8ABF, 0x8AC2, 0x5A0D,
0x8AC4, 0x8AC7, 0x5A14,
0x8AC8, 0x8ACA, 0x5A19,
0x8ACB, 0x8ACC, 0x5A1D,
0x8ACD, 0x8ACE, 0x5A21,
0x8AD0, 0x8AD2, 0x5A26,
0x8AD3, 0x8AD9, 0x5A2A,
0x8ADC, 0x8AE0, 0x5A37,
0x8AE1, 0x8AE3, 0x5A3D,
0x8AE4, 0x8AE8, 0x5A41,
0x8AE9, 0x8AEA, 0x5A47,
0x8AEB, 0x8AF4, 0x5A4B,
0x8AF5, 0x8AF8, 0x5A56,
0x8AF9, 0x8AFE, 0x5A5B,
0x8B41, 0x8B44, 0x5A63,
0x8B45, 0x8B46, 0x5A68,
0x8B47, 0x8B4F, 0x5A6B,
0x8B50, 0x8B51, 0x5A78,
0x8B52, 0x8B55, 0x5A7B,
0x8B56, 0x8B67, 0x5A80,
0x8B68, 0x8B6E, 0x5A93,
0x8B6F, 0x8B7C, 0x5A9C,
0x8B7D, 0x8B7E, 0x5AAB,
0x8B80, 0x8B84, 0x5AAD,
0x8B86, 0x8B87, 0x5AB6,
0x8B88, 0x8B8C, 0x5AB9,
0x8B8D, 0x8B8E, 0x5ABF,
0x8B8F, 0x8B94, 0x5AC3,
0x8B95, 0x8B96, 0x5ACA,
0x8B97, 0x8B9B, 0x5ACD,
0x8B9F, 0x8BA1, 0x5AD9,
0x8BA2, 0x8BA4, 0x5ADD,
0x8BA6, 0x8BA7, 0x5AE4,
0x8BA8, 0x8BA9, 0x5AE7,
0x8BAB, 0x8BAF, 0x5AEC,
0x8BB0, 0x8BC6, 0x5AF2,
0x8BC7, 0x8BD2, 0x5B0A,
0x8BD3, 0x8BEC, 0x5B18,
0x8BEE, 0x8BEF, 0x5B35,
0x8BF0, 0x8BF7, 0x5B38,
0x8BF8, 0x8BFE, 0x5B41,
0x8C40, 0x8C47, 0x5B48,
0x8C4B, 0x8C4C, 0x5B60,
0x8C4D, 0x8C4E, 0x5B67,
0x8C50, 0x8C52, 0x5B6D,
0x8C55, 0x8C58, 0x5B76,
0x8C59, 0x8C5A, 0x5B7B,
0x8C5B, 0x8C5C, 0x5B7E,
0x8C60, 0x8C61, 0x5B8D,
0x8C62, 0x8C64, 0x5B90,
0x8C68, 0x8C6A, 0x5BA7,
0x8C6B, 0x8C6E, 0x5BAC,
0x8C6F, 0x8C70, 0x5BB1,
0x8C72, 0x8C74, 0x5BBA,
0x8C75, 0x8C76, 0x5BC0,
0x8C78, 0x8C7B, 0x5BC8,
0x8C7C, 0x8C7E, 0x5BCD,
0x8C81, 0x8C89, 0x5BD4,
0x8C8B, 0x8C8C, 0x5BE2,
0x8C8D, 0x8C8E, 0x5BE6,
0x8C8F, 0x8C93, 0x5BE9,
0x8C95, 0x8C9B, 0x5BF1,
0x8C9C, 0x8C9D, 0x5BFD,
0x8C9F, 0x8CA0, 0x5C02,
0x8CA2, 0x8CA3, 0x5C07,
0x8CA4, 0x8CA7, 0x5C0B,
0x8CA9, 0x8CAA, 0x5C12,
0x8CAE, 0x8CB1, 0x5C1E,
0x8CB4, 0x8CB7, 0x5C28,
0x8CB8, 0x8CBB, 0x5C2D,
0x8CBC, 0x8CBD, 0x5C32,
0x8CBE, 0x8CC0, 0x5C35,
0x8CC1, 0x8CC2, 0x5C43,
0x8CC3, 0x8CC4, 0x5C46,
0x8CC5, 0x8CC6, 0x5C4C,
0x8CC7, 0x8CC9, 0x5C52,
0x8CCA, 0x8CCC, 0x5C56,
0x8CCD, 0x8CD0, 0x5C5A,
0x8CD4, 0x8CDA, 0x5C67,
0x8CDC, 0x8CE2, 0x5C72,
0x8CE3, 0x8CE6, 0x5C7B,
0x8CE8, 0x8CEC, 0x5C83,
0x8CED, 0x8CEF, 0x5C89,
0x8CF0, 0x8CF1, 0x5C8E,
0x8CF2, 0x8CF3, 0x5C92,
0x8CF5, 0x8CF9, 0x5C9D,
0x8CFA, 0x8CFE, 0x5CA4,
0x8D41, 0x8D43, 0x5CAE,
0x8D47, 0x8D4A, 0x5CB9,
0x8D4D, 0x8D4E, 0x5CC2,
0x8D4F, 0x8D54, 0x5CC5,
0x8D55, 0x8D5A, 0x5CCC,
0x8D5B, 0x8D60, 0x5CD3,
0x8D61, 0x8D67, 0x5CDA,
0x8D68, 0x8D69, 0x5CE2,
0x8D6C, 0x8D6D, 0x5CEB,
0x8D6E, 0x8D6F, 0x5CEE,
0x8D70, 0x8D79, 0x5CF1,
0x8D7A, 0x8D7E, 0x5CFC,
0x8D81, 0x8D82, 0x5D04,
0x8D83, 0x8D88, 0x5D08,
0x8D89, 0x8D8D, 0x5D0F,
0x8D8F, 0x8D92, 0x5D17,
0x8D93, 0x8D94, 0x5D1C,
0x8D95, 0x8D99, 0x5D1F,
0x8D9C, 0x8D9E, 0x5D2A,
0x8D9F, 0x8DA3, 0x5D2F,
0x8DA4, 0x8DAB, 0x5D35,
0x8DAC, 0x8DB3, 0x5D3F,
0x8DB4, 0x8DB5, 0x5D48,
0x8DB6, 0x8DC0, 0x5D4D,
0x8DC1, 0x8DC2, 0x5D59,
0x8DC4, 0x8DCE, 0x5D5E,
0x8DD0, 0x8DD1, 0x5D6D,
0x8DD2, 0x8DD5, 0x5D70,
0x8DD6, 0x8DE2, 0x5D75,
0x8DE3, 0x8DF8, 0x5D83,
0x8DF9, 0x8DFB, 0x5D9A,
0x8DFC, 0x8DFE, 0x5D9E,
0x8E40, 0x8E55, 0x5DA1,
0x8E56, 0x8E62, 0x5DB8,
0x8E63, 0x8E69, 0x5DC6,
0x8E6A, 0x8E76, 0x5DCE,
0x8E78, 0x8E79, 0x5DDF,
0x8E7A, 0x8E7B, 0x5DE3,
0x8E7D, 0x8E7E, 0x5DEC,
0x8E81, 0x8E82, 0x5DF5,
0x8E83, 0x8E87, 0x5DF8,
0x8E88, 0x8E89, 0x5DFF,
0x8E8C, 0x8E8E, 0x5E09,
0x8E8F, 0x8E90, 0x5E0D,
0x8E91, 0x8E92, 0x5E12,
0x8E94, 0x8E9B, 0x5E1E,
0x8E9C, 0x8EA0, 0x5E28,
0x8EA1, 0x8EA2, 0x5E2F,
0x8EA3, 0x8EA7, 0x5E32,
0x8EA8, 0x8EA9, 0x5E39,
0x8EAA, 0x8EAD, 0x5E3E,
0x8EAF, 0x8EB4, 0x5E46,
0x8EB5, 0x8EBB, 0x5E4D,
0x8EBC, 0x8EC0, 0x5E56,
0x8EC1, 0x8EC2, 0x5E5C,
0x8EC3, 0x8EC4, 0x5E5F,
0x8EC5, 0x8ED3, 0x5E63,
0x8ED8, 0x8EDA, 0x5E81,
0x8EDC, 0x8EDD, 0x5E88,
0x8EDE, 0x8EE0, 0x5E8C,
0x8EE5, 0x8EE8, 0x5EA1,
0x8EE9, 0x8EED, 0x5EA8,
0x8EEE, 0x8EF2, 0x5EAE,
0x8EF4, 0x8EF7, 0x5EBA,
0x8EF8, 0x8EFE, 0x5EBF,
0x8F40, 0x8F42, 0x5EC6,
0x8F43, 0x8F48, 0x5ECB,
0x8F49, 0x8F4A, 0x5ED4,
0x8F4B, 0x8F4E, 0x5ED7,
0x8F4F, 0x8F5A, 0x5EDC,
0x8F5C, 0x8F64, 0x5EEB,
0x8F66, 0x8F67, 0x5EF8,
0x8F68, 0x8F6A, 0x5EFB,
0x8F6B, 0x8F6D, 0x5F05,
0x8F6F, 0x8F71, 0x5F0C,
0x8F76, 0x8F77, 0x5F19,
0x8F78, 0x8F7A, 0x5F1C,
0x8F7B, 0x8F7E, 0x5F21,
0x8F81, 0x8F82, 0x5F2B,
0x8F85, 0x8F8B, 0x5F32,
0x8F8D, 0x8F8F, 0x5F3D,
0x8F90, 0x8F9E, 0x5F41,
0x8FA1, 0x8FA4, 0x5F59,
0x8FA5, 0x8FA7, 0x5F5E,
0x8FAA, 0x8FAB, 0x5F67,
0x8FAD, 0x8FAE, 0x5F6E,
0x8FB0, 0x8FB2, 0x5F74,
0x8FB5, 0x8FB7, 0x5F7D,
0x8FBA, 0x8FBC, 0x5F8D,
0x8FBE, 0x8FBF, 0x5F93,
0x8FC1, 0x8FC2, 0x5F9A,
0x8FC3, 0x8FC6, 0x5F9D,
0x8FC7, 0x8FCC, 0x5FA2,
0x8FCE, 0x8FCF, 0x5FAB,
0x8FD0, 0x8FD5, 0x5FAF,
0x8FD7, 0x8FDA, 0x5FB8,
0x8FDB, 0x8FDF, 0x5FBE,
0x8FE0, 0x8FE1, 0x5FC7,
0x8FE2, 0x8FE3, 0x5FCA,
0x8FE5, 0x8FE7, 0x5FD3,
0x8FE8, 0x8FEA, 0x5FDA,
0x8FEB, 0x8FEC, 0x5FDE,
0x8FED, 0x8FEE, 0x5FE2,
0x8FEF, 0x8FF0, 0x5FE5,
0x8FF1, 0x8FF2, 0x5FE8,
0x8FF4, 0x8FF5, 0x5FEF,
0x8FF6, 0x8FF8, 0x5FF2,
0x8FF9, 0x8FFA, 0x5FF6,
0x8FFB, 0x8FFC, 0x5FF9,
0x9040, 0x9041, 0x6008,
0x9042, 0x9043, 0x600B,
0x9044, 0x9045, 0x6010,
0x9047, 0x9048, 0x6017,
0x904A, 0x904B, 0x601E,
0x904C, 0x904E, 0x6022,
0x904F, 0x9051, 0x602C,
0x9052, 0x9056, 0x6030,
0x9057, 0x905B, 0x6036,
0x905C, 0x905D, 0x603D,
0x905F, 0x9065, 0x6044,
0x9067, 0x9068, 0x604E,
0x906A, 0x906B, 0x6053,
0x906C, 0x906E, 0x6056,
0x906F, 0x9070, 0x605B,
0x9071, 0x9074, 0x605E,
0x9075, 0x9076, 0x6065,
0x9078, 0x9079, 0x6071,
0x907A, 0x907B, 0x6074,
0x9080, 0x9081, 0x6081,
0x9082, 0x9085, 0x6085,
0x9086, 0x9087, 0x608A,
0x9088, 0x908B, 0x608E,
0x908E, 0x9090, 0x6097,
0x9093, 0x9094, 0x60A1,
0x9095, 0x9096, 0x60A4,
0x9098, 0x9099, 0x60A9,
0x909D, 0x909F, 0x60B5,
0x90A0, 0x90A1, 0x60B9,
0x90A2, 0x90A9, 0x60BD,
0x90AA, 0x90AC, 0x60C7,
0x90AD, 0x90B1, 0x60CC,
0x90B2, 0x90B4, 0x60D2,
0x90B5, 0x90B6, 0x60D6,
0x90BA, 0x90BE, 0x60E1,
0x90C0, 0x90C1, 0x60F1,
0x90C3, 0x90C4, 0x60F7,
0x90C5, 0x90C9, 0x60FB,
0x90CA, 0x90CD, 0x6102,
0x90CF, 0x90D1, 0x610A,
0x90D2, 0x90D6, 0x6110,
0x90D7, 0x90DA, 0x6116,
0x90DB, 0x90DE, 0x611B,
0x90DF, 0x90E0, 0x6121,
0x90E2, 0x90E4, 0x6128,
0x90E5, 0x90F7, 0x612C,
0x90F8, 0x90FE, 0x6140,
0x9144, 0x9145, 0x614F,
0x9146, 0x9148, 0x6152,
0x9149, 0x914F, 0x6156,
0x9150, 0x9153, 0x615E,
0x9154, 0x9157, 0x6163,
0x9158, 0x915E, 0x6169,
0x915F, 0x9162, 0x6171,
0x9164, 0x9176, 0x6178,
0x9177, 0x9178, 0x618C,
0x9179, 0x917D, 0x618F,
0x9180, 0x9186, 0x6196,
0x9187, 0x918F, 0x619E,
0x9190, 0x9191, 0x61AA,
0x9192, 0x919B, 0x61AD,
0x919C, 0x91A1, 0x61B8,
0x91A2, 0x91A4, 0x61BF,
0x91A5, 0x91A9, 0x61C3,
0x91AB, 0x91AF, 0x61CC,
0x91B1, 0x91C1, 0x61D5,
0x91C2, 0x91CF, 0x61E7,
0x91D0, 0x91D8, 0x61F6,
0x91D9, 0x91DE, 0x6200,
0x91E1, 0x91E2, 0x6213,
0x91E4, 0x91E6, 0x621C,
0x91E9, 0x91EC, 0x6226,
0x91EF, 0x91F2, 0x622F,
0x91F3, 0x91F4, 0x6235,
0x91F5, 0x91F9, 0x6238,
0x91FB, 0x91FD, 0x6244,
0x9240, 0x9241, 0x624F,
0x9242, 0x9244, 0x6255,
0x9245, 0x9246, 0x6259,
0x9247, 0x924D, 0x625C,
0x924E, 0x924F, 0x6264,
0x9251, 0x9252, 0x6271,
0x9253, 0x9254, 0x6274,
0x9255, 0x9256, 0x6277,
0x9257, 0x9258, 0x627A,
0x925A, 0x925C, 0x6281,
0x925D, 0x9260, 0x6285,
0x9261, 0x9266, 0x628B,
0x9269, 0x926B, 0x629C,
0x926D, 0x926E, 0x62A6,
0x926F, 0x9270, 0x62A9,
0x9271, 0x9274, 0x62AD,
0x9275, 0x9277, 0x62B2,
0x9278, 0x927A, 0x62B6,
0x927D, 0x927E, 0x62C0,
0x9285, 0x9286, 0x62DD,
0x9287, 0x9288, 0x62E0,
0x928A, 0x928B, 0x62EA,
0x928F, 0x9292, 0x62F8,
0x9294, 0x9297, 0x6303,
0x9298, 0x929B, 0x630A,
0x929C, 0x929D, 0x630F,
0x929E, 0x92A1, 0x6312,
0x92A2, 0x92A4, 0x6317,
0x92A6, 0x92A7, 0x6326,
0x92A9, 0x92AB, 0x632C,
0x92AC, 0x92AD, 0x6330,
0x92AE, 0x92B3, 0x6333,
0x92B4, 0x92B5, 0x633B,
0x92B6, 0x92B9, 0x633E,
0x92BB, 0x92BC, 0x6347,
0x92BE, 0x92C1, 0x6351,
0x92C2, 0x92C9, 0x6356,
0x92CB, 0x92CD, 0x6364,
0x92CF, 0x92D1, 0x636A,
0x92D2, 0x92D3, 0x636F,
0x92D4, 0x92D7, 0x6372,
0x92D8, 0x92D9, 0x6378,
0x92DA, 0x92DD, 0x637C,
0x92DF, 0x92E2, 0x6383,
0x92E6, 0x92E8, 0x6393,
0x92EA, 0x92F0, 0x6399,
0x92F6, 0x92F7, 0x63B1,
0x92F8, 0x92F9, 0x63B5,
0x92FD, 0x92FE, 0x63BF,
0x9340, 0x9342, 0x63C1,
0x9344, 0x9345, 0x63C7,
0x9346, 0x9348, 0x63CA,
0x934A, 0x934C, 0x63D3,
0x934D, 0x9353, 0x63D7,
0x9356, 0x935A, 0x63E4,
0x935B, 0x935C, 0x63EB,
0x935D, 0x9360, 0x63EE,
0x9364, 0x9367, 0x63F9,
0x9369, 0x936A, 0x6403,
0x936B, 0x936F, 0x6406,
0x9370, 0x9371, 0x640D,
0x9372, 0x9373, 0x6411,
0x9374, 0x9379, 0x6415,
0x937C, 0x937E, 0x6422,
0x9381, 0x9383, 0x6427,
0x9385, 0x938A, 0x642E,
0x938B, 0x938F, 0x6435,
0x9390, 0x9391, 0x643B,
0x9394, 0x9395, 0x6442,
0x9397, 0x939D, 0x644B,
0x939F, 0x93A1, 0x6455,
0x93A2, 0x93A6, 0x6459,
0x93A7, 0x93AE, 0x645F,
0x93B0, 0x93B2, 0x646A,
0x93B3, 0x93BC, 0x646E,
0x93BD, 0x93C3, 0x647B,
0x93C6, 0x93CE, 0x6488,
0x93CF, 0x93D0, 0x6493,
0x93D1, 0x93D2, 0x6497,
0x93D3, 0x93D6, 0x649A,
0x93D7, 0x93DB, 0x649F,
0x93DC, 0x93DF, 0x64A5,
0x93E0, 0x93E1, 0x64AA,
0x93E3, 0x93E6, 0x64B1,
0x93EA, 0x93EC, 0x64BD,
0x93EE, 0x93EF, 0x64C3,
0x93F0, 0x93F6, 0x64C6,
0x93F9, 0x93FC, 0x64D3,
0x93FD, 0x93FE, 0x64D9,
0x9440, 0x9442, 0x64DB,
0x9443, 0x9445, 0x64DF,
0x9448, 0x9460, 0x64E7,
0x9461, 0x9468, 0x6501,
0x9469, 0x9470, 0x650A,
0x9471, 0x9475, 0x6513,
0x9476, 0x947E, 0x6519,
0x9480, 0x9482, 0x6522,
0x9483, 0x9487, 0x6526,
0x9488, 0x9489, 0x652C,
0x948A, 0x948D, 0x6530,
0x9490, 0x9491, 0x653C,
0x9492, 0x9496, 0x6540,
0x9497, 0x9498, 0x6546,
0x9499, 0x949A, 0x654A,
0x949B, 0x949C, 0x654D,
0x949E, 0x94A0, 0x6552,
0x94A1, 0x94A2, 0x6557,
0x94A5, 0x94A7, 0x655F,
0x94A8, 0x94A9, 0x6564,
0x94AA, 0x94AD, 0x6567,
0x94AE, 0x94B0, 0x656D,
0x94B3, 0x94B4, 0x6575,
0x94B5, 0x94C3, 0x6578,
0x94C4, 0x94C6, 0x6588,
0x94C7, 0x94C9, 0x658D,
0x94CB, 0x94CD, 0x6594,
0x94D0, 0x94D1, 0x659D,
0x94D3, 0x94D4, 0x65A2,
0x94DA, 0x94E1, 0x65B1,
0x94E2, 0x94E3, 0x65BA,
0x94E4, 0x94E6, 0x65BE,
0x94E8, 0x94EB, 0x65C7,
0x94ED, 0x94EE, 0x65D0,
0x94EF, 0x94F1, 0x65D3,
0x94F2, 0x94F9, 0x65D8,
0x94FB, 0x94FC, 0x65E3,
0x94FD, 0x94FE, 0x65EA,
0x9540, 0x9543, 0x65F2,
0x9544, 0x9545, 0x65F8,
0x9546, 0x954A, 0x65FB,
0x954C, 0x954D, 0x6604,
0x954E, 0x9550, 0x6607,
0x9553, 0x9555, 0x6610,
0x9556, 0x9558, 0x6616,
0x9559, 0x955B, 0x661A,
0x955D, 0x9560, 0x6621,
0x9562, 0x9565, 0x6629,
0x9568, 0x9569, 0x6632,
0x956A, 0x956E, 0x6637,
0x9570, 0x9571, 0x663F,
0x9573, 0x9579, 0x6644,
0x957A, 0x957B, 0x664D,
0x957C, 0x957D, 0x6650,
0x9581, 0x9584, 0x665B,
0x9586, 0x9587, 0x6662,
0x958A, 0x958E, 0x6669,
0x958F, 0x9591, 0x6671,
0x9593, 0x9594, 0x6678,
0x9595, 0x9597, 0x667B,
0x9598, 0x959A, 0x667F,
0x959C, 0x959D, 0x6685,
0x959E, 0x95A1, 0x6688,
0x95A2, 0x95A5, 0x668D,
0x95A6, 0x95A9, 0x6692,
0x95AA, 0x95AE, 0x6698,
0x95AF, 0x95B7, 0x669E,
0x95B8, 0x95BC, 0x66A9,
0x95BD, 0x95C1, 0x66AF,
0x95C2, 0x95C5, 0x66B5,
0x95C6, 0x95C9, 0x66BA,
0x95CA, 0x95E3, 0x66BF,
0x95E5, 0x95EC, 0x66DE,
0x95ED, 0x95EE, 0x66E7,
0x95EF, 0x95F4, 0x66EA,
0x95F6, 0x95F7, 0x66F5,
0x95F9, 0x95FA, 0x66FA,
0x95FC, 0x95FE, 0x6701,
0x9640, 0x9643, 0x6704,
0x9645, 0x9646, 0x670E,
0x9647, 0x9649, 0x6711,
0x964B, 0x964D, 0x6718,
0x9650, 0x9655, 0x6720,
0x965A, 0x965B, 0x6732,
0x965C, 0x965F, 0x6736,
0x9660, 0x9661, 0x673B,
0x9662, 0x9663, 0x673E,
0x9665, 0x9666, 0x6744,
0x9668, 0x9669, 0x674A,
0x966C, 0x966D, 0x6754,
0x966E, 0x9672, 0x6757,
0x9674, 0x9676, 0x6762,
0x9677, 0x9678, 0x6766,
0x9679, 0x967A, 0x676B,
0x9680, 0x9683, 0x6778,
0x9686, 0x9687, 0x6782,
0x9688, 0x9689, 0x6785,
0x968C, 0x968F, 0x678C,
0x9690, 0x9693, 0x6791,
0x9697, 0x9699, 0x679F,
0x969F, 0x96A0, 0x67B1,
0x96A2, 0x96A9, 0x67B9,
0x96AB, 0x96B4, 0x67C5,
0x96B5, 0x96B7, 0x67D5,
0x96BB, 0x96BC, 0x67E3,
0x96BD, 0x96BF, 0x67E6,
0x96C0, 0x96C1, 0x67EA,
0x96C2, 0x96C3, 0x67ED,
0x96C5, 0x96CC, 0x67F5,
0x96CE, 0x96D1, 0x6801,
0x96D6, 0x96D7, 0x6814,
0x96D8, 0x96DC, 0x6818,
0x96DD, 0x96DF, 0x681E,
0x96E0, 0x96E6, 0x6822,
0x96E7, 0x96ED, 0x682B,
0x96EE, 0x96F0, 0x6834,
0x96F1, 0x96F2, 0x683A,
0x96F9, 0x96FE, 0x6856,
0x9740, 0x9743, 0x685C,
0x9745, 0x974C, 0x686C,
0x974E, 0x9756, 0x6878,
0x9759, 0x9760, 0x6887,
0x9761, 0x9763, 0x6890,
0x9764, 0x9766, 0x6894,
0x9767, 0x9770, 0x6898,
0x9771, 0x9773, 0x68A3,
0x9774, 0x9777, 0x68A9,
0x9779, 0x977A, 0x68B1,
0x977C, 0x977E, 0x68B6,
0x9780, 0x9786, 0x68B9,
0x9788, 0x978D, 0x68C3,
0x9790, 0x9793, 0x68CE,
0x9794, 0x9795, 0x68D3,
0x9796, 0x9797, 0x68D6,
0x9799, 0x979D, 0x68DB,
0x979E, 0x979F, 0x68E1,
0x97A0, 0x97A9, 0x68E4,
0x97AB, 0x97AD, 0x68F2,
0x97AE, 0x97B0, 0x68F6,
0x97B2, 0x97B5, 0x68FD,
0x97B6, 0x97B8, 0x6902,
0x97B9, 0x97BD, 0x6906,
0x97C1, 0x97CC, 0x6913,
0x97CD, 0x97CF, 0x6921,
0x97D0, 0x97D7, 0x6925,
0x97D8, 0x97D9, 0x692E,
0x97DA, 0x97DC, 0x6931,
0x97DD, 0x97E0, 0x6935,
0x97E1, 0x97E3, 0x693A,
0x97E5, 0x97E6, 0x6940,
0x97E7, 0x97F7, 0x6943,
0x97F8, 0x97F9, 0x6955,
0x97FA, 0x97FB, 0x6958,
0x97FC, 0x97FD, 0x695B,
0x9840, 0x9841, 0x6961,
0x9842, 0x9843, 0x6964,
0x9844, 0x9847, 0x6967,
0x9848, 0x9849, 0x696C,
0x984A, 0x984B, 0x696F,
0x984C, 0x9850, 0x6972,
0x9851, 0x9852, 0x697A,
0x9853, 0x9855, 0x697D,
0x9859, 0x985B, 0x698A,
0x985C, 0x9861, 0x698E,
0x9862, 0x9863, 0x6996,
0x9864, 0x9865, 0x6999,
0x9866, 0x986F, 0x699D,
0x9870, 0x9871, 0x69A9,
0x9873, 0x9875, 0x69AE,
0x9876, 0x9877, 0x69B2,
0x9878, 0x9879, 0x69B5,
0x987A, 0x987C, 0x69B8,
0x987D, 0x987E, 0x69BC,
0x9880, 0x9882, 0x69BE,
0x9883, 0x988A, 0x69C2,
0x988E, 0x9890, 0x69D1,
0x9891, 0x9896, 0x69D5,
0x9897, 0x9899, 0x69DC,
0x989A, 0x98A5, 0x69E1,
0x98A6, 0x98A9, 0x69EE,
0x98AA, 0x98B3, 0x69F3,
0x98B5, 0x98BE, 0x6A00,
0x98BF, 0x98CA, 0x6A0B,
0x98CB, 0x98D0, 0x6A19,
0x98D2, 0x98D7, 0x6A22,
0x98D9, 0x98DC, 0x6A2B,
0x98DE, 0x98E0, 0x6A32,
0x98E1, 0x98E7, 0x6A36,
0x98E8, 0x98EC, 0x6A3F,
0x98ED, 0x98EE, 0x6A45,
0x98EF, 0x98F6, 0x6A48,
0x98F7, 0x98FD, 0x6A51,
0x9940, 0x9944, 0x6A5C,
0x9945, 0x9947, 0x6A62,
0x9948, 0x9952, 0x6A66,
0x9953, 0x9959, 0x6A72,
0x995A, 0x995B, 0x6A7A,
0x995C, 0x995E, 0x6A7D,
0x995F, 0x9961, 0x6A81,
0x9962, 0x996A, 0x6A85,
0x996C, 0x9970, 0x6A92,
0x9971, 0x9978, 0x6A98,
0x9979, 0x997E, 0x6AA1,
0x9980, 0x9981, 0x6AA7,
0x9983, 0x99F5, 0x6AAD,
0x99F6, 0x99F7, 0x6B25,
0x99F8, 0x99FE, 0x6B28,
0x9A40, 0x9A42, 0x6B2F,
0x9A43, 0x9A46, 0x6B33,
0x9A48, 0x9A4A, 0x6B3B,
0x9A4B, 0x9A4E, 0x6B3F,
0x9A4F, 0x9A50, 0x6B44,
0x9A52, 0x9A53, 0x6B4A,
0x9A54, 0x9A5F, 0x6B4D,
0x9A60, 0x9A67, 0x6B5A,
0x9A68, 0x9A69, 0x6B68,
0x9A6A, 0x9A77, 0x6B6B,
0x9A79, 0x9A7C, 0x6B7D,
0x9A81, 0x9A84, 0x6B8E,
0x9A85, 0x9A86, 0x6B94,
0x9A87, 0x9A89, 0x6B97,
0x9A8A, 0x9A8E, 0x6B9C,
0x9A8F, 0x9A96, 0x6BA2,
0x9A97, 0x9A9E, 0x6BAB,
0x9AA0, 0x9AA6, 0x6BB8,
0x9AA8, 0x9AA9, 0x6BC3,
0x9AAA, 0x9AAE, 0x6BC6,
0x9AB1, 0x9AB2, 0x6BD0,
0x9AB5, 0x9AB9, 0x6BDC,
0x9ABA, 0x9AC1, 0x6BE2,
0x9AC2, 0x9AC4, 0x6BEC,
0x9AC5, 0x9AC7, 0x6BF0,
0x9AC9, 0x9ACB, 0x6BF6,
0x9ACC, 0x9ACE, 0x6BFA,
0x9ACF, 0x9AD5, 0x6BFE,
0x9AD6, 0x9ADA, 0x6C08,
0x9ADE, 0x9AE0, 0x6C1C,
0x9AE4, 0x9AE6, 0x6C2B,
0x9AE9, 0x9AEA, 0x6C36,
0x9AEB, 0x9AEE, 0x6C39,
0x9AEF, 0x9AF0, 0x6C3E,
0x9AF1, 0x9AF3, 0x6C43,
0x9AF5, 0x9AF9, 0x6C4B,
0x9AFA, 0x9AFC, 0x6C51,
0x9B40, 0x9B41, 0x6C59,
0x9B42, 0x9B43, 0x6C62,
0x9B44, 0x9B46, 0x6C65,
0x9B47, 0x9B4B, 0x6C6B,
0x9B4F, 0x9B50, 0x6C77,
0x9B51, 0x9B53, 0x6C7A,
0x9B54, 0x9B55, 0x6C7F,
0x9B58, 0x9B59, 0x6C8A,
0x9B5A, 0x9B5B, 0x6C8D,
0x9B5C, 0x9B5D, 0x6C91,
0x9B5E, 0x9B61, 0x6C95,
0x9B63, 0x9B65, 0x6C9C,
0x9B6A, 0x9B6B, 0x6CAF,
0x9B6C, 0x9B6F, 0x6CB4,
0x9B71, 0x9B74, 0x6CC0,
0x9B75, 0x9B77, 0x6CC6,
0x9B79, 0x9B7B, 0x6CCD,
0x9B7C, 0x9B7D, 0x6CD1,
0x9B80, 0x9B81, 0x6CD9,
0x9B82, 0x9B83, 0x6CDC,
0x9B86, 0x9B87, 0x6CE6,
0x9B89, 0x9B8A, 0x6CEC,
0x9B8E, 0x9B8F, 0x6CFF,
0x9B90, 0x9B91, 0x6D02,
0x9B92, 0x9B93, 0x6D05,
0x9B94, 0x9B96, 0x6D08,
0x9B98, 0x9B9A, 0x6D0F,
0x9B9B, 0x9B9E, 0x6D13,
0x9BA0, 0x9BA1, 0x6D1C,
0x9BA2, 0x9BA7, 0x6D1F,
0x9BA9, 0x9BAA, 0x6D28,
0x9BAB, 0x9BAC, 0x6D2C,
0x9BAD, 0x9BAE, 0x6D2F,
0x9BB0, 0x9BB2, 0x6D36,
0x9BB4, 0x9BB5, 0x6D3F,
0x9BBB, 0x9BBE, 0x6D55,
0x9BC2, 0x9BC3, 0x6D61,
0x9BC4, 0x9BC5, 0x6D64,
0x9BC6, 0x9BC7, 0x6D67,
0x9BC8, 0x9BCA, 0x6D6B,
0x9BCB, 0x9BCE, 0x6D70,
0x9BCF, 0x9BD0, 0x6D75,
0x9BD1, 0x9BD3, 0x6D79,
0x9BD4, 0x9BD8, 0x6D7D,
0x9BD9, 0x9BDA, 0x6D83,
0x9BDB, 0x9BDC, 0x6D86,
0x9BDD, 0x9BDE, 0x6D8A,
0x9BE0, 0x9BE1, 0x6D8F,
0x9BE3, 0x9BE7, 0x6D96,
0x9BEB, 0x9BEC, 0x6DAC,
0x9BED, 0x9BEE, 0x6DB0,
0x9BEF, 0x9BF0, 0x6DB3,
0x9BF1, 0x9BF2, 0x6DB6,
0x9BF3, 0x9BF8, 0x6DB9,
0x9BF9, 0x9BFB, 0x6DC1,
0x9BFC, 0x9BFE, 0x6DC8,
0x9C40, 0x9C43, 0x6DCD,
0x9C44, 0x9C47, 0x6DD2,
0x9C49, 0x9C4B, 0x6DDA,
0x9C4D, 0x9C4E, 0x6DE2,
0x9C50, 0x9C53, 0x6DE7,
0x9C55, 0x9C56, 0x6DEF,
0x9C58, 0x9C5A, 0x6DF4,
0x9C5D, 0x9C64, 0x6DFD,
0x9C65, 0x9C68, 0x6E06,
0x9C6B, 0x9C6C, 0x6E12,
0x9C6E, 0x9C6F, 0x6E18,
0x9C70, 0x9C71, 0x6E1B,
0x9C72, 0x9C73, 0x6E1E,
0x9C75, 0x9C77, 0x6E26,
0x9C7B, 0x9C7C, 0x6E30,
0x9C80, 0x9C81, 0x6E36,
0x9C83, 0x9C8A, 0x6E3B,
0x9C8B, 0x9C92, 0x6E45,
0x9C93, 0x9C96, 0x6E4F,
0x9C99, 0x9C9A, 0x6E59,
0x9C9B, 0x9C9D, 0x6E5C,
0x9C9E, 0x9CA8, 0x6E60,
0x9CA9, 0x9CAA, 0x6E6C,
0x9CAB, 0x9CB9, 0x6E6F,
0x9CBA, 0x9CBC, 0x6E80,
0x9CBE, 0x9CBF, 0x6E87,
0x9CC0, 0x9CC4, 0x6E8A,
0x9CC5, 0x9CCB, 0x6E91,
0x9CCC, 0x9CCE, 0x6E99,
0x9CCF, 0x9CD0, 0x6E9D,
0x9CD1, 0x9CD2, 0x6EA0,
0x9CD3, 0x9CD4, 0x6EA3,
0x9CD6, 0x9CD7, 0x6EA8,
0x9CD8, 0x9CDB, 0x6EAB,
0x9CDF, 0x9CE0, 0x6EB8,
0x9CE2, 0x9CE4, 0x6EBE,
0x9CE5, 0x9CE8, 0x6EC3,
0x9CE9, 0x9CEB, 0x6EC8,
0x9CEC, 0x9CEE, 0x6ECC,
0x9CF2, 0x9CF3, 0x6ED8,
0x9CF4, 0x9CF6, 0x6EDB,
0x9CF9, 0x9CFE, 0x6EEA,
0x9D40, 0x9D43, 0x6EF0,
0x9D44, 0x9D47, 0x6EF5,
0x9D48, 0x9D4F, 0x6EFA,
0x9D50, 0x9D52, 0x6F03,
0x9D53, 0x9D54, 0x6F07,
0x9D55, 0x9D59, 0x6F0A,
0x9D5A, 0x9D5C, 0x6F10,
0x9D5D, 0x9D66, 0x6F16,
0x9D67, 0x9D69, 0x6F21,
0x9D6A, 0x9D6D, 0x6F25,
0x9D72, 0x9D73, 0x6F34,
0x9D74, 0x9D7A, 0x6F37,
0x9D7B, 0x9D7E, 0x6F3F,
0x9D80, 0x9D82, 0x6F43,
0x9D83, 0x9D85, 0x6F48,
0x9D87, 0x9D90, 0x6F4E,
0x9D91, 0x9D93, 0x6F59,
0x9D95, 0x9D97, 0x6F5F,
0x9D98, 0x9D9A, 0x6F63,
0x9D9B, 0x9DA0, 0x6F67,
0x9DA1, 0x9DA3, 0x6F6F,
0x9DA5, 0x9DA7, 0x6F75,
0x9DAA, 0x9DB0, 0x6F7D,
0x9DB1, 0x9DB3, 0x6F85,
0x9DB4, 0x9DB5, 0x6F8A,
0x9DB6, 0x9DC2, 0x6F8F,
0x9DC3, 0x9DC6, 0x6F9D,
0x9DC7, 0x9DCB, 0x6FA2,
0x9DCC, 0x9DD6, 0x6FA8,
0x9DD7, 0x9DD8, 0x6FB4,
0x9DD9, 0x9DDA, 0x6FB7,
0x9DDB, 0x9DE0, 0x6FBA,
0x9DE2, 0x9DE7, 0x6FC3,
0x9DE8, 0x9DEE, 0x6FCA,
0x9DEF, 0x9DF9, 0x6FD3,
0x9DFB, 0x9DFE, 0x6FE2,
0x9E40, 0x9E47, 0x6FE6,
0x9E48, 0x9E68, 0x6FF0,
0x9E69, 0x9E70, 0x7012,
0x9E71, 0x9E77, 0x701C,
0x9E78, 0x9E7E, 0x7024,
0x9E80, 0x9E89, 0x702B,
0x9E8A, 0x9E8C, 0x7036,
0x9E8D, 0x9E9E, 0x703A,
0x9E9F, 0x9EA0, 0x704D,
0x9EA1, 0x9EAE, 0x7050,
0x9EAF, 0x9EBA, 0x705F,
0x9EBC, 0x9EBF, 0x7071,
0x9EC1, 0x9EC3, 0x7079,
0x9EC5, 0x9EC8, 0x7081,
0x9EC9, 0x9ECB, 0x7086,
0x9ECC, 0x9ECE, 0x708B,
0x9ECF, 0x9ED1, 0x708F,
0x9ED3, 0x9ED4, 0x7097,
0x9ED5, 0x9ED6, 0x709A,
0x9ED7, 0x9EE3, 0x709E,
0x9EE6, 0x9EE8, 0x70B4,
0x9EEA, 0x9EEB, 0x70BE,
0x9EEC, 0x9EEF, 0x70C4,
0x9EF1, 0x9EFD, 0x70CB,
0x9F40, 0x9F42, 0x70DC,
0x9F43, 0x9F46, 0x70E0,
0x9F4A, 0x9F50, 0x70F0,
0x9F52, 0x9F54, 0x70FA,
0x9F55, 0x9F5F, 0x70FE,
0x9F60, 0x9F64, 0x710B,
0x9F65, 0x9F66, 0x7111,
0x9F69, 0x9F73, 0x711B,
0x9F74, 0x9F7B, 0x7127,
0x9F7C, 0x9F7E, 0x7132,
0x9F81, 0x9F8E, 0x7137,
0x9F8F, 0x9F92, 0x7146,
0x9F95, 0x9FA1, 0x714F,
0x9FA3, 0x9FA7, 0x715F,
0x9FA9, 0x9FAD, 0x7169,
0x9FAE, 0x9FB0, 0x716F,
0x9FB1, 0x9FB4, 0x7174,
0x9FB6, 0x9FB7, 0x717B,
0x9FB8, 0x9FBD, 0x717E,
0x9FBE, 0x9FC2, 0x7185,
0x9FC3, 0x9FC6, 0x718B,
0x9FC7, 0x9FCA, 0x7190,
0x9FCB, 0x9FCD, 0x7195,
0x9FCE, 0x9FD2, 0x719A,
0x9FD3, 0x9FD9, 0x71A1,
0x9FDA, 0x9FDC, 0x71A9,
0x9FDD, 0x9FE2, 0x71AD,
0x9FE4, 0x9FE6, 0x71B6,
0x9FE7, 0x9FEF, 0x71BA,
0x9FF0, 0x9FF9, 0x71C4,
0x9FFA, 0x9FFE, 0x71CF,
0xA040, 0xA049, 0x71D6,
0xA04A, 0xA04D, 0x71E1,
0xA04F, 0xA054, 0x71E8,
0xA055, 0xA05E, 0x71EF,
0xA05F, 0xA06A, 0x71FA,
0xA06B, 0xA07E, 0x7207,
0xA080, 0xA081, 0x721B,
0xA082, 0xA08B, 0x721E,
0xA08E, 0xA090, 0x722D,
0xA091, 0xA093, 0x7232,
0xA097, 0xA09D, 0x7240,
0xA09E, 0xA0A0, 0x7249,
0xA0A1, 0xA0A4, 0x724E,
0xA0A5, 0xA0A7, 0x7253,
0xA0A8, 0xA0A9, 0x7257,
0xA0AE, 0xA0B0, 0x7263,
0xA0B2, 0xA0B5, 0x726A,
0xA0B6, 0xA0B7, 0x7270,
0xA0B8, 0xA0B9, 0x7273,
0xA0BA, 0xA0BC, 0x7276,
0xA0BD, 0xA0BF, 0x727B,
0xA0C0, 0xA0C1, 0x7282,
0xA0C2, 0xA0C6, 0x7285,
0xA0C9, 0xA0CA, 0x7290,
0xA0CB, 0xA0D6, 0x7293,
0xA0D7, 0xA0E2, 0x72A0,
0xA0E4, 0xA0E6, 0x72B1,
0xA0E8, 0xA0EE, 0x72BA,
0xA0EF, 0xA0F1, 0x72C5,
0xA0F2, 0xA0F5, 0x72C9,
0xA0F8, 0xA0FB, 0x72D3,
0xA0FD, 0xA0FE, 0x72DA,
0xA1A1, 0xA1A3, 0x3000,
0xA1AE, 0xA1AF, 0x2018,
0xA1B0, 0xA1B1, 0x201C,
0xA1B2, 0xA1B3, 0x3014,
0xA1B4, 0xA1BB, 0x3008,
0xA1BC, 0xA1BD, 0x3016,
0xA1BE, 0xA1BF, 0x3010,
0xA1C4, 0xA1C5, 0x2227,
0xA1DA, 0xA1DB, 0x226E,
0xA1DC, 0xA1DD, 0x2264,
0xA1E4, 0xA1E5, 0x2032,
0xA1E9, 0xA1EA, 0xFFE0,
0xA1FB, 0xA1FC, 0x2190,
0xA2A1, 0xA2AA, 0x2170,
0xA2B1, 0xA2C4, 0x2488,
0xA2C5, 0xA2D8, 0x2474,
0xA2D9, 0xA2E2, 0x2460,
0xA2E5, 0xA2EE, 0x3220,
0xA2F1, 0xA2FC, 0x2160,
0xA3A1, 0xA3A3, 0xFF01,
0xA3A5, 0xA3FD, 0xFF05,
0xA4A1, 0xA4F3, 0x3041,
0xA5A1, 0xA5F6, 0x30A1,
0xA6A1, 0xA6B1, 0x0391,
0xA6B2, 0xA6B8, 0x03A3,
0xA6C1, 0xA6D1, 0x03B1,
0xA6D2, 0xA6D8, 0x03C3,
0xA6E0, 0xA6E1, 0xFE35,
0xA6E2, 0xA6E3, 0xFE39,
0xA6E4, 0xA6E5, 0xFE3F,
0xA6E6, 0xA6E7, 0xFE3D,
0xA6E8, 0xA6EB, 0xFE41,
0xA6EE, 0xA6EF, 0xFE3B,
0xA6F0, 0xA6F1, 0xFE37,
0xA6F4, 0xA6F5, 0xFE33,
0xA7A1, 0xA7A6, 0x0410,
0xA7A8, 0xA7C1, 0x0416,
0xA7D1, 0xA7D6, 0x0430,
0xA7D8, 0xA7F1, 0x0436,
0xA840, 0xA841, 0x02CA,
0xA849, 0xA84C, 0x2196,
0xA851, 0xA852, 0x2266,
0xA854, 0xA877, 0x2550,
0xA878, 0xA87E, 0x2581,
0xA880, 0xA887, 0x2588,
0xA888, 0xA88A, 0x2593,
0xA88B, 0xA88C, 0x25BC,
0xA88D, 0xA890, 0x25E2,
0xA894, 0xA895, 0x301D,
0xA8C5, 0xA8E9, 0x3105,
0xA940, 0xA948, 0x3021,
0xA94A, 0xA94B, 0x338E,
0xA94C, 0xA94E, 0x339C,
0xA952, 0xA953, 0x33D1,
0xA961, 0xA962, 0x309B,
0xA963, 0xA964, 0x30FD,
0xA966, 0xA967, 0x309D,
0xA968, 0xA971, 0xFE49,
0xA972, 0xA975, 0xFE54,
0xA976, 0xA97E, 0xFE59,
0xA980, 0xA984, 0xFE62,
0xA985, 0xA988, 0xFE68,
0xA9A4, 0xA9EF, 0x2500,
0xAA40, 0xAA41, 0x72DC,
0xAA43, 0xAA48, 0x72E2,
0xAA49, 0xAA4A, 0x72EA,
0xAA4B, 0xAA4C, 0x72F5,
0xAA4E, 0xAA51, 0x72FD,
0xAA53, 0xAA58, 0x7304,
0xAA59, 0xAA5B, 0x730B,
0xAA5C, 0xAA5F, 0x730F,
0xAA61, 0xAA63, 0x7318,
0xAA64, 0xAA65, 0x731F,
0xAA66, 0xAA67, 0x7323,
0xAA68, 0xAA6A, 0x7326,
0xAA6C, 0xAA6D, 0x732F,
0xAA6E, 0xAA6F, 0x7332,
0xAA70, 0xAA71, 0x7335,
0xAA72, 0xAA75, 0x733A,
0xAA76, 0xAA7E, 0x7340,
0xAA80, 0xAA83, 0x7349,
0xAA84, 0xAA85, 0x734E,
0xAA87, 0xAA8A, 0x7353,
0xAA8B, 0xAA92, 0x7358,
0xAA93, 0xAA9D, 0x7361,
0xAA9F, 0xAAA0, 0x7370,
0xAB40, 0xAB4B, 0x7372,
0xAB4C, 0xAB50, 0x737F,
0xAB51, 0xAB52, 0x7385,
0xAB55, 0xAB56, 0x738C,
0xAB57, 0xAB58, 0x738F,
0xAB59, 0xAB5C, 0x7392,
0xAB5D, 0xAB60, 0x7397,
0xAB61, 0xAB63, 0x739C,
0xAB64, 0xAB65, 0x73A0,
0xAB66, 0xAB6B, 0x73A3,
0xAB6D, 0xAB6E, 0x73AC,
0xAB70, 0xAB72, 0x73B4,
0xAB73, 0xAB74, 0x73B8,
0xAB75, 0xAB78, 0x73BC,
0xAB7A, 0xAB7E, 0x73C3,
0xAB80, 0xAB81, 0x73CB,
0xAB83, 0xAB89, 0x73D2,
0xAB8A, 0xAB8D, 0x73DA,
0xAB8F, 0xAB92, 0x73E1,
0xAB95, 0xAB97, 0x73EA,
0xAB98, 0xAB9B, 0x73EE,
0xAB9C, 0xABA0, 0x73F3,
0xAC40, 0xAC4A, 0x73F8,
0xAC4C, 0xAC4D, 0x7407,
0xAC4E, 0xAC51, 0x740B,
0xAC52, 0xAC5A, 0x7411,
0xAC5B, 0xAC60, 0x741C,
0xAC61, 0xAC62, 0x7423,
0xAC68, 0xAC69, 0x7431,
0xAC6A, 0xAC6E, 0x7437,
0xAC6F, 0xAC72, 0x743D,
0xAC73, 0xAC7E, 0x7442,
0xAC80, 0xAC86, 0x744E,
0xAC8A, 0xAC96, 0x7460,
0xAC97, 0xAC98, 0x746E,
0xAC99, 0xAC9D, 0x7471,
0xAC9E, 0xACA0, 0x7478,
0xAD40, 0xAD42, 0x747B,
0xAD45, 0xAD47, 0x7484,
0xAD48, 0xAD4A, 0x7488,
0xAD4B, 0xAD4C, 0x748C,
0xAD4E, 0xAD58, 0x7491,
0xAD5A, 0xAD61, 0x749F,
0xAD62, 0xAD71, 0x74AA,
0xAD72, 0xAD7E, 0x74BB,
0xAD80, 0xAD89, 0x74C8,
0xAD8A, 0xAD92, 0x74D3,
0xAD97, 0xAD9D, 0x74E7,
0xAD9E, 0xADA0, 0x74F0,
0xAE42, 0xAE48, 0x74F8,
0xAE49, 0xAE4C, 0x7500,
0xAE4D, 0xAE54, 0x7505,
0xAE58, 0xAE5B, 0x7514,
0xAE5D, 0xAE5E, 0x751D,
0xAE5F, 0xAE63, 0x7520,
0xAE64, 0xAE65, 0x7526,
0xAE6B, 0xAE6C, 0x753C,
0xAE6E, 0xAE71, 0x7541,
0xAE72, 0xAE73, 0x7546,
0xAE74, 0xAE75, 0x7549,
0xAE77, 0xAE7A, 0x7550,
0xAE7B, 0xAE7E, 0x7555,
0xAE80, 0xAE87, 0x755D,
0xAE88, 0xAE8A, 0x7567,
0xAE8B, 0xAE91, 0x756B,
0xAE93, 0xAE95, 0x7575,
0xAE96, 0xAE9A, 0x757A,
0xAE9B, 0xAE9D, 0x7580,
0xAE9E, 0xAE9F, 0x7584,
0xAF40, 0xAF42, 0x7588,
0xAF43, 0xAF45, 0x758C,
0xAF4A, 0xAF4B, 0x759B,
0xAF4E, 0xAF52, 0x75A6,
0xAF54, 0xAF55, 0x75B6,
0xAF56, 0xAF57, 0x75BA,
0xAF58, 0xAF5A, 0x75BF,
0xAF5C, 0xAF5D, 0x75CB,
0xAF5E, 0xAF61, 0x75CE,
0xAF64, 0xAF65, 0x75D9,
0xAF66, 0xAF67, 0x75DC,
0xAF68, 0xAF6A, 0x75DF,
0xAF6D, 0xAF70, 0x75EC,
0xAF71, 0xAF72, 0x75F2,
0xAF73, 0xAF76, 0x75F5,
0xAF77, 0xAF78, 0x75FA,
0xAF79, 0xAF7A, 0x75FD,
0xAF7D, 0xAF7E, 0x7606,
0xAF80, 0xAF81, 0x7608,
0xAF83, 0xAF85, 0x760D,
0xAF86, 0xAF89, 0x7611,
0xAF8C, 0xAF8E, 0x761C,
0xAF91, 0xAF92, 0x7627,
0xAF94, 0xAF95, 0x762E,
0xAF96, 0xAF97, 0x7631,
0xAF98, 0xAF99, 0x7636,
0xAF9A, 0xAF9C, 0x7639,
0xAF9E, 0xAF9F, 0x7641,
0xB040, 0xB046, 0x7645,
0xB047, 0xB04C, 0x764E,
0xB04E, 0xB052, 0x7657,
0xB054, 0xB057, 0x765F,
0xB058, 0xB05E, 0x7664,
0xB05F, 0xB061, 0x766C,
0xB062, 0xB069, 0x7670,
0xB06A, 0xB06B, 0x7679,
0xB06D, 0xB06F, 0x767F,
0xB072, 0xB073, 0x7689,
0xB074, 0xB075, 0x768C,
0xB076, 0xB077, 0x768F,
0xB079, 0xB07A, 0x7694,
0xB07B, 0xB07C, 0x7697,
0xB07D, 0xB07E, 0x769A,
0xB080, 0xB087, 0x769C,
0xB088, 0xB090, 0x76A5,
0xB091, 0xB092, 0x76AF,
0xB094, 0xB09D, 0x76B5,
0xB09E, 0xB09F, 0x76C0,
0xB143, 0xB144, 0x76CB,
0xB147, 0xB148, 0x76D9,
0xB149, 0xB14B, 0x76DC,
0xB14C, 0xB150, 0x76E0,
0xB151, 0xB158, 0x76E6,
0xB15B, 0xB15D, 0x76F5,
0xB15E, 0xB15F, 0x76FA,
0xB161, 0xB162, 0x76FF,
0xB163, 0xB164, 0x7702,
0xB165, 0xB166, 0x7705,
0xB169, 0xB173, 0x770E,
0xB174, 0xB177, 0x771B,
0xB179, 0xB17B, 0x7723,
0xB17D, 0xB17E, 0x772A,
0xB182, 0xB186, 0x7730,
0xB189, 0xB18B, 0x773D,
0xB18D, 0xB18F, 0x7744,
0xB190, 0xB197, 0x7748,
0xB198, 0xB19F, 0x7752,
0xB1E6, 0xB1E7, 0x8FA8,
0xB240, 0xB243, 0x775D,
0xB246, 0xB247, 0x7769,
0xB248, 0xB253, 0x776D,
0xB254, 0xB256, 0x777A,
0xB257, 0xB259, 0x7781,
0xB25A, 0xB25F, 0x7786,
0xB260, 0xB261, 0x778F,
0xB262, 0xB26D, 0x7793,
0xB26F, 0xB270, 0x77A3,
0xB274, 0xB276, 0x77AD,
0xB277, 0xB278, 0x77B1,
0xB27A, 0xB27E, 0x77B6,
0xB282, 0xB28E, 0x77C0,
0xB28F, 0xB297, 0x77CE,
0xB298, 0xB29A, 0x77D8,
0xB29B, 0xB29F, 0x77DD,
0xB343, 0xB346, 0x77EF,
0xB347, 0xB348, 0x77F4,
0xB34A, 0xB34D, 0x77F9,
0xB34E, 0xB353, 0x7803,
0xB354, 0xB355, 0x780A,
0xB356, 0xB358, 0x780E,
0xB35E, 0xB360, 0x7820,
0xB363, 0xB364, 0x782A,
0xB365, 0xB366, 0x782E,
0xB367, 0xB369, 0x7831,
0xB36A, 0xB36B, 0x7835,
0xB36E, 0xB371, 0x7841,
0xB373, 0xB376, 0x7848,
0xB37A, 0xB37B, 0x7853,
0xB37C, 0xB37E, 0x7858,
0xB380, 0xB381, 0x785B,
0xB382, 0xB38D, 0x785E,
0xB38E, 0xB395, 0x786F,
0xB396, 0xB399, 0x7878,
0xB39A, 0xB3A0, 0x787D,
0xB440, 0xB442, 0x7884,
0xB444, 0xB445, 0x788A,
0xB446, 0xB447, 0x788F,
0xB449, 0xB44B, 0x7894,
0xB44D, 0xB44E, 0x789D,
0xB453, 0xB45A, 0x78A8,
0xB45B, 0xB45E, 0x78B5,
0xB45F, 0xB462, 0x78BA,
0xB463, 0xB464, 0x78BF,
0xB465, 0xB467, 0x78C2,
0xB468, 0xB46A, 0x78C6,
0xB46B, 0xB46E, 0x78CC,
0xB46F, 0xB471, 0x78D1,
0xB472, 0xB474, 0x78D6,
0xB475, 0xB47E, 0x78DA,
0xB480, 0xB483, 0x78E4,
0xB484, 0xB486, 0x78E9,
0xB487, 0xB48B, 0x78ED,
0xB48D, 0xB48E, 0x78F5,
0xB48F, 0xB490, 0x78F8,
0xB491, 0xB496, 0x78FB,
0xB497, 0xB499, 0x7902,
0xB49A, 0xB4A0, 0x7906,
0xB540, 0xB545, 0x790D,
0xB546, 0xB54F, 0x7914,
0xB550, 0xB554, 0x791F,
0xB555, 0xB563, 0x7925,
0xB564, 0xB568, 0x7935,
0xB56B, 0xB56E, 0x7942,
0xB570, 0xB578, 0x794A,
0xB579, 0xB57A, 0x7954,
0xB57B, 0xB57C, 0x7958,
0xB582, 0xB585, 0x7969,
0xB587, 0xB58D, 0x7970,
0xB58F, 0xB593, 0x797B,
0xB594, 0xB595, 0x7982,
0xB596, 0xB599, 0x7986,
0xB59A, 0xB59D, 0x798B,
0xB59E, 0xB5A0, 0x7990,
0xB640, 0xB646, 0x7993,
0xB647, 0xB652, 0x799B,
0xB653, 0xB65D, 0x79A8,
0xB65E, 0xB662, 0x79B4,
0xB666, 0xB667, 0x79C4,
0xB668, 0xB669, 0x79C7,
0xB66C, 0xB66E, 0x79CE,
0xB66F, 0xB670, 0x79D3,
0xB671, 0xB672, 0x79D6,
0xB673, 0xB678, 0x79D9,
0xB679, 0xB67B, 0x79E0,
0xB682, 0xB688, 0x79F1,
0xB689, 0xB68A, 0x79F9,
0xB68C, 0xB68D, 0x79FE,
0xB68F, 0xB690, 0x7A04,
0xB691, 0xB694, 0x7A07,
0xB696, 0xB69A, 0x7A0F,
0xB69B, 0xB69C, 0x7A15,
0xB69D, 0xB69E, 0x7A18,
0xB69F, 0xB6A0, 0x7A1B,
0xB742, 0xB743, 0x7A21,
0xB744, 0xB752, 0x7A24,
0xB753, 0xB755, 0x7A34,
0xB759, 0xB75E, 0x7A40,
0xB75F, 0xB768, 0x7A47,
0xB769, 0xB76D, 0x7A52,
0xB76E, 0xB77E, 0x7A58,
0xB780, 0xB786, 0x7A69,
0xB787, 0xB789, 0x7A71,
0xB78B, 0xB78E, 0x7A7B,
0xB792, 0xB795, 0x7A89,
0xB796, 0xB798, 0x7A8E,
0xB799, 0xB79A, 0x7A93,
0xB79B, 0xB79D, 0x7A99,
0xB79F, 0xB7A0, 0x7AA1,
0xB840, 0xB841, 0x7AA3,
0xB843, 0xB845, 0x7AA9,
0xB846, 0xB84A, 0x7AAE,
0xB84B, 0xB855, 0x7AB4,
0xB856, 0xB860, 0x7AC0,
0xB861, 0xB86A, 0x7ACC,
0xB86B, 0xB86C, 0x7AD7,
0xB86D, 0xB870, 0x7ADA,
0xB871, 0xB872, 0x7AE1,
0xB874, 0xB879, 0x7AE7,
0xB87B, 0xB87E, 0x7AF0,
0xB880, 0xB884, 0x7AF4,
0xB885, 0xB886, 0x7AFB,
0xB888, 0xB88A, 0x7B00,
0xB88E, 0xB890, 0x7B0C,
0xB892, 0xB893, 0x7B12,
0xB894, 0xB896, 0x7B16,
0xB898, 0xB899, 0x7B1C,
0xB89B, 0xB89D, 0x7B21,
0xB940, 0xB941, 0x7B2F,
0xB943, 0xB946, 0x7B34,
0xB94A, 0xB94F, 0x7B3F,
0xB953, 0xB954, 0x7B4D,
0xB95A, 0xB95B, 0x7B5E,
0xB95D, 0xB967, 0x7B63,
0xB968, 0xB969, 0x7B6F,
0xB96A, 0xB96B, 0x7B73,
0xB96F, 0xB970, 0x7B7C,
0xB972, 0xB975, 0x7B81,
0xB976, 0xB97C, 0x7B86,
0xB97D, 0xB97E, 0x7B8E,
0xB980, 0xB982, 0x7B91,
0xB984, 0xB987, 0x7B98,
0xB988, 0xB98A, 0x7B9E,
0xB98B, 0xB98D, 0x7BA3,
0xB98E, 0xB990, 0x7BAE,
0xB991, 0xB992, 0x7BB2,
0xB993, 0xB995, 0x7BB5,
0xB996, 0xB99D, 0x7BB9,
0xB99E, 0xB9A0, 0x7BC2,
0xBA41, 0xBA44, 0x7BC8,
0xBA45, 0xBA48, 0x7BCD,
0xBA4A, 0xBA4E, 0x7BD4,
0xBA4F, 0xBA50, 0x7BDB,
0xBA51, 0xBA53, 0x7BDE,
0xBA54, 0xBA56, 0x7BE2,
0xBA57, 0xBA59, 0x7BE7,
0xBA5A, 0xBA5C, 0x7BEB,
0xBA5D, 0xBA5E, 0x7BEF,
0xBA5F, 0xBA63, 0x7BF2,
0xBA64, 0xBA67, 0x7BF8,
0xBA69, 0xBA70, 0x7BFF,
0xBA71, 0xBA73, 0x7C08,
0xBA74, 0xBA75, 0x7C0D,
0xBA76, 0xBA7B, 0x7C10,
0xBA7C, 0xBA7E, 0x7C17,
0xBA80, 0xBA84, 0x7C1A,
0xBA85, 0xBA8A, 0x7C20,
0xBA8B, 0xBA8C, 0x7C28,
0xBA8D, 0xBA99, 0x7C2B,
0xBA9A, 0xBA9F, 0x7C39,
0xBB40, 0xBB49, 0x7C43,
0xBB4A, 0xBB6E, 0x7C4E,
0xBB6F, 0xBB74, 0x7C75,
0xBB75, 0xBB7E, 0x7C7E,
0xBB81, 0xBB87, 0x7C8A,
0xBB88, 0xBB89, 0x7C93,
0xBB8B, 0xBB8D, 0x7C99,
0xBB8E, 0xBB8F, 0x7CA0,
0xBB91, 0xBB94, 0x7CA6,
0xBB95, 0xBB97, 0x7CAB,
0xBB98, 0xBB99, 0x7CAF,
0xBB9A, 0xBB9E, 0x7CB4,
0xBB9F, 0xBBA0, 0x7CBA,
0xBC40, 0xBC41, 0x7CBF,
0xBC42, 0xBC44, 0x7CC2,
0xBC48, 0xBC4E, 0x7CCE,
0xBC50, 0xBC51, 0x7CDA,
0xBC52, 0xBC53, 0x7CDD,
0xBC54, 0xBC5A, 0x7CE1,
0xBC5B, 0xBC60, 0x7CE9,
0xBC61, 0xBC68, 0x7CF0,
0xBC69, 0xBC6A, 0x7CF9,
0xBC6B, 0xBC78, 0x7CFC,
0xBC79, 0xBC7E, 0x7D0B,
0xBC80, 0xBC8E, 0x7D11,
0xBC90, 0xBC93, 0x7D23,
0xBC94, 0xBC96, 0x7D28,
0xBC97, 0xBC99, 0x7D2C,
0xBC9A, 0xBCA0, 0x7D30,
0xBD40, 0xBD76, 0x7D37,
0xBD77, 0xBD7E, 0x7D6F,
0xBD80, 0xBDA0, 0x7D78,
0xBE40, 0xBE4C, 0x7D99,
0xBE4D, 0xBE53, 0x7DA7,
0xBE54, 0xBE7E, 0x7DAF,
0xBE80, 0xBEA0, 0x7DDA,
0xBF40, 0xBF7E, 0x7DFB,
0xBF81, 0xBF85, 0x7E3C,
0xBF86, 0xBF8A, 0x7E42,
0xBF8B, 0xBFA0, 0x7E48,
0xC040, 0xC063, 0x7E5E,
0xC064, 0xC07B, 0x7E83,
0xC07C, 0xC07E, 0x7E9C,
0xC082, 0xC083, 0x7EBB,
0xC08D, 0xC093, 0x7F3B,
0xC095, 0xC09E, 0x7F46,
0xC09F, 0xC0A0, 0x7F52,
0xC142, 0xC145, 0x7F5B,
0xC147, 0xC14B, 0x7F63,
0xC14C, 0xC14E, 0x7F6B,
0xC14F, 0xC150, 0x7F6F,
0xC152, 0xC155, 0x7F75,
0xC156, 0xC159, 0x7F7A,
0xC15A, 0xC15B, 0x7F7F,
0xC15C, 0xC163, 0x7F82,
0xC166, 0xC16A, 0x7F8F,
0xC16B, 0xC16F, 0x7F95,
0xC170, 0xC171, 0x7F9B,
0xC173, 0xC174, 0x7FA2,
0xC175, 0xC176, 0x7FA5,
0xC177, 0xC17D, 0x7FA8,
0xC180, 0xC184, 0x7FB3,
0xC185, 0xC186, 0x7FBA,
0xC189, 0xC18B, 0x7FC2,
0xC18C, 0xC18F, 0x7FC6,
0xC192, 0xC196, 0x7FCF,
0xC197, 0xC198, 0x7FD6,
0xC199, 0xC19E, 0x7FD9,
0xC19F, 0xC1A0, 0x7FE2,
0xC241, 0xC242, 0x7FE7,
0xC243, 0xC246, 0x7FEA,
0xC249, 0xC24F, 0x7FF4,
0xC250, 0xC252, 0x7FFD,
0xC254, 0xC257, 0x8007,
0xC258, 0xC259, 0x800E,
0xC25C, 0xC25D, 0x801A,
0xC25E, 0xC260, 0x801D,
0xC262, 0xC263, 0x8023,
0xC264, 0xC269, 0x802B,
0xC26C, 0xC26D, 0x8039,
0xC270, 0xC271, 0x8040,
0xC272, 0xC273, 0x8044,
0xC274, 0xC276, 0x8047,
0xC277, 0xC27A, 0x804E,
0xC27C, 0xC27E, 0x8055,
0xC281, 0xC28E, 0x805B,
0xC28F, 0xC294, 0x806B,
0xC295, 0xC2A0, 0x8072,
0xC341, 0xC342, 0x8081,
0xC346, 0xC34B, 0x808D,
0xC34C, 0xC34D, 0x8094,
0xC352, 0xC354, 0x80A6,
0xC358, 0xC359, 0x80B5,
0xC35A, 0xC35B, 0x80B8,
0xC35E, 0xC362, 0x80C7,
0xC363, 0xC369, 0x80CF,
0xC36B, 0xC36C, 0x80DF,
0xC36D, 0xC36E, 0x80E2,
0xC375, 0xC378, 0x80FE,
0xC379, 0xC37B, 0x8103,
0xC37C, 0xC37D, 0x8107,
0xC384, 0xC386, 0x811B,
0xC387, 0xC393, 0x811F,
0xC394, 0xC395, 0x812D,
0xC397, 0xC399, 0x8133,
0xC39B, 0xC39F, 0x8139,
0xC440, 0xC445, 0x8140,
0xC448, 0xC44A, 0x814D,
0xC44C, 0xC44E, 0x8156,
0xC44F, 0xC453, 0x815B,
0xC454, 0xC457, 0x8161,
0xC45A, 0xC45C, 0x816A,
0xC45E, 0xC45F, 0x8172,
0xC460, 0xC463, 0x8175,
0xC465, 0xC469, 0x8183,
0xC46B, 0xC46E, 0x818B,
0xC470, 0xC475, 0x8192,
0xC476, 0xC477, 0x8199,
0xC478, 0xC47C, 0x819E,
0xC47D, 0xC47E, 0x81A4,
0xC482, 0xC489, 0x81AB,
0xC48A, 0xC48F, 0x81B4,
0xC490, 0xC493, 0x81BC,
0xC494, 0xC495, 0x81C4,
0xC496, 0xC498, 0x81C7,
0xC49A, 0xC4A0, 0x81CD,
0xC540, 0xC54E, 0x81D4,
0xC54F, 0xC551, 0x81E4,
0xC552, 0xC553, 0x81E8,
0xC555, 0xC559, 0x81EE,
0xC55A, 0xC55F, 0x81F5,
0xC563, 0xC567, 0x8207,
0xC568, 0xC569, 0x820E,
0xC56C, 0xC571, 0x8215,
0xC574, 0xC577, 0x8224,
0xC57C, 0xC57D, 0x823C,
0xC580, 0xC583, 0x8240,
0xC584, 0xC585, 0x8245,
0xC588, 0xC58A, 0x824C,
0xC58B, 0xC592, 0x8250,
0xC594, 0xC597, 0x825B,
0xC598, 0xC59F, 0x8260,
0xC640, 0xC643, 0x826A,
0xC645, 0xC648, 0x8275,
0xC649, 0xC64A, 0x827B,
0xC64B, 0xC64C, 0x8280,
0xC64E, 0xC650, 0x8285,
0xC654, 0xC657, 0x8293,
0xC658, 0xC659, 0x829A,
0xC65C, 0xC65D, 0x82A2,
0xC660, 0xC661, 0x82B5,
0xC662, 0xC664, 0x82BA,
0xC665, 0xC666, 0x82BF,
0xC667, 0xC668, 0x82C2,
0xC669, 0xC66A, 0x82C5,
0xC66E, 0xC66F, 0x82D9,
0xC672, 0xC675, 0x82E7,
0xC676, 0xC678, 0x82EC,
0xC67A, 0xC67B, 0x82F2,
0xC67C, 0xC67D, 0x82F5,
0xC681, 0xC685, 0x82FC,
0xC686, 0xC687, 0x830A,
0xC68A, 0xC68B, 0x8312,
0xC68D, 0xC68E, 0x8318,
0xC68F, 0xC698, 0x831D,
0xC699, 0xC69A, 0x8329,
0xC740, 0xC741, 0x833E,
0xC742, 0xC743, 0x8341,
0xC744, 0xC745, 0x8344,
0xC747, 0xC74B, 0x834A,
0xC74D, 0xC751, 0x8355,
0xC754, 0xC75A, 0x8370,
0xC75B, 0xC75C, 0x8379,
0xC75D, 0xC763, 0x837E,
0xC764, 0xC765, 0x8387,
0xC766, 0xC769, 0x838A,
0xC76A, 0xC76C, 0x838F,
0xC76D, 0xC770, 0x8394,
0xC771, 0xC772, 0x8399,
0xC775, 0xC77B, 0x83A1,
0xC77C, 0xC77E, 0x83AC,
0xC783, 0xC784, 0x83BE,
0xC785, 0xC787, 0x83C2,
0xC789, 0xC78A, 0x83C8,
0xC78C, 0xC78D, 0x83CD,
0xC78E, 0xC791, 0x83D0,
0xC794, 0xC796, 0x83D9,
0xC798, 0xC79A, 0x83E2,
0xC79B, 0xC79D, 0x83E6,
0xC79E, 0xC7A0, 0x83EB,
0xC840, 0xC841, 0x83EE,
0xC842, 0xC846, 0x83F3,
0xC847, 0xC849, 0x83FA,
0xC84A, 0xC84C, 0x83FE,
0xC84F, 0xC852, 0x8407,
0xC854, 0xC859, 0x8412,
0xC85A, 0xC85C, 0x8419,
0xC85D, 0xC862, 0x841E,
0xC863, 0xC86A, 0x8429,
0xC86B, 0xC870, 0x8432,
0xC871, 0xC873, 0x8439,
0xC874, 0xC87B, 0x843E,
0xC87C, 0xC87E, 0x8447,
0xC880, 0xC886, 0x844A,
0xC887, 0xC88B, 0x8452,
0xC88D, 0xC890, 0x845D,
0xC892, 0xC896, 0x8464,
0xC898, 0xC89A, 0x846E,
0xC89F, 0xC8A0, 0x847B,
0xC940, 0xC944, 0x847D,
0xC945, 0xC948, 0x8483,
0xC94B, 0xC952, 0x848F,
0xC954, 0xC955, 0x849A,
0xC956, 0xC959, 0x849D,
0xC95A, 0xC966, 0x84A2,
0xC967, 0xC968, 0x84B0,
0xC96A, 0xC96C, 0x84B5,
0xC96D, 0xC96E, 0x84BB,
0xC971, 0xC972, 0x84C2,
0xC973, 0xC976, 0x84C5,
0xC977, 0xC978, 0x84CB,
0xC979, 0xC97A, 0x84CE,
0xC97C, 0xC97D, 0x84D4,
0xC980, 0xC984, 0x84D8,
0xC986, 0xC987, 0x84E1,
0xC989, 0xC98D, 0x84E7,
0xC98E, 0xC990, 0x84ED,
0xC991, 0xC99B, 0x84F1,
0xC99C, 0xC99D, 0x84FD,
0xC99E, 0xC9A0, 0x8500,
0xC9E0, 0xC9E1, 0x820C,
0xCA40, 0xCA48, 0x8503,
0xCA49, 0xCA4C, 0x850D,
0xCA4E, 0xCA50, 0x8514,
0xCA51, 0xCA52, 0x8518,
0xCA53, 0xCA56, 0x851B,
0xCA58, 0xCA60, 0x8522,
0xCA61, 0xCA6A, 0x852D,
0xCA6B, 0xCA6F, 0x853E,
0xCA70, 0xCA73, 0x8544,
0xCA74, 0xCA7E, 0x854B,
0xCA80, 0xCA81, 0x8557,
0xCA82, 0xCA85, 0x855A,
0xCA86, 0xCA8A, 0x855F,
0xCA8B, 0xCA8D, 0x8565,
0xCA8E, 0xCA96, 0x8569,
0xCA98, 0xCA9B, 0x8575,
0xCA9C, 0xCA9D, 0x857C,
0xCA9E, 0xCAA0, 0x857F,
0xCB40, 0xCB41, 0x8582,
0xCB43, 0xCB49, 0x8588,
0xCB4A, 0xCB54, 0x8590,
0xCB55, 0xCB5B, 0x859D,
0xCB5C, 0xCB5E, 0x85A5,
0xCB60, 0xCB62, 0x85AB,
0xCB63, 0xCB68, 0x85B1,
0xCB6A, 0xCB70, 0x85BA,
0xCB71, 0xCB77, 0x85C2,
0xCB78, 0xCB7C, 0x85CA,
0xCB7D, 0xCB7E, 0x85D1,
0xCB81, 0xCB86, 0x85D6,
0xCB87, 0xCB8D, 0x85DD,
0xCB8E, 0xCB91, 0x85E5,
0xCB92, 0xCBA0, 0x85EA,
0xCC40, 0xCC41, 0x85F9,
0xCC42, 0xCC44, 0x85FC,
0xCC45, 0xCC49, 0x8600,
0xCC4A, 0xCC54, 0x8606,
0xCC55, 0xCC58, 0x8612,
0xCC59, 0xCC68, 0x8617,
0xCC6A, 0xCC77, 0x862A,
0xCC78, 0xCC7A, 0x8639,
0xCC7B, 0xCC7E, 0x863D,
0xCC80, 0xCC8B, 0x8641,
0xCC8C, 0xCC8D, 0x8652,
0xCC8E, 0xCC92, 0x8655,
0xCC93, 0xCC95, 0x865B,
0xCC96, 0xCC98, 0x865F,
0xCC99, 0xCCA0, 0x8663,
0xCD41, 0xCD42, 0x866F,
0xCD43, 0xCD49, 0x8672,
0xCD4A, 0xCD50, 0x8683,
0xCD51, 0xCD55, 0x868E,
0xCD57, 0xCD5C, 0x8696,
0xCD5D, 0xCD61, 0x869E,
0xCD62, 0xCD63, 0x86A5,
0xCD65, 0xCD66, 0x86AD,
0xCD67, 0xCD68, 0x86B2,
0xCD69, 0xCD6B, 0x86B7,
0xCD6C, 0xCD70, 0x86BB,
0xCD71, 0xCD73, 0x86C1,
0xCD76, 0xCD77, 0x86CC,
0xCD78, 0xCD79, 0x86D2,
0xCD7A, 0xCD7C, 0x86D5,
0xCD81, 0xCD84, 0x86E0,
0xCD85, 0xCD88, 0x86E5,
0xCD89, 0xCD8B, 0x86EA,
0xCD8D, 0xCD8F, 0x86F5,
0xCD90, 0xCD93, 0x86FA,
0xCD96, 0xCD98, 0x8704,
0xCD99, 0xCD9A, 0x870B,
0xCD9B, 0xCD9E, 0x870E,
0xCE43, 0xCE44, 0x871F,
0xCE46, 0xCE48, 0x8726,
0xCE49, 0xCE4C, 0x872A,
0xCE4D, 0xCE4E, 0x872F,
0xCE4F, 0xCE50, 0x8732,
0xCE51, 0xCE52, 0x8735,
0xCE53, 0xCE55, 0x8738,
0xCE56, 0xCE57, 0x873C,
0xCE58, 0xCE5E, 0x8740,
0xCE5F, 0xCE60, 0x874A,
0xCE62, 0xCE65, 0x874F,
0xCE66, 0xCE68, 0x8754,
0xCE6A, 0xCE6F, 0x875A,
0xCE70, 0xCE71, 0x8761,
0xCE72, 0xCE79, 0x8766,
0xCE7B, 0xCE7D, 0x8771,
0xCE80, 0xCE83, 0x8777,
0xCE84, 0xCE86, 0x877F,
0xCE88, 0xCE89, 0x8786,
0xCE8A, 0xCE8B, 0x8789,
0xCE8D, 0xCE91, 0x878E,
0xCE92, 0xCE94, 0x8794,
0xCE95, 0xCE9B, 0x8798,
0xCE9C, 0xCEA0, 0x87A0,
0xCF40, 0xCF42, 0x87A5,
0xCF43, 0xCF44, 0x87A9,
0xCF46, 0xCF48, 0x87B0,
0xCF4A, 0xCF4D, 0x87B6,
0xCF4E, 0xCF4F, 0x87BB,
0xCF50, 0xCF51, 0x87BE,
0xCF52, 0xCF56, 0x87C1,
0xCF57, 0xCF59, 0x87C7,
0xCF5A, 0xCF5E, 0x87CC,
0xCF5F, 0xCF65, 0x87D4,
0xCF66, 0xCF69, 0x87DC,
0xCF6A, 0xCF6D, 0x87E1,
0xCF6E, 0xCF71, 0x87E6,
0xCF72, 0xCF74, 0x87EB,
0xCF75, 0xCF7E, 0x87EF,
0xCF80, 0xCF83, 0x87FA,
0xCF84, 0xCF87, 0x87FF,
0xCF88, 0xCF8D, 0x8804,
0xCF8E, 0xCF95, 0x880B,
0xCF97, 0xCF9A, 0x8817,
0xCF9B, 0xCF9F, 0x881C,
0xD040, 0xD04D, 0x8824,
0xD04E, 0xD053, 0x8833,
0xD054, 0xD055, 0x883A,
0xD056, 0xD058, 0x883D,
0xD059, 0xD05B, 0x8841,
0xD05C, 0xD061, 0x8846,
0xD062, 0xD067, 0x884E,
0xD068, 0xD069, 0x8855,
0xD06B, 0xD071, 0x885A,
0xD072, 0xD073, 0x8866,
0xD078, 0xD07B, 0x8873,
0xD07C, 0xD07E, 0x8878,
0xD080, 0xD081, 0x887B,
0xD084, 0xD085, 0x8886,
0xD086, 0xD087, 0x8889,
0xD089, 0xD08C, 0x888E,
0xD08D, 0xD08F, 0x8893,
0xD090, 0xD094, 0x8897,
0xD095, 0xD099, 0x889D,
0xD09B, 0xD0A0, 0x88A5,
0xD141, 0xD143, 0x88AE,
0xD144, 0xD148, 0x88B2,
0xD149, 0xD14C, 0x88B8,
0xD14D, 0xD150, 0x88BD,
0xD151, 0xD152, 0x88C3,
0xD153, 0xD154, 0x88C7,
0xD155, 0xD158, 0x88CA,
0xD159, 0xD15B, 0x88CF,
0xD15D, 0xD15E, 0x88D6,
0xD15F, 0xD163, 0x88DA,
0xD164, 0xD165, 0x88E0,
0xD166, 0xD167, 0x88E6,
0xD168, 0xD16E, 0x88E9,
0xD170, 0xD172, 0x88F5,
0xD173, 0xD174, 0x88FA,
0xD176, 0xD178, 0x88FF,
0xD179, 0xD17E, 0x8903,
0xD181, 0xD185, 0x890B,
0xD187, 0xD18B, 0x8914,
0xD18C, 0xD190, 0x891C,
0xD191, 0xD193, 0x8922,
0xD194, 0xD197, 0x8926,
0xD198, 0xD19B, 0x892C,
0xD19C, 0xD19E, 0x8931,
0xD240, 0xD248, 0x8938,
0xD249, 0xD24A, 0x8942,
0xD24B, 0xD263, 0x8945,
0xD264, 0xD269, 0x8960,
0xD26A, 0xD27D, 0x8967,
0xD280, 0xD281, 0x897D,
0xD284, 0xD285, 0x8984,
0xD286, 0xD2A0, 0x8987,
0xD340, 0xD35E, 0x89A2,
0xD361, 0xD363, 0x89D3,
0xD364, 0xD366, 0x89D7,
0xD369, 0xD36C, 0x89DF,
0xD36E, 0xD371, 0x89E7,
0xD372, 0xD374, 0x89EC,
0xD375, 0xD377, 0x89F0,
0xD378, 0xD37E, 0x89F4,
0xD380, 0xD384, 0x89FB,
0xD385, 0xD38A, 0x8A01,
0xD38B, 0xD3A0, 0x8A08,
0xD3A9, 0xD3AA, 0x8424,
0xD440, 0xD45F, 0x8A1E,
0xD460, 0xD468, 0x8A3F,
0xD469, 0xD47E, 0x8A49,
0xD480, 0xD499, 0x8A5F,
0xD49A, 0xD4A0, 0x8A7A,
0xD540, 0xD547, 0x8A81,
0xD548, 0xD54F, 0x8A8B,
0xD550, 0xD57E, 0x8A94,
0xD580, 0xD5A0, 0x8AC3,
0xD640, 0xD662, 0x8AE4,
0xD663, 0xD67E, 0x8B08,
0xD680, 0xD681, 0x8B24,
0xD682, 0xD6A0, 0x8B27,
0xD6C1, 0xD6C2, 0x81F3,
0xD740, 0xD75F, 0x8B46,
0xD760, 0xD764, 0x8B67,
0xD765, 0xD77E, 0x8B6D,
0xD780, 0xD798, 0x8B87,
0xD840, 0xD848, 0x8C38,
0xD849, 0xD84C, 0x8C42,
0xD84E, 0xD84F, 0x8C4A,
0xD850, 0xD857, 0x8C4D,
0xD858, 0xD85B, 0x8C56,
0xD85C, 0xD861, 0x8C5B,
0xD862, 0xD868, 0x8C63,
0xD869, 0xD86F, 0x8C6C,
0xD870, 0xD873, 0x8C74,
0xD874, 0xD87A, 0x8C7B,
0xD87B, 0xD87C, 0x8C83,
0xD87D, 0xD87E, 0x8C86,
0xD882, 0xD888, 0x8C8D,
0xD889, 0xD88B, 0x8C95,
0xD88C, 0xD8A0, 0x8C99,
0xD8DB, 0xD8DC, 0x523F,
0xD940, 0xD97E, 0x8CAE,
0xD980, 0xD9A0, 0x8CED,
0xDA40, 0xDA4E, 0x8D0E,
0xDA50, 0xDA51, 0x8D51,
0xDA55, 0xDA57, 0x8D68,
0xDA59, 0xDA5A, 0x8D6E,
0xDA5B, 0xDA5C, 0x8D71,
0xDA5D, 0xDA65, 0x8D78,
0xDA66, 0xDA67, 0x8D82,
0xDA68, 0xDA6B, 0x8D86,
0xDA6C, 0xDA70, 0x8D8C,
0xDA71, 0xDA72, 0x8D92,
0xDA73, 0xDA7C, 0x8D95,
0xDA7D, 0xDA7E, 0x8DA0,
0xDA81, 0xDA8D, 0x8DA4,
0xDA8F, 0xDA90, 0x8DB6,
0xDA94, 0xDA96, 0x8DC0,
0xDA98, 0xDA9B, 0x8DC7,
0xDA9E, 0xDAA0, 0x8DD2,
0xDAA6, 0xDAA7, 0x8BA6,
0xDAA9, 0xDAAA, 0x8BB4,
0xDAAC, 0xDAAD, 0x8BC2,
0xDAB1, 0xDAB3, 0x8BD2,
0xDAB5, 0xDAB6, 0x8BD8,
0xDAB8, 0xDAB9, 0x8BDF,
0xDABB, 0xDABC, 0x8BE8,
0xDAC3, 0xDAC4, 0x8BFF,
0xDACA, 0xDACB, 0x8C11,
0xDACC, 0xDACE, 0x8C14,
0xDAD3, 0xDAD5, 0x8C1F,
0xDAD8, 0xDAD9, 0x8C2A,
0xDADA, 0xDADB, 0x8C2E,
0xDADC, 0xDADD, 0x8C32,
0xDADE, 0xDADF, 0x8C35,
0xDB41, 0xDB42, 0x8DD8,
0xDB44, 0xDB46, 0x8DE0,
0xDB47, 0xDB49, 0x8DE5,
0xDB4B, 0xDB4C, 0x8DED,
0xDB4D, 0xDB4F, 0x8DF0,
0xDB53, 0xDB59, 0x8DFE,
0xDB5A, 0xDB5C, 0x8E06,
0xDB5E, 0xDB5F, 0x8E0D,
0xDB60, 0xDB63, 0x8E10,
0xDB64, 0xDB6B, 0x8E15,
0xDB6C, 0xDB6D, 0x8E20,
0xDB6E, 0xDB72, 0x8E24,
0xDB76, 0xDB78, 0x8E32,
0xDB79, 0xDB7B, 0x8E36,
0xDB7C, 0xDB7D, 0x8E3B,
0xDB82, 0xDB83, 0x8E45,
0xDB84, 0xDB88, 0x8E4C,
0xDB89, 0xDB8E, 0x8E53,
0xDB8F, 0xDB9A, 0x8E5A,
0xDB9B, 0xDB9C, 0x8E67,
0xDB9D, 0xDB9E, 0x8E6A,
0xDBBE, 0xDBBF, 0x52AC,
0xDBDC, 0xDBDD, 0x572E,
0xDC42, 0xDC46, 0x8E77,
0xDC47, 0xDC48, 0x8E7D,
0xDC4A, 0xDC4C, 0x8E82,
0xDC4E, 0xDC54, 0x8E88,
0xDC55, 0xDC57, 0x8E91,
0xDC58, 0xDC5E, 0x8E95,
0xDC60, 0xDC6B, 0x8E9F,
0xDC6C, 0xDC6D, 0x8EAD,
0xDC6E, 0xDC6F, 0x8EB0,
0xDC70, 0xDC76, 0x8EB3,
0xDC77, 0xDC7E, 0x8EBB,
0xDC80, 0xDC8A, 0x8EC3,
0xDC8B, 0xDCA0, 0x8ECF,
0xDCC8, 0xDCC9, 0x82CB,
0xDCE3, 0xDCE4, 0x8314,
0xDCE9, 0xDCEA, 0x835B,
0xDD40, 0xDD7E, 0x8EE5,
0xDD80, 0xDDA0, 0x8F24,
0xDDA6, 0xDDA7, 0x836D,
0xDDAA, 0xDDAB, 0x83B3,
0xDDCE, 0xDDCF, 0x83F8,
0xDDDB, 0xDDDC, 0x8487,
0xDE40, 0xDE60, 0x8F45,
0xDE66, 0xDE68, 0x8FA0,
0xDE69, 0xDE6C, 0x8FA4,
0xDE6E, 0xDE71, 0x8FAC,
0xDE72, 0xDE75, 0x8FB2,
0xDE76, 0xDE77, 0x8FB7,
0xDE78, 0xDE7A, 0x8FBA,
0xDE7B, 0xDE7C, 0x8FBF,
0xDE80, 0xDE84, 0x8FC9,
0xDE87, 0xDE88, 0x8FD6,
0xDE8A, 0xDE8B, 0x8FE0,
0xDE90, 0xDE91, 0x8FF1,
0xDE92, 0xDE94, 0x8FF4,
0xDE95, 0xDE97, 0x8FFA,
0xDE98, 0xDE99, 0x8FFE,
0xDE9A, 0xDE9B, 0x9007,
0xDF42, 0xDF44, 0x9023,
0xDF45, 0xDF4A, 0x9027,
0xDF4B, 0xDF4F, 0x9030,
0xDF51, 0xDF52, 0x9039,
0xDF54, 0xDF55, 0x903F,
0xDF57, 0xDF58, 0x9045,
0xDF59, 0xDF5D, 0x9048,
0xDF5F, 0xDF61, 0x9054,
0xDF62, 0xDF63, 0x9059,
0xDF64, 0xDF69, 0x905C,
0xDF6B, 0xDF6C, 0x9066,
0xDF6D, 0xDF70, 0x9069,
0xDF71, 0xDF75, 0x906F,
0xDF76, 0xDF7C, 0x9076,
0xDF80, 0xDF83, 0x9084,
0xDF84, 0xDF85, 0x9089,
0xDF86, 0xDF8A, 0x908C,
0xDF91, 0xDF93, 0x909E,
0xDF94, 0xDF95, 0x90A4,
0xDF96, 0xDF98, 0x90A7,
0xDF9D, 0xDF9E, 0x90BC,
0xDF9F, 0xDFA0, 0x90BF,
0xDFA2, 0xDFA3, 0x64B7,
0xDFBC, 0xDFBE, 0x5452,
0xDFCB, 0xDFCC, 0x549A,
0xDFD8, 0xDFD9, 0x54D3,
0xDFE0, 0xDFE1, 0x54D9,
0xDFE3, 0xDFE4, 0x54A9,
0xDFEF, 0xDFF0, 0x5522,
0xE040, 0xE041, 0x90C2,
0xE043, 0xE044, 0x90C8,
0xE045, 0xE047, 0x90CB,
0xE049, 0xE04B, 0x90D4,
0xE04C, 0xE04E, 0x90D8,
0xE04F, 0xE051, 0x90DE,
0xE052, 0xE054, 0x90E3,
0xE055, 0xE056, 0x90E9,
0xE059, 0xE05C, 0x90F0,
0xE05D, 0xE05F, 0x90F5,
0xE060, 0xE063, 0x90F9,
0xE064, 0xE066, 0x90FF,
0xE068, 0xE07B, 0x9105,
0xE07C, 0xE07E, 0x911A,
0xE081, 0xE083, 0x911F,
0xE084, 0xE08E, 0x9124,
0xE090, 0xE096, 0x9132,
0xE097, 0xE09F, 0x913A,
0xE0A3, 0xE0A5, 0x5575,
0xE0B6, 0xE0B7, 0x55BD,
0xE0BF, 0xE0C0, 0x55EB,
0xE0C7, 0xE0C8, 0x55F2,
0xE0C9, 0xE0CA, 0x55CC,
0xE0E7, 0xE0E8, 0x567B,
0xE0FD, 0xE0FE, 0x5E3B,
0xE141, 0xE142, 0x9147,
0xE144, 0xE147, 0x9153,
0xE148, 0xE149, 0x9158,
0xE14A, 0xE14B, 0x915B,
0xE14C, 0xE14D, 0x915F,
0xE14E, 0xE150, 0x9166,
0xE154, 0xE156, 0x917A,
0xE157, 0xE15B, 0x9180,
0xE15F, 0xE160, 0x918E,
0xE161, 0xE167, 0x9193,
0xE168, 0xE16D, 0x919C,
0xE16E, 0xE173, 0x91A4,
0xE174, 0xE175, 0x91AB,
0xE176, 0xE179, 0x91B0,
0xE17A, 0xE17D, 0x91B6,
0xE180, 0xE18A, 0x91BC,
0xE18E, 0xE197, 0x91D2,
0xE198, 0xE1A0, 0x91DD,
0xE1AD, 0xE1AE, 0x5C98,
0xE1C0, 0xE1C1, 0x5D02,
0xE1EE, 0xE1EF, 0x72B7,
0xE240, 0xE27E, 0x91E6,
0xE280, 0xE2A0, 0x9225,
0xE2BC, 0xE2C1, 0x9967,
0xE2CA, 0xE2CB, 0x9990,
0xE2CC, 0xE2CE, 0x9993,
0xE2EA, 0xE2EB, 0x6005,
0xE2FA, 0xE2FB, 0x6078,
0xE340, 0xE36D, 0x9246,
0xE36E, 0xE37E, 0x9275,
0xE380, 0xE387, 0x9286,
0xE388, 0xE3A0, 0x928F,
0xE3C9, 0xE3CA, 0x95F5,
0xE3CD, 0xE3CE, 0x9603,
0xE3D1, 0xE3D4, 0x960A,
0xE3D7, 0xE3D9, 0x9615,
0xE3DA, 0xE3DB, 0x9619,
0xE3E8, 0xE3E9, 0x6C68,
0xE3F1, 0xE3F2, 0x6CF7,
0xE440, 0xE445, 0x92A8,
0xE446, 0xE45E, 0x92AF,
0xE45F, 0xE47E, 0x92C9,
0xE480, 0xE4A0, 0x92E9,
0xE4B8, 0xE4B9, 0x6D93,
0xE4D4, 0xE4D5, 0x6E53,
0xE4EB, 0xE4EC, 0x6F46,
0xE540, 0xE573, 0x930A,
0xE574, 0xE57E, 0x933F,
0xE580, 0xE59F, 0x934A,
0xE5D3, 0xE5D4, 0x9035,
0xE5D8, 0xE5D9, 0x9051,
0xE5FC, 0xE5FD, 0x59A9,
0xE640, 0xE662, 0x936C,
0xE663, 0xE67E, 0x9390,
0xE680, 0xE69D, 0x93AC,
0xE69E, 0xE6A0, 0x93CB,
0xE6AB, 0xE6AC, 0x5A05,
0xE6E1, 0xE6E2, 0x9A77,
0xE6E6, 0xE6E7, 0x9A80,
0xE6EC, 0xE6ED, 0x9A92,
0xE6F0, 0xE6F2, 0x9A9B,
0xE6F3, 0xE6F4, 0x9A9F,
0xE6F5, 0xE6F6, 0x9AA2,
0xE6FD, 0xE6FE, 0x7EA8,
0xE740, 0xE747, 0x93CE,
0xE748, 0xE77E, 0x93D7,
0xE780, 0xE7A0, 0x940E,
0xE7A4, 0xE7A6, 0x7EC0,
0xE7A8, 0xE7A9, 0x7ECB,
0xE7AE, 0xE7AF, 0x7EE0,
0xE7B2, 0xE7B3, 0x7EEE,
0xE7B4, 0xE7B5, 0x7EF1,
0xE7B8, 0xE7B9, 0x7EFA,
0xE7BB, 0xE7BD, 0x7F01,
0xE7BE, 0xE7BF, 0x7F07,
0xE7C0, 0xE7C1, 0x7F0B,
0xE7C3, 0xE7C4, 0x7F11,
0xE7CA, 0xE7D0, 0x7F21,
0xE7D1, 0xE7D4, 0x7F2A,
0xE7D5, 0xE7D9, 0x7F2F,
0xE840, 0xE84E, 0x942F,
0xE84F, 0xE87A, 0x943F,
0xE87B, 0xE87E, 0x946C,
0xE880, 0xE894, 0x9470,
0xE89A, 0xE89B, 0x94D3,
0xE8AD, 0xE8AE, 0x7480,
0xE8B2, 0xE8B3, 0x74A8,
0xE8B8, 0xE8BA, 0x97EA,
0xE8E0, 0xE8E1, 0x6832,
0xE8E2, 0xE8E3, 0x6860,
0xE8FC, 0xE8FD, 0x691F,
0xE94A, 0xE94B, 0x9574,
0xE94C, 0xE953, 0x9577,
0xE954, 0xE97E, 0x9580,
0xE980, 0xE9A0, 0x95AB,
0xE9B4, 0xE9B5, 0x6987,
0xE9CB, 0xE9CC, 0x6A17,
0xE9E2, 0xE9E3, 0x6B81,
0xE9E6, 0xE9E7, 0x6B92,
0xE9E9, 0xE9EA, 0x6B9A,
0xE9EF, 0xE9F1, 0x8F71,
0xE9F2, 0xE9F3, 0x8F75,
0xE9F6, 0xE9F7, 0x8F79,
0xE9FA, 0xE9FB, 0x8F81,
0xEA40, 0xEA5B, 0x95CC,
0xEA64, 0xEA6A, 0x9623,
0xEA6B, 0xEA6D, 0x962B,
0xEA6E, 0xEA6F, 0x962F,
0xEA70, 0xEA73, 0x9637,
0xEA78, 0xEA79, 0x964E,
0xEA7A, 0xEA7C, 0x9651,
0xEA7D, 0xEA7E, 0x9656,
0xEA80, 0xEA82, 0x9658,
0xEA83, 0xEA85, 0x965C,
0xEA88, 0xEA89, 0x9665,
0xEA8B, 0xEA8F, 0x966D,
0xEA91, 0xEA9D, 0x9678,
0xEA9F, 0xEAA0, 0x9689,
0xEAA1, 0xEAA3, 0x8F8D,
0xEAB8, 0xEABA, 0x65EE,
0xEAD6, 0xEAD7, 0x66DB,
0xEADA, 0xEADB, 0x8D32,
0xEAE0, 0xEAE1, 0x8D45,
0xEAE2, 0xEAE3, 0x8D48,
0xEAE9, 0xEAEB, 0x89CA,
0xEAEC, 0xEAEF, 0x89CE,
0xEAF5, 0xEAF6, 0x727E,
0xEB42, 0xEB44, 0x9691,
0xEB45, 0xEB46, 0x9695,
0xEB47, 0xEB48, 0x969A,
0xEB49, 0xEB52, 0x969D,
0xEB53, 0xEB5A, 0x96A8,
0xEB5B, 0xEB5C, 0x96B1,
0xEB5D, 0xEB5E, 0x96B4,
0xEB5F, 0xEB60, 0x96B7,
0xEB61, 0xEB62, 0x96BA,
0xEB64, 0xEB65, 0x96C2,
0xEB67, 0xEB68, 0x96CA,
0xEB69, 0xEB6A, 0x96D0,
0xEB6B, 0xEB6C, 0x96D3,
0xEB6D, 0xEB76, 0x96D6,
0xEB77, 0xEB7D, 0x96E1,
0xEB80, 0xEB82, 0x96EC,
0xEB83, 0xEB85, 0x96F0,
0xEB86, 0xEB87, 0x96F4,
0xEB89, 0xEB8C, 0x96FA,
0xEB8E, 0xEB8F, 0x9702,
0xEB91, 0xEB93, 0x970A,
0xEB94, 0xEB96, 0x9710,
0xEB97, 0xEB98, 0x9714,
0xEB99, 0xEB9D, 0x9717,
0xEB9F, 0xEBA0, 0x971F,
0xEBAE, 0xEBB0, 0x6C18,
0xEBCA, 0xEBCD, 0x80E7,
0xEBDA, 0xEBDB, 0x810D,
0xEBEA, 0xEBEB, 0x8159,
0xEBEF, 0xEBF0, 0x817C,
0xEC40, 0xEC48, 0x9721,
0xEC49, 0xEC4A, 0x972B,
0xEC4B, 0xEC4C, 0x972E,
0xEC4E, 0xEC52, 0x9733,
0xEC53, 0xEC56, 0x973A,
0xEC57, 0xEC69, 0x973F,
0xEC6A, 0xEC6B, 0x9754,
0xEC6C, 0xEC6D, 0x9757,
0xEC6F, 0xEC70, 0x975C,
0xEC72, 0xEC73, 0x9763,
0xEC74, 0xEC76, 0x9766,
0xEC77, 0xEC7E, 0x976A,
0xEC82, 0xEC86, 0x9777,
0xEC87, 0xEC8E, 0x977D,
0xEC8F, 0xEC93, 0x9786,
0xEC95, 0xEC97, 0x978E,
0xEC99, 0xEC9B, 0x9795,
0xEC9C, 0xECA0, 0x9799,
0xECA9, 0xECAB, 0x98D1,
0xECAD, 0xECAE, 0x98D9,
0xECE8, 0xECE9, 0x6248,
0xECEE, 0xECEF, 0x795B,
0xED40, 0xED41, 0x979E,
0xED42, 0xED43, 0x97A1,
0xED44, 0xED4A, 0x97A4,
0xED4D, 0xED4E, 0x97B0,
0xED50, 0xED7E, 0x97B5,
0xED80, 0xED81, 0x97E4,
0xED83, 0xED87, 0x97EE,
0xED89, 0xEDA0, 0x97F7,
0xEDBA, 0xEDBB, 0x7817,
0xEDBF, 0xEDC0, 0x781C,
0xEDC1, 0xEDC3, 0x7839,
0xEDCC, 0xEDCD, 0x7856,
0xEDEA, 0xEDEB, 0x9EFB,
0xEDF0, 0xEDF1, 0x7707,
0xEDF9, 0xEDFA, 0x7750,
0xEE40, 0xEE7E, 0x980F,
0xEE80, 0xEEA0, 0x984E,
0xEEA9, 0xEEAA, 0x779F,
0xEEC4, 0xEEC6, 0x9485,
0xEEC9, 0xEECA, 0x948C,
0xEECB, 0xEECC, 0x948F,
0xEED0, 0xEED2, 0x949A,
0xEED3, 0xEED4, 0x94A3,
0xEED9, 0xEEDA, 0x94AF,
0xEEDD, 0xEEE1, 0x94B6,
0xEEE2, 0xEEE3, 0x94BC,
0xEEE6, 0xEEEC, 0x94C8,
0xEEED, 0xEEEF, 0x94D0,
0xEEF0, 0xEEF2, 0x94D5,
0xEEF6, 0xEEF8, 0x94DE,
0xEEFA, 0xEEFB, 0x94E4,
0xEEFC, 0xEEFD, 0x94E7,
0xEF40, 0xEF45, 0x986F,
0xEF4C, 0xEF71, 0x98A8,
0xEF72, 0xEF73, 0x98CF,
0xEF75, 0xEF76, 0x98D6,
0xEF77, 0xEF79, 0x98DB,
0xEF7A, 0xEF7E, 0x98E0,
0xEF80, 0xEF81, 0x98E5,
0xEF82, 0xEFA0, 0x98E9,
0xEFA3, 0xEFA4, 0x94EE,
0xEFA5, 0xEFA7, 0x94F3,
0xEFAA, 0xEFAB, 0x94FC,
0xEFAF, 0xEFB0, 0x9506,
0xEFB1, 0xEFB2, 0x9509,
0xEFB3, 0xEFB5, 0x950D,
0xEFB6, 0xEFBA, 0x9512,
0xEFBD, 0xEFBF, 0x951D,
0xEFC1, 0xEFC2, 0x952A,
0xEFC5, 0xEFC6, 0x9531,
0xEFC8, 0xEFCA, 0x9536,
0xEFCC, 0xEFCD, 0x953E,
0xEFD0, 0xEFD2, 0x9544,
0xEFD5, 0xEFD6, 0x954E,
0xEFD7, 0xEFD9, 0x9552,
0xEFDA, 0xEFDD, 0x9556,
0xEFDF, 0xEFE0, 0x955E,
0xEFE2, 0xEFE3, 0x9561,
0xEFE4, 0xEFEC, 0x9564,
0xEFEE, 0xEFF0, 0x9571,
0xF040, 0xF044, 0x9908,
0xF045, 0xF046, 0x990E,
0xF047, 0xF063, 0x9911,
0xF064, 0xF07E, 0x992F,
0xF080, 0xF089, 0x994A,
0xF08A, 0xF096, 0x9956,
0xF09A, 0xF09B, 0x9978,
0xF09E, 0xF09F, 0x9982,
0xF0B1, 0xF0B5, 0x9E28,
0xF0BB, 0xF0BC, 0x9E39,
0xF0BE, 0xF0BF, 0x9E41,
0xF0C1, 0xF0C4, 0x9E46,
0xF0C5, 0xF0C6, 0x9E4B,
0xF0CB, 0xF0CD, 0x9E5A,
0xF0D0, 0xF0D6, 0x9E66,
0xF0E1, 0xF0E2, 0x75B3,
0xF142, 0xF14C, 0x999A,
0xF14D, 0xF14E, 0x99A6,
0xF14F, 0xF17E, 0x99A9,
0xF180, 0xF1A0, 0x99D9,
0xF1B6, 0xF1B7, 0x7A78,
0xF1ED, 0xF1EF, 0x8025,
0xF240, 0xF27E, 0x99FA,
0xF280, 0xF2A0, 0x9A39,
0xF2A2, 0xF2A3, 0x988C,
0xF2A6, 0xF2A7, 0x989A,
0xF2A8, 0xF2A9, 0x989E,
0xF2AA, 0xF2AB, 0x98A1,
0xF2AC, 0xF2AD, 0x98A5,
0xF2CC, 0xF2CD, 0x86F1,
0xF2ED, 0xF2EE, 0x877D,
0xF340, 0xF351, 0x9A5A,
0xF355, 0xF356, 0x9A8D,
0xF357, 0xF358, 0x9A94,
0xF35B, 0xF361, 0x9AA9,
0xF362, 0xF365, 0x9AB2,
0xF368, 0xF36A, 0x9ABD,
0xF36B, 0xF36C, 0x9AC3,
0xF36D, 0xF371, 0x9AC6,
0xF372, 0xF375, 0x9ACD,
0xF377, 0xF37A, 0x9AD4,
0xF37B, 0xF37E, 0x9AD9,
0xF380, 0xF381, 0x9ADD,
0xF383, 0xF386, 0x9AE2,
0xF387, 0xF38A, 0x9AE7,
0xF38D, 0xF395, 0x9AF0,
0xF397, 0xF39D, 0x9AFC,
0xF39E, 0xF3A0, 0x9B04,
0xF3C0, 0xF3C1, 0x7F44,
0xF3C6, 0xF3C7, 0x7B03,
0xF3E5, 0xF3E6, 0x7BA6,
0xF3F6, 0xF3F7, 0x7BE5,
0xF441, 0xF446, 0x9B09,
0xF447, 0xF449, 0x9B10,
0xF44A, 0xF454, 0x9B14,
0xF455, 0xF457, 0x9B20,
0xF458, 0xF462, 0x9B24,
0xF463, 0xF464, 0x9B30,
0xF465, 0xF46C, 0x9B33,
0xF46D, 0xF470, 0x9B3D,
0xF472, 0xF474, 0x9B4A,
0xF477, 0xF478, 0x9B52,
0xF479, 0xF47E, 0x9B55,
0xF480, 0xF4A0, 0x9B5B,
0xF4A8, 0xF4A9, 0x8201,
0xF4AD, 0xF4AF, 0x8221,
0xF4B6, 0xF4B7, 0x8233,
0xF4C9, 0xF4CA, 0x7FAF,
0xF4D4, 0xF4D5, 0x7CBC,
0xF4D8, 0xF4D9, 0x7CCC,
0xF4FC, 0xF4FD, 0x914E,
0xF540, 0xF57E, 0x9B7C,
0xF580, 0xF5A0, 0x9BBB,
0xF5A6, 0xF5A7, 0x917D,
0xF5B0, 0xF5B1, 0x91A2,
0xF5B3, 0xF5B5, 0x91AD,
0xF5C5, 0xF5C6, 0x8DD6,
0xF5C9, 0xF5CA, 0x8DCE,
0xF5CE, 0xF5CF, 0x8DF7,
0xF5E4, 0xF5E5, 0x8E41,
0xF5E6, 0xF5E7, 0x8E51,
0xF640, 0xF67E, 0x9BDC,
0xF680, 0xF6A0, 0x9C1B,
0xF6B5, 0xF6BA, 0x9F85,
0xF6C0, 0xF6C1, 0x96BC,
0xF6D1, 0xF6D4, 0x9C85,
0xF6D8, 0xF6DA, 0x9C90,
0xF6DB, 0xF6DC, 0x9C94,
0xF6DD, 0xF6DE, 0x9C9A,
0xF6DF, 0xF6E4, 0x9C9E,
0xF6E5, 0xF6E9, 0x9CA5,
0xF6EB, 0xF6EC, 0x9CAD,
0xF6ED, 0xF6F4, 0x9CB0,
0xF6F5, 0xF6F8, 0x9CBA,
0xF6F9, 0xF6FC, 0x9CC4,
0xF6FD, 0xF6FE, 0x9CCA,
0xF740, 0xF77E, 0x9C3C,
0xF781, 0xF782, 0x9C7D,
0xF784, 0xF785, 0x9C83,
0xF786, 0xF787, 0x9C89,
0xF78B, 0xF78E, 0x9C96,
0xF794, 0xF798, 0x9CBE,
0xF799, 0xF79A, 0x9CC8,
0xF79B, 0xF79C, 0x9CD1,
0xF79D, 0xF79E, 0x9CDA,
0xF79F, 0xF7A0, 0x9CE0,
0xF7A1, 0xF7A5, 0x9CCC,
0xF7A6, 0xF7A8, 0x9CD3,
0xF7A9, 0xF7AB, 0x9CD7,
0xF7AC, 0xF7AD, 0x9CDC,
0xF7B2, 0xF7B3, 0x9791,
0xF7C5, 0xF7C6, 0x9ACB,
0xF7E1, 0xF7E2, 0x9EBD,
0xF7E5, 0xF7E6, 0x9E87,
0xF7EC, 0xF7EE, 0x9EDB,
0xF7FC, 0xF7FD, 0x9F3D,
0xF840, 0xF87E, 0x9CE3,
0xF880, 0xF8A0, 0x9D22,
0xF940, 0xF97E, 0x9D43,
0xF980, 0xF9A0, 0x9D82,
0xFA40, 0xFA7E, 0x9DA3,
0xFA80, 0xFAA0, 0x9DE2,
0xFB40, 0xFB5B, 0x9E03,
0xFB61, 0xFB62, 0x9E3B,
0xFB66, 0xFB68, 0x9E52,
0xFB6C, 0xFB6F, 0x9E5F,
0xFB71, 0xFB72, 0x9E6E,
0xFB74, 0xFB7D, 0x9E74,
0xFB81, 0xFB84, 0x9E83,
0xFB85, 0xFB86, 0x9E89,
0xFB87, 0xFB8C, 0x9E8C,
0xFB8D, 0xFB95, 0x9E94,
0xFB97, 0xFB9C, 0x9EA0,
0xFB9D, 0xFBA0, 0x9EA7,
0xFC40, 0xFC48, 0x9EAB,
0xFC49, 0xFC4B, 0x9EB5,
0xFC4C, 0xFC4D, 0x9EB9,
0xFC4F, 0xFC53, 0x9EBF,
0xFC54, 0xFC57, 0x9EC5,
0xFC58, 0xFC5A, 0x9ECA,
0xFC5C, 0xFC5D, 0x9ED2,
0xFC5E, 0xFC60, 0x9ED5,
0xFC61, 0xFC62, 0x9ED9,
0xFC65, 0xFC66, 0x9EE3,
0xFC69, 0xFC6C, 0x9EEB,
0xFC6D, 0xFC75, 0x9EF0,
0xFC78, 0xFC7E, 0x9EFF,
0xFC80, 0xFC84, 0x9F06,
0xFC87, 0xFC88, 0x9F11,
0xFC89, 0xFC8B, 0x9F14,
0xFC8D, 0xFC92, 0x9F1A,
0xFC94, 0xFC9C, 0x9F23,
0xFC9D, 0xFC9E, 0x9F2D,
0xFC9F, 0xFCA0, 0x9F30,
0xFD40, 0xFD44, 0x9F32,
0xFD48, 0xFD4C, 0x9F3F,
0xFD4D, 0xFD57, 0x9F45,
0xFD58, 0xFD7E, 0x9F52,
0xFD80, 0xFD85, 0x9F79,
0xFD86, 0xFD87, 0x9F81,
0xFD88, 0xFD93, 0x9F8D,
0xFD94, 0xFD96, 0x9F9C,
0xFD97, 0xFD9B, 0x9FA1,
0xFE40, 0xFE43, 0xFA0C,
0xFE45, 0xFE46, 0xFA13,
0xFE48, 0xFE4A, 0xFA1F,
0xFE4B, 0xFE4C, 0xFA23,
0xFE4D, 0xFE4F, 0xFA27,
0xFE50, 0xFEA0, 0xE815, // }}}
};
static const unsigned short * _initTrad2Simp_utf16()
{
unsigned short *gbk2utf16 = new unsigned short[0x8000];
for (unsigned short c = 0; c < sizeof(_gbk2utf16_2) / sizeof(short); c += 2)
gbk2utf16[_gbk2utf16_2[c] - 0x8000] = _gbk2utf16_2[c + 1];
for (unsigned short c = 0; c < sizeof(_gbk2utf16_3) / sizeof(short); c += 3)
for (unsigned short d = _gbk2utf16_3[c]; d <= _gbk2utf16_3[c + 1]; d ++)
gbk2utf16[d - 0x8000] = _gbk2utf16_3[c + 2] + d - _gbk2utf16_3[c];
static unsigned short t2s[0x10000];
for (unsigned short c = 1; c; c ++)
t2s[c] = c;
t2s[0] = 0;
for (unsigned short c = 0; c < sizeof(_tns) / sizeof(short); c += 2)
// do not convert GB2312 (Simplified Chinese)
if (!((_tns[c] >> 8) >= 0xA1 && (_tns[c] >> 8) < 0xF8
&& (_tns[c] & 0xFF) >= 0xA1))
t2s[gbk2utf16[_tns[c] - 0x8000]] = gbk2utf16[_tns[c + 1] - 0x8000];
delete []gbk2utf16;
return t2s;
}
static const unsigned short * _initTrad2Simp_gbk()
{
static unsigned short t2s[0x8000];
for (unsigned short c = 0; c < 0x8000; c ++)
t2s[c] = SWAPBYTE(c | 0x8000);
for (unsigned short c = 0; c < sizeof(_tns) / sizeof(short); c += 2)
// do not convert GB2312 (Simplified Chinese)
if (!((_tns[c] >> 8) >= 0xA1 && (_tns[c] >> 8) < 0xF8
&& (_tns[c] & 0xFF) >= 0xA1))
t2s[_tns[c] - 0x8000] = SWAPBYTE(_tns[c + 1]);
return t2s;
}
static const unsigned short * _initPlain_utf16()
{
static unsigned short plain[0x10000];
for (unsigned short c = 1; c; c ++)
plain[c] = c;
plain[0] = 0;
return plain;
}
static const unsigned short * _initPlain_gbk()
{
static unsigned short plain[0x8000];
for (unsigned short c = 0; c < 0x8000; c ++)
plain[c] = SWAPBYTE(c | 0x8000);
return plain;
}
static const char * _initUpper2Lower()
{
static char u2l[0x80];
for (unsigned short c = 0; c < 0x80; c ++)
if (c >= 'A' && c <= 'Z') u2l[c] = c + 'a' - 'A';
else u2l[c] = c;
return u2l;
}
static const char * _initLower2Upper()
{
static char l2u[0x80];
for (unsigned short c = 0; c < 0x80; c ++)
if (c >= 'a' && c <= 'z') l2u[c] = c + 'A' - 'a';
else l2u[c] = c;
return l2u;
}
static const char * _initPlain()
{
static char plain[0x80];
for (unsigned short c = 0; c < 0x80; c ++)
plain[c] = c;
return plain;
}
static const unsigned short * _initGbk2Utf16()
{
static unsigned short gbk2utf16[0x8000] = { 0 };
for (unsigned short c = 0; c < sizeof(_gbk2utf16_2) / sizeof(short); c += 2)
gbk2utf16[_gbk2utf16_2[c] - 0x8000] = _gbk2utf16_2[c + 1];
for (unsigned short c = 0; c < sizeof(_gbk2utf16_3) / sizeof(short); c += 3)
for (unsigned short d = _gbk2utf16_3[c]; d <= _gbk2utf16_3[c + 1]; d ++)
gbk2utf16[d - 0x8000] = _gbk2utf16_3[c + 2] + d - _gbk2utf16_3[c];
return gbk2utf16;
}
static const unsigned short * _initUtf162Gbk()
{
static unsigned short utf162gbk[0x10000] = { 0 };
for (unsigned short c = 0; c < sizeof(_gbk2utf16_2) / sizeof(short); c += 2)
utf162gbk[_gbk2utf16_2[c + 1]] = _gbk2utf16_2[c];
for (unsigned short c = 0; c < sizeof(_gbk2utf16_3) / sizeof(short); c += 3)
for (unsigned short d = _gbk2utf16_3[c]; d <= _gbk2utf16_3[c + 1]; d ++)
utf162gbk[_gbk2utf16_3[c + 2] + d - _gbk2utf16_3[c]] = d;
return utf162gbk;
}
static const unsigned short *_pTrad2Simp_gbk = _initTrad2Simp_gbk();
static const unsigned short *_pTrad2Simp_utf16 = _initTrad2Simp_utf16();
static const unsigned short *_pPlain_gbk = _initPlain_gbk();
static const unsigned short *_pPlain_utf16 = _initPlain_utf16();
static const char *_pUpper2Lower = _initUpper2Lower();
static const char *_pLower2Upper = _initLower2Upper();
static const char *_pPlain = _initPlain();
static const unsigned short *_pGbk2Utf16 = _initGbk2Utf16();
static const unsigned short *_pUtf162Gbk = _initUtf162Gbk();
void strnormalize_utf8(char *text, unsigned options)
{
const char *pTransTable =
(options & SNO_TO_LOWER) ? _pUpper2Lower : (
(options & SNO_TO_UPPER) ? _pLower2Upper :
_pPlain);
const unsigned short *pTransTable_utf16 =
(options & SNO_TO_SIMPLIFIED) ? _pTrad2Simp_utf16 : _pPlain_utf16;
unsigned i_from = 0, i_to = 0;
while (text[i_from])
{
if ((text[i_from] & 0x80) == 0)
{
text[i_to ++] = pTransTable[text[i_from ++]];
}
else if ((text[i_from] & 0xF0) == 0xE0
&& (text[i_from + 1] & 0xC0) == 0x80
&& (text[i_from + 2] & 0xC0) == 0x80)
{
unsigned short utf16 = (unsigned short)(text[i_from] & 0x0F) << 12
| (unsigned short)(text[i_from + 1] & 0x3F) << 6
| (unsigned short)(text[i_from + 2] & 0x3F);
if (options & SNO_TO_HALF)
{
if (utf16 == 0x3000)
utf16 = ' ';
else if (utf16 > 0xFF00 && utf16 < 0xFF60)
utf16 = ' ' + (utf16 & 0xFF);
}
if (utf16 < 0x80)
{
utf16 = pTransTable[utf16];
text[i_to ++] = utf16;
}
else
{
utf16 = pTransTable_utf16[utf16];
text[i_to ++] = (utf16 & 0xF000) >> 12 | 0xE0;
text[i_to ++] = (utf16 & 0x0FC0) >> 6 | 0x80;
text[i_to ++] = (utf16 & 0x003F) | 0x80;
}
i_from += 3;
}
else if ((text[i_from] & 0xE0) == 0xC0
&& (text[i_from + 1] & 0xC0) == 0x80)
{
text[i_to ++] = text[i_from ++];
text[i_to ++] = text[i_from ++];
}
else
{
text[i_to ++] = text[i_from ++];
}
}
text[i_to] = 0;
}
void strnormalize_utf8(string &text, unsigned options)
{
const char *pTransTable =
(options & SNO_TO_LOWER) ? _pUpper2Lower : (
(options & SNO_TO_UPPER) ? _pLower2Upper :
_pPlain);
const unsigned short *pTransTable_utf16 =
(options & SNO_TO_SIMPLIFIED) ? _pTrad2Simp_utf16 : _pPlain_utf16;
unsigned i_from = 0, i_to = 0;
while (i_from < text.size())
{
if ((text[i_from] & 0x80) == 0)
{
text[i_to ++] = pTransTable[text[i_from ++]];
}
else if ((text[i_from] & 0xF0) == 0xE0
&& (text[i_from + 1] & 0xC0) == 0x80
&& (text[i_from + 2] & 0xC0) == 0x80)
{
unsigned short utf16 = (unsigned short)(text[i_from] & 0x0F) << 12
| (unsigned short)(text[i_from + 1] & 0x3F) << 6
| (unsigned short)(text[i_from + 2] & 0x3F);
if (options & SNO_TO_HALF)
{
if (utf16 == 0x3000)
utf16 = ' ';
else if (utf16 > 0xFF00 && utf16 < 0xFF60)
utf16 = ' ' + (utf16 & 0xFF);
}
if (utf16 < 0x80)
{
utf16 = pTransTable[utf16];
text[i_to ++] = utf16;
}
else
{
utf16 = pTransTable_utf16[utf16];
text[i_to ++] = (utf16 & 0xF000) >> 12 | 0xE0;
text[i_to ++] = (utf16 & 0x0FC0) >> 6 | 0x80;
text[i_to ++] = (utf16 & 0x003F) | 0x80;
}
i_from += 3;
}
else if ((text[i_from] & 0xE0) == 0xC0
&& (text[i_from + 1] & 0xC0) == 0x80)
{
text[i_to ++] = text[i_from ++];
text[i_to ++] = text[i_from ++];
}
else
{
text[i_to ++] = text[i_from ++];
}
}
text.resize(i_to);
}
void strnormalize_gbk(char *text, unsigned options)
{
const char *pTransTable =
(options & SNO_TO_LOWER) ? _pUpper2Lower : (
(options & SNO_TO_UPPER) ? _pLower2Upper :
_pPlain);
const unsigned short *pTransTable_gbk =
(options & SNO_TO_SIMPLIFIED) ? _pTrad2Simp_gbk : _pPlain_gbk;
unsigned i_from = 0, i_to = 0, flag = 0;
for (; text[i_from]; i_from ++)
{
if (flag && (options & SNO_TO_HALF))
{
if ((unsigned char)text[i_from - 1] == 0xA1
&& (unsigned char)text[i_from] == 0xA1)
{
flag = 0;
text[i_from] = ' ';
}
else if ((unsigned char)text[i_from - 1] == 0xA3
&& text[i_from] < 0 && text[i_from] > char(0xA0))
{
flag = 0;
text[i_from] &= ~0x80;
}
}
if (flag)
{
flag = 0;
unsigned short tmp =
pTransTable_gbk[COMPBYTE(text[i_from - 1], text[i_from]) & ~0x8000];
text[i_to ++] = tmp & 0xFF;
text[i_to ++] = tmp >> 8;
}
else if (text[i_from] < 0)
flag = 1;
else
text[i_to ++] = pTransTable[text[i_from]];
}
if (flag)
text[i_to ++] = text[i_from - 1];
text[i_to] = 0;
}
void strnormalize_gbk(string &text, unsigned options)
{
const char *pTransTable =
(options & SNO_TO_LOWER) ? _pUpper2Lower : (
(options & SNO_TO_UPPER) ? _pLower2Upper :
_pPlain);
const unsigned short *pTransTable_gbk =
(options & SNO_TO_SIMPLIFIED) ? _pTrad2Simp_gbk : _pPlain_gbk;
unsigned i_from = 0, i_to = 0, flag = 0;
for (; i_from < text.size(); i_from ++)
{
if (flag && (options & SNO_TO_HALF))
{
if ((unsigned char)text[i_from - 1] == 0xA1
&& (unsigned char)text[i_from] == 0xA1)
{
flag = 0;
text[i_from] = ' ';
}
else if ((unsigned char)text[i_from - 1] == 0xA3
&& text[i_from] < 0 && text[i_from] > char(0xA0))
{
flag = 0;
text[i_from] &= ~0x80;
}
}
if (flag)
{
flag = 0;
unsigned short tmp =
pTransTable_gbk[COMPBYTE(text[i_from - 1], text[i_from]) & ~0x8000];
text[i_to ++] = tmp & 0xFF;
text[i_to ++] = tmp >> 8;
}
else if (text[i_from] < 0)
flag = 1;
else
text[i_to ++] = pTransTable[text[i_from]];
}
if (flag)
text[i_to ++] = text[i_from - 1];
text.resize(i_to);
}
const string gbk_to_utf8(const std::string &text)
{
char result[text.size() * 3 + 1];
unsigned i_from = 0, i_to = 0, flag = 0;
for (; i_from < text.size(); i_from ++)
{
if (flag)
{
flag = 0;
unsigned short tmp =
_pGbk2Utf16[COMPBYTE(text[i_from - 1], text[i_from]) & ~0x8000];
if (tmp == 0)
continue;
else if (tmp >= 0x800)
{
result[i_to ++] = 0xE0 | (tmp >> 12);
result[i_to ++] = 0x80 | ((tmp >> 6) & 0x3F);
result[i_to ++] = 0x80 | (tmp & 0x3F);
}
else if (tmp >= 0x80)
{
result[i_to ++] = 0xC0 | (tmp >> 6);
result[i_to ++] = 0x80 | (tmp & 0x3F);
}
else
{
result[i_to ++] = tmp;
}
}
else if (text[i_from] < 0)
flag = 1;
else
result[i_to ++] = text[i_from];
}
result[i_to] = 0;
return result;
}
const string utf8_to_gbk(const std::string &text)
{
char result[text.size() * 2 + 1];
unsigned i_from = 0, i_to = 0;
for (; i_from < text.size(); )
{
if ((unsigned char)text[i_from] < 0x80)
{
result[i_to ++] = text[i_from ++];
}
else if ((unsigned char)text[i_from] < 0xC2)
{
i_from ++;
}
else if ((unsigned char)text[i_from] < 0xE0)
{
if (i_from >= text.size() - 1) break;
unsigned short tmp = _pUtf162Gbk[
((text[i_from] & 0x1F) << 6) | text[i_from + 1] & 0x3F];
if (tmp)
{
result[i_to ++] = tmp >> 8;
result[i_to ++] = tmp & 0xFF;
}
i_from += 2;
}
else if ((unsigned char)text[i_from] < 0xF0)
{
if (i_from >= text.size() - 2) break;
unsigned short tmp = _pUtf162Gbk[((text[i_from] & 0x0F) << 12)
| ((text[i_from + 1] & 0x3F) << 6) | text[i_from + 2] & 0x3F];
if (tmp)
{
result[i_to ++] = tmp >> 8;
result[i_to ++] = tmp & 0xFF;
}
i_from += 3;
}
else
{
i_from += 4;
}
}
result[i_to] = 0;
return result;
}
bool is_gbk(unsigned short code)
{
return code >= 0x8000 && _pGbk2Utf16[code - 0x8000] != 0;
}
/*
#include <iostream>
int main(int argc, char **argv)
{
string line;
if (argc > 1 && argv[1] == string("-g"))
{
while (getline(cin, line))
cout << utf8_to_gbk(gbk_to_utf8(line)) << endl;
}
else if (argc > 1 && argv[1] == string("-u"))
{
while (getline(cin, line))
cout << gbk_to_utf8(utf8_to_gbk(line)) << endl;
}
else
{
unsigned options = SNO_TO_LOWER | SNO_TO_HALF;
if (argc > 1) options = atoi(argv[1]);
while (getline(cin, line))
{
strnormalize_utf8(line, options);
cout << line << endl;
}
}
return 0;
}
*/
// vim: foldmethod=marker
}
| [
"luoyan5@163.com"
] | luoyan5@163.com |
3fef7d1741903d322baa2dc979948ab5df0be32a | 40f77053c8ef35f9044891a48ed47608b0eb6635 | /Fiction_Out.cpp | c3d124dfd62b16761e3dda103edbea4505c68055 | [] | no_license | Kandyba-Kat/LR8 | dc67624a5163602e3c0e41c9ca52f8e9e53d7e20 | f0b1e7636ff83a04697f823c5e80ba6a269949dd | refs/heads/main | 2023-04-11T13:43:03.104548 | 2021-04-21T04:52:19 | 2021-04-21T04:52:19 | 360,036,219 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 153 | cpp | #include <fstream>
#include "Fiction.h"
namespace myLab {
void Out(Fiction& f, ofstream& ofst)
{
ofst << ", Director's name = " << f.mDirector;
}
} | [
"kandyba.ekaterina2012@yandex.ru"
] | kandyba.ekaterina2012@yandex.ru |
8c1fedb900f5548bc7b97985cb583c95788ff894 | ede6bb95b22e8b2315fea50af2415691b17519a7 | /crtp/example-6/C.h | c7e770d11178cf8c9cf3461be93c8a98fd388673 | [
"MIT"
] | permissive | gusenov/examples-cpp | d3880c1bd436b7d0b8d4955266a580602a378f56 | f2e60b6d3d61cfcb7cc69aba1081162ce2de5193 | refs/heads/master | 2022-10-20T09:13:56.065787 | 2022-10-12T15:48:13 | 2022-10-12T15:48:13 | 154,664,278 | 21 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 129 | h | #ifndef C_H
#define C_H
#include "B.h"
class C : public B<C> {
void foo(...) {
std::cout << "C::foo()\n";
}
};
#endif
| [
"gusenov@live.ru"
] | gusenov@live.ru |
55125bf497eb66998854511fa3ab9865ae8fb454 | a909df0ba2abf695df4a7d15350312d4c6463c48 | /UVa/929_2.cpp | e1b2b21ae3ad774cba9134aff082c3987557e067 | [] | no_license | SayaUrobuchi/uvachan | 1dadd767a96bb02c7e9449c48e463847480e98ec | c213f5f3dcfc72376913a21f9abe72988a8127a1 | refs/heads/master | 2023-07-23T03:59:50.638063 | 2023-07-16T04:31:23 | 2023-07-16T04:31:23 | 94,064,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,393 | cpp | #include <stdio.h>
#include <string.h>
int n, m, len, st, nx, ny, lx, ly, rx, ry;
char map[1000][1000];
int dis[1000][1000];
int heapx[600000], heapy[600000];
int wayx[4] = {0, 1, 0, -1};
int wayy[4] = {1, 0, -1, 0};
char str[5000];
int valid(int x, int y)
{
return x > -1 && x < n && y > -1 && y < m;
}
void swap(int *p, int *q)
{
st = *p;
*p = *q;
*q = st;
}
void heapdown(int now)
{
int left, right;
left = now + now;
right = left + 1;
if(left >= len)
{
return;
}
for(; left<len; left=now+now, right=left+1)
{
nx = heapx[now];
ny = heapy[now];
lx = heapx[left];
ly = heapy[left];
rx = heapx[right];
ry = heapy[right];
if(right >= len || dis[lx][ly] < dis[rx][ry])
{
if(dis[nx][ny] > dis[lx][ly])
{
swap(heapx+now, heapx+left);
swap(heapy+now, heapy+left);
now = left;
}
else
{
return;
}
}
else
{
if(dis[nx][ny] > dis[rx][ry])
{
swap(heapx+now, heapx+right);
swap(heapy+now, heapy+right);
now = right;
}
else
{
return;
}
}
}
}
void heapup(int now)
{
int temp;
temp = now / 2;
if(!temp)
{
return;
}
for(; temp; temp=now/2)
{
nx = heapx[now];
ny = heapy[now];
lx = heapx[temp];
ly = heapy[temp];
if(dis[nx][ny] < dis[lx][ly])
{
swap(heapx+now, heapx+temp);
swap(heapy+now, heapy+temp);
now = temp;
}
else
{
return;
}
}
}
void push(int x, int y, int value)
{
dis[x][y] = value;
heapx[len] = x;
heapy[len] = y;
heapup(len++);
}
int pop()
{
if(len == 1)
{
return 0;
}
heapx[0] = heapx[1];
heapy[0] = heapy[1];
heapx[1] = heapx[--len];
heapy[1] = heapy[len];
heapdown(1);
return 1;
}
int main()
{
int count, i, j, k, v, x, y, tx, ty;
scanf("%d", &count);
while(count--)
{
scanf("%d%d", &n, &m);
gets(str);
for(i=0; i<n; i++)
{
gets(str);
for(j=0, k=0; j<m; j++, k+=2)
{
map[i][j] = str[k] - 48;
dis[i][j] = 2147483647;
}
}
len = 1;
push(0, 0, map[0][0]);
for(; pop(); )
{
x = heapx[0];
y = heapy[0];
if(x == n-1 && y == m-1)
{
break;
}
if(dis[x][y] != -1)
{
for(k=0; k<4; k++)
{
tx = x + wayx[k];
ty = y + wayy[k];
if(valid(tx, ty))
{
if(dis[tx][ty] > dis[x][y] + map[tx][ty])
{
push(tx, ty, dis[x][y]+map[tx][ty]);
}
}
}
dis[x][y] = -1;
}
}
printf("%d\n", dis[x][y]);
}
return 0;
}
| [
"sa072688@gmail.com"
] | sa072688@gmail.com |
b5ca2cfa1e2daa1de79baf92609f0391e0d59a34 | 0b63fa8325233e25478b76d0b4a9a6ee3070056d | /src/appleseed/renderer/meta/benchmarks/benchmark_ewa.cpp | c2658dc50ca0edb728f5b64008c628842be4ec33 | [
"MIT"
] | permissive | hipopotamo-hipotalamo/appleseed | e8c61ccec64baf01b6aeb3cde4dd3031d37ece17 | eaf07e3e602218a35711e7495ac633ce210c6078 | refs/heads/master | 2020-12-07T02:39:27.454003 | 2013-10-29T13:10:59 | 2013-10-29T13:10:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,317 | cpp |
//
// This source file is part of appleseed.
// Visit http://appleseedhq.net/ for additional information and resources.
//
// This software is released under the MIT license.
//
// Copyright (c) 2010-2013 Francois Beaune, Jupiter Jazz Limited
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// appleseed.renderer headers.
#include "renderer/kernel/atomkraft/ewa.h"
#include "renderer/kernel/atomkraft/textureobject.h"
// appleseed.foundation headers.
#include "foundation/image/color.h"
#include "foundation/image/image.h"
#include "foundation/utility/benchmark.h"
// Standard headers.
#include <cstddef>
using namespace foundation;
using namespace renderer;
BENCHMARK_SUITE(AtomKraft_EWA)
{
struct Fixture
{
static const size_t TextureWidth = 2048;
static const size_t TextureHeight = 2048;
Image m_texture;
TextureObject m_texture_object;
ak::EWAFilter<4, TextureObject> m_filter;
Color4f m_result;
Fixture()
: m_texture(TextureWidth, TextureHeight, TextureWidth, TextureHeight, 4, PixelFormatFloat)
, m_texture_object(m_texture)
{
}
};
BENCHMARK_CASE_F(Filter_NoClamping, Fixture)
{
m_filter.filter(
m_texture_object,
1020.0f, // center x
1020.0f, // center y
10.0f, // du/dx
0.0f, // du/dy
0.0f, // dv/dx
10.0f, // dv/dy
100.0f, // max radius
&m_result[0]);
}
BENCHMARK_CASE_F(Filter_Clamping, Fixture)
{
m_filter.filter(
m_texture_object,
1020.0f, // center x
1020.0f, // center y
10.0f, // du/dx
0.0f, // du/dy
0.0f, // dv/dx
10.0f, // dv/dy
5.0f, // max radius
&m_result[0]);
}
}
| [
"beaune@aist.enst.fr"
] | beaune@aist.enst.fr |
831389ec89dc067b17f4aeea25c0657de08ae3c7 | 6dabadec787db7e84d61892a3222b3fdb7734ec8 | /libnoise-helpers/planetmaps/granite.cpp | 8ee11f0819206e1fc59b3164dedb504ede4ce791 | [] | no_license | maxlambertini/Warp2010 | da378062eb1192ba59e14b91859d15513cab0225 | db76ddedd7a9180ad964bca65a9860bdcf1fc475 | refs/heads/master | 2021-01-06T20:46:29.252571 | 2019-08-25T22:05:30 | 2019-08-25T22:05:30 | 4,446,271 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,781 | cpp | #include "granite.h"
using namespace maps;
Granite::Granite()
{
}
void Granite::generate() {
module::Billow primaryGranite;
primaryGranite.SetSeed (_seed);
primaryGranite.SetFrequency (7.0 * ( 0.8 + SSGX::floatRand()*0.4));
primaryGranite.SetPersistence (0.625 * ( 0.8 + SSGX::floatRand()*0.4));
primaryGranite.SetLacunarity (2.18359375 * ( 0.8 + SSGX::floatRand()*0.4));
primaryGranite.SetOctaveCount (6);
primaryGranite.SetNoiseQuality (QUALITY_STD);
// Use Voronoi polygons to produce the small grains for the granite texture.
module::Voronoi baseGrains;
baseGrains.SetSeed (1);
baseGrains.SetFrequency (16.0 * ( 0.8 + SSGX::floatRand()*0.4));
baseGrains.EnableDistance (true);
// Scale the small grain values so that they may be added to the base
// granite texture. Voronoi polygons normally generate pits, so apply a
// negative scaling factor to produce bumps instead.
module::ScaleBias scaledGrains;
scaledGrains.SetSourceModule (0, baseGrains);
scaledGrains.SetScale (-0.5);
scaledGrains.SetBias (0.0);
// Combine the primary granite texture with the small grain texture.
module::Add combinedGranite;
combinedGranite.SetSourceModule (0, primaryGranite);
combinedGranite.SetSourceModule (1, scaledGrains);
// Finally, perturb the granite texture to add realism.
module::Turbulence finalGranite;
finalGranite.SetSourceModule (0, combinedGranite);
finalGranite.SetSeed (_seed/2);
finalGranite.SetFrequency (4.0 * ( 0.8 + SSGX::floatRand()*0.4));
finalGranite.SetPower (1.0 / 8.0);
finalGranite.SetRoughness (6);
utils::NoiseMapBuilderSphere sphere;
utils::NoiseMap noiseMap;
sphere.SetBounds (-90.0, 90.0, -180.0, 180.0); // degrees
sphere.SetDestSize (_sizeX, _sizeY);
sphere.SetSourceModule(finalGranite);
sphere.SetDestNoiseMap (noiseMap);
sphere.Build ();
utils::RendererImage textureRenderer;
textureRenderer.ClearGradient ();
auto steps = 2 + SSGX::d6();
auto colorMap = ColorOps::randomGradient(steps,13);
QMapIterator<double, QColor> i(colorMap);
while (i.hasNext()) {
i.next();
textureRenderer.AddGradientPoint(i.key(), QColorToColor(i.value()));
}
textureRenderer.AddGradientPoint(1.00,QColorToColor(ColorOps::randomColor()));
// Set up us the texture renderer and pass the noise map to it.
textureRenderer.SetSourceNoiseMap (noiseMap);
textureRenderer.SetDestImage (m_image);
textureRenderer.EnableLight (true);
textureRenderer.SetLightElev (45);
textureRenderer.SetLightContrast (0.15);
textureRenderer.SetLightBrightness (3.0);
// Render the texture.
textureRenderer.Render ();
emit imageCreated("Granite");
}
| [
"maxl@mr-finch.lamboz.priv"
] | maxl@mr-finch.lamboz.priv |
aea7fddde29975df25b31fa8d5f828fcd1f923f2 | acc2f5336d768a7d86dbd2eec441283cfd11d52d | /src/Core/GCUseBonusPointFail.h | 0d59fd866ff7586a3063b5f9b542e4818a0ce3ed | [] | no_license | stevexk/server | 86df9e8c2448ad97db9c3ab86820beec507ef092 | 4ddb6e7cfa510bb13ccd87f56db008aa1be1baad | refs/heads/master | 2020-01-23T22:00:57.359964 | 2015-09-18T14:58:27 | 2015-09-18T14:58:27 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 2,571 | h | //////////////////////////////////////////////////////////////////////
//
// Filename : GCUseBonusPointFail.h
// Written By : crazydog
// Description :
//
//////////////////////////////////////////////////////////////////////
#ifndef __GC_USE_BONUS_POINT_FAIL_H__
#define __GC_USE_BONUS_POINT_FAIL_H__
// include files
#include "Packet.h"
#include "PacketFactory.h"
//////////////////////////////////////////////////////////////////////
//
// class GCUseBonusPointFail;
//
//////////////////////////////////////////////////////////////////////
class GCUseBonusPointFail : public Packet {
public :
// constructor
GCUseBonusPointFail() throw() {}
~GCUseBonusPointFail() {};
public :
// ์
๋ ฅ์คํธ๋ฆผ(๋ฒํผ)์ผ๋ก๋ถํฐ ๋ฐ์ดํ๋ฅผ ์ฝ์ด์ ํจํท์ ์ด๊ธฐํํ๋ค.
void read(SocketInputStream & iStream) throw(ProtocolException, Error);
// ์ถ๋ ฅ์คํธ๋ฆผ(๋ฒํผ)์ผ๋ก ํจํท์ ๋ฐ์ด๋๋ฆฌ ์ด๋ฏธ์ง๋ฅผ ๋ณด๋ธ๋ค.
void write(SocketOutputStream & oStream) const throw(ProtocolException, Error);
// execute packet's handler
void execute(Player* pPlayer) throw(ProtocolException, Error);
// get packet id
PacketID_t getPacketID() const throw() { return PACKET_GC_USE_BONUS_POINT_FAIL; }
// get packet's body size
PacketSize_t getPacketSize() const throw() { return 0; }
// get packet's name
string getPacketName() const throw() { return "GCUseBonusPointFail"; }
// get packet's debug string
string toString() const throw();
public :
private :
};
//////////////////////////////////////////////////////////////////////
//
// class GCUseBonusPointFailFactory;
//
// Factory for GCUseBonusPointFail
//
//////////////////////////////////////////////////////////////////////
class GCUseBonusPointFailFactory : public PacketFactory {
public :
// create packet
Packet* createPacket() throw() { return new GCUseBonusPointFail(); }
// get packet name
string getPacketName() const throw() { return "GCUseBonusPointFail"; }
// get packet id
PacketID_t getPacketID() const throw() { return Packet::PACKET_GC_USE_BONUS_POINT_FAIL; }
// get packet's max body size
PacketSize_t getPacketMaxSize() const throw() { return 0; }
};
//////////////////////////////////////////////////////////////////////
//
// class GCUseBonusPointFailHandler;
//
//////////////////////////////////////////////////////////////////////
class GCUseBonusPointFailHandler {
public :
// execute packet's handler
static void execute(GCUseBonusPointFail* pPacket, Player* pPlayer) throw(Error);
};
#endif
| [
"tiancaiamao@gmail.com"
] | tiancaiamao@gmail.com |
ca6e1ab30348bf826e6e35adb1a462d104f96bbe | 70450f0c551adf47b450468e424f4f90bebfb58d | /MuonGun/private/pybindings/Flux.cxx | c21f0ca25c53894dfd0170829537c88ccc0a0c65 | [
"MIT"
] | permissive | hschwane/offline_production | ebd878c5ac45221b0631a78d9e996dea3909bacb | e14a6493782f613b8bbe64217559765d5213dc1e | refs/heads/master | 2023-03-23T11:22:43.118222 | 2021-03-16T13:11:22 | 2021-03-16T13:11:22 | 280,381,714 | 0 | 0 | MIT | 2020-07-17T09:20:29 | 2020-07-17T09:20:29 | null | UTF-8 | C++ | false | false | 1,363 | cxx | /** $Id: Flux.cxx 177771 2019-12-09 09:25:23Z jvansanten $
* @file
* @author Jakob van Santen <vansanten@wisc.edu>
*
* $Revision: 177771 $
* $Date: 2019-12-09 02:25:23 -0700 (Mon, 09 Dec 2019) $
*/
#include <MuonGun/Flux.h>
#include <icetray/python/gil_holder.hpp>
#include "utils.h"
namespace I3MuonGun {
using namespace boost::python;
class PyFlux : public Flux, public wrapper<Flux> {
public:
virtual double GetLog(double h, double ct, unsigned m) const override
{
detail::gil_holder lock;
return get_override("GetLog")(h, ct, m);
}
};
}
void register_Flux()
{
using namespace I3MuonGun;
using namespace boost::python;
class_<Flux, boost::shared_ptr<Flux>, boost::noncopyable>("Flux", no_init)
DEF("__call__", &Flux::operator(), (args("depth"), "cos_theta", "multiplicity"))
#define PROPS (MinMultiplicity)(MaxMultiplicity)
BOOST_PP_SEQ_FOR_EACH(WRAP_PROP, Flux, PROPS)
#undef PROPS
;
class_<SplineFlux, bases<Flux> >("SplineFlux", init<const std::string&, const std::string&>())
;
class_<BMSSFlux, bases<Flux> >("BMSSFlux")
;
class_<PyFlux, boost::noncopyable>("FluxBase")
DEF("__call__", &Flux::operator(), (args("depth"), "cos_theta", "multiplicity"))
#define PROPS (MinMultiplicity)(MaxMultiplicity)
BOOST_PP_SEQ_FOR_EACH(WRAP_PROP, Flux, PROPS)
#undef PROPS
;
}
| [
"aolivas@umd.edu"
] | aolivas@umd.edu |
9e98b2511c5000df58b6a580b73e890f83fb65d1 | fa8d6d7d2c30de360c4f0bbcaa59167fcd582a03 | /THACO/thaco_translator.cpp | c31f76dc2f787a45e8062723699e51743a0f0595 | [] | no_license | JodsintZ/roadtotoi | 0a699b5cbafa577696d0d20b3f7c977914c6b751 | e336227d34392af379632cb40d449727539976d5 | refs/heads/master | 2023-07-16T12:23:06.194672 | 2021-08-31T11:35:16 | 2021-08-31T11:35:16 | 212,324,761 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 668 | cpp | #include <bits/stdc++.h>
#define long long long
using namespace std;
const int N = 1e5 + 5;
int n, m, a[N], chk[N], tmp, ans;
vector<pii> b;
priority_queue<int> pr;
int main() {
scanf("%d %d", &n, &m);
for(int i = 0; i <n; i++) {
scanf("%d", a + i);
}
for(int i = 0; i < m; i++ ) {
scanf("%d", &tmp);
b.emplace_back(tmp, i);
}
for(int i = 0; i < n; i++) {
int cnt = 0;
if(chk[i]) continue;
chk[i] = true;
tmp = a[i];
while(69) {
t2 = a[a[i]];
cnt++;
if(t2 == tmp) break;
}
pr.emplace_back(cnt);
}
return 0;
} | [
"jodsint@gmail.com"
] | jodsint@gmail.com |
f5847b159b4f19d9a3c5da45d90ee9a25aa60832 | 7e90a1f8280618b97729d0b49b80c6814d0466e2 | /workspace_pc/catkin_ws/devel_isolated/gazebo_msgs/include/gazebo_msgs/JointRequestResponse.h | d49b80ecf7cb3f8ff6b8f4b21e06c26b5653a5f9 | [] | no_license | IreneYIN7/Map-Tracer | 91909f4649a8b65afed56ae3803f0c0602dd89ff | cbbe9acf067757116ec74c3aebdd672fd3df62ed | refs/heads/master | 2022-04-02T09:53:15.650365 | 2019-12-19T07:31:31 | 2019-12-19T07:31:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,163 | h | // Generated by gencpp from file gazebo_msgs/JointRequestResponse.msg
// DO NOT EDIT!
#ifndef GAZEBO_MSGS_MESSAGE_JOINTREQUESTRESPONSE_H
#define GAZEBO_MSGS_MESSAGE_JOINTREQUESTRESPONSE_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace gazebo_msgs
{
template <class ContainerAllocator>
struct JointRequestResponse_
{
typedef JointRequestResponse_<ContainerAllocator> Type;
JointRequestResponse_()
{
}
JointRequestResponse_(const ContainerAllocator& _alloc)
{
(void)_alloc;
}
typedef boost::shared_ptr< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> const> ConstPtr;
}; // struct JointRequestResponse_
typedef ::gazebo_msgs::JointRequestResponse_<std::allocator<void> > JointRequestResponse;
typedef boost::shared_ptr< ::gazebo_msgs::JointRequestResponse > JointRequestResponsePtr;
typedef boost::shared_ptr< ::gazebo_msgs::JointRequestResponse const> JointRequestResponseConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace gazebo_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
// {'sensor_msgs': ['/opt/ros/melodic/share/sensor_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'trajectory_msgs': ['/opt/ros/melodic/share/trajectory_msgs/cmake/../msg'], 'gazebo_msgs': ['/home/gse5/catkin_ws/src/gazebo_ros_pkgs/gazebo_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
{
static const char* value()
{
return "d41d8cd98f00b204e9800998ecf8427e";
}
static const char* value(const ::gazebo_msgs::JointRequestResponse_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd41d8cd98f00b204ULL;
static const uint64_t static_value2 = 0xe9800998ecf8427eULL;
};
template<class ContainerAllocator>
struct DataType< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
{
static const char* value()
{
return "gazebo_msgs/JointRequestResponse";
}
static const char* value(const ::gazebo_msgs::JointRequestResponse_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
{
static const char* value()
{
return "\n"
"\n"
;
}
static const char* value(const ::gazebo_msgs::JointRequestResponse_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream&, T)
{}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct JointRequestResponse_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::gazebo_msgs::JointRequestResponse_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream&, const std::string&, const ::gazebo_msgs::JointRequestResponse_<ContainerAllocator>&)
{}
};
} // namespace message_operations
} // namespace ros
#endif // GAZEBO_MSGS_MESSAGE_JOINTREQUESTRESPONSE_H
| [
"sh9339@outlook.com"
] | sh9339@outlook.com |
1eaa4f95c85f6adf114a5c1f7dbca4bc458b5855 | aaab34e615cf2bd0909b7306164a6707e106fa38 | /ubuntu3/clientcout_2.cpp | 1bb708b6bdbd2e8ee9350d209fe4da757dfc3763 | [] | no_license | cyerrajodu0616/Des-Cracking | e85cc7c03d3e0510c4ace68a6db5d320af91e5c6 | 5679611bcdcf9d737112165673fd6fd9ff7f7e09 | refs/heads/master | 2021-01-01T05:22:36.751290 | 2016-05-05T18:14:17 | 2016-05-05T18:14:17 | 58,151,285 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 36,965 | cpp | #include<math.h>
#include<stdio.h> //printf
#include<string> //strlen
#include<sys/socket.h> //socket
#include<arpa/inet.h> //inet_addr
#include<unistd.h>
#include <stdlib.h>
#include <iostream>
#include <bitset>
#include <cstring>
using namespace std;
int sock;
class Key_Generation{
public :
int round;
//unsigned char Sample_key[64]={'0','0','0','1','0','0','1','1','0','0','1','1','0','1','0','0','0','1','0','1','0','1','1','1','0','1','1','1','1','0','0','1','1','0','0','1','1','0','1','1','1','0','1','1','1','1','0','0','1','1','0','1','1','1','1','1','1','1','1','1','0','0','0','1'};
//char Text[64];
//char Text1[64];
char Cipher[64];
//char Cipher1[64];
char Sub_Key[17][48];
char Left_Key[28];
char Right_Key[28];
char Expansion_Key[48];
char Permutation_Choice_1[56];
char Permutation_Choice_2[48];
char initialPermutation[64];
char inversePermutation[64];
char Iterated_Key[58];
char inputString[64];// = {'0','0','0','0','0','0','0','1','0','0','1','0','0','0','1','1','0','1','0','0','0','1','0','1','0','1','1','0','0','1','1','1','1','0','0','0','1','0','0','1','1','0','1','0','1','0','1','1','1','1','0','0','1','1','0','1','1','1','1','0','1','1','1','1'};
char leftText[17][32];
char rightText[17][32];
char exprightText[17][48];
char permRight[32];
char ciphertext[64];
char inversepermutation[64];
void Permutation_Choice1(int rounds, char *Sample_key,int *flag);
void Shift_Bits(int round,char Left_Key[28],char Right_Key[28]);
void inputTextProcessing();
void expansion(int round,char rightText[17][32], char Sub_Key[17][48]);
void permutateRightSubText(char permRight[32]);
void readInitialDataFromFile(int flag);
};
/*
Permutation_Choice1 function will remove pairity bits and load them in pre-defined order
into Permutation_Choice_1 array.
After Permutation choice 1, 57th bit of key should be 1st bit of Permutation choice 1
Left: 57 49 41 33 25 17 9 1 58 50 42 34 26 18 10 2 59 51 43 35 27 19 11 3 60 52 44 36
Right: 63 55 47 39 31 23 15 7 62 54 46 38 30 22 14 6 61 53 45 37 29 21 13 5 28 20 12 4
-------------------------------------------------------------------------------------------
AS array index is started from 0 we can consider this as 1, so 57 bit will be at 56th position of key
*/
void Key_Generation::Permutation_Choice1(int rounds, char *Sample_key,int *flag)
{
// for checking whether program fouund key or not
*flag =0;
Permutation_Choice_1[0]=Sample_key[57-1];
Permutation_Choice_1[1]=Sample_key[49-1];
Permutation_Choice_1[2]=Sample_key[41-1];
Permutation_Choice_1[3]=Sample_key[33-1];
Permutation_Choice_1[4]=Sample_key[25-1];
Permutation_Choice_1[5]=Sample_key[17-1];
Permutation_Choice_1[6]=Sample_key[9-1];
Permutation_Choice_1[7]=Sample_key[1-1];
Permutation_Choice_1[8]=Sample_key[58-1];
Permutation_Choice_1[9]=Sample_key[50-1];
Permutation_Choice_1[10]=Sample_key[42-1];
Permutation_Choice_1[11]=Sample_key[34-1];
Permutation_Choice_1[12]=Sample_key[26-1];
Permutation_Choice_1[13]=Sample_key[18-1];
Permutation_Choice_1[14]=Sample_key[10-1];
Permutation_Choice_1[15]=Sample_key[2-1];
Permutation_Choice_1[16]=Sample_key[59-1];
Permutation_Choice_1[17]=Sample_key[51-1];
Permutation_Choice_1[18]=Sample_key[43-1];
Permutation_Choice_1[19]=Sample_key[35-1];
Permutation_Choice_1[20]=Sample_key[27-1];
Permutation_Choice_1[21]=Sample_key[19-1];
Permutation_Choice_1[22]=Sample_key[11-1];
Permutation_Choice_1[23]=Sample_key[3-1];
Permutation_Choice_1[24]=Sample_key[60-1];
Permutation_Choice_1[25]=Sample_key[52-1];
Permutation_Choice_1[26]=Sample_key[44-1];
Permutation_Choice_1[27]=Sample_key[36-1];
Permutation_Choice_1[28]=Sample_key[63-1];
Permutation_Choice_1[29]=Sample_key[55-1];
Permutation_Choice_1[30]=Sample_key[47-1];
Permutation_Choice_1[31]=Sample_key[39-1];
Permutation_Choice_1[32]=Sample_key[31-1];
Permutation_Choice_1[33]=Sample_key[23-1];
Permutation_Choice_1[34]=Sample_key[15-1];
Permutation_Choice_1[35]=Sample_key[7-1];
Permutation_Choice_1[36]=Sample_key[62-1];
Permutation_Choice_1[37]=Sample_key[54-1];
Permutation_Choice_1[38]=Sample_key[46-1];
Permutation_Choice_1[39]=Sample_key[38-1];
Permutation_Choice_1[40]=Sample_key[30-1];
Permutation_Choice_1[41]=Sample_key[22-1];
Permutation_Choice_1[42]=Sample_key[14-1];
Permutation_Choice_1[43]=Sample_key[6-1];
Permutation_Choice_1[44]=Sample_key[61-1];
Permutation_Choice_1[45]=Sample_key[53-1];
Permutation_Choice_1[46]=Sample_key[45-1];
Permutation_Choice_1[47]=Sample_key[37-1];
Permutation_Choice_1[48]=Sample_key[29-1];
Permutation_Choice_1[49]=Sample_key[21-1];
Permutation_Choice_1[50]=Sample_key[13-1];
Permutation_Choice_1[51]=Sample_key[5-1];
Permutation_Choice_1[52]=Sample_key[28-1];
Permutation_Choice_1[53]=Sample_key[20-1];
Permutation_Choice_1[54]=Sample_key[12-1];
Permutation_Choice_1[55]=Sample_key[4-1];
for(int i=0;i<28;i++)
{
Left_Key[i]=Permutation_Choice_1[i];
}
for(int i=28;i<56;i++)
{
Right_Key[i-28]=Permutation_Choice_1[i];
}
// processing input string to divide into two halfs
inputTextProcessing();
//ROUNDS
for(int i=1;i<=rounds;i++)
{
Shift_Bits(i,Left_Key,Right_Key);
// subkeys finding
for (int j=0;j<48;j++)
{
Sub_Key[i][j] = Permutation_Choice_2[j];
}
// Text processing
expansion(i,rightText,Sub_Key);
// xor with lefttext
for (int p=0;p<32;p++)
{
if (permRight[p] == leftText[i-1][p])
{
rightText[i][p]= '0';
}
else
{
rightText[i][p]= '1';
}
}
// Copying Right half to left one
for(int j=0;j<32;j++)
{
leftText[i][j]=rightText[i-1][j];
}
}
for (int i=0;i<32;i++)
{
ciphertext[i]=rightText[16][i];
}
for (int i=0;i<32;i++)
{
ciphertext[i+32]=leftText[16][i];
}
//Inverse permutation
inversepermutation[0]=ciphertext[40-1];
inversepermutation[1]=ciphertext[8-1];
inversepermutation[2]=ciphertext[48-1];
inversepermutation[3]=ciphertext[16-1];
inversepermutation[4]=ciphertext[56-1];
inversepermutation[5]=ciphertext[24-1];
inversepermutation[6]=ciphertext[64-1];
inversepermutation[7]=ciphertext[32-1];
inversepermutation[8]=ciphertext[39-1];
inversepermutation[9]=ciphertext[7-1];
inversepermutation[10]=ciphertext[47-1];
inversepermutation[11]=ciphertext[15-1];
inversepermutation[12]=ciphertext[55-1];
inversepermutation[13]=ciphertext[23-1];
inversepermutation[14]=ciphertext[63-1];
inversepermutation[15]=ciphertext[31-1];
inversepermutation[16]=ciphertext[38-1];
inversepermutation[17]=ciphertext[6-1];
inversepermutation[18]=ciphertext[46-1];
inversepermutation[19]=ciphertext[14-1];
inversepermutation[20]=ciphertext[54-1];
inversepermutation[21]=ciphertext[22-1];
inversepermutation[22]=ciphertext[62-1];
inversepermutation[23]=ciphertext[30-1];
inversepermutation[24]=ciphertext[37-1];
inversepermutation[25]=ciphertext[5-1];
inversepermutation[26]=ciphertext[45-1];
inversepermutation[27]=ciphertext[13-1];
inversepermutation[28]=ciphertext[53-1];
inversepermutation[29]=ciphertext[21-1];
inversepermutation[30]=ciphertext[61-1];
inversepermutation[31]=ciphertext[29-1];
inversepermutation[32]=ciphertext[36-1];
inversepermutation[33]=ciphertext[4-1];
inversepermutation[34]=ciphertext[44-1];
inversepermutation[35]=ciphertext[12-1];
inversepermutation[36]=ciphertext[52-1];
inversepermutation[37]=ciphertext[20-1];
inversepermutation[38]=ciphertext[60-1];
inversepermutation[39]=ciphertext[28-1];
inversepermutation[40]=ciphertext[35-1];
inversepermutation[41]=ciphertext[3-1];
inversepermutation[42]=ciphertext[43-1];
inversepermutation[43]=ciphertext[11-1];
inversepermutation[44]=ciphertext[51-1];
inversepermutation[45]=ciphertext[19-1];
inversepermutation[46]=ciphertext[59-1];
inversepermutation[47]=ciphertext[27-1];
inversepermutation[48]=ciphertext[34-1];
inversepermutation[49]=ciphertext[2-1];
inversepermutation[50]=ciphertext[42-1];
inversepermutation[51]=ciphertext[10-1];
inversepermutation[52]=ciphertext[50-1];
inversepermutation[53]=ciphertext[18-1];
inversepermutation[54]=ciphertext[58-1];
inversepermutation[55]=ciphertext[26-1];
inversepermutation[56]=ciphertext[33-1];
inversepermutation[57]=ciphertext[1-1];
inversepermutation[58]=ciphertext[41-1];
inversepermutation[59]=ciphertext[9-1];
inversepermutation[60]=ciphertext[49-1];
inversepermutation[61]=ciphertext[17-1];
inversepermutation[62]=ciphertext[57-1];
inversepermutation[63]=ciphertext[25-1];
cout << "Program cipher" << endl;
for(int i=0;i<64;i++)
{
cout << inversepermutation[i];
}
cout<<endl<<"Cipher Text" << endl;
for(int i=0;i<64;i++)
{
cout<<Cipher[i];
if(inversepermutation[i] != Cipher[i])
{
*flag = -1;
break;
}
}
}
void Key_Generation::inputTextProcessing(){
initialPermutation[0]=inputString[57];
initialPermutation[1]=inputString[49];
initialPermutation[2]=inputString[41];
initialPermutation[3]=inputString[33];
initialPermutation[4]=inputString[25];
initialPermutation[5]=inputString[17];
initialPermutation[6]=inputString[9];
initialPermutation[7]=inputString[1];
initialPermutation[8]=inputString[59];
initialPermutation[9]=inputString[51];
initialPermutation[10]=inputString[43];
initialPermutation[11]=inputString[35];
initialPermutation[12]=inputString[27];
initialPermutation[13]=inputString[19];
initialPermutation[14]=inputString[11];
initialPermutation[15]=inputString[3];
initialPermutation[16]=inputString[61];
initialPermutation[17]=inputString[53];
initialPermutation[18]=inputString[45];
initialPermutation[19]=inputString[37];
initialPermutation[20]=inputString[29];
initialPermutation[21]=inputString[21];
initialPermutation[22]=inputString[13];
initialPermutation[23]=inputString[5];
initialPermutation[24]=inputString[63];
initialPermutation[25]=inputString[55];
initialPermutation[26]=inputString[47];
initialPermutation[27]=inputString[39];
initialPermutation[28]=inputString[31];
initialPermutation[29]=inputString[23];
initialPermutation[30]=inputString[15];
initialPermutation[31]=inputString[7];
initialPermutation[32]=inputString[56];
initialPermutation[33]=inputString[48];
initialPermutation[34]=inputString[40];
initialPermutation[35]=inputString[32];
initialPermutation[36]=inputString[24];
initialPermutation[37]=inputString[16];
initialPermutation[38]=inputString[8];
initialPermutation[39]=inputString[0];
initialPermutation[40]=inputString[58];
initialPermutation[41]=inputString[50];
initialPermutation[42]=inputString[42];
initialPermutation[43]=inputString[34];
initialPermutation[44]=inputString[26];
initialPermutation[45]=inputString[18];
initialPermutation[46]=inputString[10];
initialPermutation[47]=inputString[2];
initialPermutation[48]=inputString[60];
initialPermutation[49]=inputString[52];
initialPermutation[50]=inputString[44];
initialPermutation[51]=inputString[36];
initialPermutation[52]=inputString[28];
initialPermutation[53]=inputString[20];
initialPermutation[54]=inputString[12];
initialPermutation[55]=inputString[4];
initialPermutation[56]=inputString[62];
initialPermutation[57]=inputString[54];
initialPermutation[58]=inputString[46];
initialPermutation[59]=inputString[38];
initialPermutation[60]=inputString[30];
initialPermutation[61]=inputString[22];
initialPermutation[62]=inputString[14];
initialPermutation[63]=inputString[6];
//Divide Left and right array
for(int i=0; i<32; i++){
leftText[0][i] = initialPermutation[i];
}
for(int i=32; i<64; i++){
rightText[0][i-32] = initialPermutation[i];
}
}
void Key_Generation::expansion(int round,char rightText[17][32],char Sub_Key[17][48])
{
int sBox1[4][16]=
{
{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}
};
int sBox2[4][16]=
{
15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9
};
int sBox3[4][16]=
{
10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12
};
int sBox4[4][16]=
{
7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14
};
int sBox5[4][16]=
{
2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,
4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3
};
int sBox6[4][16]=
{
12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13
};
int sBox7[4][16]=
{
4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,
13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12
};
int sBox8[4][16]=
{
13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11
};
exprightText[round][0] = rightText[round-1][32-1];
exprightText[round][1] = rightText[round-1][1-1];
exprightText[round][2] = rightText[round-1][2-1];
exprightText[round][3] = rightText[round-1][3-1];
exprightText[round][4] = rightText[round-1][4-1];
exprightText[round][5] = rightText[round-1][5-1];
exprightText[round][6] = rightText[round-1][4-1];
exprightText[round][7] = rightText[round-1][5-1];
exprightText[round][8] = rightText[round-1][6-1];
exprightText[round][9] = rightText[round-1][7-1];
exprightText[round][10] = rightText[round-1][8-1];
exprightText[round][11] = rightText[round-1][9-1];
exprightText[round][12] = rightText[round-1][8-1];
exprightText[round][13] = rightText[round-1][9-1];
exprightText[round][14] = rightText[round-1][10-1];
exprightText[round][15] = rightText[round-1][11-1];
exprightText[round][16] = rightText[round-1][12-1];
exprightText[round][17] = rightText[round-1][13-1];
exprightText[round][18] = rightText[round-1][12-1];
exprightText[round][19] = rightText[round-1][13-1];
exprightText[round][20] = rightText[round-1][14-1];
exprightText[round][21] = rightText[round-1][15-1];
exprightText[round][22] = rightText[round-1][16-1];
exprightText[round][23] = rightText[round-1][17-1];
exprightText[round][24] = rightText[round-1][16-1];
exprightText[round][25] = rightText[round-1][17-1];
exprightText[round][26] = rightText[round-1][18-1];
exprightText[round][27] = rightText[round-1][19-1];
exprightText[round][28] = rightText[round-1][20-1];
exprightText[round][29] = rightText[round-1][21-1];
exprightText[round][30] = rightText[round-1][20-1];
exprightText[round][31] = rightText[round-1][21-1];
exprightText[round][32] = rightText[round-1][22-1];
exprightText[round][33] = rightText[round-1][23-1];
exprightText[round][34] = rightText[round-1][24-1];
exprightText[round][35] = rightText[round-1][25-1];
exprightText[round][36] = rightText[round-1][24-1];
exprightText[round][37] = rightText[round-1][25-1];
exprightText[round][38] = rightText[round-1][26-1];
exprightText[round][39] = rightText[round-1][27-1];
exprightText[round][40] = rightText[round-1][28-1];
exprightText[round][41] = rightText[round-1][29-1];
exprightText[round][42] = rightText[round-1][28-1];
exprightText[round][43] = rightText[round-1][29-1];
exprightText[round][44] = rightText[round-1][30-1];
exprightText[round][45] = rightText[round-1][31-1];
exprightText[round][46] = rightText[round-1][32-1];
exprightText[round][47] = rightText[round-1][1-1];
// xor with key
for (int i=0;i<48;i++)
{
if (exprightText[round][i] == Sub_Key[round][i])
{
exprightText[round][i]= '0';
}
else
{
exprightText[round][i]= '1';
}
}
int p = 0;
//int q = 0;
int bit4 = sBox1[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c1(bit4);
string str1 = c1.to_string();
p=p+6;
bit4 = sBox2[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c2(bit4);
str1 = str1.append(c2.to_string());
p=p+6;
bit4 = sBox3[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c3(bit4);
str1 = str1.append(c3.to_string());
p=p+6;
bit4 = sBox4[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c4(bit4);
str1 = str1.append(c4.to_string());
p=p+6;
bit4 = sBox5[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c5(bit4);
str1 = str1.append(c5.to_string());
p=p+6;
bit4 = sBox6[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c6(bit4);
str1 = str1.append(c6.to_string());
p=p+6;
bit4 = sBox7[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c7(bit4);
str1 = str1.append(c7.to_string());
p=p+6;
bit4 = sBox8[((exprightText[round][p]-'0')*2) + (exprightText[round][p+5]-'0')] [(((exprightText[round][p+1])-'0')*8) + (((exprightText[round][p+2])-'0')*4)+(((exprightText[round][p+3])-'0')*2) + ((exprightText[round][p+4])-'0')];
bitset<4> c8(bit4);
str1 = str1.append(c8.to_string());
char tmpRight[32];
for(int k=0;k<32;k++){
tmpRight[k] = (char)str1[k];
}
permutateRightSubText(tmpRight);
}
void Key_Generation::permutateRightSubText( char tempRight[32]){
permRight[0]=tempRight[16-1];
permRight[1]=tempRight[7-1];
permRight[2]=tempRight[20-1];
permRight[3]=tempRight[21-1];
permRight[4]=tempRight[29-1];
permRight[5]=tempRight[12-1];
permRight[6]=tempRight[28-1];
permRight[7]=tempRight[17-1];
permRight[8]=tempRight[1-1];
permRight[9]=tempRight[15-1];
permRight[10]=tempRight[23-1];
permRight[11]=tempRight[26-1];
permRight[12]=tempRight[5-1];
permRight[13]=tempRight[18-1];
permRight[14]=tempRight[31-1];
permRight[15]=tempRight[10-1];
permRight[16]=tempRight[2-1];
permRight[17]=tempRight[8-1];
permRight[18]=tempRight[24-1];
permRight[19]=tempRight[14-1];
permRight[20]=tempRight[32-1];
permRight[21]=tempRight[27-1];
permRight[22]=tempRight[3-1];
permRight[23]=tempRight[9-1];
permRight[24]=tempRight[19-1];
permRight[25]=tempRight[13-1];
permRight[26]=tempRight[30-1];
permRight[27]=tempRight[6-1];
permRight[28]=tempRight[22-1];
permRight[29]=tempRight[11-1];
permRight[30]=tempRight[4-1];
permRight[31]=tempRight[25-1];
}
void Key_Generation::Shift_Bits(int Round,char Left_Key[28],char Right_Key[28])
{
if (Round!=1 && Round!=2 && Round!=9 && Round!=16)
{
char temp1[2];
temp1[0]=Left_Key[0];
temp1[1]=Left_Key[1];
for ( int i=0;i<28;i++)
{
Left_Key[i] = Left_Key[i+2];
}
Left_Key[26]=temp1[0];
Left_Key[27]=temp1[1];
temp1[0] = Right_Key[0];
temp1[1] = Right_Key[1];
for ( int i=0;i<28;i++)
{
Right_Key[i] = Right_Key[i+2];
}
Right_Key[26]=temp1[0];
Right_Key[27]=temp1[1];
}
else
{
char temp1[1];
temp1[0] = Left_Key[0];
for ( int i=0;i<28;i++)
{
Left_Key[i] = Left_Key[i+1];
}
Left_Key[27]=temp1[0];
temp1[0] = Right_Key[0];
for ( int i=0;i<28;i++)
{
Right_Key[i] = Right_Key[i+1];
}
Right_Key[27]=temp1[0];
}
for (int i=0;i<28;i++)
{
Iterated_Key[i]=Left_Key[i];
}
for (int j=28;j<56;j++)
{
Iterated_Key[j]=Right_Key[j-28];
}
Permutation_Choice_2[0] = Iterated_Key[14-1];
Permutation_Choice_2[1] = Iterated_Key[17-1];
Permutation_Choice_2[2] = Iterated_Key[11-1];
Permutation_Choice_2[3] = Iterated_Key[24-1];
Permutation_Choice_2[4] = Iterated_Key[1-1];
Permutation_Choice_2[5] = Iterated_Key[5-1];
Permutation_Choice_2[6] = Iterated_Key[3-1];
Permutation_Choice_2[7] = Iterated_Key[28-1];
Permutation_Choice_2[8] = Iterated_Key[15-1];
Permutation_Choice_2[9] = Iterated_Key[6-1];
Permutation_Choice_2[10] = Iterated_Key[21-1];
Permutation_Choice_2[11] = Iterated_Key[10-1];
Permutation_Choice_2[12] = Iterated_Key[23-1];
Permutation_Choice_2[13] = Iterated_Key[19-1];
Permutation_Choice_2[14] = Iterated_Key[12-1];
Permutation_Choice_2[15] = Iterated_Key[4-1];
Permutation_Choice_2[16] = Iterated_Key[26-1];
Permutation_Choice_2[17] = Iterated_Key[8-1];
Permutation_Choice_2[18] = Iterated_Key[16-1];
Permutation_Choice_2[19] = Iterated_Key[7-1];
Permutation_Choice_2[20] = Iterated_Key[27-1];
Permutation_Choice_2[21] = Iterated_Key[20-1];
Permutation_Choice_2[22] = Iterated_Key[13-1];
Permutation_Choice_2[23] = Iterated_Key[2-1];
Permutation_Choice_2[24] = Iterated_Key[41-1];
Permutation_Choice_2[25] = Iterated_Key[52-1];
Permutation_Choice_2[26] = Iterated_Key[31-1];
Permutation_Choice_2[27] = Iterated_Key[37-1];
Permutation_Choice_2[28] = Iterated_Key[47-1];
Permutation_Choice_2[29] = Iterated_Key[55-1];
Permutation_Choice_2[30] = Iterated_Key[30-1];
Permutation_Choice_2[31] = Iterated_Key[40-1];
Permutation_Choice_2[32] = Iterated_Key[51-1];
Permutation_Choice_2[33] = Iterated_Key[45-1];
Permutation_Choice_2[34] = Iterated_Key[33-1];
Permutation_Choice_2[35] = Iterated_Key[48-1];
Permutation_Choice_2[36] = Iterated_Key[44-1];
Permutation_Choice_2[37] = Iterated_Key[49-1];
Permutation_Choice_2[38] = Iterated_Key[39-1];
Permutation_Choice_2[39] = Iterated_Key[56-1];
Permutation_Choice_2[40] = Iterated_Key[34-1];
Permutation_Choice_2[41] = Iterated_Key[53-1];
Permutation_Choice_2[42] = Iterated_Key[46-1];
Permutation_Choice_2[43] = Iterated_Key[42-1];
Permutation_Choice_2[44] = Iterated_Key[50-1];
Permutation_Choice_2[45] = Iterated_Key[36-1];
Permutation_Choice_2[46] = Iterated_Key[29-1];
Permutation_Choice_2[47] = Iterated_Key[32-1];
}
void Key_Generation::readInitialDataFromFile(int flag1){
FILE * CipherFile;
FILE * PlainText;
// FILE * CipherFile1;
//FILE * PlainText1;
char buffer [64];
if(flag1==1){
CipherFile = fopen ("//home//ubuntu//ciphertext1.txt" , "r");
if (CipherFile == NULL) perror ("Error opening file");
else
{
while ( ! feof (CipherFile) )
{
if ( fgets (buffer , 100 , CipherFile) == NULL ) break;
}
printf("Cipher From File");
for(int i=0;i<64;i++)
{
Cipher[i]=(char)buffer[i];
printf("%c",Cipher[i]);
}
// Cipher[64]='\0';
fclose (CipherFile);
}
PlainText = fopen ("//home//ubuntu//plaintext1.txt" , "r");
if (PlainText == NULL) perror ("Error opening file");
else
{
while ( ! feof (PlainText) )
{
if ( fgets (buffer , 100 , PlainText) == NULL ) break;
}
printf("Text From File");
for(int i=0;i<64;i++)
{
inputString[i]=(char)buffer[i];
printf(" %c ",inputString[i]);
}
// inputString[64]='\0';
fclose (PlainText);
}
}else{
CipherFile = fopen ("//home//ubuntu//ciphertext2.txt" , "r");
if (CipherFile == NULL) perror ("Error opening file");
else
{
while ( ! feof (CipherFile) )
{
if ( fgets (buffer , 100 , CipherFile) == NULL ) break;
}
for(int i=0;i<64;i++)
{
Cipher[i]=(char)buffer[i];
}
Cipher[64]='\0';
fclose (CipherFile);
}
PlainText = fopen ("//home//ubuntu//plaintext2.txt" , "r");
if (PlainText == NULL) printf ("Error opening file");
else
{
while ( ! feof (PlainText) )
{
if ( fgets (buffer , 100 , PlainText) == NULL ) break;
}
for(int i=0;i<64;i++)
{
inputString[i]=(char)buffer[i];
}
inputString[64]='\0';
fclose (PlainText);
}
}
}
void *clientReturn(void *arg){
char server_reply[20];
int msg_length;
if( msg_length = read(sock , server_reply , 20) < 0)
{
//br90eak;
exit(0);
}
puts(server_reply);
puts("\n server reply in clietn return");
if(strcmp(server_reply,"close")==0){
puts("ending thread\n");
cout<<pthread_self();
exit(0);
}
puts("end of client return");
}
void *desFunction(void *arg){
Key_Generation KG;
string str1;
unsigned long long int bit4 = 0;
int keyFound = -1;
int flag=0;
int msg_length=0;
int rounds = *(int*)arg;
cout << "rounds" << rounds <<endl;
KG.readInitialDataFromFile(1);
char sampleKey[64];
for(bit4=pow(2,51)*31; bit4<pow(2,56); bit4++){
bitset<64> key(bit4);
str1 = key.to_string();
for(int k=0;k<64;k++)
{
sampleKey[k] = (char)str1[k];
}
KG.Permutation_Choice1(rounds,sampleKey,&flag);
cout << "flag" << flag << endl;
if(flag == 0)
{
flag=1;
KG.readInitialDataFromFile(0);
KG.Permutation_Choice1(rounds,sampleKey,&flag);
if(flag == 0)
{
cout<<"Found: %ul:"<<bit4<<"\n";
keyFound = bit4;
write(sock,sampleKey,65);
exit(0);
break;
}
else
{
memset(sampleKey,' ',64);
write(sock,sampleKey,65);
exit(0);
cout << "not a key %d: " << bit4;
}
}
else
{ //memset(sampleKey,' ',64);
//write(sock,sampleKey,65);
// exit(0);
cout << "not a key %d: " << bit4;
}
}
}
int main(int argc, char *argv[])
{
//int sock;
int rounds = atoi(argv[1]);
struct sockaddr_in server;
//char message[1000] , server_reply[2000];
pthread_t cr,des;
//Create socket
sock = socket(AF_INET , SOCK_STREAM , 0);
if (sock == -1)
{
printf("Could not create socket");
}
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons(3333);
//Connect to remote server
if (connect(sock , (struct sockaddr *)&server , sizeof(server)) < 0)
{
return 0;
}
pthread_create(&des,NULL,desFunction,&rounds);
pthread_create(&cr,NULL,clientReturn,NULL);
pthread_exit(NULL);
return 0;
}
| [
"yc.raghava@gmail.com"
] | yc.raghava@gmail.com |
415ce6b9090bd248ba62c93b0c8ec30b63ad2b02 | 27c917a12edbfd2dba4f6ce3b09aa2e3664d3bb1 | /Misc/sort_test.cpp | 7788cad68043dea9165d0879962b577149737a27 | [] | no_license | Spetsnaz-Dev/CPP | 681ba9be0968400e00b5b2cb9b52713f947c66f8 | 88991e3b7164dd943c4c92784d6d98a3c9689653 | refs/heads/master | 2023-06-24T05:32:30.087866 | 2021-07-15T19:33:02 | 2021-07-15T19:33:02 | 193,662,717 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 829 | cpp | int Solution::solve(int A) {
int n = A;
int count = 0;
int index;
for (int i = 31; i >= 0; i--) {
int b = A & (1 << i);
if (b != 0) {
index = i;
break;
}
}
// cout<<index<<endl;
for (int i = 0; i <= index; i++) {
int b = n & (1 << i);
if (b == 0) {
int a = n / (1 << (i + 1));
a = ((a % mod)((1 << i) % mod)) % mod;
count = ((count % mod) + (a % mod)) % mod;
} else {
int a = n / (1 << (i + 1));
a = ((a % mod)((1 << i) % mod)) % mod;
count = ((count % mod) + (a % mod)) % mod;
int k = n % (1 << (i + 1)) - (1 << i) + 1;
count = ((count % mod) + (k % mod)) % mod;
}
}
// cout<<index<<endl;
return count % mod;
} | [
"ravindrafk@gmail.com"
] | ravindrafk@gmail.com |
304036705a7b0accfa4b29c93d6c1b75dc5d0aa1 | 1435e3531731d27cb1e82888dace27a1edfbcaa1 | /ezEngine-rev858/Code/Engine/Foundation/Reflection/Implementation/DynamicRTTI.h | 39f0940a9b6eebf7fcaba23c4dbfd47c04b20982 | [] | no_license | lab132/toolbox | cf7ec9b3e6076169d8b1e12c24d0e2a273ee90be | 30f85d07fbbdde461f9027e651fc6cbbfe2f15c5 | refs/heads/master | 2020-04-26T19:40:38.059086 | 2015-11-08T14:35:09 | 2015-11-08T14:35:09 | 42,679,912 | 0 | 0 | null | 2015-10-28T13:57:32 | 2015-09-17T20:21:41 | C | UTF-8 | C++ | false | false | 5,663 | h | #pragma once
/// \file
#include <Foundation/Reflection/Implementation/StaticRTTI.h>
#include <Foundation/IO/SerializationContext.h>
#include <Foundation/Containers/Set.h>
#include <Foundation/Containers/Map.h>
/// \brief This needs to be put into the class declaration of EVERY dynamically reflectable class.
///
/// This macro extends a class, such that it is now able to return its own type information via GetDynamicRTTI(),
/// which is a virtual function, that is reimplemented on each type. A class needs to be derived from ezReflectedClass
/// (at least indirectly) for this.
#define EZ_ADD_DYNAMIC_REFLECTION(SELF) \
EZ_ALLOW_PRIVATE_PROPERTIES(SELF); \
public: \
EZ_FORCE_INLINE static const ezRTTI* GetStaticRTTI() \
{ \
return &SELF::s_RTTI; \
} \
virtual const ezRTTI* GetDynamicRTTI() const \
{ \
return &SELF::s_RTTI; \
} \
private: \
static ezRTTI s_RTTI;
/// \brief Implements the necessary functionality for a type to be dynamically reflectable.
///
/// \param Type
/// The type for which the reflection functionality should be implemented.
/// \param BaseType
/// The base class type of \a Type. If it has no base class, pass ezNoBase
/// \param AllocatorType
/// The type of an ezRTTIAllocator that can be used to create and destroy instances
/// of \a Type. Pass ezRTTINoAllocator for types that should not be created dynamically.
/// Pass ezRTTIDefaultAllocator<Type> for types that should be created on the default heap.
/// Pass a custom ezRTTIAllocator type to handle allocation differently.
#define EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(Type, BaseType, Version, AllocatorType) \
EZ_RTTIINFO_DECL(Type, BaseType, Version) \
ezRTTI Type::s_RTTI = ezRTTInfo_##Type::GetRTTI(); \
EZ_RTTIINFO_GETRTTI_IMPL_BEGIN(Type, AllocatorType)
/// \brief Ends the reflection code block that was opened with EZ_BEGIN_DYNAMIC_REFLECTED_TYPE.
#define EZ_END_DYNAMIC_REFLECTED_TYPE() \
return ezRTTI(GetTypeName(), \
ezGetStaticRTTI<OwnBaseType>(), \
sizeof(OwnType), \
GetTypeVersion(), \
ezVariant::TypeDeduction<ezReflectedClass*>::value, \
&Allocator, Properties, MessageHandlers); \
}
class ezArchiveWriter;
class ezArchiveReader;
/// \brief All classes that should be dynamically reflectable, need to be derived from this base class.
///
/// The only functionality that this class provides is the GetDynamicRTTI() function.
class EZ_FOUNDATION_DLL ezReflectedClass
{
EZ_ADD_DYNAMIC_REFLECTION(ezReflectedClass);
public:
EZ_FORCE_INLINE ezReflectedClass()
{
}
virtual ~ezReflectedClass() {}
/// \brief Returns whether the type of this instance is of the given type or derived from it.
EZ_FORCE_INLINE bool IsInstanceOf(const ezRTTI* pType) const
{
return GetDynamicRTTI()->IsDerivedFrom(pType);
}
/// \brief Returns whether the type of this instance is of the given type or derived from it.
template<typename T>
EZ_FORCE_INLINE bool IsInstanceOf() const
{
return GetDynamicRTTI()->IsDerivedFrom<T>();
}
/// \brief This function is called to serialize the instance.
///
/// It should be overridden by deriving classes. In general each overridden version should always call the
/// function of the base class. Only classes directly derived from ezReflectedClass must not do this, due to the assert in the
/// base implementation.
virtual void Serialize(ezArchiveWriter& stream) const
{
EZ_REPORT_FAILURE("Serialize is not overridden by deriving class.");
}
/// \brief This function is called to deserialize the instance.
///
/// During deserialization only data should be read from the stream. References to other objects will not be valid,
/// thus no setup should take place. Leave this to the OnDeserialized() function.
///
/// It should be overridden by deriving classes. In general each overridden version should always call the
/// function of the base class. Only classes directly derived from ezReflectedClass must not do this, due to the assert in the
/// base implementation.
virtual void Deserialize(ezArchiveReader& stream)
{
EZ_REPORT_FAILURE("Deserialize is not overridden by deriving class.");
}
/// \brief This function is called after all objects are deserialized and thus all references to other objects are valid.
///
/// This functions should do any object setup that might depend on other objects being available.
///
/// It should be overridden by deriving classes. In general each overridden version should always call the
/// function of the base class. Only classes directly derived from ezReflectedClass must not do this, due to the assert in the
/// base implementation.
virtual void OnDeserialized()
{
EZ_REPORT_FAILURE("OnDeserialized is not overridden by deriving class.");
}
};
| [
"mjmaier@gmx.de"
] | mjmaier@gmx.de |
8dae459296f8eabbb9724408ebb41b26134d9808 | 2ade54db80e23ab0acd59679e7c43fd08eb29170 | /AOCday7p2.cpp | 3cb408ed848e32fc1ca470466db9963f2c8a502a | [] | no_license | miguelraffoul/AdventOfCode17 | 5a0df1128525d9f68764bfba3e69b609fe145148 | 9ee6d81c78c74f97d3f4f3dd9e158f7e5ba58905 | refs/heads/master | 2020-03-31T19:33:12.884114 | 2019-01-09T00:35:37 | 2019-01-09T00:35:37 | 152,502,379 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,654 | cpp | #include <cstdlib>
#include <iostream>
#include <string>
#include <sstream>
#include <unordered_map>
#include <vector>
using namespace std;
struct Program {
string parent;
string name;
int weight;
vector<string> sub_programs;
};
vector<string> split( string& );
struct Program createProgram( const vector<string>& );
void constructTree( vector<struct Program>&, unordered_map<string, int>& );
int traverseTree( const string&, vector<struct Program>&, unordered_map<string, int>& );
int main( void ) {
vector<struct Program> program_list;
unordered_map<string, int> program_idex;
string input, root;
int index = 0;
while( getline( cin, input ) ) {
struct Program new_program = createProgram( split( input ) );
program_list.push_back( new_program );
program_idex.insert( make_pair<string, int>( new_program.name, index ) );
++index;
}
constructTree( program_list, program_idex );
for( unsigned int i = 0; i < program_list.size(); ++i ){
if( program_list[i].parent == "*" ) {
cout << program_list[i].name << endl;
root = program_list[i].name;
}
}
cout << "Total tree weight: " << traverseTree( root, program_list, program_idex) << endl;
return EXIT_SUCCESS;
}
vector<string> split( string& input ) {
for( unsigned int i = 0; i < input.size(); ++i ) {
if( input[i] == '(' || input[i] == ')' ||
input[i] == '-' || input[i] == '>' ||
input[i] == ',' ) {
input[i] = ' ';
}
}
istringstream iss( input );
vector<string> list;
string tmp;
while( iss >> tmp ) {
list.push_back( tmp );
}
return list;
}
struct Program createProgram( const vector<string>& list ) {
struct Program new_program;
new_program.parent = "*";
new_program.name = list[0];
new_program.weight = stoi( list[1] );
if( list.size() > 2 )
new_program.sub_programs.insert(
new_program.sub_programs.begin(),
list.begin() + 2,
list.end()
);
return new_program;
}
void constructTree( vector<struct Program>& program_list,
unordered_map<string, int>& program_idex ) {
for( unsigned int i = 0; i < program_list.size(); ++i ) {
for( unsigned int j = 0; j < program_list[i].sub_programs.size(); ++j ) {
int child_index = program_idex[program_list[i].sub_programs[j]];
program_list[child_index].parent = program_list[i].name;
}
}
}
int traverseTree( const string& name, vector<struct Program>& program_list,
unordered_map<string, int>& program_idex ) {
struct Program curr_program = program_list[program_idex[name]];
vector<int> sub_programs_weight;
int cummulative_wight, tmp;
cummulative_wight = 0;
for( unsigned int i = 0; i < curr_program.sub_programs.size(); ++i ) {
tmp = traverseTree( curr_program.sub_programs[i], program_list, program_idex );
if( i > 0 && sub_programs_weight.back() != tmp ) {
cout << "*****Weight difference found*****" << endl;
cout << "Current program: " << name << endl;
cout << "Weight in previous sub program (" << curr_program.sub_programs[i - 1];
cout << "): " << sub_programs_weight.back() << endl;
cout << "Weight in current sub program: (" << curr_program.sub_programs[i];
cout << "): " << tmp << endl;
}
cummulative_wight += tmp;
sub_programs_weight.push_back( tmp );
}
return cummulative_wight + curr_program.weight;
} | [
"oracle@bigdatalite.localdomain"
] | oracle@bigdatalite.localdomain |
f16342e0abd8c350091f0175c2fc472baa735b57 | bafae1c46014f4069fda40735b7a305616707c9b | /SaturdayNightEngine/NR_StepperBase.h | 2b7ab4ca9303cac9514e95b77e70fdb09621b06c | [] | no_license | Glimster/PhysicsAndGames | b9bd212436b8226617ecfde870640a30a96bd42e | 2bcbc9085889167c11b1adf89132f371cf65e898 | refs/heads/master | 2021-01-20T11:45:40.528735 | 2017-11-01T09:53:18 | 2017-11-01T09:53:18 | 101,686,173 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 697 | h | // More or less a copy of the Numerical Recipes ODE solver
#pragma once
#include< vector >
class NR_StepperBase
{
public:
NR_StepperBase( std::vector< double >& y,
std::vector< double >& dydx,
double& x,
const double absoluteTolerance,
const double relativeTolerance,
bool dense );
template<class T>
inline T SQR( const T a ) { return a*a; }
public:
double& x_;
double xOld_;
std::vector< double >& y_;
std::vector< double >& dydx_;
double absoluteTolerance_, relativeTolerance_;
bool dense_;
double hdid_;
double hnext_;
int n_, neqn_;
std::vector< double > yout_, yerr_;
};
| [
"Hemulen@DESKTOP-3ISETHD"
] | Hemulen@DESKTOP-3ISETHD |
538cd1f90851aa623fc19a082773f8596f771088 | 145bfed5c44000d0c443752ee6123ecbff0ac089 | /src/timedata.cpp | 392acbd85336f93df569b8d80b04445fdad09eea | [
"MIT"
] | permissive | gitBullcoin/bullcoin | e49f80638d16e09aaa890de7c123be9a1cde590f | 02399ccb6bf7eb9ce20db54feda02c03bfee86dc | refs/heads/master | 2021-01-13T01:44:25.834030 | 2015-07-21T18:09:13 | 2015-07-21T18:09:13 | 39,459,931 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,562 | cpp | // Copyright (c) 2014 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "timedata.h"
#include "netbase.h"
#include "sync.h"
#include "ui_interface.h"
#include "util.h"
#include <boost/foreach.hpp>
using namespace std;
static CCriticalSection cs_nTimeOffset;
static int64_t nTimeOffset = 0;
//
// "Never go to sea with two chronometers; take one or three."
// Our three time sources are:
// - System clock
// - Median of other nodes clocks
// - The user (asking the user to fix the system clock if the first two disagree)
//
//
int64_t GetTimeOffset()
{
LOCK(cs_nTimeOffset);
return nTimeOffset;
}
int64_t GetAdjustedTime()
{
return GetTime() + GetTimeOffset();
}
void AddTimeData(const CNetAddr& ip, int64_t nTime)
{
int64_t nOffsetSample = nTime - GetTime();
LOCK(cs_nTimeOffset);
// Ignore duplicates
static set<CNetAddr> setKnown;
if (!setKnown.insert(ip).second)
return;
// Add data
static CMedianFilter<int64_t> vTimeOffsets(200,0);
vTimeOffsets.input(nOffsetSample);
LogPrintf("Added time data, samples %d, offset %+d (%+d minutes)\n", vTimeOffsets.size(), nOffsetSample, nOffsetSample/60);
// There is a known issue here (see issue #4521):
//
// - The structure vTimeOffsets contains up to 200 elements, after which
// any new element added to it will not increase its size, replacing the
// oldest element.
//
// - The condition to update nTimeOffset includes checking whether the
// number of elements in vTimeOffsets is odd, which will never happen after
// there are 200 elements.
//
// But in this case the 'bug' is protective against some attacks, and may
// actually explain why we've never seen attacks which manipulate the
// clock offset.
//
// So we should hold off on fixing this and clean it up as part of
// a timing cleanup that strengthens it in a number of other ways.
//
if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
{
int64_t nMedian = vTimeOffsets.median();
std::vector<int64_t> vSorted = vTimeOffsets.sorted();
// Only let other nodes change our time by so much
if (abs64(nMedian) < 70 * 60)
{
nTimeOffset = nMedian;
}
else
{
nTimeOffset = 0;
static bool fDone;
if (!fDone)
{
// If nobody has a time different than ours but within 5 minutes of ours, give a warning
bool fMatch = false;
BOOST_FOREACH(int64_t nOffset, vSorted)
if (nOffset != 0 && abs64(nOffset) < 5 * 60)
fMatch = true;
if (!fMatch)
{
fDone = true;
string strMessage = _("Warning: Please check that your computer's date and time are correct! If your clock is wrong Bullcoin will not work properly.");
strMiscWarning = strMessage;
LogPrintf("*** %s\n", strMessage);
uiInterface.ThreadSafeMessageBox(strMessage, "", CClientUIInterface::MSG_WARNING);
}
}
}
if (fDebug) {
BOOST_FOREACH(int64_t n, vSorted)
LogPrintf("%+d ", n);
LogPrintf("| ");
}
LogPrintf("nTimeOffset = %+d (%+d minutes)\n", nTimeOffset, nTimeOffset/60);
}
}
| [
"gitBullcoin@users.noreply.github.com"
] | gitBullcoin@users.noreply.github.com |
5bbd75b1c33c400e855b55eb63daf0ee6d213cfc | 753839345d394de155ce5d78877049f6bf16ce6f | /1232.็ผ็นๆ็บฟ.cpp | 6978cfb81ca484408e3293cbdf224dc4af1ad837 | [] | no_license | WonderfulUnknown/LeetCode | 2df5a68b855f84787cee8fa5e553e70e9f62512d | c392622e567bf5551a92d7fc47d4477000b4d7ee | refs/heads/master | 2021-01-02T05:50:59.457795 | 2020-03-18T09:47:15 | 2020-03-18T09:47:15 | 239,516,921 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 488 | cpp | /*
* @lc app=leetcode.cn id=1232 lang=cpp
*
* [1232] ็ผ็นๆ็บฟ
*/
// @lc code=start
class Solution {
public:
bool checkStraightLine(vector<vector<int>>& coordinates) {
for (int i = 2; i < coordinates.size(); i++)
{
if ((coordinates[i][1] - coordinates[0][1]) * (coordinates[1][0] - coordinates[0][0]) !=
(coordinates[1][1] - coordinates[0][1]) * (coordinates[i][0] - coordinates[0][0]))
return false;
}
return true;
}
};
// @lc code=end
| [
"389038968@qq.com"
] | 389038968@qq.com |
875617ff7308448ea385dfad87a03b000e07797d | e4ef4a361bfe540ffcbcc8029e9ac28f0d014339 | /dune/Hydrate-DG/Ex2/properties/H2O.hh | 95c5db1d500f094c911b2a19f24e96e960b94911 | [] | no_license | apminaei/Hydrate-DG | 48472f0e821a9c7757c7dc6dccdd57d25f7ef44e | 4b24626bc53ab92d32f4855d722f777d9f63adc4 | refs/heads/master | 2023-04-14T23:21:11.431945 | 2022-09-12T07:30:24 | 2022-09-12T07:30:24 | 309,623,539 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,211 | hh | /* ALL PARAMETERS ARE NONDIMENSIONAL */
template <typename PTree>
class Water
{
private:
CharacteristicValues characteristicValue;
const PTree &ptree;
Parameters<PTree> parameter;
public:
Water(const PTree &ptree_)
: ptree(ptree_),
parameter(ptree_)
{
}
double CriticalTemperature() const
{
return 647.096; /* [K] */
}
double CriticalPressure() const
{
return 22.064 * 1.0e6; /* [Pa] */
}
double MolarMass() const
{
/* unit -> kg/mol */
return 18.0 / 1000.;
}
double Density(double T, double Pw, double S) const
{
double rho;
/* rho: unit -> kg/m^3 */
/*
* averages values & expansion coefficients: ฯ0=1027 kg/m^3, T0=10ยฐC, S_0=35 g/kg
* Thermal expansion: \alpha_T=0.15 kg/(m^3 ยฐC)
* Salinity contraction: \alpha_S=0.78 kg/(m^3 g/kg)
* Pressure compressibility: \alpha_P=0.0045 kg/(m^3 dbar)
* UNESCO EOS-80 : Equation of state for seawater
* We use a linear EOS (web ref:http://www.ccpo.odu.edu/~atkinson/OEAS405/Chapter2_Stratified_Ocean/Lec_04_DensityEOS.pdf)
*/
double rho_0 = 1027.0;
double T_0 = 10.;
double S_0 = 0.035;
double alpha_T = -0.15;
double alpha_S = 0.96706917808 * 1e2; // 0.78*1e3;//108.524;//
double alpha_P = 0.0045;
rho = rho_0 + (alpha_P * (Pw * 1.e-4) + alpha_T * ((T - 273.15) - T_0) + alpha_S * (S - S_0));
return rho / characteristicValue.density_c;
}
double MolarDensity(double T, double Pw, double S) const
{
return Density(T, Pw, S) * characteristicValue.density_c / MolarMass();
}
double DynamicViscosity(double T, double Pw, double S) const
{
double mu;
/* mu: unit -> Pa.s */
// REFERENCE:
double mu_0 = 0.001792; // kg/m/s
double a = -1.94;
double b = -4.80;
double c = 6.74;
double T0 = 273.15; // K
double Tr = T0 / T;
mu = mu_0 * exp(a + b * Tr + c * Tr * Tr);
return mu / characteristicValue.viscosity_c;
}
double ThermalConductivity(double T, double Pw, double S) const
{
double kth;
/* kth: unit -> W.m^-1 K^-1 */
kth = 0.57153 * (1 + 0.003 * (T - 273.15) - 1.025e-5 * (T - 273.15) * (T - 273.15) + 6.53e-10 * Pw - 0.29 * S); // 0.024565
return kth / characteristicValue.thermalconductivity_c;
}
double Cp(double T, double Pw, double S) const
{
double Cp;
/* Cp: unit -> J*kg^-1*K^-1 */
Cp = 3945.0;
return Cp / characteristicValue.specificheat_c;
}
double Cv(double T, double Pw, double S) const
{
double Cv;
/* mu: unit -> J*kg^-1*K^-1 */
Cv = Cp(T, Pw, S) * characteristicValue.specificheat_c;
return Cv / characteristicValue.volumetricheat_c;
}
double SaturatedVaporPressure(double T /*K*/, double S) const
{
double psat; /* [Pa] */
// REF: SUGAR TOOLBOX
double Pc = CriticalPressure(); // in Pa
double Tc = CriticalTemperature(); // in K
double Tr = T / Tc;
double c1 = -7.85951783;
double c2 = 1.84408259;
double c3 = -11.7866497;
double c4 = 22.6807411;
double c5 = -15.9618719;
double c6 = 1.80122502;
double lnppc = 1. / Tr * (c1 * (1 - Tr) + c2 * pow((1 - Tr), 1.5) + c3 * pow((1 - Tr), 3) + c4 * pow((1 - Tr), 3.5) + c5 * pow((1 - Tr), 4) + c6 * pow((1 - Tr), 7.5));
psat = Pc * exp(lnppc); /* [Pa] */
return psat / characteristicValue.P_c;
}
};
| [
"apminaei@gmail.com"
] | apminaei@gmail.com |
adf804542ded92a8beb55af3fe94d75fd27df9c0 | e766e93530c5ea535fda61e9f17379d9319df75e | /src/init.cpp | b54aff7aaae327405ffa2ed263a51283ffb28f42 | [
"MIT"
] | permissive | iscoin/interstellarcoin | eadcc886766106a581515a3f34f032d748626670 | 54bf527d0555dacf5ec29494bde2420ff7af6b43 | refs/heads/master | 2021-01-10T21:59:32.696000 | 2015-03-19T15:25:15 | 2015-03-19T15:25:15 | 32,468,110 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29,338 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Copyright (c) 2011-2012 Litecoin Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "db.h"
#include "walletdb.h"
#include "bitcoinrpc.h"
#include "net.h"
#include "init.h"
#include "util.h"
#include "ui_interface.h"
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/convenience.hpp>
#include <boost/interprocess/sync/file_lock.hpp>
#include <boost/algorithm/string/predicate.hpp>
#ifndef WIN32
#include <signal.h>
#endif
using namespace std;
using namespace boost;
CWallet* pwalletMain;
CClientUIInterface uiInterface;
//////////////////////////////////////////////////////////////////////////////
//
// Shutdown
//
void ExitTimeout(void* parg)
{
#ifdef WIN32
Sleep(5000);
ExitProcess(0);
#endif
}
void StartShutdown()
{
#ifdef QT_GUI
// ensure we leave the Qt main loop for a clean GUI exit (Shutdown() is called in bitcoin.cpp afterwards)
uiInterface.QueueShutdown();
#else
// Without UI, Shutdown() can simply be started in a new thread
CreateThread(Shutdown, NULL);
#endif
}
void Shutdown(void* parg)
{
static CCriticalSection cs_Shutdown;
static bool fTaken;
// Make this thread recognisable as the shutdown thread
RenameThread("bitcoin-shutoff");
bool fFirstThread = false;
{
TRY_LOCK(cs_Shutdown, lockShutdown);
if (lockShutdown)
{
fFirstThread = !fTaken;
fTaken = true;
}
}
static bool fExit;
if (fFirstThread)
{
fShutdown = true;
nTransactionsUpdated++;
bitdb.Flush(false);
StopNode();
bitdb.Flush(true);
boost::filesystem::remove(GetPidFile());
UnregisterWallet(pwalletMain);
delete pwalletMain;
CreateThread(ExitTimeout, NULL);
Sleep(50);
printf("interstellarcoin exited\n\n");
fExit = true;
#ifndef QT_GUI
// ensure non UI client get's exited here, but let Bitcoin-Qt reach return 0; in bitcoin.cpp
exit(0);
#endif
}
else
{
while (!fExit)
Sleep(500);
Sleep(100);
ExitThread(0);
}
}
void HandleSIGTERM(int)
{
fRequestShutdown = true;
}
void HandleSIGHUP(int)
{
fReopenDebugLog = true;
}
//////////////////////////////////////////////////////////////////////////////
//
// Start
//
#if !defined(QT_GUI)
bool AppInit(int argc, char* argv[])
{
bool fRet = false;
try
{
//
// Parameters
//
// If Qt is used, parameters/litecoin.conf are parsed in qt/bitcoin.cpp's main()
ParseParameters(argc, argv);
if (!boost::filesystem::is_directory(GetDataDir(false)))
{
fprintf(stderr, "Error: Specified directory does not exist\n");
Shutdown(NULL);
}
ReadConfigFile(mapArgs, mapMultiArgs);
if (mapArgs.count("-?") || mapArgs.count("--help"))
{
// First part of help message is specific to interstellarcoin server / RPC client
std::string strUsage = _("interstellarcoin version") + " " + FormatFullVersion() + "\n\n" +
_("Usage:") + "\n" +
" interstellarcoin [options] " + "\n" +
" interstellarcoin [options] <command> [params] " + _("Send command to -server or interstellarcoin") + "\n" +
" interstellarcoin [options] help " + _("List commands") + "\n" +
" interstellarcoin [options] help <command> " + _("Get help for a command") + "\n";
strUsage += "\n" + HelpMessage();
fprintf(stderr, "%s", strUsage.c_str());
return false;
}
// Command-line RPC
for (int i = 1; i < argc; i++)
if (!IsSwitchChar(argv[i][0]) && !boost::algorithm::istarts_with(argv[i], "interstellarcoin:"))
fCommandLine = true;
if (fCommandLine)
{
int ret = CommandLineRPC(argc, argv);
exit(ret);
}
fRet = AppInit2();
}
catch (std::exception& e) {
PrintException(&e, "AppInit()");
} catch (...) {
PrintException(NULL, "AppInit()");
}
if (!fRet)
Shutdown(NULL);
return fRet;
}
extern void noui_connect();
int main(int argc, char* argv[])
{
bool fRet = false;
// Connect signal handlers
noui_connect();
fRet = AppInit(argc, argv);
if (fRet && fDaemon)
return 0;
return 1;
}
#endif
bool static InitError(const std::string &str)
{
uiInterface.ThreadSafeMessageBox(str, _("interstellarcoin"), CClientUIInterface::OK | CClientUIInterface::MODAL);
return false;
}
bool static InitWarning(const std::string &str)
{
uiInterface.ThreadSafeMessageBox(str, _("interstellarcoin"), CClientUIInterface::OK | CClientUIInterface::ICON_EXCLAMATION | CClientUIInterface::MODAL);
return true;
}
bool static Bind(const CService &addr, bool fError = true) {
if (IsLimited(addr))
return false;
std::string strError;
if (!BindListenPort(addr, strError)) {
if (fError)
return InitError(strError);
return false;
}
return true;
}
/* import from bitcoinrpc.cpp */
extern double GetDifficulty(const CBlockIndex* blockindex = NULL);
// Core-specific options shared between UI and daemon
std::string HelpMessage()
{
string strUsage = _("Options:") + "\n" +
" -conf=<file> " + _("Specify configuration file (default: interstellarcoin.conf)") + "\n" +
" -pid=<file> " + _("Specify pid file (default: interstellarcoin.pid)") + "\n" +
" -gen " + _("Generate coins") + "\n" +
" -gen=0 " + _("Don't generate coins") + "\n" +
" -datadir=<dir> " + _("Specify data directory") + "\n" +
" -dbcache=<n> " + _("Set database cache size in megabytes (default: 25)") + "\n" +
" -dblogsize=<n> " + _("Set database disk log size in megabytes (default: 100)") + "\n" +
" -timeout=<n> " + _("Specify connection timeout (in milliseconds)") + "\n" +
" -proxy=<ip:port> " + _("Connect through socks proxy") + "\n" +
" -socks=<n> " + _("Select the version of socks proxy to use (4-5, default: 5)") + "\n" +
" -tor=<ip:port> " + _("Use proxy to reach tor hidden services (default: same as -proxy)") + "\n"
" -dns " + _("Allow DNS lookups for -addnode, -seednode and -connect") + "\n" +
" -port=<port> " + _("Listen for connections on <port> (default: 42001 or testnet: 32001)") + "\n" +
" -maxconnections=<n> " + _("Maintain at most <n> connections to peers (default: 125)") + "\n" +
" -addnode=<ip> " + _("Add a node to connect to and attempt to keep the connection open") + "\n" +
" -connect=<ip> " + _("Connect only to the specified node(s)") + "\n" +
" -seednode=<ip> " + _("Connect to a node to retrieve peer addresses, and disconnect") + "\n" +
" -externalip=<ip> " + _("Specify your own public address") + "\n" +
" -onlynet=<net> " + _("Only connect to nodes in network <net> (IPv4, IPv6 or Tor)") + "\n" +
" -discover " + _("Discover own IP address (default: 1 when listening and no -externalip)") + "\n" +
" -irc " + _("Find peers using internet relay chat (default: 0)") + "\n" +
" -listen " + _("Accept connections from outside (default: 1 if no -proxy or -connect)") + "\n" +
" -bind=<addr> " + _("Bind to given address. Use [host]:port notation for IPv6") + "\n" +
" -dnsseed " + _("Find peers using DNS lookup (default: 1 unless -connect)") + "\n" +
" -banscore=<n> " + _("Threshold for disconnecting misbehaving peers (default: 100)") + "\n" +
" -bantime=<n> " + _("Number of seconds to keep misbehaving peers from reconnecting (default: 86400)") + "\n" +
" -maxreceivebuffer=<n> " + _("Maximum per-connection receive buffer, <n>*1000 bytes (default: 5000)") + "\n" +
" -maxsendbuffer=<n> " + _("Maximum per-connection send buffer, <n>*1000 bytes (default: 1000)") + "\n" +
" -detachdb " + _("Detach block and address databases. Increases shutdown time (default: 0)") + "\n" +
" -paytxfee=<amt> " + _("Fee per KB to add to transactions you send") + "\n" +
" -mininput=<amt> " + _("When creating transactions, ignore inputs with value less than this (default: 0.0001)") + "\n" +
#ifdef QT_GUI
" -server " + _("Accept command line and JSON-RPC commands") + "\n" +
#endif
#if !defined(WIN32) && !defined(QT_GUI)
" -daemon " + _("Run in the background as a daemon and accept commands") + "\n" +
#endif
" -testnet " + _("Use the test network") + "\n" +
" -debug " + _("Output extra debugging information. Implies all other -debug* options") + "\n" +
" -debugnet " + _("Output extra network debugging information") + "\n" +
" -logtimestamps " + _("Prepend debug output with timestamp") + "\n" +
" -printtoconsole " + _("Send trace/debug info to console instead of debug.log file") + "\n" +
#ifdef WIN32
" -printtodebugger " + _("Send trace/debug info to debugger") + "\n" +
#endif
" -rpcuser=<user> " + _("Username for JSON-RPC connections") + "\n" +
" -rpcpassword=<pw> " + _("Password for JSON-RPC connections") + "\n" +
" -rpcport=<port> " + _("Listen for JSON-RPC connections on <port> (default: 42000)") + "\n" +
" -rpcallowip=<ip> " + _("Allow JSON-RPC connections from specified IP address") + "\n" +
" -rpcconnect=<ip> " + _("Send commands to node running on <ip> (default: 127.0.0.1)") + "\n" +
" -blocknotify=<cmd> " + _("Execute command when the best block changes (%s in cmd is replaced by block hash)") + "\n" +
" -upgradewallet " + _("Upgrade wallet to latest format") + "\n" +
" -keypool=<n> " + _("Set key pool size to <n> (default: 100)") + "\n" +
" -rescan " + _("Rescan the block chain for missing wallet transactions") + "\n" +
" -checkblocks=<n> " + _("How many blocks to check at startup (default: 2500, 0 = all)") + "\n" +
" -checklevel=<n> " + _("How thorough the block verification is (0-6, default: 1)") + "\n" +
" -loadblock=<file> " + _("Imports blocks from external blk000?.dat file") + "\n" +
" -? " + _("This help message") + "\n";
strUsage += string() +
_("\nSSL options: (see the Bitcoin Wiki for SSL setup instructions)") + "\n" +
" -rpcssl " + _("Use OpenSSL (https) for JSON-RPC connections") + "\n" +
" -rpcsslcertificatechainfile=<file.cert> " + _("Server certificate file (default: server.cert)") + "\n" +
" -rpcsslprivatekeyfile=<file.pem> " + _("Server private key (default: server.pem)") + "\n" +
" -rpcsslciphers=<ciphers> " + _("Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)") + "\n";
return strUsage;
}
/** Initialize interstellarcoin.
* @pre Parameters should be parsed and config file should be read.
*/
bool AppInit2()
{
// ********************************************************* Step 1: setup
#ifdef _MSC_VER
// Turn off microsoft heap dump noise
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));
#endif
#if _MSC_VER >= 1400
// Disable confusing "helpful" text message on abort, ctrl-c
_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
#endif
#ifndef WIN32
umask(077);
#endif
#ifndef WIN32
// Clean shutdown on SIGTERM
struct sigaction sa;
sa.sa_handler = HandleSIGTERM;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
// Reopen debug.log on SIGHUP
struct sigaction sa_hup;
sa_hup.sa_handler = HandleSIGHUP;
sigemptyset(&sa_hup.sa_mask);
sa_hup.sa_flags = 0;
sigaction(SIGHUP, &sa_hup, NULL);
#endif
// ********************************************************* Step 2: parameter interactions
fTestNet = GetBoolArg("-testnet");
// Keep irc seeding on by default for now.
// if (fTestNet)
// {
SoftSetBoolArg("-irc", true);
// }
if (mapArgs.count("-bind")) {
// when specifying an explicit binding address, you want to listen on it
// even when -connect or -proxy is specified
SoftSetBoolArg("-listen", true);
}
if (mapArgs.count("-connect")) {
// when only connecting to trusted nodes, do not seed via DNS, or listen by default
SoftSetBoolArg("-dnsseed", false);
SoftSetBoolArg("-listen", false);
}
if (mapArgs.count("-proxy")) {
// to protect privacy, do not listen by default if a proxy server is specified
SoftSetBoolArg("-listen", false);
}
if (!GetBoolArg("-listen", true)) {
// do not map ports or try to retrieve public IP when not listening (pointless)
SoftSetBoolArg("-upnp", false);
SoftSetBoolArg("-discover", false);
}
if (mapArgs.count("-externalip")) {
// if an explicit public IP is specified, do not try to find others
SoftSetBoolArg("-discover", false);
}
// ********************************************************* Step 3: parameter-to-internal-flags
fDebug = GetBoolArg("-debug");
// -debug implies fDebug*
if (fDebug)
fDebugNet = true;
else
fDebugNet = GetBoolArg("-debugnet");
bitdb.SetDetach(GetBoolArg("-detachdb", false));
#if !defined(WIN32) && !defined(QT_GUI)
fDaemon = GetBoolArg("-daemon");
#else
fDaemon = false;
#endif
if (fDaemon)
fServer = true;
else
fServer = GetBoolArg("-server");
/* force fServer when running without GUI */
#if !defined(QT_GUI)
fServer = true;
#endif
fPrintToConsole = GetBoolArg("-printtoconsole");
fPrintToDebugger = GetBoolArg("-printtodebugger");
fLogTimestamps = GetBoolArg("-logtimestamps");
if (mapArgs.count("-timeout"))
{
int nNewTimeout = GetArg("-timeout", 5000);
if (nNewTimeout > 0 && nNewTimeout < 600000)
nConnectTimeout = nNewTimeout;
}
// Continue to put "/P2SH/" in the coinbase to monitor
// BIP16 support.
// This can be removed eventually...
const char* pszP2SH = "/P2SH/";
COINBASE_FLAGS << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
if (mapArgs.count("-paytxfee"))
{
if (!ParseMoney(mapArgs["-paytxfee"], nTransactionFee))
return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s'"), mapArgs["-paytxfee"].c_str()));
if (nTransactionFee > 0.25 * COIN)
InitWarning(_("Warning: -paytxfee is set very high. This is the transaction fee you will pay if you send a transaction."));
}
if (mapArgs.count("-mininput"))
{
if (!ParseMoney(mapArgs["-mininput"], nMinimumInputValue))
return InitError(strprintf(_("Invalid amount for -mininput=<amount>: '%s'"), mapArgs["-mininput"].c_str()));
}
// ********************************************************* Step 4: application initialization: dir lock, daemonize, pidfile, debug log
// Make sure only a single interstellarcoin process is using the data directory.
boost::filesystem::path pathLockFile = GetDataDir() / ".lock";
FILE* file = fopen(pathLockFile.string().c_str(), "a"); // empty lock file; created if it doesn't exist.
if (file) fclose(file);
static boost::interprocess::file_lock lock(pathLockFile.string().c_str());
if (!lock.try_lock())
return InitError(strprintf(_("Cannot obtain a lock on data directory %s. interstellarcoin is probably already running."), GetDataDir().string().c_str()));
#if !defined(WIN32) && !defined(QT_GUI)
if (fDaemon)
{
// Daemonize
pid_t pid = fork();
if (pid < 0)
{
fprintf(stderr, "Error: fork() returned %d errno %d\n", pid, errno);
return false;
}
if (pid > 0)
{
CreatePidFile(GetPidFile(), pid);
return true;
}
pid_t sid = setsid();
if (sid < 0)
fprintf(stderr, "Error: setsid() returned %d errno %d\n", sid, errno);
}
#endif
if (!fDebug)
ShrinkDebugFile();
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf("interstellarcoin version %s (%s)\n", FormatFullVersion().c_str(), CLIENT_DATE.c_str());
printf("Startup time: %s\n", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
printf("Default data directory %s\n", GetDefaultDataDir().string().c_str());
printf("Used data directory %s\n", GetDataDir().string().c_str());
std::ostringstream strErrors;
if (fDaemon)
fprintf(stdout, "interstellarcoin server starting\n");
int64 nStart;
// ********************************************************* Step 5: network initialization
int nSocksVersion = GetArg("-socks", 5);
if (nSocksVersion != 4 && nSocksVersion != 5)
return InitError(strprintf(_("Unknown -socks proxy version requested: %i"), nSocksVersion));
if (mapArgs.count("-onlynet")) {
std::set<enum Network> nets;
BOOST_FOREACH(std::string snet, mapMultiArgs["-onlynet"]) {
enum Network net = ParseNetwork(snet);
if (net == NET_UNROUTABLE)
return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet.c_str()));
nets.insert(net);
}
for (int n = 0; n < NET_MAX; n++) {
enum Network net = (enum Network)n;
if (!nets.count(net))
SetLimited(net);
}
}
CService addrProxy;
bool fProxy = false;
if (mapArgs.count("-proxy")) {
addrProxy = CService(mapArgs["-proxy"], 9050);
if (!addrProxy.IsValid())
return InitError(strprintf(_("Invalid -proxy address: '%s'"), mapArgs["-proxy"].c_str()));
if (!IsLimited(NET_IPV4))
SetProxy(NET_IPV4, addrProxy, nSocksVersion);
if (nSocksVersion > 4) {
#ifdef USE_IPV6
if (!IsLimited(NET_IPV6))
SetProxy(NET_IPV6, addrProxy, nSocksVersion);
#endif
SetNameProxy(addrProxy, nSocksVersion);
}
fProxy = true;
}
// -tor can override normal proxy, -notor disables tor entirely
if (!(mapArgs.count("-tor") && mapArgs["-tor"] == "0") && (fProxy || mapArgs.count("-tor"))) {
CService addrOnion;
if (!mapArgs.count("-tor"))
addrOnion = addrProxy;
else
addrOnion = CService(mapArgs["-tor"], 9050);
if (!addrOnion.IsValid())
return InitError(strprintf(_("Invalid -tor address: '%s'"), mapArgs["-tor"].c_str()));
SetProxy(NET_TOR, addrOnion, 5);
SetReachable(NET_TOR);
}
// see Step 2: parameter interactions for more information about these
fNoListen = !GetBoolArg("-listen", true);
fDiscover = GetBoolArg("-discover", true);
fNameLookup = GetBoolArg("-dns", true);
bool fBound = false;
if (!fNoListen)
{
std::string strError;
if (mapArgs.count("-bind")) {
BOOST_FOREACH(std::string strBind, mapMultiArgs["-bind"]) {
CService addrBind;
if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false))
return InitError(strprintf(_("Cannot resolve -bind address: '%s'"), strBind.c_str()));
fBound |= Bind(addrBind);
}
} else {
struct in_addr inaddr_any;
inaddr_any.s_addr = INADDR_ANY;
#ifdef USE_IPV6
if (!IsLimited(NET_IPV6))
fBound |= Bind(CService(in6addr_any, GetListenPort()), false);
#endif
if (!IsLimited(NET_IPV4))
fBound |= Bind(CService(inaddr_any, GetListenPort()), !fBound);
}
if (!fBound)
return InitError(_("Failed to listen on any port. Use -listen=0 if you want this."));
}
if (mapArgs.count("-externalip"))
{
BOOST_FOREACH(string strAddr, mapMultiArgs["-externalip"]) {
CService addrLocal(strAddr, GetListenPort(), fNameLookup);
if (!addrLocal.IsValid())
return InitError(strprintf(_("Cannot resolve -externalip address: '%s'"), strAddr.c_str()));
AddLocal(CService(strAddr, GetListenPort(), fNameLookup), LOCAL_MANUAL);
}
}
BOOST_FOREACH(string strDest, mapMultiArgs["-seednode"])
AddOneShot(strDest);
// ********************************************************* Step 6: load blockchain
if (GetBoolArg("-loadblockindextest"))
{
CTxDB txdb("r");
txdb.LoadBlockIndex();
PrintBlockTree();
return false;
}
uiInterface.InitMessage(_("Loading block index..."));
printf("Loading block index...\n");
nStart = GetTimeMillis();
if (!LoadBlockIndex())
strErrors << _("Error loading blkindex.dat") << "\n";
// as LoadBlockIndex can take several minutes, it's possible the user
// requested to kill interstellarcoin-qt during the last operation. If so, exit.
// As the program has not fully started yet, Shutdown() is possibly overkill.
if (fRequestShutdown)
{
printf("Shutdown requested. Exiting.\n");
return false;
}
printf(" block index %15"PRI64d"ms\n", GetTimeMillis() - nStart);
if (GetBoolArg("-printblockindex") || GetBoolArg("-printblocktree"))
{
PrintBlockTree();
return false;
}
if (mapArgs.count("-printblock"))
{
string strMatch = mapArgs["-printblock"];
int nFound = 0;
for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
{
uint256 hash = (*mi).first;
if (strncmp(hash.ToString().c_str(), strMatch.c_str(), strMatch.size()) == 0)
{
CBlockIndex* pindex = (*mi).second;
CBlock block;
block.ReadFromDisk(pindex);
block.BuildMerkleTree();
block.print();
printf("\n");
nFound++;
}
}
if (nFound == 0)
printf("No blocks matching %s were found\n", strMatch.c_str());
return false;
}
if (mapArgs.count("-exportStatData"))
{
FILE* file = fopen((GetDataDir() / "blockstat.dat").string().c_str(), "w");
if (!file)
return false;
for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
{
CBlockIndex* pindex = (*mi).second;
CBlock block;
block.ReadFromDisk(pindex);
block.BuildMerkleTree();
fprintf(file, "%d,%s,%s,%d,%f,%u\n",
pindex->nHeight, /* todo: height */
block.GetHash().ToString().c_str(),
block.GetPoWHash().ToString().c_str(),
block.nVersion,
//CBigNum().SetCompact(block.nBits).getuint256().ToString().c_str(),
GetDifficulty(pindex),
block.nTime
);
}
fclose(file);
return false;
}
// ********************************************************* Step 7: load wallet
uiInterface.InitMessage(_("Loading wallet..."));
printf("Loading wallet...\n");
nStart = GetTimeMillis();
bool fFirstRun;
pwalletMain = new CWallet("wallet.dat");
int nLoadWalletRet = pwalletMain->LoadWallet(fFirstRun);
if (nLoadWalletRet != DB_LOAD_OK)
{
if (nLoadWalletRet == DB_CORRUPT)
strErrors << _("Error loading wallet.dat: Wallet corrupted") << "\n";
else if (nLoadWalletRet == DB_TOO_NEW)
strErrors << _("Error loading wallet.dat: Wallet requires newer version of interstellarcoin") << "\n";
else if (nLoadWalletRet == DB_NEED_REWRITE)
{
strErrors << _("Wallet needed to be rewritten: restart interstellarcoin to complete") << "\n";
printf("%s", strErrors.str().c_str());
return InitError(strErrors.str());
}
else
strErrors << _("Error loading wallet.dat") << "\n";
}
if (GetBoolArg("-upgradewallet", fFirstRun))
{
int nMaxVersion = GetArg("-upgradewallet", 0);
if (nMaxVersion == 0) // the -upgradewallet without argument case
{
printf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
nMaxVersion = CLIENT_VERSION;
pwalletMain->SetMinVersion(FEATURE_LATEST); // permanently upgrade the wallet immediately
}
else
printf("Allowing wallet upgrade up to %i\n", nMaxVersion);
if (nMaxVersion < pwalletMain->GetVersion())
strErrors << _("Cannot downgrade wallet") << "\n";
pwalletMain->SetMaxVersion(nMaxVersion);
}
if (fFirstRun)
{
// Create new keyUser and set as default key
RandAddSeedPerfmon();
CPubKey newDefaultKey;
if (!pwalletMain->GetKeyFromPool(newDefaultKey, false))
strErrors << _("Cannot initialize keypool") << "\n";
pwalletMain->SetDefaultKey(newDefaultKey);
if (!pwalletMain->SetAddressBookName(pwalletMain->vchDefaultKey.GetID(), ""))
strErrors << _("Cannot write default address") << "\n";
}
printf("%s", strErrors.str().c_str());
printf(" wallet %15"PRI64d"ms\n", GetTimeMillis() - nStart);
RegisterWallet(pwalletMain);
CBlockIndex *pindexRescan = pindexBest;
if (GetBoolArg("-rescan"))
pindexRescan = pindexGenesisBlock;
else
{
CWalletDB walletdb("wallet.dat");
CBlockLocator locator;
if (walletdb.ReadBestBlock(locator))
pindexRescan = locator.GetBlockIndex();
}
if (pindexBest != pindexRescan)
{
uiInterface.InitMessage(_("Rescanning..."));
printf("Rescanning last %i blocks (from block %i)...\n", pindexBest->nHeight - pindexRescan->nHeight, pindexRescan->nHeight);
nStart = GetTimeMillis();
pwalletMain->ScanForWalletTransactions(pindexRescan, true);
printf(" rescan %15"PRI64d"ms\n", GetTimeMillis() - nStart);
}
// ********************************************************* Step 8: import blocks
if (mapArgs.count("-loadblock"))
{
BOOST_FOREACH(string strFile, mapMultiArgs["-loadblock"])
{
FILE *file = fopen(strFile.c_str(), "rb");
if (file)
LoadExternalBlockFile(file);
}
}
// ********************************************************* Step 9: load peers
uiInterface.InitMessage(_("Loading addresses..."));
printf("Loading addresses...\n");
nStart = GetTimeMillis();
{
CAddrDB adb;
if (!adb.Read(addrman))
printf("Invalid or missing peers.dat; recreating\n");
}
printf("Loaded %i addresses from peers.dat %"PRI64d"ms\n",
addrman.size(), GetTimeMillis() - nStart);
// ********************************************************* Step 10: start node
if (!CheckDiskSpace())
return false;
RandAddSeedPerfmon();
//// debug print
printf("mapBlockIndex.size() = %d\n", mapBlockIndex.size());
printf("nBestHeight = %d\n", nBestHeight);
printf("setKeyPool.size() = %d\n", pwalletMain->setKeyPool.size());
printf("mapWallet.size() = %d\n", pwalletMain->mapWallet.size());
printf("mapAddressBook.size() = %d\n", pwalletMain->mapAddressBook.size());
if (!CreateThread(StartNode, NULL))
InitError(_("Error: could not start node"));
if (fServer)
CreateThread(ThreadRPCServer, NULL);
// ********************************************************* Step 11: finished
uiInterface.InitMessage(_("Done loading"));
printf("Done loading\n");
if (!strErrors.str().empty())
return InitError(strErrors.str());
// Add wallet transactions that aren't already in a block to mapTransactions
pwalletMain->ReacceptWalletTransactions();
#if !defined(QT_GUI)
// Loop until process is exit()ed from shutdown() function,
// called from ThreadRPCServer thread when a "stop" command is received.
while (1)
Sleep(5000);
#endif
return true;
}
| [
"interstellarcoin@gmail.com"
] | interstellarcoin@gmail.com |
c92e08276f118a7785a3258016932b93ef2ca6fd | 93c433ce85bde07817195df220c5f40dac4cde61 | /Game Engine/Game Engine/Header Files/Objects/oGeometry.h | fc6f390d45f35e0b6ff5c7396f70e0cbb02c75f9 | [] | no_license | JARD-GAMES/Engine_Project | 4894305e1a2bad3063d1ab0339b3f2d4fe687e1e | 76f32a46209172e1b368ae0292f718c6b7134dd1 | refs/heads/master | 2020-03-19T11:33:41.431686 | 2018-07-02T16:40:09 | 2018-07-02T16:40:09 | 136,461,566 | 0 | 3 | null | 2018-09-17T12:28:30 | 2018-06-07T10:31:59 | C | UTF-8 | C++ | false | false | 141 | h | #ifndef GEOMETRYOBJECT
#define GEOMETRYOBJECT
class oGeometry
{
private:
public:
oGeometry();
~oGeometry();
};
#endif // GEOMETRYOBJECT | [
"Jake.Scrivener55@gmail.com"
] | Jake.Scrivener55@gmail.com |
6929ab2ce015d8087bd1e6a8b18d15dd25dcdb5f | fac8de123987842827a68da1b580f1361926ab67 | /inc/physics/Physics/Collide/Query/Collector/PointCollector/hkpSimpleClosestContactCollector.inl | e5b9288656aa310cae9ee885add001b95c22fb69 | [] | no_license | blockspacer/transporter-game | 23496e1651b3c19f6727712a5652f8e49c45c076 | 083ae2ee48fcab2c7d8a68670a71be4d09954428 | refs/heads/master | 2021-05-31T04:06:07.101459 | 2009-02-19T20:59:59 | 2009-02-19T20:59:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,687 | inl | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent.This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2008 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
void hkpSimpleClosestContactCollector::reset()
{
m_hasHit = false;
m_hitPoint.setDistance( HK_REAL_MAX );
hkpCdPointCollector::reset();
}
hkpSimpleClosestContactCollector::hkpSimpleClosestContactCollector()
{
reset();
}
hkpSimpleClosestContactCollector::~hkpSimpleClosestContactCollector()
{
}
hkBool hkpSimpleClosestContactCollector::hasHit( ) const
{
return m_hasHit;
}
const hkContactPoint& hkpSimpleClosestContactCollector::getHitContact() const
{
return m_hitPoint;
}
/*
* Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20080529)
*
* Confidential Information of Havok. (C) Copyright 1999-2008
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available at
* www.havok.com/tryhavok
*
*/
| [
"uraymeiviar@bb790a93-564d-0410-8b31-212e73dc95e4"
] | uraymeiviar@bb790a93-564d-0410-8b31-212e73dc95e4 |
323c0ba63bba6065b8a05108ab0f5952279529d0 | d8c56ab76e74824ecff46e2508db490e35ad6076 | /ZETLAB/ZETTools/ZETModbus/IZETModbus.h | 9ca453c798b4c69f869dbc2cc536a6bf875496f3 | [] | no_license | KqSMea8/UtilsDir | b717116d9112ec9f6ee41f4882ad3f52ebb2e84b | 14720766a2a60368495681d09676f860ea501df2 | refs/heads/master | 2020-04-25T17:21:39.538945 | 2019-02-27T14:36:32 | 2019-02-27T14:36:32 | null | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 2,342 | h | #pragma once
#include <objbase.h>
#define MAX_PDU_SIZE 253 //ะะฐะบัะธะผะฐะปัะฝัะน ัะฐะทะผะตั ะฟะฐะบะตัะฐ Modbus (PDU) ะฒ ะฑะฐะนัะฐั
#define MIN_PDU_SIZE 1 //ะะธะฝะธะผะฐะปัะฝัะน ัะฐะทะผะตั ะฟะฐะบะตัะฐ Modbus (PDU) ะฒ ะฑะฐะนัะฐั
#define MAX_ADU_SIZE (MAX_PDU_SIZE + 3) //ะะฐะบัะธะผะฐะปัะฝัะน ัะฐะทะผะตั ะฟะฐะบะตัะฐ Modbus (ADU) ะฒ ะฑะฐะนัะฐั
//ะัะธะฑะบะธ, ะฒะพะทะฒัะฐัะฐะตะผัะต ะฒ ะพัะฒะตัะต ััััะพะนััะฒะพะผ
#define MODBUS_ERR_UNKNOWN_ADDR 0x02 //ะฃะบะฐะทะฐะฝ ะฝะตะธะทะฒะตััะฝัะน ะฐะดัะตั ะฟัะธ ะดะพัััะฟะต ะบ ัะตะณะธัััะฐะผ ััััะพะนััะฒะฐ
#define MODBUS_ERR_DEV_BUSY 0x06 //ะฃัััะพะนััะฒะพ ะฒ ะฝะฐััะพััะธะน ะผะพะผะตะฝั ะทะฐะฝััะพ
interface IZETModbus
{
virtual BYTE ReadCoilStatus(BYTE dev_addr, WORD addr, WORD* pBuff, unsigned int flags_num) = 0; //ะะพะปััะธัั ะทะฝะฐัะตะฝะธั ะฝะตัะบะพะปัะบะธั
ัะตะณะธัััะพะฒ ัะปะฐะณะพะฒ
virtual BYTE ReadDiscreteInputs(BYTE dev_addr, WORD addr, WORD* pBuff, unsigned int inputs_num) = 0; //ะะพะปััะธัั ะทะฝะฐัะตะฝะธั ะฝะตัะบะพะปัะบะธั
ะดะธัะบัะตัะฝัั
ะฒั
ะพะดะพะฒ
virtual BYTE ReadHoldingRegisters(BYTE dev_addr, WORD addr, WORD* pBuff, unsigned int& regs_num) = 0; //ะะพะปััะธัั ะทะฝะฐัะตะฝะธั ะฝะตัะบะพะปัะบะธั
ัะตะณะธัััะพะฒ ั
ัะฐะฝะตะฝะธั
virtual BYTE ReadInputRegisters(BYTE dev_addr, WORD addr, WORD* pBuff, unsigned int& regs_num) = 0; //ะะพะปััะธัั ะทะฝะฐัะตะฝะธั ะฝะตัะบะพะปัะบะธั
ัะตะณะธัััะพะฒ ะฒะฒะพะดะฐ
virtual BYTE ForceSingleCoil(BYTE dev_addr, WORD addr, bool value) = 0; //ะะฐะฟะธัะฐัั ะทะฝะฐัะตะฝะธะต ะฒ ัะตะณะธััั ัะปะฐะณะฐ
virtual BYTE PresetSingleRegister(BYTE dev_addr, WORD addr, WORD value) = 0; //ะะฐะฟะธัะฐัั ะทะฝะฐัะตะฝะธะต ะฒ ัะตะณะธััั ะฒะฒะพะดะฐ
virtual BYTE ForceMultipleCoils(BYTE dev_addr, WORD addr, WORD* pBuff, unsigned int flags_num) = 0; //ะะฐะฟะธัะฐัั ะดะฐะฝะฝัะต ะฒ ะฝะตัะบะพะปัะบะพ ัะตะณะธัััะพะฒ ัะปะฐะณะพะฒ
virtual BYTE PresetMultipleRegisters(BYTE dev_addr, WORD addr, WORD* pBuff, unsigned int ®s_num) = 0;//ะะฐะฟะธัะฐัั ะดะฐะฝะฝัะต ะฒ ะฝะตัะบะพะปัะบะพ ัะตะณะธัััะพะฒ ะฒะฒะพะดะฐ
};
#include <Exception/Exception.h>
class ModbusException : public Exception
{
public:
ModbusException(unsigned int err) : Exception(err) {};
}; | [
"s-kacnep@ya.ru"
] | s-kacnep@ya.ru |
21c13b03c6130933e5087ad75a2d954b75923158 | 21553f6afd6b81ae8403549467230cdc378f32c9 | /arm/cortex/Freescale/MK22F12810/include/arch/reg/mcm.hpp | ae9383ab204a2801d0f84221f5157c9f46428bb8 | [] | no_license | digint/openmptl-reg-arm-cortex | 3246b68dcb60d4f7c95a46423563cab68cb02b5e | 88e105766edc9299348ccc8d2ff7a9c34cddacd3 | refs/heads/master | 2021-07-18T19:56:42.569685 | 2017-10-26T11:11:35 | 2017-10-26T11:11:35 | 108,407,162 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,229 | hpp | /*
* OpenMPTL - C++ Microprocessor Template Library
*
* This program is a derivative representation of a CMSIS System View
* Description (SVD) file, and is subject to the corresponding license
* (see "Freescale CMSIS-SVD License Agreement.pdf" in the parent directory).
*
* 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.
*/
////////////////////////////////////////////////////////////////////////
//
// Import from CMSIS-SVD: "Freescale/MK22F12810.svd"
//
// vendor: Freescale Semiconductor, Inc.
// vendorID: Freescale
// name: MK22F12810
// series: Kinetis_K
// version: 1.6
// description: MK22F12810 Freescale Microcontroller
// --------------------------------------------------------------------
//
// C++ Header file, containing architecture specific register
// declarations for use in OpenMPTL. It has been converted directly
// from a CMSIS-SVD file.
//
// https://digint.ch/openmptl
// https://github.com/posborne/cmsis-svd
//
#ifndef ARCH_REG_MCM_HPP_INCLUDED
#define ARCH_REG_MCM_HPP_INCLUDED
#warning "using untested register declarations"
#include <register.hpp>
namespace mptl {
/**
* Core Platform Miscellaneous Control Module
*/
struct MCM
{
static constexpr reg_addr_t base_addr = 0xe0080000;
/**
* Crossbar Switch (AXBS) Slave Configuration
*/
struct PLASC
: public reg< uint16_t, base_addr + 0x8, ro, 0xF >
{
using type = reg< uint16_t, base_addr + 0x8, ro, 0xF >;
using ASC = regbits< type, 0, 8 >; /**< Each bit in the ASC field indicates whether there is a corresponding connection to the crossbar switch's slave input port. */
};
/**
* Crossbar Switch (AXBS) Master Configuration
*/
struct PLAMC
: public reg< uint16_t, base_addr + 0xa, ro, 0x17 >
{
using type = reg< uint16_t, base_addr + 0xa, ro, 0x17 >;
using AMC = regbits< type, 0, 8 >; /**< Each bit in the AMC field indicates whether there is a corresponding connection to the AXBS master input port. */
};
/**
* Crossbar Switch (AXBS) Control Register
*/
struct PLACR
: public reg< uint32_t, base_addr + 0xc, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0xc, rw, 0 >;
using ARB = regbits< type, 9, 1 >; /**< Arbitration select */
};
/**
* Interrupt Status and Control Register
*/
struct ISCR
: public reg< uint32_t, base_addr + 0x10, rw, 0x20000 >
{
using type = reg< uint32_t, base_addr + 0x10, rw, 0x20000 >;
using FIOC = regbits< type, 8, 1 >; /**< FPU invalid operation interrupt status */
using FDZC = regbits< type, 9, 1 >; /**< FPU divide-by-zero interrupt status */
using FOFC = regbits< type, 10, 1 >; /**< FPU overflow interrupt status */
using FUFC = regbits< type, 11, 1 >; /**< FPU underflow interrupt status */
using FIXC = regbits< type, 12, 1 >; /**< FPU inexact interrupt status */
using FIDC = regbits< type, 15, 1 >; /**< FPU input denormal interrupt status */
using FIOCE = regbits< type, 24, 1 >; /**< FPU invalid operation interrupt enable */
using FDZCE = regbits< type, 25, 1 >; /**< FPU divide-by-zero interrupt enable */
using FOFCE = regbits< type, 26, 1 >; /**< FPU overflow interrupt enable */
using FUFCE = regbits< type, 27, 1 >; /**< FPU underflow interrupt enable */
using FIXCE = regbits< type, 28, 1 >; /**< FPU inexact interrupt enable */
using FIDCE = regbits< type, 31, 1 >; /**< FPU input denormal interrupt enable */
};
/**
* Compute Operation Control Register
*/
struct CPO
: public reg< uint32_t, base_addr + 0x40, rw, 0 >
{
using type = reg< uint32_t, base_addr + 0x40, rw, 0 >;
using CPOREQ = regbits< type, 0, 1 >; /**< Compute Operation request */
using CPOACK = regbits< type, 1, 1 >; /**< Compute Operation acknowledge */
using CPOWOI = regbits< type, 2, 1 >; /**< Compute Operation wakeup on interrupt */
};
};
} // namespace mptl
#endif // ARCH_REG_MCM_HPP_INCLUDED
| [
"axel@tty0.ch"
] | axel@tty0.ch |
ee29cf1e06303de744f6832d609fcfbbc1f00d68 | fc66f7285c8f68f76cde450f130c334ebdbbaa84 | /src/liblogcabin/Event/SignalTest.cc | 4282c419fe5a40a14648a620ef55347459993670 | [
"ISC"
] | permissive | logcabin/liblogcabin | 231d30488fe7c9f5b13c27322ad26ca0007e9e7d | c41b10eec52b6062ec240b052acb855d3d72cbda | refs/heads/master | 2023-08-19T22:02:38.577581 | 2017-10-13T03:43:38 | 2017-10-13T03:43:38 | 61,775,291 | 39 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 3,989 | cc | /* Copyright (c) 2012 Stanford University
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <gtest/gtest.h>
#include <signal.h>
#include "liblogcabin/Core/Debug.h"
#include "liblogcabin/Event/Loop.h"
#include "liblogcabin/Event/Signal.h"
namespace LibLogCabin {
namespace Event {
namespace {
struct ExitOnSignal : public Event::Signal {
ExitOnSignal(Event::Loop& loop, int signal)
: Signal(signal)
, eventLoop(loop)
, triggerCount(0)
{
}
void handleSignalEvent() {
++triggerCount;
eventLoop.exit();
}
Event::Loop& eventLoop;
uint32_t triggerCount;
};
struct ExitOnTimer : public Event::Timer {
explicit ExitOnTimer(Event::Loop& loop)
: Timer()
, eventLoop(loop)
, triggerCount(0)
{
}
void handleTimerEvent() {
++triggerCount;
eventLoop.exit();
}
Event::Loop& eventLoop;
uint32_t triggerCount;
};
struct EventSignalTest : public ::testing::Test {
EventSignalTest()
: loop()
{
}
Event::Loop loop;
};
struct EventSignalBlockerTest : EventSignalTest {
};
TEST_F(EventSignalBlockerTest, constructor) {
Event::Signal::Blocker block(SIGTERM);
ExitOnSignal signal(loop, SIGTERM);
Event::Signal::Monitor monitor(loop, signal);
EXPECT_EQ(0, kill(getpid(), SIGTERM));
ExitOnTimer timer(loop);
Event::Timer::Monitor timerMonitor(loop, timer);
timer.schedule(1000*1000);
loop.runForever();
EXPECT_EQ(1U, signal.triggerCount);
}
TEST_F(EventSignalBlockerTest, destructor) {
ExitOnSignal signal(loop, SIGTERM);
Event::Signal::Monitor monitor(loop, signal);
{
Event::Signal::Blocker block(SIGTERM);
}
EXPECT_DEATH(kill(getpid(), SIGTERM),
"");
}
TEST_F(EventSignalBlockerTest, block) {
Event::Signal::Blocker block(SIGTERM);
ExitOnSignal signal(loop, SIGTERM);
Event::Signal::Monitor monitor(loop, signal);
block.unblock();
block.block();
block.block();
EXPECT_EQ(0, kill(getpid(), SIGTERM));
ExitOnTimer timer(loop);
Event::Timer::Monitor timerMonitor(loop, timer);
timer.schedule(1000*1000);
loop.runForever();
EXPECT_EQ(1U, signal.triggerCount);
}
TEST_F(EventSignalBlockerTest, unblock) {
Event::Signal::Blocker block(SIGTERM);
ExitOnSignal signal(loop, SIGTERM);
Event::Signal::Monitor monitor(loop, signal);
block.unblock();
block.unblock();
EXPECT_DEATH(kill(getpid(), SIGTERM),
"");
}
TEST_F(EventSignalTest, constructor) {
Event::Signal::Blocker block(SIGTERM);
ExitOnSignal signal(loop, SIGTERM);
Event::Signal::Monitor monitor(loop, signal);
}
TEST_F(EventSignalTest, destructor) {
// Nothing to test.
}
TEST_F(EventSignalTest, fires) {
Event::Signal::Blocker block(SIGTERM);
ExitOnSignal signal(loop, SIGTERM);
Event::Signal::Monitor monitor(loop, signal);
// Warning: if you run this in gdb, you'll need to pass the signal through
// to the application.
EXPECT_EQ(0, kill(getpid(), SIGTERM));
// must have been caught if we get this far
loop.runForever();
EXPECT_EQ(1U, signal.triggerCount);
}
} // namespace LibLogCabin::Event::<anonymous>
} // namespace LibLogCabin::Event
} // namespace LibLogCabin
| [
"tnachen@gmail.com"
] | tnachen@gmail.com |
fafe70f9d44fcc46c35fcdd477ec68d488915ffe | 360f3d117f1c0397cb118a45dec862f8132bc1ff | /data-access/src/preprocess/data_access_impl.h | 7bf257c28c8d74e2301b21a150f22659981650bb | [] | no_license | ldak47/logprocess | 0f64138cb7cadcc88343a490084084656cb755a5 | cee95e4c170e25df16f82a8bc30cab2f2a520172 | refs/heads/master | 2021-01-19T01:00:00.069489 | 2017-08-24T08:40:10 | 2017-08-24T08:40:10 | 95,614,645 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,925 | h | #ifndef DATAACCESS_ACCESS_IMPL_H
#define DATAACCESS_ACCESS_IMPL_H
#include "libconfig.h++"
#include "range_iterator.h"
#include "client_hook.h"
#include "data_access_pv.h"
#include "data_access_filter.h"
#include "data_preprocess_action.h"
#include <boost/lockfree/queue.hpp>
namespace dataaccess {
class Access_Impl {
PvStater &pvstater_;
DataFieldRuler &datafieldruler_;
AccessFilter &accessfilter_;
bool &switch_old_;
bool &switch_new_;
public:
Access_Impl(PvStater &pvstater,
DataFieldRuler &datafieldruler,
AccessFilter &accessfilter,
bool &switch_old,
bool &switch_new);
~Access_Impl(){}
bool Init(const libconfig::Setting &filter_cfg, const libconfig::Setting &field_cfg);
void SetLogFilterConfig(
const manage::SetLogFilterConfigRequest *request,
manage::SetLogFilterConfigResponse *response,
::google::protobuf::Closure *done
);
void GetLogFilterConfig(
const manage::GetLogFilterConfigRequest *request,
manage::GetLogFilterConfigResponse *response,
::google::protobuf::Closure *done
);
void SetLogFieldConfig(
const manage::SetLogFieldConfigRequest *request,
manage::SetLogFieldConfigResponse *response,
::google::protobuf::Closure *done
);
void GetLogFieldConfig(
const manage::GetLogFieldConfigRequest *request,
manage::GetLogFieldConfigResponse *response,
::google::protobuf::Closure *done
);
void GetLogTransmitStat(
const manage::GetLogTransmitStatRequest *request,
manage::GetLogTransmitStatResponse *response,
::google::protobuf::Closure *done
);
void AddLogTransmitStat(
const manage::AddLogTransmitStatRequest *request,
manage::AddLogTransmitStatResponse *response,
::google::protobuf::Closure *done
);
void PullSwitchConfig(
const manage::PullSwitchConfigRequest *request,
manage::PullSwitchConfigResponse *response,
::google::protobuf::Closure *done
);
void Retransmit(
const manage::RetransmitRequest *request,
manage::RetransmitResponse *response,
::google::protobuf::Closure *done
);
};
};
#endif
| [
"root@cp01-misheng-glb-test01.epc.baidu.com"
] | root@cp01-misheng-glb-test01.epc.baidu.com |
48771d1cb98bb166f8930fe1efa78cbefa2255f7 | 41f5ce839be6d4c247bce5d5b5d687ad3bf60c45 | /C++ Programs/Timer.cpp | 6a156b50c94e37d6478636476e95bd4538f59c71 | [] | no_license | himanshusanecha/One-day-Before-Interview | 269bd617fdc71419460f7f487d66d7bb19f40ec6 | bf1dc77c009ae9ddf1920dde4f684248c54559ac | refs/heads/master | 2023-08-24T08:58:01.572847 | 2021-10-24T20:45:42 | 2021-10-24T20:45:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,476 | cpp | #include <iostream>
#include <utility>
#include <vector>
#include <numeric>
#include <queue>
#include <cmath>
#include <map>
#include <string>
#include <cstring>
#include <algorithm>
#include <fstream>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <list>
#include <stack>
#define ll long long
#define dd double
#include <stack>
#include <chrono>
#include <thread>
using namespace std;
struct Timer{
chrono::time_point<chrono::system_clock> start,end;
chrono::duration<float> duration;
Timer(){
start = chrono::system_clock::now();
}
~Timer(){
end = chrono::system_clock::now();;
duration = end - start;
float ms = duration.count() * 1000.0f;
cout<<"\nFunction took: "<<ms<<"ms"<<endl;
}
};
void sorted(){
Timer timer;
vector<int> x={1,1,32,1,532,723,19,131,13223,15};
vector<int> sorted;
while(!x.empty()){
auto mine=min_element(x.begin(), x.end());
sorted.push_back(*mine);
x.erase(mine);
}
for(auto t: sorted){
cout<<t<<" ";
}
}
int main(){
sorted();
}
//int main()
//{
//
// std::chrono::time_point<std::chrono::system_clock> start, end;
//
// start = std::chrono::system_clock::now();
// sorted();
// end = std::chrono::system_clock::now();
//
// std::chrono::duration<double> elapsed_seconds = end - start;
//
// std::cout<< "\nElapsed time: " << elapsed_seconds.count() << "s\n";
//} | [
"iamvikrant1@gmail.com"
] | iamvikrant1@gmail.com |
1a89b6b4760fae6c0d363632a0058cbdac441b13 | 91a286855887229c2603a049841ec1cb23a7495f | /getComment.cpp | 7fac168980bad961ce58f6336061c4c4414af1b4 | [] | no_license | iourigouz/LHCbCALOtb | e2c89d0c4d4228a225382035f81ca77e185f6e06 | cc00acfd9acf7bbc46c2686db3aabc861c577c58 | refs/heads/master | 2021-06-22T20:15:26.509656 | 2021-05-11T17:29:49 | 2021-05-11T17:29:49 | 213,742,670 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,112 | cpp | //
// Author: Ilka Antcheva 1/12/2006
// This macro gives an example of how to create a status bar
// related to an embedded canvas that shows the info of the selected object
// exactly as the status bar of any canvas window
// To run it do either:
// .x statusBar.C
// .x statusBar.C++
#include <math.h>
#include <iostream>
#include <map>
#include "TROOT.h"
#include "TSystem.h"
#include "TApplication.h"
#include "TGClient.h"
#include "TClass.h"
#include "TString.h"
#include "getComment.h"
ClassImp(getComment)
#define TOTWID 500
#define TOTHGT 500
getComment::getComment(const TGWindow *main, char* answer, char* comment)
{
Answer=answer;
Comment=comment;
fMain = new TGTransientFrame(gClient->GetRoot(), main, TOTWID, TOTHGT);
fMain->Connect("CloseWindow()", "getComment", this, "CloseWindow()");
fMain->DontCallClose(); // to avoid double deletions.
// use hierarchical cleaning
fMain->SetCleanup(kDeepCleanup);
TGHorizontalFrame *hframCom = new TGHorizontalFrame(fMain, TOTWID, 40);
TGLabel *tCom=new TGLabel(hframCom,"Enter a comment:");
hframCom->AddFrame(tCom, new TGLayoutHints(kLHintsLeft, 5, 1, 3, 4));
fMain->AddFrame(hframCom,new TGLayoutHints(kLHintsLeft, 5, 1, 3, 4));
fEdit = new TGTextEdit(fMain, TOTWID, 300, kSunkenFrame | kDoubleBorder);
fMain->AddFrame(fEdit, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 3, 3, 3, 3));
fEdit->Connect("Closed()", "getComment", this, "DoCANCEL()");
// Create a horizontal frame for OK and CANCEL buttons
TGHorizontalFrame *hframButt = new TGHorizontalFrame(fMain, TOTWID, 50);
fOK = new TGTextButton(hframButt, " &OK ");
//fOK->SetToolTipText("YES, PLEASE add the comment to the logbook",200);
fOK->Connect("Released()", "getComment", this, "DoOK()");
hframButt->AddFrame(fOK, new TGLayoutHints(kLHintsLeft, 5, 1, 3, 4));
fCANCEL = new TGTextButton(hframButt, " &CANCEL ");
//fCANCEL->SetToolTipText("NO, DO NOT add the comment to the logbook",200);
fCANCEL->Connect("Released()", "getComment", this, "DoCANCEL()");
hframButt->AddFrame(fCANCEL, new TGLayoutHints(kLHintsLeft, 5, 1, 3, 4));
fMain->AddFrame(hframButt,new TGLayoutHints(kLHintsLeft, 5, 1, 3, 4));
SetTitle();
fMain->MapSubwindows();
fMain->Resize();
// editor covers right half of parent window
fMain->CenterOnParent(kTRUE, TGTransientFrame::kRight);
}
getComment::~getComment()
{
// Delete editor dialog.
fMain->DeleteWindow(); // deletes fMain
}
void getComment::Popup()
{
fMain->MapWindow();
gClient->WaitFor(fMain);
}
void getComment::SetTitle()
{
fMain->SetWindowName("getComment");
fMain->SetIconName("getComment");
}
void getComment::CloseWindow()
{
// Called when closed via window manager action.
delete this;
}
void getComment::DoOK()
{
// Handle ok button.
strcpy(Answer,"OK");
TString tstrcomm=(fEdit->GetText()->AsString());
const char* txtcomm=(const char*)tstrcomm;
strncpy(Comment, txtcomm, 10000); Comment[10000]=0;
CloseWindow();
}
void getComment::DoCANCEL()
{
// Handle ok button.
strcpy(Answer,"CANCEL");
CloseWindow();
}
| [
"yuri@pclbectb01.dyndns.cern.ch"
] | yuri@pclbectb01.dyndns.cern.ch |
71ab89c0b958fdb8badb1a3de401c327259958f2 | ea7777c7dcfa42d5b9d46871098f7e6eb68dd712 | /project 2/2. Simulation Module/Simulation Code/Simulation Module code/Path.h | aa83a1db313d8bdfd190c451e6b996b63ee361a7 | [] | no_license | cli402/CS6730-Project | 28187510bf4c5bcdf4eafa3ea3980f798d5f7e8e | 4574ea8f02973dee2a033cabe40441df0a69489c | refs/heads/master | 2021-01-10T13:07:24.023662 | 2016-02-24T22:25:03 | 2016-02-24T22:25:03 | 52,470,741 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 791 | h | #ifndef DISTANCE_H_INCLUDED
#define DISTANCE_H_INCLUDED
#include <vector>
#include <string>
#include <queue>
using namespace std;
static const int number=50;
class Dij{
public:
queue <int> shortestPath;
static const int numOfV = number;
int predecessor[numOfV], distance[numOfV];
int adjMatrix[number][number];
void trys(string);
int tree[numOfV][numOfV];
bool mark[numOfV];
int source;
int dest;
void initialize();
void calculateDistance();
void output();
void printPath(int);
int getClosestUnmarkedNode();
};
void Init_Graph(Dij*G);
queue<int> Shortest_Path(int, int , Dij&);
void Print_Path(queue<int> a);
void Clear_Path(queue<int> *a);
#endif // DISTANCE_H_INCLUDED
| [
"chengwei.li@careerbuilder.com"
] | chengwei.li@careerbuilder.com |
2d2d34b35c631e97a158268d1e8810ccd73eb162 | f7f9c671dd998eeee5857d3042a22d27108c8d8b | /AesQtApp/Aes256.h | 983593878604254fe499036f67766bfebf6de106 | [] | no_license | wald3/Aes256App | f5315babc83b8ed625693edf0336c0c10e0aacf0 | 54a9cf8721ce60402ec1766eac922119144ed469 | refs/heads/master | 2020-12-01T22:01:41.372704 | 2019-12-29T17:47:54 | 2019-12-29T17:47:54 | 230,784,229 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,466 | h | #ifndef AES256_HPP
#define AES256_HPP
#include <vector>
typedef std::vector<unsigned char> ByteArray;
#define BLOCK_SIZE 16
class Aes256 {
public:
Aes256(const ByteArray& key);
~Aes256();
static ByteArray::size_type encrypt(const ByteArray& key, const ByteArray& plain, ByteArray& encrypted);
static ByteArray::size_type encrypt(const ByteArray& key, const unsigned char* plain, const ByteArray::size_type plain_length, ByteArray& encrypted);
static ByteArray::size_type decrypt(const ByteArray& key, const ByteArray& encrypted, ByteArray& plain);
static ByteArray::size_type decrypt(const ByteArray& key, const unsigned char* encrypted, const ByteArray::size_type encrypted_length, ByteArray& plain);
ByteArray::size_type encrypt_start(const ByteArray::size_type plain_length, ByteArray& encrypted);
ByteArray::size_type encrypt_continue(const ByteArray& plain, ByteArray& encrypted);
ByteArray::size_type encrypt_continue(const unsigned char* plain, const ByteArray::size_type plain_length, ByteArray& encrypted);
ByteArray::size_type encrypt_end(ByteArray& encrypted);
ByteArray::size_type decrypt_start(const ByteArray::size_type encrypted_length);
ByteArray::size_type decrypt_continue(const ByteArray& encrypted, ByteArray& plain);
ByteArray::size_type decrypt_continue(const unsigned char* encrypted, const ByteArray::size_type encrypted_length, ByteArray& plain);
ByteArray::size_type decrypt_end(ByteArray& plain);
private:
ByteArray m_key;
ByteArray m_salt;
ByteArray m_rkey;
unsigned char m_buffer[3 * BLOCK_SIZE];
unsigned char m_buffer_pos;
ByteArray::size_type m_remainingLength;
bool m_decryptInitialized;
void check_and_encrypt_buffer(ByteArray& encrypted);
void check_and_decrypt_buffer(ByteArray& plain);
void encrypt(unsigned char* buffer);
void decrypt(unsigned char* buffer);
void expand_enc_key(unsigned char* rc);
void expand_dec_key(unsigned char* rc);
void sub_bytes(unsigned char* buffer);
void sub_bytes_inv(unsigned char* buffer);
void copy_key();
void add_round_key(unsigned char* buffer, const unsigned char round);
void shift_rows(unsigned char* buffer);
void shift_rows_inv(unsigned char* buffer);
void mix_columns(unsigned char* buffer);
void mix_columns_inv(unsigned char* buffer);
};
#endif /* AES256_HPP */
| [
"onessse@gmail.com"
] | onessse@gmail.com |
f053d6f0a41ab66d1dbebd2c3961a327b690d3de | f21294b3508c96643c7088f74e4b01c776fb95f0 | /wrapper/Examples/MotionControlTestWrappedCPP/MotionControlTestWrappedCPP.cpp | f6c668c2e1c71b964ce3fce96eaafb1cbf8aa122 | [] | no_license | Roel1l/wrapper | fac272907ea429bd3255b55c11cf765d313f12cc | efac82e14147175d195fcf8f7a5a597a14d794a7 | refs/heads/master | 2021-08-14T17:56:39.169987 | 2017-11-16T10:40:16 | 2017-11-16T10:40:16 | 110,958,843 | 0 | 0 | null | null | null | null | IBM852 | C++ | false | false | 2,230 | cpp | // MotionControlTestWrappedCPP.cpp : Defines the entry point for the console application.
//
#include <iostream>
#include "stdafx.h"
#include <Windows.h>
#include <string>
#include "mctl.h"
#include "mctlWrapper.h"
using namespace std;
typedef DWORD(*MCTLW_INIT)(char*);
typedef DWORD(*MCTLW_MOVEABS)(LPAXISPOS);
typedef DWORD(*MCTLW_EXIT)(void);
typedef DWORD(*MCTLW_RESET)(void);
typedef DWORD(*MCTLW_REFERENCE)(DWORD);
int main()
{
cout << "MotionControlTestWrappedCPP starting" << endl;
HINSTANCE hInstLibrary = LoadLibraryA("mctlWrapper.dll");
if (hInstLibrary)
{
cout << "canapi loaded successfully" << endl;
MCTLW_INIT _initialize = (MCTLW_INIT)GetProcAddress(hInstLibrary, "mctlw_Initialize");
MCTLW_MOVEABS _moveAbs = (MCTLW_MOVEABS)GetProcAddress(hInstLibrary, "mctlw_MoveAbs");
MCTLW_EXIT _xit = (MCTLW_EXIT)GetProcAddress(hInstLibrary, "mctlw_Exit");
MCTLW_RESET _reset = (MCTLW_RESET)GetProcAddress(hInstLibrary, "mctlw_Reset");
MCTLW_REFERENCE _reference = (MCTLW_REFERENCE)GetProcAddress(hInstLibrary, "mctlw_Reference");
unsigned int uiResult = 0;
uiResult = _initialize("c:\\CNCworkbench\\Control\\CAN\\CAN_PCI_3_Axis.ini");
if ((uiResult & 0xC000FFFF) == 0)
{
uiResult = _reset();
if ((uiResult & 0xC000FFFF) == 0)
{
uiResult = _reference(1);
if ((uiResult & 0xC000FFFF) == 0)
{
AXISPOS ax;
ax.X = 100000; // รm
ax.Y = 120000; // รm
//Correct init bug...
ax.Z = 0;
ax.A = 0;
ax.B = 0;
ax.C = 0;
ax.U = 0;
ax.V = 0;
ax.W = 0;
printf("Bewegung wird gestartet.\n");
uiResult = _moveAbs(&ax);
if ((uiResult & 0xC000FFFF) == 0)
{
string dump;
cout << "whack a key once movement stops" << endl;
getline(cin, dump);
uiResult = _xit();
}
else
{
printf("Fehler bei axctl_MoveAbs: %x", uiResult);
}
}
else
{
printf("Fehler bei axctl_Reference: %x", uiResult);
}
}
else
{
printf("Fehler bei axctl_Reset: %x", uiResult);
}
}
else
{
printf("Fehler bei mctl_Initialize: %x", uiResult);
}
FreeLibrary(hInstLibrary);
}
else
{
cout << "failed to load mctlWrapper" << endl;
}
return 0;
}
| [
"raa.guerand@student.avans.nl"
] | raa.guerand@student.avans.nl |
a588d4a7f1be35ab0b794de288605f7cf38c4d5d | 51e245861cf33d14f73e772ebb74230e14d6a58c | /src/Core/Entities/Entity.cpp | 26253b34baa20926990c20fbab99deabeefcb158 | [] | no_license | ErickNK/BlastEngine | 83fbe82b84931be0880d0bfef7ce39268f3bc67f | 96bb7a8fb240d33188761f86afb3aac475d9eb17 | refs/heads/master | 2020-03-31T14:37:25.115378 | 2018-10-27T14:36:08 | 2018-10-27T14:36:08 | 152,302,765 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 59 | cpp | //
// Created by erick on 9/16/18.
//
#include "Entity.h"
| [
"eriknjiru73@gmail.com"
] | eriknjiru73@gmail.com |
0e006270e22a72eca287b0b31ab0f1c2e8bcb173 | 08b8cf38e1936e8cec27f84af0d3727321cec9c4 | /data/crawl/wget/new_hunk_3396.cpp | 1e08e6020f4cf4589c866f3ada777c63650a94e1 | [] | no_license | ccdxc/logSurvey | eaf28e9c2d6307140b17986d5c05106d1fd8e943 | 6b80226e1667c1e0760ab39160893ee19b0e9fb1 | refs/heads/master | 2022-01-07T21:31:55.446839 | 2018-04-21T14:12:43 | 2018-04-21T14:12:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 464 | cpp | {
if (!chain->permanent)
continue;
if (COOKIE_EXPIRED_P (chain))
continue;
fputs (domain, fp);
if (chain->port != PORT_ANY)
fprintf (fp, ":%d", chain->port);
fprintf (fp, "\t%s\t%s\t%s\t%.0f\t%s\t%s\n",
*domain == '.' ? "TRUE" : "FALSE",
chain->path, chain->secure ? "TRUE" : "FALSE",
(double)chain->expiry_time,
chain->attr, chain->value);
if (ferror (fp))
return 1; /* stop mapping */
| [
"993273596@qq.com"
] | 993273596@qq.com |
121e87d372a7d7b5436e613ff56b7dbfe629efe6 | aa650dcd632a4e50c83af9564ea973549f592017 | /src/leveldb/db/filename.h | 54b70043b71ba79276d0c5b1b7ba7529912d6cbd | [
"MIT",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla"
] | permissive | Buenoscoin/Buenoscoin | 16815c26cfc630ab85a25fdb5b41b7e66b376802 | 8dae1d242a99fab55802d8958a831d83db6ac008 | refs/heads/master | 2020-03-17T10:11:42.422660 | 2018-09-26T02:03:53 | 2018-09-26T02:03:53 | 133,503,459 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,048 | h | // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
//
// File names used by DB code
#ifndef STORAGE_LEVELDB_DB_FILENAME_H_
#define STORAGE_LEVELDB_DB_FILENAME_H_
#include <stdint.h>
#include <string>
#include "leveldb/slice.h"
#include "leveldb/status.h"
#include "port/port.h"
namespace leveldb {
class Env;
enum FileType {
kLogFile,
kDBLockFile,
kTableFile,
kDescriptorFile,
kCurrentFile,
kTempFile,
kInfoLogFile // Either the current one, or an old one
};
// Return the name of the log file with the specified number
// in the db named by "dbname". The result will be prefixed with
// "dbname".
extern std::string LogFileName(const std::string& dbname, uint64_t number);
// Return the name of the sstable with the specified number
// in the db named by "dbname". The result will be prefixed with
// "dbname".
extern std::string TableFileName(const std::string& dbname, uint64_t number);
// Return the legacy file name for an sstable with the specified number
// in the db named by "dbname". The result will be prefixed with
// "dbname".
extern std::string SSTTableFileName(const std::string& dbname, uint64_t number);
// Return the name of the descriptor file for the db named by
// "dbname" and the specified incarnation number. The result will be
// prefixed with "dbname".
extern std::string DescriptorFileName(const std::string& dbname,
uint64_t number);
// Return the name of the current file. This file contains the name
// of the current buenfest file. The result will be prefixed with
// "dbname".
extern std::string CurrentFileName(const std::string& dbname);
// Return the name of the lock file for the db named by
// "dbname". The result will be prefixed with "dbname".
extern std::string LockFileName(const std::string& dbname);
// Return the name of a temporary file owned by the db named "dbname".
// The result will be prefixed with "dbname".
extern std::string TempFileName(const std::string& dbname, uint64_t number);
// Return the name of the info log file for "dbname".
extern std::string InfoLogFileName(const std::string& dbname);
// Return the name of the old info log file for "dbname".
extern std::string OldInfoLogFileName(const std::string& dbname);
// If filename is a leveldb file, store the type of the file in *type.
// The number encoded in the filename is stored in *number. If the
// filename was successfully parsed, returns true. Else return false.
extern bool ParseFileName(const std::string& filename,
uint64_t* number,
FileType* type);
// Make the CURRENT file point to the descriptor file with the
// specified number.
extern Status SetCurrentFile(Env* env, const std::string& dbname,
uint64_t descriptor_number);
} // namespace leveldb
#endif // STORAGE_LEVELDB_DB_FILENAME_H_
| [
"barneychambers@hotmail.com"
] | barneychambers@hotmail.com |
c2b89d0face9e627acb892cc126b90bc80fbe9b9 | 70a68b26754dea16f643ecb97ce06eeb6ab9f026 | /Multi Asteroids/States/MPState.h | 6c915c30cee938407a5d6d08070505a6b7c36556 | [] | no_license | Mesiow/Masteroids | 726c645206e846b722aa58e0dd8e7be291d6ab9f | 8fc6e4070b3445c21f46bdcd7b524194dead36db | refs/heads/main | 2023-03-03T07:25:58.801357 | 2021-02-10T00:10:31 | 2021-02-10T00:10:31 | 335,388,669 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 575 | h | #pragma once
#include <Game/State/State.h>
#include <Game/Utility/FPSCounter.h>
#include "../Net/Peer.h"
#include "../Entities/Starfield.h"
/*
Multiplayer state instance of the game
*/
class MPState : public State {
public:
MPState(Game* game, bool peerHost = true);
~MPState();
void handleEvents(sf::Event& ev, sf::RenderWindow& window)override;
void handleInput(float dt)override;
void update(float dt)override;
void render(sf::RenderWindow& window)override;
private:
Peer* _peer = nullptr; //multiplayer instance
Starfield _starfield;
FPSCounter _counter;
}; | [
"34993144+Mesiow@users.noreply.github.com"
] | 34993144+Mesiow@users.noreply.github.com |
9a7796a82b6899abb220e6dc8e63f5214cab85d3 | d90cc5b23233e1a6f48bc2de2d8831370d953a9f | /HACKEDGame/Source/HACKED/InGame/Character/ESPER/HACKED_ESPER.h | e4b376d1204e0bc61a9a29eb7b007862eec708e2 | [] | no_license | LJH960101/JHNet_HACKED | d1389fd9303932eda57b9742d75fc82a5543035a | 13962fc4dc16ad4d852c09bec7a85be6a8b0f9a0 | refs/heads/main | 2023-06-15T00:43:43.398914 | 2021-07-04T08:22:38 | 2021-07-04T08:22:38 | 326,329,710 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 18,490 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "HACKED.h"
#include "InGame/Character/HACKEDCharacter.h"
#include "ESPER_StatComponent.h"
#include "InGame/Network/Component/NetworkBaseCP.h"
#include "HACKED_ESPER.generated.h"
UCLASS()
class HACKED_API AHACKED_ESPER : public AHACKEDCharacter
{
GENERATED_BODY()
public:
// Sets default values for this character's properties
AHACKED_ESPER();
virtual void Possessed(AController* NewController) override;
virtual void UnPossessed() override;
// Called every frame
virtual void Tick(float DeltaTime) override;
virtual void PostInitializeComponents() override;
// Called to bind functionality to input
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
UFUNCTION(BlueprintPure, Category = SkillSystem)
virtual int GetSkillRate(int skill);
UFUNCTION(BlueprintPure, Category = EsperPrimaryAttack)
bool GetOnPrimaryAttack() { return bOnPrimaryAttack; }
UFUNCTION(BlueprintImplementableEvent, Category = Aim)
void OnHitAim(bool IsCritical);
bool IsOnSelfHealing();
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
virtual float TakeDamage(float DamageAmount, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;
public:
void InitEsperStat();
UPROPERTY(VisibleAnywhere, Category = Stat)
class UESPER_StatComponent* Esper_Stat;
public:
UFUNCTION(BlueprintImplementableEvent, Category = Sound)
void PlaySkill1Sound(FVector location);
UFUNCTION(BlueprintImplementableEvent, Category = Sound)
void PlaySkill2Sound(FVector location);
private:
//------------์ง์คํ ์ถํ ๋ฐ ์คํ ์ถ์ ์ํ ์ต์ข
์์คํผ ์์น ๋ฐ์ดํฐ ํ
์ด๋ธ ์ ์ฉ์ ์ํ ํจ์์
๋๋ค. ----------------//
FHACKED_ESPER_Stat esperStat;
float GetMaxHp();
float GetprimaryAttackDamage();
float GetPASPDamage();
float GetPASPRange();
float GetPASpeed();
float GetPsychicForceDamage();
float GetPsychicForceRange();
float GetPsychicDropDamage();
float GetPsychicDropRange();
float GetPsychicWaveDamage();
float GetPsychicWaveRange();
// Aim ์์ ฏ์ ์์ฑ๋๋ค.
// ๊ฒ์์ค๋ฒ์์ ์ฌ์ฉํฉ๋๋ค.
void DisableAimWidget();
// ๋ชจ๋ ์คํฌ์ BindAction์ ํ ๋น๋ ์คํฌ ๊ณ ์ ์ ๋ค์ด๋ฐ์ ํจ์์์ ์์๋ฉ๋๋ค. (SetupPlayerInputComponent ์ฐธ๊ณ )
// ๋ชจ๋ ์คํฌ์ ํค๋์ ๋์ด๋ ์์๋๋ก ํธ์ถ๋์ด ์ฌ์ฉ๋ฉ๋๋ค.
private:
//------------ Link Beam ------------//
public:
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = LinkBeam, Meta = (AllowPrivateAccess = true))
class UParticleSystemComponent* PC_LinkBeam = nullptr;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = VitalityShield, Meta = (AllowPrivateAccess = true))
class UParticleSystem* PS_LinkBeam;
public:
RPC_FUNCTION(AHACKED_ESPER, EsperIntroSkipStart)
UFUNCTION()
void EsperIntroSkipStart();
UFUNCTION()
void EsperIntroSkip();
RPC_FUNCTION(AHACKED_ESPER, EsperIntroSkipStop)
UFUNCTION()
void EsperIntroSkipStop();
UFUNCTION(BlueprintImplementableEvent)
void EsperTurnOffSkipUI();
private:
//------------ Esper Primary Attack ------------//
RPC_FUNCTION(AHACKED_ESPER, Esper_Attack)
void Esper_Attack();
RPC_FUNCTION(AHACKED_ESPER, Esper_AttackEnd)
void Esper_AttackEnd();
bool bOnPrimaryAttack; // ๊ณต๊ฒฉ์ค์ธ์ง๋ฅผ ์์๋ด๋ ๋ณ์์
๋๋ค.
// ๊ณต๊ฒฉ์ ๋ฐ๋ํฉ๋๋ค.
UFUNCTION()
void OnAttackCheck();
//------------ Skill(1). Psychic Force ------------//
// ์คํฌ ์ค๋ช
: ์์คํผ ์ฃผ๋ณ์ ์ ์ ์ผ๋๋ ฅ์ผ๋ก ๊ฐํ๊ฒ ๋ฐ์ด๋ด๋ฉฐ, ์ฝ๊ฐ์ ํผํด๋ฅผ ์ค๋๋ค.
private:
RPC_FUNCTION(AHACKED_ESPER, PsychicForce)
UFUNCTION()
void PsychicForce(); // Psychic Force ์คํฌ์ ์ฌ์ฉํ๊ธฐ ์ํ ์์ ํจ์์
๋๋ค. <Delegate ํธ์ถ>
UFUNCTION()
void PsychicForceDamaging(); // HACKED_AI์ ๋ง๋ HACKEDLaunchCharacterํจ์๋ฅผ ํตํด ์ ์ ๋ฐ์ด๋ด๋ฉฐ ํผํด๋ฅผ ์ฃผ๋ ํจ์์
๋๋ค. <Delegate ํธ์ถ>
UFUNCTION()
void PsychicForceStun(); // ํผํด๋ฅผ ์
์ AI์๊ฒ ์ ์๋์ ์คํด์ ๋ฃ์ด์ฃผ๋ ํจ์์
๋๋ค. <๊ฐ๋ณ ํธ์ถ>
UFUNCTION()
void OnPsychicForceEnd(); // ํด๋น ์คํฌ์ด ๋๋ ๊ธฐ๋ณธ State๋ก ๋์๊ฐ๊ธฐ ์ํ ์๋ ํจ์์
๋๋ค. <Delegate ํธ์ถ>
TArray<class AHACKED_AI*> PsychicForceCheckAI;
public:
UFUNCTION()
void PsychicForceDamageChange(float plusDamage);
//------------ Skill(M). Psychic Drop ------------//
// ์คํฌ ์ค๋ช
: ์์คํผ๊ฐ ์์ด๋ฐ ์์ ์ค๋ธ์ ํธ์ ์๋์ง ๊ตฌ์ฒด๋ฅผ ๋ถ์ธํ ํฐ๋จ๋ ค ํผํด๋ฅผ ์
ํ๋ ์คํฌ์
๋๋ค. (์ต๋ ์ฌ๊ฑฐ๋ฆฌ 15m)
private:
RPC_FUNCTION(AHACKED_ESPER, PsychicDrop)
UFUNCTION()
void PsychicDrop(); // Psychic Force ์คํฌ์ ์ฌ์ฉํ๊ธฐ ์ํ ์์ ํจ์์
๋๋ค.
UFUNCTION()
void PsychicDropSpawnEmitter(); // ํ๋ ์ด์ด๊ฐ ์ง์ ํ ๋ชฉํ์ ์ดํํธ๋ฅผ ์ํํ๊ธฐ ์ํ ํจ์ (ํด๋น ํจ์ ๋ค์ AfterDamage๋ฅผ ์ํด PsychicDropDamaging์ด ํธ์ถ๋ฉ๋๋ค.)
RPC_FUNCTION(AHACKED_ESPER, RPCSpawnDropEmitter, FVector, FVector)
UFUNCTION()
void RPCSpawnDropEmitter(FVector targetPoint, FVector targetRotation);
UFUNCTION()
void OnPsychicDropDamaging(); // ์์ฑ๋ ์ดํํธ์ ๋ฒ์ ํผํด๋ฅผ ์ฃผ๊ธฐ ์ํ ํจ์์
๋๋ค.
UFUNCTION()
void OnPsychicDropEnd(); // ํด๋น ์คํฌ์ด ๋๋ ๊ธฐ๋ณธ State๋ก ๋์๊ฐ๊ธฐ ์ํ ์๋ ํจ์์
๋๋ค.
class AEsper_PsychicDrop* lastPhychicDrop;
UPROPERTY(VisibleAnywhere)
class UParticleSystem* PS_PsychicDropCharge;
public:
UFUNCTION()
void PsychicDropDamageChange(float plusDamage);
//------------ Skill(2). Psychic ShockWave ------------//
// ์คํฌ ์ค๋ช
: ์์คํผ๊ฐ ์ ๋ฐฉ์ ๊ฐ๋ ฅํ ์๋์ง๋น์ ๋ฐ์ฌํฉ๋๋ค. ์ข์ฐ ํ์ ๋ง์ผ๋ก ๋ฐ๋ฏธ์ง๋ฅผ ์
ํ์ ์์ต๋๋ค.
private:
RPC_FUNCTION(AHACKED_ESPER, PsychicShockWave)
UFUNCTION()
void PsychicShockWave(); // Psychic ShockWave ์คํฌ์ ์ฌ์ฉํ๊ธฐ ์ํ ์์ ํจ์์
๋๋ค.
UFUNCTION()
void ShockWaveSpawnEmitter(); // ์ธ์ดํฅ ์ผํฌ์จ์ด๋ธ ์ดํํธ๋ฅผ ์ํํฉ๋๋ค.
UFUNCTION()
void ShockWaveDamagingStart(); // ์ธ์ดํฅ ์ผํฌ ์จ์ด๋ธ ๋ฐ๋ฏธ์ง ์คํํธ
UFUNCTION()
void ShockWaveDamaging(); // ์ ๋ฐฉ์ ๋ณต์์ ์ ์๊ฒ ๋ํธ ๋ฐ๋ฏธ์ง๋ฅผ ์
ํ๋๋ค.
UFUNCTION()
void ShockWaveDamagingEnd(); // ์ธ์ดํฅ ์ผํฌ์จ์ด๋ธ ์ดํํธ๋ฅผ ์ญ์ ํ๋ฉฐ, ๋ฐ๋ฏธ์ง์ ์ข
๋ฃํฉ๋๋ค.
UFUNCTION()
void ShockWaveSetTarget(); // Beam Data Type์ธ ์ธ์ดํฅ ์ผํฌ์จ์ด๋ธ ์ดํํธ์ ๋ฐฉํฅ์ ๋ง์ถค๊ณผ ๋์์ ์ดํํธ์ ์บ๋ฆญํฐ์ ํ์ ์ ๋๊ธฐํํฉ๋๋ค.
UFUNCTION()
void ShockWaveEnd(); // ํด๋น ์คํฌ์ด ๋๋ ๊ธฐ๋ณธ State๋ก ๋์๊ฐ๊ธฐ ์ํ ์๋ ํจ์์
๋๋ค.
UPROPERTY(VisibleAnywhere)
class UParticleSystemComponent* ShockWave = nullptr;
UPROPERTY(VisibleAnywhere)
class UParticleSystemComponent* ShockWaveHit = nullptr;
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Particle, Meta = (AllowPrivateAccess = "true"))
class UParticleSystem* PA_ShockWave;
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Particle, Meta = (AllowPrivateAccess = "true"))
class UParticleSystem* PA_ShockWaveHit;
public:
UFUNCTION()
void PsychicShockWaveDamageChange(float plusDamage);
//------------ Skill(3). Psychic Shield ------------//
// ์คํฌ ์ค๋ช
: ์์คํผ๊ฐ ์ค๋๋ฅผ ์์ฑํฉ๋๋ค. ๋ฐ๊ฒฝ 7m ๋ด์ ํฌ๋ฌ์
๊ฐ ์์๊ฒฝ์ฐ ํฌ๋ฌ์
๋ ์ค๋ ํจ๊ณผ๋ฅผ ๊ฐ์ด ๋ฐ์ต๋๋ค.
private:
RPC_FUNCTION(AHACKED_ESPER, PsychicShield)
UFUNCTION()
void PsychicShield();
RPC_FUNCTION(AHACKED_ESPER, RPCCreatePsychicShield, bool)
UFUNCTION()
void RPCCreatePsychicShield(bool isBoth);
UFUNCTION()
void PsychicShieldOn();
RPC_FUNCTION(AHACKED_ESPER, RPCDestroyShield)
UFUNCTION()
void RPCDestroyShield();
UFUNCTION()
void PsychicShieldAnimEnd();
public:
UFUNCTION()
void PsychicShieldDestroy();
UFUNCTION()
void PsychicShieldTimeChange(float plusTime);
//------------ Ultimate(U). Psychic OverDrive ------------//
// ์คํฌ ์ค๋ช
: ์์คํผ ์ฃผ๋ณ์ ์ ์ ์ ์ํด ๋ค์ด์ฌ๋ฆฐํ ๊ฐ๋ ฅํ ์ผ๋๋ ฅ์ผ๋ก ์ ์ ๋
์ผ๋ก ๊ฝ์ต๋๋ค.
private:
RPC_FUNCTION(AHACKED_ESPER, PsychicOverDrive)
UFUNCTION()
void PsychicOverDrive(); // ์์คํผ ๊ถ๊ทน๊ธฐ(Psychic OverDrive)์ ์ฒ์ ์ํ ์ค์ ํจ์์
๋๋ค.
UFUNCTION()
void PsychicOverDriveCamReturn();
UFUNCTION()
void PsychicOverDriveEndAction(); // ๋ฐ์ธ๋ํจ์์ Tick์์ ๋ค์ด์ฌ๋ฆฐ ์ ์ ๋
์ผ๋ก ๊ฝ์ต๋๋ค.
UFUNCTION()
void PsychicOverDriveDamaging(); // ๋
์ผ๋ก ๊ฝํ ์ ์๊ฒ ํผํด๋ฅผ ์
ํ๋๋ค.
UFUNCTION()
void PsychicOverDriveEnd(); // ํด๋น ์คํฌ์ด ๋๋ ๊ธฐ๋ณธ State๋ก ๋์๊ฐ๊ธฐ ์ํ ์์น ์กฐ์ ํจ์์
๋๋ค.
UPROPERTY()
class UMaterial* PrimaryPartsMaterial;
UPROPERTY()
class UMaterial* UltimatePartsMaterial;
UPROPERTY()
class UMaterialInstanceDynamic* PrimaryMaterialInst;
UPROPERTY()
class UMaterialInstanceDynamic* UltimateMaterialInst;
FTimerHandle UltimateDamagingTimer; // ๊ถ๊ทน๊ธฐ๊ฐ ๋๋ ๋ค ๋ด๋ ค ๋ฐํ๋ ํผํด๋ฅผ ์ง์ ์
ํ๋ ํจ์๋ฅผ ์คํ์ํค๋ ํจ์์
๋๋ค.
TArray<class AHACKED_AI*> UltimateCheckedAI; // ๊ฝํ ์ ์๊ฒ ํผํด๋ฅผ ์
ํ๊ธฐ ์ํด ์ ์ ์ ์ฅํ๋ Array
public:
UFUNCTION(BlueprintImplementableEvent, Category = Ultimate)
void OnTranslucent(bool IsTranslucent);
UFUNCTION(BlueprintImplementableEvent, Category = Ultiamte)
void UltimateDecal();
UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
class UMaterialInterface* DC_EsperUltimateDecal;
// SelfHealing ------------------------------------
private:
RPC_FUNCTION(AHACKED_ESPER, RPCSelfHealing)
UFUNCTION()
// ์๊ฐ ์น์ ์ํ์ ์ง์
ํ๋ ํจ์์
๋๋ค.
void RPCSelfHealing();
// ์๊ฐ ์น์ ๊ฐ ๋๋ฌ์๋ ์ง์
ํ๋ ํจ์์
๋๋ค.
UFUNCTION()
void SelfHealingEnd();
// ์๊ฐ ์น์ ์ ๋๋ฉ์ด์
ํ ๋ณต๊ท๋์์ ๋ง์ง๋ง์ ์ง์
ํ๋ ํจ์์
๋๋ค.
UFUNCTION()
void SelfHealingAnimEnd();
UPROPERTY(VisibleAnywhere)
class UParticleSystemComponent* PC_EsperSelfHeal = nullptr;
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Particle, Meta = (AllowPrivateAccess = "true"))
class UParticleSystem* PS_EsperSelfHeal;
public:
RPC_FUNCTION(AHACKED_ESPER, RPCBothDieProcess)
UFUNCTION()
void RPCBothDieProcess();
private:
// Dash ------------------------------------
RPC_FUNCTION(AHACKED_ESPER, PsychicDash)
UFUNCTION()
void PsychicDash();
UFUNCTION()
void PsychicDashing();
RPC_FUNCTION(AHACKED_ESPER, PsychicDashFinish)
UFUNCTION()
void PsychicDashFinish();
// Camera ------------------------------------
void CameraBackToOrigin(); // ์นด๋ฉ๋ผ๋ฅผ ๊ธฐ๋ณธ State ์ํ๋ก ๋๋ฆฝ๋๋ค.
public:
// Camera Shake Bp ์ฐ๋
UPROPERTY(EditAnywhere)
TSubclassOf<UCameraShake> CS_EsperPrimary;
UPROPERTY(EditAnywhere)
TSubclassOf<UCameraShake> CS_PsychicOverDrive;
UPROPERTY(EditAnywhere)
TSubclassOf<UCameraShake> CS_PsychicOverDriveEnd;
UPROPERTY(EditAnywhere)
TSubclassOf<UCameraShake> CS_PsychicShockWave;
UPROPERTY(EditAnywhere)
TSubclassOf<UCameraShake> CS_PsychicForce;
UPROPERTY(EditAnywhere)
TSubclassOf<UCameraShake> CS_PsychicDrop;
private:
//------------------------------------------ Esper Stat ------------------------------------------//
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = EsperPrimaryStat, Meta = (AllowPrivateAccess = true))
float _esperMaxHp;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = EsperPrimaryStat, Meta = (AllowPrivateAccess = true))
float _esperMaxWalkSpeed;
private:
//------------------------------------------ Esper Primary Attack ------------------------------------------//
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
float _primaryAttackDamage;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
float _primaryAttackSPDamage;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
float _primaryAttackRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
float _primaryAttackSPRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
float _primaryAttackSpeed;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
float _primaryAttackLifeTime;
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = PrimaryAttack, Meta = (AllowPrivateAccess = true))
bool bIsPrimaryAttacking;
//------------------------------------------ Skill 1 PsychicForce ------------------------------------------//
private:
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Skill1_PsychicForce, Meta = (AllowPrivateAccess = true))
bool bIsPsychicForce;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill1_PsychicForce, Meta = (AllowPrivateAccess = true))
float _psychicForceRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill1_PsychicForce, Meta = (AllowPrivateAccess = true))
float _psychicForceDamage;
FTimerHandle PsychicForceStunDelay;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill1_PsychicForce, Meta = (AllowPrivateAccess = true))
float _stunDelayTime;
//------------------------------------------ Skill MouseRight PsychicDrop ------------------------------------------//
private:
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Skill2_PsychicDrop, Meta = (AllowPrivateAccess = true))
bool bIsPsychicDrop;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill2_PsychicDrop, Meta = (AllowPrivateAccess = true))
float _psychicDropSpeed;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill2_PsychicDrop, Meta = (AllowPrivateAccess = true))
float _psychicDropRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill2_PsychicDrop, Meta = (AllowPrivateAccess = true))
float _psychicDropDamageRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill2_PsychicDrop, Meta = (AllowPrivateAccess = true))
float _psychicDropDamage;
float PsychicDropDamageCount;
bool bActorHitCheck;
FVector PsychicDropSavePos;
FVector PsychicDropStartVec;
FVector PsychicDropEndVec;
FVector FollowCamVec;
FVector WorldCamVec;
FVector PsychicDropHitLocation;
//------------------------------------------ Skill 2 PsychicShockWave ------------------------------------------//
private:
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
bool bIsPsychicShockWave;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _shockWaveRadius;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _shockWaveRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _shockWaveDamage;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _shockWaveTime;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _shockWaveMaxTime;
FVector ShockWaveSpawnLocation;
FTimerHandle ShockWaveTimerHandle;
//------------------------------------------ Skill 3 PsychicShield ------------------------------------------//
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
bool bIsPsychicShield;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _psychicShieldDistance;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _psychicShieldAmount;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Skill3_PsychicShockWave, Meta = (AllowPrivateAccess = true))
float _psychicShieldTime;
FTimerHandle PsychicShieldTimerHandle;
//------------------------------------------ Shift PsychicDash ------------------------------------------//
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Dash_PsychicDash, Meta = (AllowPrivateAccess = true))
bool bIsPsychicDash;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Dash_PsychicDash, Meta = (AllowPrivateAccess = true))
float _psychicDashDistance = 700.0f;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Dash_PsychicDash, Meta = (AllowPrivateAccess = true))
float _psychicDashPower;
FVector DashStartPos;
FVector DashDirection;
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Particle, Meta = (AllowPrivateAccess = "true"))
class UParticleSystem* PS_PsychicDash;
//------------------------------------------ Ultimate PsychicOverDrive ------------------------------------------//
public:
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Ultimate_PsychicOverDrive, Meta = (AllowPrivateAccess = true))
bool bIsPsychicOverDrive = false;
private:
// ๊ถ๊ทน๊ธฐ ๋์ฐ๋ ํ์ ๋ฐ๋ ์ฌ๋ถ
bool bOnPsychicOverDriveHovering;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Ultimate_PsychicOverDrive, Meta = (AllowPrivateAccess = true))
float _psychicOverDriveRange;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Ultimate_PsychicOverDrive, Meta = (AllowPrivateAccess = true))
float _psychicOverDriveDamage;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Ultimate_PsychicOverDrive, Meta = (AllowPrivateAccess = true))
float _ultimateDropDelay;
FVector OverDriveSavePos;
FTimerHandle UltimateTimerHandle;
float OverDriveTimeCount;
private:
UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Particle, Meta = (AllowPrivateAccess = "true"))
class UParticleSystem* PA_PsychicDrop;
UPROPERTY()
TSubclassOf<class AEsper_PA_EnergyBall> EnergyBallClass;
UPROPERTY()
TSubclassOf<class AEsper_PsychicDrop> PsychicTrailClass;
UPROPERTY()
TSubclassOf<class UUserWidget> WG_Aim_Class;
UPROPERTY()
class UEsper_AnimInstance* Esper_Anim;
public:
UPROPERTY(BlueprintReadOnly, Category = "Widget")
class UUserWidget* WG_Aim = nullptr;
};
| [
"ljh960101@gmail.com"
] | ljh960101@gmail.com |
1817939d42b67c3afd15995f963aee4f33e81e56 | 51c6f5f1ad140301e801b8944aada031b63c5d9c | /engine/gui/core/guiTypes.h | e0c7201a1e6d2960dcbdc6758d2b9e0c90f6a34e | [
"LicenseRef-scancode-other-permissive",
"MIT"
] | permissive | ClayHanson/B4v21-Launcher-Public-Repo | 916f1e47e7c1b9069b151751db9ee4d7df6420ed | c812aa7bf2ecb267e02969c85f0c9c2a29be0d28 | refs/heads/master | 2022-11-28T19:54:47.391592 | 2020-08-06T18:59:30 | 2020-08-06T18:59:30 | 285,645,055 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,950 | h | //-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------
#ifndef _GUITYPES_H_
#define _GUITYPES_H_
#ifndef _GFONT_H_
#include "dgl/gFont.h"
#endif
#ifndef _COLOR_H_
#include "core/color.h"
#endif
#ifndef _SIMBASE_H_
#include "console/simBase.h"
#endif
#ifndef _GTEXMANAGER_H_
#include "dgl/gTexManager.h"
#endif
#ifndef _PLATFORMAUDIO_H_
#include "platform/platformAudio.h"
#endif
#ifndef _AUDIODATABLOCK_H_
#include "audio/audioDataBlock.h"
#endif
class GBitmap;
/// Represents a single GUI event.
///
/// This is passed around to all the relevant controls so they know what's going on.
struct GuiEvent
{
U16 ascii; ///< ascii character code 'a', 'A', 'b', '*', etc (if device==keyboard) - possibly a uchar or something
U8 modifier; ///< SI_LSHIFT, etc
U8 keyCode; ///< for unprintables, 'tab', 'return', ...
Point2I mousePoint; ///< for mouse events
U8 mouseClickCount; ///< to determine double clicks, etc...
};
class GuiCursor : public SimObject
{
private:
typedef SimObject Parent;
StringTableEntry mBitmapName;
Point2I mHotSpot;
Point2F mRenderOffset;
Point2I mExtent;
TextureHandle mTextureHandle;
public:
Point2I getHotSpot() { return mHotSpot; }
Point2I getExtent() { return mExtent; }
DECLARE_CONOBJECT(GuiCursor);
GuiCursor(void);
~GuiCursor(void);
static void initPersistFields();
bool onAdd(void);
void onRemove();
void render(const Point2I &pos);
};
/// A GuiControlProfile is used by every GuiObject and is akin to a
/// datablock. It is used to control information that does not change
/// or is unlikely to change during execution of a program. It is also
/// a level of abstraction between script and GUI control so that you can
/// use the same control, say a button, and have it look completly different
/// just with a different profile.
class GuiControlProfile : public SimObject
{
private:
typedef SimObject Parent;
public:
S32 mRefCount; ///< Used to determine if any controls are using this profile
bool mTabable; ///< True if this object is accessable from using the tab key
static StringTableEntry sFontCacheDirectory;
bool mCanKeyFocus; ///< True if the object can be given keyboard focus (in other words, made a first responder @see GuiControl)
bool mModal; ///< True if this is a Modeless dialog meaning it will pass input through instead of taking it all
bool mOutlineFont; ///< True if the font rendered should be outlined
S32 mOutlineWidth; ///< Width of the font outline
ColorI mOutlineColor; ///< Outline color
ColorI mOutlineColorHL; ///< Outline color for when this object is highlighted
ColorI mOutlineColorNA; ///< Outline color for when this object is disabled
ColorI mOutlineColorSEL; ///< Outline color for when this object is selected
bool mOpaque; ///< True if this object is not translucent
ColorI mFillColor; ///< Fill color, this is used to fill the bounds of the control if it is opaque
ColorI mFillColorHL; ///< This is used insetead of mFillColor if the object is highlited
ColorI mFillColorNA; ///< This is used to instead of mFillColor if the object is not active or disabled
S32 mBorder; ///< For most controls, if mBorder is > 0 a border will be drawn, some controls use this to draw different types of borders however @see guiDefaultControlRender.cc
S32 mBorderThickness; ///< Border thickness
ColorI mBorderColor; ///< Border color, used to draw a border around the bounds if border is enabled
ColorI mBorderColorHL; ///< Used instead of mBorderColor when the object is highlited
ColorI mBorderColorNA; ///< Used instead of mBorderColor when the object is not active or disabled
ColorI mBevelColorHL; ///< Used for the high-light part of the bevel
ColorI mBevelColorLL; ///< Used for the low-light part of the bevel
// font members
StringTableEntry mFontType; ///< Font face name for the control
S32 mFontSize; ///< Font size for the control
enum {
BaseColor = 0,
ColorHL,
ColorNA,
ColorSEL,
ColorUser0,
ColorUser1,
ColorUser2,
ColorUser3,
ColorUser4,
ColorUser5,
};
ColorI mFontColors[10]; ///< Array of font colors used for drawText with escape characters for changing color mid-string
ColorI& mFontColor; ///< Main font color
ColorI& mFontColorHL; ///< Highlited font color
ColorI& mFontColorNA; ///< Font color when object is not active/disabled
ColorI& mFontColorSEL; ///< Font color when object/text is selected
FontCharset mFontCharset; ///< Font character set
Resource<GFont> mFont; ///< Font resource
enum AlignmentType
{
LeftJustify,
RightJustify,
CenterJustify
};
AlignmentType mAlignment; ///< Horizontal text alignment
bool mAutoSizeWidth; ///< Auto-size the width-bounds of the control to fit it's contents
bool mAutoSizeHeight; ///< Auto-size the height-bounds of the control to fit it's contents
bool mReturnTab; ///< Used in GuiTextEditCtrl to specify if a tab-event should be simulated when return is pressed.
bool mNumbersOnly; ///< For text controls, true if this should only accept numerical data
bool mMouseOverSelected; ///< True if this object should be "selected" while the mouse is over it
ColorI mCursorColor; ///< Color for the blinking cursor in text fields (for example)
Point2I mTextOffset; ///< Text offset for the control
// bitmap members
StringTableEntry mBitmapName; ///< Bitmap file name for the bitmap of the control
TextureHandle mTextureHandle; ///< Texture handle for the control
Vector<RectI> mBitmapArrayRects; ///< Used for controls which use an array of bitmaps such as checkboxes
// sound members
AudioProfile *mSoundButtonDown; ///< Sound played when the object is "down" ie a button is pushed
AudioProfile *mSoundButtonOver; ///< Sound played when the mouse is over the object
GuiControlProfile* mProfileForChildren; ///< Profile used with children controls (such as the scroll bar on a popup menu) when defined.
public:
DECLARE_CONOBJECT(GuiControlProfile);
GuiControlProfile();
~GuiControlProfile();
static void initPersistFields();
bool onAdd();
/// This method creates an array of bitmaps from one single bitmap with
/// seperator color. The seperator color is whatever color is in pixel 0,0
/// of the bitmap. For an example see darkWindow.png and some of the other
/// UI textures. It returns the number of bitmaps in the array it created
/// It also stores the sizes in the mBitmapArrayRects vector.
S32 constructBitmapArray();
void incRefCount();
void decRefCount();
};
DefineConsoleType( TypeGuiProfile)
#endif //_GUITYPES_H
| [
"11217112+ClayHanson@users.noreply.github.com"
] | 11217112+ClayHanson@users.noreply.github.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.